Strings in C++: Roman to Integer, Integer to Roman, and Factorial of Large Numbers

This chapter focuses on advanced string and array manipulation techniques in C++. It addresses two major categories of problems: Roman Numeral Conversions (positional number systems, lookahead strategies, and structural decomposition) and Massive Numerical Computations (handling integer overflow using arbitrary-precision dynamic array storage).

1. Fundamentals of Roman Numerals & Problem Constraints

Roman numerals are a non-positional numeral system represented by specific alphabetic characters. Each character corresponds to a fixed integer value.

Standard Character Mapping

Note: A common shorthand sequence to memorize character order from smallest to largest is: I, V, X, L, C, D, M ($1, 5, 10, 50, 100, 500, 1000$).

Core Constraints & Guarantees

In standard algorithmic problems (such as LeetCode 13 & 12), inputs and expected outputs are strictly bounded:

• Valid Range: $1 \le \text{Value} \le 3999$
• This upper bound guarantees that we never need symbols beyond M ($1000$) or complex bar-notation for values $\ge 4000$.

2. Roman to Integer: Core Mental Model & Algorithm

Basic Addition vs. Subtraction Rule

In standard non-subtractive cases, values are written from largest to smallest, and we simply sum them up:

• III $= 1 + 1 + 1 = 3$
• LXX $= 50 + 10 + 10 = 70$
• CCCXXXV $= 100 + 100 + 100 + 10 + 10 + 10 + 5 = 335$

However, when a smaller value symbol appears before a larger value symbol, it indicates a subtractive combination:

• IV $= 5 - 1 = 4$ (not $1 + 5 = 6$)
• IX $= 10 - 1 = 9$
• XL $= 50 - 10 = 40$
• CD $= 500 - 100 = 400$

Lookahead Decision Strategy

To convert a Roman numeral string $S$ to an integer:

1. Traverse the string character by character from index i = 0 up to s.size() - 2.
2. Compare the numeric value of the current character s[i] with the numeric value of the next character s[i + 1]:
   • Case A (Value(s[i]) < Value(s[i + 1])): The current character is subtractive. Subtract Value(s[i]) from the cumulative total (sum -= Value(s[i])).
   • Case B (Value(s[i]) >= Value(s[i + 1])): The current character is additive. Add Value(s[i]) to the cumulative total (sum += Value(s[i])).
3. After the loop terminates, the final character s[s.size() - 1] has no lookahead neighbor. Always add its value directly to sum.

Lookahead Decision Workflow

3. Roman to Integer: Complete C++ Implementation

Code Implementation

#include <iostream>
#include <string>

using namespace std;

// Helper function to map individual Roman characters to their integer values
int number(char c) {
    if (c == 'I') return 1;
    if (c == 'V') return 5;
    if (c == 'X') return 10;
    if (c == 'L') return 50;
    if (c == 'C') return 100;
    if (c == 'D') return 500;
    return 1000; // 'M'
}

int romanToInt(string s) {
    int sum = 0;
    int index = 0;
    int n = s.size();

    // Iterate up to the second-to-last character
    while (index < n - 1) {
        if (number(s[index]) < number(s[index + 1])) {
            sum -= number(s[index]);
        } else {
            sum += number(s[index]);
        }
        index++;
    }

    // Always add the last character's value directly
    sum += number(s[n - 1]);

    return sum;
}

int main() {
    string str = "XLIII";
    cout << "Integer value of " << str << " is: " << romanToInt(str) << endl; // Output: 43
    return 0;
}

Dry-Run Walkthrough (s = "XLIII", Length = $5$)

• Initial State: sum = 0, index = 0

Complexity Analysis

• Time Complexity: $\mathcal{O}(N)$, where $N$ is the length of the string. The lookahead logic processes each character in $\mathcal{O}(1)$ time.
• Space Complexity: $\mathcal{O}(1)$ auxiliary space, as no extra dynamic memory is allocated.

4. Integer to Roman: Positional Breakdown & Framework

