Siehe auch: Mach einen Zug auf einem Go-Brett .

Aufgabe

Go ist ein Brettspiel, bei dem zwei Spieler (Schwarz und Weiß) Steine ​​auf die Schnittpunkte der Gitterlinien auf einem 19 × 19-Brett legen. Schwarz zieht zuerst - zum Beispiel auf D4:

In dieser Herausforderung müssen Sie eine Go-Brett-Koordinate wie D4als Eingabe nehmen und eine ASCII-Darstellung eines Brettes mit dem ersten Zug ausgeben, der an dem angegebenen Punkt gespielt wird.

Es ist zu beachten, dass es keine Spalte I gibt. Dies dient historisch gesehen dazu, die Verwechslung mit J und L zu verringern.

Diese Ausgabe besteht aus 19 Zeilen mit jeweils 19 Zeichen. Der Punkt mit dem Stein ist markiert O. Leere Punkte auf dem Brett sind , wie gezeigt ., mit Ausnahme der neun Sternpunkte (auf D4, D10, D16, K4, K10, K16, Q4, Q10, und Q16), die gekennzeichnet sind *.

Beispiel: F5Als Eingabe muss die Ausgabe Ihrer Antwort lauten:

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

Und Q16als Eingabe angegeben, muss Ihre Ausgabe sein:

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

Regeln

• Sie können eine Funktion schreiben, die die Koordinate als Argument verwendet, oder ein Programm, das die Koordinate von der Befehlszeile oder von liest STDIN.

• Sie können wählen, ob Sie Eingaben in Klein- oder Großbuchstaben akzeptieren möchten, Ihre Antwort muss jedoch nicht beide behandeln.

• Die Eingabe ist immer eine einzelne Zeichenfolge wie a1oder T19, niemals eine Zeichenfolge + Zahl oder zwei Zeichenfolgen.

• Wenn Sie ein vollständiges Programm schreiben, muss Ihre Antwort STDOUTals Zeichenfolge gedruckt werden , optional gefolgt von einer abschließenden Newline. Wenn Ihre Antwort ist eine Funktion, können Sie drucken STDOUT, oder  einen String zurückgeben, oder  einen Array / Liste von Strings (Zeilen), oder  geben eine zweidimensionale Anordnung oder verschachtelte Liste von Zeichen.

• Das ist Code-Golf . Die kürzeste Antwort in Bytes gewinnt.

MATL , 33 Bytes

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

Probieren Sie es online!

Erläuterung

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

1 Byte dank @FryAmTheEggman gespeichert, 5 Byte dank @orlp

Rufen Sie f()mit der Position zum Spielen an (muss in Großbuchstaben geschrieben werden), und es wird die resultierende Tafel ausgedruckt.

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

Probiere es auf ideone aus .

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

Eine Funktion, die die Karte nach STDOUT druckt. Erfordert die Buchstabenkoordinate als Großbuchstaben. Das Drucken in einer Schleife scheint etwas kürzer zu sein als beim vorherigen Ansatz mit verschachtelten Schleifen.

MATLAB, 135 Bytes

Ein erster Versuch, nichts Schlaues, nur um zu sehen, wie viel besser andere können:

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'

Verwendung:

go('T19')

Ruby, 93 91 Bytes

Übernimmt Eingaben in der Kommandozeile, z $ 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??*:?.}*""}

Testen Sie es auf repl.it (dort in ein Lambda eingeschlossen, da repl.it keine Befehlszeilenargumente akzeptiert: 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
}

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

Wahrscheinlich golfen ein bisschen aufhören, ich bin ein Anfänger

Ruby, 130 128 121 + 3 ( -nFlag) = 124 Bytes

Umgestellt -pauf, -nweil puts bein Byte kürzer ist als$_=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 dank @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]]

