Convert a number into a Roman Numeral in javaScript

Question

How can I convert integers into roman numerals   function romanNumeralGenerator  int         For example  see the following sample inputs and outputs   1    I  5    V  10    X  20    XX  3999    MMMCMXCIX    Caveat  Only support numbers between 1 and 3999

User · Answer

x000D   x000D  const romanize   num   gt    x000D    const romans     x000D      M 1000  x000D      CM 900  x000D      D 500  x000D      CD 400  x000D      C 100  x000D      XC 90  x000D      L 50  x000D      XL 40  x000D      X 10  x000D      IX 9  x000D      V 5  x000D      IV 4  x000D      I 1 x000D       x000D     x000D    let roman       x000D     x000D    for  let key in romans    x000D      const times   Math trunc num   romans key    x000D      roman    key repeat times   x000D      num -  romans key    times  x000D      x000D   x000D    return roman  x000D    x000D   x000D  console log  x000D    romanize 38  x000D    x000D   x000D   x000D

User · Answer

Loops may be more elegant but I find them hard to read  Came up with a more or less hard coded version that s easy on the eyes  As long as you understand the very first line  the rest is a no-brainer   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

User · Answer

Here s a way of doing it without having to loop through all the different roman numerals and their corresponding numbers  It has a constant time O 1  lookup  saving a little in time complexity    It breaks down each integer from right to left  so 2 473 becomes 3   70   400   2 000  and then finds the corresponding roman numeral using the romanNumerals hash table  and appends it to the result string  It does this by adding an additional 0 to each integer before the lookup as you move right to left  This solution only works for numbers between 1 and 3 999       function integerToRoman int        if  int  lt  1    int  gt  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  gt   0  i--             if  intStr i       0                 digit     0               continue                    var num   intStr i    digit          result   romanNumerals num    result          digit     0              return result

User · Answer

This is my solution  I m not too sure how well it performs   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  gt  0              res   res concat mil Math floor num 1000              if num 100  gt  0              res   res concat cen Math floor  num 1000  100              if num 10  gt 0              res   res concat dec Math floor   num 1000  100  10              res res concat uni Math floor   num 1000  100  10        return res join

User · Answer

This solution runs only one loop and has the minimun object to map numerals to roman letters  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   gt       if  i   lt  rom length -1  amp  amp  order indexOf e   gt  order indexOf rom i 1           result -  keys e        else         result   keys e                 return result    RomantoNumeral  MMDCCCXXXVII    2837

User · Answer

I know this is an old question but I m pretty proud of this solution    It only handles numbers less than 1000 but could easily be expanded to include however large you d need by adding on to the  numeralCodes  2D array    x000D   x000D  var numeralCodes         I   II   III   IV   V   VI   VII   VIII   IX               Ones x000D                           X   XX   XXX    XL    L    LX    LXX    LXXX    XC         Tens x000D                           C   CC   CCC   CD   D   DC   DCC   DCCC   CM               Hundreds x000D   x000D  function convert num    x000D    var numeral       x000D    var digits   num toString   split     reverse    x000D    for  var i 0  i  lt  digits length  i     x000D      numeral   numeralCodes i  parseInt digits i      numeral  x000D      x000D    return numeral    x000D    x000D   lt input id  text-input  type  text  gt  x000D   lt button id  convert-button  onClick  var n   parseInt document getElementById  text-input   value  document getElementById  text-output   value   convert n    gt Convert  lt  button gt  x000D   lt input id  text-output  style  display block  type  text  gt  x000D   x000D   x000D

User · Answer

x000D   x000D  function convertToRoman num    x000D   x000D    var romans     x000D      1000   M   x000D      900   CM   x000D      500   D   x000D      400   CD   x000D      100   C   x000D      90   XC   x000D      50   L   x000D      40   XL   x000D      10   X   x000D      9   IX   x000D      5   V   x000D      4   IV   x000D      1   I  x000D       x000D    var popped  rem  roman       x000D      keys   Object keys romans   x000D    while  num  gt  0    x000D      popped   keys pop    x000D      m   Math floor num   popped   x000D      num   num   popped  x000D      console log  popped    popped    m    m    num    num    roman    roman   x000D      while  m--  gt  0    x000D        roman    romans popped   x000D        x000D      while  num   popped     0    x000D        popped   keys pop    x000D        delete romans popped   x000D        x000D      x000D    return roman  x000D    x000D  var result   convertToRoman 3999   x000D  console log result   x000D  document getElementById  roman   innerHTML    Roman      result  x000D  p   x000D    color  darkblue  x000D    x000D   lt p gt Decimal  3999 lt  p gt  x000D   lt p id  roman  gt Roman  lt  p gt  x000D   x000D   x000D

User · Answer

function toRoman n            var r               for  var c   0  c  lt  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  gt  2            var str               for  var m   1  m  lt   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

User · Answer

I tried to do this by mapping an array of the arabic numerals to an array of pairs of roman  The nasty 3-level ternaries could be replaced by if      else   blocks to make it more readable  It works from 1 to 3999 but could be extended   function romanize num      if num  gt  3999    num  lt  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    gt        return         e  lt  9   roman i  1  repeat Math floor e   5                        e   5  lt  4           roman i  0  repeat Math floor e   5             e   5     4  amp  amp  Math floor e   5      0             roman i  0    roman i  1              Math floor e   5      1               roman i  0    roman i - 1  0                               join

User · Answer

function atalakit  num        var result   quot  quot       var roman     quot MMM quot    quot MM quot    quot M quot    quot CM quot    quot DCCC quot    quot DCC quot    quot DC quot    quot D quot    quot CD quot    quot CCC quot    quot CC quot    quot C quot    quot XC quot    quot LXXX quot    quot LXX quot    quot LX quot    quot L quot    quot XL quot    quot XXX quot    quot XX quot    quot XI quot    quot X quot    quot IX quot    quot VIII quot    quot VII quot    quot VI quot    quot V quot    quot IV quot    quot III quot    quot II quot    quot I quot        var arabic    3000  2000  1000  900  800  700  600  500  400  300  200  100  90  80  70  60  50  40  30  20  11  10  9  8  7  6  5  4  3  2  1                 if   num gt 0  amp  amp  num lt 4000            var arabiclength   arabic length          for   i 0  arabiclength  gt  i  i                  if  Math floor num arabic i   gt 0                   result    roman i                   num -  arabic i                                     else           document getElementById  text   innerHTML    quot too much quot             document getElementById  text2   innerHTML   result

