Roomalaiset numerot

Kokeneet kirjoittajat eivät ole vielä tarkistaneet sivun nykyistä versiota, ja se voi poiketa merkittävästi 12. lokakuuta 2022 tarkistetusta versiosta . tarkastukset vaativat 2 muokkausta .
Numerojärjestelmät kulttuurissa
indoarabia
arabia
tamili
burma 		Khmer
Lao
Mongolian
Thai
Itä-Aasialainen
Kiinalainen
japanilainen
Suzhou
korealainen 		Vietnamilaiset
laskukepit
Aakkosellinen
Abjadia
armenia
Aryabhata
kyrillinen
kreikka 		Georgian
Etiopian
juutalainen
Akshara Sankhya
muu
Babylonian
egyptiläinen
etruski
roomalainen
Tonava 		Ullakko
Kipu
Mayan
Egeanmeren
KPPU-symbolit
paikallinen
2 , 3 , 4 , 5 , 6 , 8 , 10 , 12 , 16 , 20 , 60
Nega-asentoinen
symmetrinen
sekajärjestelmät
Fibonacci
ei-asentoinen
Yksikkö (yksittäinen)

Roomalaiset numerot  ovat numeroita , joita muinaiset roomalaiset käyttivät ei-sijaintinumerojärjestelmässään .

Luonnolliset luvut kirjoitetaan toistamalla näitä numeroita. Samanaikaisesti, jos suurempi luku tulee pienemmän eteen, ne lasketaan yhteen (lisäysperiaate), mutta jos pienempi tulee ennen suurempaa, niin pienempi vähennetään suuremmasta (vähennysperiaate). Viimeinen sääntö koskee vain saman kuvion nelinkertaisen toiston välttämistä.

Roomalaiset numerot ilmestyivät 500 eKr . etruskeilta (katso etruskien aakkoset ), jotka saattoivat lainata joitakin numeroita proto-kelteiltä .

Numerot ja numeroiden merkintä

Roomalainen numeroiden merkintätapa tunnetaan nyt paremmin kuin mikään muu vanha lukujärjestelmä. Tämä ei selity niinkään Rooman järjestelmän erityisillä ansioilla, vaan sillä valtavalla vaikutuksella, joka Rooman valtakunnalla oli suhteellisen lähimenneisyydessä. Etruskit , jotka valloittivat Rooman 700-luvulla eKr. e. sai vaikutteita itäisen Välimeren kulttuureista. Tämä selittää osittain roomalaisen ja attikan lukujärjestelmän perusperiaatteiden samankaltaisuuden. Molemmat järjestelmät olivat desimaalilukuja, vaikka numerolla viisi oli erityinen rooli molemmissa numerojärjestelmissä. Molemmat järjestelmät käyttivät toistuvia merkkejä kirjoittaessaan numeroita.

Vanhat roomalaiset symbolit numeroille 1, 5, 10, 100 ja 1000 ( hindo-arabialainen merkintä ) olivat symbolit I, V, X, Θ (tai ⊕ , tai ⊗ ) ja Φ (tai ↀ tai CIƆ ) , vastaavasti. Vaikka näiden symbolien alkuperäisestä merkityksestä on kirjoitettu paljon, niille ei vieläkään ole tyydyttävää selitystä. Yhden laajalle levinneen teorian mukaan roomalainen numero V kuvaa avointa kättä, jossa on neljä sormea ​​painettuina yhteen ja peukalo ojennettuna; symboli X, saman teorian mukaan, kuvaa kahta ristissä olevaa kättä tai kaksinumeroista V:tä. Numeroiden 100 ja 1000 symbolit ovat todennäköisesti peräisin kreikkalaisista kirjaimista Θ ja φ. Ei tiedetä, ovatko myöhemmät nimitykset C ja M johdettu vanhemmista roomalaisista kirjaimista vai ovatko ne akrofonisesti sukua latinalaisten sanojen alkukirjaimiin, jotka tarkoittavat 100 (centum) ja 1000 (mille). Uskotaan, että roomalainen symboli numerolle 500, kirjain D , on peräisin puolesta vanhasta 1000-symbolista. Paitsi että useimmat roomalaiset symbolit eivät todennäköisesti olleet akrofonisia ja että numeroiden 50 ja 500 välimerkit eivät olleet yhdistelmiä. symboleista numeroille 5 ja 10 tai 5 ja 100, muu roomalainen numerojärjestelmä muistutti ullakkoa. Roomalaiset käyttivät usein vähennysperiaatetta, joten joskus he käyttivät IX:ää VIIII:n sijasta ja XC:tä LXXXX:n sijaan; verrattain myöhemmin symboli IV IIII:n sijaan. Siksi nyt kaikki roomalaiset numerot voidaan kirjoittaa isoilla latinalaisilla kirjaimilla.