anonyme Lambda-Funktion, übernimmt die Eingabe der Form "A1" (Großbuchstaben) und gibt eine Liste mit Zeichenlisten aus (len == 1 Strings in 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^^

Beachten Sie, dass sich 0x14in der ersten Zeile nach der ersten 'und 0x19zwischen 9der ersten ^und der letzten Zeile eine befindet. Probieren Sie es online!

Die Eingabe wird so zugeordnet, dass A-Tsie 1-19(wobei 0 eine imaginäre "Newline" -Spalte bedeutet) wird und die ganzzahlige Zeilennummer um 1 dekrementiert wird. Das Programm führt eine Schleife von 379 bis 0 durch und wählt dabei ein Zeichen aus der untersten Zeile aus ( um 15 versetzt, um die Tatsache zu berücksichtigen, dass Sie in der Codebox keinen wörtlichen Zeilenumbruch eingeben können). Zeilenumbrüche werden i % 20 == 0mit und Sternchen mit geprüft ((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".")

Tricky one this one ... Ich frage mich, ob es kürzer gemacht werden kann.

Bearbeiten: Fehler behoben, Nummern hinzugefügt, an einigen Stellen Nummern entfernt, irgendwie mit der gleichen Anzahl beendet. Vielleicht versuchen Sie es später noch einmal. Fertig.

Edit2: mehr Bytes gespart, indem eine der Bedingungen formuliert wurde, was sich intuitiv widerspiegelt.

Edit3: Ein weiterer Fehler wurde behoben: Sollte jetzt für Teile mit dem letzten Rang funktionieren und es gelang mir irgendwie, zwei Bytes zu sparen, während ich dabei bin.

Probieren Sie es online aus

Retina , 134 129 122 Bytes

11 Bytes danke an Martin Ender und für die Inspiration von 1 weiteren.

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

Probieren Sie es online!

Perl, 132 Bytes

-3 Bytes dank @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;

Übernimmt die Eingabe über die Befehlszeile. Muss -M5.010laufen. Zum Beispiel :

$ 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

Ich denke, das könnte kürzer sein, aber ich konnte nicht herausfinden, wie ... lass es mich wissen, wenn du es tust!

Batch, 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%%%

Erläuterung: Beginnt mit der Aufforderung, den Stein auf stdin einzugeben. Setzt dann Variablen für jede mögliche Spalte, so dass das erste Zeichen des Steins als Variable ausgewertet werden kann, um die yKoordinate zu erhalten. Subtrahiert 1 von der xKoordinate, weil sie 1-indiziert ist und 0-indiziert sein soll, und berechnet auch, z=y+1wie es später benötigt wird. Anschließend werden rfür jede Zeile Schleifen von 18 bis 0 ausgeführt. Nimmt die Zeichenfolge ...*.....*.....*...und extrahiert das Zeichen an der rdritten Position für später. In der xdritten Zeile wird das ydritte Zeichen durch ein ersetzt o. Schließlich wird das .*s durch ein .Pluszeichen des zuvor extrahierten Zeichens ersetzt. Dies ist ein No-Op für die Zeilen 4, 10 und 16, aber dies ist der kürzeste Weg, um dies zu erreichen. (Ich muss benutzen.*weil das Ersetzen *in Batch anscheinend illegal ist.)

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

_{(Ich glaube, ich bin mit dem Komma-Operator auf eine seltsame Panne gestoßen, daher ist die Array-Konstruktion etwas länger als sie sein sollte.)}

Nimmt die Eingabe als Zeichenfolge in Großbuchstaben über $args[0], wandelt sie in ein Zeichen-Array um, speichert den ersten Buchstaben $xund die verbleibenden Buchstaben in $y. Dies teilt die Eingabe effektiv in Buchstaben / Zahlen auf.

Wir konstruieren dann unser mehrdimensionales Array $a. Wir füllen ein Array von Größen 19mit 0s vor, indem wir den Komma-Operator verwenden. Wir schleifen dann 0..18, um jedes Element $a[$_]gleich zu machen, stattdessen ein Array von Punkten, wieder unter Verwendung des Komma-Operators. (NB - Theoretisch sollte dies in der Lage sein, komprimiert zu werden $a=,(,'.'*19)*19, aber das scheint bei der Indizierungszuweisung nicht richtig zu funktionieren ... Ich habe es geschafft, ganze Spalten auf zu setzen. *)

Als nächstes durchlaufen wir die Schleife zweimal 3,9,15, um die entsprechenden Elemente auf zu setzen *. Wir indizieren es dann an der richtigen Stelle, um den Stein zu setzen O. Dazu subtrahieren wir 65von $x(dh ASCII "A" ist 65, und wir sind null-indiziert) und subtrahieren eine zusätzliche Eins unter Verwendung einer Umwandlung von Boolesch nach Int, wenn $xgrößer ist als 73(dh ASCII "I"). ).

Jetzt ist unsere Ausgabe umgekehrt (dh oben links wäre A1), also müssen wir das Array mit umkehren $a[18..0]. Schließlich geben wir jede Zeile -joinzusammen als String aus.

> <> 124 Bytes

Verwendet genau den gleichen Ansatz wie meine C-Antwort. Die Eingabe muss aus einem Großbuchstaben gefolgt von einer Dezimalzahl bestehen.

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

Probieren Sie es online!

Erläuterung:

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)

Gibt ein Array von Zeichenfolgen zurück. Erläuterung:

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

Mit Einrückungen und Zeilenumbrüchen:

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

Verwendung:

> 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

Ich fühle mich nicht schlecht wegen 187 für dieses spezielle Projekt. Lua kommt immer noch als sehr klobig zum Golfen heraus, aber ich bin ziemlich stolz darauf, wie weit ich damit kommen kann.

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

Mein erster Golf.

Verwendung:
Speichern Sie als PHP-Datei und rufen Sie sie php filename.php coordinatezB aufphp go.php k13