Tutti conoscono il vecchio gioco dragamine fornito con Windows XP. È una griglia semplice con una matrice di celle 9x9 contenente un numero (che indica quante mine sono adiacenti ad essa) o una miniera.

La sfida è quella di generare una griglia casuale 9x9 con 10 bombe dati qualsiasi seme intero (fino a qualunque sia l'int più grande della tua macchina / lingua) con punti brownie se implementi il ​​PRNG da solo

esempio di output: le celle contengono numeri 0-8 o * per le miniere

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

Vince il codice più breve in byte .. regole standard ecc. Ecc.

Dyalog APL, 40 byte

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

(presume ⎕io←0)

l'in 1in ⎕rl←1è il seme

da destra a sinistra:

?⍨81è uguale a 81?81- una permutazione casuale

9≥ risulta una maschera di bit contenente dieci 1 in posizioni casuali, il resto sono 0

a←9 9⍴ rimodellare in un quadrato 9 per 9 e chiamarlo "a"

{ }⍣2 fai due volte quanto segue:

⍉3+/0,⍵,0 somma della finestra scorrevole di 3 colonne (presuppone 0 all'esterno), quindi trasponi

(1,¨a)⍕¨è formato (converti in stringa) ciascuno. L'argomento sinistro per ⍕specificare il numero totale di caratteri e caratteri frazionari nel risultato. Se ⍕non è possibile formattare in base a tale specifica, viene emesso un *- una coincidenza fortunata per questo problema. asarà 1 dove si trovano le mine - è impossibile cercare di adattare una parte intera e frazionaria in un singolo carattere, quindi quelli appariranno come *s.

MATLAB, 94 93 byte

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

Esempio di esecuzione (la prima riga dopo il codice è l'input digitato dall'utente):

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

Spiegazione

rng(input(''));

prende un numero intero e lo usa come seme. (Funziona nelle moderne versioni MATLAB. Le vecchie versioni potrebbero aver bisogno di una sintassi diversa.)

x(9,9)=~1;

assegna logico 0o false(ottenuto negando logicamente 1) l'ingresso (9,9)di una matrice x. Anche il resto delle voci viene automaticamente inizializzato in logico 0.

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

assegna 1(cast automaticamente a logico 1, o true) 10delle 81voci di x, scelte casualmente senza sostituzione. Queste voci sono quelle che contengono bombe.

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

è un'abbreviazione di conv2(+x,ones(3),'same'). Convolge la matrice x(che deve essere lanciata double, usando +) con un vicinato 3 × 3 contenente 1. Questo conta quante bombe sono adiacenti a ciascuna voce. Per le voci che contengono una bomba include quella bomba, ma il valore verrà sovrascritto in seguito.

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

aggiunge 48 al valore, per convertire dal numero al codice ASCII. La concatenazione con la matrice vuota lancia questi codici ASCII in caratteri.

y(x)=42;

assegna 42 (codice ASCII per '*') alle posizioni delle bombe. Queste posizioni sono indicate da x, che viene qui utilizzato come indice logico.

disp(y)

visualizza il risultato.

Javascript (ES6), 204 o 198 byte

PRNG personalizzato (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`
`

Questo codice utilizza un generatore congruenziale lineare con moltiplicatore 22695477e incremento 1(questa è l'implementazione di Borland C / C ++).

A causa della scarsa efficienza del PRNG durante la sua fase di riscaldamento, ho dovuto posizionare una bomba per fila (invece di 10 all'inizio o 10 alla fine dell'array non mischiato). Quindi, ci sono solo 9 bombe. Potrei provare a risolverlo più tardi.

Inoltre, ci deve essere un modo più semplice / più breve di elaborare il controllo "fuori bordo", (x=p%9-(n+=p)%9)*x-64ma non riesco proprio a capirlo adesso.

Utilizzo di Math.random () (198 byte)

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

Questo include 10 mine come richiesto.

dimostrazione

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 byte

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

Provalo su ideone.com

Salvato 2 byte grazie ad Aaron.

Molto probabilmente ancora golfabile.

Spiegazione

randomviene importato per essere utilizzato seedper seminare il PRNG e sampleper selezionare dieci ubicazioni di bombe in modo casuale. mè una matrice 9 x 9 che salva la scheda. Per ciascuna delle posizioni della bomba, la voce corrispondente in mviene impostata su -9e tutte le voci vicine vengono incrementate. In questo modo mfinisce per contenere il conteggio delle bombe adiacenti per le celle non bomba e un numero negativo per le celle bomba. Le ultime printstampe dell'intero bordo scorrendo tutte le linee lin me tutte le celle cin l.

R, 187 byte

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

Provalo su Ideone

Spiegazione:

set.seed() prendi un seme cst.

x è l'indice per una matrice 11 * 11

y è l'indice della matrice 9 * 9 nella matrice 11 * 11

z è l'indice della bomba

x=x*0 inizializza il valore della matrice

Il loop aggiunge 1 a x in caso di bomba adiacente.

JavaScript ES6, 244 byte

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>

Rubino , 181 194 183 + 1 = 184 byte

Ho dimenticato di impostare effettivamente il seme, whoops. Usa la -nbandiera.

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

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

Provalo online!