Římské číslice

Aktuální verze stránky ještě nebyla zkontrolována zkušenými přispěvateli a může se výrazně lišit od verze recenzované 12. října 2022; kontroly vyžadují 2 úpravy .
Číselné soustavy v kultuře
Indoarabština
Arabská
tamilská
barmština 		Khmer
Lao
Mongol
Thai
východní Asiat
Čínský
Japonec
Suzhou
Korejský 		Vietnamské
počítací tyčinky
Abecední
Abjadia
arménská
Aryabhata
azbuka
Řek 		Gruzínský
etiopský
židovský
Akshara Sankhya
jiný
Babylonian
Egyptian
Etruscan
Roman
Danubian 		Attic
Kipu
Mayské
Egejské
KPPU Symboly
poziční
2 , 3 , 4 , 5 , 6 , 8 , 10 , 12 , 16 , 20 , 60
Nega-poziční
symetrický
smíšené systémy
Fibonacci
nepoziční
jednotné číslo (unární)

Římské číslice  jsou čísla používaná starověkými Římany v jejich nepoziční číselné soustavě .

Přirozená čísla se zapisují opakováním těchto číslic. Zároveň platí, že pokud je větší číslo před menším, pak se sčítají (princip sčítání), ale pokud je menší před větším, pak se menší odečítá od většího (princip odčítání). Poslední pravidlo platí pouze pro zamezení čtyřnásobného opakování stejného obrázku.

Římské číslice se objevily 500 př.nl od Etruscans (viz Etruscan abeceda ), kdo mohl půjčit si některá ta čísla od proto-Keltů .

Čísla a zápis čísel

Římský zápis čísel je nyní známější než jakýkoli jiný starověký číselný systém. To se vysvětluje ani ne tak nějakými zvláštními zásluhami římského systému, ale obrovským vlivem, kterému se římská říše těšila v relativně nedávné minulosti. Etruskové , kteří dobyli Řím v 7. století před naším letopočtem. byly ovlivněny kulturami východního Středomoří. To částečně vysvětluje podobnost základních principů římské a attické číselné soustavy. Oba systémy byly desítkové, i když číslo pět hrálo v obou číselných systémech zvláštní roli. Oba systémy používaly při psaní čísel opakované znaky.

Staré římské symboly pro čísla 1, 5, 10, 100 a 1000 ( hindoarabská notace ) byly symboly I, V, X, Θ (nebo ⊕ nebo ⊗ ) a Φ (nebo ↀ nebo CIƆ ) , resp. Přestože o původním významu těchto symbolů bylo napsáno mnoho, stále pro ně neexistuje uspokojivé vysvětlení. Podle jedné z rozšířených teorií římská číslice V zobrazuje otevřenou ruku se čtyřmi přitisknutými prsty a nataženým palcem; symbol X podle stejné teorie zobrazuje dvě zkřížené ruce nebo dvojčíslí V. Symboly pro čísla 100 a 1000 pravděpodobně pocházejí z řeckých písmen Θ a φ. Není známo, zda pozdější označení C a M jsou odvozena od starších římských znaků nebo akrofonicky souvisí s počátečními písmeny latinských slov s významem 100 (centum) a 1000 (mille). Předpokládá se, že římský symbol pro číslo 500, písmeno D , pochází z poloviny starého symbolu pro 1000. Kromě toho, že většina římských symbolů s největší pravděpodobností nebyla akrofonická a že mezilehlé symboly pro čísla 50 a 500 nebyly kombinacemi. symbolů pro čísla 5 a 10 nebo 5 a 100, zbytek římského číselného systému připomínal Attiku. Římané často používali princip odčítání, takže někdy používali IX místo VIIII a XC místo LXXXX; poměrně později, symbol IV místo IIII. Proto lze nyní všechny římské číslice psát velkými latinskými písmeny.

Obecně platí, že Římané neinklinovali k matematice, a tak necítili velkou potřebu velkých čísel. Občas však používali symbol CCIƆƆ pro 10000 a symbol CCCIƆƆƆ pro číslo 100000 . Poloviny těchto symbolů byly někdy používány k reprezentaci čísel 5000 ( IƆƆ ) a 50000 ( IƆƆƆ ).

