Xem thêm: Thực hiện di chuyển trên một bảng Go .

Bài tập

Go là một trò chơi bảng trong đó hai người chơi (Đen và Trắng) đặt đá trên các giao điểm của các đường lưới trên bảng 19 × 19. Đen di chuyển trước - ví dụ, trên D4:

Trong thử thách này, bạn phải thực hiện tọa độ bảng Go D4như đầu vào và xuất đại diện ASCII của một bảng với bước di chuyển đầu tiên được phát tại điểm đã cho.

Lưu ý rằng không có cột I. Điều này, về mặt lịch sử, để giảm sự nhầm lẫn với J và L.

Đầu ra này bao gồm 19 dòng, mỗi dòng chứa 19 ký tự. Điểm với đá trên đó được đánh dấu O. Điểm trống trên bảng được hiển thị như ., ngoại trừ chín điểm sao (ít D4, D10, D16, K4, K10, K16, Q4, Q10, và Q16), được đánh dấu *.

Ví dụ: được cung cấp F5làm đầu vào, đầu ra câu trả lời của bạn phải là:

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

Và được đưa ra Q16làm đầu vào, đầu ra của bạn phải là:

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

Quy tắc

• Bạn có thể viết một hàm lấy tọa độ làm đối số hoặc chương trình đọc tọa độ từ dòng lệnh hoặc từ STDIN.

• Bạn có thể chọn chấp nhận đầu vào bằng chữ thường hoặc chữ hoa, nhưng câu trả lời của bạn không cần xử lý cả hai.

• Đầu vào là luôn luôn một chuỗi duy nhất như a1hoặc T19, không bao giờ một số chuỗi + hoặc hai chuỗi.

• Nếu bạn viết một chương trình đầy đủ, câu trả lời của bạn phải được in thành STDOUTmột chuỗi, tùy ý theo sau là một dòng mới. Nếu câu trả lời của bạn là một chức năng, bạn có thể in ra STDOUT, hoặc  trả về một chuỗi, hoặc  trả lại một mảng / danh sách các chuỗi (hàng), hoặc  trả lại một mảng hai chiều hoặc danh sách lồng nhau của các nhân vật.

• Đây là mã golf . Câu trả lời ngắn nhất trong byte thắng.

MATL , 33 byte

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

Hãy thử trực tuyến!

Giải trình

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

Đã lưu 1 byte nhờ @FryAmTheEggman, 5 byte nhờ @orlp

Gọi f()với vị trí để chơi (phải được viết hoa) và nó in ra bảng kết quả.

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

Hãy thử nó trên 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;}

Ý tưởng

Một chức năng in bảng thành STDOUT. Yêu cầu phối hợp chữ cái để được vốn. In trong một vòng lặp dường như ngắn hơn một chút so với cách tiếp cận vòng lặp lồng nhau trước đó.

MATLAB, 135 byte

Một nỗ lực đầu tiên, không có gì thông minh, chỉ để xem người khác có thể làm tốt hơn bao nhiêu:

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'

Sử dụng:

go('T19')

Ruby, 93 91 byte

Đưa đầu vào vào dòng lệnh, vd $ 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??*:?.}*""}

Kiểm tra nó trên repl.it (được bọc trong lambda ở đó vì repl.it không lấy các đối số dòng lệnh: https://repl.it/CkvT/1

Bị đánh cắp

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
}

Đi, 319 286 byte

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}

Có lẽ golf có thể bỏ một chút, tôi là người mới bắt đầu

Ruby, 130 128 121 + 3 ( -ncờ) = 124 byte

Chuyển -psang -nvì puts bngắn hơn một byte so với$_=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 byte

-3 Byte nhờ @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]]

Hàm lambda ẩn danh, nhận đầu vào có dạng "A1" (chữ lớn) và xuất ra danh sách các danh sách ký tự (len == 1 chuỗi trong Python)

> <> , 98 96 byte

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

Lưu ý rằng có một 0x14hàng đầu tiên sau hàng đầu tiên 'và 0x19giữa 9hàng đầu tiên và hàng đầu tiên ^. Hãy thử trực tuyến!

Đầu vào được ánh xạ sao cho A-Ttrở thành 1-19(với 0 biểu thị một cột "dòng mới" tưởng tượng) và số hàng nguyên được giảm đi 1. Chương trình thực hiện một vòng lặp từ 379 xuống 0, chọn một char từ hàng dưới cùng khi nó đi ( bù lại bằng 15, để giải thích cho việc bạn không thể nhập một dòng mới theo nghĩa đen trong bảng mã). Các dòng mới được kiểm tra thông qua i % 20 == 0và các điểm sao được kiểm tra bởi ((i%20-1)%6)*((i/20)%6) == 9.

F #, 241 237 225 216 214 211 byte

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

Lừa một cái này ... Tôi tự hỏi nếu nó có thể được làm ngắn hơn.

Chỉnh sửa: đã sửa một lỗi, thêm số một số vị trí đã xóa số ở những người khác, bằng cách nào đó đã kết thúc với cùng một số lượng. Có thể thử xáo trộn số xung quanh sau Xong.

