Đường cong là một tập hợp các điểm trên một ô vuông sao cho mỗi điểm có chính xác hai lân cận trong vùng lân cận bốn lân cận và các điểm tạo thành một thành phần được kết nối duy nhất. Đó là, biểu đồ gây ra bởi các điểm trên biểu đồ lưới là đẳng cấu cho một chu kỳ. "Cảm ứng" có nghĩa là hai điểm không thể chạm vào đầu vào mà không phải là hàng xóm trong chu kỳ.

Một antipode của một đỉnh V trong đồ thị là một đỉnh xa nhất so với V. Các antipode luôn là duy nhất trên một chu kỳ có độ dài chẵn (và mỗi chu kỳ trên biểu đồ lưới đều có độ dài bằng nhau). Khoảng cách sẽ được đo bằng cảm ứng của chính chu kỳ mà không tôn trọng lưới ô vuông bên dưới.

Đầu vào của bạn sẽ là một hình ảnh của một đường cong. Đường cong sẽ được đánh dấu bằng một chuỗi các ký tự ký hiệu số ( #) trên nền ngoài các ký tự không gian ( ). Một trong những điểm trên đường cong sẽ được đánh dấu bằng Pký tự ("pode"). Đầu ra của bạn sẽ giống như đầu vào ngoại trừ một điểm đường cong sẽ được thay thế bằng A("antipode").

Bạn có thể giả sử các ký tự sẽ được đệm thành hình chữ nhật. Bạn có thể giả sử hàng đầu tiên và cuối cùng và cột đầu vào sẽ bao gồm toàn bộ khoảng trắng (đầu vào được đệm với nền). Ngoài ra, bạn có thể giả định rằng hàng và cột đầu tiên và cuối cùng sẽ chứa một điểm đường cong (đầu vào có phần đệm tối thiểu).

Bạn có thể nhập và xuất lưới này dưới dạng một chuỗi phân tách dòng mới, dưới dạng một mảng các hàng hoặc dưới dạng một mảng 2D của các ký tự riêng lẻ. Sự lựa chọn này sẽ giống nhau cho đầu vào và đầu ra. Nếu ngôn ngữ của bạn cho phép điều này, bạn có thể xuất bằng cách sửa đổi đầu vào tại chỗ thay vì trả về chuỗi hoặc mảng đã sửa đổi.

Đầu vào có thể:

P#    P##   #P#   #####      #####P# #######   #####P#########   #####P#########
##    # #   # #   #   #      #     # #     #   #             #   #             #
      ###   ###   ## ##      # ### # # ### #   # ### ### ### #   #             #
###                # # ###   # # # # # # # #   # # # # # # # #   #             #
# P#    ### ###    # ### #   # # ### ### # #   # # ### ### # #   #             #
## #    # ### #    #     #   # #         # #   # #         # #   #             #
 # #    P     #    ##### P   # ########### #   # ##### ##### #   #             #
 ###    #######        ###   #             #   #     # #     #   #             #
                             ###############   ####### #######   ###############

Đầu ra tương ứng:

P#    P##   #P#   #A###      #####P# #A#####   #####P#########   #####P#########
#A    # #   # #   #   #      #     # #     #   #             #   #             #
      ##A   #A#   ## ##      # ### # # ### #   # ### ### ### #   #             #
###                # # ###   # # # # # # # #   # # # # A # # #   #             #
# P#    ### ##A    # ### #   # # ### ### # #   # # ### ### # #   #             #
## #    # ### #    #     #   # #         # #   # #         # #   #             #
 A #    P     #    ##### P   # ########### #   # ##### ##### #   #             #
 ###    #######        ###   #             #   #     # #     #   #             #
                             ###############   ####### #######   #########A#####

Khoảng cách Vertex từ các nút (modulo 10) (không xuất các giá trị này):

P1    P12   1P1   5A543      54321P1 9A98765   54321P123456789   54321P123456789
1A    1 3   2 2   4   2      6     2 8     4   6             0   6             0
      23A   3A3   32 01      7 109 3 7 109 3   7 901 789 543 1   7             1
321                1 9 543   8 2 8 4 6 2 8 2   8 8 2 6 A 6 2 2   8             2
4 P1    234 89A    0 876 2   9 3 765 543 7 1   9 7 345 987 1 3   9             3
56 2    1 567 9    9     1   0 4         6 0   0 6         0 4   0             4
 A 3    P     8    87654 P   1 56789012345 9   1 54321 56789 5   1             5
 654    1234567        321   2             8   2     0 4     6   2             6
                             345678901234567   3456789 3210987   345678901A10987

JavaScript (ES6), 193 181 byte

f=s=>s==(`P#1P#21#12#221A`[r=`replace`](/.../g,([n,f,t])=>s=s[r](eval(`/([${n+=f}])([^]{${s.search`\n`}})?(?!\\1)[${n}]/`),m=>m[r](eval(`/^${f}|${f}$/`),t))),s)?s[r](/\d/g,`#`):f(s)

Phiên bản cung cấp hình ảnh động lặp:

f=s=>s==(`#A#1#12#221AP#1P#2`[r=`replace`](/.../g,([n,f,t])=>s=s[r](eval(`/([${n+=f}])([^]{${s.search`\n`}})?(?!\\1)[${n}]/`),m=>m[r](eval(`/^${f}|${f}$/`),t))),s)?s[r](/\d/g,`#`):s
;setInterval(_=>i.value=f(i.value),1e3)

<textarea rows=10 cols=20 id=i style="font-family:monospace"></textarea>

Python 2 , 333 221 215 byte

-17 byte nhờ @JanDvorak

g=input()
y=map(max,g).index('P')
x=g[y].index('P')
m=[k[:]for k in g]
v=x;w=y
while'#'in sum(m,[]):x,y,(v,w)=v,w,[(x+a,y+b)for a,b in((1,0),(-1,0),(0,1),(0,-1))if'#'==m[y+b][x+a]][0];m[w][v]='_'
g[w][v]='A'
print g

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

Python 3 , 402 288 282 byte, Chuỗi IO

g=[[*k]for k in open(0).read().split('\n')]
y=[max(k)for k in g].index('P')
x=g[y].index('P')
m=[k[:]for k in g]
v=x;w=y
while'#'in sum(m,[]):x,y,(v,w)=v,w,[(x+a,y+b)for a,b in((1,0),(-1,0),(0,1),(0,-1))if'#'==m[y+b][x+a]][0];m[w][v]='_'
g[w][v]='A'
print('\n'.join(map(''.join,g)))

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

Hoạt ảnh của mã đang chạy:

MATL , 43 42 byte

32-I#fbbJ*+!w3>y"&)yy-|&X<]vJQ2/)G65b&Zj&(

Mã chấp nhận một lượng không gian đệm tùy ý trong các hàng và cột đầu tiên và cuối cùng. Đầu vào là một mảng hình chữ nhật của ký tự, sử dụng ;như dấu phân cách hàng. Ví dụ: đầu vào

#####   
#   #   
## ##   
 # # ###
 # ### #
 #     #
 ##### P
     ###

được đại diện như

['#####   ';
 '#   #   ';
 '## ##   ';
 ' # # ###';
 ' # ### #';
 ' #     #';
 ' ##### P';
 '     ###']

hoặc, trong một dòng (để có thể nhập thông qua STDIN),

['#####   '; '#   #   '; '## ##   '; ' # # ###'; ' # ### #'; ' #     #'; ' ##### P'; '     ###']

Hãy thử trực tuyến! Hoặc xác minh bốn trường hợp cuối cùng: 1 , 2 , 3 , 4 (những trường hợp này đã được chọn vì chúng có các đường cong phức tạp nhất; trường hợp cuối cùng có một số phần đệm không gian).

Giải trình

TL; WR: Số phức, nhiều chỉ mục, không tích chập.

32-     % Implicitly input char matrix. Subtract 32. Space becomes zero
I#f     % 3-output find: pushes nonzero values, their row indices,
        % and their column indices, as column vectors
bb      % Bubble up twice, so row and column indices are on top
J*+     % Times 1j, add. This transforms row and column indices into
        % complex numbers, where real is row and imaginary is column
!       % Transpose into a row vector
w       % Swap, so vector of nonzero values is on top
3>      % Logical index of elements exceeding 3. ASCII codes of space,
        % '#' and 'P0 are 32, 35 and 80 respectively. Since 32 was
        % subtracted these became 0, 3 and 48. So the only entry with
        % value exceeding 3 is that corresponding to the original 'P'.
y"      % Do this as many times as the number of complex positions
        %   The stack now contains the vector of complex positions and an
        %   index into that vector. The index points to the complex position 
        %   to be processed next.
  &)    %   Two-output reference indexing: pushes the indexed entry and
        %   a vector with the remaining entries. This pulls off the
        %   current complex position, which is initially that of 'P'
  yy    %   Duplicate top two elements, i.e. current position and vector
        %   of remaining positions
  -|    %   Absolute differences
  &X<   %   Index of minimum. Gives the index of the complex position
        %   that is closest to the current one. In case of tie (which
        %   only happens in the first iteration) it picks the first. The 
        %   result is the index of the complex position to be processed in 
        %   the next iteration. This index will be empty if this is the last
        %   iteration.
]       % End
        % The stack now contains the complex positions as individual
        % values, starting from 'P' and sorted as per the curve; plus two 
        % empty arrays. These empty arrays have been produced by the last
        % iteration as the index for the "next" iteration and the array of
        % "remaining" complex positions
