Mölkky

Mölkky to fińska gra w rzucanie. Gracze używają drewnianej szpilki (zwanej również „mölkky”), aby spróbować przewrócić drewniane szpilki o prawie podobnych wymiarach za pomocą szpilki do rzucania, oznaczonej cyframi od 1 do 12. Początkowa pozycja szpilek jest następująca:

   (07)(09)(08)
 (05)(11)(12)(06)
   (03)(10)(04)
     (01)(02)

^{Ten opis i poniższe zasady oparte są na Wikipedii .}

Uproszczone zasady Mölkky

Przewrócenie jednego kołka powoduje zdobycie liczby punktów zaznaczonych na kołku.
Pukanie 2 lub więcej szpilek oznacza liczbę przewróconych szpilek (np. Przewrócenie 3 szpilek daje 3 punkty).
Celem gry jest osiągnięcie dokładnie 50 punktów. Punktowanie powyżej 50 jest karane poprzez przywrócenie wyniku do 25 punktów.
Na potrzeby tego wyzwania przyjmiemy, że piny są zawsze w dokładnie opisanej powyżej kolejności. (W prawdziwej grze szpilki są podnoszone ponownie po każdym rzucie w miejscu, w którym wylądowały.)

Wszystkie pozostałe zasady Mölkky są ignorowane i brany jest pod uwagę tylko jeden gracz.

Wkład

Niepusta lista list 12 booleanów. Każda lista booleanów opisuje wynik rzutu: 1, jeśli szpilka została przewrócona, a 0 w przeciwnym razie. Wartości logiczne są podane w dokładnej kolejności pinów, od lewego górnego do prawego dolnego rogu: 7 , 9 , 8 , 5 , 11 , 12 , 6 , 3 , 10 , 4 , 1 , 2 .

Wydajność

Wynik po wszystkich rzutach opisanych na wejściu, obliczany przy zastosowaniu reguł 1 , 2 i 3 .

Szczegółowy przykład

Rozważmy następujące dane wejściowe:

// 07 09 08 05 11 12 06 03 10 04 01 02
[ [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],  // scores 5 (rule #1)
  [ 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],  // scores 2 (rule #2), total: 7
  [ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 ],  // scores 7, total: 14
  [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],  // scores 12, total: 26
  [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],  // scores 12, total: 38
  [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],  // scores 11, total: 49
  [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],  // scores 7, total: 56 -> 25 (rule #3)
  [ 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ] // scores 2, total: 27

Oczekiwany wynik to 27 .

Zasady wyzwania

Możesz przyjmować dane wejściowe w dowolnym rozsądnym formacie. Zamiast list wartości logicznych można użyć liczb całkowitych, w których najbardziej znaczącym bitem jest pin # 7, a najmniej znaczącym bitem jest pin # 2. W tym formacie powyższy przykład zostałby przekazany jako [ 256, 2304, 127, 64, 64, 128, 2048, 3072 ].
Lista wejściowa może zawierać rzuty, w których nie zostanie przewrócony żaden pin, w którym to przypadku wynik zostaje pozostawiony bez zmian.
Nie masz nic specjalnego do roboty, gdy wynik osiągnie dokładnie 50 punktów. Możesz jednak założyć, że kiedy to nastąpi, nie nastąpi żaden inny rzut.
To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.

Przypadki testowe

Korzystanie z list liczb całkowitych jako danych wejściowych:

[ 0 ] --> 0
[ 528 ] --> 2
[ 4095 ] --> 12
[ 64, 0, 3208 ] --> 16
[ 16, 1907, 2048 ] --> 18
[ 2023, 2010, 1, 8 ] --> 29
[ 1726, 128, 35, 3136, 1024 ] --> 34
[ 32, 32, 2924, 2, 256, 16 ] --> 28
[ 64, 64, 2434, 1904, 3251, 32, 256 ] --> 25
[ 3659, 2777, 2211, 3957, 64, 2208, 492, 2815 ] --> 25
[ 2047, 1402, 2, 2599, 4, 1024, 2048, 3266 ] --> 50
[ 256, 2304, 127, 64, 64, 128, 2048, 3072 ] --> 27
[ 16, 8, 128, 1, 2048, 1, 2048, 513, 8, 3206 ] --> 30

Możesz użyć tego linku, aby uzyskać te przypadki testowe w formacie boolowskim.

code-golf game binary

— Arnauld
źródło

5

Fajne wyzwanie, a także świetna gra latem dla tych z was, którzy jeszcze tego nie wypróbowali - świetnie współpracuje z grillem.

— Nit

2

@Nit Dziękuję. :) Muszę wyznać, że do tej pory nie znałem tej gry. Widziałem ludzi grających podczas popołudnia w parku. Teraz chciałbym spróbować.

