Avec une seule lettre de A à Z (sauf J et K) en entrée, indiquez le plus petit entier non négatif contenant cette lettre sous sa forme écrite. Supposons que les nombres ne contiennent jamais le mot "et", donc 101"cent un" et non "cent un". Supposons que les comptes américains (à petite échelle) comptent, donc un million 10^6et un milliard 10^9.

a 1000                           one thousand
b 1000000000                     one billion
c 1000000000000000000000000000   one octillion
d 100                            one hundred
e 0                              zero
f 4                              four
g 8                              eight
h 3                              three
i 5                              five
j 
k
l 11                             eleven
m 1000000                        one million
n 1                              one
o 0                              zero
p 1000000000000000000000000      one septillion
q 1000000000000000               one quadrillion
r 0                              zero
s 6                              six
t 2                              two
u 4                              four
v 5                              five
w 2                              two
x 6                              six
y 20                             twenty
z 0                              zero

J et K ne font pas partie de la spécification d'entrée, votre comportement n'est donc pas défini pour eux. Étant donné l’une des lettres ci-dessus, indiquez le nombre (décimal) à côté. Vous pouvez entrer des entrées en minuscules ou en majuscules, mais vous ne pouvez pas exiger que certaines entrées soient en minuscules et d'autres en majuscules.

C'est du code-golf , donc la réponse la plus courte en octets est gagnante.

JavaScript (Node.js) ,  78 75 74  73 octets

c=>(n=([x]=Buffer(c+'8>P7 $(#%  +;! MD &"$%"&4 '))[x-96]-53)<0?n+21:10**n

Essayez-le en ligne!

Comment?

Chaque valeur est codée avec un seul caractère imprimable. Nous utilisons la plage ASCII $[32..52]$ pour coder $n-32$ et la plage $[53..80]$ pour coder $10^{n-53}$ .

Commenté

c =>                                   // c = input character
  ( n =                                //
    ( [x] =                            // let x be the 1st byte of the
        Buffer(                        // buffer made of:
          c +                          //   c followed by
          '8>P7 $(#%  +;! MD &"$%"&4 ' //   the encoded values
        )                              //
    )[x - 96]                          // let n be the encoded value corresponding to c
    - 53                               // minus 53
  ) < 0 ?                              // if n is negative:
    n + 21                             //   return n + 21
  :                                    // else:
    10 ** n                            //   return 10 ** n

Ruby , 65 octets

->n{i="CI[B?;7<:??4F>?XO?9=;:=9+?"[n.ord-65].ord-64;i>0?10**i:~i}

Essayez-le en ligne!

Améliorations inspirées par le commentaire de GB.

Ruby , 70 octets

->n{i="ci}b@DHCE@@KfA@xo@FBDEBFT@"[n.ord-65].ord;i>96?10**(i-96):i-64}

Essayez-le en ligne!

/// , 125 octets

/:/\/\///T/000:d/100:a/d0:m/aT:b/aTT:q/bTT:p/qTTT:c/pT:e/0:f/4:g/8:h/3:i/5:l/11:n/1:o/0:r/0:s/6:t/2:u/4:v/5:w/2:x/6:y/20:z/0/

Essayez-le en ligne!

L' entrée est ajoutée à la fin du code, selon I / O meta . Le pied de page du lien TIO ci-dessus teste toutes les lettres simultanément, en tant que chaîne unique délimitée par des lignes, mais le code fonctionne également très bien lors de la saisie d' un seul caractère .

Wolfram Language (Mathematica) , 50 octets

Les lettres b, c, m, p et q sont ignorées pour des raisons de performances lors des tests sur TIO.

