Zobacz także: Wykonaj ruch na planszy Go .

Zadanie

Go to gra planszowa, w której dwóch graczy (czarno-biały) umieszcza kamienie na przecięciach linii siatki na planszy 19 × 19. Czarne poruszają się jako pierwsze - na przykład na D4:

W tym wyzwaniu musisz wziąć współrzędną planszy Go D4jako dane wejściowe i wygenerować reprezentację tablicy ASCII z pierwszym ruchem zagranym w danym punkcie.

Zauważ, że nie ma kolumny I. Historycznie ma to na celu zmniejszenie pomyłek z J i L.

Ten wynik składa się z 19 wierszy, z których każdy zawiera 19 znaków. Punkt z kamieniem jest oznaczony O. Puste punkty na pokładzie są pokazane jako ., z wyjątkiem dziewięciu punktów gwiazdy (w D4, D10, D16, K4, K10, K16, Q4, Q10, i Q16), które są zaznaczone *.

Na przykład podany F5jako dane wejściowe wynik wyjściowy Twojej odpowiedzi musi wynosić:

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

I podane Q16jako dane wejściowe, twój wynik musi być:

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

Zasady

• Możesz napisać funkcję, która przyjmuje współrzędną jako argument, lub program, który odczytuje współrzędne z wiersza poleceń lub z STDIN.

• Możesz zaakceptować wprowadzanie zarówno małymi, jak i dużymi literami, ale twoja odpowiedź nie musi obsługiwać obu.

• Dane wejściowe są zawsze pojedynczymi ciągami, takimi jak a1lub T19, nigdy ciągiem + liczbą lub dwoma ciągami.

• Jeśli piszesz pełny program, twoja odpowiedź musi być wydrukowana STDOUTjako ciąg znaków, opcjonalnie po nim końcowy znak nowej linii. Jeśli odpowiedź jest funkcją, można drukować STDOUT, lub  powrócić ciąg, albo  zwracają tablicę / listę ciągów (wiersze), lub  wrócić dwuwymiarową tablicę lub zagnieżdżony listę znaków.

• To jest golf golfowy . Najkrótsza odpowiedź w bajtach wygrywa.

MATL , 33 bajty

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

Wypróbuj online!

Wyjaśnienie

'*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 bajtów

Zapisano 1 bajt dzięki @FryAmTheEggman, 5 bajtów dzięki @orlp

Call f()z pozycją do gry (musi być pisane wielkimi literami), a to drukuje wynikową planszę.

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

Wypróbuj na 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

Funkcja, która drukuje płytę do STDOUT. Wymaga, aby współrzędna litery była wielka. Drukowanie w jednej pętli wydaje się być nieco krótsze niż w przypadku poprzedniej metody zagnieżdżonej.

MATLAB, 135 bajtów

Pierwsza próba, nic sprytnego, aby zobaczyć, jak wiele inni mogą zrobić:

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'

Stosowanie:

go('T19')

Ruby, 93 91 bajtów

Pobiera dane z wiersza poleceń, np $ 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??*:?.}*""}

Przetestuj na repl.it (tam zawarty w lambda, ponieważ repl.it nie przyjmuje argumentów wiersza poleceń: https://repl.it/CkvT/1

Bez golfa

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
}

Udać się, 319 286 bajtów

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}

Prawdopodobnie rzuciłem trochę golfa, jestem początkujący

Rubin, 130 128 121 + 3 ( -nflaga) = 124 bajty

Przełączono -pna, -nponieważ puts bjest o jeden bajt krótszy niż$_=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 bajtów

-3 Bajty dzięki @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]]

anonimowa funkcja lambda, przyjmuje dane w postaci „A1” (duże litery) i wyświetla listę list znaków (len == 1 ciągi znaków w Pythonie)

> <> , 98 96 bajtów

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

Zauważ, że 0x14w pierwszym rzędzie jest pierwszy wiersz ', a 0x19między 9pierwszym ^a ostatnim wierszem.Wypróbuj online!

Dane wejściowe są odwzorowywane w taki sposób, że A-Tstają się 1-19(przy czym 0 oznacza fikcyjną kolumnę „nowej linii”), a liczba wierszy liczb całkowitych jest zmniejszana o 1. Program wykonuje pętlę od 379 do 0, wybierając znak z dolnego wiersza w miarę jak ( przesunięty o 15, aby uwzględnić fakt, że nie można wprowadzić dosłownego nowego wiersza w pudełku kodowym). Nowe linie są sprawdzane przez i % 20 == 0, a punkty w gwiazdkach sprawdzane przez ((i%20-1)%6)*((i/20)%6) == 9.

F #, 241 237 225 216 214 211 bajtów

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

