Hepimiz eski okul telefon tuş takımına alışkınız değil mi? Başvuru için, işte şöyle görünüyor:

Yalnızca küçük harfli ASCII harflerinden ve tek boşluklardan oluşan bir Dize verildiğinde göreviniz, bir Dize'yi bir telefon tuş takımı ile tam Dize yazmak için yapmanız gereken musluk sayısını döndürmektir.

Buna aşina olmayanlar için, işte nasıl çalıştığı:

• 2Örneğin basamaklı anahtarın abcüzerinde de yazılı bir dize vardır . Yazmak için abu tuşa bir kez bbasmanız gerekir , çünkü iki kez basmanız ve cüç kere basmanız gerekir.

• Aynı tuştaki ardışık harfler için, tekrar basmadan önce 1 saniye beklemelisiniz. Bu nedenle, yazmak istiyorsanız cb, 3 kez basmanız c, bir saniye beklemeniz ve sonra iki kez basmanız gerekir b, yine de 5 dokunma.

• Aynısı , sadece 1 basış gerektiren tek bir boşluk hariç, diğer tüm tuşlar için geçerlidir . Ayrıca, tuşların 7ve 9üzerlerinde dört harf bulunduğunu unutmayın . Aynı algoritma uygulanır, tek fark harf sayısıdır. Her bir tuşa karşılık gelen dizeler yukarıdaki resimde (ancak küçük harf) veya alabileceğiniz tüm karakterleri içeren aşağıdaki listede bulunabilir:

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

Test Kılıfları

Giriş -> Çıkış (Açıklama)

"" -> 0 (hiçbir şey kullanılmamalıdır)
"su" -> 8 ("w, a, t" her biri 1 musluğu gerektirir (9, 2 ve 8 tuşlarında), "e" 2 musluğu gerektirir (3 tuşunda), "r", 3 musluğu gerektirir (7 tuşunda) ), 1 + 1 + 1 + 2 + 3 = 8)
"sabun" -> 9 (4 + 3 + 1 + 1)
"kandela" -> 13 (3 + 1 + 2 + 1 + 2 + 3 + 1)
"kod golf" -> 20 (3 + 3 + 1 + 2 + 1 (alan için) + 1 + 3 + 3 + 3)
"Tepenin Kralı" -> 33 (2 + 3 + 2 + 1 + 1 + 3 + 3 + 1 + 1 + 2 + 2 + 1 + 2 + 3 + 3 + 3)

gözlük

• Standart G / Ç kuralları ve Varsayılan Loopholes uygulanır.

• Yalnızca kendi dilinizin yerel String türüne giriş yapabilirsiniz. Çıktı, bir tam sayı veya o tamsayının dizgi gösterimi olabilir.

• Bu kod golf , her dilde kazanılan en kısa cevap .

JavaScript (ES6) 77 66 64 60 bayt

(@Johan Karlsson ve @Arnauld sayesinde bazı baytlar kaydedildi).

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 bayt

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

Çevrimiçi deneyin!

açıklama

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

@ RickHitchcock's Javascript çözümü ile aynı algoritmayı kullanır

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

Çevrimiçi deneyin!

Python 3 , 69 67 65 64 bayt

Bay Xcoder'a 1 bayt teşekkürler.

Felipe Nardi Batista'ya 1 bayt teşekkürler.

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

Çevrimiçi deneyin!

Dyalog APL, 37 bayt

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

Çevrimiçi deneyin!

Nasıl?

Get ⍳dizesinde girdi her char nDex 'adgjmptw behknqux~cfilorvy~'( sve z28'e varsayılan olarak) 9, yuvarlak yukarı ve toplamı bölün.

JavaScript (ES6), 71 bayt

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>

Mektup masalarına bakma! @ LeakyNun formülünü pek anlamadım, bu yüzden kendiminkini buldum.

C 211 196 bayt

Buraya ilk gönderim ... oldukça uzun görünüyor ve bunun verimli bir yaklaşım olmadığını görüyorum ama en azından işe yarıyor :)

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 versiyonu:

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 bayt

Düzenleme: filtre yerine bir liste anlama kullanarak 3 bayt kaldırıldı

Düzenleme: Siracusa, Laikoni ve Zgarb sayesinde 9 bayt tasarruf edin!

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

kullanım

λ> f "candela"
13
λ>

Çevrimiçi deneyin!

Jöle , 25 bayt

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

Çevrimiçi deneyin!

Clojure, 82 76 bayt

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

Ah sadece filterve countkullanmaktan daha basittir frequencies. Orijinal:

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

Dize, belirli bir karakter için tuşa basmanız gereken bir kereden daha fazla kere kodlar :)

Python 3 , 91 bayt

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

Çevrimiçi deneyin!

Python 3 , 60 bayt

Muhtemelen sub-optimal, çünkü bu benim Python'daki ilk golf.

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

Çevrimiçi deneyin!

Retina , 46 36 bayt

6 bayt tasarrufu için CalculatorFeline sayesinde.

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

Çevrimiçi deneyin!

Java, 95 73 bayt

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

Fonksiyonunu lambda ifadesi (yapım Kevin Cruijssen sayesinde atiptedirString ). 95 bayt 73 bayt oldu!

Bir lambda ifadesi, kullanan her karakterin baskı sayısını toplar map(). map()Bu matematiği kullanarak her karakteri (küçük harf aralıktaki ASCII 97-122'dir) uygun değere dönüştürür (basit testere dalgası gibi görünür, ancak her iki 4 çevrimi de can sıkıcıdır) 1+(b<64?0:b+(Math.abs(b-115)<4?4:5))%(3+b/112). İşte bu modelin bir desmos grafiği.

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

Explanation

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

Try it online!

Folds one char per line, transliterates each newline with +, each space with 1 and each letter with the corresponding number of pushes. bc does the sum.

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

Try it online!

Finds the mod-3 indices in the alphabet without S and Z. Since space, S, and Z are not found, they "have" index 25 (one more than the max index), which is good for space. Then we just need to add 3 for each S or Z.

{ anonymous function where the argument is represented by ⍵:

 ⎕A~'SZ' the uppercase Alphabet, except for S and Z

 819⌶ lowercase

 ⍵⍳⍨ the ɩndices of the argument in that

 ¯1+ add negative one

 3| mod-3

 1+ add one (this converts all 0-mods to 3)

 (…), prepend:

  ⍵∊'sz' Boolean where the argument is either s or z

  3× multiply by 3

 +/ sum

C (gcc), 75 77 bytes

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

The unprintable string "" is a table of 04 01 02 03 01 02 03 04.

Try it online!

Pip, 100 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

Check each character of the input for a match in each element of b. The index of that match plus 1 gets added to the total.

Try it online!