Números romanos

La versión actual de la página aún no ha sido revisada por colaboradores experimentados y puede diferir significativamente de la versión revisada el 12 de octubre de 2022; las comprobaciones requieren 2 ediciones .

Sistemas numéricos en la cultura
indoárabe
árabe tamil birmano	Khmer Laosiano Mongol Tailandés
asiático del este
Chino Japonés Suzhou Coreano	Palos vietnamitas para contar
Alfabético
Abjadia Armenio Aryabhata Cirílico Griego	Georgiano Etíope Judío Akshara Sankhya
Otro
Babilónico Egipcio Etrusco Romano Danubiano	Ático Kipu Maya Egeo KPPU Símbolos
posicional
2 , 3 , 4 , 5 , 6 , 8 , 10 , 12 , 16 , 20 , 60
Nega-posicional
simétrico
sistemas mixtos
Fibonacci
no posicional
Singular (unario)

Esta página o sección contiene caracteres Unicode especiales .
Si no tiene las fuentes requeridas , es posible que algunos caracteres no se muestren correctamente.

Los números romanos son números utilizados por los antiguos romanos en su sistema numérico no posicional .

Los números naturales se escriben repitiendo estos dígitos. Al mismo tiempo, si un número mayor viene antes de uno más pequeño, entonces se suman (principio de la suma), pero si uno más pequeño viene antes de uno más grande, entonces el más pequeño se resta del más grande (principio de la resta). La última regla se aplica sólo para evitar la repetición cuádruple de la misma figura.

Los números romanos aparecieron en el 500 a. C. de los etruscos (ver alfabeto etrusco ), quienes pudieron tomar prestados algunos de los números de los proto-celtas .

Números y notación de números

La notación romana para números ahora es más conocida que cualquier otro sistema numérico antiguo. Esto se explica no tanto por algunos méritos especiales del sistema romano, sino por la enorme influencia que disfrutó el Imperio Romano en un pasado relativamente reciente. Etruscos que conquistaron Roma en el siglo VII a. e., fueron influenciados por las culturas del Mediterráneo oriental. Esto explica en parte la similitud de los principios básicos de los sistemas numéricos romano y ático. Ambos sistemas eran decimales, aunque el número cinco jugaba un papel especial en ambos sistemas numéricos. Ambos sistemas usaban caracteres repetidos al escribir números.

Los antiguos símbolos romanos para los números 1, 5, 10, 100 y 1000 ( notación hindú-árabe ) eran los símbolos I, V, X, Θ (o ⊕ o ⊗ ) y Φ (o ↀ o CIƆ ) , respectivamente. Aunque se ha escrito mucho sobre el significado original de estos símbolos, todavía no existe una explicación satisfactoria para ellos. Según una de las teorías más difundidas, el número romano V representa una mano abierta con cuatro dedos apretados y el pulgar extendido; el símbolo X, según la misma teoría, representa dos manos cruzadas o una V de dos dígitos. Los símbolos de los números 100 y 1000 probablemente tienen su origen en las letras griegas Θ y φ. No se sabe si las designaciones posteriores C y M se derivan de caracteres romanos más antiguos o están relacionadas acrofónicamente con las letras iniciales de las palabras latinas que significan 100 (centum) y 1000 (mille). Se cree que el símbolo romano para el número 500, la letra D , se originó a partir de la mitad del antiguo símbolo para 1000. Excepto que la mayoría de los símbolos romanos probablemente no eran acrofónicos y que los símbolos intermedios para los números 50 y 500 no eran combinaciones. de símbolos para los números 5 y 10 o 5 y 100, el resto del sistema numérico romano se parecía al ático. Los romanos usaban a menudo el principio de la resta, por lo que a veces usaban IX en lugar de VIIII, y XC en lugar de LXXXX; comparativamente más tarde, el símbolo IV en lugar de IIII. Por lo tanto, ahora todos los números romanos se pueden escribir en mayúsculas latinas.

En general, los romanos no se inclinaban por las matemáticas, por lo que no sentían mucha necesidad de grandes números. Sin embargo, ocasionalmente usaron el símbolo CCIƆƆ para 10000 y el símbolo CCCIƆƆƆ para el número 100000 . Las mitades de estos símbolos a veces se usaban para representar los números 5000 ( IƆƆ ) y 50000 ( IƆƆƆ ).

Los romanos evitaban las fracciones con tanta obstinación como los números grandes. En los problemas prácticos de medición, no usaban fracciones, subdividiendo la unidad de medida generalmente en 12 partes, de modo que el resultado de la medición se presenta como un número compuesto, la suma de múltiplos de varias unidades, como se hace hoy en día cuando se mide la longitud. expresada en yardas, pies y pulgadas. Las palabras en inglés "ounce" ( onza ) y "inch" ( pulgada ) provienen de la palabra latina lat. uncia ( onza ), que denota una doceava parte de la unidad básica de longitud [1] [2] .

