Jones quer fazer uma viagem de ida e volta em sua bicicleta. Ele quer visitar várias cidades em ordem arbitrária, mas sua rota não deve se cruzar, já que ele odeia estar no mesmo lugar duas vezes em suas férias. Como ele realmente gosta de andar de bicicleta, o comprimento de sua rota é completamente irrelevante, mas ele não gosta de andar pela paisagem sem um alvo. A rota que ele gosta é da cidade em linha reta para outra, sem nenhum desvio.

Como Jones é um jogador de código apaixonado, ele quer que você encontre um programa que planeje uma viagem de ida e volta para ele, considerando um conjunto de cidades. A entrada tem o formulário A (B|C). Aé o nome de uma cidade Be Csão suas coordenadas. Você pode assumir que as coordenadas são positivas e menores que 1000. Os conjuntos de dados para as cidades são separados por linhas. Aqui está um exemplo de como uma entrada de exemplo pode parecer:

SomeTown (1 | 10)
ACidade (3 | 4)
Onde quer que (7 | 7)
Casa (5 | 1)

Jones não é pedante, ele só quer ter um programa útil. Assim, você pode decidir por si mesmo como será a saída, desde que atenda a esses critérios:

• A saída é um mapa das cidades, com a rota traçada entre elas. Se algo estiver correto, a rota não deve se sobrepor e deve terminar onde começou
• As coordenadas são como na programação usual: (1 | 1) está no canto noroeste. Adicione uma espécie de régua à borda do mapa para facilitar a leitura
• Os nomes das cidades devem ser anotados no mapa, mas fique à vontade para usar as abreviações explicadas em outro lugar no mapa
• O mapa pode ser uma arte ASCII ou uma imagem
• Mantenha a saída legível

Uma saída pode ser assim:

  1234567
 1 D  
 2 * * 
 3 * * 
 4 B *
 5 * *
 6 * *
 7 * C
 8 * ** 
 9 * *   
10A **

A: SomeTown
B: ACity
C: Onde quer que
D: Início

O programa com a menor contagem de caracteres vence. Não conto os parâmetros para o compilador / intérprete, se eles forem necessários para a compilação, mas não abuse dessa regra. Aplicam-se as regras usuais de golfe com código.

Aqui está outro caso de teste. Sua saída não precisa coincidir com a minha, nem você precisa escolher o mesmo caminho que eu. A saída é desenhada à mão e mostra uma saída possível. Entrada:

casa (5 | 7)
supermercado (13 | 12)
parque (15 | 5)
nova praça (9 | 16)
casa de um amigo (20 | 11)
castelo velho (14 | 21)
ribeirinha (1 | 20)
praia (10 | 1)
cinema (21 | 18)
floresta (23 | 7)
pequena ilha (21 | 1)
museu do código-golfe (6 | 25)
aeroporto (18 | 25)
loja de chá (24 | 14)
restaurante (24 | 22)
ótima ponte (3 | 12)
Edifício SO (25 | 9)

E este é um exemplo de saída:

           1111111111222222
  1234567890123456789012345
 1 H * * K    
 2 * * * *   
 3 * * * *   
 4 * * ** *   
 5 * C *   
 6 * *   
 7 AJ  
 8 * *  
 9 * Q
10 * *
11 * *** E *
12 PB *** * * 
13 * * * * 
14 * * * N 
15 * * * * 
16 * D * * 
17 * * * * 
18 * * eu * 
19 * * * * 
20G * * * 
21 * F * *
22 * ** * O 
23 * ** * **  
24 * ** * *    
25 L ** M **

Um lar
B: supermercado
C: parque
D: nova praça
E: casa do amigo
F: castelo velho
G: ribeirinha
H: praia
I: cinema
J: floresta
K: pequena ilha
L: museu do código-golfe
M: aeroporto
N: loja de chá
O: restaurante
P: ótima ponte
Q: SO edifício

Eu não sou um falante nativo de inglês. Fique à vontade para corrigir meu idioma e gramática, se necessário.

J, 357 288

