41

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.

code-golf number kolmogorov-complexity

— Stephen
fuente

11

No estoy muy seguro de por qué este desafío se ha rechazado tanto. Hasta donde puedo ver, es claro y sobre el tema. Claro, lo más probable es que simplemente esté codificando cada letra a su número correspondiente, pero no creo que eso justifique 3 votos negativos.

— caird coinheringaahing

2

@Jonah agregó, gracias por los comentarios

— Stephen

10

¿Estás diciendo que "un billón" no es un número real?

— Jo King

2

@JoKing, ¿qué es la representación decimal? :)

— Stephen

8

Creo que un usuario de StackExchange que piensa que k no puede aparecer en el nombre de un número es más bien vago en imaginación.

— Andrew Grimm

16

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

— Arnauld
fuente

7

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!

— Level River St
fuente

67 bytes

— GB

@GB gracias, la idea de tener valores negativos para ifue útil. Ahora baja a 65.

— Level River St

6

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

— siete negativo
fuente

6

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!

— alguien
fuente

41 bytes

— attinat

6

Stax , 33 bytes

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

Ejecutar y depurarlo

Procedimiento:

Extraer el punto de código de la entrada.
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)
Si el resultado es negativo, niegue y aumente 10a ese poder, de lo contrario, déjelo como está.

— recursivo
fuente

6

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

— Wernisch
fuente

4

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].

— Kevin Cruijssen
fuente

2

32 . 05AB1E no debe perder con Stax!

— Grimmy

3

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!

— Xcali
fuente

72 bytes usando la tabla de búsqueda de la solución Perl 6 de @ JoKing

— Nahuel Fouilleul

3

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!

— Jitse
fuente

3

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!

— Encarnación de la ignorancia
fuente

2

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.

— Jo King
fuente

2

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

— Mugriento
fuente

Todavía no entiendo eso 'binary', jaja. xD Pero supongo que a veces puede ser útil así. ;)

— Kevin Cruijssen

2

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.

— golpear
fuente

2

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.

— alguien
fuente

1

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)

— Nick Kennedy
fuente

1

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.

— Neil
fuente

1

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".

— Noche2
fuente

Primer número que contiene cada letra

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

¿Cómo?

Comentado

Ruby , 65 bytes

Ruby , 70 bytes

/// , 125 bytes

Wolfram Language (Mathematica) , 50 bytes

Stax , 33 bytes

Procedimiento:

Excel, 85 bytes

05AB1E , 36 bytes

Perl 5 -p , 84 bytes

Python 3 , 103 bytes

C # (compilador interactivo de Visual C #) , 77 74 68 bytes

Perl 6 , 67 bytes

05AB1E , 32 bytes

Bash , 129100 bytes

Cómo funciona:

Almádena , 17 bytes

Jalea , 36 bytes

Explicación

Retina 0.8.2 , 89 bytes

PHP , 104 bytes

Perl 5 `-p` , 84 bytes