Démineur est un jeu de puzzle où les mines sont cachées autour d'un tableau de tuiles indéfinissables dans le but d'identifier l'emplacement de toutes les mines. Cliquer sur une mine perd la partie, mais cliquer sur n'importe quelle autre tuile révèlera un nombre compris entre 0 et 8, ce qui signifie combien de mines l'entourent directement.

Étant donné un nombre, vous devez afficher une combinaison aléatoire * possible de tuiles vides et de mines qui l'entourent. Cela devrait être sous la forme d'un tableau 3x3. La tuile centrale doit être le nombre de mines prises en entrée.

* Doit avoir une chance non nulle pour que toutes les combinaisons se produisent.

Exemples

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

Contribution

• Le nombre de mines entourant la tuile centrale (0-8)

Sortie

• Toute forme de sortie raisonnable qui affiche le tableau de tuiles 3x3

Autres règles

• Chaque combinaison n'a pas à avoir une chance égale de se produire. Il doit simplement y avoir une chance non nulle que chaque combinaison se produise lors de l'exécution de votre programme.
• 2 personnages peuvent être choisis pour la mine et la tuile vide.
• C'est le golf de code, le programme avec le moins d'octets gagne.

Gelée , 9 octets

<Ɱ8Ẋs4js3

Essayez-le en ligne!

vide = le 1
mien =0

Notez que 1et 0sont des entiers.

Autre remarque: elle est quelque peu similaire à la réponse de 10 octets de Jonathan Allan, mais elle n'est pas du tout influencée par elle, et le mécanisme, si vous y prêtez attention, est en fait plus différent qu'à première vue.

APL (Dyalog Unicode) , 28 15 octets

-13 octets grâce à ngn!

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

Explication:

{...}Une fonction directe (D-Fn), ⍵est son bon argument.

8?8 traiter 8 nombres aléatoires de la liste 1 à 8:

      8?8                         
7 2 1 8 4 6 5 3

⍵≥ l'argument est-il supérieur ou égal à chacun d'eux ?:

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

⍵, ajouter l'argument à la liste booléenne:

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

5⌽ faites pivoter la liste de 5 positions vers la gauche, de sorte que l'argument soit au centre:

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

3 3⍴ remodeler la liste en une matrice 3x3:

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

Essayez-le en ligne!

J , 15 octets

Beaucoup d'octets aussi grâce à ngn!

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

Essayez-le en ligne!

JavaScript (ES6), 67 octets

Version plus courte suggérée par @tsh

Les emplacements vides le sont 0, les mines le sont 1.

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

Essayez-le en ligne!

Version d'essai et d'erreur d'origine, 78 octets

Les emplacements vides le sont _, les mines le sont 7.

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

Essayez-le en ligne!

Commenté

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

Gelée ,  13  10 octets

8Ẉ>RẊs4js3

La liste de listes renvoyée a l'entier affiché au centre entouré de 0 et de 1 représentant respectivement les mines et les blancs.

Essayez-le en ligne! (le pied de page imprime assez bien le tableau)

Comment?

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 octets

