Jeder kennt das alte Minensuchspiel, das mit Windows XP geliefert wurde. Es ist ein einfaches Gitter mit einer 9x9-Matrix von Zellen, die entweder eine Zahl (die angibt, wie viele Minen sich daneben befinden) oder eine Mine enthält.

Die Herausforderung besteht darin, ein zufälliges 9x9-Raster mit 10 Bomben zu generieren, wenn Sie einen beliebigen ganzzahligen Startwert (bis zu dem, was der größte Startwert Ihrer Maschine / Sprache ist) mit Brownie-Punkten erhalten, wenn Sie das PRNG selbst implementieren

Beispielausgabe: Zellen enthalten entweder die Ziffern 0-8 oder * für Minen

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

Kürzester Code in Bytes gewinnt .. Standardregeln etc, etc ..

Dyalog APL, 40 Bytes

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

(nimmt an ⎕io←0)

das 1 In ⎕rl←1ist der Same

von rechts nach links:

?⍨81 ist das gleiche wie 81?81 - eine zufällige Permutation

9≥ führt zu einer Bitmaske mit zehn Einsen an zufälligen Positionen, der Rest sind Nullen

a←9 9⍴ verwandle dich in ein 9-mal-9-Quadrat und nenne es "a"

{ }⍣2 mache zweimal folgendes:

⍉3+/0,⍵,0 Schiebefenstersumme von 3 Spalten (0s außerhalb annehmen), dann transponieren

(1,¨a)⍕¨ist jeweils das Format (in Zeichenfolge konvertieren). Das linke Argument für ⍕gibt die Gesamtzahl der Zeichen und Bruchzeichen im Ergebnis an. Wenn ⍕es nicht möglich ist, nach dieser Spezifikation zu formatieren, gibt es a aus *- ein glücklicher Zufall für dieses Problem. awird 1 sein, wo die Minen sind - es ist unmöglich, ein ganzes und einen Bruchteil in ein einzelnes Zeichen zu passen, daher werden diese als *s angezeigt.

MATLAB, 94 93 Bytes

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

Beispiellauf (die erste Zeile nach dem Code ist die vom Benutzer eingegebene Eingabe):

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

Erläuterung

rng(input(''));

Nimmt eine ganze Zahl und verwendet sie als Startwert. (Dies funktioniert in modernen MATLAB-Versionen. Alte Versionen benötigen möglicherweise eine andere Syntax.)

x(9,9)=~1;

ordnet logische 0oder false(durch logische Negierung erhalten 1zu dem Eintrag) (9,9)eine Matrix x. Die restlichen Einträge werden automatisch auch logisch 0initialisiert.

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

ordnet 1(automatisch umgewandelt in logisch 1oder true) 10den 81Einträgen zu x, die nach dem Zufallsprinzip ausgewählt wurden, ohne sie zu ersetzen. Diese Einträge enthalten Bomben.

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

ist eine Abkürzung von conv2(+x,ones(3),'same'). Es faltet die Matrix x(in die gegossen doublewerden muss +) mit einem 3 × 3-Nachbarschaftsgehalt zusammen 1. Dies zählt, wie viele Bomben sich neben jedem Eintrag befinden. Einträge, die eine Bombe enthalten, enthalten diese Bombe, der Wert wird jedoch später überschrieben.

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

Addiert 48 zum Wert, um von Zahl in ASCII-Code zu konvertieren. Durch die Verkettung mit der leeren Matrix werden diese ASCII-Codes in Zeichen umgewandelt.

y(x)=42;

weist '*'den Positionen der Bomben 42 (ASCII-Code für ) zu. Diese Positionen sind gegeben durch x, was hier als logischer Index verwendet wird.

disp(y)

zeigt das Ergebnis an.

Javascript (ES6), 204 oder 198 Bytes

Benutzerdefiniertes PRNG (204 Byte)

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`
`

Dieser Code verwendet einen linearen Kongruenzgenerator mit Multiplikator 22695477und Inkrement 1(dies ist die Borland C / C ++ - Implementierung).

Aufgrund der schlechten Effizienz des PRNG während seiner Aufwärmphase musste ich eine Bombe pro Reihe platzieren (anstelle von 10 am Anfang oder 10 am Ende des nicht gemischten Arrays). Es gibt also nur 9 Bomben. Ich kann versuchen, das später zu beheben.

Außerdem muss es eine einfachere / kürzere Möglichkeit geben, den "Out-of-Board" -Scheck zu verarbeiten, (x=p%9-(n+=p)%9)*x-64aber ich kann es gerade nicht herausfinden.

Verwenden von Math.random () (198 Bytes)

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`
`

Dieser beinhaltet 10 Minen wie gewünscht.

Demo

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 Bytes

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

Probieren Sie es auf ideone.com

2 Bytes gespart dank Aaron.

Höchstwahrscheinlich noch golffähig.

Erläuterung

randomwird importiert, seedum das PRNG zu säen und samplezehn Bombenstandorte zufällig auszuwählen. mist eine 9 x 9 Matrix, die das Board speichert. Für jede der Bombenpositionen wird der entsprechende Eintrag in auf mgesetzt -9und alle benachbarten Einträge werden inkrementiert. Auf diese Weise erhalten Sie mdie Anzahl benachbarter Bomben für Nicht-Bomben-Zellen und eine negative Zahl für Bomben-Zellen. Das endgültige printdruckt das ganze Brett durch Iterieren durch alle Linien lin mund alle Zellen cin l.

R, 187 Bytes

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

Probieren Sie es auf Ideone

Erläuterung:

set.seed() nimm einen samen.

x ist der Index für eine 11 * 11-Matrix

y ist der Index der 9 * 9-Matrix in der 11 * 11-Matrix

z ist der Index der Bombe

x=x*0 Initialisieren Sie den Matrixwert

Die Schleife addiert 1 zu x im Falle einer benachbarten Bombe.

JavaScript ES6, 244 Bytes

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>

Ruby , 181 194 183 + 1 = 184 Bytes

Ich habe vergessen, den Samen tatsächlich zu setzen, hoppla. Verwendet die -nFlagge.

Probieren Sie es online!

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 Bytes

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

Probieren Sie es online!