Minesweeper ist ein Puzzlespiel, bei dem Minen um ein Brett mit unscheinbaren Kacheln versteckt sind, um den Standort aller Minen zu ermitteln. Wenn Sie auf eine Mine klicken, verlieren Sie das Spiel. Wenn Sie jedoch auf ein anderes Plättchen klicken, wird eine Zahl zwischen 0 und 8 angezeigt, die angibt, wie viele Minen die Mine direkt umgeben.

Bei einer gegebenen Zahl müssen Sie eine zufällige * mögliche Kombination leerer Kacheln und Minen anzeigen, die sie umgeben. Dies sollte in Form eines 3x3-Arrays erfolgen. Die mittlere Kachel sollte die Anzahl der Minen sein, die als Eingabe verwendet wurden.

* Muss eine Chance ungleich Null haben, damit alle Kombinationen auftreten.

Beispiele

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

Eingang

• Die Anzahl der Minen, die das Mittelplättchen umgeben (0-8)

Ausgabe

• Jede sinnvolle Ausgabeform, die das 3x3-Array von Kacheln anzeigt

Andere Regeln

• Jede Kombination muss nicht die gleiche Chance haben. Es muss nur eine Wahrscheinlichkeit ungleich Null für jede Kombination geben, um bei der Ausführung Ihres Programms aufzutreten.
• Für die Mine und das leere Plättchen können 2 beliebige Zeichen gewählt werden.
• Dies ist Codegolf, das Programm mit den wenigsten Bytes gewinnt.

Gelee , 9 Bytes

<Ɱ8Ẋs4js3

Probieren Sie es online!

leer = 1
meins =0

Beachten Sie, dass 1und 0ganze Zahlen sind.

Noch ein Hinweis: Dies ähnelt in etwa der 10-Byte-Antwort von Jonathan Allan, wird jedoch in keiner Weise wirklich beeinflusst, und der Mechanismus ist, wenn Sie genau hinschauen, tatsächlich anders als auf den ersten Blick.

APL (Dyalog Unicode) , 28 15 Bytes

-13 bytes dank ngn!

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

Erläuterung:

{...}Eine direkte Funktion (D-Fn) ⍵ist das richtige Argument.

8?8 Deal 8 Zufallszahlen aus der Liste 1..8:

      8?8                         
7 2 1 8 4 6 5 3

⍵≥ Ist das Argument größer oder gleich jedem von ihnen ?:

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

⍵, Stellen Sie das Argument vor die Boolesche Liste:

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

5⌽ Drehe die Liste um 5 Positionen nach links, so dass das Argument in der Mitte ist:

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

3 3⍴ Formt die Liste in eine 3x3 Matrix um:

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

Probieren Sie es online!

J , 15 Bytes

Auch viele Bytes dank ngn!

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

Probieren Sie es online!

JavaScript (ES6), 67 Byte

Kürzere Version von @tsh vorgeschlagen

Leere Slots sind 0Minen 1.

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

Probieren Sie es online!

Ursprüngliche Trial-and-Error-Version, 78 Byte

Leere Slots sind _Minen 7.

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

Probieren Sie es online!

Kommentiert

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

Jelly ,  13  10 Bytes

8Ẉ>RẊs4js3

In der zurückgegebenen Liste der Listen ist die angezeigte Ganzzahl in der Mitte von Nullen und Einsen umgeben, die Minen bzw. Leerzeichen darstellen.

Probieren Sie es online! (Fußzeile druckt hübsch das Array)

Wie?

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 bis 14 Bytes

