Étant donné un tableau rectangulaire non vide d'entiers de 0à 9, affichez la quantité de cellules qui sont 8et n'ont pas de voisin qui l'est 8. Le voisin est ici compris au sens de Moore , c'est-à-dire y compris les diagonales. Ainsi, chaque cellule a des 8voisins, à l'exception des cellules situées aux bords du tableau.

Par exemple, étant donné l'entrée

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

la sortie devrait être 3. Les trois cellules qualifiées seraient les suivantes, marquées d'un astérisque (mais seul le nombre de ces entrées devrait être affiché):

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

Règles supplémentaires

• Vous pouvez éventuellement prendre deux nombres définissant la taille du tableau comme entrées supplémentaires.

• L'entrée peut être prise par tout moyen raisonnable . Le format est flexible comme d'habitude. Par exemple, il peut s'agir d'un tableau de caractères 2D, ou d'une liste de listes de nombres, ou d'une liste plate.

• Les programmes ou fonctions sont autorisés, dans n'importe quel langage de programmation . Les failles standard sont interdites.

• Le code le plus court en octets gagne.

Cas de test

1. Contribution:

   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
   

   Sortie: 3

2. Contribution

   8 8
   2 3
   

   Sortie: 0

3. Contribution:

   5 3 4
   2 5 2
   

   Sortie: 0

4. Contribution:

   5 8 3 8
   

   Sortie: 2

5. Contribution:

   8
   0
   8
   

   Sortie: 2.

6. Contribution:

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

   Sortie: 1

7. Contribution:

   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
   

   Sortie 3.

8. Contribution:

   8
   

   Sortie: 1

9. Contribution:

   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
   

   Sortie: 4.

10. Contribution:

    8 1 8
    2 5 7
    8 0 1
    

    Sortie: 3.

Entrées au format 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]

Entrées au format 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]]

Les sorties:

3, 0, 0, 2, 2, 1, 3, 1, 4, 3

MATL , 21 17 10 octets

8=t3Y6Z+>z

Essayez-le en ligne!

Merci à Luis Mendo pour son aide dans le chat et pour avoir suggéré une convolution 2D.

Explication:

	#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

R , 117 63 59 octets

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

Essayez-le en ligne!

distcalcule les distances (la valeur par défaut est euclidienne) entre les lignes d'une matrice. whichavec le deuxième argument TRUErenvoie les coordonnées où le prédicat est vrai.

Les coordonnées sont voisines si la distance entre elles n'est pas supérieure à la racine carrée de 2, mais l'intérieur <2est assez bon car la distance possible saute de sqrt(2)ro 2.

APL (Dyalog Classic) , 29 28 25 octets

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

Essayez-le en ligne!

Gelée , ₁₈ 15 octets

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

Essayez-le en ligne!

Comment ça marche

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

Solution précédente, 18 octets

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

Essayez-le en ligne!

Je voulais partager une autre approche, bien que ce soit 1 octet de plus que la solution de Jonathan Allan .

Comment ça marche

æ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

JavaScript (Node.js) , 88 85 octets

a=>g=(x,y=0,c=0)=>a.map(p=>p.map((q,j)=>c+=q-8?0:1/x?(x-j)**2+y*y<3:g(j,-y)<2)&--y)|c

Essayez-le en ligne!

Merci Arnauld pour 2 octets

J , 43, 40 37 octets

-3 octets grâce à Bubbler

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

Essayez-le en ligne!

Explication:

La première partie de l'algorithme garantit que nous pouvons appliquer une fenêtre coulissante 3x3 à l'entrée. Ceci est réalisé en ajoutant une rangée de zéros et une rotation de 90 degrés, répétée 4 fois.

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

Retina 0.8.2 , 84 octets

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

Essayez-le en ligne! Explication:

.+
_$&_

Enveloppez chaque ligne dans des non- 8caractères afin que tous les 8s aient au moins un caractère de chaque côté.

m`

Ceci est la dernière étape, donc le comptage des correspondances est implicite. Le mmodificateur fait correspondre les caractères ^et $au début ou à la fin d'une ligne.

(?<!...|8)

Ne faites pas correspondre un caractère directement après un 8, ou ...

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

... un caractère sous un 8; le (?(1).)^(?<-1>.)*correspond à la même colonne que le ¶(.)*sur la ligne suivante, mais le .?.?permet 8d'être 1 à gauche ou à droite du caractère après le .sur la ligne suivante.

8

Match 8s.

(?!8|...)

Ne faites pas correspondre un 8 juste avant un 8, ou ...

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

... un caractère avec un 8 dans la ligne ci-dessous; encore une fois, le (?<-2>.)*$(?(2).)correspond à la même colonne que le (.)*¶sur la ligne précédente, mais le .?.?permet 8d'être 1 à gauche ou à droite de 8avant le .sur la ligne précédente.

Gelée , 17 octets

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

Essayez-le en ligne! Ou consultez la suite de tests .

Comment?

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

J, 42 octets

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

Essayez-le en ligne!

explication

L'approche de haut niveau ici est similaire à celle utilisée dans la solution APL classique du jeu de la vie: https://www.youtube.com/watch?v=a9xAKttWgP4 .

Dans cette solution, nous déplaçons notre matrice dans les 8 directions voisines possibles, créant 8 doublons de l'entrée, les empilons, puis ajoutons les «plans» ensemble pour obtenir le nombre de voisins.

Ici, nous utilisons une astuce "multiplier par l'infini" pour adapter la solution à ce problème.

[: +/@, 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

Java 8, 181 157 156 156 octets

(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 octets grâce à @ OlivierGrégoire .

Prend les dimensions comme paramètres supplémentaires R(quantité de lignes) et C(quantité de colonnes).

Les cellules sont vérifiées assez similaires comme je l'ai fait dans ma réponse au simulateur Fryer .

Essayez-le en ligne.

Explication:

(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

Python 2 , 130 octets

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

Essayez-le en ligne!

Powershell, 121 octets

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

Script de test moins golfé:

$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"
}

Sortie:

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 : 

Explication:

Tout d'abord, le script calcule la longueur de la première chaîne.

Deuxièmement, il ajoute une bordure supplémentaire aux chaînes. La chaîne de réalité augmentée aime:

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

représente la chaîne multiligne:

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

Remarque 1: le nombre de =est suffisant pour une chaîne de n'importe quelle longueur.

Remarque 2: un grand nombre de =n'affecte pas la recherche de huit.

Ensuite, l'expression régulière (?<=[^8]{3}.{$l}[^8])8(?=[^8].{$l}[^8]{3})recherche le chiffre 8avec les non-huit précédents (?<=[^8]{3}.{$l}[^8])et les non-huit suivants (?=[^8].{$l}[^8]{3}):

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

Enfin, le nombre de correspondances est renvoyé en conséquence.

Gelée , 12 octets

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

Essayez-le en ligne!

Comment ça marche

œẹ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.

JavaScript (ES6), 106 octets

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

Essayez-le en ligne!

Approche au niveau du bit, 110 octets

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

Essayez-le en ligne!

Clojure , 227 198 octets

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

Aie. Certainement pas le plus court ici par tous les moyens. 54 octets de parenthèses est tueur. J'en suis encore relativement satisfait.

-29 octets en créant une fonction d'assistance qui génère une gamme puisque je faisais que deux fois, en changeant l' reduceune (count (filterconfiguration, et de se débarrasser de la macro filetage après le 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]

Où test-casesest un tableau contenant tous les "cas de test Python"

Essayez-le en ligne!