Romerska siffror

Den aktuella versionen av sidan har ännu inte granskats av erfarna bidragsgivare och kan skilja sig väsentligt från versionen som granskades den 12 oktober 2022; kontroller kräver 2 redigeringar .
Talsystem i kulturen
indo-arabiska
Arabiska
tamilska
burmesiska 		Khmer
Lao
Mongoliska
Thai
Öst asiat
kinesiska
japanska
Suzhou
koreanska 		Vietnamesiska
räknepinnar
Alfabetisk
Abjadia
Armeniska
Aryabhata
kyrilliska
grekiska 		georgiska
etiopiska
judiska
Akshara Sankhya
Övrig
Babyloniska
egyptiska
etruskiska
romerska
Donau 		Attic
Kipu
Mayan
Egeiska
KPPU-symboler
positionella
2 , 3 , 4 , 5 , 6 , 8 , 10 , 12 , 16 , 20 , 60
Nega-positionell
symmetrisk
blandade system
Fibonacci
icke-positionell
Singular (unär)

Romerska siffror  är siffror som används av de gamla romarna i deras icke-positionella nummersystem .

Naturliga tal skrivs genom att dessa siffror upprepas. Samtidigt, om ett större tal kommer före ett mindre, så adderas de (additionsprincipen), men om ett mindre kommer före ett större, så subtraheras det mindre från det större (subtraktionsprincipen). Den sista regeln gäller endast för att undvika fyrfaldig upprepning av samma figur.

Romerska siffror dök upp 500 f.Kr. från etruskerna (se etruskiska alfabetet ), som kunde låna några av siffrorna från protokelterna .

Siffror och notering av siffror

Romersk notation för siffror är nu mer känd än något annat forntida talsystem. Detta förklaras inte så mycket av några speciella fördelar med det romerska systemet, utan av det enorma inflytande som det romerska riket åtnjöt i det relativt korta förflutna. Etrusker som erövrade Rom på 700-talet f.Kr. t.ex. påverkades av östra Medelhavskulturer. Detta förklarar delvis likheten mellan de grundläggande principerna för de romerska och attiska talsystemen. Båda systemen var decimala, även om siffran fem spelade en speciell roll i båda talsystemen. Båda systemen använde upprepade tecken när de skrev siffror.

De gamla romerska symbolerna för siffrorna 1, 5, 10, 100 och 1000 ( hindo-arabisk notation ) var symbolerna I, V, X, Θ (eller ⊕ , eller ⊗ ) och Φ (eller ↀ , eller CIƆ ) , respektive. Även om mycket har skrivits om den ursprungliga betydelsen av dessa symboler, finns det fortfarande ingen tillfredsställande förklaring till dem. Enligt en av de utbredda teorierna visar den romerska siffran V en öppen hand med fyra fingrar sammanpressade och tummen utsträckt; symbolen X, enligt samma teori, avbildar två korsade händer eller ett tvåsiffrigt V. Symbolerna för siffrorna 100 och 1000 kommer troligen från de grekiska bokstäverna Θ och φ. Det är inte känt om de senare beteckningarna C och M härrör från äldre romerska tecken eller är akrofoniskt relaterade till initialbokstäverna i de latinska orden som betyder 100 (centum) och 1000 (mille). Man tror att den romerska symbolen för siffran 500, bokstaven D , härstammar från hälften av den gamla symbolen för 1000. Förutom att de flesta romerska symboler med största sannolikhet inte var akrofoniska och att mellansymbolerna för siffrorna 50 och 500 inte var kombinationer av symboler för siffrorna 5 och 10 eller 5 och 100, liknade resten av det romerska talsystemet Attic. Romarna använde ofta subtraktionsprincipen, så ibland använde de IX istället för VIIII och XC istället för LXXXX; jämförelsevis senare, symbolen IV i stället för IIII. Därför kan nu alla romerska siffror skrivas med latinska versaler.

