Donald Trump est très impressionné par le travail des gens sur ce site. Il a vu à quel point vous étiez incroyable d' avoir aidé Ben Carson , alors il vous a même engagé pour construire son mur . Il pense que tu es formidable. Maintenant, il a encore besoin de votre aide. Bien qu'il ait réussi à construire son mur, il a maintenant besoin du gouvernement mexicain pour le payer. Il veut facturer 1 million de dollars par mile, et il leur a dit que la frontière américano-mexicaine faisait 1 989 miles de long . Cependant, ils ne sont pas tout à fait sûrs que ce nombre est exact, ils souhaitent donc également une représentation visuelle à l'échelle. C'est là que vous intervenez. Vous devez prendre cette carte:

et pour chaque n (50 <= n <= 500) miles sur la frontière, tracez une ligne de 25 pixels de long, perpendiculaire à la pente de la frontière à ce point. En utilisant l'échelle sur le côté droit de la carte, j'ai déterminé que 100 miles ~ 50 pixels . J'ai dessiné un échantillon des 3 premières lignes pour n = 60, mais celles-ci ne sont qu'approximatives:

Remarques:

• La seule entrée est n . La sortie doit être l'image de la carte, avec les lignes ajoutées, tracées à l'écran ou enregistrées dans un fichier d'image raster (vous pouvez remplacer le fichier de carte d'origine).
• Vous pouvez enregistrer le fichier de carte vierge avec le nom de fichier que vous souhaitez. Il s'agit d'un JPEG, mais vous pouvez le convertir en un autre format raster courant si vous préférez. De plus, vous pouvez réduire la taille de l'image jusqu'à 50%, tant que vous gardez les dimensions proportionnelles et que vos lignes sont toujours à l'échelle.
• Chaque ligne doit être perpendiculaire à la pente de la frontière à ce point. La pente doit être calculée à partir de 50 milles avant le point et se terminant à 50 milles après le point.

Précision:

• La pente de chaque ligne peut avoir une marge d'erreur de ± 5 °
• L'espacement entre chaque ligne peut avoir une marge d'erreur de ± 20 miles (10 pixels sur la carte normale).

Python 2 + numpy + OpenCV , 576 octets

from cv2 import*
from numpy import*
n=input()/4
f="m.png"
i=imread(f)
b=array([0]*3)
y=array([165,195,225])
j=inRange(i,b,b+120)
k=inRange(i,y,y+25)
for x,y in zip(*where(j)):j[x,y]=k[x+3,y]-j[x+1,y]>1
j=j[506:732,152:557]
p=[array([11,9])]
for c in sorted(zip(*where(j)),key=lambda c:c[1]):r=range(p[-1][1]+1,c[1]+1);p+=map(array,zip(map(int,interp(r,*zip(p[-1],c)[::-1])),r))
for x,c in enumerate(p[25:-25:n]):s=-1/true_divide(*p[x*n+50]-p[x*n+25]);k=6/(1+s**2)**.5;line(i,*map(tuple,[(c+[int(k*s)+506,int(k)+152])[::-1],(c-[int(k*s)-506,int(k)-152])[::-1],b]))
imwrite(f,i)

Ce programme est presque entièrement non golfé, et certains aspects de celui-ci sont quelque peu inexacts pour le moment, mais au moins il fonctionne pour la plupart. De plus, il y a un peu de codage en dur, mais ce n'est que pour une fenêtre approximative entourant la bordure et les coordonnées du premier pixel de la bordure (ce dernier dont je supprimerai très probablement la suite).

L'image utilisée par le programme est réduite de moitié (c.-à-d. 1120 x 865), ainsi la longueur des lignes tracées et la distance entre les lignes sont plus petites.