Coloque uma pedra em um tabuleiro vazio

34

Veja também: Faça uma jogada em um quadro Go .

Tarefa

Go é um jogo de tabuleiro no qual dois jogadores (preto e branco) colocam pedras nas interseções das linhas de grade em um tabuleiro 19 × 19. O preto se move primeiro - por exemplo, no D4:

       ir coordenadas

Neste desafio, você deve pegar uma coordenada do quadro Go D4como entrada e gerar uma representação ASCII de um quadro com a primeira jogada executada no ponto especificado.

Observe que não há coluna I. Isso é, historicamente, para reduzir a confusão com J e L.

Esta saída consiste em 19 linhas, cada uma contendo 19 caracteres. O ponto com a pedra está marcado O. Pontos vazios na placa são mostrados como ., exceto para os nove pontos da estrela (a D4, D10, D16, K4, K10, K16, Q4, Q10, e Q16), que estão marcados *.

Por exemplo, dado F5como uma entrada, a saída da sua resposta deve ser:

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

E dado Q16como entrada, sua saída deve ser:

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

Regras

  • Você pode escrever uma função que usa a coordenada como argumento ou um programa que lê a coordenada na linha de comando ou em STDIN.

  • Você pode optar por aceitar entradas em letras minúsculas ou maiúsculas, mas sua resposta não precisa lidar com ambas.

  • A entrada é sempre uma única string como a1ou T19, nunca uma string + número ou duas strings.

  • Se você escrever um programa completo, sua resposta deverá ser impressa STDOUTcomo uma sequência, opcionalmente seguida por uma nova linha final. Se a sua resposta é uma função, você pode imprimir STDOUT, ou  retornar uma string, ou  retornar um array / lista de strings (linhas), ou  devolver uma matriz bidimensional ou lista aninhada de caracteres.

  • Isso é . A resposta mais curta em bytes vence.

Lynn
fonte
Só para ter certeza, "a coordenada como argumento" significa que não podemos aceitar dois argumentos, como f("G", 14), correto?
FryAmTheEggman 8/08
8
Parabéns por 20k !!
Luis Mendo
2
"Isso é, historicamente, para reduzir a confusão com J e L." Mas J e L estão no quadro ?!
Fatalize 8/08/16
2
Sim. Além disso, é claro, a letra faltando provavelmente causado mais confusão e surpresa do que qualquer coisa ...
Lynn
2
@Fatalize, J e L parecem bastante distintos, pois as partes inferiores giram em direções separadas. Como j e l, um desce, o outro sobe. Mas i e j são um pouco semelhantes, e por isso são i, l e eu ...
ilkkachu

Respostas:

9

MATL , 33 bytes

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

Experimente online!

Explicação

'*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
fonte
16

C, 212 195 193 181 171 132 103 98 bytes

Salvo 1 byte graças a @FryAmTheEggman, 5 bytes graças a @orlp

Faça call f()com a posição de jogar (deve estar em maiúscula) e imprime o quadro 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);}

Experimente em ideone .

owacoder
fonte
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 9/08/16
Obrigado. Eu estava procurando uma maneira de reduzir essa expressão de módulo.
Owacoder 9/08
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;}

Ideone

Uma função que imprime o quadro em STDOUT. Requer que a coordenada da letra seja maiúscula. A impressão em um loop parece ser um pouco mais curta que a abordagem de loop aninhado anterior.

FryAmTheEggman
fonte
7

MATLAB, 135 bytes

Uma primeira tentativa, nada inteligente, apenas para ver o quão melhor os outros podem fazer:

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')
user58321
fonte
4
Bem-vindo ao PPCG! Algumas sugestões para reduzir bytes: use um nome de função com 1 caractere (ou um script com a=input('');); remover novas linhas; mudar '*'para 42e '0'para 48; substituir endpor 19; subtraia o valor lógico diretamente em vez da iframificação. De fato, você pode substituir as últimas cinco linhas porb(20-a(2),a(1)-64-(a(1)>8))=48
Luis Mendo
Olá e bem-vindo ao PPCG. Se não me engano, o código é 137 bytes de comprimento e não 135. (eu acho que não importa muito, mas eu só queria que você saiba)
Dada
7

Ruby, 93 91 bytes

Recebe entrada na linha de comando, por exemplo $ 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??*:?.}*""}

