Démineur au travail

18

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.

entrez la description de l'image ici

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.

Aaron
la source
3
Vous devez indiquer la signification des chiffres :)
Nathan Merrill
4
Microsoft Minesweeper est bien plus ancien que XP et les jeux de type dragueur de mines remontent au moins aux années 60.
AdmBorkBork
11
De plus, je n'ai pas le temps de jouer au démineur au travail - je suis trop occupé sur PPCG. ;-)
AdmBorkBork
1
Qu'est-ce qui compte exactement comme un PRNG? Combien de configurations différentes doit-elle pouvoir produire? Ne pouvons-nous pas utiliser la graine et générer simplement une configuration différente à chaque fois, si notre langue a un PRNG qui est automatiquement initialisé en une graine "aléatoire"?
Luis Mendo
1
@TimmyD Mais la version de XP est la première version à avoir une grille 9x9. Tout ce qui est plus ancien utilise une grille 8x8 pour les débutants. #outnerded;)
mbomb007

Réponses:

3

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.

ngn
la source
Pouvez-vous expliquer l' ⎕io←0hypothèse? Je ne connais pas Dyalog APL ...
Aaron
1
Les indices de tableau dans Dyalog sont basés sur 1 par défaut. Régler ⎕io("l' origine de l'index ") sur 0 les rend basés sur 0 et modifie certaines primitives en conséquence, par exemple le ⍳3sera 0 1 2, non 1 2 3. Cela peut être fait par programme ( ⎕io←0) ou à partir des préférences de l'interface graphique. Avoir ce choix est une erreur vieille de 50 ans qui divise encore la petite communauté APL d'aujourd'hui.
2017
5

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.

Luis Mendo
la source
4

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

Arnauld
la source
'**********'+'0'est égal à '**********'+0; qui enregistre deux octets sur la version 198 octets.
Paul Schmitz
@PaulSchmitz - Malheureusement, cela '0'est censé se répéter et 0.repeat()ne fonctionnera pas.
Arnauld
Oups, je pensais que ce serait exécuté comme ...('**********'+0).repeat(71). Pardon.
Paul Schmitz
3

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.

LévitationLion
la source
À quoi sert exactement «aléatoire», exactement?
clismique
@ Qwerp-Derp probablement pour amorcer le générateur de nombres aléatoires indirectement utilisé parsample()
Patrick Roberts
économisez 2 octets en mélangeant les retraits de tabulation dans le for a in z:bloc (uniquement python 2.x)
Aaron
3

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.

YCR
la source
1
Je pense que vous devez prendre l'argument de set.seed () en entrée.
BLT
2

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>

Neil
la source
Vous voudrez peut-être préciser quelle partie est votre code.
NoOneIsHere
@NoOneIsHere Les 244 premiers octets, espérons-le ;-) La première ligne devrait faire 242 octets, puis il y a la nouvelle ligne et le `caractère.
Neil
1

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}/
Encre de valeur
la source
0

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!

tsh
la source