I allmänhet var romarna inte benägna att göra matematik, så de kände inte stort behov av stora siffror. Emellertid använde de ibland symbolen CCIƆƆ för 10000 och symbolen CCCIƆƆƆ för talet 100000 . Halvorna av dessa symboler användes ibland för att representera siffrorna 5000 ( IƆƆ ) och 50000 ( IƆƆƆ ).

Romarna undvek bråkdelar lika envist som stora tal. I praktiska mätproblem använde man inte bråk, delade måttenheten vanligtvis i 12 delar, så att resultatet av mätningen presenteras som ett sammansatt tal, summan av multiplar av olika enheter, som man gör idag när längden är uttryckt i yards, fot och tum. De engelska orden "ounce" ( ounce ) och "inch" ( inch ) kommer från det latinska ordet lat.  uncia ( uns ), som betecknar en tolftedel av den grundläggande längdenheten [1] [2] .

ett jag lat.  unus, unum
5 V lat.  quinque
tio X lat.  decem
femtio L lat.  quinquaginta
100 C lat.  procent
500 D lat.  quingenti
1000 M lat.  mille
Arabisk notation Romersk notation
ett jag
2 II
3 III
fyra IV
5 V
6 VI
7 VII
åtta VIII
9 IX
tio X
elva XI
12 XII
13 XIII
fjorton XIV
femton XV
16 XVI
17 XVII
arton XVIII
19 XIX
tjugo XX
trettio XXX
40 XL
femtio 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 CENTIMETER; CCIƆ
1000 M; ↀ; CIƆ
2000 MM; CIƆCIƆ
3000 MMM; CIƆCIƆCIƆ
3999 MMMCMXCIX
4000 MV ; _ ↀↁ; CIƆIƆƆ
5 000 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 CENTIMETER
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

För att korrekt skriva stora tal i romerska siffror måste du först skriva ner antalet tusentals, sedan hundratals, sedan tiotals och slutligen enheter.

Det finns ingen nolla i det romerska siffersystemet, men noll användes tidigare som nulla (nej), nihil (ingenting) och N (första bokstaven i dessa ord).

I det här fallet kan vissa av siffrorna (I, X, C, M) upprepas, men inte mer än tre gånger i rad ; sålunda kan de användas för att skriva vilket naturligt tal som helst inte mer än 3999 (MMMCMXCIX). Under de tidiga perioderna fanns det tecken som tydde på större antal - 5 000, 10 000, 50 000 och 100 000 (då är maxantalet enligt nämnda regel 399 999). När man skriver tal i det romerska siffersystemet kan den mindre siffran vara till höger om den större; i detta fall läggs det till. Till exempel skrivs talet 283 på romersk som CCLXXXIII, det vill säga 100+100+50+30+3=283. Här upprepas talet som representerar hundra två gånger, och siffrorna som representerar tio respektive ett upprepas tre gånger.

Exempel: nummer 1988. Ettusen M, niohundra CM, åtta tiotals LXXX, åtta enheter VIII. Låt oss skriva dem tillsammans: MCMLXXXVIII.

Ganska ofta, för att markera siffror i texten, drogs en linje över dem: LXIV . Ibland drogs linjen både ovanför och under: XXXII  - i synnerhet är det vanligt att markera romerska siffror i rysk handskriven text (detta används inte i typografisk typsättning på grund av teknisk komplexitet). För andra författare kan överlinjen indikera en ökning av figurens värde med 1000 gånger: V = 5000.

Det var först på 1800-talet som siffran "fyra" skrevs ner som "IV" överallt , innan dess användes posten "IIII" oftast. Posten "IV" kan dock hittas redan i dokumenten till Forme of Cury- manuskriptet som går tillbaka till 1390 . Urtavlor har traditionellt använt " IIII " istället för "IV" i de flesta fall, främst av estetiska skäl: denna stavning ger visuell symmetri med siffrorna "VIII" på motsatt sida, och det omvända "IV" är svårare att läsa än "III". Det finns också en version att IV inte skrevs på urtavlan eftersom IV är de första bokstäverna i det latinska namnet på guden Jupiter (IVPITER).

