(Questa è la mia prima domanda sul codice-golf)

Quando ero bambino, mio ​​padre e io abbiamo inventato un gioco in cui la targa che vediamo sulle auto può dare alcuni punti basati su alcune regole piuttosto semplici:

La quantità X della stessa lettera o numero indica X-1 punti, esempi:

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

I numeri devono essere uno accanto all'altro, quindi 3353fornisce solo 1 punto, poiché il 5 interrompe la sequenza dei 3.

Una sequenza di X numeri in ordine crescente o decrescente, almeno 3, fornisce X punti, esempi:

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

Il sistema di punti funziona solo con numeri di 1 cifra, quindi 1919non dà punti e 14710dà solo 3, (147).

Le sequenze possono essere combinate per creare più punti, esempi:

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

Non ti è tuttavia permesso di tagliare una sequenza più grande in 2 sequenze più piccole per ottenere punti extra: 1234 = 123, 234 (6 points)non è permesso.

Il tuo compito è, in base a una sequenza, determinare il numero di punti assegnati dalla targa.

In Danimarca, le targhe sono strutturate in questo modo: CC II III, dove C è carattere e I è intero, e quindi i miei input di esempio rispecchieranno questa struttura. Se lo desideri, puoi adattare la sequenza alla tua struttura o, se ti senti davvero avventuroso, lasciare che il programma analizzi la struttura della targa e quindi funzioni su qualsiasi tipo di targa in tutto il mondo. Indica esplicitamente la struttura che decidi di utilizzare nella tua risposta.

Puoi prendere l'input nel modo che preferisci, o una stringa o un array sembrano avere più senso per me.

Test input | produzione:

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

A causa della natura della scelta della propria struttura, o persino della copertura di tutte le strutture, non vedo necessariamente come un vincitore possa essere esplicitamente determinato. Suppongo che il vincitore sarà il byte più breve sulla struttura che uno ha deciso. (E non prendere un input come CICIC, solo per renderti facile per te)

MODIFICARE:

A causa di commenti, ho alcune informazioni in più da condividere: una sequenza di numeri crescente o decrescente si riferisce a una sequenza aritmetica, quindi X +/- a * 0, X +/- a * 1, ... X +/- a * n ecc. Quindi 3-5-7 ad esempio è 3 + 2 * 0, 3 + 2 * 1, 3 + 2 * 2. Tuttavia, la sequenza non deve iniziare da 0 né terminare tra 0.

ALTRE MODIFICHE:

Puoi dare l'input nel modo che preferisci, non è necessario inserire spazi, trattini o qualsiasi altra cosa che renda più leggibile una targa. Se puoi salvare byte accettando solo lettere maiuscole o qualcosa del genere, puoi farlo anche tu. L'unico requisito è che il tuo programma possa prendere una stringa / matrice / qualsiasi cosa che contenga sia caratteri che numeri, e produrre la giusta quantità di punti secondo le regole stabilite.

05AB1E , 25 22 20 18 byte

Accetta una stringa di caratteri alfabetici minuscoli e numeri senza spazi.

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

Provalo online! o come una suite di test

Buccia , 20 16 15 byte

-1 byte grazie a @Zgarb

Accetta input senza spazi e in minuscolo.

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

Provalo online!

Spiegazione

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

-3 byte grazie a Lynn

Prende ingresso come un byte-stringa con lettere minuscole come: 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

Provalo online!

Java 8, 195 byte

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

Puoi sicuramente giocare a golf un po 'di più usando un'altra tecnica per controllare le sequenze.

Spiegazione:

Provalo qui.

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 byte (sconcertante)

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

Verifica tutti i casi di test o provalo qui.

R , 153 , 145 , 143 byte

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

Funzione anonima che accetta un vettore di carattere e restituisce un numero intero.
Input previstoz(c("A", "A", "1", "1", "1", "1", "1"))

Provalo online!

Versione 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 byte

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

Provalo online!

Idea rubata dalla risposta Python di Felipe Nardi Batista .

Pyth , 48 42 byte

Porta diretta dalla mia risposta Python. Accetta l'input come stringa di byte con lettere minuscole come: b'aa11111 '.

Questa è la prima volta che scrivo codice in Pyth, quindi tutti i suggerimenti sono i benvenuti: D

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

Provalo qui

JavaScript, 216 192 186 202 201 byte

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}

Unminified

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
}

Modifica cronologia:

• Limitato il codice per funzionare solo con il 0000 XXXformato. (-24 byte)
• Modifiche come suggerito da @Titus. (-6 byte)
• corretto un bug in cui quattro numeri identici davano un punteggio di 7 invece di 3. (+16 byte)
• Rimosso l'ultimo punto e virgola. (-1 byte)
• Risolto un errore di battitura nel codice. (nessuna variazione di byte)