una	yo	lat. unus, unum
5	V	lat. Quinque
diez	X	lat. diciembre
cincuenta	L	lat. quincuaginta
100	C	lat. por ciento
500	D	lat. quingenti
1000	METRO	lat. mil

notación árabe	notación romana
una	yo
2	II
3	tercero
cuatro	IV
5	V
6	VI
7	VII
ocho	viii
9	IX
diez	X
once	XI
12	XII
13	XIII
catorce	XIV
quince	XV
dieciséis	XVI
17	XVII
Dieciocho	XVIII
19	XIX
veinte	XX
treinta	XXX
40	SG
cincuenta	L
60	LX
70	LXX
80	LXXX
90	XC
100	C
200	CC
300	CCC
400	CD
500	D; yo
600	CORRIENTE CONTINUA; IƆC
700	CCD; IƆCC
800	DCCC; IƆCCC
900	CM; CCIƆ
1000	METRO; ↀ; CIƆ
2000	mm; CIƆCIƆ
3000	MMM; CIƆCIƆCIƆ
3999	MMMCMXCIX
4000	MV ; _ ↀↁ; CIƆIƆƆ
5000	V ; ↁ; yo
6000	máquina virtual ; ↁↀ; IƆƆCIƆ
7000	VMM ; ↁↀↀ; IƆƆCIƆCIƆ
8000	VMMMM ; ↁↀↀↀ; IƆƆCIƆCIƆCIƆ
9000	MX ; _ ↀↂ; CIƆCCIƆƆ
10,000	x ; ↂ; CCIƆƆ
20 000	XX ; ↂↂ; CCIƆƆCCIƆƆ
30,000	XXX ; ↂↂↂ; CCIƆƆCCIƆƆCCIƆƆ
40 000	XL ; ↂↇ; CCIƆƆƆƆƆ
50,000	L ; ↇ; yo
60 000	LX ; ↇↂ; IƆƆƆCCIƆƆ
70 000	LXX ; ↇↂↂ; IƆƆƆCCIƆƆCCIƆƆ
80 000	LXX ; ↇↂↂↂ; 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	disco compacto ; CCCIƆƆƆIƆƆƆƆ
500 000	D ; yo ƆƆƆƆ
600 000	corriente continua ; IƆƆƆƆCCCIƆƆƆ
700 000	CCD ; IƆƆƆƆCCCIƆƆƆCCCIƆƆƆ
800 000	DCCC
900 000	CM
1,000,000	METRO
2,000,000	milímetro
3,000,000	MMM
4,000,000	MV _
5,000,000	V
6,000,000	VM _
7,000,000	VMM _
8,000,000	V MMM
9,000,000	MX _
10,000,000	X
100,000,000	C
1,000,000,000	METRO
1,000,000,000,000	METRO
1,000,000,000,000,000,000,000,000,000,000,000	METRO
10^100	X^C

Para escribir correctamente números grandes en números romanos, primero debes escribir el número de miles, luego centenas, luego decenas y finalmente unidades.

No hay cero en el sistema numérico romano, pero el cero se usaba anteriormente como nulla (no), nihil (nada) y N (la primera letra de estas palabras).

En este caso, algunos de los números (I, X, C, M) pueden repetirse, pero no más de tres veces seguidas ; por lo tanto, pueden usarse para escribir cualquier número natural no más de 3999 (MMMCMXCIX). En los primeros períodos, había signos para indicar números más grandes: 5000, 10,000, 50,000 y 100,000 (entonces el número máximo según la regla mencionada es 399,999). Al escribir números en el sistema numérico romano, el dígito más pequeño puede estar a la derecha del más grande; en este caso se le añade. Por ejemplo, el número 283 en romano se escribe CCLXXXIII, es decir, 100+100+50+30+3=283. Aquí, el número que representa cien se repite dos veces, y los números que representan diez y uno, respectivamente, se repiten tres veces.

Ejemplo: número 1988. Mil M, novecientos CM, ocho decenas LXXX, ocho unidades VIII. Escribámoslos juntos: MCMLXXXVIII.

Muy a menudo, para resaltar números en el texto, se dibujaba una línea sobre ellos: LXIV . A veces, la línea se dibujaba tanto arriba como abajo: XXXII : en particular, se acostumbra resaltar los números romanos en el texto escrito a mano en ruso (esto no se usa en la composición tipográfica debido a la complejidad técnica). Para otros autores, la línea superior podría indicar un aumento en el valor de la cifra de 1000 veces: V = 5000.

