Im Rahmen eines Stadtplanungsprojekts haben Sie den Auftrag erhalten, ein Programm oder eine Funktion zu erstellen, mit der die Skyline der Stadt angezeigt wird, und zwar unter Einbeziehung der Architekten. Das Projekt befindet sich erst in der Startphase, daher ist eine sehr grobe Skizze ausreichend. Am einfachsten ist es natürlich, die Skyline einfach in ASCII-Kunst zu zeichnen.

Alle Gebäude werden am Fluss liegen, daher sind sie alle ausgerichtet. Die Architekten geben die Höhe jedes Gebäudes als Eingabe an, und Ihr Code sollte die Skyline anzeigen.

Die Eingabe von den Architekten wird entweder eine ganze oder eine halbe ganze Zahl sein. Wenn die Zahl eine Ganzzahl ist, hat das Gebäude ein flaches Dach, während eine halbe Ganzzahl ein geneigtes Dach ergibt. Eine Null ist eben eben. Die Wände eines Gebäudes sind 3 Zeichen voneinander entfernt, während eine Null ein einzelnes Zeichen breit ist. Benachbarte Gebäude teilen sich Wände.

Einzelheiten und Erläuterungen zur Ausgabe finden Sie in den folgenden Beispielen:

N = 3
 ___
|   |
|   |
|___|

N = 3.5
  _      
 / \
|   |
|   |
|___|

N = 6
 ___
|   |
|   |
|   |
|   |
|   |
|___|

n = 0
_

Beispiel Eingabe: 3 3.5 0 2

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

Beispiel Eingabe: 0 0 2.5 3 0 4 1

             ___
    _  ___  |   |
   / \|   | |   |
  |   |   | |   |___
__|___|___|_|___|___|

Louisville ,0 2 1 3.5 0 4 2 4 2 4 6 1 6 0 5 1

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

Die verwendeten ASCII-Zeichen sind: Zeilenvorschub, Leerzeichen und /\_|(Codepunkte 10, 32, 47, 92, 95, 124).

Regeln:

• Es ist optional, ein Programm zu erstellen, das nur Ganzzahlen als Eingabe verwendet, indem alle Zahlen mit zwei multipliziert werden. Anstatt also zu nehmen 3 3.5 2, kann Ihr Programm dauern 6 7 4. Wenn das zweite Eingabeformat ausgewählt ist, sollte eine Eingabe von 6 zu einem dreistöckigen Gebäude führen, 7 sollte ein dreistöckiges Gebäude mit geneigten Dächern usw. sein.
• Die Ausgabe sollte genau wie oben beschrieben sein, aber nachgestellte Leerzeichen und Zeilenumbrüche sind in Ordnung.
• Das genaue Format der Eingabe ist optional. Was auch immer am besten in Ihrer Sprache ist.
• Das Ergebnis muss auf dem Bildschirm angezeigt werden, damit die Architekten es sich ansehen können.
• Sie können davon ausgehen, dass mindestens eine Ganzzahl angegeben wird und dass nur gültige Eingaben erfolgen.

Das ist Codegolf, also gewinnt der kürzeste Code in Bytes.

Python 2, 199 193 188 185 Bytes

a=map(int,raw_input().split())
l=max(a)+1|1
while~l:print''.join((x%2*'/  _\\ '[x<l::2]*(x<=l<x+4)or'_ '[x|1!=l>1]*3)[x<1:x+2]+'| '[x<=l>=y]*(x+y>0)for x,y in zip([0]+a,a+[0]))[1:];l-=2

Dies ist ein vollständiges Programm, das Ganzzahlen als Eingabe akzeptiert. Beispiel Eingabe .

MATLAB, 219 209 203 Bytes

i=input('');x=1;c=0;m(1:4*numel(i))='_';for a=i;b=fix(a);m(1:b,x)='|';s=95;if a~=b;m(b+2,x+2)=95;s='/ \';end;m(b+1,x+(1:3))=s;x=x+(a>0)*3+1;m(1:b,x)='|';x=x+(a<1&c>0);c=a;end;disp(flipud(m(:,1:x-(a<1))))

Dies funktioniert bei Octave leider nicht . Nicht ganz sicher, warum, scheint etwas mit dem Disp / Flipud-Bit zu tun zu haben, das bricht.

Außerdem gibt es derzeit keine Definition dessen, wie ein Gebäude mit einer Höhe von 0,5 aussieht, und ich nehme an, dass sie in diesem Code nicht zulässig sind.

Das Folgende ist der Code auf etwas besser lesbare Weise:

