Mis padres tienen un dispositivo de cine en casa. El control remoto está roto, lo que hace que sea increíblemente difícil navegar hacia la derecha en un menú. La mayoría de las veces no funciona, pero cuando lo hace se mueve hacia la derecha increíblemente rápido.

Obviamente, esto es frustrante, pero es más frustrante cuando desea ingresar un título de película que requiere navegar por un teclado que se ve así:

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

Su tarea es tomar como entrada un título de película y calcular cuán "frustrante" es escribir ese título de película. El número de frustración de una cadena en particular es el número de letras que requieren moverse directamente desde la letra anterior a ellas. No nos importa qué tan a la derecha estén, ya que si comenzamos a movernos a la derecha, casi instantáneamente llegamos al final de la línea, y no nos importa el movimiento hacia arriba, hacia abajo o hacia la izquierda porque son fáciles.

Por ejemplo, si quisiéramos escribir

keyboard

• Comenzamos en kgratis.
• eestá justo arriba, kasí que no necesitamos movernos a la derecha.
• y está completamente a la izquierda, así que no hay necesidad de moverse a la derecha.
• b sin embargo, está en la siguiente columna hacia la derecha, por lo que debemos movernos a la derecha para llegar a ella.
• o está en la siguiente columna, así que tenemos que movernos hacia la derecha para llegar a ella.
• a está de vuelta en la primera columna, así que nos movemos a la izquierda para llegar a ella.
• r está todo el camino a la derecha, así que nos movemos directamente hacia él.
• dson dos columnas a la izquierda de rla columna de.

Los personajes que necesitan moverse hacia la derecha borsignifican que esto es frustración 3.

Reglas adicionales

Este es un desafío de código de golf, por lo que sus respuestas se puntuarán en bytes con menos bytes mejor. La entrada siempre consistirá en caracteres alfanuméricos, puede admitir letras mayúsculas o minúsculas y solo necesita admitir una. La entrada nunca estará vacía.

Casos de prueba

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

JavaScript (Node.js) , 61 55 54 bytes

Guardado 1 byte gracias a @nwellnhof

Toma la entrada como una matriz de caracteres.

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

Pruébalo en línea!

¿Cómo?

Para todos los caracteres pero dígitos mayores que , la columna indexada en 0 viene dada por:$0$$x$

donde es el código ASCII del personaje.$c$

Para dígitos positivos , debemos hacer en su lugar:$n$

Ejemplos:

"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

Comentado

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

Jalea , 11 bytes

⁾04yO‘%6<ƝS

Un enlace monádico que acepta una lista de caracteres (mayúsculas).

Pruébalo en línea!

¿Cómo?

Primero reemplaza cualquier '0's con '4's (por lo que el resto del código los trata como si estuvieran en la columna más a la derecha). Luego se convierte en ordinales, agrega uno y módulo por 6para obtener índices de columna basados ​​en 0. Luego compara a los vecinos con is-less-than y suma el resultado.

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

Pruébalo en línea!

Funciona con letras mayúsculas. (2-ord(c))%46%6calcula la coordenada x invertida.

Limpio , 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)

Pruébalo en línea!

Ruby , 56 bytes

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

Pruébalo en línea!

Versión ingenua preliminar, se jugará golf.

Japt -x , 14 bytes

®rT4 c Ä u6Ãä<

Pruébalo en línea!

Puerto de esta respuesta Jelly. Toma la entrada como una matriz de caracteres, con letras mayúsculas.

Explicación:

®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 bytes

¡No es una mala solución para Java! Ese cero en el lado derecho me costó varios bytes.

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

Pruébalo en línea!

Explicado

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 gracias a @Kevin Cruijssen

¾4:Ç>6%¥1@O

Otro puerto de la respuesta de Jonathan Allan Jelly. Toma entrada en mayúsculas.

Explicación:

¾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

Pruébalo en línea!

K (ngn / k) , 32 31 28 bytes

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

Pruébalo en línea!

Retina 0.8.2 , 46 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

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

Enumere el alfabeto y los dígitos en el orden en el OSK y asigne cada uno a un número de columna (1 indexado).

.
;$&$*

Convierta cada número de columna a unario.

&`;(1+);1\1

Cuente el número de columnas seguidas por una columna más grande (es decir, hacia la derecha). El &`permite que los partidos que se solapan.

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))

Pruébalo en línea!

Mathematica, 102 bytes

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

Pura función. Toma una lista de caracteres como entrada y devuelve un número como salida. Esta es una solución bastante ingenua, las sugerencias de golf son bienvenidas.

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;

Ejecutar como tubería -nRo probarlo en línea .

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

Pruébalo en línea!

Esta función solo admitirá entradas en minúsculas

Ungolfed y comentó:

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
}

Si mi función puede aceptar cadenas de caracteres anchas, se puede reducir a 76 bytes con:

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

Pruébalo en línea!

Esta versión solo acepta entradas como en int*lugar dechar*

Ediciones:

• Golfed 3 bytes en el cálculo de la columna (función c)
• Golfó 2 bytes gracias a ceilingcat