Oto sztuka ASCII 4-kierunkowego skrzyżowania:

     |  |  |
     |     |
     |  |  |
     |     |
     |  |  |
-----+-----+-----
     |     |     
- - -|     |- - -
     |     |     
-----+-----+-----
     |  |  |
     |     |
     |  |  |
     |     |
     |  |  |

(Zwróć uwagę, jak poziome drogi mają 3 rzędy wysokości, podczas gdy pionowe drogi mają 5 kolumn szerokości. Jest to ze względów estetycznych, ze względu na prostokątną czcionkę).

Twoim wyzwaniem jest stworzenie tej sztuki ASCII. Jednak, jak zapewne wszyscy wiecie, nie każde skrzyżowanie ma drogę biegnącą w każdym kierunku. To konkretne skrzyżowanie idzie NESW, ale niektóre skrzyżowania mogą iść na przykład NW:

     |  |  |
     |     |
     |  |  |
     |     |
     |  |  |
-----+-----+
     |     |
- - -|     |
     |     |
-----+-----+

Lub może pójść SWE:

-----+-----+-----
     |     |     
- - -|     |- - -
     |     |     
-----+-----+-----
     |  |  |
     |     |
     |  |  |
     |     |
     |  |  |

A może nawet pójść E, tylko w jednym kierunku (chociaż trudno nazwać to skrzyżowaniem , ale staraj się unikać nadmiernej pedantyczności):

     +-----+-----
     |     |     
     |     |- - -
     |     |     
     +-----+-----

Musisz napisać program lub funkcję, która może łatwo wygenerować dowolną z tych kombinacji. Mówiąc dokładniej, Twoim wyzwaniem jest napisanie programu lub funkcji, która pobiera ciąg kierunków, składający się z NESW, jako danych wejściowych, danych wyjściowych lub zwraca tę sztukę ASCII skrzyżowania z drogami wskazującymi w tych kierunkach. Kierunki te mogą występować w dowolnej kolejności, ale wejście nie będzie zawierać żadnych znaków z wyjątkiem N, E, S, lub W. Jeśli chcesz, możesz zamiast tego poprosić o wprowadzanie małych liter, ale musisz podać to w swojej odpowiedzi. Możesz również założyć, że wszystkie dane wejściowe będą zawierać co najmniej jeden kierunek.

Ostatni przykład miał spacje wiodące na każdej linii, ponieważ nie ma drogi prowadzącej na zachód. Jeśli nie masz drogi prowadzącej na zachód, te wiodące pola są opcjonalne. To:

+-----+-----
|     |     
|     |- - -
|     |     
+-----+-----

Byłby również akceptowalnym wyjściem. Podobnie, jeśli Nlub Szniknie, puste linie tam są opcjonalne. Dozwolony jest jeden końcowy znak nowej linii, a końcowe spacje są dozwolone, o ile wynik jest wizualnie taki sam.

Możesz pobierać dane wejściowe i wyjściowe w dowolnym rozsądnym formacie, takim jak STDIN / STDOUT, argumenty wiersza poleceń, pliki, argumenty funkcji / zwracane wartości itp.

Jak zwykle jest to gra w golfa , więc postaraj się uzyskać możliwie najkrótszą odpowiedź w jakimkolwiek języku, którego używasz!

Próbka IO:

NESW:

     |  |  |
     |     |
     |  |  |
     |     |
     |  |  |
-----+-----+-----
     |     |     
- - -|     |- - -
     |     |     
-----+-----+-----
     |  |  |
     |     |
     |  |  |
     |     |
     |  |  |


NS:

|  |  |
|     |
|  |  |
|     |
|  |  |
+-----+
|     |
|     |
|     |
+-----+
|  |  |
|     |
|  |  |
|     |
|  |  |

S:

+-----+
|     |
|     |
|     |
+-----+
|  |  |
|     |
|  |  |
|     |
|  |  |

EW:

-----+-----+-----
     |     |     
- - -|     |- - -
     |     |     
-----+-----+-----

SE:
+-----+-----
|     |     
|     |- - -
|     |     
+-----+-----
|  |  |
|     |
|  |  |
|     |
|  |  |

JavaScript (ES6), 190 187 185 bajtów

Jest to próba zbudowania tego znaku ASCII na znak przez iterację na matrycy 17x15. Dlatego dane wyjściowe są zawsze tworzone z 15 rzędów 17 kolumn z przecięciem dróg pośrodku.

