Крива - це набір точок на квадратній сітці таким чином, що кожна точка має рівно двох сусідів по сусідству з чотирма сусідами, а точки утворюють єдиний з'єднаний компонент. Тобто графік, індукований точками на графіку сітки, є ізоморфним для одного циклу. "Індукований" означає, що дві точки не можуть торкатися у вході, не будучи сусідами по циклу.

Антипод вершини V у графі є вершиною, віддаленою від V. Антипод завжди унікальний на циклі рівної довжини (і кожен цикл на сітчастому графіку має парну довжину). Відстань вимірюється відповідно до індукованого самим циклом без поваги до нижньої квадратної сітки.

Вашим входом має бути зображення кривої. Крива буде позначена послідовністю символів з цифрою ( #) на тлі поза символами пробілу ( ). Одна з точок на кривій буде позначена Pсимволом ("pod"). Ваш вихід повинен бути таким же, як і вхід, за винятком того, що одна точка кривої повинна бути замінена на A("антипод").

Ви можете припустити, що символи будуть викладені прямокутної форми. Ви можете припустити, що перший і останній рядок і стовпець введення будуть повністю складені з пробілів (вхід підкладений фоном). Як варіант, ви можете припустити, що перший і останній рядок і стовпець будуть містити точку кривої (вхід має мінімальний пробіл).

Ви можете вводити та виводити цю сітку у вигляді єдиного рядка, розділеного новим рядком, як масив рядків або як двовимірний масив окремих символів. Цей вибір повинен бути однаковим для введення та виводу. Якщо ваша мова дозволяє це, ви можете вивести, змінивши ввід на місці замість повернення зміненого рядка або масиву.

Можливі входи:

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

Відстань вершин від поділів (модуль 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 байт, рядок 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)))

Спробуйте в Інтернеті!

Математика, 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, щоб обернутись, якщо ми проходимо межі списку циклів), щоб знайти антипод, і тоді ми можемо замінити відповідний запис оригіналу вхід mс"A"

Ви можете спробувати його в режимі он-лайн , вставивши наступне у хмарний пісочник Wolfram та натиснувши "Оцінити клітинку" або натиснувши 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раз. Це насправді навіть не правильно обчислює відстані, оскільки одна гілка може пройти повз антипод, але лише одне місце буде пронумеровано n/2незалежно від того.