Home
5
Cobol

Roman Numerals in Cobol: Complete Solution & Deep Dive Guide

shape, arrow

The Complete Guide to Roman Numerals in Cobol: From Zero to Hero

Discover how to convert Arabic numbers into Roman numerals using Cobol, a cornerstone of enterprise computing. This in-depth guide provides a fully functional code solution, a detailed algorithmic breakdown, and explores the structured programming principles that make Cobol powerful for data transformation tasks up to 3,999.

You’ve just been handed a task that feels like a bridge between two worlds: the hyper-logical, structured domain of mainframe programming and the ancient, character-based system of Roman numerals. It seems straightforward, but as you stare at your Cobol editor, you realize this isn't just about loops and variables. It's about thinking methodically, managing data with precision, and appreciating the very design philosophy of Cobol.

Many developers, especially those new to legacy systems, hit a wall with this kind of problem. How do you handle the special cases like 4 (IV) or 900 (CM)? How do you build a string character by character in a language that pre-dates the dynamic strings of Python or JavaScript? This isn't a failure of skill; it's a gap in understanding the Cobol way of thinking.

This guide is your solution. We will not only provide a clean, efficient Cobol program to solve this challenge but also dissect the logic behind it. You will learn how to structure your data, implement a classic greedy algorithm, and master the Cobol verbs necessary for elegant string manipulation. By the end, you'll have a powerful new tool in your Cobol arsenal and a deeper appreciation for this legendary language.

What Exactly Are Roman Numerals? A Primer for Programmers

Before we can write a single line of Cobol, we must first understand the rules of the system we're trying to build. Roman numerals are a base-10 numeral system that originated in ancient Rome. Unlike our modern Arabic numeral system, which uses a positional value for each digit, Roman numerals rely on a combination of letters from the Latin alphabet to signify values.

The core symbols are:

  • I = 1
  • V = 5
  • X = 10
  • L = 50
  • C = 100
  • D = 500
  • M = 1000

These symbols are combined based on two fundamental principles:

  1. Additive Notation: When a symbol of equal or lesser value is placed after a symbol of greater value, the values are added. For example, VI is 5 + 1 = 6, and LXX is 50 + 10 + 10 = 70.
  2. Subtractive Notation: This is the tricky part that often trips up programmers. When a symbol of a smaller value is placed before a symbol of a larger value, the smaller value is subtracted from the larger one. This is only allowed for specific pairings:
    • IV = 4 (5 - 1)
    • IX = 9 (10 - 1)
    • XL = 40 (50 - 10)
    • XC = 90 (100 - 10)
    • CD = 400 (500 - 100)
    • CM = 900 (1000 - 100)

The traditional system, which our program will handle, doesn't typically represent numbers larger than 3,999 (MMMCMXCIX). This constraint simplifies our logic, as we don't need to account for more complex historical notations involving bars over letters to signify multiplication by 1,000.

Why Cobol is Perfectly Suited for This Logic Puzzle

At first glance, using a vintage language like Cobol for a classic algorithm might seem like an academic exercise. However, this problem beautifully highlights the very features that have kept Cobol relevant in banking, insurance, and government systems for over 60 years.

  • Structured Data Definition: Cobol's DATA DIVISION forces you to think about your data upfront. You must explicitly define variable types, sizes, and structures using PIC clauses. For the Roman numeral problem, this allows us to create a perfectly sized, fixed-layout mapping table, which is highly efficient and memory-safe.
  • Procedural Clarity: The language is designed to be self-documenting. The logic flows through paragraphs and sections, executed by verbs like PERFORM, IF, and EVALUATE. This makes the conversion algorithm, which is a series of steps, easy to read and maintain.
  • Powerful Iteration and Control: Cobol’s PERFORM VARYING and PERFORM UNTIL constructs provide robust looping mechanisms that are ideal for iterating through our numeral map and repeatedly subtracting values from the input number.
  • Precise String Handling: While not as flexible as modern languages, Cobol's STRING verb gives developers granular control over concatenating data into a target field. This is perfect for building the Roman numeral string piece by piece.

Tackling this challenge from the kodikra learning path is more than just a coding exercise; it's a lesson in the discipline and structure that define enterprise-level software development.

How to Design the Conversion Algorithm: The Greedy Approach

The most intuitive and efficient way to solve this problem is with a "greedy algorithm." The strategy is simple: at every step, we take the largest possible "bite" out of the number we're trying to convert. We do this by iterating through a list of Roman numeral values from largest to smallest.

This means we must include both the standard values (1000, 500, 100...) and the special subtractive values (900, 400, 90...) in our list to handle all cases correctly. The complete, ordered list of values we'll check against is: 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1.

