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!

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)

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"

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

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

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".