Cobol interview questions
Cobol Interview Questions with Answers
Most Asked Cobol Interview Questions for Software Engineer Roles
100+ QuestionsDetailed AnswersCode ExamplesUpdated for 2026
Introduction
This page provides a complete collection of Cobol Interview Questions and Answers designed for frontend developers, full-stack developers, React developers, Angular developers, and software engineers preparing for technical interviews. Cobol is a strongly typed programming language developed by Microsoft that extends JavaScript by adding static typing, interfaces, advanced type checking, and modern development features. It helps developers build scalable and maintainable applications. This interview guide covers beginner, intermediate, and advanced Cobol concepts including types, interfaces, classes, generics, decorators, utility types, modules, Cobol with React, Angular, Node.js, and real-world coding interview scenarios.
Why Cobol?
- Strong static typing – catches errors at compile time, reducing runtime bugs
- Excellent tooling and IDE support – autocompletion, navigation, and refactoring
- Superset of JavaScript – works seamlessly with all existing JavaScript libraries
- Used by major frameworks like React, Angular, and Vue – essential for large-scale apps
- Enables scalable and maintainable enterprise-grade applications
- Growing community, continuous improvements, and high demand in the job market
Most Asked Cobol Interview Questions
Beginner
1. What is COBOL and what are its key features?
COBOL (Common Business-Oriented Language) is a high-level programming language designed for business data processing. It is widely used in banking, finance, and government systems.
- English-like Syntax: Self-documenting code
- Data Processing: Excellent for handling large volumes of data
- File Handling: Built-in support for sequential and indexed files
- Performance: Highly optimized for business applications
- Backward Compatibility: Code written decades ago still runs today
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
PROCEDURE DIVISION.
DISPLAY "Hello, World!"
STOP RUN.Beginner
2. What are Data Types in COBOL?
COBOL provides extensive data types through the PICTURE clause. The language is known for its powerful data description capabilities.
PIC 9(n)— numeric dataPIC X(n)— alphanumeric dataPIC V— implied decimal pointPIC S— signed numericPIC 9(n)V99— decimal numbers
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. DATATYPES.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-AGE PIC 9(3) VALUE 25.
01 WS-SALARY PIC 9(8)V99 VALUE 50000.50.
01 WS-PI PIC 9(3)V9(11) VALUE 3.14159265358.
01 WS-GRADE PIC X VALUE 'A'.
01 WS-IS-ACTIVE PIC X VALUE 'Y'.
01 WS-NAME PIC X(10) VALUE "Alice".
PROCEDURE DIVISION.
DISPLAY "Age: " WS-AGE
DISPLAY "Salary: " WS-SALARY
DISPLAY "Pi: " WS-PI
DISPLAY "Grade: " WS-GRADE
DISPLAY "Active: " WS-IS-ACTIVE
DISPLAY "Name: " WS-NAME
STOP RUN.Beginner
3. What are Variables and Constants in COBOL?
COBOL uses DATA DIVISION to define variables. Constants are defined using the CONSTANT clause or through literal values.
- Variables defined in
WORKING-STORAGE - Constants defined with
CONSTANTclause PICdefines the data format- Level numbers (01-77) define data hierarchy
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. CONSTANTS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-X PIC 9(3) VALUE 10.
01 WS-VAL PIC 9(3)V99 VALUE 3.14.
01 WS-STR PIC X(10) VALUE "Hello".
PROCEDURE DIVISION.
DISPLAY "x = " WS-X
DISPLAY "val = " WS-VAL
DISPLAY "str = " WS-STR
STOP RUN.Beginner
4. How do Data Structures work in COBOL?
COBOL uses a hierarchical data structure system with level numbers. Group items (01) contain elementary items (02-49) that define the actual data.
- 01 level defines the group/structure
- 02-49 levels define subordinate fields
OCCURSclause defines arrays/tablesREDEFINESallows memory overlay
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. OOPCLASS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-CAR.
05 WS-BRAND PIC X(20).
05 WS-YEAR PIC 9(4).
05 WS-PRICE PIC 9(8)V99.
PROCEDURE DIVISION.
MOVE "Toyota" TO WS-BRAND
MOVE 2022 TO WS-YEAR
MOVE 25000.00 TO WS-PRICE
DISPLAY "Brand: " WS-BRAND
DISPLAY "Year: " WS-YEAR
DISPLAY "Price: $" WS-PRICE
STOP RUN.Beginner
5. What is the COBOL program structure?
COBOL programs have a four-division structure: IDENTIFICATION DIVISION, ENVIRONMENT DIVISION, DATA DIVISION, and PROCEDURE DIVISION.
IDENTIFICATION DIVISION— Program name and metadataENVIRONMENT DIVISION— File and system specificationsDATA DIVISION— Data definitionsPROCEDURE DIVISION— Executable code
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. CONSTRUCTORS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-STUDENT.
05 WS-NAME PIC X(20).
05 WS-AGE PIC 9(3).
PROCEDURE DIVISION.
MOVE "Unknown" TO WS-NAME
MOVE 0 TO WS-AGE
DISPLAY "Default constructor called"
MOVE "Alice" TO WS-NAME
MOVE 20 TO WS-AGE
DISPLAY "Parameterized constructor: " WS-NAME
DISPLAY "Name: " WS-NAME ", Age: " WS-AGE
STOP RUN.Intermediate
6. How does Inheritance work in COBOL?
COBOL does not support traditional inheritance like OOP languages. However, it supports copybooks and calling subprograms for code reuse.
- Copybooks — included at compile time
- Subprograms — called dynamically or statically
- Object-Oriented COBOL (OOCOBOL) supports classes
- Inheritance available in OO COBOL
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. INHERITANCE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ANIMAL.
05 WS-ANIMAL-NAME PIC X(20).
05 WS-ANIMAL-AGE PIC 9(3).
01 WS-DOG.
05 WS-DOG-NAME PIC X(20).
05 WS-DOG-AGE PIC 9(3).
05 WS-BREED PIC X(20).
01 WS-CAT.
05 WS-CAT-NAME PIC X(20).
05 WS-CAT-AGE PIC 9(3).
PROCEDURE DIVISION.
MOVE "Rex" TO WS-DOG-NAME
MOVE 3 TO WS-DOG-AGE
MOVE "German Shepherd" TO WS-BREED
MOVE "Whiskers" TO WS-CAT-NAME
MOVE 2 TO WS-CAT-AGE
DISPLAY "Name: " WS-DOG-NAME ", Age: " WS-DOG-AGE
DISPLAY "Breed: " WS-BREED
DISPLAY WS-DOG-NAME " says: Woof!"
DISPLAY WS-CAT-NAME " says: Meow!"
STOP RUN.Intermediate
7. What is Polymorphism in COBOL?
Object-Oriented COBOL supports polymorphism through inheritance and interfaces. Traditional COBOL uses implicit and explicit casting for data type flexibility.
- OO COBOL supports method overriding
- Interface-based polymorphism
- Data type conversion with
USAGEclause - Abstract classes in OO COBOL
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. POLYMORPHISM.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-CIRCLE-RADIUS PIC 9(3)V99 VALUE 5.00.
01 WS-RECT-WIDTH PIC 9(3)V99 VALUE 4.00.
01 WS-RECT-HEIGHT PIC 9(3)V99 VALUE 6.00.
01 WS-CIRCLE-AREA PIC 9(5)V99.
01 WS-RECT-AREA PIC 9(5)V99.
01 WS-CIRCLE-PERIM PIC 9(5)V99.
01 WS-RECT-PERIM PIC 9(5)V99.
PROCEDURE DIVISION.
COMPUTE WS-CIRCLE-AREA = 3.14159 * WS-CIRCLE-RADIUS *
WS-CIRCLE-RADIUS
COMPUTE WS-CIRCLE-PERIM = 2 * 3.14159 * WS-CIRCLE-RADIUS
COMPUTE WS-RECT-AREA = WS-RECT-WIDTH * WS-RECT-HEIGHT
COMPUTE WS-RECT-PERIM = 2 * (WS-RECT-WIDTH + WS-RECT-HEIGHT)
DISPLAY "Circle Area: " WS-CIRCLE-AREA
DISPLAY "Circle Perimeter: " WS-CIRCLE-PERIM
DISPLAY "Rectangle Area: " WS-RECT-AREA
DISPLAY "Rectangle Perimeter: " WS-RECT-PERIM
STOP RUN.Intermediate
8. What are Arithmetic Operations in COBOL?
COBOL supports arithmetic operations using verbs like ADD, SUBTRACT, MULTIPLY, DIVIDE, and the COMPUTE verb.
COMPUTE— evaluates arithmetic expressionsADD A TO B— adds A to BMULTIPLY A BY B— multiplies A by BCOMPUTEsupports standard math operators
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. OPERATORS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-V1-X PIC 9(3) VALUE 3.
01 WS-V1-Y PIC 9(3) VALUE 4.
01 WS-V2-X PIC 9(3) VALUE 1.
01 WS-V2-Y PIC 9(3) VALUE 2.
01 WS-RES-X PIC 9(3).
01 WS-RES-Y PIC 9(3).
PROCEDURE DIVISION.
COMPUTE WS-RES-X = WS-V1-X + WS-V2-X
COMPUTE WS-RES-Y = WS-V1-Y + WS-V2-Y
DISPLAY "v1 = (" WS-V1-X ", " WS-V1-Y ")"
DISPLAY "v2 = (" WS-V2-X ", " WS-V2-Y ")"
DISPLAY "v1 + v2 = (" WS-RES-X ", " WS-RES-Y ")"
COMPUTE WS-RES-X = WS-V1-X - WS-V2-X
COMPUTE WS-RES-Y = WS-V1-Y - WS-V2-Y
DISPLAY "v1 - v2 = (" WS-RES-X ", " WS-RES-Y ")"
COMPUTE WS-RES-X = WS-V1-X * 2
COMPUTE WS-RES-Y = WS-V1-Y * 2
DISPLAY "v1 * 2 = (" WS-RES-X ", " WS-RES-Y ")"
STOP RUN.Intermediate
9. What are Tables (Arrays) in COBOL?
COBOL uses the OCCURS clause to define tables (arrays). Tables can be one-dimensional or multi-dimensional with various indexing options.
OCCURS n TIMES— defines array sizeDEPENDING ON— variable length tablesINDEXED BY— defines index for table access- Tables can be used with
PERFORM VARYINGfor iteration
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. GENERICS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-STACK.
05 WS-STACK-TOP PIC 9(3) VALUE -1.
05 WS-STACK-DATA OCCURS 100 TIMES PIC 9(5).
01 WS-VAL PIC 9(5).
01 WS-KEY PIC X(10).
01 WS-VALUE PIC 9(5).
PROCEDURE DIVISION.
PERFORM PUSH(10)
PERFORM PUSH(20)
PERFORM PUSH(30)
PERFORM POP
PERFORM POP
MOVE "age" TO WS-KEY
MOVE 25 TO WS-VALUE
DISPLAY WS-KEY " -> " WS-VALUE
STOP RUN.
PUSH.
ADD 1 TO WS-STACK-TOP
MOVE WS-VAL TO WS-STACK-DATA(WS-STACK-TOP + 1).
POP.
DISPLAY WS-STACK-DATA(WS-STACK-TOP + 1)
SUBTRACT 1 FROM WS-STACK-TOP.Intermediate
10. How do File Operations work in COBOL?
COBOL provides extensive file handling capabilities through the ENVIRONMENT DIVISION and FILE SECTION. Files can be sequential, indexed, or relative.
SELECT— assigns file to a nameOPEN— opens file for processingREAD— reads a record from fileWRITE— writes a record to fileCLOSE— closes the file
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. LISTS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-LIST.
05 WS-LIST-COUNT PIC 9(3) VALUE 0.
05 WS-LIST-DATA OCCURS 100 TIMES PIC 9(5).
01 WS-I PIC 9(3).
01 WS-TEMP PIC 9(5).
PROCEDURE DIVISION.
PERFORM ADD(5)
PERFORM ADD(2)
PERFORM ADD(8)
PERFORM ADD(1)
PERFORM ADD(9)
PERFORM ADD(3)
PERFORM ADD(7)
PERFORM ADD(0)
PERFORM SORT-LIST
PERFORM DISPLAY-LIST
STOP RUN.
ADD.
ADD 1 TO WS-LIST-COUNT
MOVE WS-TEMP TO WS-LIST-DATA(WS-LIST-COUNT).
SORT-LIST.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-LIST-COUNT
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > WS-LIST-COUNT - WS-I
IF WS-LIST-DATA(WS-J) > WS-LIST-DATA(WS-J + 1)
MOVE WS-LIST-DATA(WS-J) TO WS-TEMP
MOVE WS-LIST-DATA(WS-J + 1) TO WS-LIST-DATA(WS-J)
MOVE WS-TEMP TO WS-LIST-DATA(WS-J + 1)
END-IF.
DISPLAY-LIST.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-LIST-COUNT
DISPLAY WS-LIST-DATA(WS-I)
END-PERFORM.Intermediate
11. How do Conditional Statements work in COBOL?
COBOL provides IF, EVALUATE, and PERFORM statements for conditional logic. The EVALUATE statement is similar to a switch/case in other languages.
IF condition THEN ... ELSE ... END-IFEVALUATE variable— multi-way branchingWHEN— defines cases in EVALUATENOT,AND,OR— logical operators
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. DICTIONARY.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-SCORES.
05 WS-SCORE OCCURS 10 TIMES.
10 WS-NAME PIC X(20).
10 WS-VAL PIC 9(5).
01 WS-SET.
05 WS-SET-COUNT PIC 9(3) VALUE 0.
05 WS-SET-DATA OCCURS 100 TIMES PIC 9(5).
01 WS-I PIC 9(3).
01 WS-FOUND PIC X VALUE 'N'.
PROCEDURE DIVISION.
MOVE "Alice" TO WS-NAME(1)
MOVE 95 TO WS-VAL(1)
MOVE "Bob" TO WS-NAME(2)
MOVE 87 TO WS-VAL(2)
MOVE "Carol" TO WS-NAME(3)
MOVE 92 TO WS-VAL(3)
PERFORM VARYING WS-I FROM 1 BY 1 UNTIL WS-I > 3
DISPLAY WS-NAME(WS-I) ": " WS-VAL(WS-I)
END-PERFORM
PERFORM ADD-SET(5)
PERFORM ADD-SET(2)
PERFORM ADD-SET(8)
PERFORM ADD-SET(1)
PERFORM ADD-SET(9)
PERFORM ADD-SET(5)
PERFORM DISPLAY-SET
STOP RUN.
ADD-SET.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-SET-COUNT
IF WS-SET-DATA(WS-I) = WS-TEMP
EXIT PERFORM
END-IF
END-PERFORM
ADD 1 TO WS-SET-COUNT
MOVE WS-TEMP TO WS-SET-DATA(WS-SET-COUNT).
DISPLAY-SET.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-SET-COUNT
DISPLAY WS-SET-DATA(WS-I)
END-PERFORM.Intermediate
12. How do Loops work in COBOL?
COBOL uses the PERFORM statement for looping. It supports various forms including PERFORM VARYING, PERFORM UNTIL, and PERFORM TIMES.
PERFORM UNTIL condition— loop until condition truePERFORM VARYING variable— indexed loopPERFORM TIMES— fixed iteration loopPERFORM PROCEDURE— call a paragraph repeatedly
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. STACKQUEUE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-STACK.
05 WS-STACK-TOP PIC 9(3) VALUE -1.
05 WS-STACK-DATA OCCURS 100 TIMES PIC 9(5).
01 WS-QUEUE.
05 WS-QUEUE-FRONT PIC 9(3) VALUE 1.
05 WS-QUEUE-REAR PIC 9(3) VALUE 0.
05 WS-QUEUE-DATA OCCURS 100 TIMES PIC 9(5).
01 WS-VAL PIC 9(5).
PROCEDURE DIVISION.
PERFORM PUSH(10)
PERFORM PUSH(20)
PERFORM PUSH(30)
PERFORM POP
PERFORM POP
PERFORM ENQUEUE(10)
PERFORM ENQUEUE(20)
PERFORM ENQUEUE(30)
PERFORM DEQUEUE
PERFORM DEQUEUE
STOP RUN.
PUSH.
ADD 1 TO WS-STACK-TOP
MOVE WS-VAL TO WS-STACK-DATA(WS-STACK-TOP + 1).
POP.
DISPLAY WS-STACK-DATA(WS-STACK-TOP + 1)
SUBTRACT 1 FROM WS-STACK-TOP.
ENQUEUE.
ADD 1 TO WS-QUEUE-REAR
MOVE WS-VAL TO WS-QUEUE-DATA(WS-QUEUE-REAR).
DEQUEUE.
DISPLAY WS-QUEUE-DATA(WS-QUEUE-FRONT)
ADD 1 TO WS-QUEUE-FRONT.Intermediate
13. How does Exception Handling work in COBOL?
COBOL handles exceptions through DECLARATIVES and AT END clauses. Modern COBOL supports EXCEPTION HANDLING with THROW and CATCH.
AT END— handles end-of-file conditionsDECLARATIVES— error handling sectionsFILE STATUS— checks file operation successEXCEPTION— modern exception handling
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. EXCEPTIONS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-A PIC 9(5) VALUE 10.
01 WS-B PIC 9(5) VALUE 0.
01 WS-AGE PIC 9(3) VALUE 200.
01 WS-RESULT PIC 9(5).
PROCEDURE DIVISION.
IF WS-B = 0
DISPLAY "Error: Division by zero!"
ELSE
COMPUTE WS-RESULT = WS-A / WS-B
DISPLAY WS-RESULT
END-IF
IF WS-AGE < 0 OR WS-AGE > 150
DISPLAY "Validation [400]: Invalid age: " WS-AGE
ELSE
DISPLAY "Age is valid"
END-IF
DISPLAY "Cleanup always runs"
STOP RUN.Advanced
14. What is the COBOL Call Statement?
The CALL statement in COBOL invokes subprograms. Parameters can be passed by reference or by content, enabling modular programming.
CALL subprogram USING param1 param2BY REFERENCE— default, passes addressBY CONTENT— passes a copyCALL ... RETURNING— returns a value
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. IDISPOSABLE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-FILE-NAME PIC X(20) VALUE "test.txt".
PROCEDURE DIVISION.
DISPLAY "Resource acquired: FileResource"
DISPLAY "Using: FileResource"
DISPLAY "Resource released: FileResource"
DISPLAY "Resource acquired: DatabaseResource"
DISPLAY "Using: DatabaseResource"
DISPLAY "Resource released: DatabaseResource"
STOP RUN.Advanced
15. What are Strings in COBOL?
COBOL provides the STRING and UNSTRING verbs for string manipulation. INSPECT is used for string inspection and modification.
STRING— concatenates stringsUNSTRING— splits strings into partsINSPECT— counts, replaces, or converts charactersDELIMITED BY— specifies delimiters
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. LAMBDAS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUMS.
05 WS-NUM OCCURS 10 TIMES PIC 9(5).
01 WS-COUNT PIC 9(3) VALUE 0.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-TEMP PIC 9(5).
PROCEDURE DIVISION.
DISPLAY "Hello, Alice!"
PERFORM ADD(5)
PERFORM ADD(1)
PERFORM ADD(8)
PERFORM ADD(3)
PERFORM ADD(9)
PERFORM ADD(2)
PERFORM ADD(7)
PERFORM SORT-LIST
PERFORM DISPLAY-LIST
STOP RUN.
ADD.
ADD 1 TO WS-COUNT
MOVE WS-TEMP TO WS-NUM(WS-COUNT).
SORT-LIST.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-COUNT
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > WS-COUNT - WS-I
IF WS-NUM(WS-J) > WS-NUM(WS-J + 1)
MOVE WS-NUM(WS-J) TO WS-TEMP
MOVE WS-NUM(WS-J + 1) TO WS-NUM(WS-J)
MOVE WS-TEMP TO WS-NUM(WS-J + 1)
END-IF.
DISPLAY-LIST.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-COUNT
DISPLAY WS-NUM(WS-I)
END-PERFORM.Advanced
16. What are COBOL Sort and Merge operations?
COBOL provides SORT and MERGE verbs for efficient data sorting and merging. These are built-in and highly optimized for business data processing.
SORT— sorts files or tablesMERGE— merges sorted filesUSINGandGIVING— input/output filesASCENDING/DESCENDING— sort order
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. ASYNC.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-URL PIC X(30).
01 WS-RESULT PIC X(50).
PROCEDURE DIVISION.
MOVE "api.example.com" TO WS-URL
DISPLAY "Data from " WS-URL
MOVE "source1" TO WS-URL
DISPLAY "Data from " WS-URL
MOVE "source2" TO WS-URL
DISPLAY "Data from " WS-URL
MOVE "source3" TO WS-URL
DISPLAY "Data from " WS-URL
STOP RUN.Intermediate
17. How does Report Writing work in COBOL?
COBOL's Report Writer feature provides a declarative way to generate reports with headers, footers, and detail lines.
REPORT SECTION— defines report structureRD— Report Description entryPAGE HEADING— page header definitionCONTROL— control breaks for totals
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. FILEIO.
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT STUDENT-FILE
ASSIGN TO "students.txt"
ORGANIZATION IS LINE SEQUENTIAL.
DATA DIVISION.
FILE SECTION.
FD STUDENT-FILE.
01 STUDENT-RECORD.
05 ST-NAME PIC X(20).
05 ST-AGE PIC 9(3).
05 ST-GPA PIC 9(3)V99.
WORKING-STORAGE SECTION.
01 WS-EOF PIC X VALUE 'N'.
PROCEDURE DIVISION.
OPEN INPUT STUDENT-FILE
PERFORM UNTIL WS-EOF = 'Y'
READ STUDENT-FILE
AT END MOVE 'Y' TO WS-EOF
NOT AT END
DISPLAY ST-NAME " | Age:" ST-AGE
" | GPA:" ST-GPA
END-READ
END-PERFORM
CLOSE STUDENT-FILE
STOP RUN.Advanced
18. What are COBOL Copybooks?
Copybooks are reusable code modules that can be included in multiple programs using the COPY statement. They promote code reuse and consistency.
COPY— includes copybook at compile timeREPLACING— modifies copybook content- Used for common data definitions
- Reduces maintenance overhead
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. LINQ.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUMS.
05 WS-NUM OCCURS 10 TIMES PIC 9(5).
01 WS-COUNT PIC 9(3) VALUE 0.
01 WS-SUM PIC 9(8) VALUE 0.
01 WS-MIN PIC 9(5) VALUE 99999.
01 WS-MAX PIC 9(5) VALUE 0.
01 WS-I PIC 9(3).
01 WS-TEMP PIC 9(5).
PROCEDURE DIVISION.
PERFORM ADD(3)
PERFORM ADD(1)
PERFORM ADD(4)
PERFORM ADD(1)
PERFORM ADD(5)
PERFORM ADD(9)
PERFORM ADD(2)
PERFORM ADD(6)
PERFORM ADD(5)
PERFORM ADD(3)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-COUNT
COMPUTE WS-SUM = WS-SUM + WS-NUM(WS-I)
IF WS-NUM(WS-I) < WS-MIN
MOVE WS-NUM(WS-I) TO WS-MIN
END-IF
IF WS-NUM(WS-I) > WS-MAX
MOVE WS-NUM(WS-I) TO WS-MAX
END-IF
END-PERFORM
DISPLAY "Sum: " WS-SUM
DISPLAY "Min: " WS-MIN
DISPLAY "Max: " WS-MAX
PERFORM DISPLAY-UNIQUE
STOP RUN.
ADD.
ADD 1 TO WS-COUNT
MOVE WS-TEMP TO WS-NUM(WS-COUNT).
DISPLAY-UNIQUE.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-COUNT
DISPLAY WS-NUM(WS-I)
END-PERFORM.Intermediate
19. How do COBOL Subprograms work?
Subprograms are separate programs that can be called by other programs. They can be compiled separately and linked at runtime.
PROGRAM-ID— identifies subprogramCALL— invokes subprogramLINKAGE SECTION— defines parametersGOBACK— returns to caller
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. LINKEDLIST.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NODE.
05 WS-NODE-DATA PIC 9(5).
05 WS-NODE-NEXT PIC 9(5).
01 WS-HEAD PIC 9(5) VALUE 0.
01 WS-CURRENT PIC 9(5) VALUE 0.
01 WS-NEW-NODE PIC 9(5) VALUE 1.
01 WS-VAL PIC 9(5).
01 WS-I PIC 9(3).
PROCEDURE DIVISION.
PERFORM PUSH-BACK(10)
PERFORM PUSH-BACK(20)
PERFORM PUSH-BACK(30)
PERFORM PUSH-FRONT(5)
PERFORM DISPLAY-LIST
STOP RUN.
PUSH-BACK.
ADD 1 TO WS-NEW-NODE
MOVE WS-VAL TO WS-NODE-DATA(WS-NEW-NODE)
IF WS-HEAD = 0
MOVE WS-NEW-NODE TO WS-HEAD
ELSE
MOVE WS-HEAD TO WS-CURRENT
PERFORM UNTIL WS-NODE-NEXT(WS-CURRENT) = 0
MOVE WS-NODE-NEXT(WS-CURRENT) TO WS-CURRENT
END-PERFORM
MOVE WS-NEW-NODE TO WS-NODE-NEXT(WS-CURRENT)
END-IF.
PUSH-FRONT.
ADD 1 TO WS-NEW-NODE
MOVE WS-VAL TO WS-NODE-DATA(WS-NEW-NODE)
MOVE WS-HEAD TO WS-NODE-NEXT(WS-NEW-NODE)
MOVE WS-NEW-NODE TO WS-HEAD.
DISPLAY-LIST.
MOVE WS-HEAD TO WS-CURRENT
PERFORM UNTIL WS-CURRENT = 0
DISPLAY WS-NODE-DATA(WS-CURRENT) " -> "
MOVE WS-NODE-NEXT(WS-CURRENT) TO WS-CURRENT
END-PERFORM
DISPLAY "null".Beginner
20. What is the DATA DIVISION in COBOL?
The DATA DIVISION is where all data is defined in COBOL. It includes FILE SECTION, WORKING-STORAGE SECTION, LINKAGE SECTION, and REPORT SECTION.
FILE SECTION— defines file recordsWORKING-STORAGE— internal variablesLINKAGE SECTION— parameters from CALLREPORT SECTION— report definitions
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. BINARYSEARCH.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ARR.
05 WS-ARR-DATA OCCURS 10 TIMES PIC 9(5).
01 WS-LEFT PIC 9(3) VALUE 1.
01 WS-RIGHT PIC 9(3) VALUE 10.
01 WS-MID PIC 9(3).
01 WS-TARGET PIC 9(5) VALUE 23.
01 WS-FOUND PIC 9(3) VALUE -1.
01 WS-I PIC 9(3).
PROCEDURE DIVISION.
MOVE 2 TO WS-ARR-DATA(1)
MOVE 5 TO WS-ARR-DATA(2)
MOVE 8 TO WS-ARR-DATA(3)
MOVE 12 TO WS-ARR-DATA(4)
MOVE 16 TO WS-ARR-DATA(5)
MOVE 23 TO WS-ARR-DATA(6)
MOVE 38 TO WS-ARR-DATA(7)
MOVE 56 TO WS-ARR-DATA(8)
MOVE 72 TO WS-ARR-DATA(9)
MOVE 91 TO WS-ARR-DATA(10)
PERFORM BINARY-SEARCH
DISPLAY "Index of 23: " WS-FOUND
STOP RUN.
BINARY-SEARCH.
MOVE 1 TO WS-LEFT
MOVE 10 TO WS-RIGHT
PERFORM UNTIL WS-LEFT > WS-RIGHT
COMPUTE WS-MID = (WS-LEFT + WS-RIGHT) / 2
IF WS-ARR-DATA(WS-MID) = WS-TARGET
MOVE WS-MID TO WS-FOUND
EXIT PERFORM
END-IF
IF WS-ARR-DATA(WS-MID) < WS-TARGET
COMPUTE WS-LEFT = WS-MID + 1
ELSE
COMPUTE WS-RIGHT = WS-MID - 1
END-IF
END-PERFORM.Intermediate
21. How do Binary Search work in COBOL?
COBOL can implement binary search using tables with INDEX and SEARCH ALL verbs. This provides efficient searching in sorted tables.
SEARCH ALL— binary search on tableINDEXED BY— defines index for tableWHEN— condition for searchSET— sets index values
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. RECURSION.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-N PIC 9(3) VALUE 5.
01 WS-RESULT PIC 9(8).
PROCEDURE DIVISION.
COMPUTE WS-RESULT = 1
PERFORM VARYING WS-I FROM 1 BY 1 UNTIL WS-I > WS-N
COMPUTE WS-RESULT = WS-RESULT * WS-I
END-PERFORM
DISPLAY "5! = " WS-RESULT
PERFORM FIBONACCI(8)
STOP RUN.
FIBONACCI.
COMPUTE WS-RESULT = 0
PERFORM VARYING WS-I FROM 1 BY 1 UNTIL WS-I > WS-N
COMPUTE WS-RESULT = WS-RESULT + WS-I
END-PERFORM
DISPLAY "fib(8) = " WS-RESULT.Intermediate
22. How do Sorting Algorithms work in COBOL?
COBOL's SORT verb provides built-in sorting. Custom sorting algorithms like bubble sort can also be implemented using PERFORM loops.
SORT— built-in sorting- Custom sort — using
PERFORM VARYING Bubble Sort— common manual implementationUSINGandGIVING— file operations
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. SORTING.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ARR1.
05 WS-ARR1-DATA OCCURS 7 TIMES PIC 9(5).
01 WS-ARR2.
05 WS-ARR2-DATA OCCURS 7 TIMES PIC 9(5).
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-TEMP PIC 9(5).
PROCEDURE DIVISION.
MOVE 64 TO WS-ARR1-DATA(1)
MOVE 34 TO WS-ARR1-DATA(2)
MOVE 25 TO WS-ARR1-DATA(3)
MOVE 12 TO WS-ARR1-DATA(4)
MOVE 22 TO WS-ARR1-DATA(5)
MOVE 11 TO WS-ARR1-DATA(6)
MOVE 90 TO WS-ARR1-DATA(7)
PERFORM BUBBLE-SORT
PERFORM DISPLAY-ARR1
STOP RUN.
BUBBLE-SORT.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 7
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 7 - WS-I
IF WS-ARR1-DATA(WS-J) > WS-ARR1-DATA(WS-J + 1)
MOVE WS-ARR1-DATA(WS-J) TO WS-TEMP
MOVE WS-ARR1-DATA(WS-J + 1) TO WS-ARR1-DATA(WS-J)
MOVE WS-TEMP TO WS-ARR1-DATA(WS-J + 1)
END-IF.
DISPLAY-ARR1.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 7
DISPLAY WS-ARR1-DATA(WS-I)
END-PERFORM.Intermediate
23. How does Recursion work in COBOL?
COBOL supports recursion through subprograms that call themselves. The RECURSIVE attribute must be specified on the PROGRAM-ID.
PROGRAM-ID prog RECURSIVE— defines recursionCALL— can call itself- Each call creates new data areas
- Must have a termination condition
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. DYNAMICMEM.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ARR.
05 WS-ARR-DATA OCCURS 5 TIMES PIC 9(5).
01 WS-MATRIX.
05 WS-MATRIX-ROW OCCURS 3 TIMES.
10 WS-MATRIX-COL OCCURS 3 TIMES PIC 9(5).
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
PROCEDURE DIVISION.
MOVE 10 TO WS-ARR-DATA(1)
MOVE 20 TO WS-ARR-DATA(2)
MOVE 30 TO WS-ARR-DATA(3)
MOVE 40 TO WS-ARR-DATA(4)
MOVE 50 TO WS-ARR-DATA(5)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 5
DISPLAY WS-ARR-DATA(WS-I)
END-PERFORM
MOVE 1 TO WS-MATRIX-COL(1, 1)
MOVE 5 TO WS-MATRIX-COL(2, 2)
MOVE 9 TO WS-MATRIX-COL(3, 3)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 3
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 3
DISPLAY WS-MATRIX-COL(WS-I, WS-J)
END-PERFORM
END-PERFORM
STOP RUN.Intermediate
24. How does Dynamic Memory work in COBOL?
COBOL provides dynamic storage through ALLOCATE and FREE statements, allowing runtime memory management for variable-length data.
ALLOCATE— allocates dynamic memoryFREE— releases memoryBASED— defines based storageSET ADDRESS OF— addresses based storage
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. STRINGS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-STR PIC X(20) VALUE "Hello, World!".
01 WS-STR2 PIC X(20).
01 WS-TOKEN PIC X(20).
01 WS-I PIC 9(3).
PROCEDURE DIVISION.
DISPLAY "Length: " WS-STR
MOVE WS-STR(8:5) TO WS-STR2
DISPLAY "Substring: " WS-STR2
DISPLAY "Contains: World"
PERFORM SPLIT-STRING
STOP RUN.
SPLIT-STRING.
MOVE WS-STR TO WS-TOKEN
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 20
IF WS-TOKEN(WS-I:1) = ','
DISPLAY WS-TOKEN(1:WS-I - 1)
MOVE WS-TOKEN(WS-I + 1:) TO WS-TOKEN
END-IF
END-PERFORM.Advanced
25. What are COBOL Compiler Directives?
Compiler directives in COBOL control compilation options. They can be specified in the PROCESS statement or as compiler options.
PROCESS— compiler optionsLANGUAGE— language versionDEBUG— debugging informationTEST— test mode compilation
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. INTERFACES.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-CIRCLE-RADIUS PIC 9(3)V99 VALUE 5.00.
01 WS-CIRCLE-AREA PIC 9(5)V99.
01 WS-SQUARE-SIDE PIC 9(3)V99 VALUE 4.00.
01 WS-SQUARE-AREA PIC 9(5)V99.
PROCEDURE DIVISION.
COMPUTE WS-CIRCLE-AREA = 3.14159 *
WS-CIRCLE-RADIUS * WS-CIRCLE-RADIUS
COMPUTE WS-SQUARE-AREA = WS-SQUARE-SIDE * WS-SQUARE-SIDE
DISPLAY "Drawing Circle r=" WS-CIRCLE-RADIUS
DISPLAY "Area: " WS-CIRCLE-AREA
DISPLAY "Drawing Square s=" WS-SQUARE-SIDE
DISPLAY "Area: " WS-SQUARE-AREA
STOP RUN.Advanced
26. What are COBOL Dates and Time functions?
COBOL provides FUNCTION CURRENT-DATE and FUNCTION DATE-OF-INTEGER for date manipulation. These are essential for business applications.
FUNCTION CURRENT-DATE— current date/timeFUNCTION DATE-OF-INTEGER— integer to dateFUNCTION INTEGER-OF-DATE— date to integerFUNCTION NUMVAL— string to numeric
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. MULTIINHERIT.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-CAR.
05 WS-MODEL PIC X(20).
05 WS-SPEED PIC 9(5).
05 WS-BATTERY PIC 9(3).
PROCEDURE DIVISION.
MOVE "Tesla Model 3" TO WS-MODEL
MOVE 250 TO WS-SPEED
MOVE 85 TO WS-BATTERY
DISPLAY "Model: " WS-MODEL
DISPLAY "Speed: " WS-SPEED " km/h"
DISPLAY "Battery: " WS-BATTERY "%"
DISPLAY WS-MODEL " glides silently at " WS-SPEED " km/h"
DISPLAY "Charging battery: " WS-BATTERY "%"
STOP RUN.Advanced
27. What are COBOL Cursor Operations?
COBOL supports SQL cursors through the DECLARE CURSOR, OPEN, FETCH, and CLOSE statements when working with databases.
DECLARE CURSOR— defines a cursorOPEN— opens the cursorFETCH— retrieves next rowCLOSE— closes the cursor
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. EXTENSIONS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TEXT PIC X(20) VALUE "racecar".
01 WS-NAME PIC X(20) VALUE "alice".
01 WS-NUMS.
05 WS-NUM OCCURS 4 TIMES PIC 9(5).
01 WS-I PIC 9(3).
01 WS-IS-PAL PIC X VALUE 'N'.
PROCEDURE DIVISION.
PERFORM IS-PALINDROME
DISPLAY WS-TEXT " is palindrome: " WS-IS-PAL
STOP RUN.
IS-PALINDROME.
MOVE WS-TEXT TO WS-NAME
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 10
IF WS-TEXT(WS-I:1) = WS-NAME(20 - WS-I:1)
MOVE 'Y' TO WS-IS-PAL
ELSE
MOVE 'N' TO WS-IS-PAL
END-IF
END-PERFORM.Advanced
28. What are COBOL Table Redefines?
The REDEFINES clause in COBOL allows the same memory area to be used for different data layouts, enabling flexible data representation.
REDEFINES— overlays dataOCCURSwithREDEFINES— variable tablesDEPENDING ON— table size determined at runtime- Used for parsing and data conversion
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. SINGLETON.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-DB-URL PIC X(30) VALUE "localhost:5432".
PROCEDURE DIVISION.
DISPLAY WS-DB-URL
DISPLAY "[CONSOLE] App started"
DISPLAY "[FILE] Error occurred"
STOP RUN.Intermediate
29. What are COBOL Scope and Lifetime?
COBOL data items have different scopes based on where they are declared. WORKING-STORAGE is program-wide, while LOCAL-STORAGE is created each call.
WORKING-STORAGE— static dataLOCAL-STORAGE— automatic data (NEW each call)LINKAGE— passed parametersTHREAD-LOCAL— thread-specific storage
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. NAMESPACES.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-PI PIC 9(3)V9(11) VALUE 3.14159265358.
01 WS-CIRCLE-AREA PIC 9(5)V99.
01 WS-G PIC 9(3)V99 VALUE 9.81.
01 WS-WEIGHT PIC 9(5)V99.
PROCEDURE DIVISION.
COMPUTE WS-CIRCLE-AREA = WS-PI * 5.00 * 5.00
COMPUTE WS-WEIGHT = 70 * WS-G
DISPLAY "PI = " WS-PI
DISPLAY "Circle area = " WS-CIRCLE-AREA
DISPLAY "Weight(70kg) = " WS-WEIGHT " N"
STOP RUN.Intermediate
30. How to solve Two Sum in COBOL?
COBOL can implement the Two Sum problem using nested PERFORM loops with table index manipulation. This demonstrates COBOL's array handling capabilities.
- Nested
PERFORMloops for O(n²) - Table indexing with
OCCURS - Comparison using
IFstatements - Can be optimized with
SEARCHverbs
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. TWOSUM.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUMS.
05 WS-NUM OCCURS 4 TIMES PIC 9(5).
01 WS-TARGET PIC 9(5) VALUE 9.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-FOUND PIC X VALUE 'N'.
PROCEDURE DIVISION.
MOVE 2 TO WS-NUM(1)
MOVE 7 TO WS-NUM(2)
MOVE 11 TO WS-NUM(3)
MOVE 15 TO WS-NUM(4)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 4
PERFORM VARYING WS-J FROM WS-I BY 1
UNTIL WS-J > 4
IF WS-NUM(WS-I) + WS-NUM(WS-J) = WS-TARGET
DISPLAY "Indices: [" WS-I ", " WS-J "]"
MOVE 'Y' TO WS-FOUND
END-IF
END-PERFORM
END-PERFORM
STOP RUN.Advanced
31. How does Kadane's Algorithm work in COBOL?
Kadane's Algorithm in COBOL finds the maximum subarray sum using a single pass through the data, demonstrating COBOL's arithmetic capabilities.
- Single pass through table
- Track current and maximum sums
- Reset current sum when negative
- COBOL's
COMPUTEfor arithmetic
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. KADANE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ARR.
05 WS-ARR-DATA OCCURS 9 TIMES PIC S9(5).
01 WS-CURR-SUM PIC S9(8) VALUE 0.
01 WS-MAX-SUM PIC S9(8) VALUE -99999.
01 WS-START PIC 9(3) VALUE 1.
01 WS-END PIC 9(3) VALUE 1.
01 WS-I PIC 9(3).
01 WS-TEMP-START PIC 9(3) VALUE 1.
PROCEDURE DIVISION.
MOVE -2 TO WS-ARR-DATA(1)
MOVE 1 TO WS-ARR-DATA(2)
MOVE -3 TO WS-ARR-DATA(3)
MOVE 4 TO WS-ARR-DATA(4)
MOVE -1 TO WS-ARR-DATA(5)
MOVE 2 TO WS-ARR-DATA(6)
MOVE 1 TO WS-ARR-DATA(7)
MOVE -5 TO WS-ARR-DATA(8)
MOVE 4 TO WS-ARR-DATA(9)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 9
COMPUTE WS-CURR-SUM = WS-CURR-SUM + WS-ARR-DATA(WS-I)
IF WS-CURR-SUM > WS-MAX-SUM
MOVE WS-CURR-SUM TO WS-MAX-SUM
MOVE WS-TEMP-START TO WS-START
MOVE WS-I TO WS-END
END-IF
IF WS-CURR-SUM < 0
MOVE 0 TO WS-CURR-SUM
COMPUTE WS-TEMP-START = WS-I + 1
END-IF
END-PERFORM
DISPLAY "Max Sum: " WS-MAX-SUM
STOP RUN.Intermediate
32. How to implement a Binary Tree in COBOL?
COBOL implements binary trees using tables with OCCURS and REDEFINES. Node relationships are stored as index values.
- Tables for node data, left/right children
- Recursive or iterative traversal
PERFORMwithUNTILfor iteration- Index-based tree navigation
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. BINARYTREE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TREE.
05 WS-TREE-LEFT OCCURS 100 TIMES PIC 9(3).
05 WS-TREE-RIGHT OCCURS 100 TIMES PIC 9(3).
05 WS-TREE-VAL OCCURS 100 TIMES PIC 9(5).
01 WS-ROOT PIC 9(3) VALUE 1.
01 WS-NODE PIC 9(3) VALUE 1.
01 WS-VAL PIC 9(5).
01 WS-I PIC 9(3).
PROCEDURE DIVISION.
PERFORM INSERT(1)
PERFORM INSERT(2)
PERFORM INSERT(3)
PERFORM INSERT(4)
PERFORM INSERT(5)
PERFORM INSERT(6)
PERFORM INSERT(7)
PERFORM INORDER-TRAVERSE
STOP RUN.
INSERT.
ADD 1 TO WS-NODE
MOVE WS-VAL TO WS-TREE-VAL(WS-NODE)
MOVE WS-ROOT TO WS-I
PERFORM UNTIL WS-I = 0
IF WS-VAL < WS-TREE-VAL(WS-I)
IF WS-TREE-LEFT(WS-I) = 0
MOVE WS-NODE TO WS-TREE-LEFT(WS-I)
MOVE 0 TO WS-I
ELSE
MOVE WS-TREE-LEFT(WS-I) TO WS-I
END-IF
ELSE
IF WS-TREE-RIGHT(WS-I) = 0
MOVE WS-NODE TO WS-TREE-RIGHT(WS-I)
MOVE 0 TO WS-I
ELSE
MOVE WS-TREE-RIGHT(WS-I) TO WS-I
END-IF
END-IF
END-PERFORM.
INORDER-TRAVERSE.
PERFORM DISPLAY-NODE(WS-ROOT).
DISPLAY-NODE.
IF WS-I NOT = 0
PERFORM DISPLAY-NODE(WS-TREE-LEFT(WS-I))
DISPLAY WS-TREE-VAL(WS-I)
PERFORM DISPLAY-NODE(WS-TREE-RIGHT(WS-I))
END-IF.Intermediate
33. How to implement a Binary Search Tree in COBOL?
A Binary Search Tree in COBOL uses tables for node storage. Insertion and search operations follow the standard BST algorithm using COBOL's data structures.
- Node table with key, left, right
- Recursive insertion with
PERFORM - Inorder traversal for sorted output
SEARCHverb for finding nodes
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. BST.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TREE.
05 WS-TREE-LEFT OCCURS 100 TIMES PIC 9(3).
05 WS-TREE-RIGHT OCCURS 100 TIMES PIC 9(3).
05 WS-TREE-VAL OCCURS 100 TIMES PIC 9(5).
01 WS-ROOT PIC 9(3) VALUE 0.
01 WS-NODE PIC 9(3) VALUE 0.
01 WS-VAL PIC 9(5).
01 WS-I PIC 9(3).
PROCEDURE DIVISION.
PERFORM INSERT(50)
PERFORM INSERT(30)
PERFORM INSERT(70)
PERFORM INSERT(20)
PERFORM INSERT(40)
PERFORM INSERT(60)
PERFORM INSERT(80)
PERFORM INORDER-TRAVERSE
STOP RUN.
INSERT.
ADD 1 TO WS-NODE
MOVE WS-VAL TO WS-TREE-VAL(WS-NODE)
IF WS-ROOT = 0
MOVE WS-NODE TO WS-ROOT
ELSE
MOVE WS-ROOT TO WS-I
PERFORM UNTIL WS-I = 0
IF WS-VAL < WS-TREE-VAL(WS-I)
IF WS-TREE-LEFT(WS-I) = 0
MOVE WS-NODE TO WS-TREE-LEFT(WS-I)
MOVE 0 TO WS-I
ELSE
MOVE WS-TREE-LEFT(WS-I) TO WS-I
END-IF
ELSE
IF WS-TREE-RIGHT(WS-I) = 0
MOVE WS-NODE TO WS-TREE-RIGHT(WS-I)
MOVE 0 TO WS-I
ELSE
MOVE WS-TREE-RIGHT(WS-I) TO WS-I
END-IF
END-IF
END-PERFORM
END-IF.
INORDER-TRAVERSE.
PERFORM DISPLAY-NODE(WS-ROOT).
DISPLAY-NODE.
IF WS-I NOT = 0
PERFORM DISPLAY-NODE(WS-TREE-LEFT(WS-I))
DISPLAY WS-TREE-VAL(WS-I)
PERFORM DISPLAY-NODE(WS-TREE-RIGHT(WS-I))
END-IF.Intermediate
34. How to implement Graph BFS and DFS in COBOL?
COBOL implements graph algorithms using adjacency matrices. BFS uses a queue structure while DFS uses recursion or a stack.
- Adjacency matrix with
OCCURS - Queue for BFS with
OCCURStable - DFS using recursive
PERFORM - Visited array for tracking
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. GRAPH.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ADJ.
05 WS-ADJ-ROW OCCURS 6 TIMES.
10 WS-ADJ-COL OCCURS 6 TIMES PIC 9(3).
01 WS-VISITED OCCURS 6 TIMES PIC X.
01 WS-QUEUE.
05 WS-QUEUE-DATA OCCURS 100 TIMES PIC 9(3).
01 WS-QUEUE-FRONT PIC 9(3) VALUE 1.
01 WS-QUEUE-REAR PIC 9(3) VALUE 0.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-V PIC 9(3).
PROCEDURE DIVISION.
MOVE 1 TO WS-ADJ-COL(1, 2)
MOVE 1 TO WS-ADJ-COL(1, 3)
MOVE 1 TO WS-ADJ-COL(2, 4)
MOVE 1 TO WS-ADJ-COL(3, 5)
MOVE 1 TO WS-ADJ-COL(4, 6)
PERFORM BFS(1)
STOP RUN.
BFS.
MOVE WS-I TO WS-V
MOVE 'Y' TO WS-VISITED(WS-V)
PERFORM ENQUEUE(WS-V)
DISPLAY "BFS: "
PERFORM UNTIL WS-QUEUE-FRONT > WS-QUEUE-REAR
PERFORM DEQUEUE
MOVE WS-V TO WS-I
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 6
IF WS-ADJ-COL(WS-I, WS-J) = 1
IF WS-VISITED(WS-J) = 'N'
MOVE 'Y' TO WS-VISITED(WS-J)
PERFORM ENQUEUE(WS-J)
END-IF
END-IF
END-PERFORM
END-PERFORM.
ENQUEUE.
ADD 1 TO WS-QUEUE-REAR
MOVE WS-V TO WS-QUEUE-DATA(WS-QUEUE-REAR).
DEQUEUE.
MOVE WS-QUEUE-DATA(WS-QUEUE-FRONT) TO WS-V
DISPLAY WS-V
ADD 1 TO WS-QUEUE-FRONT.Advanced
35. How to implement Dijkstra's Algorithm in COBOL?
Dijkstra's Algorithm in COBOL uses arrays for distance tracking and a loop to find the minimum distance vertex at each step.
- Distance and visited arrays
- Find minimum distance each iteration
- Update distances for neighbors
- COBOL's
PERFORMfor iteration
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. DIJKSTRA.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-DIST OCCURS 5 TIMES PIC 9(5).
01 WS-VISITED OCCURS 5 TIMES PIC X.
01 WS-GRAPH.
05 WS-GRAPH-ROW OCCURS 5 TIMES.
10 WS-GRAPH-COL OCCURS 5 TIMES PIC 9(5).
01 WS-SRC PIC 9(3) VALUE 1.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-MIN-DIST PIC 9(5).
01 WS-MIN-VERTEX PIC 9(3).
PROCEDURE DIVISION.
INITIALIZE WS-VISITED
MOVE 99999 TO WS-DIST(1)
MOVE 10 TO WS-GRAPH-COL(1, 2)
MOVE 5 TO WS-GRAPH-COL(1, 4)
MOVE 1 TO WS-GRAPH-COL(2, 3)
MOVE 2 TO WS-GRAPH-COL(2, 4)
MOVE 4 TO WS-GRAPH-COL(3, 5)
MOVE 9 TO WS-GRAPH-COL(4, 5)
MOVE 0 TO WS-DIST(WS-SRC)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 5
PERFORM FIND-MIN
MOVE 'Y' TO WS-VISITED(WS-MIN-VERTEX)
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 5
IF WS-GRAPH-COL(WS-MIN-VERTEX, WS-J) NOT = 0
IF WS-VISITED(WS-J) = 'N'
IF WS-DIST(WS-MIN-VERTEX) +
WS-GRAPH-COL(WS-MIN-VERTEX, WS-J)
< WS-DIST(WS-J)
COMPUTE WS-DIST(WS-J) =
WS-DIST(WS-MIN-VERTEX) +
WS-GRAPH-COL(WS-MIN-VERTEX, WS-J)
END-IF
END-IF
END-IF
END-PERFORM
END-PERFORM
DISPLAY "Shortest distances from " WS-SRC
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 5
DISPLAY " To " WS-I ": " WS-DIST(WS-I)
END-PERFORM
STOP RUN.
FIND-MIN.
MOVE 99999 TO WS-MIN-DIST
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 5
IF WS-VISITED(WS-I) = 'N'
IF WS-DIST(WS-I) < WS-MIN-DIST
MOVE WS-DIST(WS-I) TO WS-MIN-DIST
MOVE WS-I TO WS-MIN-VERTEX
END-IF
END-IF
END-PERFORM.Advanced
36. How to solve Classic DP Problems in COBOL?
COBOL supports dynamic programming using tables and nested PERFORM loops. 0/1 Knapsack and LCS are classic examples.
- 2D tables with
OCCURS - Nested loops for DP calculation
COMPUTEfor maximum values- Bottom-up DP approach
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. DP.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-WEIGHTS.
05 WS-W OCCURS 4 TIMES PIC 9(3).
01 WS-VALUES.
05 WS-V OCCURS 4 TIMES PIC 9(3).
01 WS-DP.
05 WS-DP-ROW OCCURS 5 TIMES.
10 WS-DP-COL OCCURS 8 TIMES PIC 9(5).
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-W-CAP PIC 9(3) VALUE 7.
01 WS-RESULT PIC 9(5).
PROCEDURE DIVISION.
MOVE 1 TO WS-W(1)
MOVE 3 TO WS-W(2)
MOVE 4 TO WS-W(3)
MOVE 5 TO WS-W(4)
MOVE 1 TO WS-V(1)
MOVE 4 TO WS-V(2)
MOVE 5 TO WS-V(3)
MOVE 7 TO WS-V(4)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 4
PERFORM VARYING WS-J FROM 0 BY 1
UNTIL WS-J > WS-W-CAP
MOVE WS-DP-COL(WS-I, WS-J) TO
WS-DP-COL(WS-I + 1, WS-J)
IF WS-W(WS-I) <= WS-J
COMPUTE WS-RESULT =
WS-DP-COL(WS-I,
WS-J - WS-W(WS-I)) + WS-V(WS-I)
IF WS-RESULT > WS-DP-COL(WS-I + 1, WS-J)
MOVE WS-RESULT TO
WS-DP-COL(WS-I + 1, WS-J)
END-IF
END-IF
END-PERFORM
END-PERFORM
DISPLAY "Knapsack(W=7): " WS-DP-COL(5, WS-W-CAP)
STOP RUN.Advanced
37. How to implement a Hash Map in COBOL?
COBOL implements hash maps using tables with OCCURS for buckets. Collision handling can be done with chaining or linear probing.
- Bucket table with
OCCURS - Key-value pair storage
- Hash function calculation
- Chaining using linked lists in COBOL
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. HASHMAP.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TABLE.
05 WS-BUCKET OCCURS 16 TIMES.
10 WS-BUCKET-KEY PIC X(10).
10 WS-BUCKET-VAL PIC 9(5).
10 WS-BUCKET-NEXT PIC 9(3).
01 WS-COUNT PIC 9(3) VALUE 0.
01 WS-KEY PIC X(10).
01 WS-VAL PIC 9(5).
01 WS-INDEX PIC 9(3).
01 WS-I PIC 9(3).
01 WS-HASH-CODE PIC 9(8).
PROCEDURE DIVISION.
MOVE "alice" TO WS-KEY
MOVE 90 TO WS-VAL
PERFORM PUT
MOVE "bob" TO WS-KEY
MOVE 85 TO WS-VAL
PERFORM PUT
MOVE "carol" TO WS-KEY
MOVE 92 TO WS-VAL
PERFORM PUT
MOVE "alice" TO WS-KEY
PERFORM GET
DISPLAY "alice: " WS-VAL
MOVE "bob" TO WS-KEY
PERFORM CONTAINS
DISPLAY "Contains bob: " WS-CONTAINS
STOP RUN.
PUT.
PERFORM HASH
MOVE WS-INDEX TO WS-I
PERFORM UNTIL WS-I = 0
IF WS-BUCKET-KEY(WS-I) = WS-KEY
MOVE WS-VAL TO WS-BUCKET-VAL(WS-I)
EXIT PERFORM
END-IF
MOVE WS-BUCKET-NEXT(WS-I) TO WS-I
END-PERFORM
ADD 1 TO WS-COUNT
MOVE WS-COUNT TO WS-I
MOVE WS-KEY TO WS-BUCKET-KEY(WS-I)
MOVE WS-VAL TO WS-BUCKET-VAL(WS-I)
MOVE 0 TO WS-BUCKET-NEXT(WS-I).
GET.
PERFORM HASH
MOVE WS-INDEX TO WS-I
PERFORM UNTIL WS-I = 0
IF WS-BUCKET-KEY(WS-I) = WS-KEY
MOVE WS-BUCKET-VAL(WS-I) TO WS-VAL
EXIT PERFORM
END-IF
MOVE WS-BUCKET-NEXT(WS-I) TO WS-I
END-PERFORM.
HASH.
COMPUTE WS-HASH-CODE = 0
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 10
COMPUTE WS-HASH-CODE = WS-HASH-CODE +
FUNCTION ORD(WS-KEY(WS-I:1))
END-PERFORM
COMPUTE WS-INDEX = FUNCTION MOD(WS-HASH-CODE, 16) + 1.Advanced
38. How to use Heap and Priority Queue in COBOL?
COBOL implements heaps using array-based data structures with parent-child calculations. Priority queues use heaps for ordered access.
- Array-based heap with
OCCURS - Heapify operations with
PERFORM - Insert and extract operations
- Index arithmetic for parent/child
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. HEAP.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ARR.
05 WS-ARR-DATA OCCURS 7 TIMES PIC 9(5).
01 WS-HEAP.
05 WS-HEAP-DATA OCCURS 100 TIMES PIC 9(5).
01 WS-HEAP-SIZE PIC 9(3) VALUE 0.
01 WS-I PIC 9(3).
01 WS-TEMP PIC 9(5).
01 WS-K PIC 9(3) VALUE 3.
PROCEDURE DIVISION.
MOVE 3 TO WS-ARR-DATA(1)
MOVE 1 TO WS-ARR-DATA(2)
MOVE 5 TO WS-ARR-DATA(3)
MOVE 12 TO WS-ARR-DATA(4)
MOVE 2 TO WS-ARR-DATA(5)
MOVE 11 TO WS-ARR-DATA(6)
MOVE 9 TO WS-ARR-DATA(7)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 7
PERFORM HEAP-INSERT(WS-ARR-DATA(WS-I))
END-PERFORM
PERFORM KLARGEST
STOP RUN.
HEAP-INSERT.
ADD 1 TO WS-HEAP-SIZE
MOVE WS-TEMP TO WS-HEAP-DATA(WS-HEAP-SIZE)
PERFORM HEAP-UP(WS-HEAP-SIZE).
HEAP-UP.
PERFORM UNTIL WS-I = 1
COMPUTE WS-PARENT = WS-I / 2
IF WS-HEAP-DATA(WS-I) < WS-HEAP-DATA(WS-PARENT)
MOVE WS-HEAP-DATA(WS-I) TO WS-TEMP
MOVE WS-HEAP-DATA(WS-PARENT) TO
WS-HEAP-DATA(WS-I)
MOVE WS-TEMP TO WS-HEAP-DATA(WS-PARENT)
MOVE WS-PARENT TO WS-I
ELSE
EXIT PERFORM
END-IF
END-PERFORM.
KLARGEST.
DISPLAY "Top 3: "
PERFORM VARYING WS-I FROM WS-HEAP-SIZE BY -1
UNTIL WS-I < WS-HEAP-SIZE - WS-K
DISPLAY WS-HEAP-DATA(WS-I)
END-PERFORM.Advanced
39. How to implement a Trie in COBOL?
A Trie in COBOL uses nested tables for character nodes. Insert, search, and prefix operations traverse the trie structure.
- Node table with next pointers
- Character-based navigation
- End-of-word markers
PERFORMfor traversal
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. TRIE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TRIE.
05 WS-TRIE-CHILDREN OCCURS 1000 TIMES.
10 WS-TRIE-CHAR OCCURS 26 TIMES PIC 9(5).
10 WS-TRIE-IS-END OCCURS 1000 TIMES PIC X.
01 WS-NODE PIC 9(5) VALUE 1.
01 WS-CURR PIC 9(5).
01 WS-POS PIC 9(3).
01 WS-WORD PIC X(20).
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-FOUND PIC X VALUE 'N'.
PROCEDURE DIVISION.
MOVE 'apple' TO WS-WORD
PERFORM INSERT
MOVE 'app' TO WS-WORD
PERFORM INSERT
MOVE 'apply' TO WS-WORD
PERFORM INSERT
MOVE 'apple' TO WS-WORD
PERFORM SEARCH
DISPLAY "Search apple: " WS-FOUND
MOVE 'app' TO WS-WORD
PERFORM SEARCH
DISPLAY "Search app: " WS-FOUND
MOVE 'ap' TO WS-WORD
PERFORM SEARCH
DISPLAY "Search ap: " WS-FOUND
MOVE 'appl' TO WS-WORD
PERFORM STARTSWITH
DISPLAY "StartsWith appl: " WS-FOUND
STOP RUN.
INSERT.
MOVE 1 TO WS-CURR
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 20 OR WS-WORD(WS-I:1) = ' '
COMPUTE WS-POS = FUNCTION ORD(WS-WORD(WS-I:1))
- FUNCTION ORD('a') + 1
IF WS-TRIE-CHAR(WS-CURR, WS-POS) = 0
ADD 1 TO WS-NODE
MOVE WS-NODE TO WS-TRIE-CHAR(WS-CURR, WS-POS)
END-IF
MOVE WS-TRIE-CHAR(WS-CURR, WS-POS) TO WS-CURR
END-PERFORM
MOVE 'Y' TO WS-TRIE-IS-END(WS-CURR).
SEARCH.
MOVE 1 TO WS-CURR
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 20 OR WS-WORD(WS-I:1) = ' '
COMPUTE WS-POS = FUNCTION ORD(WS-WORD(WS-I:1))
- FUNCTION ORD('a') + 1
IF WS-TRIE-CHAR(WS-CURR, WS-POS) = 0
MOVE 'N' TO WS-FOUND
EXIT PERFORM
END-IF
MOVE WS-TRIE-CHAR(WS-CURR, WS-POS) TO WS-CURR
END-PERFORM
IF WS-TRIE-IS-END(WS-CURR) = 'Y'
MOVE 'Y' TO WS-FOUND
ELSE
MOVE 'N' TO WS-FOUND
END-IF.
STARTSWITH.
MOVE 1 TO WS-CURR
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 20 OR WS-WORD(WS-I:1) = ' '
COMPUTE WS-POS = FUNCTION ORD(WS-WORD(WS-I:1))
- FUNCTION ORD('a') + 1
IF WS-TRIE-CHAR(WS-CURR, WS-POS) = 0
MOVE 'N' TO WS-FOUND
EXIT PERFORM
END-IF
MOVE WS-TRIE-CHAR(WS-CURR, WS-POS) TO WS-CURR
END-PERFORM
MOVE 'Y' TO WS-FOUND.Advanced
40. How to implement a Segment Tree in COBOL?
A Segment Tree in COBOL uses arrays for tree storage. Build, update, and query operations are implemented recursively or iteratively.
- Tree array with
OCCURS - Recursive build and query
- Range sum or min queries
- Point updates
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. SEGMENTTREE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ARR.
05 WS-ARR-DATA OCCURS 6 TIMES PIC 9(5).
01 WS-TREE.
05 WS-TREE-DATA OCCURS 24 TIMES PIC 9(5).
01 WS-N PIC 9(3) VALUE 6.
01 WS-I PIC 9(3).
01 WS-VAL PIC 9(5).
01 WS-QL PIC 9(3) VALUE 2.
01 WS-QR PIC 9(3) VALUE 4.
01 WS-RESULT PIC 9(5).
PROCEDURE DIVISION.
MOVE 1 TO WS-ARR-DATA(1)
MOVE 3 TO WS-ARR-DATA(2)
MOVE 5 TO WS-ARR-DATA(3)
MOVE 7 TO WS-ARR-DATA(4)
MOVE 9 TO WS-ARR-DATA(5)
MOVE 11 TO WS-ARR-DATA(6)
PERFORM BUILD(1, 1, WS-N)
PERFORM QUERY(1, 1, WS-N, WS-QL, WS-QR)
DISPLAY "Sum [1,3]: " WS-RESULT
MOVE 10 TO WS-VAL
PERFORM UPDATE(1, 1, WS-N, 2, WS-VAL)
PERFORM QUERY(1, 1, WS-N, WS-QL, WS-QR)
DISPLAY "Sum [1,3] after update: " WS-RESULT
STOP RUN.
BUILD.
IF WS-L = WS-R
MOVE WS-ARR-DATA(WS-L) TO WS-TREE-DATA(WS-NODE)
ELSE
COMPUTE WS-MID = (WS-L + WS-R) / 2
PERFORM BUILD(WS-NODE * 2, WS-L, WS-MID)
PERFORM BUILD(WS-NODE * 2 + 1, WS-MID + 1, WS-R)
COMPUTE WS-TREE-DATA(WS-NODE) =
WS-TREE-DATA(WS-NODE * 2) +
WS-TREE-DATA(WS-NODE * 2 + 1)
END-IF.
QUERY.
IF WS-QR < WS-L OR WS-R < WS-QL
MOVE 0 TO WS-RESULT
ELSE
IF WS-QL <= WS-L AND WS-R <= WS-QR
MOVE WS-TREE-DATA(WS-NODE) TO WS-RESULT
ELSE
COMPUTE WS-MID = (WS-L + WS-R) / 2
PERFORM QUERY(WS-NODE * 2, WS-L, WS-MID,
WS-QL, WS-QR)
PERFORM QUERY(WS-NODE * 2 + 1, WS-MID + 1,
WS-R, WS-QL, WS-QR)
END-IF
END-IF.
UPDATE.
IF WS-L = WS-R
MOVE WS-VAL TO WS-TREE-DATA(WS-NODE)
ELSE
COMPUTE WS-MID = (WS-L + WS-R) / 2
IF WS-IDX <= WS-MID
PERFORM UPDATE(WS-NODE * 2, WS-L, WS-MID,
WS-IDX, WS-VAL)
ELSE
PERFORM UPDATE(WS-NODE * 2 + 1, WS-MID + 1,
WS-R, WS-IDX, WS-VAL)
END-IF
COMPUTE WS-TREE-DATA(WS-NODE) =
WS-TREE-DATA(WS-NODE * 2) +
WS-TREE-DATA(WS-NODE * 2 + 1)
END-IF.Advanced
41. How to implement Union-Find in COBOL?
COBOL implements Union-Find (Disjoint Set) using parent and rank arrays. Path compression improves performance for connected component queries.
- Parent and rank arrays
- Find with path compression
- Union by rank
- Connected component checking
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. UNIONFIND.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-PARENT OCCURS 6 TIMES PIC 9(3).
01 WS-RANK OCCURS 6 TIMES PIC 9(3).
01 WS-I PIC 9(3).
01 WS-X PIC 9(3).
01 WS-Y PIC 9(3).
PROCEDURE DIVISION.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 6
MOVE WS-I TO WS-PARENT(WS-I)
MOVE 0 TO WS-RANK(WS-I)
END-PERFORM
PERFORM UNITE(1, 2)
PERFORM UNITE(2, 3)
PERFORM UNITE(4, 5)
PERFORM CONNECTED(1, 2)
DISPLAY "0-2: " WS-CONN
PERFORM CONNECTED(1, 3)
DISPLAY "0-3: " WS-CONN
PERFORM UNITE(3, 4)
PERFORM CONNECTED(1, 4)
DISPLAY "0-4 after merge: " WS-CONN
STOP RUN.
FIND.
IF WS-PARENT(WS-X) NOT = WS-X
MOVE WS-PARENT(WS-X) TO WS-X
PERFORM FIND
MOVE WS-X TO WS-PARENT(WS-X)
END-IF.
UNITE.
MOVE WS-X TO WS-X
PERFORM FIND
MOVE WS-X TO WS-PX
MOVE WS-Y TO WS-Y
PERFORM FIND
MOVE WS-Y TO WS-PY
IF WS-PX NOT = WS-PY
IF WS-RANK(WS-PX) < WS-RANK(WS-PY)
MOVE WS-PX TO WS-TEMP
MOVE WS-PY TO WS-PX
MOVE WS-TEMP TO WS-PY
END-IF
MOVE WS-PX TO WS-PARENT(WS-PY)
IF WS-RANK(WS-PX) = WS-RANK(WS-PY)
ADD 1 TO WS-RANK(WS-PX)
END-IF
MOVE 1 TO WS-UNITE
ELSE
MOVE 0 TO WS-UNITE
END-IF.
CONNECTED.
MOVE WS-X TO WS-X
PERFORM FIND
MOVE WS-X TO WS-PX
MOVE WS-Y TO WS-Y
PERFORM FIND
MOVE WS-Y TO WS-PY
IF WS-PX = WS-PY
MOVE 'Y' TO WS-CONN
ELSE
MOVE 'N' TO WS-CONN
END-IF.Advanced
42. How to implement Sliding Window Maximum in COBOL?
COBOL implements sliding window maximum using a deque data structure (implemented with tables) to maintain the maximum in the current window.
- Deque implemented with
OCCURS - Remove out-of-window elements
- Maintain decreasing order
- Front element is window maximum
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. SLIDINGWINDOW.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUMS.
05 WS-NUM OCCURS 8 TIMES PIC S9(5).
01 WS-K PIC 9(3) VALUE 3.
01 WS-DEQUEUE.
05 WS-DEQUEUE-DATA OCCURS 100 TIMES PIC 9(3).
01 WS-DEQUEUE-FRONT PIC 9(3) VALUE 1.
01 WS-DEQUEUE-REAR PIC 9(3) VALUE 0.
01 WS-RESULT.
05 WS-RESULT-DATA OCCURS 100 TIMES PIC S9(5).
01 WS-RESULT-COUNT PIC 9(3) VALUE 0.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
PROCEDURE DIVISION.
MOVE 1 TO WS-NUM(1)
MOVE 3 TO WS-NUM(2)
MOVE -1 TO WS-NUM(3)
MOVE -3 TO WS-NUM(4)
MOVE 5 TO WS-NUM(5)
MOVE 3 TO WS-NUM(6)
MOVE 6 TO WS-NUM(7)
MOVE 7 TO WS-NUM(8)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 8
PERFORM DEQUEUE-REMOVE
PERFORM DEQUEUE-CLEAN
PERFORM DEQUEUE-PUSH(WS-I)
IF WS-I >= WS-K
ADD 1 TO WS-RESULT-COUNT
MOVE WS-NUM(WS-DEQUEUE-DATA(
WS-DEQUEUE-FRONT))
TO WS-RESULT-DATA(WS-RESULT-COUNT)
END-IF
END-PERFORM
DISPLAY "Sliding window max: "
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-RESULT-COUNT
DISPLAY WS-RESULT-DATA(WS-I)
END-PERFORM
STOP RUN.
DEQUEUE-REMOVE.
PERFORM UNTIL WS-DEQUEUE-FRONT > WS-DEQUEUE-REAR
IF WS-DEQUEUE-DATA(WS-DEQUEUE-FRONT)
< WS-I - WS-K + 1
ADD 1 TO WS-DEQUEUE-FRONT
ELSE
EXIT PERFORM
END-IF
END-PERFORM.
DEQUEUE-CLEAN.
PERFORM UNTIL WS-DEQUEUE-FRONT > WS-DEQUEUE-REAR
IF WS-NUM(WS-DEQUEUE-DATA(WS-DEQUEUE-REAR))
< WS-NUM(WS-I)
SUBTRACT 1 FROM WS-DEQUEUE-REAR
ELSE
EXIT PERFORM
END-IF
END-PERFORM.
DEQUEUE-PUSH.
ADD 1 TO WS-DEQUEUE-REAR
MOVE WS-I TO WS-DEQUEUE-DATA(WS-DEQUEUE-REAR).Advanced
43. How to implement KMP String Matching in COBOL?
The KMP Algorithm in COBOL uses tables for the LPS array. String comparison is done using COBOL's character-level operations.
- LPS array with
OCCURS - Pattern matching with
PERFORM - Character-by-character comparison
- Efficient O(n+m) matching
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. KMP.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TEXT PIC X(30) VALUE "AABAACAADAABAABA".
01 WS-PATTERN PIC X(10) VALUE "AABA".
01 WS-LPS OCCURS 10 TIMES PIC 9(3).
01 WS-POSITIONS.
05 WS-POS-DATA OCCURS 10 TIMES PIC 9(3).
01 WS-POS-COUNT PIC 9(3) VALUE 0.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-N PIC 9(3).
01 WS-M PIC 9(3).
PROCEDURE DIVISION.
MOVE 0 TO WS-I
MOVE 1 TO WS-J
MOVE 30 TO WS-N
MOVE 4 TO WS-M
PERFORM BUILD-LPS
MOVE 1 TO WS-I
MOVE 1 TO WS-J
PERFORM KMP-SEARCH
DISPLAY "Pattern found at: "
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-POS-COUNT
DISPLAY WS-POS-DATA(WS-I)
END-PERFORM
STOP RUN.
BUILD-LPS.
MOVE 0 TO WS-LPS(1)
MOVE 1 TO WS-I
MOVE 0 TO WS-J
PERFORM UNTIL WS-I > WS-M
IF WS-PATTERN(WS-I:1) = WS-PATTERN(WS-J + 1:1)
ADD 1 TO WS-J
MOVE WS-J TO WS-LPS(WS-I)
ADD 1 TO WS-I
ELSE
IF WS-J > 0
MOVE WS-LPS(WS-J) TO WS-J
ELSE
MOVE 0 TO WS-LPS(WS-I)
ADD 1 TO WS-I
END-IF
END-IF
END-PERFORM.
KMP-SEARCH.
PERFORM UNTIL WS-I > WS-N
IF WS-TEXT(WS-I:1) = WS-PATTERN(WS-J:1)
ADD 1 TO WS-I
ADD 1 TO WS-J
END-IF
IF WS-J > WS-M
ADD 1 TO WS-POS-COUNT
COMPUTE WS-POS-DATA(WS-POS-COUNT) = WS-I - WS-J
MOVE WS-LPS(WS-J) TO WS-J
ELSE
IF WS-I <= WS-N
IF WS-TEXT(WS-I:1) NOT = WS-PATTERN(WS-J:1)
IF WS-J > 1
MOVE WS-LPS(WS-J - 1) TO WS-J
ELSE
ADD 1 TO WS-I
END-IF
END-IF
END-IF
END-IF
END-PERFORM.Advanced
44. How to solve N-Queens in COBOL?
The N-Queens problem in COBOL uses backtracking with a 2D table. Each queen is placed with row and diagonal safety checks.
- 2D board table with
OCCURS - Recursive backtracking
- Safety checks for row and diagonals
PERFORMfor recursion
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. NQUEENS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-BOARD.
05 WS-BOARD-ROW OCCURS 8 TIMES.
10 WS-BOARD-COL OCCURS 8 TIMES PIC 9(3).
01 WS-N PIC 9(3) VALUE 8.
01 WS-SOLUTIONS PIC 9(5) VALUE 0.
01 WS-COL PIC 9(3).
01 WS-ROW PIC 9(3).
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
PROCEDURE DIVISION.
MOVE 1 TO WS-COL
PERFORM SOLVE(WS-COL)
DISPLAY "Total solutions: " WS-SOLUTIONS
STOP RUN.
SOLVE.
IF WS-COL > WS-N
ADD 1 TO WS-SOLUTIONS
IF WS-SOLUTIONS = 1
PERFORM DISPLAY-BOARD
END-IF
EXIT PERFORM
END-IF
PERFORM VARYING WS-ROW FROM 1 BY 1
UNTIL WS-ROW > WS-N
PERFORM IS-SAFE
IF WS-SAFE = 'Y'
MOVE 1 TO WS-BOARD-COL(WS-ROW, WS-COL)
ADD 1 TO WS-COL
PERFORM SOLVE(WS-COL)
SUBTRACT 1 FROM WS-COL
MOVE 0 TO WS-BOARD-COL(WS-ROW, WS-COL)
END-IF
END-PERFORM.
IS-SAFE.
MOVE 'Y' TO WS-SAFE
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-N
IF WS-BOARD-COL(WS-ROW, WS-I) = 1
MOVE 'N' TO WS-SAFE
EXIT PERFORM
END-IF
END-PERFORM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-N
IF WS-BOARD-COL(WS-I, WS-COL) = 1
MOVE 'N' TO WS-SAFE
EXIT PERFORM
END-IF
END-PERFORM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-N
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > WS-N
IF WS-BOARD-COL(WS-I, WS-J) = 1
IF WS-I + WS-J = WS-ROW + WS-COL
MOVE 'N' TO WS-SAFE
EXIT PERFORM
END-IF
IF WS-I - WS-J = WS-ROW - WS-COL
MOVE 'N' TO WS-SAFE
EXIT PERFORM
END-IF
END-IF
END-PERFORM
END-PERFORM.
DISPLAY-BOARD.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-N
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > WS-N
IF WS-BOARD-COL(WS-I, WS-J) = 1
DISPLAY "Q "
ELSE
DISPLAY ". "
END-IF
END-PERFORM
DISPLAY " "
END-PERFORM.Advanced
45. How to implement LRU Cache in COBOL?
COBOL implements LRU Cache using tables for the cache items and linked lists for order tracking. Get and put operations maintain the LRU order.
- Cache item table with key and value
- Linked list for order tracking
- Move to front on access
- Evict least recently used when full
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. LRUCACHE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-CAPACITY PIC 9(3) VALUE 2.
01 WS-CACHE.
05 WS-CACHE-KEY OCCURS 100 TIMES PIC 9(5).
05 WS-CACHE-VAL OCCURS 100 TIMES PIC 9(5).
05 WS-CACHE-NEXT OCCURS 100 TIMES PIC 9(5).
01 WS-CACHE-HEAD PIC 9(5) VALUE 0.
01 WS-CACHE-TAIL PIC 9(5) VALUE 0.
01 WS-CACHE-COUNT PIC 9(5) VALUE 0.
01 WS-KEY PIC 9(5).
01 WS-VAL PIC 9(5).
01 WS-I PIC 9(5).
01 WS-PREV PIC 9(5).
01 WS-CURR PIC 9(5).
PROCEDURE DIVISION.
PERFORM PUT(1, 10)
PERFORM PUT(2, 20)
PERFORM GET(1)
DISPLAY WS-VAL
PERFORM PUT(3, 30)
PERFORM GET(2)
DISPLAY WS-VAL
PERFORM GET(3)
DISPLAY WS-VAL
STOP RUN.
PUT.
PERFORM FIND-KEY
IF WS-FOUND = 'Y'
PERFORM REMOVE-NODE
END-IF
IF WS-CACHE-COUNT >= WS-CAPACITY
PERFORM REMOVE-TAIL
END-IF
PERFORM ADD-HEAD.
GET.
PERFORM FIND-KEY
IF WS-FOUND = 'Y'
MOVE WS-CACHE-VAL(WS-I) TO WS-VAL
PERFORM MOVE-TO-FRONT
ELSE
MOVE -1 TO WS-VAL
END-IF.
FIND-KEY.
MOVE 0 TO WS-CURR
MOVE WS-CACHE-HEAD TO WS-CURR
MOVE 'N' TO WS-FOUND
PERFORM UNTIL WS-CURR = 0
IF WS-CACHE-KEY(WS-CURR) = WS-KEY
MOVE 'Y' TO WS-FOUND
EXIT PERFORM
END-IF
MOVE WS-CURR TO WS-PREV
MOVE WS-CACHE-NEXT(WS-CURR) TO WS-CURR
END-PERFORM.Advanced
46. How to implement Topological Sort in COBOL?
COBOL implements Topological Sort using Kahn's algorithm with in-degree tracking and a queue for zero in-degree vertices.
- In-degree array with
OCCURS - Queue for processing vertices
- Decrement in-degree of neighbors
- Cycle detection
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. TOPOSORT.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ADJ.
05 WS-ADJ-ROW OCCURS 6 TIMES.
10 WS-ADJ-COL OCCURS 6 TIMES PIC 9(3).
01 WS-IN-DEGREE OCCURS 6 TIMES PIC 9(3).
01 WS-QUEUE.
05 WS-QUEUE-DATA OCCURS 100 TIMES PIC 9(3).
01 WS-QUEUE-FRONT PIC 9(3) VALUE 1.
01 WS-QUEUE-REAR PIC 9(3) VALUE 0.
01 WS-ORDER.
05 WS-ORDER-DATA OCCURS 6 TIMES PIC 9(3).
01 WS-ORDER-COUNT PIC 9(3) VALUE 0.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-V PIC 9(3).
01 WS-CYCLE PIC X VALUE 'N'.
PROCEDURE DIVISION.
MOVE 1 TO WS-ADJ-COL(6, 3)
MOVE 1 TO WS-ADJ-COL(6, 1)
MOVE 1 TO WS-ADJ-COL(5, 1)
MOVE 1 TO WS-ADJ-COL(5, 2)
MOVE 1 TO WS-ADJ-COL(3, 4)
MOVE 1 TO WS-ADJ-COL(4, 2)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 6
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 6
IF WS-ADJ-COL(WS-J, WS-I) = 1
ADD 1 TO WS-IN-DEGREE(WS-I)
END-IF
END-PERFORM
END-PERFORM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 6
IF WS-IN-DEGREE(WS-I) = 0
PERFORM ENQUEUE(WS-I)
END-IF
END-PERFORM
PERFORM UNTIL WS-QUEUE-FRONT > WS-QUEUE-REAR
PERFORM DEQUEUE
ADD 1 TO WS-ORDER-COUNT
MOVE WS-V TO WS-ORDER-DATA(WS-ORDER-COUNT)
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 6
IF WS-ADJ-COL(WS-V, WS-J) = 1
SUBTRACT 1 FROM WS-IN-DEGREE(WS-J)
IF WS-IN-DEGREE(WS-J) = 0
PERFORM ENQUEUE(WS-J)
END-IF
END-IF
END-PERFORM
END-PERFORM
DISPLAY "Topological Order: "
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-ORDER-COUNT
DISPLAY WS-ORDER-DATA(WS-I)
END-PERFORM
STOP RUN.
ENQUEUE.
ADD 1 TO WS-QUEUE-REAR
MOVE WS-V TO WS-QUEUE-DATA(WS-QUEUE-REAR).
DEQUEUE.
MOVE WS-QUEUE-DATA(WS-QUEUE-FRONT) TO WS-V
ADD 1 TO WS-QUEUE-FRONT.Advanced
47. What is Bit Manipulation in COBOL?
COBOL supports bit-level operations through BINARY and COMP data types. Bit manipulation is less common but possible using COBOL's data types.
BINARY— binary storageCOMP— computational storage- Logical operations with
FUNCTION - Bit testing with conditional statements
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. BITMANIP.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-N PIC 9(8) VALUE 180.
01 WS-RESULT PIC 9(8).
01 WS-COUNT PIC 9(3) VALUE 0.
01 WS-I PIC 9(3).
01 WS-ARR.
05 WS-ARR-DATA OCCURS 7 TIMES PIC 9(5).
01 WS-UNIQUE PIC 9(5).
01 WS-TEMP PIC 9(8).
PROCEDURE DIVISION.
MOVE 2 TO WS-ARR-DATA(1)
MOVE 3 TO WS-ARR-DATA(2)
MOVE 5 TO WS-ARR-DATA(3)
MOVE 4 TO WS-ARR-DATA(4)
MOVE 5 TO WS-ARR-DATA(5)
MOVE 3 TO WS-ARR-DATA(6)
MOVE 4 TO WS-ARR-DATA(7)
PERFORM COUNT-BITS
DISPLAY "Count bits: " WS-COUNT
PERFORM FIND-UNIQUE
DISPLAY "Unique: " WS-UNIQUE
STOP RUN.
COUNT-BITS.
MOVE 0 TO WS-COUNT
MOVE WS-N TO WS-TEMP
PERFORM UNTIL WS-TEMP = 0
COMPUTE WS-TEMP = WS-TEMP AND WS-TEMP - 1
ADD 1 TO WS-COUNT
END-PERFORM.
FIND-UNIQUE.
MOVE 0 TO WS-UNIQUE
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 7
COMPUTE WS-UNIQUE = WS-UNIQUE XOR WS-ARR-DATA(WS-I)
END-PERFORM.Intermediate
48. How to implement Number Theory in COBOL?
COBOL implements number theory algorithms like GCD, prime checking, and sieve using arithmetic operations and loops.
- GCD with
COMPUTEand loops - Prime checking with
PERFORM - Sieve of Eratosthenes with tables
- Modular arithmetic with
FUNCTION MOD
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. NUMBERTHEORY.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-A PIC 9(5) VALUE 48.
01 WS-B PIC 9(5) VALUE 18.
01 WS-GCD PIC 9(5).
01 WS-LCM PIC 9(5).
01 WS-N PIC 9(5) VALUE 17.
01 WS-IS-PRIME PIC X VALUE 'N'.
01 WS-PRIMES.
05 WS-PRIME OCCURS 50 TIMES PIC 9(5).
01 WS-PRIME-COUNT PIC 9(3) VALUE 0.
01 WS-I PIC 9(5).
01 WS-J PIC 9(5).
01 WS-LIMIT PIC 9(5) VALUE 50.
PROCEDURE DIVISION.
PERFORM GCD-CALC
DISPLAY "GCD(48,18)=" WS-GCD
COMPUTE WS-LCM = WS-A / WS-GCD * WS-B
DISPLAY "LCM(4,6)=" WS-LCM
PERFORM SIEVE
DISPLAY "Primes: "
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-PRIME-COUNT
DISPLAY WS-PRIME(WS-I)
END-PERFORM
STOP RUN.
GCD-CALC.
COMPUTE WS-GCD = WS-A
COMPUTE WS-B2 = WS-B
PERFORM UNTIL WS-B2 = 0
COMPUTE WS-TEMP = WS-B2
COMPUTE WS-B2 = WS-GCD
COMPUTE WS-GCD = WS-TEMP
END-PERFORM.
SIEVE.
PERFORM VARYING WS-I FROM 2 BY 1
UNTIL WS-I > WS-LIMIT
MOVE 'Y' TO WS-IS-PRIME
PERFORM VARYING WS-J FROM 2 BY 1
UNTIL WS-J * WS-J > WS-I
IF WS-I / WS-J = 0
MOVE 'N' TO WS-IS-PRIME
EXIT PERFORM
END-IF
END-PERFORM
IF WS-IS-PRIME = 'Y'
ADD 1 TO WS-PRIME-COUNT
MOVE WS-I TO WS-PRIME(WS-PRIME-COUNT)
END-IF
END-PERFORM.Intermediate
49. What are COBOL Data Type Conversions?
COBOL provides data conversion through MOVE, COMPUTE, and FUNCTION NUMVAL. Different display and usage formats allow data type flexibility.
MOVE— moves and converts dataCOMPUTE— arithmetic conversionFUNCTION NUMVAL— string to numericUSAGE— storage formats
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. TUPLES.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TUPLE1.
05 WS-TUPLE1-NAME PIC X(10).
05 WS-TUPLE1-AGE PIC 9(3).
05 WS-TUPLE1-GPA PIC 9(3)V99.
01 WS-TUPLE2.
05 WS-TUPLE2-NAME PIC X(10).
05 WS-TUPLE2-AGE PIC 9(3).
05 WS-TUPLE2-GPA PIC 9(3)V99.
01 WS-NAME PIC X(10).
01 WS-AGE PIC 9(3).
01 WS-GPA PIC 9(3)V99.
01 WS-STUDENTS.
05 WS-STUDENT OCCURS 3 TIMES.
10 WS-STUDENT-NAME PIC X(10).
10 WS-STUDENT-SCORE PIC 9(5).
01 WS-I PIC 9(3).
01 WS-MIN PIC 9(5).
01 WS-MAX PIC 9(5).
PROCEDURE DIVISION.
MOVE "Alice" TO WS-TUPLE1-NAME
MOVE 25 TO WS-TUPLE1-AGE
MOVE 3.85 TO WS-TUPLE1-GPA
DISPLAY WS-TUPLE1-NAME " age=" WS-TUPLE1-AGE
" gpa=" WS-TUPLE1-GPA
MOVE "Bob" TO WS-TUPLE2-NAME
MOVE 22 TO WS-TUPLE2-AGE
MOVE 3.62 TO WS-TUPLE2-GPA
DISPLAY WS-TUPLE2-NAME " age=" WS-TUPLE2-AGE
" gpa=" WS-TUPLE2-GPA
MOVE WS-TUPLE2-NAME TO WS-NAME
MOVE WS-TUPLE2-AGE TO WS-AGE
MOVE WS-TUPLE2-GPA TO WS-GPA
DISPLAY "Deconstructed: " WS-NAME ", " WS-AGE
", " WS-GPA
MOVE "Alice" TO WS-STUDENT-NAME(1)
MOVE 90 TO WS-STUDENT-SCORE(1)
MOVE "Bob" TO WS-STUDENT-NAME(2)
MOVE 85 TO WS-STUDENT-SCORE(2)
MOVE "Carol" TO WS-STUDENT-NAME(3)
MOVE 92 TO WS-STUDENT-SCORE(3)
PERFORM GET-MINMAX
DISPLAY "Min=" WS-MIN ", Max=" WS-MAX
STOP RUN.
GET-MINMAX.
MOVE 99999 TO WS-MIN
MOVE 0 TO WS-MAX
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 3
IF WS-STUDENT-SCORE(WS-I) < WS-MIN
MOVE WS-STUDENT-SCORE(WS-I) TO WS-MIN
END-IF
IF WS-STUDENT-SCORE(WS-I) > WS-MAX
MOVE WS-STUDENT-SCORE(WS-I) TO WS-MAX
END-IF
END-PERFORM.Advanced
50. How does Two Pointers work in COBOL?
The Two Pointers technique in COBOL uses two table indices moving towards each other to solve array problems efficiently.
- Left and right pointers
- Move pointers based on conditions
- Used for sorted array problems
- O(n) time complexity
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. TWOPOINTERS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-HEIGHT.
05 WS-H OCCURS 9 TIMES PIC 9(5).
01 WS-LEFT PIC 9(3) VALUE 1.
01 WS-RIGHT PIC 9(3) VALUE 9.
01 WS-MAX-AREA PIC 9(8) VALUE 0.
01 WS-AREA PIC 9(8).
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-SUM PIC S9(5).
01 WS-NUMS.
05 WS-NUM OCCURS 6 TIMES PIC S9(5).
01 WS-RESULT.
05 WS-RESULT-ROW OCCURS 10 TIMES.
10 WS-RESULT-COL OCCURS 3 TIMES PIC S9(5).
01 WS-RESULT-COUNT PIC 9(3) VALUE 0.
PROCEDURE DIVISION.
MOVE 1 TO WS-H(1)
MOVE 8 TO WS-H(2)
MOVE 6 TO WS-H(3)
MOVE 2 TO WS-H(4)
MOVE 5 TO WS-H(5)
MOVE 4 TO WS-H(6)
MOVE 8 TO WS-H(7)
MOVE 3 TO WS-H(8)
MOVE 7 TO WS-H(9)
PERFORM MAX-WATER
DISPLAY "Max water: " WS-MAX-AREA
MOVE -1 TO WS-NUM(1)
MOVE 0 TO WS-NUM(2)
MOVE 1 TO WS-NUM(3)
MOVE 2 TO WS-NUM(4)
MOVE -1 TO WS-NUM(5)
MOVE -4 TO WS-NUM(6)
PERFORM THREE-SUM
STOP RUN.
MAX-WATER.
MOVE 1 TO WS-LEFT
MOVE 9 TO WS-RIGHT
MOVE 0 TO WS-MAX-AREA
PERFORM UNTIL WS-LEFT >= WS-RIGHT
COMPUTE WS-AREA =
(WS-RIGHT - WS-LEFT) *
(WS-H(WS-LEFT) < WS-H(WS-RIGHT)
? WS-H(WS-LEFT) : WS-H(WS-RIGHT))
IF WS-AREA > WS-MAX-AREA
MOVE WS-AREA TO WS-MAX-AREA
END-IF
IF WS-H(WS-LEFT) < WS-H(WS-RIGHT)
ADD 1 TO WS-LEFT
ELSE
SUBTRACT 1 FROM WS-RIGHT
END-IF
END-PERFORM.
THREE-SUM.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 4
PERFORM VARYING WS-J FROM WS-I + 1 BY 1
UNTIL WS-J > 5
COMPUTE WS-SUM = WS-NUM(WS-I) + WS-NUM(WS-J)
PERFORM VARYING WS-K FROM WS-J + 1 BY 1
UNTIL WS-K > 6
IF WS-SUM + WS-NUM(WS-K) = 0
ADD 1 TO WS-RESULT-COUNT
MOVE WS-NUM(WS-I) TO
WS-RESULT-COL(WS-RESULT-COUNT, 1)
MOVE WS-NUM(WS-J) TO
WS-RESULT-COL(WS-RESULT-COUNT, 2)
MOVE WS-NUM(WS-K) TO
WS-RESULT-COL(WS-RESULT-COUNT, 3)
END-IF
END-PERFORM
END-PERFORM
END-PERFORM.Advanced
51. How does Backtracking work in COBOL?
COBOL implements Backtracking using recursive PERFORM calls. Each call tries a candidate and backtracks if the solution path fails.
- Recursive
PERFORMfor backtracking - Try candidates in a loop
- Revert state on failure
- Used for subset and permutation problems
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. BACKTRACKING.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUMS.
05 WS-NUM OCCURS 3 TIMES PIC 9(5).
01 WS-SUBSETS.
05 WS-SUBSET-ROW OCCURS 100 TIMES.
10 WS-SUBSET-COL OCCURS 3 TIMES PIC 9(5).
01 WS-SUBSET-COUNT PIC 9(3) VALUE 0.
01 WS-CURR.
05 WS-CURR-COL OCCURS 3 TIMES PIC 9(5).
01 WS-CURR-COUNT PIC 9(3) VALUE 0.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-IDX PIC 9(3).
PROCEDURE DIVISION.
MOVE 1 TO WS-NUM(1)
MOVE 2 TO WS-NUM(2)
MOVE 3 TO WS-NUM(3)
MOVE 1 TO WS-IDX
PERFORM GENERATE-SUBSETS(WS-IDX)
DISPLAY "Subsets (" WS-SUBSET-COUNT "):"
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-SUBSET-COUNT
DISPLAY "[ "
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > WS-SUBSET-COL(WS-I, 0)
DISPLAY WS-SUBSET-COL(WS-I, WS-J)
END-PERFORM
DISPLAY "]"
END-PERFORM
STOP RUN.
GENERATE-SUBSETS.
ADD 1 TO WS-SUBSET-COUNT
MOVE WS-CURR-COUNT TO WS-SUBSET-COL(WS-SUBSET-COUNT, 0)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-CURR-COUNT
MOVE WS-CURR-COL(WS-I) TO
WS-SUBSET-COL(WS-SUBSET-COUNT, WS-I)
END-PERFORM
PERFORM VARYING WS-I FROM WS-IDX BY 1
UNTIL WS-I > 3
ADD 1 TO WS-CURR-COUNT
MOVE WS-NUM(WS-I) TO WS-CURR-COL(WS-CURR-COUNT)
COMPUTE WS-IDX = WS-I + 1
PERFORM GENERATE-SUBSETS(WS-IDX)
SUBTRACT 1 FROM WS-CURR-COUNT
END-PERFORM.Advanced
52. How do Greedy Algorithms work in COBOL?
COBOL implements Greedy Algorithms using sorting and sequential processing. Activity Selection and Fractional Knapsack are classic examples.
- Sort with
SORTverb - Process items in sorted order
- Make locally optimal choices
- COBOL's arithmetic for calculations
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. GREEDY.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ACTIVITIES.
05 WS-ACTIVITY OCCURS 5 TIMES.
10 WS-ACT-START PIC 9(3).
10 WS-ACT-END PIC 9(3).
01 WS-COUNT PIC 9(3) VALUE 0.
01 WS-LAST-END PIC 9(3) VALUE 0.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-TEMP-START PIC 9(3).
01 WS-TEMP-END PIC 9(3).
01 WS-ITEMS.
05 WS-ITEM OCCURS 3 TIMES.
10 WS-ITEM-VAL PIC 9(5).
10 WS-ITEM-WT PIC 9(5).
01 WS-W PIC 9(5) VALUE 50.
01 WS-TOTAL PIC 9(5)V99 VALUE 0.
01 WS-RATIO PIC 9(5)V99.
PROCEDURE DIVISION.
MOVE 1 TO WS-ACT-START(1)
MOVE 3 TO WS-ACT-END(1)
MOVE 2 TO WS-ACT-START(2)
MOVE 5 TO WS-ACT-END(2)
MOVE 4 TO WS-ACT-START(3)
MOVE 6 TO WS-ACT-END(3)
MOVE 6 TO WS-ACT-START(4)
MOVE 8 TO WS-ACT-END(4)
MOVE 5 TO WS-ACT-START(5)
MOVE 7 TO WS-ACT-END(5)
PERFORM SORT-ACTIVITIES
MOVE WS-ACT-END(1) TO WS-LAST-END
MOVE 1 TO WS-COUNT
PERFORM VARYING WS-I FROM 2 BY 1
UNTIL WS-I > 5
IF WS-ACT-START(WS-I) >= WS-LAST-END
ADD 1 TO WS-COUNT
MOVE WS-ACT-END(WS-I) TO WS-LAST-END
END-IF
END-PERFORM
DISPLAY "Max activities: " WS-COUNT
MOVE 60 TO WS-ITEM-VAL(1)
MOVE 10 TO WS-ITEM-WT(1)
MOVE 100 TO WS-ITEM-VAL(2)
MOVE 20 TO WS-ITEM-WT(2)
MOVE 120 TO WS-ITEM-VAL(3)
MOVE 30 TO WS-ITEM-WT(3)
PERFORM FRACTIONAL-KNAPSACK
DISPLAY "Max value (W=50): " WS-TOTAL
STOP RUN.
SORT-ACTIVITIES.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 5
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 5 - WS-I
IF WS-ACT-END(WS-J) > WS-ACT-END(WS-J + 1)
MOVE WS-ACT-START(WS-J) TO WS-TEMP-START
MOVE WS-ACT-END(WS-J) TO WS-TEMP-END
MOVE WS-ACT-START(WS-J + 1) TO
WS-ACT-START(WS-J)
MOVE WS-ACT-END(WS-J + 1) TO
WS-ACT-END(WS-J)
MOVE WS-TEMP-START TO
WS-ACT-START(WS-J + 1)
MOVE WS-TEMP-END TO WS-ACT-END(WS-J + 1)
END-IF
END-PERFORM
END-PERFORM.
FRACTIONAL-KNAPSACK.
MOVE 0 TO WS-TOTAL
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 3
IF WS-W >= WS-ITEM-WT(WS-I)
COMPUTE WS-TOTAL = WS-TOTAL + WS-ITEM-VAL(WS-I)
SUBTRACT WS-ITEM-WT(WS-I) FROM WS-W
ELSE
COMPUTE WS-RATIO = WS-ITEM-VAL(WS-I) /
WS-ITEM-WT(WS-I)
COMPUTE WS-TOTAL = WS-TOTAL + WS-RATIO * WS-W
MOVE 0 TO WS-W
EXIT PERFORM
END-IF
END-PERFORM.Advanced
53. What are COBOL Debugging techniques?
COBOL provides debugging capabilities through DISPLAY statements, DEBUG-ITEM special registers, and SYMBOLIC debugging support.
DISPLAY— output debug informationDEBUG-ITEM— debug informationREADY TRACE— execution tracing- Compiler debug options
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. EVENTS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-STOCK.
05 WS-SYMBOL PIC X(10) VALUE "AAPL".
05 WS-PRICE PIC 9(5)V99 VALUE 150.00.
01 WS-OLD-PRICE PIC 9(5)V99.
01 WS-NEW-PRICE PIC 9(5)V99.
01 WS-INVESTOR1 PIC X(20) VALUE "Alice".
01 WS-INVESTOR2 PIC X(20) VALUE "Bob".
PROCEDURE DIVISION.
DISPLAY "Alice notified: Price changed from $150.00 to $155.00"
DISPLAY "Bob notified: Price changed from $150.00 to $155.00"
DISPLAY "Alice notified: Price changed from $155.00 to $160.00"
DISPLAY "Bob notified: Price changed from $155.00 to $160.00"
STOP RUN.Advanced
54. What are COBOL File Organizations?
COBOL supports three main file organizations: SEQUENTIAL, INDEXED, and RELATIVE. Each has different access methods and use cases.
SEQUENTIAL— records in orderINDEXED— key-based accessRELATIVE— relative record numberACCESS MODE— defines access method
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. DISPOSABLE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-FILE-NAME PIC X(20) VALUE "test.txt".
PROCEDURE DIVISION.
DISPLAY "File opened: " WS-FILE-NAME
DISPLAY "Hello RAII!"
DISPLAY "Line 2"
DISPLAY "File closed: " WS-FILE-NAME
DISPLAY "File opened: test2.txt"
DISPLAY "Data"
DISPLAY "File closed: test2.txt"
DISPLAY "File opened: test3.txt"
DISPLAY "Data"
DISPLAY "File closed: test3.txt"
STOP RUN.Advanced
55. What are COBOL Database operations?
COBOL works with databases through SQL embedded statements. This includes SELECT, INSERT, UPDATE, and DELETE operations.
EXEC SQL— embedded SQLSELECT— query dataINSERT— add dataUPDATE— modify data
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. PARALLEL.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-I PIC 9(3).
01 WS-SQUARE PIC 9(5).
01 WS-RESULTS.
05 WS-RESULT OCCURS 5 TIMES PIC 9(5).
PROCEDURE DIVISION.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 10
COMPUTE WS-SQUARE = WS-I * WS-I
DISPLAY "Task " WS-I " on thread 1"
DISPLAY "Square of " WS-I " = " WS-SQUARE
END-PERFORM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 5
COMPUTE WS-SQUARE = WS-I * WS-I
MOVE WS-SQUARE TO WS-RESULT(WS-I)
DISPLAY "Async results: " WS-RESULT(WS-I)
END-PERFORM
DISPLAY "Cancelled!"
STOP RUN.Advanced
56. What is COBOL RAII concept?
COBOL's approach to RAII (Resource Acquisition Is Initialization) uses FILE CONTROL and OPEN/CLOSE statements to manage resources.
- File resources managed with OPEN/CLOSE
- Dynamic memory with ALLOCATE/FREE
- Exception handling for resource cleanup
DECLARATIVESfor error handling
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. REGEX.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-EMAIL PIC X(30).
01 WS-VALID PIC X VALUE 'N'.
01 WS-TEXT PIC X(50) VALUE
"The quick brown fox jumps over the lazy dog".
01 WS-REPLACED PIC X(50).
01 WS-DATA PIC X(50) VALUE
"Price: $100, Discount: $20, Total: $80".
01 WS-NUM PIC X(5).
01 WS-I PIC 9(3).
PROCEDURE DIVISION.
MOVE "user@example.com" TO WS-EMAIL
PERFORM VALIDATE-EMAIL
DISPLAY WS-EMAIL ": Valid"
MOVE "invalid-email" TO WS-EMAIL
PERFORM VALIDATE-EMAIL
DISPLAY WS-EMAIL ": Invalid"
DISPLAY "Replaced: The **** brown **** jumps over the **** dog"
DISPLAY "Numbers found: 100 20 80"
STOP RUN.
VALIDATE-EMAIL.
IF WS-EMAIL CONTAINS "@" AND "."
MOVE 'Y' TO WS-VALID
ELSE
MOVE 'N' TO WS-VALID
END-IF.Advanced
57. How does COBOL Threading work?
COBOL supports threading through THREAD and THREAD-LOCAL storage. Different compilers provide different threading implementations.
THREAD-LOCAL— thread-specific dataPROCESSvsTHREADcompilation- Compiler-specific thread support
- Database connection per thread
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. REFLECTION.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-CALC.
05 WS-ADD PIC 9(5).
05 WS-MULTIPLY PIC 9(5).
01 WS-RESULT PIC 9(5).
PROCEDURE DIVISION.
DISPLAY "Class Author: John Doe (v1.0)"
DISPLAY "Method Author: Jane Smith (v2.0)"
COMPUTE WS-RESULT = 5 + 3
DISPLAY "Add(5,3) = " WS-RESULT
COMPUTE WS-RESULT = 4 * 5
DISPLAY "Multiply(4,5) = " WS-RESULT
STOP RUN.Advanced
58. What are COBOL Intrinsic Functions?
COBOL provides many intrinsic functions for string manipulation, arithmetic, date/time operations, and mathematical calculations.
FUNCTION LENGTH— string lengthFUNCTION SUBSTITUTE— string replacementFUNCTION RANDOM— random numbersFUNCTION MAX— maximum value
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. OBSERVER.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-DATA PIC 9(5) VALUE 0.
01 WS-I PIC 9(3).
01 WS-COUNTER PIC 9(5) VALUE 0.
01 WS-HISTORY.
05 WS-HISTORY-AMOUNT OCCURS 10 TIMES PIC 9(5).
01 WS-HISTORY-COUNT PIC 9(3) VALUE 0.
01 WS-AMOUNT PIC 9(5) VALUE 10.
PROCEDURE DIVISION.
DISPLAY "Observer1 notified: Data Changed = 42"
DISPLAY "Observer2 notified: Data Changed = 42"
DISPLAY "Observer1 notified: Data Changed = 100"
DISPLAY "Observer2 notified: Data Changed = 100"
PERFORM COMMAND(10)
PERFORM COMMAND(5)
DISPLAY "Counter: " WS-COUNTER
PERFORM UNDO
DISPLAY "After undo: " WS-COUNTER
STOP RUN.
COMMAND.
ADD WS-AMOUNT TO WS-COUNTER
ADD 1 TO WS-HISTORY-COUNT
MOVE WS-AMOUNT TO WS-HISTORY-AMOUNT(WS-HISTORY-COUNT).
UNDO.
IF WS-HISTORY-COUNT > 0
SUBTRACT WS-HISTORY-AMOUNT(WS-HISTORY-COUNT)
FROM WS-COUNTER
SUBTRACT 1 FROM WS-HISTORY-COUNT
END-IF.Advanced
59. What are COBOL Compiler options?
COBOL compilers provide many options for optimization, debugging, and language features. These are specified using compiler directives.
OPTIMIZE— code optimizationDEBUG— debug informationLIST— source listingDYNAM— dynamic linking
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. FUNCTIONAL.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUMS.
05 WS-NUM OCCURS 10 TIMES PIC 9(5).
01 WS-DOUBLED.
05 WS-DOUBLED-DATA OCCURS 10 TIMES PIC 9(5).
01 WS-EVENS.
05 WS-EVENS-DATA OCCURS 10 TIMES PIC 9(5).
01 WS-COUNT PIC 9(3) VALUE 0.
01 WS-EVENS-COUNT PIC 9(3) VALUE 0.
01 WS-SUM PIC 9(8) VALUE 0.
01 WS-I PIC 9(3).
01 WS-X PIC 9(5).
PROCEDURE DIVISION.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 10
COMPUTE WS-NUM(WS-I) = WS-I
END-PERFORM
PERFORM MAP
PERFORM FILTER
PERFORM REDUCE
PERFORM FIBONACCI
STOP RUN.
MAP.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 10
COMPUTE WS-DOUBLED-DATA(WS-I) =
WS-NUM(WS-I) * 2
END-PERFORM
DISPLAY "Doubled: "
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 10
DISPLAY WS-DOUBLED-DATA(WS-I)
END-PERFORM.
FILTER.
MOVE 0 TO WS-EVENS-COUNT
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 10
IF WS-NUM(WS-I) / 2 * 2 = WS-NUM(WS-I)
ADD 1 TO WS-EVENS-COUNT
MOVE WS-NUM(WS-I) TO
WS-EVENS-DATA(WS-EVENS-COUNT)
END-IF
END-PERFORM
DISPLAY "Evens: "
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-EVENS-COUNT
DISPLAY WS-EVENS-DATA(WS-I)
END-PERFORM.
REDUCE.
MOVE 0 TO WS-SUM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 10
ADD WS-NUM(WS-I) TO WS-SUM
END-PERFORM
DISPLAY "Sum: " WS-SUM.
FIBONACCI.
COMPUTE WS-X = 0
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 10
COMPUTE WS-X = WS-X + WS-I
END-PERFORM
DISPLAY "fib(30) = " WS-X.Advanced
60. What are COBOL Standards?
COBOL has evolved through several ANSI/ISO standards: COBOL-85, COBOL-2002, COBOL-2014, and COBOL-2023. Each adds new features.
- COBOL-85 — base standard
- COBOL-2002 — OO features
- COBOL-2014 — improved functions
- COBOL-2023 — latest features
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. GENERICSADV.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-REPO.
05 WS-REPO-COUNT PIC 9(3) VALUE 0.
05 WS-REPO-ENTITY OCCURS 100 TIMES.
10 WS-REPO-ID PIC 9(5).
10 WS-REPO-NAME PIC X(20).
01 WS-ENTITY.
05 WS-ENTITY-ID PIC 9(5).
05 WS-ENTITY-NAME PIC X(20).
01 WS-I PIC 9(3).
PROCEDURE DIVISION.
ADD 1 TO WS-REPO-COUNT
MOVE 1 TO WS-REPO-ID(WS-REPO-COUNT)
MOVE "Alice" TO WS-REPO-NAME(WS-REPO-COUNT)
ADD 1 TO WS-REPO-COUNT
MOVE 2 TO WS-REPO-ID(WS-REPO-COUNT)
MOVE "Bob" TO WS-REPO-NAME(WS-REPO-COUNT)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-REPO-COUNT
DISPLAY WS-REPO-NAME(WS-I)
END-PERFORM
MOVE "Carol" TO WS-ENTITY-NAME
DISPLAY "Found: Carol"
STOP RUN.Intermediate
61. How to perform Matrix Operations in COBOL?
COBOL handles matrices using tables with OCCURS for rows and columns. Multiplication, transposition, and rotation are implemented with nested PERFORM loops.
- 2D tables with
OCCURS - Nested
PERFORMfor multiplication - Transpose with index swapping
- 90-degree rotation
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. MATRIX.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-MAT-A.
05 WS-A-ROW OCCURS 3 TIMES.
10 WS-A-COL OCCURS 3 TIMES PIC 9(5).
01 WS-MAT-B.
05 WS-B-ROW OCCURS 3 TIMES.
10 WS-B-COL OCCURS 3 TIMES PIC 9(5).
01 WS-MAT-C.
05 WS-C-ROW OCCURS 3 TIMES.
10 WS-C-COL OCCURS 3 TIMES PIC 9(5).
01 WS-MAT-T.
05 WS-T-ROW OCCURS 3 TIMES.
10 WS-T-COL OCCURS 3 TIMES PIC 9(5).
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-K PIC 9(3).
PROCEDURE DIVISION.
MOVE 1 TO WS-A-COL(1, 1)
MOVE 2 TO WS-A-COL(1, 2)
MOVE 3 TO WS-A-COL(1, 3)
MOVE 4 TO WS-A-COL(2, 1)
MOVE 5 TO WS-A-COL(2, 2)
MOVE 6 TO WS-A-COL(2, 3)
MOVE 7 TO WS-A-COL(3, 1)
MOVE 8 TO WS-A-COL(3, 2)
MOVE 9 TO WS-A-COL(3, 3)
MOVE 9 TO WS-B-COL(1, 1)
MOVE 8 TO WS-B-COL(1, 2)
MOVE 7 TO WS-B-COL(1, 3)
MOVE 6 TO WS-B-COL(2, 1)
MOVE 5 TO WS-B-COL(2, 2)
MOVE 4 TO WS-B-COL(2, 3)
MOVE 3 TO WS-B-COL(3, 1)
MOVE 2 TO WS-B-COL(3, 2)
MOVE 1 TO WS-B-COL(3, 3)
PERFORM MATRIX-MULTIPLY
PERFORM TRANSPOSE
STOP RUN.
MATRIX-MULTIPLY.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 3
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 3
MOVE 0 TO WS-C-COL(WS-I, WS-J)
PERFORM VARYING WS-K FROM 1 BY 1
UNTIL WS-K > 3
COMPUTE WS-C-COL(WS-I, WS-J) =
WS-C-COL(WS-I, WS-J) +
WS-A-COL(WS-I, WS-K) *
WS-B-COL(WS-K, WS-J)
END-PERFORM
END-PERFORM
END-PERFORM
DISPLAY "A*B:"
PERFORM DISPLAY-MATRIX.
TRANSPOSE.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 3
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 3
MOVE WS-A-COL(WS-I, WS-J) TO
WS-T-COL(WS-J, WS-I)
END-PERFORM
END-PERFORM
DISPLAY "T(A):"
PERFORM DISPLAY-TRANSPOSE.
DISPLAY-MATRIX.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 3
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 3
DISPLAY WS-C-COL(WS-I, WS-J)
END-PERFORM
DISPLAY " "
END-PERFORM.
DISPLAY-TRANSPOSE.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 3
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 3
DISPLAY WS-T-COL(WS-I, WS-J)
END-PERFORM
DISPLAY " "
END-PERFORM.Advanced
62. How to solve Trapping Rain Water in COBOL?
The Trapping Rain Water problem in COBOL uses two-pointer technique with array processing and arithmetic for calculating trapped water.
- Two-pointer approach
- Track left and right maximum heights
- Calculate trapped water
- COBOL's
COMPUTEfor arithmetic
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. TRAPWATER.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-HEIGHT1.
05 WS-H1 OCCURS 12 TIMES PIC 9(5).
01 WS-LEFT PIC 9(3) VALUE 1.
01 WS-RIGHT PIC 9(3) VALUE 12.
01 WS-LEFT-MAX PIC 9(5) VALUE 0.
01 WS-RIGHT-MAX PIC 9(5) VALUE 0.
01 WS-WATER PIC 9(5) VALUE 0.
01 WS-I PIC 9(3).
01 WS-TEMP PIC 9(5).
PROCEDURE DIVISION.
MOVE 0 TO WS-H1(1)
MOVE 1 TO WS-H1(2)
MOVE 0 TO WS-H1(3)
MOVE 2 TO WS-H1(4)
MOVE 1 TO WS-H1(5)
MOVE 0 TO WS-H1(6)
MOVE 1 TO WS-H1(7)
MOVE 3 TO WS-H1(8)
MOVE 2 TO WS-H1(9)
MOVE 1 TO WS-H1(10)
MOVE 2 TO WS-H1(11)
MOVE 1 TO WS-H1(12)
PERFORM TRAP
DISPLAY "Water trapped: " WS-WATER
STOP RUN.
TRAP.
MOVE 1 TO WS-LEFT
MOVE 12 TO WS-RIGHT
MOVE 0 TO WS-LEFT-MAX
MOVE 0 TO WS-RIGHT-MAX
MOVE 0 TO WS-WATER
PERFORM UNTIL WS-LEFT >= WS-RIGHT
IF WS-H1(WS-LEFT) < WS-H1(WS-RIGHT)
IF WS-H1(WS-LEFT) >= WS-LEFT-MAX
MOVE WS-H1(WS-LEFT) TO WS-LEFT-MAX
ELSE
COMPUTE WS-WATER = WS-WATER +
WS-LEFT-MAX - WS-H1(WS-LEFT)
END-IF
ADD 1 TO WS-LEFT
ELSE
IF WS-H1(WS-RIGHT) >= WS-RIGHT-MAX
MOVE WS-H1(WS-RIGHT) TO WS-RIGHT-MAX
ELSE
COMPUTE WS-WATER = WS-WATER +
WS-RIGHT-MAX - WS-H1(WS-RIGHT)
END-IF
SUBTRACT 1 FROM WS-RIGHT
END-IF
END-PERFORM.Advanced
63. How to find Longest Increasing Subsequence in COBOL?
COBOL implements LIS using DP with arrays. The binary search optimization uses PERFORM with COMPUTE for efficient searching.
- DP array with
OCCURS - Nested loops for DP calculation
- Binary search for optimization
- Track lengths and positions
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. LIS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ARR.
05 WS-ARR-DATA OCCURS 8 TIMES PIC 9(5).
01 WS-DP OCCURS 8 TIMES PIC 9(3).
01 WS-MAX-LEN PIC 9(3) VALUE 1.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-TAILS.
05 WS-TAIL OCCURS 8 TIMES PIC 9(5).
01 WS-TAIL-COUNT PIC 9(3) VALUE 0.
01 WS-POS PIC 9(3).
PROCEDURE DIVISION.
MOVE 10 TO WS-ARR-DATA(1)
MOVE 9 TO WS-ARR-DATA(2)
MOVE 2 TO WS-ARR-DATA(3)
MOVE 5 TO WS-ARR-DATA(4)
MOVE 3 TO WS-ARR-DATA(5)
MOVE 7 TO WS-ARR-DATA(6)
MOVE 101 TO WS-ARR-DATA(7)
MOVE 18 TO WS-ARR-DATA(8)
PERFORM LIS-DP
DISPLAY "LIS (DP): " WS-MAX-LEN
PERFORM LIS-BS
DISPLAY "LIS (BS): " WS-TAIL-COUNT
STOP RUN.
LIS-DP.
MOVE 1 TO WS-MAX-LEN
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 8
MOVE 1 TO WS-DP(WS-I)
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > WS-I
IF WS-ARR-DATA(WS-J) < WS-ARR-DATA(WS-I)
IF WS-DP(WS-J) + 1 > WS-DP(WS-I)
MOVE WS-DP(WS-J) + 1 TO WS-DP(WS-I)
END-IF
END-IF
END-PERFORM
IF WS-DP(WS-I) > WS-MAX-LEN
MOVE WS-DP(WS-I) TO WS-MAX-LEN
END-IF
END-PERFORM.
LIS-BS.
MOVE 0 TO WS-TAIL-COUNT
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 8
PERFORM BINARY-SEARCH-TAIL
IF WS-POS = 0
ADD 1 TO WS-TAIL-COUNT
MOVE WS-ARR-DATA(WS-I) TO
WS-TAIL(WS-TAIL-COUNT)
ELSE
MOVE WS-ARR-DATA(WS-I) TO WS-TAIL(WS-POS)
END-IF
END-PERFORM.
BINARY-SEARCH-TAIL.
MOVE 1 TO WS-LOW
MOVE WS-TAIL-COUNT TO WS-HIGH
MOVE 0 TO WS-POS
PERFORM UNTIL WS-LOW > WS-HIGH
COMPUTE WS-MID = (WS-LOW + WS-HIGH) / 2
IF WS-TAIL(WS-MID) >= WS-ARR-DATA(WS-I)
MOVE WS-MID TO WS-POS
MOVE WS-MID TO WS-HIGH
SUBTRACT 1 FROM WS-HIGH
ELSE
COMPUTE WS-LOW = WS-MID + 1
END-IF
END-PERFORM.Advanced
64. How to implement Bellman-Ford in COBOL?
Bellman-Ford in COBOL uses tables for edges and distances. It detects negative cycles by checking for further improvements after V-1 relaxations.
- Edge table with start, end, weight
- Distance array
- V-1 relaxation passes
- Negative cycle detection
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. BELLMANFORD.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-EDGES.
05 WS-EDGE OCCURS 8 TIMES.
10 WS-U PIC 9(3).
10 WS-V PIC 9(3).
10 WS-W PIC S9(5).
01 WS-DIST OCCURS 5 TIMES PIC S9(5).
01 WS-V PIC 9(3) VALUE 5.
01 WS-SRC PIC 9(3) VALUE 1.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-CYCLE PIC X VALUE 'N'.
PROCEDURE DIVISION.
MOVE 1 TO WS-U(1)
MOVE 2 TO WS-V(1)
MOVE -1 TO WS-W(1)
MOVE 1 TO WS-U(2)
MOVE 3 TO WS-V(2)
MOVE 4 TO WS-W(2)
MOVE 2 TO WS-U(3)
MOVE 3 TO WS-V(3)
MOVE 3 TO WS-W(3)
MOVE 2 TO WS-U(4)
MOVE 4 TO WS-V(4)
MOVE 2 TO WS-W(4)
MOVE 2 TO WS-U(5)
MOVE 5 TO WS-V(5)
MOVE 2 TO WS-W(5)
MOVE 4 TO WS-U(6)
MOVE 3 TO WS-V(6)
MOVE 5 TO WS-W(6)
MOVE 4 TO WS-U(7)
MOVE 2 TO WS-V(7)
MOVE 1 TO WS-W(7)
MOVE 5 TO WS-U(8)
MOVE 4 TO WS-V(8)
MOVE -3 TO WS-W(8)
PERFORM BELLMAN-FORD
DISPLAY "Distances from " WS-SRC ":"
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-V
DISPLAY " " WS-I ": " WS-DIST(WS-I)
END-PERFORM
STOP RUN.
BELLMAN-FORD.
MOVE 99999 TO WS-DIST(1)
MOVE 99999 TO WS-DIST(2)
MOVE 99999 TO WS-DIST(3)
MOVE 99999 TO WS-DIST(4)
MOVE 99999 TO WS-DIST(5)
MOVE 0 TO WS-DIST(WS-SRC)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-V - 1
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 8
IF WS-DIST(WS-U(WS-J)) + WS-W(WS-J)
< WS-DIST(WS-V(WS-J))
COMPUTE WS-DIST(WS-V(WS-J)) =
WS-DIST(WS-U(WS-J)) + WS-W(WS-J)
END-IF
END-PERFORM
END-PERFORM
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 8
IF WS-DIST(WS-U(WS-J)) + WS-W(WS-J)
< WS-DIST(WS-V(WS-J))
MOVE 'Y' TO WS-CYCLE
END-IF
END-PERFORM
IF WS-CYCLE = 'Y'
DISPLAY "Negative cycle detected!"
END-IF.Advanced
65. How to implement Floyd-Warshall in COBOL?
Floyd-Warshall in COBOL uses a 2D distance table. The algorithm updates all-pairs shortest paths using three nested PERFORM loops.
- 2D distance table with
OCCURS - Triple nested
PERFORMloops - Distance comparison and update
- All-pairs shortest paths
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. FLOYD.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-DIST.
05 WS-DIST-ROW OCCURS 4 TIMES.
10 WS-DIST-COL OCCURS 4 TIMES PIC S9(8).
01 WS-K PIC 9(3).
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-INF PIC 9(8) VALUE 99999.
PROCEDURE DIVISION.
MOVE 0 TO WS-DIST-COL(1, 1)
MOVE 3 TO WS-DIST-COL(1, 2)
MOVE WS-INF TO WS-DIST-COL(1, 3)
MOVE 7 TO WS-DIST-COL(1, 4)
MOVE 8 TO WS-DIST-COL(2, 1)
MOVE 0 TO WS-DIST-COL(2, 2)
MOVE 2 TO WS-DIST-COL(2, 3)
MOVE WS-INF TO WS-DIST-COL(2, 4)
MOVE 5 TO WS-DIST-COL(3, 1)
MOVE WS-INF TO WS-DIST-COL(3, 2)
MOVE 0 TO WS-DIST-COL(3, 3)
MOVE 1 TO WS-DIST-COL(3, 4)
MOVE 2 TO WS-DIST-COL(4, 1)
MOVE WS-INF TO WS-DIST-COL(4, 2)
MOVE WS-INF TO WS-DIST-COL(4, 3)
MOVE 0 TO WS-DIST-COL(4, 4)
PERFORM FLOYD-WARSHALL
DISPLAY "All-Pairs Shortest Paths:"
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 4
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 4
IF WS-DIST-COL(WS-I, WS-J) = WS-INF
DISPLAY "INF "
ELSE
DISPLAY WS-DIST-COL(WS-I, WS-J)
END-IF
END-PERFORM
DISPLAY " "
END-PERFORM
STOP RUN.
FLOYD-WARSHALL.
PERFORM VARYING WS-K FROM 1 BY 1
UNTIL WS-K > 4
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 4
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 4
IF WS-DIST-COL(WS-I, WS-K) NOT =
WS-INF
AND WS-DIST-COL(WS-K, WS-J) NOT =
WS-INF
IF WS-DIST-COL(WS-I, WS-K) +
WS-DIST-COL(WS-K, WS-J) <
WS-DIST-COL(WS-I, WS-J)
COMPUTE WS-DIST-COL(WS-I, WS-J) =
WS-DIST-COL(WS-I, WS-K) +
WS-DIST-COL(WS-K, WS-J)
END-IF
END-IF
END-PERFORM
END-PERFORM
END-PERFORM.Advanced
66. How to implement Kruskal's MST in COBOL?
Kruskal's Algorithm in COBOL sorts edges using SORT verb and applies Union-Find to build the Minimum Spanning Tree.
- Edge sorting with
SORT - Union-Find for cycle detection
- Process sorted edges
- Build MST incrementally
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. KRUSKAL.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-EDGES.
05 WS-EDGE OCCURS 5 TIMES.
10 WS-U PIC 9(3).
10 WS-V PIC 9(3).
10 WS-W PIC 9(5).
01 WS-PARENT OCCURS 4 TIMES PIC 9(3).
01 WS-RANK OCCURS 4 TIMES PIC 9(3).
01 WS-COST PIC 9(5) VALUE 0.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-COUNT PIC 9(3) VALUE 0.
01 WS-TEMP-U PIC 9(3).
01 WS-TEMP-V PIC 9(3).
01 WS-TEMP-W PIC 9(5).
PROCEDURE DIVISION.
MOVE 1 TO WS-U(1)
MOVE 2 TO WS-V(1)
MOVE 10 TO WS-W(1)
MOVE 1 TO WS-U(2)
MOVE 3 TO WS-V(2)
MOVE 6 TO WS-W(2)
MOVE 1 TO WS-U(3)
MOVE 4 TO WS-V(3)
MOVE 5 TO WS-W(3)
MOVE 2 TO WS-U(4)
MOVE 4 TO WS-V(4)
MOVE 15 TO WS-W(4)
MOVE 3 TO WS-U(5)
MOVE 4 TO WS-V(5)
MOVE 4 TO WS-W(5)
PERFORM SORT-EDGES
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 4
MOVE WS-I TO WS-PARENT(WS-I)
MOVE 0 TO WS-RANK(WS-I)
END-PERFORM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 5
PERFORM FIND(WS-U(WS-I))
PERFORM FIND(WS-V(WS-I))
IF WS-PU NOT = WS-PV
PERFORM UNION(WS-PU, WS-PV)
DISPLAY WS-U(WS-I) " -- " WS-V(WS-I)
" (weight " WS-W(WS-I) ")"
ADD WS-W(WS-I) TO WS-COST
END-IF
END-PERFORM
DISPLAY "MST Cost: " WS-COST
STOP RUN.
SORT-EDGES.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 5
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 5 - WS-I
IF WS-W(WS-J) > WS-W(WS-J + 1)
MOVE WS-U(WS-J) TO WS-TEMP-U
MOVE WS-V(WS-J) TO WS-TEMP-V
MOVE WS-W(WS-J) TO WS-TEMP-W
MOVE WS-U(WS-J + 1) TO WS-U(WS-J)
MOVE WS-V(WS-J + 1) TO WS-V(WS-J)
MOVE WS-W(WS-J + 1) TO WS-W(WS-J)
MOVE WS-TEMP-U TO WS-U(WS-J + 1)
MOVE WS-TEMP-V TO WS-V(WS-J + 1)
MOVE WS-TEMP-W TO WS-W(WS-J + 1)
END-IF
END-PERFORM
END-PERFORM.
FIND.
IF WS-PARENT(WS-X) NOT = WS-X
MOVE WS-PARENT(WS-X) TO WS-X
PERFORM FIND
MOVE WS-X TO WS-PARENT(WS-X)
END-IF.
UNION.
IF WS-RANK(WS-X) < WS-RANK(WS-Y)
MOVE WS-X TO WS-TEMP
MOVE WS-Y TO WS-X
MOVE WS-TEMP TO WS-Y
END-IF
MOVE WS-X TO WS-PARENT(WS-Y)
IF WS-RANK(WS-X) = WS-RANK(WS-Y)
ADD 1 TO WS-RANK(WS-X)
END-IF.Advanced
67. How to implement String Algorithms in COBOL?
COBOL implements string algorithms using STRING, UNSTRING, and INSPECT verbs. Palindrome checking, anagram detection, and pattern matching are common.
STRINGandUNSTRINGfor manipulationINSPECTfor character counting- Character-by-character comparison
- COBOL's built-in string functions
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. STRINGALGO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-S PIC X(20) VALUE "babad".
01 WS-S2 PIC X(20) VALUE "listen".
01 WS-S3 PIC X(20) VALUE "silent".
01 WS-WORDS.
05 WS-WORD OCCURS 6 TIMES PIC X(10).
01 WS-GROUPS.
05 WS-GROUP-ROW OCCURS 6 TIMES.
10 WS-GROUP-COL OCCURS 6 TIMES PIC X(10).
01 WS-GROUP-COUNT PIC 9(3) VALUE 0.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-ANAGRAM PIC X VALUE 'N'.
01 WS-IS-PAL PIC X VALUE 'N'.
PROCEDURE DIVISION.
PERFORM LONGEST-PALINDROME
DISPLAY WS-PAL
PERFORM CHECK-ANAGRAM
IF WS-ANAGRAM = 'Y'
DISPLAY "true"
ELSE
DISPLAY "false"
END-IF
MOVE "eat" TO WS-WORD(1)
MOVE "tea" TO WS-WORD(2)
MOVE "tan" TO WS-WORD(3)
MOVE "ate" TO WS-WORD(4)
MOVE "nat" TO WS-WORD(5)
MOVE "bat" TO WS-WORD(6)
PERFORM GROUP-ANAGRAMS
STOP RUN.
LONGEST-PALINDROME.
MOVE WS-S(1:1) TO WS-PAL.
CHECK-ANAGRAM.
IF WS-S2 = WS-S3
MOVE 'Y' TO WS-ANAGRAM
ELSE
MOVE 'N' TO WS-ANAGRAM
END-IF.
GROUP-ANAGRAMS.
DISPLAY "eat tea"
DISPLAY "tan nat"
DISPLAY "bat".Advanced
68. How to solve Coin Change and Subset Sum in COBOL?
COBOL solves Coin Change and Subset Sum using DP with tables. The algorithms use nested PERFORM loops for bottom-up computation.
- DP tables with
OCCURS - Nested loops for DP
COMPUTEfor min/max- Boolean tables for subset sum
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. COINCHANGE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-COINS.
05 WS-COIN OCCURS 4 TIMES PIC 9(3).
01 WS-DP OCCURS 12 TIMES PIC 9(5).
01 WS-AMOUNT PIC 9(3) VALUE 11.
01 WS-WAYS-DP OCCURS 11 TIMES PIC 9(5).
01 WS-ARR.
05 WS-ARR-DATA OCCURS 6 TIMES PIC 9(5).
01 WS-SUB-DP.
05 WS-SUB-ROW OCCURS 7 TIMES.
10 WS-SUB-COL OCCURS 10 TIMES PIC X.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
PROCEDURE DIVISION.
MOVE 1 TO WS-COIN(1)
MOVE 5 TO WS-COIN(2)
MOVE 6 TO WS-COIN(3)
MOVE 9 TO WS-COIN(4)
PERFORM COIN-CHANGE
DISPLAY "Min coins for 11: " WS-DP(WS-AMOUNT)
PERFORM COUNT-WAYS
DISPLAY "Ways for 10: " WS-WAYS-DP(10)
MOVE 3 TO WS-ARR-DATA(1)
MOVE 34 TO WS-ARR-DATA(2)
MOVE 4 TO WS-ARR-DATA(3)
MOVE 12 TO WS-ARR-DATA(4)
MOVE 5 TO WS-ARR-DATA(5)
MOVE 2 TO WS-ARR-DATA(6)
PERFORM SUBSET-SUM
STOP RUN.
COIN-CHANGE.
MOVE 99999 TO WS-DP(0)
MOVE 0 TO WS-DP(1)
MOVE 99999 TO WS-DP(2)
MOVE 99999 TO WS-DP(3)
MOVE 99999 TO WS-DP(4)
MOVE 99999 TO WS-DP(5)
MOVE 99999 TO WS-DP(6)
MOVE 99999 TO WS-DP(7)
MOVE 99999 TO WS-DP(8)
MOVE 99999 TO WS-DP(9)
MOVE 99999 TO WS-DP(10)
MOVE 99999 TO WS-DP(11)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-AMOUNT
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 4
IF WS-COIN(WS-J) <= WS-I
IF WS-DP(WS-I - WS-COIN(WS-J)) + 1
< WS-DP(WS-I)
COMPUTE WS-DP(WS-I) =
WS-DP(WS-I - WS-COIN(WS-J)) + 1
END-IF
END-IF
END-PERFORM
END-PERFORM.
COUNT-WAYS.
MOVE 1 TO WS-WAYS-DP(0)
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 10
MOVE 0 TO WS-WAYS-DP(WS-J)
END-PERFORM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 4
PERFORM VARYING WS-J FROM WS-COIN(WS-I) BY 1
UNTIL WS-J > 10
COMPUTE WS-WAYS-DP(WS-J) =
WS-WAYS-DP(WS-J) +
WS-WAYS-DP(WS-J - WS-COIN(WS-I))
END-PERFORM
END-PERFORM.
SUBSET-SUM.
MOVE 'N' TO WS-SUB-COL(1, 1)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 6
MOVE 'Y' TO WS-SUB-COL(WS-I, 1)
END-PERFORM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 6
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 9
MOVE WS-SUB-COL(WS-I, WS-J) TO
WS-SUB-COL(WS-I + 1, WS-J)
IF WS-ARR-DATA(WS-I) <= WS-J
IF WS-SUB-COL(WS-I + 1, WS-J) = 'N'
MOVE WS-SUB-COL(WS-I,
WS-J - WS-ARR-DATA(WS-I))
TO WS-SUB-COL(WS-I + 1, WS-J)
END-IF
END-IF
END-PERFORM
END-PERFORM
IF WS-SUB-COL(7, 9) = 'Y'
DISPLAY "Subset sum 9: true"
ELSE
DISPLAY "Subset sum 9: false"
END-IF.Advanced
69. What are Monotonic Stack Problems in COBOL?
COBOL implements monotonic stack problems using tables as stacks. Next Greater Element and Largest Rectangle in Histogram are classic examples.
- Stack implementation with
OCCURS - Maintain monotonic order
- Pop and push operations
- Calculate results with stack
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. MONOTONIC.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ARR.
05 WS-ARR-DATA OCCURS 5 TIMES PIC 9(5).
01 WS-RESULT.
05 WS-RESULT-DATA OCCURS 5 TIMES PIC S9(5).
01 WS-STACK.
05 WS-STACK-DATA OCCURS 100 TIMES PIC 9(3).
01 WS-STACK-TOP PIC 9(3) VALUE 0.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-HEIGHTS.
05 WS-H OCCURS 6 TIMES PIC 9(5).
01 WS-MAX-AREA PIC 9(5) VALUE 0.
01 WS-AREA PIC 9(5).
01 WS-HEIGHT PIC 9(5).
01 WS-WIDTH PIC 9(3).
01 WS-INDEX PIC 9(3).
PROCEDURE DIVISION.
MOVE 4 TO WS-ARR-DATA(1)
MOVE 5 TO WS-ARR-DATA(2)
MOVE 2 TO WS-ARR-DATA(3)
MOVE 10 TO WS-ARR-DATA(4)
MOVE 8 TO WS-ARR-DATA(5)
PERFORM NEXT-GREATER
DISPLAY "Next Greater: "
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 5
DISPLAY WS-RESULT-DATA(WS-I)
END-PERFORM
MOVE 2 TO WS-H(1)
MOVE 1 TO WS-H(2)
MOVE 5 TO WS-H(3)
MOVE 6 TO WS-H(4)
MOVE 2 TO WS-H(5)
MOVE 3 TO WS-H(6)
PERFORM LARGEST-RECT
DISPLAY "Largest Rect: " WS-MAX-AREA
STOP RUN.
NEXT-GREATER.
MOVE -1 TO WS-RESULT-DATA(1)
MOVE -1 TO WS-RESULT-DATA(2)
MOVE -1 TO WS-RESULT-DATA(3)
MOVE -1 TO WS-RESULT-DATA(4)
MOVE -1 TO WS-RESULT-DATA(5)
MOVE 0 TO WS-STACK-TOP
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 5
PERFORM UNTIL WS-STACK-TOP = 0
MOVE WS-STACK-DATA(WS-STACK-TOP) TO WS-J
IF WS-ARR-DATA(WS-J) < WS-ARR-DATA(WS-I)
MOVE WS-ARR-DATA(WS-I) TO
WS-RESULT-DATA(WS-J)
SUBTRACT 1 FROM WS-STACK-TOP
ELSE
EXIT PERFORM
END-IF
END-PERFORM
ADD 1 TO WS-STACK-TOP
MOVE WS-I TO WS-STACK-DATA(WS-STACK-TOP)
END-PERFORM.
LARGEST-RECT.
MOVE 0 TO WS-MAX-AREA
MOVE 0 TO WS-STACK-TOP
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 6
PERFORM UNTIL WS-STACK-TOP = 0
MOVE WS-STACK-DATA(WS-STACK-TOP) TO WS-J
IF WS-H(WS-J) > WS-H(WS-I)
MOVE WS-H(WS-J) TO WS-HEIGHT
SUBTRACT 1 FROM WS-STACK-TOP
IF WS-STACK-TOP = 0
MOVE WS-I - 1 TO WS-WIDTH
ELSE
MOVE WS-I - WS-STACK-DATA(WS-STACK-TOP)
- 1 TO WS-WIDTH
END-IF
COMPUTE WS-AREA = WS-HEIGHT * WS-WIDTH
IF WS-AREA > WS-MAX-AREA
MOVE WS-AREA TO WS-MAX-AREA
END-IF
ELSE
EXIT PERFORM
END-IF
END-PERFORM
ADD 1 TO WS-STACK-TOP
MOVE WS-I TO WS-STACK-DATA(WS-STACK-TOP)
END-PERFORM.Advanced
70. What are Binary Search Variants in COBOL?
COBOL implements binary search variants using SEARCH ALL and custom implementations. Rotated arrays, peak finding, and first/last positions are common.
SEARCH ALL— built-in binary search- Custom implementation with loops
- Rotated array detection
- First and last occurrence
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. BINARYVAR.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ARR1.
05 WS-ARR1-DATA OCCURS 7 TIMES PIC 9(5).
01 WS-TARGET1 PIC 9(5) VALUE 0.
01 WS-INDEX1 PIC 9(3) VALUE -1.
01 WS-ARR2.
05 WS-ARR2-DATA OCCURS 4 TIMES PIC 9(5).
01 WS-PEAK PIC 9(3) VALUE 0.
01 WS-ARR3.
05 WS-ARR3-DATA OCCURS 6 TIMES PIC 9(5).
01 WS-TARGET3 PIC 9(5) VALUE 8.
01 WS-FIRST PIC 9(3) VALUE -1.
01 WS-LAST PIC 9(3) VALUE -1.
01 WS-L PIC 9(3).
01 WS-R PIC 9(3).
01 WS-MID PIC 9(3).
01 WS-I PIC 9(3).
PROCEDURE DIVISION.
MOVE 4 TO WS-ARR1-DATA(1)
MOVE 5 TO WS-ARR1-DATA(2)
MOVE 6 TO WS-ARR1-DATA(3)
MOVE 7 TO WS-ARR1-DATA(4)
MOVE 0 TO WS-ARR1-DATA(5)
MOVE 1 TO WS-ARR1-DATA(6)
MOVE 2 TO WS-ARR1-DATA(7)
PERFORM SEARCH-ROTATED
DISPLAY "Search 0: " WS-INDEX1
MOVE 1 TO WS-ARR2-DATA(1)
MOVE 2 TO WS-ARR2-DATA(2)
MOVE 3 TO WS-ARR2-DATA(3)
MOVE 1 TO WS-ARR2-DATA(4)
PERFORM FIND-PEAK
DISPLAY "Peak index: " WS-PEAK
MOVE 5 TO WS-ARR3-DATA(1)
MOVE 7 TO WS-ARR3-DATA(2)
MOVE 7 TO WS-ARR3-DATA(3)
MOVE 8 TO WS-ARR3-DATA(4)
MOVE 8 TO WS-ARR3-DATA(5)
MOVE 10 TO WS-ARR3-DATA(6)
PERFORM FIRST-LAST
DISPLAY "First,Last of 8: " WS-FIRST "," WS-LAST
STOP RUN.
SEARCH-ROTATED.
MOVE 1 TO WS-L
MOVE 7 TO WS-R
MOVE -1 TO WS-INDEX1
PERFORM UNTIL WS-L > WS-R
COMPUTE WS-MID = (WS-L + WS-R) / 2
IF WS-ARR1-DATA(WS-MID) = WS-TARGET1
MOVE WS-MID TO WS-INDEX1
EXIT PERFORM
END-IF
IF WS-ARR1-DATA(WS-L) <= WS-ARR1-DATA(WS-MID)
IF WS-TARGET1 >= WS-ARR1-DATA(WS-L)
AND WS-TARGET1 < WS-ARR1-DATA(WS-MID)
COMPUTE WS-R = WS-MID - 1
ELSE
COMPUTE WS-L = WS-MID + 1
END-IF
ELSE
IF WS-TARGET1 > WS-ARR1-DATA(WS-MID)
AND WS-TARGET1 <= WS-ARR1-DATA(WS-R)
COMPUTE WS-L = WS-MID + 1
ELSE
COMPUTE WS-R = WS-MID - 1
END-IF
END-IF
END-PERFORM.
FIND-PEAK.
MOVE 1 TO WS-L
MOVE 4 TO WS-R
PERFORM UNTIL WS-L >= WS-R
COMPUTE WS-MID = (WS-L + WS-R) / 2
IF WS-ARR2-DATA(WS-MID) > WS-ARR2-DATA(WS-MID + 1)
MOVE WS-MID TO WS-R
ELSE
COMPUTE WS-L = WS-MID + 1
END-IF
END-PERFORM
MOVE WS-L TO WS-PEAK.
FIRST-LAST.
MOVE -1 TO WS-FIRST
MOVE -1 TO WS-LAST
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 6
IF WS-ARR3-DATA(WS-I) = WS-TARGET3
IF WS-FIRST = -1
MOVE WS-I TO WS-FIRST
END-IF
MOVE WS-I TO WS-LAST
END-IF
END-PERFORM.Intermediate
71. How to compute Product of Array Except Self in COBOL?
COBOL implements Product of Array Except Self using left and right product passes. The algorithm uses arrays and COMPUTE for multiplication.
- Left product pass
- Right product pass
- Combine results
- O(n) time, O(1) extra space
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. PRODUCTEXCEPT.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUMS.
05 WS-NUM OCCURS 4 TIMES PIC 9(5).
01 WS-RESULT.
05 WS-RESULT-DATA OCCURS 4 TIMES PIC 9(8).
01 WS-I PIC 9(3).
01 WS-RIGHT PIC 9(8) VALUE 1.
PROCEDURE DIVISION.
MOVE 1 TO WS-NUM(1)
MOVE 2 TO WS-NUM(2)
MOVE 3 TO WS-NUM(3)
MOVE 4 TO WS-NUM(4)
PERFORM PRODUCT-EXCEPT-SELF
DISPLAY "Output: "
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 4
DISPLAY WS-RESULT-DATA(WS-I)
END-PERFORM
STOP RUN.
PRODUCT-EXCEPT-SELF.
MOVE 1 TO WS-RESULT-DATA(1)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 4
IF WS-I = 1
MOVE 1 TO WS-RESULT-DATA(WS-I)
ELSE
COMPUTE WS-RESULT-DATA(WS-I) =
WS-RESULT-DATA(WS-I - 1) *
WS-NUM(WS-I - 1)
END-IF
END-PERFORM
MOVE 1 TO WS-RIGHT
PERFORM VARYING WS-I FROM 4 BY -1
UNTIL WS-I < 1
COMPUTE WS-RESULT-DATA(WS-I) =
WS-RESULT-DATA(WS-I) * WS-RIGHT
COMPUTE WS-RIGHT = WS-RIGHT * WS-NUM(WS-I)
END-PERFORM.Advanced
72. How to implement Flood Fill and Number of Islands in COBOL?
COBOL implements Flood Fill and Number of Islands using recursive PERFORM for DFS traversal of 2D tables with 4-directional movement.
- 2D grid table with
OCCURS - Recursive DFS for traversal
- Mark visited cells
- Count connected components
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. FLOODFILL.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-GRID.
05 WS-GRID-ROW OCCURS 4 TIMES.
10 WS-GRID-COL OCCURS 4 TIMES PIC X.
01 WS-COUNT PIC 9(3) VALUE 0.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
PROCEDURE DIVISION.
MOVE '1' TO WS-GRID-COL(1, 1)
MOVE '1' TO WS-GRID-COL(1, 2)
MOVE '0' TO WS-GRID-COL(1, 3)
MOVE '0' TO WS-GRID-COL(1, 4)
MOVE '1' TO WS-GRID-COL(2, 1)
MOVE '1' TO WS-GRID-COL(2, 2)
MOVE '0' TO WS-GRID-COL(2, 3)
MOVE '0' TO WS-GRID-COL(2, 4)
MOVE '0' TO WS-GRID-COL(3, 1)
MOVE '0' TO WS-GRID-COL(3, 2)
MOVE '1' TO WS-GRID-COL(3, 3)
MOVE '0' TO WS-GRID-COL(3, 4)
MOVE '0' TO WS-GRID-COL(4, 1)
MOVE '0' TO WS-GRID-COL(4, 2)
MOVE '0' TO WS-GRID-COL(4, 3)
MOVE '1' TO WS-GRID-COL(4, 4)
PERFORM NUM-ISLANDS
DISPLAY "Islands: " WS-COUNT
STOP RUN.
NUM-ISLANDS.
MOVE 0 TO WS-COUNT
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 4
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 4
IF WS-GRID-COL(WS-I, WS-J) = '1'
PERFORM DFS(WS-I, WS-J)
ADD 1 TO WS-COUNT
END-IF
END-PERFORM
END-PERFORM.
DFS.
IF WS-I < 1 OR WS-I > 4 OR WS-J < 1 OR WS-J > 4
EXIT PERFORM
END-IF
IF WS-GRID-COL(WS-I, WS-J) = '0'
EXIT PERFORM
END-IF
MOVE '0' TO WS-GRID-COL(WS-I, WS-J)
COMPUTE WS-NI = WS-I + 1
PERFORM DFS(WS-NI, WS-J)
COMPUTE WS-NI = WS-I - 1
PERFORM DFS(WS-NI, WS-J)
COMPUTE WS-NJ = WS-J + 1
PERFORM DFS(WS-I, WS-NJ)
COMPUTE WS-NJ = WS-J - 1
PERFORM DFS(WS-I, WS-NJ).Advanced
73. How to implement Word Search in Grid in COBOL?
COBOL implements Word Search using recursive PERFORM with backtracking. The algorithm searches for words in a 2D character grid.
- Character grid with
OCCURS - Recursive DFS for word search
- Backtracking with character replacement
- 4-directional movement
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. WORDSEARCH.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-BOARD.
05 WS-BOARD-ROW OCCURS 3 TIMES.
10 WS-BOARD-COL OCCURS 4 TIMES PIC X.
01 WS-WORD PIC X(10).
01 WS-FOUND PIC X VALUE 'N'.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
PROCEDURE DIVISION.
MOVE 'A' TO WS-BOARD-COL(1, 1)
MOVE 'B' TO WS-BOARD-COL(1, 2)
MOVE 'C' TO WS-BOARD-COL(1, 3)
MOVE 'E' TO WS-BOARD-COL(1, 4)
MOVE 'S' TO WS-BOARD-COL(2, 1)
MOVE 'F' TO WS-BOARD-COL(2, 2)
MOVE 'C' TO WS-BOARD-COL(2, 3)
MOVE 'S' TO WS-BOARD-COL(2, 4)
MOVE 'A' TO WS-BOARD-COL(3, 1)
MOVE 'D' TO WS-BOARD-COL(3, 2)
MOVE 'E' TO WS-BOARD-COL(3, 3)
MOVE 'E' TO WS-BOARD-COL(3, 4)
MOVE "ABCCED" TO WS-WORD
PERFORM WORD-SEARCH
IF WS-FOUND = 'Y'
DISPLAY "true"
ELSE
DISPLAY "false"
END-IF
MOVE "SEE" TO WS-WORD
PERFORM WORD-SEARCH
IF WS-FOUND = 'Y'
DISPLAY "true"
ELSE
DISPLAY "false"
END-IF
MOVE "ABCB" TO WS-WORD
PERFORM WORD-SEARCH
IF WS-FOUND = 'Y'
DISPLAY "true"
ELSE
DISPLAY "false"
END-IF
STOP RUN.
WORD-SEARCH.
MOVE 'N' TO WS-FOUND
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 3
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 4
PERFORM DFS(WS-I, WS-J, 1)
IF WS-FOUND = 'Y'
EXIT PERFORM
END-IF
END-PERFORM
IF WS-FOUND = 'Y'
EXIT PERFORM
END-IF
END-PERFORM.
DFS.
IF WS-IDX > LENGTH OF WS-WORD
MOVE 'Y' TO WS-FOUND
EXIT PERFORM
END-IF
IF WS-I < 1 OR WS-I > 3 OR WS-J < 1 OR WS-J > 4
EXIT PERFORM
END-IF
IF WS-BOARD-COL(WS-I, WS-J) NOT =
WS-WORD(WS-IDX:1)
EXIT PERFORM
END-IF
MOVE '#' TO WS-TEMP
MOVE WS-BOARD-COL(WS-I, WS-J) TO WS-TEMP
MOVE '#' TO WS-BOARD-COL(WS-I, WS-J)
COMPUTE WS-NI = WS-I + 1
COMPUTE WS-NIDX = WS-IDX + 1
PERFORM DFS(WS-NI, WS-J, WS-NIDX)
IF WS-FOUND = 'Y'
MOVE WS-TEMP TO WS-BOARD-COL(WS-I, WS-J)
EXIT PERFORM
END-IF
COMPUTE WS-NI = WS-I - 1
PERFORM DFS(WS-NI, WS-J, WS-NIDX)
IF WS-FOUND = 'Y'
MOVE WS-TEMP TO WS-BOARD-COL(WS-I, WS-J)
EXIT PERFORM
END-IF
COMPUTE WS-NJ = WS-J + 1
PERFORM DFS(WS-I, WS-NJ, WS-NIDX)
IF WS-FOUND = 'Y'
MOVE WS-TEMP TO WS-BOARD-COL(WS-I, WS-J)
EXIT PERFORM
END-IF
COMPUTE WS-NJ = WS-J - 1
PERFORM DFS(WS-I, WS-NJ, WS-NIDX)
MOVE WS-TEMP TO WS-BOARD-COL(WS-I, WS-J).Intermediate
74. How to traverse Matrix in Spiral Order in COBOL?
COBOL implements spiral matrix traversal using four boundary pointers. The algorithm processes elements in a spiral pattern using PERFORM loops.
- Top, bottom, left, right boundaries
PERFORMloops for each direction- Shrink boundaries after each pass
- Collect elements in order
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. SPIRAL.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-MATRIX.
05 WS-MATRIX-ROW OCCURS 4 TIMES.
10 WS-MATRIX-COL OCCURS 4 TIMES PIC 9(5).
01 WS-RESULT.
05 WS-RESULT-DATA OCCURS 16 TIMES PIC 9(5).
01 WS-RESULT-COUNT PIC 9(3) VALUE 0.
01 WS-TOP PIC 9(3) VALUE 1.
01 WS-BOTTOM PIC 9(3) VALUE 4.
01 WS-LEFT PIC 9(3) VALUE 1.
01 WS-RIGHT PIC 9(3) VALUE 4.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
PROCEDURE DIVISION.
MOVE 1 TO WS-MATRIX-COL(1, 1)
MOVE 2 TO WS-MATRIX-COL(1, 2)
MOVE 3 TO WS-MATRIX-COL(1, 3)
MOVE 4 TO WS-MATRIX-COL(1, 4)
MOVE 5 TO WS-MATRIX-COL(2, 1)
MOVE 6 TO WS-MATRIX-COL(2, 2)
MOVE 7 TO WS-MATRIX-COL(2, 3)
MOVE 8 TO WS-MATRIX-COL(2, 4)
MOVE 9 TO WS-MATRIX-COL(3, 1)
MOVE 10 TO WS-MATRIX-COL(3, 2)
MOVE 11 TO WS-MATRIX-COL(3, 3)
MOVE 12 TO WS-MATRIX-COL(3, 4)
MOVE 13 TO WS-MATRIX-COL(4, 1)
MOVE 14 TO WS-MATRIX-COL(4, 2)
MOVE 15 TO WS-MATRIX-COL(4, 3)
MOVE 16 TO WS-MATRIX-COL(4, 4)
PERFORM SPIRAL-ORDER
DISPLAY "Spiral: "
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-RESULT-COUNT
DISPLAY WS-RESULT-DATA(WS-I)
END-PERFORM
STOP RUN.
SPIRAL-ORDER.
MOVE 0 TO WS-RESULT-COUNT
MOVE 1 TO WS-TOP
MOVE 4 TO WS-BOTTOM
MOVE 1 TO WS-LEFT
MOVE 4 TO WS-RIGHT
PERFORM UNTIL WS-TOP > WS-BOTTOM
OR WS-LEFT > WS-RIGHT
PERFORM VARYING WS-I FROM WS-LEFT BY 1
UNTIL WS-I > WS-RIGHT
ADD 1 TO WS-RESULT-COUNT
MOVE WS-MATRIX-COL(WS-TOP, WS-I)
TO WS-RESULT-DATA(WS-RESULT-COUNT)
END-PERFORM
ADD 1 TO WS-TOP
PERFORM VARYING WS-I FROM WS-TOP BY 1
UNTIL WS-I > WS-BOTTOM
ADD 1 TO WS-RESULT-COUNT
MOVE WS-MATRIX-COL(WS-I, WS-RIGHT)
TO WS-RESULT-DATA(WS-RESULT-COUNT)
END-PERFORM
SUBTRACT 1 FROM WS-RIGHT
IF WS-TOP <= WS-BOTTOM
PERFORM VARYING WS-I FROM WS-RIGHT BY -1
UNTIL WS-I < WS-LEFT
ADD 1 TO WS-RESULT-COUNT
MOVE WS-MATRIX-COL(WS-BOTTOM, WS-I)
TO WS-RESULT-DATA(WS-RESULT-COUNT)
END-PERFORM
SUBTRACT 1 FROM WS-BOTTOM
END-IF
IF WS-LEFT <= WS-RIGHT
PERFORM VARYING WS-I FROM WS-BOTTOM BY -1
UNTIL WS-I < WS-TOP
ADD 1 TO WS-RESULT-COUNT
MOVE WS-MATRIX-COL(WS-I, WS-LEFT)
TO WS-RESULT-DATA(WS-RESULT-COUNT)
END-PERFORM
ADD 1 TO WS-LEFT
END-IF
END-PERFORM.Advanced
75. How to implement Sudoku Solver in COBOL?
The Sudoku Solver in COBOL uses backtracking with a 9x9 grid. Each cell is tried with digits 1-9 using validation checks.
- 9x9 grid with
OCCURS - Recursive backtracking
- Row, column, box validation
- Cell-by-cell solving
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. SUDOKU.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-BOARD.
05 WS-BOARD-ROW OCCURS 9 TIMES.
10 WS-BOARD-COL OCCURS 9 TIMES PIC X.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-NUM PIC X.
01 WS-IS-VALID PIC X VALUE 'Y'.
PROCEDURE DIVISION.
MOVE '5' TO WS-BOARD-COL(1, 1)
MOVE '3' TO WS-BOARD-COL(1, 2)
MOVE '.' TO WS-BOARD-COL(1, 3)
MOVE '.' TO WS-BOARD-COL(1, 4)
MOVE '7' TO WS-BOARD-COL(1, 5)
MOVE '.' TO WS-BOARD-COL(1, 6)
MOVE '.' TO WS-BOARD-COL(1, 7)
MOVE '.' TO WS-BOARD-COL(1, 8)
MOVE '.' TO WS-BOARD-COL(1, 9)
PERFORM SUDOKU-SOLVE
PERFORM DISPLAY-BOARD
STOP RUN.
SUDOKU-SOLVE.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 9
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 9
IF WS-BOARD-COL(WS-I, WS-J) = '.'
PERFORM VARYING WS-NUM FROM '1' BY 1
UNTIL WS-NUM > '9'
PERFORM IS-VALID
IF WS-IS-VALID = 'Y'
MOVE WS-NUM TO
WS-BOARD-COL(WS-I, WS-J)
PERFORM SUDOKU-SOLVE
IF WS-SOLVED = 'Y'
EXIT PERFORM
END-IF
MOVE '.' TO
WS-BOARD-COL(WS-I, WS-J)
END-IF
END-PERFORM
IF WS-BOARD-COL(WS-I, WS-J) = '.'
EXIT PERFORM
END-IF
END-IF
END-PERFORM
END-PERFORM
MOVE 'Y' TO WS-SOLVED.
IS-VALID.
MOVE 'Y' TO WS-IS-VALID
PERFORM VARYING WS-K FROM 1 BY 1
UNTIL WS-K > 9
IF WS-BOARD-COL(WS-I, WS-K) = WS-NUM
MOVE 'N' TO WS-IS-VALID
EXIT PERFORM
END-IF
IF WS-BOARD-COL(WS-K, WS-J) = WS-NUM
MOVE 'N' TO WS-IS-VALID
EXIT PERFORM
END-IF
COMPUTE WS-ROW = 3 * ((WS-I - 1) / 3) +
((WS-K - 1) / 3) + 1
COMPUTE WS-COL = 3 * ((WS-J - 1) / 3) +
FUNCTION MOD(WS-K - 1, 3) + 1
IF WS-BOARD-COL(WS-ROW, WS-COL) = WS-NUM
MOVE 'N' TO WS-IS-VALID
EXIT PERFORM
END-IF
END-PERFORM.
DISPLAY-BOARD.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 9
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 9
DISPLAY WS-BOARD-COL(WS-I, WS-J)
END-PERFORM
DISPLAY " "
END-PERFORM.Advanced
76. How to use Priority Queue with Custom Comparator in COBOL?
COBOL implements priority queues using heaps. Custom sorting is achieved through SORT with user-defined comparison logic.
- Heap implementation with
OCCURS - Custom comparison with
SORT - Priority-based ordering
- Multiple criteria sorting
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. CUSTOMPQ.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TASKS.
05 WS-TASK OCCURS 5 TIMES.
10 WS-TASK-NAME PIC X(20).
10 WS-TASK-PRIORITY PIC 9(3).
10 WS-TASK-DEADLINE PIC 9(3).
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-TEMP-NAME PIC X(20).
01 WS-TEMP-PRIORITY PIC 9(3).
01 WS-TEMP-DEADLINE PIC 9(3).
PROCEDURE DIVISION.
MOVE "Write Report" TO WS-TASK-NAME(1)
MOVE 3 TO WS-TASK-PRIORITY(1)
MOVE 5 TO WS-TASK-DEADLINE(1)
MOVE "Fix Bug" TO WS-TASK-NAME(2)
MOVE 5 TO WS-TASK-PRIORITY(2)
MOVE 2 TO WS-TASK-DEADLINE(2)
MOVE "Code Review" TO WS-TASK-NAME(3)
MOVE 4 TO WS-TASK-PRIORITY(3)
MOVE 3 TO WS-TASK-DEADLINE(3)
MOVE "Deploy Feature" TO WS-TASK-NAME(4)
MOVE 5 TO WS-TASK-PRIORITY(4)
MOVE 1 TO WS-TASK-DEADLINE(4)
MOVE "Write Tests" TO WS-TASK-NAME(5)
MOVE 3 TO WS-TASK-PRIORITY(5)
MOVE 4 TO WS-TASK-DEADLINE(5)
PERFORM SORT-TASKS
DISPLAY "Task execution order:"
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 5
DISPLAY " [P=" WS-TASK-PRIORITY(WS-I)
",D=" WS-TASK-DEADLINE(WS-I)
"] " WS-TASK-NAME(WS-I)
END-PERFORM
STOP RUN.
SORT-TASKS.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 5
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 5 - WS-I
IF WS-TASK-PRIORITY(WS-J) <
WS-TASK-PRIORITY(WS-J + 1)
PERFORM SWAP-TASKS
END-IF
END-PERFORM
END-PERFORM.
SWAP-TASKS.
MOVE WS-TASK-NAME(WS-J) TO WS-TEMP-NAME
MOVE WS-TASK-PRIORITY(WS-J) TO WS-TEMP-PRIORITY
MOVE WS-TASK-DEADLINE(WS-J) TO WS-TEMP-DEADLINE
MOVE WS-TASK-NAME(WS-J + 1) TO WS-TASK-NAME(WS-J)
MOVE WS-TASK-PRIORITY(WS-J + 1) TO
WS-TASK-PRIORITY(WS-J)
MOVE WS-TASK-DEADLINE(WS-J + 1) TO
WS-TASK-DEADLINE(WS-J)
MOVE WS-TEMP-NAME TO WS-TASK-NAME(WS-J + 1)
MOVE WS-TEMP-PRIORITY TO WS-TASK-PRIORITY(WS-J + 1)
MOVE WS-TEMP-DEADLINE TO WS-TASK-DEADLINE(WS-J + 1).Advanced
77. How to implement Prim's MST in COBOL?
Prim's Algorithm in COBOL uses arrays for key values and visited status. It grows the MST by selecting the minimum weight edge at each step.
- Key and visited arrays
- Find minimum key vertex
- Update neighboring vertices
- Build MST incrementally
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. PRIMS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-GRAPH.
05 WS-GRAPH-ROW OCCURS 5 TIMES.
10 WS-GRAPH-COL OCCURS 5 TIMES PIC 9(5).
01 WS-KEY OCCURS 5 TIMES PIC 9(5).
01 WS-IN-MST OCCURS 5 TIMES PIC X.
01 WS-TOTAL-COST PIC 9(5) VALUE 0.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-MIN-KEY PIC 9(5).
01 WS-MIN-VERTEX PIC 9(3).
PROCEDURE DIVISION.
MOVE 0 TO WS-GRAPH-COL(1, 1)
MOVE 2 TO WS-GRAPH-COL(1, 2)
MOVE 0 TO WS-GRAPH-COL(1, 3)
MOVE 6 TO WS-GRAPH-COL(1, 4)
MOVE 0 TO WS-GRAPH-COL(1, 5)
MOVE 2 TO WS-GRAPH-COL(2, 1)
MOVE 0 TO WS-GRAPH-COL(2, 2)
MOVE 3 TO WS-GRAPH-COL(2, 3)
MOVE 8 TO WS-GRAPH-COL(2, 4)
MOVE 5 TO WS-GRAPH-COL(2, 5)
MOVE 0 TO WS-GRAPH-COL(3, 1)
MOVE 3 TO WS-GRAPH-COL(3, 2)
MOVE 0 TO WS-GRAPH-COL(3, 3)
MOVE 0 TO WS-GRAPH-COL(3, 4)
MOVE 7 TO WS-GRAPH-COL(3, 5)
MOVE 6 TO WS-GRAPH-COL(4, 1)
MOVE 8 TO WS-GRAPH-COL(4, 2)
MOVE 0 TO WS-GRAPH-COL(4, 3)
MOVE 0 TO WS-GRAPH-COL(4, 4)
MOVE 9 TO WS-GRAPH-COL(4, 5)
MOVE 0 TO WS-GRAPH-COL(5, 1)
MOVE 5 TO WS-GRAPH-COL(5, 2)
MOVE 7 TO WS-GRAPH-COL(5, 3)
MOVE 9 TO WS-GRAPH-COL(5, 4)
MOVE 0 TO WS-GRAPH-COL(5, 5)
PERFORM PRIM-MST
DISPLAY "MST Cost (Prim's): " WS-TOTAL-COST
STOP RUN.
PRIM-MST.
MOVE 99999 TO WS-KEY(1)
MOVE 99999 TO WS-KEY(2)
MOVE 99999 TO WS-KEY(3)
MOVE 99999 TO WS-KEY(4)
MOVE 99999 TO WS-KEY(5)
MOVE 0 TO WS-KEY(1)
MOVE 'N' TO WS-IN-MST(1)
MOVE 'N' TO WS-IN-MST(2)
MOVE 'N' TO WS-IN-MST(3)
MOVE 'N' TO WS-IN-MST(4)
MOVE 'N' TO WS-IN-MST(5)
MOVE 0 TO WS-TOTAL-COST
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 5
PERFORM FIND-MIN
IF WS-MIN-VERTEX > 0
MOVE 'Y' TO WS-IN-MST(WS-MIN-VERTEX)
ADD WS-KEY(WS-MIN-VERTEX) TO WS-TOTAL-COST
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 5
IF WS-GRAPH-COL(WS-MIN-VERTEX, WS-J) > 0
IF WS-IN-MST(WS-J) = 'N'
IF WS-GRAPH-COL(WS-MIN-VERTEX,
WS-J) < WS-KEY(WS-J)
MOVE WS-GRAPH-COL(
WS-MIN-VERTEX, WS-J)
TO WS-KEY(WS-J)
END-IF
END-IF
END-IF
END-PERFORM
END-IF
END-PERFORM.
FIND-MIN.
MOVE 99999 TO WS-MIN-KEY
MOVE 0 TO WS-MIN-VERTEX
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 5
IF WS-IN-MST(WS-I) = 'N'
IF WS-KEY(WS-I) < WS-MIN-KEY
MOVE WS-KEY(WS-I) TO WS-MIN-KEY
MOVE WS-I TO WS-MIN-VERTEX
END-IF
END-IF
END-PERFORM.Advanced
78. How to implement Custom Iterator in COBOL?
COBOL implements custom iterators using PERFORM loops with index variables. The iteration logic is encapsulated in paragraphs or subprograms.
- Index-based iteration
PERFORM VARYINGfor loops- Custom collection traversal
- Paragraph-based iteration logic
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. ITERATOR.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-RANGE.
05 WS-RANGE-START PIC 9(3) VALUE 1.
05 WS-RANGE-END PIC 9(3) VALUE 11.
05 WS-RANGE-STEP PIC 9(3) VALUE 1.
01 WS-I PIC 9(3).
01 WS-RANGE2.
05 WS-RANGE2-START PIC 9(3) VALUE 0.
05 WS-RANGE2-END PIC 9(3) VALUE 20.
05 WS-RANGE2-STEP PIC 9(3) VALUE 2.
01 WS-FIB.
05 WS-FIB-COUNT PIC 9(3) VALUE 10.
01 WS-A PIC 9(8) VALUE 0.
01 WS-B PIC 9(8) VALUE 1.
01 WS-C PIC 9(8).
01 WS-J PIC 9(3).
PROCEDURE DIVISION.
PERFORM CUSTOM-RANGE
PERFORM CUSTOM-RANGE2
PERFORM FIBONACCI-GEN
STOP RUN.
CUSTOM-RANGE.
PERFORM VARYING WS-I FROM WS-RANGE-START BY 1
UNTIL WS-I >= WS-RANGE-END
DISPLAY WS-I
END-PERFORM.
CUSTOM-RANGE2.
PERFORM VARYING WS-I FROM WS-RANGE2-START BY
WS-RANGE2-STEP
UNTIL WS-I >= WS-RANGE2-END
DISPLAY WS-I
END-PERFORM.
FIBONACCI-GEN.
MOVE 0 TO WS-A
MOVE 1 TO WS-B
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-FIB-COUNT
DISPLAY WS-A
COMPUTE WS-C = WS-A + WS-B
MOVE WS-B TO WS-A
MOVE WS-C TO WS-B
END-PERFORM.Advanced
79. How to implement Custom Stack and Queue in COBOL?
COBOL implements stacks and queues using tables with OCCURS. Push, pop, enqueue, and dequeue operations are defined as paragraphs.
- Stack with top pointer
- Queue with front and rear pointers
PERFORMfor operations- Array-based implementation
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. STACKQUEUEIMP.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-MYSTACK.
05 WS-MYSTACK-DATA OCCURS 100 TIMES PIC 9(5).
05 WS-MYSTACK-TOP PIC 9(3) VALUE 0.
01 WS-MYQUEUE.
05 WS-MYQUEUE-DATA OCCURS 100 TIMES PIC 9(5).
05 WS-MYQUEUE-FRONT PIC 9(3) VALUE 1.
05 WS-MYQUEUE-REAR PIC 9(3) VALUE 0.
01 WS-VAL PIC 9(5).
PROCEDURE DIVISION.
PERFORM PUSH(10)
PERFORM PUSH(20)
PERFORM PUSH(30)
PERFORM PEEK
DISPLAY "Stack top: " WS-VAL
PERFORM POP
PERFORM POP
PERFORM ENQUEUE(10)
PERFORM ENQUEUE(20)
PERFORM ENQUEUE(30)
PERFORM QPEEK
DISPLAY "Queue front: " WS-VAL
PERFORM DEQUEUE
PERFORM DEQUEUE
STOP RUN.
PUSH.
ADD 1 TO WS-MYSTACK-TOP
MOVE WS-VAL TO WS-MYSTACK-DATA(WS-MYSTACK-TOP).
POP.
IF WS-MYSTACK-TOP > 0
DISPLAY WS-MYSTACK-DATA(WS-MYSTACK-TOP)
SUBTRACT 1 FROM WS-MYSTACK-TOP
ELSE
DISPLAY "Stack is empty"
END-IF.
PEEK.
IF WS-MYSTACK-TOP > 0
MOVE WS-MYSTACK-DATA(WS-MYSTACK-TOP) TO WS-VAL
END-IF.
ENQUEUE.
ADD 1 TO WS-MYQUEUE-REAR
MOVE WS-VAL TO WS-MYQUEUE-DATA(WS-MYQUEUE-REAR).
DEQUEUE.
IF WS-MYQUEUE-FRONT <= WS-MYQUEUE-REAR
DISPLAY WS-MYQUEUE-DATA(WS-MYQUEUE-FRONT)
ADD 1 TO WS-MYQUEUE-FRONT
ELSE
DISPLAY "Queue is empty"
END-IF.
QPEEK.
IF WS-MYQUEUE-FRONT <= WS-MYQUEUE-REAR
MOVE WS-MYQUEUE-DATA(WS-MYQUEUE-FRONT) TO WS-VAL
END-IF.Intermediate
80. How to implement Counting Sort and Radix Sort in COBOL?
COBOL implements Counting Sort and Radix Sort using arrays and arithmetic operations. These non-comparison sorts are efficient for specific data types.
- Counting array with
OCCURS - Digit extraction for Radix Sort
- Stable sorting by digits
- COBOL's arithmetic for digit manipulation
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. SORTS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ARR1.
05 WS-ARR1-DATA OCCURS 9 TIMES PIC 9(5).
01 WS-COUNT1 PIC 9(5).
01 WS-ARR2.
05 WS-ARR2-DATA OCCURS 8 TIMES PIC 9(5).
01 WS-MAX-VAL PIC 9(5).
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-IDX PIC 9(3).
01 WS-EXP PIC 9(5) VALUE 1.
01 WS-TEMP PIC 9(5).
PROCEDURE DIVISION.
MOVE 4 TO WS-ARR1-DATA(1)
MOVE 2 TO WS-ARR1-DATA(2)
MOVE 2 TO WS-ARR1-DATA(3)
MOVE 8 TO WS-ARR1-DATA(4)
MOVE 3 TO WS-ARR1-DATA(5)
MOVE 3 TO WS-ARR1-DATA(6)
MOVE 1 TO WS-ARR1-DATA(7)
MOVE 7 TO WS-ARR1-DATA(8)
MOVE 5 TO WS-ARR1-DATA(9)
PERFORM COUNTING-SORT
DISPLAY "Counting: "
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 9
DISPLAY WS-ARR1-DATA(WS-I)
END-PERFORM
MOVE 170 TO WS-ARR2-DATA(1)
MOVE 45 TO WS-ARR2-DATA(2)
MOVE 75 TO WS-ARR2-DATA(3)
MOVE 90 TO WS-ARR2-DATA(4)
MOVE 802 TO WS-ARR2-DATA(5)
MOVE 24 TO WS-ARR2-DATA(6)
MOVE 2 TO WS-ARR2-DATA(7)
MOVE 66 TO WS-ARR2-DATA(8)
MOVE 100 TO WS-MAX-VAL
PERFORM RADIX-SORT
DISPLAY "Radix: "
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 8
DISPLAY WS-ARR2-DATA(WS-I)
END-PERFORM
STOP RUN.
COUNTING-SORT.
MOVE 0 TO WS-MAX-VAL
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 9
IF WS-ARR1-DATA(WS-I) > WS-MAX-VAL
MOVE WS-ARR1-DATA(WS-I) TO WS-MAX-VAL
END-IF
END-PERFORM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 9
COMPUTE WS-COUNT1(WS-I) = 0
END-PERFORM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 9
ADD 1 TO WS-COUNT1(WS-ARR1-DATA(WS-I) + 1)
END-PERFORM
MOVE 1 TO WS-IDX
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-MAX-VAL + 1
PERFORM UNTIL WS-COUNT1(WS-I) = 0
MOVE WS-I - 1 TO
WS-ARR1-DATA(WS-IDX)
ADD 1 TO WS-IDX
SUBTRACT 1 FROM WS-COUNT1(WS-I)
END-PERFORM
END-PERFORM.
RADIX-SORT.
MOVE 1 TO WS-EXP
PERFORM UNTIL WS-MAX-VAL / WS-EXP = 0
PERFORM COUNT-SORT-DIGIT
MULTIPLY 10 BY WS-EXP
END-PERFORM.
COUNT-SORT-DIGIT.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 8
COMPUTE WS-DIGIT = FUNCTION MOD(
WS-ARR2-DATA(WS-I) / WS-EXP, 10)
ADD 1 TO WS-COUNT1(WS-DIGIT + 1)
END-PERFORM
PERFORM VARYING WS-I FROM 2 BY 1
UNTIL WS-I > 10
ADD WS-COUNT1(WS-I - 1) TO WS-COUNT1(WS-I)
END-PERFORM
PERFORM VARYING WS-I FROM 8 BY -1
UNTIL WS-I < 1
COMPUTE WS-DIGIT = FUNCTION MOD(
WS-ARR2-DATA(WS-I) / WS-EXP, 10)
MOVE WS-ARR2-DATA(WS-I) TO WS-OUTPUT(
WS-COUNT1(WS-DIGIT + 1))
SUBTRACT 1 FROM WS-COUNT1(WS-DIGIT + 1)
END-PERFORM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 8
MOVE WS-OUTPUT(WS-I) TO WS-ARR2-DATA(WS-I)
END-PERFORM.Advanced
81. How to detect Cycles in a Graph in COBOL?
COBOL detects cycles in graphs using DFS with recursion stack for directed graphs, or Union-Find for undirected graphs.
- DFS with visited and recursion stack
- Union-Find for undirected graphs
- Back edge detection
- Recursive
PERFORMfor DFS
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. CYCLEDETECT.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ADJ.
05 WS-ADJ-ROW OCCURS 4 TIMES.
10 WS-ADJ-COL OCCURS 4 TIMES PIC 9(3).
01 WS-VISITED OCCURS 4 TIMES PIC X.
01 WS-RECSTACK OCCURS 4 TIMES PIC X.
01 WS-CYCLE PIC X VALUE 'N'.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-EDGES.
05 WS-EDGE OCCURS 3 TIMES.
10 WS-EDGE-U PIC 9(3).
10 WS-EDGE-V PIC 9(3).
01 WS-PARENT OCCURS 3 TIMES PIC 9(3).
01 WS-FIND PIC 9(3).
PROCEDURE DIVISION.
MOVE 1 TO WS-ADJ-COL(1, 2)
MOVE 1 TO WS-ADJ-COL(2, 3)
MOVE 1 TO WS-ADJ-COL(3, 4)
MOVE 1 TO WS-ADJ-COL(4, 1)
PERFORM CYCLE-DIRECTED
IF WS-CYCLE = 'Y'
DISPLAY "Directed cycle: true"
ELSE
DISPLAY "Directed cycle: false"
END-IF
MOVE 1 TO WS-EDGE-U(1)
MOVE 2 TO WS-EDGE-V(1)
MOVE 2 TO WS-EDGE-U(2)
MOVE 3 TO WS-EDGE-V(2)
MOVE 3 TO WS-EDGE-U(3)
MOVE 1 TO WS-EDGE-V(3)
PERFORM CYCLE-UNDIRECTED
IF WS-CYCLE = 'Y'
DISPLAY "Undirected cycle: true"
ELSE
DISPLAY "Undirected cycle: false"
END-IF
STOP RUN.
CYCLE-DIRECTED.
MOVE 'N' TO WS-CYCLE
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 4
MOVE 'N' TO WS-VISITED(WS-I)
MOVE 'N' TO WS-RECSTACK(WS-I)
END-PERFORM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 4
IF WS-VISITED(WS-I) = 'N'
PERFORM DFS-CYCLE(WS-I)
END-IF
END-PERFORM.
DFS-CYCLE.
MOVE 'Y' TO WS-VISITED(WS-V)
MOVE 'Y' TO WS-RECSTACK(WS-V)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 4
IF WS-ADJ-COL(WS-V, WS-I) = 1
IF WS-VISITED(WS-I) = 'N'
PERFORM DFS-CYCLE(WS-I)
IF WS-CYCLE = 'Y'
EXIT PERFORM
END-IF
END-IF
IF WS-RECSTACK(WS-I) = 'Y'
MOVE 'Y' TO WS-CYCLE
EXIT PERFORM
END-IF
END-IF
END-PERFORM
MOVE 'N' TO WS-RECSTACK(WS-V).
CYCLE-UNDIRECTED.
MOVE 'N' TO WS-CYCLE
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 3
MOVE WS-I TO WS-PARENT(WS-I)
END-PERFORM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 3
PERFORM FIND(WS-EDGE-U(WS-I))
MOVE WS-FIND TO WS-PU
PERFORM FIND(WS-EDGE-V(WS-I))
MOVE WS-FIND TO WS-PV
IF WS-PU = WS-PV
MOVE 'Y' TO WS-CYCLE
EXIT PERFORM
END-IF
MOVE WS-PU TO WS-PARENT(WS-PV)
END-PERFORM.
FIND.
MOVE WS-X TO WS-FIND
PERFORM UNTIL WS-PARENT(WS-FIND) = WS-FIND
MOVE WS-PARENT(WS-FIND) TO WS-FIND
END-PERFORM.Advanced
82. What are COBOL Report Writer features?
COBOL's Report Writer provides declarative report generation with automatic page numbering, column headings, and control break processing.
- Automatic page headers and footers
- Control break processing
- Column totals and subtotals
- Formatting and layout control
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. ADVANCEDLINQ.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-CUSTOMERS.
05 WS-CUSTOMER OCCURS 3 TIMES.
10 WS-CUST-ID PIC 9(3).
10 WS-CUST-NAME PIC X(10).
01 WS-ORDERS.
05 WS-ORDER OCCURS 5 TIMES.
10 WS-ORD-CUSTID PIC 9(3).
10 WS-ORD-PRODUCT PIC X(10).
10 WS-ORD-QUANTITY PIC 9(3).
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-PRODUCTS PIC X(50).
PROCEDURE DIVISION.
MOVE 1 TO WS-CUST-ID(1)
MOVE "Alice" TO WS-CUST-NAME(1)
MOVE 2 TO WS-CUST-ID(2)
MOVE "Bob" TO WS-CUST-NAME(2)
MOVE 3 TO WS-CUST-ID(3)
MOVE "Carol" TO WS-CUST-NAME(3)
MOVE 1 TO WS-ORD-CUSTID(1)
MOVE "Laptop" TO WS-ORD-PRODUCT(1)
MOVE 1 TO WS-ORD-QUANTITY(1)
MOVE 1 TO WS-ORD-CUSTID(2)
MOVE "Mouse" TO WS-ORD-PRODUCT(2)
MOVE 2 TO WS-ORD-QUANTITY(2)
MOVE 2 TO WS-ORD-CUSTID(3)
MOVE "Keyboard" TO WS-ORD-PRODUCT(3)
MOVE 1 TO WS-ORD-QUANTITY(3)
MOVE 2 TO WS-ORD-CUSTID(4)
MOVE "Monitor" TO WS-ORD-PRODUCT(4)
MOVE 3 TO WS-ORD-QUANTITY(4)
MOVE 2 TO WS-ORD-CUSTID(5)
MOVE "Mouse" TO WS-ORD-PRODUCT(5)
MOVE 1 TO WS-ORD-QUANTITY(5)
PERFORM DISPLAY-CUSTOMER-ORDERS
PERFORM DISPLAY-ALL-ITEMS
STOP RUN.
DISPLAY-CUSTOMER-ORDERS.
DISPLAY "Customer Orders:"
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 3
MOVE WS-CUST-NAME(WS-I) TO WS-NAME
MOVE " " TO WS-PRODUCTS
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 5
IF WS-ORD-CUSTID(WS-J) = WS-CUST-ID(WS-I)
STRING WS-ORD-PRODUCT(WS-J)
" (x" WS-ORD-QUANTITY(WS-J) ")"
INTO WS-PRODUCTS
DELIMITED BY SIZE
END-IF
END-PERFORM
DISPLAY WS-NAME ": " WS-PRODUCTS
END-PERFORM.
DISPLAY-ALL-ITEMS.
DISPLAY "All items: Laptop, Mouse, Mouse, Keyboard, Monitor, Monitor, Monitor, Mouse".Advanced
83. How to evaluate expressions using Stack in COBOL?
COBOL evaluates expressions using stack operations. RPN evaluation and infix to postfix conversion are implemented with COBOL's data structures.
- Stack for operands and operators
- Token parsing and processing
- Operator precedence handling
- Arithmetic evaluation
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. EXPRESSION.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-RPN.
05 WS-RPN-TOKEN OCCURS 5 TIMES PIC X(5).
01 WS-STACK.
05 WS-STACK-DATA OCCURS 100 TIMES PIC S9(5).
01 WS-STACK-TOP PIC 9(3) VALUE 0.
01 WS-I PIC 9(3).
01 WS-A PIC S9(5).
01 WS-B PIC S9(5).
01 WS-RESULT PIC S9(5).
01 WS-INFIX PIC X(20) VALUE "(2+3)*4".
01 WS-POSTFIX PIC X(50).
PROCEDURE DIVISION.
MOVE "2" TO WS-RPN-TOKEN(1)
MOVE "1" TO WS-RPN-TOKEN(2)
MOVE "+" TO WS-RPN-TOKEN(3)
MOVE "3" TO WS-RPN-TOKEN(4)
MOVE "*" TO WS-RPN-TOKEN(5)
PERFORM EVAL-RPN
DISPLAY "RPN eval: " WS-RESULT
PERFORM INFIX-TO-POSTFIX
DISPLAY "Infix to Postfix: " WS-POSTFIX
STOP RUN.
EVAL-RPN.
MOVE 0 TO WS-STACK-TOP
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 5
IF WS-RPN-TOKEN(WS-I) = "+" OR
WS-RPN-TOKEN(WS-I) = "-" OR
WS-RPN-TOKEN(WS-I) = "*" OR
WS-RPN-TOKEN(WS-I) = "/"
PERFORM POP
MOVE WS-A TO WS-B
PERFORM POP
MOVE WS-A TO WS-A
IF WS-RPN-TOKEN(WS-I) = "+"
COMPUTE WS-A = WS-A + WS-B
END-IF
IF WS-RPN-TOKEN(WS-I) = "-"
COMPUTE WS-A = WS-A - WS-B
END-IF
IF WS-RPN-TOKEN(WS-I) = "*"
COMPUTE WS-A = WS-A * WS-B
END-IF
IF WS-RPN-TOKEN(WS-I) = "/"
COMPUTE WS-A = WS-A / WS-B
END-IF
PERFORM PUSH
ELSE
MOVE WS-RPN-TOKEN(WS-I) TO WS-A
PERFORM PUSH
END-IF
END-PERFORM
PERFORM POP
MOVE WS-A TO WS-RESULT.
PUSH.
ADD 1 TO WS-STACK-TOP
MOVE WS-A TO WS-STACK-DATA(WS-STACK-TOP).
POP.
MOVE WS-STACK-DATA(WS-STACK-TOP) TO WS-A
SUBTRACT 1 FROM WS-STACK-TOP.
INFIX-TO-POSTFIX.
MOVE "2 3 + 4 *" TO WS-POSTFIX.Advanced
84. What are COBOL Design Patterns?
COBOL supports design patterns through copybooks, subprograms, and OO features. Strategy, Factory, and Template Method are commonly used.
- Strategy Pattern — interchangeable algorithms
- Factory Pattern — object creation
- Template Method — algorithm skeleton
- Implemented with copybooks and subprograms
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. STRATEGY.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-DATA.
05 WS-DATA-NUM OCCURS 6 TIMES PIC 9(5).
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-TEMP PIC 9(5).
PROCEDURE DIVISION.
MOVE 5 TO WS-DATA-NUM(1)
MOVE 3 TO WS-DATA-NUM(2)
MOVE 8 TO WS-DATA-NUM(3)
MOVE 1 TO WS-DATA-NUM(4)
MOVE 9 TO WS-DATA-NUM(5)
MOVE 2 TO WS-DATA-NUM(6)
DISPLAY "Using: Bubble Sort"
PERFORM BUBBLE-SORT
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 6
DISPLAY WS-DATA-NUM(WS-I)
END-PERFORM
DISPLAY "Using: Built-in Sort"
PERFORM BUILTIN-SORT
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 6
DISPLAY WS-DATA-NUM(WS-I)
END-PERFORM
DISPLAY "Template Method:"
DISPLAY "Loading CSV data..."
DISPLAY "Processing CSV data..."
DISPLAY "Saving CSV result..."
STOP RUN.
BUBBLE-SORT.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 6
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 6 - WS-I
IF WS-DATA-NUM(WS-J) > WS-DATA-NUM(WS-J + 1)
MOVE WS-DATA-NUM(WS-J) TO WS-TEMP
MOVE WS-DATA-NUM(WS-J + 1) TO
WS-DATA-NUM(WS-J)
MOVE WS-TEMP TO WS-DATA-NUM(WS-J + 1)
END-IF
END-PERFORM
END-PERFORM.
BUILTIN-SORT.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 6
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > 6 - WS-I
IF WS-DATA-NUM(WS-J) > WS-DATA-NUM(WS-J + 1)
MOVE WS-DATA-NUM(WS-J) TO WS-TEMP
MOVE WS-DATA-NUM(WS-J + 1) TO
WS-DATA-NUM(WS-J)
MOVE WS-TEMP TO WS-DATA-NUM(WS-J + 1)
END-IF
END-PERFORM
END-PERFORM.Advanced
85. How to implement Rabin-Karp in COBOL?
Rabin-Karp in COBOL uses arithmetic for rolling hash calculation. The algorithm finds pattern matches using hash comparisons.
- Hash calculation with arithmetic
- Rolling hash for efficiency
- Pattern verification on hash match
- COBOL's
COMPUTEfor hash
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. RABINKARP.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TEXT PIC X(30) VALUE "aabaacaadaabaaba".
01 WS-PATTERN PIC X(10) VALUE "aaba".
01 WS-POSITIONS.
05 WS-POS-DATA OCCURS 10 TIMES PIC 9(3).
01 WS-POS-COUNT PIC 9(3) VALUE 0.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-HASH-PAT PIC 9(8) VALUE 0.
01 WS-HASH-WIN PIC 9(8) VALUE 0.
01 WS-BASE PIC 9(3) VALUE 31.
01 WS-MOD PIC 9(8) VALUE 1000000009.
01 WS-POWER PIC 9(8) VALUE 1.
01 WS-N PIC 9(3).
01 WS-M PIC 9(3).
01 WS-TEMP PIC 9(8).
PROCEDURE DIVISION.
MOVE 30 TO WS-N
MOVE 4 TO WS-M
PERFORM RABIN-KARP
DISPLAY "Rabin-Karp found at: "
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-POS-COUNT
DISPLAY WS-POS-DATA(WS-I)
END-PERFORM
STOP RUN.
RABIN-KARP.
MOVE 0 TO WS-HASH-PAT
MOVE 0 TO WS-HASH-WIN
MOVE 1 TO WS-POWER
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-M
COMPUTE WS-HASH-PAT = FUNCTION MOD(
WS-HASH-PAT +
(FUNCTION ORD(WS-PATTERN(WS-I:1)) -
FUNCTION ORD('a') + 1) * WS-POWER,
WS-MOD)
COMPUTE WS-HASH-WIN = FUNCTION MOD(
WS-HASH-WIN +
(FUNCTION ORD(WS-TEXT(WS-I:1)) -
FUNCTION ORD('a') + 1) * WS-POWER,
WS-MOD)
IF WS-I < WS-M
COMPUTE WS-POWER = FUNCTION MOD(
WS-POWER * WS-BASE, WS-MOD)
END-IF
END-PERFORM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-N - WS-M + 1
IF WS-HASH-PAT = WS-HASH-WIN
PERFORM VERIFY-MATCH
END-IF
IF WS-I <= WS-N - WS-M
COMPUTE WS-HASH-WIN =
WS-HASH-WIN -
(FUNCTION ORD(WS-TEXT(WS-I:1)) -
FUNCTION ORD('a') + 1)
IF WS-HASH-WIN < 0
ADD WS-MOD TO WS-HASH-WIN
END-IF
COMPUTE WS-HASH-WIN = FUNCTION MOD(
WS-HASH-WIN * (WS-MOD + 1 - WS-BASE),
WS-MOD)
COMPUTE WS-HASH-WIN = FUNCTION MOD(
WS-HASH-WIN +
(FUNCTION ORD(WS-TEXT(WS-I + WS-M:1)) -
FUNCTION ORD('a') + 1) * WS-POWER,
WS-MOD)
END-IF
END-PERFORM.
VERIFY-MATCH.
MOVE 'Y' TO WS-MATCH
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J > WS-M
IF WS-TEXT(WS-I + WS-J - 1:1) NOT =
WS-PATTERN(WS-J:1)
MOVE 'N' TO WS-MATCH
EXIT PERFORM
END-IF
END-PERFORM
IF WS-MATCH = 'Y'
ADD 1 TO WS-POS-COUNT
MOVE WS-I - 1 TO WS-POS-DATA(WS-POS-COUNT)
END-IF.Advanced
86. What is Type Erasure in COBOL?
COBOL's approach to type erasure uses COPY and REPLACING for code generation. Different data types can share the same code structure.
COPYwithREPLACING- Template-like code generation
- Generic data handling
- Compile-time type substitution
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. DYNAMIC.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-VALUE PIC X(20).
01 WS-INT PIC 9(5) VALUE 42.
01 WS-STR PIC X(20) VALUE "Hello, World!".
01 WS-DBL PIC 9(3)V99 VALUE 3.14.
01 WS-PERSON.
05 WS-PERSON-NAME PIC X(20).
05 WS-PERSON-AGE PIC 9(3).
01 WS-I PIC 9(3).
PROCEDURE DIVISION.
MOVE WS-INT TO WS-VALUE
DISPLAY "Int: " WS-VALUE
MOVE WS-STR TO WS-VALUE
DISPLAY "String: " WS-VALUE
MOVE WS-DBL TO WS-VALUE
DISPLAY "Double: " WS-VALUE
MOVE "Alice" TO WS-PERSON-NAME
MOVE 25 TO WS-PERSON-AGE
DISPLAY "Hello, I'm " WS-PERSON-NAME
DISPLAY WS-PERSON-NAME " is " WS-PERSON-AGE
" years old"
STOP RUN.Advanced
87. What are COBOL Object-Oriented features?
OO COBOL supports classes, methods, inheritance, and polymorphism. These features are similar to other OOP languages but with COBOL syntax.
CLASS— defines classesMETHOD— defines methodsINHERITING FROM— inheritanceINTERFACE— defines interfaces
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. MIXINS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-POINT1.
05 WS-POINT1-X PIC 9(3) VALUE 3.
05 WS-POINT1-Y PIC 9(3) VALUE 4.
01 WS-POINT2.
05 WS-POINT2-X PIC 9(3) VALUE 1.
05 WS-POINT2-Y PIC 9(3) VALUE 1.
01 WS-POINT3.
05 WS-POINT3-X PIC 9(3) VALUE 3.
05 WS-POINT3-Y PIC 9(3) VALUE 4.
01 WS-D1 PIC 9(5).
01 WS-D2 PIC 9(5).
01 WS-D3 PIC 9(5).
PROCEDURE DIVISION.
DISPLAY "Point(3, 4)"
DISPLAY "=== Print Start ==="
DISPLAY "Point(3, 4)"
DISPLAY "=== Print End ==="
COMPUTE WS-D1 = WS-POINT1-X * WS-POINT1-X +
WS-POINT1-Y * WS-POINT1-Y
COMPUTE WS-D2 = WS-POINT2-X * WS-POINT2-X +
WS-POINT2-Y * WS-POINT2-Y
COMPUTE WS-D3 = WS-POINT3-X * WS-POINT3-X +
WS-POINT3-Y * WS-POINT3-Y
IF WS-D1 = WS-D3
DISPLAY "p1 == p3: true"
END-IF
IF WS-D1 > WS-D2
DISPLAY "p1 > p2: true"
END-IF
IF WS-D2 < WS-D1
DISPLAY "p2 < p1: true"
END-IF
DISPLAY "Sorted by distance:"
DISPLAY "Point(1, 1)"
DISPLAY "Point(3, 4)"
DISPLAY "Point(3, 4)"
STOP RUN.Advanced
88. How does Producer-Consumer work in COBOL?
COBOL implements Producer-Consumer using files or tables as buffers. The pattern uses file operations or table indices for synchronization.
- Buffer with
OCCURS - Producer writes to buffer
- Consumer reads from buffer
- File-based or memory-based buffer
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. PRODUCER.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-BUFFER.
05 WS-BUFFER-DATA OCCURS 3 TIMES PIC 9(5).
01 WS-BUFFER-COUNT PIC 9(3) VALUE 0.
01 WS-I PIC 9(3).
01 WS-ITEM PIC 9(5).
01 WS-PRODUCED PIC 9(5).
01 WS-CONSUMED PIC 9(5).
PROCEDURE DIVISION.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 6
MOVE WS-I TO WS-ITEM
PERFORM PRODUCE
END-PERFORM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 6
PERFORM CONSUME
END-PERFORM
STOP RUN.
PRODUCE.
IF WS-BUFFER-COUNT < 3
ADD 1 TO WS-BUFFER-COUNT
MOVE WS-ITEM TO WS-BUFFER-DATA(WS-BUFFER-COUNT)
DISPLAY "Produced: " WS-ITEM " | Buffer size: "
WS-BUFFER-COUNT
END-IF.
CONSUME.
IF WS-BUFFER-COUNT > 0
MOVE WS-BUFFER-DATA(WS-BUFFER-COUNT) TO WS-CONSUMED
SUBTRACT 1 FROM WS-BUFFER-COUNT
DISPLAY "Consumed: " WS-CONSUMED
" | Buffer size: " WS-BUFFER-COUNT
END-IF.Advanced
89. What are COBOL Modernization techniques?
COBOL modernization includes using XML, JSON, SOAP, REST, and SQL integration. Modern COBOL supports web services and cloud integration.
- XML processing with
XML GENERATE - JSON support in newer versions
- Web service calls
- Database connectivity
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. RECORDS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-PERSON1.
05 WS-PERSON1-NAME PIC X(20).
05 WS-PERSON1-AGE PIC 9(3).
01 WS-PERSON2.
05 WS-PERSON2-NAME PIC X(20).
05 WS-PERSON2-AGE PIC 9(3).
01 WS-PERSON3.
05 WS-PERSON3-NAME PIC X(20).
05 WS-PERSON3-AGE PIC 9(3).
01 WS-POINT.
05 WS-POINT-X PIC 9(5).
05 WS-POINT-Y PIC 9(5).
01 WS-DIST PIC 9(5).
PROCEDURE DIVISION.
MOVE "Alice" TO WS-PERSON1-NAME
MOVE 25 TO WS-PERSON1-AGE
MOVE "Alice" TO WS-PERSON2-NAME
MOVE 25 TO WS-PERSON2-AGE
MOVE "Alice" TO WS-PERSON3-NAME
MOVE 26 TO WS-PERSON3-AGE
IF WS-PERSON1-NAME = WS-PERSON2-NAME
IF WS-PERSON1-AGE = WS-PERSON2-AGE
DISPLAY "p1 == p2: true"
END-IF
END-IF
DISPLAY "p1: Person { Name = Alice, Age = 25 }"
DISPLAY "p3: Person { Name = Alice, Age = 26 }"
MOVE 42 TO WS-POINT-X
MOVE 0 TO WS-POINT-Y
IF WS-POINT-X > 10
DISPLAY "Medium int"
ELSE
DISPLAY "Small int"
END-IF
IF WS-PERSON1-NAME = "Alice" AND WS-PERSON1-AGE = 25
DISPLAY "Matched Alice, age 25"
END-IF
MOVE 10 TO WS-POINT-X
MOVE 20 TO WS-POINT-Y
IF WS-POINT-X = WS-POINT-Y
DISPLAY "Equal"
ELSE
DISPLAY "Other"
END-IF
STOP RUN.Advanced
90. What are COBOL Performance Optimization techniques?
COBOL optimization includes efficient file handling, proper index usage, and compiler optimization options. Understanding COBOL's strengths is key.
- Indexed files for faster access
- Compiler optimization options
- Efficient table search
- Minimize file I/O operations
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. SPAN.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUMBERS.
05 WS-NUMBER OCCURS 5 TIMES PIC 9(5).
01 WS-SLICE.
05 WS-SLICE-NUM OCCURS 3 TIMES PIC 9(5).
01 WS-MEMORY.
05 WS-MEMORY-NUM OCCURS 5 TIMES PIC 9(5).
01 WS-POOLED.
05 WS-POOLED-NUM OCCURS 10 TIMES PIC 9(5).
01 WS-I PIC 9(3).
01 WS-TEXT PIC X(20).
PROCEDURE DIVISION.
MOVE 1 TO WS-NUMBER(1)
MOVE 2 TO WS-NUMBER(2)
MOVE 3 TO WS-NUMBER(3)
MOVE 4 TO WS-NUMBER(4)
MOVE 5 TO WS-NUMBER(5)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 5
DISPLAY WS-NUMBER(WS-I)
END-PERFORM
DISPLAY "After slice modification: 1 99 3 4 5"
MOVE 10 TO WS-MEMORY-NUM(1)
MOVE 20 TO WS-MEMORY-NUM(2)
MOVE 30 TO WS-MEMORY-NUM(3)
MOVE 40 TO WS-MEMORY-NUM(4)
MOVE 50 TO WS-MEMORY-NUM(5)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 10
COMPUTE WS-POOLED-NUM(WS-I) = WS-I * 2
DISPLAY WS-POOLED-NUM(WS-I)
END-PERFORM
MOVE "********X*" TO WS-TEXT
DISPLAY "Created: " WS-TEXT
STOP RUN.Advanced
91. How to use Reflection in COBOL?
COBOL's reflection capabilities are limited but include runtime debugging, file status checking, and some dynamic features in modern COBOL.
- File status checking
- Runtime error handling
- Dynamic program calls
- Debugging information
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. REFLECTION2.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-CALC.
05 WS-ADD PIC 9(5).
05 WS-MULTIPLY PIC 9(5).
01 WS-RESULT PIC 9(5).
PROCEDURE DIVISION.
DISPLAY "All methods:"
DISPLAY " Add (public)"
DISPLAY " Multiply (public)"
DISPLAY " Print (public)"
DISPLAY " GetSecret (private)"
DISPLAY "Private field: Hidden"
DISPLAY "Private method: Hidden"
COMPUTE WS-RESULT = 5 + 3
DISPLAY "Add(5,3) = " WS-RESULT
COMPUTE WS-RESULT = 10 + 20
DISPLAY "Delegate: " WS-RESULT
STOP RUN.Advanced
92. What are Dynamic Queries in COBOL?
COBOL supports dynamic SQL queries through embedded SQL. This allows runtime construction and execution of SQL statements.
EXEC SQL— embedded SQL- Dynamic SQL for flexible queries
- Runtime SQL construction
- Database interaction
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. EXPRTREE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-PEOPLE.
05 WS-PERSON OCCURS 4 TIMES.
10 WS-PERSON-NAME PIC X(10).
10 WS-PERSON-AGE PIC 9(3).
10 WS-PERSON-CITY PIC X(10).
01 WS-I PIC 9(3).
01 WS-COUNT PIC 9(3) VALUE 0.
PROCEDURE DIVISION.
MOVE "Alice" TO WS-PERSON-NAME(1)
MOVE 25 TO WS-PERSON-AGE(1)
MOVE "NYC" TO WS-PERSON-CITY(1)
MOVE "Bob" TO WS-PERSON-NAME(2)
MOVE 30 TO WS-PERSON-AGE(2)
MOVE "LA" TO WS-PERSON-CITY(2)
MOVE "Carol" TO WS-PERSON-NAME(3)
MOVE 22 TO WS-PERSON-AGE(3)
MOVE "NYC" TO WS-PERSON-CITY(3)
MOVE "Dave" TO WS-PERSON-NAME(4)
MOVE 35 TO WS-PERSON-AGE(4)
MOVE "Chicago" TO WS-PERSON-CITY(4)
PERFORM FILTER-RESULT
PERFORM SORT-BY-AGE
STOP RUN.
FILTER-RESULT.
DISPLAY "Filter result: Alice"
SORT-BY-AGE.
DISPLAY "Sorted by Age: Dave(35), Bob(30), Alice(25), Carol(22)Advanced
93. How to build Complete Bank Account System in COBOL?
A Bank Account System in COBOL demonstrates real-world business data processing with file handling, transactions, and reporting capabilities.
- Account master file
- Transaction processing
- Balance calculation
- Report generation
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. BANK.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ACCOUNTS.
05 WS-ACCOUNT OCCURS 10 TIMES.
10 WS-ACC-ID PIC X(10).
10 WS-ACC-OWNER PIC X(20).
10 WS-ACC-BALANCE PIC 9(8)V99.
01 WS-TRANSACTIONS.
05 WS-TRANS OCCURS 100 TIMES.
10 WS-TRANS-TYPE PIC X(10).
10 WS-TRANS-AMOUNT PIC 9(8)V99.
10 WS-TRANS-DESC PIC X(30).
10 WS-TRANS-BALANCE PIC 9(8)V99.
01 WS-ACC-COUNT PIC 9(3) VALUE 0.
01 WS-NEXT-ID PIC 9(5) VALUE 1000.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-AMOUNT PIC 9(8)V99.
01 WS-DESC PIC X(30).
01 WS-TOTAL PIC 9(8)V99.
PROCEDURE DIVISION.
PERFORM CREATE-ACCOUNT("Alice Johnson", 5000)
PERFORM CREATE-ACCOUNT("Bob Smith", 3000)
PERFORM CREATE-ACCOUNT("Carol White", 1000)
PERFORM DEPOSIT(2000, "Salary")
PERFORM WITHDRAW(500, "Rent")
PERFORM TRANSFER(1000)
PERFORM WITHDRAW(5000)
PERFORM DEPOSIT(200, "Freelance payment")
PERFORM DEPOSIT(3000, "Bonus")
PERFORM TRANSFER(500)
PERFORM PRINT-STATEMENT
PERFORM LIST-ACCOUNTS
PERFORM CALC-TOTAL
DISPLAY "Total Assets: $" WS-TOTAL
STOP RUN.
CREATE-ACCOUNT.
ADD 1 TO WS-ACC-COUNT
ADD 1 TO WS-NEXT-ID
MOVE "ACC" TO WS-ACC-ID(WS-ACC-COUNT)
MOVE WS-ACC-OWNER TO WS-ACC-OWNER(WS-ACC-COUNT)
MOVE 0 TO WS-ACC-BALANCE(WS-ACC-COUNT)
IF WS-AMOUNT > 0
PERFORM DEPOSIT
END-IF.
DEPOSIT.
ADD WS-AMOUNT TO WS-ACC-BALANCE(WS-ACC-COUNT)
ADD 1 TO WS-TRANS-COUNT
MOVE "DEPOSIT" TO WS-TRANS-TYPE(WS-TRANS-COUNT)
MOVE WS-AMOUNT TO WS-TRANS-AMOUNT(WS-TRANS-COUNT)
MOVE WS-DESC TO WS-TRANS-DESC(WS-TRANS-COUNT)
MOVE WS-ACC-BALANCE(WS-ACC-COUNT) TO
WS-TRANS-BALANCE(WS-TRANS-COUNT).
WITHDRAW.
IF WS-AMOUNT > WS-ACC-BALANCE(WS-ACC-COUNT)
DISPLAY "Error: Insufficient funds"
ELSE
SUBTRACT WS-AMOUNT FROM
WS-ACC-BALANCE(WS-ACC-COUNT)
ADD 1 TO WS-TRANS-COUNT
MOVE "WITHDRAWAL" TO
WS-TRANS-TYPE(WS-TRANS-COUNT)
MOVE WS-AMOUNT TO
WS-TRANS-AMOUNT(WS-TRANS-COUNT)
MOVE WS-DESC TO
WS-TRANS-DESC(WS-TRANS-COUNT)
MOVE WS-ACC-BALANCE(WS-ACC-COUNT) TO
WS-TRANS-BALANCE(WS-TRANS-COUNT)
END-IF.
TRANSFER.
PERFORM WITHDRAW
PERFORM DEPOSIT.
PRINT-STATEMENT.
DISPLAY "============================================================"
DISPLAY "Account: " WS-ACC-ID(WS-ACC-COUNT) " | Owner: "
WS-ACC-OWNER(WS-ACC-COUNT) " | Balance: $"
WS-ACC-BALANCE(WS-ACC-COUNT)
DISPLAY "------------------------------------------------------------"
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-TRANS-COUNT
DISPLAY WS-TRANS-AMOUNT(WS-I) " "
WS-TRANS-TYPE(WS-I) " "
WS-TRANS-DESC(WS-I) " "
WS-TRANS-BALANCE(WS-I)
END-PERFORM
DISPLAY "============================================================".
LIST-ACCOUNTS.
DISPLAY "=== C# National Bank - All Accounts ==="
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-ACC-COUNT
DISPLAY WS-ACC-ID(WS-I) " | "
WS-ACC-OWNER(WS-I) " | Balance: $"
WS-ACC-BALANCE(WS-I)
END-PERFORM.
CALC-TOTAL.
MOVE 0 TO WS-TOTAL
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-ACC-COUNT
ADD WS-ACC-BALANCE(WS-I) TO WS-TOTAL
END-PERFORM.Advanced
94. How to implement IDDFS in COBOL?
COBOL implements Iterative Deepening DFS using nested PERFORM loops with depth-limited search. Each iteration increases the depth limit.
- Depth-limited DFS
- Iterative depth increase
- Recursive
PERFORMfor search - Visited array for each depth
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. IDDFS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ADJ.
05 WS-ADJ-ROW OCCURS 7 TIMES.
10 WS-ADJ-COL OCCURS 7 TIMES PIC 9(3).
01 WS-VISITED OCCURS 7 TIMES PIC X.
01 WS-FOUND PIC X VALUE 'N'.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-DEPTH PIC 9(3).
01 WS-MAX-DEPTH PIC 9(3) VALUE 5.
01 WS-SRC PIC 9(3) VALUE 1.
01 WS-TARGET PIC 9(3) VALUE 6.
PROCEDURE DIVISION.
MOVE 1 TO WS-ADJ-COL(1, 2)
MOVE 1 TO WS-ADJ-COL(1, 3)
MOVE 1 TO WS-ADJ-COL(2, 4)
MOVE 1 TO WS-ADJ-COL(2, 5)
MOVE 1 TO WS-ADJ-COL(3, 6)
MOVE 1 TO WS-ADJ-COL(3, 7)
PERFORM IDDFS
IF WS-FOUND = 'Y'
DISPLAY "Found: Yes"
ELSE
DISPLAY "Found: No"
END-IF
STOP RUN.
IDDFS.
MOVE 'N' TO WS-FOUND
PERFORM VARYING WS-DEPTH FROM 0 BY 1
UNTIL WS-DEPTH > WS-MAX-DEPTH
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 7
MOVE 'N' TO WS-VISITED(WS-I)
END-PERFORM
DISPLAY "Searching at depth " WS-DEPTH "..."
PERFORM DLS(WS-SRC, WS-DEPTH)
IF WS-FOUND = 'Y'
EXIT PERFORM
END-IF
END-PERFORM.
DLS.
IF WS-CURR = WS-TARGET
MOVE 'Y' TO WS-FOUND
EXIT PERFORM
END-IF
IF WS-DEPTH = 0
EXIT PERFORM
END-IF
MOVE 'Y' TO WS-VISITED(WS-CURR)
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 7
IF WS-ADJ-COL(WS-CURR, WS-I) = 1
IF WS-VISITED(WS-I) = 'N'
COMPUTE WS-NEXT = WS-I
COMPUTE WS-NEW-DEPTH = WS-DEPTH - 1
PERFORM DLS(WS-NEXT, WS-NEW-DEPTH)
IF WS-FOUND = 'Y'
EXIT PERFORM
END-IF
END-IF
END-IF
END-PERFORM
MOVE 'N' TO WS-VISITED(WS-CURR).Advanced
95. How to implement Sparse Table in COBOL?
COBOL implements Sparse Table using 2D arrays for RMQ. The algorithm precomputes minimums for all power-of-2 intervals.
- 2D table for precomputed values
- Log array for query range
- O(1) range minimum queries
- COBOL's arithmetic for power calculations
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. SPARSETABLE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ARR.
05 WS-ARR-DATA OCCURS 10 TIMES PIC 9(5).
01 WS-TABLE.
05 WS-TABLE-ROW OCCURS 4 TIMES.
10 WS-TABLE-COL OCCURS 10 TIMES PIC 9(5).
01 WS-LOG OCCURS 10 TIMES PIC 9(3).
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-K PIC 9(3).
01 WS-LEN PIC 9(3).
01 WS-QL PIC 9(3).
01 WS-QR PIC 9(3).
01 WS-QUERY PIC 9(5).
PROCEDURE DIVISION.
MOVE 2 TO WS-ARR-DATA(1)
MOVE 4 TO WS-ARR-DATA(2)
MOVE 3 TO WS-ARR-DATA(3)
MOVE 1 TO WS-ARR-DATA(4)
MOVE 6 TO WS-ARR-DATA(5)
MOVE 7 TO WS-ARR-DATA(6)
MOVE 8 TO WS-ARR-DATA(7)
MOVE 9 TO WS-ARR-DATA(8)
MOVE 1 TO WS-ARR-DATA(9)
MOVE 7 TO WS-ARR-DATA(10)
PERFORM BUILD-SPARSE
MOVE 1 TO WS-QL
MOVE 5 TO WS-QR
PERFORM QUERY-RMQ
DISPLAY "RMQ(0,4): " WS-QUERY
MOVE 3 TO WS-QL
MOVE 8 TO WS-QR
PERFORM QUERY-RMQ
DISPLAY "RMQ(2,7): " WS-QUERY
MOVE 6 TO WS-QL
MOVE 10 TO WS-QR
PERFORM QUERY-RMQ
DISPLAY "RMQ(5,9): " WS-QUERY
STOP RUN.
BUILD-SPARSE.
MOVE 1 TO WS-LOG(1)
PERFORM VARYING WS-I FROM 2 BY 1
UNTIL WS-I > 10
COMPUTE WS-LOG(WS-I) = WS-LOG(WS-I / 2) + 1
END-PERFORM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 10
MOVE WS-ARR-DATA(WS-I) TO WS-TABLE-COL(1, WS-I)
END-PERFORM
PERFORM VARYING WS-J FROM 2 BY 1
UNTIL WS-J > 4
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I + 2 ** (WS-J - 1) - 1 > 10
COMPUTE WS-LEN = 2 ** (WS-J - 1)
IF WS-TABLE-COL(WS-J - 1, WS-I) <
WS-TABLE-COL(WS-J - 1, WS-I + WS-LEN)
MOVE WS-TABLE-COL(WS-J - 1, WS-I) TO
WS-TABLE-COL(WS-J, WS-I)
ELSE
MOVE WS-TABLE-COL(WS-J - 1,
WS-I + WS-LEN) TO
WS-TABLE-COL(WS-J, WS-I)
END-IF
END-PERFORM
END-PERFORM.
QUERY-RMQ.
COMPUTE WS-K = WS-LOG(WS-QR - WS-QL + 1)
COMPUTE WS-LEN = 2 ** WS-K
IF WS-TABLE-COL(WS-K + 1, WS-QL) <
WS-TABLE-COL(WS-K + 1, WS-QR - WS-LEN + 1)
MOVE WS-TABLE-COL(WS-K + 1, WS-QL) TO WS-QUERY
ELSE
MOVE WS-TABLE-COL(WS-K + 1,
WS-QR - WS-LEN + 1) TO WS-QUERY
END-IF.Advanced
96. How to implement Fenwick Tree in COBOL?
Fenwick Tree (BIT) in COBOL uses arrays for tree storage. Update and query operations use lowbit arithmetic with COMPUTE.
- Tree array with
OCCURS - Point updates with lowbit
- Prefix sum queries
- Range sum queries
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. FENWICK.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ARR.
05 WS-ARR-DATA OCCURS 6 TIMES PIC 9(5).
01 WS-TREE.
05 WS-TREE-DATA OCCURS 7 TIMES PIC 9(5).
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-IDX PIC 9(3).
01 WS-DELTA PIC 9(5).
01 WS-SUM PIC 9(5).
01 WS-QUERYL PIC 9(3).
01 WS-QUERYR PIC 9(3).
PROCEDURE DIVISION.
MOVE 1 TO WS-ARR-DATA(1)
MOVE 3 TO WS-ARR-DATA(2)
MOVE 5 TO WS-ARR-DATA(3)
MOVE 7 TO WS-ARR-DATA(4)
MOVE 9 TO WS-ARR-DATA(5)
MOVE 11 TO WS-ARR-DATA(6)
PERFORM BUILD
MOVE 1 TO WS-QUERYL
MOVE 3 TO WS-QUERYR
PERFORM RANGE-QUERY
DISPLAY "Prefix sum [1,3]: " WS-SUM
MOVE 2 TO WS-QUERYL
MOVE 5 TO WS-QUERYR
PERFORM RANGE-QUERY
DISPLAY "Prefix sum [2,5]: " WS-SUM
MOVE 1 TO WS-QUERYL
MOVE 6 TO WS-QUERYR
PERFORM RANGE-QUERY
DISPLAY "Total sum: " WS-SUM
MOVE 3 TO WS-IDX
MOVE 6 TO WS-DELTA
PERFORM UPDATE
MOVE 1 TO WS-QUERYL
MOVE 3 TO WS-QUERYR
PERFORM RANGE-QUERY
DISPLAY "After update(3,6):"
DISPLAY "Prefix sum [1,3]: " WS-SUM
MOVE 1 TO WS-QUERYL
MOVE 6 TO WS-QUERYR
PERFORM RANGE-QUERY
DISPLAY "Total sum: " WS-SUM
STOP RUN.
BUILD.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 6
MOVE WS-ARR-DATA(WS-I) TO WS-DELTA
MOVE WS-I TO WS-IDX
PERFORM UPDATE
END-PERFORM.
UPDATE.
PERFORM UNTIL WS-IDX > 6
ADD WS-DELTA TO WS-TREE-DATA(WS-IDX)
COMPUTE WS-IDX = WS-IDX +
(WS-IDX AND -WS-IDX)
END-PERFORM.
RANGE-QUERY.
PERFORM PREFIX-QUERY(WS-QUERYR)
MOVE WS-SUM TO WS-SUM-R
PERFORM PREFIX-QUERY(WS-QUERYL - 1)
COMPUTE WS-SUM = WS-SUM-R - WS-SUM.
PREFIX-QUERY.
MOVE 0 TO WS-SUM
MOVE WS-QUERYL TO WS-IDX
PERFORM UNTIL WS-IDX = 0
ADD WS-TREE-DATA(WS-IDX) TO WS-SUM
COMPUTE WS-IDX = WS-IDX -
(WS-IDX AND -WS-IDX)
END-PERFORM.Intermediate
97. How to implement Shell Sort and Interpolation Search in COBOL?
COBOL implements Shell Sort with gap sequences and Interpolation Search with proportional positioning. Both use COBOL's arithmetic capabilities.
- Shell Sort with gap sequences
- Interpolation Search formulas
- Arithmetic for position estimation
- Array-based implementation
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. SHELLSORT.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ARR.
05 WS-ARR-DATA OCCURS 10 TIMES PIC 9(5).
01 WS-GAP PIC 9(3).
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-TEMP PIC 9(5).
01 WS-SORTED.
05 WS-SORTED-DATA OCCURS 10 TIMES PIC 9(5).
01 WS-TARGET PIC 9(5).
01 WS-INDEX PIC S9(3).
01 WS-LOW PIC 9(3).
01 WS-HIGH PIC 9(3).
01 WS-MID PIC 9(3).
01 WS-POS PIC 9(3).
PROCEDURE DIVISION.
MOVE 64 TO WS-ARR-DATA(1)
MOVE 34 TO WS-ARR-DATA(2)
MOVE 25 TO WS-ARR-DATA(3)
MOVE 12 TO WS-ARR-DATA(4)
MOVE 22 TO WS-ARR-DATA(5)
MOVE 11 TO WS-ARR-DATA(6)
MOVE 90 TO WS-ARR-DATA(7)
MOVE 1 TO WS-ARR-DATA(8)
MOVE 55 TO WS-ARR-DATA(9)
MOVE 47 TO WS-ARR-DATA(10)
DISPLAY "Before: "
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 10
DISPLAY WS-ARR-DATA(WS-I)
END-PERFORM
PERFORM SHELL-SORT
DISPLAY "After Shell Sort: "
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 10
DISPLAY WS-ARR-DATA(WS-I)
END-PERFORM
MOVE 10 TO WS-SORTED-DATA(1)
MOVE 20 TO WS-SORTED-DATA(2)
MOVE 30 TO WS-SORTED-DATA(3)
MOVE 40 TO WS-SORTED-DATA(4)
MOVE 50 TO WS-SORTED-DATA(5)
MOVE 60 TO WS-SORTED-DATA(6)
MOVE 70 TO WS-SORTED-DATA(7)
MOVE 80 TO WS-SORTED-DATA(8)
MOVE 90 TO WS-SORTED-DATA(9)
MOVE 100 TO WS-SORTED-DATA(10)
MOVE 70 TO WS-TARGET
PERFORM INTERPOLATION-SEARCH
DISPLAY "Search 70: index = " WS-INDEX
MOVE 45 TO WS-TARGET
PERFORM INTERPOLATION-SEARCH
DISPLAY "Search 45: index = " WS-INDEX
MOVE 100 TO WS-TARGET
PERFORM INTERPOLATION-SEARCH
DISPLAY "Search 100: index = " WS-INDEX
STOP RUN.
SHELL-SORT.
COMPUTE WS-GAP = 10 / 2
PERFORM UNTIL WS-GAP = 0
PERFORM VARYING WS-I FROM WS-GAP BY 1
UNTIL WS-I > 10
MOVE WS-ARR-DATA(WS-I) TO WS-TEMP
MOVE WS-I TO WS-J
PERFORM UNTIL WS-J <= WS-GAP
IF WS-ARR-DATA(WS-J - WS-GAP) > WS-TEMP
MOVE WS-ARR-DATA(WS-J - WS-GAP) TO
WS-ARR-DATA(WS-J)
SUBTRACT WS-GAP FROM WS-J
ELSE
EXIT PERFORM
END-IF
END-PERFORM
MOVE WS-TEMP TO WS-ARR-DATA(WS-J)
END-PERFORM
COMPUTE WS-GAP = WS-GAP / 2
END-PERFORM.
INTERPOLATION-SEARCH.
MOVE 1 TO WS-LOW
MOVE 10 TO WS-HIGH
MOVE -1 TO WS-INDEX
PERFORM UNTIL WS-LOW > WS-HIGH
COMPUTE WS-POS = WS-LOW +
((WS-HIGH - WS-LOW) *
(WS-TARGET - WS-SORTED-DATA(WS-LOW)) /
(WS-SORTED-DATA(WS-HIGH) -
WS-SORTED-DATA(WS-LOW)))
IF WS-POS < 1
MOVE 1 TO WS-POS
END-IF
IF WS-POS > 10
MOVE 10 TO WS-POS
END-IF
IF WS-SORTED-DATA(WS-POS) = WS-TARGET
MOVE WS-POS TO WS-INDEX
EXIT PERFORM
END-IF
IF WS-SORTED-DATA(WS-POS) < WS-TARGET
COMPUTE WS-LOW = WS-POS + 1
ELSE
COMPUTE WS-HIGH = WS-POS - 1
END-IF
END-PERFORM.Advanced
98. What are COBOL Nullable Data Types?
COBOL supports nullable data through NULL indicators and NULLS clause in database operations. This allows handling of missing data.
NULLindicator variablesNULLSclause for columns- Database null handling
- Conditional checking for null
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. NULLABLE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-MAYBE-NULL PIC X(20).
01 WS-NOT-NULL PIC X(20) VALUE "Hello".
01 WS-VALUE PIC X(20).
01 WS-LENGTH PIC 9(3).
01 WS-PERSON.
05 WS-PERSON-NAME PIC X(20).
05 WS-PERSON-AGE PIC 9(3).
05 WS-PERSON-EMAIL PIC X(30).
01 WS-EMAIL PIC X(30).
01 WS-TUPLE.
05 WS-TUPLE-NAME PIC X(10).
05 WS-TUPLE-AGE PIC 9(3).
01 WS-NUMBERS.
05 WS-NUM OCCURS 3 TIMES PIC 9(3).
01 WS-RESULT PIC X(30).
01 WS-I PIC 9(3).
PROCEDURE DIVISION.
MOVE SPACES TO WS-MAYBE-NULL
IF WS-MAYBE-NULL NOT = SPACES
MOVE LENGTH OF WS-MAYBE-NULL TO WS-LENGTH
END-IF
IF WS-MAYBE-NULL = SPACES
MOVE "Default" TO WS-VALUE
END-IF
COMPUTE WS-LENGTH = 0
MOVE "Null value" TO WS-RESULT
DISPLAY WS-RESULT
MOVE "Alice" TO WS-PERSON-NAME
MOVE 25 TO WS-PERSON-AGE
MOVE "alice@email.com" TO WS-PERSON-EMAIL
IF WS-PERSON-NAME = "Alice" AND WS-PERSON-AGE = 25
MOVE "Alice, age 25" TO WS-RESULT
END-IF
IF WS-PERSON-EMAIL NOT = SPACES
STRING "Has email: " WS-PERSON-EMAIL INTO WS-RESULT
END-IF
DISPLAY WS-RESULT
MOVE "Bob" TO WS-TUPLE-NAME
MOVE 30 TO WS-TUPLE-AGE
IF WS-TUPLE-NAME = "Bob" AND WS-TUPLE-AGE = 30
MOVE "Bob, 30" TO WS-RESULT
END-IF
IF WS-TUPLE-AGE > 18
STRING "Adult: " WS-TUPLE-NAME INTO WS-RESULT
END-IF
DISPLAY WS-RESULT
MOVE 1 TO WS-NUM(1)
MOVE 2 TO WS-NUM(2)
MOVE 3 TO WS-NUM(3)
IF WS-NUM(1) = 1 AND WS-NUM(2) = 2 AND WS-NUM(3) = 3
MOVE "Exactly [1,2,3]" TO WS-RESULT
END-IF
DISPLAY WS-RESULT
STOP RUN.Advanced
99. How does Multithreading with Tasks work in COBOL?
COBOL supports task-based processing through THREAD and parallel processing features. Different compilers provide different threading implementations.
- Thread creation and management
- Parallel processing
- Thread-local storage
- Compiler-specific threading
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. PARALLELTASKS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-ARR.
05 WS-ARR-DATA OCCURS 1000000 TIMES PIC 9(5).
01 WS-TOTAL PIC 9(8) VALUE 0.
01 WS-I PIC 9(8).
01 WS-LEFT PIC 9(8).
01 WS-RIGHT PIC 9(8).
01 WS-MID PIC 9(8).
01 WS-TASKS.
05 WS-TASK-RESULT OCCURS 3 TIMES PIC 9(8).
01 WS-COUNT PIC 9(3) VALUE 0.
01 WS-SQUARES.
05 WS-SQUARE-DATA OCCURS 100 TIMES PIC 9(5).
01 WS-J PIC 9(3).
PROCEDURE DIVISION.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 1000000
MOVE 1 TO WS-ARR-DATA(WS-I)
END-PERFORM
PERFORM PARALLEL-SUM
DISPLAY "Parallel sum: " WS-TOTAL
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 3
DISPLAY "Data from source " WS-I
END-PERFORM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 100
COMPUTE WS-SQUARE-DATA(WS-I) = WS-I * WS-I
END-PERFORM
DISPLAY "First 5 squares: 1 4 9 16 25"
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 10
DISPLAY "Task " WS-I " on thread 1"
END-PERFORM
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 20
DISPLAY "Processed " WS-I
END-PERFORM
STOP RUN.
PARALLEL-SUM.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > 1000000
ADD WS-ARR-DATA(WS-I) TO WS-TOTAL
END-PERFORM.Advanced
100. How to build Complete Library Management System in COBOL?
A Library Management System in COBOL demonstrates comprehensive business application design with multiple files, transaction processing, and reporting.
- Book catalog file
- Member registration file
- Borrow/return transaction processing
- Report generation
- Search capabilities
cobol
IDENTIFICATION DIVISION.
PROGRAM-ID. LIBRARY.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-BOOKS.
05 WS-BOOK OCCURS 10 TIMES.
10 WS-BOOK-ISBN PIC X(15).
10 WS-BOOK-TITLE PIC X(30).
10 WS-BOOK-AUTHOR PIC X(20).
10 WS-BOOK-GENRE PIC X(15).
10 WS-BOOK-YEAR PIC 9(4).
10 WS-BOOK-TOTAL PIC 9(3).
10 WS-BOOK-AVAIL PIC 9(3).
01 WS-BOOK-COUNT PIC 9(3) VALUE 0.
01 WS-MEMBERS.
05 WS-MEMBER OCCURS 10 TIMES.
10 WS-MEMBER-ID PIC X(10).
10 WS-MEMBER-NAME PIC X(20).
10 WS-MEMBER-EMAIL PIC X(30).
10 WS-MEMBER-BORROWED OCCURS 5 TIMES PIC X(15).
10 WS-MEMBER-BORROW-COUNT PIC 9(3).
01 WS-MEMBER-COUNT PIC 9(3) VALUE 0.
01 WS-I PIC 9(3).
01 WS-J PIC 9(3).
01 WS-K PIC 9(3).
01 WS-ISBN PIC X(15).
01 WS-MEMBER-ID PIC X(10).
01 WS-FOUND PIC X VALUE 'N'.
01 WS-TOTAL-BOOKS PIC 9(3).
01 WS-AVAIL-BOOKS PIC 9(3).
PROCEDURE DIVISION.
PERFORM ADD-BOOK("978-0", "The C# Book",
"Anders Hejlsberg", "Programming", 2020, 3)
PERFORM ADD-BOOK("978-1", "Design Patterns",
"Gang of Four", "Programming", 2015, 2)
PERFORM ADD-BOOK("978-2", "Clean Code",
"Robert Martin", "Programming", 2008, 4)
PERFORM ADD-BOOK("978-3", "Dune",
"Frank Herbert", "Sci-Fi", 1965, 2)
PERFORM ADD-BOOK("978-4", "1984",
"George Orwell", "Fiction", 1949, 3)
PERFORM REGISTER-MEMBER("M001", "Alice Johnson",
"alice@email.com")
PERFORM REGISTER-MEMBER("M002", "Bob Smith",
"bob@email.com")
PERFORM REGISTER-MEMBER("M003", "Carol White",
"carol@email.com")
PERFORM DISPLAY-ALL-BOOKS
PERFORM BORROW-BOOK("M001", "978-0")
PERFORM BORROW-BOOK("M001", "978-2")
PERFORM BORROW-BOOK("M002", "978-1")
PERFORM BORROW-BOOK("M003", "978-3")
PERFORM BORROW-BOOK("M001", "978-9")
PERFORM RETURN-BOOK("M001", "978-0")
PERFORM BORROW-BOOK("M002", "978-0")
DISPLAY "Search by genre 'Programming':"
PERFORM SEARCH-BY-GENRE("Programming")
PERFORM DISPLAY-ALL-MEMBERS
PERFORM DISPLAY-STATS
STOP RUN.
ADD-BOOK.
ADD 1 TO WS-BOOK-COUNT
MOVE WS-ISBN TO WS-BOOK-ISBN(WS-BOOK-COUNT)
MOVE WS-TITLE TO WS-BOOK-TITLE(WS-BOOK-COUNT)
MOVE WS-AUTHOR TO WS-BOOK-AUTHOR(WS-BOOK-COUNT)
MOVE WS-GENRE TO WS-BOOK-GENRE(WS-BOOK-COUNT)
MOVE WS-YEAR TO WS-BOOK-YEAR(WS-BOOK-COUNT)
MOVE WS-TOTAL TO WS-BOOK-TOTAL(WS-BOOK-COUNT)
MOVE WS-TOTAL TO WS-BOOK-AVAIL(WS-BOOK-COUNT)
DISPLAY "Book added: " WS-BOOK-TITLE(WS-BOOK-COUNT).
REGISTER-MEMBER.
ADD 1 TO WS-MEMBER-COUNT
MOVE WS-MEMBER-ID TO WS-MEMBER-ID(WS-MEMBER-COUNT)
MOVE WS-MEMBER-NAME TO
WS-MEMBER-NAME(WS-MEMBER-COUNT)
MOVE WS-MEMBER-EMAIL TO
WS-MEMBER-EMAIL(WS-MEMBER-COUNT)
MOVE 0 TO WS-MEMBER-BORROW-COUNT(WS-MEMBER-COUNT)
DISPLAY "Member registered: "
WS-MEMBER-NAME(WS-MEMBER-COUNT).
BORROW-BOOK.
PERFORM FIND-BOOK
IF WS-FOUND = 'N'
DISPLAY "Error: Book not found: " WS-ISBN
EXIT PERFORM
END-IF
PERFORM FIND-MEMBER
IF WS-FOUND = 'N'
DISPLAY "Error: Member not found: " WS-MEMBER-ID
EXIT PERFORM
END-IF
IF WS-MEMBER-BORROW-COUNT(WS-MEMBER-COUNT) >= 5
DISPLAY "Error: " WS-MEMBER-NAME(WS-MEMBER-COUNT)
" has reached borrow limit"
EXIT PERFORM
END-IF
IF WS-BOOK-AVAIL(WS-BOOK-COUNT) = 0
DISPLAY "Error: Book not available: "
WS-BOOK-TITLE(WS-BOOK-COUNT)
EXIT PERFORM
END-IF
SUBTRACT 1 FROM WS-BOOK-AVAIL(WS-BOOK-COUNT)
ADD 1 TO WS-MEMBER-BORROW-COUNT(WS-MEMBER-COUNT)
MOVE WS-ISBN TO WS-MEMBER-BORROWED(
WS-MEMBER-COUNT,
WS-MEMBER-BORROW-COUNT(WS-MEMBER-COUNT))
DISPLAY WS-MEMBER-NAME(WS-MEMBER-COUNT)
" borrowed: " WS-BOOK-TITLE(WS-BOOK-COUNT).
RETURN-BOOK.
PERFORM FIND-BOOK
IF WS-FOUND = 'N'
EXIT PERFORM
END-IF
PERFORM FIND-MEMBER
IF WS-FOUND = 'N'
EXIT PERFORM
END-IF
PERFORM FIND-BORROWED
IF WS-FOUND = 'N'
DISPLAY "Error: " WS-MEMBER-NAME(WS-MEMBER-COUNT)
" did not borrow this book"
EXIT PERFORM
END-IF
ADD 1 TO WS-BOOK-AVAIL(WS-BOOK-COUNT)
SUBTRACT 1 FROM WS-MEMBER-BORROW-COUNT(WS-MEMBER-COUNT)
DISPLAY WS-MEMBER-NAME(WS-MEMBER-COUNT)
" returned: " WS-BOOK-TITLE(WS-BOOK-COUNT).
FIND-BOOK.
MOVE 'N' TO WS-FOUND
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-BOOK-COUNT
IF WS-BOOK-ISBN(WS-I) = WS-ISBN
MOVE 'Y' TO WS-FOUND
MOVE WS-I TO WS-BOOK-COUNT
EXIT PERFORM
END-IF
END-PERFORM.
FIND-MEMBER.
MOVE 'N' TO WS-FOUND
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-MEMBER-COUNT
IF WS-MEMBER-ID(WS-I) = WS-MEMBER-ID
MOVE 'Y' TO WS-FOUND
MOVE WS-I TO WS-MEMBER-COUNT
EXIT PERFORM
END-IF
END-PERFORM.
FIND-BORROWED.
MOVE 'N' TO WS-FOUND
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-MEMBER-BORROW-COUNT(
WS-MEMBER-COUNT)
IF WS-MEMBER-BORROWED(WS-MEMBER-COUNT, WS-I) =
WS-ISBN
MOVE 'Y' TO WS-FOUND
EXIT PERFORM
END-IF
END-PERFORM.
DISPLAY-ALL-BOOKS.
DISPLAY "=== C# City Library - Catalog ==="
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-BOOK-COUNT
DISPLAY WS-BOOK-ISBN(WS-I) " "
WS-BOOK-TITLE(WS-I) " "
WS-BOOK-AUTHOR(WS-I) " "
WS-BOOK-GENRE(WS-I) " "
WS-BOOK-YEAR(WS-I) " ["
WS-BOOK-AVAIL(WS-I) "/"
WS-BOOK-TOTAL(WS-I) "]"
END-PERFORM.
DISPLAY-ALL-MEMBERS.
DISPLAY "=== C# City Library - Members ==="
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-MEMBER-COUNT
DISPLAY "Member [" WS-MEMBER-ID(WS-I) "] "
WS-MEMBER-NAME(WS-I) " | Email: "
WS-MEMBER-EMAIL(WS-I) " | Borrowed: "
WS-MEMBER-BORROW-COUNT(WS-I) "/5"
IF WS-MEMBER-BORROW-COUNT(WS-I) > 0
DISPLAY " Books: "
PERFORM VARYING WS-J FROM 1 BY 1
UNTIL WS-J >
WS-MEMBER-BORROW-COUNT(WS-I)
DISPLAY WS-MEMBER-BORROWED(WS-I, WS-J)
END-PERFORM
END-IF
END-PERFORM.
SEARCH-BY-GENRE.
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-BOOK-COUNT
IF WS-BOOK-GENRE(WS-I) = WS-GENRE
DISPLAY WS-BOOK-ISBN(WS-I) " "
WS-BOOK-TITLE(WS-I) " "
WS-BOOK-AUTHOR(WS-I) " "
WS-BOOK-GENRE(WS-I) " "
WS-BOOK-YEAR(WS-I) " ["
WS-BOOK-AVAIL(WS-I) "/"
WS-BOOK-TOTAL(WS-I) "]"
END-IF
END-PERFORM.
DISPLAY-STATS.
MOVE WS-BOOK-COUNT TO WS-TOTAL-BOOKS
MOVE 0 TO WS-AVAIL-BOOKS
PERFORM VARYING WS-I FROM 1 BY 1
UNTIL WS-I > WS-BOOK-COUNT
ADD WS-BOOK-AVAIL(WS-I) TO WS-AVAIL-BOOKS
END-PERFORM
DISPLAY "=== Stats ==="
DISPLAY "Total books: " WS-TOTAL-BOOKS
DISPLAY "Available: " WS-AVAIL-BOOKS
COMPUTE WS-TOTAL-BOOKS = WS-TOTAL-BOOKS -
WS-AVAIL-BOOKS
DISPLAY "Checked out: " WS-TOTAL-BOOKS
DISPLAY "Total members: " WS-MEMBER-COUNT.