Bei einem nicht leeren rechteckigen Array von Ganzzahlen von 0bis 9wird die Anzahl der Zellen ausgegeben, die 8einen Nachbarn haben oder nicht 8. Unter Nachbarn wird hier der Moore-Sinn verstanden , also auch Diagonalen. Jede Zelle hat also 8Nachbarn, mit Ausnahme der Zellen an den Rändern des Arrays.

Zum Beispiel angesichts der Eingabe

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

die Ausgabe sollte sein 3. Die drei qualifizierenden Zellen wären die folgenden, mit einem Sternchen gekennzeichneten (es sollte jedoch nur die Anzahl solcher Einträge ausgegeben werden):

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

Zusätzliche Regeln

• Sie können optional zwei Zahlen verwenden, um die Größe des Arrays als zusätzliche Eingabe zu definieren.

• Die Eingabe kann auf jede vernünftige Weise erfolgen . Das Format ist wie gewohnt flexibel. Beispielsweise kann es sich um ein 2D-Zeichenfeld oder eine Liste mit Zahlenlisten oder eine flache Liste handeln.

• Programme oder Funktionen sind in jeder Programmiersprache zulässig . Standardlücken sind verboten.

• Kürzester Code in Bytes gewinnt.

Testfälle

1. Eingang:

   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
   

   Ausgabe: 3

2. Eingang

   8 8
   2 3
   

   Ausgabe: 0

3. Eingang:

   5 3 4
   2 5 2
   

   Ausgabe: 0

4. Eingang:

   5 8 3 8
   

   Ausgabe: 2

5. Eingang:

   8
   0
   8
   

   Ausgang: 2.

6. Eingang:

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

   Ausgabe: 1

7. Eingang:

   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
   

   Ausgabe 3.

8. Eingang:

   8
   

   Ausgabe: 1

9. Eingang:

   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
   

   Ausgang: 4.

10. Eingang:

    8 1 8
    2 5 7
    8 0 1
    

    Ausgang: 3.

Eingaben im MATLAB-Format:

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

Eingaben im Python-Format:

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

Ausgänge:

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

MATL , 21 17 10 Bytes

8=t3Y6Z+>z

Probieren Sie es online!

Vielen Dank an Luis Mendo für die Hilfe im Chat und für die Anregung der 2D-Faltung.

Erläuterung:

	#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 Bytes

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

Probieren Sie es online!

distberechnet Abstände (Standard ist Euklidisch) zwischen Zeilen einer Matrix. whichmit zweitem Argument werden TRUEdie Koordinaten zurückgegeben, bei denen das Prädikat wahr ist.

Koordinaten sind Nachbarn, wenn der Abstand zwischen ihnen nicht mehr als die Quadratwurzel von 2 ist, sondern die innere <2 ist gut genug, weil der mögliche Abstand von sqrt(2)ro springt 2.

APL (Dyalog Classic) , 29 28 25 Bytes

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

Probieren Sie es online!

Jelly , _18-15 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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

Vorherige Lösung, 18 Bytes

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

Probieren Sie es online!

Wollte einen anderen Ansatz teilen, obwohl dies 1 Byte länger ist als die Lösung von Jonathan Allan .

Wie es funktioniert

æ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 Byte

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

Probieren Sie es online!

Danke Arnauld für 2 Bytes

J , 43, 40 37 Bytes

-3 Bytes dank Bubbler

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

Probieren Sie es online!

Erläuterung:

Der erste Teil des Algorithmus stellt sicher, dass wir ein 3x3-Schiebefenster auf die Eingabe anwenden können. Dies wird erreicht, indem eine Reihe von Nullen und eine Drehung um 90 Grad vorangestellt werden, die viermal wiederholt wird.

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 Bytes

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

Probieren Sie es online! Erläuterung:

.+
_$&_

Umbrechen Sie jede Zeile in Nicht- 8Zeichen, so dass alle 8s mindestens ein Zeichen auf jeder Seite haben.

