Skip to main content

How to Convert Decimal to Roman Numerals in Batch Script

Converting a standard decimal number into a Roman numeral string is the reverse of parsing Roman numerals. Instead of reading characters, you repeatedly subtract the largest possible Roman value from the number, appending the corresponding symbol to your result string. This is useful for generating formal document numbering, chapter headings, or decorative clock faces.

In this guide, we will demonstrate how to convert any decimal number (1 to 3999) into its Roman numeral equivalent.

The Strategy: The Greedy Subtraction​

  1. Define an ordered list of Roman values from largest to smallest (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1).
  2. While the number is greater than 0:
    • Find the largest Roman value that fits into the remaining number.
    • Subtract it and append the corresponding symbol to the result.

Implementation Script​

@echo off
setlocal enabledelayedexpansion

set /p "num=Enter a decimal number (1-3999): "

:: Basic numeric/range validation (optional but recommended)
set "n=!num!"
if not defined n goto :bad
for /f "delims=0123456789" %%A in ("!n!") do goto :bad
if !n! LSS 1 goto :bad
if !n! GTR 3999 goto :bad

:: 1. Define the Value-Symbol Pairs (13 pairs)
set /a "count=13"
set /a "VAL_1=1000" & set "SYM_1=M"
set /a "VAL_2=900"  & set "SYM_2=CM"
set /a "VAL_3=500"  & set "SYM_3=D"
set /a "VAL_4=400"  & set "SYM_4=CD"
set /a "VAL_5=100"  & set "SYM_5=C"
set /a "VAL_6=90"   & set "SYM_6=XC"
set /a "VAL_7=50"   & set "SYM_7=L"
set /a "VAL_8=40"   & set "SYM_8=XL"
set /a "VAL_9=10"   & set "SYM_9=X"
set /a "VAL_10=9"   & set "SYM_10=IX"
set /a "VAL_11=5"   & set "SYM_11=V"
set /a "VAL_12=4"   & set "SYM_12=IV"
set /a "VAL_13=1"   & set "SYM_13=I"

:: 2. The Conversion Loop
set "result="
set /a "remaining=n"

for /L %%i in (1,1,!count!) do (
    call :consume %%i
)

echo.
echo ==========================================
echo DECIMAL: !n!
echo ROMAN:   !result!
echo ==========================================
pause
exit /b

:consume
set "i=%~1"
:inner
if !remaining! GEQ !VAL_%i%! (
    set "result=!result!!SYM_%i%!"
    set /a "remaining-=VAL_%i%"
    goto :inner
)
exit /b

:bad
echo.
echo Invalid input. Enter an integer from 1 to 3999.
pause
exit /b
tip

The conversion uses a “greedy” approach: always subtract the largest Roman value that still fits. Because the subtractive pairs (CM, CD, XC, XL, IX, IV) are included in the table, this produces the canonical Roman numeral form.

Why Convert to Roman Numerals?​

  1. Document Formatting: Generating formal appendix or chapter numbering (Appendix I, Appendix II) for automated report generation.
  2. UI Design: Adding a decorative flair to text-based menus or interactive tools.
  3. Educational Tools: Building a bidirectional Roman/Decimal converter as a learning project.

Important Considerations​

  1. Range Limit: Standard Roman numerals only cover the range 1 to 3999. Numbers above this require a non-standard "Vinculum" (bar above the letter) notation, which cannot be represented in plain text.
  2. Zero: Roman numerals have no representation for zero. If your input is 0, the script should handle it as a special case.
  3. Negative Numbers: There is no concept of negative values in Roman numerals.

Best Practices​

  1. Input Validation: Always verify that the input is between 1 and 3999 before starting the conversion.
  2. Subtractive Pairs: The pairs like CM (900), CD (400), XC (90), XL (40), IX (9), and IV (4) are critical for correct output. Omitting them would result in incorrect forms like DCCCC instead of CM.
danger

Avoid percent expansion (%count%, %num%) inside loops when values can change or when user input may contain special characters. Using delayed expansion (!var!) prevents stale values and reduces parsing/injection problems.

Conclusion​

Converting decimal numbers to Roman numerals is an elegant exercise in "Greedy Algorithm" design. By systematically subtracting the largest possible value at each step, you build the Roman string with perfect accuracy. This technique demonstrates powerful loop control and lookup-table management, providing a solid foundation for building format converters and text-processing tools of any complexity.

Table of Contents