Tout le monde connaît l'ancien jeu de dragueur de mines fourni avec Windows XP. Il s'agit d'une simple grille avec une matrice de cellules 9x9 contenant soit un nombre (indiquant le nombre de mines adjacentes), soit une mine.

Le défi est de générer une grille aléatoire 9x9 avec 10 bombes avec n'importe quelle valeur de départ entière (jusqu'à ce que soit le plus grand int de votre machine / langage) avec des points brownie si vous implémentez le PRNG vous-même

exemple de sortie: les cellules contiennent les chiffres 0-8 ou * pour les mines

*101*1000
110111000
123210000
1***10000
123210011
00000002*
00000114*
000112*3*
0001*2121

Le code le plus court en octets gagne .. règles standard etc, etc.

Dyalog APL, 40 octets

⎕rl←1⋄(1,¨a)⍕¨{⍉3+/0,⍵,0}⍣2⊢a←9 9⍴9≥?⍨81

(suppose ⎕io←0 )

l' 1en ⎕rl←1est la graine

de droite à gauche:

?⍨81est identique à 81?81- une permutation aléatoire

9≥ résulte en un masque de bits contenant dix 1 à des positions aléatoires, le reste est 0

a←9 9⍴ remodeler en un carré de 9 par 9 et l'appeler "a"

{ }⍣2 procédez comme suit deux fois:

