Umieść kamień na pustej planszy Go

34

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:

       idź współrzędne

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 . Najkrótsza odpowiedź w bajtach wygrywa.

Lynn
źródło
Dla pewności „współrzędna jako argument” ma sugerować, że nie możemy przyjąć dwóch argumentów, na przykład f("G", 14), prawda?
FryAmTheEggman
8
Gratulacje na 20k !!
Luis Mendo,
2
„Historycznie ma to na celu zmniejszenie zamieszania w stosunku do J i L.” Ale zarówno J, jak i L są na płycie?
Fatalize
2
Tak. Oczywiście brakujący list spowodował prawdopodobnie więcej zamieszania i zaskoczenia niż cokolwiek…
Lynn
2
@Fatalize, J i L wyglądają dość wyraźnie, ponieważ dolne części obracają się w oddzielnych kierunkach. Podobnie jak w j i l, jedno zstępuje, drugie idzie w górę. Ale ja i j są trochę podobne, podobnie jak ja, ja i ja ...
ilkkachu

Odpowiedzi:

9

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
Luis Mendo
źródło
16

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 .

owacoder
źródło
2
98 bajtówputchar(i%20?i^20*atoi(p+1)+64-*p+(*p>72)?i%6^4|i/20%6^3?46:42:79:10)
lub
Dzięki. Szukałem sposobu na zmniejszenie ekspresji modulo.
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

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.

FryAmTheEggman
źródło
7

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')
użytkownik58321
źródło
4
Witamy w PPCG! Kilka sugestii dotyczących zmniejszenia bajtów: użyj nazwy funkcji z 1 char (lub skryptu z a=input('');); usuń nowe linie; zmienić '*'na 42i '0'na 48; zastąpić endprzez 19; odejmij wartość logiczną bezpośrednio zamiast ifgałęzi. W rzeczywistości można zastąpić ostatnie wiersze five przezb(20-a(2),a(1)-64-(a(1)>8))=48
Luisa Mendo
Witam i witam w PPCG. Jeśli się nie mylę, twój kod ma długość 137 bajtów i nie 135. (Chyba nie ma to większego znaczenia, ale chciałem cię tylko poinformować)
Dada
7

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
}
Jordania
źródło
Myślę, że możesz zapisać bajt, wykonując $><<zamiast puts . Jednak nie jestem pewien.
Pozew funduszu Moniki
@QPaysTaxes Niestety, musiałbym gdzieś dodać nową linię.
Jordan,
O tak. Nieważne
pozew Fund Moniki
6

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

Sefa
źródło
Czy możesz zapisać 9 znaków, zmieniając nazwę partna p?
corsiKa,
Wskazówki dotyczące gry w golfa w Go. Pozwoliłem sobie zastosować je do twojej odpowiedzi.
EMBLEMAT
Czy zauważyłeś, że komentarz „+1 do wyboru języka” ma więcej głosów pozytywnych niż sam post? (zdarza się, że komentarze mają więcej pozytywnych opinii, ale dla takiego komentarza jest to raczej nieoczekiwane)
Dada
4

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
Wartość tuszu
źródło
Czy możesz zaoszczędzić bajty, sprawdzając, czy indeks mod 6 wynosi 3 zamiast twardego kodowania 3, 9 i 15?
FryAmTheEggman
@FryAmTheEggman To może, ale jeszcze nie znalazłem rozwiązania, które to robi.
Wartość tuszu
4

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)

KarlKastor
źródło
Zaoszczędź 8 bajtów, używając ".*oo"[2*(j==ord(x[0])-(x[0]>"I")-65and int(x[1:])==i+1)+(i%6==j%6==3)]zamiast"o"if...else"*"if...else"."
RootTwo
Myślę też, że możesz użyć (x>'I')zamiast (x[0]>'I')zaoszczędzić jeszcze 3 bajty.
RootTwo
@RootTwo Dzięki, pierwsza sugestia nie jest już przydatna, ponieważ od tego czasu znalazłem jeszcze krótsze rozwiązanie. Drugi wydaje się teraz oczywisty i każe mi zapytać, dlaczego wcześniej o tym nie myślałem.
KarlKastor,
4

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

Sp3000
źródło
4

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

asibahi
źródło
To był problem. Zabawne, to jedna rzecz, na którą nie
patrzyłem
3

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!

Leaky Nun
źródło
2
Hej, gratuluję złotej odznaki!
Luis Mendo,
3

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!

Dada
źródło
Przyjemne użycie więcej magicznych zmiennych ponownie! Nie przetestowałem tego poprawnie, ale myślę, że możesz zaoszczędzić jeszcze kilka @v=([(".")x18])x18;na inicjalizacji listy ... Może być nawet lepszy sposób, ale nie jestem teraz w terminalu! Myślę, że możesz zastąpić @{...}rozszerzenie również strzałkami dereferencyjnymi: $v[$_]->[@t]jeszcze raz niesprawdzone! Mam również nadzieję, że nie masz nic przeciwko sugerowaniu zmian w kodzie ...
Dom Hastings,
1
@DomHastings Oczywiście nie mam nic przeciwko, wręcz przeciwnie, wolałbym zachęcić cię do zasugerowania ulepszeń! @v=([(".")x19])x19nie działa (próbowałem przed btw), ponieważ tworzy tylko jedną tablicę referencji i kopiuje 19 razy ref, a nie tablicę (więc ostatecznie masz tylko 1 linię zduplikowaną 19 razy). Zastąpienie @{..}zgodnie z sugestią również nie działa. Zgaduję, że to dlatego, że pracuję nad plasterkiem, a nie tylko jednym elementem. Jeśli masz jakieś inne sugestie, możesz je zasugerować! :)
Dada,
1
Cholera, oczywiście, że to będzie takie samo ... udało mi się stosowania evaldo -3 jednak: @v=eval"[('*')x19],"x19;. I jesteś w 100% poprawny z arrayref ... Czy może jest jednak możliwe użycie tablicy 1D i opracowanie indeksu? Może później z tym pogrywamy!
Dom Hastings,
@DomHastings Dzięki za -3 bajty. Może rzeczywiście warto wypróbować macierz 1D. Spróbuję wkrótce
Dada,
3

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

Neil
źródło
2

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.

AdmBorkBork
źródło
2

> <> , 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 '.'
owacoder
źródło
1

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
Neil
źródło
Tablica ciągów nie odpowiada wymaganemu wynikowi, tylko join. Również umieszcza o w niewłaściwym wierszu i niewłaściwej kolumnie dla D5 (pierwszy przypadek testowy).
Konijn,
@tomdemuyt Tablica ciągów znaków jest dozwolona jako wartość zwracana. Możliwe jednak, że pomieszałem moje wiersze i kolumny, więc sprawdzę dokładnie.
Neil,
Hmm, rzeczywiście tablica ciągów
Konijn,
1

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.....*...
...................
...................
...................
...................
...................
...*.....*.....*...
...................
...................
...................
plannapus
źródło
1

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ąć.

ATaco
źródło
1

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

gabe3886
źródło