p=>eval("for(y=15,s='';y--;s+=`\n`)for(x=17;x--;)s+=' |-+'[+[a=y>4,b=y<10,c=x>4,d=x<12].every((c,i)=>c|p.search('SNEW'[i])+1)&&!((z=x-8||y&1|a&b)&&z*z-9)+2*!((z=y-7||x&1|c&d)&&z*z-4)]")

Nie golfił i skomentował

for(y = 15, s = ''; y--; s += `\n`)   // iterate on y, from 14 to 0 / append line feeds
  for(x = 17; x--;)                   // iterate on x, from 16 to 0
    s += ' |-+' [                     // append next character to string
      +[ a = y > 4,                   // a = outside South area?
         b = y < 10,                  // b = outside North area?
         c = x > 4,                   // c = outside East area?
         d = x < 12 ]                 // d = outside West area?
      .every((c, i) =>                // for each area, see if either:
        c |                           //   - we're currently outside it
        p.search('SNEW' [i]) + 1      //   - or it's an allowed area (p = function param.)
      )                               // if all tests pass, add a:
      &&                              //   - vertical bar (encoded as 1) if:
      !((z = x - 8 || y & 1 | a & b)  //     - x=8, y is even and we're not in the middle
      && z * z - 9)                   //     - OR x=5 OR x=11 (<=> (x-8)*(x-8) = 9)
      + 2 *                           //   - horizontal bar (encoded as 2) if:
      !((z = y - 7 || x & 1 | c & d)  //     - y=7, x is even and we're not in the middle
      && z * z - 4)                   //     - OR y=5 OR y=9 (<=> (y-7)*(y-7) = 4)
    ]                                 // (vertical + horizontal = 3, which leads to '+')

Matryca

Poniżej znajduje się macierz ze współrzędnymi użytymi w kodzie.

Próbny

Poniższy fragment kodu pozwala wypróbować dowolną konfigurację drogi.

let f =
p=>eval("for(y=15,s='';y--;s+=`\n`)for(x=17;x--;)s+=' |-+'[+[a=y>4,b=y<10,c=x>4,d=x<12].every((c,i)=>c|p.search('SNEW'[i])+1)&&!((z=x-8||y&1|a&b)&&z*z-9)+2*!((z=y-7||x&1|c&d)&&z*z-4)]")

function update() {
  document.getElementById("o").innerHTML = f(document.getElementById("s").value);
}
update();

<input id="s" size=4 value="NSEW" oninput="update()">
<pre id="o" style="font-size:9px"></pre>

PowerShell v3 +, 226 204 192 191 bajtów

param([char[]]$a)($n=0..4|%{($x=' '*5*($b=87-in$a))+('|  |  |',($w='|     |'))[$_%2]})*(78-in$a)
($z=($y='-'*5)*$b+"+$y+"+$y*($c=69-in$a))
$x+$w
'- - -'*$b+$w+'- - -'*$c
$x+$w
$z
$n*(83-in$a)

Pobiera dane wejściowe jako ciąg wielkich liter, jawnie rzutuje je jako chartablicę. Konstruuje segment „północny” poprzez zapętlenie od 0do 4. Każda pętla konstruuje ciąg 5 spacji (jeśli W/ 87jest obecny na wejściu), przechowuje to w $x, a następnie albo | |( zapisuje w $w) lub | | |, w zależności od tego, czy obecnie jesteśmy parzyste czy nieparzyste. Ta tablica ciągów jest przechowywana $ni mnożona przez to, czy N/ 78jest -inwejściem. To określi, czy $nzostanie umieszczony w rurociągu, czy nie.

Następnie konstruujemy środkową część. Pierwszy wiersz $zto „szczyt” trasy wschód-zachód, wykorzystujący tę samą logikę dla Wi E/ 69i otoczony w parens, aby również umieścić kopię na rurociągu. Używamy zmiennej pomocniczej, $yaby zapisać bajt na -----sekcjach.

Kolejny wiersz to tylko odpowiednia liczba spacji (tzn. $x) Połączona z łańcuchem z rurami o odpowiedniej szerokości (tj $w.). Następnie, środkowa linia paski, dzięki Wi Elogiki i $wnadzieniem w środku. Potem $x+$wi $zznowu.

Wreszcie, ponieważ droga południowa jest taka sama jak północ, postaw $nna rurociągu, jeśli S/ 83jest -in $a.

Wszystkie te łańcuchy wynikowe są gromadzone z potoku, a dane wyjściowe są niejawne pod koniec wykonywania programu. Nadużywa domyślnego Write-Outputseparatora do wstawiania nowej linii między elementami.

