Roman numerals/Encode: Difference between revisions

{{trans|Python}}

 

V rnums = ‘M CM D CD C XC L XL X IX V IV I’.split(‘ ’)

 

1009, 1444, 1666, 1945, 1997, 1999, 2000, 2008, 2010, 2011, 2500, 3000, 3999]

L(val) test

 

=={{header|8080 Assembly}}==

jmp test

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

dgtbufdef: db 5,0

dgtbuf: ds 6

=={{header|8086 Assembly}}==

===Main and Supporting Functions===

The main program and test values: 70,1776,2021,3999,4000

call EncodeRoman

mov si,offset StringRam

 

 

The <code>EncodeRoman</code> routine:

 

EncodeRoman:

ror al,cl ;AX = 0X0Yh

pop cx

 

Macros used:

push ax

push bx

pop bx

pop ax

===Output===

{{out}}

 

=={{header|Action!}}==

CARD ARRAY arabic=[1000 900 500 400 100 90 50 40 10 9 5 4 1]

PTR ARRAY roman(13)

PrintF("%U=%S%E",data(i),r)

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Roman_numerals_encode.png Screenshot from Atari 8-bit computer]

 

=={{header|ActionScript}}==

var lookup:Object = {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 roman:String = "", i:String;

trace("2008 in roman is " + arabic2roman(2008));

trace("1666 in roman is " + arabic2roman(1666));

{{out}}

<pre>1990 in roman is MCMXC

</pre>

And the reverse:

var romanArr:Array = roman.toUpperCase().split('');

var lookup:Object = {I:1, V:5, X:10, L:50, C:100, D:500, M:1000};

trace("MCMXC in arabic is " + roman2arabic("MCMXC"));

trace("MMVIII in arabic is " + roman2arabic("MMVIII"));

{{out}}

<pre>MCMXC in arabic is 1990

 

=={{header|Ada}}==

 

procedure Roman_Numeral_Test is

Put_Line (To_Roman (25));

Put_Line (To_Roman (944));

{{out}}

<pre>

 

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

[]CHAR adjust roman = "CCXXmmccxxii";

[]INT arabic = (1000000, 500000, 100000, 50000, 10000, 5000, 1000, 500, 100, 50, 10, 5, 1);

print((val, " - ", arabic to roman(val), new line))

OD

{{out}} (last example is manually wrapped):

<pre style="height:30ex;overflow:scroll">

{{works with|awtoc|any - tested with release [http://www.jampan.co.nz/~glyn/aw2c.tar.gz Mon Apr 27 14:25:27 NZST 2009]}}

<!-- This specimen was emailed to be by Glyn Webster > "Here's a Roman number procedure that would fit in:" -->

 

PROCEDURE ROMAN (INTEGER VALUE NUMBER; STRING(15) RESULT CHARACTERS; INTEGER RESULT LENGTH);

ROMAN(2009, S, I); WRITE(S, I);

ROMAN(405, S, I); WRITE(S, I);

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

⍝ Digits and corresponding values

ds←((⊢≠⊃)⊆⊢)' M CM D CD C XC L XL X IX V IV I'

(d⊃ds),∇⍵-d⊃vs ⍝ While one exists, add it and subtract from number

}⍵

 

{{out}}

{{Trans|Haskell}}

(mapAccumL version)

 

-- roman :: Int -> String

missing value

end if

{{Out}}

<pre>{"MMXVI", "MCMXC", "MMVIII", "MM", "MDCLXVI"}</pre>

=={{header|Arturo}}==

{{trans|Nim}}

[50 "L"] [40 "XL"] [10 "X"] [9 "IX"] [5 "V"] [4 "IV"] [1 "I"])

1000 1009 1444 1666 1945 1997 1999 2000 2008 2010 2011 2500

3000 3999] 'n

 

{{out}}

=={{header|AutoHotkey}}==

{{trans|C++}}

 

stor(value)

}

Return result . "O"

 

=={{header|Autolisp}}==

