श्री जोन्स को अपनी साइकिल राउंड-ट्रिप का आनंद लेने में मदद करें

Question

श्री जोन्स अपनी साइकिल पर एक गोल-यात्रा करना चाहते हैं। वह मनमाने क्रम में कई शहरों की यात्रा करना चाहता है, लेकिन उसका मार्ग उसे स्वयं नहीं पार करना चाहिए, क्योंकि वह अपनी छुट्टियों में दो बार एक ही स्थान पर रहने से घृणा करता है। जैसा कि वह वास्तव में साइकिल चलाना पसंद करता है, उसके मार्ग की लंबाई पूरी तरह से अप्रासंगिक है, लेकिन वह लक्ष्य के बिना परिदृश्य के आसपास ड्राइव करने के लिए नापसंद करता है। वह जिस मार्ग को पसंद करता है वह शहर से एक सीधी रेखा में दूसरे तक, बिना किसी चक्कर के है।

जैसा कि मि। जोन्स एक भावुक कोड गोल्फर है, वह चाहता है कि आप एक कार्यक्रम खोजें, जो उसके लिए एक दौर की यात्रा की योजना बनाये, उसे शहरों का एक सेट दिया जाए। इनपुट का रूप है A (B|C)। Aशहर का नाम है, Bऔर Cइसके निर्देशांक हैं। आप मान सकते हैं, कि समन्वय सकारात्मक है और 1000 से कम है। शहरों के लिए डेटा सेट लाइन-अलग हैं। यहाँ एक उदाहरण है, उदाहरण इनपुट कैसे दिख सकता है:

कुछ एयरपोर्ट (1 | 10)
ACity (3 | 4)
जहां (7 | 7)
घर (5 | 1)

श्री जोन्स पांडित्यपूर्ण नहीं हैं, वे केवल एक उपयोगी कार्यक्रम रखना चाहते हैं। इस प्रकार, आप अपने आप से तय कर सकते हैं कि आउटपुट कैसा दिख रहा है, जब तक यह इन मानदंडों को पूरा करता है:

• आउटपुट शहरों का एक नक्शा है, जिसके बीच का रास्ता निकाला गया है। यदि कुछ भी सही है, तो मार्ग को खुद को ओवरलैप नहीं करना चाहिए और जहां शुरू हुआ था, उसे समाप्त करना चाहिए
• निर्देशांक सामान्य प्रोग्रामिंग की तरह हैं: (1 | 1) NW कोने में है। मैप्स बॉर्डर पर एक शासक को जोड़ें, ताकि उसे पढ़ने में आसानी हो
• शहरों के नामों को मानचित्र पर लिखा जाना चाहिए, लेकिन उन संक्षिप्ताक्षरों का उपयोग करने के लिए स्वतंत्र महसूस करें जिन्हें मानचित्र में कहीं और समझाया गया है
• नक्शा ASCII- कला या एक छवि दोनों हो सकता है
• आउटपुट को पठनीय रखें

एक आउटपुट इस तरह दिख सकता है:

  1234567
 1 डी  
 2 * * 
 3 * * 
 4 बी *
 ५ * *
 6 * *
 7 * सी
 * ** 
 ९ * *   
10:00 पूर्वाह्न**

A: कुछ शहर
B: ACity
C: जहाँ भी
डी: घर

सबसे छोटी चार गिनती के साथ कार्यक्रम जीतता है। मैं कंपाइलर / दुभाषिया के मापदंडों की गणना नहीं करता, अगर उन्हें संकलन के लिए आवश्यक है, लेकिन कृपया इस नियम का दुरुपयोग न करें। सामान्य कोड गोल्फ नियम लागू होते हैं।

यहाँ एक और टेस्टकेस है। आपको आउटपुट से मेरा मिलान नहीं करना है, न ही आपको मेरे जैसा ही रास्ता चुनना है। आउटपुट हाथ से तैयार किया गया है और एक संभावित आउटपुट दिखाता है। इनपुट:

घर (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 एच * * के    
 2 * * * *   
 3 * * * *   
 4 * * ** *   
 5 * सी *   
 6 * *   
 7 एजे  
 8 * *  
 ९ * प्र
10 * *
११ * *** ई *
12 पीबी *** * * 
13 * * * * 
14 * * * एन 
15 * * * * 
16 * डी * * 
17 * * * * 
18 * * मैं * 
19 * * * * 
20G * * * 
21 * एफ * *
22 * ** * हे 
23 * ** * **  
24 * ** * *    
25 एल ** एम **

एक घर
B: सुपरमार्केट
C: पार्क
डी: नया प्लाज़ा
E: दोस्त का घर
F: पुराना महल
जी: नदी के किनारे
एच: समुद्र तट
मैं: सिनेमा
जे: वन
K: छोटा द्वीप
एल: कोड-गोल्फ का संग्रहालय
एम: हवाई अड्डा
N: चाय की दुकान
O: रेस्तरां
P: महान पुल
प्रश्न: एसओ भवन

मैं अंग्रेजी मूल का वक्ता नहीं हूं। यदि आवश्यक हो तो मेरी भाषा और व्याकरण को ठीक करने के लिए स्वतंत्र महसूस करें।

Answer 1

जे, 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)

Comments

आप जानते हैं, सवाल यह है कि उत्पादन ज्यादातर फ्रीफ़ॉर्म है, इसलिए आपको लेबल का एक विशिष्ट क्रम रखने की आवश्यकता नहीं है।

— फूजएक्सएक्सएल

@FUxxxxl: यह आदेश नहीं है, यह है कि शहरों को गलत (गलत स्थान) लेबल किया गया था

— जेसी मिलिकन

तुम जीते। (15 वर्ण)

— फूज़लक्ल

एक टिप्पणी में कम से कम 15 वर्ण होने चाहिए। चूँकि मैं आपको बताना चाहता था, कि आपने मेरा काम जीत लिया, और सादा संदेश »आप जीत गए।« छोटा है तो 15, मुझे यह पाठ जोड़ना पड़ा।

— फ़ूजएक्सएक्सएल

खैर, मुझे खुशी है कि हमारी यह छोटी सी बात थी।

— जेसी मिलिकन

Answer 2

हास्केल, 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, उस छवि का PNG नहीं संभाल सकता है:

---

• संपादित करें: (648 -> 633) इन-लाइन ड्राइंग को समन्वित करते हैं, और संभवतः आवश्यकता से अधिक खींचते हैं, जिससे उन्हें क्लिप किया जा सकता है viewBox; कुछ गोल्फ-चाल यहाँ और वहाँ भी।

Comments

कैसे xmlns सामान छीनने के बारे में? कुछ दर्शकों को इसकी आवश्यकता नहीं है।

— फूज़लक्ले

मेरे पास कोई ब्राउज़र नहीं है जो SVG w / o को xmlns घोषणा प्रदर्शित करेगा।

— माउंटन व्यूमार्क

हम्म ... कम से कम आंखें सूँघेंगी। (हालांकि यह एक ब्राउज़र नहीं है)

— FUZxxl

Answer 3

पायथन, 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└──────────────────────────────┘

याय, यूनिकोड ग्लिफ़!

Comments

ओह ... यह नहीं है कि मैं अपनी साइकिल यात्रा कैसे चाहूँगा। मूल रूप से, मैंने केवल दो शहरों के बीच सबसे छोटे मार्ग की अनुमति देने की योजना बनाई, लेकिन मैं इस प्रतिबंध को भूल गया। यदि आप सहमत हैं, तो मैं प्रश्न को फिर से लिखना चाहूंगा, ताकि दो शहरों के बीच केवल सीधे मार्ग की अनुमति हो।

— फ़ूजएक्सल

यकीन है, यह ठीक होगा। यह नकद पुरस्कार नहीं है :)

— कीथ रान्डेल

बहुत बहुत धन्यवाद। मुझे आपके प्रवेश को गलत बनाने के लिए बहुत खेद है, आपको इसके बदले एक विशेष मूल्य मिलता है।

— फूज़ल

Answer 4

पायथन, 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     └──────────────────────────┘

Comments

यह एक अच्छा है, हालांकि यह दो शहरों में सबसे कम संभव कनेक्शन का उपयोग नहीं करता है।

— फ़ूजएक्सएक्सएल