Minesweeper è un puzzle game in cui le mine sono nascoste attorno a un tabellone di tessere anonime con l'obiettivo di identificare la posizione di tutte le mine. Fare clic su una miniera perde il gioco, ma facendo clic su qualsiasi altra tessera si rivelerà un numero compreso tra 0 e 8 che indica quante mine la circondano direttamente.

Dato un numero, è necessario visualizzare una possibile combinazione casuale * di tessere vuote e mine circostanti. Questo dovrebbe essere sotto forma di un array 3x3. La tessera centrale dovrebbe essere il numero di mine prese come input.

* Deve avere una possibilità diversa da zero per tutte le combinazioni.

Esempi

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

Ingresso

• Il numero di mine che circondano la tessera centrale (0-8)

Produzione

• Qualsiasi forma ragionevole di output che visualizza l'array 3x3 di riquadri

Altre regole

• Ogni combinazione non deve avere pari possibilità di accadere. Ci deve essere solo una possibilità diversa da zero per ciascuna combinazione che si verifichi durante l'esecuzione del programma.
• È possibile scegliere 2 caratteri per la miniera e la tessera vuota.
• Questo è il codice golf, vince il programma con il minor numero di byte.

Gelatina , 9 byte

<Ɱ8Ẋs4js3

Provalo online!

vuoto = 1
mio =0

Si noti che 1e 0sono numeri interi.

Un'altra nota: questo è in qualche modo simile alla risposta a 10 byte di Jonathan Allan, ma non è in alcun modo influenzato da essa in alcun modo, e il meccanismo, se presti molta attenzione, è in realtà più diverso rispetto a prima vista.

APL (Dyalog Unicode) , 28 15 byte

-13 byte grazie a ngn!

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

Spiegazione:

{...}Una funzione diretta (D-Fn) ⍵è l'argomento giusto.

8?8 distribuire 8 numeri casuali dall'elenco 1..8:

      8?8                         
7 2 1 8 4 6 5 3

⍵≥ l'argomento è maggiore o uguale a ciascuno di essi ?:

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

⍵, anteponi l'argomento all'elenco booleano:

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

5⌽ ruota la lista di 5 posizioni a sinistra, in modo che l'argomento sia al centro:

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

3 3⍴ rimodella l'elenco in una matrice 3x3:

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

Provalo online!

J , 15 byte

Anche molti byte grazie a ngn!

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

Provalo online!

JavaScript (ES6), 67 byte

Versione più breve suggerita da @tsh

Le slot vuote sono 0, le miniere lo sono 1.

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

Provalo online!

Versione originale di prova ed errore, 78 byte

Le slot vuote sono _, le miniere lo sono 7.

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

Provalo online!

Commentate

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 byte

8Ẉ>RẊs4js3

L'elenco di liste restituito ha il numero intero visualizzato al centro circondato da 0 e 1 che rappresentano rispettivamente le miniere e gli spazi.

