Die Herausforderung

Ihr Programm oder Ihre Funktion akzeptiert eine einzelne Zeichenfolge, die von STDIN eingegeben wurde, oder einen Funktionsparameter. Sie können davon ausgehen, dass die Eingabe nur alphabetische Zeichen (a-zA-Z), Leerzeichen und Punkte enthält. Bei der Eingabe wird die Groß- und Kleinschreibung nicht berücksichtigt, daher sollten Sie "a" genauso behandeln wie "A".

Für jedes Zeichen in der Zeichenfolge geben Sie eine Darstellung eines Gebäudes gemäß der folgenden Spezifikation aus.

Jedes Gebäude muss ein Dach haben, das in der obersten Zeile durch einen Unterstrich und in der zweiten Zeile durch einen Schrägstrich, ein Leerzeichen und einen umgekehrten Schrägstrich gekennzeichnet ist.

 _
/ \

Sie haben dann mehrere Stockwerke, die mit der Buchstabenanzahl (a = 1, b = 2, c = 3 usw.) übereinstimmen und durch eine Wand (|) auf jeder Seite und ein Leerzeichen in der Mitte dargestellt werden. Das Untergeschoss (und nur das Untergeschoss) sollte ein Fundament haben, das einen Unterstrich zwischen den Wänden darstellt. So was...

|_|

So würde zum Beispiel 'b' so aussehen

 _
/ \
| |
|_|

Jetzt wissen wir, dass sehr hohe, schmale Gebäude nicht stehen können und an der Basis breiter werden müssen, sodass kein Gebäude ohne zusätzliche Unterstützung mehr als drei Stockwerke hoch stehen kann. Also sollten Sie alle drei Ebenen (nicht weniger) eine "Verbreiterungsebene" hinzufügen. Die sich erweiternde Schicht besteht aus einem Schrägstrich und einem umgekehrten Schrägstrich direkt über den Wänden des Abschnitts darunter, und der Abschnitt darunter sollte zwei Stellen breiter sein als der Abschnitt darüber. Die zusätzliche Schicht zählt nicht zur Höhe des Gebäudes.

Gebäude sollten sich nicht überlappen, aber keine unnötigen Abstände haben, und der Boden sollte immer flach sein, sodass alle Gebäude ihre Basis auf derselben Ebene haben sollten.

Beispielsweise sieht 'abcdefga' so aus.

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

Leerzeichen in der Zeichenfolgeneingabe sollten durch ein doppeltes Leerzeichen dargestellt werden.

Punkte in der Zeichenfolgeneingabe sollten durch Trümmer wie dieses dargestellt werden.

/\/\

Weitere Beispiele

Eingabe = Hello world.

Ausgabe =

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

Eingabe = lorem ipsum

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

Eingabe = a.a.a.x.x.x.a.a.a

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

Regeln

• Natürlich ist dies Codegolf, die niedrigste Punktzahl in Bytes gewinnt
• Es gelten Standard-Regelungslücken
• Es sind beliebig viele zusätzliche Leerzeilen vor oder nach der Ausgabe zulässig
• Sie können das gesamte Ergebnis in einer Zeichenfolge ausgeben oder die Ausgabe als Array anbieten, wobei jedes Element eine Ausgabezeile darstellt, oder an STDOUT senden

Hinweis

Dies ist mein erster Beitrag bei PPCG. Es ist durch den Sandkasten gegangen. Alle negativen Punkte oder mögliche Verbesserungen bitte als Kommentar posten und ich werde tun, was ich kann

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

Erstellt die ASCII-Grafik rekursiv, beginnend mit der untersten Ebene und Anwenden mehrerer regulärer Ausdrücke zwischen den einzelnen Phasen:

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

Wie es funktioniert

1) Untergeschoss

Wir beginnen mit der Übersetzung der Eingabezeichenfolge in ein unteres Stockwerk wie:

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

wo:

• y ist ein kürzerer Alias ​​für den Backslash (der ein Escape erfordert)
• Die Ziffer ( 0, 1oder 2) kurz vor einer Folge von _der linken Wand des Gebäudes. Es gibt die Anzahl der Wände an, die vor der nächsten „Ausbreitungsschicht“ darüber platziert werden müssen.
• Die Ziffer nach einer Folge von _steht für die rechte Wand des Gebäudes und ist immer auf gesetzt 0.

2) Reguläre Ausdrücke, die zwischen den einzelnen Phasen angewendet werden

Der rekursive Prozess besteht aus dem Anwenden von 9 Ersetzungen in der vorherigen Etage unter Verwendung der folgenden regulären Ausdrücke:

