Biorąc jedną literę od A do Z (z wyjątkiem J i K) jako dane wejściowe, wypisz najmniejszą nieujemną liczbę całkowitą zawierającą tę literę w formie pisemnej. Załóżmy, że liczby nigdy nie zawierają słowa „i”, podobnie jak 101„sto jeden”, a nie „sto jeden”. Załóżmy, że liczenie w Ameryce (na małą skalę), więc milion to 10^6jeden miliard 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 i K nie są częścią specyfikacji wejściowej, więc twoje zachowanie jest dla nich niezdefiniowane. Biorąc pod uwagę jedną z powyższych liter, wypisz (dziesiętną) liczbę obok niej. Można pobierać dane małymi lub dużymi literami, ale nie można wymagać, aby niektóre dane były pisane małymi literami, a inne dużymi literami.

To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.

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

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

Wypróbuj online!

W jaki sposób?

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

Skomentował

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

Rubinowy , 65 bajtów

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

Wypróbuj online!

Ulepszenia inspirowane komentarzem GB.

Rubinowy , 70 bajtów

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

Wypróbuj online!

/// , 125 bajtów

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

Wypróbuj online!

Dane wejściowe są dołączane na końcu kodu, zgodnie z meta we / wy . Stopka w powyższym linku TIO testuje jednocześnie wszystkie litery, jako pojedynczy ciąg rozdzielany znakiem nowej linii, ale kod działa również dobrze przy wprowadzaniu pojedynczego znaku .

Wolfram Language (Mathematica) , 50 bajtów

Litery b, c, m, p i q są pomijane ze względu na wydajność podczas testowania na TIO.

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

Wypróbuj online!

Stax , 33 bajty

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

Uruchom i debuguj

Procedura:

1. Wyodrębnij kod z punktu wejściowego.
2. Indeksuj do stałej tablicy [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]za pomocą punktu kodowego. (z zawijaniem)
3. Jeśli wynik jest negatywny, zaneguj i podnieś 10do tej mocy, w przeciwnym razie pozostaw bez zmian.

Excel, 85 bajtów

=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 bity Golfy:

• Używanie wykładników (np. 1E15) Zapisuje 26 bytes.
• Domyślnie, CHOOSEgdy nic nie jest podane 0, zapisuje4 bytes

05AB1E , 36 bajtów

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

Port odpowiedzi Stax @recursive .
Wprowadzaj małymi literami.

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

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

Zobacz moją wskazówkę 05AB1E (sekcja Jak kompresować duże liczby całkowite? I Jak kompresować listy liczb całkowitych? ), Aby zrozumieć, dlaczego •—ßusδtθ}™-5„©‘öæH•jest 3133432551338094772548436198140408157771728287i •—ßusδtθ}™-5„©‘öæH•57вjest [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 bajtów

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

Wypróbuj online!

Python 3 , 103 bajty

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]

Wypróbuj online!

C # (interaktywny kompilator Visual C #) , 77 74 68 bajtów

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

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

Skomentował

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

Wypróbuj online!

Perl 6 , 67 bajtów

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

Wypróbuj online!

Używa tabeli odnośników, w której liczba ujemna oznacza, że ​​jest ujemna wykładnika wykładniczego, w przeciwnym razie jest to sama liczba.

05AB1E , 32 bajty

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

Wypróbuj 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 bajtów

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

Wypróbuj online!

Wypróbuj online!

Jak to działa:

A=xDVw04835zzbA10SJ0624526k0

$ A: Base64 zakodowane „a” - „z”: liczby mniejsze niż 100 są przechowywane bezpośrednio. Większe liczby są kodowane jako liczba zer +30. (np .: 1000 = 33, 100 = 32 itd.)

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

Wyodrębnij jedną literę z $ A w pozycji określonej w argumencie $ 1 (zdekodowany base64, -10, aby uwzględnić przesunięcie „a”). Base64 dekoduje ten znak i przechowuje w c.

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

Jeśli $ c jest większe niż 30, wydrukuj „1” wypełniony zerami $ c-30. W przeciwnym razie wydrukuj $ c.

Młot kowalski , 17 bajtów

Technicznie rzecz biorąc, ma on długość 133 bitów, ale tak naprawdę nie daje to 16.625 bajtów, jak twierdzi kompresor.

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

To prawdopodobnie dekoduje

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

(w przybliżeniu taka sama jak moja odpowiedź Mathematica), chociaż ledwo go zakodowałem (wygląda na to, że mój komputer ma problemy ze zgodnością ze wszystkim), więc powodzenia w dekodowaniu go ponownie, aby to sprawdzić. Mogłem popełnić błędy podczas korzystania z enkodera, więc bądź ostrożny.

Galaretka , 36 bajtów

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

Wypróbuj online!

Łącze monadyczne przyjmujące jako argument małą literę i zwracające liczbę całkowitą. Zwraca 0za ji k.

Wyjaśnienie

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 bajtów

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

Wypróbuj online! Link zawiera przypadki testowe. Wyjaśnienie:

^
$'

Zduplikuj dane wejściowe.

T`l`111104835__111011062452620`^.

Zmień pierwszą kopię na (pierwszą) cyfrę odpowiedniego wyniku.

T`abcm\pq`139285

Jeśli liczba ma wielokrotność 3 ostatnich zer, uzyskaj tę wielokrotność teraz.

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

I faktycznie przekonwertuj go na odpowiednią liczbę zer końcowych. (Zauważ, że uprościłoby to *3*0w Retina 1.)

d
00

Naprawcie d.

T`\lyl`10_

Naprawić li yi usunąć wszelkie pozostałe litery.

PHP , 104 bajty

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

Wypróbuj online!

Mam ciąg znaków, ^FX]0483500GC10UL0624526P0który zawiera pojedynczy znak dla każdej litery wejściowej od „a” do „z”. Wyodrębniam ten znak na podstawie danych wejściowych i przechowuję go $a. Jeśli znak nie jest cyfrą, jego kod ASCII mod 30 zostanie zapisany $b.

Jeśli $ajest to cyfra, drukowana jest ta sama cyfra, jest ona wykorzystywana do każdego wejścia, które wymaga wyjścia od 0 do 9 (np. „E”, „f” itp.).

W przeciwnym razie, jeśli $bjest to 20 lub 11, drukowany jest ten sam numer, jest on używany dla „l” i „y”.

W przeciwnym razie $bdrukowana jest cyfra „1” uzupełniona „0”. Na przykład dla wprowadzenia „a” znakiem jest „^”, który ma kod ASCII 94., 94 % 30 = 4a „1” uzupełniony do 4, przy czym „0” s będzie wynosić „1000”.