Dada uma única letra de A a Z (exceto J e K) como entrada, imprima o menor número inteiro não negativo que contém essa letra em sua forma escrita. Suponha que os números nunca contenham a palavra "e", assim 101como "cento e um", não "cento e um". Suponha a contagem americana (em pequena escala), então um milhão é 10^6e um bilhão é 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 e K não fazem parte da especificação de entrada, portanto, seu comportamento é indefinido para eles. Dada uma das letras acima, imprima o número (decimal) próximo a ela. Você pode receber entradas em minúsculas ou maiúsculas, mas não pode exigir que algumas entradas sejam minúsculas e outras maiúsculas.

Isso é código-golfe , então a resposta mais curta em bytes vence.

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

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

Experimente online!

Quão?

$[32..52]$$n-32$$[53..80]$$10^{n-53}$

Comentado

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 bytes

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

Experimente online!

Melhorias inspiradas no comentário do GB.

Ruby , 70 bytes

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

Experimente online!

/// , 125 bytes

/:/\/\///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/

Experimente online!

A entrada é anexado ao fim do código, como por E / S de meta . O rodapé no link TIO acima testa todas as letras simultaneamente, como uma única string delimitada por nova linha, mas o código também funciona bem ao inserir um único caractere .

Wolfram Language (Mathematica) , 50 bytes

As letras b, c, m, peq são ignoradas por motivos de desempenho ao testar no TIO.

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

Experimente online!

Stax , 33 bytes

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

Execute e depure

Procedimento:

1. Extrair o ponto de código da entrada.
2. Índice em matriz constante [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]usando o codepoint. (com envolvente)
3. Se o resultado for negativo, negue e aumente 10para esse poder, caso contrário, deixe como está.

Excel, 85 bytes

=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 golfe:

• O uso de expoentes (por exemplo 1E15) salva 26 bytes.
• O padrão de CHOOSEquando nada é fornecido é 0, salva4 bytes

05AB1E , 36 bytes

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

Porto da resposta Stax do @recursive .
Entrada em minúsculas.

Experimente online ou verifique todos os casos de teste .

Explicação:

•—ß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)

Consulte esta minha dica 05AB1E (seção Como compactar números inteiros grandes? E Como compactar listas de números inteiros? ) Para entender por que •—ßusδtθ}™-5„©‘öæH•é 3133432551338094772548436198140408157771728287e •—ßusδtθ}™-5„©‘öæH•57вé [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 bytes

$_=(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]

Experimente online!

Python 3 , 103 bytes

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]

Experimente online!

C # (Compilador interativo do Visual C #) , 77 74 68 bytes

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

$a \times 10^b$$a$$b$

Comentado

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

Experimente online!

Perl 6 , 67 bytes

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

Experimente online!

Usa uma tabela de pesquisa em que um número negativo significa que é o negativo do expoente, caso contrário, é o próprio número.

05AB1E , 32 bytes

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

Experimente online!

•н“вü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 bytes

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

Experimente online!

Experimente online!

Como funciona:

A=xDVw04835zzbA10SJ0624526k0

$ A: Base64 codificado "a" - "z": números menores que 100 são armazenados diretamente. Números maiores são codificados como o número de zeros +30. (ex: 1.000 = 33, 100 = 32, etc.)

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

Extraia uma letra de $ A na posição especificada no argumento $ 1 (base64 decodificada, -10 para contabilizar o deslocamento de 'a'). Base64 decodifica esse caractere e armazena em c.

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

Se $ c for maior que 30, imprima "1" preenchido com zeros de $ c-30. Senão, imprima $ c.

Marreta , 17 bytes

Tecnicamente, isso tem 133 bits, mas isso não gera 16.625 bytes, como afirma o compressor.

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

Provavelmente decodifica

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

(aproximadamente o mesmo que a minha resposta do Mathematica), embora mal o tenha codificado (parece que meu PC tem problemas de compatibilidade com tudo), então boa sorte decodificá-lo novamente para verificar. Posso ter cometido alguns erros ao usar o codificador, portanto, tenha cuidado.

Gelatina , 36 bytes

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

Experimente online!

Um link monádico usando uma letra minúscula como argumento e retornando um número inteiro. Retorna 0para je k.

Explicação

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 bytes

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

Experimente online! O link inclui casos de teste. Explicação:

^
$'

Duplique a entrada.

T`l`111104835__111011062452620`^.

Altere a primeira cópia para o (primeiro) dígito do resultado relevante.

T`abcm\pq`139285

Se o número tiver um múltiplo de três zeros à direita, obtenha esse múltiplo agora.

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

Na verdade, converta-o no número relevante de zeros à direita. (Observe que isso seria simplificado *3*0na Retina 1.)

d
00

Conserte d.

T`\lyl`10_

Arrumar le ye remover quaisquer cartas restantes.

PHP , 104 bytes

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

Experimente online!

Eu tenho uma seqüência de caracteres ^FX]0483500GC10UL0624526P0que contém um único caractere para cada letra de entrada de "a" a "z". Eu extraio esse caractere com base na entrada e o armazeno $a. Se o caractere não for um dígito, seu código ASCII mod 30 será armazenado $b.

Se $afor um dígito, o mesmo dígito é impresso, é usado para qualquer entrada que precise de uma saída entre 0 e 9 (como "e", "f", etc).

Caso $bcontrário, se for 20 ou 11, o mesmo número é impresso, é usado para "l" e "y".

Senão, o dígito "1" preenchido $bcom "0" s é impresso. Por exemplo, para a entrada de "a", o caractere é "^" que possui um código ASCII de 94. 94 % 30 = 4"1" preenchido com 4 e "0" s será "1000".