W czasach dziadków wybieranie numeru telefonu odbywało się za pomocą tarczy obrotowej w następujący sposób:

Aby wybrać każdą cyfrę, włóż palec do odpowiedniego otworu, pociągnij go do oporu i zwolnij. Mechanizm powoduje, że tarcza obraca się z powrotem do pozycji spoczynkowej, a telefon rozłącza i ponownie łączy obwód określoną liczbę razy, słyszalnie klikając.

Wybranie cyfry N wymaga N takich „impulsów”, z wyjątkiem N = 0, czyli dziesięciu impulsów.

Telefony obrotowe mają tę właściwość, że wybieranie dużych cyfr (8, 9, 0) trwa dłużej niż małe cyfry (1, 2, 3). Było to ważne przy opracowywaniu wczesnych map kierunkowych i dlaczego Nowy Jork z gęstą gęstością zaludnienia (i linii telefonicznej) otrzymał 212 (tylko 5 impulsów), podczas gdy 907 (26 impulsów) pojechało na rzadko zamieszkaną Alaskę. Oczywiście wszystko to stało się nieistotne, gdy popularne stało się wybieranie tonowe.

Wyzwanie

Napisz, w jak najmniejszej liczbie bajtów, program lub funkcję, która przyjmuje jako dane wejściowe ciąg znaków (lub sekwencję znaków) zawierający numer telefonu i wysyła liczbę impulsów wybierania obrotowego. Należy je liczyć w następujący sposób:

Cyfry

• Cyfry 1-9 liczą się jako liczba impulsów.
• Cyfra 0 liczy się jako 10 impulsów.

Listy

Zauważ, że cyfry 2-9 na tarczy mają przypisane litery alfabetu łacińskiego. Pierwotnie były one przeznaczone do wymiany nazwanych , ale później zostały ponownie wykorzystane w słowach telefonicznych i systemach wprowadzania wiadomości tekstowych.

Musisz obsługiwać litery w numerach telefonów, używając przypisania liter E.161 do cyfr:

• A, B, C = 2
• D, E, F = 3
• G, H, I = 4
• J, K, L = 5
• M, N, O = 6
• P, Q, R, S = 7
• T, U, V = 8
• W, X, Y, Z = 9

Możesz założyć, że dane wejściowe zostały już złożone na duże lub małe litery.

Inne postaci

Państwo musi umożliwić wykonanie wybranego wykorzystanie znaków ()+-./i przestrzeń jako separatory formatowania. Państwo może wybrał, aby umożliwić dowolną postać niealfanumeryczny do tego celu, jeśli jest to łatwiejsze do wykonania.

Te postacie nie mają wpływu na liczbę impulsów.

Przykładowy kod

Tabela i funkcja wyszukiwania bez golfa w Pythonie:

PULSES = {
    '1': 1,
    '2': 2, 'A': 2, 'B': 2, 'C': 2,
    '3': 3, 'D': 3, 'E': 3, 'F': 3,
    '4': 4, 'G': 4, 'H': 4, 'I': 4,
    '5': 5, 'J': 5, 'K': 5, 'L': 5,
    '6': 6, 'M': 6, 'N': 6, 'O': 6,
    '7': 7, 'P': 7, 'Q': 7, 'R': 7, 'S': 7,
    '8': 8, 'T': 8, 'U': 8, 'V': 8,
    '9': 9, 'W': 9, 'X': 9, 'Y': 9, 'Z': 9,
    '0': 10
}

def pulse_count(phone_num):
    return sum(PULSES.get(digit, 0) for digit in phone_num)

Przykładowe wejście i wyjście

• 911 → 11
• 867-5309 → 48
• 713 555 0123 → 42
• +1 (212) PE6-5000 → 57
• 1-800-FLOWERS → 69
• PUZZLES → 48

05AB1E , 19 18 17 15 bajtów

AÁ0ªā6+žq÷9š‡þO

Wypróbuj online!

To jest pierwsza odpowiedź na użycie π. Po co używać π, możesz zapytać? Cóż, litery są powiązane z 22233344455566677778889999, w kolejności. Zauważ, że większość cyfr powtarza się 3 razy, ale 7 powtarza się 4 razy. Można powiedzieć, że każda cyfra powtarza się (średnio 3 + 1/7) razy. Zastanawiam się, czy jest jakaś liczba w przybliżeniu 3 + 1/7 i zajmuje mniej bajtów niż 22/7…

