Jones는 자전거를 타고 왕복 여행을하고 싶어합니다. 그는 여러 도시를 임의의 순서로 방문하기를 원하지만 휴가 중 같은 장소에 두 번있는 것을 싫어하기 때문에 자신의 경로가 자체 경로를 넘어서는 안됩니다. 그는 자전거 타기를 좋아하기 때문에 경로의 길이는 전혀 관련이 없지만 목표없이 풍경을 돌아 다니는 것을 싫어합니다. 그가 좋아하는 길은 도시에서 다른 곳으로가는 직선으로 우회하지 않습니다.

Jones는 열렬한 코드 골퍼이므로 도시 세트를 고려할 때 왕복 여행을 계획하는 프로그램을 원합니다. 입력 형식은 A (B|C)입니다. A도시의 이름, B그리고 C그 좌표입니다. 좌표가 양수이고 1000보다 작다고 가정 할 수 있습니다. 도시에 대한 데이터 세트는 선으로 구분됩니다. 다음은 입력 예의 모양에 대한 예입니다.

SomeTown (1 | 10)
활동 (3 | 4)
어디에나 (7 | 7)
홈 (5 | 1)

존스는 미숙하지 않고 유용한 프로그램을 원합니다. 따라서 다음 기준을 충족하는 한 출력 결과가 어떻게 보이는지 스스로 결정할 수 있습니다.

• 결과는 도시들 사이에 경로가 그려진 도시의지도입니다. 올바른 것이 있으면 경로가 겹치지 않아야하며 시작된 위치에서 끝나야합니다.
• 좌표는 일반적인 프로그래밍과 같습니다 : (1 | 1)은 NW 코너에 있습니다. 지도 테두리에 눈금자를 추가하여 쉽게 읽을 수 있습니다.
• 도시 이름은지도에 기록해야하지만지도의 다른 곳에서 설명하는 약어를 자유롭게 사용하십시오.
• 지도는 ASCII 아트 또는 이미지 일 수 있습니다.
• 출력을 읽을 수있게 유지

출력은 다음과 같습니다.

  1234567
 1 일  
 2 * * 
 삼 * * 
 4 B *
 5 * *
 6 * *
 7 * C
 8 * ** 
 9 * *   
10A **

A : SomeTown
B : ACity
C : 어디서나
D : 홈

가장 작은 문자 수를 가진 프로그램이 승리합니다. 컴파일러 / 인터프리터에 매개 변수를 컴파일에 필요한 경우 계산하지 않지만이 규칙을 남용하지 마십시오. 일반적인 코드 골프 규칙이 적용됩니다.

다른 테스트 케이스가 있습니다. 출력 결과가 나와 일치하지 않아도되고 나와 같은 경로를 선택하지 않아도됩니다. 출력은 손으로 그려지며 가능한 출력을 보여줍니다. 입력:

집 (5 | 7)
슈퍼마켓 (13 | 12)
공원 (15 | 5)
새로운 광장 (9 | 16)
친구의 집 (20 | 11)
오래된 성 (14 | 21)
리버 사이드 (1 | 20)
해변 (10 | 1)
시네마 (21 | 18)
숲 (23 | 7)
작은 섬 (21 | 1)
코드 골프 박물관 (6 | 25)
공항 (18 | 25)
차 가게 (24 | 14)
레스토랑 (24 | 22)
큰 다리 (3 | 12)
SO 건물 (25 | 9)

그리고 이것은 예제 출력입니다.

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

홈
B : 슈퍼마켓
C : 공원
D : 새로운 광장
E : 친구의 집
F : 오래된 성
G : 강변
H : 해변
나 : 영화
J : 숲
K : 작은 섬
L : 코드 골프 박물관
M : 공항
N : 티샵
O : 식당
P : 큰 다리
Q : SO 건물

나는 영어 원어민이 아닙니다. 필요한 경우 내 언어와 문법을 수정하십시오.

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

이것은 원본을 빠르게 압축하는 것입니다 (아래 참조). 쓸모없는 계급 조작과 복싱을 없애기 위해 많은 골프가 여전히 가능합니다.

주의 사항 : 눈금자는 예제 출력과 달리 마지막 숫자입니다.

편집 : 버그 수정-도시에 잘못된 레이블이 있었고지도에서 알파 순서가 아닙니다.

편집 2 : 69자를 절약하기 위해 모든 종류의 말놀이 및 tomfoolery를 제거했습니다.

출력 (테스트 스크립트에서 사용한 그대로) :

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

ungolfed 원본 :

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)

하스켈, 633 자

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

코드 골프를 갈망하지만 멋진 SVG 맵을 생성합니다.

또는 브라우저가 SVG, 해당 이미지의 PNG를 처리 할 수없는 경우 :

• 편집 : (648-> 633) 인라인 좌표 그리기 및 필요한 것 이상을 그려서 viewBox; 여기저기서 골프 트릭도 있습니다.

파이썬, (516) 476 바이트

#!/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])

(참고 : 바이트 수에 처음 두 줄을 포함시키지 않았으며 "인터프리터 매개 변수"라고 생각합니다. 그러나 프로그램의 utf-8 길이를 바이트 단위로 청구했습니다.)

두 번째 예에서 나는 다음을 생산합니다.

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└──────────────────────────────┘

예, 유니 코드 글리프!

파이썬, 1074 바이트

좋아, 합리적인 경로를 얻기 위해 너무 많은 바이트 (및 시간)를 보냈습니다.

#!/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])

그러나 좋은 길을 만듭니다.

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


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

과

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     └──────────────────────────┘