Wir sind alle an die alte Telefontastatur gewöhnt, oder? Als Referenz sehen Sie hier, wie es aussieht:

Bei einer Zeichenfolge, die nur aus ASCII-Kleinbuchstaben und einzelnen Leerzeichen besteht , müssen Sie die Anzahl der Abgriffe zurückgeben, die erforderlich sind, um die gesamte Zeichenfolge mit einer Telefontastatur wie der oben angegebenen abzutippen.

Für diejenigen, die damit nicht vertraut sind, ist hier, wie es funktioniert:

• Auf dem Schlüssel mit der Ziffer 2ist beispielsweise auch die Zeichenfolge abcgeschrieben. Um zu tippen a, müssen Sie diese Taste einmal drücken, denn bSie müssen zweimal drücken und cSie müssen dreimal drücken.

• Bei aufeinanderfolgenden Buchstaben, die sich auf derselben Taste befinden, müssen Sie eine Sekunde warten, bevor Sie erneut drücken. Wenn Sie also tippen möchten cb, müssen Sie 3 Mal drücken c, eine Sekunde warten und dann zweimal drücken b, sodass Sie immer noch 5 Mal tippen müssen .

• Gleiches gilt für alle anderen Tasten, mit Ausnahme einer einzelnen Leerstelle, für die nur ein Tastendruck erforderlich ist. Beachten Sie auch, dass die Tasten 7und 9vier Buchstaben haben. Es wird derselbe Algorithmus angewendet, der einzige Unterschied besteht in der Anzahl der Buchstaben. Die Zeichenfolgen für die einzelnen Tasten finden Sie in der Abbildung oben (jedoch in Kleinbuchstaben) oder in der folgenden Liste, die alle Zeichen enthält, die Sie möglicherweise erhalten:

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

Testfälle

Eingabe -> Ausgabe (Erläuterung)

"" -> 0 (nichts sollte getippt werden)
"Wasser" -> 8 ("w, a, t" erfordern jeweils 1 Tippen (auf die Tasten 9, 2 und 8), "e" erfordern 2 Tippen (auf die Taste 3), "r" erfordern 3 Tippen (auf die Taste 7) ), 1 + 1 + 1 + 2 + 3 = 8)
"Seife" -> 9 (4 + 3 + 1 + 1)
"candela" -> 13 (3 + 1 + 2 + 1 + 2 + 3 + 1)
"Code Golf" -> 20 (3 + 3 + 1 + 2 + 1 (für das Leerzeichen) + 1 + 3 + 3 + 3)
"König des Hügels" -> 33 (2 + 3 + 2 + 1 + 1 + 3 + 3 + 1 + 1 + 2 + 2 + 1 + 2 + 3 + 3 + 3)

Technische Daten

• Es gelten Standard-E / A-Regeln und Standard-Regelungslücken.

• Sie können nur Eingaben in den systemeigenen String-Typ Ihrer Sprache vornehmen. Die Ausgabe kann entweder eine Ganzzahl oder eine Zeichenfolgendarstellung dieser Ganzzahl sein.

• Dies ist Code-Golf , die kürzeste Antwort in jeder Sprache gewinnt.

JavaScript (ES6) 77 66 64 60 Bytes

(Sparte einige Bytes dank @Johan Karlsson und @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 Bytes

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

Probieren Sie es online!

Erläuterung

ð¢                         # 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 Bytes

Verwendet den gleichen Algorithmus wie die JavaScript-Lösung von @ RickHitchcock

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

Probieren Sie es online!

Python 3 , 69 67 65 64 Bytes

1 Byte danke an Herrn Xcoder.

1 Byte danke an Felipe Nardi Batista.

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

Probieren Sie es online!

Dyalog APL, 37 Bytes

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

Probieren Sie es online!

Wie?

Holen Sie sich das ⍳ndex jedes Zeichen der Eingabe in der Zeichenfolge 'adgjmptw behknqux~cfilorvy~'( sund zwird standardmäßig bis 28), Division durch 9, rund und Summe.

JavaScript (ES6), 71 Byte

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>

Schau mal keine Buchstabentabellen! Ich habe die Formel von @ LeakyNun nicht ganz verstanden und bin auf meine eigene gekommen.

C, 211 196 Bytes

Erste Einreichung hier ... sieht ziemlich lang aus und ich sehe, dass dies kein effizienter Ansatz ist, aber zumindest funktioniert es :)

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