Yleensä roomalaiset eivät olleet taipuvaisia ​​tekemään matematiikkaa, joten he eivät kokeneet suurta tarvetta suurille numeroille. He käyttivät kuitenkin toisinaan symbolia CCIƆƆ 10000:lle ja symbolia CCCIƆƆ numerolle 100000 . Näiden symbolien puolikkaita käytettiin joskus edustamaan numeroita 5000 ( IƆƆ ) ja 50 000 ( IƆƆƆ ).

Roomalaiset välttelivät murto-osia yhtä itsepäisesti kuin suuria lukuja. Käytännön mittaustehtävissä he eivät käyttäneet murtolukuja jakoivat mittayksikön yleensä 12 osaan, jolloin mittauksen tulos esitetään yhdistelmälukuna, eri yksiköiden kerrannaisten summana, kuten nykyään tehdään, kun pituus on ilmaistuna jaardeina, jalkoina ja tuumina. Englannin sanat "ounce" ( unssi ) ja "inch" ( tuumaa ) tulevat latinan sanasta lat.  uncia ( unssi ), joka tarkoittaa kahdestoistaosaa pituuden perusyksiköstä [1] [2] .

yksi minä lat.  unus, unum
5 V lat.  quinque
kymmenen X lat.  decem
viisikymmentä L lat.  quinquaginta
100 C lat.  prosenttia
500 D lat.  quingenti
1000 M lat.  mille
Arabialainen merkintä Roomalainen merkintä
yksi minä
2 II
3 III
neljä IV
5 V
6 VI
7 VII
kahdeksan VIII
9 IX
kymmenen X
yksitoista XI
12 XII
13 XIII
neljätoista XIV
viisitoista XV
16 XVI
17 XVII
kahdeksantoista XVIII
19 XIX
kaksikymmentä XX
kolmekymmentä XXX
40 XL
viisikymmentä 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 MV ; _ ↀↁ; 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

Jotta voit kirjoittaa oikein suuria lukuja roomalaisin numeroin, sinun on ensin kirjoitettava muistiin tuhansien, sitten satojen, sitten kymmenien ja lopuksi ykkösten lukumäärä.

Roomalaisessa numerojärjestelmässä ei ole nollaa, mutta nollaa käytettiin aiemmin numeroina nulla (ei), nihil (ei mitään) ja N (näiden sanojen ensimmäinen kirjain).

Tässä tapauksessa jotkin numerot (I, X, C, M) voidaan toistaa, mutta enintään kolme kertaa peräkkäin ; joten niitä voidaan käyttää minkä tahansa luonnollisen luvun kirjoittamiseen enintään 3999 (MMMCMXCIX). Alkuaikoina oli merkkejä suurempien lukujen osoittamisesta - 5000, 10 000, 50 000 ja 100 000 (siis enimmäismäärä mainitun säännön mukaan on 399 999). Kun kirjoitat numeroita roomalaisessa numerojärjestelmässä, pienempi numero voi olla suuremman oikealla puolella; tässä tapauksessa se lisätään siihen. Esimerkiksi roomalainen luku 283 kirjoitetaan muodossa CCLXXXIII, eli 100+100+50+30+3=283. Tässä sataa edustava luku toistetaan kahdesti, ja numerot, jotka edustavat kymmentä ja yhtä, toistetaan kolme kertaa.

Esimerkki: numero 1988. Tuhat M, yhdeksänsataa CM, kahdeksan kymmenen LXXX, kahdeksan yksikköä VIII. Kirjoitetaan ne yhdessä: MCMLXXXVIII.

Melko usein numeroiden korostamiseksi tekstissä niiden päälle vedettiin viiva: LXIV . Joskus viiva piirrettiin sekä ylä- että alapuolelle: XXXII  - erityisesti venäläisessä käsinkirjoitetussa tekstissä on tapana korostaa roomalaisia ​​numeroita (tätä ei käytetä typografisessa ladossa teknisen monimutkaisuuden vuoksi). Muille kirjoittajille yliviivaus voisi merkitä luvun arvon kasvua 1000-kertaiseksi: V = 5000.

Vasta 1800-luvulla numero "neljä" kirjoitettiin kaikkialla "IV" :ksi , sitä ennen käytettiin useimmiten tietuetta "IIII". Merkintä "IV" löytyy kuitenkin jo vuodelta 1390 peräisin olevan Forme of Curyn käsikirjoituksen asiakirjoista . Kellotauluissa on perinteisesti käytetty kirjaa "IIII" "IV":n sijaan useimmissa tapauksissa, lähinnä esteettisistä syistä: tämä oikeinkirjoitus antaa visuaalisen symmetrian vastakkaisella puolella olevien numeroiden "VIII" kanssa, ja käänteinen "IV" on vaikeampi lukea kuin "III". On myös versio, että IV ei kirjoitettu kellotauluun, koska IV on jumalan Jupiterin latinankielisen nimen (IVPITER) ensimmäiset kirjaimet.

