Các thách thức

Chương trình hoặc chức năng của bạn sẽ chấp nhận đầu vào chuỗi đơn từ STDIN hoặc tham số chức năng. Bạn có thể giả sử đầu vào sẽ chỉ chứa các ký tự chữ cái (a-zA-Z), dấu cách và dấu dừng đầy đủ. Đầu vào không phân biệt chữ hoa chữ thường, vì vậy bạn nên đối xử với 'a' chính xác giống như bạn sẽ đối xử với 'A'.

Đối với mỗi ký tự trong chuỗi, bạn sẽ xuất đại diện cho một tòa nhà theo thông số kỹ thuật sau.

Mỗi tòa nhà phải có một mái nhà, được chỉ định bởi một dấu gạch dưới ở dòng trên cùng sau đó là dấu gạch chéo, dấu cách, dấu gạch chéo ngược trên dòng thứ hai.

 _
/ \

Sau đó, bạn sẽ có một số tầng, khớp với số chữ cái (a = 1, b = 2, c = 3, v.v.) được thể hiện bằng một bức tường (|) ở mỗi bên và một khoảng trống ở giữa. Tầng dưới cùng (và chỉ tầng dưới cùng) nên có một nền tảng, đó là một gạch dưới giữa các bức tường. Như thế này...

|_|

Vì vậy, ví dụ, 'b' sẽ trông như thế này

 _
/ \
| |
|_|

Bây giờ, chúng ta biết rằng các tòa nhà rất cao, hẹp không thể đứng và phải rộng hơn ở chân đế, vì vậy không có tòa nhà nào có thể cao hơn ba tầng mà không có một số hỗ trợ bổ sung. Vì vậy, cứ ba cấp độ (không ít hơn), bạn nên thêm một 'lớp mở rộng'. Lớp mở rộng bao gồm một dấu gạch chéo và dấu gạch chéo ngược ngay phía trên các bức tường của phần bên dưới nó, và phần bên dưới nên rộng hơn hai khoảng trống so với phần bên trên. Lớp bổ sung không được tính vào chiều cao của tòa nhà.

Các tòa nhà không nên chồng chéo nhưng không nên có bất kỳ khoảng trống không cần thiết nào giữa chúng và mặt đất luôn bằng phẳng để tất cả các tòa nhà nên có căn cứ của chúng ở cùng một cấp độ.

Ví dụ: 'abcdefga' sẽ trông như thế này.

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

Các không gian trong đầu vào chuỗi phải được biểu thị bằng một khoảng trắng kép.

Dừng hoàn toàn trong đầu vào chuỗi nên được thể hiện bằng đống đổ nát như thế này.

/\/\

Ví dụ khác

Đầu vào = Hello world.

Đầu ra =

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

Đầu vào = lorem ipsum

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

Đầu vào = a.a.a.x.x.x.a.a.a

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

Quy tắc

• Tất nhiên đây là mã golf, điểm thấp nhất tính bằng byte thắng
• Quy tắc kẽ hở tiêu chuẩn áp dụng
• Bất kỳ số lượng dòng trống bổ sung trước hoặc sau khi đầu ra được cho phép
• Bạn có thể chọn xuất toàn bộ kết quả trong một chuỗi hoặc cung cấp đầu ra dưới dạng một mảng trong đó mỗi phần tử đại diện cho một dòng đầu ra hoặc gửi đến STDOUT

chú thích

Đây là bài viết đầu tiên của tôi đến PPCG, vì vậy hãy đi dễ dàng với tôi. Nó đã đi qua hộp cát. Bất kỳ điểm tiêu cực hoặc cải thiện có thể xin vui lòng gửi như một nhận xét và tôi sẽ làm những gì tôi có thể

JavaScript (ES6), 330 326 ... 315 309 byte

Xây dựng nghệ thuật ASCII theo cách đệ quy, bắt đầu từ tầng dưới cùng và áp dụng một số biểu thức chính quy giữa mỗi giai đoạn:

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

Làm thế nào nó hoạt động

1) Tầng dưới cùng

Chúng tôi bắt đầu bằng cách dịch chuỗi đầu vào thành tầng dưới cùng, chẳng hạn như:

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

Ở đâu:

• y là một bí danh ngắn hơn cho dấu gạch chéo ngược (yêu cầu thoát)
• Chữ số ( 0, 1hoặc 2) ngay trước một dãy _là bức tường bên trái của tòa nhà. Nó đại diện cho số lượng các bức tường phải được đặt phía trên nó trước khi 'lớp mở rộng' tiếp theo.
• Chữ số sau một chuỗi _là bức tường bên phải của tòa nhà và luôn được đặt thành 0.

2) Biểu thức chính quy được áp dụng giữa mỗi giai đoạn

