（这是我的第一个代码高尔夫球问题）

当我还是个孩子的时候，我父亲和我发明了一款游戏，我们在车上看到的车牌可以根据一些相当简单的规则给出一些要点：

X个相同字母或数字的数量给出X-1分，例如：

22 = 1 point
aa = 1 point
5555 = 3 points

这些数字必须彼此相邻，因此3353仅给出1分，因为5打破了3的序列。

X的升序或降序序列（至少3个）给出X点，例如：

123 = 3 points
9753 = 4 points
147 = 3 points

分数系统仅适用于1位数字，因此1919不给出分数，而14710仅给出3（147）。

序列可以结合起来以提出更多的观点，例如：

1135 = 4 points (1 point for 11 and 3 points for 135)
34543 = 6 points (3 points for 345 and 3 points for 543)

但是，您不能将一个较大的序列切成2个较小的序列以获取加分：1234 = 123, 234 (6 points)不允许。

给定序列，您的任务是确定车牌给出的分数。

在丹麦，车牌的结构如下：CC II III，其中C是字符，I是整数，因此我的示例输入将反映这种结构。如果您愿意，可以使序列适合您自己的结构，或者，如果您真的很冒险，请让该程序分析车牌的结构，从而使其可以在世界各地的任何类型的车牌上使用。明确说明您决定在答案中使用的结构。

您可以按照自己喜欢的任何方式进行输入，对于我来说，字符串或数组似乎最有意义。

测试输入 输出：

AA 11 111 | 5
AB 15 436 | 3
OJ 82 645 | 0
UI 65 456 | 6
HH 45 670 | 5
YH 00 244 | 5
AJ 00 754 | 1

由于选择自己的结构甚至覆盖所有结构的性质，我不一定会看到如何明确确定赢家。我想获胜者将是一个已经决定的结构中最短的字节。（也不要接受CICIC这样的输入，只是为了方便自己）

编辑：

由于提出了一些评论，我需要分享一些额外的信息：升序或降序序列是指算术序列，因此X +/- a * 0，X +/- a * 1，... X +/- a * n等。例如3-5-7是3 + 2 * 0、3 + 2 * 1、3 + 2 *2。但是，该序列无需从0开始或以结尾0。

更多编辑：

您可以按照自己的喜好输入任何内容，而无需输入空格，破折号或其他任何使车牌更具可读性的内容。如果您可以只接受大写字母或类似的东西来节省字节，那么您也可以这样做。唯一的要求是您的程序可以采用包含字符和数字的字符串/数组/任何东西，并根据规定的规则输出正确数量的点。

05AB1E，25 22 20 18字节

接受一串小写字母字符和不带空格的数字。

Ç¥0Kγ€gXK>OIγ€g<OO

在线尝试！ 或作为测试套件

外壳，20 16 15字节

-1个字节感谢@Zgarb

接受无空格且小写的输入。

ṁ??¬o→LεL←gẊ¤-c

在线尝试！

说明

           Ẋ      Map over all adjacent pairs
            ¤-c   get the difference of their codepoints
          g       Split into groups of equal elements
ṁ                 Map then sum
 ?       ←          If the head of the list is truthy (not 0)
  ?    ε              If the length of the list is 1
   ¬                    return 0
                       Else
    o→L                 return the length + 1
                     Else
        L             return the length

Python 3中，193 85个字节

-3字节感谢Lynn

需要输入一个字节串用小写字母为：b'aa11111'。

def f(s):
 d=l=L=p=0
 for c in s:C=0!=d==c-l;p+=(c==l)+C*L;L=3>>C;d=c-l;l=c
 return p

在线尝试！

Java 8，195字节

a->{int r=a[0]==a[1]?1:0,i=3,j,p=a[2],x,y,z;for(;i<7;p=a[i++])for(r+=(x=a[i])==p?1:0,j=-4;++j<4;r+=j==0?0:i<6&&p+j==x&x+j==(y=a[i+1])?++i<6&&y+j==(z=a[i+1])?++i<6&&z+j==a[i+1]?5:4:3:0);return r;}

通过使用另一种技术来检查序列，绝对可以打更多的高尔夫球。

说明：

在这里尝试。

