เส้นโค้งคือชุดของจุดบนกริดสี่เหลี่ยมซึ่งแต่ละจุดมีเพื่อนบ้านสองคนในละแวกเพื่อนบ้านสี่คนและจุดนั้นเป็นส่วนประกอบที่เชื่อมต่อกัน นั่นคือกราฟที่เกิดจากจุดบนกราฟกริดนั้นมีลักษณะเป็นมอร์ฟิคกับรอบเดียว "เหนี่ยวนำ" หมายความว่าจุดสองจุดไม่สามารถสัมผัสในอินพุตโดยไม่ต้องเป็นเพื่อนบ้านในวงจร

antipode ของจุดสุดยอด V ในกราฟนั้นเป็นจุดสุดยอดที่อยู่ห่างจาก V มากที่สุด antipode นั้นจะมีลักษณะเฉพาะในวงจรที่มีความยาวเท่ากันเสมอ ระยะทางจะวัดตามวงจรของตัวมันเองโดยไม่ต้องคำนึงถึงตารางสี่เหลี่ยมพื้นฐาน

การป้อนข้อมูลของคุณจะต้องเป็นภาพของเส้นโค้ง เส้นโค้งจะถูกทำเครื่องหมายด้วยลำดับของอักขระเครื่องหมายตัวเลข ( #) บนพื้นหลังของอักขระเว้นวรรค ( ) จุดหนึ่งบนเส้นโค้งจะถูกทำเครื่องหมายด้วยPอักขระ ("pode") ผลลัพธ์ของคุณจะเหมือนกับอินพุตยกเว้นหนึ่งจุดโค้งจะถูกแทนที่ด้วยA("antipode")

คุณอาจสันนิษฐานว่าตัวละครจะถูกทำให้เป็นรูปสี่เหลี่ยมผืนผ้า คุณอาจสันนิษฐานว่าแถวแรกและแถวสุดท้ายและคอลัมน์ของอินพุตจะประกอบด้วยช่องว่างทั้งหมด (อินพุตมีการเสริมด้วยพื้นหลัง) อีกทางหนึ่งคุณอาจสมมติว่าแถวแรกและแถวสุดท้ายและคอลัมน์แต่ละแห่งจะมีจุดโค้ง (อินพุตมีช่องว่างภายในขั้นต่ำ)

คุณสามารถป้อนและส่งออกกริดนี้เป็นสตริงที่คั่นด้วยบรรทัดใหม่เดียวเป็นอาร์เรย์ของแถวหรือเป็นอาร์เรย์ 2D ของอักขระแต่ละตัว ตัวเลือกนี้จะต้องเหมือนกันสำหรับอินพุตและเอาต์พุต หากภาษาของคุณอนุญาตสิ่งนี้คุณอาจส่งออกโดยการปรับเปลี่ยนอินพุตแทนการส่งคืนสตริงหรืออาร์เรย์ที่แก้ไข

อินพุตที่เป็นไปได้:

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

ผลลัพธ์ที่สอดคล้องกัน:

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

จุดสุดยอดระยะทางจาก pode (modulo 10) (อย่าส่งออกสิ่งเหล่านี้):

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 ไบต์

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)

เวอร์ชันที่ให้ภาพเคลื่อนไหวแบบวนซ้ำ:

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 ไบต์

-17 ไบต์ขอบคุณ @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

ลองออนไลน์!

Python 3 , 402 288 282 ไบต์, String 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)))

ลองออนไลน์!

นิเมชั่นของรหัสที่ทำงาน:

MATL , 43 42 ไบต์

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

รหัสยอมรับจำนวนช่องว่างภายในโดยพลการในแถวและคอลัมน์แรกและสุดท้าย อินพุตเป็นอาร์เรย์สี่เหลี่ยมของตัวอักษรโดยใช้;เป็นตัวคั่นแถว ตัวอย่างเช่นการป้อนข้อมูล

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

ถูกแทนด้วย

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

หรือในหนึ่งบรรทัด (เพื่อให้สามารถป้อนผ่าน STDIN)

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

ลองออนไลน์! หรือตรวจสอบกรณีสี่ครั้งล่าสุด: 1 , 2 , 3 , 4 (สิ่งเหล่านี้ได้รับเลือกเพราะมีเส้นโค้งที่ซับซ้อนที่สุดกรณีสุดท้ายมีช่องว่างภายใน)

คำอธิบาย

TL; WR: ตัวเลขที่ซับซ้อน, การทำดัชนีจำนวนมาก, ไม่มีการแปลง

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 ไบต์

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

ลองออนไลน์!

Mathematica, 234 223 ไบต์

(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"])&

รหัสนี้จะทำให้vเป็นจุดสุดยอดรายการสำหรับกราฟ: ดัชนีของ"#"และ"P"s จากนั้นnคือความยาว (จำเป็นต้องสม่ำเสมอ) และqแยกจุดยอดที่ป้อนเข้า (ดังนั้นจึงไม่สนใจรูปร่างของลูป)

จากนั้นhเป็นฟังก์ชั่นที่สร้างกราฟโดยมีจุดยอดในvและขอบที่ไม่ได้บอกทิศทางระหว่างจุดยอดเมื่อความยาวของความแตกต่างของคู่ดัชนีของพวกเขาคือ 1 (ดังนั้นความแตกต่างของพวกมันคืออะไร) {-1,0}หรือ{0,1}จากนั้น (เฉพาะ) วนรอบ (เป็นรายการของขอบ) จากนั้นนำค่าขอบที่ป้อนเข้าและใช้จุดสุดยอดแรกสร้างขอบนั้น

ใช้hเราสามารถหาดัชนีของ"P"รอบและไปครึ่งทาง (ใช้ Mod เพื่อพันรอบถ้าเราผ่านขอบเขตของรายการวงจร) เพื่อค้นหา antipode แล้วเราสามารถแทนที่รายการที่สอดคล้องกันของต้นฉบับ ป้อนข้อมูลmด้วย"A"

คุณสามารถลองออนไลน์ด้วยการวางต่อไปนี้ที่Wolfram Cloud Sandboxและคลิก "ประเมินเซลล์" หรือกด Shift + Enter หรือ 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

แนวคิดทางเลือก 258 ไบต์

แรงบันดาลใจเล็กน้อยจากโซลูชัน Python ของ ovsฉันพยายามเขียนโค้ดที่จะไม่ใช้คุณลักษณะทฤษฎีกราฟใด ๆ ของ Mathematica และเพียงแค่คำนวณระยะทางแบบสุ่ม ฉันไม่สามารถทำให้สั้นได้ แต่สงสัยว่าใครบางคนสามารถปรับปรุงได้:

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"])`

รหัสนี้ไม่มีประสิทธิภาพมาก โดยพื้นฐานแล้วมันจะแทนที่"P"ด้วย0แล้วมองหาสิ่งที่"#"อยู่ถัดจากสิ่งที่ไม่ใช่การ"#"วนซ้ำทั้งสองครั้งและแทนที่ด้วยตัวเลขที่แสดงระยะทางจาก"P"นั้นและเพื่อให้แน่ใจว่ามันเสร็จสิ้นnแล้ว สิ่งนี้ไม่ได้คำนวณระยะทางได้อย่างถูกต้องเนื่องจากมีสาขาหนึ่งสามารถผ่าน antipode ได้ แต่จะมีเลขn/2ที่เดียวเท่านั้น