Voir aussi: Faites un geste sur un tableau de Go .

Tâche

Go est un jeu de plateau où deux joueurs (noir et blanc) placent des pierres aux intersections des lignes de la grille sur un tableau 19 × 19. Noir se déplace en premier - par exemple, à J4:

Dans ce défi, vous devez prendre une coordonnée de tableau Aller D4comme entrée et générer une représentation ASCII d'un tableau avec le premier coup joué à un moment donné.

Notez qu'il n'y a pas de colonne I. Ceci est, historiquement, pour réduire la confusion avec J et L.

Cette sortie consiste en 19 lignes de 19 caractères chacune. La pointe avec la pierre est marquée O. Des points vides sur la carte sont présentés comme ., sauf pour les neuf points étoiles (à D4, D10, D16, K4, K10, K16, Q4, Q10et Q16), qui sont marqués *.

Par exemple, F5en entrée, le résultat de votre réponse doit être:

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

Et donné Q16en entrée, votre sortie doit être:

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

Règles

• Vous pouvez écrire une fonction qui prend la coordonnée en argument, ou un programme qui lit la coordonnée à partir de la ligne de commande STDIN.

• Vous pouvez choisir d’accepter les entrées en minuscule ou en majuscule, mais votre réponse ne doit pas nécessairement traiter les deux.

• L'entrée est toujours une simple chaîne comme a1ou T19, jamais une chaîne + nombre ou deux chaînes.

• Si vous écrivez un programme complet, votre réponse doit être imprimée STDOUTsous la forme d'une chaîne, suivie éventuellement d'une nouvelle ligne. Si votre réponse est une fonction, vous pouvez imprimer sur STDOUT, ou  renvoyer une chaîne, ou  retourne un tableau / liste des chaînes (lignes), ou  retourner un tableau à deux dimensions ou liste imbriquée de caractères.

• C'est du code-golf . La réponse la plus courte en octets gagne.

MATL , 33 octets

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

Essayez-le en ligne!

Explication

'*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 98 octets

Enregistré 1 octet grâce à @FryAmTheEggman, 5 octets grâce à @orlp

Appelez f()avec la position à jouer (doit être en majuscule), et le résultat est imprimé.

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);}

Essayez sur 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;}

Ideone

Une fonction qui imprime le tableau sur STDOUT. Requiert que la coordonnée de la lettre soit capitale. L'impression dans une boucle semble être légèrement plus courte que la précédente approche par boucle imbriquée.

MATLAB, 135 octets

Un premier essai, rien d’intelligent, juste pour voir à quel point les autres peuvent faire mieux:

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'

Usage:

go('T19')

Ruby, 93 91 octets

Prend une entrée sur la ligne de commande, par exemple $ 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??*:?.}*""}

Testez-le sur repl.it (encapsulé dans un lambda car repl.it ne prend pas d'arguments en ligne de commande: 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
}

Aller, 319 286 octets

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}

Probablement golfable arrêter un peu, je suis un débutant

Ruby, 130 128 121 + 3 ( -ndrapeau) = 124 octets

Basculé -psur -ncar puts bun octet est plus court 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 121 119 116 Octets

-3 octets grâce à @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]]

Fonction lambda anonyme, prend la forme "A1" (en lettres majuscules) et génère une liste de listes de caractères (len == 1 chaînes en Python)

> <> , 98 96 octets

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

Notez qu'il y a un 0x14dans la première ligne après la première ', et un 0x19entre le 9et le premier ^de la dernière ligne. Essayez-le en ligne!

L'entrée est mappée de manière à A-Tdevenir 1-19(avec 0 une colonne imaginaire de "nouvelle ligne") et le nombre entier de lignes est décrémenté de 1. Le programme effectue une boucle de 379 à 0, choisissant un caractère dans la ligne du bas comme il se doit ( compensé par 15, pour tenir compte du fait que vous ne pouvez pas entrer de nouvelle ligne littérale dans la boîte à code). Les nouvelles lignes sont vérifiées via i % 20 == 0, et les points étoiles sont vérifiés par ((i%20-1)%6)*((i/20)%6) == 9.

F #, 241 237 225 216 214 211 octets

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 one this one ... Je me demande si cela peut être raccourci.

Edit: corrigé un bogue, ajouté des numéros à certains endroits, effacé des numéros dans d’autres, avec le même nombre. Peut-être essayer de mélanger les chiffres plus tard . Terminé.

