Tutti i singoli otto

24

Dato un array rettangolare non vuoto di numeri interi da 0a 9, genera la quantità di celle che sono 8e non hanno un vicino che è 8. Il vicinato è qui inteso nel senso di Moore , cioè comprese le diagonali. Quindi ogni cella ha dei 8vicini, ad eccezione delle celle ai bordi dell'array.

Ad esempio, dato l'input

8 4 5 6 5
9 3 8 4 8
0 8 6 1 5
6 7 9 8 2
8 8 7 4 2

l'output dovrebbe essere 3. Le tre celle qualificanti sarebbero le seguenti, contrassegnate da un asterisco (ma dovrebbe essere emesso solo il numero di tali voci):

* 4 5 6 5
9 3 8 4 *
0 8 6 1 5
6 7 9 * 2
8 8 7 4 2

Regole aggiuntive

  • Puoi facoltativamente prendere due numeri che definiscono la dimensione dell'array come input aggiuntivi.

  • L'input può essere preso con qualsiasi mezzo ragionevole . Il formato è flessibile come al solito. Ad esempio, può essere una matrice di caratteri 2D o un elenco di elenchi di numeri o un elenco semplice.

  • Programmi o funzioni sono consentiti, in qualsiasi linguaggio di programmazione . Sono vietate le scappatoie standard .

  • Vince il codice più breve in byte.

Casi test

  1. Ingresso:

    8 4 5 6 5
9 3 8 4 8
0 8 6 1 5
6 7 9 8 2
8 8 7 4 2

    Produzione: 3

  2. Ingresso

    8 8
2 3

    Produzione: 0

  3. Ingresso:

    5 3 4
2 5 2

    Produzione: 0

  4. Ingresso:

    5 8 3 8

    Produzione: 2

  5. Ingresso:

    8
0
8

    Uscita: 2.

  6. Ingresso:

    4 2 8 5
2 6 1 8
8 5 5 8

    Produzione: 1

  7. Ingresso:

    4 5 4 3 8 1 8 2
8 2 7 7 8 3 9 3
9 8 7 8 5 4 2 8
4 5 0 2 1 8 6 9
1 5 4 3 4 5 6 1

    Uscita 3.

  8. Ingresso:

    8

    Produzione: 1

  9. Ingresso:

    8 5 8 1 6 8 7 7
9 9 2 8 2 7 8 3
2 8 4 9 7 3 2 7
9 2 9 7 1 9 5 6
6 9 8 7 3 1 5 2
1 9 9 7 1 8 8 2
3 5 6 8 1 4 7 5

    Uscita: 4.

  10. Ingresso:

    8 1 8
2 5 7
8 0 1

    Uscita: 3.

Ingressi in formato MATLAB:

[8 4 5 6 5; 9 3 8 4 8; 0 8 6 1 5; 6 7 9 8 2; 8 8 7 4 2]
[8 8; 2 3]
[5 3 4; 2 5 2]
[5 8 3 8]
[8; 0; 8]
[4 2 8 5; 2 6 1 8; 8 5 5 8]
[4 5 4 3 8 1 8 2; 8 2 7 7 8 3 9 3; 9 8 7 8 5 4 2 8; 4 5 0 2 1 8 6 9; 1 5 4 3 4 5 6 1]
[8]
[8 5 8 1 6 8 7 7; 9 9 2 8 2 7 8 3; 2 8 4 9 7 3 2 7; 9 2 9 7 1 9 5 6; 6 9 8 7 3 1 5 2; 1 9 9 7 1 8 8 2; 3 5 6 8 1 4 7 5]
[8 1 8; 2 5 7; 8 0 1]

Ingressi in formato Python:

[[8, 4, 5, 6, 5], [9, 3, 8, 4, 8], [0, 8, 6, 1, 5], [6, 7, 9, 8, 2], [8, 8, 7, 4, 2]]
[[8, 8], [2, 3]]
[[5, 3, 4], [2, 5, 2]]
[[5, 8, 3, 8]]
[[8], [0], [8]]
[[4, 2, 8, 5], [2, 6, 1, 8], [8, 5, 5, 8]]
[[4, 5, 4, 3, 8, 1, 8, 2], [8, 2, 7, 7, 8, 3, 9, 3], [9, 8, 7, 8, 5, 4, 2, 8], [4, 5, 0, 2, 1, 8, 6, 9], [1, 5, 4, 3, 4, 5, 6, 1]]
[[8]]
[[8, 5, 8, 1, 6, 8, 7, 7], [9, 9, 2, 8, 2, 7, 8, 3], [2, 8, 4, 9, 7, 3, 2, 7], [9, 2, 9, 7, 1, 9, 5, 6], [6, 9, 8, 7, 3, 1, 5, 2], [1, 9, 9, 7, 1, 8, 8, 2], [3, 5, 6, 8, 1, 4, 7, 5]]
[[8, 1, 8], [2, 5, 7], [8, 0, 1]]

