Roman to Integer Conversion in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to get the integer value of a single Roman numeral character.

DSA Go

func value(r byte) int {
    switch r {
    case 'I':
        return [1]
    case 'V':
        return 5
    case 'X':
        return 10
    case 'L':
        return 50
    case 'C':
        return 100
    case 'D':
        return 500
    case 'M':
        return 1000
    default:
        return 0
    }
}

Drag options to blanks, or click blank then click option'

A1

B0

C10

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Returning 0 instead of 1 for 'I'.

Confusing 'I' with 'V' or 'X'.

The Roman numeral 'I' represents the integer 1.

2fill in blank

medium

Complete the code to iterate through the Roman numeral string correctly.

DSA Go

func romanToInt(s string) int {
    total := 0
    for i := 0; i < [1]; i++ {
        // logic here
    }
    return total
}

Drag options to blanks, or click blank then click option'

Alen(s)

Bcap(s)

Clen(s) + 1

Dlen(s) - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using len(s) - 1 as loop condition, which misses the last character.

Using cap(s), which is not valid for strings.

We iterate from 0 to len(s)-1, so the loop condition is i < len(s).

3fill in blank

hard

Fix the error in the condition to check if the current Roman numeral is less than the next one.

DSA Go

if i+1 < len(s) && value(s[i]) [1] value(s[i+1]) {
    total -= value(s[i])
} else {
    total += value(s[i])
}

Drag options to blanks, or click blank then click option'

A>

B==

C<

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>' instead of '<' causing wrong subtraction logic.

Using '==' which does not handle subtraction cases.

If the current value is less than the next, we subtract it according to Roman numeral rules.

4fill in blank

hard

Fill both blanks to complete the function that converts Roman numerals to integers.

DSA Go

func romanToInt(s string) int {
    total := 0
    for i := 0; i < [1]; i++ {
        if i+1 < len(s) && value(s[i]) [2] value(s[i+1]) {
            total -= value(s[i])
        } else {
            total += value(s[i])
        }
    }
    return total
}

Drag options to blanks, or click blank then click option'

Alen(s)

B<

C>

Dlen(s) - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Looping only till len(s)-1 causing last character to be skipped.

Using '>' instead of '<' in subtraction condition.

Loop runs till i < len(s) and subtraction happens when current value is less than next.

5fill in blank

hard

Fill all three blanks to create a map of Roman numerals and use it in the conversion function.

DSA Go

var romanMap = map[byte]int{
    'I': [1],
    'V': [2],
    'X': [3],
}

func romanToInt(s string) int {
    total := 0
    for i := 0; i < len(s); i++ {
        if i+1 < len(s) && romanMap[s[i]] < romanMap[s[i+1]] {
            total -= romanMap[s[i]]
        } else {
            total += romanMap[s[i]]
        }
    }
    return total
}

Drag options to blanks, or click blank then click option'

A1

B5

C10

D50

Attempts:

3 left

💡 Hint

Common Mistakes

Incorrect mapping values causing wrong results.

Not using the map for value lookup.

Roman numerals I=1, V=5, X=10 are mapped correctly for conversion.

Practice

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

easy

A. 6

B. 11

C. 19

D. 9

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 D

4. Quick Check:

   IX = 9 [OK]

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

Common Mistakes:

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

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

easy

A. romanMap := map[string]int{"I" = 1, "V" = 5, "X" = 10}

B. romanMap := map[int]string{1: "I", 5: "V", 10: "X"}

C. romanMap := map[string]int{"I": 1, "V": 5, "X": 10}

D. romanMap := map[string]int{I: 1, V: 5, X: 10}

Solution

1. Step 1: Check map key and value types

   The map should have string keys (Roman numerals) and int values (their integer equivalents). romanMap := map[string]int{"I": 1, "V": 5, "X": 10} uses map[string]int correctly.

2. Step 2: Verify syntax correctness

   romanMap := map[string]int{"I": 1, "V": 5, "X": 10} uses correct Go syntax with colon ':' to assign values. Options A and C have syntax errors, and B reverses key-value types.

3. Final Answer:

   romanMap := map[string]int{"I": 1, "V": 5, "X": 10} -> Option C

4. Quick Check:

   Correct map syntax uses colons and proper types [OK]

Hint: Use colon ':' for map key-value pairs in Go [OK]

Common Mistakes:

• Using '=' instead of ':' in map initialization
• Swapping key and value types
• Omitting quotes around string keys

3. What will be the output of the following Go code snippet?

func romanToInt(s string) int {
    romanMap := map[byte]int{'I': 1, 'V': 5, 'X': 10}
    total := 0
    for i := 0; i < len(s); i++ {
        if i+1 < len(s) && romanMap[s[i]] < romanMap[s[i+1]] {
            total -= romanMap[s[i]]
        } else {
            total += romanMap[s[i]]
        }
    }
    return total
}

fmt.Println(romanToInt("IV"))

medium

A. 6

B. 4

C. 9

D. Error

Solution

1. Step 1: Analyze the loop and subtraction logic

   The code subtracts the value if the current numeral is less than the next one, else adds it. For "IV", 'I' (1) < 'V' (5), so subtract 1, then add 5.

2. Step 2: Calculate total value

   Total = -1 + 5 = 4.

3. Final Answer:

   4 -> Option B

4. Quick Check:

   IV = 4 using subtraction rule [OK]

Hint: Subtract when current < next numeral [OK]

Common Mistakes:

• Adding all values without subtraction
• Index out of range errors
• Confusing byte and string keys in map

4. The following Go function is intended to convert Roman numerals to integers. What is the bug?

func romanToInt(s string) int {
    romanMap := map[byte]int{'I': 1, 'V': 5, 'X': 10}
    total := 0
    for i := 0; i < len(s); i++ {
        if romanMap[s[i]] < romanMap[s[i+1]] {
            total -= romanMap[s[i]]
        } else {
            total += romanMap[s[i]]
        }
    }
    return total
}

medium

A. Missing check for i+1 < len(s) causing index out of range

B. Using map with byte keys instead of string keys

C. Incorrect subtraction logic for Roman numerals

D. Returning total before loop ends

Solution

1. Step 1: Identify loop boundary issue

   The code accesses s[i+1] without checking if i+1 is within string length, causing possible index out of range error.

2. Step 2: Explain fix

   Adding condition 'i+1 < len(s)' before accessing s[i+1] prevents runtime error.

3. Final Answer:

   Missing check for i+1 < len(s) causing index out of range -> Option A

4. Quick Check:

   Always check bounds before accessing next element [OK]

Hint: Check i+1 < len(s) before accessing s[i+1] [OK]

Common Mistakes:

• Ignoring string length check for next index
• Confusing byte and string keys (not a bug here)
• Incorrect subtraction logic (logic is correct)

5. Given the Roman numeral MCMXCIV, what integer does it convert to using the standard Roman to Integer rules?

hard

A. 1994

B. 1984

C. 2004

D. 1949

Solution

1. Step 1: Break down the numeral into parts

   M = 1000, CM = 900 (100 before 1000 means subtract 100), XC = 90 (10 before 100), IV = 4 (1 before 5).

2. Step 2: Sum all parts

   1000 + 900 + 90 + 4 = 1994.

3. Final Answer:

   1994 -> Option A

4. Quick Check:

   MCMXCIV = 1994 by adding and subtracting parts [OK]

Hint: Add values, subtract when smaller before larger [OK]

Common Mistakes:

• Adding all numerals without subtraction
• Misreading CM as 1100 instead of 900
• Ignoring subtraction pairs