c3jQc2.S.[d8*N

Enregistré 2 octets grâce à isaacg.
Utilise des espaces pour des endroits sûrs et des citations pour les mines.
Essayez-le ici

Explication

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 octets

Pas une langue de golf mais ...

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

La valeur d'entrée est dans un tableau navec une colonne n:

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

Essayez-le en ligne - connectez-vous sur https://livesql.oracle.com et collez-le dans une feuille de calcul.

Sortie:

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

Pour obtenir toutes les combinaisons possibles (183 octets):

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

Sortie:

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 octets

çÊú8 öÊi4U ò3

L'essayer

Explication

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

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 grâce à DLosc (nouvelle astuce de golf publiée).

Vide = 0
mine =1

Notez que 0et 1sont des entiers, mais j'utilise quand même STDOUT, donc ...

La sortie apparaît comme ceci:

 A  B  C
 D  x  E
 F  G  H

Où AH vaut 0/1 et x est l'entrée.

Fusain , 19 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Utilise 0une mine, 1un espace vide. Explication:

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

• Peekrenvoie un tableau de chaînes, qui Sumconcatène simplement, c'est pourquoi nous devons d'abord convertir en entier. ( Sum(Sum(PeekAll()))fonctionne également.)
• Sumrenvoie Nonepour un tableau vide (première boucle), donc la seule comparaison sûre est Not(Equals(...)).
• Nilary Randomrevient toujours 0, bien que sa documentation dise le contraire.

Solution alternative, était de 19 octets, maintenant 17 octets après un correctif de charbon de bois:

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Utilise 0une mine, 1un espace vide. Explication:

θ

Imprimez l'entrée d'origine.

←9

Imprimez 9vers la gauche. Cela ramène le curseur sur l'entrée d'origine et force également au moins une itération de la boucle while (sinon une entrée de 8ne ferait rien).

Ｗ⁻ΣＩＫＡ⁸

Répétez pendant que la différence entre la somme de tous les chiffres sur le canevas et 8 est différente de zéro:

ＵＭＫＭＩ‽²

Remplacez au hasard chacun des caractères environnants par 0ou 1.

R , 67 63 62 59 octets

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

Essayez-le en ligne!

Utilise 1et 0. Construisez un n* 1 +(8-n)* 0vecteur, mélangez-le, ajoutez n, construisez la matrice plus grande illustrée ci-dessous (où a...ise trouvent les éléments du vecteur d'origine) et extrayez la sous-matrice appropriée affichée en majuscules:

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

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

Essayez-le en ligne!

0pour vide; 1pour une mine; et npour soi-même.

Attaché , 51 octets

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

Essayez-le en ligne!

Explication

Semblable à la réponse J / APL de Galen , la technique de base consiste à générer un tableau de 1 et de 0 avec le nombre correct de mines, en insérant l'entrée en l'ajoutant à la fin, en faisant tourner le tableau de sorte que l'entrée se trouve au centre, puis remodelage en une matrice 3x3.

Partie 1: générer le tableau binaire

Il existe de nombreuses façons de procéder, mais je suis principalement tombé sur deux types: la force brute et la sélection.

La méthode de force brute principale ressemble à ceci:

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

Cela génère des tableaux aléatoires de 8 chiffres binaires ( Random[8&2]) alors que leurs sommes ne sont pas égales à l'entrée {Sum@_/=_2}&_. C'est un peu verbeux, car les parties soulignées suivantes du code sont là "juste pour le faire fonctionner":

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

Et j'ai rejeté l'idée.

La sélection est plus intéressante. Le concept principal est d'utiliser la fonction BaseBelow[b, n]intégrée, qui génère une liste de tous les bentiers de base de largeur n(sous forme de tableaux de chiffres), de 0à b^n-1. Par exemple, BaseBelow[3, 2]génère tous les entiers ternaires de largeur 2:

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

Nous utilisons spécifiquement BaseBelow[2, 8]pour tous les entiers binaires de largeur 8. Ils représentent tous les champs de mines possibles de toutes longueurs. C'est le premier pas.

La deuxième étape consiste à sélectionner tous ces tableaux avec seulement N1s, où Nest l'entrée. Ma première idée a été de traduire cette déclaration en anglais directement dans Attache:

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

Cependant, non seulement cela s'est avéré être 1 octet de plus que l'approche susmentionnée, mais c'est également très répétitif - et ce n'est même pas encore aléatoire! Bien sûr, je pourrais probablement économiser 1 octet en réorganisant la façon d' BaseBelowappeler, mais cela ne vaut tout simplement pas la peine d'utiliser l'approche.

J'ai donc décidé de tuer deux oiseaux avec une pierre et d'utiliser une Shuffleapproche basée. Ce qui suit donne tous les champs de mines valides de longueur Ndans un ordre aléatoire:

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

Ensuite, il suffit de sélectionner le premier. Mais je peux faire mieux - ce serait sûrement mieux de simplement Samplefiltrer le tableau? Cette approche se présente comme suit:

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

J'ai dû revenir sur le BaseBelow&8!2golf car la \priorité est trop élevée. Sinon satisfait, j'ai procédé à la découpe d'un octet:

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

(J'ai découvert une autre façon d'appeler succinctement une fonction dyadique ici: x&f@yest une expression de haute priorité qui s'évalue f[x, y].)

Cependant, malgré cela, je me suis souvenu que, tout le long, un alias pour 2&BaseBelowexister: BinBelow. J'ai donc utilisé ça:

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

Cela génère le champ de mines souhaité. Je suis convaincu que c'est presque optimal.

Partie 2: Formation du tableau

Comme dit précédemment, la technique de formage que j'ai utilisée est similaire à la réponse J / APL, donc je n'entrerai pas dans trop de détails. Supposons que MINEFIELDle résultat de la dernière section. La fonction devient alors:

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

MINEFIELD'_concatène le champ de mines avec l'entrée d'origine _, nous donnant quelque chose comme ceci:

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

Ensuite, Rotate[MINEFIELD'_,4]tourne cette liste 4fois vers la gauche, en plaçant le centre:

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

La dernière étape consiste [3,3]&à remodeler la liste en une matrice 3x3:

 1 0 0
 1 3 1
 0 0 0

Java 10, 165 157 141 octets

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

Les tuiles vides sont _(tout caractère avec une valeur unicode supérieure à 58 est très bien) et les mines le sont 0.

Essayez-le en ligne.

Explication:

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 octets

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

Essayez-le en ligne!

PHP , 135 134 123 117 117 122 121 octets

Faire une boucle sur str pour imprimer à la place économise 1 octet

str_split et imploser pour insérer le nombre central économise 11 octets

Plus besoin d'attribuer la chaîne à $ s en économisant 6 octets
. Sinon, la chaîne est mélangée après chaque écho ...

Supprimer un espace après l'écho enregistre 1 octet

Remplacer "\ n" par un saut de ligne ctual économise 1 octet

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

Essayez-le en ligne!

Alice , 24 octets

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

Essayez-le en ligne!

Les emplacements vides le sont 9et les mines le sont 0.

J'ai aussi fait un programme de 27 octets avec 1pour les mines et 0pour les slots vides:

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

Essayez-le en ligne!

PowerShell , 91 86 octets

^{-5 octets grâce à mazzy}

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

Essayez-le en ligne!

Mélange une chaîne générée allant de ________à XXXXXXXX(en remplaçant à partir de la gauche). Il le découpe ensuite plusieurs fois, en l'insérant $nau milieu, pour créer la chaîne de sortie. Cette dernière partie peut probablement être grandement optimisée car chaque index coûte un minimum de 5 octets.

Ruby , 59 octets

Renvoie une liste de chaînes (une pour chaque ligne).

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

Essayez-le en ligne!

C (gcc) , 81 octets

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

Essayez-le en ligne!

Perl 5 -pa , 105 101 octets

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

Essayez-le en ligne!

05AB1E , 12 octets

$×8j.r2äIý3ô

Utilisé 0pour les mines, les espaces pour les carrés vides. Génère une liste de lignes, qui est assez imprimée dans les TIO ci-dessous en se joignant au délimiteur de nouvelle ligne ( »).

Essayez-le en ligne ou vérifiez quelques cas de test supplémentaires à la fois .

Explication:

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

Alternative de 12 octets :

[email protected]š5._3ô

Utilise 1pour les mines, 0pour les carrés vides. Produit une matrice de chiffres, qui est assez imprimée dans les TIO ci-dessous en joignant chaque ligne, puis ces lignes avec un délimiteur de nouvelle ligne ( J»).

Essayez-le en ligne ou vérifiez quelques cas de test supplémentaires à la fois .

Explication:

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)