24

Cho một mảng số nguyên không phải hình chữ nhật từ 0đến 9, xuất ra số lượng ô đang 8và không có hàng xóm 8. Hàng xóm ở đây được hiểu theo nghĩa Moore , nghĩa là, bao gồm cả các đường chéo. Vì vậy, mỗi ô có 8hàng xóm, ngoại trừ các ô ở các cạnh của mảng.

Ví dụ, đưa ra đầu vào

đầu ra nên được 3. Ba ô đủ điều kiện sẽ là như sau, được đánh dấu bằng dấu hoa thị (nhưng chỉ nên xuất số lượng các mục như vậy):

Quy tắc bổ sung

Bạn có thể tùy ý lấy hai số xác định kích thước của mảng làm đầu vào bổ sung.
Đầu vào có thể được thực hiện bằng bất kỳ phương tiện hợp lý . Các định dạng linh hoạt như bình thường. Ví dụ, nó có thể là một mảng ký tự 2D hoặc danh sách các danh sách số hoặc danh sách phẳng.
Các chương trình hoặc chức năng được cho phép, trong bất kỳ ngôn ngữ lập trình . Sơ hở tiêu chuẩn bị cấm.
Mã ngắn nhất trong byte thắng.

Các trường hợp thử nghiệm

Đầu vào:

Đầu ra: 3

Đầu vào
```
8 8
2 3
```
Đầu ra: 0
Đầu vào:
```
5 3 4
2 5 2
```
Đầu ra: 0
Đầu vào:
```
5 8 3 8
```
Đầu ra: 2
Đầu vào:
```
8
0
8
```
Đầu ra : 2.
Đầu vào:
```
4 2 8 5
2 6 1 8
8 5 5 8
```
Đầu ra: 1

Đầu vào:

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

Đầu ra 3.

Đầu vào:
```
8
```
Đầu ra: 1

Đầu vào:

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

Đầu ra : 4.

Đầu vào:
```
8 1 8
2 5 7
8 0 1
```
Đầu ra : 3.

Các đầu vào ở định dạng 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]

Các đầu vào ở định dạng 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]]

Đầu ra:

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

code-golf array-manipulation integer

— Luis Mendo
nguồn

17

Nếu bạn thích nó thì bạn nên bỏ phiếu cho nó

— Luis Mendo

Khi tôi đọc "các ô bằng 8", trong một lúc, tôi nghĩ rằng bạn có nghĩa là một ô có thể lớn hơn mâm 1x1 (NxN) của lưới. Có lẽ nên viết lại rằng "các ô là 8" để làm rõ không cần toán học. = P

— Tezra

@Tezra Đã chỉnh sửa. Tôi thấy cách diễn đạt mới ít tự nhiên hơn một chút, nhưng tôi không phải là người bản ngữ nên tôi tin tưởng vào tiêu chí của bạn

— Luis Mendo

2

MATL , 21 17 10 byte

8=t3Y6Z+>z

Hãy thử trực tuyến!

Cảm ơn Luis Mendo vì đã giúp đỡ trong trò chuyện và đề xuất tích chập 2D.

Giải trình:

	#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
nguồn

Bạn có thể lưu khá nhiều byte bằng cách sử dụng tích chập (2D-), nếu bạn là famiiar với khái niệm

— Luis Mendo

1

Kết hợp @LuisMendo 2D là một trong những điều mà tôi không hiểu về tích chập 1D vì vậy không có hy vọng nào cho tôi ở đó ... nghe có vẻ như là một cơ hội để học cả hai!

— Giuseppe

1

Nếu bạn cần giúp đỡ với điều đó hãy cho tôi biết trong phòng chat. Convolution là một hoạt động rất hữu ích. Nếu bạn muốn học tích chập bắt đầu với 1D. Việc khái quát hóa thành 2D là ngay lập tức

— Luis Mendo

9

R , 117 63 59 byte

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

Hãy thử trực tuyến!

disttính khoảng cách (mặc định là Euclide) giữa các hàng của ma trận. whichvới đối số thứ hai TRUEtrả về tọa độ trong đó vị từ là đúng.

Tọa độ là hàng xóm nếu khoảng cách giữa chúng không lớn hơn căn bậc 2, nhưng bên trong <2đủ tốt vì khoảng cách có thể nhảy từ sqrt(2)ro 2.

— ngm
nguồn