Pienempi luku voidaan kirjoittaa suuremman vasemmalle puolelle, sitten se tulee vähentää suuremmasta. Tässä tapauksessa vain numerot, jotka merkitsevät 1:tä tai 10:n potenssit, voidaan vähentää, ja vain kaksi lähintä numerosarjan numeroa vähennetylle (eli vähennetty, kerrottuna 5:llä tai 10:llä) voivat toimia minuutteina. Pienemmän määrän toistot eivät ole sallittuja. Näin ollen "vähennyssäännöllä" on vain kuusi käyttötapaa:

Esimerkiksi numero 94 on XCIV = 100 - 10 + 5 - 1 = 94 - niin sanottu "vähennyssääntö" (ilmittyi myöhäisen antiikin aikakaudella, ja ennen sitä roomalaiset kirjoittivat luvun 4:ksi IIII, ja numero 40 muodossa XXXX).

On huomattava, että muut "vähennysmenetelmät" eivät ole sallittuja; siis numero 99 tulee kirjoittaa XCIX, mutta ei IC. Nykyään kuitenkin joissakin tapauksissa käytetään myös roomalaisten numeroiden yksinkertaistettua merkintää: esimerkiksi Microsoft Excelissä , kun arabialaiset numerot muunnetaan roomalaiseksi "ROMAN ()" -funktiolla, voit käyttää useita lukujen esitystyyppejä, klassisesta erittäin yksinkertaistettuun (esimerkiksi numero 499 voidaan kirjoittaa muodossa CDXCIX, LDVLIV, XDIX, VDIV tai ID). Yksinkertaistettuna on, että minkä tahansa numeron pienentämiseksi mikä tahansa muu numero voidaan kirjoittaa sen vasemmalle puolelle:

Tapauksia, joissa numeroita (yleensä vuosia) merkitään, löytyy usein yhdysvaltalaisista televisiosarjoista. Esimerkiksi vuodelle 1998: MIIM MCMXCVIII:n sijaan.

Roomalaisia ​​numeroita voidaan käyttää myös suurempien lukuluokkien kirjoittamiseen. Tätä varten viiva asetetaan niiden lukujen yläpuolelle, jotka edustavat tuhansia, ja kaksoisviiva sijoitetaan miljoonia edustavien lukujen yläpuolelle. Poikkeuksena on numero I; yläpuolella olevan rivin sijasta kirjoitetaan numero M, ja miljoonasta alkaen - yksi rivi ylhäältä. Esimerkiksi numero 123123 näyttäisi tältä:

CXXIII CXXIII

Ja miljoona on kuin minä , mutta ei yhdellä, vaan kahdella piirteellä päässä: minä

Sovellus

Venäjällä roomalaisia ​​numeroita käytetään seuraavissa tapauksissa:

Roomalaisia ​​numeroita käytettiin laajalti Neuvostoliitossa ilmoitettaessa päivämäärää vuoden kuukauden ilmaisemiseksi , esimerkiksi: 11 / III-85 tai 9.XI.89, tämä näkyy monissa noiden aikojen arkistoasiakirjoissa. Samalla tavalla vinoviivalla kirjoitettiin myös oppitunnin päivämäärä luokkapäiväkirjaan , esimerkiksi 24/II. Elämän ja kuoleman päivämäärän merkitsemiseksi hautakiviin käytettiin usein erityistä muotoa, jossa vuoden kuukausi merkittiin myös roomalaisilla numeroilla, esimerkiksi (25.11.1887 - 26.1.1943). Samanlaista muotoa käytettiin lääkärintodistuksissa 1970- ja 1980-luvuilla.

Kun siirryttiin tietojenkäsittelyyn tietokoneella , roomalaisiin numeroihin perustuvat päivämäärämuodot ovat käytännössä jääneet pois käytöstä.

Muilla kielillä roomalaisten numeroiden laajuus voi vaihdella. Länsimaissa vuosiluku kirjoitetaan usein roomalaisin numeroin, esimerkiksi rakennusten päätyihin sekä video-, elokuva- ja televisiotuotteiden krediitteihin [3] .

Nykyaikaisessa Liettuassa roomalaiset numerot voivat osoittaa viikonpäivät liikennemerkeissä , näyteikkunoissa , yritysten kylteissä .

Unicode