v       % Concatenate into a column vector. The empty arrays have no effect.
        % The resulting vector contains the sorted complex positions
JQ      % Push 1j and add 1
2/      % Divide by 2. This gives (1+1j)/2. When used as an index this is
        % interpreted as (1+end)/2. Since the length of the curve is even
        % this gives a non-integer number, which will be implicitly
        % rounded up (because of .5 fracctional part). As an example, for
        % length 32 this gives 16.5, which rounded becomes 17. Position 17
        % along the curve is the antipode of position 1
)       % Reference indexing. Gives the complex position of the antipode
G       % Push input char matrix again
65      % Push 65 (ASCII for 'A')
b       % Bubble up, so complex position is on top
&Zj     % Separate into real and imagimary parts, corresponding to row and
        % column indices
&(      % 4-input assignment indexing. This writes 'A' at the specified row
        % and column of the char matrix. Implicitly display

Python 3 , 421 byte

l,e=len,enumerate
r=open(0).read()
n=lambda x:[(x[0]-1,x[1]),(x[0]+1,x[1]),(x[0],x[1]-1),(x[0],x[1]+1)]
p=a={(i,j):y for i,x in e(r.split('\n'))for j,y in e(x)}
t=l(r.split('\n'));s=l(r.split('\n')[0])
for i in a:p=[p,i][a[i]=='P']
w=[p]
while l(w)!=r.count('#')+1:
 for x in a:
  if x in n(w[-1])and a[x]!=' 'and x not in w:w+=[x]
a[w[(l(w)+1)//2]]='A';print('\n'.join(''.join(a[j,i]for i in range(s))for j in range(t)))

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

Toán học, 234 223 byte

(p=Position;v=p[#,"#"|"P"];n=Length@v;q=v[[#]]&;h=FindCycle[Graph[v,Join@@Table[If[Norm[q@i-q@j]==1,q@i<->q@j,Nothing],{i,n},{j,i-1}]]][[1,#,1]]&;ReplacePart[#,h@Mod[p[Table[h@x,{x,n}],p[#,"P"][[1]]][[1,1]]+n/2,n,1]->"A"])&

Mã này làm vdanh sách đỉnh cho biểu đồ: các chỉ số của "#"và "P"s. Sau đó nlà độ dài (nhất thiết là chẵn) và qtrích xuất đỉnh đầu vào (vì vậy bỏ qua hình dạng của vòng lặp).

Sau đó, hlà một hàm xây dựng biểu đồ với các đỉnh trong vvà các cạnh vô hướng giữa các đỉnh khi độ dài của sự khác biệt của các cặp chỉ số của chúng là chính xác 1 (vì vậy sự khác biệt của chúng là một cái gì đó giống như {-1,0}hoặc {0,1}) và sau đó tìm thấy một danh sách tất cả các chu kỳ và cung cấp đầu tiên (chỉ) chu kỳ (như một danh sách các cạnh) và sau đó lấy cạnh đầu vào và lấy đỉnh đầu tiên tạo nên cạnh đó.

Sử dụng h, chúng ta có thể tìm chỉ số của "P"chu kỳ và đi một nửa (sử dụng Mod để bọc xung quanh nếu chúng ta đi qua giới hạn của danh sách chu kỳ) để tìm antipode, và sau đó chúng ta có thể thay thế mục nhập tương ứng của bản gốc đầu vào mvới"A"

Bạn có thể dùng thử trực tuyến bằng cách dán các mục sau vào Wolfram Cloud Sandbox và nhấp vào "đánh giá ô" hoặc nhấn Shift + Enter hoặc Numpad Enter:

(p=Position;v=p[#,"#"|"P"];n=Length@v;q=v[[#]]&;h=FindCycle[Graph[v,Join@@Table[If[Norm[q@i-q@j]==1,q@i<->q@j,Nothing],{i,n},{j,i-1}]]][[1,#,1]]&;ReplacePart[#,h@Mod[p[Table[h@x,{x,n}],p[#,"P"][[1]]][[1,1]]+n/2,n,1]->"A"])&@{{"#","#","#","#","#"," "," "," "},{"#"," "," "," ","#"," "," "," "},{"#","#"," ","#","#"," "," "," "},{" ","#"," ","#"," ","#","#","#"},{" ","#"," ","#","#","#"," ","#"},{" ","#"," "," "," "," "," ","#"},{" ","#","#","#","#","#"," ","P"},{" "," "," "," "," ","#","#","#"}}//MatrixForm

Ý tưởng thay thế, 258 byte

Lấy cảm hứng một chút từ các giải pháp Python của ovs , tôi đã cố gắng viết mã không sử dụng bất kỳ tính năng lý thuyết đồ thị nào của Mathematica và chỉ mù quáng tính toán khoảng cách. Tôi không thể hiểu nó ngắn như vậy, nhưng nghi ngờ ai đó có thể cải thiện nó:

f[m_]:=(x="#";t=ReplacePart;p=Position;l=t[m,p[m,"P"][[1]]->0];v=p[l,x|0];n=Length[v];q=v[[#]]&;r=l[[q[#][[1]],q[#][[2]]]]&;y=t[l,q@#->(r@#2+1)]&;Do[If[Norm[q@i-q@j]==1&&Xor[r@i==x,r@j==x],If[r@i==x,l=y[i,j],l=y[j,i]]],n,{i,n},{j,n}];t[m,p[l,n/2][[1]]->"A"])`

Mã này rất không hiệu quả. Về cơ bản, nó thay thế "P"bằng 0và sau đó tìm kiếm một "#"thứ không phải là "#"bằng cách lặp qua toàn bộ hai lần và thay thế chúng bằng các số biểu thị khoảng cách từ đó "P", và để đảm bảo nó kết thúc, nó sẽ xử lý nthời gian. Điều này thực sự thậm chí không tính toán khoảng cách một cách chính xác vì một nhánh có thể đi qua cực âm, nhưng chỉ một vị trí sẽ được đánh số mà n/2không có vấn đề gì.