+ - +
+ - + | | + - + + - +
| | | | | | | |
+ - + + - + + - + + - +

Mieszkańcy ASCIIville odbudowują swoje miasto i opracowują nowe plany. Twoim zadaniem jest narysowanie nowego miasta na podstawie liczby budynków, których chcą.

Dane wejściowe będą polegały na liczbie budynków. Każdy budynek ma połowę wysokości nakładu (zaokrąglony w górę, jeśli jest nieparzysty), nie licząc górnej i dolnej części budynku.

Narysujmy podstawowy przykład 4

+ - + + - + + - + + - +
| | | | | | | |
| | | | | | | |
+ - + + - + + - + + - +

Jak widać tutaj, |w każdym budynku są dwa s, ponieważ dane wejściowe wynosiły cztery. Ale jest haczyk! (co oznacza, że ​​powyższy przykład jest niepoprawny, a przykład na górze tego posta to rzeczywisty wynik dla 4)

Dla każdego budynku, który nie jest liczbą pierwszą, jego wysokość spada o jeden. Jeśli liczba jest podzielna przez 3 , 5 lub 10 , zmniejsza się o jeszcze jeden. Jeśli jest podzielna przez dwie lub więcej z tych liczb, odliczana kwota sumuje się ( 10 jest podzielne przez 10 i 5, i nie jest liczbą pierwszą, więc zostaje odjęte przez 3 ).

Spójrzmy na przykład z wejściem 5.

     + - +
+ - + | | + - + + - + + - +
| | | | | | | | | |
| | | | | | | | | |
+ - + + - + + - + + - + + - +

Oto przykład 7

     + - + + - +
+ - + | | + - + + - + + - + | |
| | | | | | | | | | + - + | |
| | | | | | | | | | | | | |
| | | | | | | | | | | | | |
+ - + + - + + - + + - + + - + + - + + - +

I przykład 10

     + - + + - +
+ - + | | + - + + - + + - + | | + - +
| | | | | | | | | | + - + | | | | + - +
| | | | | | | | | | | | | | | | | | + - +
| | | | | | | | | | | | | | | | | | | |
| | | | | | | | | | | | | | | | | | | |
+ - + + - + + - + + - + + - + + - + + - + + - + + - + + - +

I wracając do 6

     + - +
+ - + | | + - + + - + + - +
| | | | | | | | | | + - +
| | | | | | | | | | | |
+ - + + - + + - + + - + + - + + - +

Zasady:

• Jeśli liczba zostanie odjęta tak bardzo, że jej wysokość jest mniejsza lub równa zeru, nie jest wyświetlana, ale pozostawia miejsce dla niej (nie wierzę, że jest to możliwe, 6jest najbliżej osiągnięcia zera) .
• Końcowe spacje są dozwolone.
• Szerokość każdego budynku musi wynosić 2.
• Twój wkład może być z wejścia standardowego lub zakodowany w programie.
• Twój program musi być pełnym programem , bez żadnych funkcji.
• Twój program musi mieć możliwość tworzenia 4-15 wersji. 0-3 i liczby ujemne nie są potrzebne i nie są określone, aby cokolwiek robić, co oznacza, że ​​mogą zgłaszać błąd, drukować śmieci lub nic nie robić.

CJam, 68 66 58 55 bajtów

To na razie za długo. Ale początek.

ri:K"!;tK"206b4b<{S5*a*"+--+ "a:I+K)2/)"|  | "e]I+}%zN*

AKTUALIZACJA: Teraz twarde kodowanie dla wejść do 15 zamiast obliczania przesunięcia. Sugestia Sp3000

Wypróbuj online tutaj

Python 2, 247 245 237 229 bajtów

I=input()
R=range
B=[(-~I/2)-(x%3<1)-(x%5<1)-(x%10<1)-(~all([x%a for a in R(2,x)]or[x==2])+2)for x in R(1,I+1)]
E='+--+'
O=['\n']*I
for r in R(I):
 for h in B:O[r]+=['|  |',' '*4,E][(r==h)+(r>=h)]
print ''.join(O[::-1])+'\n'+E*I

C #, 223 205 bajtów

Wykorzystuje to potrzebę przejścia tylko do 15 budynków.

