Collatz Conjecture in Cobol: Complete Solution & Deep Dive Guide

The Complete Guide to Solving the Collatz Conjecture in Cobol

Solving the Collatz Conjecture in Cobol provides a perfect exercise for understanding core procedural logic. It involves creating a program that iteratively applies two simple rules to a positive integer—if even, divide by 2; if odd, multiply by 3 and add 1—counting the steps until the number becomes 1.

Have you ever encountered a problem so simple to describe, yet so profoundly difficult to solve that it has baffled mathematicians for decades? This is the essence of the Collatz Conjecture, often called the "3n+1 problem." It's a puzzle that feels like it should have an easy answer, but none has ever been found. Now, imagine tackling this enigma using a language forged in the crucible of mainframe computing: Cobol.

You might be thinking that Cobol, with its verbose syntax and rigid structure, is an odd choice for a mathematical puzzle. You're likely here because you're navigating the robust world of Cobol as part of the kodikra learning path, perhaps feeling that its application is limited to finance and business. This guide is here to shatter that perception. We will demonstrate how Cobol's deliberate and structured nature makes it an incredibly clear and powerful tool for implementing algorithms like the Collatz Conjecture, turning its perceived weaknesses into strengths for logical clarity.

What Exactly is the Collatz Conjecture?

The Collatz Conjecture is a famous unsolved problem in mathematics. It was proposed by Lothar Collatz in 1937 and, despite its simple rules, remains unproven. The conjecture applies to any positive integer and defines a sequence of numbers based on a straightforward iterative process.

The rules are as follows:

If the current number is even, the next number in the sequence is half of the current number (n / 2).
If the current number is odd, the next number is three times the current number plus one (3n + 1).

The conjecture states that no matter which positive integer you start with, the sequence will eventually reach the number 1. Once it reaches 1, it enters a simple loop: 1 → 4 → 2 → 1 → ...

An Example in Action

Let's trace the sequence for the starting number 6:

6 is even, so we divide by 2 to get 3. (Step 1)
3 is odd, so we compute (3 * 3) + 1 to get 10. (Step 2)
10 is even, so we divide by 2 to get 5. (Step 3)
5 is odd, so we compute (3 * 5) + 1 to get 16. (Step 4)
16 is even, so we divide by 2 to get 8. (Step 5)
8 is even, so we divide by 2 to get 4. (Step 6)
4 is even, so we divide by 2 to get 2. (Step 7)
2 is even, so we divide by 2 to get 1. (Step 8)

For the starting number 6, it takes 8 steps to reach 1. The challenge in this kodikra module is to write a program that can take any positive integer and return this step count.

This problem is a fantastic way to practice fundamental programming concepts like loops, conditional logic (if/else), and basic arithmetic operations—all of which are cornerstones of the Cobol language.

Why Use Cobol for an Algorithm Challenge?

At first glance, Cobol might seem like an archaic choice for a mathematical problem. Modern languages like Python or JavaScript can solve this in just a few lines of code. However, using Cobol for this task reveals the language's unique strengths and provides invaluable insights, especially for developers working on enterprise systems.

Unmatched Clarity and Self-Documentation

Cobol's syntax is famously verbose and English-like. A statement like ADD 1 TO WS-STEP-COUNTER is instantly understandable to anyone, programmer or not. In a complex business logic environment, this self-documenting quality is a massive advantage. For an algorithm like the Collatz Conjecture, it forces you to write code that reads like a set of instructions, making the logic flow transparent and easy to debug.

Precision in Data Handling

Cobol was built for business, which means it handles numbers with extreme precision. The DATA DIVISION and its PICTURE (PIC) clauses give you granular control over data types, storage, and formatting. You can define a variable to hold exactly 18 digits (PIC 9(18)), eliminating the floating-point inaccuracies that can plague other languages. This precision is critical in financial calculations and, in our case, ensures our integer arithmetic is flawless, even with large numbers.

Structured and Procedural Logic

