도전

프로그램 또는 함수는 STDIN 또는 함수 매개 변수에서 단일 문자열 입력을 허용합니다. 입력에 영문자 (a-zA-Z), 공백 및 전체 정지 만 포함한다고 가정 할 수 있습니다. 입력은 대소 문자를 구분하지 않으므로 'A'를 처리 할 때와 동일하게 'a'를 처리해야합니다.

문자열의 각 문자에 대해 다음 사양에 따라 건물의 표현을 출력합니다.

각 건물에는 맨 위 줄에 밑줄로 지정된 지붕이 있어야하고 두 번째 줄에는 슬래시, 공간, 백 슬래시가 있어야합니다.

 _
/ \

그런 다음 문자 수 (a = 1, b = 2, c = 3 등)와 일치하는 여러 층을 가지게되는데, 각면에는 벽 (|)과 중간에는 공백이 표시됩니다. 맨 아래 층 (및 맨 아래 층만)에는 벽 사이의 밑줄 인 기초가 있어야합니다. 이렇게 ...

|_|

예를 들어 'b'는 다음과 같습니다.

 _
/ \
| |
|_|

이제 우리는 매우 키가 크고 좁은 건물은 기슭에 서있을 수없고 더 넓어야합니다. 따라서 어떤 추가 지원 없이도 3 층 이상의 높이에서는 건물이 없습니다. 따라서 세 가지 수준 (또는 그 이하)마다 '확장 레이어'를 추가해야합니다. 확장 레이어는 그 아래 섹션의 벽 바로 위의 슬래시와 백 슬래시로 구성되며 아래 섹션은 위 섹션보다 두 칸 넓어야합니다. 추가 층은 건물 높이에 포함되지 않습니다.

건물은 겹치지 않아야하고 건물 사이에 불필요한 공간이 없어야하며 바닥은 항상 평평하므로 모든 건물의 바닥은 같은 수준이어야합니다.

예를 들어, 'abcdefga'는 다음과 같습니다.

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

문자열 입력의 공백은 이중 공백으로 표시되어야합니다.

문자열 입력의 전체 정지는 다음과 같이 잔해로 표시되어야합니다.

/\/\

추가 예

입력 = Hello world.

출력 =

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

입력 = lorem ipsum

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

입력 = a.a.a.x.x.x.a.a.a

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

규칙

• 물론 이것은 코드 골프이며 바이트 단위로 가장 낮은 점수를 얻습니다.
• 표준 허점 규칙이 적용됩니다
• 출력 전후에 추가 빈 줄 수
• 전체 결과를 하나의 문자열로 출력하거나 각 요소가 한 줄의 출력을 나타내는 배열로 출력을 제공하거나 STDOUT에 보낼 수 있습니다.

노트

이것은 PPCG에 대한 첫 번째 게시물이므로 제발 쉽게 가십시오. 샌드 박스를 통과했습니다. 부정적인 점이나 가능한 개선 사항은 의견으로 게시하고 내가 할 수있는 일을 할 것입니다

자바 스크립트 (ES6), 330 326 ... 315 309 바이트

바닥부터 시작하여 각 단계 사이에 여러 정규 표현식을 적용하여 ASCII 아트를 재귀 적으로 만듭니다.

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

작동 원리

1) 바닥

입력 문자열을 다음과 같이 1 층으로 변환합니다.

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

어디:

• y 백 슬래시의 짧은 별명입니다 (이스케이프해야 함).
• 시퀀스 바로 앞 의 숫자 ( 0, 1또는 2) _는 건물의 왼쪽 벽입니다. 다음 '확장 레이어'전에 그 위에 배치되어야하는 벽의 수를 나타냅니다.
• 시퀀스 뒤의 숫자 _는 건물의 오른쪽 벽이며 항상로 설정됩니다 0.

2) 각 단계 사이에 적용되는 정규식

재귀 프로세스는 다음 정규식을 사용하여 이전 층에 9 개의 교체를 적용하는 것으로 구성됩니다.

1. /\/y/g=> " "(잔해 제거)
2. /_/g=> "x"(건물 기초 또는 건물의 상단을 단단한 블록으로 교체)
3. /\/xy/g=> " _ "(마지막 확장 레이어를 건물 상단으로 교체)
4. /1/g=> "3"(일시적 대체 1와 함께 3- 마지막 단계 참조)
5. /2/g=> "1"(대체 2하여 1)
6. /\/xx(x+)y/g=> " 2$10 "(확장 층을 새롭고 좁은 벽으로 교체)
7. /0(x+)0/g=> "/$1y"(벽의 상단을 확장 레이어로 교체)
8. /3/g=> "0"(대체 3하여0)

예를 들어, 2___0(으로 생성 된 바닥) 의 연속 변환은 '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 

_{주의 : 건물의 상단은로 대체됩니다 x. 위의 다이어그램에는 표시되지 않았습니다.}

3) 최종 결과에 적용되는 정규식

더 이상 교체 할 것이 없으면 재귀가 중지됩니다. 즉, 우리는 가장 높은 건물의 꼭대기를 넘어 섭니다.

이제 몇 가지 정규 표현식으로 모든 것을 정리해야합니다.

1. /\d/g=> "|"(숫자로 파이프 교체)
2. /x/g=> " "(공백으로 공백 블록 교체)
3. /y/g=> "\"( y백 슬래시로 교체 )

예를 들어 :

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

데모

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

기고자 : Charles가 아니라
Hedi 덕분에 4 바이트가 절약되었습니다.

PHP, 386 376 367 364 362 358 356 바이트

첫 번째 접근법; 여전히 골프를 칠 수 있습니다.

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 바이트