To daje tylko 4 7, a nie 4 9, więc nadal musimy traktować Z jako specjalny przypadek.

A               # alphabet (abcdefghijklmnopqrstuvwxyz)
 Á              # rotate right (zabcdefghijklmnopqrstuvwxy)
  0ª            # append 0 (zabcdefghijklmnopqrstuvwxy0)

ā6+             # range [7..33]
   žq÷          # divide by π (22233344455566677778889991010)
      9š        # prepend 9 (922233344455566677778889991010)

‡               # transliterate the implicit input with the two lists above
                # this replaces z → 9, a → 2, … y → 9, 0 → 10
 þ              # remove all non-digits
  O             # sum

C # (interaktywny kompilator Visual C #) , 51 bajtów

n=>n.Sum(x=>x>64?(x-59-x/83-x/90)/3:x>47?1-~x%~9:0)

Zapisano 1 bajt dzięki @recursive

Zaoszczędzono 10 bajtów dzięki obserwacji @ ExpiredData, że ​​tylko () +-/. będzie na wejściu

Wypróbuj online!

n =>                     // Function taking input as string
  n.Sum(x =>             // Map each value 'x' through the following
    x>64 ?               //   If 'x' is an uppercase letter
      (x-59-x/83-x/90)/3 //     Take each char's ASCII value subtracted by 59, and subtract
                         //     one if the char is 'S' and one if the char is 'Z'
    : x>47 ?             //   Else if the char is a digit
      1-~x%~9            //   Take 1 - (-x - 1) % -10 (Maps 0 to 10, and 1-9 to themselves
    : 0                  //   Else, 0
  )                      // And sum it all up, then return it

APL (Dyalog Unicode) , 27 bajtów ^SBCS

Anonimowa ukryta funkcja prefiksu.

+/'@ADGJMPTW'∘⍸+11|(1⌽⎕D)∘⍳

Wypróbuj online!

(... )∘⍳ znaleźć ɩ ndex * każdego znaku w następujący ciąg:
  ^{* elementy, które nie zostały znalezione, uzyskać indeks 1 + indeks maksymalnej, czyli 11}
 ⎕D  cyfr:"0123456789"

 1⌽ cyklicznie obracaj o jeden krok w lewo; "1234567890"

11| dzielenie pozostałej części po podzieleniu przez 11 *
  ^{* daje to 0 dla wszystkich znaków innych niż cyfry}
… + dodaj to do:

 '@ADGJMPTW'∘⍸ɩ nterval ɩ ndex * dla każdego znaku
  ^{* Więc [-∞, "@") daje 0 [ "@", "A") daje 1, [ "A", "D") daje 2, itd.}
+/  Suma że

Python 2 , 74 bajty

lambda s:sum([(n-59-n/83-n/90)/3,1-~n%~9][n<58]for n in map(ord,s)if n>47)

Wypróbuj online!

Wykonuje pewną arytmetykę wartości ASCII dla każdego znaku. Pierwsza opcja sprawdza litery, a druga opcja sprawdza cyfry. Wyjaśnienie, że wszystkie znaki interpunkcyjne dozwolone w danych wejściowych są znakami o wartości ASCII mniejszej niż 48, pozwolę uprościć logikę, ale nowa metoda może być teraz lepsza.

Python 2 , 84 bajtów

lambda s:sum(1+'1xxxx2ABCx3DEFx4GHIx5JKLx6MNOx7PQRS8TUVx9WXYZ0'.find(c)/5for c in s)

Wypróbuj online!

Używa zakodowanego ciągu wyszukiwania, przy czym każdy blok 5 znaków odpowiada znakom podającym każdą wartość rozpoczynającą się od 1. Puste spacje są wypełniane x, których nie można wstawić dużymi literami. Na szczęście znaki, które nie pojawiają się w ciągu, dają -1wynik, .findktóry daje sumę zerową.

JavaScript (Node.js) , ... 76 69 bajtów