Římané se vyhýbali zlomkům stejně tvrdohlavě jako velkým číslům. V praktických úlohách měření nepoužívali zlomky, rozdělující měrnou jednotku obvykle na 12 částí, takže výsledek měření je prezentován jako složené číslo, součet násobků různých jednotek, jak se to dnes dělá, když je délka vyjádřeno v yardech, stopách a palcích. Anglická slova "ounce" ( unce ) a "inch" ( palec ) pocházejí z latinského slova lat.  uncia ( unce ), označující jednu dvanáctinu základní jednotky délky [1] [2] .

jeden já lat.  unus, unum
5 PROTI lat.  quinque
deset X lat.  prosince
padesáti L lat.  Quinquaginta
100 C lat.  procento
500 D lat.  quingenti
1000 M lat.  míle
Arabská notace Římský zápis
jeden já
2 II
3 III
čtyři IV
5 PROTI
6 VI
7 VII
osm VIII
9 IX
deset X
jedenáct XI
12 XII
13 XIII
čtrnáct XIV
patnáct XV
16 XVI
17 XVII
osmnáct XVIII
19 XIX
dvacet XX
třicet XXX
40 XL
padesáti 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 PROTI
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

Chcete-li správně psát velká čísla římskými číslicemi, musíte nejprve zapsat počet tisíců, poté stovek, pak desítek a nakonec jednotek.

V římském číselném systému není žádná nula, ale dříve se nula používala jako nula (ne), nihil (nic) a N (první písmeno těchto slov).

V tomto případě se některá čísla (I, X, C, M) mohou opakovat, ale ne více než třikrát za sebou ; lze je tedy použít k zápisu libovolného přirozeného čísla nejvýše 3999 (MMMCMXCIX). V raných obdobích existovaly známky označující větší čísla - 5 000, 10 000, 50 000 a 100 000 (pak je maximální počet dle zmíněného pravidla 399 999). Při psaní čísel v římské číselné soustavě může být menší číslice vpravo od větší; v tomto případě se k němu přidá. Například číslo 283 v římském jazyce se píše jako CCLXXXIII, tedy 100+100+50+30+3=283. Zde se číslo představující sto opakuje dvakrát a čísla představující deset a jedna se opakují třikrát.

Příklad: číslo 1988. Tisíc M, devět set CM, osm desítek LXXX, osm jednotek VIII. Napišme je společně: MCMLXXXVIII.

Dost často se pro zvýraznění čísel v textu přes ně nakreslila čára: LXIV . Někdy byla čára nakreslena jak nad, tak pod: XXXII  - zejména je obvyklé zvýraznit římské číslice v ruském ručně psaném textu (to se kvůli technické složitosti v typografické sazbě nepoužívá). U jiných autorů by přeškrtnutí mohlo znamenat zvýšení hodnoty obrázku o 1000krát: V = 5000.

Teprve v 19. století se všude zapisovala číslice „čtyřka“ jako „IV“ , dříve se nejčastěji používal záznam „IIII“. Zápis „IV“ však najdeme již v listinách rukopisu Forme of Cury z roku 1390 . Ciferníky hodinek tradičně používají ve většině případů „IIII“ místo „IV“, hlavně z estetických důvodů: tento pravopis poskytuje vizuální symetrii s čísly „VIII“ na opačné straně a obrácené „IV“ je obtížnější číst než "III". Existuje také verze, že IV nebylo na číselníku napsáno, protože IV jsou první písmena latinského jména boha Jupitera (IVPITER).

Menší číslo může být zapsáno vlevo od většího, pak by mělo být odečteno od většího. V tomto případě lze odečítat pouze čísla označující 1 nebo mocniny 10 a jako minuend mohou fungovat pouze dvě nejbližší čísla v číselné řadě k odečítanému (tj. odečítaná, násobená 5 nebo 10). Opakování menšího počtu není povoleno. Existuje tedy pouze šest použití „pravidla odčítání“:

Například číslo 94 bude XCIV = 100 - 10 + 5 - 1 = 94 - takzvané "pravidlo odčítání" (objevilo se v éře pozdní antiky a předtím Římané psali číslo 4 jako IIII a číslo 40 jako XXXX).