i=input(''); %e.g. [0 0 2 1 3.5 0 4 2 4 2 4 6 1 6 0 5 1 0 0 1 0]
x=1;
c=0;
m(1:4*numel(i))='_';
for a=i;
    b=fix(a);
    m(1:b,x)='|';
    s=95;
    if a~=b;
        m(b+2,x+2)=95;
        s='/ \';
    end;
    m(b+1,x+(1:3))=s;
    x=x+(a>0)*3+1;
    m(1:b,x)='|';
    x=x+(a<1&c>0);
    c=a;
end;
disp(flipud(m(:,1:x-(a<1))))

Zuerst nehmen wir eine Eingabe als Array und führen eine variable Initialisierung durch.

i=input(''); %e.g. [0 0 2 1 3.5 0 4 2 4 2 4 6 1 6 0 5 1]
x=1;
c=0;

Da die Gebäude mit der Höhe Null ein Schmerz sind - sie haben im Grunde genommen eine Breite, die davon abhängt, in welcher Umgebung sie sich befinden (obwohl sich die gedruckten Objekte nicht ändern), vereinfachen wir die Dinge, indem wir für alle Gebäude genügend Boden zeichnen. Wir gehen davon aus, dass jedes Gebäude 4 Zeichen breit sein wird (da benachbarte Gebäude zusammengeführt werden) - Null hohe Gebäude sind es nicht, aber der Überschuss wird später gekürzt.

m(1:4*numel(i))='_';

Jetzt zeichnen wir jedes Gebäude der Reihe nach aus.

for a=i

Zuerst erhalten wir den ganzzahligen Teil der Höhe, da dieser bestimmt, wie viele '|' wir brauchen.

    b=fix(a);

Zeichnen Sie nun die Wand für dieses Gebäude ein. Wenn zwei benachbarte Gebäude vorhanden sind, befindet sich die Wand für dieses neue Gebäude in der gleichen Spalte wie die Wand des letzten Gebäudes.

    m(1:b,x)='|';

Überprüfen Sie, ob es sich um ein halbhohes Gebäude handelt. Wenn ja, dann ist das Dach anders. Für die halben Höhen wird das Dach so sein, wie / \es sein wird ___(Matlab wird dies implizit aus einem einzelnen Unterstrich replizieren, also dort ein paar Bytes sparen). Für die halbhohen Gebäude gibt es ein zusätzliches Stück Dach, das ebenfalls hinzugefügt wird.

    s=95;
    if a~=b;
        m(b+2,x+2)=95;
        s='/ \';
    end;

Zeichne das Dach ein

    m(b+1,x+(1:3))=s;

Gehen Sie nun zum Anfang des nächsten Gebäudes und zeichnen Sie die gemeinsame Wand ein (wenn die Wand an dieser Stelle zu kurz ist, wird sie beim Zeichnen des nächsten Gebäudes größer). Beachten Sie, dass Gebäude mit einer Höhe von null eine Breite von 1 und normale Gebäude eine Breite von vier haben. Wir vereinfachen das, was ansonsten ein Wenn-Sonst wäre, indem wir (a> 0) als Dezimalzahl und nicht als Booleschen Wert behandeln.

    x=x+(a>0)*3+1;
    m(1:b,x)='|';

Als nächstes kommt ein bisschen Hackergeist, um mit null hohen Gebäuden zu arbeiten. Dies besagt im Grunde genommen, dass, wenn dieses Gebäude eine Höhe von null hat und das vorherige Gebäude keine Höhe hat, die Position des nächsten Gebäudes um 1 erhöht werden muss, da ein Gebäude mit einer Höhe von null, das zwischen zwei anderen Gebäuden liegt, doppelt so breit ist berücksichtigt die zusätzliche Wand, die normalerweise mit einem angrenzenden Gebäude geteilt wird. Wir behalten auch diese Gebäudehöhe im Auge, um diese Prüfung beim nächsten Mal durchzuführen.

    x=x+(a<1&c>0);
    c=a;
end;

Wenn Sie fertig sind, drehen Sie die Gebäudematrix um und zeigen Sie sie an. Beachten Sie, dass wir auch hier überschüssigen Boden abschneiden.

disp(flipud(m(:,1:x-(a<1))))

Wenn wir dieses Skript ausführen, werden wir nach unserer Eingabe gefragt, zum Beispiel:

[0 0 2 1 3.5 0 4 2 4 2 4 6 1 6 0 5 1 0 0 1 0]

