(To jest moje pierwsze pytanie w golfa)

Kiedy byłem dzieckiem, mój tata i ja wymyśliliśmy grę, w której tablica rejestracyjna, którą widzimy w samochodach, może dawać pewne punkty na podstawie kilku dość prostych zasad:

Liczba X tej samej litery lub cyfry daje punkty X-1, przykłady:

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

Liczby muszą znajdować się obok siebie, więc 3353daje tylko 1 punkt, ponieważ 5 łamie sekwencję 3.

Sekwencja liczb X w porządku rosnącym lub malejącym, co najmniej 3, daje X punktów, przykłady:

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

System punktowy działa tylko dla liczb jednocyfrowych, więc 1919nie daje punktów, a 14710jedynie 3, (147).

Sekwencje można łączyć, aby uzyskać więcej punktów, przykłady:

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

Nie możesz jednak pociąć większej sekwencji na 2 mniejsze sekwencje dla dodatkowych punktów: 1234 = 123, 234 (6 points)nie jest dozwolone.

Twoim zadaniem jest ustalenie liczby punktów przyznanych przez tablicę rejestracyjną.

W Danii tablice rejestracyjne mają następującą strukturę: CC II III, gdzie C to znak, a I to liczba całkowita, a zatem moje przykładowe dane wejściowe będą odzwierciedlać tę strukturę. Jeśli chcesz, możesz dopasować sekwencję do własnej struktury lub, jeśli czujesz się naprawdę ryzykowny, pozwól programowi przeanalizować strukturę tablicy rejestracyjnej, a tym samym sprawić, by działała na dowolnym typie tablicy rejestracyjnej na całym świecie. Jednak w odpowiedzi wyraźnie określ strukturę, z której zdecydowałeś się skorzystać.

Możesz wziąć dane wejściowe w dowolny sposób, ciąg znaków lub tablica wydają mi się najbardziej sensowne.

Wejście testowe | wydajność:

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

Ze względu na charakter wyboru własnej struktury, a nawet obejmowania wszystkich struktur, niekoniecznie widzę, jak można wyraźnie określić zwycięzcę. Przypuszczam, że zwycięzcą będą najkrótsze bajty w strukturze, którą zdecydowano. (I nie bierz takich danych jak CICIC, tylko dla ułatwienia dla siebie)

EDYTOWAĆ:

W związku z pytaniami o komentarze mam kilka dodatkowych informacji: Sekwencja liczb rosnących lub malejących odnosi się do sekwencji arytmetycznej, więc X +/- a * 0, X +/- a * 1, ... X +/- a * n itd. Tak więc na przykład 3-5-7 to 3 + 2 * 0, 3 + 2 * 1, 3 + 2 * 2. Sekwencja nie musi jednak zaczynać się od 0 ani kończyć w 0.

WIĘCEJ EDYCJI:

Możesz podać dane w dowolny sposób, nie musisz wprowadzać spacji, myślników ani żadnych innych rzeczy, które czynią tablicę rejestracyjną bardziej czytelną. Jeśli możesz zaoszczędzić bajty, akceptując tylko wielkie litery lub coś w tym rodzaju, możesz to zrobić również. Jedynym wymaganiem jest to, aby Twój program mógł pobrać ciąg / tablicę / cokolwiek zawierającego zarówno znaki, jak i liczby, i wygenerować odpowiednią liczbę punktów zgodnie z podanymi regułami.

05AB1E , 25 22 20 18 bajtów

Akceptuje ciąg małych liter alfabetu i znaków bez spacji.

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

Wypróbuj online! lub jako pakiet testowy

Łuska , 20 16 15 bajtów

-1 bajt dzięki @Zgarb

Pobiera dane wejściowe bez spacji i małymi literami.

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

Wypróbuj online!

Wyjaśnienie

           Ẋ      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 bajtów

-3 bajty dzięki Lynn

Zajmuje wejście jako bajt-string z literami małymi jak: 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

Wypróbuj online!

Java 8, 195 bajtów

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

Można zdecydowanie zagrać w golfa za pomocą innej techniki sprawdzania sekwencji.

Wyjaśnienie:

Wypróbuj tutaj.

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 bajtów ( zataczanie się )

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

Sprawdź wszystkie przypadki testowe lub wypróbuj tutaj.

R , 153 , 145 , 143 bajty

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

Anonimowa funkcja, która pobiera wektor znaków i zwraca liczbę całkowitą.
Oczekiwany wkładz(c("A", "A", "1", "1", "1", "1", "1"))

Wypróbuj online!

Wersja bez golfa

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 bajtów

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

Wypróbuj online!

Pomysł skradziony z odpowiedzi Pythona Felipe Nardi Batisty .

Pyth , 48 42 bajtów

Bezpośredni port z mojej odpowiedzi na python. Pobiera dane wejściowe jako ciąg bajtów z małymi literami jako: b'aa11111 '.

To jest mój pierwszy kod w Pyth, więc wszelkie wskazówki są mile widziane: D

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

Wypróbuj tutaj

JavaScript, 216 192 186 202 201 bajtów

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
}

Edytuj historię:

• Zawęziłem kod do pracy tylko z 0000 XXXformatem. (-24 bajty)
• Edycje sugerowane przez @Titus. (-6 bajtów)
• naprawiono błąd, w którym cztery identyczne liczby dały wynik 7 zamiast 3. (+16 bajtów)
• Usunięto ostatni średnik. (-1 bajt)
• Naprawiono literówkę w kodzie. (bez zmiany bajtów)