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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Roman to Integer Conversion Function

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

DSA Typescript

function romanToInt(s: string): number {
  const map: {[key: string]: number} = {
    'I': 1, 'V': 5, 'X': 10, 'L': 50,
    'C': 100, 'D': 500, 'M': 1000
  };
  let total = 0;
  for (let i = 0; i < s.length; i++) {
    const current = map[s[i]];
    const next = map[s[i + 1]] || 0;
    if (current < next) {
      total -= current;
    } else {
      total += current;
    }
  }
  return total;
}

console.log(romanToInt('MCMXCIV'));

A 1999

B 1094

C 1994

D null (runtime error)

💡 Hint

Remember that when a smaller numeral appears before a larger one, you subtract it.

The Roman numeral 'MCMXCIV' breaks down as M(1000) + CM(900) + XC(90) + IV(4) = 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 Roman numerals are always read from right to left

B Because it represents a special case where the smaller numeral reduces the larger numeral's value

C Because it indicates the smaller numeral should be added twice

D Because the smaller numeral is a mistake and should be ignored

💡 Hint

Think about how 'IV' means 4, not 6.

When a smaller numeral comes before a larger one, it means subtract the smaller from the larger, e.g., IV = 5 - 1 = 4.

🔧 Debug

advanced

Identify the Error in Roman to Integer Conversion Code

What error will occur when running this TypeScript code snippet?

DSA Typescript

function romanToInt(s: string): number {
  const map: {[key: string]: number} = {
    'I': 1, 'V': 5, 'X': 10, 'L': 50,
    'C': 100, 'D': 500, 'M': 1000
  };
  let total = 0;
  for (let i = 0; i <= s.length; i++) {
    const current = map[s[i]];
    const next = map[s[i + 1]] || 0;
    if (current < next) {
      total -= current;
    } else {
      total += current;
    }
  }
  return total;
}

console.log(romanToInt('IX'));

A Output is NaN

B SyntaxError: Unexpected token

C Output is 9

D Output is 11

💡 Hint

Check the loop condition and array indexing carefully.

The loop runs until i <= s.length, so s[i] is undefined on the last iteration, map[s[i]] returns undefined, and total += undefined results in NaN.

📝 Syntax

advanced

Which Option Causes a Syntax Error?

Which of the following TypeScript code snippets for Roman to Integer conversion will cause a syntax error?

A const map = {'I': 1, 'V': 5, 'X': 10}; for(let i=0; i<s.length; i++) total += map[s[i]]

B const map = {'I': 1, 'V': 5, 'X': 10}; for(let i=0; i<s.length; i++) { total += map[s[i]]; }

C const map = {'I': 1, 'V': 5, 'X': 10}; for(let i=0; i<s.length; i++) total += map[s[i]];

D const map = {'I': 1, 'V': 5, 'X': 10}; for(let i=0; i<s.length; i++) { total += map[s[i]] }

💡 Hint

Look carefully at the missing semicolon or braces.

Option A is missing a semicolon at the end of the statement, which causes a syntax error in TypeScript strict mode.

🚀 Application

expert

Result of Complex Roman Numeral Conversion

What is the integer value returned by the following TypeScript function call?

DSA Typescript

function romanToInt(s: string): number {
  const map: {[key: string]: number} = {
    'I': 1, 'V': 5, 'X': 10, 'L': 50,
    'C': 100, 'D': 500, 'M': 1000
  };
  let total = 0;
  for (let i = 0; i < s.length; i++) {
    const current = map[s[i]];
    const next = map[s[i + 1]] || 0;
    if (current < next) {
      total -= current;
    } else {
      total += current;
    }
  }
  return total;
}

console.log(romanToInt('MMMDCCCLXXXVIII'));

A null (runtime error)

B 3887

C 3889

D 3888

💡 Hint

Break down the numeral into thousands, hundreds, tens, and ones.

'MMMDCCCLXXXVIII' is 3000 (MMM) + 800 (DCCC) + 80 (LXXX) + 8 (VIII) = 3888.

Practice

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

easy

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

B. Multiply all symbol values together

C. Add values only if symbols are the same

D. Subtract all symbol values from 1000

Solution

1. Step 1: Understand Roman numeral rules

   Roman numerals are converted by adding values of symbols, but if a smaller value comes before a larger one, it is subtracted.

2. Step 2: Apply the rule to conversion

   For example, IV is 5 - 1 = 4, not 1 + 5 = 6.

3. Final Answer:

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

4. Quick Check:

   Roman to integer = add/subtract values [OK]

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