Przykłady

PS C:\Tools\Scripts\golfing> .\4-way-intersection.ps1 'EN'
|  |  |
|     |
|  |  |
|     |
|  |  |
+-----+-----
|     |
|     |- - -
|     |
+-----+-----

PS C:\Tools\Scripts\golfing> .\4-way-intersection.ps1 'SNW'
     |  |  |
     |     |
     |  |  |
     |     |
     |  |  |
-----+-----+
     |     |
- - -|     |
     |     |
-----+-----+
     |  |  |
     |     |
     |  |  |
     |     |
     |  |  |

PS C:\Tools\Scripts\golfing> .\4-way-intersection.ps1 'WE'
-----+-----+-----
     |     |
- - -|     |- - -
     |     |
-----+-----+-----

C ++ 317 280 276 bajtów

int i(char*j){for(int y=0;y<15;++y)for(int x=0;x<18;++x)putchar(x-17?y<5&!strchr(j,'N')|y>9&!strchr(j,'S')|x<5&!strchr(j,'W')|x>11&!strchr(j,'E')?' ' :x==5|x==11?y==5|y==9?'+':'|':y==5|y==9?x==5|x==11?'+':'-':x==8&y%2|y==7&x%2?' ':x==8&(y/5-1)?'|':y==7&(x/6-1)?'-':' ':'\n');}

Nie golfowany:

int i (char* j)
{
  for (int y=0; y<15; ++y)
    for (int x=0; x<18; ++x)
      putchar(
        x-17 ? 
        y<5 & !strchr(j,'N') |
        y>9 & !strchr(j,'S') |
        x<5 & !strchr(j,'W') |
        x>11 & !strchr(j,'E') ? ' ' :
        x==5 | x==11 ? y==5 | y==9 ? '+' : '|' : 
        y==5 | y==9 ? x==5 | x==11 ? '+' : '-' : 
        x==8 & y%2 | y==7 & x%2 ? ' ' : 
        x==8 & (y / 5 - 1) ? '|' :
        y==7 & (x / 6 - 1) ? '-' :
        ' ' : '\n');
}

Python 3, 186 bajtów

S=' -- -  -- -  --'
lambda d:'\n'.join(S[r//4:15*('W'in d):3]+'||+  -  -| -  -  -||+'[r%4::3]+S[r//4:15*('E'in d):3]for r in[0,1,0,1,0,6,1,9,1,6,0,1,0,1,0][5-5*('N'in d):10+5*('S'in d)])

Anonimowy lambda dzwonił z ciągiem wskazówek, np. „NWS”

Wyjaśnienie do naśladowania

sed 234

s,$,@+-----+@|     |@!     !@|     |@+-----+@,
:l;tl
/N/s,^,#,;t
:r
/S/s,@$,#,;t
/E/{s,!@,|- - -@,;s,+@,+-----@,g}
/W/{s,@!,@- - -|,;s,@+,@-----+,g;s,@|,@     |,g}
y,@!NSEW,\n|    ,
q
:
s,#,@|  |  |@|     |@|  |  |@|     |@|  |  |,
tr

Po prostu buduje różne części, jeśli na linii znajduje się właściwy znak.
Używa @zamiast \ni subskrybuje z \npowrotem na końcu.
Części północna i południowa są identyczne, więc używam tego, co w zasadzie jest funkcją, aby je wstawić.

Partia, 351 344 341 bajtów

@echo off
set/pi=
set t=     
if not "%i:n=%"=="%i%" call:l
set l=-----
set r=%l%
if "%i:w=%"=="%i%" set l=%t%
if "%i:e=%"=="%i%" set r= 
for %%s in (%l%+-----+%r% "%t%|%t%|" "%l:--=- %|%t%|%r:--=- %" "%t%|%t%|" %l%+-----+%r%) do echo %%~s
if "%i:s=%"=="%i%" exit/b
:l
call :m
call :n
:n
echo %t%^|%t%^|
:m
echo %t%^|  ^|  ^|

Uwaga: Linia set t=kończy się pięcioma spacjami, a linia if "%i:e=%"=="%i%" set r=kończy się spacją. Pobiera rozróżnianie wielkości liter od STDIN. Edycja: Zapisano 7 bajtów, eliminując dzmienną. Zaoszczędzono 3 bajty, używając forpętli do wydrukowania środkowej części. Jeśli zamiast tego wolno mi używać osobnych parametrów wiersza polecenia, to dla 326 319 316 bajtów:

@echo off
set t=%*
set/an=s=e=w=5,%t: ==%=0
set t=     
call:%n%
set r=-----%t%
call set l=%%r:~%w%,5%%
call set r=%%r:~%e%%%
for %%s in (%l%+-----+%r% "%t%|%t%|" "%l:--=- %|%t%|%r:--=- %" "%t%|%t%|" %l%+-----+%r%) do echo %%~s
goto %s%
:0
call :1
call :2
:2
echo %t%^|%t%^|
:1
echo %t%^|  ^|  ^|
:5

Python 2, 290 bajtów

t,s,r,i=[],[],range(5),raw_input()
for n in r:t+=[" "*5*("W"in i)+"|  "+("|"," ")[n%2]+"  |"]
exec"s+=['-'*5];s[:1]+=' '*5,;"*2;s[:2]+="- - -",
if"N"in i:print'\n'.join(t)
print'\n'.join([s[n]*("W"in i)+("|     |","+-----+")[`n`in"04"]+s[n]*("E"in i)for n in r])
if"S"in i:print'\n'.join(t)

GolfScript, 154 bajtów

{a?1+}:x;'-'5*:e;' '5*:b;"+"e+"+"+:f;{b'|'b'|'b n}:k;{'W'x{e}{b}if\'E'x{e}{}if n}:y;{x{b"|  |  |
"+:c k c k c}{}if}:z;1/:a;'N'z f y k'|'b+'|'+ y k f y'S'z

Wypróbuj online!

Pyth ( 385 380 373 353 bajtów)

Gra w golfa:

K"     |  |  |\n     |     |\n"?}\Nz++KKPKk?}\Wz?}\Ez+++*5\-*2+\+*5\-"\n     |     |\n- - -|     |- - -\n     |     |\n"+*5\-*2+\+*5\-++*2+*5\-\+"\n     |     |\n- - -|     |\n     |     |\n"*2+*5\-\+?}\Ez+"     "+*2+\+*5\-"\n     |     |\n     |     |- - -\n     |     |\n     +-----+-----"++"     +-----+\n"*3"     |     |\n""     +-----+"?}\Sz++KKPKk