(defun c:roman() (romanNumber (getint "\n Enter number > "))

(defun romanNumber (n / uni dec hun tho nstr strlist nlist rom)

rom

)

{{out}}

<pre>

 

=={{header|AWK}}==

# syntax: GAWK -f ROMAN_NUMERALS_ENCODE.AWK

BEGIN {

return(roman1000[v] roman100[w] roman10[x] roman1[y])

}

{{out}}

<pre>

 

=={{header|BASIC}}==

==={{header|ASIC}}===

{{trans|DWScript}}

REM Roman numerals/Encode

DIM Weights(12)

ExitToRoman:

RETURN

 

==={{header|Commodore BASIC}}===

{{works with|Commodore BASIC|7.0}}

C-128 version:

110 FOR I=0 TO 12

120 : READ RN$(I), NV(I)

330 : LOOP

340 : PRINT RN$;CHR$(13)

 

{{works with|Commodore BASIC|3.5}}

C-16/116/Plus-4 version (BASIC 3.5 has DO/LOOP but not BEGIN/BEND)

110 FOR I=0 TO 12

120 : READ RN$(I), NV(I)

330 : LOOP

340 : PRINT RN$;CHR$(13)

 

{{works with|Commodore BASIC|2.0}}

This version works on any Commodore, though the title banner should be adjusted to match the color and screen width of the particular machine.

110 FOR I=0 TO 12

120 : READ RN$(I), NV(I)

340 : PRINT RN$;CHR$(13)

350 GOTO 210

 

The output is the same for all the above versions:

==={{header|FreeBASIC}}===

{{works with|FreeBASIC}}

DIM SHARED arabic(0 TO 12) AS Integer => {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1 }

DIM SHARED roman(0 TO 12) AS String*2 => {"M", "CM", "D","CD", "C","XC","L","XL","X","IX","V","IV","I"}

PRINT "1666 = "; toRoman(1666)

PRINT "3888 = "; toRoman(3888)

 

{{out}}

1666 = MDCLXVI

3888 = MMMDCCCLXXXVIII

</pre>

 

==={{header|IS-BASIC}}===

110 DO

120 PRINT :INPUT PROMPT "Enter an arabic number: ":N

310 END DEF

320 DATA 1000,"M",900,"CM",500,"D",400,"CD",100,"C",90,"XC"

 

==={{header|ZX Spectrum Basic}}===

20 DATA 500,"D",400,"CD"

30 DATA 100,"C",90,"XC"

150 GO TO 120

160 NEXT I

 

=={{header|Batch File}}==

{{trans|BASIC}}

setlocal enabledelayedexpansion

 

set result=!result!!rom%a%!

set /a value-=!arab%a%!

{{Out}}

<pre>2009 = MMIX

1666 = MDCLXVI

3888 = MMMDCCCLXXXVIII</pre>

 

=={{header|BCPL}}==

 

let toroman(n, v) = valof

show(3888)

show(2021)

{{out}}

<pre>1666 = MDCLXVI

Reads the number to convert from standard input. No range validation is performed.

 

4-v >5+#:/#<\55+%:5/\5%:

vv_$9+00g+5g\00g8+>5g\00

g>\20p>:10p00g \#v _20gv

> 2+ v^-1g01\g5+8<^ +9 _

 

{{out}}

=={{header|BQN}}==

{{trans|APL}}

ds ← 1↓¨(¯1+`⊏⊸=)⊸⊔" I IV V IX X XL L XC C CD D CM M"

vs ← 1e3∾˜ ⥊1‿4‿5‿9×⌜˜10⋆↕3

(⊑⟜ds∾·𝕊𝕩-⊑⟜vs) 1-˜⊑vs⍋𝕩

}

{{out|Example use}}

 

=={{header|Bracmat}}==

= indian roman cifr tenfoldroman letter tenfold

. !arg:#?indian

)

)

{{out}}

<pre>1990 MCMXC

===Naive solution===

This solution is a smart but does not return the number written as a string.

 

 

return 0;

}

{{out}}

<pre>Enter arabic number:

</pre>

===Not thread-safe===

 

#include <stdio.h>

} digits[] = {

{"M", 1000}, {"CM", 900}, {"D", 500 }, {"CD", 400 },

};

 

 

return 0;

{{Output}}

<pre>Write given numbers as Roman numerals.

 

=={{header|C sharp|C#}}==

class Program

{

}

}

 

One-liner Mono REPL

Func<int, string> toRoman = (number) =>

new Dictionary<int, string>

{1, "I"}

}.Aggregate(new string('I', number), (m, _) => m.Replace(new string('I', _.Key), _.Value));

 

{{out}}

=={{header|C++}}==

===C++ 98===

#include <string>

 

std::cout << to_roman(i) << std::endl;

}

 

===C++ 11===

#include <string>

 

for (int i = 0; i < 2018; i++)

std::cout << i << " --> " << to_roman(i) << std::endl;

 

=={{header|Ceylon}}==

class Numeral(shared Character char, shared Integer int) {}

assert (toRoman(1990) == "MCMXC");

assert (toRoman(2008) == "MMVIII");

 

=={{header|Clojure}}==

The easiest way is to use the built-in cl-format function

(partial clojure.pprint/cl-format nil "~@R"))

 

;"CXXIII"

(arabic->roman 99)

(sorted-map

1 "I", 4 "IV", 5 "V", 9 "IX",

 

(int->roman 1999)

 

 

An alternate implementation:

 

(defn a2r [a]

(let [rv '(1000 500 100 50 10 5 1)

(and (< a v) (< a l)) (recur a (rest rv) (rest dv) r)

:else (recur (- a l) (rest rv) (rest dv) (str r (rm d) (rm v)))))))))

 

Usage:

 

(a2r 1666)

"MDCLXVI"

(map a2r [1000 1 389 45])

("M" "I" "CCCLXXXIX" "XLV")

 

An alternate implementation:

 

(def roman-map

(sorted-map-by >

(>= v e) (cons roman (a2r v n))

(< v e) (cons roman (a2r v (rest n))))))))

 

Usage:

 

(a2r 1666)

"MDCLXVI"

(map a2r [1000 1 389 45])

("M" "I" "CCCLXXXIX" "XLV")

 

=={{header|CLU}}==

rep = null

stream$putl(po, int$unparse(test) || " = " || roman$encode(test))

end

{{out}}

<pre>1666 = MDCLXVI

=={{header|COBOL}}==

 

IDENTIFICATION DIVISION.

PROGRAM-ID. TOROMAN.

end-perform

.

{{out}} (input was supplied via STDIN)

<pre>

=={{header|CoffeeScript}}==

 

decimal_to_roman = (n) ->

# This should work for any positive integer, although it

else

console.log "error for #{decimal}: #{roman} is wrong"

 

=={{header|Common Lisp}}==

 

 

=={{header|Cowgol}}==

include "argv.coh";

 

print(decimalToRoman(number as uint16, &buffer as [uint8]));

print_nl();

 

{{out}}

 

=={{header|D}}==

in {

assert(n < 5000);

}

 

 

=={{header|Delphi}}==

{{trans|DWScript}}

 

{$APPTYPE CONSOLE}

Writeln(IntegerToRoman(2008)); // MMVIII

Writeln(IntegerToRoman(1666)); // MDCLXVI

 

=={{header|DWScript}}==

{{trans|D}}

const symbols = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"];

 

PrintLn(toRoman(455));

PrintLn(toRoman(3456));

 

=={{header|EasyLang}}==

 

.

 

=={{header|ECL}}==

SetWeights := [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];

SetSymbols := ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I'];

RomanEncode(1990 ); //MCMXC

RomanEncode(2008 ); //MMVIII

 

=={{header|Eiffel}}==

APPLICATION

 

Result := rnum

end

 

=={{header|Ela}}==

{{trans|Haskell}}

 

digit x y z k =

| else = digit 'I' 'V' 'X' x

 

 

{{out}}

=={{header|Elena}}==

{{trans|C#}}

import system'routines;

import extensions;

extension op

{

}

console.printLine("2008 : ", 2008.toRoman());

console.printLine("1666 : ", 1666.toRoman())

{{out}}

<pre>

=={{header|Elixir}}==

{{trans|Erlang}}

def encode(0), do: ''

def encode(x) when x >= 1000, do: [?M | encode(x - 1000)]

defp digit(8, x, y, _), do: [y, x, x, x]

defp digit(9, x, _, z), do: [x, z]

 

'''Another:'''

{{trans|Ruby}}

@symbols [ {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'} ]

Enum.join(roman)

end

 

'''Test:'''

IO.puts "#{n}: #{Roman_numeral.encode(n)}"

 

{{out}}

 

=={{header|Emacs Lisp}}==

"Translate from arabic number AN to roman number.

For example, (ar2ro 1666) returns (M D C L X V I)."

((>= AN 4) (cons 'I (cons 'V (ar2ro (- AN 4)))))

((>= AN 1) (cons 'I (ar2ro (- AN 1))))

 

=={{header|Erlang}}==

{{trans|OCaml}}

-export([to_roman/1]).

 

digit(7, X, Y, _) -> [Y, X, X];

digit(8, X, Y, _) -> [Y, X, X, X];

 

sample:

 

Alternative:

-module( roman_numerals ).

 

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}].

 

{{out}}

 

=={{header|ERRE}}==

PROGRAM ARAB2ROMAN

 

TOROMAN(3888->ANS$) PRINT("3888 = ";ANS$)

END PROGRAM

 

=={{header|Euphoria}}==

{{trans|BASIC}}

constant roman = {"M", "CM", "D","CD", "C","XC","L","XL","X","IX","V","IV","I"}

 

printf(1,"%d = %s\n",{2009,toRoman(2009)})

printf(1,"%d = %s\n",{1666,toRoman(1666)})

 

{{out}}

Excel can encode numbers in Roman forms in 5 successively concise forms.

These can be indicated from 0 to 4. Type in a cell:

=ROMAN(2013,0)

 

It becomes:

MMXIII

 

=={{header|F_Sharp|F#}}==

1 -> x

| 2 -> x + x

|> List.map (fun n -> roman n)

|> List.iter (printfn "%s")

{{out}}

<pre>MCMXC

=={{header|Factor}}==

A roman numeral library ships with Factor.

( scratchpad ) 3333 >roman .

 

Parts of the implementation:

 

{ "m" "cm" "d" "cd" "c" "xc" "l" "xl" "x" "ix" "v" "iv" "i" }

 

roman-values roman-digits [

[ /mod swap ] dip <repetition> concat

 

=={{header|FALSE}}==

[$999>][1000- "M"]#

$899> [ 900-"CM"]?

$ 4> [ 5- "V"]?

$ 3> [ 4-"IV"]?

 

=={{header|Fan}}==

** converts a number to its roman numeral representation

**

}

 

 

=={{header|Forth}}==

\ these are ( numerals -- numerals )

: ,I dup c@ C, ; : ,V dup 1 + c@ C, ; : ,X dup 2 + c@ C, ;

1999 roman type \ MCMXCIX

25 roman type \ XXV

Alternative implementation

does> swap cells + @ ;

 

create (roman) 16 chars allot

 

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

 

implicit none

end function roman

 

{{out}}

MDCLXVI

MMMDCCCLXXXVIII

</pre>

 

 

If you see boxes in the code below, those are supposed to be the Unicode combining overline (U+0305) and look like {{overline|IVXLCDM}}. Or, if you see overstruck combinations of letters, that's a different font rendering problem. (If you need roman numerals > 3999 reliably, it might best to stick to chiseling them in stone...)

 

import "fmt"

}

}

{{out}}

<pre>

 

=={{header|Golo}}==

----

This module takes a decimal integer and converts it to a Roman numeral.

println("2008 == MMVIII? " + (2008: encode() == "MMVIII"))

println("1666 == MDCLXVI? " + (1666: encode() == "MDCLXVI"))

 

=={{header|Groovy}}==

 

def roman(arabic) {

assert roman(1666) == 'MDCLXVI'

assert roman(1990) == 'MCMXC'

 

=={{header|Haskell}}==

With an explicit decimal digit representation list:

 

digit x y z k =

[[x], [x, x], [x, x, x], [x, y], [y], [y, x], [y, x, x], [y, x, x, x], [x, z]] !!

 

main :: IO ()

{{out}}

<pre>["MCMXCIX","XXV","CMXLIV"]</pre>

or, defining '''romanFromInt''' in terms of mapAccumL

 

import Data.List (mapAccumL)

import Data.Tuple (swap)

 

main :: IO ()

{{Out}}

<pre>MDCLXVI

With the Roman patterns abstracted, and in a simple logic programming idiom:

 

module Main where

 

(if roman == expected then "PASS"

else ("FAIL, expected " ++ (show expected))) ++ ")"

{{out}}

<pre>

 

=={{header|HicEst}}==

 

CALL RomanNumeral(1990, Roman) ! MCMXC

ENDDO

ENDDO

 

=={{header|Icon}} and {{header|Unicon}}==

 

procedure main(arglist)

every x := !arglist do

write(commas(x), " -> ",roman(x)|"*** can't convert to Roman numerals ***")

 

{{libheader|Icon Programming Library}}

[http://www.cs.arizona.edu/icon/library/src/procs/numbers.icn numbers.icn provides roman] as seen below and is based upon a James Gimple SNOBOL4 function.

 

local arabic, result

static equiv

result := map(result,"IVXLCDM","XLCDM**") || equiv[arabic + 1]

if find("*",result) then fail else return result

 

{{out}}

INTERCAL outputs numbers as Roman numerals by default, so this is surprisingly trivial for a language that generally tries to make things as difficult as possible. Although you do still have to <i>input</i> the numbers as spelled out digitwise in all caps.

 

DO READ OUT .1

 

{{Out}}

 

{{trans|C#}}

nums := list(1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1)

rum := list("M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I")

)

 

 

=={{header|J}}==

<tt>rfd</tt> obtains Roman numerals from decimals.

 

C CC CCC CD D DC DCC DCCC CM

X XX XXX XL L LX LXX LXXX XC

)

 

 

Explanation: R1000's definition contains rows representing each of 10 different digits in the 100s, 10s and 1s column (the first entry in each row is blank -- each entry is preceded by a space). R1000 itself represents the first 1000 roman numerals (the cartesian product of these three rows of roman numeral "digits" which is constructed so that they are in numeric order. And the first entry -- zero -- is just blank). To convert a number to its roman numeral representation, we will separate the number into the integer part after dividing by 1000 (that's the number of 'M's we need) and the remainder after dividing by 1000 (which will be an index into R1000).

 

MCCXXXIV

rfd 567

DLXVII

rfd 89

 

Derived from the [[j:Essays/Roman Numerals|J Wiki]]. Further examples of use will be found there.

The conversion function throws an IllegalArgumentException for non-positive numbers, since Java does not have unsigned primitives.

{{works with|Java|1.5+}}

 

enum Numeral {

}

 

{{out}}

<pre>1999 = MCMXCIX

at RN.main(RN.java:38)</pre>

{{works with|Java|1.8+}}

import java.util.EnumSet;

import java.util.Collections;

LongStream.of(1999, 25, 944).forEach(RomanNumerals::test);

}

{{out}}

<pre>1999 = MCMXCIX

 

{{trans|Tcl}}

map: [

1000, 'M', 900, 'CM', 500, 'D', 400, 'CD', 100, 'C', 90, 'XC',

}

 

 

====Functional composition====

 

'use strict';

 

romanTranscription);

 

 

{{Out}}

 

===ES6===

{{Trans|Haskell}}

(mapAccumL version)

"use strict";

 

 

// roman :: Int -> String

const roman = n =>

)(n)(

zip([

.join("");

 

 

// main :: IO ()

const main = () => (

 

// ---------------- GENERIC FUNCTIONS ----------------

 

// mapAccumL :: (acc -> x -> (acc, y)) -> acc ->

const tpl = f(a[0])(x);

 

a[1].concat(tpl[1])

},

);

 

 

 

 

// to a function over a tuple.

// f (a, b) -> (a, f(b))

 

 

length: Math.min(xs.length, ys.length)

}, (_, i) => [xs[i], ys[i]]);

 

// MAIN --

return main();

{{Out}}

<pre>MDCLXVI

 

====Declarative====

return 'I'

.repeat(num)

}

 

{{Out}}

 

=={{header|jq}}==

 

===Easy-to-code version===

def romans:

[100000, "\u2188"],

| .n = .n - $i ) )

| .res

'''Test Cases'''

 

"Decimal => Roman:",

(testcases[]

{{out}}

<pre>

==="Orders of Magnitude" version===

'''Translated from [[#Julia|Julia]]''' extended to 399,999

# Non-negative integer to Roman numeral up to 399,999

def to_roman_numeral:

| .rnum

end;

 

=={{header|Jsish}}==

This covers both Encode (toRoman) and Decode (fromRoman).

 

var Roman = {

ord: ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I'],

Roman.toRoman(1666) ==> MDCLXVI

=!EXPECTEND!=

 

{{out}}

 

=={{header|Julia}}==

 

function romanencode(n::Integer)

for n in testcases

@printf("%-4i => %s\n", n, romanencode(n))

 

{{out}}

 

=={{header|Kotlin}}==

1000 to "M",

900 to "CM",

println(encode(1666))

println(encode(2008))

 

{{out}}

</pre>

Alternatively:

fun digit(k: Int, unit: String, five: String, ten: String): String {

return when (k) {

else -> throw IllegalArgumentException("${this} not in range 0..3999")

}

 

=={{header|Lasso}}==

// encode roman

define encodeRoman(num::integer)::string => {

'2008 in roman is '+encodeRoman(2008)

br

 

=={{header|LaTeX}}==

The macro <code>\Roman</code> is defined for uppercase roman numeral, accepting as ''argument'' a name of an existing counter.

 

\newcounter{currentyear}

\setcounter{currentyear}{\year}

\begin{document}

Anno Domini \Roman{currentyear}

 

=={{header|LiveCode}}==

local roman,numArabic

put "M,CM,D,CD,C,XC,L,XL,X,IX,V,IV,I" into romans

end repeat

return cc

 

Examples

 

=={{header|Logo}}==

[1000 M] [900 CM] [500 D] [400 CD]

[ 100 C] [ 90 XC] [ 50 L] [ 40 XL]

if :n < first first :rules [output (roman :n bf :rules :acc)]

output (roman :n - first first :rules :rules word :acc last first :rules)

 

{{works with|UCB Logo}}

 

to digit :d :numerals

print roman 1999 ; MCMXCIX

print roman 25 ; XXV

 

=={{header|LOLCODE}}==

I HAS A Romunz ITZ A BUKKIT

Romunz HAS A SRS 0 ITZ "M"

VISIBLE SMOOSH 1666 " = " I IZ Romunize YR 1666 MKAY MKAY

VISIBLE SMOOSH 3888 " = " I IZ Romunize YR 3888 MKAY MKAY

 

{{Out}}

 

=={{header|LotusScript}}==

Function toRoman(value) As String

Dim arabic(12) As Integer

End Function

 

 

=={{header|Lua}}==

 

{1000, "M"},

{900, "CM"}, {500, "D"}, {400, "CD"}, {100, "C"},

end

end

 

=={{header|M4}}==

`ifelse(eval($1>=900),1,`CM`'roman(eval($1-900))',

`ifelse(eval($1>=500),1,`D`'roman(eval($1-500))',

)')')')')')')')')')')')')dnl

dnl

 

{{out}}

 

=={{header|Maple}}==

1666 MDCLXVI

1990 MCMXC

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

RomanNumeral is a built-in function in the Wolfram language. Examples:

RomanNumeral[99]

RomanNumeral[1337]

RomanNumeral[1666]

gives back:

<pre>IV

=== roman.m ===

 

:- module roman.

 

 

:- end_module roman.

 

{{out}}

Another implementation using an algorithm inspired by [[#Erlang|the Erlang implementation]] could look like this:

 

:- module roman2.

 

 

:- end_module roman2.

 

This implementation calculates the value of the thousands, then the hundreds, then the tens, then the ones. In each case it uses the <code>digit/4</code> function and some tricks with unification to build the appropriate list of characters for the digit and multiplier being targeted.

Its output is identical to that of the previous version.

 

{{out}}

 

=={{header|Modula-2}}==

{{trans|DWScript}}

{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}

MODULE RomanNumeralsEncode;

 

ToRoman(3888, Numeral); WriteString(Numeral); WriteLn; (* MMMDCCCLXXXVIII *)

END RomanNumeralsEncode.

{{out}}

<pre>

 

=={{header|MUMPS}}==

;Converts INPUT into a Roman numeral. INPUT must be an integer between 1 and 3999

;OUTPUT is the string to return

.FOR Q:CURRVAL<$PIECE(ROMANVAL,"^",I) SET OUTPUT=OUTPUT_$PIECE(ROMANNUM,"^",I),CURRVAL=CURRVAL-$PIECE(ROMANVAL,"^",I)

KILL I,CURRVAL

{{out}}

<pre>USER>W $$ROMAN^ROSETTA(1666)

 

Another variant

;return empty string if input parameter 'n' is not in 1-3999

Quit:(n'?1.4N)!(n'<4000)!'n ""

. Set x=$Translate(x,"IVX",$Piece("IVX~XLC~CDM~M","~",p-j+1))

. Set r=r_x

 

=={{header|Nim}}==

{{trans|Python}}

 

const nums = [(1000, "M"), (900, "CM"), (500, "D"), (400, "CD"), (100, "C"), (90, "XC"),

1000, 1009, 1444, 1666, 1945, 1997, 1999,

2000, 2008, 2010, 2011, 2500, 3000, 3999]:

 

{{out}}

=={{header|Objeck}}==

{{trans|C sharp}}

bundle Default {

class Roman {

}

}

 

=={{header|OCaml}}==

With an explicit decimal digit representation list:

 

1 -> [x]

| 2 -> [x;x]

digit 'X' 'L' 'C' (x / 10) @ to_roman (x mod 10)

else

 

{{out}}

=={{header|Oforth}}==

 

 

: roman(n)

| r |

StringBuffer new

 

=={{header|OpenEdge/Progress}}==

i_i AS INT

):

1666 encodeRoman( 1666 ) SKIP

VIEW-AS ALERT-BOX.

{{out}}

<pre>---------------------------

=={{header|Oz}}==

{{trans|Haskell}}

fun {Digit X Y Z K}

unit([X] [X X] [X X X] [X Y] [Y] [Y X] [Y X X] [Y X X X] [X Z])

end

in

 

=={{header|PARI/GP}}==

Old-style Roman numerals

while(n>999999,

n-=1000000;

);

print()

 

This simple version of medieval Roman numerals does not handle large numbers.

while(n>999,

n-=1000;

);

print()

 

=={{header|Pascal}}==

=={{header|Peloton}}==

Roman numbers are built in to Peloton as a particular form of national number. However, for the sake of the task the _RO opcode has been defined.

 

<@ ENU$$DLSTLITLIT>1990,2008,1,2,64,124,1666,10001|,|

<@ SAYELTLST>...</@> is <@ SAY_ROELTLSTLIT>...|RomanLowerUnicode</@> <@ SAY_ROELTLSTLIT>...|RomanUpperUnicode</@> <@ SAY_ROELTLSTLIT>...|RomanASCII</@>

 

Same code in padded-out, variable-length English dialect

 

<# ENUMERATION LAMBDASPECIFIEDDELMITER LIST LITERAL LITERAL>1990,2008,1,2,64,124,1666,10001|,|

<# SAY ELEMENT LIST>...</#> is <# SAY _RO ELEMENT LIST LITERAL>...|RomanLowerUnicode</#> <# SAY _RO ELEMENT LIST LITERAL>...|RomanUpperUnicode</#> <# SAY _RO ELEMENT LIST LITERAL>...|RomanASCII</#>

 

{{out}} Notice here the three different ways of representing the results.

==== Simple program ====

Simple, fast, produces same output as the Math::Roman module and the Raku example, less crazy than writing a Latin program, and doesn't require experimental modules like the Raku translation.

 

sub roman {

}

 

 

==== Using a module ====

 

==== Ported version of Raku ====

 

my %symbols = (

};

 

 

=={{header|Phix}}==

{{out}}

<pre>

{{1990,"MCMXC"},{2008,"MMVIII"},{1666,"MDCLXVI"}}

</pre>

 

=={{header|Phixmonti}}==

 

def romanEnc /# n -- s #/

enddef

 

{{trans|Lua}}

var k

( ( 1000 "M" ) ( 900 "CM" ) ( 500 "D" ) ( 400 "CD" ) ( 100 "C" ) ( 90 "XC" )

enddef

 

Without vars

>ps

( ( 1000 "M" ) ( 900 "CM" ) ( 500 "D" ) ( 400 "CD" ) ( 100 "C" ) ( 90 "XC" )

enddef

 

 

=={{header|PHP}}==

{{works with|PHP|4+ tested in 5.2.12}}

/**

* int2roman

return $numeral . $leastSig;

}

 

=={{header|PicoLisp}}==

(pack

(make

(link C) ) )

'(M CM D CD C XC L XL X IX V IV I)

{{out}}

<pre>: (roman 1009)

 

=={{header|Pike}}==

int main(){

write(int2roman(2009) + "\n");

write(int2roman(1666) + "\n");

write(int2roman(1337) + "\n");

 

=={{header|PL/I}}==

/* From Wiki Fortran */

roman: procedure (n) returns(character (32) varying);

return (r);

end roman;

Results:

<pre>

 

=={{header|PL/SQL}}==

 

/*****************************************************************

 

END;

 

=={{header|plainTeX}}==

TeX has its own way to convert a number into roman numeral, but it produces lowercase letters; the following macro (and usage example), produce uppercase roman numeral.

 

Anno Domini \upperroman{\year}

 

=={{header|PowerShell}}==

Filter ToRoman {

$output = ''

$output

}

19,4,0,2479,3001 | ToRoman

{{Out}}

<pre>

{{libheader|clpfd}}

Library clpfd assures that the program works in both managements : Roman towards Arabic and Arabic towards Roman.

 

roman :-

my_print(A, R) :-

format('~w in roman is ~w~n', [A, R]).

{{out}}

<pre> ?- roman.

</pre>

 

 

 

===Imperative===

# Version for Python 2

adjust_roman = "CCXXmmccxxii";

arabic = (1000000, 500000, 100000, 50000, 10000, 5000, 1000, 500, 100, 50, 10, 5, 1);

2000,2008,2500,3000,4000,4999,5000,6666,10000,50000,100000,500000,1000000);

for val in test:

 

def ToRoman(num):

else:

namoR += r*romanDgts[rdix] + (romanDgts[rdix+1] if(v==1) else '')

 

It is more Pythonic to use zip to iterate over two lists together:

rnums = "M CM D CD C XC L XL X IX V IV I".split()

 

for val in test:

print '%d - %s'%(val, to_roman(val))

 

# Version for Python 3

#===========================

'''Convert an integer from the decimal notation to the Roman notation'''

for val in test:

 

===Declarative===

Less readable, but a 'one liner':

'6' : 'DC', '5' : 'D', '4' : 'CD', '3' : 'CCC', '2' : 'CC', '1' : 'C', '0' : '' }, { '9' : 'XC',

'8' : 'LXXX', '7' : 'LXX', '6' : 'LX', '5' : 'L', '4' : 'XL', '3' : 'XXX', '2' : 'XX', '1' : 'X',

# Option 2

def number2romannumeral(n):

 

 

{{works with|Python|3}}

{{Trans|Haskell}}

 

from functools import reduce

q, r = divmod(a, m)

return (r, s * q)

return concat(snd(mapAccumL(go)(n)(

zip([

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>MDCLXVI

Pasting epitomised.

 

swap 1000 /mod $ "M" rot of rot swap join swap

dup 900 < not if [ 900 - dip [ $ "CM" join ] ]

1990 dup echo say " = " ->roman echo$ cr

2008 dup echo say " = " ->roman echo$ cr

 

{{Out}}

=={{header|R}}==

R has a built-in function, <code>[https://svn.r-project.org/R/trunk/src/library/utils/R/roman.R as.roman]</code>, for conversion to Roman numerals. The implementation details are found in <code>utils:::.numeric2roman</code> (see previous link), and <code>utils:::.roman2numeric</code>, for conversion back to Arabic decimals.

Since the object <code>as.roman</code> creates is just an integer vector with a class, you can do arithmetic with Roman numerals:

 

=={{header|Racket}}==

Straight recursion:

(define (encode/roman number)

(cond ((>= number 1000) (string-append "M" (encode/roman (- number 1000))))

((>= number 4) (string-append "IV" (encode/roman (- number 4))))

((>= number 1) (string-append "I" (encode/roman (- number 1))))

 

Using for/fold and quotient/remainder to remove repetition:

(define (number->list n)

(for/fold ([result null])

1000 1009 1444 1666 1945 1997 1999 2000 2008 2010 2011 2500

3000 3999)])

 

=={{header|Raku}}==

(formerly Perl 6)

 

1 => "I", 5 => "V", 10 => "X", 50 => "L", 100 => "C",

500 => "D", 1_000 => "M";

for 1 .. 2_010 -> $x {

say roman($x);

 

=={{header|Red}}==

Straight iterative solution:

 

to-Roman: function [n [integer!] return: [string!]][

 

foreach number [40 33 1888 2016][print [number ":" to-Roman number]]

Straight recursive solution:

 

to-Roman: func [n [integer!] return: [string!]][

 

foreach number [40 33 1888 2016][print [number ":" to-Roman number]]

This solution builds, using metaprogramming, a `case` table, that relies on recursion to convert every digit.

 

to-Roman: function [n [integer!]] reduce [

'case collect [

 

foreach number [40 33 1888 2016][print [number ":" to-Roman number]]

 

=={{header|Retro}}==

This is a port of the [[Forth]] code; but returns a string rather than displaying the roman numerals. It only handles numbers between 1 and 3999.

 

: vector ( ...n"- )

here [ &, times ] dip : .data ` swap ` + ` @ ` do ` ; ;

dup 1 3999 within 0 =

[ "EX LIMITO!\n" ] [ "IVXLCDM" swap record here ] if ;

 

=={{header|REXX}}==

===version 1===

arg number

 

end

end

===version 2===

This version of a REXX program allows almost any non-negative decimal integer.

The general REXX code is bulkier than most at it deals with &nbsp; ''any'' &nbsp; non-negative decimal number, &nbsp; and more

<br>boilerplate code is in the general REXX code to handle the above versions.

numeric digits 10000 /*decimal digs can be higher if wanted.*/

parse arg # /*obtain optional integers from the CL.*/

if pos(_, #)\==0 then #=changestr(_, #, copies('M', i))

end /*i*/

Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, &nbsp; so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]]. <br><br>

'''output''' &nbsp; when using the default (internal) input):

 

=={{header|Ring}}==

arabic = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]

