Słowa -> Panoramę miasta

40

Wyzwanie

Twój program lub funkcja zaakceptuje pojedynczy ciąg wejściowy ze STDIN lub parametr funkcji. Możesz założyć, że dane wejściowe będą zawierać tylko znaki alfabetyczne (a-zA-Z), spacje i kropki. W danych wejściowych nie jest rozróżniana wielkość liter, więc powinieneś traktować „a” dokładnie tak samo, jak traktowałbyś „A”.

Dla każdego znaku w ciągu wyświetlisz reprezentację budynku zgodnie z następującą specyfikacją.

Każdy budynek musi mieć dach oznaczony znakiem podkreślenia w górnej linii, a następnie ukośnikiem, spacją i ukośnikiem w drugiej linii.

 _
/ \

Będziesz wtedy miał kilka pięter, pasujących do litery (a = 1, b = 2, c = 3 itd.), Które są reprezentowane przez ścianę (|) po każdej stronie i spację w środku. Dolna podłoga (i tylko dolna podłoga) powinna mieć fundament, który jest podkreśleniem między ścianami. Lubię to...

|_|

Na przykład „b” wyglądałoby tak

 _
/ \
| |
|_|

Teraz wiemy, że bardzo wysokie, wąskie budynki nie mogą stać i muszą się poszerzyć u podstawy, więc żaden budynek nie może stanąć wyżej niż trzy piętra bez dodatkowego wsparcia. Więc co trzy poziomy (nie mniej) powinieneś dodać „warstwę rozszerzającą”. Warstwa poszerzająca składa się z ukośnika i odwrotnego ukośnika bezpośrednio nad ścianami sekcji poniżej, a sekcja poniżej powinna być o dwie przestrzenie szersza niż sekcja powyżej. Dodatkowa warstwa nie wlicza się do wysokości budynku.

Budynki nie powinny się pokrywać, ale nie powinny mieć między nimi niepotrzebnych przestrzeni, a ziemia jest zawsze płaska, więc wszystkie budynki powinny mieć bazę na tym samym poziomie.

Na przykład „abcdefga” będzie wyglądać tak.

                           _
                          / \
                     _    | |
                _   / \   | |
           _   / \  | |   | |
          / \  | |  | |  /   \
       _  | |  | |  | |  |   |
    _ / \ | |  | | /   \ |   |
 _ / \| | | | /   \|   | |   |  _
/ \| || |/   \|   ||   |/     \/ \
|_||_||_||___||___||___||_____||_|

Spacje na wejściu łańcucha powinny być reprezentowane przez podwójną spację.

Kropki na wejściu łańcucha powinny być reprezentowane przez taki gruz.

/\/\

Dalsze przykłady

Dane wejściowe = Hello world.

Wyjście =

                                                   _                                                  
                                                  / \                                                 
                                                  | |                                                 
                                                  | |                                                 
                                                  | |                                                 
                                                 /   \                                                
                                                 |   |                                                
                                                 |   |                       _                        
                                                 |   |                      / \                       
                                                /     \                     | |                       
                                                |     |                     | |                       
                                   _            |     |          _          | |                       
                                  / \           |     |         / \        /   \                      
                                  | |          /       \        | |        |   |                      
                                  | |          |       |        | |        |   |                      
                _        _        | |          |       |        | |        |   |        _             
               / \      / \      /   \         |       |       /   \      /     \      / \            
               | |      | |      |   |        /         \      |   |      |     |      | |            
               | |      | |      |   |        |         |      |   |      |     |      | |            
               | |      | |      |   |        |         |      |   |      |     |      | |            
   _          /   \    /   \    /     \       |         |     /     \    /       \    /   \           
  / \         |   |    |   |    |     |      /           \    |     |    |       |    |   |           
  | |         |   |    |   |    |     |      |           |    |     |    |       |    |   |           
  | |         |   |    |   |    |     |      |           |    |     |    |       |    |   |           
  | |    _   /     \  /     \  /       \     |           |   /       \  /         \  /     \          
 /   \  / \  |     |  |     |  |       |    /             \  |       |  |         |  |     |   _      
 |   |  | |  |     |  |     |  |       |    |             |  |       |  |         |  |     |  / \     
 |   |  | |  |     |  |     |  |       |    |             |  |       |  |         |  |     |  | |     
 |   |  | | /       \/       \/         \   |             | /         \/           \/       \ | |     