Edit2: lưu nhiều byte hơn bằng cách đánh vần một trong các điều kiện, truy cập trực quan.

Edit3: Đã sửa một lỗi khác: nên hoạt động ngay bây giờ cho các mảnh ở thứ hạng cuối cùng và quản lý để lưu hai byte trong khi tôi đang ở đó, bằng cách nào đó.

Dùng thử trực tuyến

Võng mạc , 134 129 122 byte

11 byte nhờ Martin Ender và cho cảm hứng thêm 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^$`

Hãy thử trực tuyến!

Perl, 132 byte

-3 byte nhờ @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;

Đưa đầu vào dòng lệnh. Cần -M5.010tu chạy. Ví dụ :

$ 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

Tôi nghĩ rằng điều này có thể ngắn hơn, nhưng tôi không thể hiểu làm thế nào ... xin vui lòng cho tôi biết nếu bạn làm!

Hàng loạt, 322 310 308 byte

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

Giải thích: Bắt đầu bằng cách nhắc đá trên stdin. Sau đó, đặt các biến cho mỗi cột có thể, để nó có thể đánh giá ký tự đầu tiên của viên đá là biến để lấy ytọa độ. Trừ 1 từ xtọa độ vì nó được lập chỉ mục 1 và chúng tôi muốn lập chỉ mục 0 và cũng sẽ tính toán z=y+1vì nó sẽ cần điều đó sau. Sau đó, các vòng lặp rtừ 18 xuống 0 cho mỗi hàng. Lấy chuỗi ...*.....*.....*...và trích xuất ký tự ở rvị trí thứ sau. Trên xhàng thứ, yký tự thứ được thay thế bằng một o. Cuối cùng, các .*s được thay thế bằng một .ký tự cộng được trích xuất trước đó; đây không phải là hàng trên các hàng 4, 10 và 16 nhưng đây là cách ngắn nhất để đạt được điều đó. (Tôi phải dùng.*bởi vì thay thế *rõ ràng là bất hợp pháp trong Batch.)

PowerShell v2 +, 157 152 byte

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

_{(Tôi nghĩ rằng tôi đã gặp phải một số trục trặc kỳ lạ với toán tử dấu phẩy, do đó việc xây dựng mảng dài hơn một chút so với bình thường)}

Đưa đầu vào dưới dạng một chuỗi chữ hoa thông qua $args[0], biến nó thành một mảng char, lưu chữ cái đầu tiên vào $xvà các chữ cái còn lại vào $y. Điều này có hiệu quả phân chia đầu vào thành chữ / số.

Sau đó chúng tôi xây dựng mảng đa chiều của chúng tôi $a. Chúng tôi điền trước một mảng kích thước19 với 0s bằng toán tử dấu phẩy. Sau đó, chúng tôi lặp 0..18để làm cho mỗi phần tử $a[$_]bằng nhau thay vì một mảng các dấu chấm, một lần nữa sử dụng toán tử dấu phẩy. (NB - Về lý thuyết, điều này sẽ có thể được cô đọng lại $a=,(,'.'*19)*19, nhưng điều đó dường như không hoạt động đúng với việc gán chỉ mục ... Tôi cố gắng để toàn bộ các cột được đặt thành *)

Tiếp theo, chúng tôi lặp lại hai lần 3,9,15để đặt các yếu tố tương ứng thành* . Sau đó chúng tôi lập chỉ mục vào đúng vị trí để đặt viên đá O. Để làm như vậy, chúng ta trừ 65từ $x(ví dụ, ASCII "A" là 65, và chúng tôi không lập chỉ mục), và trừ là một bổ sung sử dụng một Boolean-to-int cast nếu $xlớn hơn 73(ví dụ, ASCII "I" ).

Bây giờ, đầu ra của chúng ta bị đảo ngược (nghĩa là phía trên bên trái sẽ là A1), vì vậy chúng ta cần đảo ngược mảng với $a[18..0]. Cuối cùng, chúng tôi xuất ra từng dòng-join ed với nhau để tạo thành một chuỗi.

> <> , 124 byte

Sử dụng cách tiếp cận chính xác như câu trả lời C của tôi. Đầu vào phải là chữ in hoa theo sau là số thập phân.

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

Hãy thử trực tuyến!

Giải trình:

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 byte

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)

Trả về một chuỗi các chuỗi. Giải trình:

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 byte

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

Với thụt lề và dòng mới:

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

Sử dụng:

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

Lua, 187 byte

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

Tôi không cảm thấy quá tệ về 187 cho dự án cụ thể này. Lua vẫn rất hay chơi golf, nhưng tôi rất tự hào về việc tôi có thể đi được bao xa.

PHP, 280 268 263 261 255 218 216 byte

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

Golf đầu tiên của tôi.

Cách sử dụng:
Lưu dưới dạng tệp PHP và gọi nó bằng php filename.php coordinatevdphp go.php k13