The conjecture is a purely procedural algorithm: start, loop with conditions, end. This maps perfectly to Cobol's structured design. The program is neatly divided into `DIVISIONS`, `SECTIONS`, and `PARAGRAPHS`. The logic lives in the PROCEDURE DIVISION, where statements are executed sequentially. This rigid structure encourages clean, organized, and maintainable code, a skill that is highly valued in any programming discipline.

Tackling this problem in Cobol isn't just about finding a solution; it's about mastering the foundational, structured programming techniques that are central to the Cobol programming language and its real-world applications.

How to Implement the Collatz Conjecture in Cobol

Now, let's dive into the practical implementation. We will build a complete Cobol program from scratch. This program will take a hardcoded positive integer, calculate the steps to reach 1, and display the result. We'll then walk through every line of the code to ensure you understand its purpose.

The Complete Cobol Solution

Here is the full source code. This program is designed to be compiled with a standard Cobol compiler like GnuCOBOL.


      ******************************************************************
      * Program: COLLATZ - Collatz Conjecture Step Counter
      * Author:  Kodikra.com Exclusive Curriculum
      * Date:    (Current Date)
      * Purpose: Given a positive integer, calculate the number of
      *          steps required to reach 1 using the Collatz rules.
      ******************************************************************
       IDENTIFICATION DIVISION.
       PROGRAM-ID. COLLATZ.

       DATA DIVISION.
       WORKING-STORAGE SECTION.
      *> Input and state variables
       01 WS-INPUT-NUMBER       PIC 9(18) VALUE 12.
       01 WS-CURRENT-NUMBER     PIC 9(18).
       01 WS-STEP-COUNTER       PIC 9(9)  VALUE 0.

      *> Variables for arithmetic operations
       01 WS-REMAINDER          PIC 9(1).
       01 WS-QUOTIENT           PIC 9(18).

      *> Output formatting
       01 WS-OUTPUT-LINE        PIC X(80).
       01 WS-DISPLAY-STEPS      PIC Z(8)9.

       PROCEDURE DIVISION.
       
       100-MAIN-LOGIC.
      *    Initialize the process
           MOVE WS-INPUT-NUMBER TO WS-CURRENT-NUMBER.
           DISPLAY "Starting Collatz sequence for: " WS-INPUT-NUMBER.

      *    Input validation
           IF WS-CURRENT-NUMBER IS NOT POSITIVE
               DISPLAY "Error: Input must be a positive integer."
               STOP RUN
           END-IF.

      *    Main loop: Continue until the number is 1
           PERFORM 200-CALCULATION-LOOP UNTIL WS-CURRENT-NUMBER = 1.

      *    Display the final result
           MOVE WS-STEP-COUNTER TO WS-DISPLAY-STEPS.
           STRING "Total steps to reach 1: "
                  FUNCTION TRIM(WS-DISPLAY-STEPS)
                  INTO WS-OUTPUT-LINE.
           DISPLAY WS-OUTPUT-LINE.

      *    End the program
           STOP RUN.

       200-CALCULATION-LOOP.
      *    Increment the step counter for each iteration
           ADD 1 TO WS-STEP-COUNTER.

      *    Check if the number is even or odd
           DIVIDE WS-CURRENT-NUMBER BY 2
               GIVING WS-QUOTIENT
               REMAINDER WS-REMAINDER.

           IF WS-REMAINDER = 0
      *        It's an even number
               MOVE WS-QUOTIENT TO WS-CURRENT-NUMBER
           ELSE
      *        It's an odd number
               COMPUTE WS-CURRENT-NUMBER = (WS-CURRENT-NUMBER * 3) + 1
           END-IF.

Setting Up Your Environment and Running the Code

To compile and run this program, you'll need a Cobol compiler. GnuCOBOL is a popular, free, and open-source option available for most operating systems.

1. Save the code above into a file named `collatz.cob`. The `.cob` extension is a common convention.

2. Open your terminal or command prompt and navigate to the directory where you saved the file.

3. Compile the code using the following command:


$ cobc -x -free collatz.cob

Let's break down this command:

cobc is the GnuCOBOL compiler.
-x tells the compiler to create an executable file.
-free specifies that we are using a modern, free-format source code style (as opposed to the old fixed-format with specific column requirements).
collatz.cob is our source file.