User · Answer

These functions convert any positive whole number to its equivalent Roman Numeral string  and any Roman Numeral to its number   Number to Roman Numeral   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  gt  1000                var prefix       suffix       n   rem  s        rem  magnitude   1              while  n  gt  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  lt  1  num   0      if  num  gt  3999  return toBigRoman num        while  num            val   v i           while  num  gt   val                num -  val              s    r i                       i            return s       Roman Numeral string to Number   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  lt  L                val   R s charAt i                  next   R s charAt i      0              if  next - val  gt  0  val    -1              sum    val                    if  accept    sum toRoman       s  return sum            return NaN

User · Answer

If it is just for display purpose  use the standard HTML with a bit of JS for the value  if needed  and CSS to make it inline    x000D   x000D  ol roman-lowercase  x000D  ol roman-uppercase   x000D    display  inline-flex  x000D    margin  0  x000D    padding  0  x000D    x000D   x000D  ol roman-lowercase   x000D    list-style  lower-roman inside  x000D    x000D   x000D  ol roman-uppercase   x000D    list-style  upper-roman inside  x000D    x000D   lt ol class  roman-lowercase  gt  lt li value  4  gt  lt  li gt  lt  ol gt   lt  -- iv  -- gt  x000D   lt ol class  roman-uppercase  gt  lt li value  142  gt  lt  li gt  lt  ol gt   lt  -- CXLII  -- gt  x000D   x000D   x000D

User · Answer

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      many other suggestions can be found at http   blog stevenlevithan com archives javascript-roman-numeral-converter

User · Answer

There is a nice one here on this blog I found using 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

User · Answer

There is several ways to accomplish this  I personally prefer using objects and iterate through the key-value pairs   const solution  n   gt      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   gt   0               romanNumber  Object keys romanLetters  i                n- valuesArr i                     return romanNumber

User · Answer

x000D   x000D  function convertToRoman num    x000D      var arr       x000D      for  var i   0  i  lt  num toString   length  i      x000D          arr push Number num toString   substr i  1     x000D        x000D      var romanArr     x000D            I    II    III    IV    V    VI    VII    VIII    IX    x000D            X    XX    XXX    XL    L    LX    LXX    LXXX    XC    x000D            C    CC    CCC    CD    D    DC    DCC    DCCC    CM    x000D            M   x000D         x000D      var roman   arr reverse   map function  val  i    x000D          if  val     0    x000D              return     x000D            x000D          if  i     3    x000D              var r       x000D              for  var j   0  j  lt  val  j      x000D                  r    romanArr i  0   x000D                x000D              return r  x000D            else   x000D              return romanArr i  val - 1   x000D            x000D          x000D      console log roman reverse   join       x000D      return roman join      x000D    x000D   x000D   x000D  convertToRoman 10   x000D   x000D   x000D

User · Answer

var romanToInt   function s        var sum           var obj     I  1  V  5  X  10  L  50  C  100  D  500  M  1000       for var i 0 i lt s length i             if obj s i   gt obj s i-1                 sum i-1     obj s i  -obj s i-1             else                  sum i   obj s i                              return sum reduce  a  b    gt  a   b  0        The above code uses an object to look up the values and calculate accordingly       var romanToInt   function s        var sum            for var i 0 i lt s length i              if s i    I               sum push 1            else if s i    V               sum push 5               else if s i    X               sum push 10               else if s i    L               sum push 50              else if s i    C               sum push 100              else if s i    D               sum push 500             else if s i    M               sum push 1000                        if sum i-1  lt sum i                sum i    sum i -sum i-1              sum i-1    0          else              sum i    sum i                      return sum reduce  a  b    gt  a   b  0        The code in the above case uses the if else-if statement to carry out the same operation  This method executes faster and is also memory efficient   It can be worked out with switch statement also in the following way     var romanToInt   function s        var sum            for var i 0 i lt s length i              switch s i                case  I                   sum push 1                   break              case  V                   sum push 5                   break              case  X                   sum push 10                   break              case  L                   sum push 50                   break              case  C                   sum push 100                   break              case  D                   sum push 500                   break              case  M                       sum push 1000                   break                     if sum i-1  lt sum i                sum i    sum i -sum i-1              sum i-1    0          else              sum i    sum i                      return sum reduce  a  b    gt  a   b  0

User · Answer

If you want to convert a big number with more symbols  maybe this algo could help   The only premise for symbols is that must be odd and follow the same rule  1  5  10  50 100       10  N  2  10  N      x000D   x000D  var rnumbers     I   V   X   L   C   D   M    x000D          rnumbers   rnumbers concat   V   X   L   C   D   M   map function n   return   lt span style  border-top 1px solid black  padding 1px   gt   n   lt  span gt        x000D          rnumbers   rnumbers concat   V   X   L   C   D   M   map function n   return   lt span style  border 1px solid black  border-bottom 1px none black  padding 1px   gt   n   lt  span gt        x000D          rnumbers   rnumbers concat   V   X   L   C   D   M   map function n   return   lt span style  border-top 3px double black  padding 1px   gt   n   lt  span gt        x000D   x000D   x000D      String prototype repeat   function  num     x000D          return new Array  num   1   join  this    x000D         x000D   x000D      function toRoman n    x000D   x000D          if  n  return     x000D   x000D          var strn   new String n   x000D          var strnlength   strn length  x000D          var ret       x000D          for var i   0   i  lt  strnlength  i      x000D              var index   strnlength 2 -2 - i 2  x000D              var str  x000D              var m    strn i   x000D              if index  gt  rnumbers length -1    x000D                  str   rnumbers rnumbers length-1  repeat m Math pow 10 Math ceil  index-rnumbers length  2     x000D               else   x000D                  str   rnumbers index  repeat m   x000D                  if  rnumbers length  gt   index   2    x000D                      var rnregexp   rnumbers index  x000D                               split      join        x000D                               split      join         x000D                       x000D                      str   str replace new RegExp       rnregexp      9     rnumbers index    rnumbers index   2   x000D                               replace new RegExp       rnregexp      5     rnumbers index   1   x000D                               replace new RegExp       rnregexp      4     rnumbers index    rnumbers index   1   x000D                    x000D                x000D              ret   str  x000D            x000D   x000D          return ret  x000D        x000D       x000D   lt input type  text  value    onkeyup  document getElementById  result   innerHTML   toRoman this value    gt  x000D   x000D   lt br  gt  lt br  gt  x000D   x000D   lt div id  result  gt  lt  div gt  x000D   x000D   x000D