đó là một sự thiếu chính xác về số lượng không cho phép colSums()^2<=2làm việc.

— Giuseppe

@Giuseppe tất nhiên chỉ có một vài khoảng cách có thể và sqrt(2)nhảy tới 2(ví dụ sort(c(dist(expand.grid(1:6,1:6))), decreasing = TRUE))) vì vậy chúng tôi đã quá thông minh ở đó.

— ngm

7

APL (Dyalog Classic) , 29 28 25 byte

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

Hãy thử trực tuyến!

— ngn
nguồn

Lưu ý: 0 chỉ số gốc thậm chí không cần thiết.

— Zacharý

@ Zacharý Tôi luôn sử dụng nó như một mặc định, để tránh những điều bất ngờ.

— ngn

Ah, vì vậy, giống như những người khác với 1(ngoại trừ không được thiết lập rõ ràng). Điều đó có ý nghĩa.

— Zacharý

Ngạc nhiên vì điều này không sử dụng stt. Có một cái gì đó làm cho stprint bất tiện ở đây?

— lirtosiast

@lirtosiast nó chỉ dài hơn với nó :)

— ngn

5

Thạch , ₁₈ 15 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Giải pháp trước đó, 18 byte

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

Hãy thử trực tuyến!

Muốn chia sẻ một cách tiếp cận khác, mặc dù điều này dài hơn 1 byte so với giải pháp của Jonathan Allan .

Làm thế nào nó hoạt động

æ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

— Bong bóng
nguồn

4

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

Hãy thử trực tuyến!

Cảm ơn Arnauld vì 2 byte

— l4m2
nguồn

4

J , 43, 40 37 byte

-3 byte nhờ Bubbler

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

Hãy thử trực tuyến!

Giải trình:

Phần đầu tiên của thuật toán đảm bảo rằng chúng ta có thể áp dụng cửa sổ trượt 3x3 cho đầu vào. Điều này đạt được bằng cách thêm vào một hàng số 0 và xoay 90 độ, lặp lại 4 lần.

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
nguồn

1

37 byte sử dụng @:và di chuyển|. . Lưu ý rằng @thay @:vì không hoạt động.

— Bong bóng

@Bubbler Cảm ơn bạn!

— Galen Ivanov

Cái này đẹp đấy. Có lẽ đáng để thêm ít nhất một lời giải thích cấp cao về cách thức hoạt động của nó, nếu không phải là một sự cố mã. Tôi phải mất khoảng 10m để tìm ra nó. Ngoài ra, thật thú vị khi phiên bản APL ngắn hơn (sử dụng cùng một cách tiếp cận). Có vẻ như đó chủ yếu là kết quả của các bản vẽ thay vì các ký hiệu char đơn lẻ ...

— Jonah

@Jonah Tôi sẽ thêm một lời giải thích. Để so sánh với APL, bạn có thể xem các bản sửa đổi của giải pháp ngn , đặc biệt là phiên bản 28 byte

— Galen Ivanov

1

@Jonah Giải thích thêm

— Galen Ivanov

3

Võng mạc 0.8.2 , 84 byte

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

Hãy thử trực tuyến! Giải trình:

.+
_$&_

Gói mỗi dòng thành các 8ký tự không sao cho tất cả các 8s có ít nhất một ký tự ở mỗi bên.

