Number Difference

Irvi Aini · May 28, 2025

Leetcode

🎮 Number Difference Game 🎮

An interactive programming challenge that visualizes the difference between sums of numbers divisible and not divisible by a given value.

🎮 Interactive Challenge 🎮

Play the Game

Range (n): Divisor (m):

🧑‍💻 Code Implementation

class Solution {
public:
    int differenceOfSums(int n, int m) {
        std::vector<int> numbers(n);
        std::iota(numbers.begin(), numbers.end(), 1);
        
        return std::transform_reduce(numbers.begin(), numbers.end(), 0, 
            std::plus<int>{},
            [m](int num) { return num % m == 0 ? -num : num; });
    }
};

from functools import reduce
from operator import add

def difference_of_sums(n, m):
    """Calculate difference using functional programming approach"""
    numbers = list(range(1, n + 1))
    transformed = map(lambda num: -num if num % m == 0 else num, numbers)
    
    return reduce(add, transformed, 0)

# Alternative using sum() with generator expression:
def difference_of_sums_modern(n, m):
    return sum(-num if num % m == 0 else num 
              for num in range(1, n + 1))

function differenceOfSums(n, m) {
    const numbers = Array.from({length: n}, (_, i) => i + 1);
    
    return numbers
        .map(num => num % m === 0 ? -num : num)
        .reduce((sum, val) => sum + val, 0);
}

// Modern ES6+ approach with chaining:
const differenceOfSums = (n, m) => 
    Array.from({length: n}, (_, i) => i + 1)
        .reduce((sum, num) => sum + (num % m === 0 ? -num : num), 0);

// Using Array.keys() alternative:
const differenceOfSumsKeys = (n, m) => 
    [...Array(n).keys()]
        .map(i => i + 1)
        .reduce((sum, num) => sum + (num % m === 0 ? -num : num), 0);

import java.util.stream.IntStream;

public class Solution {
    public int differenceOfSums(int n, int m) {
        return IntStream.rangeClosed(1, n)
            .map(num -> num % m == 0 ? -num : num)
            .sum();
    }
    
    // Alternative using reduce for more explicit control:
    public int differenceOfSumsReduce(int n, int m) {
        return IntStream.rangeClosed(1, n)
            .reduce(0, (sum, num) -> 
                sum + (num % m == 0 ? -num : num));
    }
    
    // Using parallel stream for larger datasets:
    public int differenceOfSumsParallel(int n, int m) {
        return IntStream.rangeClosed(1, n)
            .parallel()
            .map(num -> num % m == 0 ? -num : num)
            .sum();
    }
}

🎯 How it works:

Goal: Calculate the difference between the sum of numbers NOT divisible by m and the sum of numbers divisible by m.

Algorithm: For each number from 1 to n, if it's divisible by m, subtract it from our answer. Otherwise, add it to our answer.

Math Formula: result = Σ(non-divisible) - Σ(divisible)

Share: Twitter, Facebook