Aiuta Mr Jones a godersi il viaggio di andata e ritorno in bicicletta

18

Jones vuole fare un viaggio di andata e ritorno in bicicletta. Vuole visitare diverse città in ordine arbitrario, ma il suo percorso non deve attraversare se stesso, dal momento che odia essere nello stesso posto due volte durante le sue vacanze. Dato che ama davvero andare in bicicletta, la lunghezza del suo percorso è completamente irrilevante, ma non gli piace guidare il paesaggio senza un bersaglio. Il percorso che gli piace è dalla città in linea retta all'altro, senza alcuna deviazione.

Dato che Jones è un appassionato golfista di codici, vuole che tu trovi un programma, che pianifichi un viaggio di andata e ritorno per lui, dato un insieme di città. L'input ha il modulo A (B|C). Aè il nome di una città Be Csono le sue coordinate. Si può presumere che le coordinate siano positive e inferiori a 1000. I set di dati per le città sono separati da linee. Ecco un esempio di come potrebbe apparire un input di esempio:

SomeTown (1 | 10)
ACity (3 | 4)
Ovunque (7 | 7)
Home (5 | 1)

Il signor Jones non è pedante, vuole solo avere un programma utile. Pertanto, puoi decidere da solo come appare l'output, purché soddisfi questi criteri:

  • L'output è una mappa delle città, con il percorso tracciato tra di loro. Se qualcosa è corretto, il percorso non dovrebbe sovrapporsi e dovrebbe terminare dove è iniziato
  • Le coordinate sono come nella normale programmazione: (1 | 1) è nell'angolo NO. Aggiungi una specie di righello al bordo delle mappe, per facilitarne la lettura
  • I nomi delle città devono essere scritti sulla mappa, ma sentiti libero di usare abbreviazioni che sono spiegate altrove sulla mappa
  • La mappa può essere sia arte ASCII che un'immagine
  • Mantieni l'output leggibile

Un output potrebbe essere simile al seguente:

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

A: SomeTown
B: ACity
C: Ovunque
D: Casa

Vince il programma con il conteggio dei caratteri più piccolo. Non conto i parametri per il compilatore / interprete, se sono necessari per la compilazione, ma per favore non abusare di questa regola. Si applicano le normali regole del golf.

Ecco un altro testcase. L'output non deve corrispondere al mio, né devi scegliere lo stesso percorso per me. L'output viene disegnato a mano e mostra un output possibile. Ingresso:

casa (5 | 7)
supermercato (13 | 12)
parco (15 | 5)
nuova piazza (9 | 16)
casa degli amici (20 | 11)
vecchio castello (14 | 21)
lungo il fiume (1 | 20)
spiaggia (10 | 1)
cinema (21 | 18)
foresta (23 | 7)
isoletta (21 | 1)
museo del code-golf (6 | 25)
aeroporto (18 | 25)
negozio di tè (24 | 14)
ristorante (24 | 22)
grande ponte (3 | 12)
Edificio SO (25 | 9)

E questo è un esempio di output:

           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 * * I * 
19 * * * * 
20G * * * 
21 * F * *
22 * ** * O 
23 * ** * **  
24 * ** * *    
25 L ** M **

Una casa
B: supermercato
C: parco
D: nuova piazza
E: casa dell'amico
F: vecchio castello
G: lungo il fiume
H: spiaggia
I: cinema
J: foresta
K: piccola isola
L: museo del code-golf
M: aeroporto
N: negozio di tè
O: ristorante
P: grande ponte
D: SO building

Non sono un madrelingua inglese. Sentiti libero di correggere la mia lingua e la mia grammatica, se necessario.

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

Risposte:

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

Questa è solo una breve compressione dell'originale (vedi sotto). Un sacco di golf è probabilmente ancora possibile eliminare un sacco di inutili manipolazioni di rango e boxe.

Unico avvertimento: il righello è solo l'ultima cifra a differenza dell'output di esempio.

Modifica: correzione bug - Le città avevano etichette errate (e non erano in ordine alfabetico sulla mappa).

Modifica 2: rimossi tutti i tipi di equitazione e buffonate per un risparmio di 69 caratteri.

Output (Verbatim, dallo script di test):

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

Originale nonolfatto:

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
fonte
Sai, la domanda afferma che l'output è per lo più a mano libera, quindi non è necessario mantenere un ordine specifico delle etichette.
— FUZxxl
@FUZxxl: Non è l'ordine, è che le città sono state etichettate come sbagliate (posizioni sbagliate)
— Jesse Millikan
1
Hai vinto. (15 caratteri)
— FUZxxl
2
Un commento deve contenere almeno 15 caratteri. Dato che volevo dirti che hai vinto il mio compito e che il semplice messaggio "Hai vinto." È più corto di 15 anni, ho dovuto aggiungere questo testo.
— FUZxxl,
2
Bene, sono contento che abbiamo avuto questi discorsi.
— Jesse Millikan,
21

Haskell, 633 caratteri

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

Piuttosto longish per il code-golf, ma produce una bella mappa SVG: Percorso del signor Jones

Oppure, se il tuo browser non è in grado di gestire SVG, un PNG di quell'immagine: Percorso del signor Jones

  • Modifica: (648 -> 633) disegno di coordinate in linea e possibilmente disegna più del necessario, lasciandoli ritagliati dal viewBox; anche alcuni trucchi da golf qua e là.
— MtnViewMark
fonte
Che ne dici di rimuovere le cose xmlns? Alcuni spettatori non ne hanno bisogno.
— FUZxxl,
1
Nessun browser che ho mostrerà SVG senza la dichiarazione xmlns.
— MtnViewMark,
Hm ... almeno lo faranno gli occhi dello gnomo. (Anche se non è un browser)
— FUZxxl
12

Python, 516 476 byte

#!/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: non ho incluso le prime due righe nel conteggio dei byte, le considero "parametri dell'interprete". Ma mi sono addebitato la lunghezza del programma utf-8 in byte.)

Nel tuo secondo esempio produco:

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

Sì, glifi Unicode!

— Keith Randall
fonte
Ooo ... non è così che mi piacerebbe il mio viaggio in bicicletta. Inizialmente, avevo pianificato di consentire il percorso più breve solo tra due città, ma ho dimenticato questa restrizione. Se sei d'accordo, vorrei riscrivere la domanda, in modo che siano consentite solo rotte dirette tra due città.
— FUZxxl
1
Certo, andrebbe bene. Non è un premio in denaro :)
— Keith Randall
Grazie mille. Mi dispiace molto per aver sbagliato la tua iscrizione, invece ottieni un prezzo speciale.
— FUZxxl
6

Python, 1074 byte

Ok, ho passato troppi byte (e tempo) a ottenere percorsi ragionevoli per lavorare.

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

Fa bei percorsi, però:

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     └──────────────────────────┘
— Keith Randall
fonte
È bello, anche se non usa la connessione più breve possibile tra due città.
— FUZxxl
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.