У моих родителей есть домашний кинотеатр. Пульт дистанционного управления сломан, что делает его невероятно сложным для навигации по меню. Большую часть времени это не работает, но когда это происходит, оно движется вправо невероятно быстро.

Это, конечно, расстраивает, но больше всего расстраивает, когда вы хотите ввести название фильма, которое требует навигации по клавиатуре, которая выглядит следующим образом:

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

Ваша задача - взять в качестве входных данных заголовок фильма и рассчитать, насколько «сложно» набрать этот заголовок фильма. Число разочарования конкретной строки - это количество букв, которые требуют перемещения прямо от буквы перед ними. Нам все равно, насколько они правы, потому что, если мы начинаем двигаться вправо, мы практически мгновенно переходим к концу линии, и нам нет дела до движения вверх, вниз или влево, потому что они легкие.

Например, если мы хотим ввести

keyboard

• Мы начинаем kбесплатно.
• eчуть выше, kпоэтому нам не нужно двигаться прямо.
• y все пути влево, так что нет необходимости двигаться вправо.
• b однако находится на следующем столбце вправо, поэтому нам нужно двигаться вправо, чтобы добраться до него.
• o находится на следующем столбце, поэтому мы должны двигаться вправо, чтобы добраться до него.
• a вернулся в первый столбец, поэтому мы двигаемся влево, чтобы добраться до него.
• r все пути справа, поэтому мы идем прямо к нему.
• dэто два столбца слева от rстолбца.

Символы, которым нужно двигаться вправо, borозначают, что это разочарование 3.

Дополнительные правила

Это задача кода-гольфа, поэтому ваши ответы будут оцениваться в байтах, а меньшее количество байтов будет лучше. Ввод всегда будет состоять из буквенно-цифровых символов, вы можете поддерживать как заглавные, так и строчные буквы, и вам нужна только одна. Ввод никогда не будет пустым.

Testcases

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

JavaScript (Node.js) , 61 55 54 байта

Сохранено 1 байт благодаря @nwellnhof

Принимает ввод как массив символов.

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

Попробуйте онлайн!

Как?

Для всех символов, кроме цифр больше $0$ , 0-индексированный столбец $x$ определяется как:

где - код ASCII символа.$c$

Для положительных цифр нам нужно сделать вместо этого:$n$

Примеры:

"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

комментарии

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

Желе , 11 байт

⁾04yO‘%6<ƝS

Монадическая ссылка, принимающая список (заглавных) символов.

Попробуйте онлайн!

Как?

Сначала заменяет любые '0's на '4's (поэтому остальная часть кода обрабатывает их как находящиеся в крайнем правом столбце). Затем приводит к порядковым номерам, добавляет единицу и по модулю, 6чтобы получить индексы столбцов на основе 0. Затем сравнивает соседей с «меньше» и суммирует результат.

⁾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 байт

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

Попробуйте онлайн!

Работает с заглавными буквами. (2-ord(c))%46%6вычисляет обратную координату х

Чисто , 85 байт

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

Попробуйте онлайн!

Рубин , 56 байт

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

Попробуйте онлайн!

Предварительная наивная версия, будет в гольфе.

Japt -x , 14 байт

®rT4 c Ä u6Ãä<

Попробуйте онлайн!

Порт этого желе ответ. Принимает ввод в виде массива символов, с заглавными буквами.

Объяснение:

®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 байта

Неплохое решение для Java! То, что ноль находится справа, стоило мне нескольких байтов.

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

Попробуйте онлайн!

Разъяснения

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 байт

-1 байт благодаря @Kevin Cruijssen

¾4:Ç>6%¥1@O

Еще один порт желе Джонатана Аллана. Принимает ввод в верхнем регистре.

Объяснение:

¾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

Попробуйте онлайн!

K (нгн / к) , 32 31 28 байт

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

Попробуйте онлайн!

Сетчатка 0.8.2 , 46 байт

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

Попробуйте онлайн! Ссылка включает в себя тестовые случаи. Объяснение:

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

Перечислите алфавит и цифры в порядке на OSK и сопоставьте каждый из них с (1-индексированным) номером столбца.

.
;$&$*

Конвертировать каждый номер столбца в одинарный.

&`;(1+);1\1

Подсчитайте количество столбцов, за которыми следует столбец большего размера (т. Е. Вправо). &`Позволяет спички , чтобы перекрытия.

Python 2 , 84 байта

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

Попробуйте онлайн!

Mathematica, 102 байта

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

Чистая функция. Принимает список символов в качестве ввода и возвращает число в качестве вывода. Это довольно наивное решение, приветствуем предложения по игре в гольф.

PHP, 74 81 77 байт

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

Запустите как трубу с -nRили попробуйте онлайн .

C (gcc) ,  82 79  77 байтов

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

Попробуйте онлайн!

Эта функция будет поддерживать только строчные вводы

Развернулся и прокомментировал:

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
}

Если моей функции разрешено принимать строки широких символов, ее можно уменьшить до 76 байт с помощью:

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

Попробуйте онлайн!

Эта версия просто принимает ввод, а int*неchar*

Редактирование:

• Гольф 3 байта в расчете столбца (функция c)
• Гольф 2 байта, благодаря функциюcatcat