Roman to Integer Conversion in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Roman to Integer Conversion

What is the output of the following Java code that converts a Roman numeral string to an integer?

DSA Java

import java.util.*;
public class RomanToInt {
    public static int romanToInt(String s) {
        Map<Character, Integer> map = new HashMap<>();
        map.put('I', 1);
        map.put('V', 5);
        map.put('X', 10);
        map.put('L', 50);
        map.put('C', 100);
        map.put('D', 500);
        map.put('M', 1000);
        int result = 0;
        for (int i = 0; i < s.length(); i++) {
            int value = map.get(s.charAt(i));
            if (i + 1 < s.length() && value < map.get(s.charAt(i + 1))) {
                result -= value;
            } else {
                result += value;
            }
        }
        return result;
    }
    public static void main(String[] args) {
        System.out.println(romanToInt("MCMXCIV"));
    }
}

A 1994

B 1904

C 2094

D None (runtime error)

💡 Hint

Remember that when a smaller value precedes a larger value, you subtract it.

The Roman numeral MCMXCIV is 1000 + (1000-100) + (100-10) + (5-1) = 1994.

🧠 Conceptual

intermediate

Understanding Subtraction Rule in Roman Numerals

In Roman numeral conversion, why do we subtract the value of a smaller numeral when it appears before a larger numeral?

A Because it represents a special subtractive notation to avoid four repetitions.

B Because the smaller numeral is always a mistake and should be ignored.

C Because Roman numerals are always added regardless of order.

D Because subtraction is used only for numerals larger than 1000.

💡 Hint

Think about how Romans wrote numbers like 4 or 9.

Romans used subtractive notation to write numbers like 4 as IV (5 - 1) instead of IIII to avoid repeating the same symbol four times.

🔧 Debug

advanced

Identify the Bug in Roman to Integer Code

What error will occur when running this Java code snippet for Roman to Integer conversion?

DSA Java

import java.util.*;
public class RomanToIntBug {
    public static int romanToInt(String s) {
        Map<Character, Integer> map = new HashMap<>();
        map.put('I', 1);
        map.put('V', 5);
        map.put('X', 10);
        map.put('L', 50);
        map.put('C', 100);
        map.put('D', 500);
        map.put('M', 1000);
        int result = 0;
        for (int i = 0; i <= s.length(); i++) {
            int value = map.get(s.charAt(i));
            if (i + 1 < s.length() && value < map.get(s.charAt(i + 1))) {
                result -= value;
            } else {
                result += value;
            }
        }
        return result;
    }
}

A ClassCastException

B NullPointerException

C No error, returns correct integer

D ArrayIndexOutOfBoundsException

💡 Hint

Check the loop condition carefully.

The loop uses i <= s.length(), which causes s.charAt(i) to access an index equal to string length, causing ArrayIndexOutOfBoundsException.

🚀 Application

advanced

Result After Multiple Roman Numeral Conversions

Given the following Roman numerals: ["III", "IV", "IX", "LVIII"], what is the sum of their integer conversions?

A 84

B 74

C 87

D 90

💡 Hint

Convert each numeral individually and add the results.

III = 3, IV = 4, IX = 9, LVIII = 58; sum = 3 + 4 + 9 + 58 = 74

❓ Predict Output

expert

Output of Modified Roman to Integer with Invalid Input

What will be the output of this Java code when given an invalid Roman numeral string "IM"?

DSA Java

import java.util.*;
public class RomanToIntInvalid {
    public static int romanToInt(String s) {
        Map<Character, Integer> map = new HashMap<>();
        map.put('I', 1);
        map.put('V', 5);
        map.put('X', 10);
        map.put('L', 50);
        map.put('C', 100);
        map.put('D', 500);
        map.put('M', 1000);
        int result = 0;
        for (int i = 0; i < s.length(); i++) {
            int value = map.getOrDefault(s.charAt(i), -1);
            if (value == -1) return -1; // invalid character
            if (i + 1 < s.length() && value < map.getOrDefault(s.charAt(i + 1), 0)) {
                result -= value;
            } else {
                result += value;
            }
        }
        return result;
    }
    public static void main(String[] args) {
        System.out.println(romanToInt("IM"));
    }
}

A -1

B 1001

C 999

D 0

💡 Hint

The code does not validate subtractive rules strictly, only invalid characters.

The code treats 'I' as 1 and 'M' as 1000. Since 1 < 1000, it subtracts 1 then adds 1000, resulting in 999. But the code returns 999, not -1, because 'I' and 'M' are valid characters.

Practice

1. What is the value of the Roman numeral IX when converted to an integer?

easy

A. 6

B. 11

C. 9

D. 19

Solution

1. Step 1: Understand Roman numeral rules for subtraction

   In Roman numerals, when a smaller numeral appears before a larger one, it is subtracted. Here, I (1) is before X (10), so 1 is subtracted from 10.

2. Step 2: Calculate the integer value

   10 - 1 = 9.

3. Final Answer:

   9 -> Option C

4. Quick Check:

   IX = 9 [OK]

Hint: Subtract when smaller numeral precedes larger one [OK]

Common Mistakes:

• Adding values instead of subtracting
• Confusing IX with XI
• Ignoring subtraction rule

2. Which of the following Java code snippets correctly initializes a map for Roman numeral values?

easy

A. Map map = new HashMap<>(); map.add('I', 1); map.add('V', 5);

B. Map map = Map.of("I", 1, "V", 5, "X", 10);

C. Map map = new Map(); map['I'] = 1; map['V'] = 5;

D. Map map = new HashMap<>(); map.put('I', 1); map.put('V', 5); map.put('X', 10);

Solution

1. Step 1: Check correct Map initialization syntax in Java

   Java requires using a concrete class like HashMap to create a Map instance. Then, use put() method to add key-value pairs.

2. Step 2: Verify each option

   Map map = new HashMap<>(); map.put('I', 1); map.put('V', 5); map.put('X', 10); correctly uses new HashMap<>(), then map.put() calls. B uses Map.of with string keys ("I", etc.) causing type mismatch for Map<Character, Integer>. Options C and D use invalid syntax.

3. Final Answer:

   Map map = new HashMap<>(); map.put('I', 1); map.put('V', 5); map.put('X', 10); -> Option D

4. Quick Check:

   Use HashMap and put() for map initialization [OK]

Hint: Use HashMap and put() to add entries [OK]

Common Mistakes:

• Using invalid Map constructor
• Using map.add() instead of map.put()
• Trying to assign values with brackets

3. What is the output of the following Java code snippet?

String s = "MCMXCIV";
int result = 0;
Map map = Map.of('I',1,'V',5,'X',10,'L',50,'C',100,'D',500,'M',1000);
for (int i = 0; i < s.length(); i++) {
    int value = map.get(s.charAt(i));
    if (i + 1 < s.length() && value < map.get(s.charAt(i + 1))) {
        result -= value;
    } else {
        result += value;
    }
}
System.out.println(result);

medium

A. 1904

B. 1994

C. 1094

D. 1949

Solution

1. Step 1: Understand the Roman numeral string and map values

   The string "MCMXCIV" represents a Roman numeral. Map assigns values: M=1000, C=100, X=10, I=1, V=5.

2. Step 2: Trace the loop and calculate result

   Loop through each character:
   - M(1000), next C(100): 1000 > 100, add 1000
   - C(100), next M(1000): 100 < 1000, subtract 100
   - M(1000), next X(10): 1000 > 10, add 1000
   - X(10), next C(100): 10 < 100, subtract 10
   - C(100), next I(1): 100 > 1, add 100
   - I(1), next V(5): 1 < 5, subtract 1
   - V(5), no next, add 5
   Sum = 1000 - 100 + 1000 - 10 + 100 - 1 + 5 = 1994.

3. Final Answer:

   1994 -> Option B

4. Quick Check:

   MCMXCIV = 1994 [OK]

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

Common Mistakes:

• Adding all values without subtraction
• Incorrectly subtracting when not needed
• Misreading character order

4. The following Java method aims to convert a Roman numeral string to an integer but has a bug. What is the bug?

public int romanToInt(String s) {
    Map map = Map.of('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++) {
        int value = map.get(s.charAt(i));
        if (i + 1 < s.length() && value > map.get(s.charAt(i + 1))) {
            result -= value;
        } else {
            result += value;
        }
    }
    return result;
}

medium

A. The comparison operator should be '<' instead of '>' in the if condition.

B. The map initialization is incorrect and causes runtime error.

C. The loop should start from 1 instead of 0.

D. The method does not handle lowercase Roman numerals.

Solution

1. Step 1: Analyze the if condition logic

   The code subtracts value when current value is greater than next. But Roman numerals subtract when current is less than next.

2. Step 2: Identify the correct comparison operator

   The condition should be value < map.get(next char) to subtract, not value > next value.

3. Final Answer:

   The comparison operator should be '<' instead of '>' in the if condition. -> Option A

4. Quick Check:

   Subtract when current < next [OK]

Hint: Subtract if current numeral is smaller than next [OK]

Common Mistakes:

• Using wrong comparison operator
• Ignoring subtraction rule
• Assuming map initialization error

5. You want to convert a list of Roman numerals ["XL", "IX", "MMXX"] to their integer values using Java. Which approach correctly handles this with minimal code duplication?

hard

A. Write a separate method to convert one Roman numeral to integer, then loop over the list calling this method for each element.

B. Manually convert each Roman numeral in the list with separate code blocks for each string.

C. Use a single loop over the list and convert each character individually without a helper method.

D. Convert only the first Roman numeral and reuse the result for all elements.

Solution

1. Step 1: Identify the need for reusable code

   Converting Roman numerals requires the same logic for each string. Writing a helper method avoids repeating code.

2. Step 2: Use a loop to process the list

   Loop through the list and call the helper method for each Roman numeral string to get its integer value.

3. Final Answer:

   Write a separate method to convert one Roman numeral to integer, then loop over the list calling this method for each element. -> Option A

4. Quick Check:

   Use helper method + loop for clean code [OK]

Hint: Use helper method and loop to avoid repetition [OK]

Common Mistakes:

• Repeating conversion code for each string
• Ignoring code reuse principles
• Using incorrect logic for all elements