Przekształć x-illion w standardową formę

14

Biorąc pod uwagę ciąg znaków, składający się z przedrostka, a następnie „iluzji”, zamień ten numer na standardową.

Na przykład:

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

Program musi być w stanie obsłużyć dane wejściowe dochodzące do Centillion, czyli 10 ^ 303. Listę nazw i ich standardowych wartości formularza można znaleźć tutaj - pamiętaj, że daje to wartości dla każdego przyrostu 10 ^ 3 do 10 ^ 63, ale następnie daje je w przyrostach 10 ^ 30, jednak wzór jest dość prosty.

Program musi obsłużyć wszystkie 100 przypadków (nawet te, które nie zostały wyraźnie podane przez podaną stronę internetową) - oto kilka przykładów:

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

Dane wejściowe można podać za pomocą STDIN, argumentu funkcji lub na stałe zakodować jako ciąg.

To jest golf golfowy, więc wygrywa najkrótszy kod!

code-golf math number kolmogorov-complexity James Williams
źródło
Co by to było 10 ^ 70?
Scimonster,
3
10 ^ 70 nie ma reprezentacji, ponieważ 3 nie jest współczynnikiem 70 - ale 10 ^ 69 to sexvigintillion. 10 ^ 70 to 10vigintillion.
James Williams
W rzeczywistości doevigintillion = 10 ^ 69, a sexvigintillion = 10 ^ 81.
Remy,
@Remy Zgaduję, że używasz dużej skali (jeśli to prawda)? Wygląda na to, że to pytanie używa krótkiej skali.
Cole Johnson
@Cole Johnson: Podana lista pytań zawiera vigintillion = 10 ^ 63 i pokazuje, że un- dodaje 3 do mocy, doe dodaje 6, sex- dodaje 18 itd.
Remy

Odpowiedzi:

11

Python 2 ( 384 368 365 348 347 bajtów)

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)

( ifLinia jest wcięta za pomocą jednej tabulacji, a pozostałe za pomocą pojedynczych spacji.)

To c('million') == 10**6musi być szczególny przypadek, ponieważ 'novem'również kończy się na 'm'.

Przykłady:

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

Dzięki Falko za zaciemnienie go do 350 bajtów.

Do ćwiczeń próbowałem przepisać to jako liniówkę przy użyciu lambdas. Ma 404 398 390 384 380 379 bajtów:

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
źródło
2
+1 za nadużywanie braku specyfikacji OP, czy „10 ^ x” powinno zostać wydrukowane, czy też wystarczy zwrócenie wartości liczbowej.
Ingo Bürk
1
Dzięki, chociaż return'10^'+str(3*k)byłoby tylko 4 bajty więcej.
Remy
1
Ponieważ jest to python 2, możesz użyć wcięcia spacji dla pierwszego poziomu i tabulacji dla drugiego poziomu. Można także przenieść zarówno ai bdo funkcji jako argumenty kluczowe.
FryAmTheEggman
2
1000**kjest krótszy niż 10**(3*k). Zwiększenie ko 3*d[p]jest również równie krótkie.
xnor
2
Możesz zapisać kilka znaków, unikając wcześniejszego wyjścia if'm'==s:k=6;d=[]zamiast drugiej długiej returninstrukcji.
Falko
9

JS (ES6), 292 270

Rozumie tylko liczby zapisane na podanej liście. OP nie ma jasności co do pozostałych.

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

Przykład:

z("Billion") // "10^9"
z("Centillion") // "10^303"
Xem
źródło
Możesz usunąć zera z ciągu i zastąpić split(0)go, match(/[A-Z][a-z]*/g)aby użyć wyrażeń regularnych w celu dopasowania każdego ciągu.
NinjaBearMonkey
To obsługuje tylko przedrostki „un, doe, tre itp.” Dla decylionu. Powinien także obsługiwać przypadki takie jak unvigintillion = 10 ^ 66 i novemnonagintillion = 10 ^ 300
Remy
Możesz to skrócić, używając funkcji ES6 =>.
soktinpk
dzięki za wskazówki. @Remy jesteś pewien? OP nie wydaje się tego pytać
xem.
Wydaje mi się jasne, że wszystkie wielokrotności liczby 3 są wymagane: „... daje to wartości dla każdego przyrostu 10 ^ 3 do 10 ^ 63, ale następnie daje je w przyrostach 10 ^ 30, jednak wzór jest dość prosty” w OP. Również OP podaje w komentarzu przykład „sexvigintillion”.
feersum
9

C, 235

Obsługuje wszystkie 100 skrzynek. Program używa stdin i stdout.

Kto potrzebuje wyrażeń regularnych do dzielenia wielbłądów?

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

Przykład

octoseptuagintillion
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
feersum
źródło
1
Ta rzecz już nawet nie wygląda jak C ... Jestem zdumiony.
Quentin
Dlaczego spacja ( *U<95 ?) i wszystkie nowe znaki?
tomsmeding
@tomsmeding Przestrzeń była niedopatrzeniem. Nowe wiersze sprawiają, że kod jest „czytelny” i nie są uwzględniane w liczeniu.
feersum
2

Clojure, 381 377 bajtów

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

Przykład:

(c "Septuagintillion") ;; 1.0E213

Headmastersquall
źródło
2

Haskell, 204 bajty (+9 dla sformatowanego ciągu znaków)

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

W GHCi:

*Main> x "decillion"
1000000000000000000000000000000000

Zastąpienie 10^(przez "10^"++(show.dodaje kolejne 9 bajtów:

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

W GHCi:

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

Edycja: Musiałem poprawić, "quinquagintillion"który zawiera "qua".

AplusKminus
źródło