m=:>:>./c=:>1{"1 p=:([:<`([:<1-~[:".;._1'|',}:);._1'(',]);._2(1!:1)3
'n c'=:|:o=:p/:12 o.j./"1 c-"1(+/%#)c
C=:<"1 c
L=:u:65+i.#o
g=:<"1;c([:<@|:0.5<.@+[+>@])"1(-~/"2(<@:*]%~i.@>:@])"0([:>./|@-/)"2)>C,"0(1|.C)
echo(u:48+10|i.>:0{m),|:(u:48+10|>:i.1{m),L C}'*'g}m$' '
echo' ',L,.':',.' ',.n

Este é apenas um rápido aperto do original (veja abaixo). Provavelmente ainda é possível jogar muito golfe para eliminar muita manipulação inútil de classificação e boxe.

Apenas ressalva: a régua é apenas o último dígito, diferente da saída de exemplo.

Editar: Correção de bugs - as cidades tinham rótulos errados (e não estavam em ordem alfabética no mapa).

Edição 2: foram removidos todos os tipos de brincadeiras e brincadeiras para economizar 69 caracteres.

Saída (Verbatim, do script de teste):

First example: 
01234567
1    B  
2   **  
3   * * 
4  A  * 
5  *  * 
6 *    *
7 *    C
8 *  ** 
9* **   
0D*     

A: ACity    
B: Home     
C: Wherever 
D: SomeTown 

Second example:
012345678901234567890123456789012
1         D          F           
2        * *       ***           
3       *   **    *  *           
4       *     * **   *           
5      *       E     *           
6     *              *           
7    C              *          *I
8     **            *      ***** 
9       *           *   *H*   *  
0        **         * **     *   
1          **       G*     **    
2  A*********B            *      
3   **                   *       
4     *                 J        
5      **              *         
6        Q             *         
7      **             *          
8    **              K           
9  **                 *          
0P*                    *         
1 *           N        *         
2  *        ** *        L        
3   *     **    *     **         
4    *  **       *  **           
5     O*          M*             

A: great bridge        
B: supermarket         
C: home                
D: beach               
E: park                
F: little island       
G: friend's house      
H: SO building         
I: forest              
J: tea-shop            
K: cinema              
L: restaurant          
M: airport             
N: old castle          
O: museum of code-golf 
P: riverside           
Q: new plaza           
   End Second

Original não destruído:

coords =: > 1 {" 1 parsed =: ([:<`([:<[:".;._1'|',}:);._1'(',]);._2 (1!:1)3

