Leetcode13. 罗马数字转整数

难度：容易

题目

---

罗马数字书写规范

1.低位减去高位 不能跨越一个位数 且 高位的数只能是I，X，C（即只能减1，减10，减100）

如99不能表示成100-1，即IC。因为C表示的100和I表示的1之间超过了一个位数。99应该表示成（100-10）+（10-1），即XCIX。
如45不能表示成50-5，因为50-5要写成VL，而低位减高位，高位的数只能是I，X，C，显然V不在此列。所以45只能写成（50-10）+ 5的形式，即XLV

2.罗马数字一般从高位到低位书写，从左向右阅读。若位于高位的数较大，则用高位的数加上低位的数；若位于高位的数较小，则用低位的数减去高位的数
3.罗马数字通过7个不同字母的重复或组合，能够表示出所有正整数（罗马数字中没有0）
4.表示为5的倍数的字母（V，L，D）不得重复。其余字母（I，X，C，M）至多可以重复3次

示例

输入: "MCMXCIV"
输出: 1994
解释: M = 1000, CM = 900, XC = 90, IV = 4.

---

思路

思路1

对于获取到的每一位字符，我们可以判断：当前位与后一位的大小关系

• 如果当前位字符的值大于后一位，那么加上当前位的值；
• 如果当前位字符的值小于后一位，那么减去当前位的值；
• 如果是最后一位，那么加上相应的值

精选描述：
可以往后看多一位，对比当前位与后一位的大小关系，从而确定当前位是加还是减法。当没有下一位时，做加法即可

也可保留当前位的值，当遍历到下一位时，对比保留值与遍历位的大小关系，再确定保留值为加还是减。最后一位做加法即可

	public static void romanToInt1(String s) {

        int sum1 = 0;

        for (int i = 0; i <= s.length() - 1; i++) {
            //保留当前位的值
            int temp = getValue(s.charAt(i));

            if (i != s.length() - 1) {
                //对比保留值与遍历位的大小关系
                if (getValue(s.charAt(i + 1)) > temp) {
                    sum1 -= temp;
                } else {
                    sum1 += temp;
                }
            } else {
                //最后一位做加法即可
                sum1 += getValue(s.charAt(i));

            }
        }

        System.out.println("罗马字符对应的值是：" + sum1);
    }

	//获取字符对应的值
    public static int getValue(char a) {
    
        switch (a) {
            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;
        }

    }

提交

class Solution {
    public int romanToInt(String s) {
        int sum = 0;
        for (int i = 0; i < s.length(); i++) {
//            char a = s.charAt(i);
            if (i != s.length() - 1) {
                int temp = getValue(s.charAt(i));
                int temp1 = getValue(s.charAt(i + 1));

                if (temp >= temp1) {
                    sum += temp;
                } else {
                    sum -= temp;
                }

//                System.out.println(sum);

            } else {
                sum += getValue(s.charAt(s.length() - 1));
//                sum += 1;
            }


        }
        return sum;

    }
    public static int getValue(char a) {
        switch (a) {
            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;
        }
    }
}

本地测试

package com.cskaoyan.otherstream;

import com.sun.org.apache.bcel.internal.generic.RETURN;

/*
罗马数字转字符

规则：
        当小值在大值的左边，则减小值，如 IV=5-1=4
        当小值在大值的右边，则加小值，如 VI=5+1=6；

        输入: "MCMXCIV"
        输出: 1994
        解释: M = 1000, CM = 900, XC = 90, IV = 4.

        输入: "LVIII"
        输出: 58
        解释: L = 50, V= 5, III = 3.
 */
public class Leetcode13 {
    public static void main(String[] args) {
        System.out.println(Conversion("MCMXCIV"));

    }