Anschließend wird das Gebäude generiert und das Ergebnis angezeigt. Für die obige Eingabe wird Folgendes generiert:

                                     ___     ___                   
                                    |   |   |   |  ___             
            _    ___     ___     ___|   |   |   | |   |            
           / \  |   |   |   |   |   |   |   |   | |   |            
   ___    |   | |   |___|   |___|   |   |   |   | |   |            
  |   |___|   | |   |   |   |   |   |   |___|   | |   |___    ___  
__|___|___|___|_|___|___|___|___|___|___|___|___|_|___|___|__|___|_

Kotlin, 447 442 Bytes

val a={s:String->val f=s.split(" ").map{it.toFloat()}.toFloatArray();val m=(f.max()!!+1).toInt();for(d in m downTo 0){var l=0f;for(c in f){val h=c.toInt();print(if(h==d&&d!=0)if(h<l-0.5)"|" else{" "}+if(c>h)"/ \\" else "___" else if(h<d)if(d<l-0.5)"|" else{" "}+if(h==0)" " else if((c+0.5).toInt()==d)" _ " else "   " else{if(h==0)if(l<1)"  " else "| " else "|   "}.replace(' ',if(d==0)'_' else ' '));l=c;};if(d<l-0.5)print("|");println();}}

Ungolfed-Version:

val ungolfed: (String) -> Unit = {
    s ->

    val floats = s.split(" ").map { it.toFloat() }.toFloatArray()
    val maxH = (floats.max()!! + 1).toInt()

    for (drawHeight in maxH downTo 0) {
        var lastBuildingH = 0f
        for (f in floats) {
            val buildingH = f.toInt()
            if (drawHeight == 0) {
                // Baseline
                if (buildingH == 0)
                    if (lastBuildingH.toInt() == 0) print("__")
                    else print("|_")
                else print("|___")
            } else if (buildingH == drawHeight) {
                // Ceiling
                if (buildingH < lastBuildingH - 0.5) print("|")
                else print(" ")
                if (f > buildingH) print("/ \\")
                else print("___")
            } else if (buildingH < drawHeight) {
                // Above building
                if (drawHeight < lastBuildingH - 0.5) print("|")
                else print(" ")
                if (buildingH == 0) print(" ")
                else {
                    if ((f + 0.5).toInt() == drawHeight) print(" _ ")
                    else print("   ")
                }
            } else {
                if (buildingH == 0) print("| ")
                else print("|   ")
            }
            lastBuildingH = f;
        }
        if (drawHeight < lastBuildingH - 0.5) print("|")
        println()
    }
}

Python 2, 357 306 299 294 287 281 276 Bytes

def s(l):
 d=len(l)+1;l=[0]+l+[0];h=(max(l)+3)/2;o=''
 for i in range(d*h):
  a=l[i%d+1];c=l[i%d];b=2*(h-1-i/d);o+="|"if(a>b+1)+(c>b+1)else" "*(a+c>0);o+=" _/__  _\\"[a-b+1::3]if b*(1>=abs(a-b))else" "*(1+2*(a>0))
  if b==0:o=o.replace(" ","_")
  if i%d==d-1:print o[:-1];o=''

Hierbei wird die "doppelte" Codierung verwendet, die als Liste an die Funktion übergeben wird. Bearbeiten: Rasierte Bytes, indem ein Teil der großen Bedingung als Array-Auswahl wiederhergestellt und auf die doppelte Codierung umgeschaltet wurde. Sie haben mehr Bytes gespart, indem Sie die Bedingung noch mehr neu geordnet und mehr Logik in Arithmetik umgewandelt haben.

EDIT: xsot ist besser

Erläuterung:

d=len(l)+1;l=[0]+l+[0];m=max(l);h=m/2+m%2+1;o=''

dist 1 mehr als die Länge des Arrays, da wir an jedem Ende der Liste vom zweiten Element bis zu der am Ende hinzugefügten Null Nullen hinzufügen. hist die Höhe der Zeichnung. (Wir müssen in dieser Berechnung durch 2 dividieren, weil wir die doppelte Darstellung verwenden, die wir speziell verwenden, um zu vermeiden, dass Schwimmer überall auf Ints geworfen werden müssen. Wir addieren auch 1, bevor wir so ungerade Höhen teilen - spitze Gebäude - Holen Sie sich ein wenig mehr Spielraum als die normale Art.) oist die Ausgabe-Zeichenfolge.

 for i in range(d*h):

Ein Standardtrick zum Zusammenfassen einer double for-Schleife zu einer single for-Schleife. Sobald wir machen:

  a=l[i%d+1];c=l[i%d];b=2*(h-1-i/d)