Uscite:

3, 0, 0, 2, 2, 1, 3, 1, 4, 3
code-golf  array-manipulation  integer 
— Luis Mendo
fonte
17
Se ti piace, allora avresti dovuto
— votarci
Quando ho letto "celle uguali a 8", per un momento ho pensato che intendevi dire che una cella poteva essere più grande di un mandrino 1x1 (NxN) della griglia. Dovrebbe probabilmente riformularlo in "celle che sono 8" per chiarire che non è necessaria la matematica. = P
— Tezra,
@Tezra Edited. Trovo la nuova formulazione un po 'meno naturale, ma non sono un madrelingua, quindi mi fiderò del tuo criterio
— Luis Mendo,

Risposte:

2

MATL , 21 17 10 byte

8=t3Y6Z+>z

Provalo online!

Grazie a Luis Mendo per l'aiuto nella chat e per aver suggerito la convoluzione 2D.

Spiegazione:

	#implicit input, m
8=	#equal to 8? matrix of 1 where m is 8, 0 otherwise
t	#duplicate
3Y6	#push [1 1 1; 1 0 1; 1 1 1], "neighbor cells" for convolution
Z+	#2D convolution; each element is replaced by the number of neighbors that are 8
>	#elementwise greater than -- matrix of 1s where an 8 is single, 0s otherwise
z	#number of nonzero elements -- number of single eights
	#implicit output
— Giuseppe
fonte
Puoi risparmiare parecchi byte usando la convoluzione (2D-), se hai familiarità con il concetto
— Luis Mendo,
1
@LuisMendo La convoluzione 2D è una di quelle cose in cui non capisco nemmeno la convoluzione 1D, quindi non c'è speranza per me lì ... sembra un'opportunità per imparare entrambi!
— Giuseppe,
1
Se hai bisogno di aiuto, fammelo sapere nella chat room. La convoluzione è un'operazione molto utile. Se vuoi imparare la convoluzione, inizia con 1D. La generalizzazione in 2D è immediata
— Luis Mendo il
9

R , 117 63 59 byte

function(m)sum(colSums(as.matrix(dist(which(m==8,T)))<2)<2)

Provalo online!

distcalcola le distanze (il valore predefinito è Euclideo) tra le file di una matrice. whichcon il secondo argomento TRUErestituisce le coordinate in cui il predicato è vero.

Le coordinate sono vicine se la distanza tra loro non è superiore alla radice quadrata di 2, ma l'interno <2è abbastanza buono perché la possibile distanza salta da sqrt(2)ro 2.

— ngm
fonte
è un peccato che l'imprecisione numerica non permetta colSums()^2<=2di funzionare.
— Giuseppe,
@Giuseppe ovviamente ci sono solo poche distanze possibili e sqrt(2)salti 2(ad esempio sort(c(dist(expand.grid(1:6,1:6))), decreasing = TRUE))), quindi eravamo troppo intelligenti lì.
— ngm,
7

APL (Dyalog Classic) , 29 28 25 byte

≢∘⍸16=2⊥¨3,⌿3,/8=(⍉0,⌽)⍣4

Provalo online!

— NGN
fonte
Nota: l'origine dell'indice 0 non è nemmeno necessaria.
— Zacharý,
@ Zacharý Lo uso sempre come predefinito, per evitare sorprese.
— ngn,
Ah, così come gli altri con 1(tranne che non esplicitamente impostato). Ciò ha senso.
— Zacharý,
Sorpreso, questo non usa Stencil. C'è qualcosa che rende scomodo lo stencil qui?
— Lirtosiast
@lirtosiast è solo più a lungo :)
— ngn
5

Gelatina , 18 15 byte

8=µ+Ż+ḊZµ⁺ỊṖḋµS

Provalo online!

Come funziona

