Voici un art ASCII d'une intersection à 4 voies:

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

(Notez que les routes horizontales mesurent 3 rangées, tandis que les routes verticales ont 5 colonnes de large. C'est pour des raisons esthétiques, en raison de la police rectangulaire.)

Votre défi est de produire cet art ASCII. Cependant, comme vous le savez sûrement tous, toutes les intersections n'ont pas de route qui part dans toutes les directions. Cette intersection va NESW, mais certaines intersections pourraient aller, par exemple NW,:

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

Ou cela pourrait aller SWE:

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

Ou il peut même aller Edans une seule direction (même si vous pouvez difficilement appeler cela une intersection , mais essayez d'éviter d'être trop pédant):

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

Vous devez écrire un programme ou une fonction qui peut facilement générer n'importe laquelle de ces combinaisons. Plus précisément, votre défi consiste à écrire un programme ou une fonction qui prend une chaîne de directions, consistant NESWen entrée et qui renvoie ou renvoie cet art ASCII d'une intersection avec des routes pointant dans ces directions. Ces instructions peuvent apparaître dans un ordre quelconque, mais l'entrée ne contiennent aucun caractère à l' exception N, E, Sou W. Si vous le souhaitez, vous pouvez demander que les entrées soient en minuscules à la place, mais vous devez le spécifier dans votre réponse. Vous pouvez également supposer que toutes les entrées contiendront au moins une direction.

Le dernier exemple avait des espaces de tête sur chaque ligne, car il n'y a pas de route vers l'ouest. Si vous n'avez pas de route vers l'ouest, ces espaces de tête sont facultatifs. Cette:

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

Serait également une sortie acceptable. De même, si Nou Sest parti, les lignes vides à cet endroit sont facultatives. Une nouvelle ligne de fin est autorisée et les espaces de fin sont autorisés tant que la sortie est visuellement la même.

Vous pouvez prendre des entrées et des sorties dans n'importe quel format raisonnable, tel que STDIN / STDOUT, les arguments de ligne de commande, les fichiers, les arguments de fonction / valeurs de retour, etc.

Comme d'habitude, il s'agit de code-golf , alors essayez d'obtenir la réponse la plus courte possible dans la langue que vous utilisez!

Exemple d'E / S:

NESW:

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


NS:

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

S:

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

EW:

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

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

Javascript (ES6), 190 187 185 octets

Il s'agit d'une tentative de construction de ce personnage d'art ASCII par personnage en itérant sur une matrice 17x15. Par conséquent, la sortie est toujours composée de 15 lignes de 17 colonnes avec l'intersection des routes centrée au milieu.

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)]")

Non golfé et commenté

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 '+')

Matrice

Ci-dessous se trouve la matrice avec les coordonnées utilisées dans le code.

Démo

L'extrait suivant permet d'essayer n'importe quelle configuration de route.

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 octets

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)

Prend l'entrée comme une chaîne de lettres majuscules, la transforme explicitement en chartableau. Construit le segment "Nord" via une boucle de 0à 4. Chaque boucle, construit une chaîne de 5 espaces (si W/ 87est présent dans l'entrée), le stocke dans $x, puis soit | |(stocké dans $w) ou | | |, selon que nous sommes actuellement pairs ou impairs. Ce tableau de chaînes est stocké dans $n, et multiplié par si N/ 78est -inl'entrée. Cela déterminera si $nest placé sur le pipeline ou non.

Ensuite, nous construisons la partie médiane. La première ligne, $zest le "haut" de la route est-ouest, utilisant la même logique pour Wet E/ 69et entourée de parens pour placer également une copie sur le pipeline. Nous utilisons la variable d'assistance $ypour enregistrer un octet sur les -----sections.

La ligne suivante est juste le nombre approprié d'espaces (c'est-à-dire $x) concaténé en chaîne avec les tuyaux de bonne largeur (c'est-à-dire $w). Ensuite, la ligne rayée du milieu, encore une fois avec Wet la Elogique et le $wremplissage au milieu. Ensuite , $x+$wet à $znouveau.

Enfin, comme la route Sud est la même que le nord, mettez $nle pipeline si S/ 83est -in $a.

Toutes ces chaînes résultantes sont collectées à partir du pipeline et la sortie est implicite à la fin de l'exécution du programme. Abuse le Write-Outputdélimiteur par défaut pour insérer une nouvelle ligne entre les éléments.

Exemples

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 octets

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');}

Non golfé:

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 octets

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)])

Un lambda anonyme appelé avec une chaîne de directions, par exemple 'NWS'

Explication à suivre

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

Il construit simplement les différentes parties si le caractère approprié est sur la ligne.
Utilise à la @place de \net s'abonne \nà la fin.
Les parties nord et sud sont identiques, donc j'utilise ce qui est essentiellement une fonction pour les insérer.

Lot, 351 344 341 octets

@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%^|  ^|  ^|

Remarque: la ligne set t=se termine par cinq espaces et la ligne if "%i:e=%"=="%i%" set r=se termine par un espace. Prend une entrée insensible à la casse de STDIN. Edit: enregistré 7 octets en éliminant la dvariable. Enregistré 3 octets en utilisant une forboucle pour imprimer la section centrale. Si on me permet des paramètres de ligne de commande séparés à la place, alors pour 326 319 316 octets:

@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 octets

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 octets

{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

Essayez-le en ligne!

Pyth ( 385 380 373 353 octets)

Golfé:

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

Non golfé:

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 ""

Bien sûr, s'il y a des améliorations, veuillez me le dire.

5 octets enregistrés grâce à Maltysen

Vous pouvez l'essayer ici

Groovy (274 octets)

Non golfé

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}:[])
}

Golfé

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}:[])}

Essayez-le: https://groovyconsole.appspot.com/script/5082600544665600