— Arnauld

7

Python 2 , 126 111 108 104 bajtów

-3 bajty dzięki Jonathanowi Allanowi

-4 bajty dzięki Kaya!

f=lambda A,t=0:t>50and f(A,25)or A and f(A[1:],t-~(sum(A[0])-1or 762447093078/12**A[0].index(1)%12))or t

Wypróbuj online!

Definiuje funkcję rekurencyjną, która pobiera tablicę 2D 1 i 0 i zwraca wartość całkowitą. Nic specjalnego w konstrukcji i jestem pewien, że istnieje prostsze rozwiązanie.

Wyjaśnienie:

f=lambda A,t=0:    #Define the function, initialising t to 0 on the first iteration
               t>50and f(A,25)      #If t>50 then iterate again with t=25
                              or    #Else
               A and                #If A exists
                     f(A[1:],       #Iterate again without the first list of A
                        t-~         #And add to t, either
                           (sum(A[0])-1   #The sum of all elements if that's not 1
                                         or
                           762447093078/12**A[0].index(1)%12   #Else the appropriate pin value (black magic!)
               or t       #Finally, if A is finished, just return t

— Jo King
źródło

(0x103925BA4786>>4*A[0].index(1))%16zapisuje 1 postać kontraord('GIHEKLFCJDAB'[A[0].index(1)])-65

— Kaya

1

Nieco bardziej optymalne:762447093078/12**A[0].index(1)%12

— Kaya

To dla mnie wygląda jak czarna magia! Dzięki @Kaya!

— Jo King

1

To tylko kodowanie z bazą 12

— enedil

6

Galaretka , 25 bajtów

“ñ€bḷ’œ?TLḢṖ?µ€+25¹>?50ɗ/

Monadyczny link akceptujący listę list zer i jedynek (każda o długości 12), który zwraca liczbę całkowitą.

Wypróbuj online! Lub zobacz zestaw testów (używając wartości całkowitych podanych w OP)

W jaki sposób?

W tym rozwiązaniu wykorzystano œ?, który, podając liczbę, n, a lista znajduje n- ^tą permutację leksykograficzną listy, w której lista określa kolejność sortowania. Najpierw musimy to wypracować n:

 index:  1  2  3  4  5  6  7  8  9 10 11 12
 value:  7  9  8  5 11 12  6  3 10  4  1  2   (as defined by the question)
     P: 11 12  8 10  4  7  1  3  2  9  5  6   (our permutation lookup array)

... to znaczy, że Pindeks ijest ustawiony na oryginalny indeks wartości i.
To Pma leksykograficznego indeks 438,337,469 (czyli, jeśli wziął wszystkie 12! Permutacji liczb 1 do 12 i sortowane je leksykograficznie, do 438,337,469 ^th będzie P).
Można to znaleźć za pomocą Œ¿atomu Jelly .
Oba kroki można wykonać za jednym razem, używając programu JellyĠŒ¿

“ñ€bḷ’œ?TLḢṖ?µ€+25¹>?50ɗ/ - Link: list of lists of zeros and ones
             µ€           - perform the monadic chain to the left for €ach list:
“ñ€bḷ’                    -   base 250 number = 438337469
      œ?                  -   nth permutation (reorder the 1s and 0s to their pin values)
        T                 -   truthy indices (get the pin values of the 1s)
            ?             -   if...
           Ṗ              -   ...condition: pop (length greater than 1 ?)
         L                -   ...then: length (the number of pins)
          Ḣ               -   ...else: head (the first (& only) pin value)
                        / - reduce the resulting list of integers with:
                       ɗ  -   last three links as a dyad:
               +          -     addition (add the two values together)
                     50   -     literal fifty
                    ?     -     if...
                   >      -     ...condition: greater than (sum greater than 50 ?)
                25        -     ...then: literal twenty-five
                  ¹       -     ...else: identity (do nothing - just yield the sum)

— Jonathan Allan
źródło

Myślę, że twoje wyjaśnienie dotyczące znalezienia odpowiedniego indeksu leksykograficznego wśród wszystkich permutacji byłoby warte dodania jako końcówka galaretki . (Ostatnim razem musiałem to zrobić, przeprowadziłem ręczne wyszukiwanie dychotomiczne, które nie jest tak długie w przypadku krótkich sekwencji, ale ... trochę nudne. ^^)

— Arnauld

LOL; Miałem dokładnie to samo rozwiązanie, z wyjątkiem dwóch różnych bajtów: Ṗ-> Ḋ, µ-> Ʋ. Jelly będzie naprawdę korzystać z acceppting się niladic link jako ¡„s <link>(pierwszy argument), z tym, że jeśli na samym początku programu, zachować zachowanie specjalnej obudowie.

— Erik the Outgolfer,

... i prawie wykorzystałem oba!

— Jonathan Allan

5

Python 2 , 90 bajtów

^{Mocno zainspirowany odpowiedzią Jo King na Python 2 i wykorzystujący komentarz reprezentacji Kaya o podstawie 12}

t=0
for v in input():t+=sum(v)-1or 762447093078/12**v.index(1)%12;t=[t+1,25][t>49]
print t

Wypróbuj online! Lub zobacz zestaw testowy

— Jonathan Allan
źródło

4

Pyth, 51 48 38 bajtów

VQI>=+Z?qJsN1@.PC"îO&"S12xN1J50=Z25;Z

Zaoszczędzono 10 bajtów dzięki Jonathanowi Allanowi. Wprowadza dane jako listę boolean.
Wypróbuj tutaj

Wyjaśnienie

VQI>=+Z?qJsN1@.PC"îO&"S12xN1J50=Z25;Z
VQ                                  ;     For each input...
    =+Z                                   ... add to the total...
       ?q sN1                             ... if one pin is down...
             @.PC"îO&"S12xN1              ... the score of that pin.
         J                    J           ... otherwise, the count.
  I>                           50         If we pass 50...
                                 =Z25     ... reset to 25.
                                     Z    Output the total.

Nie jestem pewien, jak dokładnie wprowadzić go do programu, ale powinien zaoszczędzić 6 lub 7 bajtów, jeśli możesz ... 7tT8h4hT12h5h2T4h02-> .PC"îO&"S12- używa indeksowania permutacyjnego leksykograficznego jak moja odpowiedź Jelly. (Kod ma niezadrukowany bajt 0x0F na początku łańcucha.)

— Jonathan Allan

))może być;