Teste-o no repl.it (envolto em um lambda, pois o repl.it não aceita argumentos de linha de comando: https://repl.it/CkvT/1

Ungolfed

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ânia
fonte
Eu acho que você pode salvar um byte fazendo em $><<vez de puts . Não tenho certeza, no entanto.
Fund Monica's Lawsuit
@QPaysTaxes Infelizmente, eu teria que acrescentar uma nova linha em algum lugar, então.
Jordan
Ah sim. Não importa
Fund Monica's Lawsuit
6

Vai, 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}

Provavelmente golfable parar um pouco, eu sou um iniciante

Sefa
fonte
Você poderia salvar 9 caracteres renomeando partpara p?
precisa saber é o seguinte
Dicas para jogar golfe em Go. Tomei a liberdade de aplicá-las à sua resposta.
EMBLEMA
Você notou que o comentário "+1 para a escolha do idioma" tem mais votos positivos do que a própria postagem? (acontece que os comentários têm mais upvotes, mas para tal comentário, que é bastante inesperada)
Dada
4

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

Comutado -ppara -nporque puts bé um byte menor 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
Value Ink
fonte
Você pode salvar bytes verificando se o índice mod 6 é 3 em vez de codificar 3, 9 e 15?
FryAmTheEggman
@FryAmTheEggman Poderia, mas ainda estou para descobrir uma solução que o faça.
Value Ink
4

Python, 148 145 136 130 121 119 116 116 Bytes

-3 Bytes graças 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]]

função lambda anônima, recebe a entrada do formato "A1" (letras grandes) e gera uma lista de listas de caracteres (len == 1 string em Python)

KarlKastor
fonte
Salve 8 bytes usando, em ".*oo"[2*(j==ord(x[0])-(x[0]>"I")-65and int(x[1:])==i+1)+(i%6==j%6==3)]vez de, o"o"if...else"*"if...else"."
RootTwo
Além disso, acho que você pode usar em (x>'I')vez de (x[0]>'I')salvar mais 3 bytes.
precisa saber é o seguinte
@RootTwo Obrigado, a primeira sugestão não é mais útil, pois desde então encontrei uma solução ainda mais curta. O segundo agora parece óbvio e me faz questionar por que não pensei nisso antes.
KarlKastor 8/08/16
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^^

Observe que existe um 0x14na primeira linha após o primeiro 'e um 0x19entre o 9e o primeiro ^da última linha. Experimente online!

A entrada é mapeada para que A-Tse torne 1-19(com 0 denotando uma coluna "nova linha" imaginária) e o número da linha inteira seja decrementado por 1. O programa executa um loop de 379 para 0, escolhendo um caracter da linha de baixo à medida que segue ( compensado por 15, para explicar o fato de que você não pode inserir uma nova linha literal no codebox). As novas linhas são verificadas por i % 20 == 0e os pontos estrela são verificados por ((i%20-1)%6)*((i/20)%6) == 9.

Sp3000
fonte
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".")

Tricky this this ... Gostaria de saber se pode ser reduzido.

Editar: corrigido um bug, adicionamos números em alguns lugares, removemos números em outros, de alguma forma acabamos com a mesma contagem. Pode tentar embaralhar números mais tarde . Concluído.

Edit2: salvou mais bytes digitando um dos condicionais, contra-intuitivamente.

Edit3: Corrigido outro bug: deve funcionar agora para peças no último rank e conseguiu salvar dois bytes enquanto estou nele, de alguma forma.

Experimente online

asibahi
fonte
Oh, esse era o problema. Engraçado, é a única coisa que eu não olhar para duas vezes
asibahi
3

Retina , 134 129 122 bytes

11 bytes graças a Martin Ender e pela inspiração de mais 1.

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

Experimente online!

Freira Furada
fonte
2
Ei, parabéns pelo seu distintivo dourado!
Luis Mendo
3

Perl, 132 bytes

-3 bytes graças 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;

Recebe a entrada da linha de comando. Precisa -M5.010correr. Por exemplo :

$ 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

Eu acho que isso poderia ser mais curto, mas eu não conseguia descobrir como ... por favor, deixe-me saber se você faz!

