Skip to main content

How to Calculate the Least Common Multiple (LCM) in Batch Script

In mathematics, the Least Common Multiple (LCM) of two numbers is the smallest positive integer that is divisible by both of them. It is widely used in scheduling, where you might want to find when two different recurring tasks will next happen at the exact same time. The most efficient way to find the LCM is to first find the Greatest Common Divisor (GCD) and then use a mathematical formula.

In this guide, we will demonstrate how to calculate the LCM using the GCD formula.

The Strategy: The GCD-to-LCM Formula​

The relationship between the GCD and the LCM is: LCM(a, b) = abs(a) / GCD(a, b) * abs(b)

To implement this in Batch:

  1. Calculate the GCD using the Euclidean Algorithm.
  2. Divide one of the original numbers by the GCD first (to avoid overflow).
  3. Multiply the result by the other number.
note

By dividing before multiplying ((a / gcd) * b instead of (a * b) / gcd), we keep intermediate values as small as possible and significantly reduce the risk of 32-bit integer overflow.

Implementation Script​

@echo off
setlocal enabledelayedexpansion

set /p "num1=Enter first number: "
set /p "num2=Enter second number: "

:: 1. Convert to absolute values (LCM is defined for positive integers)
if !num1! LSS 0 set /a "num1=-num1"
if !num2! LSS 0 set /a "num2=-num2"

:: 2. Handle zero inputs
if !num1! EQU 0 (
    echo [RESULT] LCM is 0 (any number's LCM with 0 is 0^).
    pause
    exit /b 0
)
if !num2! EQU 0 (
    echo [RESULT] LCM is 0 (any number's LCM with 0 is 0^).
    pause
    exit /b 0
)

:: 3. Calculate GCD using the Euclidean Algorithm
set "a=!num1!"
set "b=!num2!"

:gcd_loop
if !b! EQU 0 goto :calc_lcm
set /a "rem=a %% b"
set "a=!b!"
set "b=!rem!"
goto :gcd_loop

:calc_lcm
set "gcd=!a!"

:: 4. Calculate LCM using divide-first method to minimize overflow risk
:: LCM = (num1 / gcd) * num2
set /a "lcm=(num1 / gcd) * num2"

echo.
echo ==========================================
echo Numbers: !num1! and !num2!
echo GCD:     !gcd!
echo LCM:     !lcm!
echo ==========================================

endlocal
pause

Why Calculate the LCM in Batch?​

  1. Task Synchronization: If Task A runs every 4 hours and Task B runs every 6 hours, the LCM (12) tells you they will both run simultaneously every 12 hours.
  2. Logic Planning: Determining the smallest possible batch size that satisfies two different processing requirements.
  3. Educational Tools: Building mathematical calculators as a way to master advanced Batch scripting and formula implementation.

Important Limitations​

warning

Even with the divide-first optimization, the final (num1 / gcd) * num2 multiplication can still exceed the 32-bit signed integer limit of ±2,147,483,647. For example, LCM(50000, 70000) produces 350,000, safe. But LCM(100000, 99999) produces 9,999,900,000, which overflows silently. Always verify that your expected LCM fits within 32-bit bounds.

  1. Integer Overflow: Because Batch uses 32-bit signed integers, the intermediate multiplication can exceed ~2.1 billion and produce incorrect results. The divide-first method mitigates this but does not eliminate it for very large inputs.
  2. Division by Zero: If either input is 0, the LCM is 0. The script handles this case explicitly before the GCD calculation begins.
  3. Whole Numbers Only: Batch math cannot handle decimals or fractions.

Best Practices​

  1. Divide First: Always use (num1 / gcd) * num2 instead of (num1 * num2) / gcd. This keeps intermediate values smaller and avoids overflow in many more cases.
  2. Absolute Values: If your script accepts negative inputs, convert them to positive values before the calculation, as LCM is defined for positive integers. The implementation above handles this automatically.
tip

To calculate the LCM of three or more numbers, apply the formula iteratively: LCM(a, b, c) = LCM(LCM(a, b), c). Calculate the LCM of the first two numbers, then use that result as the first input for the next pair.

Conclusion​

Calculating the Least Common Multiple is a powerful way to manage cycles and synchronization in your automation logic. By utilizing the mathematical bridge between GCD and LCM, you turn a complex search into a simple, two-step arithmetic operation. This level of mathematical control allows you to build sophisticated scripts that are capable of managing complex time-based schedules and resource-sync events with absolute accuracy.

Table of Contents