Coloque una piedra en un tablero vacío

34

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:

       ir coordenadas

En este desafío, debe tomar una coordenada de tablero Go D4como 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 F5como entrada, la salida de su respuesta debe ser:

...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
.....O.............
...*.....*.....*...
...................
...................
...................

Y dado Q16como 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 a1o T19, nunca una cadena + número o dos cadenas.

  • Si escribe un programa completo, su respuesta debe imprimirse STDOUTcomo una cadena, opcionalmente seguida de una nueva línea final. Si su respuesta es una función, es posible imprimir en STDOUT, 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 . La respuesta más corta en bytes gana.

Lynn
fuente
Solo para estar seguros, "la coordenada como argumento" implica que no podemos tomar dos argumentos, f("G", 14)¿correcto?
FryAmTheEggman
8
¡Felicidades por 20k!
Luis Mendo
2
"Esto es, históricamente, para reducir la confusión con J y L." ¿Pero tanto J como L están en el tablero?
Fatalize
2
Sí. Además, por supuesto, la carta que falta probablemente ha causado más confusión y sorpresa que cualquier otra cosa ...
Lynn
2
@Fatalize, J y L se ven bastante distintos ya que las partes inferiores giran en direcciones separadas. Al igual que con j y l, uno desciende, el otro sube. Pero yo y j son un poco similares, y yo, yo y yo también ...
ilkkachu

Respuestas:

9

MATL , 33 bytes

'*O.'19: 6\4=&*Hj1&)Uw64-t8>-&(P)

Pruébalo en línea!

Explicación

'*O.'    % Push string with needed characters. Will be indexed into
19:      % Push numeric vector [1 2 ... 19]
6\4=     % 1 for values that equal 4 mod 6, 0 for the rest
&*       % Multiply by transposed version of itself with broadcast. This gives
         % the 19×19 board with 0 instead of '.' and 1 instead of '*'
H        % Push 2. This will correspond to 'O' (stone)
j        % Input string, such as 'Q16'
1&)      % Split into its first char ('Q') and then the rest ('16')
U        % Convert to number (16)
w        % Swap, to move 'Q' to top
64-      % Subtract 64. Thus 'A' gives 1, 'B' gives 2 etc
t8>-     % Duplicate. Subtract 1 if it exceeds 8. This corrects for missing 'I'
&(       % Fill a 2 at coordinates given by the number and the letter
P        % Flip upside down, because matrix coordinates start up, not down
)        % Index the string '*O.' with the 19×19 array containing 0,1,2.
         % Implicitly display
Luis Mendo
fuente
16

C, 212 195 193 181 171 132 103 98 bytes

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

i;f(char*p){for(i=380;i--;)putchar(i%20?i^20*atoi(p+1)+64-*p+(*p>72)?i%6^4|i/20%6^3?46:42:79:10);}

Pruébalo con ideone .

owacoder
fuente
2
98 bytesputchar(i%20?i^20*atoi(p+1)+64-*p+(*p>72)?i%6^4|i/20%6^3?46:42:79:10)
orlp
Gracias. Estaba buscando una manera de reducir esa expresión de módulo.
owacoder
9

C (gcc) 132 128 109

i;m;f(char*s){for(i=380;i--;putchar(m?m^84-*s+(*s>73)|(i/20+1)^atoi(s+1)?m%6^4|i/20%6^3?46:42:79:10))m=i%20;}

Ideona

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.

FryAmTheEggman
fuente
7

MATLAB, 135 bytes

Un primer intento, nada inteligente, solo para ver cuánto mejor pueden hacer los demás:

function go(a)
b=repmat('.',19);
b(4:6:end,4:6:end)='*';
a=sscanf(a,'%c%d');
a(1)=a(1)-64;
if a(1)>8
a(1)=a(1)-1;
end
b(20-a(2),a(1))='0'

Uso:

go('T19')
usuario58321
fuente
44
Bienvenido a PPCG! Algunas sugerencias para reducir bytes: use un nombre de función con 1 carácter (o un script con a=input('');); eliminar nuevas líneas; cambiar '*'hacia 42y '0'hacia 48; reemplazar endpor 19; reste el valor lógico directamente en lugar de la iframa. De hecho, puede reemplazar las últimas cinco líneas porb(20-a(2),a(1)-64-(a(1)>8))=48
Luis Mendo
Hola y bienvenidos a PPCG. Si no me equivoco, su código tiene 137 bytes de longitud y no 135. (Supongo que no importa mucho, pero solo quería que lo supiera)
Dada
7