Fue solo en el siglo XIX que el número "cuatro" se escribió como "IV" en todas partes , antes de que el registro "IIII" se usara con mayor frecuencia. Sin embargo, la entrada "IV" ya se puede encontrar en los documentos del manuscrito Forma de Cury que datan de 1390 . Las esferas de los relojes han usado tradicionalmente "IIII" en lugar de "IV" en la mayoría de los casos, principalmente por razones estéticas : esta grafía proporciona simetría visual con los números "VIII" en el lado opuesto, y el "IV" invertido es más difícil de leer que "III". También hay una versión de que IV no estaba escrito en el dial porque IV son las primeras letras del nombre latino del dios Júpiter (IVPITER).

El número más pequeño se puede escribir a la izquierda del más grande, luego se debe restar del más grande. En este caso, solo se pueden restar números que denotan 1 o potencias de 10, y solo los dos números más cercanos en la serie numérica al restado (es decir, el restado, multiplicado por 5 o 10) pueden actuar como minuendo. No se permiten repeticiones de un número menor. Por lo tanto, solo hay seis usos de la "regla de la resta":

VI = 4
IX = 9
XL=40
XC = 90
CD=400
cm=900

Por ejemplo, el número 94 será XCIV = 100 - 10 + 5 - 1 = 94 - la llamada "regla de la resta" (aparecida en la era de la antigüedad tardía, y antes de eso, los romanos escribieron el número 4 como IIII, y el número 40 como XXXX).

Cabe señalar que no se permiten otros métodos de "resta"; por lo tanto, el número 99 debe escribirse como XCIX, pero no como IC. Sin embargo, hoy en día, en algunos casos, también se usa una notación simplificada de números romanos: por ejemplo, en Microsoft Excel , al convertir números arábigos a romanos usando la función “ROMANO ()”, puede usar varios tipos de representación de números, desde clásico hasta muy simplificado (por ejemplo, el número 499 se puede escribir como CDXCIX, LDVLIV, XDIX, VDIV o ID). La simplificación es que para reducir cualquier dígito, se puede escribir cualquier otro dígito a la izquierda del mismo:

999. Mil (M), reste 1 (I), obtenga 999 (IM) en lugar de CMXCIX. Consecuencia: 1999 - MIM en lugar de MCMXCIX
95. Cien (C), reste 5 (V), obtenga 95 (VC) en lugar de XCV
1950: mil (M), restamos 50 (L), obtenemos 950 (LM). Consecuencia: 1950 - MLM en lugar de MCML

Los casos de tal notación de números (generalmente años) se encuentran a menudo en los créditos de las series de televisión estadounidenses. Por ejemplo, para el año 1998: MIIM en lugar de MCMXCVIII.

Los números romanos también se pueden usar para escribir clases más grandes de números. Para ello, se coloca una línea sobre aquellos números que representan miles, y una doble línea sobre los números que representan millones. La excepción es el número I; en lugar de una línea arriba, se escribe el número M y, a partir de un millón, una línea desde arriba. Por ejemplo, el número 123123 se vería así:

CXXIII CXXIII

Y un millón es como yo , pero no con uno, sino con dos rasgos a la cabeza: yo

Aplicación

En ruso, los números romanos se utilizan en los siguientes casos:

Número de siglo o milenio: siglo XIX, II milenio antes de Cristo. mi.
Conjugación de verbos.
Marcado de caras de reloj " antiguo " .
Número de volumen en un libro de varios volúmenes o volumen de revistas (a veces números de partes de un libro, secciones o capítulos ).
En alfabetización musical.
Número ordinal del monarca .
Tipo de sangre en los parches del uniforme de los militares de las Fuerzas Armadas de la Federación Rusa .
En los barcos soviéticos , el calado se indicaba en metros en letras romanas (en los barcos ingleses , en pies en letras romanas).
En algunas ediciones, números de página con el prefacio del libro, para no corregir las referencias dentro del texto principal al cambiar el prefacio.
Otros eventos importantes o elementos de la lista, por ejemplo: V postulado de Euclides , Segunda Guerra Mundial , XX Congreso del PCUS , Juegos de la XXII Olimpiada y similares.
Valencia de los elementos químicos.
Número de cuerpo en las fuerzas armadas.
Año de finalización del edificio en su frontón.
El número ordinal de un paso en la escala.
En el análisis matemático , el número de la derivada se escribe en números romanos , sin embargo, al leer (normalmente) dicen “trazo” en lugar de I, “dos trazos” en lugar de II, “tres trazos” en lugar de III. Finalmente, a partir de IV, se lee la “cuarta derivada”: y . $f'(x)=f^{I}(x)=f^{(1)}(x)$ $f^{IV}(x)=f^{(4)}(x)$