    public static int Conversion(String s) {
//        char preChar = s.charAt(0);
//        System.out.println(preChar);
        int sum = 0;
        for (int i = 0; i < s.length(); i++) {
//            char a = s.charAt(i);
            if (i != s.length() - 1) {
                int temp = getValue(s.charAt(i));
                int temp1 = getValue(s.charAt(i + 1));

                if (temp >= temp1) {
                    sum += temp;
                }else {
                    sum -= temp;
                }

//                System.out.println(sum);

            }else {
                sum += getValue(s.charAt(s.length() - 1));
//                sum += 1;
            }


        }
        return sum;
    }

    public static int getValue(char a) {
        switch (a) {
            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;
        }
    }


}

思路2

	public static int romanToInt(String s) {
        //String类中的方法
        //public String replace(CharSequence target,CharSequence replacement)
        s = s.replace("IV","a");
        s = s.replace("IX","b");

        s = s.replace("XL","c");
        s = s.replace("XC","d");

        s = s.replace("CD","e");
        s = s.replace("CM","f");

        int result = 0;
        for (int i=0; i<s.length(); i++) {
            result += which(s.charAt(i));
        }
        return result;
    }
    

    public static int which(char ch) {
        switch(ch) {
            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;

            case 'a': return 4;
            case 'b': return 9;
            case 'c': return 40;
            case 'd': return 90;
            case 'e': return 400;
            case 'f': return 900;
        }
        return 0;
    }

思路3

将所有的可能组合（按照罗马数字书写规范）添加到哈希表中
然后对字符串进行遍历，由于组合只有两种，一种是 1 个字符，一种是 2 个字符，其中 2 个字符优先于 1 个字符

先判断两个字符的组合在哈希表中是否存在，存在则将值取出加到结果 ans 中，并向后移2个字符。
不存在则将判断当前 1 个字符是否存在，存在则将值取出加到结果 ans 中，并向后移 1 个字符
遍历结束返回结果 ans

class Solution3 {
    public int romanToInt(String s) {
        Map<String, Integer> map = new HashMap<>();
        map.put("I", 1);
        map.put("IV", 4);
        map.put("V", 5);
        map.put("IX", 9);
        map.put("X", 10);
        map.put("XL", 40);
        map.put("L", 50);
        map.put("XC", 90);
        map.put("C", 100);
        map.put("CD", 400);
        map.put("D", 500);
        map.put("CM", 900);
        map.put("M", 1000);

        //MCMXCIV       s.length = 7
        int ans = 0;
        for(int i = 0;i < s.length();) {
            /**
             * 两个字符的组合在HashMap中是否存在，存在加上对应值并后移2位
             */
            //map       boolean containsKey(Object key)     是否包含指定的key
            //String    String substring(int beginIndex, int endIndex)返回一个新字符串，它是此字符串的一个子字符串
            if(i + 1 < s.length() && map.containsKey(s.substring(i, i+2))) {
                //map       Object get(Object key)：获取指定key对应的value
                        //Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
                ans += map.get(s.substring(i, i+2));
                i += 2;
                /**
                 * 加上当前字符的值，后移1位
                 */
            } else {
                ans += map.get(s.substring(i, i+1));
                i ++;
            }

        }
        return ans;
    }
}

总结

分析：

1、给定一个罗马数字：即处理字符串
		 char charAt(int index) 	返回指定索引处的 char 值
		 int length() 		返回此字符串的长度 

2、转换成整数的思想：
（我的想法）对于每一个字符，当前字符（左）和后一个字符（右）进行比较：左大右小，则累加；左小右大，则减去；
最后一个字符特殊处理。


3、用到了switch，for,if	(分支\循环\判断结构)  
4、核心代码如下：

		int sum = 0;
        for (int i = 0; i < s.length(); i++) {
//            char a = s.charAt(i);
            if (i != s.length() - 1) {
                int temp = getValue(s.charAt(i));
                int temp1 = getValue(s.charAt(i + 1));

                if (temp >= temp1) {
                    sum += temp;
                } else {
                    sum -= temp;
                }

            } else {
                sum += getValue(s.charAt(s.length() - 1));
            }
        }