class P{
    static void Main(string[]a){
        int w=int.Parse(a[0]),
            h=(w+3)/2,
            b,
            x,
            y=-1;
        for(;++y<=h;)
            for(x=-2;++x<w;)
                System.Console.Write(x<0?"\n":(b=y-("012021101211102"[x]&7))<0?"     ":b>0&y<h?"|  | ":"+--+ ");
    }
}

260 bajtów

I bardziej ogólna odpowiedź, która zadziała dla dowolnej liczby budynków.

class P{
    static void Main(string[]a){
        int w=int.Parse(a[0]),
            h=(w+3)/2,
            b,
            x,
            y=-1;
        for(;++y<=h;)
            for(x=-2;++x<w;){
                if(x<1)
                    b=-1;
                else
                    for(b=1;++b<x;)
                        if((x+1)%b<1)break;
                System.Console.Write(x<0?"\n":(b=y-x%3/2-x%5/4-x%10/9-(b<x?0:1))<0?"     ":b>0&y<h?"|  | ":"+--+ ");
            }
    }
}

Python 2, 163 bajty

n=input()
k=-~n/2
for i in range(k+2):
 s="";p=j=1
 while~n+j:a=(j%3<1)+(j%5<1)+(j%10<1)+(p%j<1);s+=" |+  -  - |+   "[(i>=a)+(i in{a,k+1})::3];p*=j*j;j+=1
 print s

Pierwszości sprawdzanie części pożycza @ algorytmu XNOR jest od tutaj .

Jeśli zakodujemy na stałe pierwsze 15 przesunięć, możemy uzyskać 137 bajtów :

n=input()
k=-~n/2
for i in range(k+2):
 s=""
 for j in range(n):a=881740113>>2*j&3;s+=" |+  -  - |+   "[(i>=a)+(i in{a,k+1})::3]
 print s

Zakładam, że końcowe spacje na końcu każdego wiersza są w porządku, ale jeśli pytanie oznaczało końcowe spacje po całym wyjściu, to wynosi +9 bajtów .rstrip().

Groovy, 234 , 225 , 223 219 bajtów

Nadużywanie limitu 15 budynków

b=args[0]as int
m={n->(n!=2&(2..n-1).any{n%it==0}?1:0)+([3,5,10].sum{n%it==0?1:0})}
(9..0).each{println((1..b).collect{d=((b/2)as int)+1-m(it);(0..9).collect{it!=d&it!=0?it<d?"|  |":"    ":"+--+"}}*.get(it).join(" "))}

Szybki, 375 , 350 bajtów

import Darwin;let(B,u,z,d)=(4.0,1.0,0.0,2.0);let H=ceil(B/d);func p(n:Double)->Double{var D=d;while D<n{if n%D==0{return 1};D++};return n==1 ?1:0};for var h=z;h<H+2;h++ {for var b=u;b<=B;b++ {var m=b%3==0 ?u:z+b%5==0 ?1:0;m=min(2,b%10==0 ?m+1:m);m += p(b);if h<m {print("     ")}else if h==H+1||h==m {print("+--+ ")}else{print("|  | ")}};print("\n")}

Oto kod wcięcia

import Darwin
let(B,u,z,d)=(4.0,1.0,0.0,2.0)
let H=ceil(B/d)
func p(n:Double)->Double{
     var D=d
    while D<n{
        if n%D==0{
            return 1
        }
        D++
    }
    return n==1 ?1:0
}
for var h=z;h<H+2;h++ {
    for var b=u;b<=B;b++ {
        var m=b%3==0 ?u:z+b%5==0 ?1:0
        m=min(2,b%10==0 ?m+1:m)
        m += p(b)
        if h<m {
            print("     ")
        }
        else if h==H+1||h==m {
            print("+--+ ")
        }
        else{
            print("|  | ")
        }
    }
    print("\n")
}

B zawiera liczbę budynków.
pzwraca 1, gdy liczba nie jest liczbą pierwszą.

Muszę zaimportować Foundation, aby móc korzystać z ceil funkcji.

Nie udało mi się zoptymalizować kodu tylko dla piętnastu przypadków, ale w końcu zrobię to później.

edycja: Biorąc porady @Kametrixom i optymalizuj modczęść (zapomniałem skrócić długość nazwy zmiennej ).