À l'époque de vos grands-parents, la composition d'un numéro de téléphone se faisait avec un cadran rotatif comme celui-ci:

Pour composer chaque chiffre, placez votre doigt dans le trou correspondant, tirez-le jusqu'à la butée et relâchez-le. Un mécanisme fera revenir le cadran dans sa position de repos et le téléphone déconnectera et reconnectera un circuit un nombre spécifié de fois, en produisant des clics audibles.

La composition du chiffre N nécessite N de telles "impulsions", à l'exception de N = 0 qui correspond à dix impulsions.

Les téléphones rotatifs ont la propriété que les gros chiffres (8, 9, 0) prennent plus de temps à composer que les petits chiffres (1, 2, 3). C’était là un facteur important dans l’établissement des premières cartes indicatrices interurbaines et des raisons pour lesquelles la ville de New York, avec sa densité de population (et sa ligne téléphonique) dense, s’élevait à 212 (seulement 5 impulsions), alors que 907 (26 impulsions) étaient destinées à l’Alaska peu peuplé. Bien sûr, tout cela est devenu inutile lorsque la numérotation à clavier est devenue populaire.

Le défi

Ecrivez, avec le moins d’octets possible, un programme ou une fonction prenant en entrée une chaîne de caractères (ou une séquence de caractères) contenant un numéro de téléphone et émettant son nombre d’impulsions de cadran rotatif. Ceux-ci doivent être comptés comme suit:

Chiffres

• Les chiffres 1 à 9 comptent comme ce nombre d'impulsions.
• Le chiffre 0 compte pour 10 impulsions.

Des lettres

Notez que les lettres 2 à 9 du cadran sont associées à des lettres de l'alphabet latin. Celles-ci étaient à l'origine destinées aux échanges nommés , mais ont été réappropriées pour les mots de téléphone et les systèmes de saisie de SMS.

Vous devez pouvoir utiliser des lettres dans vos numéros de téléphone, en utilisant l' affectation de lettres en chiffres E.161 :

• 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

Vous pouvez supposer que l'entrée a déjà été pliée en majuscules ou en minuscules.

Autres personnages

Vous devez autoriser l'utilisation arbitraire des caractères ()+-./et de l'espace en tant que séparateurs de formatage. Vous pouvez choisir d’autoriser tout caractère non alphanumérique à cette fin, s’il est plus facile à implémenter.

Ces caractères ne contribuent pas au nombre d'impulsions.

Exemple de code

Une table de recherche non-golfée et une fonction en Python:

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)

Exemple d'entrée et de sortie

• 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 octets

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

Essayez-le en ligne!

C'est la première réponse à utiliser π. Pourquoi utiliser π, vous pourriez demander? Eh bien, les lettres sont associées à 22233344455566677778889999, dans l’ordre. Notez que la plupart des chiffres se répètent 3 fois, mais 7 se répètent 4 fois. On pourrait dire que chaque chiffre se répète (3 + 1/7) fois en moyenne. Je me demande s’il existe un nombre d’environ 3 + 1/7 et prenant moins d’octets que 22/7…

Cela donne seulement 4 7, pas 4 9, nous devons donc traiter Z comme cas spécial.

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 # (compilateur interactif Visual C #) , 51 octets

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

Enregistré 1 octet grâce à @recursive

Sauvegardé 10 octets grâce à l'observation de @ ExpiredData qui ne () +-/.sera que dans l'entrée

Essayez-le en ligne!

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) , ^SBCS 27 octets

Fonction de préfixe tacite anonyme.

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

Essayez-le en ligne!

(… )∘⍳ Trouvez le ɩ ndex * de chaque caractère dans la chaîne suivante:
  ^{* éléments non trouvés, obtenez l'index 1 + l'index maximum, c'est-à-dire 11}
 ⎕D  les chiffres:"0123456789"

 1⌽ faire une rotation cyclique d'un pas à gauche; "1234567890"

11| division reste quand divisé par 11 *
  ^{* cela donne 0 pour tous les chiffres non digitaux}
… + ajoutez cela à ce qui suit:

 '@ADGJMPTW'∘⍸ le ɩ ntervalle ɩ ndex * pour chaque caractère
  ^{* Alors [-∞, "@") donne 0, [ "@", "A") donne 1, [ "A", "D") donne 2, etc.}
+/  somme

Python 2 , 74 octets

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

Essayez-le en ligne!

Fait un peu d'arithmétique sur la valeur ASCII pour chaque caractère. La première option vérifie les lettres et la deuxième option vérifie les chiffres. La clarification que tous les caractères de ponctuation autorisés dans l'entrée sont ceux avec des valeurs ASCII inférieures à 48 me permet de simplifier la logique, mais une nouvelle méthode pourrait tout à fait être meilleure.

Python 2 , 84 octets

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

Essayez-le en ligne!

Utilise une chaîne de recherche codée en dur, avec chaque bloc de 5 caractères correspondant aux caractères donnant chaque valeur commençant par 1. Les espaces vides sont remplis x, ce qui ne peut pas être dans l'entrée en majuscule. Heureusement, les caractères qui n'apparaissent pas dans la chaîne produisent -1pour le .findqui donne une somme de zéro.

JavaScript (Node.js) , ... 76 69 octets

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

Essayez-le en ligne!

-7 merci @Arnauld!

Explication

 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

Tous [space]().+-/ne sont pas capturés par /\w/g, ils n'affecteront donc pas le total.

Perl 5 -p , 52 51 octets

@Grimy reçoit un crédit de -1

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

Essayez-le en ligne!

J , 39 octets

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

Essayez-le en ligne!

Un port de la solution APL d' Adám

Retina 0.8.2 , 34 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

T`WTPMJGDA`Rd

Convertissez les lettres WTPMJGDAen chiffres 9..0.

}T`L`2L