Quá trình đệ quy bao gồm áp dụng 9 thay thế ở tầng trước, sử dụng các biểu thức chính quy sau:

1. /\/y/g=> " "(loại bỏ đống đổ nát)
2. /_/g=> "x"(thay thế nền móng hoặc đỉnh của tòa nhà bằng một khối vững chắc)
3. /\/xy/g=> " _ "(thay thế lớp mở rộng cuối cùng bằng đỉnh tòa nhà)
4. /1/g=> "3"(tạm thời thay thế 1bằng 3- xem bước cuối cùng)
5. /2/g=> "1"(Thay thế 2bằng 1)
6. /\/xx(x+)y/g=> " 2$10 "(thay thế một lớp mở rộng bằng một bức tường mới hẹp hơn)
7. /0(x+)0/g=> "/$1y"(thay thế đỉnh tường bằng một lớp mở rộng)
8. /3/g=> "0"(Thay thế 3bằng 0)

Chẳng hạn, đây là các phép biến đổi liên tiếp của 2___0(tầng dưới cùng được tạo bởi 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 

_{NB : Đỉnh của tòa nhà sau đó được thay thế bằng a x. Điều này không được hiển thị trong sơ đồ trên.}

3) Biểu thức chính quy được áp dụng cho kết quả cuối cùng

Việc đệ quy dừng lại khi không còn gì để thay thế, điều đó có nghĩa là chúng tôi nằm ngoài đỉnh của tòa nhà cao nhất.

Bây giờ chúng ta cần dọn dẹp mọi thứ với một vài biểu thức thông thường khác:

1. /\d/g=> "|"(thay thế chữ số bằng đường ống)
2. /x/g=> " "(thay thế khối đặc bằng dấu cách)
3. /y/g=> "\"(thay thế ybằng dấu gạch chéo ngược)

Ví dụ:

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

Bản giới thiệu

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

Người đóng góp:
4 byte được lưu nhờ Hedi
8 byte được lưu nhờ Không phải Charles

PHP, 386 376 367 364 362 358 356 byte

cách tiếp cận đầu tiên; vẫn có thể chơi được

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 byte

cách tiếp cận tương tự với một chức năng con:

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

sự cố cho cách tiếp cận thứ hai

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 byte nếu dòng mới hàng đầu không được phép:
Thay thế echo"$o[$y]\n;bằng if($s=rtrim($o[$y]))echo"$s\n";.

-3 byte cho bất kỳ ;<=>?[\]^_{|}~như là đống đổ nát: Thay thế 1) ($n=31&ord($c))bằng $n, 2) $n=28,$w='.'!=$cbằng ($n=31&ord($c))<27và 3) 4bằng ($n=28)/7.

Một -8 khác >, ^hoặc ~như đống đổ nát: Hoàn tác 3)

Pyth, 93 79 byte

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

Hãy thử trực tuyến. Bộ thử nghiệm.

Giải trình

Tôi đã giấu điều này theo mặc định vì nó quá dài.

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

Perl, 147 146 byte

Bao gồm +1 cho -p

Chạy với đầu vào trên STDIN, ví dụ:

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

Hoạt động như được hiển thị, nhưng thay thế các \xhhlối thoát bằng giá trị theo nghĩa đen của chúng để có được điểm số được yêu cầu. Bạn có thể làm điều đó bằng cách sử dụng dòng lệnh này:

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

Tôi chưa thực sự khám phá bất kỳ cách tiếp cận nào khác, vì vậy điều này có thể rất dễ bị đánh bại ...

Haskell, 289 byte

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

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}

Bạn cho phép thêm nhiều dòng mới như bạn muốn, vì vậy tôi đang tự do với điều đó. Bên cạnh đó, quy trình như sau:

1. Khởi tạo một mảng đầu ra a.
2. Đối với mỗi char:
   1. nếu đó là '', thêm  vàoa[0]
   2. nếu đó là '.', hãy thêm /\/\vàoa[0]
   3. nếu không thì:
      1. tính chiều cao ( c.upcase.ord + (c.upcase.ord-1)/3)
      2. cho mỗi hàng trong a:
         1. đệm hàng với khoảng trắng. a[t]+=w*(a[0].size-a[t].size)
         2. nếu chúng ta ở trên h, hãy tập trung vào_
         3. khác nếu chúng ta ở trên chiều cao, trung tâm a 
         4. khác nếu chúng ta thấp hơn chiều cao, trung tâm | |hoặc / \chiều rộng thích hợp ( 1+2*((h-t)/4), tùy thuộc vào việch-t%4==0
         5. thêm "|___|"chiều rộng đúnga[0]
3. trở về a.reverse

Tôi cá là tôi có thể làm cho nó nhỏ hơn nếu tôi làm bài toán để tránh reverse

PHP, 297 byte

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

Một phiên bản dễ đọc hơn:

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