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:
Neste desafio, você deve pegar uma coordenada do quadro Go D4
como 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 F5
como uma entrada, a saída da sua resposta deve ser:
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
.....O.............
...*.....*.....*...
...................
...................
...................
E dado Q16
como 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
a1
ouT19
, nunca uma string + número ou duas strings.Se você escrever um programa completo, sua resposta deverá ser impressa
STDOUT
como uma sequência, opcionalmente seguida por uma nova linha final. Se a sua resposta é uma função, você pode imprimirSTDOUT
, ou retornar uma string, ou retornar um array / lista de strings (linhas), ou devolver uma matriz bidimensional ou lista aninhada de caracteres.Isso é código-golfe . A resposta mais curta em bytes vence.
f("G", 14)
, correto?Respostas:
MATL , 33 bytes
Experimente online!
Explicação
fonte
C,
21219519318117113210398 bytesSalvo 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.Experimente em ideone .
fonte
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),
132128109Ideone
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.
fonte
MATLAB, 135 bytes
Uma primeira tentativa, nada inteligente, apenas para ver o quão melhor os outros podem fazer:
Uso:
fonte
a=input('');
); remover novas linhas; mudar'*'
para42
e'0'
para48
; substituirend
por19
; subtraia o valor lógico diretamente em vez daif
ramificação. De fato, você pode substituir as últimas cinco linhas porb(20-a(2),a(1)-64-(a(1)>8))=48
Ruby,
9391 bytesRecebe entrada na linha de comando, por exemplo
$ ruby script.rb Q16
.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
fonte
$><<
vez deputs
. Não tenho certeza, no entanto.Vai,
319286 bytesProvavelmente golfable parar um pouco, eu sou um iniciante
fonte
part
parap
?Ruby,
130128121 + 3 (-n
sinalizador) = 124 bytesComutado
-p
para-n
porqueputs b
é um byte menor que$_=b*$/
fonte
Python,
148145136130121119116 116 Bytes-3 Bytes graças a @RootTwo
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)
fonte
".*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"."
(x>'I')
vez de(x[0]>'I')
salvar mais 3 bytes.> <> ,
9896 bytesObserve que existe um
0x14
na primeira linha após o primeiro'
e um0x19
entre o9
e o primeiro^
da última linha. Experimente online!A entrada é mapeada para que
A-T
se torne1-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 pori % 20 == 0
e os pontos estrela são verificados por((i%20-1)%6)*((i/20)%6) == 9
.fonte
F #,
241 237 225 216 214211 bytesTricky 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
fonte
Retina ,
134129122 bytes11 bytes graças a Martin Ender e pela inspiração de mais 1.
Experimente online!
fonte
Perl, 132 bytes
-3 bytes graças a @Dom Hastings
Recebe a entrada da linha de comando. Precisa
-M5.010
correr. Por exemplo :Eu acho que isso poderia ser mais curto, mas eu não conseguia descobrir como ... por favor, deixe-me saber se você faz!
fonte
@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 ...@v=([(".")x19])x19
nã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! :)eval
para -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!Lote,
322310308 bytesExplicaçã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
y
coordenada. Subtrai 1 dax
coordenada porque é indexada 1 e queremos indexada 0 e também calculaz=y+1
, pois será necessário mais tarde. Em seguida, faça um loopr
de 18 a 0 para cada linha. Pega a string...*.....*.....*...
e extrai o caractere nar
posição th para mais tarde. Nax
linha th, oy
caractere th é substituído por umo
. 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.)fonte
PowerShell v2 +,
157152 bytes(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$x
e 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 tamanho19
com0
s usando o operador de vírgula. Em seguida,0..18
fazemos 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,15
para definir os elementos correspondentes como*
. Depois, indexamos no local certo para definir a pedraO
. Para fazer isso, subtraímos65
de$x
(ou seja, ASCII "A" é 65 e somos indexados a zero) e subtraímos um adicional usando uma conversão booleana para int se$x
for maior que73
(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-join
ed para formar uma string.fonte
> <> , 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.
Experimente online!
Explicação:
fonte
JavaScript, 138 bytes
Retorna uma matriz de seqüências de caracteres. Explicação:
fonte
join
. Também coloca o na linha incorreta e na coluna errada para D5 (primeiro caso de teste).R,
169161 bytesCom recuos e novas linhas:
Uso:
fonte
Lua, 187 bytes
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.
fonte
PHP,
280 268 263 261 255 218216 bytesMeu primeiro golfe.
Uso:
Salve como um arquivo PHP e chame-o por
php filename.php coordinate
exemplophp go.php k13
fonte