User · Answer

Well  it seems as I m not the only one that got stuck on this challenge at FreeCodeCamp  But I would like to share my code with you anyhow  It s quite performant  almost 10  faster than the top-voted solution here  I haven t tested all the others and I guess mine is not the fastest   But I think it s clean and easy to understand   function convertToRoman num           Some error checking first     if   num  gt  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    gt   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      It might seem like a limitation that it only can convert numbers up to 9 999  But the fact is that from 10 000 and above a line should be provided above the literals  And that I have not solved yet   Hope this will help you

User · Answer

x000D   x000D  const basicRomanNumeral    x000D         x000D       I   II   III   IV   V   VI   VII   VIII   IX      x000D       X   XX   XXX   XL   L   LX   LXX   LXXX   XC      x000D       C   CC   CCC   CD   D   DC   DCC   DCCC   CM      x000D       M   MM   MMM  x000D       x000D   x000D  function convertToRoman num    x000D    const numArray   num toString   split      x000D    const base   numArray length  x000D    let count   base-1  x000D    const convertedRoman   numArray reduce  roman  digit    gt    x000D      const digitRoman   basicRomanNumeral  digit   count 10   x000D      const result   roman   digitRoman  x000D      count -  1  x000D      return result  x000D           x000D    return convertedRoman  x000D    x000D   x000D   x000D

User · Answer

IF this number in HTMLElement  such as span   we recommend to Add HTML attribute data-format    lt p gt Phase  lt span data-format  quot roman quot  gt 4  lt  span gt  Sales lt  p gt   Note   This is not a html standard  Javascript code used is visible once you scroll down in the html section on jsfiddle  DEMO

User · Answer

In this code  upper limit of numbers can be extended by adding new letters to 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 gt -1  i--       result   romanLetter level  numStr i     result      level           return result

User · Answer

Here is the solution with recursion  that looks simple   x000D   x000D  const toRoman    num  result         gt        const map             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                 for  const key in map            if  num  gt   map key               if  num     0                return toRoman num - map key   result   key                                       return result         console log toRoman 402       CDII console log toRoman 3000       MMM console log toRoman 93       XCIII console log toRoman 4       IV x000D   x000D   x000D

User · Answer

const convertToRoman    n   gt         let u  0      let result          let rL  IVXLCDM    while  n gt 0           u n 10      switch  u             case 1  result     rL 0    result             break            case 2  result   rL 0  rL 0    result            break            case 3  result   rL 0  rL 0  rL 0    result            break            case 4  result   rL 0  rL 1    result            break            case 5  result    rL 1    result            break            case 6  result   rL 1    rL 0    result            break            case 7  result  rL 1    rL 0   rL 0    result            break            case 8  result    rL 1    rL 0   rL 0    rL 0    result            break            case 9  result    rL 0    rL 2    result            break                             rL   rL substring 2     after every last digit   when conversion is finished       number is taking another value - same as container with roman Letter       n Math trunc n 10      return result       I m beginner  and I see like that     without arrays   of course it would be better with itter   acc in function    Just passed test at freeCodeCamp

User · Answer

Probably the simplest solution    x000D   x000D  rome   n   gt    x000D      b 0 x000D      s    x000D      for a 5  n  b   a  7  x000D          for o n a  n n a 0 o--   x000D              s  IVXLCDM  o gt 2 b n- n amp  -2   o 1  b  s x000D      return s x000D    x000D   x000D  r    rome 892  rome 3999    x000D   x000D  console log r   x000D   x000D   x000D    I can t take credit though  This is vetalperko s solution on CodeSignal

User · Answer

I didn t see this posted already so here s an interesting solution using only string manipulation    x000D   x000D  var numbers    1  4  5  7  9  14  15  19  20  44  50  94  100  444  500  659  999  1000  1024   x000D  var romanNumeralGenerator   function  number    x000D      return  I  x000D           repeat number  x000D           replace  I 5  g   V   x000D           replace  V 2  g   X   x000D           replace  X 5  g   L   x000D           replace  L 2  g   C   x000D           replace  C 5  g   D   x000D           replace  D 2  g   M   x000D           replace  DC 4  g   CM   x000D           replace  C 4  g   CD   x000D           replace  LX 4  g   XC   x000D           replace  X 4  g   XL   x000D           replace  VI 4  g   IX   x000D           replace  I 4  g   IV   x000D     x000D   x000D  console log numbers map romanNumeralGenerator   x000D   x000D   x000D

User · Answer

Still proud of it    It works between 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 lt numArr length  i          if  numArr i   lt  4          for  var j   0  j lt numArr i   j              romanNumeral push converterArray 0  numLength  0                  else if  numArr i   lt  5           for  var j   3  j lt numArr i   j              romanNumeral push converterArray 0  numLength  1                  else if  numArr i   lt  9            romanNumeral push converterArray 0  numLength  2            for  var j   5  j lt numArr i   j                romanNumeral push converterArray 0  numLength  0                  else if  numArr i   lt  10            for  var j   8  j lt numArr i   j                romanNumeral push converterArray 0  numLength  3                      numLength--         return romanNumeral join         convertToRoman 9

User · Answer

