Romertal

Den aktuelle version af siden er endnu ikke blevet gennemgået af erfarne bidragydere og kan afvige væsentligt fra den version , der blev gennemgået den 12. oktober 2022; checks kræver 2 redigeringer .

Talsystemer i kultur
indo-arabisk
arabisk tamil burmesisk	Khmer Lao Mongolsk Thai
østasiatisk
kinesisk japansk Suzhou koreansk	Vietnamesiske tællestokke
Alfabetisk
Abjadia Armensk Aryabhata kyrillisk græsk	Georgisk etiopisk jødisk Akshara Sankhya
Andet
Babylonsk egyptisk etruskisk romersk Donau	Attic Kipu Mayan Aegean KPPU-symboler
positionelle
2 , 3 , 4 , 5 , 6 , 8 , 10 , 12 , 16 , 20 , 60
Nega-positionel
symmetrisk
blandede systemer
Fibonacci
ikke-positionelle
Ental (unær)

Denne side eller sektion indeholder specielle Unicode-tegn .
Hvis du ikke har de nødvendige skrifttyper , vises nogle tegn muligvis ikke korrekt.

Romertal er tal brugt af de gamle romere i deres ikke-positionelle talsystem .

Naturlige tal skrives ved at gentage disse cifre. Samtidig, hvis et større tal kommer før et mindre, så lægges de sammen (additionsprincippet), men hvis et mindre kommer før et større, så trækkes det mindre fra det større (subtraktionsprincippet). Den sidste regel gælder kun for at undgå den firedobbelte gentagelse af samme figur.

Romertal dukkede op 500 f.Kr. fra etruskerne (se etruskisk alfabet ), som kunne låne nogle af tallene fra proto-kelterne .

Tal og notation af tal

Romersk notation for tal er nu bedre kendt end noget andet gammelt talsystem. Dette forklares ikke så meget af nogle særlige fordele ved det romerske system, men af den enorme indflydelse, som Romerriget nød i den relativt nye fortid. Etruskere , der erobrede Rom i det 7. århundrede f.Kr. e. var påvirket af østlige middelhavskulturer. Dette forklarer til dels ligheden mellem de grundlæggende principper i de romerske og attiske talsystemer. Begge systemer var decimaler, selvom tallet fem spillede en særlig rolle i begge talsystemer. Begge systemer brugte gentagne tegn, når de skrev tal.

De gamle romerske symboler for tallene 1, 5, 10, 100 og 1000 ( hindo-arabisk notation ) var symbolerne I, V, X, Θ (eller ⊕ eller ⊗ ) og Φ (eller ↀ eller CIƆ ) , henholdsvis. Selvom der er skrevet meget om den oprindelige betydning af disse symboler, er der stadig ingen tilfredsstillende forklaring på dem. Ifølge en af de udbredte teorier viser romertallet V en åben hånd med fire fingre presset sammen og tommelfingeren forlænget; symbolet X, ifølge samme teori, forestiller to krydsede hænder eller et tocifret V. Symbolerne for tallene 100 og 1000 stammer sandsynligvis fra de græske bogstaver Θ og φ. Det vides ikke, om de senere betegnelser C og M er afledt af ældre romerske tegn eller er akrofonisk relateret til begyndelsesbogstaverne i de latinske ord, der betyder 100 (centum) og 1000 (mille). Det menes, at det romerske symbol for tallet 500, bogstavet D , stammer fra halvdelen af det gamle symbol for 1000. Bortset fra at de fleste romerske symboler højst sandsynligt ikke var akrofoniske, og at mellemsymbolerne for tallene 50 og 500 ikke var kombinationer af symboler for tallene 5 og 10 eller 5 og 100, lignede resten af det romerske talsystem Loftet. Romerne brugte ofte subtraktionsprincippet, så nogle gange brugte de IX i stedet for VIIII og XC i stedet for LXXXX; forholdsvis senere symbolet IV i stedet for IIII. Derfor kan alle romertal nu skrives med store latinske bogstaver.

Generelt var romerne ikke tilbøjelige til at lave matematik, så de følte ikke meget behov for store tal. De brugte dog af og til symbolet CCIƆƆ for 10000 og symbolet CCCIƆƆƆ for tallet 100000 . Halvdelene af disse symboler blev nogle gange brugt til at repræsentere tallene 5000 ( IƆƆ ) og 50000 ( IƆƆƆ ).

Romerne undgik fraktioner lige så stædigt som store tal. I praktiske måleopgaver brugte man ikke brøker, idet man normalt underinddelte måleenheden i 12 dele, således at resultatet af målingen præsenteres som et sammensat tal, summen af multipla af forskellige enheder, som man gør i dag, når længden er udtrykt i yards, fod og inches. De engelske ord "ounce" ( ounce ) og "inch" ( inch ) kommer fra det latinske ord lat. uncia ( ounce ), der angiver en tolvtedel af den grundlæggende længdeenhed [1] [2] .

