扫雷（Minesweeper）是一款益智游戏，其中地雷被隐藏在一块非描述性瓷砖周围，目的是识别所有地雷的位置。单击一个地雷会导致游戏失败，但是单击任何其他图块都会显示一个介于0到8之间的数字，表示有多少个地雷直接围绕在它周围。

给定一个数字，您必须显示一个随机的*可能的组合，其中包含空砖和包围它的地雷。这应该是3x3数组的形式。中心磁贴应为输入的地雷数量。

*所有组合发生的机率都必须为非零。

例子

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

输入值

• 中心磁贴周围的地雷数量（0-8）

输出量

• 显示3x3瓦片阵列的任何合理形式的输出

其他规定

• 每种组合都不必具有均等的发生机会。执行程序时，每种组合都必须存在非零的机会。
• 可以选择2个字符作为地雷和空瓦。
• 这是代码高尔夫，以最少的字节数获胜的程序。

果冻，9字节

<Ɱ8Ẋs4js3

在线尝试！

空= 1
我的=0

请注意，1和0是整数。

另一个注意事项：这有点类似于乔纳森·艾伦（Jonathan Allan）的10字节答案，但是它并没有以任何方式受到真正的影响，而且，如果您密切注意的话，该机制实际上比乍一看有更多不同。

APL（Dyalog Unicode），28个 15字节

-13个字节，感谢ngn！

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

说明：

{...}直接函数（D-Fn）⍵是其正确的参数。

8?8 从列表1..8处理8个随机数：

      8?8                         
7 2 1 8 4 6 5 3

⍵≥ 该论点是大于还是等于它们中的每个？

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

⍵, 将参数放在布尔列表的前面：

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

5⌽ 将列表向左旋转5个位置，以使参数位于中间：

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

3 3⍴ 将列表调整为3x3矩阵：

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

在线尝试！

J，15个字节

也感谢ngn！

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

在线尝试！

JavaScript（ES6），67个字节

@tsh建议的较短版本

空插槽是0地雷1。

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

在线尝试！

原始的尝试和错误版本，78字节

空插槽是_地雷7。

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

在线尝试！

已评论

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

果冻， 13  10 字节

8Ẉ>RẊs4js3

返回的列表列表的中心显示的整数由0和1包围，分别代表地雷和毛坯。

在线尝试！（页脚漂亮地打印了数组）

怎么样？

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

Pyth，16个 14字节