Wir haben jetzt dasselbe erreicht wie:

for b in range(2*h-2,-2,-2):
 for j in range(d):
  a=l[j+1];c=l[j]

aber auf eine Weise, die uns zehn Bytes erspart (einschließlich Leerzeichen in den folgenden Zeilen).

  o+="|"if(a>b+1)+(c>b+1)else" "*(a+c>0)

Kleben Sie eine Wand an, wenn die Höhe des aktuellen oder des vorherigen Gebäudes höher als die aktuelle Linie ist, sofern sich hier mindestens eine Gebäudegrenze befindet. Dies entspricht der folgenden Bedingung:

  o+=("|" if a>b+1 or c>b+1 else " ") if a or c else ""

Dabei ist b die aktuelle Scanhöhe, a die aktuelle Gebäudehöhe und c die vorherige Gebäudehöhe. Der letztgenannte Teil der Bedingung verhindert, dass Wände zwischen Grundräume gesetzt werden.

  o+=" _/__  _\\"[a-b+1::3]if b*(1>=abs(a-b))else" "*(1+2*(a>0))

Dies ist der Teil, der das richtige Dach zeichnet und die Dachteile durch Vergleichen der Gebäudehöhe mit der aktuellen Scanhöhe auswählt. Wenn hier kein Dach vorhanden ist, werden entsprechend viele Felder gedruckt (3, wenn es sich um ein tatsächliches Gebäude handelt, z. B. a> 0, andernfalls 1). Beachten Sie, dass in Bodennähe niemals versucht wird, ein Dach zu zeichnen, dh Gebäude mit einer Größe von 0,5 erhalten keine spitzen Dächer. Naja.

  if b==0:o=o.replace(" ","_")

Wenn wir ebenerdig sind, möchten wir Unterstriche anstelle von Leerzeichen. Wir ersetzen sie hier nur alle auf einmal.

  if i%d==d-1:print o[:-1];o=''

Bevor wir mit der Verarbeitung der nächsten Zeile beginnen, drucken Sie die aktuelle Zeile und löschen Sie die Ausgabezeile. Das letzte Zeichen wird abgeschnitten, da es sich um das "_" handelt, das dem hinzugefügten Grundraum entspricht, indem am Anfang der Funktion eine Null angehängt wird. (Wir haben diese Null angehängt, damit wir keinen Sonderfall hinzufügen müssen, um eine rechte Wand einzufügen, wenn sie existiert. Dies würde viel mehr Code hinzufügen, als wir durch Hinzufügen der 0 und Abschneiden des "_" hinzugefügt haben.)

Python 3

725 Bytes

608 Bytes

Golf Code:

import sys,math;
m,l,w,s,bh,ls,ins,r,a="|   |","___","|"," ",0,[],[],range,sys.argv[1:]
def ru(n):return math.ceil(n)
def bl(h,n):
    if(n>ru(h)):return(s*5,s)[h==0]
    if(h==0):return"_"
    if(n==0):return w+l+w
    if(n<h-1):return m
    return("  _  "," / \ ")[n==ru(h)-1]if(h%1)else(s+l+s,m)[n==h-1]
for arg in a:
    f=ru(float(arg))
    if(bh<f):bh=f
for i in r(bh,-1,-1):
    ln=""
    for bld in a:ln+=bl(float(bld),i)
    ls.append(ln)
for i in r(len(ls[-1])-1):
    if(ls[-1][i]==ls[-1][i+1]==w):ins.append(i-len(ins))
for ln in ls:
    for i in ins:ln=(ln[:i]+ln[i+1:],ln[:i+1]+ln[i+2:])[ln[i]==w]
    print(ln)

Hier ist der Code ohne Golf. Es gibt einige Kommentare, aber die Grundidee besteht darin, Gebäude mit doppelten Wänden zu erstellen, sodass das Endergebnis so aussieht:

_|___||___|_|___||___|

Um dann Indizes dieser doppelten Wände zu erhalten und diese Spalten zu entfernen, erhalten wir:

_|___|___|_|___|___|

Code:

import sys
import numbers
import math

mid="|   |";
l="___";
w="|";
s=" ";

def printList(lst):
    for it in lst:
        print(it);

