(Esta é minha primeira pergunta sobre código de golfe)

Quando eu era criança, meu pai e eu inventamos um jogo em que a placa que vemos nos carros pode dar certos pontos com base em algumas regras bastante simples:

A quantidade X da mesma letra ou número fornece pontos X-1, exemplos:

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

Os números devem estar próximos um do outro, portanto, 3353fornece apenas 1 ponto, pois o 5 quebra a sequência dos 3's.

Uma sequência de números X em ordem crescente ou decrescente, no mínimo 3, fornece X pontos, exemplos:

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

O sistema de pontos funciona apenas para números de 1 dígito, portanto 1919 , não fornece pontos e 14710apenas 3, (147).

As sequências podem ser combinadas para dar mais pontos, exemplos:

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

No entanto, você não pode dividir uma sequência maior em duas sequências menores para obter pontos extras: 1234 = 123, 234 (6 points) não é permitido.

Sua tarefa é, dada uma sequência, determinar o número de pontos que a placa dá.

Na Dinamarca, as placas de carro estão estruturadas da seguinte forma: CC II III, onde C é caractere e I é inteiro, e, portanto, meus exemplos de entradas refletirão essa estrutura. Se desejar, você pode fazer com que a sequência se ajuste à sua própria estrutura ou, se você se sentir realmente aventureiro, deixe o programa analisar a estrutura da placa e, assim, fazer com que ela funcione em qualquer tipo de placa no mundo. Declare explicitamente a estrutura que você decide usar em sua resposta.

Você pode receber a entrada da maneira que quiser, seja uma string ou uma matriz que pareça fazer mais sentido para mim.

Entrada de teste | saída:

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

Devido à natureza de escolher sua própria estrutura, ou mesmo cobrir todas as estruturas, não vejo necessariamente como um vencedor pode ser explicitamente determinado. Suponho que o vencedor terá os bytes mais curtos da estrutura que você decidiu. (E não aceite uma entrada como o CICIC, apenas para facilitar as coisas)

EDITAR:

Devido aos comentários solicitados, tenho algumas informações extras para compartilhar: Uma sequência de números ascendentes ou descendentes se refere a uma sequência aritmética, então X +/- a * 0, X +/- a * 1, ... X +/- a * n etc. Então 3-5-7, por exemplo, é 3 + 2 * 0, 3 + 2 * 1, 3 + 2 * 2. A sequência, no entanto, não precisa começar de 0 nem terminar em 0

MAIS EDIÇÃO:

Você pode fornecer a entrada da maneira que desejar, não precisa inserir espaços, traços ou qualquer outra coisa que torne a placa mais legível. Se você pode salvar bytes aceitando apenas letras maiúsculas ou algo parecido, faça isso também. O único requisito é que seu programa possa pegar uma string / array / qualquer coisa que contenha caracteres e números e gerar a quantidade correta de pontos de acordo com as regras estabelecidas.

05AB1E , 25 22 20 18 bytes

Aceita uma sequência de caracteres alfabéticos minúsculos e números sem espaços.

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

Experimente online! ou como um conjunto de testes

Casca , 20 16 15 bytes

-1 byte graças a @Zgarb

Recebe entrada sem espaços e em letras minúsculas.

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

Experimente online!

Explicação

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

-3 bytes graças a Lynn

Toma entrada como um byte-string com letras minúsculas como: 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

Experimente online!

Java 8, 195 bytes

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

Definitivamente, você pode jogar um pouco mais usando outra técnica para verificar as seqüências.

Explicação:

Experimente aqui.

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

Pitão ,  51  50 bytes (impressionante)

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

Verifique todos os casos de teste ou Experimente aqui.

R , 153 , 145 , 143 bytes

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

Função anônima que pega um vetor de caracteres e retorna um número inteiro.
Entrada esperadaz(c("A", "A", "1", "1", "1", "1", "1"))

Experimente online!

Versão ungolfed

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 bytes

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

Experimente online!

Ideia roubada da resposta Python de Felipe Nardi Batista .

Pitão , 48 42 bytes

Porta direta da minha resposta python. Recebe a entrada como uma sequência de bytes com letras minúsculas como: b'aa11111 '.

Esta é minha primeira vez em Pyth, então qualquer dica é bem-vinda: D

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

Experimente aqui

JavaScript, 216 192 186 202 201 bytes

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}

Desminificado

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
}

Editar histórico:

• Limitou o código para funcionar apenas com o 0000 XXXformato. (-24 bytes)
• Edita como sugerido por @Titus. (-6 bytes)
• Foi corrigido um erro em que quatro números idênticos davam uma pontuação de 7 em vez de 3. (+16 bytes)
• Removido o último ponto e vírgula. (-1 byte)
• Corrigido um erro de digitação no código. (sem alteração de bytes)