c3jQc2.S.[d8*N

感谢isaacg，节省了2个字节。
为安全地点使用空格，为地雷使用报价。
在这里尝试

说明

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字节

不是打高尔夫球的语言，而是...

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

输入值在n带有列的表中n：

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

在线尝试-登录https://livesql.oracle.com并将其粘贴到工作表中。

输出：

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

要获得所有可能的组合（183字节）：

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

输出：

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个字节

çÊú8 öÊi4U ò3

试试吧

说明

                   :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字节

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感谢DLosc（新发布的高尔夫技巧）。

空= 0
矿=1

请注意，0和1是整数，但是无论如何我都在使用STDOUT，所以...

输出显示如下：

 A  B  C
 D  x  E
 F  G  H

其中AH为0/1，x为输入。

木炭，19字节

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

在线尝试！链接是详细版本的代码。用途0用于矿山，1一个空的空间。说明：

     ＫＡ             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

• Peek返回一个字符串数组，该字符串Sum简单地连接在一起，这就是为什么我们必须首先转换为整数的原因。（Sum(Sum(PeekAll()))也可以。）
• Sum返回None空数组（第一个循环），因此唯一安全的比较是Not(Equals(...))。
• Nilary Random总是返回0，尽管其文档中另有说明。

替代解决方案是19个字节，现在在修复木炭后修正了17个字节：

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

在线尝试！链接是详细版本的代码。用途0用于矿山，1一个空的空间。说明：

θ

打印原始输入。

←9

打印一个 9向左。这会将光标移回原始输入上方，并且还会强制while循环至少进行一次迭代（否则，of的输入8将不起作用）。

Ｗ⁻ΣＩＫＡ⁸

重复，同时画布上所有数字的总和与8的差不为零：

ＵＭＫＭＩ‽²

用0或随机替换每个周围的字符1。

R，67 63 62 59字节

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

在线尝试！

用途1和0。构建一个n* 1 +(8-n)* 0矢量，对其进行随机组合，追加n，构建如下所示的更大矩阵（其中a...i代表原始矢量的元素），并提取以大写形式显示的适当子矩阵：

     [,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字节

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

在线尝试！

0空的 1为了一个地雷 和n一个人的自我。

附件，51字节

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

在线尝试！

说明

与Galen的J / APL答案类似，基本技术是生成具有正确数量的地雷的1和0的数组，通过将输入附加到末尾来插入输入，旋转数组以使输入位于中心，然后重塑为3x3矩阵。

第1部分：生成二进制数组

有很多方法可以做到这一点，但是我主要遇到两种类型：蛮力和选择。

主要的暴力破解方法如下所示：

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

这将生成8个二进制数字（Random[8&2]）的随机数组，而它们的总和不等于输入{Sum@_/=_2}&_。这有点冗长，因为下面的代码强调部分“只是为了使它起作用”：

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

我放弃了这个主意。

选择更加有趣。主要概念是使用BaseBelow[b, n]内置b函数，该函数生成n从0to到所有宽度（以数字数组形式）的基整数的列表b^n-1。例如，BaseBelow[3, 2]生成所有宽度为2的三进制整数：

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

我们专门将BaseBelow[2, 8]宽度8的所有二进制整数使用。它们表示所有长度的所有可能的雷区。这是第一步。

第二步是选择只有N1的所有此类数组，其中N输入为。我的第一个想法是将英语声明直接翻译为Attache：

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

但是，这不仅比上述方法长了1个字节，而且还具有很高的重复性-甚至还没有随机化！当然，我可以通过重新组织BaseBelow调用方式来节省1个字节，但是使用这种方法根本不值得。

因此，我决定用一块石头杀死两只鸟，并采用一种Shuffle基本方法。以下内容N以随机顺序给出了所有有效长度的雷区：

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

然后，所有需要做的就是选择第一个。但是我可以做得更好-当然，仅Sample过滤数组会更好吗？这种方法出来是这样的：

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

BaseBelow&8!2由于\s的优先级太高，我不得不恢复高尔夫球。否则感到满意，我开始砍掉一个字节：

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

（我在这里发现了另一种简洁地调用二进位函数的方法：x&f@y是一个高等价表达式，其结果为f[x, y]。）

但是，尽管如此，我仍然记得一个别名2&BaseBelow：BinBelow。所以我用了：

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

这将产生所需的雷区。我相信这几乎是最佳的。

第2部分：形成数组

如前所述，我使用的成形技术与J / APL答案类似，因此我不会赘述过多。假设MINEFIELD是最后一节的结果。该函数将变为：

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

MINEFIELD'_将雷区与原始输入连接起来_，给我们这样的东西：

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

然后，Rotate[MINEFIELD'_,4]将此列表4向左旋转一次，并放置在中心：

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

最后一步是[3,3]&将列表重塑为3x3矩阵：

 1 0 0
 1 3 1
 0 0 0

Java的10，165个 157 141字节

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;}

空图块是_（任何unicode值大于58的字符都可以），而地雷是0。

在线尝试。

说明：

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字节

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

在线尝试！

PHP，135个 134 123 117 122 121字节

循环打印str可以节省1个字节

str_split和爆破插入中心号可节省11个字节

不再需要将字符串分配给$ s节省6个字节，
是的。否则，在每次回声之后，字符串都会被打乱。

回声后删除空格可节省1个字节

用精简换行符替换“ \ n”可节省1个字节

$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?"":"
");

在线尝试！

爱丽丝，24字节

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

在线尝试！

空插槽是9，地雷是0。

我还1为地雷和0空插槽制作了一个27字节的程序：

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

在线尝试！

PowerShell，91 86字节

^{-5个字节，感谢mazzy}

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

在线尝试！

随机排列生成的字符串，范围从________到XXXXXXXX（从左侧替换）。然后，它会对其进行多次切片，插入$n中间，以构建输出字符串。由于每个索引至少要占用5个字节，因此可能会大大优化最后一部分。

红宝石，59个字节

返回字符串列表（每行一个）。

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

在线尝试！

C（gcc），81个字节

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

在线尝试！

Perl 5中 -pa，105个 101字节

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

在线尝试！

05AB1E，12 个字节

$×8j.r2äIý3ô

用途0用于矿山，空白方格空间。输出行列表，通过与换行定界符（»）一起在下面的TIO中漂亮地打印出来。

在线尝试或一次验证更多测试用例。

说明：

$             # 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 字节替代：

8L@.rIš5._3ô

用途1用于矿山，0空白方格。输出一个数字矩阵，该矩阵通过连接每一行，然后在这些行中使用换行定界符（J»），漂亮地打印在下面的TIO中。

在线尝试或一次验证更多测试用例。

说明：

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)