This COBOL program implements an optimized Bubble Sort algorithm to sort an array of integers in ascending order. It includes a flag to detect if any swaps occurred in a pass, allowing for early termination if the array...

The Bubble Sort algorithm repeatedly steps through the list, compares adjacent elements and swaps them if they are in the wrong order. The optimization implemented here uses a `SWAPPED-FLAG` to check if any swaps were made during a pass. If no swaps occur, it means the array is already sorted, and the algorithm terminates early. The outer loop runs at most N-1 times, and the inner loop compares adjacent elements. In the worst case, where the array is in reverse order, the time complexity is O(N^2). In the best case, with the optimization, if the array is already sorted, it's O(N). The space complexity is O(1) as it only uses a few extra variables for swapping and control. Edge cases handled include an empty array (N=0, loops won't execute) and a single-element array (N=1, loops won't execute). The algorithm guarantees correctness because each pass moves the largest unsorted element to its correct final position.

PROCEDURE BUBBLE-SORT-OPTIMIZED: SET SWAPPED-FLAG to TRUE DECREMENT N by 1 LOOP I from 1 to N: SET SWAPPED-FLAG to FALSE LOOP J from 1 to N - I: IF element at J > element at J+1: SWAP elements at J and J+1 SET SWAPPED-FL...

This COBOL program calculates the factorial of a given non-negative integer using recursion. The `CALCULATE-FACTORIAL` subroutine is designed to call itself with a decremented input until it reaches the base case (0 or 1...

The factorial of a non-negative integer N, denoted by N!, is the product of all positive integers less than or equal to N. The recursive definition is N! = N * (N-1)! for N > 0, and 0! = 1. The COBOL program implements this using a subroutine `CALCULATE-FACTORIAL`. The base case is when N is 0 or 1, returning 1. Otherwise, it recursively calls itself with N-1, then multiplies the result by N. The `MAIN-LOGIC` section handles input validation, ensuring the number is within a safe range (0-12) to prevent overflow with a `PIC 9(10)` result field. The time complexity is O(N) because each number from N down to 1 is processed once. The space complexity is also O(N) due to the recursion depth creating stack frames. Edge cases include 0! and 1!, which are correctly handled by the base case. The input validation prevents issues with negative numbers and potential overflows for larger inputs.

PROCEDURE CALCULATE-FACTORIAL(N): IF N is 0 OR N is 1: RETURN 1 ELSE: RETURN N * CALCULATE-FACTORIAL(N - 1) END IF END PROCEDURE

This COBOL program updates records in an indexed customer file. It reads update transactions from a sequential file, identifies the target customer record by ID, and modifies fields like credit limit or balance based on...

The program uses `ACCESS MODE IS RANDOM` on an indexed file (`CUSTOMER-FILE`) for efficient record retrieval and modification. It reads update instructions from `UPDATE-TRANSACTIONS`. For each transaction, it reads the target `CUSTOMER-RECORD` using the `CUST-ID`. The `INVALID KEY` clause of the `READ` statement handles cases where the customer ID is not found. If the record is found, the `4000-APPLY-UPDATE` routine modifies the relevant field (`CUST-CREDIT-LIMIT` or `CUST-BALANCE`) based on `UPD-OPERATION` and then uses `REWRITE` to save the modified record back to the indexed file. The `REWRITE` operation itself can fail, and its success is checked via `WS-FILE-STATUS`. Time complexity for each update is O(log N) due to indexed file access. Total time is O(M log N), where M is the number of updates and N is the number of records in the customer file. Space complexity is O(1). Edge cases include file opening errors, missing records, invalid operation codes, and potential issues during the `REWRITE` operation.

INITIALIZE: Open CUSTOMER-FILE for I/O. Open UPDATE-TRANSACTIONS for input. Check file opening statuses. Read the first update transaction. PROCESS_UPDATES: Increment update count. Set CUSTOMER-FILE key to the customer I...

This COBOL program serves as a data migration utility, transforming records from a legacy format to a modern one. It reads data from 'legacy.dat', reorders fields, potentially converts data types (e.g., to packed decimal...

The program uses sequential file processing to read from `LEGACY-DATA` and write to `MODERN-DATA`. The `4000-MAP-AND-CONVERT` paragraph is the core of the migration logic. It directly moves data from fields in `LEGACY-RECORD` to corresponding fields in `MODERN-RECORD`. For example, `LEGACY-ID` is moved to `MODERN-CUSTOMER-ID`, and `LEGACY-AMOUNT` (a zoned decimal) is moved to `MODERN-TRANSACTION-AMT` (a packed decimal, `COMP-3`), which handles the type conversion. The `MODERN-STATUS-CODE` is pre-initialized. The time complexity is O(N), where N is the number of records in the legacy file, as each record is processed once. Space complexity is O(1) for working storage. Edge cases include an empty legacy file, records with unexpected data (though not explicitly handled here for simplicity), and ensuring the target fields are large enough to accommodate the migrated data. Correctness is achieved by accurate field mapping and type conversion.

INITIALIZE: Open legacy input file. Open modern output file. Read the first record from the legacy file. PROCESS_RECORDS: Increment record count. MAP_AND_CONVERT the legacy record to the modern format. Write the modern r...