en	jeg	lat. unus, unum
5	V	lat. quinque
ti	x	lat. decem
halvtreds	L	lat. quinquaginta
100	C	lat. procent
500	D	lat. quingenti
1000	M	lat. mille

Arabisk notation	romersk notation
en	jeg
2	II
3	III
fire	IV
5	V
6	VI
7	VII
otte	VIII
9	IX
ti	x
elleve	XI
12	XII
13	XIII
fjorten	XIV
femten	XV
16	XVI
17	XVII
atten	XVIII
19	XIX
tyve	XX
tredive	XXX
40	XL
halvtreds	L
60	LX
70	LXX
80	LXXX
90	XC
100	C
200	CC
300	CCC
400	CD
500	D; IƆ
600	DC; IƆC
700	DCC; IƆCC
800	DCCC; IƆCCC
900	CM; CCIƆ
1000	M; ↀ; CIƆ
2000	MM; CIƆCIƆ
3000	MMM; CIƆCIƆCIƆ
3999	MMMCMXCIX
4000	M V ; ↀↁ; CIƆIƆƆ
5000	V ; ↁ; IƆƆ
6000	VM ; ↁↀ; IƆƆCIƆ
7000	VMM ; ↁↀↀ; IƆƆCIƆCIƆ
8000	V MMM; ↁↀↀↀ; IƆƆCIƆCIƆCIƆ
9000	M X ; ↀↂ; CIƆCCIƆƆ
10.000	X ; ↂ; CCIƆƆ
20.000	XX ; ↂↂ; CCIƆƆCCIƆƆ
30.000	XXX ; ↂↂↂ; CCIƆƆCCIƆƆCCIƆƆ
40.000	XL ; ↂↇ; CCIƆƆƆƆƆ
50.000	L ; ↇ; IƆƆƆ
60.000	LX ; ↇↂ; IƆƆƆCCIƆƆ
70.000	LXX ; ↇↂↂ; IƆƆƆCCIƆƆCCIƆƆ
80.000	LXXX ; ↇↂↂↂ; IƆƆƆCCIƆƆCCIƆƆCCIƆƆ
90.000	XC ; ↂↈ; CCIƆƆCCCIƆƆƆ
100.000	C ; ↈ; CCCIƆƆƆ
200.000	CC ; ↈↈ; CCCIƆƆƆCCCIƆƆƆ
300.000	CCC ; ↈↈↈ; CCCIƆƆƆCCCIƆƆƆCCCIƆƆƆ
400.000	CD ; CCCIƆƆƆIƆƆƆƆ
500.000	D ; IƆƆƆƆ
600.000	DC ; IƆƆƆƆCCCIƆƆƆ
700.000	DCC ; IƆƆƆƆCCCIƆƆƆCCCIƆƆƆ
800.000	DCCC
900.000	CM
1.000.000	M
2.000.000	MM
3.000.000	MMM
4.000.000	M V
5.000.000	V
6.000.000	V M
7.000.000	VMM _
8.000.000	V MMM
9.000.000	M X
10.000.000	x
100.000.000	C
1.000.000.000	M
1.000.000.000.000	M
1.000.000.000.000.000.000.000.000.000.000.000	M
10^100	X^C

For korrekt at skrive store tal i romertal, skal du først nedskrive antallet af tusinder, derefter hundreder, så tiere og til sidst enheder.

Der er intet nul i det romerske talsystem, men nul blev tidligere brugt som nulla (nej), nihil (intet) og N (det første bogstav i disse ord).

I dette tilfælde kan nogle af tallene (I, X, C, M) gentages, men ikke mere end tre gange i træk ; således kan de bruges til at skrive ethvert naturligt tal, der ikke er mere end 3999 (MMMCMXCIX). I de tidlige perioder var der tegn på større tal - 5000, 10.000, 50.000 og 100.000 (så er det maksimale antal ifølge den nævnte regel 399.999). Når man skriver tal i det romerske talsystem, kan det mindre ciffer være til højre for det større; i dette tilfælde tilføjes det. For eksempel skrives tallet 283 på romersk som CCLXXXIII, det vil sige 100+100+50+30+3=283. Her gentages tallet, der repræsenterer hundrede, to gange, og tallene, der repræsenterer henholdsvis ti og én, gentages tre gange.

Eksempel: nummer 1988. Et tusinde M, ni hundrede CM, otte tiere LXXX, otte enheder VIII. Lad os skrive dem sammen: MCMLXXXVIII.

Ganske ofte, for at fremhæve tal i teksten, blev der tegnet en streg over dem: LXIV . Nogle gange blev linjen tegnet både over og under: XXXII - især er det sædvanligt at fremhæve romertal i russisk håndskrevet tekst (dette bruges ikke i typografisk sætning på grund af teknisk kompleksitet). For andre forfattere kunne overlinjen indikere en stigning i værdien af figuren med 1000 gange: V = 5000.

