(Ceci est ma première question de code-golf)

Quand j'étais enfant, mon père et moi avons inventé un jeu où la plaque d'immatriculation que nous voyons sur les voitures peut donner certains points sur la base de règles assez simples:

X montant de la même lettre ou du même chiffre donne X-1 points, exemples:

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

Les nombres doivent être côte à côte, donc 3353ne donne que 1 point, car le 5 rompt la séquence de 3.

Une séquence de nombres X dans l'ordre croissant ou décroissant, au moins 3, donne X points, des exemples:

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

Le système de points ne fonctionne que pour les nombres à 1 chiffre, donc 1919ne donne pas de points, et 14710ne donne que 3, (147).

Les séquences peuvent être combinées pour faire plus de points, des exemples:

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

Vous n'êtes cependant pas autorisé à couper une séquence plus grande en 2 séquences plus petites pour des points supplémentaires: 1234 = 123, 234 (6 points)n'est pas autorisé.

Votre tâche consiste, selon une séquence, à déterminer le nombre de points accordés par la plaque d'immatriculation.

Au Danemark, les plaques d'immatriculation sont structurées comme ceci: CC II III, où C est un caractère et I est un entier, et donc mes exemples d'entrées refléteront cette structure. Si vous le souhaitez, vous pouvez adapter la séquence à votre propre structure ou, si vous vous sentez vraiment aventureux, laissez le programme analyser la structure de la plaque d'immatriculation et ainsi la faire fonctionner sur n'importe quel type de plaque d'immatriculation à travers le monde. Indiquez explicitement la structure que vous décidez d'utiliser dans votre réponse.

Vous pouvez prendre l'entrée comme bon vous semble, soit une chaîne ou un tableau me semble plus logique.

Entrée de test | sortie:

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

En raison de la nature du choix de votre propre structure, ou même de la couverture de toutes les structures, je ne vois pas nécessairement comment un gagnant peut être explicitement déterminé. Je suppose que le gagnant sera les octets les plus courts sur la structure que l'on a décidé. (Et ne prenez pas une entrée comme CICIC, juste pour vous faciliter la tâche)

MODIFIER:

En raison de commentaires demandant, j'ai quelques informations supplémentaires à partager: Une séquence de nombres ascendants ou descendants fait référence à une séquence arithmétique, donc X +/- a * 0, X +/- a * 1, ... X +/- a * n etc. Donc 3-5-7 par exemple est 3 + 2 * 0, 3 + 2 * 1, 3 + 2 * 2. La séquence n'a cependant pas besoin de commencer par 0 ni de se terminer par 0.

PLUS DE MODIFICATION:

Vous pouvez donner l'entrée comme bon vous semble, vous n'avez pas besoin de saisir d'espaces, de tirets ou de toute autre chose qui rend la plaque d'immatriculation plus lisible. Si vous pouvez économiser des octets en n'acceptant que des majuscules ou quelque chose comme ça, vous pouvez le faire également. La seule exigence est que votre programme puisse prendre une chaîne / un tableau / n'importe quoi contenant à la fois des caractères et des nombres, et produire le nombre correct de points selon les règles énoncées.

05AB1E , 25 22 20 18 octets

Accepte une chaîne de caractères et de chiffres alphabétiques en minuscules sans espaces.

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

Essayez-le en ligne! ou comme suite de tests

Husk , 20 16 15 octets

-1 octet grâce à @Zgarb

Prend la saisie sans espaces et en minuscules.

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

Essayez-le en ligne!

Explication

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

-3 octets grâce à Lynn

Prend entrée comme une chaîne d'octets avec des lettres minuscules que: 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

Essayez-le en ligne!

Java 8, 195 octets

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

Peut certainement être joué un peu plus en utilisant une autre technique pour vérifier les séquences.

Explication:

Essayez ici.

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 octets (stupéfiant)

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

Vérifiez tous les cas de test ou essayez-le ici.

R , 153 , 145 , 143 octets

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

Fonction anonyme qui prend un vecteur de caractères et retourne un entier.
Entrée attenduez(c("A", "A", "1", "1", "1", "1", "1"))

Essayez-le en ligne!

Version non golfée

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 octets

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

Essayez-le en ligne!

Idée volée à la réponse de Felipe Nardi Batista en Python .

Pyth , 48 42 octets

Port direct de ma réponse python. Prend l'entrée comme une chaîne d'octets avec des lettres minuscules comme: b'aa11111 '.

C'est mon premier codage en Pyth, donc tous les conseils sont les bienvenus: D

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

Essayez-le ici

JavaScript, 216 192 186 202 201 octets

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}

Non minifié

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
}

Modifier l'historique:

• Limité le code pour ne travailler qu'avec le 0000 XXXformat. (-24 octets)
• Modifications comme suggéré par @Titus. (-6 octets)
• correction d'un bug où quatre nombres identiques donnaient un score de 7 au lieu de 3. (+16 octets)
• Suppression du dernier point-virgule. (-1 octet)
• Correction d'une faute de frappe dans le code. (pas de changement d'octet)