Buscaminas es un popular juego de rompecabezas en el que debes descubrir qué fichas son "minas" sin hacer clic en esas fichas. Cada ficha es una mina (representada por *
) o una pista, es decir, un número del 0 al 8 que representa cuántas de las 8 fichas vecinas son minas. Su tarea hoy es tomar una tabla que contenga las minas y completar todas las pistas. Por ejemplo, mira el siguiente tablero de 5x4, con 5 minas:
*
* *
*
*
Después de completar las pistas, el tablero se verá así:
2*211
*33*1
12*32
0112*
Detalles
Debe escribir un programa completo o una función que incluya una cuadrícula de caracteres que contenga solo espacios y asteriscos y genere otra cuadrícula donde cada espacio se reemplace con el número de minas adyacentes (asteriscos). Cualquiera de estos son formatos aceptables para sus cuadrículas:
Una cadena con líneas nuevas
Una lista 2D de caracteres / cadenas de caracteres individuales
Una lista de cadenas
Puede suponer que la cuadrícula será al menos 1x1, aunque es posible que sea todas las minas o todos los espacios.
La cuadrícula de entrada siempre se rellenará con el número apropiado de espacios. Como de costumbre, este es el código de golf , por lo que se aplican las lagunas estándar y gana la respuesta más corta en bytes.
Muestra IO
Para que pueda ver el espacio en blanco, mostraré todas las muestras de E / S con paréntesis.
Input:
[ * ]
[* ]
[ ]
[ ]
[ ** ]
[ * * ]
Output:
[1101*1]
[*10111]
[110000]
[012210]
[12**21]
[1*33*1]
Input:
[****]
[****]
Output:
[****]
[****]
Input:
[ ]
[ ]
[ ]
[ ]
Output:
[000]
[000]
[000]
[000]
Input:
[* ]
[** ]
[ ]
[ *]
Ouput:
[*310]
[**10]
[2221]
[001*]
Input:
[** ]
[* *]
[ * ]
[ ]
[* ]
[**** ]
Output:
[**1011]
[*4211*]
[12*111]
[121100]
[*43210]
[****10]
Input:
[ * ]
[ * ]
[ * ]
[** *** ]
[ *** ]
[ ]
[ ** ]
[ * * ]
[* ** ]
[ ** ]
Output:
[00001*1111]
[00002221*1]
[22102*4321]
[**102***31]
[221013***1]
[0000013542]
[0112111**1]
[12*2*12442]
[*212112**2]
[1100002**2]
fuente
Respuestas:
MATL ,
1817 bytesGracias a @ mbomb007 por una corrección en la entrada del caso de prueba 6
La entrada es una matriz de caracteres 2D, en el formato
Pruébalo en línea!
Casos de prueba: 1 , 2 , 3 , 4 , 5 , 6 .
Explicación
fuente
JavaScript (ES6),
11496 bytesEditar: guardado 18 bytes gracias a una idea de @ETHproductions.
fuente
a=>a.map((s,i)=>s.replace(/ /g,(_,j)=>a.slice(i-!!i,i+2).reduce((t,s)=>t+(q=i=>s[i+j]>' ')(-1)+q(0)+q(1),0)))
R,
127112 bytesgracias a @gtwebb y @ sebastian-c por las mejoras.
Puntos notables:
Las matrices son vectores en R. No necesita indexación 2D para extraer elementos.
seq(M)
devolverá una secuencia de la misma "longitud" (filas x columnas) queM
.No se pueden mezclar índices de extracción positivos y negativos en R. El
M[-3]
código R es legítimo, pero no es lo que se desea.La entrada tiene la forma de una matriz R. Algunos ejemplos:
fuente
T
lugar deTRUE
. Me las arreglé para deslizar algunas llaves de una de las funciones if también:f=function(M){a=nrow(M);b=ncol(M);for(i in seq(M))if(M[i]!="*")M[i]=sum(M[pmax(i+c(-1,1,-a+-1:1,a+-1:1),0)]=="*",na.rm=T);M}
b=ncol(M)
y luego no lo usa para poder deshacerse de eso.M->{a=nrow(M);p=M=='*';M[]=ifelse(p,'*',sapply(seq(M),i->sum(p[pmax(i+c(-1,1,-a+-1:1,a+-1:1),0)],na.rm=T)))}
- sin embargo, esto engaña un poco porque requiere una<-
lambda redefinida , ver klmr / funcional / lambdaJava, 190 bytes
Editar:
Snipet
Sin golf:
Ideónalo.
fuente
x,y,i,j
c[i][j]==32
y así sucesivamente, y simplemente los cambié en la parte de Ungolfed0000*1\n*10011\n110000\n000000\n00**10\n0*22*1
. ¿Podría agregar un enlace de prueba de ideone.com? EDITAR: Además, a menos que yo mismo esté haciendo algo mal, su salida de código de golf:ssss0s\n0sssss\nssssss\nssssss\nss00ss\ns0ss0s
para el primer caso de prueba (ha reemplazado todo*
con ceros ...): SJavaScript (ES6), 107
Entrada / salida como un conjunto de cadenas
tenga en cuenta que cuando se llama a la función s con un elemento de la lista l fuera de los límites, el parámetro
a
esundefined
yc+a
resultará" undefined"
gracias a las extrañas reglas de conversión de javascriptMás legible
fuente
Python 2, 138 bytes
Define una función
f
que acepta una cadena de entrada comoe imprime una cadena en STDOUT:
fuente
enumerate(s,2)
) y reemplace todas las apariciones dei + 2
withi
yi - 1
withi - 3
. Eso reducirá un par de bytes.JavaScript (ES6)
186182177161152 bytesActualizar
El código anterior para
" *"
devoluciones"2*"
. Esto se soluciona en el siguiente script.168167 bytesPruébalo aquí
fuente
t+=(a[x+i%3-1]||[])[y+i/3-1|0]==k
debería funcionar de manera similar y ahorrarle la partetry
/catch
.(a[x+i%3-1]||1)[y+i/3-1|0]
.Haskell, 115 bytes
Define una función
f
en listas de cadenasfuente
Python 2, 192 bytes
-3 bytes gracias a Copper, -10 bytes si se permite modificar la cuadrícula de entrada, otros -11 bytes
continue
eliminando y otros -12 bytes para eliminar la variable del contadorUtiliza una lista de caracteres
L
y crea una versión acolchadaK
, por lo que no hay problema en los límites. La sangría esUso:
fuente
if'*'==L[y][x]:
para guardar un byte.r=range;
en la misma línea quen,S,s
, puede guardar cinco caracteres reemplazando las llamadasrange(...)
conr(...)
.ange
por lo que 8 bytes, pero tengo que agregar,r
y,range
que también es de 8 bytes, por lo que no se gana nada.range
.Ruby, 112
Toma y devuelve una cadena. La cadena debe estar separada por nueva línea y terminada por nueva línea.
en programa de prueba
fuente
TSQL
292291 bytesGolfizado:
Sin golf:
Violín
fuente
;
al principio de su código? Parece que lo has contado.Raqueta 415 bytes
Sin golf:
Prueba (enumera como una sola cadena con el número de columna especificado; también funcionará con espacios):
Salida:
fuente
PHP,
145133132127 bytestoma la entrada como una sola cadena, nueva línea separada. Corre con
-r
.Descompostura
fuente
"!">$n=$s[$p]
en lugar de" "==$n=$s[$p]
Turtlèd , 99 bytes
(whoops sigo olvidando el enlace: |)
Toma entradas con corchetes alrededor de cada línea
Turtlèd no puede tomar entradas de varias líneas, por lo tanto, después de la última línea, escriba
|
al final de la señal de entradaTenga en cuenta que los corchetes no coinciden porque los corchetes abiertos analizan el siguiente carácter como parte del comando de corchetes
Pruébalo en línea!
Cómo funciona (descripción general):
Hasta que
|
se ingresa, escribe la entrada en cada línea, con corchetes para ayudarlo a reconocer el final de cada línea. Después de que eso ha sucedido, vuelve a la parte superior de la entrada. Pasa por cada carácter en la entrada. Si es un espacio, mira alrededor del espacio, agregando uno al contador por cada bomba que encuentre. después de cada línea, elimina los corchetes. Cuando llega a la última línea, con el | en él, se detiene y elimina el |. la cuadrícula se imprime implícitamente.fuente
C,
152150147145 bytesLa entrada tiene la forma de una matriz bidimensional de caracteres, seguida del número de filas y columnas. El resultado será devuelto en su lugar.
(Principalmente) Sin golfos:
El enfoque es directo: haga un bucle sobre cada posición, haga un bucle sobre sus vecinos y sume todos los asteriscos. Hay dos trucos a nivel de bits:
Cuando estamos decidiendo si una celda es un asterisco o no, simplemente podemos verificar si el bit de ocho lugares está establecido, porque el número en la celda debe ser menor que 8 (el valor máximo de la celda).
Podemos convertir un carácter de espacio en un carácter cero OR-ing 16.
Editar: Golfed dos bytes mediante el uso de
/
en lugar de>=
.Editar: Otros cinco bytes invirtiendo la dirección de los bucles.
fuente
C #, 341 bytes
Una implementación ingenua que definitivamente se puede acortar.
fuente
Python 2, 183 bytes
fuente