I hate listing every possibility into an array   which many people chose to solve this puzzle  so I use another function to do that work  Here are my solution    x000D   x000D    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 x000D  function romannum num rnum1 rnum2 rnum3   x000D    var result       x000D    if num  gt   1  amp  amp  num  lt  4   x000D      while num gt 0   x000D        result    rnum1  x000D        num--  x000D        x000D      x000D    else if num  gt  5  amp  amp  num  lt  9   x000D      result   rnum2  x000D      while num gt 5   x000D        result    rnum1  x000D        num--  x000D          x000D      x000D    else if num    4   x000D      result    rnum1   rnum2  x000D      x000D    else if  num    5   x000D      result    rnum2  x000D      x000D    else if  num    9   x000D      result    rnum1  rnum3  x000D      x000D    return result  x000D    x000D    the main function x000D  function convertToRoman num    x000D   num   num toString   split      x000D   var length   num length  x000D   var x   0  x000D   var result      x000D   x000D   while  length - x   gt  0   x000D     if length -x     4   x000D      result push romannum num x   M           x000D       x000D     else if length -x      3   x000D       result push romannum num x   C   D   M     x000D       x000D     else if length - x      2   x000D       result push romannum num x   X   L   C     x000D       x000D     else if length - x     1   x000D       result push romannum num x   I   V   X     x000D       x000D     x      x000D     x000D   x000D   x000D

User · Answer

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  gt   lookup i            roman    i        num -  lookup i               return roman     Reposted from a 2008 comment located at  http   blog stevenlevithan com archives javascript-roman-numeral-converter VIEW DEMO

User · Answer

I feel my solution is much more readable and easy to understand   var intToRoman   function num        let symbolMap     I   V   X   L   C   D   M   P   Q         if  num  lt  1    num  gt  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

User · Answer

This function works on the the different character sets in each digit  To add another digit add the roman numeral string the 1 place  5 place and next 1 place   This is nice because you update it with only knowing the next set of characters used    x000D   x000D  function toRoman n   x000D    var d 0 o    v k  IVXLCDM  split      x000D                       x000D    while n  0   x000D      v n 10 x k d  y k d 1  z k d 2   x000D      o     x x x x x x x y y y x y x x y x x x x z  v  o  x000D      n  n-v  10 d  2  x000D      x000D     x000D    return o x000D    x000D   x000D  var out       x000D   x000D  for  var i   0  i  lt  100  i      x000D    out    toRoman i      n   x000D    x000D   x000D  document getElementById  output   innerHTML   out  x000D   lt pre id  output  gt  lt  pre gt  x000D   x000D   x000D

User · Answer

I created two twin arrays one with arabic numbers the other with the roman characters    x000D   x000D  function convert num    x000D   x000D    var result       x000D    var rom     M    CM    D    CD    C    XC    L    XL    X    IX    V    IV    I    x000D    var ara    1000  900  500  400  100  90  50  40  10  9  5  4  1   x000D   x000D   x000D    Then I added a cycle which scan the roman elements  adding the biggest still comprised in NUM to RESULT  then we decrease NUM of the same amount    It is like we map a part of NUM in roman numbers and then we decrease it of the same amount    x000D   x000D    for  var x   0  x  lt  rom length  x      x000D      while  num  gt   ara x     x000D        result    rom x   x000D        num -  ara x   x000D        x000D      x000D    return result  x000D    x000D   x000D   x000D

User · Answer

Having seen all previous 46 solutions for  Number-To-Roman  since this question was asked  there is only one post for the reverse Roman-to-Number by kennebec  and that has several problems   Number  object cannot be directly extended  you need to use prototype  Also prototyping does not make sense in this context  String object is a better candidate if any   Secondly it is unnecessarily complex and additionally calls toRoman method  Thirdly it fails for numbers greater than 4000  Here is an elegant and and the most concise of all the 47 posts for the both type of conversions  These conversions work for basically any number  The romanToNumber is a small variation of gregoryr s elegant solution    x000D   x000D  function numberToRoman val rom     returns empty string if invalid number x000D    rom rom     x000D    if isNaN val   val  0   x000D      return rom  x000D    for i 0 curval  1000 900 500 400 100 90 50 40 10 9 5 4 1  i  i lt 13 i    x000D      if val  gt   curval  x000D      return numberToRoman val-curval rom   M   CM   D   CD   C   XC   L   XL   X   IX   V   IV   I   i   x000D    x000D   x000D  function romanToNumber txtRom    returns NaN if invalid string x000D    txtRom txtRom toUpperCase    x000D    if     M  CM CD  D C 0 3     XC XL  L X 0 3     IX IV  V I 0 3       test txtRom   x000D      return NaN  x000D    var retval 0  x000D    txtRom replace   MDLV  C MD   X CL   I XV   g  function i    x000D      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    x000D        x000D    return retval  x000D    x000D   tblRoman border-collapse collapse font-family sans-serif font-size  8em  x000D   lt h3 gt Roman to Number Conversion lt  h3 gt  x000D   lt input type  button  value  example 1  onclick  document getElementById  romanval   value  mmmmmmmcdlxxxiv   gt  x000D   lt input type  button  value  example 2  onclick  document getElementById  romanval   value  mmmmmmmdclxxxiv   gt  x000D   lt input type  button  value  example 3  onclick  document getElementById  romanval   value  mmmmmmmdxcdlxxxiv   gt  x000D   lt p gt  x000D  Enter a Roman Number below  or click on an example button  Then click Convert  x000D   lt  p gt  x000D   lt input type  text  size  40  id  romanval  gt  x000D    lt input type  button  onclick  document getElementById  resultval   innerText x000D     romanToNumber document getElementById  romanval   value   value  Convert  gt   x000D   lt p   gt  x000D  Numeric Value   lt b id  resultval  gt  lt  b gt  x000D   x000D   lt hr gt  x000D   lt h3 gt Number to Roman Conversion lt  h3 gt  x000D   lt input type  button  value  Generate table upto 2000  onclick  document getElementById  tblRoman   innerHTML    lt  tr gt       Array 2000  keys    map x   gt    lt td gt    x 1       numberToRoman x 1    lt  td gt     x 1  10  0   lt  tr gt  lt tr gt        join       lt  tr gt    gt  x000D   x000D   lt table id  tblRoman  border gt  lt  table gt  x000D   x000D   x000D

