我的父母有家庭影院设备。遥控器坏了，很难在菜单中向右导航。大多数情况下，它不起作用，但是当它起作用时，它会迅速向右快速移动。

这显然很令人沮丧，但是当您想要输入需要导航如下所示的键盘的电影标题时，这最令人沮丧：

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。

附加规则

这是一个代码高尔夫球挑战，因此您的答案将以字节计分，而字节数越少越好。输入将始终由字母数字字符组成，您可以支持大写或小写字母，并且只需要支持一个。输入永远不会为空。

测试用例

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

JavaScript（Node.js），61 55 54字节

@nwellnhof节省了1个字节

将输入作为字符数组。

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 替换任何s '4'（因此其余代码将它们视为在最右边的列中）。然后转换为普通数，加1和取模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计算反向的x坐标。

干净，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（ngn / 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个字节