/     \/   \|       ||       ||         |  /               \|         ||           ||       | | |     
|     ||   ||       ||       ||         |  |               ||         ||           ||       |/   \    
|_____||___||_______||_______||_________|  |_______________||_________||___________||_______||___|/\/\

Dane wejściowe = lorem ipsum

                                                                                             _                  
                                                                                            / \                 
                                                                              _             | |                 
                                                                             / \            | |                 
                          _                                                  | |            | |                 
                         / \                                                 | |           /   \                
                         | |                                    _            | |           |   |                
                         | |                                   / \          /   \          |   |                
              _          | |                                   | |          |   |          |   |                
             / \        /   \                                  | |          |   |         /     \               
             | |        |   |              _                   | |          |   |         |     |         _     
             | |        |   |             / \                 /   \        /     \        |     |        / \    
    _        | |        |   |             | |                 |   |        |     |        |     |        | |    
   / \      /   \      /     \            | |                 |   |        |     |       /       \       | |    
   | |      |   |      |     |            | |                 |   |        |     |       |       |       | |    
   | |      |   |      |     |           /   \               /     \      /       \      |       |      /   \   
   | |      |   |      |     |           |   |        _      |     |      |       |      |       |      |   |   
  /   \    /     \    /       \          |   |       / \     |     |      |       |     /         \     |   |   
  |   |    |     |    |       |          |   |       | |     |     |      |       |     |         |     |   |   
  |   |    |     |    |       |         /     \      | |    /       \    /         \    |         |    /     \  
  |   |    |     |    |       |         |     |      | |    |       |    |         |    |         |    |     |  
 /     \  /       \  /         \   _    |     |     /   \   |       |    |         |   /           \   |     |  
 |     |  |       |  |         |  / \   |     |     |   |   |       |    |         |   |           |   |     |  
 |     |  |       |  |         |  | |  /       \    |   |  /         \  /           \  |           |  /       \ 
 |     |  |       |  |         |  | |  |       |    |   |  |         |  |           |  |           |  |       | 
/       \/         \/           \ | |  |       |   /     \ |         |  |           | /             \ |       | 
|       ||         ||           |/   \ |       |   |     | |         |  |           | |             | |       | 
|       ||         ||           ||   |/         \  |     |/           \/             \|             |/         \
|_______||_________||___________||___||_________|  |_____||___________||_____________||_____________||_________|

Dane wejściowe = a.a.a.x.x.x.a.a.a

                             _                    _                    _                             
                            / \                  / \                  / \                            
                            | |                  | |                  | |                            
                            | |                  | |                  | |                            
                            | |                  | |                  | |                            
                           /   \                /   \                /   \                           
                           |   |                |   |                |   |                           
                           |   |                |   |                |   |                           
                           |   |                |   |                |   |                           
                          /     \              /     \              /     \                          
                          |     |              |     |              |     |                          
                          |     |              |     |              |     |                          
                          |     |              |     |              |     |                          
                         /       \            /       \            /       \                         
                         |       |            |       |            |       |                         
                         |       |            |       |            |       |                         
                         |       |            |       |            |       |                         
                        /         \          /         \          /         \                        
                        |         |          |         |          |         |                        
                        |         |          |         |          |         |                        
                        |         |          |         |          |         |                        
                       /           \        /           \        /           \                       
                       |           |        |           |        |           |                       
                       |           |        |           |        |           |                       
                       |           |        |           |        |           |                       
                      /             \      /             \      /             \                      
                      |             |      |             |      |             |                      
                      |             |      |             |      |             |                      
                      |             |      |             |      |             |                      
                     /               \    /               \    /               \                     
 _      _      _     |               |    |               |    |               |     _      _      _ 
/ \    / \    / \    |               |    |               |    |               |    / \    / \    / \
|_|/\/\|_|/\/\|_|/\/\|_______________|/\/\|_______________|/\/\|_______________|/\/\|_|/\/\|_|/\/\|_|

Zasady

  • Oczywiście jest to kod golfowy, wygrywa najniższy wynik w bajtach
  • Obowiązują standardowe zasady dotyczące luk
  • Dozwolona jest dowolna liczba dodatkowych pustych wierszy przed wyjściem lub po nim
  • Możesz wybrać, aby wydrukować cały wynik w jednym ciągu lub zaoferować wynik jako tablicę, w której każdy element reprezentuje jeden wiersz wyniku, lub wysłać do STDOUT

Uwaga

