Tóm tắt

Cho đầu vào đại diện cho hai vectơ và "trọng số" tương ứng của chúng, tạo ra đầu ra cũng đại diện cho tổng trọng số của các vectơ đó.

Thử thách

Đầu vào sẽ bao gồm một hoặc nhiều dòng ký tự sau:

• chính xác một lần xuất hiện của chữ số 0, đại diện cho gốc tọa độ trong mặt phẳng hai chiều;
• chính xác hai chữ số khác (1-9; có thể có hoặc không cùng một chữ số), có vị trí liên quan đến gốc đại diện cho vectơ và có giá trị đại diện cho các trọng số gắn với vectơ;
• một số "nhân vật nền". Người giải có thể chọn một nhân vật nền cụ thể; ví dụ: tôi sẽ chọn "." (chủ yếu cho khả năng đọc của con người). Thay phiên, các nhân vật nền có thể là bất cứ thứ gì trông giống như không gian trống.

(Bộ giải có thể chọn đầu vào là một chuỗi nhiều dòng đơn hay một chuỗi các chuỗi một dòng.)

Ví dụ: đầu vào

....2
.0...
...3.

đại diện cho một vectơ tại tọa độ (3,1) với trọng số 2 và một vectơ tại tọa độ (2, -1) với trọng số 3.

Đầu ra phải gần giống với đầu vào, với các thay đổi sau:

• một "ký tự kết quả", được chọn bởi người giải, được thêm vào vị trí được chỉ định bởi tổng trọng số của các vectơ đầu vào (tương đương, tại vị trí là tổ hợp tuyến tính thích hợp của các vectơ đầu vào);
• càng nhiều ký tự nền cần thiết để phù hợp với nguồn gốc, hai vectơ đầu vào và vectơ đầu ra trong cùng một hình ảnh. Nhân vật nền có thể được bao gồm nếu muốn; hạn chế duy nhất là, nếu ký tự nền là ký tự hiển thị, thì toàn bộ đầu ra phải có hình chữ nhật và mọi ký tự không đại diện cho vectơ phải là ký tự nền. (Nếu không gian trống được sử dụng làm ký tự nền, thì các ràng buộc này không cần phải được thi hành.)

(Nói chung, nếu chúng ta có một vectơ (v, w) có trọng số a và vectơ thứ hai (x, y) có trọng số b, tổng trọng số của chúng là a (v, w) + b (x, y) = (av + bx, aw + by).)

Trong ví dụ trước, tổ hợp tuyến tính thích hợp là 2 * (3,1) + 3 * (2, -1) = (12, -1). Nếu chúng ta sử dụng "X" làm ký tự kết quả, thì đầu ra có thể trông như

....2.........
.0............
...3.........X

hoặc là

................
...2............
0...............
..3.........X...
................
................

Điểm golf-code thông thường : câu trả lời ngắn nhất, tính bằng byte, thắng.

Ví dụ đầu vào và đầu ra

Nếu không gian trống được sử dụng, đầu vào trên sẽ trông như

    2
 0
   3

và đầu ra sẽ như thế nào

    2
 0
   3         X

Các ký tự / dòng khoảng trắng hàng đầu / dấu là không liên quan; nếu chúng vô hình với người đọc, thì tốt thôi. (Như đã nói, trong phần còn lại của các ví dụ tôi sẽ quay lại sử dụng "." Cho ký tự nền, để dễ đọc hơn.)

Nếu cả hai vectơ có trọng số 1, thì kết quả sẽ giống như hình bình hành: đầu vào

.1.
...
1.0

dẫn đến đầu ra

X.1.
....
.1.0

Lưu ý hình bình hành này có thể suy biến nếu các vectơ đầu vào được cộng tuyến: đầu vào

0.1..1

dẫn đến đầu ra

0.1..1.X

Có thể cho vectơ kết quả bằng một trong các vectơ đầu vào hoặc gốc; trong trường hợp này, nó chỉ đơn giản ghi đè ký tự đầu vào. Ví dụ: đầu vào

..2.0.1...

mang lại sản lượng

..X.0.1...

(trong đó ở đầu vào và / hoặc đầu ra, các khoảng thời gian đầu và cuối có thể bị xóa). Đầu vào

.....3
......
...0..
......
......
2.....

mang lại sản lượng

.....3
......
...X..
......
......
2.....

Cuối cùng, đầu vào

90
.8

mang lại sản lượng

........90
.........8
..........
..........
..........
..........
..........
..........
X.........

MATL , 48 byte

tZyyX:UX>*Yat48-tt0>*3#fbbhb~2#fh-*s7M+'X'wZ}4$(

Nhân vật nền là không gian. Đầu vào là một mảng char 2D với các hàng được phân tách bằng dấu chấm phẩy. Vì vậy, các trường hợp thử nghiệm có đầu vào tương ứng:

['    2'; ' 0   '; '   3 ']
[' 1 '; '   '; '1 0']
['0 1  1']
['  2 0 1   ']
['     3'; '      '; '   0  '; '      '; '      '; '2     ']
['90'; ' 8']