Ungolfed-Version:

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 Bytes

Bearbeiten: 3 Bytes wurden entfernt, indem ein Listenverständnis anstelle eines Filters verwendet wurde

Edit: Sparen Sie 9 Bytes dank Siracusa, Laikoni und Zgarb!

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

Verwendung

λ> f "candela"
13
λ>

Probieren Sie es online!

Gelee , 25 Bytes

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

Probieren Sie es online!

Clojure, 82-76 Bytes

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

Oh, es ist einfacher filterund einfacher zu countbedienen frequencies. Original:

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

Die Zeichenfolge kodiert, wie oft Sie die Taste für ein bestimmtes Zeichen mehrmals drücken müssen :)

Python 3 , 91 Bytes

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

Probieren Sie es online!

Python 3 , 60 Bytes

Wahrscheinlich suboptimal, da dies mein erster Golf in Python ist.

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

Probieren Sie es online!

Netzhaut , 46 36 Bytes

Dank CalculatorFeline für das Speichern von 6 Bytes.

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

Probieren Sie es online!

Java, 95 73 Bytes

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

Vielen Dank an Kevin Cruijssen, der die Funktion zu einem Lambda - Ausdruck gemacht hat (wobei aes sich um einen Typ handelt)String ). 95 Bytes wurden 73 Bytes!

Ein Lambda-Ausdruck summiert die Pressezahl jedes Zeichens mit map(). map()konvertiert jedes Zeichen (ASCII in Kleinbuchstaben 97-122) im Stream in den entsprechenden Wert (sieht aus wie eine einfache Sägewelle, berücksichtigt aber beide 4 Zyklen, ist das ärgerlich) 1+(b<64?0:b+(Math.abs(b-115)<4?4:5))%(3+b/112). Hier ist ein Desmos-Diagramm dieses Modells.

Mathematica, 83 Bytes

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

QBIC , 94 Bytes

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

Erläuterung

[    |      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 Bytes

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

Probieren Sie es online!

Faltet ein Zeichen pro Zeile, transkribiert jede neue Zeile mit +, jedes Leerzeichen mit 1und jeden Buchstaben mit der entsprechenden Anzahl von Anschlägen. bc macht die Summe.

C 92 88 Bytes

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 Bytes

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

Probieren Sie es online!

Findet den mod-3 - Indizes im Alphabet ohne S und Z . Da Leerzeichen, S und Z nicht gefunden werden, haben sie den Index 25 (einen mehr als den Maximalindex), was für Leerzeichen gut ist. Dann müssen wir nur noch 3 für jedes S oder Z addieren .

{ anonyme Funktion, bei der das Argument durch ⍵ dargestellt wird :

 ⎕A~'SZ' der Großbuchstabe A lphabet mit Ausnahme von S und Z

 819⌶ Kleinbuchstaben

 ⍵⍳⍨ die Gründe des Arguments darin

 ¯1+ Fügen Sie ein negatives hinzu

 3| mod-3

 1+ addiere einen (dies wandelt alle 0-Mods in 3 um)

 (… ), Voranstellen:

  ⍵∊'sz' Boolescher Wert, bei dem das Argument entweder s oder z ist

  3× multiplizieren mit 3

 +/ Summe

C (gcc) , 7577 Bytes

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

Die nicht druckbare Zeichenfolge ""ist eine Tabelle von 04 01 02 03 01 02 03 04.

Probieren Sie es online!

Pip , 100 bis 90 Bytes

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

Überprüfen Sie jedes Zeichen der Eingabe auf eine Übereinstimmung in jedem Element von b. Der Index dieser Übereinstimmung plus 1 wird zur Gesamtsumme hinzugefügt.

Probieren Sie es online!