— Jonathan Allan

4

05AB1E , 29 28 bajtów

v•CÞŸαLć•13вyOΘmyÏOO25‚¬50›è

Wypróbuj online!

Wyjaśnienie

v                              # for each boolean list in input
 •CÞŸαLć•                      # push 13875514324986
         13в                   # convert to a list of base-13 numbers
            yO                 # push the sum of y
              Θm               # truthify and raise the pin-list to this number (0 or 1)
                yÏ             # keep those which are true in the current list
                  OO           # sum the list and the stack
                    25‚        # pair with 25
                       ¬50›    # check if the first number is larger than 50
                           è   # index into the pair with this result

— Emigna
źródło

4

Perl 5 , 74 70 bajtów

$\+=y/1//-1||/1/g&&(0,6,8,7,4,10,11,5,2,9,3,0,1)[pos];$\=25if++$\>50}{

Wypróbuj online!

Pobiera dane wejściowe jako ciąg bitów oddzielonych znakiem nowej linii.

— Xcali
źródło

3

Haskell , 96 bajtów

foldl(\s a->([s..50]++e)!!sum(last$zipWith(*)[7,9,8,5,11,12,6,3,10,4,1,2]a:[a|sum a>1]))0
e=25:e

Wypróbuj online!

Opakowanie jest sprytne: zasadniczo indeksuję pozycję s+sum(…)na liście ([0..50]++cycle[25]). Jednak krótszy sposób pisania to indeksowanie na pozycji sum(…)i rozpoczynanie listy od s.