Ruby, 93 91 bytes

Toma entrada en la línea de comando, por ejemplo $ ruby script.rb Q16.

19.downto(1){|c|puts ([*?A..?T]-[?I]).map{|d|d+c.to_s==$*[0]??O:"DKQ"[d]&&c%6==4??*:?.}*""}

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

19.downto(1) do |row|
  puts ([*?A..?T] - [?I]).map {|column|
    if column + row.to_s == ARGV[0]
      "O"
    elsif "DKQ"[column] && row % 6 == 4
      "*"
    else
      "."
    end
  }.join
}
Jordán
fuente
Creo que puedes guardar un byte haciendo en $><<lugar de puts . Aunque no estoy seguro.
Financia la demanda de Mónica el
@QPaysTaxes Por desgracia, tendría que agregar una nueva línea en algún lugar, entonces.
Jordania
Oh si. No importa
Financia la demanda de Mónica el
6

Ir, 319 286 bytes

import(."strconv"
."strings")
func g(c string)(s string){p:=SplitN(c,"",2)
n,_:=Atoi(p[1])
for i:=19;i>0;i--{
for j:= 'a';j<'t';j++{
if j=='i'{
}else if n==i&&ContainsRune(p[0],j){s+="o"
}else if((i==4||i==10||i==16)&&(j=='d'||j=='k'||j=='q')){s+="*"
}else{s+="."}}
s+="\n"}
return}

Probablemente golfable renunció un poco, soy un principiante

Sefa
fuente
¿Podría guardar 9 caracteres cambiando el nombre parta p?
corsiKa
Consejos para jugar al golf en Go. Me tomé la libertad de aplicarlos a su respuesta yo mismo.
EMBLEMA
¿Notó que el comentario "+1 para elegir el idioma" tiene más votos a favor que la publicación misma? (sucede que los comentarios tienen más votos a favor, pero para tal comentario, eso es bastante inesperado)
Dada
4

Ruby, 130 128 121 + 3 ( -nflag) = 124 bytes

Cambiado -pa -nporque puts bes un byte más corto que$_=b*$/

~/(.)(.+)/
b=(1..19).map{?.*19}
(a=3,9,15).map{|i|a.map{|j|b[i][j]=?*}}
b[19-$2.to_i][([*?A..?T]-[?I]).index$1]=?o
puts b
Tinta de valor
fuente
¿Puede guardar bytes comprobando si el índice mod 6 es 3 en lugar de codificar 3, 9 y 15?
FryAmTheEggman
@FryAmTheEggman Podría, pero todavía tengo que encontrar una solución que lo haga.
Value Ink el
4

Python, 148 145 136 130 121 119 116 Bytes

-3 Bytes gracias a @RootTwo

lambda x,r=range(19):[[".*o"[[i%6==j%6==3,2][j==ord(x[0])-(x>"I")-65and-~i==int(x[1:])]]for j in r]for i in r[::-1]]

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)

KarlKastor
fuente
Ahorre 8 bytes utilizando en ".*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"."
RootTwo
Además, creo que puede usar en (x>'I')lugar de (x[0]>'I')guardar 3 bytes más.
RootTwo
@RootTwo Gracias, la primera sugerencia ya no es útil, ya que desde entonces he encontrado una solución aún más corta. El segundo ahora parece obvio y me hace preguntarme por qué no había pensado en esto antes.
KarlKastor
4

> <> , 98 96 bytes