4. If the compilation is successful, you will have a new executable file (e.g., `collatz` on Linux/macOS or `collatz.exe` on Windows). Run it from your terminal:


$ ./collatz

You should see the following output:


Starting Collatz sequence for: 12
Total steps to reach 1: 9

You can change the starting number by modifying the VALUE 12 clause in the DATA DIVISION and recompiling.

Detailed Code Walkthrough

Understanding a Cobol program means understanding its structure. Let's dissect our solution division by division, section by section.

The Four Divisions of a Cobol Program

Every Cobol program is composed of up to four divisions:

IDENTIFICATION DIVISION: Names the program. It's the only mandatory division.
ENVIRONMENT DIVISION: Describes the computer environment. We've omitted it for simplicity as it's often not needed for basic programs.
DATA DIVISION: Defines all the variables (data items) the program will use.
PROCEDURE DIVISION: Contains the actual logic and executable statements.

`IDENTIFICATION DIVISION`


       IDENTIFICATION DIVISION.
       PROGRAM-ID. COLLATZ.

This is the simplest part. We are giving our program a name, COLLATZ. This is how the operating system and other programs will identify it.

`DATA DIVISION`


       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 WS-INPUT-NUMBER       PIC 9(18) VALUE 12.
       01 WS-CURRENT-NUMBER     PIC 9(18).
       01 WS-STEP-COUNTER       PIC 9(9)  VALUE 0.
       01 WS-REMAINDER          PIC 9(1).
       01 WS-QUOTIENT           PIC 9(18).
       01 WS-DISPLAY-STEPS      PIC Z(8)9.

This is where we declare our variables. The WORKING-STORAGE SECTION is used for temporary variables that exist only during the program's execution.

01 is the level number, indicating a top-level data item.
WS- is a common prefix for "Working-Storage" variables, improving readability.
PIC stands for PICTURE, which defines the variable's type and size. 9 represents a numeric digit. 9(18) means a number with up to 18 digits. X(80) would be an 80-character alphanumeric string.
VALUE initializes the variable. WS-INPUT-NUMBER starts at 12, and our WS-STEP-COUNTER starts at 0.
WS-REMAINDER and WS-QUOTIENT are helper variables for our division calculation.
WS-DISPLAY-STEPS uses a special picture clause: Z(8)9. The Z is a zero-suppression character. It means that if the number is, for example, 00000009, it will be displayed as 9, trimming leading zeros for cleaner output.

`PROCEDURE DIVISION`

This is the heart of our program, containing the executable logic. We've structured it into paragraphs (like 100-MAIN-LOGIC) for better organization.

ASCII Art: Program Flow Logic

This diagram illustrates the high-level flow of our Cobol program's PROCEDURE DIVISION.

    ● Start Program
    │
    ▼
  ┌───────────────────────┐
  │ Initialize Variables  │
  │ (Move Input to Current) │
  └──────────┬────────────┘
             │
             ▼
    ◆ Is Input Positive?
   ╱           ╲
  Yes           No
  │              │
  ▼              ▼
┌──────────────────┐  ┌──────────────────┐
│ PERFORM Loop     │  │ Display Error    │
│ Until Number = 1 │  │ STOP RUN         │
└────────┬─────────┘  └──────────────────┘
         │
         ▼
┌──────────────────┐
│ Format & Display │
│ Final Step Count │
└────────┬─────────┘
         │
         ▼
    ● STOP RUN

Paragraph 100-MAIN-LOGIC:


           MOVE WS-INPUT-NUMBER TO WS-CURRENT-NUMBER.
           DISPLAY "Starting Collatz sequence for: " WS-INPUT-NUMBER.

We begin by copying our starting value into WS-CURRENT-NUMBER, which will be modified during the loop. We also display a message to inform the user what number we're processing.


           IF WS-CURRENT-NUMBER IS NOT POSITIVE
               DISPLAY "Error: Input must be a positive integer."
               STOP RUN
           END-IF.