Here is a conceptual flowchart of the logic:

    ● Start (Input: Arabic Number `N`)
    │
    ▼
  ┌────────────────────────┐
  │ Initialize Result = "" │
  └────────────┬───────────┘
               │
               ▼
  ┌────────────────────────┐
  │ For each Roman/Arabic  │
  │ pair (V, R) from largest to smallest
  └────────────┬───────────┘
               │
               ▼
         ┌─────────────────┐
         │ Loop while N >= V
         └────────┬────────┘
                  │
     Yes ◀───(Condition)───▶ No
     │                      │
     ▼                      │
  ┌──────────────────┐      │
  │ Append R to Result │      │
  └─────────┬────────┘      │
            │               │
            ▼               │
  ┌──────────────────┐      │
  │   N = N - V      │      │
  └─────────┬────────┘      │
            │               │
            └───────────────┘
               │
               ▼
  ┌────────────────────────┐
  │ (Move to next smaller pair)
  └────────────┬───────────┘
               │
               ▼
    ● End (Output: Result)

Let's trace this with an example, say the number 1994:

  1. Start with 1994. Is 1994 >= 1000? Yes. Result is "M", number becomes 994.
  2. Current number is 994. Is 994 >= 1000? No. Move to next value (900).
  3. Is 994 >= 900? Yes. Result is "M" + "CM", number becomes 94.
  4. Current number is 94. Is 94 >= 900? No. Move to 500? No... Move to 100? No. Move to 90.
  5. Is 94 >= 90? Yes. Result is "MCM" + "XC", number becomes 4.
  6. Current number is 4. Is 4 >= 90? No... Move down to 5? No. Move to 4.
  7. Is 4 >= 4? Yes. Result is "MCMXC" + "IV", number becomes 0.
  8. Current number is 0. The loops will all fail their conditions. The final result is MCMXCIX.

This approach is robust because the ordered list of values prevents ambiguity. We'll never accidentally create "IIII" because the "IV" check will always be performed first.

Where the Magic Happens: The Complete Cobol Solution

Now, let's translate our algorithm into a fully functional Cobol program. This solution is written using modern, free-format GnuCOBOL syntax, but the core logic is compatible with traditional mainframe Cobol compilers.

The program is structured into the standard divisions. The key components are in the WORKING-STORAGE SECTION, where we define our data map, and the PROCEDURE DIVISION, where the conversion logic resides.


       IDENTIFICATION DIVISION.
       PROGRAM-ID. RomanNumeralConverter.
       AUTHOR. Kodikra.

       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 WS-INPUT-NUMBER         PIC 9(04) VALUE 1994.
       01 WS-ROMAN-RESULT         PIC X(15) VALUE SPACES.
       01 WS-RESULT-POINTER       PIC 9(02) VALUE 1.

       01 WS-CONVERSION-TABLE.
           05 FILLER PIC X(32) VALUE "1000M   0900CM  0500D   0400CD  ".
           05 FILLER PIC X(32) VALUE "0100C   0090XC  0050L   0040XL  ".
           05 FILLER PIC X(24) VALUE "0010X   0009IX  0005V   0004IV  ".
           05 FILLER PIC X(08) VALUE "0001I   ".

       01 WS-CONVERSION-MAP REDEFINES WS-CONVERSION-TABLE.
           05 WS-MAP-ENTRY OCCURS 13 TIMES INDEXED BY I.
               10 WS-ARABIC-VAL      PIC 9(04).
               10 WS-ROMAN-SYM       PIC X(02).

       PROCEDURE DIVISION.
       0000-MAIN-LOGIC.
           DISPLAY "Converting Arabic Number: " WS-INPUT-NUMBER

           PERFORM 1000-VALIDATE-INPUT
           
           IF WS-INPUT-NUMBER > 0 AND WS-INPUT-NUMBER < 4000
               PERFORM 2000-CONVERT-TO-ROMAN
               DISPLAY "Roman Numeral Result: " WS-ROMAN-RESULT
           ELSE
               DISPLAY "Error: Input must be between 1 and 3999."
           END-IF.

           STOP RUN.

       1000-VALIDATE-INPUT.
      * This paragraph is a placeholder for more robust validation.
      * For this example, the IF statement in 0000-MAIN-LOGIC handles it.
           CONTINUE.

       2000-CONVERT-TO-ROMAN.
           PERFORM VARYING I FROM 1 BY 1 UNTIL I > 13
               PERFORM UNTIL WS-INPUT-NUMBER < WS-ARABIC-VAL(I)
                   
                   STRING WS-ROMAN-SYM(I) DELIMITED BY SPACE
                       INTO WS-ROMAN-RESULT
                       WITH POINTER WS-RESULT-POINTER
                   END-STRING

                   SUBTRACT WS-ARABIC-VAL(I) FROM WS-INPUT-NUMBER
               END-PERFORM
           END-PERFORM.

