剑指leetcode—整数转罗马数字

题目描述：罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。

字符 数值

I 表示的是 1
V 表示的是 5
X 表示的是 10
L 表示的是 50
C 表示的是 100
D 表示的是 500
M 表示的是 1000

例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。

示例 1:
输入: 3
输出: “III”

示例 2:

输入: 4
输出: “IV”

示例 3:
输入: 9
输出: “IX”

示例 4:
输入: 58
输出: “LVIII”
解释: L = 50, V = 5, III = 3.

示例5:
输入: 1994
输出: “MCMXCIV”
解释: M = 1000, CM = 900, XC = 90, IV = 4.

这道题目不难，实际上就是一一对应的问题，依次转换为罗马对应的字母。找出特殊情况。

罗马数字符号

罗马数字由七个单字母符号组成，每一个符号都有自己的价值，此外，减法规则给出了额外的六个符号，所以一共有十三个独特的符号。

一个整数表示为一个罗马数字，通过从上到下查找符号来增加它的值。

歧义处理

方法一：贪心方法
给定整数，转换为十三个独特符号中的特殊表示，而且需要满足表示大的罗马数字需要在表示小的罗马数字之前，所以十三个独特的符号必须按照从大到小的顺序排列。
关键：表示应该尽可能使用大的符号，从最左侧开始工作。从上到下依次查找。
为了表示一个给定的整数，我们寻找适合它的最大符号。我们减去它，然后寻找适合余数的最大符号，依此类推，直到余数为0。我们取出的每个符号都附加到输出的罗马数字字符串上。
贪心算法的意义：贪心算法是一种在当前时间做出最佳可能决策的算法；在这种情况下，它会取出最大可能的符号。、、

java语言实现：

class Solution {
 String string []={"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};
 int [] values={1000,900,500,400,100,90,50,40,10,9,5,4,1};
    public String intToRoman(int num) {
     StringBuilder sb=new StringBuilder();
     for(int i=0;num>0;i++)
     {
      while(num>=values[i])
      {
       num=num-values[i];
       sb.append(string[i]);
      }
     }
  return sb.toString();
    }
}

for(int i=0;num>0;i++)
     {
      while(num>=values[i])
      {
       num=num-values[i];
       sb.append(string[i]);
      }
     }
     这段代码for循环中有一个点需要注意
     1. num的最后的值只会是0，所以这里的结束条件是num=0，
     for结束。
     2. for中也可以这样表示，
      for (int i = 0; i < values.length && num >= 0; i++) 
      当num=0了，但是i超过了values数组的最大下标13，for也会结束

     

方法二：硬编码数字
当把整数转换成罗马数字时，整数的十进制表示中的每一个数字都可以单独处理。所有的符号可以根据在 1000，100，10 和 1 的最大因子分成多个组。
当数字至少为 1000 时，将向输出追加 M(1000），并从整数中减去 1000。其他符号在数字低于 1000 之前都不会被考虑。此外，M(1000) 不能表示数字的任何较低的部分。因此，我们可以用 M(1000) 来表示整数的千位。
现在，假设我们有 100 到 999 之间的余数。接下来考虑在此范围的符号。最高的符号是 CM(900)，最低的是 C(100)。此范围内的任何符号都不可能修改成十或一。只要余数仍在100以上，我们就至少可以取 C(100)。这意味着只要数字至少是 100，我们就只能从余数中减去符号。
同样的方法也适用于十，然后是一。
因此，我们可以计算出每个数字在每个地方的表示形式。总共有 34 个，千列是 0、1、2、3、4，百、十、一列是 0、1、2、3、4、5、6、7、8、9。因此，计算出它们的表示情况，并对它们进行硬编码。然后，将整数转换为罗马数字将需要将整数分解为并将每个数字的表示追加到结果。

thousands=integer/1000;
hundred=(integer%1000)/100;
ten=(integer%100)/10;
one=integer%10;

然后，我们可以简单地在硬编码表中查找这些结果，并将结果附加在一起！
算法：
在代码中实现它最简单的方法是使用 4 个独立的数组；每个位置值对应一个数组。然后，在输入数字中提取每个位置的数字，在相关数组中查找它们的符号，并将它们全部附加在一起。

java语言实现

public String intToRoman(int num) {
    String[] thousands = {"", "M", "MM", "MMM"};
    String[] hundreds = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"}; 
    String[] tens = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
    String[] ones = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
    return thousands[num / 1000] + hundreds[num % 1000 / 100] + tens[num % 100 / 10] + ones[num % 10];
}

这种方法的缺点，如果拓展罗马数字，它不是灵活的，例如，如果我们说符号H现在表示5000，而p现在表示10000，允许我们表示多达39999的数字，会怎么样？对于方法二，需要计算并硬编码10个新的表示。如果我们再加上一些符号就可以达到399999999呢？方法二就变得越来越难管理，因为添加的而符号越多。

C语言实现：

char * intToRoman(int num)
{
 int i;
 int sym[13]={0};
 int div[13]={1000,  900, 500,  400, 100,   90,  50,   40,  10,    9,   5,    4,   1};
 char symcat[13][3] = { "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
 char *s=(char *)malloc(20*sizeof(char));
 memset(s,0,20*sizeof(char));
 for(i=0;i<13;i++)
 {
  sym[i]=num/div[i];
  num=num%div[i];
 }
 for(i=0;i<13;i++)
 {
  while(sym[i]-->0)
  {
   strcat(s,symcat[i]);
  }
 }
 return s;
}