User · Answer

I just made this at freecodecamp  It can easily be expanded   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 lt values length i         if num gt  values i          if 5 lt  num  amp  amp  num lt  8  num -  5        else if 1 lt  num  amp  amp  num lt  3  num -  1        else num -  values i         roman    literals i         i--               return roman

User · Answer

I ve developed the recursive solution below  The function returns one letter and then calls itself to return the next letter  It does it until the number passed to the function is 0 which means that all letters have been found and we can exit the recursion   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  lt  romanMatrix length  i          if  num  gt   romanMatrix i  0           return romanMatrix i  1    convertToRoman num - romanMatrix i  0

User · Answer

After testing some of the implementations in this post  I have created a new optimized one in order to execute faster  The time execution is really low comparing with the others  but obviously the code is uglier      It could be even faster with an indexed array with all the posibilities  Just in case it helps someone   function concatNumLetters letter  num        var text           for var i 0  i lt num  i             text    letter            return text      function arabicToRomanNumber arabic        arabic   parseInt arabic       var roman           if  arabic  gt   1000            var thousands      arabic   1000           roman   concatNumLetters  M   thousands           arabic -  thousands   1000              if  arabic  gt   900             roman     CM            arabic -  900               if  arabic  gt   500             roman     D            arabic -  500               if  arabic  gt   400             roman     CD            arabic -  400               if  arabic  gt   100             var hundreds      arabic   100           roman    concatNumLetters  C   hundreds           arabic -  hundreds   100               if  arabic  gt   90             roman     XC            arabic -  90               if  arabic  gt   50             roman     L            arabic -  50               if  arabic  gt   40             roman     XL            arabic -  40               if  arabic  gt   10            var dozens      arabic   10           roman    concatNumLetters  X   dozens           arabic -  dozens   10               if  arabic  gt   9             roman     IX            arabic -  9                if  arabic  gt   5             roman     V            arabic -  5               if  arabic  gt   4             roman     IV            arabic -  4               if  arabic  gt   1            roman    concatNumLetters  I   arabic                return roman

User · Answer

I am just posting a function I made to convert to Roman  I hope you like it  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  gt  0        if  numToConv  gt  R 0  1             if  numToConv  lt  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  lt  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  gt  0                if   R i-1  1   gt  numToConv   amp  amp   R i  1   lt  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   lt  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  lt  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       The edited code with comments   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  gt  0      just checking  there is no zero         if  numToConv  gt  R 0  1       checks if the number is bigger than the bigger number in the array             if  numToConv  lt  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  lt  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  gt  0      just a precaution because we are about to use  i-1                   if   R i-1  1   gt  numToConv   amp  amp   R i  1   lt  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   lt  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  lt  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

User · Answer

I don t understand why everyones solution is so long and uses multiple for loops   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

User · Answer

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 lt numArr length  i         romanReturn unshift search i  numArr i -1          return romanReturn join

User · Answer

This works for all numbers only in need of roman numerals M and below    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 lt code length  i          while num  gt   code i  0           rom    code i  1         num -  code i  0               return rom

User · Answer

just connecting on the answer of Piotr Berebecki  I edited it so that the recursive function does not only subtract 1 from the given number  but it immediately subtracts the highest matched number in the provided array to speed up the process      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  lt  arabicFormat length  i         if  num  gt   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

User · Answer

My solution breaks the number in to an array of strings  adds zeros to each element based on its position relative to the length of the array  converts the new strings with zeros to roman numerals  and then joins them back together   This will only work with numbers up to 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  lt  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

User · Answer

While my answer is not as performant as others  my focus was more on not hard coding in base numbers and allowing the program to figure out the rest  For example    Instead of  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    I used     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  lt  0                return base idx     pivot idx            else              return pivot idx     base idx                  else if distance     0           return pivot idx        else if distance  gt  1           return pivot idx     base idx  repeat  num-5        else          return base idx  repeat  num            reverse   join

User · Answer

This is my solution with a single loop  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 gt  roman key         if check             console log romanNum             romanNum    key            num-  roman key                  return romanNum    convertToRoman 150

User · Answer

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  lt  v length  i              value   parseInt num v i            for j   0  j  lt  value  j                  s    r i                     num   num v i             return s

User · Answer

Use this code   function convertNumToRoman num     const romanLookUp    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 result            Sort the object values to get them to descending order   Object keys romanLookUp  sort  a b   gt romanLookUp b -romanLookUp a   forEach  key   gt       while num gt  romanLookUp key          result  key        num- romanLookUp key               return result

User · Answer

Here is my solution   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  lt   strNum length  i            if  Number strNum strNum length - i       0              romanNum   romans i  strNum strNum length - i  - 1    romanNum       return romanNum      It performs quite well in Chrome 60 - https   jsperf com num-to-roman

User · Answer

Nice responses  You can get this done programmatically without hardcoding the values too much  Only that your code will be a little longer   const convertToRoman    arabicNum    gt        const roman benchmarks    1   I   5   V   10   X   50   L   100   C   500   D   1000   M   5000    V   10000    X   50000    L   100000    C            in the future  you can add higher numbers with their corresponding roman symbols letters and the program will adjust to the change     const arabic benchmarks    1  5  10  50  100  500  1000  5000  10000  50000  100000        don t forget to include the new numbers here too     arabicNum   parseInt arabicNum       let proceed   parseInt arabicNum toString   length       let romanNumeral           while proceed          the loop continues as long as there s still a unit left in arabicNum         const temp denominator   1    10   arabicNum toString   length-1       determine what multiple of 10 arabicNum is         const multiple   Math floor arabicNum temp denominator             get its first digit         const newNum   multiple temp denominator           regenerate a floored version of arabicNum         const filtered two   arabic benchmarks filter  x  i    gt  newNum  gt   x  amp  amp  newNum lt   arabic benchmarks i 1     newNum  lt   x  amp  amp  newNum gt   arabic benchmarks i-1                   filter arabic benchmarks for the 2 boundary numbers newNum falls within         switch  newNum         check for what roman numeral best describes newNum and assign it to romanNumeral             case  newNum    filtered two 0 -temp denominator   newNum                      romanNumeral    roman benchmarks temp denominator  roman benchmarks filtered two 0                   break              case  newNum    filtered two 0    newNum                        romanNumeral    roman benchmarks filtered two 0                   break               case  newNum  gt  filtered two 0   amp  amp  newNum  lt   filtered two 1 -temp denominator    newNum                       romanNumeral    roman benchmarks filtered two 0                  const factor   multiple  lt  5    multiple 5 -1   multiple 5                  for let i   0  i  lt  factor  i                         romanNumeral    roman benchmarks temp denominator                                     break              case  newNum    filtered two 1 -temp denominator   newNum                        romanNumeral    roman benchmarks temp denominator  roman benchmarks filtered two 1                    break              case  newNum    filtered two 1    newNum                        romanNumeral    roman benchmarks filtered two 1                    break              default                  break                     arabicNum   arabicNum - newNum     reduce arabicNum by its first hierarchy         proceed--     continue the loop            return romanNumeral

