Roman to Integer Conversion in DSA C# - Execution Trace

Concept Flow - Roman to Integer Conversion

Start with input Roman string

↓

Initialize total = 0, index = 0

↓

Check current and next Roman chars

↓

If current < next: add (next - current)

↓

Else: add current to total

↓

Move index forward (1 or 2 steps)

↓

Repeat until end of string

↓

Return total as integer

The flow reads Roman numerals left to right, adding or subtracting values based on the next character, accumulating the total integer.

Execution Sample

DSA C#

string s = "MCMXCIV";
int total = 0;
int i = 0;
while (i < s.Length) {
  // check and add/subtract
}

This code converts the Roman numeral "MCMXCIV" to its integer value by scanning characters and updating total.

Execution Table

Step	Operation	Current Char	Next Char	Action	Total	Index	Visual State
1	Initialize	M	C	M < C? No, add 1000	1000	1	M(1000)
2	Check pair	C	M	C < M? Yes, add 900 (M - C)	1900	3	M(1000) - C(100) + M(1000) = 1900
3	Check pair	X	C	X < C? Yes, add 90 (C - X)	1990	5	MCM(1900) - X(10) + C(100) = 1990
4	Check pair	I	V	I < V? Yes, add 4 (V - I)	1994	7	MCMXC(1990) - I(1) + V(5) = 1994
5	End	-	-	End of string reached	1994	7	Final total 1994

💡 Index reached string length; all characters processed.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
total	0	1000	1900	1990	1994	1994
i	0	1	3	5	7	7

Key Moments - 3 Insights

Why do we subtract the value of the current Roman numeral when it is less than the next one?

Because in Roman numerals, a smaller value before a larger one means subtraction. For example, 'IV' means 5 - 1 = 4. This is shown in execution_table steps 2, 3, and 4 where subtraction happens.

Why do we sometimes move the index by 2 instead of 1?

When a smaller numeral precedes a larger one, we process both together as a pair (like 'CM' or 'IV'), so we move index by 2. Otherwise, we move by 1. This is reflected in the index changes in variable_tracker.

What happens if the Roman numeral string is empty?

The loop does not run, total remains 0, and the function returns 0 immediately. This is the base case for empty input.

Visual Quiz - 3 Questions

Look at the execution_table, what is the total after step 2?

A 1000

B 1900

C 1890

D 1884

💡 Hint

Check the 'Total' column in execution_table row with Step 2.

At which step does the index reach the end of the string?

A Step 5

B Step 4

C Step 3

D Step 1

💡 Hint

Look at the 'Index' column and the exit_note in execution_table.

If the Roman numeral was 'III' instead of 'MCMXCIV', how would the total change after step 1?

A Total would be 3

B Total would be 1000

C Total would be 1

D Total would be 0

💡 Hint

Look at how the first character 'M' adds 1000 in the original; 'I' adds 1.

Concept Snapshot

Roman to Integer Conversion:
- Read Roman string left to right
- If current < next, add (next - current)
- Else, add current value
- Move index by 2 if subtracting, else by 1
- Continue until end
- Return total integer value

Full Transcript

This visualization shows how to convert Roman numerals to integers by scanning the string from left to right. At each step, we compare the current Roman character with the next one. If the current is smaller, we subtract its value from the total; otherwise, we add it. We move the index accordingly and repeat until the entire string is processed. The example uses 'MCMXCIV' which converts to 1994. Key points include understanding subtraction pairs and index movement. The final total is returned as the integer value.

Practice

1. What is the main rule to convert Roman numerals to integers?

easy

A. Subtract all values from the largest symbol

B. Multiply values of all symbols

C. Add values of symbols, subtract if a smaller symbol is before a larger one

D. Add values only if symbols are in alphabetical order

Solution

1. Step 1: Understand Roman numeral rules

   Roman numerals add values unless a smaller symbol is before a larger one, then subtract.

2. Step 2: Apply rule to conversion

   When converting, add values normally but subtract when a smaller symbol precedes a larger one.

3. Final Answer:

   Add values of symbols, subtract if a smaller symbol is before a larger one -> Option C

4. Quick Check:

   Roman numeral conversion rule = Add values of symbols, subtract if a smaller symbol is before a larger one [OK]

Hint: Subtract only when smaller symbol is before larger one [OK]

Common Mistakes:

• Multiplying values instead of adding/subtracting
• Ignoring subtraction rule
• Adding all values without checking order

