Todos conocen el antiguo juego de buscaminas que se incluye con Windows XP. Es una cuadrícula simple con una matriz de celdas de 9x9 que contiene un número (que indica cuántas minas hay adyacentes) o una mina.

El desafío es generar una cuadrícula aleatoria de 9x9 con 10 bombas con cualquier semilla entera (hasta lo que sea el int más grande de su máquina / idioma) con puntos de brownie si implementa el PRNG usted mismo

salida de ejemplo: las celdas contienen números 0-8 o * para minas

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

El código más corto en bytes gana ... reglas estándar, etc., etc.

Dyalog APL, 40 bytes

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

(asume ⎕io←0)

el 1en ⎕rl←1es la semilla

de derecha a izquierda:

?⍨81es lo mismo que 81?81- una permutación aleatoria

9≥ da como resultado una máscara de bits que contiene diez 1s en posiciones aleatorias, el resto son 0s

a←9 9⍴ remodelar a un cuadrado de 9 por 9 y llamarlo "a"

{ }⍣2 haz lo siguiente dos veces:

⍉3+/0,⍵,0 ventana deslizante suma de 3 columnas (suponga 0s afuera), luego transponga

(1,¨a)⍕¨es formato (convertir a cadena) cada uno. El argumento izquierdo para ⍕especifica el número total de caracteres y caracteres fraccionarios en el resultado. Si ⍕no puede formatear de acuerdo con esa especificación, genera una *- una coincidencia afortunada para este problema. aserá 1 donde están las minas; es imposible tratar de encajar una parte entera y fraccional en un solo carbón, por lo que aparecerán como *s.

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)

Ejemplo de ejecución (la primera línea después del código es la entrada escrita por el usuario):

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

Explicación

rng(input(''));

toma un número entero y lo usa como semilla. (Esto funciona en versiones modernas de MATLAB. Las versiones antiguas pueden necesitar una sintaxis diferente).

x(9,9)=~1;

asigna lógico 0u false(obtenido negando lógicamente 1) a la entrada (9,9)de una matriz x. El resto de las entradas también se inicializan automáticamente a lógico 0.

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

asigna 1(automáticamente convertido a lógico 1, o true) a 10las 81entradas de x, elegidas al azar sin reemplazo. Estas entradas son las que contienen bombas.

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

es una abreviatura de conv2(+x,ones(3),'same'). Convoluciona la matriz x(que necesita ser convertida double, usando +) con una vecindad de 3 × 3 que contiene 1. Esto cuenta cuántas bombas hay adyacentes a cada entrada. Para las entradas que contienen una bomba, incluye esa bomba, pero el valor allí se sobrescribirá más adelante.

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

agrega 48 al valor, para convertir de número a código ASCII. La concatenación con la matriz vacía convierte estos códigos ASCII en caracteres.

y(x)=42;

asigna 42 (código ASCII para '*') a las posiciones de las bombas. Estas posiciones están dadas por x, que aquí se usa como un índice lógico.

disp(y)

Muestra el resultado.

Javascript (ES6), 204 o 198 bytes

PRNG personalizado (204 bytes)

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

Este código está utilizando un generador congruencial lineal con multiplicador 22695477e incremento 1(esta es la implementación de Borland C / C ++).

Debido a la pobre eficiencia del PRNG durante su fase de calentamiento, tuve que colocar una bomba por fila (en lugar de 10 al principio o 10 al final de la matriz sin mezclar). Entonces, solo hay 9 bombas. Puedo tratar de arreglar eso más tarde.

Además, debe haber una forma más simple / más corta de procesar la verificación 'fuera de borda', (x=p%9-(n+=p)%9)*x-64pero no puedo resolverlo en este momento.

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

Este incluye 10 minas según lo solicitado.

Manifestación

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

Pruébalo en ideone.com

Guardado 2 bytes gracias a Aaron.

Lo más probable es que sea golfable.

Explicación

randomse importa para usar seedpara sembrar el PRNG y sampleseleccionar diez ubicaciones de bombas al azar. mes una matriz de 9 x 9 que salva el tablero. Para cada una de las ubicaciones de bombas, la entrada correspondiente en mse establece en -9y todas las entradas vecinas se incrementan. Esta forma mtermina conteniendo el recuento de bombas adyacentes para las células que no son bombas y un número negativo para las células de la bomba. Las últimas printimpresiones de todo el tablero por iteración a través de todas las líneas len my todas las células cen 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

Pruébalo en Ideone

Explicación:

set.seed() tomar una semilla cst.

x es el índice para una matriz 11 * 11

y es el índice de la matriz 9 * 9 en la matriz 11 * 11

z es el índice de la bomba

x=x*0 inicializar el valor de la matriz

El bucle agrega 1 a x en caso de bomba adyacente.

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>

Rubí , 181 194 183 + 1 = 184 bytes

Se olvidó de establecer la semilla, whoops. Usa la -nbandera.

Pruébalo en línea!

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

Pruébalo en línea!