How to Compile and Run This Code

If you are using GnuCOBOL (a popular open-source compiler), you can save the code as roman.cbl and execute the following commands in your terminal:


# Compile the program
cobc -x -free roman.cbl

# Run the executable
./roman

The output will be:


Converting Arabic Number: 1994
Roman Numeral Result: MCMXCIV

A Deep Dive into the Cobol Code: A Line-by-Line Walkthrough

Understanding a Cobol program requires looking at its structure. The code isn't just a script; it's a blueprint for data and procedures.

The DATA DIVISION: Defining Our Tools

This is where we define every piece of data our program will use. Think of it as setting up your workshop before starting a project.

Our data structure mapping is visualized below:

  WS-CONVERSION-TABLE (A single, long string)
  "1000M   0900CM  0500D   ..."
   │
   └─ REDEFINES as ─▶ WS-CONVERSION-MAP (An array-like structure)
                      │
                      ├─ WS-MAP-ENTRY (Index 1)
                      │   ├─ WS-ARABIC-VAL: 1000
                      │   └─ WS-ROMAN-SYM: "M "
                      │
                      ├─ WS-MAP-ENTRY (Index 2)
                      │   ├─ WS-ARABIC-VAL: 0900
                      │   └─ WS-ROMAN-SYM: "CM"
                      │
                      ├─ WS-MAP-ENTRY (Index 3)
                      │   ├─ WS-ARABIC-VAL: 0500
                      │   └─ WS-ROMAN-SYM: "D "
                      │
                      ▼
                     ... and so on for 13 entries
  • WS-INPUT-NUMBER PIC 9(04): A numeric field that can hold up to 4 digits. We initialize it with our test value.
  • WS-ROMAN-RESULT PIC X(15): An alphanumeric field to store our result. The size 15 is chosen because the longest Roman numeral under 3999 is MMMCMXCIX, which is 9 characters, but we allocate extra space for safety. It's initialized to SPACES.
  • WS-RESULT-POINTER PIC 9(02): This is crucial for our string building. It acts as a cursor, telling the STRING verb where to place the next character(s) in WS-ROMAN-RESULT.
  • WS-CONVERSION-TABLE: This is a clever Cobol technique. We define our entire map as a single, contiguous block of text. Each entry is fixed-width: 4 digits for the number and 2 characters for the symbol (e.g., "1000M ", "0900CM").
  • WS-CONVERSION-MAP REDEFINES ...: The REDEFINES clause is a powerful feature. It tells Cobol to overlay a different data structure on the same memory location as WS-CONVERSION-TABLE. We define WS-MAP-ENTRY which OCCURS 13 TIMES, effectively turning our flat string into an array of records. Each record has two fields: WS-ARABIC-VAL and WS-ROMAN-SYM. This allows us to access the data using an index (I).

The PROCEDURE DIVISION: Executing the Logic

This is where the action happens. The logic flows from one paragraph to the next, controlled by PERFORM statements.

  • 0000-MAIN-LOGIC: This is our program's entry point. It displays the input, performs validation, calls the main conversion routine, and then displays the final result before stopping. The IF statement acts as a simple guard clause to ensure we only process valid numbers.
  • 2000-CONVERT-TO-ROMAN: This is the heart of the algorithm.
    • PERFORM VARYING I FROM 1 BY 1 UNTIL I > 13: This is the outer loop. It iterates through our WS-CONVERSION-MAP from the first entry (1000, "M") to the last (1, "I"). The index I is automatically managed by Cobol.
    • PERFORM UNTIL WS-INPUT-NUMBER < WS-ARABIC-VAL(I): This is the inner loop. For the current map entry (e.g., the one for 1000), it repeatedly executes as long as our remaining input number is large enough to be "bitten" by it.
    • STRING WS-ROMAN-SYM(I) ...: This is the string-building step. The STRING verb takes the Roman symbol (e.g., "CM") and concatenates it into WS-ROMAN-RESULT. The WITH POINTER WS-RESULT-POINTER clause is essential; it ensures each new symbol is placed right after the previous one. The pointer is automatically updated by the verb.
    • SUBTRACT WS-ARABIC-VAL(I) FROM WS-INPUT-NUMBER: After appending the symbol, we subtract its value from our input number. The inner loop then re-evaluates its condition with the new, smaller number.