'_U'i-:b)-0\
+*a$%cv?(0:i<
{*+{4*\+
+4gf-o>1-:?!;:{:}=3*&::aa+%::0=2*&+&6%1-}-aa+,6%{*9=&
=9^^

Tenga en cuenta que hay una 0x14en la primera fila después de la primera ', y una 0x19entre la 9y la primera ^de la última línea. Pruébalo en línea!

La entrada se asigna de manera que se A-Tconvierta 1-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 de i % 20 == 0, y puntas de la estrella son comprobados por ((i%20-1)%6)*((i/20)%6) == 9.

Sp3000
fuente
4

F #, 241 237 225 216 214 211 bytes

let G(c:string)=for k=1 to 380 do printf(if k%20=0 then"\n"elif"_ABCDEFGHJKLMNOPQRST".IndexOf c.[0]=k%20&&19-k/20=int(c.Substring 1)then"o"elif(k%20=4||k%20=10||k%20=16)&&(k/20=3||k/20=9||k/20=15)then"*"else".")

Este 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

asibahi
fuente
Oh, ese era el problema. Es curioso, es lo único que no miré dos veces
asibahi el
3

Retina , 134 129 122 bytes

11 bytes gracias a Martin Ender, y por la inspiración de 1 más.

S2=`
[K-S]
1$&
T`xL`d9d
.+
$*
$
aaab
a
bbbcbb
b|c
¶$0
c
ddd.
d
...*..
b
19$*.
1(1)*¶1(1)*¶((?<-2>.+¶)*(?<-1>.)*).
$3O
O^$`

Pruébalo en línea!

Monja permeable
fuente
2
¡Hola, felicidades por tu insignia de oro!
Luis Mendo
3

Perl, 132 bytes

-3 bytes gracias a @Dom Hastings

@v=eval"[('.')x19],"x19;@{$v[$_]}[@t]=("*")x3for@t=(3,9,15);pop=~/\d+/;$v[19-$&][($t=ord$`)-65-($t>73)]=O;map{say}map{join"",@$_}@v;

Toma entrada de línea de comando. Necesariamente-M5.010 correr. Por ejemplo :

$ cat go_board.pl
@v=eval"[('.')x19],"x19;@{$v[$_]}[@t]=("*")x3for@t=(3,9,15);pop=~/\d+/;$v[19-$&][($t=ord$`)-65-($t>73)]=O;map{say}map{join"",@$_}@v;
$ perl -M5.010 go_board.pl Q16

Creo que esto podría ser más corto, pero no pude entender cómo ... ¡avíseme si lo hace!

Dada
fuente
Buen uso de más variables mágicas de nuevo! No lo he probado correctamente, pero creo que puedes ahorrar un poco más @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 ...
Dom Hastings
1
@DomHastings ¡Por supuesto que no me importa, por el contrario, prefiero alentarlo a que sugiera mejoras! @v=([(".")x19])x19no 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! :)
Dada
1
Maldita sea, por supuesto que sería lo mismo ... Me las he arreglado para el uso evalde -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!
Dom Hastings
@DomHastings Gracias por los -3 bytes. Tal vez algo para probar con una matriz 1D, de hecho. Lo intentaré pronto
Dada
3

Lote, 322 310 308 bytes

@echo off
set/pi=
set/aa=0,b=1,c=2,d=3,e=4,f=5,g=6,h=7,j=8,k=9,l=10,m=11,n=12,o=13,p=14,q=15,r=16,s=17,t=18,x=%i:~1%-1,y=%i:~,1%,z=y+1
for /l %%r in (18,-1,0)do call:l %%r
exit/b
:l
set s=...*.....*.....*...
call set t=%%s:~%1,1%%
if %x%==%1 call set s=%%s:~,%y%%%o%%s:~%z%%%
call echo %%s:.*=.%t%%%

Explicació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 ycoordenada. Resta 1 de la xcoordenada porque está indexado en 1 y queremos indexado en 0 y también calcula, z=y+1ya que lo necesitará más adelante. Luego, pasa rde 18 a 0 para cada fila. Toma la cadena ...*.....*.....*...y extrae el carácter en la rposición th para más tarde. En la xfila th, el ycarácter th se reemplaza con un o. 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).

Neil
fuente
2

PowerShell v2 +, 157152 bytes

$x,$y=[char[]]$args[0];$a=,0*19;0..18|%{$a[$_]=,'.'*19};3,9,15|%{$i=$_;3,9,15|%{$a[$_][$i]='*'}};$a[-join$y-1][$x-65-($x-gt73)]='O';$a[18..0]|%{-join$_}

(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 $xy 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ño 19con 0s utilizando el operador de coma. Luego hacemos un bucle 0..18para 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,15para establecer los elementos correspondientes en *. Luego lo indexamos en el lugar correcto para colocar la piedra O. Para hacerlo, restamos 65de $x(es decir, ASCII "A" es 65, y estamos indexados a cero), y resta uno adicional usando un booleano a int int si $xes mayor que 73(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 -joinunida para formar una cadena.

AdmBorkBork
fuente
2

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

88*i:&-&'I')+0 v
*a&-'0'v!?)0:i&<+
+**2a&~/*a'&'&
:;!?:-1<o'O'v!?=&:&
{*?!v'*'o63.>:6%4=}:a4*+'x'%aa*)
*2a:/  av?%
.37o<'.'<

Pruébalo en línea!

Explicación:

88*i:&-&'I')+0 v         'Push 64-<first input char>+(<first input char> > 'I')
*a&-'0'v!?)0:i&<+        'Set register to 0, parse decimal integer into register.
+**2a&~/*a'&'&           'Pop the -1 (EOF) from stack, multiply register by 20.
                         'Add result of first line to register.
                         'Push 380 onto stack.
:;!?:-1<o'O'v!?=&:&      'Main loop, while top of stack is not 0.
                         'Subtract 1 from top of stack (loop counter)
                         'If current index is the playing piece index, print 'O'
{*?!v'*'o63.>:6%4=}:a4*+'x'%aa*) 
                         'If (index%6)=4 and (index+40)%120>100, print '*'
*2a:/  av?%              'If (index%20)=0, print newline
.37o<'.'<                'Otherwise, print '.'
owacoder
fuente
1

JavaScript, 138 bytes

s=>[...t="...*.....*.....*..."].map((c,i)=>t.replace(/\*/g,c).replace(/./g,(c,j)=>x-j|19-i-s.slice(1)?c:'o'),x=parseInt(s[0],36)*.944-9|0)