⍉3+/0,⍵,0 fenêtre glissante somme de 3 colonnes (supposons 0 à l'extérieur), puis transposition

(1,¨a)⍕¨est format (convertir en chaîne) chacun. L'argument de gauche pour ⍕spécifie le nombre total de caractères et de caractères fractionnaires dans le résultat. S'il ⍕ne peut pas formater selon cette spécification, il génère un *- une heureuse coïncidence pour ce problème. asera 1 là où se trouvent les mines - il est impossible d'essayer d'intégrer une partie entière et fractionnée en un seul caractère, donc celles-ci apparaîtront comme l' *art.

MATLAB, 94 93 octets

rng(input(''));x(9,9)=~1;x(randperm(81,10))=1;y=[conv2(+x,ones(3),'s')+48 ''];y(x)=42;disp(y)

Exemple d'exécution (la première ligne après le code est l'entrée saisie par l'utilisateur):

>> rng(input(''));x(9,9)=~1;x(randperm(81,10))=1;y=[conv2(+x,ones(3),'s')+48 ''];y(x)=42;disp(y)
99
*10001*2*
220001232
*201111*1
*312*1111
12*211000
011211000
0001*1000
000112110
000001*10

Explication

rng(input(''));

prend un entier et l'utilise comme graine. (Cela fonctionne dans les versions MATLAB modernes. Les anciennes versions peuvent nécessiter une syntaxe différente.)

x(9,9)=~1;

assigne logique 0, ou false(obtenu en niant logiquement 1) à l'entrée (9,9)d'une matrice x. Les autres entrées sont également automatiquement initialisées en logique 0.

x(randperm(81,10))=1; 

ayants 1(autoomatically coulés à logique 1ou true) à 10des 81entrées de x, choisis de manière aléatoire sans remplacement. Ces entrées sont celles qui contiennent des bombes.

conv2(+x,ones(3),'s')

est une abréviation de conv2(+x,ones(3),'same'). Il convole la matrice x(qui doit être convertie en double, utilisant +) avec un voisinage 3 × 3 contenant 1. Cela compte le nombre de bombes adjacentes à chaque entrée. Pour les entrées qui contiennent une bombe, elle inclut cette bombe, mais la valeur y sera remplacée plus tard.

y=[...+48 ''];

ajoute 48 à la valeur, pour convertir le nombre en code ASCII. La concaténation avec la matrice vide convertit ces codes ASCII en caractères.

y(x)=42;

attribue 42 (code ASCII pour '*') aux positions des bombes. Ces positions sont données par x, qui est ici utilisé comme index logique.

disp(y)

affiche le résultat.

Javascript (ES6), 204 ou 198 octets

PRNG personnalisé (204 octets)

s=>(p=-1,S=n=>(x=p%9-(n+=p)%9)*x-64&&b[n]=='*',T=n=>S(n)+S(-n),b=[...'*00000000'.repeat(9)]).sort(_=>(s=(22695477*s+1)>>>0)&1||-1).map(c=>(p++,c=='0'?T(1)+T(8)+T(9)+T(10):c)).join``.match(/.{9}/g).join`
`

Ce code utilise un générateur linéaire congruentiel avec multiplicateur 22695477et incrément 1(c'est l'implémentation Borland C / C ++).

En raison de la faible efficacité du PRNG pendant sa phase de préchauffage, j'ai dû placer une bombe par ligne (au lieu de 10 au début ou 10 à la fin de la matrice non mélangée). Donc, il n'y a que 9 bombes. Je peux essayer de résoudre ce problème plus tard.

De plus, il doit y avoir un moyen plus simple / plus court de traiter le chèque «hors carte», (x=p%9-(n+=p)%9)*x-64mais je ne peux pas le comprendre pour le moment.

Utilisation de Math.random () (198 octets)

s=>(p=-1,S=n=>(x=p%9-(n+=p)%9)*x-64&&b[n]=='*',T=n=>S(n)+S(-n),b=[...'**********'+'0'.repeat(71)]).sort(_=>Math.random()-.5).map(c=>(p++,c=='0'?T(1)+T(8)+T(9)+T(10):c)).join``.match(/.{9}/g).join`
`

Celui-ci comprend 10 mines comme demandé.

Démo

let f =
_=>(p=-1,S=n=>(x=p%9-(n+=p)%9)*x-64&&b[n]=='*',T=n=>S(n)+S(-n),b=[...'**********'+'0'.repeat(71)]).sort(_=>Math.random()-.5).map(c=>(p++,c=='0'?T(1)+T(8)+T(9)+T(10):c)).join``.match(/.{9}/g).join`
`
console.log(f())

Python 2, 269 266 264 octets

from random import*
seed(input())
z=1,0,-1
n=range(9)
m=[[0]*9 for _ in n]
for x,y in sample([[x,y]for x in n for y in n],10):
 m[x][y]=-9
 for a in z:
  for b in z:
    if 0<=x+a<9>0<=y+b<9:m[x+a][y+b]+=1 # it gets displayed as 4 spaces, but the beginning of this line is a single tab
print("\n".join("".join([`c`,'*'][c<0]for c in l)for l in m))

Essayez-le sur ideone.com

Enregistré 2 octets grâce à Aaron.

Très probablement encore jouable au golf.

Explication

randomest importé pour être utilisé seedpour amorcer le PRNG et samplepour sélectionner au hasard dix emplacements de bombes. mest une matrice 9 x 9 qui sauve la carte. Pour chacun des emplacements des bombes, l'entrée correspondante dans mest définie sur -9et toutes les entrées voisines sont incrémentées. De cette façon m, on obtient le nombre de bombes adjacentes pour les cellules non bombes et un nombre négatif pour les cellules bombes. Les finales printimprime la planche tout en parcourant toutes les lignes ldans met toutes les cellules cdans l.

R, 187 octets

set.seed();x=1:121;y=x[!(x%%11 %in% 0:1|(x-1)%/%11 %in% c(0,10))];z=sample(y,10);x=x*0;for(t in z){p=t+c(-10:-12,-1,1,10:12);x[p]=x[p]+1};x[z]=9;m=data.frame(matrix(x[y],9));m[m==9]='*';m

Essayez-le sur Ideone

Explication:

set.seed() prendre une graine cst.

x est l'indice d'une matrice 11 * 11

y est l'indice de la matrice 9 * 9 dans la matrice 11 * 11

z est l'indice de la bombe

x=x*0 initialiser la valeur de la matrice

La boucle ajoute 1 à x en cas de bombe adjacente.

JavaScript ES6, 244 octets

f=(a=[...Array(11)].map(_=>Array(11).fill(0)),n=10,r=_=>Math.random()*9|0,x=r(),y=r())=>a[x+1][y+1]>8||[0,1,2].map(i=>[0,1,2].map(j=>a[x+i][y+j]++),a[x+1][y+1]=9)&&--n?f(a,n):a.slice(1,-1).map(a=>a.slice(1,-1).map(n=>n<9?n:`*`).join``).join`
`
;o.textContent=f()

<pre id=o>

Rubis , 181 194 183 + 1 = 184 octets

J'ai oublié de mettre la graine, whoops. Utilise le-n drapeau.

Essayez-le en ligne!

srand$_.to_i
a=[0]*81
[*0..80].sample(10).map{|i|w=i%9;h=i/9;a[i]=-99
(r=-1..1).map{|x|x+=w
x<0||x>8?0:r.map{|y|y+=h
y<0||y>8?0:a[9*y+x]+=1}}}
puts a.map{|c|c<0??*:c}.join.scan /.{9}/

Python 2 , 172 octets

from random import*
seed(input())
r=range
b=set(sample(r(81),10))
for j in r(9):print''.join([[`len({x-10,x-9,x-8,x-1,x+1,x+8,x+9,x+10}&b)`,'*'][x in b]for x in r(j,81,9)])

Essayez-le en ligne!