Det var først i 1800-tallet , at tallet "fire" blev skrevet ned som "IV" overalt , før det blev rekorden "IIII" oftest brugt. Indgangen "IV" kan dog findes allerede i dokumenterne til Forme of Cury- manuskriptet , der dateres tilbage til 1390 . Urskiver har traditionelt brugt " IIII " i stedet for "IV" i de fleste tilfælde, hovedsageligt af æstetiske årsager: denne stavemåde giver visuel symmetri med tallene "VIII" på den modsatte side, og den omvendte "IV" er sværere at læse end "III". Der er også en version, hvor IV ikke var skrevet på urskiven, fordi IV er de første bogstaver i det latinske navn på guden Jupiter (IVPITER).

Det mindre tal kan skrives til venstre for det større, så skal det trækkes fra det større. I dette tilfælde kan kun tal, der angiver 1 eller potenser af 10, trækkes fra, og kun de to nærmeste tal i talrækken til det subtraherede (det vil sige det subtraherede, ganget med 5 eller 10) kan fungere som minuend. Gentagelser af et mindre antal er ikke tilladt. Der er således kun seks anvendelser af "subtraktionsreglen":

IV = 4
IX = 9
XL=40
XC = 90
CD=400
CM=900

For eksempel vil tallet 94 være XCIV = 100 - 10 + 5 - 1 = 94 - den såkaldte "subtraktionsregel" (optrådte i senantikkens æra, og før det skrev romerne tallet 4 som IIII, og tallet 40 som XXXX).

Det skal bemærkes, at andre metoder til "subtraktion" ikke er tilladt; således skal tallet 99 skrives som XCIX, men ikke som IC. Men i dag bruges i nogle tilfælde også en forenklet notation af romerske tal: for eksempel i Microsoft Excel , når du konverterer arabiske tal til romerske ved hjælp af funktionen "ROMAN ()", kan du bruge flere typer repræsentation af tal, fra klassisk til meget forenklet (f.eks. kan tallet 499 skrives som CDXCIX, LDVLIV, XDIX, VDIV eller ID). Forenklingen er, at for at reducere et hvilket som helst ciffer, kan et hvilket som helst andet ciffer skrives til venstre for det:

999. Tusind (M), træk 1 (I), få 999 (IM) i stedet for CMXCIX. Konsekvens: 1999 - MIM i stedet for MCMXCIX
95. Et hundrede (C), træk 5 (V), få 95 (VC) i stedet for XCV
1950: Et tusinde (M), træk 50 (L) fra, vi får 950 (LM). Konsekvens: 1950 - MLM i stedet for MCML

Tilfælde af sådan notation af tal (normalt år) findes ofte i krediteringerne af amerikanske tv-serier. For eksempel for året 1998: MIIM i stedet for MCMXCVIII.

Romertal kan også bruges til at skrive større klasser af tal. For at gøre dette placeres en linje over de tal, der repræsenterer tusinder, og en dobbelt linje er placeret over de tal, der repræsenterer millioner. Undtagelsen er tallet I; i stedet for en linje over, skrives tallet M, og startende fra en million - en linje fra oven. For eksempel ville tallet 123123 se sådan ud:

CXXIII CXXIII

Og en million er ligesom jeg , men ikke med én, men med to funktioner i spidsen: Jeg

Ansøgning

På russisk bruges romertal i følgende tilfælde:

Århundrede eller årtusindetal: XIX århundrede, II årtusinde f.Kr. e.
Bøjning af verber.
Mærkning af urskiver " antikke " .
Bindnummer i en bog med flere bind eller bind af tidsskrifter (nogle gange antallet af dele af en bog, sektioner eller kapitler ).
I musikalsk læsefærdighed.
Monarkens ordensnummer .
Blodtype på pletterne på uniformen af soldaterne fra de væbnede styrker i Den Russiske Føderation .
På sovjetiske skibe blev dybgangen angivet i meter med romerske bogstaver (på engelske skibe - i fod med romerske bogstaver).
I nogle udgaver sidetal med forord til bogen, for ikke at rette henvisninger indenfor hovedteksten ved ændring af forord.
Andre vigtige begivenheder eller listepunkter, for eksempel: Euklids V-postulat , Anden Verdenskrig , CPSU's XX kongres , XXII Olympiade og lignende.
Valens af kemiske elementer.
Korpsnummer i de væbnede styrker.
År for færdiggørelsen af bygningen på dens fronton.
Ordinaltallet for et trin på skalaen.
I matematisk analyse er tallet på den afledte skrevet med romertal , men når man læser (normalt) siger man "slag" i stedet for I, "to streger" i stedet for II, "tre streger" i stedet for III. Til sidst, begyndende fra IV, læses den "fjerde afledte": og . $f'(x)=f^{I}(x)=f^{(1)}(x)$ $f^{IV}(x)=f^{(4)}(x)$