To convert an integer $N$ ($1 \le N \le 3999$) to a Roman numeral string, decompose $N$ into its decimal place values: Thousands, Hundreds, Tens, and Units.

Positional Decomposition Principle

Consider $N = 1248$:

Each place value is mapped independently to its corresponding Roman representation:

• $1000 \rightarrow \text{"M"}$
• $200 \rightarrow \text{"CC"}$
• $40 \rightarrow \text{"XL"}$
• $8 \rightarrow \text{"VIII"}$
• Combined Result: "MCCXLVIII"

Lookup Framework Table

By pre-defining lookup arrays for all possible place values, conversion reduces to a sequence of direct indexed lookups:

Conceptual Solution Paradigm

Using static lookup arrays for each position allows $O(1)$ constant time lookup:

string ones[]     = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
string tens[]     = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
string hundreds[] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
string thousands[]= {"", "M", "MM", "MMM"};

string intToRoman(int num) {
    return thousands[num / 1000] + 
           hundreds[(num % 1000) / 100] + 
           tens[(num % 100) / 10] + 
           ones[num % 10];
}

• Time Complexity: $\mathcal{O}(1)$
• Space Complexity: $\mathcal{O}(1)$

5. The Integer Overflow Challenge in Large Factorials

Why Standard Data Types Fail

Calculating factorials ($N! = N \times (N-1) \times \dots \times 1$) using primitive integer types fails rapidly due to fixed bit-width storage boundaries.

Standard 32-bit Signed Integer Range:
  -2^31  to  +(2^31 - 1)   =>  -2,147,483,648  to  +2,147,483,647

Bit Distribution in 32-bit Primitive Integers

1 bit is reserved for the sign, leaving 31 bits for value magnitude:

[ Sign Bit (1 bit) ] [ Magnitude Bits (31 bits) ]

Maximum positive capacity $= 2^{31} - 1 \approx 2.14 \times 10^9$.

Growth Rate of Factorials

When $N!$ exceeds the container limit, arithmetic wraparound occurs, producing incorrect negative numbers or truncated zero outputs.

6. Representing Large Numbers via Arrays/Vectors

To bypass hardware register limitations, we represent massive numbers using dynamic arrays (std::vector<int>).

Array Storage Architecture

Instead of storing $N!$ as a scalar integer, each single-digit value ($0$ through $9$) is stored in its own array slot:

Number: 40320

Array Representation:
Index:   [ 0 ] [ 1 ] [ 2 ] [ 3 ] [ 4 ]
Digit:     0     2     3     0     4   (Stored in REVERSE order)

Why Store Digits in Reverse Order?

When multiplying a multi-digit number by a scalar multiplier $x$, carry operations propagate from the least significant digit (LSD) to the most significant digit (MSD):

In a standard C++ std::vector:

• Inserting at the end via vector::push_back() runs in $\mathcal{O}(1)$ amortized time.
• Inserting at the beginning via vector::insert(begin(), val) runs in $\mathcal{O}(K)$ time because all existing elements must shift right.

By storing the number in reverse order (index 0 holds the units digit):

1. New digits generated by residual carries are pushed directly to the back of the vector in $\mathcal{O}(1)$ time.
2. Once all multiplications are complete, the entire vector is reversed once at the very end to produce the correct final string/array output.

7. Step-by-Step Multiplication & Carry Workflow

To compute $N!$, initialize the array with a single element [1]. Iteratively multiply the contents of the array by $x = 2, 3, 4, \dots, N$.

Primary Loop Algorithm (Multiplying Vector by Scalar $x$)

1. Initialize carry = 0.
2. Iterate through all existing elements ans[i] from i = 0 up to size - 1:
   • Compute raw product: result = (ans[i] * x) + carry
   • Store single-digit remainder in slot i: ans[i] = result % 10
   • Calculate new carry: carry = result / 10
3. Process remaining multi-digit carry (if carry > 0 after completing element-wise operations):
   • While carry > 0:
     • Append its unit digit to the array: ans.push_back(carry % 10)
     • Reduce carry: carry = carry / 10