Nie golfowany:

K"     |  |  |\n     |     |\n"  //sets K to first two lines of north
?}\Nz                            //if north in the input 
  ++KKPK                         //then: return K + K + K[:-1]
  k                              //else: return ""
?}\Wz                            //if West in input
  ?}\Ez                          //if East in input
    +++*5\-*2+\+*5\-"\n     |     |\n- - -|     |- - -\n     |     |\n"+*5\-*2+\+*5\-    //then: Return E+W string
    ++*2+*5\-\+"\n     |     |\n- - -|     |\n     |     |\n"*2+*5\-\+         //else: Return W string
  ?}\Ez                          //else: if east in input (and not W)
    +"     "+*2+\+*5\-"\n     |     |\n     |     |- - -\n     |     |\n     +-----+-----" //return East without West String
    ++"     +-----+\n"*3"     |     |\n""     +-----+" \\Return empty left and right intersection
?}\Sz                            //if south in input
  ++KKPK                         //return north string
  k                              //return ""

Oczywiście, jeśli są jakieś ulepszenia, proszę o informację.

Zaoszczędź 5 bajtów dzięki Maltysen

Możesz spróbować tutaj

Groovy (274 bajtów)

Nie golfił

r{
    l->
    t='+-----+'
    s='     ';
    m='|     |'
    x='-----'
    v=(1..5).collect{s}
    nsR=(1..5).collect{[s,((it%2)?'|  |  |':m),s]}
    ewR=[x,s,'- - -',s,x]
    c=[l[3]?ewR:v,[t,m,m,m,t],l[1]?ewR:v]
    (l[0]?nsR.collect{it}:[])+((0..4).collect{x->((0..2).collect{y->c[y][x]})}​)​+​(l[2]?nsR.collect{it}:[])
}

Grał w golfa

def i(l) {t='+-----+';s='     ';m='|     |';x='-----';v=(1..5).collect{s};n=(1..5).collect{[s,((it%2)?'|  |  |':m),s]};e=[x,s,'- - -',s,x];c=[l[3]?e:v,[t,m,m,m,t],l[1]?e:v];(l[0]?n.collect{it}:[])+((0..4).collect{x->((0..2).collect{y->c[y][x]})}​)​+​(l[2]?n.collect{it}:[])}

Wypróbuj: https://groovyconsole.appspot.com/script/5082600544665600