This is a crucial validation step. The Collatz Conjecture is defined for positive integers only. If the input is zero or negative, we display an error and terminate the program with STOP RUN.


           PERFORM 200-CALCULATION-LOOP UNTIL WS-CURRENT-NUMBER = 1.

This is the main loop driver. The PERFORM ... UNTIL statement repeatedly executes the code in the 200-CALCULATION-LOOP paragraph. The loop continues as long as WS-CURRENT-NUMBER is not equal to 1.

Paragraph 200-CALCULATION-LOOP:

This paragraph contains the core logic of the Collatz algorithm.

ASCII Art: Collatz Algorithm Logic

This diagram shows the decision-making process inside each step of the calculation loop.

    ● Enter Loop Step
    │
    ▼
  ┌─────────────────┐
  │ Add 1 to Steps  │
  └────────┬────────┘
           │
           ▼
  ┌─────────────────┐
  │ Divide Number   │
  │ by 2, get Remainder │
  └────────┬────────┘
           │
           ▼
    ◆ Remainder = 0?
   ╱           ╲
  Even          Odd
  │              │
  ▼              ▼
┌──────────────────┐  ┌────────────────────┐
│ Set Number to    │  │ Set Number to      │
│ Quotient (n/2)   │  │ (Number * 3) + 1   │
└──────────────────┘  └────────────────────┘
  ╲              ╱
   └──────┬──────┘
          │
          ▼
     ● Exit Loop Step


           ADD 1 TO WS-STEP-COUNTER.

The first thing we do in each iteration is increment our step counter.


           DIVIDE WS-CURRENT-NUMBER BY 2
               GIVING WS-QUOTIENT
               REMAINDER WS-REMAINDER.

This is a powerful Cobol verb. It performs division and conveniently populates two separate variables for us: WS-QUOTIENT gets the result of the division, and WS-REMAINDER gets the remainder. This is how we efficiently check for evenness.


           IF WS-REMAINDER = 0
               MOVE WS-QUOTIENT TO WS-CURRENT-NUMBER
           ELSE
               COMPUTE WS-CURRENT-NUMBER = (WS-CURRENT-NUMBER * 3) + 1
           END-IF.

This is our conditional logic.

If WS-REMAINDER is 0, the number was even. We update WS-CURRENT-NUMBER with the quotient (the result of n/2).
If the remainder is not 0, the number was odd. We use the COMPUTE verb to perform the 3n+1 calculation and update WS-CURRENT-NUMBER with the result. COMPUTE is useful for complex arithmetic expressions involving multiple operators.

Alternative Approaches and Considerations

While our implementation is clean and effective, it's worth considering other ways this could be approached in Cobol and the potential risks involved.

Using Nested `IF` Statements

Instead of a separate paragraph for the loop body, some programmers might place the logic directly inside the PERFORM loop using an inline structure. This is less common in older, highly structured Cobol styles but is possible with modern compilers. However, for complex logic, using separate, well-named paragraphs (like 200-CALCULATION-LOOP) greatly improves readability and maintainability.

Risk: Numeric Overflow

The Collatz sequence can produce very large numbers before eventually descending to 1. For example, the number 27 takes 111 steps and reaches a peak of 9,232. Our variable WS-CURRENT-NUMBER is defined as PIC 9(18), which can hold a number up to 9,999,999,999,999,999,999. This is equivalent to a 64-bit unsigned integer and is sufficient for most inputs tested. However, for extremely large starting numbers, this could overflow, leading to incorrect results. In critical financial systems, Cobol developers must be vigilant about defining data sizes that can accommodate the largest possible values to prevent such errors.

Pros and Cons of the Cobol Approach

To provide a balanced view, let's compare solving this problem in Cobol versus a modern scripting language like Python.

