W ramach projektu urbanistycznego otrzymałeś zadanie stworzenia programu lub funkcji, która wyświetli panoramę miasta, biorąc pod uwagę pewien wkład architektów. Projekt jest dopiero w fazie początkowej, więc wystarczy bardzo przybliżony szkic. Najłatwiej jest oczywiście narysować linię horyzontu w sztuce ASCII.

Wszystkie budynki będą nad rzeką, więc wszystkie są wyrównane. Architekci podadzą wysokość każdego budynku jako dane wejściowe, a Twój kod powinien wyświetlać linię horyzontu.

Dane wejściowe od architektów będą albo liczbami całkowitymi, albo pół liczbami całkowitymi. Jeśli liczba jest liczbą całkowitą, budynek będzie miał płaski dach, a połowa będzie skutkować dachem dwuspadowym. Zero będzie po prostu płaskie. Ściany budynku są oddalone od siebie o 3 znaki, a zero będzie miało szerokość jednego znaku. Sąsiednie budynki dzielą ściany.

Aby uzyskać szczegółowe informacje i wyjaśnienia dotyczące wyników, spójrz na poniższe przykłady:

N = 3
 ___
|   |
|   |
|___|

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

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

n = 0
_

Przykładowe dane wejściowe: 3 3.5 0 2

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

Przykładowe dane wejściowe: 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

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

Stosowane znaki ASCII to: nowa linia, spacja i /\_|(punkty kodowe 10, 32, 47, 92, 95, 124).

Zasady:

• Opcjonalne jest utworzenie programu, który przyjmuje tylko liczby całkowite jako dane wejściowe, poprzez pomnożenie wszystkich liczb przez dwa. Więc zamiast brać 3 3.5 2, twój program może zająć 6 7 4. Jeśli zostanie wybrany drugi format wejściowy, wprowadzenie wartości 6 powinno dać budynek trzypiętrowy, 7 powinien być budynkiem trzypiętrowym ze spadzistymi dachami itp.
• Dane wyjściowe powinny być dokładnie takie, jak opisano powyżej, ale końcowe spacje i znaki nowej linii są prawidłowe.
• Dokładny format danych wejściowych jest opcjonalny. Cokolwiek jest najlepsze w twoim języku.
• Wynik musi być wyświetlony na ekranie, aby architekci mogli go obejrzeć.
• Możesz założyć, że podana zostanie co najmniej jedna liczba całkowita i że podana będzie tylko poprawna wartość wejściowa.

To jest codegolf, więc wygrywa najkrótszy kod w bajtach.

Python 2, 199 193 188 185 bajtów

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

Jest to pełny program, który przyjmuje liczby całkowite jako dane wejściowe. Przykładowe dane wejściowe .

MATLAB, 219 209 203 bajtów

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

To niestety nie działa w Octave . Nie do końca wiadomo dlaczego, wydaje się, że ma to coś wspólnego z łamanym bitem disp / flipud.

Ponadto nie ma obecnie definicji tego, jak wygląda budynek o wysokości 0,5, ani żadnej wzmianki o nich, więc w tym kodzie zakładam, że są one niedozwolone.

Poniżej znajduje się kod w nieco bardziej czytelny sposób:

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

Najpierw bierzemy dane wejściowe jako tablicę i dokonujemy inicjalizacji zmiennej.

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;

Ponieważ budynki o zerowej wysokości są uciążliwe - w zasadzie kończą się na szerokości, która zależy od tego, co znajdują się obok (chociaż to, co jest drukowane, nie zmienia się), upraszczamy rzeczy, rysując wystarczająco dużo gruntu dla wszystkich budynków. Zakładamy, że każdy budynek będzie miał 4 znaki szerokości (ponieważ sąsiednie budynki łączą się ze sobą) - te o zerowej wysokości nie są, ale nadmiar zostanie przycięty później.

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

Teraz wyciągamy kolejno każdy budynek.

for a=i

Najpierw otrzymujemy całkowitą część wysokości, ponieważ to określi, ile „|” potrzebujemy.

    b=fix(a);

Teraz narysuj ścianę dla tego budynku - jeśli są dwa sąsiednie budynki, ściana dla tego nowego będzie znajdować się w tej samej kolumnie co ściana z ostatniego.

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

Sprawdź, czy jest to budynek o połowie wysokości. Jeśli tak, to dach będzie inny. Dla połówek wysokości dach będzie, / \podczas gdy będzie to pełna wysokość ___(Matlab domyślnie powieli to z jednego znaku podkreślenia, więc zapisz tam kilka bajtów). Jest dodatkowy kawałek dachu o jeden rząd wyżej dla budynków o połowie wysokości, więc to również jest dodawane.

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

Narysuj w dachu

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

Teraz przejdź na początek następnego budynku i narysuj wspólną ścianę (jeśli ściana jest w tym momencie zbyt krótka, zostanie powiększona, gdy zostanie narysowany następny budynek). Zauważ, że budynki o zerowej wysokości mają szerokość 1, normalne budynki mają szerokość 4, więc upraszczamy to, co w innym przypadku byłoby, gdyby nie, traktując (a> 0) jako liczbę dziesiętną, a nie logiczną.

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