Je třeba poznamenat, že jiné metody „odčítání“ nejsou povoleny; tedy číslo 99 by mělo být zapsáno jako XCIX, ale ne jako IC. V dnešní době se však v některých případech používá i zjednodušený zápis římských čísel: například v aplikaci Microsoft Excel můžete při převodu arabských číslic na římské pomocí funkce „ROMAN ()“ použít několik typů reprezentace čísel, od klasických po vysoce zjednodušené (např. číslo 499 lze zapsat jako CDXCIX, LDVLIV, XDIX, VDIV nebo ID). Zjednodušení spočívá v tom, že pro zmenšení libovolné číslice lze nalevo od ní zapsat jakoukoli jinou číslici:

Případy takového zápisu čísel (obvykle let) se často nacházejí v titulcích amerických televizních seriálů. Například pro rok 1998: MIIM místo MCMXCVIII.

Římské číslice lze také použít k zápisu větších tříd čísel. Za tímto účelem je nad čísly, která představují tisíce, umístěna čára a nad čísly, která představují miliony, je umístěna dvojitá čára. Výjimkou je číslo I; místo řádku nahoře je napsáno číslo M a počínaje milionem - jeden řádek shora. Například číslo 123123 by vypadalo takto:

CXXIII CXXIII

A milion je jako já , ale ne s jedním, ale se dvěma rysy v čele: Já

Aplikace

V ruštině se římské číslice používají v následujících případech:

Římské číslice byly v SSSR široce používány při označování data pro označení měsíce roku, například: 11 / III-85 nebo 9.XI.89, to lze vidět na mnoha archivních dokumentech té doby. Obdobným způsobem přes lomítko zapisovali i datum lekce do třídních deníků , např. 24/II. Pro označování dat života a smrti na náhrobcích se často používal speciální formát, kdy se měsíc v roce označoval např. i římskými číslicemi (25. listopadu 1887 ~ 26. ledna 1943). Podobný formát byl používán v lékařských osvědčeních v 70. a 80. letech 20. století.

S přechodem na počítačové zpracování informací se formáty dat založené na římských číslicích prakticky přestaly používat.

V jiných jazycích se rozsah římských číslic může lišit. V západních zemích se číslo letopočtu často píše římskými číslicemi, například na štítech budov a v kreditech video, filmových a televizních produktů [3] .

V moderní Litvě , na dopravních značkách , na výlohách obchodů , na vývěsních štítech podniků mohou římské číslice označovat dny v týdnu .

Unicode

Standard Unicode doporučuje, aby římské číslice byly reprezentovány pomocí jednoduchých latinských znaků [4] . Norma však obsahuje i speciální znaky pro římské číslice jako součást číselných formulářů [ 5 ] ve znakové oblasti s kódy U+2160 až U+2188. Například MCMLXXXVIII může být reprezentován ve tvaru ⅯⅭⅯⅬⅩⅩⅩⅧ. Tento rozsah zahrnuje jak malá, tak velká písmena pro čísla 1 (Ⅰ nebo I) až 12 (Ⅻ nebo XII), včetně kombinovaných glyfů pro složená čísla , jako je 8 (Ⅷ nebo VIII), hlavně pro zajištění kompatibility s východoasijskými znakovými sadami v průmyslových standardech, jako je JIS X 0213 , kde jsou tyto znaky definovány. Kombinované glyfy se používají k reprezentaci čísel, která se dříve skládala z jednotlivých znaků (například Ⅻ místo jejich znázornění jako Ⅹ a Ⅱ). Kromě toho existují glyfy pro archaické [5] formy 1000, 5000, 10 000, velké inverzní C (Ɔ), pozdní 6 (ↅ, podobné řeckému stigmatu : Ϛ), začátek 50 ( ↆ, které vypadá jako šipka směřující dolů ↓⫝⊥ [6] ), 50 000 a 100 000. Je třeba poznamenat, že malé obrácené c, ↄ není zahrnuto do římských číslic, ale je zahrnuto do standardu Unicode jako velké Claudovské písmeno Ↄ.  

