Máy quét rác là một trò chơi giải đố trong đó các mỏ được giấu xung quanh một bảng gạch không đặc trưng với mục tiêu xác định vị trí của tất cả các mỏ. Nhấp vào mỏ sẽ thua trò chơi, nhưng nhấp vào bất kỳ ô nào khác sẽ hiển thị một số từ 0-8, biểu thị có bao nhiêu mỏ trực tiếp bao quanh nó.

Cho một số, bạn phải hiển thị một sự kết hợp ngẫu nhiên * có thể có của các ô trống và các mỏ xung quanh nó. Điều này nên ở dạng một mảng 3x3. Gạch trung tâm nên là số lượng mỏ lấy làm đầu vào.

* Phải có cơ hội khác không cho tất cả các kết hợp xảy ra.

Ví dụ

_ = blank square
X = mine

0

___
_0_
___

1

_X_
_1_
___

1

___
_1_
X__

___
_1_
__X

4

_X_
X4X
_X_

4

X_X
_4_
X_X

4

___
X4X
X_X

8

XXX
X8X
XXX

Đầu vào

• Số lượng mỏ xung quanh gạch trung tâm (0-8)

Đầu ra

• Bất kỳ hình thức đầu ra hợp lý nào hiển thị mảng 3x3 của gạch

Quy tắc khác

• Mỗi sự kết hợp không phải có cơ hội như nhau. Phải có cơ hội khác không cho mỗi sự kết hợp xảy ra khi thực hiện chương trình của bạn.
• Bất kỳ 2 ký tự có thể được chọn cho mỏ và gạch trống.
• Đây là mã golf, chương trình có ít byte nhất sẽ thắng.

Thạch , 9 byte

<Ɱ8Ẋs4js3

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

trống = 1
của tôi =0

Lưu ý rằng 1và 0là số nguyên.

Một lưu ý khác: điều này hơi giống với câu trả lời 10 byte của Jonathan Allan, nhưng nó không thực sự bị ảnh hưởng bởi nó theo bất kỳ cách nào, và cơ chế, nếu bạn chú ý kỹ, thực sự khác hơn so với cái nhìn đầu tiên.

APL (Dyalog Unicode) , 28 15 byte

-13 byte nhờ ngn!

{3 3⍴5⌽⍵,⍵≥8?8}

Giải trình:

{...}Một hàm trực tiếp (D-Fn), ⍵là đối số đúng của nó.

8?8 giải quyết 8 số ngẫu nhiên từ danh sách 1..8:

      8?8                         
7 2 1 8 4 6 5 3

⍵≥ là đối số lớn hơn hoặc bằng với mỗi trong số họ?:

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

⍵, thêm đối số vào danh sách boolean:

      5 , 0 1 1 0 1 0 1 1
5 0 1 1 0 1 0 1 1

5⌽ xoay danh sách 5 vị trí sang trái, để đối số nằm ở giữa:

      5 ⌽ 5 0 1 1 0 1 0 1 1
1 0 1 1 5 0 1 1 0

3 3⍴ định hình lại danh sách thành ma trận 3x3:

      3 3 ⍴ 1 0 1 1 5 0 1 1 0
1 0 1
1 5 0
1 1 0

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

J , 15 byte

Cũng nhiều byte nhờ ngn!

3 3$5|.],]>8?8:

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

JavaScript (ES6), 67 byte

Phiên bản ngắn hơn được đề xuất bởi @tsh

Khe trống là 0, mỏ là 1.

n=>`___
_${t=9,n}_
___`.replace(/_/g,_=>n-(n-=Math.random()<n/--t))

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

Phiên bản dùng thử và lỗi gốc, 78 byte

Khe trống là _, mỏ là 7.

f=(n,o=`___
_${k=n}_
___`.replace(/_/g,c=>Math.random()<.5?--k|7:c))=>k?f(n):o

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

Đã bình luận

