Diberikan array bilangan bulat non-kosong dari dari 0ke 9, menampilkan jumlah sel yang ada 8dan tidak memiliki tetangga 8. Tetangga di sini dipahami dalam pengertian Moore , yaitu termasuk diagonal. Jadi setiap sel memiliki 8tetangga, kecuali sel-sel di tepi array.

Misalnya diberi 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

output seharusnya 3. Tiga sel yang memenuhi syarat akan menjadi yang berikut, ditandai dengan tanda bintang (tetapi hanya jumlah entri tersebut yang akan ditampilkan):

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

Aturan tambahan

• Anda secara opsional dapat mengambil dua angka yang mendefinisikan ukuran array sebagai input tambahan.

• Masukan dapat diambil dengan cara apa pun yang masuk akal . Formatnya fleksibel seperti biasa. Misalnya, bisa berupa array karakter 2D, atau daftar daftar angka, atau daftar datar.

• Program atau fungsi diizinkan, dalam bahasa pemrograman apa pun . Celah standar dilarang.

• Kode terpendek dalam byte menang.

Uji kasus

1. Memasukkan:

   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
   

   Keluaran: 3

2. Memasukkan

   8 8
   2 3
   

   Keluaran: 0

3. Memasukkan:

   5 3 4
   2 5 2
   

   Keluaran: 0

4. Memasukkan:

   5 8 3 8
   

   Keluaran: 2

5. Memasukkan:

   8
   0
   8
   

   Output: 2.

6. Memasukkan:

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

   Keluaran: 1

7. Memasukkan:

   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
   

   Keluaran 3.

8. Memasukkan:

   8
   

   Keluaran: 1

9. Memasukkan:

   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
   

   Output: 4.

10. Memasukkan:

    8 1 8
    2 5 7
    8 0 1
    

    Output: 3.

Input dalam 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]

Input dalam 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]]

Output:

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

MATL , 21 17 10 byte

8=t3Y6Z+>z

Cobalah online!

Terima kasih kepada Luis Mendo untuk bantuan dalam obrolan, dan untuk menyarankan konvolusi 2D.

Penjelasan:

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

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

Cobalah online!

distmenghitung jarak (default adalah Euclidean) di antara deretan matriks. whichdengan argumen kedua TRUEmengembalikan koordinat di mana predikat itu benar.

Koordinat adalah tetangga jika jarak di antara mereka tidak lebih dari akar kuadrat dari 2, tetapi bagian dalam <2cukup baik karena jarak yang dimungkinkan melompat dari sqrt(2)ro 2.

APL (Dyalog Classic) , 29 28 25 byte

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

Cobalah online!

Jelly , ₁₈ 15 byte

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

Cobalah online!

Bagaimana itu bekerja

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

Solusi sebelumnya, 18 byte

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

Cobalah online!

Ingin berbagi pendekatan lain, meskipun ini 1 byte lebih lama dari solusi Jonathan Allan .

Bagaimana itu bekerja

æ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

Cobalah online!

Terima kasih Arnauld untuk 2 byte

J , 43, 40 37 byte

-3 byte terima kasih kepada Bubbler

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

Cobalah online!

Penjelasan:

Bagian pertama dari algoritma memastikan bahwa kita dapat menerapkan jendela geser 3x3 untuk inputnya. Ini dicapai dengan mendahului deretan nol dan rotasi 90 derajat, diulang 4 kali.

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 byte

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

Cobalah online! Penjelasan:

.+
_$&_

Bungkus setiap baris dalam non- 8karakter sehingga semua 8memiliki setidaknya satu karakter di setiap sisi.

m`

Ini adalah tahap terakhir, jadi penghitungan kecocokan tersirat. The mpengubah membuat ^dan $karakter sesuai pada awal atau akhir setiap baris.

(?<!...|8)

Jangan mencocokkan karakter secara langsung setelah 8, atau ...

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

... karakter di bawah 8; yang (?(1).)^(?<-1>.)*sesuai dengan kolom yang sama sebagai ¶(.)*pada baris berikutnya, tetapi .?.?memungkinkan 8untuk menjadi 1 kiri atau kanan dari karakter setelah .pada baris berikutnya.

8

Cocok 8s.

(?!8|...)

Jangan mencocokkan angka 8 segera sebelum angka 8, atau ...

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

... karakter dengan 8 pada baris di bawah ini; lagi, (?<-2>.)*$(?(2).)cocok dengan kolom yang sama seperti (.)*¶pada baris sebelumnya, tetapi .?.?memungkinkan 8untuk menjadi 1 kiri atau kanan 8sebelum .pada baris sebelumnya.

Jelly , 17 byte

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

Cobalah online! Atau lihat test-suite .

Bagaimana?

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

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

Cobalah online!

penjelasan

Pendekatan tingkat tinggi di sini mirip dengan yang digunakan dalam solusi APL klasik untuk permainan kehidupan: https://www.youtube.com/watch?v=a9xAKttWgP4 .

Dalam solusi itu, kami menggeser matriks kami di 8 kemungkinan arah tetangga, membuat 8 duplikat input, menumpuknya, dan kemudian menambahkan "pesawat" bersama-sama untuk mendapatkan jumlah tetangga kami.

Di sini, kami menggunakan trik "multiply by infinity" untuk mengadaptasi solusi untuk masalah ini.

[: +/@, 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 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 terima kasih kepada @ OlivierGrégoire .

Mengambil dimensi sebagai parameter tambahan R(jumlah baris) dan C(jumlah kolom).

Sel-sel diperiksa sangat mirip seperti yang saya lakukan dalam jawaban simulator Fryer saya .

Cobalah online.

Penjelasan:

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

Cobalah online!

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

Skrip uji yang kurang 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"
}

Keluaran:

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 : 

Penjelasan:

Pertama, skrip menghitung panjang string pertama.

Kedua, itu menambahkan perbatasan ekstra ke string. Augmented reality menyukai:

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

mewakili string multiline:

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

Catatan 1: jumlah = cukup untuk string dengan panjang berapa pun.

Catatan 2: sejumlah besar = tidak mempengaruhi pencarian untuk delapan.

Selanjutnya, ekspresi reguler (?<=[^8]{3}.{$l}[^8])8(?=[^8].{$l}[^8]{3})mencari digit 8dengan non-delapan sebelumnya dan non-delapan (?<=[^8]{3}.{$l}[^8])berikut (?=[^8].{$l}[^8]{3}):

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

Akhirnya, jumlah pertandingan dikembalikan sebagai hasilnya.

Jelly , 12 byte

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

Cobalah online!

Bagaimana itu bekerja

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

Cobalah online!

Pendekatan bitwise, 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

Cobalah online!

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

Aduh. Jelas bukan yang terpendek di sini dengan cara apa pun. 54 byte kurung adalah pembunuh. Saya masih relatif senang dengan itu.

-29 byte dengan menciptakan fungsi pembantu yang menghasilkan berbagai sejak saya melakukan itu dua kali, mengubah reduceke (count (filtersetup, dan menyingkirkan makro threading setelah bermain 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]

Di mana test-casesarray memegang semua "Python test cases"

Cobalah online!