roman = ["M", "CM", "D", "CD", "C" ,"XC", "L", "XL" ,"X", "IX", "V", "IV", "I"]

next

return result

 

=={{header|Ruby}}==

Roman numeral generation was used as an example for demonstrating [http://www.xpsd.org/cgi-bin/wiki?TestDrivenDevelopmentTutorialRomanNumerals Test Driven Development] in Ruby. The solution came to be:

Subtractors = [ [1000, 100], [500, 100], [100, 10], [50, 10], [10, 1], [5, 1], [1, 0] ]

 

[1990, 2008, 1666].each do |i|

puts "%4d => %s" % [i, roman(i)]

 

{{out}}

Another shorter version if we don't consider calculating the substractors:

 

Symbols = [ [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'] ]

 

Symbols.each { |arabic_rep, roman_rep| return roman_rep + arabic_to_roman(arabic - arabic_rep) if arabic >= arabic_rep }

end

 

Yet another way to solve it in terms of reduce

 

Symbols = [ [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'] ]

 

end

end

 

=={{header|Rust}}==

symbol: &'static str,

value: u32

println!("{:2$} = {}", n, to_roman(n), 4);

}

<pre>

2014 = MMXIV

=={{header|Scala}}==

{{works with|Scala|2.8}}

1 -> "I", 5 -> "V",

10 -> "X", 50 -> "L",

case Some(key) => romanDigits(key) + toRoman(n - key)

case None => ""

{{Out}}

<pre>scala> List(1990, 2008, 1666) map toRoman

res55: List[String] = List(MCMXC, MMVIII, MDCLXVI)</pre>

===Using foldLeft===

val romanNumerals = List(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")

test(1990)

test(2008)

===Different code-style===

case class RomanUnit(value: Int, token: String)

val romanNumerals = List(

}

}

{{out}}

<pre>1990 => MCMXC

This uses format directives supported in Chez Scheme since v6.9b; YMMV.

 

 

This is a general example using Chicken Scheme.

'(("M" . 1000)

("CM" . 900)

(printf "~a ~a\n" (car n) (to-roman (car n)))

(loop (cdr n))))

 

=={{header|Seed7}}==

which writes a roman numeral to a string.

 

include "stdio.s7i";

include "wrinum.s7i";

writeln(str(ROMAN, number));

end for;

 

Original source [http://seed7.sourceforge.net/algorith/puzzles.htm#roman_numerals].

=={{header|SenseTalk}}==

 

put [

(1, "I"),

end repeat

return numerals

 

1990,

2008,

]

put RomanNumeralsEncode(it)

 

{{out}}

 

=={{header|SETL}}==

 

for example in examples loop

end loop;

return roman;

{{out}}

<pre>MMVIII

 

=={{header|Shen}}==

(define encodeGlyphs

ACC 0 _ -> ACC

N -> (encodeGlyphs "" N ["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])

)

{{out}}

<pre>

=={{header|Sidef}}==

{{trans|ActionScript}}

static lookup = [

:M:1000, :CM:900, :D:500,

say("1990 in roman is " + arabic2roman(1990));

say("2008 in roman is " + arabic2roman(2008));

{{out}}

<pre>1990 in roman is MCMXC

 

=={{header|Simula}}==

 

TEXT PROCEDURE TOROMAN(N); INTEGER N;

 

END PROGRAM;

{{out}}

<pre>

{{works with|Smalltalk/X}}

in ST/X, integers already know how to print themselves as roman number:

{{out}}

<pre>

MMXIII</pre>

the implementation is:

printRomanOn:aStream naive:naive

"print the receiver as roman number to the argument, aStream.

] doWhile:[ repeatFlag and:[ restValue >= rValue] ].

].

 

=={{header|SNOBOL4}}==

Adapted from [http://burks.bton.ac.uk/burks/language/snobol/catspaw/tutorial/ch6.htm Catspaw SNOBOL Tutorial, Chapter 6]

 

* ROMAN(N) - Convert integer N to Roman numeral form.

*

OUTPUT = " 944 = " ROMAN(944)

 

{{out}}

<pre>

Here's a non-recursive version, and a Roman-to-Arabic converter to boot.

 

define('roman(n)s,ch,val,str') :(roman_end)

roman roman = ge(n,4000) n :s(return)

astr = astr r '=' arabic(r) ' ' :(tloop)

out output = rstr; output = astr

 

{{out}}

 

=={{header|SPL}}==

r = ""

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

> i, 1..#.size(t,1)

#.output(t[i]," = ",a2r(t[i]))

{{out}}

<pre>

 

=={{header|SQL}}==

--

-- This only works under Oracle and has the limitation of 1 to 3999

--------------- ---------------

MDCLXVI mdclxvi

 

=={{header|Swift}}==

 

var result = ""

}

return result

Sample call:

{{works with|Swift|1.x}}

{{works with|Swift|2.0}}

{{output}}

<pre>MDCLXVI </pre>

 

=={{header|Tailspin}}==

def digits: [(M:1000"1"), (CM:900"1"), (D:500"1"), (CD:400"1"), (C:100"1"), (XC:90"1"), (L:50"1"), (XL:40"1"), (X:10"1"), (IX:9"1"), (V:5"1"), (IV:4"1"), (I:1"1")];

templates encodeRoman

@: 1;

when <$digits($@)::value..> do

$digits($@)::key !

$ - $digits($@)::value -> #

@:$@ + 1;

$ -> #

' -> !OUT::write

1666 -> encodeRoman -> !OUT::write

{{out}}

<pre>

 

=={{header|Tcl}}==

set map {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}

foreach {value roman} $map {

}

return $res

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

LOOP arab_number="1990'2008'1666"

PRINT "Arabic number ",arab_number, " equals ", roman_number

ENDLOOP

{{out}}

<pre>

</pre>

 

 

 

 

 

=={{header|UNIX Shell}}==

{{trans|Tcl}}

{{works with|bash}}

local values=( 1000 900 500 400 100 90 50 40 10 9 5 4 1 )

local roman=(

for test in 1999 24 944 1666 2008; do

printf "%d = %s\n" $test $(roman $test)

{{out}}

<pre>

CCCC are replaced by CD. The substitution operator (%=) is helpful

here.

 

roman =

-+

'IIII'%='IV'+ 'VIIII'%='IX'+ 'XXXX'%='XL'+ 'LXXXX'%='XC'+ 'CCCC'%='CD'+ 'DCCCC'%='CM',

This test program applies the function to each member of a list of numbers.

 

{{out}}

<pre>MCMXC

=={{header|Vala}}==

{{trans|D}}

requires (n > 0 && n < 5000)

{

print("%s\n", to_roman(3456));

print("%s\n", to_roman(2488));

 

{{out}}

 

=={{header|VBA}}==

roman = WorksheetFunction.roman(n)

End Function

Debug.Print roman(CInt(x)); " ";

Next x

<pre>X MMXVI DCCC MMDCCLXIX MDCLXVI CDLXXVI MCDLIII </pre>

 

=={{header|Vedit macro language}}==

//

do {

}

Buf_Quit(OK)

 

{{out}}

2011 = MMXI</pre>

 

 

 

 

 

=={{header|Wren}}==

{{trans|Kotlin}}

[1000, "M"],

[900, "CM"],

System.print(encode.call(1666))

System.print(encode.call(2008))

 

{{out}}

MMVIII

MMXX

</pre>

 

=={{header|XLISP}}==

(define roman-numerals '((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")))

(defun romanize (arabic-numeral numerals roman-numeral)

 

; test the function:

{{out}}

<pre>(x mmxvi dccc mmdcclxix mdclxvi cdlxxvi mcdliii)</pre>

 

=={{header|XPL0}}==

int N, A, B, C, I;

[case N of

for I:= 0 to 7 do

[IntOut(0, Tbl(I)); Text(0, ". "); Roman(Tbl(I)); CrLf(0)];

 

{{out}}

 

=={{header|XSLT}}==

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/data/number">

</xsl:template>

</xsl:stylesheet>

 

=={{header|zkl}}==

L("M", 1000), L("CM", 900), L("D", 500), L("CD", 400), L("C", 100),

L("XC", 90), L("L", 50), L("XL", 40), L("X", 10), L("IX", 9),

foreach R,N in (romans){ text += R*(i/N); i = i%N; }

return(text);

<pre>

toRoman(1990) //-->"MCMXC"

 

=={{header|Zoea}}==

program: decimal_roman

input: 12

output: 'XII'

 

=={{header|Zoea Visual}}==

=={{header|Zsh}}==

Based on the python solution.

local -a conv

local number=$1 div rom num out

done

echo $out