Multi-Digit Carry Propagation Trace

8. Complete C++ Implementation: Factorial of Large Numbers

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

// Computes factorial of large numbers and returns vector of digits
vector<int> factorial(int n) {
    // Vector stores digits in REVERSE order
    vector<int> ans;
    ans.push_back(1); // Base case: 0! or 1! = 1

    // Multiply ans by every number x from 2 up to n
    for (int x = 2; x <= n; x++) {
        int carry = 0;
        int size = ans.size();

        // Perform element-wise multiplication
        for (int i = 0; i < size; i++) {
            int result = (ans[i] * x) + carry;
            ans[i] = result % 10;   // Store unit digit
            carry = result / 10;    // Pass remainder as carry
        }

        // Process residual multi-digit carry
        while (carry > 0) {
            ans.push_back(carry % 10);
            carry /= 10;
        }
    }

    // Reverse array to restore correct Most Significant Digit -> Least Significant Digit order
    reverse(ans.begin(), ans.end());
    return ans;
}

int main() {
    int N = 50;
    vector<int> result = factorial(N);

    cout << N << "! = ";
    for (int digit : result) {
        cout << digit;
    }
    cout << endl;

    return 0;
}

Complete Execution Trace ($N = 4$)

• Initialize: ans = [1]

Complexity Analysis

• Time Complexity: $\mathcal{O}(N \cdot D)$, where $N$ is the input scalar and $D$ is the number of digits in $N!$. By Stirling's approximation, $D \approx \mathcal{O}(N \log N)$. Hence, total execution time runs in $\mathcal{O}(N^2 \log N)$, easily executing well under $0.1$ seconds for $N = 500$.
• Space Complexity: $\mathcal{O}(D)$ auxiliary space to store the output digits.

9. Real-World Debugging, Pitfalls, & Industry Mindset

Common Bugs & Edge Cases

1. Infinite Loop via Missing Counter Update:
   C++

   Copy

   // INCORRECT
   while (index < s.size() - 1) {
       if (...) sum -= ...;
       // Missing index++ leads to Time Limit Exceeded (TLE)
   }
   

2. Improper Multi-Digit Carry Processing: Assuming carry is always a single-digit number ($\le 9$) causes severe bugs when multiplying against large dynamic inputs:
   C++

   Copy

   // INCORRECT
   if (carry > 0) ans.push_back(carry); 
   
   // CORRECT: Process all digits of carry sequentially
   while (carry > 0) {
       ans.push_back(carry % 10);
       carry /= 10;
   }
   

Debugging Mindset in Technical Engineering

Instructor Insight: Multiple compilation errors or Wrong Answers (WA) during initial submissions are a natural, essential part of the learning journey. Real production debugging involves systematically identifying boundary conditions (e.g., zero factorials, multi-digit carries, container boundary limits) and step-by-step trace verification.

10. Summary and Key Takeaways

• Roman Numeral Structure: Standard conversion uses a lookahead strategy comparing s[i] with s[i + 1]. If s[i] < s[i + 1], subtract s[i]; otherwise, add s[i].
• Positional Integer Conversion: Decimal breakdown into thousands, hundreds, tens, and units maps directly to fixed $O(1)$ lookup tables.
• Integer Overflow Threshold: 32-bit signed integers overflow beyond $12!$ ($2^{31}-1 \approx 2.14 \times 10^9$). 64-bit integers overflow beyond $20!$.
• Dynamic Array Digit Storage: Large values are stored digit-by-digit inside custom dynamic arrays or vectors to achieve arbitrary-precision computation.
• Reverse Digit Orientation: Digits are processed in reverse order (LSD at index 0) to allow $\mathcal{O}(1)$ dynamic growth at the tail via .push_back().
• Residual Carry Propagation: After processing element-wise digit products, remaining carry values must be processed iteratively using while (carry > 0) loops to append every single digit correctly.
• Final Output Transformation: Once all arithmetic iterations are completed, the vector must be reversed to output the correct most-significant-to-least-significant digit sequence.