Edit2: enregistré plus d'octets en épelant l'un des conditionnels, compteur intuitivement.

Edit3: Correction d'un autre bug: devrait fonctionner maintenant pour les pièces du dernier rang et a réussi à sauvegarder deux octets pendant que j'y suis, d'une manière ou d'une autre.

Essayez-le en ligne

Retina , 134 129 122 octets

11 octets grâce à Martin Ender et l'inspiration pour un de plus.

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

Essayez-le en ligne!

Perl, 132 octets

-3 octets grâce à @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;

Prend la saisie en ligne de commande. Besoins-M5.010 courir. Par exemple :

$ 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

Je pense que cela pourrait être plus court, mais je ne pouvais pas comprendre comment ... s'il vous plaît laissez-moi savoir si vous le faites!

Lot, 322 310 308 octets

@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%%%

Explication: commence par demander la pierre sur stdin. Ensuite, définit les variables pour chaque colonne possible, afin qu’elle puisse évaluer le premier caractère de la pierre en tant que variable pour obtenir les ycoordonnées. Soustrait 1 de la xcoordonnée car il est indexé 1 et nous voulons indexé 0 et calcule également z=y+1car il en aura besoin plus tard. Ensuite, les boucles rde 18 à 0 pour chaque ligne. Prend la chaîne ...*.....*.....*...et extrait le caractère à la rposition e pour plus tard. Sur la xrangée e, le ycaractère e est remplacé par un o. Enfin, les .*s sont remplacés par un .plus du caractère précédemment extrait; c'est un non-op sur les rangées 4, 10 et 16, mais c'est le moyen le plus court pour y parvenir. (Je dois utiliser.*car le remplacement *est apparemment illégal dans le lot.)

PowerShell v2 +, 157 152 octets

$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$_}

_{(Je pense que j'ai rencontré une sorte de pépin étrange avec l'opérateur virgule, donc la construction de tableau est un peu plus longue qu'elle ne devrait l'être)}

Prend l'entrée en tant que chaîne majuscule via $args[0], la transforme en tableau de caractères, stocke la première lettre $xet les autres lettres $y. Cela divise efficacement l'entrée en lettre / chiffre.

Nous construisons ensuite notre tableau multidimensionnel $a. Nous pré-remplissons un tableau de taille 19avec 0s en utilisant l'opérateur virgule. Nous effectuons ensuite une boucle 0..18pour rendre chaque élément $a[$_]égal à un tableau de périodes, en utilisant à nouveau l'opérateur virgule. (NB - En théorie, cela devrait pouvoir être condensé $a=,(,'.'*19)*19, mais cela ne semble pas fonctionner correctement avec la tâche d'indexation ... J'ai fini par avoir les colonnes entières réglées à *)

Ensuite, nous parcourons deux fois 3,9,15pour définir les éléments correspondants *. Nous y indexons ensuite au bon endroit pour poser la pierre O. Pour ce faire, nous soustrayons 65de $x(c'est-à-dire que l'ASCII "A" vaut 65 et que nous sommes indexés à zéro), et en soustrayons un autre à l'aide d'une conversion booléenne-int si $xest plus grand que 73(c'est -à- dire que l'ASCII "I" ).

Maintenant, notre sortie est inversée (la partie supérieure gauche le serait A1), nous devons donc inverser le tableau $a[18..0]. Enfin, nous produisons chaque ligne -joinensemble pour former une chaîne.

> <> , 124 octets

Utilise exactement la même approche que ma réponse en C. La saisie doit être une lettre majuscule suivie d'un nombre décimal.

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

Essayez-le en ligne!

Explication:

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 octets

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)

Retourne un tableau de chaînes. Explication:

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 octets

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="")}

Avec les retraits et les nouvelles lignes:

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="")
}

Usage:

> f("A19")
O..................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
> f("D4")
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...O.....*.....*...
...................
...................
...................
> f("K10")
...................
...................
...................
...*.....*.....*...
...................
...................
...................
...................
...................
...*.....O.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................

Lua, 187 octets

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

Je ne me sens pas trop mal avec 187 pour ce projet particulier. Lua est encore très maladroit pour le golf, mais je suis assez fier de pouvoir aller si loin.

PHP, 280 268 263 261 255 218 216 octets

<?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";}

Mon premier golf.

Utilisation:
Enregistrer en tant que fichier PHP et appeler par php filename.php coordinateexemplephp go.php k13