Romertal blev meget brugt i USSR, når de angiver datoen for at angive årets måned , for eksempel: 11 / III-85 eller 9.XI.89, dette kan ses på mange arkivdokumenter fra dengang. På lignende måde skrev de gennem en skråstreg også datoen for lektionen ned i klassens journaler , for eksempel 24/II. For at angive datoer for liv og død på gravsten blev der ofte brugt et særligt format, hvor måneden i året også blev angivet med romertal, for eksempel (25. november 1887 ~ 26. januar 1943). Et lignende format blev brugt i lægeerklæringer i 1970'erne og 1980'erne. $18{\textstyle {\frac {25}{XI))}87\sim 19{\textstyle {\frac {26}{I))}43$

Med overgangen til computerbehandling af information er datoformater baseret på romertal praktisk talt gået ud af brug.

På andre sprog kan omfanget af romertal variere. I vestlige lande er årstallet ofte skrevet med romertal, for eksempel på bygningers gavle og i krediteringer af video-, film- og tv-produkter [3] .

I det moderne Litauen , på vejskilte , på butiksvinduer , på skilte fra virksomheder, kan romertal angive ugedagene .

Unicode

Unicode- standarden anbefaler, at romertal repræsenteres med almindelige latinske tegn [4] . Standarden omfatter dog også specialtegn for romertal som en del af Number Forms [ 5 ] i tegnområdet med koderne U+2160 til U+2188. For eksempel kan MCMLXXXVIII være repræsenteret i formen ⅯⅭⅯⅬⅩⅩⅩⅧ. Dette interval omfatter både små og store cifre for tallene 1 (Ⅰ eller I) til 12 (Ⅻ eller XII), inklusive kombinerede glyffer for sammensatte tal såsom 8 (Ⅷ eller VIII), primært for at sikre kompatibilitet med østasiatiske tegnsæt i industristandarder såsom JIS X 0213 , hvor disse karakterer er defineret. Kombinerede glyffer bruges til at repræsentere tal, der tidligere bestod af enkelte tegn (for eksempel Ⅻ i stedet for dets repræsentation som Ⅹ og Ⅱ). Derudover findes der glyffer for de arkaiske [5] former for 1000, 5000, 10.000, kapital invers C (Ɔ), sent 6 (ↅ, svarende til det græske stigma : Ϛ), tidligt 50 ( ↆ, som ligner en pil peger ned ↓⫝⊥ [6] ), 50.000 og 100.000. Det skal bemærkes, at det lille omvendte c, ↄ ikke er inkluderet i romertalstegn, men er inkluderet i Unicode-standarden som det store Claudian-bogstav Ↄ.

Koden	0	en	2	3	fire	5	6	7	otte	9	EN	B	C	D	E	F
Værdi [7]	en	2	3	fire	5	6	7	otte	9	ti	elleve	12	halvtreds	100	500	1000
U+2160	Ⅰ 2160	Ⅱ 2161	Ⅲ 2162	Ⅳ 2163	Ⅴ 2164	Ⅵ 2165	Ⅶ 2166	Ⅷ 2167	Ⅸ 2168	Ⅹ 2169	Ⅺ 216A	Ⅻ 216B	Ⅼ 216C	Ⅽ 216D	Ⅾ 216E	nr. 216F
U+2170	ⅰ 2170	ⅱ 2171	ⅲ 2172	ⅳ 2173	ⅴ 2174	ⅵ 2175	ⅶ 2176	ⅷ 2177	ⅸ 2178	ⅹ 2179	ⅺ 217A	ⅻ 217B	ⅼ217C _	ⅽ 217D	ⅾ 217E	ⅿ 217F
Betyder	1000		5000		10.000		100		6		halvtreds		50.000		100.000
U+2180	ↀ 2180		ↁ 2181		ↂ 2182		Ↄ 2183		ↅ 2185		ↆ 2186		ↇ 2187		ↈ 2188

Visning af alle disse tegn kræver software, der understøtter Unicode-standarden og en skrifttype , der indeholder de tilsvarende glyffer for disse tegn (f.eks. Universalia -skrifttypen ).

Regulære udtryk

Regulært udtryk til kontrol af romertal - ^(M{0,3})(D?C{0,3}|C[DM])(L?X{0,3}|X[LC])(V?I{0,3}|I[VX])$[8] I Perl kan du bruge et regulært udtryk til at søge efter romertal i en streng m/\b((?:M{0,3}?(?:D?C{0,3}|C[DM])?(?:L?X{0,3}|X[LC])?(?:I{0,3}?V?I{0,3}|I[VX])))\b/gs.

Transformation

For at konvertere tal skrevet med arabiske tal til romerske, bruges specielle funktioner.

For eksempel, i den engelske version af Microsoft Excel og i enhver version af OpenOffice.org Calc , er der en ROMAN (argument; form) funktion for dette , i den russiske version af Microsoft Excel kaldes denne funktion ROMAN (tal; form) . Det valgfrie argument "shape" kan have værdier fra 0 til 4, såvel som "False" og "True". Fraværet af argumentet "Form" eller dets lighed med 0 eller "Sandt" giver transformationens "klassiske" (strenge) form; en værdi på 4 eller "False" giver den mest forenklede; værdier 1, 2, 3 giver varianter, der er mellemliggende i rigor-simplifikation. Forskelle vises for eksempel i tallene 45, 49, 495, 499 (de første er angivet i området [1;3999]).