User · Answer

This function will convert any number smaller than 3 999 999 to roman  Notice that numbers bigger than 3999 will be inside a label with text-decoration set to overline  this will add the overline that is the correct representation for x1000 when the number is bigger than 3999   Four million  4 000 000  would be IV with two overlines so  you would need to use some trick to represent that  maybe a DIV with border-top  or some background image with those two overlines    Each overline represents x1000   function convert num       num   parseInt num        if  num  gt  3999999    alert  Number is too big     return false        if  num  lt  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  lt   3999999  amp  amp  num  gt   4000            num           need to convert to string for  substring           result     lt label style  text-decoration  overline   gt   convert num substring 0 num length-3     lt  label gt            num   num substring num length-3              for  x   0  x  lt  ref length  x             while num  gt   xis x                result    ref x               num -  xis x                       return result

User · Answer

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  lt  roNumerals prop   i            roNuStr    prop               return roNuStr     convertToRoman 9

User · Answer

I know this is a dated question but I have the shortest solution of the ones listed here and thought I would share since I think its easier to understand   This version does not require any hard coded logic for edge cases such as 4 IV  9 IX  40 XL  900 CM   etc  as the others do  This also means it can handle larger numbers greater than the maximum roman scale could  3999   For example if  T  became a new symbol you could add it to the beginning of the romanLookup object and it would keep the same algorithmic affect  or course assuming the  no more than 3 of the same symbol in a row  rule applies   I have tested this against a data set from 1-3999 and it works flawlessly   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  gt   curValue          if count  lt  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    gt  -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

User · Answer

This is the first time I really got stuck on freecodecamp  I perused through some solutions here and was amazed at how different they all were  Here is what ended up working for 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 gt 0     for  i arrayLen-1   i gt  0   i--      if num  gt   Object keys lookupObj  i         roman   roman   lookupObj Object keys lookupObj  i                num   num - Object keys lookupObj  i       break                 return roman      convertToRoman 1231

User · Answer

Here is my  as functional as it gets  solution    x000D   x000D  var numerals     I   V   X   L   C   D   M    x000D        number   1453  x000D        digits   Array    Math log10 number  1   fill number  map  n i    gt  Math trunc n Math pow 10 i 1  Math pow 10 i          lt -  3 5 4 1  x000D        result   digits reduce  p c i    gt   c     0      x000D                                                     c  lt  4   numerals 2 i  repeat c  x000D                                                             c     4   numerals 2 i    numerals 2 i 1  x000D                                                                       c  lt  9   numerals 2 i 1    numerals 2 i  repeat c-5  x000D                                                                               numerals 2 i    numerals 2 i 2     p      x000D  console log result   x000D   x000D   x000D

User · Answer

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  lt  decimals length  i              if n  lt  1              return                     if n  gt   decimals i                 return roman i    toRoman n - decimals i

User · Answer

A strings way   for M chiffer and below          const romanNumerals                                          I    V    X     for ones 0-9                                    X    L    C     for tens 10-90                                    C    D    M     for hundreds 100-900                                                     function romanNumUnderThousand dijit  position                        let val                           if  position  lt  3                            const  a  b  c    romanNumerals position                           switch  dijit                                case  1   val   a               break                              case  2   val   a   a           break                              case  3   val   a   a   a       break                              case  4   val   a   b           break                              case  5   val   b               break                              case  6   val   b   a           break                              case  7   val   b   a   a       break                              case  8   val   b   a   a   a   break                              case  9   val   a   c           break                                                                      return val                         function convertToRoman num        num   parseInt num       const str num   num toString        const lastIndex   str num length - 1      return                   num  gt  999     M  repeat parseInt str num slice 0  lastIndex - 2                            num  gt  99    romanNumUnderThousand str num lastIndex - 2   2                          num  gt  9    romanNumUnderThousand str num lastIndex - 1   1                       romanNumUnderThousand str num lastIndex   0                       join                convertToRoman 36

User · Answer

x000D   x000D  function convertToRoman num    x000D    var toTen         I    II    III    IV    V    VI    VII    VIII    IX    X    x000D    var toHungred         X    XX    XXX    XL    L    LX    LXX    LXXX    XC    C    x000D    var toThousend         C    CC    CCC    CD    D    DC    DCC    DCCC    CM    M         x000D    var arrString   String num  split        x000D    var arr                  x000D    if  arrString length    3          x000D        arr push toThousend arrString  0     x000D        arr push toHungred arrString  1     x000D        arr push toTen arrString  2     x000D        x000D    else if  arrString length    2          x000D        arr push toHungred arrString  0     x000D       arr push toTen arrString  1             x000D      x000D    else if  arrString length    1          x000D     arr push toTen arrString  0                x000D      x000D    else if  arrString length    4     x000D      for  var i  1  i lt   arrString  0    i      x000D                    arr push  M                      x000D                    x000D      arr push toThousend arrString  1     x000D     arr push toHungred arrString  2     x000D     arr push toTen arrString  3     x000D                    x000D    console log  arr join       x000D    x000D   x000D  convertToRoman 36   x000D   x000D   x000D

User · Answer

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  gt  roman key       if check          result   result   key repeat parseInt num roman key           num   num roman key              return result     console log convertToRoman 36

