Mölkky

Mölkky è un gioco di lancio finlandese. I giocatori usano un perno di legno (chiamato anche "mölkky") per provare a rovesciare perni di legno di dimensioni quasi simili con il perno di lancio, contrassegnati con numeri da 1 a 12. La posizione iniziale dei perni è la seguente:

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

^{Questa descrizione e le regole seguenti sono basate su Wikipedia .}

Regole Mölkky semplificate

Bussare su un perno segna il numero di punti segnati sul perno.
Bussare 2 o più perni segna il numero di perni rovesciati (ad esempio, bussare per 3 perni ottiene 3 punti).
Lo scopo del gioco è raggiungere esattamente 50 punti. Segnare più di 50 è penalizzato riportando il punteggio a 25 punti.
Ai fini di questa sfida, supponiamo che i pin siano sempre nell'ordine esatto sopra descritto. (In una partita reale, i perni vengono rialzati dopo ogni lancio nella posizione in cui sono atterrati.)

Tutte le altre regole di Mölkky vengono ignorate e viene considerato solo un singolo giocatore.

Ingresso

Un elenco non vuoto di elenchi di 12 booleani. Ogni lista di booleani descrive l'esito di un lancio: 1 se il perno è stato rovesciato e 0 altrimenti. I booleani sono indicati nell'ordine esatto dei pin, dall'alto in basso a in basso a destra: 7 , 9 , 8 , 5 , 11 , 12 , 6 , 3 , 10 , 4 , 1 , 2 .

Produzione

Il punteggio dopo tutti i tiri descritti nell'input, calcolato applicando le regole 1 , 2 e 3 .

Esempio dettagliato

Consideriamo il seguente input:

// 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

L'output previsto è 27 .

Regole della sfida

È possibile accettare input in qualsiasi formato ragionevole. Invece di elenchi di valori booleani, è possibile utilizzare numeri interi in cui il bit più significativo è il pin # 7 e il bit meno significativo è il pin # 2. In questo formato, l'esempio sopra verrebbe passato come [ 256, 2304, 127, 64, 64, 128, 2048, 3072 ].
L'elenco di input può contenere tiri in cui non viene rovesciato alcun pin, nel qual caso il punteggio viene lasciato invariato.
Non hai niente di speciale da fare quando il punteggio raggiunge esattamente 50 punti. Ma puoi presumere che nessun altro tiro seguirà quando succede.
Questo è code-golf , quindi vince la risposta più breve in byte.

Casi test

Utilizzo di elenchi di numeri interi come input:

[ 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

Puoi seguire questo link per ottenere questi casi di test in formato booleano.

code-golf game binary

— Arnauld
fonte

5

Fantastica sfida, e anche un grande gioco da giocare in estate per quelli di voi che non l'hanno provato - funziona alla grande con una griglia.

— Nit

2

@Nit Grazie. :) Devo confessare che non conoscevo questo gioco fino ad oggi. Ho visto gente giocare mentre camminava in un parco questo pomeriggio. Ora vorrei provarlo.

— Arnauld,

7

Python 2 , 126 111 108 104 byte

-3 byte grazie a Jonathan Allan

-4 byte grazie a 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

Provalo online!

Definisce una funzione ricorsiva che accetta un array 2D di 1s e 0s e restituisce un valore intero. Niente di troppo speciale nella costruzione e sono sicuro che ci sia una soluzione più semplice.

Spiegazione:

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
fonte

(0x103925BA4786>>4*A[0].index(1))%16 salva 1 carattere contro ord('GIHEKLFCJDAB'[A[0].index(1)])-65

— Kaya

1

Un po 'più ottimale:762447093078/12**A[0].index(1)%12

— Kaya

Quella roba mi sembra una magia nera! Grazie @Kaya!

— Jo King

1

Questa è solo la codifica con base 12

— enedil

6

Gelatina , 25 byte

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

Un collegamento monadico che accetta un elenco di elenchi di uno e zeri (ciascuno di lunghezza 12) che restituisce un numero intero.

Provalo online! Oppure vedi la suite di test (usando i valori interi indicati nell'OP)

Come?

Questa soluzione utilizza, œ? , che ha dato un numero, n, e un elenco trova l' ^ennesima permutazione lessicografica dell'elenco in cui l'elenco definisce l'ordinamento. Per prima cosa dobbiamo capire questo 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)

... cioè Pall'indice iè impostato sull'indice originale del valore i.
Questo Pha un indice lessicografico di 438.337.469 (che è, se hai preso tutti i 12! Permutazioni dei numeri 1 a 12 e li smistata lessicografico, il 438.337.469 ^° sarebbe P).
Questo può essere trovato usando l' Œ¿atomo di Jelly .
Entrambi i passaggi possono essere eseguiti in una volta sola utilizzando il programma 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
fonte

Penso che la tua spiegazione su come trovare l'indice lessicografico appropriato tra tutte le permutazioni varrebbe la pena aggiungere come suggerimento Jelly . (L'ultima volta che ho dovuto farlo, ho fatto una ricerca dicotomica manuale, che non è così lunga per brevi sequenze ma ... un po 'noiosa. ^^)

— Arnauld

LOL; Ho avuto esattamente la stessa soluzione, tranne due byte diversi: Ṗ-> Ḋ, µ-> Ʋ. Jelly trarrebbe davvero beneficio dall'accettare un collegamento niladico come ¡" <link>primo argomento", tranne per il fatto che, se proprio all'inizio del programma, mantiene il comportamento speciale.

