Meine Eltern haben ein Heimkino-Gerät. Die Fernbedienung ist kaputt und es ist unglaublich schwierig, in einem Menü nach rechts zu navigieren. Meistens funktioniert es nicht, aber wenn es funktioniert, bewegt es sich unglaublich schnell nach rechts.

Dies ist offensichtlich frustrierend, aber es ist am frustrierendsten, wenn Sie einen Filmtitel eingeben möchten, für den eine Tastatur verwendet werden muss, die wie folgt aussieht:

a b c d e f
g h i j k l
m n o p q r
s t u v w x
y z 1 2 3 4
5 6 7 8 9 0

Ihre Aufgabe ist es, einen Filmtitel als Eingabe zu verwenden und zu berechnen, wie "frustrierend" es ist, diesen Filmtitel einzugeben. Die Frustrationszahl einer bestimmten Zeichenfolge ist die Anzahl der Buchstaben, die direkt von dem Buchstaben vor ihnen verschoben werden müssen. Es ist uns egal, wie weit sie richtig liegen, denn wenn wir uns nach rechts bewegen, gehen wir ziemlich sofort ans Ende der Linie und es ist uns egal, ob wir uns nach oben, unten oder links bewegen, weil sie einfach sind.

Zum Beispiel, wenn wir eintippen wollten

keyboard

• Wir starten kumsonst.
• eist gerade oben, kdamit wir uns nicht nach rechts bewegen müssen.
• y Ist ganz links, so dass Sie sich nicht nach rechts bewegen müssen.
• b Befindet sich jedoch in der nächsten Spalte nach rechts, müssen wir uns nach rechts bewegen, um dorthin zu gelangen.
• o Ist in der nächsten Spalte vorbei, müssen wir nach rechts gehen, um dorthin zu gelangen.
• a ist wieder in der ersten Spalte, also bewegen wir uns nach links, um dorthin zu gelangen.
• r ist den ganzen Weg auf der rechten Seite, also bewegen wir uns direkt dorthin.
• dbefindet sich zwei Spalten links von rder Spalte.

Die Charaktere, die sich nach rechts bewegen müssen, borbedeuten, dass dies Frustration ist 3.

Zusätzliche Regeln

Dies ist eine Code-Golf- Herausforderung, daher werden Ihre Antworten in Bytes bewertet, wobei weniger Bytes besser sind. Die Eingabe besteht immer aus alphanumerischen Zeichen. Sie können entweder Groß- oder Kleinbuchstaben eingeben und müssen nur eine eingeben. Die Eingabe wird niemals leer sein.

Testfälle

keyboard -> 3
2001aspaceodyssey -> 6
sorrytobotheryou -> 8
thinblueline -> 5
blast2 -> 3

JavaScript (Node.js) , 61 55 54 Byte

1 Byte dank @nwellnhof gespeichert

Nimmt die Eingabe als Array von Zeichen.

s=>s.map(p=c=>r+=p>(p=(+c?~c:1-Buffer(c)[0])%6),r=0)|r

Probieren Sie es online!

Wie?

Für alle Zeichen außer Ziffern größer als $0$ ist die mit 0 indizierte Spalte $x$ gegeben durch:

Dabei ist der ASCII-Code des Zeichens.$c$

Für positive Ziffern müssen wir stattdessen Folgendes tun:$n$

Beispiele:

"a" --> (97 - 1) mod 6 = 96 mod 6 = 0
"b" --> (98 - 1) mod 6 = 97 mod 6 = 1
"0" --> (48 - 1) mod 6 = 47 mod 6 = 5
"3" --> ( 3 + 1) mod 6 =  4 mod 6 = 4

Kommentiert

s =>                       // s = input string (as array)
  s.map(p =                // initialize p to a non-numeric value
  c =>                     // for each character c in s:
    r +=                   //   update the result r:
      p > (                //   compare p with
        p = (              //   the new value of p defined as:
          +c ?             //     if c is a positive digit:
            ~c             //       -(int(c) + 1)
          :                //     else:
            1-Buffer(c)[0] //       -(ord(c) - 1)
        ) % 6              //     apply modulo 6
      ),                   //   yields 1 if the previous value is greater than the new one
    r = 0                  //   start with r = 0
  ) | r                    // end of map(); return r

Jelly , 11 Bytes

⁾04yO‘%6<ƝS

Ein monadischer Link, der eine Liste von (Groß-) Zeichen akzeptiert.

Probieren Sie es online!

Wie?

Ersetzt zuerst ein beliebiges '0's durch '4's (der Rest des Codes behandelt sie also so, als ob sie sich in der äußersten rechten Spalte befinden). Wirft dann auf Ordnungszahlen, addiert Eins und Modulo 6, um 0-basierte Spaltenindizes zu erhalten. Dann vergleicht Nachbarn mit is-less-than und summiert das Ergebnis.

⁾04yO‘%6<ƝS - Link: list of characters         e.g. "BLAST20"
⁾04         - list of characters = ['0', '4']
   y        - translate                             "BLAST24"
    O       - ordinals                              [66,76,65,83,84,50,52]
     ‘      - increment                             [67,77,66,84,85,51,53]
       6    - literal six
      %     - modulo                                [ 1, 5, 0, 0, 1, 3, 5]
         Ɲ  - neighbourly:
        <   -   less than?                          [  1, 0, 0, 1, 1, 1  ]
          S - sum                                   4

Perl 6 , 45 39 Bytes

{sum .[1..*]Z<$_}o{(2 X-.ords)X%46 X%6}

Probieren Sie es online!

Funktioniert mit Großbuchstaben. (2-ord(c))%46%6berechnet die umgekehrte x-Koordinate.

Sauber , 85 Bytes