Devuelve una matriz de cadenas. Explicación:

s=>[...                         Parameter
 t="...*.....*.....*..."        Pattern of lines 4, 10 and 16
].map((c,i)=>                   Loop 19 times
 t.replace(/\*/g,c)             Change the `*` to `.` on other lines
  .replace(/./g,(c,j)=>         Loop over each character
   x-j|19-i-s.slice(1)?c:'o'),  Change to o at the appropriate position
 x=parseInt(s[0],36)*.944-9|0)  Compute the column number from the letter
Neil
fuente
Una matriz de cadenas no coincide con la salida requerida, solo join. También coloca el o en la fila incorrecta y la columna incorrecta para D5 (primer caso de prueba).
Konijn
@tomdemuyt Se permite una matriz de cadenas como valor de retorno. Sin embargo, es posible que haya mezclado mis filas y columnas, por lo que volveré a verificar.
Neil
Hmm, de hecho variedad de cuerdas
Konijn
1

R, 169 161 bytes

f=function(p){S=substr;N=rep(".",114);N[61+6*0:2]="*";M=matrix(N,19,19);M[(S(p,2,3):1)[1],which(LETTERS[-9]==S(p,1,1))]="O";for(i in 19:1)cat(M[i,],"\n",sep="")}

Con sangrías y nuevas líneas:

f=function(p){
    S=substr
    N=rep(".",114) # 6 lines of dots
    N[61+6*0:2]="*" # Place the hoshis
    M=matrix(N,19,19) # Make the 19x19 board using vector recycling
    M[(S(p,2,3):1)[1],  #grab and force coerce the row number to integer
      which(LETTERS[-9]==S(p,1,1))]="O" #Place the first stone
    for(i in 19:1) cat(M[i,],"\n",sep="")
}

Uso:

> f("A19")
O..................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
> f("D4")
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...O.....*.....*...
...................
...................
...................
> f("K10")
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....O.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
plannapus
fuente
1

Lua, 187 bytes

function g(i)i:gsub("(%a+)(%d+)",function(a,b)q=string.byte(a)-64 r=b+0 end)for x=1,19 do s=""for y=1,19 do s=s..(x+y*19==r+q*19 and"o"or(x-4)%6+(y-4)%6==0 and"*"or"-")end print(s)end end

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.

Un taco
fuente
1

PHP, 280 268 263 261 255 218 216 bytes

<?php $a=ucfirst($argv[1]);$x=substr($a,0,1);$y=substr($a,1);$s=['DKQ',4,16,10];$i=85;while(64<$i--){$j=0;while($j++<20){echo($x==chr($i)&&$y==$j)?'O':((strpos($s[0],chr($i))>-1&&in_array($j,$s))?'*':'.');}echo"\n";}

Mi primer golf

Uso:
Guardar como un archivo PHP y llamarlo por php filename.php coordinateej.php go.php k13

gabe3886
fuente