8=µ+Ż+ḊZµ⁺ỊṖḋµS    Main link (monad). Input: digit matrix
8=              1) Convert elements by `x == 8`
  µ             2) New chain:
   +Ż+Ḋ              x + [0,*x] + x[1:] (missing elements are considered 0)
                     Effectively, vertical convolution with [1,1,1]
       Z             Transpose
        µ⁺      3) Start new chain, apply 2) again
          ỊṖ       Convert elements by `|x| <= 1` and remove last row
            ḋ      Row-wise dot product with result of 1)
             µS 4) Sum

Soluzione precedente, 18 byte

æc7B¤ZḊṖ
8=µÇÇỊḋµS

Provalo online!

Volevo condividere un altro approccio, anche se questo è 1 byte più lungo della soluzione di Jonathan Allan .

Come funziona

æc7B¤ZḊṖ    Auxiliary link (monad). Input: integer matrix
æc7B¤       Convolution with [1,1,1] on each row
     ZḊṖ    Zip (transpose), remove first and last elements

8=µÇÇỊḋµS    Main link (monad). Input: digit matrix
8=           Convert 8 to 1, anything else to 0 (*A)
  怀        Apply aux.link twice (effective convolution with [[1,1,1]]*3)
     Ịḋ      Convert to |x|<=1, then row-wise dot product with A
       µS    Sum the result
— bubbler
fonte
4

J , 43, 40 37 byte

-3 byte grazie a Gorgogliatore

1#.1#.3 3(16=8#.@:=,);._3(0|:@,|.)^:4

Provalo online!

Spiegazione:

La prima parte dell'algoritmo assicura che possiamo applicare una finestra scorrevole 3x3 al suo input. Ciò si ottiene anteponendo una fila di zero e una rotazione di 90 gradi, ripetuta 4 volte.

1#.1#.3 3(16=8#.@:=,);._3(0|:@,|.)^:4
                         (       )^:4 - repeat 4 times
                          0|:@,|.     - reverse, prepend wit a row of 0 and transpose
                     ;._3             - cut the input (already outlined with zeroes)
      3 3                             - into matrices with size 3x3
         (          )                 - and for each matrix do
                   ,                  - ravel (flatten)
             8    =                   - check if each item equals 8
              #.@:                    - and convert the list of 1s and 0s to a decimal
          16=                         - is equal to 16?
   1#.                                - add (the result has the shape of the input)
1#.                                   - add again
— Galen Ivanov
fonte
1
37 byte usando @:e spostando|. . Si noti che @al posto di @:non funziona.
— Gorgogliatore
@Bubbler Grazie!
— Galen Ivanov,
Questo è carino. Probabilmente vale la pena aggiungere almeno una spiegazione di alto livello su come funziona, se non una scomposizione del codice. Mi ci sono voluti circa 10m per capirlo. Inoltre, è interessante quanto sia più breve la versione APL (che utilizza lo stesso approccio). Sembra che sia principalmente il risultato di digrafi invece di simboli a carattere singolo ...
— Giona
@Giona Aggiungerò una spiegazione. Per un confronto con APL è possibile esaminare le revisioni della soluzione di ngn , in particolare la versione a 28 byte
— Galen Ivanov,
1
@Jonah Explanation ha aggiunto
— Galen Ivanov,
3

Retina 0.8.2 , 84 byte

.+
_$&_
m`(?<!(?(1).)^(?<-1>.)*.?.?8.*¶(.)*.|8)8(?!8|.(.)*¶.*8.?.?(?<-2>.)*$(?(2).))

Provalo online! Spiegazione:

.+
_$&_

Avvolgi ciascuna riga in non 8caratteri in modo che tutti 8abbiano almeno un carattere su ciascun lato.

m`

Questa è l'ultima fase, quindi è implicito il conteggio delle partite. Il mmodificatore fa corrispondere i caratteri ^e $all'inizio o alla fine di qualsiasi riga.

(?<!...|8)

Non abbinare un personaggio direttamente dopo un 8, o ...

(?(1).)^(?<-1>.)*.?.?8.*¶(.)*.

... un personaggio sotto un 8; la (?(1).)^(?<-1>.)*corrisponde alla stessa colonna della ¶(.)*sulla riga successiva, ma la .?.?consente al 8di essere 1 a sinistra oa destra del carattere dopo la .nella riga successiva.

8

Match 8s.

(?!8|...)

