Ver también: Haz un movimiento en un tablero Go .
Tarea
Go es un juego de mesa en el que dos jugadores (blanco y negro) colocan piedras en las intersecciones de las líneas de la cuadrícula en un tablero de 19 × 19. Las negras se mueven primero, por ejemplo, en D4:
En este desafío, debe tomar una coordenada de tablero Go D4
como entrada, y generar una representación ASCII de un tablero con el primer movimiento jugado en el punto dado.
Tenga en cuenta que no hay una columna I. Esto es, históricamente, para reducir la confusión con J y L.
Esta salida consta de 19 líneas, cada una con 19 caracteres. El punto con la piedra está marcado O
. Puntos vacíos en el tablero se muestran como .
, a excepción de los nueve puntos de la estrella (en D4
, D10
, D16
, K4
, K10
, K16
, Q4
, Q10
, y Q16
), que están marcados *
.
Por ejemplo, dada F5
como entrada, la salida de su respuesta debe ser:
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
.....O.............
...*.....*.....*...
...................
...................
...................
Y dado Q16
como entrada, su salida debe ser:
...................
...................
...................
...*.....*.....O...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
Reglas
Puede escribir una función que tome la coordenada como argumento, o un programa que lea la coordenada desde la línea de comando o desde
STDIN
.Puede elegir aceptar entradas en minúsculas o mayúsculas, pero su respuesta no necesita manejar ambas.
La entrada siempre es una sola cadena como
a1
oT19
, nunca una cadena + número o dos cadenas.Si escribe un programa completo, su respuesta debe imprimirse
STDOUT
como una cadena, opcionalmente seguida de una nueva línea final. Si su respuesta es una función, es posible imprimir enSTDOUT
, o devolver una cadena, o devolver una matriz / lista de cadenas (filas), o devolver una matriz bidimensional o lista anidada de caracteres.Este es el código de golf . La respuesta más corta en bytes gana.
f("G", 14)
¿correcto?Respuestas:
MATL , 33 bytes
Pruébalo en línea!
Explicación
fuente
C,
21219519318117113210398 bytesGuardado 1 byte gracias a @FryAmTheEggman, 5 bytes gracias a @orlp
Llama
f()
con la posición para jugar (debe estar en mayúscula) e imprime el tablero resultante.Pruébalo con ideone .
fuente
putchar(i%20?i^20*atoi(p+1)+64-*p+(*p>72)?i%6^4|i/20%6^3?46:42:79:10)
C (gcc)
132128109Ideona
Una función que imprime el tablero en STDOUT. Requiere que la coordenada de la letra sea mayúscula. La impresión en un bucle parece ser ligeramente más corta que el enfoque de bucle anidado anterior.
fuente
MATLAB, 135 bytes
Un primer intento, nada inteligente, solo para ver cuánto mejor pueden hacer los demás:
Uso:
fuente
a=input('');
); eliminar nuevas líneas; cambiar'*'
hacia42
y'0'
hacia48
; reemplazarend
por19
; reste el valor lógico directamente en lugar de laif
rama. De hecho, puede reemplazar las últimas cinco líneas porb(20-a(2),a(1)-64-(a(1)>8))=48
Ruby,
9391 bytesToma entrada en la línea de comando, por ejemplo
$ ruby script.rb Q16
.Pruébelo en repl.it (envuelto en una lambda allí ya que repl.it no toma argumentos de línea de comando: https://repl.it/CkvT/1
Sin golf
fuente
$><<
lugar deputs
. Aunque no estoy seguro.Ir,
319286 bytesProbablemente golfable renunció un poco, soy un principiante
fuente
part
ap
?Ruby,
130128121 + 3 (-n
flag) = 124 bytesCambiado
-p
a-n
porqueputs b
es un byte más corto que$_=b*$/
fuente
Python,
148145136130121119116 Bytes-3 Bytes gracias a @RootTwo
función lambda anónima, toma la entrada de la forma "A1" (letras grandes) y genera una lista de listas de caracteres (len == 1 cadenas en Python)
fuente
".*oo"[2*(j==ord(x[0])-(x[0]>"I")-65and int(x[1:])==i+1)+(i%6==j%6==3)]
lugar de"o"if...else"*"if...else"."
(x>'I')
lugar de(x[0]>'I')
guardar 3 bytes más.> <> ,
9896 bytesTenga en cuenta que hay una
0x14
en la primera fila después de la primera'
, y una0x19
entre la9
y la primera^
de la última línea. Pruébalo en línea!La entrada se asigna de manera que se
A-T
convierta1-19
(con 0 que denota una columna imaginaria de "nueva línea") y el número de fila entero se disminuye en 1. El programa realiza un bucle desde 379 hasta 0, eligiendo un carácter de la fila inferior a medida que avanza ( compensado por 15, para tener en cuenta el hecho de que no puede ingresar una nueva línea literal en el cuadro de código). Saltos de línea se comprueban a través dei % 20 == 0
, y puntas de la estrella son comprobados por((i%20-1)%6)*((i/20)%6) == 9
.fuente
F #,
241 237 225 216 214211 bytesEste es complicado ... Me pregunto si se puede acortar.
Editar: reparó un error, agregó números, algunos lugares eliminaron números en otros, de alguna manera terminaron con el mismo recuento.
Podría intentar barajar números más tarde. Hecho.Edit2: ahorró más bytes al deletrear uno de los condicionales, contrarrestar intuitivamente.
Edit3: se corrigió otro error: debería funcionar ahora para piezas en el último rango y se las arregló para guardar dos bytes mientras estoy en eso, de alguna manera.
Pruébalo en línea
fuente
Retina ,
134129122 bytes11 bytes gracias a Martin Ender, y por la inspiración de 1 más.
Pruébalo en línea!
fuente
Perl, 132 bytes
-3 bytes gracias a @Dom Hastings
Toma entrada de línea de comando. Necesariamente
-M5.010
correr. Por ejemplo :Creo que esto podría ser más corto, pero no pude entender cómo ... ¡avíseme si lo hace!
fuente
@v=([(".")x18])x18;
para inicializar la lista ... Incluso podría haber una mejor manera que eso, ¡pero no estoy en una terminal en este momento! Creo que también puedes reemplazar la@{...}
expansión con flechas de desreferenciación: ¡$v[$_]->[@t]
nuevamente no probado! También espero que no te importe que sugiera cambios de código ...@v=([(".")x19])x19
no funciona (lo probé antes por cierto), porque crea solo una matrizref y copia 19 veces la referencia, no la matriz (por lo que al final solo tiene 1 línea duplicada 19 veces). Reemplazar@{..}
como sugirió tampoco parece funcionar. Supongo que es porque estoy trabajando en un segmento y no solo en un elemento. Si tiene alguna otra sugerencia, ¡no dude en sugerir! :)eval
de -3 embargo:@v=eval"[('*')x19],"x19;
. Y usted es 100% correcto con el arrayref ... ¿Es posible usar una matriz 1D y calcular el índice en eso? ¡Podría jugar con esto más tarde!Lote,
322310308 bytesExplicación: Comienza solicitando la piedra en stdin. Luego, establece variables para cada columna posible, de modo que pueda evaluar el primer carácter de la piedra como una variable para obtener la
y
coordenada. Resta 1 de lax
coordenada porque está indexado en 1 y queremos indexado en 0 y también calcula,z=y+1
ya que lo necesitará más adelante. Luego, pasar
de 18 a 0 para cada fila. Toma la cadena...*.....*.....*...
y extrae el carácter en lar
posición th para más tarde. En lax
fila th, ely
carácter th se reemplaza con uno
. Finalmente, los.*
s se reemplazan con un.
signo más el carácter extraído previamente; esta es una operación no operativa en las filas 4, 10 y 16, pero esta es la forma más corta de lograrlo. (Tengo que usar.*
porque reemplazar*
es aparentemente ilegal en Batch).fuente
PowerShell v2 +,
157152bytes(Creo que me encontré con algún tipo de falla extraña con el operador de coma, por lo que la construcción de la matriz es un poco más larga de lo que debería ser)
Toma la entrada como una cadena en mayúscula vía
$args[0]
, la convierte como una matriz de caracteres, almacena la primera letra$x
y las letras restantes en$y
. Esto efectivamente divide la entrada en letra / número.Luego construimos nuestra matriz multidimensional
$a
. Prepoblamos una matriz de tamaño19
con0
s utilizando el operador de coma. Luego hacemos un bucle0..18
para hacer que cada elemento sea$a[$_]
igual en lugar de una matriz de puntos, nuevamente usando el operador de coma. (Nota: en teoría, esto debería poder condensarse$a=,(,'.'*19)*19
, pero eso no parece funcionar bien con la asignación de indexación ... terminé configurando columnas completas en*
)A continuación, hacemos un bucle dos veces
3,9,15
para establecer los elementos correspondientes en*
. Luego lo indexamos en el lugar correcto para colocar la piedraO
. Para hacerlo, restamos65
de$x
(es decir, ASCII "A" es 65, y estamos indexados a cero), y resta uno adicional usando un booleano a int int si$x
es mayor que73
(es decir, ASCII "I" )Ahora, nuestra salida se invierte (es decir, la esquina superior izquierda sería
A1
), por lo que debemos invertir la matriz con$a[18..0]
. Finalmente, sacamos cada línea-join
unida para formar una cadena.fuente
> <> , 124 bytes
Utiliza exactamente el mismo enfoque que mi respuesta C. La entrada debe ser una letra mayúscula seguida de un número decimal.
Pruébalo en línea!
Explicación:
fuente
JavaScript, 138 bytes
Devuelve una matriz de cadenas. Explicación:
fuente
join
. También coloca el o en la fila incorrecta y la columna incorrecta para D5 (primer caso de prueba).R,
169161 bytesCon sangrías y nuevas líneas:
Uso:
fuente
Lua, 187 bytes
No me siento mal por 187 para este proyecto en particular. Lua sigue siendo muy torpe para jugar al golf, pero estoy muy orgulloso de lo lejos que puedo llegar con él.
fuente
PHP,
280 268 263 261 255 218216 bytesMi primer golf
Uso:
Guardar como un archivo PHP y llamarlo por
php filename.php coordinate
ej.php go.php k13
fuente