Kód 0 jeden 2 3 čtyři 5 6 7 osm 9 A B C D E F
Hodnota [7] jeden 2 3 čtyři 5 6 7 osm 9 deset jedenáct 12 padesáti 100 500 1000
U+2160 Ⅰ
2160 		Ⅱ
2161 		Ⅲ
2162 		Ⅳ
2163 		Ⅴ
2164 		Ⅵ
2165 		Ⅶ
2166 		Ⅷ
2167 		Ⅸ
2168 		Ⅹ
2169 		Ⅺ
216A 		Ⅻ
216B 		Ⅼ
216 °C 		Ⅽ
216D 		Ⅾ
216E 		Č. 216F
U+2170 ⅰ
2170 		ⅱ
2171 		ⅲ
2172 		ⅳ
2173 		ⅴ
2174 		ⅵ
2175 		ⅶ
2176 		ⅷ
2177 		ⅸ
2178 		ⅹ
2179 		ⅺ
217A 		ⅻ
217B 		ⅼ217C
_ 		ⅽ
217D 		ⅾ
217E 		ⅿ
217F
Význam 1000 5000 10 000 100 6 padesáti 50 000 100 000
U+2180 ↀ
2180		 ↁ
2181		 ↂ
2182		 Ↄ
2183		 ↅ
2185		 ↆ
2186		 ↇ
2187		 ↈ
2188

Zobrazení všech těchto znaků vyžaduje software, který podporuje standard Unicode, a písmo , které obsahuje odpovídající glyfy pro tyto znaky (například písmo Universalia ).

Regulární výrazy

Regulární výraz pro kontrolu římských číslic - ^(M{0,3})(D?C{0,3}|C[DM])(L?X{0,3}|X[LC])(V?I{0,3}|I[VX])$[8] V Perlu můžete k vyhledání římských číslic v řetězci použít regulární výraz 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.

Transformace

Pro převod čísel zapsaných arabskými číslicemi na římské se používají speciální funkce.

Například v anglické verzi Microsoft Excel a v jakékoli verzi OpenOffice.org Calc existuje pro toto funkce ROMAN (argument; formulář) , v ruské verzi Microsoft Excel se tato funkce nazývá ROMAN (číslo; formulář) . Volitelný argument "shape" může nabývat hodnot od 0 do 4, stejně jako "False" a "True". Absence argumentu "Form" nebo jeho rovnosti s 0 nebo "True" dává "klasickou" (přísnou) formu transformace; hodnota 4 nebo "False" dává nejvíce zjednodušené; hodnoty 1, 2, 3 dávají varianty přechodné ve zjednodušení. Rozdíly se objevují např. v číslech 45, 49, 495, 499 (první jsou uvedena v rozsahu [1;3999]).

Příklad aplikace funkce ROMAN(číslo; tvar)
formulář 0 jeden 2 3 čtyři
číslo
45 XLV VL VL VL VL
49 XLIX VLIV IL IL IL
495 CDXCV LDVL XDV VD VD
499 CDXCIX LDVLIV XDIX VDIV ID

Neceločíselné hodnoty argumentu "číslo" jsou zaokrouhleny dolů na celé číslo; pokud je poté hodnota větší než 3999 nebo menší než 0, pak funkce vrátí "#Value"; pro hodnotu 0 je vrácena prázdná buňka.


