Преобразовать число в римскую цифру в javaScript

Question

Как я могу преобразовать целые числа в римские цифры ?

function romanNumeralGenerator (int) {

}

Например, см. Следующие примеры входов и выходов:

1 = "I"
5 = "V"
10 = "X"
20 = "XX"
3999 = "MMMCMXCIX"

Предупреждение: поддерживаются только цифры от 1 до 3999

Answer 1

Эта функция работает с различными наборами символов в каждой цифре.Чтобы добавить еще одну цифру, добавьте строку с римскими цифрами 1 место, 5 место и следующее 1 место.Это хорошо, потому что вы обновляете его, зная только следующий набор используемых символов.

function toRoman(n){
  var d=0,o="",v,k="IVXLCDM".split("");
                    
  while(n!=0){
    v=n%10,x=k[d],y=k[d+1],z=k[d+2];
    o=["",x,x+x,x+x+x,x+y,y,y+x,y+x+x,y+x+x+x,x+z][v]+o;
    n=(n-v)/10,d+=2;
  }
  
  return o
}

var out = "";

for (var i = 0; i < 100; i++) {
  out += toRoman(i) + "\n";
}

document.getElementById("output").innerHTML = out;

Answer 2

Вот мое решение:

function convertToRoman(num) { 
    let romanNum = "";
    const strNum = String(num);
    const romans = {
        1: ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"], // ones
        2: ["X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"], // tens
        3: ["C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"], // hundreds
        4: ["M", "MM", "MMM"] // thousands
    };

    for (let i = 1; i <= strNum.length; i++)
        if (Number(strNum[strNum.length - i]) !== 0)
            romanNum = romans[i][strNum[strNum.length - i] - 1] + romanNum;

    return romanNum;
}

Он достаточно хорошо работает в Chrome 60 - https://jsperf.com/num-to-roman

Answer 3

Вот мое «функциональное решение» .

var numerals = ["I","V","X","L","C","D","M"],
      number = 1453,
      digits = Array(~~(Math.log10(number)+1)).fill(number).map((n,i) => Math.trunc(n%Math.pow(10,i+1)/Math.pow(10,i))),  // <- [3,5,4,1]
      result = digits.reduce((p,c,i) => (c === 0 ? ""
                                                 : c < 4 ? numerals[2*i].repeat(c)
                                                         : c === 4 ? numerals[2*i] + numerals[2*i+1]
                                                                   : c < 9 ? numerals[2*i+1] + numerals[2*i].repeat(c-5)
                                                                           : numerals[2*i] + numerals[2*i+2]) + p,"");
console.log(result);

Answer 4

Это решение запускает только один цикл и имеет минимальный объект для преобразования цифр в латинские буквы

function RomantoNumeral(r){
  let result = 0,
      keys = {M:1000, D:500, C:100, L:50, C:100, L:50, X:10, V:5, I:1},
      order = Object.keys(keys),
      rom = Array.from(r) 

  rom.forEach((e, i)=>{
    if( i  < rom.length -1 && order.indexOf(e) > order.indexOf(rom[i+1])){
      result -= keys[e]
    } else {
      result +=keys[e]
    }
  })  
  return result
}

RomantoNumeral('MMDCCCXXXVII') #2837

Answer 5

Это мое решение с одной петлей

function convertToRoman(num) {
  var roman = {
    M: 1000,
    CM: 900,
    D: 500,
    CD: 400,
    C: 100,
    XC: 90,
    L: 50,
    XL: 40,
    X: 10,
    IX: 9,
    V: 5,
    IV: 4,
    I: 1
  };

  var romanNum = "";

  for(key in roman){
      var check = num>=roman[key];
      if(check){
          console.log(romanNum);
          romanNum += key;
          num-= roman[key]; 
      }
  }
  return romanNum
}

convertToRoman(150);

Answer 6