Det mindre talet kan skrivas till vänster om det större, sedan ska det subtraheras från det större. I det här fallet kan endast siffror som betecknar 1 eller potenser av 10 subtraheras, och endast de två närmaste talen i talserien till det subtraherade (det vill säga det subtraherade, multiplicerat med 5 eller 10) kan fungera som minuend. Upprepningar av ett mindre antal är inte tillåtna. Det finns alltså bara sex användningsområden för "subtraktionsregeln":

Till exempel kommer talet 94 att vara XCIV = 100 - 10 + 5 - 1 = 94 - den så kallade "subtraktionsregeln" (dök upp under senantik, och innan dess skrev romarna siffran 4 som IIII, och siffran 40 som XXXX).

Det bör noteras att andra metoder för "subtraktion" inte är tillåtna; alltså bör siffran 99 skrivas som XCIX, men inte som IC. Men nuförtiden, i vissa fall, används också en förenklad notation av romerska siffror: till exempel, i Microsoft Excel , när du konverterar arabiska siffror till romerska med funktionen "ROMAN ()" kan du använda flera typer av representation av tal, från klassiskt till mycket förenklat (till exempel kan siffran 499 skrivas som CDXCIX, LDVLIV, XDIX, VDIV eller ID). Förenklingen är att för att minska vilken siffra som helst kan vilken annan siffra som helst skrivas till vänster om den:

Fall av sådan notering av siffror (vanligtvis år) finns ofta i krediterna för amerikanska tv-serier. Till exempel för år 1998: MIIM istället för MCMXCVIII.

Romerska siffror kan också användas för att skriva större klasser av tal. För att göra detta placeras en linje ovanför de siffror som representerar tusentals, och en dubbel linje placeras ovanför siffrorna som representerar miljoner. Undantaget är siffran I; istället för en rad ovanför skrivs talet M, och från en miljon - en rad ovanifrån. Till exempel skulle numret 123123 se ut så här:

CXXIII CXXIII

Och en miljon är som jag , men inte med en, utan med två funktioner i spetsen: Jag

Applikation

På ryska används romerska siffror i följande fall:

Romerska siffror användes i stor utsträckning i Sovjetunionen när de anger datum för att ange månaden på året, till exempel: 11 / III-85 eller 9.XI.89, detta kan ses på många arkivdokument från den tiden. På liknande sätt, genom ett snedstreck , skrev de även ner datumet för lektionen i klassdagböcker , till exempel 24/II. För att ange datum för liv och död på gravstenar användes ofta ett speciellt format, där månaden på året även angavs med romerska siffror, till exempel (25 november 1887 ~ 26 januari 1943). Ett liknande format användes i läkarintyg på 1970- och 1980-talen.

I och med övergången till datorbehandling av information har datumformat baserade på romerska siffror praktiskt taget fallit ur bruk.

På andra språk kan omfattningen av romerska siffror skilja sig åt. I västländer skrivs årets nummer ofta med romerska siffror, till exempel på byggnadsgavlarna och i krediterna för video-, film- och tv-produkter [3] .

I det moderna Litauen , på vägskyltar , på skyltfönster , på skyltar för företag, kan romerska siffror indikera veckodagar .

Unicode