— Lynn
źródło

3

Java 10, 131 130 129 bajtów

m->{int r=0,i,s,t;for(var a:m){for(i=s=t=0;i<12;s+=a[i++])t=a[i]>0?"    \n".charAt(i):t;r+=s<2?t:s;r=r>50?25:r;}return r;}

Zawiera 10 niedrukowalnych.
Wprowadź jako macierz całkowitą zer i jedynek.

-1 bajt dzięki @JonathanFrech , zmieniając \tsię w rzeczywistą kartę (działa w TIO, nie działa w moim lokalnym IDE).

Wypróbuj online.

Wyjaśnienie:

m->{                // Method with integer-matrix parameter and integer return-type
  int r=0,          //  Result-integer, starting at 0
      i,s,t;        //  Temp integers
  for(var a:m){     //  Loop over the integer-arrays of the input
    for(i=s=t=0;    //   Reset `i`, `s` and `t` to 0
        i<12;       //   Loop `i` in the range [0,12)
        s+=a[i++])  //    Increase `s` by the current value (0 or 1)
      t=a[i]>0?     //    If the current value is 1:
         "  \n".charAt(i)
                    //     Set `t` to the score at this position
        :t;         //    Else: Leave `t` the same
    r+=s<2?         //   If only a single pin was hit:
        t           //    Add its score `t` to the result
       :            //   Else:
        s;          //    Add the amount of pins `s` to the result
    r=r>50?         //   If the result is now above 50
       25           //    Penalize it back to 25
      :r;}          //   If not, it stays the same
  return r;}        //  Return the result

— Kevin Cruijssen
źródło

Myślę, że możesz zapisać jeden bajt, używając rzeczywistego znaku tabulacji w "\t\n".

— Jonathan Frech,

@JonathanFrech Hmm, rzeczywiście działa w TIO. Nie działa lokalnie w moim IDE, ale chyba kogo to obchodzi ...;)

— Kevin Cruijssen

Gdy jest gdzieś działająca implementacja, jest to dozwolone. : @

— Jonathan Frech,

2

Węgiel drzewny , 43 bajty

≔⁰ηＦθ«≧⁺⎇⊖ΣιΣι⌕α§”$｜#z⁸Ｕg⊗”⌕ι¹η¿›η⁵⁰≔²⁵η»Ｉη

Wypróbuj online! Link jest do pełnej wersji kodu. Pobiera dane wejściowe jako tablicę boolowską. Wyjaśnienie:

≔⁰η

Ustaw wynik na 0.

Ｆθ«

Pętla nad rzutami.

⎇⊖Σι

Czy liczba pinów 1?

Σι

Jeśli nie, wybierz liczbę pinów.

⌕α§”$｜#z⁸Ｕg⊗”⌕ι¹

W przeciwnym razie przetłumacz pozycję sworznia na wartość.

≧⁺...η

Dodaj to do wyniku.

¿›η⁵⁰≔²⁵η

Jeśli wynik przekroczy 50, ustaw go ponownie na 25.

»Ｉη

