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 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 código de golf . La respuesta más corta en bytes gana.

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

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 .

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.

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

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
}

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

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

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)

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

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

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!

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!

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

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.

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

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

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

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.

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