帮助琼斯先生享受他的自行车往返

18

琼斯先生想骑自行车往返。他想以任意顺序参观几个城市，但是他的路线一定不能越过它，因为他不想在假期里两次到同一个地方。因为他真的很喜欢骑自行车，所以路线的长度完全无关紧要，但是他不喜欢在没有目标的情况下绕着风景行驶。他喜欢的路线是从城市直线延伸到另一条，没有任何弯路。

琼斯先生是一位热情的标准高尔夫球手，他希望您找到一个计划，给他计划一个给定的往返城市的计划。输入具有形式A (B|C)。A是一个城市的名字，B并C为它的坐标。您可以假设坐标为正且小于1000。城市的数据集以行分隔。这是一个示例，示例输入可能如下所示：

SomeTown（1 | 10）
交流（3 | 4）
无论在哪里（7 | 7）
家（5 | 1）

琼斯先生不是书呆子，他只是想有一个有用的程序。因此，只要满足以下条件，您就可以自行决定输出的外观：

  • 输出是城市地图，并在城市之间绘制了路线。如果正确，则路线不应重叠，应在起点处结束
  • 坐标类似于常规编程：（1 | 1）在NW角。在地图边框上添加标尺，以方便阅读
  • 必须在地图上写下城市名称，但可以随意使用缩写，这在地图上的其他地方都有说明
  • 该地图可以是ASCII图片或图像
  • 保持输出可读

输出可能如下所示：

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

答：SomeTown
B：交流
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）
建筑物（25 | 9）

这是一个示例输出：

           1111111111222222
  1234567890123456789012345
 1高​​ * 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 * *我* 
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：伟大的桥梁
问：SO大厦

我不是英语母语人士。如有必要，请随时纠正我的语言和语法。

code-golf  ascii-art  graph-theory  graphical-output 
— FUZxxl
source

Answers:

9

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个字符。

输出（逐字记录，来自测试脚本）：

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

未装纸的原稿：

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)
— 杰西·米利坎（Jesse Millikan）
source
您知道，问题指出，输出大部分是自由格式的，因此您不必保持标签的特定顺序。
— FUZxxl 2011年
@FUZxxl：这不是命令，是因为城市被贴错了标签（位置错误）
— Jesse Millikan
1
你赢了。（15个字符）
— FUZxxl 2011年
2
注释必须至少包含15个字符。由于我想告诉您，您赢了我的任务，而简单的消息“您赢了。”短于15，因此我必须添加此文本。
— FUZxxl 2011年
2
好吧，我很高兴我们进行了这个小小的谈话。
— 杰西·米利坎
21

Haskell，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; 剪切；还有一些高尔夫球技巧。
— MtnViewMark
source
剥离xmlns东西怎么样？一些观众不需要它。
— FUZxxl 2011年
1
我没有浏览器将显示不带xmlns声明的SVG。
— MtnViewMark
嗯...至少侏儒会这样。（尽管它不是浏览器）
— FUZxxl
12

Python，第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└──────────────────────────────┘

是的，Unicode字形！

— 基思·兰德尔
source
哦，那不是我想要骑自行车的方式。最初，我计划只允许两个城市之间的最短路径，但我忘记了这一限制。如果您同意，我想重写这个问题，以便只允许两个城市之间的直接路线。
— 2011年
1
当然可以。这不是现金奖：)
— Keith Randall
非常感谢。非常抱歉您输入错误，而是获得了特价。
— FUZxxl 2011年
6

Python，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     └──────────────────────────┘
— 基思·兰德尔
source
那个很好，尽管它没有使用两个城市之间可能的最短连接。
— FUZxxl 2011年
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.