접두사와 "illion"으로 구성된 문자열이 제공되면이 숫자를 표준 형식으로 변환하십시오.

예를 들면 다음과 같습니다.

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

이 프로그램은 Centillion (10 ^ 303)까지 올라가는 입력을 처리 할 수 ​​있어야합니다. 이름과 표준 형식 값 목록은 여기 에서 찾을 수 있습니다. 이 값은 10 ^ 3 단위로 최대 10 ^ 63까지 값을 제공하지만 10 ^ 30 단위로 값을 제공하지만 패턴은 매우 간단합니다.

이 프로그램은 100 가지 사례를 모두 처리해야합니다 (제공된 웹 사이트에서 명시 적으로 제공하지 않은 경우도 포함)-여기에 몇 가지 예가 있습니다.

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

입력은 STDIN, 함수 인수 또는 문자열로 하드 코딩되어 제공 될 수 있습니다.

이것은 코드 골프이므로 가장 짧은 코드가 승리합니다!

파이썬 2 ( 384 368 365 348 347 바이트)

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)

( if라인은 단일 탭으로 들여 쓰기되고 나머지는 단일 공백으로 들여 쓰기됩니다.)

여기에 c('million') == 10**6있기 때문에 특별한 경우이어야 'novem'도에 끝납니다 'm'.

예 :

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

350 바이트로 난독 처리 한 Falko에게 감사합니다.

실제로 나는 이것을 람다를 사용하여 하나의 라이너로 다시 작성하려고 시도했습니다. 그건 404 398 390 384 380 379 바이트 :

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

주어진 목록에 쓰여진 숫자 만 이해합니다. OP는 다른 사람들에 대해 명확하지 않습니다.

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))}

예:

z("Billion") // "10^9"
z("Centillion") // "10^303"

C, 235

100 건을 모두 처리합니다. 프로그램은 stdin과 stdout을 사용합니다.

낙타 케이스 분할을 위해 정규식이 필요한 사람은 누구입니까?

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);
}

예

octoseptuagintillion
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

클로저, 381 377 바이트

(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)))

예:

(c "Septuagintillion") ;; 1.0E213

Haskell, 204 바이트 (형식화 된 문자열의 경우 +9)

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

GHCi에서 :

*Main> x "decillion"
1000000000000000000000000000000000

대체 10^(하면 "10^"++(show.다른 9 바이트 가 추가됩니다.

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

GHCi에서 :

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

편집 :"quinquagintillion" 포함하는에 대해 수정해야했습니다 "qua".