Wydrukuj ostateczny wynik po wszystkich rzutach.

— Neil
źródło

2

Haskell , 110 bajtów

m s|sum s==1=sum$zipWith(*)[7,9,8,5,11,12,6,3,10,4,1,2]s|1>0=sum s
f l=foldl(\b->c.(b+).m)0l
c a|a>50=25|1>0=a

Ta sama długość: f l=foldl(\b a->last$b+m a:[25|b+m a>50])0lzamiast fic

Wypróbuj online!

— Angs
źródło

Upuść argument lf na 3 bajty. f=foldl(\b->c.(b+).m)0

— aoemica,

2

Łuska , 47 35 bajtów

_{-12 bajtów dzięki H.PWiz (lepszy sposób generowania punktów kodowania listy)!}

F₅0
S?25>50+?←Lε`f`+Nm+3d4652893071

Wypróbuj online!

Wyjaśnienie

F₅0  -- input is a list of boolean lists
F    -- left fold by
 ₅   -- | the function flipped (overflowing label) on line 1
  0  -- | with initial value 0

S?25>50+?←Lε`f`+Nm+3d4652893071  -- example inputs: [0,0,0,1,0,0,0,0,0,0,0,0] 0
                     4652893071  -- integer literal: 4652893071
                    d            -- digits: [4,6,5,2,8,9,3,0,7,1]
                 m+3             -- map (+3): [7,9,8,5,11,12,6,3,10,4]
              `+N                -- append natural numbers: [7,9,8,5,11,12,6,3,10,4,1,2,3,...
            `f                   -- filter this list by argument: [5]
        ?  ε                     -- if it's of length 1
         ←                       -- | take first
          L                      -- | else the length
                                 -- : 5
       +                         -- add to argument: 5
 ?  >50                          -- if the value is > 50
  25                             -- | then 25
S                                -- | else the value
                                 -- : 5

— ბიმო
źródło

Jak o m+3d4652893071?

— H.PWiz

1

Czerwony , 189 172 bajtów

func[b][s: 0 foreach c b[d: 0 foreach e c[if e = 1[d: d + 1]]i: find c 1
n: either i[pick[7 9 8 5 11 12 6 3 10 4 1 2]index? i][0]if 50 < s: s + either 1 < d[d][n][s: 25]]s]

Wypróbuj online!

Objaśnienie niepoznanego kodu:

f: func[b][                                            ; a block of blocks of booleans
    s: 0                                               ; sets sum to 0
    foreach c b[                                       ; for each row of booleans 
        d: 0 foreach e c[if e = 1[d: d + 1]            ; count the number of 1s         
        i: find c 1                                    ; the index of the first 1
        n: either i[pick [7 9 8 5 11 12 6 3 10 4 1 2]  ; if there is 1, pick the number
                    index? i][0]                       ; at the index of 1
                                                       ; otherwise 0  
        if 50 < s: s + either 1 < d[d][n][s: 25]       ; if there is only one 1, add 
                                                       ; the number to the sum, otherwise
                                                       ; the number of 1s 
                                                       ; if the sum > 50, reset it to 25 
    ]
    s                                                  ; return the sum 
]

— Galen Iwanow
źródło

1

JavaScript (ES6), 98 bajtów

a=>a.map(b=>b.map((m,i)=>(c+=m,d+=m*('0x'+'7985bc63a412'[i])),c=d=0)|(t+=c>1?c:d)>50?t=25:0,t=0)|t

Przypadki testowe:

Pokaż fragment kodu

f=
a=>a.map(b=>b.map((m,i)=>(c+=m,d+=m*('0x'+'7985bc63a412'[i])),c=d=0)|(t+=c>1?c:d)>50?t=25:0,t=0)|t

console.log(f([ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ])) // 0
 
console.log(f([ [ 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0 ] ])) // 2
 
console.log(f([ [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ] ])) // 12

console.log(f(
[ [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0 ] ]
)); // 16

console.log(f(
[ [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ],
  [ 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1 ],
  [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] 
])); // 18

console.log(f(
[ [ 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1 ],
  [ 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ] ] 
)); // 29

console.log(f(
[ [ 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0 ],
  [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1 ],
  [ 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],
  [ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ] 
))  // 34
 
console.log(f( 
[ [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
  [ 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],
  [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ] ] 
))  // 28
 
console.log(f( 
[ [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],
  [ 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0 ],
  [ 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0 ],
  [ 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1 ],
  [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ] ] 
))  // 25

console.log(f(
[ [ 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1 ],
  [ 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1 ],
  [ 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1 ],
  [ 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1 ],
  [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],
  [ 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0 ],
  [ 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1 ] ] 
)) // 25
 
console.log(f(
[ [ 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
  [ 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ],
  [ 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 ],
  [ 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0 ] ] 
)) // 50

console.log(f(
[ [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 ],
  [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],
  [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ] 
)) // 27

console.log(f(  
[ [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
  [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ],
  [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ],
  [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],
  [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1 ],
  [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
  [ 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0 ] ] 
)) // 30

Rozwiń fragment kodu

— Rick Hitchcock
źródło

Taki sam rozmiar jak (i bardzo podobny do) mojej implementacji referencyjnej . :)

— Arnauld

A, fajnie. Cieszę się, gdy mogę dopasować rozmiar kodu. Tylko raz na niebieskim księżycu mogę go pokonać :)

— Rick Hitchcock

0

Stax , 37 bajtów

├T<↓"♥←~;▌6»≥øF←î5░U╚_π○Q▒<│∟└ù║pε♀▀æ

Uruchom i debuguj

Wypróbuj online!

Wyjaśnienie

F:1"=EA5MQ9-I1%)"!s@c%1={h+}{%+}?c50>{d25}{}?    # Full program, unpacked

F                                                # Loop through every element
 :1                                              # Get indices of truthy elements
   "=EA5MQ9-I1%)"!                               # Push encoded [7,9,8,5,11,12,6,3,10,4,1,2]
                 s@                              # Swap the top 2 elements of stack and get elements at indexes
                   c%1=                          # Copy the top element, get length of array, compare to length of 1
                       {h+}{%+}?                 # If it has length of 1, add the element, otherwise add the length of the array to total
                                 c50>            # Compare total to 50, 
                                     {d25}{}?    # If it is greater, pop it off and push 25 to reset counter, otherwise do nothing

Nie moja najlepsza praca, ale działa. Jestem pewien, że brakuje mi czegoś, co może być nieco krótsze.

— Wielo
źródło

0

Python 2 , 109 105 103 bajtów

c=0
for l in input():a=sum(l);c+=int('7985bc63a412'[l.index(1)],16)if a==1else a;c=(25,c)[c<51]
print c

Wypróbuj online!

Alternatywa bez funkcji rekurencyjnej.

-2 dzięki dzięki @Jo King

— ElPedro
źródło

Możesz usunąć nawiasy wokół dosłownego łańcucha

— Jo King

Zagrajmy w Mölkky!

Mölkky

Uproszczone zasady Mölkky

Wkład

Wydajność

Szczegółowy przykład

Zasady wyzwania

Przypadki testowe

Python 2 , 126 111 108 104 bajtów

Wyjaśnienie:

Galaretka , 25 bajtów

W jaki sposób?

Python 2 , 90 bajtów

Pyth, 51 48 38 bajtów

Wyjaśnienie

05AB1E , 29 28 bajtów

Perl 5 , 74 70 bajtów

Haskell , 96 bajtów

Java 10, 131 130 129 bajtów

Węgiel drzewny , 43 bajty

Haskell , 110 bajtów

Łuska , 47 35 bajtów

Wyjaśnienie

Czerwony , 189 172 bajtów

Objaśnienie niepoznanego kodu:

JavaScript (ES6), 98 bajtów

Stax , 37 bajtów

Python 2 , 109 105 103 bajtów