Los números romanos eran muy utilizados en la URSS a la hora de indicar la fecha para indicar el mes del año, por ejemplo: 11/III-85 o 9.XI.89, esto se puede apreciar en muchos documentos de archivo de aquellos tiempos. De manera similar, a través de una barra , también anotaron la fecha de la lección en los diarios de clase , por ejemplo, 24/II. Para indicar las fechas de vida y muerte en las lápidas, a menudo se usaba un formato especial, donde el mes del año también se indicaba con números romanos, por ejemplo, (25 de noviembre de 1887 ~ 26 de enero de 1943). Se utilizó un formato similar en los certificados médicos en los años 70 y 80. $18{\textstyle {\frac {25}{XI))}87\sim 19{\textstyle {\frac {26}{I))}43$

Con la transición al tratamiento informático de la información , los formatos de fecha basados en números romanos han caído prácticamente en desuso.

En otros idiomas, el alcance de los números romanos puede diferir. En los países occidentales, el número del año a menudo se escribe en números romanos, por ejemplo, en los frontones de los edificios y en los créditos de los productos de video, cine y televisión [3] .

En la Lituania moderna , en las señales de tráfico , en los escaparates de las tiendas , en los letreros de las empresas, los números romanos pueden indicar los días de la semana .

Unicode

El estándar Unicode recomienda que los números romanos se representen usando caracteres latinos simples [4] . Sin embargo, el estándar también incluye caracteres especiales para números romanos como parte de Formas numéricas [ 5 ] en el área de caracteres con los códigos U+2160 a U+2188. Por ejemplo, MCMLXXXVIII se puede representar en la forma ⅯⅭⅯⅬⅩⅩⅩⅧ. Este rango incluye dígitos en mayúsculas y minúsculas para los números del 1 (Ⅰ o I) al 12 (Ⅻ o XII), incluidos los glifos combinados para números compuestos como 8 (Ⅷ o VIII), principalmente para garantizar la compatibilidad con los conjuntos de caracteres de Asia oriental. en estándares de la industria como JIS X 0213 donde se definen estos caracteres. Los glifos combinados se utilizan para representar números que anteriormente estaban formados por caracteres únicos (por ejemplo, Ⅻ en lugar de su representación como Ⅹ y Ⅱ). Además, existen glifos para las formas arcaicas [5] de 1000, 5000, 10,000, C mayúscula inversa (Ɔ), 6 tardío (ↅ, similar al estigma griego : Ϛ), 50 temprano ( ↆ, que parece una flecha apuntando hacia abajo ↓⫝⊥ [6] ), 50 000 y 100 000. Debe tenerse en cuenta que la pequeña c invertida, ↄ no está incluida en los caracteres numéricos romanos, pero está incluida en el estándar Unicode como la letra claudiana mayúscula Ↄ .

El código	0	una	2	3	cuatro	5	6	7	ocho	9	A	B	C	D	mi	F
Valor [7]	una	2	3	cuatro	5	6	7	ocho	9	diez	once	12	cincuenta	100	500	1000
U+2160	Ⅰ 2160	Ⅱ 2161	Ⅲ 2162	Ⅳ 2163	Ⅴ 2164	Ⅵ 2165	Ⅶ 2166	Ⅷ 2167	Ⅸ 2168	Ⅹ 2169	Ⅺ 216A	Ⅻ 216B	Ⅼ 216C	Ⅽ 216D	Ⅾ 216E	Nº 216F
U+2170	ⅰ 2170	ⅱ 2171	ⅲ 2172	ⅳ 2173	ⅴ 2174	ⅵ 2175	ⅶ 2176	ⅷ 2177	ⅸ 2178	ⅹ 2179	ⅺ 217A	ⅻ 217B	ⅼ217C _	ⅽ 217D	ⅾ 217E	ⅿ 217F
Sentido	1000		5000		10,000		100		6		cincuenta		50,000		100,000
U+2180	ↀ 2180		ↁ 2181		ↂ 2182		Ↄ 2183		ↅ 2185		ↆ 2186		ↇ 2187		ↈ 2188

Mostrar todos estos caracteres requiere un software compatible con el estándar Unicode y una fuente que contenga los glifos correspondientes para estos caracteres (por ejemplo, la fuente Universalia ).

Expresiones regulares

Expresión regular para verificar números romanos - ^(M{0,3})(D?C{0,3}|C[DM])(L?X{0,3}|X[LC])(V?I{0,3}|I[VX])$[8] En Perl , puede usar una expresión regular para buscar números romanos en una cadena 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.

