Nous sommes tous habitués au clavier téléphonique de la vieille école, non? Pour référence, voici à quoi ça ressemble:

Étant donné une chaîne composée uniquement de lettres ASCII minuscules et d'espaces simples , votre tâche consiste à renvoyer le nombre d'appuis que vous devez effectuer afin de taper la chaîne complète avec un clavier téléphonique comme celui ci-dessus.

Pour ceux qui ne connaissent pas cela, voici comment cela fonctionne:

• La clé avec le chiffre 2, par exemple, a également la chaîne abcécrite dessus. Pour taper a, vous devez appuyer une fois sur cette touche, car bvous devez appuyer deux fois et cvous devez appuyer trois fois.

• Pour les lettres consécutives qui sont sur la même touche, vous devez attendre 1 seconde avant d'appuyer à nouveau. Donc, si vous voulez taper cb, vous devez appuyer 3 fois sur c, attendre une seconde puis appuyer deux fois sur b, donc toujours 5 taps.

• Il en va de même pour toutes les autres touches, à l'exception d'un seul espace, qui ne nécessite qu'une seule pression. Notez également que les clés 7et 9ont quatre lettres sur eux. Le même algorithme est appliqué, la seule différence étant le nombre de lettres. Les chaînes correspondant à chaque clé se trouvent dans l'image ci-dessus (mais en minuscules), ou dans la liste suivante, qui contient tous les caractères que vous pourriez recevoir:

  "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz", " "
  

Cas de test

Entrée -> Sortie (explication)