Aspect	Cobol Approach	Python Approach
Verbosity & Readability	Highly verbose but extremely clear and self-documenting. Logic is easy to follow for non-experts.	Very concise. Can be solved in a few lines, but may be less clear to a non-programmer.
Performance	Compiled to native machine code. Extremely fast for raw computation, especially on mainframes.	Interpreted, which can be slower. However, for this problem, the difference is negligible on modern hardware.
Data Control	Explicit, precise control over data types and memory layout via `PIC` clauses. Prevents common data errors.	Dynamic typing is flexible but can hide potential type errors. Integers have arbitrary precision, avoiding overflow.
Development Speed	Slower. The rigid structure and compile-run cycle take more time.	Much faster. The interactive nature and concise syntax allow for rapid prototyping.
Error Handling	Requires explicit checks (e.g., for positive input). Overflow is a silent failure if not managed.	Can use try-except blocks for robust error handling. Integer overflow is not an issue.

This comparison highlights that the "best" language is context-dependent. For the mission-critical, high-volume batch processing where Cobol excels, its rigidity and precision are indispensable features. For quick scripts and data science, Python's flexibility is superior.

Frequently Asked Questions (FAQ)

What is the 3n+1 problem?: The "3n+1 problem" is simply another name for the Collatz Conjecture. It gets its name from the rule applied to odd numbers: multiply by 3 and add 1.
Why is the WORKING-STORAGE SECTION so important in Cobol?: The WORKING-STORAGE SECTION is where all temporary variables used by the program are defined. Unlike many modern languages where variables can be declared anywhere, Cobol requires all data to be explicitly defined in the DATA DIVISION before use. This strictness enforces discipline, prevents accidental variable creation, and makes the program's memory footprint clear from the start.
Can the Collatz sequence get stuck in a loop other than 4-2-1?: This is a key part of the unsolved conjecture. Mathematicians have not found any other loops, and it is conjectured that no others exist. The problem remains open because no one has been able to prove that a starting number couldn't enter a different, very long loop, or grow to infinity.
How do I compile and run this Cobol code?: You need a Cobol compiler like GnuCOBOL. First, save the code as a .cob file (e.g., collatz.cob). Then, compile it from your terminal with cobc -x -free collatz.cob. Finally, run the resulting executable with ./collatz (on Linux/macOS) or collatz.exe (on Windows).
Is Cobol still relevant today?: Absolutely. Cobol is the backbone of the global financial system, running on mainframe computers in banks, insurance companies, and government agencies. Billions of lines of Cobol code are still in active use, processing trillions of dollars in transactions daily. Learning Cobol is a valuable and in-demand skill for maintaining and modernizing these critical systems.
What does PIC 9(18) mean in the code?: PIC 9(18) is a PICTURE clause that defines a numeric data item. The 9 signifies that it can only hold digits (0-9). The (18) specifies its length, meaning it can store an integer with up to 18 digits. This is a common way to define a large integer, similar to a long long in C or a 64-bit integer.
Could this program fail for very large numbers?: Yes. If a number in the sequence exceeds the 18-digit capacity of our PIC 9(18) variable, a numeric overflow will occur. The most significant digits will be truncated, leading to an incorrect result without any explicit error message. This is a classic risk in fixed-size integer arithmetic that developers must always consider.

Conclusion: Structure, Precision, and Power

We've successfully journeyed from a mysterious mathematical conjecture to a complete, working Cobol program. In doing so, we've demonstrated that Cobol, far from being a relic, is a language of immense structure and precision. Its verbose, self-documenting nature forces a clear and methodical approach to problem-solving, turning complex logic into an understandable, step-by-step procedure.

By implementing the Collatz Conjecture, you have practiced core programming skills—loops, conditionals, and arithmetic—within the disciplined framework of Cobol's divisions and sections. This exercise from the kodikra.com curriculum is not just about an algorithm; it's about appreciating how a language's design philosophy shapes the way we write and understand code.

As you continue your programming journey, remember the lessons learned here. The clarity and reliability instilled by Cobol's structure are valuable principles in any language you may work with in the future.

Disclaimer: The code in this article is written for GnuCOBOL 3.1+ and may require minor adjustments for other Cobol compilers or environments.

Ready to tackle the next challenge? Continue your journey on the Cobol learning path or explore more about the Cobol language in our comprehensive guides.

Published by Kodikra — Your trusted Cobol learning resource.

kodikra

Search this blog