Đầu ra bao gồm một lượng đáng kể khoảng trắng đệm.

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

Python 3, 374 355 byte

Giải pháp python không quá tinh tế mà rất hào phóng với phần đệm (sử dụng khoảng cách bàn cờ tối đa). Đầu vào là một dòng duy nhất nơi các hàng được phân tách bằng ống | (mặc dù thuật toán có thể dễ dàng sử dụng bất cứ thứ gì không phải là chữ và số không phải là dòng mới hoặc EOF). Bất cứ điều gì không chữ và số | làm việc cho phần đệm đầu vào, phần đệm đầu ra sử dụng dấu chấm. Phản hồi và cải thiện từ những người chơi golf trăn dày dạn hơn được đánh giá cao.

Chỉnh sửa: Một số cải tiến nhờ @TheBikingViking. Ngoài ra còn được thêm nhiều lợi nhuận vì tôi không đủ hào phóng với việc đệm.

s=input()
l=[len(s),1+s.find('|')]['|'in s]
P=sorted([int(c),i%l,i//l]for i,c in enumerate(s)if c.isalnum())
L=X=Y=0
P[0][0]=-sum(p[0]for p in P)
for w,x,y in P:L=max(abs(x),abs(y),L);X+=x*w;Y+=y*w
P+=[['X',P[0][1]+X,P[0][2]+Y]]
P[0][0]=0
L=2*max(abs(X),abs(Y),L)
S=[2*L*["."]for _ in[0]*2*L]
for w,x,y in P:S[L+y][L+x]=str(w)
for s in S:print(''.join(s))

JavaScript, 534 528 502 byte

n="indexOf"
J="join"
B=X=>X.split(O)
O='\n'
w=i[n](O)+1
h=B(i).length
Z=(X,Y,R)=>{C[R]+=X-1;return Array(X)[J](Y)}
C=[0,0,0]
G=(X,E,T,U,R)=>X>0&E>=0?Z(X+E+1+T,U,R):""
o=i[n]("0")
L=X=>Math.floor(X/(w-1))
l=L(o)
c=o%w
x=y=0
j=i
for(z="1";z<="9";z++){while(p=~j[n](z)){j=j.replace(z," ")
x+=~p%w-l
y+=L(~p)-c}}
I=B(i).map(X=>G(-x,-l,0," ",0)+X+G(x,l-w+2,0," ",2))
N=Z(I[0].length+1," ",2)
A=B(G(-y,-c,0,N+O,1)+I[J](O)+G(y,c-h,1,O+N,2))
M=y+c+C[1]
O=""
m=B(A[M])
m[x+l+C[0]/h]="x"
A[M]=m[J]("")
A[J]("\n")

Lưu ý rằng phần đệm là tối ưu. Chương trình này giả định rằng tôi chứa chuỗi thô, với các dòng được phân tách bằng các \nký tự. Phần đệm được thực hiện với khoảng trắng và ký tự kết quả là chữ thường x.

Đây là nỗ lực đầu tiên của tôi tại môn đánh gôn.

Nội dung kỹ thuật: - Kích thước của chương trình tăng gấp đôi (và độ phức tạp của nó tăng lên đáng kể) để chỉ tính đến ký tự kết quả, chủ yếu là do các chuỗi JavaScript là bất biến.

Từng dòng giải thích:

n="indexOf"
J="join"
B=X=>X.split(O)

Tôi sử dụng chúng rất nhiều, vì vậy việc lưu trữ chúng trong chuỗi giúp tôi tiết kiệm không gian. Bạn có thể thấy bên dưới splitchức năng này, tôi chỉ đơn giản là tạo một bí danh; điều này là do tôi chỉ cần một đối số, đối số còn lại là hằng số. Đối với indexOfvà join, tuy nhiên nó sẽ dài hơn.

O='\n'
w=i[n](O)+1
h=B(i).length

Không có gì phức tạp ở đây, tôi đang đọc chiều rộng và chiều cao của mảng ban đầu. Lưu ý việc sử dụng i[n]để truy cập indexOf, trong khi splitđược xử lý khác nhau.

Z=(X,Y,R)=>{C[R]+=X-1;return Array(X)[J](Y)}

Điều này đang trở nên thú vị. Hàm này về cơ bản tạo liên kết J-1 lần chuỗi X và trả về nó. Điều này được sử dụng để tạo chuỗi không gian cho phần đệm.

C=[0,0,0]

Mảng này sẽ chứa số lượng dòng và cột được thêm bởi phần đệm (tắt bởi một yếu tố h trong trường hợp đầu tiên). Ô cuối cùng là một ô rác và ngăn tôi có thêm một đối số trong hàm bên dưới.

G=(X,E,T,U,R)=>X>0&E>=0?Z(X+E+1+T,U,R):""

Chỉ riêng chức năng này xử lý phần đệm (cả dòng và cột); nó xác định, dựa trên tọa độ của vectơ kết quả (X) và số lượng dòng / cột cần tạo (E), cho dù có cần thiết phải tạo một. những X+E+1+Tchỉ là một mẹo để tiết kiệm một số không gian, Ulà chuỗi điền (một không gian cho các cột, và toàn bộ một dòng cho dòng), và chúng tôi sẽ trở lại R. Về cơ bản, hàm này trả về, trong trường hợp của một dòng, phần đệm được yêu cầu ở đầu hoặc cuối dòng đã nói, và trong trường hợp của một cột, nó trả về các dòng đệm được yêu cầu trước hoặc sau các dòng ban đầu.

o=i[n]("0")
L=X=>Math.floor(X/(w-1))
l=L(o)
c=o%w

Ở đây chúng tôi đọc vị trí của điểm gốc và chúng tôi lấy tọa độ của nó. L là một hàm để chuyển đổi một chỉ mục thành một số dòng.

x=y=0
j=i
for(z="1";z<="9";z++){
    while(p=~j[n](z)){
        j=j.replace(z," ")
        x+=~p%w-l
        y+=L(~p)-c
    }
}

Tôi đã thêm một số khoảng trắng để làm cho nó dễ đọc hơn. Điều xảy ra ở đây là với mỗi số có thể, chúng ta tiếp tục tìm kiếm nó trong chuỗi gốc. Thủ ~thuật tương đối phổ biến trong Javascript; nó là toán tử bitwise NOT, nhưng tất cả những gì quan trọng ở đây là ~-1==0, cho phép tôi kiểm tra kết thúc vòng lặp. Sau đó tôi xóa ký tự trong chuỗi (đó là lý do tại sao tôi tạo một bản sao), điều này cho phép tôi tiếp tục tìm kiếm miễn là cần thiết. Sau đó tôi thêm tọa độ của vectơ vào (x, y), sử dụng một phép con đơn giản.

I=B(i).map(X=>G(-x,-l,0," ",0)+X+G(x,l-w+2,0," ",2))

Tôi ở đây chia chuỗi gốc thành các dòng và với mỗi dòng, tôi gọi Gnó sẽ tạo ra phần đệm trước và sau các dòng. Và l-w+2như vậy đến từ một tính toán chỉ số đơn giản cho phép tôi kiểm tra xem tôi có cần thêm phần đệm hay không. Ví dụ, nếu x>0và x+l-w+1>0, sau đó (x+l-w+1)+1khoảng trắng phải được thêm vào sau dòng. Cái +xnày đang bị loại bỏ do nó là tham số đầu tiên và X+E+1+Tđược sử dụng trong định nghĩa của G.

Một điều tương tự được thực hiện cho các ký tự đầu tiên, và sau đó cho các cột. Có rất nhiều yếu tố ở đây cho phép tôi chỉ sử dụng một chức năng. Lưu ý tham số cuối cùng; trong trường hợp đầu tiên, tôi muốn viết để C[0]có thể biết sau này tôi đã thêm bao nhiêu cột vào đầu mỗi dòng; điều này cho phép tôi lấy vị trí cuối cùng của nhân vật kết quả. Tuy nhiên tôi không quan tâm đến các cột được thêm vào sau dòng ban đầu, đó là lý do tại sao cuộc gọi thứ hai để Gghi vào ô rác C[2]không được sử dụng.

N=Z(I[0].length+1," ",2)

Ở đây tôi chỉ cần đọc độ dài mới của các dòng và tạo một dòng khoảng trắng từ nó. Điều này sẽ được sử dụng để tạo phần đệm dọc.

A=B(G(-y,-c,0,N+O,1)+I[J](O)+G(y,c-h,1,O+N,2))

Điều này giống hệt như hai dòng trên. Sự khác biệt duy nhất là viết cho đến C[1]thời điểm này, và sử dụng các dấu phân cách N+Ovà O+N. Hãy nhớ rằng đó Olà một dòng mới, và Nlà một dòng không gian. Sau đó tôi áp dụng Bvào kết quả để phân tách lại (tôi cần truy xuất dòng chứa ký tự kết quả để chỉnh sửa nó).

M=y+c+C[1]

Đây là chỉ số dọc của nhân vật kết quả.

O=""
m=B(A[M])
m[x+l+C[0]/h]="x"

Ở đây tôi buộc phải sửa đổi Ođể có thể chia dòng thích hợp thành một mảng các ký tự. Điều này là do các chuỗi JavaScript là bất biến; cách duy nhất để chỉnh sửa một chuỗi là chuyển đổi nó thành một mảng (đó là những gì tôi đang làm ở đây), chỉnh sửa ở đúng vị trí và nối lại chuỗi. Cũng lưu ý đến hyếu tố, đó là vì Ghàm được gọi một lần trên mỗi dòng ban đầu.

A[M]=m[J]("")
A[J]("\n")

Cuối cùng tôi đã thay thế chuỗi mới trong mảng và nối nó lại thành một chuỗi. Woohoo!