Кривая - это набор точек на квадратной сетке, так что каждая точка имеет ровно двух соседей в окрестности с четырьмя соседями, и точки образуют один связанный компонент. То есть граф, индуцированный точками на графе сетки, изоморфен одному циклу. «Индуцированный» означает, что две точки не могут касаться ввода, не будучи соседями в цикле.

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

Ваш вход должен быть изображением кривой. Кривая будет выделена с помощью последовательности символов знака числа ( #) на фоне из пробелов ( ). Одна из точек на кривой будет помечена Pсимволом («подъём»). Ваш выход должен быть таким же, как вход, за исключением того, что одна точка кривой должна быть заменена на 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 байта, строка ввода-вывода

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, чтобы обернуться, если мы пройдем границы списка циклов), чтобы найти антипод, а затем мы можем заменить соответствующую запись оригинала ввод 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 байт

Немного вдохновленный решениями ovs's Python , я попытался написать код, который не использовал бы какие-либо особенности теории графов в 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несмотря ни на что.