하위 기능을 사용한 비슷한 접근 방식 :

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

두 번째 접근 방식에 대한 분석

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 바이트 :
바꾸기 echo"$o[$y]\n;로if($s=rtrim($o[$y]))echo"$s\n"; .

-3의 모든 바이트 ;<=>?[\]^_{|}~)에는 1 : 파편 등 ($n=31&ord($c))으로 $n) 2 $n=28,$w='.'!=$c로 ($n=31&ord($c))<27) 3 4와($n=28)/7 .

또 다른위한 -8 >, ^또는 ~같은 잔해 : 취소 3)

Pyth, 93 79 바이트

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

온라인으로 사용해보십시오. 테스트 스위트.

설명

너무 길어서 기본적으로 숨겼습니다.

<ul type="disc"><li>Initialize <code>K</code> to <code>"/\"</code>.</li><li>Lowercase (<code>r</code>&hellip;<code>0</code>) the input (<code>z</code>).</li><li>For each (<code>m</code>) character <code>d</code> in the lowercase input:</li><ul type="disc"><li>Find the index (<code>x</code>) of the character (<code>d</code>) in the alphabet (<code>G</code>). This results in a number 0-25 for the letters and -1 for anything else. Save the index to <code>J</code>.</li><li>Add one (<code>h</code>). This results in a positive number for the letters and 0 for anything else.</li><li>If the result was nonzero (<code>?</code>):</li><ul type="disc"><li>Int-divide (<code>/</code>) <code>J</code> by <code>3</code> and increment (<code>h</code>) and save (<code>=</code>) the result to <code>N</code>.</li><li>Increment (<code>=+</code>) <code>J</code> by that amount.</li><li>Add one (<code>h</code>). This yields the height of the house excluding the roof.</li><li>For each (<code>m</code>) number <code>k</code> from 0 to result-1:</li><ul type="disc"><li>Take <code>" "</code> (<code>\ </code>) if (<code>?</code>) the number (<code>k</code>) is not equal to (<code>n</code>) <code>J</code>, otherwise take <code>"_"</code> (<code>\_</code>).</li><li>Int-divide (<code>/</code>) the number (<code>k</code>) by <code>4</code>, double (<code>y</code>) and add one (<code>h</code>).</li><li>Multiply the string by the number (<code>*</code>).</li><li>Take <code>"||"</code> if (<code>?</code>) the number (<code>k</code>) is not divisible by 4 (<code>%</code>&hellip;<code>4</code>), otherwise take the string in <code>K</code>.</li><li>Join (<code>j</code>) that string by the previous one. This puts the previous string in the middle.</li></ul><li>Prepend (<code>+</code>) a <code>"_"</code> (<code>\_</code>) to the resulting list to add the roof.</li><li>For each line <code>k</code> in the list:</li><ul type="disc"><li>Take <code>N</code>, double (<code>y</code>) and add one (<code>h</code>).</li><li>Pad (<code>.[</code>) the line (<code>k</code>) to that length with spaces (<code>\ </code>).</li></ul><li>We now have the rows for this one house. Reverse (<code>_</code>) and transpose (<code>C</code>) the result to get the reversed columns.</li></ul><li>If the result was zero (all the way up there):</li><ul type="disc"><li>Take the intersection (<code>@</code>) of the character (<code>d</code>) and <code>" "</code> (<code>;</code>). This yields an empty string for periods and a space for itself.</li><li>Logical OR (<code>|</code>) that with the string in <code>K</code>. This yields that string for periods and a space for itself.</li><li>Repeat that string (<code>*</code>) <code>2</code> times and cast to array (<code>[F</code>). This yields the (reversed) columns for spaces and periods.</li></ul></ul><li>Concatenate (<code>s</code>) the resulting lists. This yields the total reversed columns for the output.</li><li>Transpose, padding with spaces (<code>.t</code>), reverse (<code>_</code>) and join by newline (<code>j</code>). Implicitly print the output.</li></ul>

펄, 147 바이트

에 +1 포함 -p

STDIN에서 입력으로 실행

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%__/|||\\ %

표시된대로 작동하지만 \xhh이스케이프를 리터럴 값으로 대체 하여 청구 된 점수를 얻습니다. 이 명령 줄을 사용하여이를 수행 할 수 있습니다.

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

나는 다른 접근법을 실제로 탐구하지 않았으므로 이것은 매우 이길 수 있습니다 ...

하스켈, 289 바이트

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

루비, 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}

당신은 당신이 원하는만큼 많은 새로운 줄 바꿈을 허용하므로, 나는 그것에 자유를 얻고 있습니다. 그 외에도 프로세스는 다음과 같습니다.

1. 출력 배열을 초기화합니다 a.
2. 각 문자마다 :
   1. 그것은 ''의 경우, 추가  로a[0]
   2. 그것의 경우 '.', 추가 /\/\로a[0]
   3. 그렇지 않으면:
      1. 높이 계산 ( c.upcase.ord + (c.upcase.ord-1)/3)
      2. 의 각 행에 대해 a:
         1. 공백으로 행을 채 웁니다. a[t]+=w*(a[0].size-a[t].size)
         2. 위에서 우리가 경우에있는 거 하나 h, 센터_
         3. 그렇지 않으면 우리가 높이보다 높으면 중앙 a 
         4. 그렇지 않은 경우 에 따라 높이, 중앙 | |또는 / \적절한 너비 ( 1+2*((h-t)/4) 미만인 경우h-t%4==0
         5. "|___|"올바른 너비를 추가a[0]
3. 반환 a.reverse

피하기 위해 수학을 연습하면 더 작아 질 수 있습니다. reverse

PHP, 297 바이트

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

더 읽기 쉬운 버전 :

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