s=>s.replace(/\w/g,q=>w+=1/q?+q||10:parseInt(q,35)*.32-1|0||9,w=0)&&w

Wypróbuj online!

-7 dzięki @Arnauld!

Wyjaśnienie

 q |     1/q     |  +q  | parseInt(q,35)*.32 | parseInt(q,35)*.32-1|0 | Output
---+-------------+------+--------------------+------------------------+--------
 0 | Infinity(T) | 0(F) |         N/A        |           N/A          |   10
 1 |  1.0000(T)  | 1(T) |         N/A        |           N/A          |    1
 2 |  0.5000(T)  | 2(T) |         N/A        |           N/A          |    2
 3 |  0.3333(T)  | 3(T) |         N/A        |           N/A          |    3
 4 |  0.2500(T)  | 4(T) |         N/A        |           N/A          |    4
 5 |  0.2000(T)  | 5(T) |         N/A        |           N/A          |    5
 6 |  0.1666(T)  | 6(T) |         N/A        |           N/A          |    6
 7 |  0.1428(T)  | 7(T) |         N/A        |           N/A          |    7
 8 |  0.1250(T)  | 8(T) |         N/A        |           N/A          |    8
 9 |  0.1111(T)  | 9(T) |         N/A        |           N/A          |    9
 A |    NaN(F)   |  N/A |        3.20        |          2(T)          |    2
 B |    NaN(F)   |  N/A |        3.52        |          2(T)          |    2
 C |    NaN(F)   |  N/A |        3.84        |          2(T)          |    2
 D |    NaN(F)   |  N/A |        4.16        |          3(T)          |    3
 E |    NaN(F)   |  N/A |        4.48        |          3(T)          |    3
 F |    NaN(F)   |  N/A |        4.80        |          3(T)          |    3
 G |    NaN(F)   |  N/A |        5.12        |          4(T)          |    4
 H |    NaN(F)   |  N/A |        5.44        |          4(T)          |    4
 I |    NaN(F)   |  N/A |        5.76        |          4(T)          |    4
 J |    NaN(F)   |  N/A |        6.08        |          5(T)          |    5
 K |    NaN(F)   |  N/A |        6.40        |          5(T)          |    5
 L |    NaN(F)   |  N/A |        6.72        |          5(T)          |    5
 M |    NaN(F)   |  N/A |        7.04        |          6(T)          |    6
 N |    NaN(F)   |  N/A |        7.36        |          6(T)          |    6
 O |    NaN(F)   |  N/A |        7.68        |          6(T)          |    6
 P |    NaN(F)   |  N/A |        8.00        |          7(T)          |    7
 Q |    NaN(F)   |  N/A |        8.32        |          7(T)          |    7
 R |    NaN(F)   |  N/A |        8.64        |          7(T)          |    7
 S |    NaN(F)   |  N/A |        8.96        |          7(T)          |    7
 T |    NaN(F)   |  N/A |        9.28        |          8(T)          |    8
 U |    NaN(F)   |  N/A |        9.60        |          8(T)          |    8
 V |    NaN(F)   |  N/A |        9.92        |          8(T)          |    8
 W |    NaN(F)   |  N/A |       10.24        |          9(T)          |    9
 X |    NaN(F)   |  N/A |       10.56        |          9(T)          |    9
 Y |    NaN(F)   |  N/A |       10.88        |          9(T)          |    9
 Z |    NaN(F)   |  N/A |         NaN        |          0(F)          |    9

Nie wszystkie [space]().+-/są przechwytywane przez /\w/g, więc nie wpłyną na całość.

Perl 5 -p , 52 51 bajtów

@Grimy dostaje kredyt za -1

y/A-Z/22233344455566677778889/;map$\+=$_||10,/./g}{

Wypróbuj online!

J , 39 bajtów

1#.'?@CFILOSVZ'&I.+11|1+'1234567890'i.]

Wypróbuj online!

Port rozwiązania APL firmy Adám

Retina 0.8.2 , 34 bajty

T`WTPMJGDA`Rd
}T`L`2L
0
55
\d
$*
1

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

T`WTPMJGDA`Rd

Konwertuj litery WTPMJGDAna cyfry 9..0.

}T`L`2L

