Gracias a FryAmTheEggman por la idea de esta segunda versión.
Versión 1 aquí .

Desafío no tan simple: dada una cantidad de cartas, construye la mayor casa de cartas que puedas con esa cantidad de cartas, de acuerdo con el siguiente orden de construcción:

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

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

Entonces comienza con una casa de una sola planta, luego construye el grupo adyacente, luego coloca la tarjeta de puente, luego construye el grupo en el segundo piso, luego comienza a construir grupos y puentes desde el primer piso en diagonal para llegar al tercer piso, y así en.

Una sola tarjeta se representará con a /, a \o a --. Si después de usar tantas cartas como sea posible, le queda una, simplemente envíe lo que ha logrado hasta ahora (vea el ejemplo para 3 cartas, el resultado es el mismo que para 2 cartas). La única excepción es el caso de 1 tarjeta, que debe generar una tarjeta plana.

Ejemplos:

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:

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

La entrada puede ser numérica o una cadena, y siempre será un número entero positivo. La salida debe ser exactamente como se muestra, con espacios iniciales y finales y líneas nuevas permitidas.

Este es el código de golf , ¡así que puede ganar el programa / función más corto para cada idioma!

Carbón , 67 bytes

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

Pruébalo en línea! Nota: La última versión de Charcoal no necesita el »«de -2 bytes. Explicación:

Ｎθ

Lea la entrada como un entero en θ.

⁼θ¹

Caso especial: si la entrada es 1, imprima a -.

Ａ²ηＷ¬‹θη«

η representa el número de tarjetas necesarias para construir la siguiente capa, inicialmente 2. Un bucle while se repite siempre que haya suficientes tarjetas para la capa.

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

Imprime la mitad izquierda de la siguiente capa. (Quería imprimir la mitad derecha, pero no pude hacer que se refleje correctamente por alguna razón). El número de -s es un tercio del número de tarjetas en la capa, redondeado hacia abajo. (Véase también mi respuesta a la parte 1.)

Ａ⁻θηθＡ⁺³ηη»

Reste el número de tarjetas del número de entrada y agregue tres tarjetas al número requerido para la siguiente capa.

‖Ｍ

Refleja la casa hasta ahora. (Esto también lo convierte -en --el caso de 1 carta).

Ｍ÷η³→

Mueve el cursor a la derecha de la casa.

Ｆθ

Repita para cada tarjeta restante (si la hay).

≡﹪鳦

Si la tarjeta módulo 3 es:

¹«↗←\/»

1, luego imprime un par de cartas;

²«↑Ｐ²»

2, luego imprima una tarjeta horizontal;

«

De lo contrario, omita la tarjeta (porque se necesita un par en este punto).

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

Explicación (versión 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)

Pruébalo en línea!

• Esto se siente innecesariamente largo, pero no puedo ver nada que eliminar en este momento ... siéntase libre de comentar cualquier sugerencia

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

Pruébalo en línea!