Convertir X-Illion en forme standard

14

Étant donné une chaîne, composée d'un préfixe puis de "illion", convertissez ce nombre en forme standard.

Par exemple:

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

Le programme doit être capable de gérer les entrées allant jusqu'à Centillion, soit 10 ^ 303. Une liste de noms et de leurs valeurs de formulaire standard peut être trouvée ici - notez que cela donne des valeurs pour chaque incrément de 10 ^ 3 jusqu'à 10 ^ 63, mais les donne ensuite par incréments de 10 ^ 30, cependant le modèle est assez simple.

Le programme doit gérer les 100 cas (même ceux qui ne sont pas explicitement indiqués par le site Web fourni) - en voici quelques exemples:

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

L'entrée peut être donnée via STDIN, argument de fonction ou codée en dur sous forme de chaîne.

C'est le code-golf, donc le code le plus court gagne!

code-golf math number kolmogorov-complexity James Williams
la source
Que serait 10 ^ 70?
Scimonster
3
10 ^ 70 n'a pas de représentation car 3 n'est pas un facteur de 70 - mais 10 ^ 69 serait sexvigintillion. 10 ^ 70 serait 10 sexvigintillion.
James Williams
En fait, doevigintillion = 10 ^ 69 et sexvigintillion = 10 ^ 81.
Remy
@Remy, je suppose que vous utilisez la longue échelle (si c'est vrai)? Il semble que cette question utilise l'échelle courte.
Cole Johnson
@Cole Johnson: La liste de noms fournie dans la question indique vigintillion = 10 ^ 63, et montre que dé- ajoute 3 au pouvoir, biche- ajoute 6, sexe- ajoute 18, etc.
Remy

Réponses:

11

Python 2 ( 384 368 365 348 347 octets)

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 ifligne est en retrait avec un seul onglet et le reste avec des espaces simples.)

Ici c('million') == 10**6doit être un cas spécial car 'novem'se termine également 'm'.

Exemples:

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

Merci à Falko de l'avoir obscurci jusqu'à 350 octets.

Pour m'entraîner, j'ai essayé de réécrire cela en une ligne avec des lambdas. C'est 404 398 390 384 380 379 octets:

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)
Rémy
la source
2
+1 pour avoir abusé du manque de spécification de OP quant à savoir si "10 ^ x" doit être imprimé ou s'il suffit de renvoyer la valeur numérique.
Ingo Bürk
1
Merci, mais return'10^'+str(3*k)ne serait que de 4 octets de plus.
Remy
1
Comme il s'agit de python 2, vous pouvez utiliser un retrait d'espace pour le premier niveau et un onglet pour le second. Vous pouvez également déplacer à la fois aet bdans la fonction comme arguments de mot clé.
FryAmTheEggman
2
1000**kest plus court que 10**(3*k). L'incrémentation kde 3*d[p]est également également courte.
2014
2
Vous pouvez enregistrer quelques caractères en évitant la sortie anticipée en utilisant if'm'==s:k=6;d=[]au lieu d'une deuxième longue returninstruction.
Falko
9

JS (ES6), 292 270

Comprend uniquement les nombres écrits dans la liste donnée. Le PO n'est pas clair sur les autres.

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

Exemple:

z("Billion") // "10^9"
z("Centillion") // "10^303"
xem
la source
Vous pouvez supprimer les zéros de la chaîne et les remplacer split(0)par match(/[A-Z][a-z]*/g)pour utiliser des expressions rationnelles correspondant à chaque chaîne.
NinjaBearMonkey
Cela ne gère que les préfixes "un, doe, tre, etc" pour le décillion. Il devrait également gérer des cas comme unvigintillion = 10 ^ 66 et novemnonagintillion = 10 ^ 300
Remy
Vous pouvez raccourcir cela en utilisant les fonctions ES6 =>.
soktinpk
Merci pour les conseils. @Remy êtes-vous sûr? le PO ne semble pas demander ça
xem
Il me semble clair que tous les multiples de 3 sont requis: "... cela donne des valeurs pour chaque incrément de 10 ^ 3 jusqu'à 10 ^ 63, mais les donne ensuite par incréments de 10 ^ 30, mais le schéma est assez simple" dans le OP. OP donne également un exemple de "sexvigintillion" dans un commentaire.
feersum
9

C, 235

Gère les 100 cas. Le programme utilise stdin et stdout.

Qui a besoin d'expressions régulières pour le fractionnement des caisses de chameaux?

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

Exemple

octoseptuagintillion
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
feersum
la source
1
Cette chose ne ressemble même plus à C ... Je suis étonné.
Quentin
Pourquoi l'espace ( *U<95 ?) et toutes les nouvelles lignes?
tomsmeding
@tomsmeding L'espace était un oubli. Les sauts de ligne rendent le code "lisible" et ne sont pas inclus dans le décompte.
feersum
2

Clojure, 381 377 octets

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

Exemple:

(c "Septuagintillion") ;; 1.0E213

Headmastersquall
la source
2

Haskell, 204 octets (+9 pour la chaîne formatée)

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

Dans GHCi:

*Main> x "decillion"
1000000000000000000000000000000000

Le remplacement 10^(par "10^"++(show.ajoute encore 9 octets:

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

Dans GHCi:

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

Edit: je devais corriger pour"quinquagintillion" ce qui contient "qua".

AplusKminus
la source