f = (                         // f = recursive function
  n,                          // n = input
  o = `___\n_${k = n}_\n___`  // o = minesweeper field / k = backup of n
    .replace(/_/g, c =>       // for each underscore character c in o:
      Math.random() < .5 ?    //   random action:
        --k | 7               //     either decrement k and yield 7
      :                       //   or:
        c                     //     let the underscore unchanged
    )                         // end of replace()
) =>                          //
  k ?                         // if k is not equal to 0:
    f(n)                      //   try again
  :                           // else:
    o                         //   stop recursion and return o

Thạch ,  13  10 byte

8Ẉ>RẊs4js3

Danh sách danh sách được trả về có số nguyên được hiển thị ở trung tâm được bao quanh bởi 0 và 1 tương ứng với các mỏ và khoảng trống.

Hãy thử trực tuyến! (chân trang đẹp in mảng)

Làm sao?

8Ẉ>RẊs4js3 - Link: integer, n                   e.g.  3
8          - eight                                    8
 Ẉ         - length of each (implicit range of eight) [1,1,1,1,1,1,1,1]
   R       - range of n                               [1,2,3]
  >        - greater than? (vectorises)               [0,0,0,1,1,1,1,1]
    Ẋ      - shuffle                                  [1,1,1,0,0,1,1,0]
     s4    - split into chunks of 4                   [[1,1,1,0],[0,1,1,0]]
       j   - join (with n)                            [1,1,1,0,3,0,1,1,0]
        s3 - split into chunks of 3                   [[1,1,1],[0,3,0],[1,1,0]]

Bình thường, 16 14 byte