User · Answer

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 gt  10            var decNum    num - lastDig  10          if decNum gt 9 decNum  10       var ourNumb2   RomNumDig 1  decNum-1             if num gt  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 gt 0  i--        while num gt  decNum i             ourNumb    romNumDig i           num -  decNum i               return ourNumb    console log convert 9     IX

User · Answer

I just completed this on freeCodeCamp too  I didn t see this particular solution  I know this solution can be optimized with recursion but I just wanted to throw it out there so at least you can see other options   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  gt   1000        temp   Math floor num   1000        buffer   offsets temp - 1        base   6       value push getValue base  letters  buffer         num -  temp   1000            Hundreds   if  num  gt   100        temp   Math floor num   100        buffer   offsets temp - 1        base   4       value push getValue base  letters  buffer         num -  temp   100            Tens   if  num  gt   10        temp   Math floor num   10        buffer   offsets temp - 1        base   2       value push getValue base  letters  buffer         num -  temp   10            Ones   if  num  gt  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  lt  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  gt  0  value push letters base   val2            Now add in the next letters of the base for the inciment     for  var i   0  i  lt  val1  i            value push letters base                 return value join         convertToRoman 90     I m pretty sure the companion function means it can have almost limitless potential  assuming you provide the correct symbols for numbers larger than M  but don t quote me on that

User · Answer

I personally think the neatest way  not by any means the fastest  is with recursion    function convert num       if num  lt  1   return        if num  gt   40   return  XL    convert num - 40      if num  gt   10   return  X    convert num - 10      if num  gt   9   return  IX    convert num - 9      if num  gt   5   return  V    convert num - 5      if num  gt   4   return  IV    convert num - 4      if num  gt   1   return  I    convert num - 1        console log convert 39       Output  XXXIX   This will only support numbers 1-40  but it can easily be extended by following the pattern

User · Answer

Here s mine  function convertToRoman num    let decimalValueArray    1  4  5  9  10  40  50  90  100  400  500  900  1000   quot bigger quot    let romanNumArray     quot I quot    quot IV quot    quot V quot    quot IX quot    quot X quot    quot XL quot    quot L quot    quot XC quot    quot C quot    quot CD quot    quot D quot    quot CM quot    quot M quot    let resultNumArray       function getRoman num        for  let i   0  i  lt  decimalValueArray length  i              let decimalElem   decimalValueArray i           if  num     decimalElem    num     0                resultNumArray push romanNumArray i                return              else if  decimalElem  gt  num    decimalElem      quot bigger quot         using  decimalElem gt num  and then array value of i-1  to get the highest decimal value from the array but this doesnt work when highest decimel value is 1000 so added   quot bigger quot  element              resultNumArray push romanNumArray i - 1                getRoman num -  decimalValueArray i - 1               else               continue                    return          getRoman num   let resultNumber    resultNumArray join  quot  quot     return resultNumber

User · Answer

I wrote this from scratch for freecodecamp challenge  I hope this will help someone    x000D   x000D  function convertToRoman num    x000D   x000D      var nums    0  0  0  0   x000D   x000D      var numsRom                     x000D   x000D      var nRom     x000D          I   I   x000D          V   V   x000D          X   X   x000D          L   L   x000D          C   C   x000D          D   D   x000D          M   M  x000D         x000D         x000D      1  x000D      5  x000D      10  x000D      50  x000D      100  x000D      500  x000D      1000 x000D         x000D   x000D      var i  x000D   x000D      nums 0    Math floor num   1000   x000D      nums 1    Math floor  num - nums 0    1000    100   x000D      nums 2    Math floor  num - nums 0    1000 - nums 1    100    10   x000D      nums 3    num - nums 0    1000 - nums 1    100 - nums 2    10  x000D   x000D        1000 x000D      for  i   0  i  lt  nums 0   i      x000D          numsRom 0     nRom M  x000D        x000D   x000D        100 x000D      switch  nums 1     x000D          case 1  x000D          case 2  x000D          case 3  x000D              for  i   0  i  lt  nums 1   i      x000D                  numsRom 1     nRom C  x000D                x000D              break  x000D          case 4  x000D              numsRom 1     nRom C   nRom D  x000D              break  x000D          case 5  x000D              numsRom 1     nRom D  x000D              break  x000D          case 6  x000D          case 7  x000D          case 8  x000D              numsRom 1     nRom D  x000D              for  i   0  i  lt  nums 1  - 5  i      x000D                  numsRom 1     nRom C  x000D                x000D              break  x000D          case 9  x000D              numsRom 1     nRom C   nRom M  x000D        x000D   x000D        10 x000D      switch  nums 2     x000D          case 1  x000D          case 2  x000D          case 3  x000D              for  i   0  i  lt  nums 2   i      x000D                  numsRom 2     nRom X  x000D                x000D              break  x000D          case 4  x000D              numsRom 2     nRom X   nRom L  x000D              break  x000D          case 5  x000D              numsRom 2     nRom L  x000D              break  x000D          case 6  x000D          case 7  x000D          case 8  x000D              numsRom 2     nRom L  x000D              for  i   0  i  lt  nums 2  - 5  i      x000D                  numsRom 2     nRom X  x000D                x000D              break  x000D          case 9  x000D              numsRom 2     nRom X   nRom C  x000D        x000D   x000D        1 x000D      switch  nums 3     x000D          case 1  x000D          case 2  x000D          case 3  x000D              for  i   0  i  lt  nums 3   i      x000D                  numsRom 3     nRom I  x000D                x000D              break  x000D          case 4  x000D              numsRom 3     nRom I   nRom V  x000D              break  x000D          case 5  x000D              numsRom 3     nRom V  x000D              break  x000D          case 6  x000D          case 7  x000D          case 8  x000D              numsRom 3     nRom V  x000D              for  i   0  i  lt  nums 3  - 5  i      x000D                  numsRom 3     nRom I  x000D                x000D              break  x000D          case 9  x000D              numsRom 2     nRom I   nRom X  x000D        x000D   x000D      return numsRom join      x000D    x000D   x000D  console log  Number      1234     is     convertToRoman 1234    x000D   x000D   x000D