a->{                      // Method with character-array parameter and integer return-type
  int r=                  //  Result-integer
        a[0]==a[1]?       //   If the two letters are equal:
         1                //    Start this result-integer at 1
        :                 //   Else:
         0,               //    Start the result-integer at 0 instead
      i=3,j,              //  Index-integers
      p=a[2],x,y,z;       //  Temp integers
   for(;i<7;              //  Loop (1) from index 3 to 7 (exclusive)
       p=a[i++])          //    And after every iteration: Set `p` and raise `i` by 1
     for(r+=(x=a[i])==p?  //   If the current digit (now `x`) equals the previous `p`:
             1            //    Raise the result-integer by 1
            :             //   Else:
             0,           //    Keep the result-integer the same
         j=-4;++j<4;      //   Inner loop (2) from -3 to 3 (inclusive)
       r+=j==0?           //    If `j` is 0:
           0              //     Skip it, so keep the result-integer the same
          :i<6            //    Else-if `i` is not 6,
           &&p+j==x       //    and the previous digit `p` + `j` equals the current digit,
           &x+j==(y=a[i+1])?
                          //    and the current digit `x` + `j` equals the next digit `y`:
            ++            //     Raise index `i` by 1 first,
              i<6         //     and check if `i` is not 6 again,
              &&y+j==(z=a[i+1])?
                          //     and if the new current digit `y` + `j` equals the next digit `z`:
               ++         //      Raise index `i` by 1 first again,
                 i<6      //      and check if `i` is not 6 again,
                 &&z+j==a[i+1]?
                          //      and if the new current digit `z` + `j` equals the next digit:
                  5       //       Raise the result-integer by 5
                 :        //      Else:
                  4       //       Raise it by 4 instead
              :           //     Else:
               3          //      Raise it by 3 instead
           :              //    Else:
            0             //     Keep it the same
     );                   //   End of inner loop (2)
                          //  End of loop (1) (implicit / single-line body)
  return r;               //  Return the result-integer
}                         // End of method

Pyth， 51  50字节（交错）

+/|R0.+QZslM.MlZ+kfTsmm?&!-K.+sMkhK.AKkY.:>Q2d}3 5

验证所有测试用例或在此处尝试。

[R ，153，145，143个字节

function(x){p=0;s=sum;if(x[1]==x[2])p=1;a=diff(strtoi(x[3:7]));p=p+s(a==0);l=sort(table(a[a!=0]),T);(p=p+s(l[(l[((s(l)>0)&(l[1]>1))]+1)>2]+1))}

带有字符向量并返回整数的匿名函数。
预期输入z(c("A", "A", "1", "1", "1", "1", "1"))

在线尝试！

非高尔夫版本

function(x){
  pnt <- 0; s <- sum
  if(x[1] == x[2]) pnt <- 1
  a <- diff(strtoi(x[3:7]))
  pnt <- pnt + s(a == 0)
  l <- sort(table(a[a!=0]), T)
  (pnt <- pnt + s(l[(l[((s(l) > 0) & (l[1] > 1))] + 1) > 2] + 1))
}

C（gcc），91字节

f(p,r,d,D,s,l)char*p;{for(r=D=0;d=p[1]-*p,*++p;D=d){s=d&&d==D;r+=!d+s*l;l=3-2*s;}return r;}

在线尝试！

想法从Felipe Nardi Batista的Python回答中被盗。

Pyth，48 42字节

从我的python答案直接端口。将输入作为带小写字母的字节字符串作为：b'aa11111'。

这是我第一次在Pyth中编码，因此欢迎任何提示：D

KJ=b0VQ=d&KqK-NJ=+b+qNJ*dZ=Z-3yd=K-NJ=JN;b

在这里尝试

JavaScript中，216个 192 186 202 201字节

function f(s){var a=s.split(" "),c=a[1],a=a[0],r,h=b=i=p=0;for(i=0;i<4;i++){if(i<2&(r=a[i+1]-a[i]==a[i+2]-a[i+1])){p++;b=2}if(i>0){if(a[i]==a[i-1]){p++;h++}if(i<3&c[i]==c[i-1])p++}}return h==4?p+b:p-b}

未缩小

function f(s){
    var a=s.split(" "),c=a[1],a=a[0],r,h=b=i=p=0;
    for(i=0;i<4;i++){
        if(i<2&(r=a[i+1]-a[i]==a[i+2]-a[i+1])){
            p++;
            b=2
        }
        if(i>0){
            if(a[i]==a[i-1]){
                p++;
                h++;
            }
            if(i<3&c[i]==c[i-1]) 
                p++;
        }
    }

    return h==4?p+b:p-b
}

编辑历史记录：

• 缩小代码以仅使用0000 XXX格式。（-24字节）
• 根据@Titus的建议进行编辑。（-6个字节）
• 修复了四个相同的数字得到7而不是3的错误。（+ 16字节）
• 删除了最后一个分号。（-1字节）
• 修复了代码中的错字。（无字节更改）