dada
fonte
Bom uso de mais variáveis ​​mágicas novamente! Não testei isso corretamente, mas acho que você pode economizar um pouco mais @v=([(".")x18])x18;para inicializar a lista ... Pode até haver uma maneira melhor do que isso, mas não estou em um terminal agora! Acho que você também pode substituir a @{...}expansão por setas de desreferenciamento: $v[$_]->[@t]novamente não testadas! Também espero que você não se importa me sugerindo alterações no código ...
Dom Hastings
1
@DomHastings Claro que não me importo, pelo contrário, prefiro encorajá-lo a sugerir melhorias! @v=([(".")x19])x19não funciona (tentei antes da btw), porque cria apenas um arrayref e copia 19 vezes o ref, não o array (no final, você só tem uma linha duplicada 19 vezes). Substituir @{..}conforme sugerido também não parece funcionar. Acho que é porque estou trabalhando em uma fatia e não apenas em um elemento. Se você tiver alguma outra sugestão, fique à vontade para sugerir! :)
Dada
1
Droga, é claro que seria o mesmo ... Eu consegui uso evalpara -3 entanto: @v=eval"[('*')x19],"x19;. E você está 100% correto com o arrayref ... Talvez seja possível usar um array 1D e calcular o índice nisso? Pode jogar com isso mais tarde!
Dom Hastings
@DomHastings Obrigado pelos -3 bytes. Talvez algo para tentar com uma matriz 1D, de fato. Vou tentar isso em breve #
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%%%

Explicação: Inicia solicitando a pedra em stdin. Em seguida, define variáveis ​​para cada coluna possível, para que ele possa avaliar o primeiro caractere da pedra como uma variável para obter a ycoordenada. Subtrai 1 da xcoordenada porque é indexada 1 e queremos indexada 0 e também calcula z=y+1, pois será necessário mais tarde. Em seguida, faça um loop rde 18 a 0 para cada linha. Pega a string ...*.....*.....*...e extrai o caractere na rposição th para mais tarde. Na xlinha th, o ycaractere th é substituído por um o. Finalmente, os .*s são substituídos por um .mais o caractere extraído anteriormente; este é um não operacional nas linhas 4, 10 e 16, mas é a maneira mais curta de conseguir isso. (Eu tenho que usar.*porque a substituição *é aparentemente ilegal no Lote.)

Neil
fonte
2

PowerShell v2 +, 157 152 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$_}

(Acho que tive algum tipo de falha estranha com o operador de vírgula, portanto a construção da matriz é um pouco mais longa do que deveria)

Pega a entrada como uma string maiúscula $args[0], lança-a como uma matriz de caracteres, armazena a primeira letra $xe as letras restantes em $y. Isso efetivamente divide a entrada em letra / número.

Em seguida, construímos nossa matriz multidimensional $a. Preenchemos previamente uma matriz de tamanho 19com 0s usando o operador de vírgula. Em seguida, 0..18fazemos um loop para tornar cada elemento $a[$_]igual em vez de uma matriz de períodos, novamente usando o operador vírgula. (NB - Em teoria, isso deve poder ser condensado $a=,(,'.'*19)*19, mas isso não parece funcionar corretamente com a atribuição de indexação ... acabei definindo colunas inteiras *)

Em seguida, fazemos um loop duas vezes 3,9,15para definir os elementos correspondentes como *. Depois, indexamos no local certo para definir a pedra O. Para fazer isso, subtraímos 65de $x(ou seja, ASCII "A" é 65 e somos indexados a zero) e subtraímos um adicional usando uma conversão booleana para int se $xfor maior que 73(ou seja, ASCII "I" )

Agora, nossa saída é invertida (ou seja, a parte superior esquerda seria A1), então precisamos inverter a matriz com $a[18..0]. Finalmente, produzimos cada linha -joined para formar uma string.

AdmBorkBork
fonte
2

> <> , 124 bytes

Usa exatamente a mesma abordagem da minha resposta C. A entrada deve ser uma letra maiúscula seguida por um 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<'.'<

Experimente online!

Explicação:

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

Retorna uma matriz de seqüências de caracteres. Explicação:

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
fonte
Uma matriz de seqüências de caracteres não corresponde à saída necessária, apenas join. Também coloca o na linha incorreta e na coluna errada para D5 (primeiro caso de teste).
Konijn
@tomdemuyt Uma matriz de strings é permitida como valor de retorno. No entanto, é possível que eu tenha minhas linhas e colunas misturadas, por isso vou verificar novamente.
Neil
Hmm, na verdade, matriz de cordas #
5287
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="")}

Com recuos e novas linhas:

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

Não me sinto muito mal por esse projeto em particular. Lua ainda parece muito desajeitada para o golfe, mas estou muito orgulhosa de quão longe eu posso ir com isso.

ATaco
fonte
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";}

Meu primeiro golfe.

Uso:
Salve como um arquivo PHP e chame-o por php filename.php coordinateexemplophp go.php k13

gabe3886
fonte