m`

Dies ist die letzte Stufe, daher ist das Zählen von Übereinstimmungen impliziert. Der mModifikator bewirkt, dass die Zeichen ^und $am Anfang oder Ende einer Zeile übereinstimmen.

(?<!...|8)

Entspricht keinem Zeichen direkt nach einer 8 oder ...

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

... ein Zeichen unter einer 8; das (?(1).)^(?<-1>.)*entspricht der gleichen Spalte wie ¶(.)*in der nächsten Zeile, aber das .?.?erlaubt 8, dass 1 links oder rechts vom Zeichen nach dem .in der nächsten Zeile steht.

8

Spiel 8s.

(?!8|...)

Ordne keine 8 unmittelbar vor einer 8 zu, oder ...

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

... ein Zeichen mit einer 8 in der Zeile darunter; Auch hier (?<-2>.)*$(?(2).)stimmt der Wert mit der Spalte (.)*¶in der vorherigen Zeile überein , jedoch darf der .?.?Wert 81 links oder rechts 8vor dem .Wert in der vorherigen Zeile stehen.

Gelee , 17 Bytes

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

Probieren Sie es online! Oder schauen Sie sich die Testsuite an .

Wie?

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

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

Probieren Sie es online!

Erläuterung

Der High-Level-Ansatz ähnelt dem in der klassischen APL-Lösung für das Spiel des Lebens verwendeten: https://www.youtube.com/watch?v=a9xAKttWgP4 .

In dieser Lösung verschieben wir unsere Matrix in die 8 möglichen Nachbarrichtungen, erstellen 8 Duplikate der Eingabe, stapeln sie und addieren dann die "Ebenen", um die Anzahl unserer Nachbarn zu ermitteln.

Hier verwenden wir einen "Multiplizieren mit Unendlich" -Trick, um die Lösung für dieses Problem anzupassen.

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

(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 Bytes dank @ OlivierGrégoire .

Nimmt die Dimensionen als zusätzliche Parameter R (Anzahl der Zeilen) undC (Anzahl der Spalten).

Die Zellen werden ähnlich wie in meinem Fritteusensimulator überprüft Antwort .

Probieren Sie es online aus.

Erläuterung:

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

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

Probieren Sie es online!

Powershell, 121 Bytes

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

Weniger Golf-Testskript:

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

Ausgabe:

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 : 

Erläuterung:

Zunächst berechnet das Skript die Länge der ersten Zeichenfolge.

Zweitens wird den Zeichenfolgen ein zusätzlicher Rahmen hinzugefügt. Augmended- Reality- String gefällt:

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

stellt die mehrzeilige Zeichenfolge dar:

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

Anmerkung 1: Die Anzahl =ist ausreichend für eine Zeichenkette beliebiger Länge.

Anmerkung 2: eine große Anzahl von = wirkt sich nicht auf die Suche nach Acht aus.

Als nächstes (?<=[^8]{3}.{$l}[^8])8(?=[^8].{$l}[^8]{3})sucht der reguläre Ausdruck nach der Ziffer 8mit den vorhergehenden Nicht-Achteln (?<=[^8]{3}.{$l}[^8])und den folgenden Nicht-Achteln (?=[^8].{$l}[^8]{3}):

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

Schließlich wird die Anzahl der Übereinstimmungen als Ergebnis zurückgegeben.

Gelee , 12 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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

Probieren Sie es online!

Bitweiser Ansatz, 110 Bytes

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

Probieren Sie es online!

Clojure , 227 198 Bytes

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

Autsch. Auf keinen Fall die kürzeste hier. 54 Bytes in Klammern sind Killer. Ich bin trotzdem relativ zufrieden damit.

-29 Bytes durch eine Hilfsfunktion zu schaffen , die einen Bereich erzeugt , da ich das zweimal tun wurde der Wechsel reducezu einem(count (filter Setup geändert und das Threading-Makro nach dem Golfen entfernt hat.

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

Woher test-cases ist ein Array, das alle "Python-Testfälle" enthält?

Probieren Sie es online!