Agradecemos a FryAmTheEggman pela ideia para esta segunda versão.
Versão 1 aqui .

Desafio não tão simples: dado um número de cartas, construa o maior castelo de cartas possível com esse número, de acordo com a seguinte ordem de construção:

                          /\       /\         /\         /\/\
                 --       --       --         ----       ----
/\  →  /\/\  →  /\/\  →  /\/\  →  /\/\/\  →  /\/\/\  →  /\/\/\  →

                /\         /\
     --         --         --
    /\/\       /\/\       /\/\
    ----       ----       ----
→  /\/\/\  →  /\/\/\  →  /\/\/\/\  →  ...

Então, você começa com uma casa de um andar, constrói o grupo adjacente, coloca a placa da ponte, constrói o grupo no segundo andar, começa a construir grupos e pontes do primeiro andar na diagonal para alcançar o terceiro andar, e assim em.

Um único cartão será representado com a /, a \ou a --. Se, depois de usar o maior número possível de cartões, você tiver apenas um, basta imprimir o que você realizou até o momento (veja o exemplo de 3 cartões, o resultado é o mesmo que para 2 cartões). A única exceção é o caso de 1 cartão, que deve gerar um cartão plano.

Exemplos:

Input: 1
Output: 

--   <a card lying on the floor>

Input: 2
Output:

/\

Input: 3
Output:

/\

Input: 5
Output:

 --
/\/\

Input: 10
Output:

 /\
 ----
/\/\/\

Input: 20
Output:

  /\
  --
 /\/\/\
 ------
/\/\/\/\

Input: 39
Output:

    --
   /\/\
   ----
  /\/\/\
  ------
 /\/\/\/\
 --------
/\/\/\/\/\

Input: 40
Output:

    /\
    --
   /\/\
   ----
  /\/\/\
  ------
 /\/\/\/\
 --------
/\/\/\/\/\

A entrada pode ser numérica ou uma sequência e sempre será um número inteiro positivo. A saída deve ser exatamente como mostrada, com espaços à esquerda e à direita e novas linhas permitidas.

Isso é código-golfe , portanto, pode ganhar o programa / função mais curto para cada idioma!

Carvão , 67 bytes

Ｎθ⁼θ¹Ａ²ηＷ¬‹θη«←÷η³↓→/…\/÷η³↙Ａ⁻θηθＡ⁺³ηη»‖ＭＭ÷η³→Ｆθ≡﹪鳦¹«↗←\/»²«↑Ｐ²»«

Experimente online! Nota: A versão mais recente do Charcoal não precisa »«de -2 bytes. Explicação:

Ｎθ

Leia a entrada como um número inteiro em θ.

⁼θ¹

Caso especial: se a entrada for 1, imprima a -.

Ａ²ηＷ¬‹θη«

η representa o número de cartões necessários para construir a próxima camada, inicialmente 2. Um loop while se repete enquanto houver cartões suficientes para a camada.

←÷η³↓→/…\/÷η³↙

Imprima a metade esquerda da próxima camada. (Eu queria imprimir a metade certa, mas não consegui que ela refletisse corretamente por algum motivo.) O número de -s é um terço do número de cartões na camada, arredondados para baixo. (Veja também minha resposta à parte 1.)

Ａ⁻θηθＡ⁺³ηη»

Subtraia o número de cartões do número de entrada e adicione três cartões ao número necessário para a próxima camada.

‖Ｍ

Espelhe a casa até agora. (Isso também transforma o -em --para o caso de um cartão.)

Ｍ÷η³→

Mova o cursor para a direita da casa.

Ｆθ

Repita para cada cartão restante (se houver).

≡﹪鳦

Se o módulo de cartão 3 for:

¹«↗←\/»

1 e depois imprima um par de cartões;

²«↑Ｐ²»

2 e, em seguida, imprima um cartão horizontal;

«

Caso contrário, pule a carta (porque um par é necessário neste momento).

Python 2 , 167 182 bytes

167 bytes

f=lambda x,y=0:y<x<2and"--"or~-x>y*3and f(x-2-y*3,y+1)or d(y,x)
d=lambda h,r,v=0:h and d(~-h,max(r-3,1),-~v)+" "*-~v+"--"*(h-(r<3))+"\n"+" "*v+"/\\"*(h+(r>1))+"\n"or""

182 bytes

f=lambda x,y=0:[x>1+y*3and f(x-2-y*3,y+1)or d(y,x),"--"][2>x>y]
d=lambda h,r,v=0:d(h-1,r-3*(r>2)-2*(r==2),v+1)+" "*(v+1)+"--"*(h-1+(r>2))+"\n"+" "*v+"/\\"*(h+(r>1))+"\n"if h+r else""

Explicação (versão de 167 bytes)

f=lambda x,y=0:
    "--" if y<x<2         # handle case where x is 1 on step 0 (only one card) 
    else f(x-2-y*3,y+1)   # recursive call with one full triangular level accounted for
    if x>= 2+y*3          # one full level requires 2+3y cards (2, 7, 15...)
    else d(y,x)           # if no more full levels can be constructed, draw
d=lambda h,r,v=0:         # (h)eight to draw, (r)emaining cards, (v)ertical height already drawn (to determine leading white space)
    d(h-1,          ,v+1) # recursive call to draw upper lines
          max(r-3,1)      # subtract remainder cards used in this iteration
    +" "*(v+1)            # leading whitespace for -- row
    +"--"*(       )+"\n"  # -- line. 
           h-(r<3)        # horizontal card count is equal to the remaining count of levels to draw, minus 1, 
                          # ...plus 1 if there are at least three remaining cards to add to the right
    +" "*v                # leading whitespace for /\ row
    +"/\\"*(       )+"\n" # /\ line
            h+(r>1)       # vertical card pair count equals remaining level count
                          # ...plus 1 if there are at least two extra cards
    if h                  # return above is there are levels to draw (h) 
    else ""               # else return nothing (ends recursion)

Experimente online!

• Parece desnecessariamente longo, mas não vejo nada para remover no momento ... fique à vontade para comentar qualquer sugestão

Perl 5 , 129 bytes

@r=($_=<>-2)<0?'--':'/\\';while($_>1){$#r+=2;$i=0;$r[$i].=$i++%2?'--':'/\\'while$i<@r&&($_-=2-$i%2)>=0}say$"x(@r/2).pop@r while@r

Experimente online!