Dada una sola letra de la A a la Z (excepto J y K) como entrada, genera el número entero no negativo más pequeño que contiene esa letra en su forma escrita. Suponga que los números nunca contienen la palabra "y", así 101es "ciento uno", no "ciento uno". Suponga el recuento estadounidense (a pequeña escala), por lo que un millón es 10^6y mil millones es 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 y K no son parte de la especificación de entrada, por lo que su comportamiento no está definido para ellos. Dada una de las letras anteriores, muestra el número (decimal) al lado. Puede tomar la entrada en minúsculas o mayúsculas, pero no puede requerir que algunas entradas sean minúsculas y otras mayúsculas.

Este es el código de golf , por lo que gana la respuesta más corta en bytes.

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

Pruébalo en línea!

¿Cómo?

Cada valor está codificado con un solo carácter imprimible. Usamos el rango ASCII para codificar y el rango para codificar .$[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}

Pruébalo en línea!

Mejoras inspiradas en el comentario de GB.

Ruby , 70 bytes

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

Pruébalo en línea!

/// , 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/

Pruébalo en línea!

De entrada se añade al final del código, como por I / O meta . El pie de página en el enlace TIO anterior prueba todas las letras simultáneamente, como una sola cadena delimitada por una nueva línea, pero el código también funciona bien al ingresar un solo carácter .

Wolfram Language (Mathematica) , 50 bytes

Las letras b, c, m, p y q se omiten por razones de rendimiento al realizar pruebas en TIO.

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

Pruébalo en línea!

Stax , 33 bytes

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

Ejecutar y depurarlo

Procedimiento:

1. Extraer el punto de código de la entrada.
2. Indice en una 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]utilizando codepoint. (con envoltura)
3. Si el resultado es negativo, niegue y aumente 10a ese poder, de lo contrario, déjelo 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 golf:

• El uso de exponentes (por ejemplo 1E15) guarda 26 bytes.
• El valor predeterminado de CHOOSEcuando no se proporciona nada es 0, guarda4 bytes

05AB1E , 36 bytes

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

Puerto de la respuesta Stax de @recursive .
Entrada en minúsculas.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

Vea esta sugerencia mía 05AB1E (sección ¿Cómo comprimir enteros grandes? Y ¿Cómo comprimir listas enteras? ) Para comprender por qué •—ßusδtθ}™-5„©‘öæH•es 3133432551338094772548436198140408157771728287y •—ßusδtθ}™-5„©‘öæH•57вes [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]

Pruébalo en línea!

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]

Pruébalo en línea!

C # (compilador interactivo de 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))

Pruébalo en línea!

Perl 6 , 67 bytes

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

Pruébalo en línea!

Utiliza una tabla de búsqueda donde un número negativo significa que es el negativo del exponente; de ​​lo contrario, es el número mismo.

05AB1E , 32 bytes

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

Pruébalo en línea!

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

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

Pruébalo en línea!

Pruébalo en línea!

Cómo funciona:

A=xDVw04835zzbA10SJ0624526k0

$ A: Base64 codificado "a" - "z": los números inferiores a 100 se almacenan directamente. Los números más grandes se codifican como el número de ceros +30. (ej .: 1,000 = 33, 100 = 32, etc.)

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

Extraiga una letra de $ A en la posición especificada en el argumento $ 1 (base64 decodificada, -10 para tener en cuenta el desplazamiento de 'a'). Base64 decodifica ese personaje y lo almacena en c.

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

Si $ c es mayor que 30, imprima "1" rellenado con ceros $ c-30. De lo contrario, imprima $ c.

Almádena , 17 bytes

Técnicamente, esto tiene 133 bits de largo, pero eso realmente no genera 16.625 bytes, como afirma el compresor.

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

Esto probablemente decodifica a

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

(aproximadamente lo mismo que mi respuesta de Mathematica), aunque apenas lo codifiqué (parece que mi PC tiene problemas de compatibilidad con todo), así que buena suerte decodificándolo nuevamente para verificarlo. Podría haber cometido algunos errores al usar el codificador, así que tenga cuidado.

Jalea , 36 bytes

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

Pruébalo en línea!

Un enlace monádico que toma una letra minúscula como argumento y devuelve un entero. Devoluciones 0para jy k.

Explicación

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_

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

^
$'

Duplicar la entrada.

T`l`111104835__111011062452620`^.

Cambie la primera copia al (primer) dígito del resultado relevante.

T`abcm\pq`139285

Si el número tiene un múltiplo de 3 ceros finales, obtén ese múltiplo ahora.

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

Y en realidad conviértalo en el número relevante de ceros finales. (Tenga en cuenta que esto se simplificaría *3*0en Retina 1.)

d
00

Arreglar d.

T`\lyl`10_

Arreglar ly yy eliminar cualquier resto de los caracteres.

PHP , 104 bytes

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

Pruébalo en línea!

Tengo una cadena ^FX]0483500GC10UL0624526P0que contiene un solo carácter para cada letra de entrada de "a" a "z". Extraigo este carácter en función de la entrada y lo almaceno $a. Si el carácter no es un dígito, su código ASCII mod 30 se almacenará en $b.

Si $aes un dígito, se imprime el mismo dígito, esto se usa para cualquier entrada que necesite una salida entre 0 y 9 (como "e", "f", etc.).

De lo contrario, si $bes 20 u 11, se imprime el mismo número, esto se usa para "l" e "y".

De lo contrario, $bse imprime el dígito "1" rellenado con "0". Por ejemplo, para la entrada de "a", el carácter es "^" que tiene un código ASCII de 94. 94 % 30 = 4y "1" rellenado a 4 con "0" s será "1000".