1. /\/y/g=> " "(Schutt entfernen)
2. /_/g=> "x"(ersetzen Sie das Fundament oder die Oberseite des Gebäudes durch einen festen Block)
3. /\/xy/g=> " _ "(Ersetze die letzte Verbreiterungsschicht mit der Oberseite des Gebäudes)
4. /1/g=> "3"(vorübergehend ersetzen 1durch 3- siehe letzten Schritt)
5. /2/g=> "1"(ersetzen 2durch 1)
6. /\/xx(x+)y/g=> " 2$10 "(Ersetzen Sie eine verbreiternde Ebene durch eine neue, schmalere Wand)
7. /0(x+)0/g=> "/$1y"(ersetzen Sie die Oberseite der Wand mit einer verbreiternden Schicht)
8. /3/g=> "0"(ersetzen 3durch 0)

Zum Beispiel sind hier die aufeinanderfolgenden Transformationen von 2___0(unteres Stockwerk erzeugt durch 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 : Die Oberseite des Gebäudes wird dann durch a ersetzt x. Dies ist im obigen Diagramm nicht dargestellt.}

3) Reguläre Ausdrücke, die auf das Endergebnis angewendet werden

Die Rekursion hört auf, wenn nichts mehr zu ersetzen ist, was bedeutet, dass wir uns jenseits der Spitze des höchsten Gebäudes befinden.

Wir müssen jetzt alles mit noch ein paar regulären Ausdrücken aufräumen:

1. /\d/g=> "|"(Ziffern durch Pfeifen ersetzen)
2. /x/g=> " "(feste Blöcke durch Leerzeichen ersetzen)
3. /y/g=> "\"(durch yBackslashes ersetzen )

Zum Beispiel:

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

Demo

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

Mitwirkende:
4 Bytes gespart dank Hedi
8 Bytes gespart dank Not that Charles

PHP, 386 376 367 364 362 358 356 Bytes

erste Ansatz; kann noch golf sein.

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 Bytes

ähnlicher Ansatz mit einer Unterfunktion:

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

Aufschlüsselung für den zweiten Ansatz

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, wenn führende Zeilen nicht zulässig sind:
Ersetzen echo"$o[$y]\n;durch if($s=rtrim($o[$y]))echo"$s\n";.

-3 Bytes für einen der ;<=>?[\]^_{|}~Trümmer: Ersetzen Sie 1) ($n=31&ord($c))mit $n, 2) $n=28,$w='.'!=$cmit ($n=31&ord($c))<27und 3) 4mit ($n=28)/7.

Ein weiterer für -8 >, ^oder , ~wie Bauschutt: Undo 3)

Pyth, 93 79 Bytes

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

Probieren Sie es online aus. Testsuite.

Erläuterung

Ich habe dies standardmäßig ausgeblendet, da es viel zu lang ist.

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

Beinhaltet +1 für -p

Mit Eingabe auf STDIN ausführen, z

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

Funktioniert wie abgebildet, aber ersetzen Sie die \xhhEscape-Zeichen durch ihren Literalwert, um die beanspruchte Punktzahl zu erhalten. Sie können das mit dieser Kommandozeile machen:

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

Ich habe noch keine anderen Ansätze untersucht, daher ist dies möglicherweise sehr schlagbar ...

Haskell, 289 Bytes

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}

Sie erlauben so viele zusätzliche Zeilenumbrüche, wie Sie möchten, also nehme ich mir die Freiheit. Abgesehen davon ist der Prozess wie folgt:

1. Initialisieren Sie ein Ausgabearray a.
2. Für jedes Zeichen:
   1. wenn es ‚‘ ist, fügen Sie  zua[0]
   2. wenn es ‚‘, fügen Sie /\/\zua[0]
   3. Andernfalls:
      1. berechne die Höhe ( c.upcase.ord + (c.upcase.ord-1)/3)
      2. für jede Zeile in a:
         1. Füllen Sie die Zeile mit Leerzeichen auf. a[t]+=w*(a[0].size-a[t].size)
         2. wenn wir eins oben sind h, zentriere a_
         3. sonst, wenn wir über der Höhe sind, zentrieren Sie a 
         4. sonst, wenn wir unter der Höhe, Mitte | |oder / \der richtigen Breite ( 1+2*((h-t)/4) sind, je nachdem, obh-t%4==0
         5. fügen Sie "|___|"die richtigen Breite zua[0]
3. Rückkehr a.reverse

Ich wette, ich kann es kleiner machen, wenn ich die Mathematik ausarbeite, um das zu vermeiden reverse

PHP, 297 Bytes

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

Eine lesbarere Version:

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