Ten podstępny ten ... Zastanawiam się, czy można go skrócić.

Edycja: naprawiono błąd, dodano liczby w niektórych miejscach usunięto liczby w innych, jakoś skończyło się z tą samą liczbą. Może później spróbować przetasować liczby Gotowe.

Edycja2: zapisano więcej bajtów, wypowiadając jeden z warunków, licząc intuicyjnie.

Edycja3: Naprawiono kolejny błąd: powinien działać teraz dla elementów z ostatniej rangi i jakoś udało mi się zaoszczędzić dwa bajty.

Wypróbuj online

Siatkówka , 134 129 122 bajtów

11 bajtów dzięki Martinowi Enderowi i za inspirację jeszcze 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^$`

Wypróbuj online!

Perl, 132 bajty

-3 bajty dzięki @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;

Pobiera dane z wiersza poleceń. Potrzebuje -M5.010uruchomienia. Na przykład :

$ 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

Myślę, że może to być krótsze, ale nie mogłem wymyślić, jak ... proszę dać mi znać, jeśli tak!

Partia, 322 310 308 bajtów

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

Objaśnienie: Zaczyna się od pytania o kamień na stdin. Następnie ustawia zmienne dla każdej możliwej kolumny, aby mógł ocenić pierwszy znak kamienia jako zmienną w celu uzyskania ywspółrzędnych. Odejmuje 1 od xwspółrzędnej, ponieważ jest indeksowana 1, a my chcemy indeksować 0, a także obliczamy, z=y+1ponieważ będzie to później potrzebne. Następnie pętle rod 18 w dół do 0 dla każdego wiersza. Bierze ciąg ...*.....*.....*...i wyodrębnia znak z rpozycji th na później. W xwierszu yth znak th zastępuje się znakiem o. Wreszcie,.* s są zamieniane na .plus poprzednio wyodrębnionego znaku; jest to brak opcji w wierszach 4, 10 i 16, ale jest to najkrótszy sposób na osiągnięcie tego. (Muszę użyć.*ponieważ wymiana *jest najwyraźniej nielegalna w partii.)

PowerShell v2 +, 157 152 bajtów

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

_{(Wydaje mi się, że wpadłem na jakąś dziwną usterkę z operatorem przecinka, więc konstrukcja tablicy jest nieco dłuższa niż powinna)}

Pobiera dane wejściowe jako ciąg wielkich liter $args[0], rzutuje je jako tablicę znaków , przechowuje pierwszą literę w, $xa pozostałe litery w $y. To skutecznie dzieli dane wejściowe na literę / cyfrę.

Następnie konstruujemy naszą tablicę wielowymiarową $a. My wstępnie wypełnić tablicę wielkości 19z 0S i przecinkami operatora. Następnie zapętlamy, 0..18aby każdy element był $a[$_]równy tablicy okresów, ponownie używając operatora przecinka. (NB - Teoretycznie powinno się to skondensować $a=,(,'.'*19)*19, ale wydaje się , że to nie działa poprawnie z przypisaniem indeksowania ... Skończyło się na ustawieniu całych kolumn na *)

Następnie zapętlamy dwa razy, 3,9,15aby ustawić odpowiednie elementy na *. Następnie indeksujemy go w odpowiednim miejscu, aby ustawić kamień O. Aby to zrobić, odejmujemy 65od $x(tj. ASCII „A” wynosi 65, a my indeksujemy zero) i odejmujemy dodatkowy za pomocą rzutowania logicznego na int, jeśli $xjest większy niż 73(tj. ASCII „I” ).

Teraz nasze dane wyjściowe są odwrócone (tzn. Lewy górny byłby A1), więc musimy odwrócić tablicę za pomocą $a[18..0]. Na koniec wyprowadzamy każdą linię -joinrazem, tworząc ciąg.

> <> , 124 bajty

Używa dokładnie tego samego podejścia, co moja odpowiedź C. Wprowadzanie musi być wielką literą, po której następuje liczba dziesiętna.

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

Wypróbuj online!

Wyjaśnienie:

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 bajtów

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)

Zwraca tablicę ciągów. Wyjaśnienie:

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 bajtów

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

Z wcięciami i znakami nowej linii:

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

Stosowanie:

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

Lua, 187 bajtów

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

Nie jest mi przykro z powodu 187 tego konkretnego projektu. Lua wciąż wydaje się być niezgrabna dla golfistów, ale jestem dumna z tego, jak daleko mogę się posunąć.

PHP, 280 268 263 261 255 218 216 bajtów

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

Mój pierwszy golf.

Sposób użycia:
Zapisz jako plik PHP i wywołaj go php filename.php coordinatenpphp go.php k13