Skip to main content

How to Implement the Collatz Conjecture in Batch Script

Implementing the Collatz Conjecture in Batch Script is a rewarding exercise that combines mathematical curiosity with practical scripting techniques. The project reinforces core concepts like conditional branching, arithmetic operations, and loop management. It also serves as a reminder that even the simplest-looking problems can have surprising depth and complexity.

The Collatz Conjecture (also known as the 3x + 1 problem) is a mathematical sequence defined as follows: start with any positive integer n. If n is even, divide it by 2. If n is odd, multiply it by 3 and add 1. Repeat this process until n reaches 1. Constructing a script to automatically process and print this sequence provides an excellent exercise in iterative division and conditional checks.

The Theory Behind Modulus Validation​

Windows Batch natively supports fundamental mathematical operations through the /A switch inside the SET command. To determine if a number is even or odd, we use the modulus operator (%%), which returns the remainder of division.

If num %% 2 == 0, the number is even. If num %% 2 == 1, the number is odd.

Managing the Looping Mechanism​

Batch Scripts lack standard while() loop structures. To build a continuous calculation loop that stops precisely when the number reaches 1, developers must use GOTO statements dynamically.

@echo off
setlocal enabledelayedexpansion

set "num=6"

:COLLATZ_LOOP
echo Current Number: !num!
if !num! equ 1 goto END

set /a "remainder=num %% 2"

if !remainder! equ 0 (
    set /a "num=num / 2"
) else (
    set /a "num=(num * 3) + 1"
)

goto COLLATZ_LOOP

:END
echo The sequence has reached 1.

Creating a Robust Script​

A powerful interactive script should provide statistical outputs, gracefully track the current step index, and protect itself against invalid user input (such as typing text or entering a negative integer).

The Wrong Way: Trusting Raw Input​

If you directly push user input into the calculation engine without validation, the script will crash if a user enters words or blank strings.

Wrong Code Example:

@echo off
set /p "INPUT=Enter a number: "

:LOOP
if %INPUT% EQU 1 goto EOF
set /a rem=INPUT %% 2
:: Fails instantly if INPUT is empty or a word.

What Happens: Running modulus operations on uninitialized or alphabetic variables strictly breaks the Command Prompt's mathematical parser. Always check that the variable is properly initiated as a positive integer.

The Correct Way: Safe Bounds​

To successfully calculate sequences safely, we validate the input string before executing the loop.

Correct Code Example:

@echo off
setlocal enabledelayedexpansion

:PROMPT
set "START_NUM="
set /p "START_NUM=Enter a positive integer: "

:: Validate no blanks
if not defined START_NUM goto PROMPT

:: Verify it contains only digits
echo !START_NUM!| findstr /r "^[1-9][0-9]*$" >nul
if !errorlevel! neq 0 (
    echo [ERROR] Only positive integers are allowed.
    goto PROMPT
)

What Happens: The findstr regex check ensures only strings composed entirely of digits (starting with a non-zero digit) are accepted. Alphabetic input, negative numbers, zero, and empty strings are all cleanly rejected before any arithmetic is attempted.

Full Script Implementation​

By combining strong mathematical variable assignment, conditional IF branches built around modulus logic, and a dynamic loop counter, we have a complete Collatz Conjecture utility.

@echo off
setlocal enabledelayedexpansion
title Collatz Conjecture Generator

:PROMPT
cls
echo ========================================================
echo          TERMINAL COLLATZ CONJECTURE (3x + 1^)
echo ========================================================
echo The rules:
echo  - If even: divide by 2
echo  - If odd: multiply by 3 and add 1
echo --------------------------------------------------------

set "num="
set /p "num=Enter a positive starting integer: "

if not defined num goto PROMPT

:: Validate that input contains only digits starting with 1-9
echo !num!| findstr /r "^[1-9][0-9]*$" >nul
if !errorlevel! neq 0 (
    echo [ERROR] You must enter a positive integer.
    pause
    goto PROMPT
)

echo.
echo Calculating sequence for: !num!
echo --------------------------------------------------------

set "count=0"

:LOOP
echo Step !count!: !num!

if !num! equ 1 (
    goto FINISHED
)

set /a "modulo=num %% 2"

if !modulo! equ 0 (
    set /a "num=num / 2"
) else (
    set /a "num=(num * 3) + 1"
)

set /a "count+=1"
goto LOOP

:FINISHED
echo --------------------------------------------------------
color 0A
echo [COMPLETE] The sequence resolved to 1.
echo Total Steps: !count!
echo.
pause
color 07
goto PROMPT
warning

Because CMD relies on signed 32-bit integer arithmetic, values above 2,147,483,647 will overflow silently. Large starting numbers whose sequences spike above this limit mid-calculation will produce incorrect results. For example, starting with 113383 causes the sequence to exceed the 32-bit boundary.

Conclusion​

Creating a Collatz Sequence interactive calculator in Batch Script perfectly demonstrates native numeric modulo usage and continuous looped verification. This simple exercise equips any developer with strong command line mathematical problem-solving skills transferable to broader automation and scripting tasks.

Table of Contents