Buscaminas es un juego de rompecabezas donde las minas se esconden alrededor de un tablero de fichas indescriptibles con el objetivo de identificar la ubicación de todas las minas. Al hacer clic en una mina se pierde el juego, pero al hacer clic en cualquier otra ficha se mostrará un número del 0 al 8, lo que significa cuántas minas la rodean directamente.

Dado un número, debe mostrar una combinación aleatoria * posible de fichas vacías y minas que lo rodean. Esto debería ser en forma de una matriz de 3x3. El mosaico central debe ser el número de minas tomadas como entrada.

* Debe tener una probabilidad distinta de cero para que ocurran todas las combinaciones.

Ejemplos

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

• El número de minas que rodean el mosaico central (0-8)

Salida

• Cualquier forma razonable de salida que muestre la matriz 3x3 de mosaicos

Otras reglas

• Cada combinación no tiene que tener la misma posibilidad de suceder. Simplemente debe haber una probabilidad distinta de cero de que ocurra cada combinación al ejecutar su programa.
• Se pueden elegir 2 caracteres para la mina y el mosaico vacío.
• Este es el código de golf, el programa con menos bytes gana.

Jalea , 9 bytes

<Ɱ8Ẋs4js3

Pruébalo en línea!

vacío = 1
mío =0

Tenga en cuenta que 1y 0son enteros.

Otra nota: esto es algo similar a la respuesta de 10 bytes de Jonathan Allan, pero en realidad no está influenciada por ella de ninguna manera, y el mecanismo, si prestas mucha atención, en realidad es más diferente que a primera vista.

APL (Dyalog Unicode) , 28 15 bytes

-13 bytes gracias a ngn!

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

Explicación:

{...}Una función directa (D-Fn), ⍵es su argumento correcto.

8?8 tratar 8 números aleatorios de la lista 1..8:

      8?8                         
7 2 1 8 4 6 5 3

⍵≥ ¿Es el argumento mayor o igual a cada uno de ellos ?:

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

⍵, anteponer el argumento a la lista booleana:

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

5⌽ gire la lista 5 posiciones hacia la izquierda, de modo que el argumento esté en el centro:

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

3 3⍴ remodelar la lista a una matriz 3x3:

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

Pruébalo en línea!

J , 15 bytes

También muchos bytes gracias a ngn!

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

Pruébalo en línea!

JavaScript (ES6), 67 bytes

Versión más corta sugerida por @tsh

Las ranuras vacías son 0, las minas son 1.

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

Pruébalo en línea!

Versión original de prueba y error, 78 bytes

Las ranuras vacías son _, las minas son 7.

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

Pruébalo en línea!

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

Jalea ,  13  10 bytes

8Ẉ>RẊs4js3

La lista de listas devuelta tiene el número entero visualizado en el centro rodeado de 0 y 1 que representan minas y espacios en blanco, respectivamente.

Pruébalo en línea! (pie de página bonito imprime la matriz)

¿Cómo?

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 bytes