To jest mój pierwszy post na PPCG, więc nie przejmuj się. To było przez piaskownicę. Wszelkie negatywne punkty lub możliwe ulepszenia prosimy pisać jako komentarz, a ja zrobię, co mogę

Darren H.
źródło
7
Konwersja [a,z]i [A,Z]do [1,26]wydaje się wymóg bezcelowe. O wiele lepiej byłoby po prostu użyć liczb całkowitych z listy jako danych wejściowych (jako danych 0wejściowych dla gruzu). Również publikowanie wyzwania po tym, jak zostało w piaskownicy tylko przez 21 godzin , bez oczekiwania na głosy lub opinie od więcej niż jednego użytkownika, nie jest liczone jako „przejście przez piaskownicę”. Zaleca się pozostawianie wyzwań w piaskownicy na co najmniej 48-72 godziny, aby dać ludziom dużo czasu na ich przejrzenie.
Mego
2
Przypomina mi o tym . Nicea pierwszym wyzwaniem, ale proponuję rozważyć zmianę [a,z], [1.26]Parts Mego wymienione. Opcjonalne jest często najlepsze (chyba że jest to kluczowa część wyzwania (nie ma go tutaj).
Stewie Griffin
2
Powiem, że to bardzo miłe pierwsze wyzwanie. Witamy na stronie!
DJMcMayhem
1
Rozumiem sens mapowania az do liczb całkowitych. To miało sens w pierwszej iteracji wyzwania, ale ponieważ edytowanie dla jasności i zwięzłości (istniała historia, którą usunąłem), litery nie są już istotne. Będę odpowiednio edytować jak najszybciej
Darren H
1
Wolę az, spację, kropkę, osobiście.
isaacg,

Odpowiedzi:

10

JavaScript (ES6), 330 326 ... 315 309 bajtów

Tworzy rekurencyjnie grafikę ASCII, zaczynając od najniższego piętra i stosując kilka wyrażeń regularnych między każdym etapem:

(a,l,R=(E,b)=>E.split`:`.map((e,i)=>l=(l||a).replace(RegExp(e,'g'),b?b.split`:`[i]:n=>(x=(n.charCodeAt()-65)%32)<0?x+1?'/y/y':n+n:x%3+'_'.repeat((x/3<<1)+1)+0)))=>(L=l)?(R('/y:_:/xy:1:2:/xx(x+)y:0(x+)0:3','  :x: _ :3:1: 2$10 :/$1y:0'),L==l?(l=a.join`
`,R('\\d:x:y','|: :\\'),l):f([l].concat(a),l)):f(R('.'),l)

Jak to działa

1) Dolna podłoga

Zaczynamy od przetłumaczenia ciągu wejściowego na dolne piętro, takiego jak:

"ab cd.df.hcab"  -->  "0_01_0  2_00___0/y/y0___02___0/y/y1_____02_00_01_0"

gdzie:

  • y jest krótszym aliasem odwrotnego ukośnika (który wymaga zmiany znaczenia)
  • Cyfra ( 0, 1lub 2) tuż przed sekwencją _jest lewa ściana budynku. Reprezentuje liczbę ścian, które należy umieścić nad nim przed następną „warstwą rozszerzającą”.
  • Cyfra po sekwencji _oznacza prawą ścianę budynku i jest zawsze ustawiona na 0.

2) Wyrażenia regularne stosowane między każdym etapem

Proces rekurencyjny polega na zastosowaniu 9 zamienników na poprzedniej podłodze przy użyciu następujących wyrażeń regularnych:

  1. /\/y/g=> " "(usuń gruz)
  2. /_/g=> "x"(zastąp fundament lub górę budynku solidnym blokiem)
  3. /\/xy/g=> " _ "(zamień ostatnią rozszerzającą się warstwę na górę budynku)
  4. /1/g=> "3"(Tymczasowo zastąpić 1z 3- patrz ostatni etap)
  5. /2/g=> "1"(Zamiast 2z 1)
  6. /\/xx(x+)y/g=> " 2$10 "(zastąp warstwę rozszerzającą nową, węższą ścianą)
  7. /0(x+)0/g=> "/$1y"(zastąp wierzch ściany rozszerzającą się warstwą)
  8. /3/g=> "0"(Zamiast 3z 0)

Na przykład, oto kolejne przekształcenia 2___0(dolne piętro generowane przez a 'f'):