User · Answer

Here is my code Hope this helpful    x000D   x000D  function convertToRoman num    x000D      let numArr         M D C L X V I  x000D      let numStr       x000D   x000D        get num Array x000D      numArr push parseInt num   1000    x000D      num    1000  x000D      numArr push parseInt num   500    x000D      num    500  x000D      numArr push parseInt num   100    x000D      num    100  x000D      numArr push parseInt num   50    x000D      num    50  x000D      numArr push parseInt num   10    x000D      num    10  x000D      numArr push parseInt num   5    x000D      num    5  x000D      numArr push num   x000D   x000D        cancat num String x000D      for let i   0  i  lt  numArr length  i      x000D          switch i    x000D              case 0   M x000D                  for let j   0  j  lt  numArr i   j      x000D                      numStr   numStr concat  M    x000D                    x000D                  break  x000D              case 1   D x000D                  switch numArr i     x000D                      case 0  x000D                           x000D                          break  x000D                      case 1  x000D                          if numArr i   1      4    x000D                              numStr   numStr concat  CM    x000D                              i    x000D                           else   x000D                              numStr   numStr concat  D    x000D                            x000D                          break  x000D                    x000D                  break  x000D              case 2   C x000D                  switch numArr i     x000D                      case 0  x000D                           x000D                          break  x000D                      case 1  x000D                          numStr   numStr concat  C    x000D                          break  x000D                      case 2  x000D                          numStr   numStr concat  CC    x000D                          break  x000D                      case 3  x000D                          numStr   numStr concat  CCC    x000D                          break  x000D                      case 4  x000D                          numStr   numStr concat  CD    x000D                          break  x000D                    x000D                  break  x000D              case 3   L x000D                  switch numArr i     x000D                      case 0  x000D                           x000D                          break  x000D                      case 1  x000D                          if numArr i   1      4    x000D                              numStr   numStr concat  XC    x000D                              i    x000D                           else   x000D                              numStr   numStr concat  L    x000D                            x000D                          break  x000D                    x000D                  break  x000D              case 4   X x000D                  switch numArr i     x000D                      case 0  x000D                           x000D                          break  x000D                      case 1  x000D                          numStr   numStr concat  X    x000D                          break  x000D                      case 2  x000D                          numStr   numStr concat  XX    x000D                          break  x000D                      case 3  x000D                          numStr   numStr concat  XXX    x000D                          break  x000D                      case 4  x000D                          numStr   numStr concat  XL    x000D                          break  x000D                    x000D                  break  x000D              case 5   V x000D                  switch numArr i     x000D                      case 0  x000D                           x000D                          break  x000D                      case 1  x000D                          if numArr i   1      4    x000D                              numStr   numStr concat  IX    x000D                              i    x000D                           else   x000D                              numStr   numStr concat  V    x000D                            x000D                          break  x000D                    x000D                  break  x000D              case 6   I x000D                  switch numArr i     x000D                      case 0  x000D                           x000D                          break  x000D                      case 1  x000D                          numStr   numStr concat  I    x000D                          break  x000D                      case 2  x000D                          numStr   numStr concat  II    x000D                          break  x000D                      case 3  x000D                          numStr   numStr concat  III    x000D                          break  x000D                      case 4  x000D                          numStr   numStr concat  IV    x000D                          break  x000D                    x000D                  break  x000D            x000D        x000D      console log numStr   x000D      return numStr  x000D    x000D   x000D  convertToRoman 3999   x000D   x000D   x000D

User · Answer

I really liked the solution by jaggedsoft but I couldn t reply because my rep is TOO LOW        I broke it down to explain it a little bit for those that don t understand it  Hopefully it helps someone   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  gt   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

User · Answer

function convertToRoman int        console log  Number    int       let roman           let i  k  replacement      let seq     I    V    X    L    C    D    M         while  int  gt  999            roman push  M            int -  1000            while  int  gt  499            roman push  D            int -  500            while  int  gt  99            roman push  C            int -  100            while  int  gt  49            roman push  L            int -  50            while  int  gt  9            roman push  X            int -  10            while  int  gt  4            roman push  V            int -  5            while  int  gt   1            roman push  I            int -  1                Replace recurrences of 4   IIII  to  IV       for  i   0  i  lt  roman length  i              if  roman i     roman i   1   amp  amp              roman i     roman i   2   amp  amp              roman i     roman i   3                 for  k   0  k  lt  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  lt  roman length  i              if  roman i     roman i   2   amp  amp  roman i     roman i   1                 for  k   0  k  lt  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

User · Answer

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  gt   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

User · Answer

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  lt  romNumerals length  i          while  runningTotal   romNumerals i  1   lt   num          runningTotal    romNumerals i  1         roman    romNumerals i  0               return roman

User · Answer

Here s my solution   var roman    MX    function solution roman      var val   0    for  let i   0  i  lt  roman length  i          if  roman charAt i      I           if  roman charAt i   1      V             val    4       IV         else if  roman charAt i   1      X             val    9       IX         else           val    1       I               else if  roman charAt i      V           if  roman charAt i - 1      I             val   val          else           val    5       V               else if  roman charAt i      X           if  roman charAt i - 1      I          Check if there is I before X         val   val         else if  roman charAt i   1      L             val    40      XL         else if  roman charAt i   1      C             val    90      XC         else           val    10      X               else if  roman charAt i      L           if  roman charAt i - 1      X          Check if there is X before L         val   val          else           val    50      L               else if  roman charAt i      C           if  roman charAt i - 1      X             val   val      XC        else if  roman charAt i   1      D             val    400      CD         else if  roman charAt i   1      M             val    900      CM         else           val    100      C               else if  roman charAt i      D           if  roman charAt i - 1      C             val   val      CD         else           val    500     D               else if  roman charAt i      M           if  roman charAt i - 1      C             val   val      CM         else           val    1000     M                     return val    console log solution roman        The answer is  1010

User · Answer

Here s a regular expression solution   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

[javascript] Convert a number into a Roman Numeral in javaScript

Examples related to javascript

Examples related to roman-numerals