Provalo online! (piè di pagina stampa l'array)

Come?

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 byte

c3jQc2.S.[d8*N

Salvato 2 byte grazie a isaacg.
Utilizza spazi per punti sicuri e preventivi per miniere.
Provalo qui

Spiegazione

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

Non è una lingua da golf ma ...

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

Il valore di input è in una tabella ncon colonna n:

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

Provalo online: accedi a https://livesql.oracle.com e incollalo in un foglio di lavoro.

Produzione:

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

Per ottenere tutte le possibili combinazioni (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

Produzione:

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

Provalo

Spiegazione

                   :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 grazie a DLosc (trucco di golf appena pubblicato).

Vuoto = 0
mio =1

Nota che 0 e 1sono numeri interi, ma sto usando STDOUT comunque, quindi ...

L'output appare così:

 A  B  C
 D  x  E
 F  G  H

Dove AH sono 0/1 e x è l'ingresso.

Carbone , 19 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Utilizza 0per una miniera, 1per uno spazio vuoto. Spiegazione:

     ＫＡ             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 restituisce una matrice di stringhe, che Sum semplicemente concatena, motivo per cui dobbiamo prima eseguire il cast su intero. ( Sum(Sum(PeekAll()))funziona anche.)
• Sum ritorna None per un array vuoto (primo loop), quindi l'unico confronto sicuro è Not(Equals(...)).
• Nilary Random ritorna sempre 0, anche se la sua documentazione dice diversamente.

Soluzione alternativa, era di 19 byte, ora 17 byte dopo una correzione del carbone:

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Usi 0per una miniera,1per uno spazio vuoto. Spiegazione:

θ

Stampa l'input originale.

←9

Stampa a 9sinistra. Ciò sposta il cursore sull'input originale e forza anche almeno un'iterazione del ciclo while (altrimenti un input di8 non farebbe nulla).

Ｗ⁻ΣＩＫＡ⁸

Ripeti mentre la differenza tra la somma di tutte le cifre sulla tela e 8 è diversa da zero:

ＵＭＫＭＩ‽²

Sostituisci casualmente ciascuno dei personaggi circostanti con 0o 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]

Provalo online!

Usi 1e 0. Costruisci un n* 1 +(8-n)* 0vettore, mescolalo, accoda n, costruisce la matrice più grande mostrata di seguito (dove a...irappresentano gli elementi del vettore originale) ed estrae la matrice secondaria corretta mostrata in maiuscolo:

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

Provalo online!

0per vuoto; 1per una miniera; e nper se stessi.

Attache , 51 byte

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

Provalo online!

Spiegazione

Simile alla risposta J / APL di Galeno , la tecnica di base è generare un array di 1 e 0 con il numero corretto di mine, inserendo l'input accodandolo alla fine, ruotando l'array in modo tale che l'input sia al centro, quindi rimodellamento in una matrice 3x3.

Parte 1: generazione dell'array binario

Esistono molti modi per farlo, ma mi sono imbattuto principalmente in due tipi: forza bruta e selezione.

Il metodo principale della forza bruta è simile al seguente:

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

Questo genera matrici casuali di 8 cifre binarie ( Random[8&2]) mentre le loro somme non equivalgono all'input {Sum@_/=_2}&_. Questo è un po 'dettagliato, poiché le seguenti parti enfatizzate del codice sono lì "solo per farlo funzionare":

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

E ho scartato l'idea.

La selezione è più interessante. Il concetto principale è quello di usare il BaseBelow[b, n]builtin, che genera un elenco di tutti gli binteri di base della larghezza n(come array di cifre), da 0a b^n-1. Ad esempio, BaseBelow[3, 2]genera tutti gli interi ternari di larghezza 2:

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

Usiamo specificamente BaseBelow[2, 8] per tutti gli interi binari di larghezza 8. Questi rappresentano tutti i possibili campi minati di tutte le lunghezze. questo è il primo passo.

Il secondo passo è selezionare tutti questi array con solo N1s, dove Nè l'input. La mia prima idea è stata quella di tradurre questa dichiarazione inglese direttamente in Attache:

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

Tuttavia, non solo è risultato essere 1 byte più lungo dell'approccio sopra menzionato, ma è anche altamente ripetitivo, e non è nemmeno randomizzato !. Certo, potrei probabilmente salvare 1 byte riorganizzando comeBaseBelow viene chiamato, ma semplicemente non vale la pena usare l'approccio.

Così ho deciso di uccidere due uccelli con una fava e usare un Shuffleapproccio basato. Quanto segue fornisce tutti i campi minati validi di lunghezza Nin ordine casuale:

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

Quindi, tutto ciò che deve essere fatto è selezionare il primo. Ma posso fare di meglio, sicuramente sarebbe meglio semplicemente Samplel'array filtrato? Questo approccio risulta essere qualcosa del genere:

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

Ho dovuto ripristinare il BaseBelow&8!2golf perché \la precedenza è troppo alta. Altrimenti soddisfatto, ho proceduto a tagliare un byte di quello:

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

(Ho scoperto un altro modo per chiamare in modo succinto una funzione diadica qui: x&f@yè un'espressione ad alta precedenza che valuta f[x, y].)

Tuttavia, nonostante questo, mi sono ricordato che, tutti insieme, un alias per 2&BaseBelowesistito: BinBelow. Quindi l'ho usato:

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

Questo genera il campo minato desiderato. Sono convinto che questo sia quasi ottimale.

Parte 2: formazione dell'array

Come detto in precedenza, la tecnica di formatura che ho usato è simile alla risposta J / APL, quindi non entrerò in troppi dettagli. Supponiamo che MINEFIELDsia il risultato dell'ultima sezione. La funzione diventa quindi:

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

MINEFIELD'_concatena il campo minato con l'input originale _, dandoci qualcosa del genere:

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

Quindi, Rotate[MINEFIELD'_,4]ruota questo elenco 4volte a sinistra, posizionando il centro:

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

L'ultimo passaggio sta utilizzando [3,3]&per rimodellare l'elenco in una matrice 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;}

Le tessere vuote sono _(qualsiasi personaggio con un valore unicode superiore a 58 va bene) e le mine lo sono 0.

Provalo online.

Spiegazione:

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

Provalo online!

PHP , 135 134 123 117 122 121 byte

Il ciclo su str per stampare invece salva 1 byte

str_split e implode per inserire il numero centrale salva 11 byte

Non è necessario assegnare la stringa a $ s salvando più 6 byte
Sì. Altrimenti la stringa viene mescolata dopo ogni eco ...

La rimozione di spazi bianchi dopo l'eco salva 1 byte

La sostituzione di "\ n" con un'interruzione di riga corrente consente di risparmiare 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?"":"
");

Provalo online!

Alice , 24 byte

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

Provalo online!

Le slot vuote sono 9e le miniere lo sono0 .

Ho anche creato un programma a 27 byte con 1per miniere e 0per slot vuoti:

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

Provalo online!

PowerShell , 91 86 byte

^{-5 byte grazie 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]

Provalo online!

Mescola una stringa generata che va da ________a XXXXXXXX(sostituendo da sinistra). Quindi lo suddivide più volte, inserendolo $nnel mezzo, per creare la stringa di output. Quest'ultima parte può probabilmente essere notevolmente ottimizzata perché ogni indice costa un minimo di 5 byte.

Rubino , 59 byte

Restituisce un elenco di stringhe (una per ogni riga).

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

Provalo online!

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

Provalo online!

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

Provalo online!

05AB1E , 12 byte

$×8j.r2äIý3ô

Utilizza 0per miniere, spazi per quadrati vuoti. Emette un elenco di linee, che è piuttosto stampato nei TIO di seguito unendo con delimitatore newline (» ).

Provalo online o verifica alcuni altri casi di test contemporaneamente .

Spiegazione:

$             # 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 a 12 byte :

8L@.rIš5._3ô

Usi 1per miniere,0 per quadrati vuoti. Emette una matrice di cifre, che è piuttosto stampata nei TIO di seguito unendo ciascuna riga, quindi queste righe con delimitatore di nuova riga ( J»).

Provalo online o verifica alcuni altri casi di test contemporaneamente .

Spiegazione:

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)