Transformační funkce JavaScriptu 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 ( číslo ) { if ( ! číslo ) return '' ; varret = ' ' ; var i = arab . délka - 1 ; while ( číslo > 0 ) { if ( číslo >= arab [ i ]) { ret += římský [ i ]; číslo -= arab [ i ]; } else { i -- ; } } return ret ; } function romanToArab ( str ) { str = str . toUpperCase (); varret = 0 ; _ var i = arab . délka - 1 ; var pos = 0 ; while ( i >= 0 && pos < str . délka ) { if ( str . substr ( pos , římská [ i ]. délka ) == římská [ i ]) { ret += arab [ i ]; pos += římské [ i ]. délka ; } else { i -- ; } } return ret ; } Podobné funkce v jazyce C (C89): #include <řetězec.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 ( unsigned short int arab ) { statický char roman [ 80 ]; const int m = sizeof ( arabar ) / sizeof ( int ) -1 , arabmax = arabar [ m ]; const char romanmax = romanar [ m ][ 0 ]; int i , n ; if ( ! arab ) { * římský = 0 ; návrat římský ; } i = 0 _ while ( arab > arabmax ) { roman [ i ++ ] = romanmax ; arab -= arabmax ; } n = m ; while ( arab > 0 ) { if ( arab >= arabština [ n ]) { římský [ i ++ ] = románský [ n ][ 0 ]; pokud ( n & 1 ) římský [ i ++ ] = románský [ n ][ 1 ]; arab -= arabar [ n ]; } jinak n- ; _ } římské [ i ] = 0 ; návrat římský ; } unsigned short int roman2arab ( char * roman ) { const int m = sizeof ( arabština ) / sizeof ( int ) -1 ; nesignováno short int arab ; int len ​​​​, n , i , pir ; len = strlen ( římský ); arab = 0 ; n = m ; i = 0 _ while ( n >= 0 && i < len ) { pir = n & 1 ; if ( římský [ i ] == románský jazyk [ n ][ 0 ] && ( ! pir || římský jazyk [ i + 1 ] == románský jazyk [ n ][ 1 ])) { arab += arabar [ n ]; i + = 1 + pir ; } jinak n- ; _ } vrátit arab ; } Program pro převod arabských číslic na římské ve Scale : val arabar = pole ( 1 , 4 , 5 , 9 , 10 , 40 , 50 , 90 , 100 , 400 , 500 , 900 , 1000 ) val romanar = pole ( "I" , "IV" , " , "IX V" " , "X" , "XL" , "L" , "XC" , "C" , "CD" , "D" , "CM" , "M" ) def arab2roman ( arab : Int , acc : String = " " , n : Int = arabar . délka - 1 ): Řetězec = if ( arab == 0 ) acc else if ( arab >= arabar ( n )) arab2roman ( arab - arabar ( n ), acc + romanar ( n ), n ) else arab2roman ( arab , acc , n - 1 ) // arab2roman(4933) = MMMMCMXXXIII Program pro převod arabských číslic na římská čísla a naopak v jazyce Pascal [9] typ str2 = řetězec [ 2 ] ; const Rims : pole [ 1 .. 14 ] z str2 = ( 'M' , 'CM' , 'D' , 'CD' , 'C' , 'XC' , 'L' , 'XL' , 'X' , 'IX' , 'V' , 'IV' , 'I' , ' ' ) ; Arab : pole [ 1 .. 14 ] celého čísla = ( 1000 , 900 , 500 , 400 , 100 , 90 , 50 , 40 , 10 , 9 , 5 , 4 , 1 , 0 ) ; var N , NI , I , J : celé číslo ; S : řetězec _ funkce Arab2Rim ( N : celé číslo ) : řetězec ; var S : řetězec ; I : celé číslo ; begin S := '' ; I := 1 ; while N > 0 do begin while Arab [ I ] <= N do begin S := S + Rims [ I ] ; N := N - Arab [ I ] konec ; I := I + 1 konec ; Arab2Rim := S konec ; function Rim2Arab ( S : string ) : integer ; var I , N : celé číslo ; začít I := 1 ; N = 0 _ while S <> '' do begin while Rims [ I ] = Copy ( S , 1 , Length ( Rims [ I ]) ) do begin S := Copy ( S , 1 + Length ( Rims [ I ]) , 255 ) ; N := N + Arab [ I ] konec ; I := I + 1 konec ; Rim2Arab := N konec ; begin WriteLn ( 'Překlad z arabštiny na římské číslice. 1999 B_SA' ) ; { Write('Zadejte číslo pro převod:'); ReadLn(N);} pro NI := 26 až 46 do WriteLn ( NI , ' = ' , Arab2Rim ( NI ) , ' zpět ' , Rim2Arab ( Arab2Rim ( NI ) ) ) ; konec . Funkce pro převod arabského na římské číslo v Pascalu [10] function Arab2Roman ( arab : integer ) : string ; var i : celé číslo ; d : celé číslo ; arab_str : řetězec _ arab_len : integer ; begin Vysledek := '' ; arab_str := IntToStr ( arab ) ; arab_len := Délka ( arab_str ) ; for i := 0 to arab_len - 1 do begin d := StrToInt ( String ( arab_str [ arab_len - i ])) ; if ( d + 1 ) mod 5 = 0 then Result := Copy ( 'IXCM' , 1 + i , 1 ) + Copy ( 'VXLCDM' , i * 2 + ( d + 1 ) div 5 , 1 ) + Result else Výsledek := Kopírovat ( 'VLD' , 1 + i , d div 5 ) + Kopírovat ( 'IIIXXXCCCMMM' , 1 + i * 3 , ( d mod 5 )) + Výsledek ; konec ; konec ; Funkce konverze z arabštiny na římský jazyk v BASICu (nejkratší kód) [11] 10 ZADEJTE "ARABSKÉ ČÍSLO: " ; A $ 20 PRO I = 0 DO LEN ( A $ ) -1 30 X = VAL ( MID $ ( A $ , LEN ( A $ ) - I , 1 )) 40 POKUD X = 4 NEBO X = 9 POTOM B $ = MID$ ( "IXCM" , I + 1 , 1 ) + MID $ ( "VXLCDM" , I * 2 + ( X + 1 ) / 5 , 1 ) + B $ 50 POKUD X < 4 POTOM B$ = MID $ ( "IIIXXXCCCMMM" , 1 + I * 3 , X ) + B$ ELSE , POKUD X > 4 A X < 9 POTOM B$ = MID$ ( "VLD" , I + 1 , 1 ) + MID$ ( "IIIXXXCCCMMM" , 1 + I * 3 , X -5 ) + B$ 60 DALŠÍ I 70 TISK "ŘÍMSKÉ ČÍSLO: " ; B$ Funkce pro převod arabského čísla (v tomto případě 1999) na římské na XPath string-join( za $num in (1999) vrátit se( ('','M','MM','MMM')[($num idiv 1000) mod 10+1], ('','C','CC','CCC','CD','D','DC','DCC','DCCC','CM')[($num idiv 100) mod 10+ jeden], ('','X','XX','XXX','XL','L','LX','LXX','LXXX','XC')[($num idiv 10) mod 10+ jeden], ('','I','II','III','IV','V','VI','VII','VIII','IX')[$num mod 10+1] ), '') Funkce pro převod arabského čísla (v tomto případě 1999) na římské v Perlu používat přísný ; používat varování ; moje $n = 1999 ; moje $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) ] ]; moje $i = 0 ; moje @res = (); push @res , ( $nums -> [ $i ++ ][ ( $n % 10 , $n = int ( $n / 10 ))[ 0 ] ]) pro 0 .. 3 ; tisk zpětně @res ; Třída pro převod arabského čísla (od 1 do 3999) na římské na Jávě import java.util.* ; public class IntegerConverter { public static String intToRoman ( int number ) { if ( číslo >= 4000 || číslo <= 0 ) return null ; Výsledek StringBuilder = new StringBuilder (); for ( Celočíselný klíč : jednotky . sestupně Sada klíčů ()) { while ( číslo >= klíč ) { číslo -= klíč ; výsledek . připojit ( jednotky . získat ( klíč )); } } vrátí výsledek . toString (); } private static final NavigableMap < Integer , String > jednotky ; static { NavigableMap < Integer , String > initMap = new TreeMap <> (); initMap . vložit ( 1000 , "M" ); initMap . vložit ( 900 , "CM" ); initMap . vložit ( 500 , "D" ); initMap . vložit ( 400 , "CD" ); initMap . vložit ( 100 , "C" ); initMap . dát ( 90 , "XC" ); initMap . vložit ( 50 , "L" ); initMap . vložit ( 40 , "XL" ); initMap . vložte ( 10 , "X" ); initMap . vložit ( 9 , "IX" ); initMap . vložte ( 5 , "V" ); initMap . vložit ( 4 , "IV" ); initMap . vložit ( 1 , "já" ); jednotky = Sbírky . unmodifiableNavigableMap ( initMap ); } } Rozšiřující třída pro převod latinky do arabštiny a naopak na CSharp /// <summary> /// Třída je navržena tak, aby převáděla arabská čísla na římská čísla a naopak /// </summary> /// <remarks> /// <para>Třída zpočátku obsahuje latinskou abecedu čísla, která dokážou určit arabská čísla od 1 do 39999</para> /// <para>Pokud chcete rozsah rozšířit, můžete definovat další zápisy římských číslic pomocí /// pole <viz cref="BasicRomanNumbers"/> BasicRomanNumbers</remarks> public static class RomanNumber { /// <summary> /// Abeceda základních římských číslic /// <para>Abeceda je vytvořena jako slovník. Klíčem slovníku je arabské číslo (int), hodnota je jeho odpovídající /// římské číslo (řetězec)</para> /// </summary> /// <remarks> /// <para>Obsahuje římské symboly pro arabská čísla 1 *,4*,5*,9* - kde "*" představuje 0...N nul</para> /// <para>Při vytvoření obsahuje označení čísel od 1 do 10000 (I...ↂ ) Protože se jeden znak nemůže /// vyskytovat více než třikrát v římském čísle, můžete zpočátku převést čísla od 1 do 39999 do římského formátu.</para> /// <para>Pokud chcete-li pracovat s velkým počtem římských číslic, musíte do seznamu přidat /// další označení začínající od 40 000 bez přeskakování prvků 1*,4*,5*,9*.</para> /// </remarks> public static SortedList < int , string > Základní římská čísla { get ; nastavit ; } static RomanNumber () { BasicRomanNumbers = new SortedList < int , string >( 17 ); Základní římská čísla . Přidat ( 1 , "I" ); Základní římská čísla . Přidat ( 4 , "IV" ); Základní římská čísla . Přidat ( 5 , "V" ); Základní římská čísla . Přidat ( 9 , "IX" ); Základní římská čísla . Přidat ( 10 , "X" ); Základní římská čísla . Přidat ( 40 , "XL" ); Základní římská čísla . Přidat ( 50 , "L" ); Základní římská čísla . Přidat ( 90 , "XC" ); Základní římská čísla . Přidat ( 100 , "C" ); Základní římská čísla . Přidat ( 400 , "CD" ); Základní římská čísla . Přidat ( 500 , "D" ); Základní římská čísla . Přidat ( 900 , "CM" ); Základní římská čísla . Přidat ( 1000 , "M" ); Základní římská čísla . Přidat ( 4000 , "Mↁ" ); Základní římská čísla . Přidat ( 5000 , "ↁ" ); Základní římská čísla . Přidejte ( 9000 , "Mↂ" ); Základní římská čísla . Přidat ( 10000 , "ↂ" ); } /// <summary> /// Vypočítá maximální možnou římskou číslici pro aktuální abecedu římských číslic. /// </summary> /// <returns>Maximální možné římské číslo</returns> public static uint MaxRomanNumber () { int lastNumber = BaseRomanNumbers . klíče . Poslední (); int čísloNoZeros = int . Parse ( lastNumber . ToString (). Nahradit ( '0' , '\0' )); int pre = 0 ; switch ( čísloBez nul ) { case 1 : previous = lastNumber * 4-1 ; _ zlomit ; case 4 : case 9 : previous = lastNumber ; zlomit ; případ 5 : předběžné = posledníČíslo + posledníČíslo / 5 * 3 ; zlomit ; výchozí : break ; } vrátit uint . Parse ( pre . ToString ( ). Nahradit ( '0' , '9' ));; } /// <summary> /// Převede celé číslo na římské číslo /// </summary> /// <param name="Arab number">Arabské číslo, které se má převést na římský zápis</param> // / < výjimka cref="ArgumentOutOfRangeException">Vyvolá se, když je jako parametr předáno číslo rovné "0" /// nebo číslo větší než maximální římské číslo.</exception> /// <returns>Řetězec představující Roman number</returns> public static string ArabicRoman ( this int numberArab ) { StringBuilder numberRoman = new StringBuilder (); //Vylučte znak "-" z arabského čísla a udělejte z něj první znak římského čísla if ( čísloArab < 0 ) { čísloŘímské . připojit ( "-" ); cisloArab = - cisloArab ; } if ( numberArab == 0 ) throw new ArgumentOutOfRangeException ( "numberArab" , numberArab , "Neplatná hodnota argumentu: římské číslice se nemohou rovnat\"0\"" ); else if ( numberArab > MaxRomanNumber ()) throw new ArgumentOutOfRangeException ( "numberArab" , numberArab , string . Format ( "Neplatná hodnota argumentu: Nelze zadat římské číslo větší než {0}" , MaxRomanNumber ())); //Rozloží arabské číslo na římská čísla a sloučí je do jednoho řetězce var requiredBasicRomanNumbers = od do v BasicRomanNumbers . Klávesy kam < = čísloArabské pořadí podle sestupného výběru do ; foreach ( int current in requiredBaseRomanNumbers ) { while (( numberArab / current ) >= 1 ) { numberArab - = current ; číslo Roman . Append ( BaseRomanNumbers [ tech ]); } } návratové číslo Roman . ToString (); } /// <summary> /// Převede římské číslo na arabské /// </summary> /// <param name="Roman number">Římské číslo, které má být převedeno na typ int</param> /// <exception cref="FormatException">Vyvolá se, když je jako parametr předáno jiné než římské číslo</exception> /// <returns>Celé číslo představující arabský zápis římského čísla</returns> public static int RomanToArabic ( tento řetězec numberRoman ) { int cisloArab = 0 ; sbyte zápor = 1 ; řetězec římský = čísloŘímský . oříznout (); if ( římská [ 0 ] == '-' ) { zápor = - 1 ; řím = řím . podřetězec ( 1 ); } StringBuilder Šablona RomanNumber = new StringBuilder (); foreach ( int to in Base Roman Numbers . Keys ) { int index = Base Roman Numbers . klíče . IndexOf ( k ); kvantifikátor řetězce = "?" ; if ( index == 0 || ( index % 4 ) == 0 ) kvantifikátor = "{0,3}" ; šablona římského čísla . Vložte ( 0 , řetězec . Formát ( "(?<{0}>({1}){2})?" , do . ToString (), Základní římská čísla [ do ], kvantifikátor )); } //Ignorovat velikost písmen + shoda musí začínat na začátku řetězce RomanNumber template . Vložit ( 0 , "(?i)^" ); //Shoda musí nastat na konci řetězce vzor RomanNumber . připojit ( "$" ); // Zjednodušená kontrola. Nekontroluje chyby, jako je IVII, pokud (! Regex . IsMatch ( římská , římská čísla vzor . ToString ())) vyvolá novou FormatException ( string . Format ( "Text \"{0}\" není římské číslo" , římská číslice )); Číslo shody = Regex . Shoda ( Řím , Vzor RomanNumber . ToString ()); foreach ( int to v základních římských číslicích . Klíče ) { numberArab += number . Skupiny [ do . ToString ()]. Délka / Základní římská čísla [ až ]. Délka * až ; } návratové čísloArab * záporné ; } }