Transformación

Para convertir números escritos en números arábigos a números romanos, se utilizan funciones especiales.

Por ejemplo, en la versión en inglés de Microsoft Excel y en cualquier versión de OpenOffice.org Calc , hay una función ROMAN (argumento; forma) para esto , en la versión rusa de Microsoft Excel esta función se llama ROMAN (número; forma) . El argumento opcional "forma" puede tomar valores de 0 a 4, así como "Falso" y "Verdadero". La ausencia del argumento "Forma" o su igualdad a 0 o "Verdadero" da la forma "clásica" (estricta) de la transformación; un valor de 4 o "Falso" da el más simplificado; los valores 1, 2, 3 dan variantes intermedias en rigor-simplificación. Las diferencias aparecen, por ejemplo, en los números 45, 49, 495, 499 (las primeras se indican en el rango [1;3999]).

Ejemplo de aplicación de función ROMANO(número; forma)

	la forma	0	una	2	3	cuatro
número
45		XLV	VL	VL	VL	VL
49		XLIX	VLIV	ILLINOIS	ILLINOIS	ILLINOIS
495		CDXCV	LDVL	XDV	enfermedad venérea	enfermedad venérea
499		CDXCIX	LDVLIV	XDIX	VDIV	IDENTIFICACIÓN

Los valores no enteros del argumento "número" se redondean a un número entero; si después de eso el valor es mayor que 3999 o menor que 0, entonces la función devuelve "#Valor"; para un valor de 0, se devuelve una celda vacía.