Unicode - standarden rekommenderar att romerska siffror representeras med vanliga latinska tecken [4] . Standarden innehåller dock även specialtecken för romerska siffror som en del av Number Forms [ 5 ] i teckenområdet med koderna U+2160 till U+2188. Till exempel kan MCMLXXXVIII representeras i formen ⅯⅭⅯⅬⅩⅩⅩⅧ. Det här intervallet inkluderar både gemener och versaler för siffrorna 1 (Ⅰ eller I) till 12 (Ⅻ eller XII), inklusive kombinerade glyfer för sammansatta siffror som 8 (Ⅷ eller VIII), främst för att säkerställa kompatibilitet med östasiatiska teckenuppsättningar i industristandarder som JIS X 0213 där dessa tecken definieras. Kombinerade glyfer används för att representera tal som tidigare bestod av enstaka tecken (till exempel Ⅻ istället för dess representation som Ⅹ och Ⅱ). Dessutom finns glyfer för de arkaiska [5] formerna av 1000, 5000, 10 000, kapital invers C (Ɔ), sent 6 (ↅ, liknande det grekiska stigmat : Ϛ), tidiga 50 ( ↆ, som ser ut som en pil pekar nedåt ↓⫝⊥ [6] ), 50 000 och 100 000. Det bör noteras att det lilla omvända c, ↄ inte ingår i romerska siffror, utan ingår i Unicode-standarden som den stora Claudian bokstaven Ↄ.  

Koden 0 ett 2 3 fyra 5 6 7 åtta 9 A B C D E F
Värde [7] ett 2 3 fyra 5 6 7 åtta 9 tio elva 12 femtio 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
Menande 1000 5 000 10 000 100 6 femtio 50 000 100 000
U+2180 ↀ
2180		 ↁ
2181		 ↂ
2182		 Ↄ
2183		 ↅ
2185		 ↆ
2186		 ↇ
2187		 ↈ
2188

Att visa alla dessa tecken kräver programvara som stöder Unicode-standarden och ett teckensnitt som innehåller motsvarande glyfer för dessa tecken (till exempel Universalia -teckensnittet ).

Reguljära uttryck