(i=0;While[1>StringCount[IntegerName@i,#],i++];i)&

Essayez-le en ligne!

Stax , 33 octets

º░¡µ?Äz*B╥╪╩ΓoΣ4ù↓|♂5%⌡ÿΩ²┼h{☻4O└

Exécuter et déboguer

Procédure:

1. Extrait le point de code de l'entrée.
2. Index dans un tableau constant en [3, 5, 7, 9, 11, -6, 1, 0, -24, -15, 0, 6, 2, 4, 5, 2, 6, 20, 0, -3, -9, -27, -2, 0, 4, 8]utilisant un point de code. (avec enveloppement)
3. Si le résultat est négatif, annulez et augmentez 10à ce pouvoir, sinon laissez tel quel.

Excel, 85 octets

=CHOOSE(CODE(A1)-96,1E3,1E9,1E27,100,,4,8,3,5,,,11,1E6,1,,1E24,1E15,,6,2,4,5,2,6,20,)

2 bits de Golfy:

• L'utilisation d'exposants (par exemple 1E15) enregistre 26 bytes.
• La valeur par défaut CHOOSElorsque rien n'est fourni est 0, enregistre4 bytes

05AB1E , 36 octets

•—ßusδtθ}™-5„©‘öæH•57в₆-sÇ`èD0‹iÄ°

Port de la réponse Stax de @recursive .
Entrée en minuscule.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

•—ßusδtθ}™-5„©‘öæH• # Push compressed integer 3133432551338094772548436198140408157771728287
 57в                  # Converted to base-57 as list: [39,41,43,45,47,30,37,36,12,21,36,42,38,40,41,38,42,56,36,33,27,9,34,36,40,44]
    ₆-                # Subtract 36 from each: [3,5,7,9,11,-6,1,0,-24,-15,0,6,2,4,5,2,6,20,0,-3,-9,-27,-2,0,4,8]
      sÇ`             # Swap to take the input, and convert it to its unicode value
         è            # Index it into the list (with automatic wraparound)
          D0‹i        # Create a copy, and if this is negative:
              Ä       #  Take the absolute value
               °      #  And then take 10 the power this value
                      # (implicitly output the top of the stack as result)

Voir cette astuce 05AB1E (section Comment compresser des entiers de grande taille? Et Comment compresser des listes d’entiers? ) Pour comprendre pourquoi •—ßusδtθ}™-5„©‘öæH•est 3133432551338094772548436198140408157771728287et •—ßusδtθ}™-5„©‘öæH•57вest [39,41,43,45,47,30,37,36,12,21,36,42,38,40,41,38,42,56,36,33,27,9,34,36,40,44].

Perl 5 -p , 84 octets

$_=(1e3,1e9,1e27,100,0,4,8,3,5,1,1,11,1e6,1,0,1e24,1e15,0,6,2,4,5,2,6,20,0)[-65+ord]

Essayez-le en ligne!

Python 3 , 103 octets

lambda x:(1000,10**9,10**27,100,0,4,8,3,5,0,0,11,10**6,1,0,10**24,10**15,0,6,2,4,5,2,6,20,0)[ord(x)-97]

Essayez-le en ligne!

C # (compilateur interactif Visual C #) , 77 74 68 octets

x=>((x="1‘Ʊ!  aƁñ"[x-65])&15)*Math.Pow(10,x>>4)

$a \times 10^b$$a$$b$ est représenté par les cinq bits suivants. Utilise des lettres majuscules.

Commenté

x=>                                                 //Lambda taking in a char
  (x=                                         )     //Re-assign x to
     "1‘Ʊ!   aƁñ"[x-65]      //The character's value at index x-65
 (                                             &15) //Bitwise AND by 15                                
  * Math.Pow(10,x>>4)                               // Multiplied by 10**(floor(x/16))

Essayez-le en ligne!

Perl 6 , 67 octets

{/\-/??10**-$_!!$_}o{'`ZHacgkfhccn]dcKTciegheiwc'.ords[.ord-97]-99}

Essayez-le en ligne!

Utilise une table de recherche où un nombre négatif signifie que c'est le négatif de l'exposant, sinon c'est le nombre lui-même.

05AB1E , 32 octets

•н“вüQ;æ¡ζæÀÛß%aÜ×₃t•56вsCè2‰`i°

Essayez-le en ligne!

•н“вüQ;æ¡ζæÀÛß%aÜ×₃t•56в  # compressed list:
# [31, 0, 12, 4, 8, 10, 4, 12, 40, 0, 7, 19, 55, 5, 0, 8, 16, 6, 10, 1, 1, 22, 13, 2, 0, 49]

s                         # swap so the input is at the top
 C                        # parse input as "binary" (a -> 36, b -> 37, ...)
  è                       # index (wraps around)
   2‰                     # divmod 2: [n / 2, n % 2]
     `                    # dump both on the stack
      i                   # if the modulo is 1:
       °                  #  10 ** the quotient
                          # implicit output

Bash , 129 à 100 octets

A=xDVw04835zzbA10SJ0624526k0
c=$[64#${A:$[64#$1-10]:1}]
[ $c -gt 30 ]&&printf 1%0$[c-30].0f||echo $c

Essayez-le en ligne!

Essayez-le en ligne!

Comment ça marche:

A=xDVw04835zzbA10SJ0624526k0

$ A: Base64 encodé "a" - "z": les nombres inférieurs à 100 sont stockés directement. Les grands nombres sont codés en tant que nombre de zéros +30. (ex: 1 000 = 33, 100 = 32, etc.)

c=$[64#${A:$[64#$1-10]:1}]

Extrayez une lettre de $ A à la position spécifiée dans l'argument $ 1 (décodé en base64, -10 pour prendre en compte le décalage de 'a'). Base64 décoder ce caractère et le stocker dans c.

[ $c -gt 30 ]&&printf 1%0$[c-30].0f||echo $c

Si $ c est supérieur à 30, écrivez "1" avec les zéros $ c-30. Sinon, imprimez $ c.

Sledgehammer , 17 octets

Techniquement, cela fait 133 bits, mais cela ne fait pas vraiment 16,625 octets, comme le prétend le compresseur.

⣜⢍⢞⢹⡱⡋⣽⡱⡆⢺⢦⡽⡐⡌⢗⠈⣵

Cela décode probablement à

x1 = Input[]; x2 = 0; While[StringFreeQ[IntegerName[x2], x1], x2++]; Print[x2]

(à peu près la même chose que ma réponse Mathematica), même si je l’ai à peine encodé (il semble que mon PC ait des problèmes de compatibilité avec tout), alors bonne chance pour le décoder à nouveau. J'ai peut-être commis des erreurs lors de l'utilisation de l'encodeur, alors soyez prudent.

Gelée , 36 octets

Oị“[@ịẆþĊ`o&÷ḲḞṘḂỊP¥t’b48¤_⁹⁵*ɗ¹>?20

Essayez-le en ligne!

Un lien monadique prenant une lettre minuscule comme argument et renvoyant un entier. Résultats0 pourj et k.

Explication

O                       | Convert to code point
 ị          ¤           | Index into following as a nilad (wraps around):
  “[...t’               | - Integer 5370441668223940717846370165240010583188867 (stored base 250)
         b48            | - Convert to base 48
                 ɗ >?20 | If >20, following as a dyad using 20 as right argument:
             _⁹         | - Subtract right argument (20)
               ⁵*       | - 10 to the power of this
                  ¹     | Else: leave unchanged (identity function)

Retina 0.8.2 , 89 octets

^
$'
T`l`111104835__111011062452620`^.
T`abcm\pq`139285
\d$
$*0$&$*0$&$*0
d
00
T`\lyl`10_

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

^
$'

Dupliquer l'entrée.

T`l`111104835__111011062452620`^.

Remplacez la première copie par le premier chiffre du résultat correspondant.

T`abcm\pq`139285

Si le nombre a un multiple de 3 zéros finaux, obtenez ce multiple maintenant.

\d$
$*0$&$*0$&$*0

Et convertissez-le en nombre correspondant de zéros à la fin. (Notez que cela simplifierait la *3*0tâche dans Retina 1.)

d
00

Réparer d.

T`\lyl`10_

Réparer let yet enlever les lettres restantes.

PHP , 104 octets

<?=A<($a='^FX]0483500GC10UL0624526P0'[ord($argn)-97])?20==($b=ord($a)%30)||11==$b?$b:str_pad(1,$b,0):$a;

Essayez-le en ligne!

J'ai une chaîne ^FX]0483500GC10UL0624526P0qui contient un seul caractère pour chaque lettre saisie de "a" à "z". J'extrais ce caractère en fonction des entrées et le stocke dans $a. Si le caractère n'est pas un chiffre, son code ASCII mod 30 sera enregistré dans $b.

Si $aest un chiffre, le même chiffre est imprimé, il est utilisé pour toute entrée nécessitant une sortie comprise entre 0 et 9 (comme "e", "f", etc.).

Sinon si $b est 20 ou 11, le même numéro est imprimé, il est utilisé pour "l" et "y".

Sinon, le chiffre "1" complété $bpar "0" est imprimé. Par exemple, pour la saisie de "a", le caractère est "^" qui a un code ASCII de 94. 94 % 30 = 4"1" complété à 4 avec "0" s sera "1000".