Funciones de transformación de JavaScript var árabe = [ 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 ( número ) { if ( ! número ) return '' ; varret = ' ' ; var i = árabe . longitud - 1 ; while ( número > 0 ) { if ( número >= árabe [ i ]) { ret += romano [ i ]; número -= árabe [ i ]; } más { yo -- ; } } retorno ret ; } función romanToArab ( str ) { cadena = cadena . a Mayúsculas (); varret = 0 ; _ var i = árabe . longitud - 1 ; pos var = 0 ; while ( i >= 0 && pos < str . length ) { if ( str . substr ( pos , roman [ i ]. length ) == roman [ i ]) { ret += arab [ i ]; pos += romano [ i ]. longitud ; } más { yo -- ; } } retorno ret ; } Funciones similares en lenguaje C (C89): #incluir <cadena.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 ( árabe int corto sin firmar ) { char romano estático [ 80 ]; const int m = tamaño de ( arabar ) / tamaño de ( int ) -1 , arabmax = arabar [ m ]; const char romanmax = romanar [ m ][ 0 ]; int i , n ; si ( ! árabe ) { * romano = 0 ; volver romano ; } yo = 0 _ mientras ( árabe > arabmax ) { romano [ i ++ ] = romanmax ; árabe -= árabemax ; } n = metro ; mientras ( árabe > 0 ) { if ( árabe >= arabar [ n ]) { romana [ i ++ ] = romanar [ n ][ 0 ]; si ( n & 1 ) romana [ i ++ ] = romanar [ n ][ 1 ]; árabe -= arabar [ n ]; } más n- ; _ } romano [ yo ] = 0 ; volver romano ; } unsigned short int roman2arab ( char * roman ) { const int m = tamaño de ( arabar ) / tamaño de ( int ) -1 ; árabe int corto sin firmar ; int len , n , i , pir ; len = strlen ( romano ); árabe = 0 ; n = metro ; yo = 0 _ while ( norte >= 0 && yo < largo ) { pir = n & 1 ; if ( roman [ i ] == romanar [ n ][ 0 ] && ( ! pir || roman [ i + 1 ] == romanar [ n ][ 1 ])) { árabe += arabar [ norte ]; i += 1 + pir ; } más n- ; _ } volver árabe ; } Programa para convertir números arábigos a romanos en Scala : val arabar = Matriz ( 1 , 4 , 5 , 9 , 10 , 40 , 50 , 90 , 100 , 400 , 500 , 900 , 1000 ) val romanar = Matriz ( "I" , "IV" , "V" , "IX " , "X" , "XL" , "L" , "XC" , "C" , "CD" , "D" , "CM" , "M" ) def arab2roman ( árabe : 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 ) else arab2roman ( arab , acc , n - 1 ) // arab2roman(4933) = MMMMCMXXXIII Programa para convertir números arábigos a números romanos y viceversa en lenguaje Pascal [9] escriba str2 = cadena [ 2 ] ; const Llantas : arreglo [ 1 .. 14 ] de str2 = ( 'M' , 'CM' , 'D' , 'CD' , 'C' , 'XC' , 'L' , 'XL' , 'X' , 'IX' , 'V' , 'IV' , 'I' , ' ' ) ; Árabe : matriz [ 1 .. 14 ] de número entero = ( 1000 , 900 , 500 , 400 , 100 , 90 , 50 , 40 , 10 , 9 , 5 , 4 , 1 , 0 ) ; var N , NI , I , J : entero ; S : cadena _ función Arab2Rim ( N : entero ) : cadena ; var S : cadena ; yo : entero ; comenzar S := '' ; yo := 1 ; mientras que N > 0 empieza mientras que Arab [ I ] < = N empieza S := S + Rims [ I ] ; N := N - Árabe [ I ] fin ; yo := yo + 1 fin ; Arab2Rim := S fin ; función Rim2Arab ( S : cadena ) : entero ; var I , N : entero ; comienzo I := 1 ; norte : = 0 while S <> '' comienzan while Rims [ I ] = Copy ( S , 1 , Length ( Rims [ I ]) ) comienzan S : = Copy ( S , 1 + Length ( Rims [ I ] ) , 255 ) ; N := N + árabe [ I ] fin ; yo := yo + 1 fin ; Rim2Arab := N fin ; begin WriteLn ( 'Traducción del árabe al número romano. 1999 B_SA' ) ; { Write('Ingrese el número a convertir:'); ReadLn(N);} for NI := 26 to 46 do WriteLn ( NI , ' = ' , Arab2Rim ( NI ) , ' back ' , Rim2Arab ( Arab2Rim ( NI ) ) ) ; fin _ Función para convertir números arábigos a romanos en Pascal [10] función Arab2Roman ( árabe : entero ) : cadena ; var i : entero ; d : entero ; arab_str : cadena _ arab_len : entero ; comenzar Resultado := '' ; arab_str := IntToStr ( arab ) ; arab_len := Longitud ( 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 entonces Resultado := Copiar ( 'IXCM' , 1 + i , 1 ) + Copiar ( 'VXLCDM' , i * 2 + ( d + 1 ) div 5 , 1 ) + Resultado más Resultado : = Copiar ( 'VLD' , 1 + i , d div 5 ) + Copiar ( 'IIIXXXCCCMMM' , 1 + i * 3 , ( d mod 5 )) + Resultado ; fin ; fin ; Función de conversión de árabe a romano en BASIC (el código más corto) [11] 10 ENTRADA "NÚMERO ÁRABE: " ; A $ 20 FOR I = 0 TO LEN ( A$ ) -1 30 X = VAL ( MID$ ( A$ , LEN ( A$ ) - I , 1 )) 40 SI X = 4 O X = 9 ENTONCES B$ = MID$ ( "IXCM" , I + 1 , 1 ) + MID$ ( "VXLCDM" , I * 2 + ( X + 1 ) / 5 , 1 ) + B$ 50 SI X < 4 ENTONCES B$ = MID$ ( "IIIXXXCCCMMM" , 1 + I * 3 , X ) + B$ DE LO CONTRARIO SI X > 4 Y X < 9 ENTONCES B$ = MID$ ( "VLD" , I + 1 , 1 ) + MID$ ( "IIIXXXCCCMMM" , 1 + I * 3 , X -5 ) + B$ 60 SIGUIENTE I 70 PRINT "NÚMERO ROMANO: " ; B$ Función para convertir número arábigo (en este caso 1999) a romano en XPath unión de cadenas ( por $num en (1999) devolver ( ('','M','MM','MMM')[($num idiv 1000) mod 10+1], ('','C','CC','CCC','CD','D','DC','DCC','DCCC','CM')[($num idiv 100) mod 10+ una], ('','X','XX','XXX','XL','L','LX','LXX','LXXX','XC')[($num idiv 10) mod 10+ una], ('','I','II','III','IV','V','VI','VII','VIII','IX')[$num mod 10+1] ), '') Función para convertir número arábigo (en este caso 1999) a romano en Perl uso estricto ; advertencias de uso ; mi $n = 1999 ; mis $numeros = [ [ '' , 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) ] ]; mi $i = 0 ; mi @res = (); empuje @res , ( $nums -> [ $i ++ ][ ( $n % 10 , $n = int ( $n / 10 ))[ 0 ] ]) para 0 .. 3 ; imprimir reversa @res ; Clase para convertir número arábigo (del 1 al 3999) a romano en Java importar java.util.* ; Convertidor de enteros de clase pública { public static String intToRoman ( int number ) { if ( number >= 4000 || number <= 0 ) return null ; Resultado de StringBuilder = nuevo StringBuilder (); for ( clave entera : unidades . descendingKeySet ()) { while ( número >= clave ) { número -= clave ; resultado _ agregar ( unidades . obtener ( clave )); } } devuelve el resultado . a la cadena (); } private static final NavigableMap < Integer , String > units ; estático { NavigableMap < Integer , String > initMap = new TreeMap <> (); initMap . poner ( 1000 , "M" ); initMap . poner ( 900 , "CM" ); initMap . poner ( 500 , "D" ); initMap . poner ( 400 , "CD" ); initMap . poner ( 100 , "C" ); initMap . poner ( 90 , "XC" ); initMap . poner ( 50 , "L" ); initMap . poner ( 40 , "XL" ); initMap . poner ( 10 , "X" ); initMap . poner ( 9 , "IX" ); initMap . poner ( 5 , "V" ); initMap . poner ( 4 , "IV" ); initMap . poner ( 1 , "yo" ); unidades = Colecciones . unmodificableNavigableMap ( initMap ); } } Clase de extensión para convertir romano a árabe y viceversa, en CSharp /// <summary> /// La clase está diseñada para convertir números arábigos a números romanos y viceversa /// </summary> /// <remarks> /// <para>La clase inicialmente contiene un alfabeto de romano números que pueden determinar números arábigos del 1 al 39999</para> /// <para >Si desea expandir el rango, puede definir notaciones adicionales para números romanos usando /// el campo <see cref="BasicRomanNumbers"/> BasicRomanNumbers</remarks> public static class RomanNumber { /// <summary> /// Alfabeto de números romanos básicos /// <para>El alfabeto está construido como un diccionario. La clave del diccionario es un número arábigo (int), el valor es su correspondiente /// número romano (string)</para> /// </summary> /// <remarks> /// <para>Contains los símbolos romanos para números arábigos 1 *,4*,5*,9* - donde "*" representa 0...N ceros</para> /// <para>Cuando se crea, contiene la designación de números del 1 al 10000 (I...ↂ ) Dado que un carácter no puede /// aparecer más de tres veces en un número romano, inicialmente puede convertir números del 1 al 39999 al formato romano.</para> /// <para >Si desea poder trabajar con una gran cantidad de números romanos, debe agregar a la lista /// designaciones adicionales a partir de 40000 sin omitir los elementos 1*,4*,5*,9*.</para> /// </comentarios> public static SortedList < int , string > Números romanos básicos { get ; conjunto ; } static RomanNumber () { BasicRomanNumbers = new SortedList < int , string >( 17 ); Números romanos básicos . Añadir ( 1 , "yo" ); Números romanos básicos . Agregar ( 4 , "IV" ); Números romanos básicos . Añadir ( 5 , "V" ); Números romanos básicos . Añadir ( 9 , "IX" ); Números romanos básicos . Añadir ( 10 , "X" ); Números romanos básicos . Agregar ( 40 , "XL" ); Números romanos básicos . Añadir ( 50 , "L" ); Números romanos básicos . Añadir ( 90 , "XC" ); Números romanos básicos . Añadir ( 100 , "C" ); Números romanos básicos . Agregar ( 400 , "CD" ); Números romanos básicos . Añadir ( 500 , "D" ); Números romanos básicos . Añadir ( 900 , "CM" ); Números romanos básicos . Añadir ( 1000 , "M" ); Números romanos básicos . Añadir ( 4000 , "Mↁ" ); Números romanos básicos . Añadir ( 5000 , "ↁ" ); Números romanos básicos . Añadir ( 9000 , "Mↂ" ); Números romanos básicos . Añadir ( 10000 , "ↂ" ); } /// <summary> /// Calcula el número romano máximo posible para el alfabeto actual de números romanos. /// </summary> /// <returns>Máximo número romano posible</returns> public static uint MaxRomanNumber () { int lastNumber = BaseRomanNumbers . llaves _ último (); int numeroSinCeros = int . Analizar ( últimoNúmero . ToString (). Reemplazar ( '0' , '\0' )); int pre = 0 ; cambiar ( númeroSinCeros ) { caso 1 : anterior = últimoNúmero * 4 - 1 ; romper ; caso 4 : caso 9 : anterior = últimoNúmero ; romper ; caso 5 : preliminar = últimoNúmero + últimoNúmero / 5 * 3 ; romper ; predeterminado : romper ; } devolver uint . Analizar ( pre . ToString ( ). Reemplazar ( '0' , '9' ));; } /// <summary> /// Convierte un número entero a un número romano /// </summary> /// <param name="Número árabe">El número árabe que se convertirá a notación romana</param> // / <Exception cref="ArgumentOutOfRangeException">Lanzado cuando se pasa como parámetro un número igual a "0" /// o un número mayor que el número romano máximo.</exception> /// <returns>Una cadena que representa un Número romano</returns> public static string ArabicRoman ( this int numberArab ) { StringBuilder numberRoman = new StringBuilder (); //Excluye el signo "-" del número arábigo y conviértelo en el primer carácter del número romano if ( numberArab < 0 ) { numberRoman . agregar ( "-" ); numeroArabe = - numeroArabe ; } if ( numberArab == 0 ) arroja una nueva ArgumentOutOfRangeException ( "numberArab" , numberArab , "Valor de argumento no válido: los números romanos no pueden ser iguales a \"0\"" ); de lo contrario, si ( numberArab > MaxRomanNumber ()) lanza una nueva ArgumentOutOfRangeException ( "numberArab" , numberArab , string . Format ( "Valor de argumento no válido: no se puede especificar un número romano mayor que {0}" , MaxRomanNumber ())); //Descomponga el número arábigo en sus números romanos constituyentes y combínelos en una sola cadena var requiredBasicRomanNumbers = from to in BasicRomanNumbers . Teclas donde a <= numberArab orderby a descendiente seleccione a ; foreach ( int current in requiredBaseRomanNumbers ) { while (( numberArab / current ) >= 1 ) { numberArab - = current ; númeroromano . Agregar ( BaseRomanNumbers [ tecnología ]); } } número de retornoRoman . a la cadena (); } /// <summary> /// Convierte el número romano a árabe /// </summary> /// <param name="Roman number">Número romano a convertir a tipo int</param> /// <exception cref="FormatException">Se lanza cuando se pasa un número no romano como parámetro</exception> /// <returns>Un número entero que representa la notación árabe de un número romano</returns> public static int RomanToArabic ( esta cadena numberRoman ) { int número árabe = 0 ; sbyte negativo = 1 ; cadena romana = numeroromano . recortar (); if ( romano [ 0 ] == '-' ) { negativo = - 1 ; roma = roma . subcadena ( 1 ); } Plantilla StringBuilder RomanNumber = new StringBuilder (); foreach ( int to en Números Romanos Base . Claves ) { int index = Números Romanos Base . llaves _ índice de ( k ); cuantificador de cadena = "?" ; if ( índice == 0 || ( índice % 4 ) == 0 ) cuantificador = "{0,3}" ; plantilla de números romanos . Insertar ( 0 , cadena . Formato ( "(?<{0}>({1}){2})?" , a . ToString (), Números romanos básicos [ a ], cuantificador )); } //Ignorar mayúsculas y minúsculas + la coincidencia debe comenzar al principio de la cadena RomanNumber template . Insertar ( 0 , "(?i)^" ); //La coincidencia debe ocurrir al final de la cadena RomanNumber pattern . agregar ( "$" ); // Comprobación simplificada. No busca errores como IVII si (! Regex . IsMatch ( roman , patrón de números romanos . ToString ())) lanza una nueva FormatException ( cadena . Formato ( "Texto \"{0}\" no es un número romano" , número romano )); Número de coincidencia = expresión regular . Match ( roma , Patrón Número Romano . ToString ()); foreach ( int to en Números Romanos Base . Claves ) { numberArab += number . Grupos [ a . a la cadena ()]. Longitud / Números Romanos Básicos [ a ]. Longitud * a ; } número de retorno árabe * negativo ; } }

Notas

↑ Números y sistemas numéricos Archivado el 22 de noviembre de 2018 en Wayback Machine . Enciclopedia en línea alrededor del mundo.
↑ M. Ya. Vygodsky "Manual de matemáticas elementales" Moscú 1958 Editorial estatal de literatura física y matemática. página 62
↑ Beckham's road to Roman Archivado el 1 de mayo de 2020 en Wayback Machine // BBC , 17 de abril de 2002
↑ Estándar Unicode, 15.3 Archivado el 27 de junio de 2010 en Wayback Machine ("Para la mayoría de los propósitos, es preferible componer los números romanos a partir de secuencias de letras latinas apropiadas").
↑ 12 formularios numéricos Unicode . Consultado el 30 de marzo de 2009. Archivado desde el original el 25 de marzo de 2009. (indefinido)
↑ Perry, David J. Propuesta para agregar caracteres romanos antiguos adicionales a UCS Archivado el 22 de junio de 2011 en Wayback Machine .
↑ Para las dos primeras líneas
↑ Capítulo 31. Notación numérica romana :: Ideas de implementación . Fecha de acceso: 15 de octubre de 2015. Archivado desde el original el 18 de noviembre de 2015. (indefinido)
↑ "Ciencia y vida" N12 1986 página 95, V. Ptitsyn, Moscú
↑ Autor: Kuznetsov Evgeny A.
↑ Autor - Evgeny A. Kuznetsov, 1992