Alternative Approaches and Considerations

While the greedy algorithm with a lookup table is highly effective, it's not the only way to solve this. Understanding alternatives helps deepen your problem-solving skills.

Pros and Cons of Different Methods

Approach Pros Cons
Greedy Algorithm (Our Solution) - Very efficient and fast.
- Logic is straightforward and easy to follow.
- Handles all subtractive cases elegantly.		 - Requires pre-defining a lookup table in memory.
Digit-by-Digit Conversion - No large lookup table needed.
- Can feel more mathematical.		 - Much more complex logic.
- Requires separate handling for thousands, hundreds, tens, and ones places.
- Prone to errors with nested IF or EVALUATE statements.
Mathematical/Modulo Approach - Can be very compact in languages with powerful math libraries. - Not idiomatic for Cobol.
- Heavy reliance on division and modulo operations can be less readable in a procedural context.

For Cobol, the chosen approach is superior because it plays to the language's strengths: structured data tables and clear, procedural loops. A digit-by-digit approach in Cobol would involve a complex series of EVALUATE statements, which could become difficult to maintain.

Frequently Asked Questions (FAQ)

Why is the conversion limit typically 3,999?

The standard Roman numeral system does not have a dedicated symbol for 5,000. Repeating 'M' four times ('MMMM') to represent 4,000 is non-standard. While historical variations exist (like a bar over a numeral to multiply by 1,000), the conventional system taught and used today stops at 3,999 (MMMCMXCIX).

How does the code handle invalid input like 0 or negative numbers?

Our program includes a basic validation check in the 0000-MAIN-LOGIC paragraph: IF WS-INPUT-NUMBER > 0 AND WS-INPUT-NUMBER < 4000. If the input is outside this range, it prints an error message and skips the conversion logic. For a production system, this validation would be more robust, likely in its own dedicated paragraph.

What exactly is the `PIC` clause in Cobol?

PIC stands for "Picture". It's a clause used in the DATA DIVISION to define the type and size of a data item. PIC 9(04) defines a numeric field of 4 digits. PIC X(15) defines an alphanumeric (string) field of 15 characters. It's a core feature for defining strict data records.

How does `PERFORM VARYING` differ from loops in other languages?

PERFORM VARYING is Cobol's primary construct for a "for" loop. The syntax VARYING I FROM 1 BY 1 UNTIL I > 13 is very explicit: it initializes a variable (I), sets its starting value (FROM 1), defines the increment (BY 1), and specifies the exit condition (UNTIL I > 13). It's more verbose but also extremely clear about the loop's behavior.

Is learning Cobol still a valuable skill?

Absolutely. Billions of lines of Cobol code still run the global financial, insurance, and government systems. There is a high demand for developers who can maintain, modernize, and integrate these critical legacy systems. Challenges like this one, found in the kodikra.com Cobol curriculum, build the foundational skills needed for these roles.

How could this code be optimized further?

For this specific problem, the current solution is already very efficient. The main "optimization" in a real-world scenario would be to refactor it into a callable subprogram. This would allow any other program on the system to pass it an Arabic number and receive the Roman numeral back, promoting code reuse.

What is the purpose of the `REDEFINES` clause?

The REDEFINES clause is a memory-management feature. It allows you to apply a different logical structure to a previously defined area of memory without allocating new space. In our case, it lets us view a single flat string (WS-CONVERSION-TABLE) as a structured array (WS-CONVERSION-MAP), which is perfect for creating efficient lookup tables.

Conclusion: More Than Just a Number

Successfully converting Arabic numbers to Roman numerals in Cobol is a significant milestone. You've not only solved a classic algorithmic puzzle but have also engaged with the core principles of a language that powers critical infrastructure worldwide. You've mastered data definition with the DATA DIVISION, implemented clear procedural logic with PERFORM loops, and precisely manipulated data with the STRING verb and table indexing.

This exercise demonstrates that Cobol's perceived "verbosity" is actually a feature designed for clarity, maintainability, and stability. The skills you've honed here—structured thinking, careful data management, and step-by-step procedural implementation—are timeless and highly valuable in any programming discipline.

As you continue your journey through the Cobol 5 roadmap module, remember the lessons from this challenge. Every problem is an opportunity to appreciate the unique strengths of your tools and to build robust, elegant solutions that stand the test of time.

Disclaimer: The code in this article was written and tested with GnuCOBOL 3.2. The concepts are universal, but syntax may vary slightly with other compilers like those from IBM or Micro Focus.

Published by Kodikra — Your trusted Cobol learning resource.

Post a Comment