Mélangez toutes les lettres restantes de 1 et répétez l'opération jusqu'à ce que toutes les lettres aient été converties en chiffres.

0
55

Remplacez 0par 55car ils prennent le même nombre d'impulsions à composer.

\d
$*
1

Prenez la somme numérique.

K4 , 44 octets

Solution:

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

Exemples:

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

Explication:

Approche naïve, probablement assez golfable. Indice de recherche du personnage, score de recherche, somme.

+/(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 octets

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

Essayez-le en ligne!

Multiplie le code ASCII avec 0.313 au lieu de 1/3 et utilise OU au niveau du bit qui arrondit à zéro pour obtenir le biais correct .

C (gcc) , 94 89 86 80 octets

Merci à ceilingcat, nwellnhof et Rogem pour les suggestions.

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;}

Essayez-le en ligne!

Bash , 256 octets

Vous pouvez remplacer les (( … ))constructions avec letun nombre d'octets identique. Il peut exister un bon algorithme pour réduire les déclarations de cas mais ne l’a pas trouvé jusqu’à présent. Avec un peu de retouche, vous pouvez aussi en faire une fonction (mais pas avec le même nombre d’octets ou avec moins, sauf si vous pouvez ignorer le function fname { … }haut et le bas ).

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

Essayez-le en ligne!

Une meilleure solution utilisant la technique du caractère de carte utilise l' troutil:

[Bash avec tr], 173 octets

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

Essayez-le en ligne!

Gelée , 33 à 24 octets

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

Essayez-le en ligne!

Un lien monadique prenant une chaîne en tant qu'argument et renvoyant le nombre d'impulsions. Réécrit inspiré par la réponse de @ Grimy's 05AB1E , assurez-vous de les inviter à la vôtre!

PowerShell , 109 102 87 octets

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

Essayez-le en ligne!

EDIT: A utilisé l'idée de @ mazzy pour un commutateur regex avec un formatage de chaîne pour transtyper char -> int -> string et ne saisir que le premier 'chiffre'

Original:

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

J'espérais avoir moins de 100 octets, je vais donc continuer à regarder pour voir s'il y a quelque chose que je peux faire. Il y a probablement un moyen de supprimer la chaîne numérique

Désolé si cela est source de confusion car j'ai imbriqué des tableaux avec des déclarations d'indexation booléennes, mais -

Explication:

[char[]]"$args"|%{lit l'entrée convertie en chaîne, puis l'explose en tableau de caractères et commence une boucle for-each en vérifiant ()[$_-gt47]si elle a ()+-./été entrée (toutes ont une valeur de caractère ascii <48)
Remarque: Powershell accepte $trueet $falsecomme 1et 0respectivement pour les indices de tableau

Ensuite, nous obtenons soit 48les symboles, soit:
('22233344455566677778889999'[$_-65],(58,$_)[$_-ne48])[$_-lt64]

Les [$_-lt64]chèques pour un numéro ou une lettre (tous supposés capital ici). S'il s'agit d'une lettre, '22233344455566677778889999'[$_-65]réglez-le sur 0-25 pour indexer dans le tableau et générer la valeur d'impulsion (sous forme de caractère). Si le caractère est un nombre, nous examinons plutôt: la (58,$_)[$_-ne48]recherche 0et la sortie 58ou simplement le caractère numérique lui-même.

Tout autour $a+= ... -=48initialise une variable numérique $ a at 0et ajoute la sortie. La sortie est la valeur de caractère ascii d'un nombre, donc soustrayez 48.

Remarque: si l'entrée était un symbole, nous l' $a+=48-48ignorons. Si c'était le cas 0, nous $a+=58-48obtenons notre +10

Enfin, il nous ;$asuffit de sortir notre valeur finale après pour chaque boucle

PowerShell , 95 85 79 octets

inspiré par la réponse de Nwellnhof .

inspiré par la réponse[0] de Sinusoid .

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

Essayez-le en ligne!

Version déroulée:

$(
    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 octets

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

Exécuter et déboguer

Kotlin , 113 octets

{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}

Essayez-le en ligne!

Python 3 , 134 123 octets

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

Essayez-le en ligne!

-11 octets grâce à @ dan04