La conversione di un numero in un Numero Romano in javaScript

Come posso convertire interi in numeri romani?

function romanNumeralGenerator (int) {

}

Per esempio, vedere il seguente esempio di ingressi e uscite:

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

Avvertenza: Solo il supporto di numeri compresi tra 1 e 3999

  • Cosa hai provato finora e perché avete bisogno di questo? Inoltre, questo è stato coperto per altre lingue. Non dovrebbe essere difficile per convertire il codice.
  • Date un’occhiata a questo post, che vi aiuterà. blog.stevenlevithan.com/archives/…
  • Alcuni dei programmatori qui, probabilmente, poteva scrivere una funzione in pochi minuti. Ma, onestamente, si dovrebbe provare prima se stessi e poi chiedi se ti trovi in difficoltà.
  • numero Romano converter
  • qualsiasi aiuto o un modo per capire meglio, per me, è già qualcosa
  • MMMIM sarebbe anche 3999

InformationsquelleAutor DD77 | 2012-01-31

 

59 Replies
  1. 81

    C’è una bella qui su questo blog ho trovato usando google:

    http://blog.stevenlevithan.com/archives/javascript-roman-numeral-converter

    function romanize (num) {
        if (isNaN(num))
            return NaN;
        var digits = String(+num).split(""),
            key = ["","C","CC","CCC","CD","D","DC","DCC","DCCC","CM",
                   "","X","XX","XXX","XL","L","LX","LXX","LXXX","XC",
                   "","I","II","III","IV","V","VI","VII","VIII","IX"],
            roman = "",
            i = 3;
        while (i--)
            roman = (key[+digits.pop() + (i * 10)] || "") + roman;
        return Array(+digits.join("") + 1).join("M") + roman;
    }
    • Promemoria: Questo dovrebbe meglio tornare NaN o buttare invece di restituire false come discusso in questo post.
  2. 62
    function romanize(num) {
      var lookup = {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},roman = '',i;
      for ( i in lookup ) {
        while ( num >= lookup[i] ) {
          roman += i;
          num -= lookup[i];
        }
      }
      return roman;
    }

    Pubblicato da nel 2008, in un commento che si trova in: http://blog.stevenlevithan.com/archives/javascript-roman-numeral-converter

    GUARDA LA DEMO

    • Questo è bello, sembra mentalmente più facile analizzare ciò che sta accadendo qui. A partire al più grande numero, continuare a sottrarre dalla tabella di ricerca e aggiungendo, come lungo come il resto è superiore al valore di ricerca.
    • Bello, mi ha preso un micro secondo per capire, che cosa circa la complessità
    • Gli oggetti non hanno un ordine!!! Si consiglia di utilizzare un array e di evitare for...in.
    • È abbastanza semplice, utilizzare il più grande dei numeri fino a quando non può più, altrimenti prova più piccola in linea. Io non sono riuscito a trovare un metodo più veloce di questo. Credo che gli oggetti sono più veloci rispetto alle matrici in questo caso. Se si può capire come ottenere prestazioni ancora migliori, si prega di postare un esempio. Grazie per il feedback e consigli!
    • Non sto parlando di prestazioni. Io sto dicendo che l’ordine di iterazione non è garantita, quindi il risultato potrebbe essere completamente sbagliato.
    • si prega di mostrare un esempio di un caso in cui un oggetto javascript iterazione ordine non sarà garantita. Altrimenti credo si traina
    • Non riesco a dare un non-lavoro, ad esempio, l’ordine è l’implementazione dipendente. Invece, si prega di collegamento di me, parte della specifica assicura che sarà ripetuta con l’ordine desiderato. Oh, non è possibile.
    • Ci potrebbe essere un’implementazione che non funziona. Ma finora testato di lavoro nel nodo, chrome, firefox e IE
    • gli oggetti non hanno alcun modo l’ho implementato come un elenco di coppie [{M:1000}, ...]
    • Ecco un esempio in cui l’ordine cambia in alcuni browser: for (let i in { '2': 2, '1': 1 }) console.log(i);. Inoltre, anche se si prova, non significa che funziona sempre. Ci potrebbero essere casi in cui un browser cambia l’ordine per motivi di prestazioni o di qualsiasi motivo. Si può essere sicuri, se si conosce il codice sorgente di ogni versione del browser che si supportano e si desidera supportare in futuro.

  3. 39

    Non capisco perché tutti quanti soluzione è così lungo e utilizza più per i passanti.

    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 str = '';
    
      for (var i of Object.keys(roman)) {
        var q = Math.floor(num / roman[i]);
        num -= q * roman[i];
        str += i.repeat(q);
      }
    
      return str;
    }
  4. 13

    Queste funzioni la conversione di qualsiasi numero intero positivo al suo equivalente in Numero Romano stringa; e qualsiasi Numero Romano per il suo numero.

    Numero Numero Romano:

    Number.prototype.toRoman= function () {
        var num = Math.floor(this), 
            val, s= '', i= 0, 
            v = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1], 
            r = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I']; 
    
        function toBigRoman(n) {
            var ret = '', n1 = '', rem = n;
            while (rem > 1000) {
                var prefix = '', suffix = '', n = rem, s = '' + rem, magnitude = 1;
                while (n > 1000) {
                    n /= 1000;
                    magnitude *= 1000;
                    prefix += '(';
                    suffix += ')';
                }
                n1 = Math.floor(n);
                rem = s - (n1 * magnitude);
                ret += prefix + n1.toRoman() + suffix;
            }
            return ret + rem.toRoman();
        }
    
        if (this - num || num < 1) num = 0;
        if (num > 3999) return toBigRoman(num);
    
        while (num) {
            val = v[i];
            while (num >= val) {
                num -= val;
                s += r[i];
            }
            ++i;
        }
        return s;
    };

    Numero romano stringa a Numero:

    Number.fromRoman = function (roman, accept) {
        var s = roman.toUpperCase().replace(/+/g, ''), 
            L = s.length, sum = 0, i = 0, next, val, 
            R = { M: 1000, D: 500, C: 100, L: 50, X: 10, V: 5, I: 1 };
    
        function fromBigRoman(rn) {
            var n = 0, x, n1, S, rx =/(\(*)([MDCLXVI]+)/g;
    
            while ((S = rx.exec(rn)) != null) {
                x = S[1].length;
                n1 = Number.fromRoman(S[2])
                if (isNaN(n1)) return NaN;
                if (x) n1 *= Math.pow(1000, x);
                n += n1;
            }
            return n;
        }
    
        if (/^[MDCLXVI)(]+$/.test(s)) {
            if (s.indexOf('(') == 0) return fromBigRoman(s);
    
            while (i < L) {
                val = R[s.charAt(i++)];
                next = R[s.charAt(i)] || 0;
                if (next - val > 0) val *= -1;
                sum += val;
            }
            if (accept || sum.toRoman() === s) return sum;
        }
        return NaN;
    };
  5. 13

    Ho sviluppato la soluzione ricorsiva di seguito. La funzione restituisce una lettera e poi si chiama restituire la lettera successiva. Lo fa fino a quando il numero passato alla funzione è 0 il che significa che tutte le lettere sono stati trovati e siamo in grado di uscire la ricorsione.

    var romanMatrix = [
      [1000, 'M'],
      [900, 'CM'],
      [500, 'D'],
      [400, 'CD'],
      [100, 'C'],
      [90, 'XC'],
      [50, 'L'],
      [40, 'XL'],
      [10, 'X'],
      [9, 'IX'],
      [5, 'V'],
      [4, 'IV'],
      [1, 'I']
    ];
    
    function convertToRoman(num) {
      if (num === 0) {
        return '';
      }
      for (var i = 0; i < romanMatrix.length; i++) {
        if (num >= romanMatrix[i][0]) {
          return romanMatrix[i][1] + convertToRoman(num - romanMatrix[i][0]);
        }
      }
    }
    • Mi piace molto la tua soluzione. Facile da leggere, capire e molto semplice. Bello!
    • C’è anche il numero di ripetizioni che accade e che è inutile.
  6. 8

    So che questa è una vecchia questione, ma sono abbastanza fiero di questa soluzione 🙂 E ‘ solo gestisce i numeri a meno di 1000, ma potrebbe essere facilmente esteso per includere tuttavia grande è bisogno aggiungendo al ‘numeralCodes’ di matrice 2D.

    JS:

    var numeralCodes = [["","I","II","III","IV","V","VI","VII","VIII","IX"],         //Ones
                        ["","X","XX","XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"],   //Tens
                        ["","C","CC","CCC","CD","D","DC","DCC","DCCC","CM"]];        //Hundreds
    
    function convert(num) {
      var numeral = "";
      var digits = num.toString().split('').reverse();
      for (var i=0; i < digits.length; i++){
        numeral = numeralCodes[i][parseInt(digits[i])] + numeral;
      }
      return numeral;  
    }

    HTML:

    <input id="text-input" type="text">
    <button id="convert-button" onClick="var n = parseInt(document.getElementById('text-input').value);document.getElementById('text-output').value = convert(n);">Convert!</button>
    <input id="text-output" style="display:block" type="text">

    • chiara ed elegante, buon lavoro!:-D
    • Ah, questo è intelligente. Ho fatto praticamente la stessa cosa utilizzando le istruzioni switch, questo sarebbe stato il mio prossimo refactor dopo capire il modello e renderlo più elegante.
  7. 5

    JavaScript

    function romanize (num) {
        if (!+num)
            return false;
        var digits = String(+num).split(""),
            key = ["","C","CC","CCC","CD","D","DC","DCC","DCCC","CM",
                   "","X","XX","XXX","XL","L","LX","LXX","LXXX","XC",
                   "","I","II","III","IV","V","VI","VII","VIII","IX"],
            roman = "",
            i = 3;
        while (i--)
            roman = (key[+digits.pop() + (i * 10)] || "") + roman;
        return Array(+digits.join("") + 1).join("M") + roman;
    }

    molti altri suggerimenti possono essere trovati in http://blog.stevenlevithan.com/archives/javascript-roman-numeral-converter

  8. 5

    Personalmente penso che il modo più grazioso (non il più veloce) è con la ricorsione.

    function convert(num) { 
      if(num < 1){ return "";}
      if(num >= 40){ return "XL" + convert(num - 40);}
      if(num >= 10){ return "X" + convert(num - 10);}
      if(num >= 9){ return "IX" + convert(num - 9);}
      if(num >= 5){ return "V" + convert(num - 5);}
      if(num >= 4){ return "IV" + convert(num - 4);}
      if(num >= 1){ return "I" + convert(num - 1);}  
    }
    console.log(convert(39)); 
    //Output: XXXIX

    Questo supporta solo i numeri 1-40, ma può essere facilmente esteso seguendo il modello.

  9. 3

    Questa funzione permetterà di convertire qualsiasi numero minore di 3,999,999 romana. Si noti che i numeri più grandi di 3999 sarà all’interno di un etichetta con text-decoration set di overline, a questo si aggiungerà la overline che è la rappresentazione corretta per x1000 quando il numero è più grande di 3999.

    Quattro milioni di euro (4.000.000 di) sarebbe IV con due overlinecosì, si avrebbe bisogno di utilizzare qualche trucco per rappresentare che, forse un DIV con border-top, o qualche immagine di sfondo con quei due overlines… Ogni overline rappresenta x1000.

    function convert(num){
        num = parseInt(num);
    
        if (num > 3999999) { alert('Number is too big!'); return false; }
        if (num < 1) { alert('Number is too small!'); return false; }
    
        var result = '',
            ref = ['M','CM','D','CD','C','XC','L','XL','X','IX','V','IV','I'],
            xis = [1000,900,500,400,100,90,50,40,10,9,5,4,1];
    
        if (num <= 3999999 && num >= 4000) {
            num += ''; //need to convert to string for .substring()
            result = '<label style="text-decoration: overline;">'+convert(num.substring(0,num.length-3))+'</label>';
            num = num.substring(num.length-3);
        }
    
        for (x = 0; x < ref.length; x++){
            while(num >= xis[x]){
                result += ref[x];
                num -= xis[x];
            }
        }
        return result;
    }
    • Ho modificato questo codice per consentire per i numeri superiori a 3,999,999. Potrebbe produrre risultati non corretti, anche se, in modo da utilizzare con cautela. jsfiddle.net/DJDavid98/d2VEy
    • Era alla ricerca di questo.. grazie!!!
  10. 3

    Dopo la verifica di alcune delle implementazioni in questo post, ho creato un nuovo ottimizzato per eseguire più velocemente. Il tempo di esecuzione è davvero basso per un confronto con gli altri, ma ovviamente il codice è più brutto :).
    Potrebbe essere ancora più veloce con un array con tutte le possibilità.
    Solo nel caso in cui aiuta qualcuno.

    function concatNumLetters(letter, num) {
        var text = "";
        for(var i=0; i<num; i++){
            text += letter;
        }
        return text;
    }
    
    
    function arabicToRomanNumber(arabic) {
        arabic = parseInt(arabic);
        var roman = "";
        if (arabic >= 1000) {
            var thousands = ~~(arabic / 1000);
            roman = concatNumLetters("M", thousands);
            arabic -= thousands * 1000;
        }
    
         if (arabic >= 900) {
             roman += "CM";
             arabic -= 900;
         }
    
         if (arabic >= 500) {
             roman += "D";
             arabic -= 500;
         }
    
         if (arabic >= 400) {
             roman += "CD";
             arabic -= 400;
         }
    
         if (arabic >= 100) { 
            var hundreds = ~~(arabic / 100);
            roman += concatNumLetters("C", hundreds);
            arabic -= hundreds * 100;
         }
    
         if (arabic >= 90) {
             roman += "XC";
             arabic -= 90;
         }
    
         if (arabic >= 50) {
             roman += "L";
             arabic -= 50;
         }
    
         if (arabic >= 40) {
             roman += "XL";
             arabic -= 40;
         }
    
         if (arabic >= 10) {
            var dozens = ~~(arabic / 10);
            roman += concatNumLetters("X", dozens);
            arabic -= dozens * 10;
         }
    
         if (arabic >= 9) {
             roman += "IX";
             arabic -= 9;
         }
    
          if (arabic >= 5) {
             roman += "V";
             arabic -= 5;
         }
    
         if (arabic >= 4) {
             roman += "IV";
             arabic -= 4;
         }
    
         if (arabic >= 1) {
            roman += concatNumLetters("I", arabic);
         }
    
         return roman;
    }
  11. 3
    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 result = '';
      for (var key in roman) {
        if (num == roman[key]) {
          return result +=key;
        }
        var check = num > roman[key];
        if(check) {
          result = result + key.repeat(parseInt(num/roman[key]));
          num = num%roman[key];
        }
      }
     return result;
    }
    
    console.log(convertToRoman(36));
    • Si prega di spiegare la soluzione
    • consente di prendere 1012 quindi non è uguale a un qualsiasi tasto e anche più di 1000 che è il mio primo tasto quindi entrerà in 2 ° se la condizione dopo di che sarà il quoziente che sarà di 1, quindi ci vorrà risultato e aggiungere M*1, così ora il risultato variabile M e il num di 12. Così ora 12>10 di nuovo entrare e fare la stessa cosa, quindi ora il risultato diventerà MX e num = 2 e 2>1 in modo da aggiungere MXI e ora il num = 1. Così ora si entra se la prima condizione andmake risultato = MXII.
  12. 2

    Ho creato due letti matrici uno con numeri arabi e l’altra con i caratteri romani.

    JS:

    function convert(num) {
    
      var result = '';
      var rom = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I'];
      var ara = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];

    Poi ho aggiunto un ciclo di scansione romano elementi, aggiungendo il più grande ancora costituito NUM di RISULTATO, quindi si diminuisce NUM di pari importo.

    È come si mappa una parte di NUM in numeri romani e quindi si diminuisce della stessa quantità.

    JS:

      for (var x = 0; x < rom.length; x++) {
        while (num >= ara[x]) {
          result += rom[x];
          num -= ara[x];
        }
      }
      return result;
    }

  13. 2

    Se si desidera convertire un numero grande, con più simboli, forse questo algo potrebbe aiutare.

    Unica premessa per i simboli che devono essere dispari e seguire la stessa regola (1, 5, 10, 50,100 …., 10^(N)/2, 10^(N)).

    JS:

    var rnumbers = ["I","V","X","L","C","D","M"];
            rnumbers = rnumbers.concat(["V","X","L","C","D","M"].map(function(n) {return '<span style="border-top:1px solid black; padding:1px;">'+n+'</span> '}));
            rnumbers = rnumbers.concat(["V","X","L","C","D","M"].map(function(n) {return '<span style="border:1px solid black; border-bottom:1px none black; padding:1px;">'+n+'</span> '}));
            rnumbers = rnumbers.concat(["V","X","L","C","D","M"].map(function(n) {return '<span style="border-top:3px double black; padding:1px;">'+n+'</span> '}));
    
    
        String.prototype.repeat = function( num ) {
            return new Array( num + 1 ).join( this );
        };
    
        function toRoman(n) {
    
            if(!n) return "";
    
            var strn = new String(n);
            var strnlength = strn.length;
            var ret = "";
            for(var i = 0 ; i < strnlength; i++) {
                var index = strnlength*2 -2 - i*2;
                var str;
                var m = +strn[i];
                if(index > rnumbers.length -1) {
                    str = rnumbers[rnumbers.length-1].repeat(m*Math.pow(10,Math.ceil((index-rnumbers.length)/2)));
                }else {
                    str = rnumbers[index].repeat(m);
                    if (rnumbers.length >= index + 2) {
                        var rnregexp = rnumbers[index]
                                .split("(").join('\\(')
                                .split(")").join('\\)');
                        
                        str = str.replace(new RegExp('(' + rnregexp + '){9}'), rnumbers[index] + rnumbers[index + 2])
                                .replace(new RegExp('(' + rnregexp + '){5}'), rnumbers[index + 1])
                                .replace(new RegExp('(' + rnregexp + '){4}'), rnumbers[index] + rnumbers[index + 1])
                    }
                }
                ret +=str;
            }
    
            return ret;
        }

    HTML:

        
    <input type="text" value="" onkeyup="document.getElementById('result').innerHTML = toRoman(this.value)"/>
    
    <br/><br/>
    
    <div id="result"></div>

  14. 2

    SE questo numero in HTMLElement (come la luce), si consiglia di Aggiungere attributo HTML data-format :

    <p>Phase <span data-format="roman">4 </span> Sales</p>

    Nota : Questo non è un html standard. Il codice Javascript utilizzato è visibile una volta che si scorre verso il basso nella sezione html su jsfiddle.

    DEMO

  15. 2

    JS:

    function convertToRoman(num) {
    
      var romans = {
        1000: 'M',
        900: 'CM',
        500: 'D',
        400: 'CD',
        100: 'C',
        90: 'XC',
        50: 'L',
        40: 'XL',
        10: 'X',
        9: 'IX',
        5: 'V',
        4: 'IV',
        1: 'I'
      };
      var popped, rem, roman = '',
        keys = Object.keys(romans);
      while (num > 0) {
        popped = keys.pop();
        m = Math.floor(num / popped);
        num = num % popped;
        console.log('popped:', popped, ' m:', m, ' num:', num, ' roman:', roman);
        while (m-- > 0) {
          roman += romans[popped];
        }
        while (num / popped === 0) {
          popped = keys.pop();
          delete romans[popped];
        }
      }
      return roman;
    }
    var result = convertToRoman(3999);
    console.log(result);
    document.getElementById('roman').innerHTML = 'Roman: ' + result;

    CSS:

    p {
      color: darkblue;
    }

    HTML:

    <p>Decimal: 3999</p>
    <p id="roman">Roman:</p>

  16. 2

    Ho appena fatto questo a freecodecamp. Può essere facilmente ampliato.

    function convertToRoman(num) {
    
      var roman ="";
    
      var values = [1000,900,500,400,100,90,50,40,10,9,5,4,1];
      var literals = ["M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"];
    
    
      for(i=0;i<values.length;i++){
        if(num>=values[i]){
          if(5<=num && num<=8) num -= 5;
          else if(1<=num && num<=3) num -= 1;
          else num -= values[i];
          roman += literals[i];
          i--;
        }
      }
    
    
     return roman;
    }
  17. 2

    Ecco una espressione regolare soluzione:

    function deromanize(roman) {
      var r = 0;
      //regular expressions to check if valid Roman Number.
      if (!/^M*(?:D?C{0,3}|C[MD])(?:L?X{0,3}|X[CL])(?:V?I{0,3}|I[XV])$/.test(roman))
        throw new Error('Invalid Roman Numeral.');
    
      roman.replace(/[MDLV]|C[MD]?|X[CL]?|I[XV]?/g, function(i) {
        r += {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}[i]; 
      });
    
      return r;
    }
  18. 2

    So che questo è un datato domanda, ma ho la soluzione più breve di quelli elencati qui e ho pensato di condividere in quanto penso che la sua più facile da capire.

    Questa versione non richiede alcuna hard coded logica per i casi limite come il 4(IV),9(IX),40(XL),900(CM), etc. come fanno gli altri. Questo significa anche che è in grado di gestire un numero maggiore maggiore del massimo romano scala potrebbe (3999). Ad esempio, se “T” è diventato un nuovo simbolo si potrebbe aggiungere all’inizio del romanLookup oggetto e vorrei mantenere la stessa algoritmico interessa; o corso supponendo che il “non più di 3 simboli uguali in una riga” si applica la regola.

    Ho testato contro un set di dati da 1-3999 e funziona senza problemi.

    function convertToRoman(num) {
      //create key:value pairs
      var romanLookup = {M:1000, D:500, C:100, L:50, X:10, V:5, I:1};
      var roman = [];
      var romanKeys = Object.keys(romanLookup);
      var curValue;
      var index;
      var count = 1;
    
      for(var numeral in romanLookup){
        curValue = romanLookup[numeral];
        index = romanKeys.indexOf(numeral);
    
        while(num >= curValue){
    
          if(count < 4){
            //push up to 3 of the same numeral
            roman.push(numeral);
          } else {
            //else we had to push four, so we need to convert the numerals 
            //to the next highest denomination "coloring-up in poker speak"
    
            //Note: We need to check previous index because it might be part of the current number.
            //Example:(9) would attempt (VIIII) so we would need to remove the V as well as the I's
            //otherwise removing just the last three III would be incorrect, because the swap 
            //would give us (VIX) instead of the correct answer (IX)
            if(roman.indexOf(romanKeys[index - 1]) > -1){
              //remove the previous numeral we worked with 
              //and everything after it since we will replace them
              roman.splice(roman.indexOf(romanKeys[index - 1]));
              //push the current numeral and the one that appeared two iterations ago; 
              //think (IX) where we skip (V)
              roman.push(romanKeys[index], romanKeys[index - 2]);
            } else {
              //else Example:(4) would attemt (IIII) so remove three I's and replace with a V 
              //to get the correct answer of (IV)
    
              //remove the last 3 numerals which are all the same
              roman.splice(-3);
              //push the current numeral and the one that appeared right before it; think (IV)
              roman.push(romanKeys[index], romanKeys[index - 1]);
            }
          }
          //reduce our number by the value we already converted to a numeral
          num -= curValue;
          count++;
        }
        count = 1;
      }
      return roman.join("");
    }
    
    convertToRoman(36);
    • Perché ha fatto questo un downvote? Si tratta di un lavoro come-è l’esempio che risponde alla domanda ed è molto ben documentato?
  19. 1
    /*my beginner-nooby solution for numbers 1-999 :)*/
    function convert(num) {
        var RomNumDig = [['','I','II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'],['X','XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC'], ['C','CC','CCC','CD','D','DC','DCC','DCCC','CM']];
        var lastDig = num%10;
        var ourNumb1 = RomNumDig[0][lastDig]||'';
        if(num>=10) {
            var decNum = (num - lastDig)/10;
            if(decNum>9)decNum%=10; 
        var ourNumb2 = RomNumDig[1][decNum-1]||'';} 
        if(num>=100) {
            var hundNum = ((num-num%100)/100);
            var ourNumb3 = RomNumDig[2][hundNum-1]||'';}
    return ourNumb3+ourNumb2+ourNumb1;
    }
    console.log(convert(950));//CML
    
    /*2nd my beginner-nooby solution for numbers 1-10, but it can be easy transformed for larger numbers :)*/
    function convert(num) {
      var ourNumb = '';
      var romNumDig = ['I','IV','V','IX','X'];
      var decNum = [1,4,5,9,10];
      for (var i=decNum.length-1; i>0; i--) {
        while(num>=decNum[i]) {
            ourNumb += romNumDig[i];
            num -= decNum[i];
        }
      }
      return ourNumb;
    }
    console.log(convert(9));//IX
  20. 1
    function toRoman(n) {
        var decimals = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
        var roman = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I'];
    
        for (var i = 0; i < decimals.length; i++) {
            if(n < 1)
                return "";       
    
            if(n >= decimals[i]) {
                return roman[i] + toRoman(n - decimals[i]);        
            }
        }
    }
  21. 1

    Questa funzione lavora su diversi set di caratteri in ogni cifra. Per aggiungere un’altra cifra aggiungere il numero romano della stringa, il 1 posto, 5 posto e il prossimo 1 posto. Questo è bello perché ti aggiorna con solo sapere il successivo set di caratteri utilizzato.

    JS:

    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;

    HTML:

    <pre id="output"></pre>

  22. 1

    Questo funziona per tutti i numeri solo bisogno di numeri romani M e di seguito.

    function convert(num) {
      var code = [
        [1000, "M"], [900, "CM"], [800, "DCCC"], [700, "DCC"], [600, "DC"],
        [500, "D"], [400, "CD"], [300, "CCC"], [200, "CC"], 
        [100, "C"], [90, "XC"], [80, "LXXX"], [70, "LXX"], [60, "LX"], 
        [50, "L"], [40, "XL"], [30, "XXX"], [20, "XX"], 
        [10, "X"], [9, "IX"], [8, "VIII"], [7, "VII"], [6, "VI"], 
        [5, "V"], [4, "IV"], [3, "III"], [2, "II"], [1, "I"],
      ];
    
      var rom = "";
      for(var i=0; i<code.length; i++) {
        while(num >= code[i][0]) {
          rom += code[i][1];
          num -= code[i][0];
        }
      }
      return rom;
    }
  23. 1

    Questa è la prima volta che ho avuto veramente bloccato su freecodecamp. Ho sfogliato attraverso alcune soluzioni qui e sono stato stupito di quanto sia diversa erano tutti. Qui è che cosa ha funzionato per me.

    function convertToRoman(num) {
    var roman = "";
    
    var lookupObj = {
       1000:"M",
       900:"CM",
       500:"D",
       400:"CD",
       100:"C",
       90:"XC",
       50:"L",
       40:"XL",
       10:"X",
       9:"IX",   
       4:"IV",
       5:"V",
       1:"I",
    };
    
    var arrayLen = Object.keys(lookupObj).length;
    
    while(num>0){
    
     for (i=arrayLen-1 ; i>=0 ; i--){
    
      if(num >= Object.keys(lookupObj)[i]){
    
        roman = roman + lookupObj[Object.keys(lookupObj)[i]];        
        num = num - Object.keys(lookupObj)[i];
        break;
    
      }
     }
    }    
    
    return roman;
    
    }
    
    convertToRoman(1231);
  24. 1
    function convertToRoman(num) {
      var romNumerals = [["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 runningTotal = 0;
      var roman = "";
      for (var i = 0; i < romNumerals.length; i++) {
        while (runningTotal + romNumerals[i][1] <= num) {
          runningTotal += romNumerals[i][1];
          roman += romNumerals[i][0];
        }
      }
    
     return roman;
    }
  25. 1
    function convertToRoman(num) {
    
    var roNumerals = {
        M: Math.floor(num / 1000),
        CM: Math.floor(num % 1000 / 900),
        D: Math.floor(num % 1000 % 900 / 500),
        CD: Math.floor(num % 1000 % 900 % 500 / 400),
        C: Math.floor(num % 1000 % 900 % 500 % 400 / 100),
        XC: Math.floor(num % 1000 % 900 % 500 % 400 % 100 / 90),
        L: Math.floor(num % 1000 % 900 % 500 % 400 % 100 % 90 / 50),
        XL: Math.floor(num % 1000 % 900 % 500 % 400 % 100 % 90 % 50 / 40),
        X: Math.floor(num % 1000 % 900 % 500 % 400 % 100 % 90 % 50 % 40 / 10),
        IX: Math.floor(num % 1000 % 900 % 500 % 400 % 100 % 90 % 50 % 40 % 10 / 9),
        V: Math.floor(num % 1000 % 900 % 500 % 400 % 100 % 90 % 50 % 40 % 10 % 9 / 5),
        IV: Math.floor(num % 1000 % 900 % 500 % 400 % 100 % 90 % 50 % 40 % 10 % 9 % 5 / 4),
        I: Math.floor(num % 1000 % 900 % 500 % 400 % 100 % 90 % 50 % 40 % 10 % 9 % 5 % 4 / 1)
      };
      var roNuStr = "";
    
      for (var prop in roNumerals) {
        for (i = 0; i < roNumerals[prop]; i++) {
          roNuStr += prop;
        }
    
      }
      return roNuStr;
    }
    
    convertToRoman(9);
  26. 1
    function convertToRoman (num) {
        var v = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
        var r = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I'];
        var s = "";
        for(i = 0; i < v.length; i++) {
            value = parseInt(num/v[i]);
            for(j = 0; j < value; j++) {
                s += r[i];
            }
            num = num%v[i];
        }
        return s;
    }
  27. 1

    Ancora in fieri 🙂 funziona, tra 1-3999.

    var converterArray = [{"1":["I","IV","V","IX"],
                           "2":["X","XL","L","XC"],
                           "3":["C","CD","D","CM"],
                           "4":["M"]}
                         ];
    
    function convertToRoman(num) {
      var romanNumeral = [];
      var numArr = num.toString().split('');
      var numLength = numArr.length;
    
      for (var i = 0; i<numArr.length; i++) {
        if (numArr[i] < 4) {
          for (var j = 0; j<numArr[i]; j++) {
            romanNumeral.push(converterArray[0][numLength][0]);
          }
        } else if (numArr[i] < 5) {
           for (var j = 3; j<numArr[i]; j++) {
            romanNumeral.push(converterArray[0][numLength][1]);
          }
        } else if (numArr[i] < 9) {
            romanNumeral.push(converterArray[0][numLength][2]);
            for (var j = 5; j<numArr[i]; j++) {
              romanNumeral.push(converterArray[0][numLength][0]);
          }
        } else if (numArr[i] < 10) {
            for (var j = 8; j<numArr[i]; j++) {
              romanNumeral.push(converterArray[0][numLength][3]);
          }
        }
        numLength--;
       }
    
     return romanNumeral.join('');
    }
    
    convertToRoman(9);
    • Questo è a grandi e troppo complicata
    • Grazie per il feedback, hai assolutamente ragione! L’ho fatta una settimana fa, ora ho refactord un po’.
  28. 1

    La mia soluzione rompe il numero in un array di stringhe, aggiunge zeri per ogni elemento in base alla sua posizione rispetto alla lunghezza dell’array, converte le nuove stringhe di zeri in numeri romani, e poi si unisce a loro di nuovo insieme. Questo funziona solo con i numeri fino a 3999:

    function convertToRoman(num){
      var rnumerals = { 1 : 'I', 2 : 'II', 3 : 'III', 4 : 'IV', 5 : 'V', 6   : 'VI', 7 : 'VII', 
      8 : 'VIII', 9 : 'IX', 10 : 'X', 20 : 'XX', 30 : 'XXX', 40 : 'XL', 50 : 'L', 
      60 : 'LX', 70 : 'LXX', 80 : 'LXXX', 90 : 'XC', 100 : 'C', 200 : 'CC', 300 : 'CCC', 
      400 : 'CD', 500 : 'D', 600 : 'DC', 700 : 'DCC', 800 : 'DCCC', 900 : 'CM', 
      1000: 'M', 2000: 'MM', 3000: 'MMM'};
    
      var zeros, romNum;
      var arr = num.toString().split("");
      var romArr = [];
      for(var i=0; i < arr.length; i++){
        zeros = "0".repeat((arr.length - i - 1));
        arr[i] = arr[i].concat(zeros);
        romArr.push(rnumerals[(arr[i])]); 
      }
      romNum = romArr.join('');
      return romNum;
    }
  29. 1

    Se è solo per la visualizzazione, utilizzare lo standard HTML con un po ‘ di JS per il valore (se richiesto) e CSS per renderlo in linea:

    CSS:

    ol.roman-lowercase,
    ol.roman-uppercase {
      display: inline-flex;
      margin: 0;
      padding: 0;
    }
    
    ol.roman-lowercase {
      list-style: lower-roman inside;
    }
    
    ol.roman-uppercase {
      list-style: upper-roman inside;
    }

    HTML:

    <ol class="roman-lowercase"><li value="4"></li></ol> <!-- iv. -->
    <ol class="roman-uppercase"><li value="142"></li></ol> <!-- CXLII. -->

  30. 1

    JS:

    function convertToRoman(num) {
        var arr = [];
        for (var i = 0; i < num.toString().length; i++) {
            arr.push(Number(num.toString().substr(i, 1)));
        }
        var romanArr = [
            ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"],
            ["X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"],
            ["C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"],
            ["M"]
        ];
        var roman = arr.reverse().map(function (val, i) {
            if (val === 0) {
                return "";
            }
            if (i === 3) {
                var r = "";
                for (var j = 0; j < val; j++) {
                    r += romanArr[i][0];
                }
                return r;
            } else {
                return romanArr[i][val - 1];
            }
        });
        console.log(roman.reverse().join(""));
        return roman.join("");
    }
    
    
    convertToRoman(10);

    • In generale, le risposte sono molto più utili se non includere una spiegazione di ciò che il codice è destinato a fare, e perché, che risolve il problema senza l’introduzione di altri.
  31. 1

    Sento che la mia soluzione è molto più leggibile e di facile comprensione.

    var intToRoman = function(num) {
        let symbolMap = ['I','V','X','L','C','D','M','P','Q'];
    
        if (num < 1 || num > 9999) {
            return null;
        }
    
        let i = 0;
        let result = '';
    
        while (num) {
            let digit = num % 10;
            num = parseInt(num / 10);
    
            switch (digit) {
                case 1: result = symbolMap[i] + result;
                    break;
                case 2: result = symbolMap[i] + symbolMap[i] + result;
                    break;
                case 3: result = symbolMap[i] + symbolMap[i] + symbolMap[i] + result;
                    break;
                case 4: result = symbolMap[i] + symbolMap[i+1] + result;
                    break;
                case 5: result = symbolMap[i+1] + result;
                    break;
                case 6: result = symbolMap[i+1] + symbolMap[i] + result;
                    break;
                case 7: result = symbolMap[i+1] + symbolMap[i] + symbolMap[i] + result;
                    break;
                case 8: result = symbolMap[i+1] + symbolMap[i] + symbolMap[i] + symbolMap[i] + result;
                    break;
                case 9: result = symbolMap[i] + symbolMap[i+2] + result;
                    break;
            }
            i += 2;
        }
    
        return result;
     };
  32. 1

    Loop può essere più elegante, ma io li trovo di difficile lettura. Si avvicinò con un più o meno codificate versione che è facile per gli occhi. Come capire prima riga, il resto è un gioco da ragazzi.

    function romanNumeralGenerator (int) {
      let roman = '';
    
      roman +=  'M'.repeat(int / 1000);  int %= 1000; 
      roman += 'CM'.repeat(int / 900);   int %= 900; 
      roman +=  'D'.repeat(int / 500);   int %= 500;  
      roman += 'CD'.repeat(int / 400);   int %= 400;
      roman +=  'C'.repeat(int / 100);   int %= 100;
      roman += 'XC'.repeat(int / 90);    int %= 90;
      roman +=  'L'.repeat(int / 50);    int %= 50;
      roman += 'XL'.repeat(int / 40);    int %= 40;
      roman +=  'X'.repeat(int / 10);    int %= 10;
      roman += 'IX'.repeat(int / 9);     int %= 9;
      roman +=  'V'.repeat(int / 5);     int %= 5;
      roman += 'IV'.repeat(int / 4);     int %= 4;
      roman +=  'I'.repeat(int);
    
      return roman;
    }
  33. 0
    var romanNumerals = [
      ['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]];
    
    RomanNumerals = {
      romerate: function(foo) {
        var bar = '';
        romanNumerals.forEach(function(buzz) {
          while (foo >= buzz[1]) {
            bar += buzz[0];
            foo -= buzz[1]; 
          }
        });
        return bar;
      },
      numerate: function(x) {
        var y = 0;
        romanNumerals.forEach(function(z) {
          while (x.substr(0, z[0].length) == z[0]) {
            x = x.substr(z[0].length);
            y += z[1];
          }
        });
        return y;
      }
    };
  34. 0

    Beh, a quanto pare, come io non sono l’unico che è rimasto bloccato su questa sfida a FreeCodeCamp. Ma vorrei condividere il mio codice con te comunque. È abbastanza performante, quasi il 10% più veloce rispetto alla top-votati soluzione qui (non ho testato tutte le altre e credo che il mio non è il più veloce). Ma penso che è pulito e facile da capire:

    function convertToRoman(num) {
        //Some error checking first
        if (+num > 9999) {
            console.error('Error (fn convertToRoman(num)): Can\'t convert numbers greater than 9999. You provided: ' + num);
            return false;
        }
        if (!+num) {
            console.error('Error (fn convertToRoman(num)): \'num\' must be a number or number in a string. You provided: ' + num);
            return false;
        }
    
        //Convert the number into
        //an array of the numbers
        var arr = String(+num).split('').map((el) => +el );
    
        //Keys to the roman numbers
        var keys = {
            1: ['', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'],
            2: ['', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC'],
            3: ['', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM'],
            4: ['', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM', 'MMMMMMMM', 'MMMMMMMMM'],
        };
    
        //Variables to help building the roman string
        var i = arr.length;
        var roman = '';
    
        //Iterate over each number in the array and
        //build the string with the corresponding
        //roman numeral
        arr.forEach(function (el) {
            roman += keys[i][el];
            i--;
        });
    
        //Return the string
        return roman;
    }

    Potrebbe sembrare una limitazione che è solo in grado di convertire i numeri fino a 9 999. Ma il fatto è che tra 10 000 e al di sopra di una linea, che dovrebbe essere fornito sopra i valori letterali. E che non ho ancora risolto.

    Spero che questo vi aiuterà.

  35. 0
    function convertToRoman(num) {
    
      var search = {
        "0":["I","II","III","IV","V","VI","VII","VIII","IX"],
        "1":["X","XX","XXX","XL","L","LX","LXX","LXXX","XC"],
        "2":["C","CC","CCC","CD","D","DC","DCC","DCCC","CM"],
        "3":["M","MM","MMM","MV^","V^","V^M","V^MM","V^MMM","MX^"],
      };
    
      var numArr = num.toString().split("").reverse();
      var romanReturn = [];
      for(var i=0; i<numArr.length; i++){
        romanReturn.unshift(search[i][numArr[i]-1]);
      }
      return romanReturn.join("");
    }
  36. 0

    Questa è la mia soluzione, io non sono troppo sicuro di come si esegue.

    function convertToRoman(num) {
    
      var uni = ["","I","II","III","IV","V","VI","VII","VIII","IX"];
      var dec = ["","X","XX","XXX","XL","L","LX","LXX","LXXX","XC"];
      var cen = ["","C","CC","CCC","CD","D","DC","DCC","DCCC","CM"];
      var mil = ["","M","MM","MMM","MMMM","MMMMM","MMMMMM","MMMMMMM","MMMMMMMM","MMMMMMMMMM"];
    
      var res =[];
    
      if(num/1000 > 0)
        {
          res = res.concat(mil[Math.floor(num/1000)]);
        }
    
      if(num/100 > 0)
        {
          res = res.concat(cen[Math.floor((num%1000)/100)]);
        }
    
      if(num/10 >0)
        {
          res = res.concat(dec[Math.floor(((num%1000)%100)/10)]);
        }
    
      res=res.concat(uni[Math.floor(((num%1000)%100)%10)]);
    
      return res.join('');
    }
  37. 0

    Sto solo postando una funzione che ho creato per la conversione Romana, spero vi piaccia

    function converter(numToConv) {
    var numToRom = [];
    var numToRome = "";
    var R = [['M',1000], ['D',500], ['C',100], ['L',50], ['X',10], ['V',5], ['I',1]];
    while (numToConv > 0) {
        if (numToConv > R[0][1]) {
            if (numToConv < R[0][1] * 5 - R[0][1]) {   
                numToRom.push([R[0][0],"next one goes aftah"]);
                numToConv = Math.abs(numToConv - R[0][1]);
                console.log("Next comes after: " + R[0][0] + " (" + R[0][1] + ")");
                console.log(numToConv);
            } else {
                numToConv = 0;
                break;
            }
        }
        for (var i = 0; i < R.length; i++) {
            if (R[i][1] == numToConv) {
                numToRom.push([R[i][0],"end"]);
                numToConv = Math.abs(numToConv - R[i][1]);
                console.log("End: " + numToConv);
            } else if (i > 0) {
                if ((R[i-1][1] > numToConv) && (R[i][1] < numToConv)) {
                    console.log(numToConv + " is between: " + R[i][1]  + " (" + R[i][0] + ") and: " +  R[i - 1][1]  + " (" + R[i - 1][0] + ")");
                    var threshold = R[i - 1][1] - Math.pow(10, numToConv.toString().length - 1);
                    console.log("threshold: " + threshold + " : " + R[i][1] + " : " + Math.pow(10, numToConv.toString().length - 1));
                    if (numToConv  < threshold) {
                        numToRom.push([R[i][0],"next one goes aftah"]);
                        numToConv = Math.abs(numToConv - R[i][1]);
                        console.log("Next comes after: " + R[i][0] + " (" + R[i][1] + ")");
                        console.log(numToConv);
                    } else {
                        numToRom.push([R[i-1][0],"next one goes befoah"]);
                        numToConv = Math.abs(numToConv - threshold + Math.pow(10, numToConv.toString().length - 1));
                        console.log("Next comes before: " + R[i-1][0] + " (" + R[i-1][1] + ")");
                        console.log(numToConv);
                    }
                }
            }
        }
    }
    console.log("numToRom: " + numToRom);
    for (var i = 0; i < numToRom.length; i++) {
        if (numToRom[i][1] == "next one goes befoah") {
            numToRome += (numToRom[i+1][0] + numToRom[i][0]);
            console.log("numToRome goes befoah: " + numToRome + " i: " + i);
            i++;
        } else {
            numToRome += numToRom[i][0];
            console.log("numToRome goes aftah: " + numToRome + " i: " + i);
        }
    }
            console.log("numToRome: " + numToRome);
            return numToRome;

    }

    Il codice modificato con i commenti:

    function converter(numToConv) {
        var numToRom = []; //an array empty, ready to store information about the numbers we will use as we analyse the given number 
        var numToRome = ""; //this is a string to add the Roman letters forming our returning number
        var R = [['M',1000], ['D',500], ['C',100], ['L',50], ['X',10], ['V',5], ['I',1]]; //this array stores the matches with the arabic numbers that we are going to need
        while (numToConv > 0) { //just checking, there is no zero
            if (numToConv > R[0][1]) { //checks if the number is bigger than the bigger number in the array
                if (numToConv < R[0][1] * 5 - R[0][1]) { //checks if it is larger even than 4 times the larger number in the array (just because there is not usually a way to express a number by putting 4 times the same letter i.e there is no "IIII", or "XXXX" etc)
                    numToRom.push([R[0][0],"next one goes aftah"]);//here is the information we want to pass, we add the letter we are about to use along with info about the next letter
                    numToConv = Math.abs(numToConv - R[0][1]);//and now we are subtracting the value of the letter we are using from the number
                    console.log("Next comes after: " + R[0][0] + " (" + R[0][1] + ")");//informing about what we encountering
                    console.log(numToConv);//..as well as what's the next number
                } else { //if the number is larger than 4 times the larger number in the array (thus it cannot be expressed)
                    numToConv = 0; //then 0 the number (unnecessary but still, no problem doing it)
                    break;//and of course, breaking the loop, no need to continue
                }
            }
            for (var i = 0; i < R.length; i++) {//now we are about to search our number for each cell of the array with the roman letters (again and again)
                if (R[i][1] == numToConv) { //if the number is equal to the one in the cell (that means the conversion is over)
                    numToRom.push([R[i][0],"end"]); //we pass the information about that cell along with the indication that the conversion has ended
                    numToConv = Math.abs(numToConv - R[i][1]);//thai can also be skipped but again there is o harm in keeping it
                    console.log("End: " + numToConv);//again informing about what we encountering
                } else if (i > 0) { //just a precaution because we are about to use "i-1" 
                    if ((R[i-1][1] > numToConv) && (R[i][1] < numToConv)) {//we find the range in which is the given number (for instance: the number 4 is between 1[I] and 5[V])
                        console.log(numToConv + " is between: " + R[i][1]  + " (" + R[i][0] + ") and: " +  R[i - 1][1]  + " (" + R[i - 1][0] + ")");//once again informing
                        var threshold = R[i - 1][1] - Math.pow(10, numToConv.toString().length - 1);//we create this "threshold" to check if the next number is going before or after this one (difference between 7[VII] and 9[IX]). it is the larger number of our range - 10^[depends on how large is the number we want to convert] (for 999, the threshold is 900, it is smaller 1000 - 10^2)
                        console.log("threshold: " + threshold + " : " + numToConv + " : " + R[i - 1][1] + " : " + R[i][1] + " : " + Math.pow(10, numToConv.toString().length - 1));
                        if (numToConv  < threshold) {//if the number is smaller than the "threshold" (like 199 where its threshold is 400)
                            numToRom.push([R[i][0],"next one goes aftah"]);//then the next number is going after
                            numToConv = Math.abs(numToConv - R[i][1]);//and again, subtract the used value of the number we are converting
                            console.log("Next comes after: " + R[i][0] + " (" + R[i][1] + ")");
                            console.log(numToConv);
                        } else { //now, if the number is larger than the threshold (like 99 where its threshold is 90)
                            numToRom.push([R[i-1][0],"next one goes befoah"]);//then the next number is going before the one we add now
                            numToConv = Math.abs(numToConv - R[i - 1][1]);//again, the subtraction, it was "threshold + Math.pow(10, numToConv.toString().length - 1)" but I changed it to "R[i - 1][1]", same result, less operations
                            console.log("Next comes before: " + R[i-1][0] + " (" + R[i-1][1] + ")");
                            console.log(numToConv);
                        }
                    }
                }
            }
        }
        console.log("numToRom: " + numToRom); //now that we have all the info we need about the number, show it to the log (just for a check)
        for (var i = 0; i < numToRom.length; i++) {//..and we start running through that info to create our final number
            if (numToRom[i][1] == "next one goes befoah") {//if our information about the cell tells us that the next letter is going before the current one
                numToRome += (numToRom[i+1][0] + numToRom[i][0]);//we add both to our string (the next one first)
                console.log("numToRome goes befoah: " + numToRome + " i: " + i);
                i++;//and we add an extra '1' to the i, so it will skip the next letter (mind that there won't be more than one letters saying that the next one is going before them in a row
            } else {//if the next one is going after the current one
                numToRome += numToRom[i][0]; //we just add the one we are on to the string and go forth
                console.log("numToRome goes aftah: " + numToRome + " i: " + i);
            }
        }
                console.log("numToRome: " + numToRome);
                return numToRome;//return the string and we are done
    }
    • una spiegazione del codice consentirebbe di aumentare il valore risposta
    • Hai solo inviare una copia della libreria jQuery 😉 mi ha preso un po ‘ a leggere questo, potrebbe desiderare di semplificare.
    • Scusate ragazzi, ho appena visto i vostri commenti. Ho ‘ll aggiungere commenti al codice ASAP
    • Fatto, ho aggiunto alcuni commenti (anche se mi dispiace, ho esagerato)
  38. 0
    function toRoman(n) {
            var r = '';
            for (var c = 0; c < n.length; c++)
                r += calcDigit(eval(n.charAt(c)), n.length - c - 1);
            return r
        }
    
    function Level(i, v, x) {
        this.i = i;
        this.v = v;
        this.x = x
    }
    
    levels = [];
    levels[0] = new Level('I','V','X');
    levels[1] = new Level('X','L','C');
    levels[2] = new Level('C','D','M');
    
    function calcDigit(d, l) {
        if (l > 2) {
            var str = '';
            for (var m = 1; m <= d * Math.pow(10, l - 3); m++)
                str += 'M';
            return str
        } else if (d == 1)
            return levels[l].i;
        else if (d == 2)
            return levels[l].i + levels[l].i;
        else if (d == 3)
            return levels[l].i + levels[l].i + levels[l].i;
        else if (d == 4)
            return levels[l].i + levels[l].v;
        else if (d == 5)
            return levels[l].v;
        else if (d == 6)
            return levels[l].v + levels[l].i;
        else if (d == 7)
            return levels[l].v + levels[l].i + levels[l].i;
        else if (d == 8)
            return levels[l].v + levels[l].i + levels[l].i + levels[l].i;
        else if (d == 9)
            return levels[l].i + levels[l].x;
        else
            return ''
    }
  39. 0

    Odio che elenca ogni possibilità in un array ( che tante persone hanno scelto di risolvere questo puzzle) in modo da utilizzare un’altra funzione per fare quel lavoro. Ecco la mia soluzione:

    JS:

    //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++;  
     }

  40. 0

    In questo codice, il limite superiore di numeri può essere esteso aggiungendo nuove lettere di 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;
    }
  41. 0

    Qui è il mio “funzionale diventa” soluzione.

    JS:

    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);

  42. 0

    Mentre la mia risposta non è così performante come gli altri, la mia attenzione era più su, non è difficile codifica in base numeri e permettendo al programma per capire il resto.

    Per esempio…

    Invece di:

    number = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1],
    numeral = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I']

    Ho usato:

    base = ['I', 'X', 'C', 'M'];
    pivot = ['V', 'L', 'D'];

    function basicRomanNumerals(num){
    let base = ['I', 'X', 'C', 'M'];
    let pivot = ['V', 'L', 'D'];
    return String(num).split('').reverse().map(function(num, idx){
        let distance = +num - 5;
        let is1AwayFromNext = Math.abs(+num - 10) === 1;
        if(Math.abs(distance)=== 1 || is1AwayFromNext){
            if(is1AwayFromNext){
                return base[idx]+""+base[idx+1];
            }else if ( distance < 0 ){
                return base[idx]+""+pivot[idx];
            }else{
                return pivot[idx]+""+base[idx];
            }
        }else if(distance === 0){
            return pivot[idx];
        }else if(distance > 1){
            return pivot[idx]+""+base[idx].repeat(+num-5);
        }else{
            return base[idx].repeat(+num);
        }
    }).reverse().join('');
  43. 0

    Ho appena completato questo su freeCodeCamp troppo, io didn ‘ t vedere questa particolare soluzione. So che questa soluzione può essere ottimizzato con la ricorsione, ma volevo solo buttare fuori così almeno vedi altre opzioni:

    function convertToRoman(num) {
      var value = [];
      var temp, base, buffer;
    
      var letters = ['I', 'V', 'X', 'L', 'C', 'D', 'M'];
      var offsets = [
        [1, 0],  //1
        [2, 0],  //2
        [3, 0],  //3
        [-1, 1], //4
        [0, 1],  //5
        [1, 1],  //6
        [2, 1],  //7
        [3, 1],  //8
        [-2, 2],  //9
      ];
    
      //cascade through each denomination (1000's, 100's, 10's, 1's) so that each denomination is triggered
    
      //Thousands
      if (num >= 1000) {
        temp = Math.floor(num / 1000);
    
        buffer = offsets[temp - 1];
    
        base = 6;
    
        value.push(getValue(base, letters, buffer));
    
        num -= temp * 1000;
      }
    
      //Hundreds
      if (num >= 100) {
        temp = Math.floor(num / 100);
    
        buffer = offsets[temp - 1];
    
        base = 4;
    
        value.push(getValue(base, letters, buffer));
    
        num -= temp * 100;
      }
    
      //Tens
      if (num >= 10) {
        temp = Math.floor(num / 10);
    
        buffer = offsets[temp - 1];
    
        base = 2;
    
        value.push(getValue(base, letters, buffer));
    
        num -= temp * 10;
      }
    
      //Ones
      if (num > 0) {
    
        buffer = offsets[num - 1];
    
        base = 0;
    
        value.push(getValue(base, letters, buffer));
      }
    
      //Finish
    
      return value.join('');
    }
    
    
    function getValue(base, letters, buffer) {
      var val1 = buffer[0], val2 = buffer[1];
      var value = [];
    
      //If val1 is less than 0 then we know it is either a 4 or 9, which has special cases
      if (val1 < 0) {
        //Push the base index, then push the base plus the val2 offset
        value.push(letters[base]);
        value.push(letters[base + val2]);
      } else {
        //Push a letter if val2 is set - meaning we need to offset a number that is equal to or higher than 5
        //5 is basically the only scenario which this will exist
        if (val2 > 0) value.push(letters[base + val2]);
    
        //Now add in the next letters of the base for the inciment
        for (var i = 0; i < val1; i++) {
          value.push(letters[base]);
        }
      }
    
      return value.join('');
    }
    
    convertToRoman(90);

    Sono abbastanza sicuro che il compagno di una funzione può avere quasi illimitato potenziale, assumendo fornire la corretta simboli per i numeri più grandi di M, ma non metterei la mano sul fuoco.

  44. 0

    Ecco un modo per farlo senza dover scorrere tutti i diversi numeri romani e numeri corrispondenti. Ha una costante di tempo O(1) di ricerca, per risparmiare un po ‘ nel tempo della complessità.

    Si rompe ogni numero intero da destra a sinistra, 2,473 diventa 3 + 70 + 400 + 2,000, e quindi si trova il corrispondente numero romano utilizzando il numeriromani tabella di hash, e lo aggiunge alla stringa di risultato. Si fa con l’aggiunta di un ulteriore 0 per ogni intero prima che la ricerca, come si sposta da destra a sinistra. Questa soluzione funziona solo per i numeri compresi tra 1 e 3,999.

        function integerToRoman(int) {
        if (int < 1 || int > 3999) {
            return -1;
        }
    
        var result = '';
        var intStr = int.toString();
        var romanNumerals = { 1: 'I', 2: 'II', 3: 'III', 4: 'IV', 5: 'V', 6: 'VI', 7: 'VII', 8: 'VIII', 9: 'IX', 10: 'X', 20: 'XX', 30: 'XXX', 40: 'XL', 50: 'L', 60: 'LX', 70: 'LXX', 80: 'LXXX', 90: 'XC', 100: 'C', 200: 'CC', 300: 'CCC', 400: 'CD', 500: 'D', 600: 'DC', 700: 'DCC', 800: 'DCCC', 900: 'CM', 1000: 'M', 2000: 'MM', 3000: 'MMM'};
        var digit = '';
    
        for (var i = intStr.length - 1; i >= 0; i-- ) {
            if (intStr[i] === '0') {
                digit += '0';
                continue;
            }
            var num = intStr[i] + digit;
            result = romanNumerals[num] + result;
            digit += '0';
        }
    
        return result;
    }
  45. 0

    JS:

    const romanize = num => {
      const romans = {
        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
      };
      
      let roman = '';
      
      for (let key in romans) {
        const times = Math.trunc(num / romans[key]);
        roman += key.repeat(times);
        num -= romans[key] * times;
      }
    
      return roman;
    }
    
    console.log(
      romanize(38)
    )

  46. 0

    Ecco la mia soluzione:

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

    Esegue molto bene in Cromo 60 – https://jsperf.com/num-to-roman

  47. 0
    function convertToRoman(int) {
        console.log('Number:', int);
        let roman = [];
        let i, k, replacement;
        let seq = ['I', 'V', 'X', 'L', 'C', 'D', 'M'];
    
        while (int > 999) {
            roman.push('M');
            int -= 1000;
        }
        while (int > 499) {
            roman.push('D');
            int -= 500;
        }
        while (int > 99) {
            roman.push('C');
            int -= 100;
        }
        while (int > 49) {
            roman.push('L');
            int -= 50;
        }
        while (int > 9) {
            roman.push('X');
            int -= 10;
        }
        while (int > 4) {
            roman.push('V');
            int -= 5;
        }
        while (int >= 1) {
            roman.push('I');
            int -= 1;
        }
    
        //Replace recurrences of 4 ('IIII' to 'IV')
        for (i = 0; i < roman.length; i++) {
            if (roman[i] == roman[i + 1] &&
                roman[i] == roman[i + 2] &&
                roman[i] == roman[i + 3]) {
                for (k = 0; k < seq.length; k++) {
                    if (roman[i] == seq[k]) {
                        replacement = seq[k + 1];
                    }
                }
                roman.splice(i + 1, 3, replacement);
            }
        }
    
        //Converting incorrect recurrences ('VIV' to 'IX')
        for (i = 0; i < roman.length; i++) {
            if (roman[i] == roman[i + 2] && roman[i] != roman[i + 1]) {
                for (k = 0; k < seq.length; k++) {
                    if (roman[i] == seq[k]) {
                        replacement = seq[k + 1];
                    }
                }
                roman[i + 2] = replacement;
                roman.splice(i, 1);
            }
        }
    
        roman = roman.join('');
        return roman;
    }
  48. 0

    JS:

    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);

    • si dovrebbe aggiungere commenti e spiegazioni
  49. 0

    Aver visto tutti i precedenti 46 soluzioni per il “Numero-Alla-Romana” da quando è stata fatta questa domanda, c’è solo un post per la retromarcia Romano-di-Numero di kennebec, e che ha diversi problemi: il “Numero” di un oggetto non può essere direttamente estesa, è necessario utilizzare il prototipo. Anche la prototipazione non ha senso in questo contesto (oggetto String è un candidato migliore se qualsiasi). In secondo luogo è inutilmente complesso e inoltre chiamate toRoman metodo. In terzo luogo non riesce per i numeri superiori a 4000. Qui è un elegante e il più conciso di tutti i 47 posti per il tipo di conversioni. Queste conversioni lavoro praticamente per qualsiasi numero. Il romanToNumber è una piccola variazione di gregoryr elegante soluzione:

    JS:

    function numberToRoman(val,rom){ //returns empty string if invalid number
      rom=rom||''
      if(isNaN(val)||val==0) 
        return rom;
      for(i=0;curval=[1000,900,500,400,100,90,50,40,10,9,5,4,1][i],i<13;i++)
        if(val >= curval)
    	   return numberToRoman(val-curval,rom+['M','CM','D','CD','C','XC','L','XL','X','IX','V','IV','I'][i])
    }
    
    function romanToNumber(txtRom){//returns NaN if invalid string
      txtRom=txtRom.toUpperCase();
      if (!/^M*(CM|CD|(D?C{0,3}))?(XC|XL|(L?X{0,3}))?(IX|IV|(V?I{0,3}))?$/.test(txtRom))
        return NaN;
      var retval=0;
      txtRom.replace(/[MDLV]|C[MD]?|X[CL]?|I[XV]?/g, function(i) {
        retval += {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}[i]; 
      });
      return retval;
    }

    CSS:

    #tblRoman{border-collapse:collapse;font-family:sans-serif;font-size:.8em}

    HTML:

    <h3>Roman to Number Conversion</h3>
    <input type="button" value="example 1" onclick="document.getElementById('romanval').value='mmmmmmmcdlxxxiv'">
    <input type="button" value="example 2" onclick="document.getElementById('romanval').value='mmmmmmmdclxxxiv'">
    <input type="button" value="example 3" onclick="document.getElementById('romanval').value='mmmmmmmdxcdlxxxiv'">
    <p>
    Enter a Roman Number below, or click on an example button. Then click Convert 
    </p>
    <input type="text" size="40" id="romanval">
     <input type="button" onclick="document.getElementById('resultval').innerText
     = romanToNumber(document.getElementById('romanval').value)" value="Convert"> 
    <p />
    Numeric Value: <b id="resultval"></b>
    
    <hr>
    <h3>Number to Roman Conversion</h3>
    <input type="button" value="Generate table upto 2000" onclick="document.getElementById('tblRoman').innerHTML ='</tr>'+[...Array(2000).keys()].map(x => '<td>'+(x+1)+': '+numberToRoman(x+1)+'</td>'+((x+1)%10==0?'</tr><tr>':'')).join('')+'</tr>'">
    
    <table id="tblRoman" border></table>

  50. 0

    collegare solo sulla risposta di Piotr Berebecki.
    Ho modificato in modo che la funzione ricorsiva non solo sottrarre 1 dal numero dato, ma si è subito sottrae il più alto abbinato numero nell’array per accelerare il processo.

    //the arrays 
    var arabicFormat = [1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000];
    var romanFormat = ['I', 'IV', 'V', 'IX', 'X', 'XL', 'L', 'XC', 'C', 'CD', 'D', 'CM', 'M'];
    
    
    function convertToRoman(num) {
    
     //the recursion will stop here returning a blank
     if (num === 0){
     return '';
     }
    
     var returnValue = [];
    
     //this is the main For loop of the function
     for (var i=0; i < arabicFormat.length; i++){
    
       if (num >= arabicFormat[i]){
        //empty the array on every iteration until it gets to the final number
         returnValue = [];
        //store the current highest matched number in the array
         returnValue.push(romanFormat[i]);
        } 
    
     }
    
      //get the correct resulting format 
      returnValue = returnValue.join();
    
      //get the highest matched number value
      var whatIndex = romanFormat.indexOf(returnValue);
      var substractValue = arabicFormat[whatIndex];
    
      //here the recursion happens
      return returnValue + convertToRoman(num - substractValue);
    }
  51. 0

    Ho provato a fare il mapping di un array di numeri arabi a un array di coppie di romano. Il brutto 3 a livello di ternaries potrebbe essere sostituito dal se() {} else{} blocchi per renderlo più leggibile. Funziona da 1 a 3999 ma potrebbe essere esteso:

    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('');
    }
  52. 0

    Ci sono alcuni modi per ottenere questo risultato. Io personalmente preferisco l’utilizzo di oggetti e scorrere le coppie chiave-valore:

    const solution=(n)=>{
       const romanLetters ={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};
       let romanNumber ='';
       let valuesArr = Object.values(romanLetters);
    
       for(let i in valuesArr){
            while (n - valuesArr[i] >= 0){
                romanNumber+=Object.keys(romanLetters)[i]; 
                n-=valuesArr[i];
            }
       }
       return romanNumber;
    }
  53. 0

    Probabilmente la soluzione più semplice:

    JS:

    rome = n => {
        b=0
        s=''
        for(a=5; n; b++,a^=7)
            for(o=n%a, n=n/a^0;o--;)
                s='IVXLCDM'[o>2?b+n-(n&=-2)+(o=1):b]+s
        return s
    }
    
    r = [rome(892),rome(3999)];
    
    console.log(r);

    Non posso prendere credito però. Questo è vetalperko s soluzione CodeSignal.

  54. 0

    Mi piaceva molto la soluzione di jaggedsoft, ma non ho potuto rispondere perché la mia rep è TROPPO BASSA 🙁 🙁

    Ho rotto giù per spiegare un po ‘ per quelli che non la capiscono. Speriamo che qualcuno aiuta.

    function convertToRoman(num) {
    
      var lookup =   
    {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},roman = '',i;
    
      for ( i in lookup ) {
        while ( num >= lookup[i] ) { //while input is BIGGGER than lookup #..1000, 900, 500, etc.
          roman += i; //roman is set to whatever i is (M, CM, D, CD...)
          num -= lookup[i]; //takes away the first num it hits that is less than the input
                        //in this case, it found X:10, added X to roman, then took away 10 from input
                        //input lowered to 26, X added to roman, repeats and chips away at input number
                        //repeats until num gets down to 0. This triggers 'while' loop to stop.    
        }
      }
      return roman;
    }
    
    
    console.log(convertToRoman(36));
  55. 0

    Ecco il mio codice,Spero che questo aiuto:

    JS:

    function convertToRoman(num) {
        let numArr = [];//[M,D,C,L,X,V,I]
        let numStr = "";
    
        //get num Array
        numArr.push(parseInt(num / 1000));
        num %= 1000;
        numArr.push(parseInt(num / 500));
        num %= 500;
        numArr.push(parseInt(num / 100));
        num %= 100;
        numArr.push(parseInt(num / 50));
        num %= 50;
        numArr.push(parseInt(num / 10));
        num %= 10;
        numArr.push(parseInt(num / 5));
        num %= 5;
        numArr.push(num);
    
        //cancat num String
        for(let i = 0; i < numArr.length; i++) {
            switch(i) {
                case 0://M
                    for(let j = 0; j < numArr[i]; j++) {
                        numStr = numStr.concat("M");
                    }
                    break;
                case 1://D
                    switch(numArr[i]) {
                        case 0:
                            
                            break;
                        case 1:
                            if(numArr[i + 1] === 4) {
                                numStr = numStr.concat("CM");
                                i++;
                            }else {
                                numStr = numStr.concat("D");
                            }
                            break;
                    }
                    break;
                case 2://C
                    switch(numArr[i]) {
                        case 0:
                            
                            break;
                        case 1:
                            numStr = numStr.concat("C");
                            break;
                        case 2:
                            numStr = numStr.concat("CC");
                            break;
                        case 3:
                            numStr = numStr.concat("CCC");
                            break;
                        case 4:
                            numStr = numStr.concat("CD");
                            break;
                    }
                    break;
                case 3://L
                    switch(numArr[i]) {
                        case 0:
                            
                            break;
                        case 1:
                            if(numArr[i + 1] === 4) {
                                numStr = numStr.concat("XC");
                                i++;
                            }else {
                                numStr = numStr.concat("L");
                            }
                            break;
                    }
                    break;
                case 4://X
                    switch(numArr[i]) {
                        case 0:
                            
                            break;
                        case 1:
                            numStr = numStr.concat("X");
                            break;
                        case 2:
                            numStr = numStr.concat("XX");
                            break;
                        case 3:
                            numStr = numStr.concat("XXX");
                            break;
                        case 4:
                            numStr = numStr.concat("XL");
                            break;
                    }
                    break;
                case 5://V
                    switch(numArr[i]) {
                        case 0:
                            
                            break;
                        case 1:
                            if(numArr[i + 1] === 4) {
                                numStr = numStr.concat("IX");
                                i++;
                            }else {
                                numStr = numStr.concat("V");
                            }
                            break;
                    }
                    break;
                case 6://I
                    switch(numArr[i]) {
                        case 0:
                            
                            break;
                        case 1:
                            numStr = numStr.concat("I");
                            break;
                        case 2:
                            numStr = numStr.concat("II");
                            break;
                        case 3:
                            numStr = numStr.concat("III");
                            break;
                        case 4:
                            numStr = numStr.concat("IV");
                            break;
                    }
                    break;
            }
        }
        console.log(numStr);
        return numStr;
    }
    
    convertToRoman(3999);

  56. 0

    Questa è la mia soluzione con un unico ciclo di

    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);
  57. 0

    Questa soluzione viene eseguito solo un ciclo e ha la minima oggetto di mappa numeri a lettere romane

    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
  58. 0

    JS:

    const basicRomanNumeral = 
      ['',
        'I','II','III','IV','V','VI','VII','VIII','IX','',
        'X','XX','XXX','XL','L','LX','LXX','LXXX','XC','',
        'C','CC','CCC','CD','D','DC','DCC','DCCC','CM','',
        'M','MM','MMM'
      ];
    
    function convertToRoman(num) {
      const numArray = num.toString().split('');
      const base = numArray.length;
      let count = base-1;
      const convertedRoman = numArray.reduce((roman, digit) => {
        const digitRoman = basicRomanNumeral[+digit + count*10];
        const result = roman + digitRoman;
        count -= 1;
        return result;
      },'');
      return convertedRoman;
    }

  59. -1

    Ho scritto questo da zero per freecodecamp sfida. Spero che questo vi aiuterà a qualcuno.

    JS:

    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));

Lascia un commento