c3jQc2.S.[d8*N

Guardado 2 bytes gracias a isaacg.
Utiliza espacios para lugares seguros y cotizaciones para minas.
Pruébalo aquí

Explicación

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

No es un lenguaje de golf pero ...

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

El valor de entrada está en una tabla ncon columna n:

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

Pruébelo en línea: inicie sesión en https://livesql.oracle.com y péguelo en una hoja de trabajo.

Salida:

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

Para obtener todas las combinaciones posibles (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

Salida:

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 bytes

çÊú8 öÊi4U ò3

Intentalo

Explicación

                   :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 gracias a DLosc (truco de golf recientemente publicado).

Vacío = 0
mío =1

Tenga en cuenta que 0y 1son enteros, pero estoy usando STDOUT de todos modos, así que ...

La salida aparece así:

 A  B  C
 D  x  E
 F  G  H

Donde AH son 0/1 yx es la entrada.

Carbón de leña , 19 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Usos 0para una mina, 1para un espacio vacío. Explicación:

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

• Peekdevuelve una serie de cadenas, que Sumsimplemente se concatenan, por lo que primero tenemos que convertir a entero. ( Sum(Sum(PeekAll()))también funciona)
• Sumdevuelve Nonepara una matriz vacía (primer bucle), por lo que la única comparación segura es Not(Equals(...)).
• Nilary Randomsiempre regresa 0, aunque su documentación dice lo contrario.

Solución alternativa, era de 19 bytes, ahora 17 bytes después de una corrección de errores de carbón:

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

Pruébalo en línea! El enlace es a la versión detallada del código. Usos 0para una mina, 1para un espacio vacío. Explicación:

θ

Imprime la entrada original.

←9

Imprima a la 9izquierda. Esto mueve el cursor hacia atrás sobre la entrada original y también fuerza al menos una iteración del ciclo while (de lo contrario, una entrada de 8no haría nada).

Ｗ⁻ΣＩＫＡ⁸

Repita mientras la diferencia entre la suma de todos los dígitos en el lienzo y 8 no es cero:

ＵＭＫＭＩ‽²

Reemplace cada uno de los caracteres circundantes al azar con 0o 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]

Pruébalo en línea!

Usos 1y 0. Construye un n* 1 +(8-n)* 0vector, lo baraja, agrega n, construye la matriz más grande que se muestra a continuación (donde a...iestán los elementos del vector original) y extrae la submatriz adecuada que se muestra en mayúsculas:

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

Pruébalo en línea!

0por vacío 1por una mina; y npara uno mismo.

Adjunto , 51 bytes

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

Pruébalo en línea!

Explicación

Similar a la respuesta J / APL de Galen , la técnica básica es generar una matriz de 1s y 0s con el número correcto de minas, insertando la entrada al agregarla al final, girando la matriz de manera que la entrada quede en el centro, luego remodelando en una matriz de 3x3.

Parte 1: generar la matriz binaria

Hay muchas formas de hacerlo, pero principalmente me encontré con dos tipos: fuerza bruta y selección.

El método primario de fuerza bruta se ve así:

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

Esto genera matrices aleatorias de 8 dígitos binarios ( Random[8&2]) mientras que sus sumas no son iguales a la entrada {Sum@_/=_2}&_. Esto es un poco detallado, ya que las siguientes partes destacadas del código están ahí "solo para que funcione":

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

Y descarté la idea.

La selección es más interesante. El concepto principal es utilizar el BaseBelow[b, n]builtin, que genera una lista de todos los benteros base de ancho n(como matrices de dígitos), desde 0hasta b^n-1. Por ejemplo, BaseBelow[3, 2]genera todos los enteros ternarios de ancho 2:

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

Usamos específicamente BaseBelow[2, 8]para todos los enteros binarios de ancho 8. Estos representan todos los campos minados posibles de todas las longitudes. Este es el primer paso.

El segundo paso es seleccionar todas esas matrices con solo N1s, donde Nestá la entrada. Mi primera idea fue traducir esta declaración en inglés directamente en Attache:

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

Sin embargo, esto no solo resultó ser 1 byte más largo que el enfoque mencionado anteriormente, sino que también es muy repetitivo, ¡y ni siquiera es aleatorio todavía! Claro, probablemente podría ahorrar 1 byte reorganizando cómo BaseBelowse llama, pero simplemente no vale la pena usar el enfoque.

Así que decidí matar dos pájaros de un tiro y usar un Shuffleenfoque basado. Lo siguiente da todos los campos minados válidos de longitud Nen orden aleatorio:

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

Entonces, todo lo que hay que hacer es seleccionar el primero. Pero puedo hacerlo mejor, ¿seguramente sería mejor simplemente Samplela matriz filtrada? Este enfoque resulta ser algo como esto:

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

Tuve que revertir el BaseBelow&8!2golf porque \la precedencia es demasiado alta. De lo contrario satisfecho, procedí a cortar un byte de eso:

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

(Descubrí otra forma de llamar sucintamente una función diádica aquí: x&f@yes una expresión de alta precedencia que se evalúa como f[x, y]).

Sin embargo, a pesar de esto, recordé que, desde el principio, un alias para 2&BaseBelowexistido: BinBelow. Entonces usé eso:

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

Esto genera el campo minado deseado. Estoy convencido de que esto es casi óptimo.

Parte 2: formando la matriz

Como se dijo anteriormente, la técnica de formación que utilicé es similar a la respuesta J / APL, por lo que no entraré en demasiados detalles. Supongamos que MINEFIELDes el resultado de la última sección. La función se convierte en:

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

MINEFIELD'_concatena el campo minado con la entrada original _, dándonos algo como esto:

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

Luego, Rotate[MINEFIELD'_,4]rota esta lista 4veces a la izquierda, colocando el centro:

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

El último paso es usar [3,3]&para remodelar la lista en una 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;}

Las fichas vacías son _(cualquier personaje con un valor unicode superior a 58 está bien) y las minas sí 0.

Pruébalo en línea.

Explicación:

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

Pruébalo en línea!

PHP , 135 134 123 117 122 121 bytes

Recorrer str para imprimir ahorra 1 byte

str_split e implosionar para insertar el número central ahorra 11 bytes

Ya no es necesario asignar la cadena a $ s, ahorrando 6 bytes
Sí, sí. De lo contrario, la cadena se baraja después de cada eco ...

Eliminar espacios en blanco después del eco ahorra 1 byte

Reemplazar "\ n" con un salto de línea actual ahorra 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?"":"
");

Pruébalo en línea!

Alice , 24 bytes

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

Pruébalo en línea!

Las ranuras vacías son 9, y las minas son0 .

También hice un programa de 27 bytes con 1minas y 0espacios vacíos:

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

Pruébalo en línea!

PowerShell , 91 86 bytes

^{-5 bytes gracias a mazzy}

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

Pruébalo en línea!

Baraja una cadena generada que va de ________a XXXXXXXX(reemplazando desde la izquierda). Luego lo corta varias veces, insertando $nen el medio, para construir la cadena de salida. Esta última parte probablemente se puede optimizar en gran medida porque cada índice cuesta un mínimo de 5 bytes.

Rubí , 59 bytes

Devuelve una lista de cadenas (una para cada línea).

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

Pruébalo en línea!

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

Pruébalo en línea!

Perl 5 -pa , 105101 bytes

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

Pruébalo en línea!

05AB1E , 12 bytes

$×8j.r2äIý3ô

Usos 0para minas, espacios para cuadrados en blanco. Produce una lista de líneas, que está bastante impresa en los TIO a continuación uniéndose con el delimitador de nueva línea (» ).

Pruébelo en línea o verifique algunos casos de prueba más a la vez .

Explicación:

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

Usos 1para minas, 0para cuadrados en blanco. Emite una matriz de dígitos, que está bastante impresa en los TIO a continuación uniendo cada fila, y luego estas filas con un delimitador de nueva línea ( J»).

Pruébelo en línea o verifique algunos casos de prueba más a la vez .

Explicación:

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)