Unicode - standardi suosittelee, että roomalaiset numerot esitetään latinalaisilla merkeillä [4] . Standardi sisältää kuitenkin myös erikoismerkkejä roomalaisille numeroille osana numerolomakkeita [ 5 ] merkkialueella , jonka koodit ovat U+2160–U+2188. Esimerkiksi MCMLXXXVIII voidaan esittää muodossa ⅯⅭⅯⅬⅩⅩⅩⅧ. Tämä valikoima sisältää sekä pienet että isot numerot numeroille 1 (Ⅰ tai I) - 12 (Ⅻ tai XII), mukaan lukien yhdistetyt glyfit yhdistetyille numeroille , kuten 8 (Ⅷ tai VIII), pääasiassa yhteensopivuuden varmistamiseksi Itä-Aasian merkistöjen kanssa. teollisuusstandardeissa, kuten JIS X 0213 , joissa nämä merkit on määritelty. Yhdistettyjä kuvioita käytetään esittämään numeroita, jotka aiemmin koostuivat yksittäisistä merkeistä (esimerkiksi Ⅻ sen sijaan, että ne olisivat Ⅹ ja Ⅱ). Lisäksi on olemassa kuvioita arkaaisille [5] muodoille 1000, 5000, 10 000, iso käänteiskirjain C (Ɔ), myöhäinen 6 (ↅ, samanlainen kuin kreikkalainen stigma : Ϛ), alkuvuosi 50 ( ↆ, joka näyttää nuolelta osoittaa alaspäin ↓⫝⊥ [6] ), 50 000 ja 100 000. On huomattava, että pieni kääntöpuoli c, ↄ ei sisälly roomalaisiin numeroihin, mutta se sisältyy Unicode-standardiin isona Claudian-kirjaimena Ↄ .  

Koodi 0 yksi 2 3 neljä 5 6 7 kahdeksan 9 A B C D E F
Arvo [7] yksi 2 3 neljä 5 6 7 kahdeksan 9 kymmenen yksitoista 12 viisikymmentä 100 500 1000
U+2160 Ⅰ
2160 		Ⅱ
2161 		Ⅲ
2162 		Ⅳ
2163 		Ⅴ
2164 		Ⅵ
2165 		Ⅶ
2166 		Ⅷ
2167 		Ⅸ
2168 		Ⅹ
2169 		Ⅺ
216A 		Ⅻ
216B 		Ⅼ
216C 		Ⅽ
216D 		Ⅾ
216E 		nro 216F
U+2170 ⅰ
2170 		ⅱ
2171 		ⅲ
2172 		ⅳ
2173 		ⅴ
2174 		ⅵ
2175 		ⅶ
2176 		ⅷ
2177 		ⅸ
2178 		ⅹ
2179 		ⅺ
217A 		ⅻ
217B 		ⅼ217C
_ 		ⅽ
217D 		ⅾ
217E 		ⅿ
217F
Merkitys 1000 5000 10 000 100 6 viisikymmentä 50 000 100 000
U+2180 ↀ
2180		 ↁ
2181		 ↂ
2182		 Ↄ
2183		 ↅ
2185		 ↆ
2186		 ↇ
2187		 ↈ
2188

Kaikkien näiden merkkien näyttäminen vaatii ohjelmiston, joka tukee Unicode-standardia, ja fontin , joka sisältää vastaavat kuviot näille merkeille (esimerkiksi Universalia - fontti ).

Säännölliset lausekkeet

Säännöllinen lauseke roomalaisten numeroiden tarkistamiseen - ^(M{0,3})(D?C{0,3}|C[DM])(L?X{0,3}|X[LC])(V?I{0,3}|I[VX])$[8] Perlissä voit käyttää säännöllistä lauseketta roomalaisten numeroiden etsimiseen merkkijonostam/\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 .

Muutos

Arabialaisilla numeroilla kirjoitettujen numeroiden muuttamiseksi roomalaiseksi käytetään erikoistoimintoja.

Esimerkiksi Microsoft Excelin englanninkielisessä versiossa ja missä tahansa OpenOffice.org Calcin versiossa on ROMAN (argumentti; lomake) -funktio tätä varten , Microsoft Excelin venäläisessä versiossa tätä toimintoa kutsutaan nimellä ROMAN (numero; lomake). . Valinnainen argumentti "muoto" voi ottaa arvot välillä 0 - 4, sekä "False" ja "True". Argumentin "Form" puuttuminen tai sen yhtäläisyys 0:n tai "True" kanssa antaa muunnoksen "klassisen" (tiukan) muodon; arvo 4 tai "False" antaa yksinkertaisimman; arvot 1, 2, 3 antavat muunnelmia tiukkuuden yksinkertaistamisen välivaiheessa. Erot näkyvät esimerkiksi numeroissa 45, 49, 495, 499 (ensimmäiset on merkitty alueella [1;3999]).

Esimerkki toimintosovelluksesta ROMAN(numero; muoto)
lomake 0 yksi 2 3 neljä
määrä
45 XLV VL VL VL VL
49 XLIX VLIV IL IL IL
495 CDXCV LDVL XDV VD VD
499 CDXCIX LDVLIV XDIX VDIV ID

Argumentin "luku" arvot, jotka eivät ole kokonaislukuja, pyöristetään alaspäin kokonaisluvuksi; jos sen jälkeen arvo on suurempi kuin 3999 tai pienempi kuin 0, niin funktio palauttaa "#Arvo"; arvolle 0 palautetaan tyhjä solu.