Eksempel på funktionsapplikation ROMAN(tal; form)

	formen	0	en	2	3	fire
nummer
45		XLV	VL	VL	VL	VL
49		XLIX	VLIV	IL	IL	IL
495		CDXCV	LDVL	XDV	VD	VD
499		CDXCIX	LDVLIV	XDIX	VDIV	ID

Ikke-heltalsværdier af "number"-argumentet rundes ned til et heltal; hvis værdien derefter er større end 3999 eller mindre end 0, returnerer funktionen "#Value"; for en værdi på 0 returneres en tom celle.

JavaScript transformationsfunktioner var arab = [ 1 , 4 , 5 , 9 , 10 , 40 , 50 , 90 , 100 , 400 , 500 , 900 , 1000 ]; var roman = [ 'I' , 'IV' , 'V' , 'IX' , 'X' , 'XL' , 'L' , 'XC' , 'C' , 'CD' , 'D' , 'CM ' , 'M' ]; funktion arabToRoman ( tal ) { if ( ! tal ) returnerer '' ; varret = ' ' ; var i = arabisk . længde - 1 ; while ( tal > 0 ) { if ( tal >= arabisk [ i ]) { ret += romersk [ i ]; tal -= arabisk [ i ]; } andet { i -- ; } } returnere ret ; } function romanToArab ( str ) { str = str . toStore bogstaver (); varret = 0 ; _ var i = arabisk . længde - 1 ; var pos = 0 ; while ( i >= 0 && pos < str . length ) { if ( str . substr ( pos , romersk [ i ]. længde ) == romersk [ i ]) { ret += arab [ i ]; pos += romersk [ i ]. længde ; } andet { i -- ; } } returnere ret ; } Lignende funktioner i C-sprog (C89): #include <string.h> const int arabar [] = { 1 , 4 , 5 , 9 , 10 , 40 , 50 , 90 , 100 , 400 , 500 , 900 , 1000 }; const char * romanar [] = { "I" , "IV" , "V" , "IX" , "X" , "XL" , "L" , "XC" , "C" , "CD" , "D " , "CM" , "M" }; char * arab2roman ( usigneret kort int arab ) { statisk char romersk [ 80 ]; const int m = størrelse på ( arabar ) / størrelse på ( int ) -1 , arabmax = arabar [ m ]; const char romanmax = romanar [ m ][ 0 ]; int i , n ; if ( ! arab ) { * romersk = 0 ; returnere romersk ; } i = 0 _ while ( arab > arabmax ) { roman [ i ++ ] = romanmax ; arab -= arabmax ; } n = m ; while ( arabisk > 0 ) { if ( arab >= arabar [ n ]) { roman [ i ++ ] = romanar [ n ][ 0 ]; hvis ( n & 1 ) roman [ i ++ ] = romanar [ n ][ 1 ]; arab -= arabar [ n ]; } andet n- ; _ } roman [ i ] = 0 ; returnere romersk ; } usigneret kort int roman2arab ( char * roman ) { const int m = størrelse på ( arabar ) / størrelse på ( int ) -1 ; usigneret kort int arab ; int len , n , i , pir ; len = strlen ( romersk ); arabisk = 0 ; n = m ; i = 0 _ mens ( n >= 0 && i < len ) { pir = n & 1 ; if ( roman [ i ] == romanar [ n ][ 0 ] && ( ! pir || roman [ i + 1 ] == romanar [ n ][ 1 ])) { arab += arabar [ n ]; i += 1 + pir ; } andet n- ; _ } returnere arabisk ; } Program til at konvertere arabiske tal til romerske i Scala : val arabar = Array ( 1 , 4 , 5 , 9 , 10 , 40 , 50 , 90 , 100 , 400 , 500 , 900 , 1000 ) val romanar = Array ( "I" , "IV" , "IX " , "V" , " , "X" , "XL" , "L" , "XC" , "C" , "CD" , "D" , "CM" , "M" ) def arab2roman ( arab : Int , acc : String = " " , n : Int = arabar . længde - 1 ): String = if ( arab == 0 ) acc else if ( arab >= arabar ( n )) arab2roman ( arab - arabar ( n ), acc + romanar ( n ), n ) andet arab2roman ( arab , acc , n - 1 ) // arab2roman(4933) = MMMMCMXXXIII Program til at konvertere arabiske tal til romertal og omvendt på Pascal -sprog [9] type str2 = streng [ 2 ] ; const Rims : array [ 1 .. 14 ] of str2 = ( 'M' , 'CM' , 'D' , 'CD' , 'C' , 'XC' , 'L' , 'XL' , 'X' , 'IX' , 'V' , 'IV' , 'I' , '' ) ; Arabisk : matrix [ 1 .. 14 ] af heltal = ( 1000 , 900 , 500 , 400 , 100 , 90 , 50 , 40 , 10 , 9 , 5 , 4 , 1 , 0 ) ; var N , NI , I , J : heltal ; S : streng _ funktion Arab2Rim ( N : heltal ) : streng ; var S : streng ; I : heltal ; begynde S := '' ; I := 1 ; mens N > 0 begynder, mens Arab [ I ] < = N begynder S : = S + Rims [ I ] ; N := N - Arabisk [ I ] ende ; I := I + 1 ende ; Arab2Rim := S ende ; funktion Rim2Arab ( S : streng ) : heltal ; var I , N : heltal ; begynder I := 1 ; N : = 0 mens S <> '' begynder, mens Fælge [ I ] = Kopi ( S , 1 , Længde ( Fælge [ I ] ) ) begynder S := Kopi ( S , 1 + Længde ( Fælge [ I ] ) , 255 ) ; N := N + arabisk [ I ] ende ; I := I + 1 ende ; Rim2Arab := N ende ; start WriteLn ( 'Oversættelse fra arabisk til romertal. 1999 B_SA' ) ; { Write('Indtast tal for at konvertere:'); ReadLn(N);} for NI := 26 til 46 gør WriteLn ( NI , ' = ' , Arab2Rim ( NI ) , ' back ' , Rim2Arab ( Arab2Rim ( NI ) ) ) ; ende . Funktion til at konvertere arabisk til romersk tal i Pascal [10] funktion Arab2Roman ( arabisk : heltal ) : streng ; var i : heltal ; d : heltal ; arab_str : streng _ arab_len : heltal ; start Resultat := '' ; arab_str := IntToStr ( arabisk ) ; arab_len := Længde ( arab_str ) ; for i := 0 til arab_len - 1 begynder d := StrToInt ( String ( arab_str [ arab_len - i ] )) ; hvis ( d + 1 ) mod 5 = 0 , så Resultat := Kopi ( 'IXCM' , 1 + i , 1 ) + Kopi ( 'VXLCDM' , i * 2 + ( d + 1 ) div 5 , 1 ) + Resultat andet Resultat := Kopi ( 'VLD' , 1 + i , d div 5 ) + Kopi ( 'IIIXXXCCCMMM' , 1 + i * 3 , ( d mod 5 )) + Resultat ; ende ; ende ; Arabisk til romersk konverteringsfunktion i BASIC (den korteste kode) [11] 10 INDFØR "ARABISK NUMMER: " ; A $ 20 FOR I = 0 TIL LEN ( A$ ) -1 30 X = VAL ( MID$ ( A$ , LEN ( A$ ) - I , 1 )) 40 HVIS X = 4 ELLER X = 9 SÅ B$ = MID$ ( "IXCM" , I + 1 , 1 ) + MID$ ( "VXLCDM" , I * 2 + ( X + 1 ) / 5 , 1 ) + B$ 50 HVIS X < 4 SÅ B$ = MID$ ( "IIIXXXCCCMMM" , 1 + I * 3 , X ) + B$ ELSE HVIS X > 4 OG X < 9 SÅ B$ = MID$ ( "VLD" , I + 1 , 1 ) + MID$ ( "IIIXXXCCCMMM" , 1 + I * 3 , X -5 ) + B$ 60 NÆSTE I 70 UDSKRIV "ROMERSK NUMMER: " ; B$ Funktion til at konvertere arabisk tal (i dette tilfælde 1999) til romersk på XPath string-join( for $num (1999) Vend tilbage ( ('','M','MM','MMM')[($num idiv 1000) mod 10+1], ('','C','CC','CCC','CD','D','DC','DCC','DCCC','CM')[($num idiv 100) mod 10+ en], ('','X','XX','XXX','XL','L','LX','LXX','LXXX','XC')[($num idiv 10) mod 10+ en], ('','I','II','III','IV','V','VI','VII','VIII','IX')[$num mod 10+1] ), '') Funktion til at konvertere arabisk tal (i dette tilfælde 1999) til romersk i Perl brug streng ; brug advarsler ; min $n = 1999 ; mine $nums = [ [ '' , qw(I II III IV V VI VII VIII IX) ], [ '' , qw(X XX XXX XL L LX LXX LXXX XC) ], [ '' , qw(C CC CCC CD D DC DCC DCCC CM) ], [ '' , qw(M MM MMM) ] ]; min $i = 0 ; min @res = (); push @res , ( $nums -> [ $i ++ ][ ( $n % 10 , $n = int ( $n / 10 ))[ 0 ] ]) for 0 .. 3 ; udskriv omvendt @res ; Klasse til konvertering af arabisk tal (fra 1 til 3999) til romersk i Java importer java.util.* ; public class IntegerConverter { public static String intToRoman ( int tal ) { if ( tal >= 4000 || tal <= 0 ) returner null ; StringBuilder- resultat = ny StringBuilder (); for ( Heltalstast : enheder . descendingKeySet ()) { while ( number > = key ) { number -= key ; resultat . tilføj ( enheder . få ( nøgle )); } } returner resultat . toString (); } private static final NavigableMap < Integer , String > units ; static { NavigableMap < Integer , String > initMap = new TreeMap <> (); initMap . put ( 1000 , "M" ); initMap . put ( 900 , "CM" ); initMap . put ( 500 , "D" ); initMap . put ( 400 , "CD" ); initMap . put ( 100 , "C" ); initMap . put ( 90 , "XC" ); initMap . put ( 50 , "L" ); initMap . put ( 40 , "XL" ); initMap . put ( 10 , "X" ); initMap . put ( 9 , "IX" ); initMap . put ( 5 , "V" ); initMap . put ( 4 , "IV" ); initMap . put ( 1 , "I" ); enheder = Samlinger . unmodificableNavigableMap ( initMap ); } } Udvidelsesklasse til at konvertere romersk til arabisk og omvendt på CSharp /// <resumé> /// Klassen er designet til at konvertere arabiske tal til romerske tal og omvendt /// </summary> /// <remarks> /// <para >Klassen indeholder oprindeligt et alfabet af romersk tal, der kan bestemme arabiske tal fra 1 til 39999</para> /// <para >Hvis du vil udvide området, kan du definere yderligere notationer for romertal ved at bruge /// felt <see cref="BasicRomanNumbers"/> BasicRomanNumbers</remarks> offentlig statisk klasse RomanNumber { /// <summary> /// Alfabet af grundlæggende romertal /// <para>Alfabetet er bygget som en ordbog. Nøglen til ordbogen er et arabisk tal (int), værdien er dets tilsvarende /// romersk tal (streng)</para> /// </summary> /// <remarks> /// <para >Indeholder de romerske symboler for arabiske tal 1 *,4*,5*,9* - hvor "*" repræsenterer 0...N nuller</para> /// <para >Indeholder, når de er oprettet, betegnelsen for tal fra 1 til 10000 (I...ↂ ) Da et tegn ikke kan /// forekomme mere end tre gange i et romersk tal, kan du i første omgang konvertere tal fra 1 til 39999 til romersk format.</para> /// <para>Hvis du ønsker at kunne arbejde med et stort antal romertal, så skal du tilføje til listen /// yderligere betegnelser startende fra 40000 uden at springe elementerne 1*,4*,5*,9* over.</para> /// </remarks> public static SortedList < int , string > Grundlæggende romerske tal { get ; sæt ; } static RomanNumber () { BasicRomanNumbers = new SortedList < int , string >( 17 ); Grundlæggende romerske tal . Tilføj ( 1 , "I" ); Grundlæggende romerske tal . Tilføj ( 4 , "IV" ); Grundlæggende romerske tal . Tilføj ( 5 , "V" ); Grundlæggende romerske tal . Tilføj ( 9 , "IX" ); Grundlæggende romerske tal . Tilføj ( 10 , "X" ); Grundlæggende romerske tal . Tilføj ( 40 , "XL" ); Grundlæggende romerske tal . Tilføj ( 50 , "L" ); Grundlæggende romerske tal . Tilføj ( 90 , "XC" ); Grundlæggende romerske tal . Tilføj ( 100 , "C" ); Grundlæggende romerske tal . Tilføj ( 400 , "CD" ); Grundlæggende romerske tal . Tilføj ( 500 , "D" ); Grundlæggende romerske tal . Tilføj ( 900 , "CM" ); Grundlæggende romerske tal . Tilføj ( 1000 , "M" ); Grundlæggende romerske tal . Tilføj ( 4000 , "Mↁ" ); Grundlæggende romerske tal . Tilføj ( 5000 , "ↁ" ); Grundlæggende romerske tal . Tilføj ( 9000 , "Mↂ" ); Grundlæggende romerske tal . Tilføj ( 10000 , "ↂ" ); } /// <resumé> /// Beregner det maksimalt mulige romertal for det aktuelle alfabet af romertal. /// </summary> /// <returns>Maksimalt muligt romersk tal</returns> public static uint MaxRomanNumber () { int lastNumber = BaseRomanNumbers . nøgler . Sidste (); int numberNoZeros = int . Parse ( lastNumber . ToString (). Erstat ( '0' , '\0' )); int præ = 0 ; switch ( nummerUdenNuller ) { tilfælde 1 : forrige = sidsteNumber * 4-1 ; _ _ bryde ; case 4 : case 9 : previous = lastNumber ; bryde ; tilfælde 5 : foreløbig = sidste tal + sidste tal / 5 * 3 ; bryde ; default : break ; } returnere uint . Parse ( pre . ToString ( ). Erstat ( '0' , '9' ));; } /// <summary> /// Konverterer et heltal til et romersk tal /// </summary> /// <param name="Arabisk tal">Det arabiske tal, der skal konverteres til romersk notation</param> // / < exception cref="ArgumentOutOfRangeException">Kastet, når et tal lig med "0" /// eller et tal større end det maksimale romerske tal sendes som en parameter.</exception> /// <returns>En streng, der repræsenterer en Romersk tal</returns> offentlig statisk streng ArabiskRoman ( dette int nummerArab ) { StringBuilder numberRoman = new StringBuilder (); //Ekskluder tegnet "-" fra det arabiske tal og gør det til det første tegn i det romerske tal, hvis ( talArab < 0 ) { nummerRoman . tilføje ( "-" ); numberArab = - numberArab ; } if ( numberArab == 0 ) smid nyt ArgumentOutOfRangeException ( "numberArab" , numberArab , "Ugyldig argumentværdi: Romertal kan ikke være lig med\"0\"" ); else if ( numberArab > MaxRomanNumber ()) throw new ArgumentOutOfRangeException ( "numberArab" , numberArab , string . Format ( "Ugyldig argumentværdi: Kan ikke angive romersk tal større end {0}" , MaxRomanNumber ())); //Dekomponér det arabiske tal i dets konstituerende romertal og kombiner dem i én streng var requiredBasicRomanNumbers = fra til i BasicRomanNumbers . Taster hvor skal <= nummerArabisk rækkefølge efter til faldende vælg til ; foreach ( int current in requiredBaseRomanNumbers ) { while ( ( antalArab / aktuel ) >= 1 ) { numberArabisk- = aktuel ; nummerromersk . Tilføj ( BaseRomanNumbers [ tech ]); } } returnummerromersk . _ ToString (); } /// <summary> /// Konverterer romersk tal til arabisk /// </summary> /// <param name="romersk tal">romersk tal, der skal konverteres til int type</param> /// <exception cref="FormatException">Kastet, når et ikke-romersk tal sendes som en parameter</exception> /// <returns>Et heltal, der repræsenterer den arabiske notation af et romersk tal</returns > offentlig statisk int RomanToArabic ( dette strengnummerRoman ) { int talArab = 0 ; sbyte negativ = 1 ; streng roman = talRoman . trim (); if ( romersk [ 0 ] == '-' ) { negativ = - 1 ; rom = rom . understreng ( 1 ); } StringBuilder RomanNumber skabelon = ny StringBuilder (); foreach ( int to in Base romertal . Keys ) { int index = Basis romertal . nøgler . Indeks af ( k ); strengkvantifier = " ?" ; if ( indeks == 0 || ( indeks % 4 ) == 0 ) kvantifier = "{0,3}" ; romersk tal skabelon . Indsæt ( 0 , streng . Formater ( "(?<{0}>({1}){2})?" , til . ToString (), Grundlæggende romerske tal [ til ], kvantifier )); } //Ignorer store og små bogstaver + match skal starte i begyndelsen af strengen RomanNumber-skabelonen . Indsæt ( 0 , "(?i)^" ); //Tilpasningen skal forekomme i slutningen af strengen RomanNumber-mønsteret . tilføje ( "$" ); // Forenklet kontrol. Kontrollerer ikke for fejl såsom IVII, hvis (! Regex . IsMatch ( romersk , romertalsmønster . ToString ())) kaster nyt FormatException ( streng . Format ( "Tekst \"{0}\" er ikke et romertal" , romertal )); Matchnummer = Regex . _ Match ( rom , RomanNumber Pattern . ToString ()); foreach ( int til i basis romertal . Keys ) { numberArab += tal . Grupper [ til . ToString ()]. Længde / Grundlæggende romerske tal [ til ]. Længde * til ; } returner talArab * negativ ; } }