— Erik the Outgolfer

... e ho quasi usato entrambi!

— Jonathan Allan,

5

Python 2 , 90 byte

^{Fortemente ispirato dalla risposta Python 2 di Jo King e dall'utilizzo del commento di rappresentazione di base 12 di Kaya}

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

Provalo online! Oppure vedi la suite di test

— Jonathan Allan
fonte

4

Pyth, 51 48 38 byte

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

Salvato 10 byte grazie a Jonathan Allan Prende input come un elenco di elenchi di booleani.
Provalo qui

Spiegazione

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.

Non sono sicuro di come inserirlo esattamente nel programma, ma dovrebbe salvare 6 o 7 byte se puoi ... 7tT8h4hT12h5h2T4h02-> .PC"îO&"S12- usa l'indicizzazione della permutazione lessicografica come la mia risposta di Jelly. (Il codice ha un byte non stampabile di 0x0F all'inizio della stringa.)

— Jonathan Allan

))può essere;

— Jonathan Allan

4

05AB1E , 29 28 byte

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

Provalo online!

Spiegazione

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
fonte

4

Perl 5 , 74 70 byte

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

Provalo online!

Prende l'input come una serie di stringhe di bit separate di nuova riga.

— Xcali
fonte

3

Haskell , 96 byte

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

Provalo online!

Il wrapping è intelligente: essenzialmente indicizzo la posizione s+sum(…)nell'elenco ([0..50]++cycle[25]). Tuttavia, un modo più breve di scrivere è l'indicizzazione in posizione sum(…)e l'inizio dell'elenco in s.

— Lynn
fonte

3

Java 10, 131 130 129 byte

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

Contiene 10 non stampabili.
Input come matrice intera di zeri e uno.

-1 byte grazie a @JonathanFrech , cambiando \tin una scheda reale (funziona in TIO, non funziona nel mio IDE locale).

Provalo online.

Spiegazione:

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
fonte

Penso che puoi salvare un byte usando un vero carattere di tabulazione in "\t\n".

— Jonathan Frech

@JonathanFrech Hmm, sembra davvero funzionare in TIO. Non funziona localmente nel mio IDE, ma a chi importa che immagino ..;)

— Kevin Cruijssen

Quando c'è un'implementazione funzionante da qualche parte, è permesso. : @

— Jonathan Frech,

2

Carbone , 43 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Accetta l'input come un array booleano. Spiegazione:

≔⁰η

Imposta il punteggio su 0.

Ｆθ«

Passa sopra i tiri.

⎇⊖Σι

Il numero di pin è 1?

Σι

In caso contrario, prendi il numero di pin.

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

Altrimenti, traduci la posizione del perno in un valore.

≧⁺...η

Aggiungilo al punteggio.

¿›η⁵⁰≔²⁵η

Se il punteggio supera 50, riportarlo a 25.

»Ｉη

Stampa il risultato finale dopo tutti i tiri.

— Neil
fonte

2

Haskell , 110 byte

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

Stessa lunghezza: f l=foldl(\b a->last$b+m a:[25|b+m a>50])0linvece di fec

Provalo online!

— Angs
fonte

Rilascia l'argomento l in f per 3 byte. f=foldl(\b->c.(b+).m)0

— aoemica,

2

Husk , 47 35 byte

_{-12 byte grazie a H.PWiz (modo migliore per generare i punti di codifica dell'elenco)!}

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

Provalo online!

Spiegazione

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

— ბიმო
fonte

Che ne dici m+3d4652893071?

— H.Piz,

1

Rosso , 189 172 byte

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]

Provalo online!

Spiegazione del codice non salvato:

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 Ivanov
fonte

1

JavaScript (ES6), 98 byte

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

Casi test:

Mostra snippet di codice

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

Expand snippet

— Rick Hitchcock
fonte

Stesse dimensioni (e molto simili a) della mia implementazione di riferimento . :)

— Arnauld

Ah, bello. Sono felice ogni volta che posso abbinare la dimensione del tuo codice. È solo una volta in una luna blu che posso batterlo :)

— Rick Hitchcock,

0

Stax , 37 byte

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

Esegui ed esegui il debug

Provalo online!

Spiegazione

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

Non è il mio miglior lavoro, ma funziona. Sono sicuro che ci sia qualcosa che mi manca per renderlo un po 'più breve.

— Multi
fonte

0

Python 2, 109 105 103 bytes

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

Try it online!

Alternative without a recursive function.

-2 with thanks to @Jo King

— ElPedro
fonte

You can remove the brackets around the string literal

— Jo King

Giochiamo a Mölkky!

Mölkky

Regole Mölkky semplificate

Ingresso

Produzione

Esempio dettagliato

Regole della sfida

Casi test

Python 2 , 126 111 108 104 byte

Spiegazione:

Gelatina , 25 byte

Come?

Python 2 , 90 byte

Pyth, 51 48 38 byte

Spiegazione

05AB1E , 29 28 byte

Perl 5 , 74 70 byte

Haskell , 96 byte

Java 10, 131 130 129 byte

Carbone , 43 byte

Haskell , 110 byte

Husk , 47 35 byte

Spiegazione

Rosso , 189 172 byte

Spiegazione del codice non salvato:

JavaScript (ES6), 98 byte

Stax , 37 byte

Python 2, 109 105 103 bytes