Common Mistakes:

• Always adding values without subtraction
• Multiplying symbol values
• Ignoring order of symbols

2. Which TypeScript syntax correctly defines a function to convert Roman numerals to integers?

easy

A. def romanToInt(s): return 0

B. function romanToInt(s: string): number { return 0; }

C. func romanToInt(s string) int { return 0 }

D. romanToInt = (s) => { return '0'; }

Solution

1. Step 1: Identify TypeScript function syntax

   TypeScript functions use the syntax: function name(params): returnType { body }

2. Step 2: Match correct syntax

   function romanToInt(s: string): number { return 0; } matches TypeScript syntax with parameter type and return type specified.

3. Final Answer:

   function romanToInt(s: string): number { return 0; } -> Option B

4. Quick Check:

   TypeScript function syntax = function romanToInt(s: string): number { return 0; } [OK]

Hint: Use 'function name(params: type): returnType' in TypeScript [OK]

Common Mistakes:

• Using Python or Go syntax in TypeScript
• Returning string instead of number
• Missing type annotations

3. What is the output of this TypeScript code?

function romanToInt(s: string): number {
  const map: {[key: string]: number} = {I:1, V:5, X:10, L:50, C:100, D:500, M:1000};
  let total = 0;
  for(let i = 0; i < s.length; i++) {
    const current = map[s[i]];
    const next = map[s[i+1]] || 0;
    if(current < next) total -= current;
    else total += current;
  }
  return total;
}
console.log(romanToInt('IX'));

medium

A. 11

B. 4

C. 9

D. Error

Solution

1. Step 1: Trace the loop for 'IX'

   For 'I' (1) and next 'X' (10), since 1 < 10, subtract 1. For 'X' (10), no next, add 10.

2. Step 2: Calculate total

   Total = -1 + 10 = 9.

3. Final Answer:

   9 -> Option C

4. Quick Check:

   'IX' = 9 [OK]

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

Common Mistakes:

• Adding all values without subtraction
• Off-by-one error in loop
• Not handling last character correctly

4. Find the bug in this TypeScript code for Roman to Integer conversion:

function romanToInt(s: string): number {
  const map = {I:1, V:5, X:10, L:50, C:100, D:500, M:1000};
  let total = 0;
  for(let i = 0; i <= s.length; i++) {
    const current = map[s[i]];
    const next = map[s[i+1]] || 0;
    if(current < next) total -= current;
    else total += current;
  }
  return total;
}

medium

A. Return type should be string, not number

B. map object keys should be lowercase

C. Use 'var' instead of 'let' for i

D. Loop condition should be i < s.length, not i <= s.length

Solution

1. Step 1: Check loop boundary

   The loop runs from i = 0 to i <= s.length, which causes s[i] to be undefined at last iteration.

2. Step 2: Correct loop condition

   Change to i < s.length to avoid accessing undefined index.

3. Final Answer:

   Loop condition should be i < s.length, not i <= s.length -> Option D

4. Quick Check:

   Loop boundary off-by-one error fixed [OK]

Hint: Use i < length to avoid out-of-bounds access [OK]

Common Mistakes:

• Using <= instead of < in loops
• Wrong case for map keys
• Incorrect return type

5. Given the Roman numeral string 'MCMXCIV', what integer does the following TypeScript function return?

function romanToInt(s: string): number {
  const map: {[key: string]: number} = {I:1, V:5, X:10, L:50, C:100, D:500, M:1000};
  let total = 0;
  for(let i = 0; i < s.length; i++) {
    const current = map[s[i]];
    const next = map[s[i+1]] || 0;
    if(current < next) total -= current;
    else total += current;
  }
  return total;
}
console.log(romanToInt('MCMXCIV'));

hard

A. 1994

B. 1904

C. 2004

D. 1494

Solution

1. Step 1: Break down 'MCMXCIV'

   M=1000, C=100, M=1000, X=10, C=100, I=1, V=5. Apply subtraction where smaller precedes larger.

2. Step 2: Calculate total step-by-step

   1000 (M) + (100 < 1000, subtract 100) + 1000 + (10 < 100, subtract 10) + 100 + (1 < 5, subtract 1) + 5 = 1000 - 100 + 1000 - 10 + 100 - 1 + 5 = 1994.

3. Final Answer:

   1994 -> Option A

4. Quick Check:

   'MCMXCIV' = 1994 [OK]

Hint: Subtract smaller before larger, else add [OK]

Common Mistakes:

• Adding all values without subtraction
• Misreading symbol order
• Skipping last character