"2___0" > "1xxx0" > "0xxx0" > "/xxxy" > " 2x0 " > " 1x0 " > " 0x0 " > " /xy " > "  _  "

                                                                                   _   
                                                                        /xy       /xy  
                                                              0x0       0x0       0x0  
                                                    1x0       1x0       1x0       1x0  
                                          2x0       2x0       2x0       2x0       2x0  
                               /xxxy     /xxxy     /xxxy     /xxxy     /xxxy     /xxxy 
                     0xxx0     0xxx0     0xxx0     0xxx0     0xxx0     0xxx0     0xxx0 
           1xxx0     1xxx0     1xxx0     1xxx0     1xxx0     1xxx0     1xxx0     1xxx0 
 2___0     2___0     2___0     2___0     2___0     2___0     2___0     2___0     2___0 

Uwaga : Wierzchołek budynku jest następnie zastępowany przez x. Nie pokazano tego na powyższym schemacie.

3) Wyrażenia regularne zastosowane do wyniku końcowego

Rekursja kończy się, gdy nie ma już nic do zastąpienia, co oznacza, że ​​jesteśmy poza szczytem najwyższego budynku.

Teraz musimy wszystko wyczyścić za pomocą jeszcze kilku wyrażeń regularnych:

  1. /\d/g=> "|"(zamień cyfry na rury)
  2. /x/g=> " "(zamień bryły na spacje)
  3. /y/g=> "\"(zamień na yukośniki odwrotne)

Na przykład:

  _            _  
 /xy          / \ 
 0x0          | | 
 1x0          | | 
 2x0   -->    | | 
/xxxy        /   \
0xxx0        |   |
1xxx0        |   |
2___0        |___|

Próbny

let f =

(a,l,R=(E,b)=>E.split`:`.map((e,i)=>l=(l||a).replace(RegExp(e,'g'),b?b.split`:`[i]:n=>(x=(n.charCodeAt()-65)%32)<0?x+1?'/y/y':n+n:x%3+'_'.repeat((x/3<<1)+1)+0)))=>(L=l)?(R('/y:_:/xy:1:2:/xx(x+)y:0(x+)0:3','  :x: _ :3:1: 2$10 :/$1y:0'),L==l?(l=a.join`
`,R('\\d:x:y','|: :\\'),l):f([l].concat(a),l)):f(R('.'),l)

console.log(f('ab cd.df.hcab'));

Współtwórcy:
4 bajty zapisane dzięki Hedi
8 bajtów zaoszczędzonych dzięki Not that Charles

Arnauld
źródło
Każdy, kto chce wprowadzić liczbę całkowitą, jest mile widziany, ale sugeruję, aby taki wpis nie był konkurencyjny
mbomb007,
@ mbomb007 - Zostało to naprawione. Moje obecne optymalizacje nie rekompensują kosztu niesławnego .charCodeAt().
Arnauld,
Nie trzeba new wnew RegExp(e,'g')
Hedi
Bardzo podoba mi się to podejście. Kilka pomysłów, które mogą pomóc: 1. użyj znaku, yktóry nie wymaga ucieczki przed ukośnikiem. 2. Jeśli używasz _na parterze, można jeszcze odróżnić szczycie z regex: /_ /.
Nie to, że Charles
1
@NotthatCharles - Właściwie nigdy nie zauważyłem zasady „podwójnej spacji”. ;) Zostało to naprawione.
Arnauld,
7

PHP, 386 376 367 364 362 358 356 bajtów

pierwsze podejście; może nadal być golfa.

foreach(str_split($argv[1])as$c)for($n=28,$w='.'!=$c?1+2*ceil(1/3*$n=31&ord($c)):4,$p=$y=0;$y<36;){$s=str_pad("",$w,$y||!$n?" ":_);if($n>26&&!$y){$s="/\\/\\";$n=-1;}elseif($n-->0){$s[$p]=$s[$w-$p-1]="|";if($n%3<1){$o[$y++].=$s;$s=str_pad("",$w);$s[$p]="/";$s[$w-++$p]="\\";}}$o[$y++].=$s;if(!$n)$o[$y++].=str_pad(_,$w," ",2);}for($y=36;$y--;)echo"$o[$y]
";

PHP, 366 362 361 360 357 bajtów

podobne podejście z podfunkcją:

function a($p,$r){global$o,$w,$y;$o[$y++].=str_pad(str_pad($r[0],2*$p,$r[1]).$r[2],$w," ",2);}foreach(str_split($argv[1])as$i=>$c)for($n=28,$w='.'!=$c?1+2*$p=ceil(1/3*$n=31&ord($c)):$p=4,$y=0;$y<36;)if($n>26&&!$y)$o[$n=$y++].="/\\/\\";elseif($n-->0){a($p,$y?"| |":"|_|");if($n%3<1)a($p--,"/ \\");if(!$n)a(1," _");}else a(0,"");for($y=36;$y--;)echo"$o[$y]
";

podział na drugie podejście

function a($p,$r)
{
    global$o,$w,$y;
    $o[$y++].=                  // 3. add result to current line, increase line counter
        str_pad(                // 2. pad ...
        str_pad($r[0],2*$p,$r[1]).$r[2]     // 1. A + inner width(=2*$p-1) times B + C
        ,$w," ",2);             // ... to $w with blanks on both sides # 2==STR_PAD_BOTH
}

foreach(str_split($argv[1])as$i=>$c)
    for(
    $n=28,
    $w='.'!=$c                          // $w=total width
        ?1+2*$p=ceil(1/3*$n=31&ord($c)) // $n=storey count, $p=(inner width+1)/2
        :$p=4                           // $n=28, $p <= $w=4 for rubble
    ,
    $y=0;$y<36;)                        // $y=line counter
        if($n>26&&!$y)
            $o[$n=$y++].="/\\/\\";      // bottom line=rubble, $n=0
        elseif($n-->0)
        {
            a($p,$y?"| |":"|_|");       // add storey
            if($n%3<1)a($p--,"/ \\");   // add widening layer/roof
            if(!$n)a(1," _");           // add roof top
        }
        else
            a(0,"");                    // idk why str_pad doesn´t yield a warning here

for($y=36;$y--;)if($s=rtrim($o[$y]))echo"$s\n"; // output

+16 bajtów jeśli wiodące znaki nowej linii nie są dozwolone:
Wymień echo"$o[$y]\n;się if($s=rtrim($o[$y]))echo"$s\n";.

-3 bajty dowolnej z ;<=>?[\]^_{|}~a gruzu Wymienić 1) ($n=31&ord($c))o $n, 2) $n=28,$w='.'!=$cw ($n=31&ord($c))<273) 4z ($n=28)/7.

Innym -8 do >, ^albo ~jako tłuczeń: Cofanie 3)

