Primo numero per contenere ogni lettera

41

Data una singola lettera dalla A alla Z (tranne J e K) come input, genera il numero intero non negativo più piccolo contenente quella lettera nella sua forma scritta. Supponiamo che i numeri non contengano mai la parola "e", quindi 101"centouno", non "centouno". Assumi il conteggio americano (su scala ridotta), quindi un milione è 10^6e un miliardo lo è 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 non fanno parte delle specifiche di input, quindi il tuo comportamento non è definito per loro. Data una delle lettere sopra, genera il numero (decimale) accanto ad essa. È possibile accettare input in minuscolo o maiuscolo, ma non è possibile richiedere che alcuni input siano minuscoli e altri maiuscoli.

Questo è code-golf , quindi vince la risposta più breve in byte.

code-golf  number  kolmogorov-complexity 
— Stefano
fonte
11
Non sono del tutto sicuro del motivo per cui questa sfida è stata votata così in basso? Per quanto posso vedere, è chiaro e in tema. Sicuramente è molto probabile che codifichi ciascuna lettera con il numero corrispondente, ma non penso che giustifichi 3 downgrade?
— caird coinheringaahing
2
@Giona ha aggiunto, grazie per il feedback
— Stephen
10
Stai dicendo che "un bajillion" non è un numero reale?
— Jo King,
2
@JoKing cos'è la rappresentazione decimale? :)
— Stephen,
8
Suppongo che un utente StackExchange che pensa che k non possa apparire nel nome di un numero sia piuttosto imbarazzante nell'immaginazione.
— Andrew Grimm,

Risposte:

16

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

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

Provalo online!

Come?

Ogni valore è codificato con un singolo carattere stampabile. Usiamo l'intervallo ASCII [32..52] per codificare n−32 e l'intervallo [53..80] per codificare 10n−53

Commentate

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
fonte
6

/// , 125 byte

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

Provalo online!

L'ingresso è aggiunto alla fine del codice, come da / O meta I . Il piè di pagina nel collegamento TIO sopra verifica tutte le lettere contemporaneamente, come una singola stringa delimitata da una nuova riga, ma il codice funziona anche bene quando si inserisce un singolo carattere .

— sette negativi
fonte
6

Stax , 33 byte

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

Esegui ed esegui il debug

Procedura:

  1. Estrai il punto di codice dall'input.
  2. Indicizza in array costante [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 codepoint. (con avvolgente)
  3. Se il risultato è negativo, nega e aumenta 10a quel potere, altrimenti lascia così com'è.
— ricorsivo
fonte
6

Excel, 85 byte

=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 punte da golf:

  • L'uso di esponenti (ad es. 1E15) Consente di salvare 26 bytes.
  • L'impostazione predefinita di CHOOSEquando non viene fornito nulla è 0, salva4 bytes
— Wernisch
fonte
4

05AB1E , 36 byte

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

La risposta Stax di Port of @recursive .
Input in minuscolo.

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Vedi questo mio suggerimento 05AB1E (sezione Come comprimere numeri interi grandi? E Come comprimere gli elenchi di numeri interi? ) Per capire perché •—ßusδtθ}™-5„©‘öæH•è 3133432551338094772548436198140408157771728287ed •—ß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].

— Kevin Cruijssen
fonte
2
32 . 05AB1E non dovrebbe perdere a Stax!
— Grimmy,
3

C # (compilatore interattivo Visual C #) , 77 74 68 byte

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

Codifica l'output di ogni lettera come un'×10B, dove un' è rappresentato dai 4 bit più bassi del personaggio, mentre Bè rappresentato dai successivi cinque bit successivi. Utilizza lettere maiuscole.

Commentate

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

Provalo online!

— Incarnazione dell'ignoranza
fonte
2

Perl 6 , 67 byte

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

Provalo online!

Utilizza una tabella di ricerca in cui un numero negativo indica che è il negativo dell'esponente, altrimenti è il numero stesso.

— Jo King
fonte
2

05AB1E , 32 byte

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

Provalo 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
— Grimmy
fonte
Non ho ancora 'binary'capito bene, ahah. xD Ma immagino che a volte possa essere utile così. ;)
— Kevin Cruijssen il
2

Bash , 129 100 byte

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

Provalo online!

Provalo online!

Come funziona:

A=xDVw04835zzbA10SJ0624526k0

$ A: Base64 codificato "a" - "z": i numeri inferiori a 100 vengono memorizzati direttamente. I numeri più grandi sono codificati come il numero di zeri +30. (es: 1.000 = 33, 100 = 32, ecc.)

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

Estrarre una lettera da $ A nella posizione specificata nell'argomento $ 1 (base64 decodificato, -10 per tenere conto dell'offset di 'a'). Base64 decodifica quel personaggio e lo memorizza in c.

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

Se $ c è maggiore di 30, stampa "1" riempito con zeri $ c-30. Altrimenti, stampa $ c.

— Spuck
fonte
2

Mazza , 17 byte

Tecnicamente, questo è lungo 133 bit, ma questo non rende davvero questo 16.625 byte, come afferma il compressore.

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

Questo probabilmente decodifica in

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

(approssimativamente lo stesso della mia risposta Mathematica), anche se a malapena l'ho codificato (sembra che il mio PC abbia problemi di compatibilità con tutto), quindi buona fortuna decodificalo di nuovo per controllare. Potrei aver commesso degli errori durante l'utilizzo dell'encoder, quindi fai attenzione.

— il mio pronome è monicareinstate
fonte
1

Gelatina , 36 byte

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

Provalo online!

Un collegamento monadico che prende una lettera minuscola come argomento e restituisce un numero intero. Restituisce 0per je k.

Spiegazione

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
fonte
1

Retina 0.8.2 , 89 byte

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

Provalo online! Il link include casi di test. Spiegazione:

^
$'

Duplica l'input.

T`l`111104835__111011062452620`^.

Cambia la prima copia nella (prima) cifra del risultato rilevante.

T`abcm\pq`139285

Se il numero ha un multiplo di 3 zeri finali, prendilo subito.

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

E effettivamente convertirlo nel numero rilevante di zeri finali. (Si noti che questo semplificherebbe *3*0in Retina 1.)

d
00

Risolvi d.

T`\lyl`10_

Sistemare le ye rimuovere tutte le lettere rimanenti.

— Neil
fonte
1

PHP , 104 byte

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

Provalo online!

Ho una stringa ^FX]0483500GC10UL0624526P0che contiene un singolo carattere per ogni lettera di input da "a" a "z". Estraggo questo personaggio in base all'input e lo memorizzo $a. Se il carattere non è una cifra, verrà memorizzato il suo codice ASCII mod 30 $b.

Se $aè una cifra, viene stampata la stessa cifra, utilizzata per qualsiasi input che necessita di un output compreso tra 0 e 9 (come "e", "f", ecc.).

Altrimenti se $bè 20 o 11, viene stampato lo stesso numero, questo viene usato per "l" e "y".

Altrimenti, $bviene stampata la cifra "1" riempita con "0". Ad esempio per l'immissione di "a", il carattere è "^" che ha un codice ASCII di 94. 94 % 30 = 4e "1" riempito con 4 con "0" sarà "1000".

— night2
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.