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

O povo de ASCIIville está reconstruindo sua cidade e desenhando novas plantas. Seu trabalho é desenhar a nova cidade com base em quantos prédios eles querem.

A entrada será quantos edifícios existem. Cada edifício é metade da altura da entrada (arredondado para cima, se for ímpar), sem incluir a parte superior e inferior do edifício.

Vamos desenhar um exemplo básico de 4

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

Como você pode ver aqui, existem dois |s em cada edifício porque a entrada era quatro. Mas há um problema! (o exemplo acima está incorreto e o exemplo na parte superior desta postagem é a saída real de 4)

Para cada edifício que não é um número primo, sua altura diminui um. Se o número é divisível por 3 , 5 ou 10 , diminui mais um. Se é divisível por dois ou mais desses números, o valor deduzido aumenta ( 10 é divisível por 10 e 5, e não é primo, por isso é deduzido por 3 ).

Vejamos um exemplo com uma entrada de 5.

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

Aqui está um exemplo de 7

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

E um exemplo de 10

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

E de volta para 6

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

Regras:

• Se um número é deduzido tanto que sua altura é menor ou igual a zero, ele não é mostrado, mas resta um espaço para ele (não acredito que isso seja possível, 6é o mais próximo que encontrei de chegar a zero) .
• Espaços à direita são permitidos.
• A largura de cada edifício deve ser 2.
• Sua entrada pode ser do stdin ou codificada no programa.
• Seu programa deve ser um programa completo , sem funções.
• Seu programa deve ser capaz de 4-15 compilações. Números 0-3 e negativos não são necessários e não são especificados para fazer nada, o que significa que eles podem gerar um erro, imprimir lixo ou não fazer nada.

CJam, 68 66 58 55 bytes

Isso é muito longo por enquanto. Mas um começo.

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

ATUALIZAÇÃO: Agora codifique as entradas até 15 em vez de calcular o deslocamento. Sugestão de Sp3000

Experimente online aqui

Python 2, 247245237229 bytes

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 bytes

Isso tira proveito da necessidade de ir apenas para 15 edifícios.

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 bytes

E uma resposta mais genérica que funcionará para qualquer número de edifícios.

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 bytes

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

A parte de verificação da primalidade empresta o algoritmo do @ xnor a partir daqui .

Se codificarmos as 15 primeiras compensações, podemos obter 137 bytes :

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

Estou assumindo espaços à direita no final de cada linha, mas se a pergunta significa espaços à direita após toda a saída, são +9 bytes para .rstrip().

Groovy, 234 , 225 , 223 219 bytes

Abusando do limite de 15 prédios

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

Swift, 375 , 350 bytes

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

Aqui está o código recuado

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

Bcontém o número de edifícios.
pretorna 1 quando um número não é primo.

Preciso importar o Foundation para usar a ceilfunção.

Não consegui otimizar o código apenas para os quinze casos, mas acabarei fazendo isso mais tarde.

edit: Tomando conselhos @Kametrixom e otimizar a modpeça (eu esqueci de reduzir o comprimento do nome var).