Campo Minado é um jogo de quebra-cabeça onde as minas estão escondidas em torno de um tabuleiro de peças indefinidas com o objetivo de identificar a localização de todas as minas. Clicar em uma mina perde o jogo, mas clicar em qualquer outra peça revela um número de 0 a 8, o que significa quantas minas a cercam diretamente.

Dado um número, você deve exibir uma combinação * aleatória possível de ladrilhos vazios e minas ao redor. Isso deve estar na forma de uma matriz 3x3. O bloco central deve ser o número de minas tomadas como entrada.

* Deve ter uma chance diferente de zero para que todas as combinações ocorram.

Exemplos

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

Entrada

• O número de minas ao redor do ladrilho central (0-8)

Saída

• Qualquer forma razoável de saída que exibe a matriz 3x3 de blocos

Outras regras

• Cada combinação não precisa ter uma chance igual de acontecer. Só deve haver uma chance diferente de zero de cada combinação ao executar seu programa.
• Podem ser escolhidos 2 caracteres para a mina e o ladrilho vazio.
• Isso é código de golfe, o programa com menos bytes vence.

Geléia , 9 bytes

<Ɱ8Ẋs4js3

Experimente online!

vazio = 1
meu =0

Observe que 1e 0são números inteiros.

Outra observação: isso é um pouco semelhante à resposta de 10 bytes de Jonathan Allan, mas não é realmente influenciada por ela, e o mecanismo, se você prestar muita atenção, é realmente mais diferente do que à primeira vista.

APL (Dyalog Unicode) , 28 15 bytes

-13 bytes graças a ngn!

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

Explicação:

{...}Uma função direta (D-Fn), ⍵é o seu argumento correto.

8?8 negocie 8 números aleatórios da lista 1..8:

      8?8                         
7 2 1 8 4 6 5 3

⍵≥ o argumento é maior ou igual a cada um deles?

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

⍵, Anexe o argumento à lista booleana:

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

5⌽ gire a lista 5 posições para a esquerda, para que o argumento esteja no centro:

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

3 3⍴ remodelar a lista para uma matriz 3x3:

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

Experimente online!

J , 15 bytes

Também muitos bytes graças ao ngn!

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

Experimente online!

JavaScript (ES6), 67 bytes

Versão mais curta sugerida por @tsh

Slots vazios são 0, minas são 1.

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

Experimente online!

Versão original de tentativa e erro, 78 bytes

Slots vazios são _, minas são 7.

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

Experimente online!

Comentado

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

Gelatina ,  13  10 bytes

8Ẉ>RẊs4js3

A lista de listas retornada tem o número inteiro exibido no centro, cercado por 0s e 1s, representando minas e espaços em branco, respectivamente.

Experimente online! (rodapé bastante imprime a matriz)

Quão?

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

Pitão, 16 14 bytes