2. Which C# code snippet correctly initializes a dictionary for Roman numeral values?

easy

A. var map = new Dictionary { {'I', 1}, {'V', 5} };

B. var map = new Dictionary { {1, 'I'}, {5, 'V'} };

C. var map = new Dictionary { {'I', 1}, {'V', 5} };

D. var map = new Dictionary { {'I', "1"}, {'V', "5"} };

Solution

1. Step 1: Identify correct dictionary types

   Roman numerals are characters mapped to integer values, so Dictionary is correct.

2. Step 2: Check initialization syntax

   Initialization with curly braces and pairs like {'I', 1} is correct syntax in C#.

3. Final Answer:

   var map = new Dictionary { {'I', 1}, {'V', 5} }; -> Option A

4. Quick Check:

   Dictionary with correct pairs = var map = new Dictionary { {'I', 1}, {'V', 5} }; [OK]

Hint: Use Dictionary for Roman numeral mapping [OK]

Common Mistakes:

• Swapping key and value types
• Using string keys instead of char
• Incorrect initialization syntax

3. What is the output of this C# code snippet?

string s = "IX";
var map = new Dictionary { {'I', 1}, {'V', 5}, {'X', 10} };
int result = 0;
for (int i = 0; i < s.Length; i++) {
  if (i + 1 < s.Length && map[s[i]] < map[s[i + 1]]) {
    result -= map[s[i]];
  } else {
    result += map[s[i]];
  }
}
Console.WriteLine(result);

medium

A. 9

B. 11

C. 6

D. 1

Solution

1. Step 1: Analyze loop and conditions

   For 'IX', at i=0: 'I' < 'X' so subtract 1; at i=1: add 10.

2. Step 2: Calculate result

   result = -1 + 10 = 9.

3. Final Answer:

   9 -> Option A

4. Quick Check:

   IX = 9 [OK]

Hint: Subtract when current < next symbol, else add [OK]

Common Mistakes:

• Adding all values without subtraction
• Off-by-one errors in loop
• Incorrect dictionary values

4. Find the error in this C# code for Roman to integer conversion:

var map = new Dictionary { {'I', 1}, {'V', 5}, {'X', 10} };
int result = 0;
for (int i = 0; i < s.Length - 1; i++) {
  if (map[s[i]] < map[s[i + 1]]) {
    result -= map[s[i]];
  } else {
    result += map[s[i]];
  }
}
result += map[s[s.Length - 1]];
Console.WriteLine(result);

medium

A. No error, code works correctly

B. Missing initialization of string s

C. Loop should run till i < s.Length, not s.Length - 1

D. Dictionary keys should be strings, not chars

Solution

1. Step 1: Check variable declarations

   The variable 's' is used but not declared or initialized, causing a compile error.

2. Step 2: Verify loop and dictionary usage

   Loop and dictionary usage are correct; only 's' is missing.

3. Final Answer:

   Missing initialization of string s -> Option B

4. Quick Check:

   Undefined variable s causes error = Missing initialization of string s [OK]

Hint: Always declare and initialize variables before use [OK]

Common Mistakes:

• Forgetting to declare input string
• Incorrect loop range causing index errors
• Wrong dictionary key types

5. Given the Roman numeral string "MCMXCIV", what integer does the following C# code output?

string s = "MCMXCIV";
var map = new Dictionary {
  {'I', 1}, {'V', 5}, {'X', 10}, {'L', 50}, {'C', 100}, {'D', 500}, {'M', 1000}
};
int result = 0;
for (int i = 0; i < s.Length; i++) {
  if (i + 1 < s.Length && map[s[i]] < map[s[i + 1]]) {
    result -= map[s[i]];
  } else {
    result += map[s[i]];
  }
}
Console.WriteLine(result);

hard

A. 1494

B. 1904

C. 2000

D. 1994

Solution

1. Step 1: Break down the Roman numeral "MCMXCIV"

   M=1000, CM=900, XC=90, IV=4; sum = 1000 + 900 + 90 + 4.

2. Step 2: Calculate total value using code logic

   Code subtracts smaller before larger and adds others: 1000 - 100 + 1000 - 10 + 100 - 1 + 5 = 1994.

3. Final Answer:

   1994 -> Option D

4. Quick Check:

   MCMXCIV = 1994 [OK]

Hint: Sum values, subtract when smaller precedes larger [OK]

Common Mistakes:

• Adding all values without subtraction
• Misreading compound numerals like CM or XC
• Incorrect dictionary values