Lege einen Stein auf ein leeres Go-Brett

34

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:

       Koordinaten gehen

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 . Die kürzeste Antwort in Bytes gewinnt.

Lynn
quelle
Nur um sicherzugehen, "die Koordinate als Argument" soll bedeuten, dass wir nicht zwei Argumente nehmen können, wie f("G", 14), richtig?
FryAmTheEggman
8
Herzlichen Glückwunsch zu 20k !!
Luis Mendo
2
"Dies ist historisch gesehen, um die Verwechslung mit J und L zu verringern." Aber beide, J und L, sind auf dem Brett ??!
Fatalize
2
Ja. Natürlich hat der fehlende Brief auch mehr Verwirrung und Überraschung hervorgerufen als alles andere…
Lynn
2
@Fatalize, J und L sehen ziemlich unterschiedlich aus, da sich die unteren Teile in unterschiedliche Richtungen drehen. Wie bei j und l steigt einer ab, der andere steigt auf. Aber ich und j sind ein bisschen ähnlich, und so sind ich, ich und ich ...
ilkkachu

Antworten:

9

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
Luis Mendo
quelle
16

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 .

owacoder
quelle
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
Vielen Dank. Ich suchte nach einer Möglichkeit, diesen Modulo-Ausdruck zu reduzieren.
Owacoder
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

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.

FryAmTheEggman
quelle
7

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')
user58321
quelle
4
Willkommen bei PPCG! Einige Vorschläge zum Reduzieren von Bytes: Verwenden Sie einen Funktionsnamen mit 1 Zeichen (oder ein Skript mit a=input('');); Zeilenumbrüche entfernen; wechseln '*'zu 42und '0'zu 48; ersetzen enddurch 19; subtrahieren Sie den logischen Wert direkt anstelle der ifVerzweigung. In der Tat können Sie die letzten fünf Zeilen durchb(20-a(2),a(1)-64-(a(1)>8))=48
Luis Mendo
Hallo und willkommen bei PPCG. Wenn ich mich nicht irre, ist Ihr Code 137 Bytes lang und nicht 135. (Ich denke, es spielt keine Rolle, aber ich wollte Sie nur wissen lassen)
Dada
7

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
}
Jordan
quelle
Ich denke, Sie können ein Byte speichern, indem Sie tun, $><<anstatt puts . Bin mir aber nicht sicher.
Nic Hartley
@QPaysTaxes Leider müsste ich dann irgendwo eine neue Zeile anhängen.
Jordanien
Oh ja. Macht nichts
Nic Hartley
6

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

Sefa
quelle
Könnten Sie 9 Zeichen durch Umbenennen partin speichern p?
CorsiKa
Golftipps in Go. Ich habe mir erlaubt, sie selbst auf Ihre Antwort anzuwenden.
EMBLEM
Haben Sie bemerkt, dass der Kommentar "+1 für die Wahl der Sprache" mehr positive Stimmen hat als der Beitrag selbst? (Es kommt vor, dass Kommentare mehr positive Stimmen haben, aber für einen solchen Kommentar ist das eher unerwartet)
Dada
4

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
Wert Tinte
quelle
Kannst du Bytes sparen, indem du prüfst, ob der Index Mod 6 3 ist, anstatt 3, 9 und 15 hart zu codieren?
FryAmTheEggman
@FryAmTheEggman Es könnte sein, aber ich habe noch keine Lösung dafür gefunden.
Value Ink
4

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)

KarlKastor
quelle
Sparen Sie 8 Bytes, indem Sie ".*oo"[2*(j==ord(x[0])-(x[0]>"I")-65and int(x[1:])==i+1)+(i%6==j%6==3)]anstelle von"o"if...else"*"if...else"."
RootTwo den
Außerdem glaube ich , die Sie verwenden können , (x>'I')anstatt (x[0]>'I')zu 3 weitere Bytes zu speichern.
RootTwo
@RootTwo Danke, der erste Vorschlag ist nicht mehr sinnvoll, da ich seitdem eine noch kürzere Lösung gefunden habe. Der zweite scheint jetzt offensichtlich und lässt mich fragen, warum ich nicht früher darüber nachgedacht habe.
Karl Kastor
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^^

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.

Sp3000
quelle
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 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

Asibahi
quelle
Oh das war das Problem. Komisch, das ist das Einzige, was ich mir nicht zweimal angesehen habe
Asibahi
3

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!

Undichte Nonne
quelle
2
Hey, Glückwunsch zu deinem goldenen Abzeichen!
Luis Mendo
3

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!

Dada
quelle
Nizza Verwendung von mehr magischen Variablen wieder! Ich habe das nicht richtig getestet, aber ich denke, Sie können ein paar mehr speichern @v=([(".")x18])x18;, um die Liste zu initialisieren ... Es könnte sogar einen besseren Weg geben, aber ich bin gerade nicht an einem Terminal! Ich denke, Sie können die @{...}Erweiterung auch durch Dereferenzierungspfeile ersetzen : $v[$_]->[@t]Wieder ungetestet! Ich hoffe, es macht Ihnen nichts aus, wenn ich Ihnen Codeänderungen vorschlage ...
Dom Hastings
1
@DomHastings Natürlich macht es mir nichts aus, im Gegenteil, ich möchte Sie eher ermutigen, Verbesserungen vorzuschlagen! @v=([(".")x19])x19funktioniert nicht (ich habe es vor Übrigens versucht), weil es nur ein Arrayref erstellt und das 19-fache der Referenz kopiert, nicht das Array. Ersetzen, @{..}wie Sie vorgeschlagen haben, scheint auch nicht zu funktionieren. Ich schätze, das liegt daran, dass ich an einem Slice arbeite und nicht nur an einem Element. Wenn Sie einen anderen Vorschlag haben, können Sie ihn gerne vorschlagen! :)
Dada
1
Verdammt, natürlich würde es gleich sein ... Ich habe zu verwenden verwaltet evalfür -3 aber: @v=eval"[('*')x19],"x19;. Und Sie sind zu 100% korrekt mit der Array-Referenz. Ist es vielleicht möglich, ein 1D-Array zu verwenden und den Index darin zu berechnen? Könnte später mehr damit spielen!
Dom Hastings
@DomHastings Danke für die -3 Bytes. Vielleicht etwas, um es mit einem 1D-Array zu versuchen. Ich werde es bald versuchen
Dada
3

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

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

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

AdmBorkBork
quelle
2

> <> 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 '.'
owacoder
quelle
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)

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
Neil
quelle
Ein Array von Zeichenfolgen entspricht nicht der erforderlichen Ausgabe join. Außerdem setzt es das o in die falsche Zeile und die falsche Spalte für D5 (erster Testfall).
Konijn
@tomdemuyt Ein Array von Zeichenfolgen ist als Rückgabewert zulässig. Es ist jedoch möglich, dass ich meine Zeilen und Spalten verwechselt habe, also überprüfe ich es noch einmal.
Neil
Hmm, in der Tat Reihe von Streichern
Konijn
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="")}

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

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.

Ein Taco
quelle
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";}

Mein erster Golf.

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

gabe3886
quelle