"" -> 0 (rien ne doit être tapé)
"eau" -> 8 ("w, a, t" nécessitent chacun 1 robinet (sur les touches 9, 2 et 8), "e" nécessite 2 robinets (sur la touche 3), "r" nécessite 3 robinets (sur la touche 7 ), 1 + 1 + 1 + 2 + 3 = 8)
"savon" -> 9 (4 + 3 + 1 + 1)
"candela" -> 13 (3 + 1 + 2 + 1 + 2 + 3 + 1)
"code golf" -> 20 (3 + 3 + 1 + 2 + 1 (pour l'espace) + 1 + 3 + 3 + 3)
"roi de la colline" -> 33 (2 + 3 + 2 + 1 + 1 + 3 + 3 + 1 + 1 + 2 + 2 + 1 + 2 + 3 + 3 + 3)

Spécifications

• Les règles d'E / S standard et les failles par défaut s'appliquent.

• Vous ne pouvez prendre en entrée que le type de chaîne natif de votre langue. La sortie peut être soit un entier, soit une représentation sous forme de chaîne de cet entier.

• C'est le code-golf , la réponse la plus courte dans toutes les langues l' emporte.

JavaScript (ES6) 77 66 64 60 octets

(Enregistré quelques octets grâce à @Johan Karlsson et @Arnauld).

s=>[...s].map(l=>s=~~s+2+'behknquxcfilorvysz'.search(l)/8)|s

f=

s=>[...s].map(l=>s=~~s+2+'behknquxcfilorvysz'.search(l)/8)|s

console.log(f(''));                 //0
console.log(f('water'));            //8
console.log(f('soap'));             //9
console.log(f('candela'));          //13
console.log(f('code golf'));        //20
console.log(f('king of the hill')); //33

05AB1E , 29 26 25 octets

ð¢svA•22ā₂•S£ð«øðδKy.åƶOO

Essayez-le en ligne!

Explication

ð¢                         # count spaces in input
  sv                       # for each char y in input
    A                      # push the lowercase alphabet
     •22ā₂•S               # push the base-10 digit list [3,3,3,3,3,4,3,4]
            £              # split the alphabet into pieces of these sizes
             ð«            # append a space to each
               ø           # transpose
                ðδK        # deep remove spaces
                   y.å     # check y for membership of each
                      ƶ    # lift each by their index in the list
                       O   # sum the list
                        O  # sum the stack

Python 2 , 56 octets

Utilise le même algorithme que la solution Javascript de @ RickHitchcock

lambda x:sum('behknquxcfilorvysz'.find(c)/8+2for c in x)

Essayez-le en ligne!

Python 3 , 69 67 65 64 octets

1 octet merci à M. Xcoder.

1 octet merci à Felipe Nardi Batista.

lambda x:sum((ord(i)+~(i>"s"))%3+3*(i in"sz")+(i>" ")for i in x)

Essayez-le en ligne!

Dyalog APL, 37 octets

+/⌈9÷⍨'adgjmptw behknqux~cfilorvy~'⍳⍞

Essayez-le en ligne!

Comment?

Obtenez le ⍳ndex de chaque caractère de l'entrée dans la chaîne 'adgjmptw behknqux~cfilorvy~'( set zsera par défaut à 28), divisez par 9, arrondissez et additionnez.

JavaScript (ES6), 71 octets

f=
s=>[...s].map(c=>t+=((c=parseInt(0+c,36))>23?c+3:c&&~-c%3)%7%4+1,t=0)|t

<input oninput=o.textContent=f(this.value)><pre id=o>

Ne cherchez pas de tables à lettres! Je ne comprenais pas très bien la formule de @ LeakyNun alors j'ai trouvé la mienne.

C, 211 196 octets

La première soumission ici ... semble assez longue et je vois que ce n'est pas une approche efficace, mais au moins ça marche :)

f(char*n){char*k=" abcdefghijklmnopqrstuvwxyz";int t[]={0,3,3,3,3,3,4,3,4};int l=0,s,j,i;while(*n){i=0;while(k[i]){if(k[i]==*n){s=0;for(j=0;s<i-t[j];s+=t[j++]);*n++;l+=(!i?1:i-s);}i++;}}return l;}

Version non golfée:

int f(char *n){
  char *k=" abcdefghijklmnopqrstuvwxyz";
  int t[]={0,3,3,3,3,3,4,3,4};
  int l=0,s,j,i;
  while(*n){                          // loop through input characters
    i=0;
    while(k[i]){
      if(k[i]==*n){                   // find matching char in k
        s=0;
        for(j=0;s<i-t[j];s+=t[j++]);  // sum up the "key sizes" up to the key found
        *n++;
        l+=(!i?1:i-s);                // key presses are i-s except for space (1)
      }
      i++;
    }
  }
  return l;
}

Haskell - 74 71 62 octets

Edit: supprimé 3 octets en utilisant une compréhension de liste au lieu d'un filtre

Edit: économisez 9 octets grâce à Siracusa, Laikoni et Zgarb!

f=sum.(>>= \x->1:[1|y<-"bcceffhiikllnooqrrsssuvvxyyzzz",y==x])

Usage

λ> f "candela"
13
λ>

Essayez-le en ligne!

Gelée , 25 octets

Øaḟ⁾sz©;⁶s3Z®ṭċ@€€⁸×"J$ẎS

Essayez-le en ligne!

Clojure, 82 76 octets

#(apply +(for[c %](+(count(filter #{c}"bcceffhiikllnooqrrsssuvvxyyzzz"))1)))

Oh , il est plus simple de filteret countque l' utilisation frequencies. Original:

#(apply +(count %)(for[c %](get(frequencies"bcceffhiikllnooqrrsssuvvxyyzzz")c 0)))

La chaîne encode combien de fois plus qu'une seule fois vous devez appuyer sur la touche d'un caractère donné :)

Python 3 , 91 octets

lambda x:sum(j.find(i)+1for j in' !abc!def!ghi!jkl!mno!pqrs!tuv!wxyz'.split('!')for i in x)

Essayez-le en ligne!

Python 3 , 60 octets

Probablement sous-optimal, car c'est mon premier golf en Python.

lambda x:sum((ord(i)-8)%3.15//1+3*(i>'y')+(i>' ')for i in x)

Essayez-le en ligne!

Rétine , 46 36 octets

Merci à CalculatorFeline pour avoir économisé 6 octets.

s|z
,c
[cfilorvy]
,b
[behknqux]
,,
.

Essayez-le en ligne!

Java, 95 73 octets

a->a.chars().map(b->1+(b<64?0:b+(Math.abs(b-115)<4?4:5))%(3+b/112)).sum()

Merci à Kevin Cruijssen d'avoir fait de la fonction une expression lambda (où aest de type String). 95 octets sont devenus 73 octets!

Une expression lambda résume le nombre de presse de chaque caractère utilisant map(). map()convertit chaque caractère (ASCII dans la plage minuscule est 97-122) dans le flux à la valeur appropriée ( qui ressemble à simple , vague de scie, mais en prenant en compte les 4 cycles est ennuyeux) en utilisant ce calcul: 1+(b<64?0:b+(Math.abs(b-115)<4?4:5))%(3+b/112). Voici un graphique desmos de ce modèle.

Mathematica, 83 octets

c=Characters;Tr[Tr@Mod[c@"bc1def1ghi1jkl1mno1pqrstuv1wxyz "~Position~#,4]+1&/@c@#]&

QBIC , 94 octets

[_l;||_SA,a,1|p=p-(instr(@sz`,B)>0)-(instr(@cfilorvy`+C,B)>0)-(instr(@behknqux`+C+D,B)>0)+1}?p

Explication

[    |      FOR a = 1 TO
 _l |         the length of
   ;            the input string (A$)
_SA,a,1|    Take the a'th char of A$ and assign it to B$
p=p         p is our tap-counter, and in each iteration it gets increased by the code below
            which consist of this pattern:
                instr(@xyz`,B)>0    where 
                - instr tests if arg 2 is in arg 1 (it either returns 0 or X where X is the index of a2 in a1)
                - @...` defines the letters we want to test as arg1
                - B is the current letter to count the taps for
            Each of these blocks adds 1 tap to the counter, and each block has the letters of its level
            (4-taps, 3-taps or 2-taps) and the level 'above' it.
    -(instr(@sz`,B)>0)              <-- letters that require 4 taps
    -(instr(@cfilorvy`+C,B)>0)      <-- 3 or 4 taps
    -(instr(@behknqux`+C+D,B)>0)    <-- 2, 3,or 4 taps
    +1                              <-- and always a 1-tap
}           NEXT
?p          PRINT the number of taps

Bash ,69 68 octets

bc<<<`fold -1|tr "\n "adgjmptwbehknquxcfilorvysz +[1*9][2*8][3*8]44`

Essayez-le en ligne!

Plie un caractère par ligne, translitère chaque nouvelle ligne avec +, chaque espace avec 1et chaque lettre avec le nombre correspondant de poussées. bc fait la somme.

C, 92 88 octets

c,n;f(char*s){n=0;while(c=*s++)n+=(c=='s')+3*(c>'y')+1+(c+1+(c<'s'))%3-(c<33);return n;}

APL (Dyalog) , 36 octets

{+/(3×⍵∊'sz'),1+3|¯1+⍵⍳⍨819⌶⎕A~'SZ'}

Essayez-le en ligne!

Trouve les mod-3 indices dans l'alphabet sans S et Z . Puisque l'espace, S et Z ne sont pas trouvés, ils "ont" un indice 25 (un de plus que l'indice max), ce qui est bon pour l'espace. Ensuite , nous avons juste besoin d'ajouter 3 pour chaque S ou Z .

{ fonction anonyme où l'argument est représenté par ⍵ :

 ⎕A~'SZ' l' alphabet majuscule A , sauf pour S et Z

 819⌶ minuscule

 ⍵⍳⍨ les ɩ ndices de l'argument en ce que

 ¯1+ ajouter un négatif

 3| mod-3

 1+ ajouter un (cela convertit tous les 0-mods en 3)

 (… ), Ajouter:

  ⍵∊'sz' Booléen où l'argument est s ou z

  3× multiplier par 3

 +/ somme

C (gcc) , 7577 octets

n,b;f(char*a){for(n=0;b=*a++;)n+=b<'s'?--b%3+(b>31):""[b-'s'];a=n;}

La chaîne non imprimable ""est une table de 04 01 02 03 01 02 03 04.

Essayez-le en ligne!

Pip , 100 90 octets

a:qb:["abc""def""ghi""jkl""mno""pqrs""tuv""wxyz"s]Fc,#a{Fd,#b{e:((bd)@?(ac))e<4?i+:e+1x}}i

Vérifiez chaque caractère de l'entrée pour une correspondance dans chaque élément de b. L'index de cette correspondance plus 1 est ajouté au total.

Essayez-le en ligne!