c3jQc2.S.[d8*N

Economizou 2 bytes graças a isaacg.
Usa espaços para pontos seguros e cotações para minas.
Experimente aqui

Explicação

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 bytes

Não é uma língua de golfe, mas ...

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

O valor de entrada está em uma tabela ncom coluna n:

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

Experimente online - faça login em https://livesql.oracle.com e cole-o em uma planilha.

Saída:

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

Para obter todas as combinações possíveis (183 bytes):

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

Saída:

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

Japonês, 13 bytes

çÊú8 öÊi4U ò3

Tente

Explicação

                   :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 bytes

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 graças ao DLosc (truque de golfe recém-publicado).

Vazio = 0
Meu =1

Observe que 0e 1são números inteiros, mas estou usando STDOUT de qualquer maneira, então ...

A saída aparece assim:

 A  B  C
 D  x  E
 F  G  H

Onde AH são 0/1 e x é a entrada.

Carvão , 19 bytes

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

Experimente online! Link é a versão detalhada do código. Usa 0para uma mina, 1para um espaço vazio. Explicação:

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

• Peekretorna uma matriz de seqüências de caracteres, que Sumsimplesmente concatena, e é por isso que precisamos converter o número inteiro primeiro. ( Sum(Sum(PeekAll()))também funciona.)
• Sumretorna Nonepara uma matriz vazia (primeiro loop), portanto, a única comparação segura é Not(Equals(...)).
• Nilary Randomsempre retorna 0, embora sua documentação diga o contrário.

Solução alternativa, eram 19 bytes, agora 17 bytes após uma correção de bug do Charcoal:

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

Experimente online! Link é a versão detalhada do código. Usa 0para uma mina, 1para um espaço vazio. Explicação:

θ

Imprima a entrada original.

←9

Imprima uma 9para a esquerda. Isso move o cursor de volta sobre a entrada original e também força pelo menos uma iteração do loop while (caso contrário, uma entrada de 8não faria nada).

Ｗ⁻ΣＩＫＡ⁸

Repita enquanto a diferença entre a soma de todos os dígitos na tela e 8 for diferente de zero:

ＵＭＫＭＩ‽²

Substitua cada um dos caracteres ao redor aleatoriamente por 0ou 1.

R , 67 63 62 59 bytes

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

Experimente online!

Usos 1e 0. Construa um n* 1 +(8-n)* 0vetor, embaralhe-o, acrescente n, construa a matriz maior mostrada abaixo (onde a...iestão os elementos do vetor original) e extrai a sub-matriz adequada mostrada em maiúscula:

     [,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 bytes

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

Experimente online!

0para vazio; 1para uma mina; e npara si mesmo.

Anexo , 51 bytes

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

Experimente online!

Explicação

Igual a resposta J / APL de Galen , a técnica básica é gerar uma matriz de 1s e 0s com o número correto de minas, inserindo a entrada anexando-a ao final, girando a matriz de modo que a entrada fique no centro e depois remodelando em uma matriz 3x3.

Parte 1: gerando a matriz binária

Existem várias maneiras de fazer isso, mas eu deparei principalmente com dois tipos: força bruta e seleção.

O método primário de força bruta se parece com isso:

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

Isso gera matrizes aleatórias de 8 dígitos binários ( Random[8&2]) enquanto suas somas não são iguais à entrada {Sum@_/=_2}&_. Isso é um pouco detalhado, pois as seguintes partes enfatizadas do código existem "apenas para fazê-lo funcionar":

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

E eu descartei a ideia.

A seleção é mais interessante. O conceito principal é usar o BaseBelow[b, n]builtin, que gera uma lista de todos os bnúmeros inteiros base da larguran (como matrizes de dígitos), de 0até b^n-1. Por exemplo, BaseBelow[3, 2]gera todos os números inteiros ternários de largura 2:

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

Nós usamos especificamente BaseBelow[2, 8] para todos os números inteiros binários de largura 8. Eles representam todos os campos minados possíveis de todos os comprimentos. Este é o primeiro passo.

O segundo passo é selecionar todas essas matrizes apenas N 1s, onde Nestá a entrada. Minha primeira idéia foi traduzir essa declaração em inglês diretamente no Attache:

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

No entanto, isso não apenas resultou em 1 byte mais do que a abordagem mencionada, como também é altamente repetitivo - e ainda nem foi randomizado! Claro, eu provavelmente poderia economizar 1 byte reorganizando como BaseBelowé chamado, mas simplesmente não vale a pena usar a abordagem.

Então, decidi matar dois coelhos com uma cajadada e usar uma Shuffleabordagem baseada. A seguir, são apresentados todos os campos minados válidosN em ordem aleatória:

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

Então, tudo o que precisa ser feito é selecionar o primeiro. Mas posso fazer melhor - certamente seria melhor simplesmenteSample a matriz filtrada? Essa abordagem acaba sendo algo assim:

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

Eu tive que reverter o BaseBelow&8!2golfe porque \a precedência é muito alta. Caso contrário, satisfeito, passei a cortar um byte disso:

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

(Descobri outra maneira de chamar sucintamente uma função diádica aqui: x&f@y é uma expressão de alta precedência que é avaliada como f[x, y]).

No entanto, apesar disso, eu me lembrei que, o tempo todo, um alias para 2&BaseBelowexistido: BinBelow. Então eu usei isso:

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

Isso gera o campo minado desejado. Estou convencido de que isso é quase ideal.

Parte 2: formando a matriz

Como dito anteriormente, a técnica de formação que usei é semelhante à resposta J / APL, portanto não entrarei em muitos detalhes. Suponha que MINEFIELDé o resultado da última seção. A função então se torna:

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

MINEFIELD'_concatena o campo minado com a entrada original _, dando-nos algo como isto:

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

Em seguida, Rotate[MINEFIELD'_,4]gire esta lista 4vezes para a esquerda, colocando o centro:

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

A última etapa está sendo usada [3,3]&para remodelar a lista em uma matriz 3x3:

 1 0 0
 1 3 1
 0 0 0

Java 10, 165 157 141 bytes

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

As peças vazias são _(qualquer caractere com um valor unicode acima de 58 é bom) e as minas são 0.

Experimente online.

Explicação:

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 bytes

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

Experimente online!

PHP , 135 134 123 117 117 122 121 bytes

Fazer um loop sobre str para imprimir economiza 1 byte

str_split e implode para inserir o número do centro economiza 11 bytes

Não é mais necessário atribuir a string a $ s, economizando 6 bytes
Sim, você . Caso contrário, a corda é embaralhada após cada eco ...

A remoção de espaço em branco após o eco economiza 1 byte

Substituir "\ n" por uma quebra de linha real economiza 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?"":"
");

Experimente online!

Alice , 24 bytes

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

Experimente online!

Os slots vazios são 9e as minas são 0.

Também fiz um programa de 27 bytes 1para minas e 0slots vazios:

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

Experimente online!

PowerShell , 91 86 bytes

^{-5 bytes graças ao mazzy}

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

Experimente online!

Baralha aleatoriamente uma cadeia de caracteres gerada que varia de ________a XXXXXXXX(substituindo da esquerda). Em seguida, ele corta várias vezes, inserindo $nno meio, para criar a sequência de saída. Esta última parte provavelmente pode ser bastante otimizada, pois cada índice custa no mínimo 5 bytes.

Rubi , 59 bytes

Retorna uma lista de strings (uma para cada linha).

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

Experimente online!

C (gcc) , 81 bytes

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

Experimente online!

Perl 5 -pa , 105 101 bytes

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

Experimente online!

05AB1E , 12 bytes

$×8j.r2äIý3ô

Usa 0para minas, espaços para quadrados em branco. Produz uma lista de linhas, que é bastante impressa nos TIOs abaixo, juntando-se ao delimitador de nova linha (» ).

Experimente online ou verifique mais alguns casos de teste de uma só vez .

Explicação:

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

Alternativa de 12 bytes :

8L@.rIš5._3ô

Usa 1para minas, 0para quadrados em branco. Produz uma matriz de dígitos, que é bastante impressa nos TIOs abaixo, juntando cada linha e, em seguida, essas linhas com delimitador de nova linha ( J»).

Experimente online ou verifique mais alguns casos de teste de uma só vez .

Explicação:

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)