Побудуємо функцію f (x) = sin (πx) + 0,5 sin (3πx) над областю [-3,3] . Ми можемо трактувати це як сипучу струну, що лежить на дошці. Тепер введемо n цвяхів у дошку в положеннях (x ₁ , y ₁ ) до (x _n , y _n ) , де x _i ∈ (-3,3) і y _i ∈ [-1,1] . Уявіть, що в кінці струни є два вушка, тобто в положеннях (-3,0) і (3,0). Тепер ми можемо взяти кінці струни і протягнути наскрізні вушка, поки струна не буде натягнутою. Це деформує наш графік на кусково-лінійну функцію.

Деякі фотографії можуть допомогти. Візьміть 8 цвяхів при (-2,8, -0,7), (-2,5, -0,9), (-1,2, .2), (-0,5, .8), (0,5, .4), (1,2, -0,9), (1,5, -0,6), (1,8, -0,8) . Наступні три сюжети показують описаний вище процес:

^{Для більшої версії: Клацніть правою кнопкою миші -> Відкрити в новій вкладці}

Ось анімація затягування рядків, якщо у вас виникли труднощі із візуалізацією:

Змагання

Подаючи список "цвяхів" (які не обов'язково сортуються), побудуйте ці цвяхи та натягнутий рядок, якщо він починається з форми вищевказаної функції f .

Ви можете написати програму або функцію та взяти вхід через STDIN, ARGV або аргумент функції. Ви можете відображати результат на екрані або зберігати зображення у файлі.

Якщо результат розсіяний, він повинен бути не менше 300 пікселів у ширину та 100 пікселів у висоту. Діапазон координат від (-3, -1.1) до (3,1.1) повинен охоплювати щонайменше 75% горизонтальної та вертикальної протяжності зображення. Масштаби довжини x і y не повинні бути однаковими. Потрібно показати цвяхи (використовуючи принаймні 3х3 пікселі) та рядок (не менше 1 пікселя). Ви можете або не включати оси.

Кольори - це ваш вибір, але вам потрібно як мінімум два кольори, що відрізняються: один для фону і один для нігтів і рядок (хоча вони можуть мати різні кольори).

Ви можете припустити, що всі цвяхи розташовані як мінімум на 10 ^-5 одиниць від f (так що вам не потрібно турбуватися про неточність з плаваючою комою).

Це кодовий гольф, тому найкоротша відповідь (у байтах) виграє.

Більше прикладів

Ось ще два (простіші) приклади:

{{-2.5, 1}, {-1.5, -1}, {-0.5, 1}, {0.5, -1}, {1.5, 1}, {2.5, -1}}

(Рядок збігається з x -x.)

{{-2.7, -0.5}, {-2.3, -0.5}, {-1.7, 0.5}, {-1.3, 0.5}, {-0.7, -0.5}, {-0.3, -0.5}, {0.5, 1}, {1.5, -1}, {2.5, 1}}

Хочете чергового виклику?

Ось частина II!

Пітон + Пікаїро, 727 708 608, + PyLab, 383

from pylab import*
def f(N):
 def P(u,w,N):
    T=lambda v,p:(C(v-u,p-u)>0)==(C(w-v,p-v)>0)==(C(u-w,p-w)>0);M=[(i,n)for i,n in enumerate(N)if T(V([n[0],sin(pi*n[0])+sin(3*pi*n[0])/2]),n)]
    if M:i,n=max(M,key=lambda n:C(n[1]-u,w-u)**2);M=P(u,n,N[:i])+[n]+P(n,w,N[i+1:])
    return M
 V=array;C=cross;a=V([3,0]);plot(*zip(*([-a]+P(-a,a,map(V,sorted(N)))+[a])));N and scatter(*zip(*N));show()

Приклад

f([(-2.8,-0.7),(-2.5,-0.9),(-1.2,0.2),(-0.5,0.8),(0.5,0.4),(1.2,-0.9),(1.5, -0.6),(1.8, -0.8)])

Як це працює

Припустимо, ми знаємо, що натягнута струна проходить через дві точки A і B (ми завжди можемо починати з
A = (-3, 0) і B = (3, 0) .) Коли ми тягнемо рядок, вона "хоче" взяти найкоротший можливий шлях між A і B , тобто в ідеалі відрізок AB . Однак якщо в області, обмеженій функцією ( sin πx + ... ) і AB , є цвяхи , то принаймні один з них повинен блокувати рядок. Зокрема, цвях (-и), віддалені від АВ в межах зазначеної області, повинні перекривати струну. Отже, якщо C - це цвях, ми знаємо, що натягнута струна повинна проходити черезЗ , на додаток до A і B . Тепер ми можемо повторити процес для сегментів AC і CB і продовжувати таким чином, поки в кінцевому підсумку не буде більше нігтів, що втручаються.

Це бінарний алгоритм розділення і перемоги з лінійним скануванням на кожному кроці, тому він має найкращий складний варіант O (n log n) і найгірший складність O (n ² ) .

Python + pylab, 576 байт

Алгоритм:

Я трактував проблему як пошук найкоротшого шляху від (-3, 0) до (3, 0) таким чином, що вертикальний відрізок лінії, що з'єднує точку на шляху до точки на f (x), ніколи не перетинає цвях.

На кожному х, де існує щонайменше один цвях, знайдіть найменшу верхню межу і найбільшу нижню межу, задану цвяхами на цьому х . Розглянемо точки, задані цими межами плюс початкову та кінцеву точки, як вершини на графіку. Додайте ребро з вагою, заданою евклідовою відстані між двома вершинами, якщо відрізок лінії між ними потрапляє у верхню та нижню межі для кожної проміжної х координати. Знайдіть найкоротший шлях на цьому графіку.

Приклад з 27 випадковими точками:

(-0.367534, -0.722751), (-0.710649, -0.701412), (1.593101, -0.484983), (1.771199, 0.681435), (-1.878764, -0.491436), (-0.061414, 0.628570), (-0.326483, -0.512950), (0.877878, 0.858527), (1.256189, -0.300032), (1.528120, -0.606809), (-1.343850, -0.497832), (1.078216, 0.232089), (0.930588, -0.053422), (-2.024330, -0.296681), (-2.286014, 0.661657), (-0.009816, 0.170528), (2.758464, 0.099447), (-0.957686, 0.834387), (0.511607, -0.428322), (-1.657128, 0.514400), (1.507602, 0.507458), (-1.469429, -0.239108), (0.035742, 0.135643), (1.194460, -0.848291), (2.345420, -0.892100), (2.755749, 0.061595), (0.283293, 0.558334), 

Гольф

Те, що з'являється у вигляді декількох проміжків відступу в for j in R(i&~1)циклі, насправді має бути вкладкою.

from pylab import*
P=((3,0),(-3,0))+input()
X=sorted(set(zip(*P)[0]))
l=len(X)*2
if l>4:scatter(*zip(*P[2:]))
f=lambda x:sin(pi*x)+sin(3*pi*x)/2
B=[[max([-9]+[p[1]for p in P if x==p[0]and p[1]<f(x)]),min([9]+[p[1]for p in P if x==p[0]and p[1]>f(x)])]for x in X]
b=zeros(l);b[2:]=inf
v=list(b)
R=range
for i in R(l):
 for j in R(i&~1):
    A=B[j/2][j&1];D,d=B[i/2][i&1]-A,X[i/2]-X[j/2];K=1;c=b[j]+norm((d,D))
    for k in R(j/2+1,i/2):C=A+D/d*(X[k]-X[j/2]);K&=C<B[k][1];K&=C>B[k][0]
    if(c<b[i])&K:b[i]=c;v[i]=j,(X[j/2],A)
l-=2
s=P[:1]
while l/2:l,p=v[l];s+=(p,)
plot(*zip(*s))
show()

Безумовно

from pylab import*
P = input()
Xn,Yn = zip(*P)
X = set(Xn+(3,-3))
f = lambda x:sin(pi*x)+sin(3*pi*x)/2
ylb = {x: max([-9]+[p[1] for p in P if p[0] == x and p[1] < f(x)]) for x in X}
yub = {x: min([9]+[p[1] for p in P if p[0] == x and p[1] > f(x)]) for x in X}
ylb[-3] = yub[3] = ylb[3] = 0
X = sorted(X)
l = len(X)
best = zeros((l,2))
best[1:] = inf
prev = [ [0,0] for i in range(l) ]
for i in range(l): # calculate min path to X[i] lb or ub
  for ib in 0,1:
    for j in range(i): # point to come from
      for jb in 0,1:
          Y2, Y1 = (ylb, yub)[ib][X[i]], (ylb, yub)[jb][X[j]]
          dy,dx = Y2 - Y1, X[i] - X[j]
          if all([Y1 + dy/dx*(x - X[j]) < yub[x] and Y1 + dy/dx*(x - X[j]) > ylb[x] for x in X[j+1:i]]):
             c = best[j][jb] + (dy**2+dx**2)**.5
             if c < best[i][ib]:
                 best[i][ib] = c
                 prev[i][ib] = j, jb, (X[j], Y1)
j, jb = l-1,0
pts = [(3,0)]
while j:
    j, jb, p = prev[j][jb]
    pts += [p]
plot(*zip(*pts))
scatter(Xn,Yn)
show()