Noter

↑ Tal og talsystemer Arkiveret 22. november 2018 på Wayback Machine . Online Encyclopedia Around the World.
↑ M. Ya. Vygodsky "Håndbog i elementær matematik" Moskva 1958 Statens forlag for fysisk og matematisk litteratur. side 62
↑ Beckhams vej til Roman Arkiveret 1. maj 2020 på Wayback Machine // BBC , 17. april 2002
↑ Unicode Standard, 15.3 Arkiveret 27. juni 2010 på Wayback Machine ("Til de fleste formål er det at foretrække at sammensætte romertallene ud fra sekvenser af de passende latinske bogstaver.")
↑ 12 Unicode -nummerformularer . Hentet 30. marts 2009. Arkiveret fra originalen 25. marts 2009. (ubestemt)
↑ Perry, David J. Forslag om at tilføje yderligere antikke romerske karakterer til UCS Arkiveret 22. juni 2011 på Wayback Machine .
↑ For de første to linjer
↑ Kapitel 31. Romersk numerisk notation :: Implementeringsidéer . Dato for adgang: 15. oktober 2015. Arkiveret fra originalen 18. november 2015. (ubestemt)
↑ "Science and Life" N12 1986 s. 95, V. Ptitsyn, Moskva
↑ Forfatter - Kuznetsov Evgeny A.
↑ Forfatter - Evgeny A. Kuznetsov, 1992