LeetCode每日打卡之罗马数字转整数

刺骨的言语ヽ痛彻心扉 2023-01-21 11:19 2阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70 1]

初步看到觉得很简单，将罗马数字与对应的值用一个map装入，然后从右向左遍历，如果右边的值大于右边向前推一位的值，则需要将右边的大值 - 小值，然后跳过小值循环下一位

比如`CIV`就需要计算 `V的值`\- `I的值`，然后再直接计算C的值。实现代码如下

public  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;
            char[] chars = s.toCharArray();
            int length = chars.length;
            boolean flag;
            for (int i = length - 1; i >= 0; i--) { 
                flag = true;
                char a = chars[i];
                Integer aValue = map.get(a);
                if (i - 1 >= 0) { 
                    char b = chars[i - 1];
                    Integer bValue = map.get(b);
                    if (aValue > bValue) { 
                        flag = false;
                        int mid = aValue - bValue;
                        result += mid;
                        i--;
                    }
    
                }
                if (flag) { 
                    result += aValue;
                }
            }
    
            return result;
        }

使用map太消耗内存，优化为使用case when

public 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;
        }

内存可以打败90%人。但是代码仍然不够优雅，太长，看了其他人的代码，相对简洁优雅

别人的思想思路就是每次遍历往后看多一位，对比当前位与后一位的大小关系，从而确定当前位是加还是减法。当没有下一位时，做加法即可。他这种是正向遍历，而我那种是反向遍历

public int romanToInt(String s) { 
            int sum = 0;
            int preNum = getValue(s.charAt(0));
            // 注意从下标1开始
            for(int i = 1;i < s.length(); i ++) { 
                int num = getValue(s.charAt(i));
                if(preNum < num) { 
                    sum -= preNum;
                } else { 
                    sum += preNum;
                }
                preNum = num;
            }
            sum += preNum;
            return sum;
        }
        
        private int getValue(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;
                default: return 0;
            }
        }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70]: /images/20221020/6dabf72c81cf411cbb59e019d6942578.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjUxOTA0_size_16_color_FFFFFF_t_70 1]: /images/20221020/1085afdd31c54df4ade92b11a51986fc.png