Reguljärt uttryck för att kontrollera romerska siffror - ^(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 använda ett reguljärt uttryck för att söka efter romerska siffror i en sträng 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

För att konvertera tal skrivna med arabiska siffror till romerska, används speciella funktioner.

Till exempel, i den engelska versionen av Microsoft Excel och i alla versioner av OpenOffice.org Calc , finns det en ROMAN (argument; form) funktion för detta , i den ryska versionen av Microsoft Excel kallas denna funktion ROMAN (nummer; form) . Det valfria argumentet "form" kan ta värden från 0 till 4, såväl som "falskt" och "sant". Frånvaron av argumentet "Form" eller dess likhet med 0 eller "Sant" ger transformationens "klassiska" (strikta) form; ett värde på 4 eller "False" ger det mest förenklade; värden 1, 2, 3 ger varianter som är mellanliggande i rigor-förenkling. Skillnader förekommer till exempel i siffrorna 45, 49, 495, 499 (de första anges i intervallet [1;3999]).

Exempel på funktionsapplikation ROMAN(tal; form)
formen 0 ett 2 3 fyra
siffra
45 XLV VL VL VL VL
49 XLIX VLIV IL IL IL
495 CDXCV LDVL XDV VD VD
499 CDXCIX LDVLIV XDIX VDIV ID

Icke-heltalsvärden för argumentet "number" avrundas nedåt till ett heltal; om värdet efter det är större än 3999 eller mindre än 0, returnerar funktionen "#Value"; för värdet 0 returneras en tom cell.


JavaScript- transformeringsfunktioner 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' ]; function arabToRoman ( tal ) { if ( ! nummer ) returnera '' ; varret = ' ' ; var i = arabiska . längd - 1 ; while ( tal > 0 ) { if ( tal >= arab [ i ]) { ret += roman [ i ]; nummer -= arab [ i ]; } annat { i -- ; } } return ret ; } function romanToArab ( str ) { str = str . toUpperCase (); varret = 0 ; _ var i = arabiska . längd - 1 ; var pos = 0 ; while ( i >= 0 && pos < str . längd ) { if ( str . substr ( pos , romersk [ i ]. längd ) == roman [ i ]) { ret += arab [ i ]; pos += romersk [ i ]. längd ; } annat { i -- ; } } return ret ; } Liknande funktioner i C-språk (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 ( osignerad kort int arab ) { statisk röding roman [ 80 ]; const int m = sizeof ( arabar ) / sizeof ( int ) -1 , arabmax = arabar [ m ]; const char romanmax = romanar [ m ][ 0 ]; int i , n ; if ( ! arab ) { * romersk = 0 ; returnera roman ; } i = 0 _ while ( arab > arabmax ) { roman [ i ++ ] = romanmax ; arab -= arabmax ; } n = m ; while ( arab > 0 ) { if ( arab >= arabar [ n ]) { roman [ i ++ ] = romanar [ n ][ 0 ]; om ( n & 1 ) roman [ i ++ ] = romanar [ n ][ 1 ]; arab -= arabar [ n ]; } annat n- ; _ } roman [ i ] = 0 ; returnera roman ; } osignerad kort int roman2arab ( char * roman ) { const int m = storlek på ( arabar ) / storlek på ( int ) -1 ; osignerad kort int arab ; int len , n , i , pir ; len = strlen ( romersk ); arab = 0 ; n = m ; i = 0 _ while ( 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 ; } annat n- ; _ } returnera arabiska ; } Program för att konvertera arabiska siffror till romerska 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 . length - 1 ): String = if ( arab == 0 ) acc else if ( arab >= arabar ( n )) arab2roman ( arab - arabar ( n ), acc + romanar ( n ), n ) annat arab2roman ( arab , acc , n - 1 ) // arab2roman(4933) = MMMMCMXXXIII Program för att konvertera arabiska siffror till romerska siffror och vice versa på Pascal- språket [9] typ str2 = sträng [ 2 ] ; const Rims : array [ 1 .. 14 ] of str2 = ( 'M' , 'CM' , 'D' , 'CD' , 'C' , 'XC' , 'L' , 'XL' , 'X' , 'IX' , 'V' , 'IV' , 'I' , '' ) ; Arab : matris [ 1 .. 14 ] av heltal = ( 1000 , 900 , 500 , 400 , 100 , 90 , 50 , 40 , 10 , 9 , 5 , 4 , 1 , 0 ) ; var N , NI , I , J : heltal ; S : sträng _ funktion Arab2Rim ( N : heltal ) : sträng ; var S : sträng ; I : heltal ; börja S := '' ; I := 1 ; medan N > 0 börjar medan Arab [ I ] < = N börjar S : = S + Rims [ I ] ; N := N - Arabisk [ I ] slut ; I := I + 1 slut ; Arab2Rim := S slut ; funktion Rim2Arab ( S : sträng ) : heltal ; var I , N : heltal ; börja I := 1 ; N : = 0 medan S <> '' börjar medan Fälgar [ I ] = Kopiera ( S , 1 , Längd ( Fälgar [ I ] ) ) börjar S : = Kopiera ( S , 1 + Längd ( Fälgar [ I ] ) , 255 ) ; N := N + Arab [ I ] slut ; I := I + 1 slut ; Rim2Arab := N ände ; börja WriteLn ( 'Översättning från arabiska till romerska siffror. 1999 B_SA' ) ; { Write('Ange nummer för att konvertera:'); ReadLn(N);} för NI := 26 till 46 gör WriteLn ( NI , ' = ' , Arab2Rim ( NI ) , ' back ' , Rim2Arab ( Arab2Rim ( NI ) ) ) ; slut . Funktion för att konvertera arabiska till romerska tal i Pascal [10] funktion Arab2Roman ( arab : heltal ) : sträng ; var i : heltal ; d : heltal ; arab_str : sträng _ arab_len : heltal ; börja Resultat := '' ; arab_str := IntToStr ( arab ) ; arab_len := Längd ( arab_str ) ; för i := 0 till arab_len - 1 börjar d := StrToInt ( String ( arab_str [ arab_len - i ] )) ; om ( d + 1 ) mod 5 = 0 då Resultat := Kopiera ( 'IXCM' , 1 + i , 1 ) + Copy ( 'VXLCDM' , i * 2 + ( d + 1 ) div 5 , 1 ) + Resultat annat Resultat := Kopiera ( 'VLD' , 1 + i , d div 5 ) + Kopiera ( 'IIIXXXCCCMMM' , 1 + i * 3 , ( d mod 5 )) + Resultat ; slut ; slut ; Arabiska till romerska konverteringsfunktion i BASIC (den kortaste koden) [11] 10 MATTA IN "ARABISKT NUMMER: " ; A $ 20 FOR I = 0 TO LEN ( A$ ) -1 30 X = VAL ( MID$ ( A$ , LEN ( A$ ) - I , 1 )) 40 OM X = 4 ELLER X = 9 DÅ B$ = MID$ ( "IXCM" , I + 1 , 1 ) + MID$ ( "VXLCDM" , I * 2 + ( X + 1 ) / 5 , 1 ) + B$ 50 OM X < 4 DÅ B$ = MID$ ( "IIIXXXCCCMMM" , 1 + I * 3 , X ) + B$ ANNAT OM X > 4 OCH X < 9 DÅ B $ = MID$ ( "VLD" , I + 1 , 1 ) + MID$ ( "IIIXXXCCCMMM" , 1 + I * 3 , X -5 ) + B$ 60 NÄSTA I 70 SKRIV UT "ROMERSK NUMMER: " ; B$ Funktion för att konvertera arabiska tal (i detta fall 1999) till romerska på XPath string-join( för $num (1999) lämna tillbaka ( ('','M','MM','MMM')[($num idiv 1000) mod 10+1], ('','C','CC','CCC','CD','D','DC','DCC','DCCC','CM')[($num idiv 100) mod 10+ ett], ('','X','XX','XXX','XL','L','LX','LXX','LXXX','XC')[($num idiv 10) mod 10+ ett], ('','I','II','III','IV','V','VI','VII','VIII','IX')[$num mod 10+1] ), '') Funktion för att konvertera arabiska tal (i detta fall 1999) till romerska i Perl använd strikt ; använd varningar ; min $n = 1999 ; mina $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 = (); tryck @res , ( $nums -> [ $i ++ ][ ( $n % 10 , $n = int ( $n / 10 ))[ 0 ] ]) för 0 .. 3 ; skriv ut omvänd @res ; Klass för att konvertera arabiska tal (från 1 till 3999) till romerska i Java importera java.util.* ; public class IntegerConverter { public static String intToRoman ( int nummer ) { if ( tal >= 4000 || nummer <= 0 ) return null ; StringBuilder- resultat = new StringBuilder (); for ( Heltalsnyckel : enheter . descendingKeySet ()) { while ( number >= key ) { number - = key ; resultat . append ( enheter . get ( nyckel )); } } returnera resultat . toString (); } privat statisk final NavigableMap < Integer , String > enheter ; 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" ); enheter = Samlingar . unmodifiableNavigableMap ( initMap ); } } Tilläggsklass för att konvertera romerska till arabiska och vice versa, på CSharp /// <summary> /// Klassen är utformad för att konvertera arabiska siffror till romerska tal och vice versa /// </summary> /// <remarks> /// <para >Klassen innehåller initialt ett alfabet av romerska tal som kan bestämma arabiska tal från 1 till 39999</para> /// <para >Om du vill utöka intervallet kan du definiera ytterligare notationer för romerska siffror med ///-fältet <see cref="BasicRomanNumbers"/> BasicRomanNumbers</remarks> public static class RomanNumber { /// <summary> /// Alfabet med grundläggande romerska siffror /// <para>Alfabetet är byggt som en ordbok. Ordbokens nyckel är ett arabiskt tal (int), värdet är dess motsvarande /// romerska tal (sträng)</para> /// </summary> /// <remarks> /// <para >Innehåller de romerska symbolerna för arabiska siffror 1 *,4*,5*,9* - där "*" representerar 0...N nollor</para> /// <para >Innehåller när de skapats beteckningen för siffror från 1 till 10000 (I...ↂ ) Eftersom ett tecken inte kan /// förekomma mer än tre gånger i ett romerskt tal, kan du initialt konvertera tal från 1 till 39999 till romerskt format.</para> /// <para>Om du vill kunna arbeta med ett stort antal romerska siffror måste du lägga till i listan /// ytterligare beteckningar från 40000 utan att hoppa över element 1*,4*,5*,9*.</para> /// </remarks> public static SortedList < int , string > Grundläggande romerska siffror { get ; set ; } static RomanNumber () { BasicRomanNumbers = new SortedList < int , string >( 17 ); Grundläggande romerska siffror . Lägg till ( 1 , "I" ); Grundläggande romerska siffror . Lägg till ( 4 , "IV" ); Grundläggande romerska siffror . Lägg till ( 5 , "V" ); Grundläggande romerska siffror . Lägg till ( 9 , "IX" ); Grundläggande romerska siffror . Lägg till ( 10 , "X" ); Grundläggande romerska siffror . Lägg till ( 40 , "XL" ); Grundläggande romerska siffror . Lägg till ( 50 , "L" ); Grundläggande romerska siffror . Lägg till ( 90 , "XC" ); Grundläggande romerska siffror . Add ( 100 , "C" ); Grundläggande romerska siffror . Lägg till ( 400 , "CD" ); Grundläggande romerska siffror . Lägg till ( 500 , "D" ); Grundläggande romerska siffror . Lägg till ( 900 , "CM" ); Grundläggande romerska siffror . Add ( 1000 , "M" ); Grundläggande romerska siffror . Lägg till ( 4000 , "Mↁ" ); Grundläggande romerska siffror . Lägg till ( 5000 , "ↁ" ); Grundläggande romerska siffror . Lägg till ( 9000 , "Mↂ" ); Grundläggande romerska siffror . Lägg till ( 10000 , "ↂ" ); } /// <sammanfattning> /// Beräknar högsta möjliga romerska siffra för det aktuella alfabetet av romerska siffror. /// </summary> /// <returns>Högsta möjliga romerska tal</returns> public static uint MaxRomanNumber () { int lastNumber = BaseRomanNumbers . nycklar . Sista (); int numberNoZeros = int . Parse ( lastNumber . ToString (). Ersätt ( '0' , '\0' )); int pre = 0 ; switch ( nummerUtanNollor ) { fall 1 : föregående = sista numret * 4 - 1 ; bryta ; fall 4 : fall 9 : föregående = sista numret ; bryta ; fall 5 : preliminärt = sista numret + sista numret / 5 * 3 ; bryta ; default : break ; } returnera uint . Parse ( pre . ToString ( ). Ersätt ( '0' , '9' ));; } /// <summary> /// Konverterar ett heltal till ett romerskt tal /// </summary> /// <param name="arabiskt nummer">Det arabiska talet som ska konverteras till romersk notation</param> // / < exception cref="ArgumentOutOfRangeException">Kastas när ett tal lika med "0" /// eller ett tal större än det maximala romerska talet skickas som en parameter.</exception> /// <returns>En sträng som representerar en Romerskt tal</returns> offentlig statisk sträng ArabicRoman ( detta int numberArab ) { StringBuilder numberRoman = new StringBuilder (); //Uteslut tecknet "-" från det arabiska talet och gör det till det första tecknet i det romerska talet om ( nummerArab < 0 ) { nummerRoman . append ( "-" ); numberArab = - numberArab ; } if ( numberArab == 0 ) kasta nytt ArgumentOutOfRangeException ( "numberArab" , numberArab , "Ogiltigt argumentvärde: romerska siffror kan inte vara lika med\"0\"" ); else if ( numberArab > MaxRomanNumber ()) throw new ArgumentOutOfRangeException ( "numberArab" , numberArab , string . Format ( "Ogiltigt argumentvärde: Kan inte ange romerskt tal större än {0}" , MaxRomanNumber ())); //Dekomponera det arabiska talet i dess ingående romerska siffror och kombinera dem till en sträng var requiredBasicRomanNumbers = från till i BasicRomanNumbers . Tangenter vart < = nummerArabisk ordningsföljd till fallande välj till ; foreach ( int ström i requiredBaseRomanNumbers ) { while (( antalArab / aktuell ) >= 1 ) { numberArab - = aktuell ; nummerRoman . Lägg till ( BasRomanNumbers [ tech ]); } } returnummerRoman . _ ToString (); } /// <summary> /// Konverterar romerska tal till arabiska /// </summary> /// <param name="Roman number">romerska tal som ska konverteras till int-typ</param> /// <exception cref="FormatException">Kastas när ett icke-romerskt tal skickas som en parameter</exception> /// <returns>Ett heltal som representerar den arabiska notationen av ett romerskt tal</returns> offentlig statisk int RomanToArabic ( denna strängnummerRoman ) { int numberArab = 0 ; sbyte negativ = 1 ; sträng roman = nummerRoman . trimma (); if ( romersk [ 0 ] == ' - ' ) { negativ = -1 ; rom = rom . delsträng ( 1 ); } StringBuilder RomanNumber mall = ny StringBuilder (); foreach ( int to in Base Roman Numbers . Keys ) { int index = Base Roman Numbers . nycklar . IndexOf ( k ); strängkvantifierare = " ?" ; if ( index == 0 || ( index % 4 ) == 0 ) kvantifierare = "{0,3}" ; mall för romersk nummer . Infoga ( 0 , sträng . Format ( "(?<{0}>({1}){2})?" , till . ToString (), grundläggande romerska siffror [ till ], kvantifierare )); } //Ignorera skiftläge + matchning måste börja i början av strängen RomanNumber-mallen . Infoga ( 0 , "(?i)^" ); //Matchningen måste ske i slutet av strängen RomanNumber-mönstret . append ( "$" ); // Förenklad kontroll. Söker inte efter fel som IVII om (! Regex . IsMatch ( romersk , romersk siffror mönster . ToString ())) kastar nytt FormatException ( sträng . Format ( "Text \"{0}\" är inte en romersk siffra" , romersk siffra )); Matchnummer = Regex . _ Match ( rom , RomanNumber Pattern . ToString ()); foreach ( int to in Base Roman Numbers . Keys ) { numberArab += number . Grupper [ till . ToString ()]. Längd / Grundläggande romerska siffror [ till ]. Längd * till ; } returnera nummerArab * negativ ; } }

Anteckningar

  1. ↑ Siffror och nummersystem Arkiverade 22 november 2018 på Wayback Machine . Online Encyclopedia Around the World.
  2. ↑ M. Ya. Vygodsky "Handbok för elementär matematik" Moskva 1958 Statligt förlag för fysisk och matematisk litteratur. sida 62
  3. ↑ Beckhams väg till Roman Arkiverad 1 maj 2020 på Wayback Machine // BBC , 17 april 2002
  4. ↑ Unicode Standard, 15.3 Arkiverad 27 juni 2010 på Wayback Machine ("För de flesta ändamål är det att föredra att komponera de romerska siffrorna från sekvenser av lämpliga latinska bokstäver.")
  5. ↑ 12 Unicode -nummerformulär . Hämtad 30 mars 2009. Arkiverad från originalet 25 mars 2009.
  6. ↑ Perry, David J. Förslag att lägga till ytterligare antika romerska karaktärer till UCS Arkiverad 22 juni 2011 på Wayback Machine .
  7. ↑ För de två första raderna
  8. ↑ Kapitel 31. Romersk numerisk notation :: Implementeringsidéer . Datum för åtkomst: 15 oktober 2015. Arkiverad från originalet den 18 november 2015.
  9. ↑ "Science and Life" N12 1986 s. 95, V. Ptitsyn, Moskva
  10. ↑ Författare - Kuznetsov Evgeny A.
  11. ↑ Författare - Evgeny A. Kuznetsov, 1992

Se även