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|Applesoft BASIC}}===

2 N = 2008: GOSUB 5: PRINT N" = "V$

3 N = 1666: GOSUB 5: PRINT N" = "V$;

5 V = N:V$ = "": FOR I = 0 TO 12: FOR L = 1 TO 0 STEP 0:A = VAL ( MID$ ("1E3900500400100+90+50+40+10+09+05+04+01",I * 3 + 1,3))

6 L = (V - A) > = 0:V$ = V$ + MID$ ("M.CMD.CDC.XCL.XLX.IXV.IVI",I * 2 + 1,(I - INT (I / 2) * 2 + 1) * L):V = V - A * L: NEXT L,I

==={{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}}

==={{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|Nascom BASIC}}===

{{trans|DWScript}}

{{works with|Nascom ROM BASIC|4.7}}

10 REM Roman numerals/Encode

20 DIM WEIGHTS(12),SYMBOLS$(12)

580 GOTO 520

590 RETURN

{{out}}

<pre>

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

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

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

150 GO TO 120

160 NEXT I

==={{header|BaCon}}===

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

PRINT toroman$(2008)

PRINT toroman$(1666)

{{out}}

<pre>

=={{header|BASIC256}}==

{{works with|BASIC256 }}

print 1666+" = "+convert$(1666)

print 2008+" = "+convert$(2008)

next i

end function

{{out}}

<pre>

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

{{trans|BASIC}}

setlocal enabledelayedexpansion

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

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

{{Out}}

<pre>2009 = MMIX

=={{header|BBC BASIC}}==

PRINT ;2012, FNroman(2012)

PRINT ;1666, FNroman(1666)

ENDWHILE

NEXT

{{out}}

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

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

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

func num2rom num . rom$ .

print r$

call num2rom 1666 r$

=={{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}}

{{trans|C#}}

ELENA 5.0 :

import system'routines;

import extensions;

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

=={{header|FreeBASIC}}==

Function romanEncode(n As Integer) As String

Print

Print "Press any key to quit"

{{out}}

=={{header|FutureBasic}}==

local fn DecimaltoRoman( decimal as short ) as Str15

print " 33 = "; fn DecimaltoRoman( 33 )

Output:

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

// 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")

}