(Esta es mi primera pregunta de código de golf)

Cuando era niño, mi papá y yo inventamos un juego en el que la placa que vemos en los autos puede dar ciertos puntos basados ​​en algunas reglas bastante simples:

La cantidad X de la misma letra o número da puntos X-1, ejemplos:

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

Los números deben estar uno al lado del otro, por lo que 3353solo da 1 punto, ya que el 5 rompe la secuencia de 3.

Una secuencia de números X en orden ascendente o descendente, con un mínimo de 3, da X puntos, ejemplos:

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

El sistema de puntos solo funciona para números de 1 dígito, por lo 1919que no da puntos, y 14710solo da 3, (147).

Las secuencias se pueden combinar para hacer más puntos, ejemplos:

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

Sin embargo, no está permitido cortar una secuencia más grande en 2 secuencias más pequeñas para obtener puntos adicionales: 1234 = 123, 234 (6 points)no está permitido.

Su tarea es, dada una secuencia, determinar la cantidad de puntos que otorga la placa.

En Dinamarca, las placas están estructuradas de la siguiente manera: CC II III, donde C es carácter y yo es entero, y por lo tanto, mis entradas de ejemplo reflejarán esta estructura. Si lo desea, puede hacer que la secuencia se adapte a su propia estructura o, si se siente realmente aventurero, deje que el programa analice la estructura de la placa y haga que funcione en cualquier tipo de placa en todo el mundo. Explique explícitamente la estructura que decide usar en su respuesta.

Puede tomar la entrada de la forma que desee, ya sea una cadena o una matriz parece tener más sentido para mí.

Entrada de prueba | salida:

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

Debido a la naturaleza de elegir su propia estructura, o incluso cubrir todas las estructuras, no veo necesariamente cómo se puede determinar explícitamente un ganador. Supongo que el ganador serán los bytes más cortos en la estructura que uno haya decidido. (Y no tome una entrada como CICIC, solo para que sea más fácil para usted)

EDITAR:

Debido a los comentarios que piden, tengo algunas informaciones adicionales para compartir: una secuencia de números ascendentes o descendentes se refiere a una secuencia aritmética, por lo que X +/- a * 0, X +/- a * 1, ... X +/- a * n etc. Así que 3-5-7, por ejemplo, es 3 + 2 * 0, 3 + 2 * 1, 3 + 2 * 2. Sin embargo, la secuencia no necesita comenzar desde 0 ni terminar en 0.

MÁS EDITAR:

Puede dar la entrada de la forma que desee, no necesita ingresar espacios, guiones o cualquier otra cosa que haga que una placa sea más legible. Si puede guardar bytes solo aceptando letras mayúsculas o algo así, puede hacerlo también. El único requisito es que su programa pueda tomar una cadena / matriz / cualquier cosa que contenga tanto caracteres como números, y generar la cantidad correcta de puntos de acuerdo con las reglas establecidas.

05AB1E , 25 22 20 18 bytes

Acepta una cadena de caracteres alfabéticos en minúsculas y números sin espacios.

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

Pruébalo en línea! o como un conjunto de pruebas

Casco , 20 16 15 bytes

-1 byte gracias a @Zgarb

Toma entrada sin espacios y en minúsculas.

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

Pruébalo en línea!

Explicación

           Ẋ      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 gracias a Lynn

Toma de entrada como un byte-cadena con 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

Pruébalo en línea!

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 se puede jugar un poco más usando otra técnica para verificar las secuencias.

Explicación:

Pruébalo aquí.

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 bytes (asombroso)

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

Verifique todos los casos de prueba o Pruébelo aquí.

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

Función anónima que toma un vector de caracteres y devuelve un entero.
Entrada esperadaz(c("A", "A", "1", "1", "1", "1", "1"))

Pruébalo en línea!

Versión sin golf

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

Pruébalo en línea!

Idea robada de la respuesta Python de Felipe Nardi Batista .

Pyth , 48 42 bytes

Puerto directo de mi respuesta de Python. Toma la entrada como una cadena de bytes con letras minúsculas como: b'aa11111 '.

Esta es la primera vez que codifico en Pyth, por lo que cualquier sugerencia es bienvenida: D

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

Pruébalo aquí

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}

No minificado

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 historial:

• Redujo el código para que solo funcione con 0000 XXXformato. (-24 bytes)
• Ediciones según lo sugerido por @Titus. (-6 bytes)
• Se corrigió un error en el que cuatro números idénticos daban una puntuación de 7 en lugar de 3. (+16 bytes)
• Se eliminó el último punto y coma. (-1 byte)
• Se corrigió un error tipográfico en el código. (sin cambio de byte)