Convierte x-illion en forma estándar

14

Dada una cadena, que consiste en un prefijo y luego "ilión", convierte este número en forma estándar.

Por ejemplo:

"million" -> 10^6
"trillion" -> 10^12
"quattuordecillion" -> 10^45

El programa debe ser capaz de manejar la entrada que va hasta Centillion, que es 10 ^ 303. Aquí se puede encontrar una lista de nombres y sus valores de forma estándar ; tenga en cuenta que esto proporciona valores por cada incremento de 10 ^ 3 hasta 10 ^ 63, pero luego los proporciona en incrementos de 10 ^ 30, sin embargo, el patrón es bastante sencillo.

El programa debe manejar los 100 casos (incluso los que no se proporcionan explícitamente en el sitio web proporcionado). Aquí hay algunos ejemplos de esto:

"sexvigintillion" -> 10^81
"unnonagintillion" -> 10^276
"octotrigintillion" -> 10^117

La entrada se puede proporcionar a través de STDIN, argumento de función o codificado como una cadena.

Este es el código de golf, ¡el código más corto gana!

code-golf math number kolmogorov-complexity James Williams
fuente
¿Cuáles serían 10 ^ 70?
Scimonster
3
10 ^ 70 no tiene una representación porque 3 no es un factor de 70, pero 10 ^ 69 sería sexvigintillion. 10 ^ 70 serían 10 sexvigintillones.
James Williams
En realidad, doevigintillion = 10 ^ 69, y sexvigintillion = 10 ^ 81.
Remy
@Remy, ¿supongo que usa la escala larga (si es así)? Parece que esta pregunta usa la escala corta.
Cole Johnson
@Cole Johnson: la lista de nombres proporcionada por la pregunta dice vigintillion = 10 ^ 63, y muestra que elimina 3 al poder, doe, agrega 6, sexo, agrega 18, etc.
Remy

Respuestas:

11

Python 2 ( 384 368 365 348 347 bytes)

def c(s):
 s=s[:-6].replace('int','');k=0;d=dict(un=1,doe=2,tre=3,quattuor=4,quin=5,sex=6,septen=7,octo=8,novem=9,b=3,tr=4,quadr=5,qu=6,sext=7,sept=8,oct=9,non=10,dec=11,vig=21,trig=31,quadrag=41,quinquag=51,sexag=61,septuag=71,octog=81,nonag=91,cent=101)
 for p in(s!='m')*list(d)*2:
    if s.endswith(p):s=s[:-len(p)];k+=3*d[p]
 return 10**(k or 6)

(La iflínea está sangrada con una sola pestaña y el resto con espacios individuales).

Aquí c('million') == 10**6tiene que haber un caso especial porque 'novem'también termina en 'm'.

Ejemplos:

c('million') == 10**6
c('trillion') == 10**12
c('quattuordecillion') == 10**45
c('novemnonagintillion') == 10**300
c('centillion') == 10**303

Gracias a Falko por ofuscarlo hasta 350 bytes.

Para practicar intenté reescribir esto como una línea usando lambdas. Son 404 398 390 384 380 379 bytes:

c=lambda s:(lambda t=[s[:-5].replace('gint',''),0],**d:([t.__setslice__(0,2,[t[0][:-len(p)],t[1]+3*d[p]])for p in 2*list(d)if t[0].endswith(p)],10**t[1])[1])(un=1,doe=2,tre=3,quattuor=4,quin=5,sex=6,septen=7,octo=8,novem=9,mi=2,bi=3,tri=4,quadri=5,qui=6,sexti=7,septi=8,octi=9,noni=10,deci=11,vii=21,trii=31,quadrai=41,quinquai=51,sexai=61,septuai=71,octoi=81,nonai=91,centi=101)
Remy
fuente
2
+1 por abusar de la falta de especificación de OP sobre si se debe imprimir "10 ^ x" o si es suficiente devolver el valor numérico.
Ingo Bürk
1
Gracias, aunque return'10^'+str(3*k)solo serían 4 bytes más.
Remy
1
Como se trata de Python 2, puede usar una sangría de espacio para el primer nivel y una pestaña para el segundo. También puede mover tanto ay ben la función como argumentos de palabra clave.
FryAmTheEggman
2
1000**kes más corto que 10**(3*k). Incrementar ken 3*d[p]también es igualmente corto.
xnor
2
Puede guardar algunos caracteres evitando la salida anticipada usando en if'm'==s:k=6;d=[]lugar de una segunda returndeclaración larga .
Falko
9