Tytus
źródło
1
if(!$n){$o[$y++].=str_pad(_,$w," ",2);}-2 bajty dla nawiasów
Jörg Hülsermann
i wyjście można zrobić 3 bajty krócej: for($y=36;$y--;)echo"$o[$y]\n";; ale mam nowe podejście, które oszczędza kolejne 2 bajty.
Tytus
1
php.net/manual/en/functions.anonymous.php dla drugiego podejścia `funkcja a ($ p, $ r) użycie ($ o, $ w, $ y) 'zamiast globalnego
Jörg Hülsermann
@ JörgHülsermann: usedziała tylko w przypadku funkcji anonimowych. zaoszczędziłoby 2 bajty; ale musiałbym zapisać tę funkcję w zmiennej $a=zamiast nadać jej nazwę (+3 bajty) i dodać a $do każdego z czterech wywołań.
Tytus
4

Pyth, 93 79 bajtów

K"/\\"j_.tsm?hJxGdC_m.[hyNk\ +\_mj*hy/k4?nkJ\ \_?%k4"||"Kh=+J=Nh/J3[F*2|@d;Krz0

Wypróbuj online. Zestaw testowy.

Wyjaśnienie

Domyślnie to ukryłem, ponieważ jest o wiele za długi.

PurkkaKoodari
źródło
4

Perl, 147 146 bajtów

Obejmuje +1 dla -p

Uruchom z wejściem na STDIN, np

citysky.pl <<< " abcdefgxyz."

citysky.pl:

#!/usr/bin/perl -p
s%.%@{[map chr~-ord(lc$&)*4/3-4*(abs||-9),-9..9]}%g;y/M\xa248
A|-\xc6\0-\xff/MA||
A}-\xc6A/d,$a=(lc$a).$_ for($_)x36;*_=a;s/\x9f.*?\K\x9f/\xa3/g;y%A\xc6\x9f-\xa3\x0b-\xff%__/|||\\ %

Działa tak, jak pokazano, ale należy zastąpić \xhhznaki ucieczki ich dosłowną wartością, aby uzyskać deklarowany wynik. Możesz to zrobić za pomocą tego wiersza poleceń:

perl -0pi -e 's/\\x(..)/chr hex $1/eg;s/\n$//' citysky.pl

Tak naprawdę nie badałem żadnych innych podejść, więc może to być bardzo do pokonania ...

Ton Hospel
źródło
2

Haskell, 289 bajtów

c?l=c++l++c
c%s=("|"?(drop 2(r s)>>c)):s
g 46=["/\\"?""]
g 32=["  "]
g x="_"%h(mod x 32)
h 1=["/ \\"," _ "]
h x=(" "%h(x-1))!x
v!x|mod x 3/=1=v|z<-'/':r v++"\\"=z:map(" "?)v
r v=v!!0>>" "
f t|l<-map(g.fromEnum)t,m<-maximum(map length l)-1=unlines[l>>= \x->(x++cycle[r x])!!i|i<-[m,m-1..0]]
Damien
źródło
2

Ruby, 245

->s{a=['']*36
w=' '
s.chars{|c|a[u=0]+=c<?!?w*2:c<?/?"/\\"*2:(h=c.upcase.ord-64
1.upto(1+h+=(h-1)/3){|t|u=[u,l=1+2*((f=h-t)/4)].max
a[t]+=w*(a[0].size-a[t].size)+(f<-1?w:f<0??_:(f%4<1?[?/,?\\]:[?|]*2)*(w*l)).center(u+2)}
"|#{?_*u}|")}
a.reverse}

Zezwalasz na tyle dodatkowych linii, ile chcesz, więc biorę z tym wolność. Poza tym proces wygląda następująco:

  1. Zainicjuj tablicę wyjściową a.
  2. Dla każdego znaku:
    1. jeśli to '', dodaj  doa[0]
    2. jeśli to „.”, dodaj /\/\doa[0]
    3. Inaczej:
      1. obliczyć wysokość ( c.upcase.ord + (c.upcase.ord-1)/3)
      2. dla każdego wiersza w a:
        1. wypełnij wiersz białymi znakami. a[t]+=w*(a[0].size-a[t].size)
        2. jeśli jesteśmy jednym powyżej h , wyśrodkuj a_
        3. w przeciwnym razie, jeśli jesteśmy powyżej wysokości, wyśrodkuj a 
        4. w przeciwnym razie, jeśli jesteśmy poniżej wysokości, środka | |lub / \odpowiedniej szerokości (1+2*((h-t)/4 ), w zależności od tego, czyh-t%4==0
        5. dodaj "|___|"odpowiednią szerokość doa[0]
  3. powrót a.reverse

Założę się, że mogę zmniejszyć to, jeśli opracuję matematykę, której należy unikać reverse

Nie ten Charles
źródło
2

PHP, 297 bajtów

foreach(str_split($argv[1])as$c)for($j=0,$h=ord($c)-64,$g=$h+$f=ceil($h/3),$w=$v=$h<0?$h<-18?2:4:2*$f+1;$j<36;$j++,$g--,$v-=$h>0&&$v>1?($g%4||!$j)?0*$n="|$s|":2+0*$n="/$s\\":$v+0*$n=['','_','',0,'/\/\\'][$v],$o[$j].=str_pad($n,$w,' ',2))$s=str_repeat($j?' ':'_',$v-2);krsort($o);echo join($o,'
');

Bardziej czytelna wersja:

foreach (str_split($argv[1]) as $character) {
    for (
        $line = 0,
        $buildingHeight = ord($character) - 64,
        $floorsLeft = $buildingHeight + $supportFloors = ceil($buildingHeight / 3),
        $buildingWidth = $widthOnThisFloor = $buildingHeight < 0
            ? $buildingHeight < -18
                ? 2
                : 4
            : 2 * $supportFloors + 1;

        $line < 36;

        // The body of the for-loop is executed between these statements

        $line++,
        $floorsLeft--,
        $widthOnThisFloor -= $buildingHeight > 0 && $widthOnThisFloor > 1
            ? ($floorsLeft % 4 || !$line)
                ? 0 * $floorString = "|$middleSpacing|"
                : 2 + 0 * $floorString = "/$middleSpacing\\"
            : $widthOnThisFloor + 0 * $floorString = ['', '_', '', 0, '/\/\\'][$widthOnThisFloor],
        $outputArray[$line] .= str_pad($floorString, $buildingWidth, ' ', 2)
    ) {
        $middleSpacing = str_repeat($line ? ' ' : '_', $widthOnThisFloor - 2);
    }
}
krsort($outputArray);
echo join($outputArray, '
');
chocochaos
źródło