# h = height of building
# l = line numeber starting at 0
def buildingline(h,n):
    #if (h==0):
    #   return " " if(n>math.ceil(h)) else "   ";
    if(n>math.ceil(h)):
        return s if(h == 0) else s*5;
    if(h==0): return "_";
    if(n==0): return w+l+w;
    if(n<h-1): return mid;
    if(h.is_integer()):
        return mid if(n==h-1) else  s+l+s;
    else:
        return " / \ " if (n==math.ceil(h)-1) else "  _  "; 
# max height
bh=0;

for arg in sys.argv[1:]:
    f = math.ceil(float(arg));
    if(bh<f):bh=f;

# lines for printing
lines = []

for i in range(bh,-1,-1):
    line="";
    for bld in sys.argv[1:]:
        bld=float(bld);
        line += buildingline(bld,i);
        #lh = bld;
    lines.append(line);

#for line in lines:
#   print(line);
#printList(lines);


# column merging
#find indexes for merging (if there are | | next to each other)
indexes = [];
for i in range(len(lines[-1])-1):
    if (lines[-1][i]=='|' and lines[-1][i+1] == '|'):
        indexes.append(i-len(indexes));

#printList(indexes);

#index counter
for line in lines:
    newLine = line;
    for i in indexes:
        if newLine[i] == '|' :
            newLine=newLine[:i+1] + newLine[i+2:];
        else : newLine = newLine[:i] + newLine[i+1:];
    print(newLine);

Zeit zum Golfen!

PHP, 307 297 293 Bytes

<?$r=str_pad("",$p=((max($argv)+1)>>1)*$w=4*$argc,str_pad("\n",$w," ",0));for(;++$i<$argc&&$r[$p++]=_;$m=$n)if($n=$argv[$i]){$q=$p+=!$m;eval($x='$r[$q-1]=$r[$q]=$r[$q+1]=_;');for($h=$n>>1;$h--;$q-=$w)$r[$q-2]=$r[$q+2]="|";$n&1?($r[$q-1]="/")&($r[$q-$w]=_)&$r[$q+1]="\\":eval($x);$p+=3;}echo$r;

Übernimmt Argumente * 2 von der Kommandozeile. In Datei speichern, mit ausführen php <filename> <parameters>.

Nervenzusammenbruch

// initialize result    
$r=str_pad("",              // nested str_pad is 3 bytes shorter than a loop
    $p=                     // cursor=(max height-1)*(max width)=(start of last line)
    ((max($argv)+1)>>1)     // max height-1
    *
    $w=4*$argc              // we need at least 4*($argc-1)-1, +1 for newline
    ,
    // one line
    str_pad("\n",$w," ",0)  // (`str_pad("",$w-1)."\n"` is one byte shorter,
);                          // but requires `$w+1`)

// draw skyline
for(;
    ++$i<$argc              // loop through arguments
    &&$r[$p++]=_                // 0. draw empty ground and go one forward
    ;
    $m=$n                       // 7. remember value
)
    if($n=$argv[$i])            // if there is a house
    {
        $q=                         // 2. copy $p to $q
        $p+=!$m;                    // 1. go one forward if there was no house before this
        // offset all further positions by -2 (overwrite empty ground, share walls)
        eval($x=                    // 3. draw floor
        '$r[$q-1]=$r[$q]=$r[$q+1]=_;'
        );
        for($h=$n>>1;$h--;$q-=$w)   // 4. draw walls
            $r[$q-2]=$r[$q+2]="|";
        $n&1                        // 5. draw roof
            ?($r[$q-1]="/")&($r[$q-$w]=_)&$r[$q+1]="\\"
            :eval($x)               // (eval saved 7 bytes)
        ;                           // (ternary saved 6 bytes over `if`)
        $p+=3;                      // 6. go three forward (5-2)
    }

// output
echo$r;

C ++, ungolfed

(oder vielleicht ungolfbar)

Angenommen, es gibt weniger als 100 Elemente und jedes Element ist weniger als 100. sist die Anzahl der Gebäude (für die Eingabe erforderlich).

#include <iostream>
using namespace std;
int main()
{
float a[100];
int i,j,s;
cin>>s;
for(i=0;i<s;++i)
 cin>>a[i];
for(i=100;i>=1;--i)
{
for(j=0;j<s;++j)
{
if((a[j]>=i)||(a[j-1]>=i))
 cout<<"|";
else
 cout<<" ";
if(i==1)
 cout<<"___";
else if(a[j]+1==i)
 cout<<"___";
else if(a[j]+1.5==i)
 cout<<" _ ";
else if(a[j]+0.5==i)
 cout<<"/ \\";
else cout<<"   ";
}
if(a[s-1]>=i)
 cout<<"|";
cout<<endl;
}
}