JS (ES6), 292 270

Entiende solo los números escritos en la lista dada. El OP no está claro sobre los demás.

z=b=>{a="M0B0Tr0Quadr0Quint0Sext0Sept0Oct0Non0Dec0Undec0Doedec0Tredec0Quattuordec0Quindec0Sexdec0Septendec0Octodec0Novemdec0Vigint0Trigint0Quadragint0Quinquagint0Sexagint0Septuagint0Octogint0Nonagint0Cent".split(0);for(i in a)if(~b.indexOf(a[i]))return"10^"+(20>i?3*i+6:93+30*(i-20))}

Ejemplo:

z("Billion") // "10^9"
z("Centillion") // "10^303"
xem
fuente
Puede eliminar los ceros en la cadena y reemplazar split(0)con match(/[A-Z][a-z]*/g)el uso de expresiones regulares para que coincida con cada cadena.
NinjaBearMonkey
Esto solo maneja los prefijos "un, doe, tre, etc." para decillion. También debería manejar casos como unvigintillion = 10 ^ 66 y novemnonagintillion = 10 ^ 300
Remy
Puede acortar esto usando las funciones de ES6 =>.
soktinpk
Gracias por los consejos. @Remy, ¿estás seguro? el OP no parece preguntar eso
xem
Me parece claro que se requieren todos los múltiplos de 3: "... esto da valores para cada incremento de 10 ^ 3 hasta 10 ^ 63, pero luego los da en incrementos de 10 ^ 30, sin embargo, el patrón es bastante sencillo" en el OP. También OP da un ejemplo de "sexvigintillion" en un comentario.
feersum
9

C, 235

Maneja los 100 casos. El programa usa stdin y stdout.

¿Quién necesita expresiones regulares para la división de casos de camellos?

char*Z="UUUi+W<)E(<7-7-++*)('&%$,*$&%$",u[999]="\0MBRilDriPtiNiUnOeReTtUiXTeCtVeCiGRigRaUagInquiXaXsexPtuOgOoNaCeCeK1",s[99],*U=u+67;
main(n){
for(gets(s);*--U;)
*U<95?
*U|=32,
n+=!!strstr(s,U)*(*Z++-35),
*U=0:
3;puts(memset(u+68,48,3*n)-1);
}

Ejemplo

octoseptuagintillion
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Feersum
fuente
1
Esto ya ni siquiera se parece a C ... Estoy asombrado.
Quentin
¿Por qué el espacio ( *U<95 ?) y todas las nuevas líneas?
tomsmeding
@tomsmeding El espacio fue un descuido. Las nuevas líneas hacen que el código sea "legible" y no se incluyen en el recuento.
feersum
2

Clojure, 381 377 bytes

(defn c[x](let[l{"M"6"B"9"Tr"12"Quadr"15"Quint"18"Sext"21"Sept"24"Oct"27"Non"30"Dec"33"Undec"36"Doedec"39"Tredec"42"Quattuordec"45"Quindec"48"Sexdec"51"Septendec"54"Octodec"57"Novemdec"60"Vigint"63"Trigint"93"Googol"100"Quadragint"123"Quinquagint"153"Sexagint"183"Septuagint"213"Octogint"243"Nonagint"273"Cent"303}v(l(clojure.string/replace x #"illion$" ""))](Math/pow 10 v)))

Ejemplo:

(c "Septuagintillion") ;; 1.0E213

Headmastersquall
fuente
2

Haskell, 204 bytes (+9 para cadena formateada)

import Data.List
x s=10^(f$[a|k<-tails s,i<-inits k,(b,a)<-zip["ce","ad","un","do","b","mi","vi","tr","at","ui","x","p","oc","no","ec","g"]$100:4:1:2:2:[1..],b==i])
f[]=3
f(x:11:r)=30*x+f r
f(x:r)=3*x+f r

En GHCi:

*Main> x "decillion"
1000000000000000000000000000000000

Reemplazar 10^(con "10^"++(show.agrega otros 9 bytes:

import Data.List
x s="10^"++(show.f$[a|k<-tails s,i<-inits k,(b,a)<-zip["ce","ad","un","do","b","mi","vi","tr","at","ui","x","p","oc","no","ec","g"]$100:4:1:2:2:[1..],b==i])
f[]=3
f(x:11:r)=30*x+f r
f(x:r)=3*x+f r

En GHCi:

*Main> x "decillion"
"10^33"

Editar: tuve que corregir "quinquagintillion"cuál contiene "qua".

AplusKminus
fuente