Przetasuj wszystkie pozostałe litery o 1 i powtarzaj, aż wszystkie litery zostaną zamienione na cyfry.

0
55

Wymień 0się 55jak oni mieć taką samą liczbę impulsów do tarczy.

\d
$*
1

Weź cyfrową sumę.

K4 , 44 bajty

Rozwiązanie:

+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?

Przykłady:

q)k)+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?"911"
11
q)k)+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?"867-5309"
48
q)k)+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?"+1 (212) PE6-5000"
57
q)k)+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?"1-800-FLOWERS"
69

Wyjaśnienie:

Naiwne podejście, prawdopodobnie dość grywalne. Indeks postaci, wynik wyszukiwania, suma.

+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")? / the solution
                                           ? / lookup
                          (               )  / do this together
                                       "0"   / string "0"
                                      ,      / join with
                                  .Q.n       / string "0123456789"
                                1_           / drop first
                               ,             / join with
                           .Q.A              / "A..Z"
  (                      )                   / do this together
                      !10                    / range 0..9
                     ,                       / join with
     (              )                        / do this together
               4 3 4                         / list (4;3;4)
              ,                              / join with
         (5#3)                               / list (3;3;3;3;3)
        &                                    / where, creates list 0 0 0 1 1 1 2 2 etc
      1+                                     / add 1
   1+                                        / add 1
+/                                           / sum up

Perl 6 , 53 bajtów

{sum +<<m:g/\d/X||10}o{S:g[<:L>]=$/.ord*.313-28+|0+9}

Wypróbuj online!

Mnoży kod ASCII przez 0,313 zamiast 1/3 i używa bitowego OR, który zaokrągla do zera, aby uzyskać prawidłowe odchylenie .

C (gcc) , 94 89 86 80 bajtów

Podziękowania dla pułapek, nwellnhof i Rogem za sugestie.

c;f(char*s){c=*s-48;s=*s?(c<10U?c?c:10:c-17<26U?(c-11-c/35-c/42)/3:0)+f(s+1):0;}

Wypróbuj online!

Grzmotnąć , 256 bajtów

Możesz zastąpić (( … ))konstrukcje letidentyczną liczbą bajtów. Może istnieć dobry algorytm do zmniejszania instrukcji case, ale do tej pory go nie znaleziono. Przy odrobinie przeróbki możesz też uczynić ją funkcją (ale nie w takich samych lub mniejszych bajtach, chyba że możesz pominąć function fname { … }górę i ogon).

read p;while ((${#p}>0));do case ${p:0:1} in ([1-9]) ((d+=${p:0:1}));; ([0]) ((d+=10));; ([ABC) ((d+=2));; ([P-S]) ((d+=7));; ([W-Z]) ((d+=9));;([DEF]) ((d+=3));; ([GHI]) ((d+=4));; ([JKL]) ((d+=5));; ([MNO]) ((d+=6));; (?) d=$d; esac;p=${p#?};done;echo $d

Wypróbuj online!

Lepsze rozwiązanie z wykorzystaniem techniki postaci z mapy korzysta z tr narzędzia:

[Bash z tr], 173 bajtów

read p;p=$(echo $p|tr A-Z 22233344455566677778889999);while ((${#p}>0));do case ${p:0:1} in ([1-9]) ((d+=${p:0:1}));; ([0]) ((d+=10));; (?) d=$d; esac;p=${p#?}; done;echo $d

Wypróbuj online!

Galaretka , 33 24 bajtów

7r32:ØP«9Ṿ€ØAżFyfØDV€o⁵S

Wypróbuj online!

Łącze monadyczne przyjmujące ciąg za argument i zwracające liczbę impulsów. Przepisane na podstawie odpowiedzi 05AB1E @ Grimy'ego, więc pamiętajcie o ich głosowaniu!

PowerShell , 109 102 87 bajtów

$(switch -r($args|% t*y){\d{$_}[A-Y]{("{0}"-f(.313*$_-18))[0]}[Z]{9}0{10}})-join'+'|iex

Wypróbuj online!

EDYCJA: Wykorzystano pomysł @ mazzy na zamianę wyrażenia regularnego z pewnym formatowaniem łańcucha, aby rzutować char -> int -> string i pobierać tylko pierwszą „cyfrę”

Oryginalny:

[char[]]"$args"|%{$a+=(48,(('22233344455566677778889999')[$_-65],(58,$_)[$_-ne48])[$_-lt64])[$_-gt47]-=48};$a

Miałem nadzieję, że otrzymam <100 bajtów, więc będę dalej na nie patrzeć, aby sprawdzić, czy jest coś jeszcze, co mogę zrobić. Prawdopodobnie istnieje sposób na usunięcie ciągu liczbowego

Przepraszam, jeśli jest to mylące, ponieważ zagnieżdżałem tablice za pomocą instrukcji indeksowania logicznego, ale -

Wyjaśnienie:

[char[]]"$args"|%{odczytuje dane wejściowe lanego jako ciąg, a następnie eksploduje do tablicy char i rozpoczyna się za-każdej pętli z sprawdzenie ()[$_-gt47], czy któryś ()+-./został wprowadzony (mają wartości znaków ASCII <48)
Uwaga: PowerShell przyjmuje $truei $falsejak 1i 0odpowiednio indeksami macierzy

Następnie otrzymujemy albo 48symbole, albo:
('22233344455566677778889999'[$_-65],(58,$_)[$_-ne48])[$_-lt64]

Do [$_-lt64]sprawdza numeru lub listu (wszystkie Zakładana kapitału tutaj). Jeśli jest to litera, '22233344455566677778889999'[$_-65]zmienia ją na 0-25, aby zindeksować tablicę i wyprowadzić wartość impulsu (jako znak). Jeśli znak jest liczbą, zamiast tego patrzymy na: (58,$_)[$_-ne48]sprawdzanie 0i generowanie 58lub po prostu sam numeryczny znak.

Wokół wszystkiego $a+= ... -=48inicjuje zmienną numeryczną $ a, 0a następnie dodaje wynik. Dane wyjściowe to wartość ascii char liczby, więc odejmij48 .

Uwaga: jeśli wejście było symbolem, otrzymujemy $a+=48-48, skutecznie go ignorując. Jeśli tak 0, to rozumiemy$a+=58-48 naszą +10

Na koniec ;$apo prostu wyprowadza naszą końcową wartość po każdej pętli

PowerShell , 95 85 79 bajtów

zainspirowany odpowiedzią nwellnhof .

zainspirowany [0]z odpowiedzią sinusoidy za .

$(switch -r($args|% t*y){\d{$_}0{10}[A-Y]{"$(.313*$_-18)"[0]}Z{9}})-join'+'|iex

Wypróbuj online!

Wersja rozwinięta:

$(
    switch -r($args|% toCharArray){
        \d    {$_}
        0     {10}
        [A-Y] {"$(.313*$_-18)"[0]}
        Z     {9}
    }
)-join '+'|Invoke-Expression

key .313*$_-18 "$(...)"[0]
--- ---------- -----------
  A      2.345 2
  B      2.658 2
  C      2.971 2
  D      3.284 3
  E      3.597 3
  F      3.910 3
  G      4.223 4
  H      4.536 4
  I      4.849 4
  J      5.162 5
  K      5.475 5
  L      5.788 5
  M      6.101 6
  N      6.414 6
  O      6.727 6
  P      7.040 7
  Q      7.353 7
  R      7.666 7
  S      7.979 7
  T      8.292 8
  U      8.605 8
  V      8.918 8
  W      9.231 9
  X      9.544 9
  Y      9.857 9

Stax , 21 bajtów

éT6T&\²|└t5φ╛│█♪√┘↑▓^

Uruchom i debuguj

Kotlin , 113 bajtów

{s:String->var t=0
for(c in s){val v=c-'0'
t+=when(v){0->10
in 1..9->v
in 17..42->(v-11-v/35-v/42)/3
else->0}}
t}

Wypróbuj online!

Python 3 , 134 123 bajtów

f=lambda n:sum(map(int,n.translate(n.maketrans('ADGJMPTWBEHKNQUXCFILORVYSZ','23456789'*3+'79','()+-./ '))))+10*n.count('0')

Wypróbuj online!

-11 bajtów dzięki @ dan04