m`

Đây là giai đoạn cuối cùng, vì vậy đếm các trận đấu được ngụ ý. Cácm sửa đổi làm cho các ký tự ^và $ký tự khớp với nhau ở đầu hoặc cuối của bất kỳ dòng nào.

(?<!...|8)

Không khớp trực tiếp một ký tự sau 8 hoặc ...

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

... một nhân vật dưới 8; các (?(1).)^(?<-1>.)*khớp cột tương tự như ¶(.)*trên dòng tiếp theo, nhưng.?.? cho phép 8là 1 trái hoặc bên phải của nhân vật sau khi .vào dòng tiếp theo.

Trận đấu 8s.

(?!8|...)

Không khớp 8 ngay trước 8 hoặc ...

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

... một nhân vật có 8 trong dòng dưới đây; một lần nữa, (?<-2>.)*$(?(2).)khớp với cột tương tự như (.)*¶trên dòng trước, nhưng .?.?cho phép 8là 1 trái hoặc phải của dòng 8trước dòng .trên dòng trước.

— Neil
nguồn

3

Thạch , 17 byte

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

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm .

Làm sao?

=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
nguồn

3

J, 42 byte

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

Hãy thử trực tuyến!

giải trình

Cách tiếp cận cấp cao ở đây tương tự như phương pháp được sử dụng trong giải pháp APL cổ điển cho trò chơi cuộc sống: https://www.youtube.com/watch?v=a9xAKttWgP4 .

Trong giải pháp đó, chúng tôi dịch chuyển ma trận của chúng tôi theo 8 hướng lân cận có thể, tạo 8 bản sao đầu vào, xếp chúng lại và sau đó thêm các "mặt phẳng" lại với nhau để có được số đếm lân cận.

Ở đây, chúng tôi sử dụng thủ thuật "nhân với vô cực" để điều chỉnh giải pháp cho vấn đề này.

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

— Giô-na
nguồn

1

Bạn đã quên xóa khoảng cách giữa ~và>

— Galen Ivanov

@GalenIvanov Đã sửa. Cảm ơn bạn.

— Giô-na

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 nhờ @ OlivierGrégoire .

Lấy kích thước làm tham số bổ sung R(số lượng hàng) và C(số lượng cột).

Các ô được kiểm tra khá giống như tôi đã làm trong câu trả lời giả lập Fasher của mình .

Hãy thử trực tuyến.

Giải trình:

(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
nguồn

2

Con trăn 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])))

Hãy thử trực tuyến!

— Chas Brown
nguồn

Có vẻ ngắn hơn nếu lấy chiều dài từ 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

Kịch bản kiểm tra ít chơi gôn hơn:

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

Đầu ra:

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 :

Giải trình:

Đầu tiên, tập lệnh tính toán độ dài của chuỗi đầu tiên.

Thứ hai, nó thêm đường viền thêm vào chuỗi. Thích chuỗi ~~thực tế mở rộng~~ :

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

đại diện cho chuỗi đa dòng:

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

Lưu ý 1: số lượng = là đủ cho một chuỗi có độ dài bất kỳ.

Lưu ý 2: một số lượng lớn = không ảnh hưởng đến việc tìm kiếm độ cao.

Tiếp theo, biểu thức chính quy (?<=[^8]{3}.{$l}[^8])8(?=[^8].{$l}[^8]{3})tìm chữ số 8có các số không phải trước (?<=[^8]{3}.{$l}[^8])và các số không sau (?=[^8].{$l}[^8]{3}):

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

Cuối cùng, số lượng các trận đấu được trả lại như là kết quả.

— mê mẩn
nguồn

2

Thạch , 12 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

œẹ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
nguồn

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

Hãy thử trực tuyến!

Cách tiếp cận 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

Hãy thử trực tuyến!

— Arnauld
nguồn

Cách tiếp cận [[7]]

— bitwise

@ lm42 ơi, cảm ơn. Bây giờ đã sửa.

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

Ôi. Chắc chắn không phải là ngắn nhất ở đây bằng bất kỳ phương tiện. 54 byte của ngoặc là kẻ giết người. Tôi vẫn còn tương đối hài lòng với nó mặc dù.

-29 byte bằng cách tạo một hàm trợ giúp tạo ra một phạm vi kể từ khi tôi thực hiện hai lần, thay đổi reducethành một (count (filterthiết lập và loại bỏ macro luồng sau khi chơi 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]

Ở đâu test-cases một mảng chứa tất cả các "trường hợp thử nghiệm Python"

Hãy thử trực tuyến!

— Carcigenicate
nguồn

Tất cả các đêm

Quy tắc bổ sung

Các trường hợp thử nghiệm

MATL , 21 17 10 byte

R , 117 63 59 byte

APL (Dyalog Classic) , 29 28 25 byte

Thạch , 18 15 byte

Làm thế nào nó hoạt động

Giải pháp trước đó, 18 byte

Làm thế nào nó hoạt động

JavaScript (Node.js) , 88 85 byte

J , 43, 40 37 byte

Giải trình:

Võng mạc 0.8.2 , 84 byte

Thạch , 17 byte

Làm sao?

J, 42 byte

giải trình

Java 8, 181 157 156 byte

Con trăn 2 , 130 byte

Powershell, 121 byte

Thạch , 12 byte

Làm thế nào nó hoạt động

JavaScript (ES6), 106 byte

Cách tiếp cận bitwise, 110 byte

Clojure , 227 198 byte

Thạch , ₁₈ 15 byte