JavaScript -muunnosfunktiot 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 ( numero ) { if ( ! numero ) return '' ; varret = ' ' ; var i = arabia . pituus - 1 ; while ( numero > 0 ) { if ( numero >= arabi [ i ]) { ret += roomalainen [ i ]; numero -= arabi [ i ]; } else { i -- ; } } return ret ; } function romanToArab ( str ) { str = str . isot kirjaimet (); varret = 0 ; _ var i = arabia . pituus - 1 ; var pos = 0 ; while ( i >= 0 && pos < str . pituus ) { if ( str . substr ( pos , room [ i ]. pituus ) == roomalainen [ i ]) { ret += arabi [ i ]; pos += roomalainen [ i ]. pituus ; } else { i -- ; } } return ret ; } Samanlaisia ​​toimintoja C-kielellä (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 ( allekirjoittamaton lyhyt int arab ) { staattinen char room [ 80 ]; const int m = koko ( arabar ) / koko ( int ) -1 , arabmax = arabar [ m ]; const char romanmax = roomalainen [ m ][ 0 ]; int i , n ; if ( ! arabi ) { * roomalainen = 0 ; paluu roomalainen ; } i = 0_ _ while ( arabi > arabmax ) { roman [ i ++ ] = romanmax ; arabi - = arabmax ; } n = m ; while ( arabi > 0 ) { if ( arabi >= arabar [ n ]) { roomalainen [ i ++ ] = roomalainen [ n ][ 0 ]; jos ( n & 1 ) roomalainen [ i ++ ] = roomalainen [ n ][ 1 ]; arabi - = arabar [ n ]; } muuta n- ; _ } roomalainen [ i ] = 0 ; paluu roomalainen ; } allekirjoittamaton lyhyt int roman2arab ( char * roman ) { const int m = sizeof ( arabar ) / sizeof ( int ) -1 ; allekirjoittamaton lyhyt int arabi ; int len ​​, n , i , pir ; len = strlen ( roomalainen ); arabi = 0 ; n = m ; i = 0_ _ while ( n >= 0 && i < len ) { pir = n & 1 ; if ( rooma [ i ] == roomalainen [ n ][ 0 ] && ( ! pir || roomalainen [ i + 1 ] == roomalainen [ n ][ 1 ])) { arabi += arabar [ n ]; i += 1 + pir ; } muuta n- ; _ } paluu arabi ; } Ohjelma arabialaisten numeroiden muuttamiseksi latinalaisiksi Scalassa : val arabar = Array ( 1 , 4 , 5 , 9 , 10 , 40 , 50 , 90 , 100 , 400 , 500 , 900 , 1000 ) val romanar = Joukko ( " I " , " IV " , " V ​​" , " IX " " , "X" , "XL" , "L" , "XC" , "C" , "CD" , "D" , "CM" , "M" ) def arab2roman ( arabi : Int , acc : String = " " , n : Int = arabar . pituus - 1 ): Merkkijono = if ( arabi == 0 ) acc else if ( arabi >= arabar ( n )) arabi2romaan ( arabi - arabar ( n ), acc + romanar ( n ), n ) else arab2roman ( arab , acc , n - 1 ) // arab2roman(4933) = MMMMCMXXXIII Ohjelma arabialaisten numeroiden muuntamiseen roomalaisiksi numeroiksi ja päinvastoin Pascal -kielellä [9] tyyppi str2 = merkkijono [ 2 ] ; const Vanteet : array [ 1 .. 14 ] of str2 = ( 'M' , 'CM' , 'D' , 'CD' , 'C' , 'XC' , 'L' , 'XL' , 'X' , 'IX' , 'V' , 'IV' , 'I' , ' ) ; arabi : taulukko [ 1 .. 14 ] kokonaisluku = ( 1000 , 900 , 500 , 400 , 100 , 90 , 50 , 40 , 10 , 9 , 5 , 4 , 1 , 0 ) ; _ var N , NI , I , J : kokonaisluku ; S : merkkijono _ funktio Arab2Rim ( N : kokonaisluku ) : merkkijono ; var S : merkkijono ; I : kokonaisluku ; alkaa S := '' ; I := 1 ; kun taas N > 0 alkaa kun arabi [ I ] < = N alkaa S : = S + vanteet [ I ] ; N := N - Arab [ I ] loppu ; I := I + 1 pää ; Arab2Rim := S end ; funktio Rim2Arab ( S : merkkijono ) : kokonaisluku ; var I , N : kokonaisluku ; aloita I := 1 ; N : = 0 while S <> '' do alkaa while Vanteet [ I ] = Kopio ( S , 1 , pituus ( Vanteet [ I ]) ) aloita S := Kopio ( S , 1 + pituus ( Vanteet [ I ] ) , 255 ) ; N := N + Arab [ I ] loppu ; I := I + 1 pää ; Rim2Arab := N pää ; begin WriteLn ( 'Käännös arabiasta roomalaisiin numeroihin. 1999 B_SA' ) ; { Write('Syötä numero muuntaaksesi:'); ReadLn(N);} for NI := 26 - 46 do WriteLn ( NI , ' = ' , Arab2Rim ( NI ) , ' takaisin ' , Rim2Arab ( Arab2Rim ( NI ) ) ) ; loppua . Funktio muuntaa arabian roomalaiseksi luvuksi Pascalissa [10] toiminto Arab2Roman ( arabi : kokonaisluku ) : merkkijono ; var i : kokonaisluku ; d : kokonaisluku ; arab_str : merkkijono _ arab_len : kokonaisluku ; alkaa Tulos := '' ; arab_str := IntToStr ( arabi ) ; arab_len := Pituus ( arab_str ) ; for i := 0 to arab_len - 1 do begin d := StrToInt ( Merkkijono ( arab_str [ arab_len - i ])) ; jos ( d + 1 ) mod 5 = 0 sitten Tulos := Kopioi ( ' IXCM ' , 1 + i , 1 ) + Kopioi ( ' VXLCDM ' , i * 2 + ( d + 1 ) div 5 , 1 ) + tulos muu Tulos := Kopioi ( 'VLD' , 1 + i , d div 5 ) + Kopioi ( 'IIIXXXCCCMMM' , 1 + i * 3 , ( d mod 5 )) + Tulos ; loppu ; loppu ; Arabian ja roomalaisen muunnosfunktio BASICissa (lyhyin koodi) [11] 10 SYÖTÄ " ARABIAINEN NUMERO:" ; A 20 $ I = 0 PITKÄ ( A$ ) -1 30 X = VAL ( KESKIS $ ( A$ , LEN ( A $ ) - I , 1 )) 40 JOS X = 4 TAI X = 9 NIIN B$ = MID$ ( "IXCM" , I + 1 , 1 ) + MID$ ( "VXLCDM" , I * 2 + ( X + 1 ) / 5 , 1 ) + B$ 50 JOS X < 4 NIIN B$ = KESKIKÄS$ ( "IIIXXXCCCMMM" , 1 + I * 3 , X ) + B$ MUUTA JOS X > 4 JA X < 9 NIIN B$ = MID$ ( "VLD" , I + 1 , 1 ) + MID$ ( "IIIXXXCCCMMM" , 1 + I * 3 , X -5 ) + B$ 60 SEURAAVA I 70 TULOSTUS "ROOMAAN NUMERO:" ; B$ Toiminto, joka muuntaa arabian luvun (tässä tapauksessa 1999) roomalaiseksi XPathissa string-join( $num vuonna (1999) palata( ('','M','MM','MMM')[($num idiv 1000) mod 10+1], ('','C','CC','CCC','CD','D','DC','DCC','DCCC','CM')[($num idiv 100) mod 10+ yksi], ('', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC')[($num idiv 10) mod 10+ yksi], ('', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX')[$num mod 10+1] ), '') Toiminto, joka muuntaa arabian luvun (tässä tapauksessa 1999) roomalaiseksi Perlissä käytä tiukkaa ; käytä varoituksia ; minun $n = 1999 ; minun $numeroni = [ [ '' , 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) ] ]; minun $i = 0 ; minun @res = (); push @res , ( $nums -> [ $i ++ ][ ( $n % 10 , $n = int ( $n / 10 ) ) [ 0 ] ]) 0 .. 3 ; tulosta kääntöpuoli @res ; Luokka arabian numeroiden (1 - 3999) muuntamiseen roomalaiseksi Javassa tuonti java.util.* ; public class IntegerConverter { public static String intToRoman ( int numero ) { if ( numero >= 4000 || numero <= 0 ) return null ; StringBuilder tulos = uusi StringBuilder (); for ( Kokonaislukuavain : yksiköt . descendingKeySet ( ) ) { while ( numero > = avain ) { numero - = avain ; tulos . liittää ( units . get ( avain )); } } palauttaa tuloksen . toString (); } yksityinen staattinen lopullinen NavigableMap < Integer , String > units ; static { NavigableMap < Integer , String > initMap = new TreeMap <> (); initMap . laittaa ( 1000 , "M" ); initMap . laittaa ( 900 , "CM" ); initMap . laittaa ( 500 , "D" ); initMap . laittaa ( 400 , "CD" ); initMap . laittaa ( 100 , "C" ); initMap . laittaa ( 90 , "XC" ); initMap . laittaa ( 50 , "L" ); initMap . laittaa ( 40 , "XL" ); initMap . laittaa ( 10 , "X" ); initMap . laittaa ( 9 , "IX" ); initMap . laittaa ( 5 , "V" ); initMap . laittaa ( 4 , "IV" ); initMap . laittaa ( 1 , "minä" ); yksiköt = Kokoelmat . unmodifiableNavigableMap ( initMap ); } } Laajennusluokka rooman kielen muuntamiseen arabiaksi ja päinvastoin CSharpissa /// <summary> /// Luokka on suunniteltu muuttamaan arabialaiset luvut roomalaisiksi luvuiksi ja päinvastoin /// </summary> /// <remarks> /// <para>Luokka sisältää aluksi roomalaisen aakkoston numerot, jotka voivat määrittää arabialaisia ​​lukuja välillä 1 - 39999</para> /// <para >Jos haluat laajentaa aluetta, voit määrittää roomalaisille numeroille lisää merkintöjä ///-kentän avulla <katso cref="BasicRomanNumbers"/> BasicRomanNumbers</remarks> julkinen staattinen luokka RomanNumber { /// <summary> /// Roomalaisten perusnumeroiden aakkoset /// <para>Aakkoset on rakennettu sanakirjaksi. Sanakirjan avain on arabialainen luku (int), arvo on sitä vastaava /// roomalainen numero (merkkijono)</para> /// </summary> /// <remarks> /// <para>Sisältää arabialaisten numeroiden roomalaiset symbolit 1 *,4*,5*,9* - jossa "*" edustaa 0...N nollaa</para> /// <para >Luotuessaan sisältää numeroiden merkinnät 1 - 10000 (I...ↂ ) Koska yksi merkki ei /// voi esiintyä enempää kuin kolme kertaa roomalaisessa luvussa, voit aluksi muuntaa numerot 1:stä 39999:ään roomalaiseen muotoon.</para> /// <para>Jos Jos haluat työskennellä suurella määrällä roomalaisia ​​numeroita, sinun on lisättävä luetteloon /// lisää nimityksiä alkaen 40000 ohittamatta elementtejä 1*,4*,5*,9*.</para> /// </remarks> public static LajiteltuLista < int , string > Roomalaiset perusluvut { get ; asettaa ; } static RomanNumber () { BasicRomanNumbers = new LajiteltuLista < int , merkkijono >( 17 ); Roomalaiset perusnumerot . Lisää ( 1 , "I" ); Roomalaiset perusnumerot . Lisää ( 4 , "IV" ); Roomalaiset perusnumerot . Lisää ( 5 , "V" ); Roomalaiset perusnumerot . Lisää ( 9 , "IX" ); Roomalaiset perusnumerot . Lisää ( 10 , "X" ); Roomalaiset perusnumerot . Lisää ( 40 , "XL" ); Roomalaiset perusnumerot . Lisää ( 50 , "L" ); Roomalaiset perusnumerot . Lisää ( 90 , "XC" ); Roomalaiset perusnumerot . Lisää ( 100 , "C" ); Roomalaiset perusnumerot . Lisää ( 400 , "CD" ); Roomalaiset perusnumerot . Lisää ( 500 , "D" ); Roomalaiset perusnumerot . Lisää ( 900 , "CM" ); Roomalaiset perusnumerot . Lisää ( 1000 , "M" ); Roomalaiset perusnumerot . Lisää ( 4000 , "Mↁ" ); Roomalaiset perusnumerot . Lisää ( 5000 , "ↁ" ); Roomalaiset perusnumerot . Lisää ( 9000 , "Mↂ" ); Roomalaiset perusnumerot . Lisää ( 10000 , "ↂ" ); } /// <yhteenveto> /// Laskee suurimman mahdollisen roomalaisen numeron nykyiselle roomalaisten numeroiden aakkostolle. /// </summary> /// <returns>Maksimin mahdollinen roomalainen luku</returns> public static uint MaxRomanNumber () { int lastNumber = BaseRomanNumber . avaimet . Viimeinen (); int numeroNoNollat ​​= int . Jäsennä ( lastNumber . ToString (). Korvaa ( '0' , '\0' )); int pre = 0 ; kytkin ( numeroWithoutZeros ) { tapaus 1 : edellinen = viimeinenNumber * 4 - 1 ; tauko ; tapaus 4 : tapaus 9 : edellinen = viimeinenNumber ; tauko ; tapaus 5 : alustava = lastNumber + lastNumber / 5 * 3 ; tauko ; oletus : break ; } palauta uint . Jäsennä ( pre . ToString ( ). Korvaa ( '0' , '9' ));; } /// <summary> /// Muuntaa kokonaisluvun roomalaiseksi luvuksi /// </summary> /// <param name="Arab number">Arabialainen luku, joka muunnetaan roomalaiseen merkintään</param> // / < poikkeus cref="ArgumentOutOfRangeException">Heitetään, kun parametrina välitetään numero, joka on yhtä suuri kuin "0" /// tai numero, joka on suurempi kuin roomalainen enimmäisluku.</exception> /// <returns>Merkkijono, joka edustaa Roomalainen luku</returns> julkinen staattinen merkkijono arabialainenRoman ( tämä int numeroArabi ) { StringBuilder numberRoman = new StringBuilder (); //Jätä "-"-merkki pois arabialaisesta numerosta ja tee siitä roomalaisen luvun ensimmäinen merkki if ( numberArab < 0 ) { numberRoman . liittää ( "-" ); numeroArabi = - numeroArabi ; } if ( numberArab == 0 ) heittää uusi ArgumentOutOfRangeException ( "numberArab" , numeroArab , "Virheellinen argumenttiarvo: roomalaiset numerot eivät voi olla yhtä suuria kuin\"0\"" ); else if ( numberArab > MaxRomanNumber ()) throw new ArgumentOutOfRangeException ( "numberArab" , numberArab , string . Format ( "Virheellinen argumenttiarvo: ei voi määrittää roomalaista lukua, joka on suurempi kuin {0}" , MaxRomanNumber ())); //Jaa arabialainen luku sen muodostaviksi roomalaisiksi numeroiksi ja yhdistä ne yhdeksi merkkijonoksi var requiredBasicRomanNumbers = from to in BasicRomanNumbers . Näppäimet minne < = numeroArabi järjestys laskevassa valitse ; _ _ foreach ( int nykyinen vaadituissa perusromaanisissa luvuissa ) { while ( ( numeroArabi / nykyinen ) >= 1 ) { numeroArabi - = nykyinen ; numeroRoomalainen . Liitä ( BaseRomanNumbers [ tech ]); } } palautusnumeroRoomalainen . _ ToString (); } /// <summary> /// Muuntaa roomalaisen luvun arabiaksi /// </summary> /// <param name="Roman number">Roomalainen luku muunnetaan int-tyypiksi</param> /// <poikkeus cref="FormatException">Heitetään, kun ei-roomalainen luku välitetään parametrina</exception> /// <returns>Kokoluku, joka edustaa roomalaisen luvun arabiankielistä merkintää</returns> public static int romantoarabia ( tämä merkkijono numberRoman ) { int numeroArabi = 0 ; sbyte negatiivinen = 1 ; merkkijono roomalainen = numeroRoman . leikata (); if ( rooma [ 0 ] == '-' ) { negatiivinen = - 1 ; rooma = rooma . osamerkkijono ( 1 ); } StringBuilder RomanNumber- malli = uusi StringBuilder (); foreach ( int to roomalaisissa perusluvuissa . Avaimet ) { int index = roomalaiset perusluvut . avaimet . IndexOf ( k ); merkkijonon kvantori = "?" ; if ( indeksi == 0 || ( indeksi % 4 ) == 0 ) kvantori = "{0,3}" ; roomalainen numeromalli . Insert ( 0 , merkkijono . Muoto ( "(?<{0}>({1}){2})?" , . ToString (), Roomalaiset perusluvut [ to ], kvantori )); } //Ohita kirjainkoko + -osuma on aloitettava merkkijonon RomanNumber-mallin alusta . Lisää ( 0 , "(?i)^" ); //Osavuuden on oltava merkkijonon RomanNumber-mallin lopussa . liittää ( "$" ); // Yksinkertaistettu tarkistus. Ei tarkista virheitä, kuten IVII if (! Regex . IsMatch ( roomalainen , roomalainen numeromalli . ToString ())) heittää uusi FormatException ( string . Format ( "Teksti \"{0}\" ei ole roomalainen numero" , roomalainen numero )); Osumanumero = Regex . _ Match ( rooma , RomanNumber Pattern . ToString ()); foreach ( int to roomalaisin perusnumeroin . Näppäimet ) { numeroArabi += numero . Ryhmät [ to . ToString ()]. Pituus / Roomalaiset perusnumerot [ - ]. Pituus * - ; } palauttaa numeroArabi * negatiivinen ; } }

Muistiinpanot

  1. ↑ Numerot ja numerojärjestelmät Arkistoitu 22. marraskuuta 2018 Wayback Machinessa . Online-tietosanakirja ympäri maailmaa.
  2. ↑ M. Ya. Vygodsky "Alkeismatematiikan käsikirja" Moskova 1958 Valtion fyysisen ja matemaattisen kirjallisuuden kustantaja. sivu 62
  3. ↑ Beckhamin tie Roomaan Arkistoitu 1. toukokuuta 2020 Wayback Machinessa // BBC , 17. huhtikuuta 2002
  4. ↑ Unicode-standardi, 15.3 Arkistoitu 27. kesäkuuta 2010 Wayback Machinessa ("Useimmissa tarkoituksiin roomalaiset numerot on suositeltavaa muodostaa asianmukaisten latinalaisten kirjainten sarjoista.")
  5. ↑ 12 Unicode -numerolomaketta . Haettu 30. maaliskuuta 2009. Arkistoitu alkuperäisestä 25. maaliskuuta 2009.
  6. ↑ Perry, David J. Ehdotus muinaisten roomalaisten lisähahmojen lisäämiseksi UCS:ään Arkistoitu 22. kesäkuuta 2011 Wayback Machinessa .
  7. ↑ Kahdelle ensimmäiselle riville
  8. ↑ Luku 31. Roomalainen numeerinen merkintä :: Toteutusideoita . Käyttöpäivä: 15. lokakuuta 2015. Arkistoitu alkuperäisestä 18. marraskuuta 2015.
  9. ↑ "Tiede ja elämä" N12 1986 s. 95, V. Ptitsyn, Moskova
  10. ↑ Kirjoittaja - Kuznetsov Evgeny A.
  11. ↑ Kirjoittaja - Jevgeni A. Kuznetsov, 1992

Katso myös