c3jQc2.S.[d8*N

2 Bytes dank isaacg gespart.
Verwendet Räume für sichere Stellen und Anführungszeichen für Minen.
Probieren Sie es hier aus

Erläuterung

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

Keine Golfsprache, aber ...

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

Der Eingabewert befindet sich in einer Tabelle nmit Spalte n:

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

Probieren Sie es online aus - melden Sie sich bei https://livesql.oracle.com an und fügen Sie es in ein Arbeitsblatt ein.

Ausgabe:

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

So erhalten Sie alle möglichen Kombinationen (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

Ausgabe:

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

Versuch es

Erläuterung

                   :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 dank DLosc (neu eingestellter Golf-Trick).

Leer = 0
meins =1

Beachten Sie, dass 0und 1Ganzzahlen sind, aber ich benutze trotzdem STDOUT, also ...

Die Ausgabe sieht folgendermaßen aus:

 A  B  C
 D  x  E
 F  G  H

Wobei AH 0/1 ist und x die Eingabe ist.

Holzkohle , 19 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Verwendet 0für eine Mine, 1für einen leeren Raum. Erläuterung:

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

• Peekgibt ein Array von Strings zurück, die Sumeinfach verkettet werden. Deshalb müssen wir zuerst eine Ganzzahl setzen. (Sum(Sum(PeekAll())) funktioniert auch.)
• SumGibt Nonefür ein leeres Array zurück (erste Schleife), der einzige sichere Vergleich ist also Not(Equals(...)).
• Nilary Randomkehrt immer zurück 0, obwohl in der Dokumentation etwas anderes steht.

Alternative Lösung, war 19 Bytes, jetzt 17 Bytes nach einem Charcoal Bugfix:

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Verwendet 0für eine Mine, 1für einen leeren Raum. Erläuterung:

θ

Drucken Sie die ursprüngliche Eingabe.

←9

Drucken Sie eine 9nach links. Dies bewegt den Cursor zurück über die ursprüngliche Eingabe und erzwingt auch mindestens eine Iteration der while-Schleife (andernfalls würde eine Eingabe von 8nichts bewirken).

Ｗ⁻ΣＩＫＡ⁸

Wiederholen, während der Unterschied zwischen der Summe aller Ziffern auf der Zeichenfläche und 8 ungleich Null ist:

ＵＭＫＭＩ‽²

Ersetzen Sie jedes der umgebenden Zeichen nach dem Zufallsprinzip mit 0oder 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]

Probieren Sie es online!

Verwendet 1und 0. Erstellen Sie einen n* 1 +(8-n)* 0Vektor, mischen Sie ihn, fügen Sie ihn an, erstellen Sie ndie unten gezeigte größere Matrix (wobei a...ifür die Elemente des ursprünglichen Vektors steht) und extrahieren Sie die richtige Submatrix in Großbuchstaben:

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

Probieren Sie es online!

0für leer; 1für eine Mine; und nfür sich.

Attache , 51 Bytes

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

Probieren Sie es online!

Erläuterung

Ähnlich wie bei der J / APL-Antwort von Galen besteht die grundlegende Technik darin, ein Array von Einsen und Nullen mit der richtigen Anzahl von Minen zu generieren, die Eingabe einzufügen, indem sie an das Ende angehängt und das Array so gedreht wird, dass die Eingabe dann in der Mitte liegt Umformen in eine 3x3-Matrix.

Teil 1: Erzeugen des binären Arrays

Es gibt viele Möglichkeiten, dies zu tun, aber ich habe hauptsächlich zwei Arten erlebt: rohe Gewalt und Selektion.

Die primäre Brute-Force-Methode sieht folgendermaßen aus:

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

Dies erzeugt zufällige Arrays mit 8 Binärziffern ( Random[8&2]), deren Summe nicht mit der Eingabe übereinstimmt {Sum@_/=_2}&_. Dies ist etwas ausführlich, da die folgenden hervorgehobenen Teile des Codes "nur damit es funktioniert":

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

Und ich habe die Idee verworfen.

Auswahl ist interessanter. Das Hauptkonzept besteht darin, das BaseBelow[b, n]Builtin zu verwenden, das eine Liste aller Basis- bGanzzahlen der Breite n(als Ziffern-Arrays) von 0bis generiert b^n-1. Beispielsweise werden BaseBelow[3, 2]alle ternären Ganzzahlen der Breite 2 generiert:

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

Wir verwenden speziell BaseBelow[2, 8]für alle binären Ganzzahlen der Breite 8. Diese repräsentieren alle möglichen Minenfelder aller Längen. Dies ist der erste Schritt.

Der zweite Schritt ist die Auswahl aller solcher Arrays mit nur N1s, wobei Ndie Eingabe erfolgt. Meine erste Idee war, diese englische Aussage direkt in Attache zu übersetzen:

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

Dies war jedoch nicht nur 1 Byte länger als der oben beschriebene Ansatz, sondern auch sehr repetitiv - und es ist noch nicht einmal randomisiert !. Sicher, ich könnte wahrscheinlich 1 Byte einsparen, indem ich den BaseBelowAufruf reorganisiere , aber es lohnt sich einfach nicht, den Ansatz zu verwenden.

Also habe ich beschlossen, zwei Fliegen mit einer Klappe zu schlagen und einen Shufflebasierten Ansatz zu wählen. Das Folgende gibt alle gültigen Minenfelder der Länge Nin zufälliger Reihenfolge an:

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

Dann muss nur noch der erste ausgewählt werden. Aber ich kann es besser machen - wäre es sicher besser, einfach Sampledas gefilterte Array zu verwenden? Dieser Ansatz sieht ungefähr so ​​aus:

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

Ich musste den BaseBelow&8!2Golf zurücksetzen, weil die \Rangfolge zu hoch ist. Ansonsten bin ich zufrieden und habe ein Byte davon abgeschnitten:

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

(Ich habe hier einen anderen Weg gefunden, um eine dyadische Funktion kurz und bündig zu nennen: x&f@yist ein Ausdruck mit hoher Priorität, der sich als auswertet f[x, y].)

Doch trotz dieser, erinnerte ich mich , dass die ganze Zeit , einen Aliasnamen für 2&BaseBelowexistierte: BinBelow. Also habe ich das benutzt:

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

Dies erzeugt das gewünschte Minenfeld. Ich bin überzeugt, dass dies nahezu optimal ist.

Teil 2: Bilden des Arrays

Wie bereits erwähnt, ähnelt die von mir verwendete Umformtechnik der J / APL-Antwort, sodass ich nicht auf allzu viele Details eingehen werde. Angenommen, MINEFIELDdas Ergebnis stammt aus dem letzten Abschnitt. Die Funktion wird dann:

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

MINEFIELD'_verkettet das Minenfeld mit der ursprünglichen Eingabe _und gibt uns so etwas:

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

Dann Rotate[MINEFIELD'_,4]dreht sich diese Liste 4mal nach links, in der Mitte platzieren:

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

Der letzte Schritt besteht darin [3,3]&, die Liste in eine 3x3-Matrix umzuformen:

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

Leere Kacheln sind _(jedes Zeichen mit einem Unicode-Wert über 58 ist in Ordnung) und Minen sind 0.

Probieren Sie es online aus.

Erläuterung:

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

Probieren Sie es online!

PHP , 135 134 123 117 122 121 Bytes

Das Durchlaufen von str zum Drucken spart stattdessen 1 Byte

str_split und implode zum Einfügen der Zentrumsnummer sparen 11 Bytes

Die Zeichenfolge muss nicht mehr $ s zugewiesen werden. Das spart 6 Byte.
Ja, das tun Sie. Ansonsten wird die Saite nach jedem Echo gemischt ...

Durch das Entfernen von Leerzeichen nach dem Echo wird 1 Byte gespart

Durch Ersetzen von "\ n" durch einen tatsächlichen Zeilenumbruch wird 1 Byte gespart

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

Probieren Sie es online!

Alice , 24 Bytes

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

Probieren Sie es online!

Leere Slots sind 9und Minen sind 0.

Ich habe auch ein 27-Byte-Programm mit 1für Minen und 0für leere Slots gemacht:

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

Probieren Sie es online!

PowerShell , 91.86 Byte

^{-5 Bytes dank mazzy}

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

Probieren Sie es online!

Mischt eine generierte Zeichenfolge von ________bis XXXXXXXX(ersetzt von links). Es wird dann mehrmals durchgeschnitten und $nin die Mitte eingefügt , um die Ausgabezeichenfolge zu erstellen. Dieser letzte Teil kann wahrscheinlich stark optimiert werden, da jeder Index mindestens 5 Bytes kostet.

Ruby , 59 Bytes

Gibt eine Liste von Zeichenfolgen zurück (eine für jede Zeile).

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

Probieren Sie es 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));}

Probieren Sie es 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

Probieren Sie es online!

05AB1E , 12 Bytes

$×8j.r2äIý3ô

Verwendet 0für Minen, Leerzeichen für leere Felder. Gibt eine Liste von Zeilen aus, die in den unten stehenden TIOs hübsch gedruckt ist, indem sie mit newline delimiter ( ») verknüpft wird .

Probieren Sie es online aus oder überprüfen Sie einige weitere Testfälle auf einmal .

Erläuterung:

$             # 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 Bytes Alternative:

8L@.rIš5._3ô

Verwendet 1für Minen, 0für leere Quadrate. Gibt eine Ziffernmatrix aus, die in den unten stehenden TIOs hübsch gedruckt ist, indem jede Zeile und anschließend diese Zeilen mit einem Zeilenumbruchzeichen ( J») verbunden werden.

Probieren Sie es online aus oder überprüfen Sie einige weitere Testfälle auf einmal .

Erläuterung:

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)