Non abbinare un 8 immediatamente prima di un 8, o ...

.(.)*¶.*8.?.?(?<-2>.)*$(?(2).)

... un personaggio con un 8 nella riga in basso; di nuovo, la (?<-2>.)*$(?(2).)corrisponde alla stessa colonna del (.)*¶sulla linea precedente, ma .?.?permette al 8da 1 a sinistra oa destra della 8prima del .sulla linea precedente.

— Neil
fonte
3

Gelatina , 17 byte

=8ŒṪµŒcZIỊȦƲƇẎ⁸ḟL

Provalo online! Oppure vedi la suite di test .

Come?

=8ŒṪµŒcZIỊȦƲƇẎ⁸ḟL - Link: list of lists of integers (digits)
=8                - equals 8?
  ŒṪ              - multidimensional truthy indices (pairs of row & column indices of 8s)
    µ             - start a new monadic chain
     Œc           - all pairs (of the index-pairs) 
            Ƈ     - filter keep if:  (keep those that represent adjacent positions)
           Ʋ      -   last four links as a monad:
       Z          -     transpose
        I         -     incremental differences
         Ị        -     insignificant? (abs(x) <= 1)
          Ȧ       -     all?
             Ẏ    - tighten (to a list of all adjacent 8's index-pairs, at least once each)
              ⁸   - chain's left argument (all the index-pairs again)
               ḟ  - filter discard (remove those found to be adjacent to another)
                L - length (of the remaining pairs of indices of single 8s)
— Jonathan Allan
fonte
3

J, 42 byte

[:+/@,8=]+[:+/(<:3 3#:4-.~i.9)|.!.0(_*8&=)

Provalo online!

spiegazione

L'approccio di alto livello qui è simile a quello utilizzato nella classica soluzione APL per il gioco della vita: https://www.youtube.com/watch?v=a9xAKttWgP4 .

In quella soluzione, spostiamo la nostra matrice nelle 8 possibili direzioni vicine, creando 8 duplicati dell'input, impilandoli e quindi sommando gli "aerei" per ottenere i conteggi dei nostri vicini.

Qui, usiamo un trucco "moltiplica per l'infinito" per adattare la soluzione a questo problema.

[: +/@, 8 = ] + [: +/ (neighbor deltas) (|.!.0) _ * 8&= NB. 
                                                        NB.
[: +/@,                                                 NB. the sum after flattening
        8 =                                             NB. a 0 1 matrix created by
                                                        NB. elmwise testing if 8
                                                        NB. equals the matrix
            (the matrix to test for equality with 8   ) NB. defined by...
            ] +                                         NB. the original input plus
                [: +/                                   NB. the elmwise sum of 8
                                                        NB. matrices defined by
                                                _ *     NB. the elmwise product of 
                                                        NB. infinity and
                                                    8&= NB. the matrix which is 1
                                                        NB. where the input is 8
                                                        NB. and 0 elsewhere, thus
                                                        NB. creating an infinity-0
                                                        NB. matrix
                                        (|.!.0)         NB. then 2d shifting that 
                                                        NB. matrix in the 8 possible
                                                        NB. "neighbor" directions
                      (neighbor deltas)                 NB. defined by the "neighbor
                                                        NB. deltas" (see below)
                                                        NB. QED.
                                                        NB. ***********************
                                                        NB. The rest of the
                                                        NB. explanation merely
                                                        NB. breaks down the neighbor
                                                        NB. delta construction.


                      (neighbor deltas  )               NB. the neighbor deltas are
                                                        NB. merely the cross product
                                                        NB. of _1 0 1 with itself,
                                                        NB. minus "0 0"
                      (<: 3 3 #: 4 -.~ i.9)             NB. to create that...
                       <:                               NB. subtract one from
                          3 3 #:                        NB. the base 3 rep of
                                       i.9              NB. the numbers 0 - 8
                                 4 -.~                  NB. minus the number 4
                                                        NB.
                                                        NB. All of which produces
                                                        NB. the eight "neighbor"
                                                        NB. deltas:
                                                        NB. 
                                                        NB.       _1 _1
                                                        NB.       _1  0
                                                        NB.       _1  1
                                                        NB.        0 _1
                                                        NB.        0  1
                                                        NB.        1 _1
                                                        NB.        1  0
                                                        NB.        1  1
— Giona
fonte
1
Hai dimenticato di rimuovere uno spazio tra ~e>
— Galen Ivanov,
@GalenIvanov Risolto ora. Grazie.
— Giona
3

Java 8, 181 157 156 byte

(M,R,C)->{int z=0,c,f,t;for(;R-->0;)for(c=C;c-->0;z+=f>1?0:f)for(f=0,t=9;M[R][c]==8&t-->0;)try{f+=M[R+t/3-1][c+t%3-1]==8?1:0;}catch(Exception e){}return z;}

-24 byte grazie a @ OlivierGrégoire .

Accetta le dimensioni come parametri aggiuntivi R(quantità di righe) e C(quantità di colonne).

Le celle sono controllate abbastanza simili come ho fatto nella mia risposta al simulatore di friggitrice .

Provalo online.

Spiegazione:

(M,R,C)->{                    // Method with integer-matrix as parameter & integer return
  int z=0,                    //  Result-counter, starting at 0
      c,f,t;                  //  Temp-integers, starting uninitialized
  for(;R-->0;)                //  Loop over the rows:
    for(c=C;c-->0             //   Inner loop over the columns:
           ;                  //     After every iteration:
            z+=f==1?          //      If the flag-integer is larger than 1:
                0             //       Leave the result-counter the same by adding 0
               :              //      Else:
                f)            //       Add the flag-integer (either 0 or 1)
      for(f=0,                //    Reset the flag to 0
          t=9;M[R][c]==8&     //    If the current cell contains an 8:
              t-->0;)         //     Inner loop `t` in the range (9, 0]:
        try{f+=               //      Increase the flag by:
               M[R+t/3-1]     //       If `t` is 0, 1, or 2: Look at the previous row
                              //       Else-if `t` is 6, 7, or 8: Look at the next row
                              //       Else (`t` is 3, 4, or 5): Look at the current row
                [c+t%3-1]     //       If `t` is 0, 3, or 6: Look at the previous column
                              //       Else-if `t` is 2, 5, or 8: Look at the next column
                              //       Else (`t` is 1, 4, or 7): Look at the current column
                ==8?          //       And if the digit in this cell is 8:
                 1            //        Increase the flag-integer by 1
                :0;           //       Else: leave it the same
        }catch(Exception e){} //      Catch and ignore ArrayIndexOutOfBoundsExceptions
                              //      (try-catch saves bytes in comparison to if-checks)
  return z;}                  //  And finally return the counter
— Kevin Cruijssen
fonte
2

Python 2 , 130 byte

lambda a:sum(sum(u[~-c*(c>0):c+2].count(8)for u in a[~-r*(r>0):r+2])*8==8==a[r][c]for r in range(len(a))for c in range(len(a[0])))

Provalo online!

— Chas Brown
fonte
Sembra più breve se prendere la lunghezza da args
— l4m2
2

Powershell, 121 byte

param($a)(($b='='*4*($l=($a|% Le*)[0]))+($a|%{"!$_!"})+$b|sls "(?<=[^8]{3}.{$l}[^8])8(?=[^8].{$l}[^8]{3})" -a|% m*).Count

Script di test meno golfato:

$f = {

param($a)

$length=($a|% Length)[0]
$border='='*4*$length
$pattern="(?<=[^8]{3}.{$length}[^8])8(?=[^8].{$length}[^8]{3})"
$matches=$border+($a|%{"!$_!"})+$border |sls $pattern -a|% Matches
$matches.count

}

@(

,(3,"84565","93848","08615","67982","88742")
,(0,"88","23")
,(0,"534","252")
,(2,"5838")
,(2,"8","0","8")
,(1,"4285","2618","8558")
,(3,"45438182","82778393","98785428","45021869","15434561")
,(1,"8")
,(4,"85816877","99282783","28497327","92971956","69873152","19971882","35681475")
,(3,"818","257","801")
,(0,"")

) | % {
    $expected,$a = $_
    $result = &$f $a
    "$($result-eq$expected): $result : $a"
}

Produzione:

True: 3 : 84565 93848 08615 67982 88742
True: 0 : 88 23
True: 0 : 534 252
True: 2 : 5838
True: 2 : 8 0 8
True: 1 : 4285 2618 8558
True: 3 : 45438182 82778393 98785428 45021869 15434561
True: 1 : 8
True: 4 : 85816877 99282783 28497327 92971956 69873152 19971882 35681475
True: 3 : 818 257 801
True: 0 :

Spiegazione:

Innanzitutto, lo script calcola una lunghezza della prima stringa.

In secondo luogo, aggiunge un bordo extra alle stringhe. Mi piace la stringa di realtà aumentata :

....=========!84565! !93848! !08615! !67982! !88742!===========....

rappresenta la stringa multilinea:

...=====
=======
!84565!
!93848!
!08615!
!67982!
!88742!
=======
========...

Nota 1: il numero di =è sufficiente per una stringa di qualsiasi lunghezza.

Nota 2: un gran numero di =non influisce sulla ricerca di otto.

Successivamente, l'espressione regolare (?<=[^8]{3}.{$l}[^8])8(?=[^8].{$l}[^8]{3})cerca la cifra 8con le non-otto precedenti (?<=[^8]{3}.{$l}[^8])e le non-otto seguenti (?=[^8].{$l}[^8]{3}):

.......
<<<....
<8>....
>>>....
.......

Infine, il numero di corrispondenze viene restituito di conseguenza.

— Mazzy
fonte
2

Gelatina , 12 byte

œẹ8ạṀ¥þ`’Ạ€S

Provalo online!

Come funziona

œẹ8ạṀ¥þ`’Ạ€S  Main link. Argument: M (matrix)

œẹ8           Find all multidimensional indices of 8, yielding an array A of pairs.
      þ`      Table self; for all pairs [i, j] and [k, l] in A, call the link to the
              left. Return the results as a matrix.
   ạ              Absolute difference; yield [|i - k|, |j - l|].
    Ṁ             Take the maximum.
        ’     Decrement all the maxmima, mapping 1 to 0.
         Ạ€   All each; yield 1 for each row that contains no zeroes.
           S  Take the sum.
— Dennis
fonte
1

JavaScript (ES6), 106 byte

a=>a.map((r,y)=>r.map((v,x)=>k+=v==8&[...'12221000'].every((d,i,v)=>(a[y+~-d]||0)[x+~-v[i+2&7]]^8)),k=0)|k

Provalo online!

Approccio bit a bit, 110 byte

a=>a.map(r=>r.map(v=>x=x*2|v==8,x=k=0)|x).map((n,y,b)=>a[0].map((_,x)=>(n^1<<x|b[y-1]|b[y+1])*2>>x&7||k++))&&k

Provalo online!

— Arnauld
fonte
Approccio [[7]]
— bit a bit
@ lm42 Oh, grazie. Ora risolto.
— Arnauld,
1

Clojure , 227 198 byte

(fn[t w h](let[c #(for[y(range %3 %4)x(range % %2)][x y])e #(= 8(get-in t(reverse %)0))m(fn[[o p]](count(filter e(c(dec o)(+ o 2)(dec p)(+ p 2)))))](count(filter #(= 1(m %))(filter e(c 0 w 0 h))))))

Ahia. Sicuramente non il più breve qui con qualsiasi mezzo. 54 byte di parentesi sono killer. Sono comunque relativamente contento.

-29 byte con la creazione di una funzione di supporto che genera un inventario da stavo facendo che per due volte, cambiando la reducead una (count (filtermessa a punto, e per liberarsi della macro filettatura dopo golf.

(defn count-single-eights [td-array width height]
  ; Define three helper functions. One generates a list of coords for a given range of dimensions, another checks if an eight is
  ; at the given coord, and the other counts how many neighbors around a coord are an eight
  (letfn [(coords [x-min x-max y-min y-max]
            (for [y (range y-min y-max)
                  x (range x-min x-max)]
              [x y]))
          (eight? [[x y]] (= 8 (get-in td-array [y x] 0)))
          (n-eights-around [[cx cy]]
            (count (filter eight?
                           (coords (dec cx) (+ cx 2), (dec cy) (+ cy 2)))))]

    ; Gen a list of each coord of the matrix
    (->> (coords 0 width, 0 height)

         ; Remove any coords that don't contain an eight
         (filter eight?)

         ; Then count how many "neighborhoods" only contain 1 eight
         (filter #(= 1 (n-eights-around %)))
         (count))))

(mapv #(count-single-eights % (count (% 0)) (count %))
      test-cases)
=> [3 0 0 2 2 1 3 1 4 3]

Dove si test-casestrova un array che contiene tutti i "casi di test Python"

Provalo online!

— Carcigenicate
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.