import StdEnv
(\s=sum[1\\a<-s&b<-tl s|b>a])o map(\e=(toInt e+if(e-'1'>'/')1 -1)rem 6)

Probieren Sie es online!

Ruby , 56 Bytes

->s{w=9;s.count{|c|w<w=[*?a..?z,*?1..?9,?0].index(c)%6}}

Probieren Sie es online!

Vorläufige naive Version, wird Golf gespielt.

Japt -x , 14 Bytes

®rT4 c Ä u6Ãä<

Probieren Sie es online!

Port dieser Gelee-Antwort. Nimmt die Eingabe als Array von Zeichen mit Großbuchstaben.

Erläuterung:

®rT4 c Ä u6Ãä<    :
®          Ã      :Map each character through:
 rT4              : Replace 0 with 4
     c            : Get the char-code
       Ä          : Increment it
         u6       : Modulo 6
            ä<    :Replace with 1 if you had to move right, 0 otherwise
                  :Implicitly sum and output

Java (OpenJDK 8) , 73 Byte

Keine schlechte Lösung für Java! Diese Null auf der rechten Seite hat mich mehrere Bytes gekostet.

t->{int a=9,c=0;for(int d:t)c+=a<(a=(--d+(d/48==1?2:0))%6)?1:0;return c;}

Probieren Sie es online!

Erklärt

t -> {                          // Lambda taking a char array as input
    int a=9,                    // Initialise last column value
        c=0;                    // Initialise frustration count
    for(int d:t)                // Loop through all chars in title
        c+=                     // increment the frustration count if...
          a<                    // The last column is smaller than the current column
            (a=                 // Set last column to current column
              (--d+             // Decrement ascii value of char
                  (d/48==1      // If ascii decremented ascii value is between 48 and 95
                    ?2:0)       // increment by 2 (1 total) or 0 (-1 total)
                )%6)            // Mod 6 to retrieve column index
            ?1:0;               // Increment if to right hand side
    return c;                   // return calculated frustration count
}

05AB1E , 12 11 Bytes

-1 Byte danke an Kevin Cruijssen

¾4:Ç>6%¥1@O

Eine weitere Portierung von Jonathan Allans Jelly-Antwort. Nimmt die Eingabe in Großbuchstaben vor.

Erläuterung:

¾4:Ç>6%¥1@O   //full program
¾4:           //replace all '0's with '4's
   Ç          //get ASCII code points
    >         //increment
     6%       //modulo 6
       ¥      //get deltas
        1@    //is >= 1
          O   //sum

Probieren Sie es online!

K (ngn / k) , 32 31 28 Bytes

+/>':6!(,/"a10"+!'26 9 1)?0+

Probieren Sie es online!

Retina 0.8.2 , 46 Bytes

T`l1-90`1-61-61-61-61-61-6
.
;$&$*
&`;(1+);1\1

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

T`l1-90`1-61-61-61-61-61-6

Listen Sie das Alphabet und die Ziffern in der Reihenfolge auf, in der sie im OSK aufgeführt sind, und ordnen Sie sie jeweils einer (1-indizierten) Spaltennummer zu.

.
;$&$*

Wandle jede Spaltennummer in eine unäre um.

&`;(1+);1\1

Zählen Sie die Anzahl der Spalten, auf die eine größere (dh nach rechts gerichtete) Spalte folgt. Dadurch &`können sich die Übereinstimmungen überlappen.

Python 2 , 84 Bytes

def f(s,k=6):j=(ord(s[0])+('0'<s[0]<':')*2-1)%6;return(j>k)+(~-len(s)and f(s[1:],j))

Probieren Sie es online!

Mathematica, 102 Bytes

Differences[Last@@Join[Alphabet[],ToString/@Range@9,{"0"}]~Partition~6~Position~#&/@#]~Count~_?(#>0&)&

Funktion pur. Nimmt eine Liste von Zeichen als Eingabe und gibt eine Zahl als Ausgabe zurück. Dies ist eine ziemlich naive Lösung, Golf Vorschläge willkommen.

PHP, 74 81 77 Bytes

for(;$o=ord($argn[$i]);$i++&&$f+=$p<$x,$p=$x)$x=(--$o/48^1?$o:$o+2)%6;echo$f;

Laufen Sie als Pipe mit -nRoder probieren Sie es online aus .

C (gcc) ,  82 79  77 Bytes

o;c(i){i+=i<60&i>48?1:5;i%=6;}f(char*s){for(o=0;*++s;o+=c(*s)>c(s[-1]));o=o;}

Probieren Sie es online!

Diese Funktion unterstützt nur Eingaben in Kleinbuchstaben

Ungolfed und kommentiert:

o; //Used for output
c(i){             //Calculates the column of given character
     i+=          //Correct i to get the correct column
        i<60      //If i is a digit...
        & i>48   //... but not '0'
        ?1           //Then move it one column on the right
        :5;          //Else move it five columns on the right
     i%=6;        //Get the column number
}
f(char*s){                        // The actual "frustrating" function
          for(                    //Loop for each character
              o=0;                //reinitialize output
              *++s;               //move to next character / while this is not '\0'
              o+=c(*s)>c(s[-1])  //Increment if current character is on the right of the previous one
             );
           o=o;                   // Outputs result
}

Wenn meine Funktion breite Zeichenketten akzeptieren darf, kann sie auf 76 Bytes reduziert werden mit:

o;c(i){i+=i<60&i>48?1:5;i%=6;}f(int*s){for(o=0;*++s;o+=c(*s)>c(s[-1]));o=o;}

Probieren Sie es online!

Diese Version akzeptiert nur Eingaben wie int*anstelle vonchar*

Bearbeitungen:

• 3 Bytes in der Berechnung der Spalte (Funktion c) abgelegt
• Golf 2 Bytes dank Ceilingcat