Я попытался сделать это, сопоставив массив арабских цифр с массивом римских пар.Противные трехуровневые тройки можно заменить блоками if () {} else {}, чтобы сделать их более читабельными.Он работает с 1 по 3999, но может быть расширен:

function romanize(num) {
  if(num > 3999 || num < 1) return 'outside range!';
  const roman = [ ['M', ''], [ 'C', 'D' ], [ 'X', 'L' ], [ 'I', 'V' ] ];
  const arabic = num.toString().padStart(4, '0').split('');
  return arabic.map((e, i) => {
    return (
      e < 9 ? roman[i][1].repeat(Math.floor(e / 5)) : ''
    ) + (
      e % 5 < 4
        ? roman[i][0].repeat(Math.floor(e % 5))
        : e % 5 === 4 && Math.floor(e / 5) === 0
          ? roman[i][0] + roman[i][1]
          : Math.floor(e / 5) === 1
            ? roman[i][0] + roman[i - 1][0]
            : ''
    );
  }).join('');
}

Answer 7

function convertToRoman(num) {
  var toTen = ["", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X"];
  var toHungred = ["", "X" ,"XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC", "C"];
  var toThousend = ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM", "M"];  			
  var arrString = String(num).split("");  
  var arr = [];           
  if (arrString.length == 3 ){  				
  	  	arr.push(toThousend[arrString[+0]]);
  	  	arr.push(toHungred[arrString[+1]]);
  	  	arr.push(toTen[arrString[+2]]);
   } 
  else if (arrString.length == 2 ){  				
   	  arr.push(toHungred[arrString[+0]]);
  	  arr.push(toTen[arrString[+1]]);  			  	
  }
  else if (arrString.length == 1 ){  				
  	arr.push(toTen[arrString[+0]]);  			  	  	
  }
  else if (arrString.length == 4 ) {
    for (var i =1; i<=[arrString[+0]]; i++) {
                  arr.push("M");                  
                }
    arr.push(toThousend[arrString[+1]]);
  	arr.push(toHungred[arrString[+2]]);
  	arr.push(toTen[arrString[+3]]);
  }              
  console.log (arr.join(""));
}

convertToRoman(36);

Answer 8

В этом коде верхний предел чисел можно расширить, добавив новые буквы в letterTable:

letterTable = {
  0:{
    1:'I',
    5:'V',
    10:'X'
  },
  1:{
    1:'X',
    5:'L',
    10:'C'
  },
  2:{
    1:'C',
    5:'D',
    10:'M'
  },
  3:{
    1:'M',
    5:'V', // There should be a dash over this letter
    10:'X' // There should be a dash over this letter
  }, 
  // you can add new level of letters here
};

function romanLetter(i, j){
  romanTable = {
    '0':'',
    '1':letterTable[i][1],
    '2':letterTable[i][1]+letterTable[i][1],
    '3':letterTable[i][1]+letterTable[i][1]+letterTable[i][1],
    '4':letterTable[i][1]+letterTable[i][5],
    '5':letterTable[i][5],
    '6':letterTable[i][5]+letterTable[i][1],
    '7':letterTable[i][5]+letterTable[i][1]+letterTable[i][1],
    '8':letterTable[i][5]+letterTable[i][1]+letterTable[i][1]+letterTable[i][1],
    '9':letterTable[i][1]+letterTable[i][10]
  };

  return romanTable[j];
}


function convertToRoman(num) {

  numStr = String(num);
  var result = '';
  var level = 0;

  for (var i=numStr.length-1; i>-1; i--){
    result = romanLetter(level, numStr[i]) + result;
    level++;
  }

  return result;
}

Answer 9

Я написал это с нуля для вызова freecodecamp.Надеюсь, это кому-нибудь поможет.

function convertToRoman(num) {

    var nums = [0, 0, 0, 0];

    var numsRom = ["", "", "", ""];

    var nRom = {
        I: "I",
        V: "V",
        X: "X",
        L: "L",
        C: "C",
        D: "D",
        M: "M"
    };
    /*
    1,
    5,
    10,
    50,
    100,
    500,
    1000
    */

    var i;

    nums[0] = Math.floor(num / 1000);
    nums[1] = Math.floor((num - nums[0] * 1000) / 100);
    nums[2] = Math.floor((num - nums[0] * 1000 - nums[1] * 100) / 10);
    nums[3] = num - nums[0] * 1000 - nums[1] * 100 - nums[2] * 10;

    //1000
    for (i = 0; i < nums[0]; i++) {
        numsRom[0] += nRom.M;
    }

    //100
    switch (nums[1]) {
        case 1:
        case 2:
        case 3:
            for (i = 0; i < nums[1]; i++) {
                numsRom[1] += nRom.C;
            }
            break;
        case 4:
            numsRom[1] += nRom.C + nRom.D;
            break;
        case 5:
            numsRom[1] += nRom.D;
            break;
        case 6:
        case 7:
        case 8:
            numsRom[1] += nRom.D;
            for (i = 0; i < nums[1] - 5; i++) {
                numsRom[1] += nRom.C;
            }
            break;
        case 9:
            numsRom[1] += nRom.C + nRom.M;
    }

    //10
    switch (nums[2]) {
        case 1:
        case 2:
        case 3:
            for (i = 0; i < nums[2]; i++) {
                numsRom[2] += nRom.X;
            }
            break;
        case 4:
            numsRom[2] += nRom.X + nRom.L;
            break;
        case 5:
            numsRom[2] += nRom.L;
            break;
        case 6:
        case 7:
        case 8:
            numsRom[2] += nRom.L;
            for (i = 0; i < nums[2] - 5; i++) {
                numsRom[2] += nRom.X;
            }
            break;
        case 9:
            numsRom[2] += nRom.X + nRom.C;
    }

    //1
    switch (nums[3]) {
        case 1:
        case 2:
        case 3:
            for (i = 0; i < nums[3]; i++) {
                numsRom[3] += nRom.I;
            }
            break;
        case 4:
            numsRom[3] += nRom.I + nRom.V;
            break;
        case 5:
            numsRom[3] += nRom.V;
            break;
        case 6:
        case 7:
        case 8:
            numsRom[3] += nRom.V;
            for (i = 0; i < nums[3] - 5; i++) {
                numsRom[3] += nRom.I;
            }
            break;
        case 9:
            numsRom[2] += nRom.I + nRom.X;
    }

    return numsRom.join("");
}

console.log("Number: " + 1234 + " is " + convertToRoman(1234));

Answer 10

Я ненавижу перечислять каждую возможность в массив (который многие люди решили решить эту загадку), поэтому я использую другую функцию для этой работы.Вот мое решение:

//a function that convert a single number to roman number, you can choose how to convert it so later you can apply to different part of the number
function romannum(num,rnum1,rnum2,rnum3){
  var result = "";
  if(num >= 1 && num < 4){
    while(num>0){
      result += rnum1;
      num--;
    }
  }
  else if(num > 5 && num < 9){
    result = rnum2;
    while(num>5){
      result += rnum1;
      num--;
    }  
  }
  else if(num == 4){
    result += rnum1 + rnum2;
  }
  else if( num == 5){
    result += rnum2;
  }
  else if( num == 9){
    result += rnum1+ rnum3;
  }
  return result;
}
//the main function
function convertToRoman(num) {
 num = num.toString().split('');
 var length = num.length;
 var x = 0;
 var result =[];

 while((length - x) > 0){
   if(length -x === 4){
    result.push(romannum(num[x],"M","",""));
   }
   else if(length -x  === 3){
     result.push(romannum(num[x],"C","D","M"));
   }
   else if(length - x  === 2){
     result.push(romannum(num[x],"X","L","C"));
   }
   else if(length - x === 1){
     result.push(romannum(num[x],"I","V","X"));
   }
   x++;  
 }