c3jQc2.S.[d8*N

Đã lưu 2 byte nhờ isaacg.
Sử dụng không gian cho các điểm an toàn và báo giá cho các mỏ.
Hãy thử nó ở đây

Giải trình

c3jQc2.S.[d8*N
            *NQ     Get (implicit) input number of quotes...
        .[d8        ... and pad to length 8 with spaces.
      .S            Shuffle.
  jQc2              Stick the input in the middle.
c3                  Split into three.

Oracle 18 SQL, 230 byte

Không phải ngôn ngữ chơi gôn nhưng ...

WITH v(v)AS(SELECT*FROM SYS.ODCINUMBERLIST(0,1))SELECT v.v||b.v||c.v||'
'||d.v||n||e.v||'
'||f.v||g.v||h.v
FROM n,v,v b,v c,v d,v e,v f,v g,v h
WHERE v.v+b.v+c.v+d.v+e.v+f.v+g.v+h.v=n
ORDER BY DBMS_RANDOM.VALUE
FETCH NEXT ROW ONLY

Giá trị đầu vào nằm trong một bảng ncó cột n:

CREATE TABLE n(n) AS
SELECT 7 FROM DUAL;

Dùng thử trực tuyến - đăng nhập vào https://livesql.oracle.com và dán vào bảng tính.

Đầu ra:

V.V||B.V||C.V||''||D.V||N||E.V||''||F.V||G.V||H.V
-------------------------------------------------
101 
171 
111

Để có được tất cả các kết hợp có thể (183 Byte):

WITH v(v)AS(SELECT*FROM SYS.ODCINUMBERLIST(0,1))SELECT v.v||b.v||c.v||'
'||d.v||n||e.v||'
'||f.v||g.v||h.v
FROM n,v,v b,v c,v d,v e,v f,v g,v h
WHERE v.v+b.v+c.v+d.v+e.v+f.v+g.v+h.v=n

Đầu ra:

V.V||B.V||C.V||''||D.V||N||E.V||''||F.V||G.V||H.V
-------------------------------------------------
111 
171 
110

111 
171 
101

111 
171 
011

111 
170 
111

111 
071 
111

110 
171 
111

101 
171 
111

011 
171 
111

Japt, 13 byte

çÊú8 öÊi4U ò3

Thử nó

Giải trình

                   :Implicit input of integer U
 Ê                 :"l"
ç                  :Repeat U times
  ú8               :Pad right to length 8
    öÊ             :Random permutation
       i4U         :Insert U at index 4
            ò3     :Split at every 3rd character

QBasic 1.1 , 206 186 byte

RANDOMIZE TIMER
INPUT N
O=N
Z=8-N
FOR I=0TO 7
IF O*Z THEN
R=RND<.5
O=O+R
Z=Z-1-R
A(I)=-R
ELSEIF O THEN
O=O-1
A(I)=1
ELSE
Z=Z-1
A(I)=0
ENDIF
NEXT I
?A(0)A(1)A(2)
?A(3)N;A(4)
?A(5)A(6)A(7)

-20 nhờ DLosc (thủ thuật đánh gôn mới được đăng).

Trống = Của 0
tôi =1

Lưu ý rằng 0và 1là số nguyên, nhưng dù sao tôi cũng đang sử dụng STDOUT, vì vậy ...

Đầu ra xuất hiện như thế này:

 A  B  C
 D  x  E
 F  G  H

Trong đó AH là 0/1 và x là đầu vào.

Than , 19 byte

Ｗ¬⁼ΣＩＫＡ⁸«Ｅ³⭆³‽²↑↗↖θ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Sử dụng 0cho một mỏ, 1cho một không gian trống. Giải trình:

     ＫＡ             Peek the entire canvas
    Ｉ               Cast to integer
   Σ                Take the sum
       ⁸            Literal 8
  ⁼                 Equals
 ¬                  Logical Not
Ｗ       «           While
          ³ ³       Literal 3
         Ｅ          Map over implicit range
           ⭆        Map over implicit range and join
              ²     Literal 2
             ‽      Random element of implicit range
                    Implicitly print on separate lines
               ↑↗↖θ Print the original input in the middle

• Peektrả về một chuỗi các chuỗi, Sumđơn giản là nối, đó là lý do tại sao chúng ta phải truyền thành số nguyên trước. ( Sum(Sum(PeekAll()))cũng hoạt động.)
• Sumtrả về Nonecho một mảng trống (vòng lặp đầu tiên), vì vậy so sánh an toàn duy nhất là Not(Equals(...)).
• Nilary Randomluôn trở lại 0, mặc dù tài liệu của nó nói khác đi.

Giải pháp thay thế, là 19 byte, giờ là 17 byte sau lỗi Char than:

θ←9Ｗ⁻ΣＩＫＡ⁸ＵＭＫＭＩ‽²

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Sử dụng 0cho một mỏ, 1cho một không gian trống. Giải trình:

θ

In đầu vào ban đầu.

←9

In một 9bên trái. Thao tác này sẽ di chuyển con trỏ trở lại đầu vào ban đầu và cũng buộc ít nhất một lần lặp của vòng lặp while (nếu không, đầu vào 8sẽ không làm gì cả).

Ｗ⁻ΣＩＫＡ⁸

Lặp lại trong khi chênh lệch giữa tổng của tất cả các chữ số trên khung vẽ và 8 là khác không:

ＵＭＫＭＩ‽²

Thay thế ngẫu nhiên từng ký tự xung quanh bằng 0hoặc 1.

R , 67 63 62 59 byte

matrix(c(sample(rep(1:0,c(n<-scan(),8-n))),n),6,5)[2:4,1:3]

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

Sử dụng 1và 0. Xây dựng một n* 1 +(8-n)* 0vectơ, xáo trộn nó, nối thêm n, xây dựng ma trận lớn hơn được hiển thị bên dưới (trong đó đại diện a...icho các phần tử của vectơ gốc) và trích xuất ma trận con thích hợp được hiển thị bằng chữ in hoa:

     [,1] [,2] [,3] [,4] [,5]
[1,] "a"  "g"  "d"  "a"  "g" 
[2,] "B"  "H"  "E"  "b"  "h" 
[3,] "C"  "I"  "F"  "c"  "i" 
[4,] "D"  "A"  "G"  "d"  "a" 
[5,] "e"  "b"  "h"  "e"  "b" 
[6,] "f"  "c"  "i"  "f"  "c"

Python 2 , 93 byte

from random import*
def f(n):a=[1]*n+[0]*(8-n);shuffle(a);a[4:4]=[n];return zip(*[iter(a)]*3)

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

0cho trống rỗng; 1cho một mỏ; và ncho chính mình.

Tùy viên , 51 byte

{[3,3]&Rotate[Sample[{Sum@_=_2}&_\BinBelow@8]'_,4]}

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

Giải trình

Tương tự như câu trả lời J / APL của Galen , kỹ thuật cơ bản là tạo ra một mảng 1 và 0 với số lượng mỏ chính xác, chèn đầu vào bằng cách nối nó vào cuối, xoay mảng sao cho đầu vào nằm ở giữa, sau đó định hình lại thành ma trận 3x3.

Phần 1: tạo mảng nhị phân

Có nhiều cách để thực hiện điều này, nhưng tôi chủ yếu xảy ra trên hai loại: lực lượng vũ phu và lựa chọn.

Phương pháp vũ lực chính trông như thế này:

NestWhile[{Random[8&2]},0,{Sum@_/=_2}&_]

Điều này tạo ra các mảng ngẫu nhiên gồm 8 chữ số nhị phân ( Random[8&2]) trong khi tổng của chúng không bằng đầu vào {Sum@_/=_2}&_. Đây là một chút dài dòng, vì các phần được nhấn mạnh sau đây của mã là "chỉ để làm cho nó hoạt động":

NestWhile[{Random[8&2]},0,{Sum@_/=_2}&_]
          ^           ^^^^^        ^^^^

Và tôi đã loại bỏ ý tưởng.

Lựa chọn là thú vị hơn. Khái niệm chính là sử dụng BaseBelow[b, n]nội dung, tạo ra một danh sách tất cả các cơ sởb số nguyên sở có chiều rộng n(dưới dạng mảng chữ số), từ 0đến b^n-1. Ví dụ: BaseBelow[3, 2]tạo tất cả các số nguyên ternary có chiều rộng 2:

A> BaseBelow[3, 2]
 0 0
 0 1
 0 2
 1 0
 1 1
 1 2
 2 0
 2 1
 2 2

Chúng tôi đặc biệt sử dụng BaseBelow[2, 8] cho tất cả các số nguyên nhị phân có chiều rộng 8. Chúng đại diện cho tất cả các trường khai thác có thể có độ dài. Đây là bước đầu tiên.

Bước thứ hai là chọn tất cả các mảng như vậy chỉ với N1 giây, Nđầu vào là đâu . Ý tưởng đầu tiên của tôi là dịch trực tiếp câu nói tiếng Anh này sang Attache:

Chunk[SortBy[Sum,BaseBelow[2,8]],Sum]@N@1

Tuy nhiên, điều này không chỉ dài hơn 1 byte so với cách tiếp cận đã nói ở trên, mà còn lặp đi lặp lại rất cao và nó thậm chí còn chưa được ngẫu nhiên!. Chắc chắn, tôi có thể có thể tiết kiệm 1 byte bằng cách sắp xếp lại cách BaseBelowgọi, nhưng đơn giản là nó không đáng để sử dụng phương pháp này.

Vì vậy, tôi quyết định giết hai con chim bằng một hòn đá và sử dụng Shufflecách tiếp cận dựa trên. Sau đây cung cấp cho tất cả các mỏ khai thác hợp lệ chiều dàiN theo thứ tự ngẫu nhiên:

{Sum@_=_2}&N\Shuffle[BaseBelow&8!2]

Sau đó, tất cả những gì cần làm là chọn đầu tiên. Nhưng tôi có thể làm tốt hơn nữa, chắc chắn sẽ tốt hơn nếu chỉ đơn giản làSample mảng được lọc? Cách tiếp cận này được đưa ra là một cái gì đó như thế này:

Sample[{Sum@_=_2}&_\BaseBelow[2,8]]

Tôi đã phải hoàn nguyên BaseBelow&8!2golf vì \độ ưu tiên quá cao. Nếu không hài lòng, tôi đã tiến hành cắt một byte về điều đó:

Sample[{Sum@_=_2}&_\2&BaseBelow@8]

(Tôi đã phát hiện ra một cách khác để gọi một hàm dyadic ở đây: x&f@y là một biểu thức có độ ưu tiên cao để đánh giá f[x, y].)

Tuy nhiên, mặc dù vậy, tôi nhớ rằng, tất cả cùng, một bí danh cho 2&BaseBelowtồn tại : BinBelow. Vì vậy, tôi đã sử dụng rằng:

Sample[{Sum@_=_2}&_\BinBelow@8]

Điều này tạo ra các mỏ khai thác mong muốn. Tôi tin rằng điều này là gần tối ưu.

Phần 2: Hình thành mảng

Như đã nói trước đó, kỹ thuật tạo hình tôi đã sử dụng tương tự như câu trả lời của J / APL, vì vậy tôi sẽ không đi sâu vào chi tiết. Giả sử MINEFIELDlà kết quả từ phần cuối cùng. Hàm sau đó trở thành:

{[3,3]&Rotate[MINEFIELD'_,4]}

MINEFIELD'_nối các bãi mìn với đầu vào ban đầu _, cho chúng ta một cái gì đó như thế này:

[1, 0, 0, 0, 1, 0, 0, 1, 3]

Sau đó, Rotate[MINEFIELD'_,4]xoay danh sách này 4lần sang trái, đặt trung tâm:

[1, 0, 0, 1, 3, 1, 0, 0, 0]

Bước cuối cùng là sử dụng [3,3]&để định hình lại danh sách thành ma trận 3x3:

 1 0 0
 1 3 1
 0 0 0

Java 10, 165 157 141 byte

n->{var r="___\n_"+n+"_\n___";for(int i;n>0;r=r.charAt(i*=Math.random())>58?r.substring(0*n--,i)+(i>9?0:0+r.substring(i+1)):r)i=11;return r;}

Gạch trống là _(bất kỳ ký tự nào có giá trị unicode trên 58 là tốt) và các mỏ là0 .

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

Giải trình:

n->{                           // Method with integer parameter and String return-type
  var r="___\n_"+n+"_\n___";   //  Result-String, starting at:
                               //   "___
                               //    _n_
                               //    ___"
  for(int i;n>0                //  Loop as long as `n` isn't 0 yet:
      ;                        //    After every iteration:
       r=r.charAt(i*=Math.random())
                               //     Select a random integer in the range [0,11)
         >58?                  //     And if the character at this random index is a '_':
          r.substring(0*n--,i) //      Set `r` to the first part excluding character `i`,
                               //      (and decrease `n` by 1 in the process)
          +(i>9?0:0+           //      appended with a '0',
           r.substring(i+1))   //      appended with the second part
         :                     //     Else:
          r)                   //      Leave `r` unchanged
     i=11;                     //   Set `i` to 11 so a new random integer can be chosen
  return r;}                   //  Return the result

PowerShell , 77 byte

param($n)-join(0..7|random -c 8|%{'X_'[$_-ge$n]
$n[++$i-ne4]
'
'*($i-in3,5)})

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

PHP , 135 134 123 117 122 121 byte

Thay thế trên str để in thay vì tiết kiệm 1 byte

str_split và implode để chèn số trung tâm tiết kiệm 11 byte

Không cần gán chuỗi cho $ s nữa, tiết kiệm 6 byte
Có bạn làm. Nếu không thì chuỗi bị xáo trộn sau mỗi tiếng vang ...

Xóa khoảng trắng sau khi echo tiết kiệm 1 byte

Thay thế "\ n" bằng ngắt dòng ctual tiết kiệm 1 byte

$n=$argv[1];$s=implode($n,str_split(str_shuffle(str_pad(str_repeat(m,$n),8,n)),4));for(;$i<9;)echo$s[$i].(++$i%3?"":"
");

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

Alice , 24 byte

a8E/be?SZ!@
~E-\ita*.o/a

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

Khe trống là 9, và mỏ là0 .

Tôi cũng đã thực hiện một chương trình 27 byte với 1các mỏ và 0cho các khe trống:

a8Ea8/be?SZ!@
-E-9:\ita*.o/

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

PowerShell , 91 86 byte

^{-5 byte nhờ mazzy}

param($n)$x=,'X'*$n+,'_'*(8-$n)|random -c 8
-join$x[0..2]
$x[3,4]-join$n
-join$x[5..7]

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

Xáo trộn một chuỗi được tạo từ ( ________đến XXXXXXXXthay thế từ bên trái). Sau đó, nó cắt qua nó nhiều lần, chèn $nvào giữa, để xây dựng chuỗi đầu ra. Phần cuối cùng này có thể được tối ưu hóa rất nhiều vì mỗi chỉ mục tốn tối thiểu 5 byte.

Ruby , 59 byte

Trả về một danh sách các chuỗi (một cho mỗi dòng).

->n{a=([0]*(8-n)+[1]*n).shuffle;a[4,0]=n;a.join.scan /.../}

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

C (gcc) , 81 byte

f(n,i,j,k){for(j=i=8,k=n;--i+5;putchar(i%4?i-2?rand()%j--<k?k--,88:95:48+n:10));}

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

Perl 5 -pa , 105 101 byte

@o=grep!/^....1/&&y/1//=="@F",map{sprintf"%09b",$_}0..2**9-1;$_=$o[rand@o];s/....\K./@F/;s/...\K/\n/g

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

05AB1E , 12 byte

$×8j.r2äIý3ô

Công dụng 0 cho các mỏ, không gian cho hình vuông trống. Xuất ra một danh sách các dòng, được in khá đẹp trong các TIO bên dưới bằng cách kết hợp với dấu phân cách dòng mới (» ).

Dùng thử trực tuyến hoặc xác minh thêm một vài trường hợp thử nghiệm cùng một lúc .

Giải trình:

$             # Push 0 and the input-digit
 ×            # Repeat the 0 the input-digit amount of times as string
              #  i.e. 4 → "0000"
  8j          # Prepend spaces to make the size 8
              #  → "    0000"
    .r        # Randomly shuffle the characters in this string
              #  i.e. "    0000" → " 00 0  0"
      2ä      # Split it into two equal halves (of 4 characters)
              #  → [" 00 ","0  0"]
        Iý    # Join it with the input-digit
              #  → " 00 40  0"
          3ô  # And then split it into (three) parts of 3 characters
              #  → [" 00"," 40","  0"]
              # (which is output implicitly as result)

12 byte thay thế:

8L@.rIš5._3ô

Sử dụng 1cho các mỏ,0 cho hình vuông trống. Xuất ra một ma trận các chữ số, được in khá đẹp trong các TIO bên dưới bằng cách nối từng hàng và sau đó các hàng này với dấu phân cách dòng mới ( J»).

Dùng thử trực tuyến hoặc xác minh thêm một vài trường hợp thử nghiệm cùng một lúc .

Giải trình:

8L            # Push the list [1,2,3,4,5,6,7,8]
  @           # Check for each if the (implicit) input-integer is >= it
              # (1 if truthy; 0 if falsey)
              #  i.e. 4 → [1,1,1,1,0,0,0,0]
   .r         # Randomly shuffle this list
              #  i.e. [1,1,1,1,0,0,0,0] → [0,1,1,0,1,0,0,1]
     Iš       # Prepend the input-digit to the list
              #  → [4,0,1,1,0,1,0,0,1]
       5._    # Rotate the list five times towards the left
              #  → [1,0,0,1,4,0,1,1,0]
          3ô  # And then split it into (three) parts of 3 digits each
              #  → [[1,0,0],[1,4,0],[1,1,0]]
              # (which is output implicitly as result)