center =: (+/%#) coords
max =: >:>./ coords
angles =:  12 o. j./"1 coords -"1 center
ordered =: parsed /: angles
paths =: >(],"0(1)|.]) 1 {" 1 ordered

path_grid_lengths =: ([:>./|@-/)"2 paths
path_grid_interval =: ([:<]%~i.@>:@|)"0 path_grid_lengths
path_grid_distances =: -~/"2 paths
path_grid_steps =: path_grid_distances ([:<[*>@])"0 path_grid_interval

path_grid_points_sortof =: (> 1{"1 ordered) ([:<0.5<.@+[+>@])"0 path_grid_steps
path_grid_points =: <"1;([:<>@[,.>@])/"1 path_grid_points_sortof

graph_body =: }."1}. (u:65+i.#ordered) (1{"1 ordered) } '*' path_grid_points} max $ ' '

axis_top =: |:(":"0)10|}.i. 1{max
axis_side =: (":"0)10|i. 0{max

echo |:(axis_side) ,"1 axis_top, graph_body
echo ''
echo (u:65+i.#parsed),.':',.' ',.(> 0{"1 ordered)

Haskell, 633 caracteres

import List
c n=n>>=(++" ").show.(*3)
(x&y)l="<text x='"++c[x]++"' y='"++c[y]++"'>"++l++"</text>"
f%p=[a-1,b+2,(a+b)/2]where n=map(f.fst)p;a=minimum n;b=maximum n
s p=concat["<svg xmlns='http://www.w3.org/2000/svg' viewBox='",c[i,m-1,j,n],"'><polygon fill='none' stroke='#c8c' points='",c$snd=<<(sort$map a p),"'/><g font-size='1' fill='#bbb'>",(\x->(x&m$show x)++(i&x$show x))=<<[floor(i`min`m)..ceiling(j`max`n)],"</g><g font-size='2'>",snd=<<p,"</g></svg>"]where a((x,y),_)=(atan2(x-q)(y-r),[x,y]);[i,j,q,m,n,r]=fst%p++snd%p
w(l,s)=((x,y),(x&y)l)where(x,r)=v s;(y,_)=v r
v=head.reads.tail
main=interact$s.map(w.break(=='(')).lines

Bastante demorado para o código-golfe, mas produz um mapa SVG adorável:

Ou, se o seu navegador não puder lidar com SVG, um PNG dessa imagem:

• Edit: (648 -> 633) desenho de coordenadas em linha e, possivelmente, desenhe mais do que o necessário, permitindo que eles sejam cortados pelo viewBox; também alguns truques de golfe aqui e ali.

Python, 516 476 bytes

#!/usr/bin/python
#coding=utf-8
import sys
H=V=0
T=[]
k=65
for L in sys.stdin.readlines():
 i,j,K=L.find('('),L.find('|'),'%c'%k
 n,h,v=L[:i-1],int(L[i+1:j]),int(L[j+1:-2])
 H=max(H,h);V=max(V,v);T+=[(K,h,v)];k+=1;print K+':',n
V=V+1&~1
for s in zip(*['%3d'%(i+1)for i in range(H)]):print'   '+''.join(s)
C=H*V*[u'─']
C[0::H]=u'│'*V
C[1::H]=V/2*u'└┌'
C[H-1::H]=V/2*u'┐┘'
C[0:2]=u'┌─'
C[-H:-H+2]=u'└─'
for K,h,v in T:C[v*H-H+h-1]=K
for i in range(V):print'%3d'%(i+1)+''.join(C[i*H:i*H+H])

(Nota: não incluí as duas primeiras linhas na contagem de bytes, considero-as "parâmetros do interpretador". Mas cobri-me pelo comprimento utf-8 do programa em bytes.)

No seu segundo exemplo, produzo:

A: home
B: supermarket
C: park
D: new plaza
E: friend's house
F: old castle
G: riverside
H: beach
I: cinema
J: forest
K: little island
L: museum of code-golf
M: airport
N: tea-shop
O: restaurant
P: great bridge
Q: SO building

            11111111112222222222333
   12345678901234567890123456789012
  1┌────────H──────────K──────────┐
  2│┌─────────────────────────────┘
  3│└─────────────────────────────┐
  4│┌─────────────────────────────┘
  5│└────────────C────────────────┐
  6│┌─────────────────────────────┘
  7│└──A──────────────────────────J
  8│┌─────────────────────────────┘
  9│└──────────────────────Q──────┐
 10│┌─────────────────────────────┘
 11│└─────────────────E───────────┐
 12│┌P─────────B──────────────────┘
 13│└─────────────────────────────┐
 14│┌─────────────────────N───────┘
 15│└─────────────────────────────┐
 16│┌──────D──────────────────────┘
 17│└─────────────────────────────┐
 18│┌──────────────────I──────────┘
 19│└─────────────────────────────┐
 20G┌─────────────────────────────┘
 21│└───────────F─────────────────┐
 22│┌─────────────────────O───────┘
 23│└─────────────────────────────┐
 24│┌─────────────────────────────┘
 25│└───L───────────M─────────────┐
 26└──────────────────────────────┘

Sim, glifos Unicode!

Python, 1074 bytes

Ok, gastamos muitos bytes (e tempo) obtendo caminhos razoáveis ​​para o trabalho.

#!/usr/bin/python
#coding=utf-8
import sys
H=V=0
T=[]
k=65
R=1000
for L in sys.stdin.readlines():
 i,j,K=L.find('('),L.find('|'),'%c'%k
 n,h,v=L[:i-1],int(L[i+1:j]),int(L[j+1:-2])
 H=max(H,h);V=max(V,v);T+=[(v*R-R+h-1,K)];k+=1;print K+':',n
for s in zip(*['%3d'%(i+1)for i in range(H+1)]):print'   '+''.join(s)
T.sort()
U=reduce(lambda a,x:a[:-1]+[(a[-1][0],x)]if x/R==a[-1][0]/R else a+[(x,x)],[[(T[0][0],T[0][0])]]+map(lambda x:x[0],T))
C=R*V*[' ']
r=0
for x,y in U:C[x:y]=(y-x)*u'─'
for (a,b),(c,d)in zip(U,U[1:]):
 if r:
  if d%R>b%R:x=b/R*R+d%R;C[b:x]=(x-b)*u'─';C[x:d:R]=(d-x)/R*u'│';C[x]=u'┐'
  else:x=d/R*R+b%R;C[d:x]=(x-d)*u'─';C[b:x:R]=(x-b)/R*u'│';C[x]=u'┘'
 else:
  if c%R<a%R:x=a/R*R+c%R;C[x:a]=(a-x)*u'─';C[x:c:R]=(c-x)/R*u'│';C[x]=u'┌'
  else:x=c/R*R+a%R;C[a:x:R]=(x-a)/R*u'│';C[x:c]=(c-x)*u'─';C[x]=u'└'
 r^=1
p=U[0][1];C[p:H]=(H-p)*u'─'
if r:p=U[-1][1];C[p:R*V]=(R*V-p)*u'─'
else:V+=1;C+=[' ']*R;p=U[-1][0]+R;C[p:R*V]=(R*V-p)*u'─';C[p]=u'└'
C[H::R]=u'┐'+u'│'*(V-2)+u'┘'
for p,K in T:C[p]=K
for i in range(V):print'%3d'%(i+1)+''.join(C[i*R:i*R+H+1])

Faz bons caminhos, no entanto:

A: SomeTown
B: ACity
C: Wherever
D: Home


   12345678
  1  ┌─D──┐
  2  │    │
  3  │    │
  4  B───┐│
  5      ││
  6      ││
  7┌─────C│
  8│      │
  9│      │
 10A──────┘

e

A: home
B: supermarket
C: park
D: new plaza
E: friend's house
F: old castle
G: riverside
H: beach
I: cinema
J: forest
K: little island
L: museum of code-golf
M: airport
N: tea-shop
O: restaurant
P: great bridge
Q: SO building

            111111111122222222223333
   123456789012345678901234567890123
  1         H──────────K───────────┐
  2         │                      │
  3         │                      │
  4         │                      │
  5         └────C────────────────┐│
  6                               ││
  7    A──────────────────────────J│
  8    │                           │
  9    └───────────────────Q       │
 10                        │       │
 11  ┌────────────────E────┘       │
 12  P─────────B──────────┐        │
 13                       │        │
 14        ┌──────────────N        │
 15        │                       │
 16        D───────────┐           │
 17                    │           │
 18┌───────────────────I           │
 19│                               │
 20G────────────┐                  │
 21             F                  │
 22             └─────────O        │
 23                       │        │
 24                       │        │
 25     L───────────M─────┘        │
 26     └──────────────────────────┘