Poznámky

  1. ↑ Číslice a číselné soustavy Archivováno 22. listopadu 2018 na Wayback Machine . Online encyklopedie po celém světě.
  2. ↑ M. Ya. Vygodsky "Příručka elementární matematiky" Moskva 1958 Státní nakladatelství fyzikální a matematické literatury. strana 62
  3. ↑ Beckhamova cesta do Romana Archivováno 1. května 2020 na Wayback Machine // BBC , 17. dubna 2002
  4. ↑ Unicode Standard, 15.3 Archivováno 27. června 2010 na Wayback Machine („Pro většinu účelů je vhodnější skládat římské číslice ze sekvencí příslušných latinských písmen.“)
  5. ↑ 12 číselných formulářů Unicode . Získáno 30. března 2009. Archivováno z originálu 25. března 2009.
  6. ↑ Perry, David J. Návrh na přidání dalších starověkých římských postav do UCS Archivováno 22. června 2011 na Wayback Machine .
  7. ↑ Pro první dva řádky
  8. ↑ Kapitola 31. Římský číselný zápis :: Nápady na implementaci . Datum přístupu: 15. října 2015. Archivováno z originálu 18. listopadu 2015.
  9. ↑ „Věda a život“ N12 1986 str. 95, V. Ptitsyn, Moskva
  10. ↑ Autor - Kuzněcov Evgeny A.
  11. ↑ Autor - Evgeny A. Kuzněcov, 1992

Viz také