Dalej jest trochę hakerów do pracy z budynkami o zerowej wysokości. Zasadniczo to mówi, że jeśli ten budynek miał zero wysokości, a poprzedni nie był, oznacza to, że miejsce następnego budynku wymaga zwiększenia o 1, ponieważ budynek o zerowej wysokości umieszczony pomiędzy dwoma innymi budynkami jest faktycznie dwa razy szerszy - to stanowi dodatkową ścianę, która zwykle jest dzielona z sąsiednim budynkiem. Śledzimy również wysokość budynku w celu wykonania tej kontroli następnym razem.

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

Po zakończeniu odwróć matrycę budynku, aby była poprawna, i wyświetl ją. Pamiętaj, że również tutaj usuwamy nadmiar ziemi.

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

Kiedy uruchamiamy ten skrypt, jesteśmy proszeni o podanie danych, na przykład:

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

Następnie generuje budynek i wyświetla wynik. Dla powyższych danych wejściowych generowane są:

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

Kotlin, 447 442 bajtów

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

Wersja bez golfa:

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 bajtów

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

Wykorzystuje to kodowanie „podwójne”, które jest przekazywane do funkcji jako lista. Edycja: Ogolono bajty, ponawiając część dużego warunku jako selektor tablicy i przechodząc do podwójnego kodowania. Ogolono więcej bajtów, jeszcze bardziej przestawiając warunek i przekształcając więcej logiki w arytmetykę.

EDYCJA: xsot's jest lepszy

Wyjaśnienie:

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

djest o 1 większa niż długość tablicy, ponieważ dodamy zera na każdym końcu listy od drugiego elementu do zera, które dodaliśmy na końcu. hjest wysokością rysunku. (W tym obliczeniu musimy podzielić przez 2, ponieważ używamy podwójnej reprezentacji, której używamy specjalnie, aby uniknąć konieczności rzucania pływaków na ints w całym miejscu. Dodajemy również 1 przed podzieleniem tak dziwnych wysokości - spiczaste budynki - uzyskać trochę więcej luzu niż zwykły rodzaj.) oto ciąg wyjściowy.

 for i in range(d*h):

Standardowa sztuczka polegająca na zwijaniu podwójnej pętli for w pojedynczą pętlę for. Kiedy to zrobimy:

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

osiągnęliśmy teraz to samo, co:

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

ale w sposób, który pozwala nam zaoszczędzić dziesięć bajtów (w tym spacje w kolejnych wierszach).

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

Przyklej ścianę w dowolnym momencie, wysokość obecnego budynku lub poprzedniego budynku jest wyższa niż bieżąca linia, o ile jest tu co najmniej jedna granica budynku. Jest to odpowiednik następujących warunków:

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

gdzie b to aktualna wysokość skanu, a to aktualna wysokość budynku, a c to poprzednia wysokość budynku. Ta ostatnia część warunku zapobiega umieszczaniu ścian między przestrzeniami naziemnymi.

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

Jest to część, która rysuje prawidłowy dach, wybierając części dachu przez porównanie wysokości budynku z bieżącą wysokością skanu. Jeśli dach nie wchodzi tutaj, drukuje odpowiednią liczbę miejsc (3, gdy jest to prawdziwy budynek, np. A> 0, w przeciwnym razie 1). Zauważ, że kiedy jesteśmy na poziomie gruntu, nigdy nie próbuje narysować dachu, co oznacza, że ​​budynki wielkości 0,5 nie dostają spiczastych dachów. No cóż.

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

Gdy jesteśmy na poziomie gruntu, zamiast spacji chcemy podkreślenia. Po prostu wymieniamy je wszystkie tutaj naraz.

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

Tuż przed rozpoczęciem przetwarzania następnego wiersza wydrukuj bieżący i wyczyść wiersz wyjściowy. Odcinamy ostatni znak, ponieważ jest to „_” odpowiadające dodanej przestrzeni naziemnej, dodając zero na początku funkcji. (Dodaliśmy to zero, więc nie musielibyśmy dodawać specjalnego przypadku, aby wstawić prawą ścianę, jeśli istnieje, co dodałoby znacznie więcej kodu niż dodaliśmy dodając 0 i odcinając „_”.)

Python 3

725 bajtów

608 bajtów

Kod do gry w golfa:

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)

Oto nielepszy kod. Jest kilka komentarzy, ale podstawową ideą jest tworzenie budynków z podwójnymi ścianami, więc dolna linia wygląda następująco:

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

Następnie, aby uzyskać indeksy tych podwójnych ścian i usunąć te kolumny, otrzymujemy:

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

Kod:

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

Czas na golfa!

PHP, 307 297 293 bajtów

<?$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;

Pobiera argumenty * 2 z wiersza poleceń. zapisz do pliku, uruchom z php <filename> <parameters>.

awaria

// 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 ++, bez golfa

(a może nie do zdobycia)

Zakładając, że jest mniej niż 100 elementów, a każdy element jest mniejszy niż 100. sto liczba budynków (wymagana na wejściu).

#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;
}
}