Vielen Dank an FryAmTheEggman für die Idee für diese zweite Version.
Version 1 hier .

Nicht ganz so einfache Herausforderung: Bauen Sie bei einer bestimmten Anzahl von Karten das größte Kartenhaus, das Sie können, mit dieser Anzahl von Karten gemäß der folgenden Baureihenfolge:

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

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

Sie beginnen also mit einem einstöckigen Haus, bauen dann die angrenzende Gruppe, legen dann die Brückenkarte ein, bauen dann die Gruppe im zweiten Stock und beginnen dann, Gruppen und Brücken vom ersten Stock diagonal zu bauen, um den dritten Stock zu erreichen, und so weiter auf.

Eine einzelne Karte wird mit a /, a \oder a dargestellt --. Wenn Sie nach der Verwendung so vieler Karten wie möglich nur noch eine Karte übrig haben, geben Sie einfach das aus, was Sie bisher erreicht haben (siehe Beispiel für 3 Karten, das Ergebnis ist das gleiche wie für 2 Karten). Die einzige Ausnahme ist der Fall einer Karte, die eine flache Karte ausgeben muss.

Beispiele:

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:

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

Die Eingabe kann numerisch oder eine Zeichenfolge sein und ist immer eine positive Ganzzahl. Die Ausgabe muss genau wie gezeigt sein, wobei führende und nachfolgende Leerzeichen und Zeilenumbrüche zulässig sind.

Dies ist Code-Golf , also kann das kürzeste Programm / die kürzeste Funktion für jede Sprache gewinnen!

Holzkohle , 67 Bytes

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

Probieren Sie es online aus! Hinweis: Die neueste Version von Charcoal benötigt keine »«-2 Bytes. Erläuterung:

Ｎθ

Lesen Sie die Eingabe als Ganzzahl in θ.

⁼θ¹

Sonderfall: Wenn die Eingabe 1 ist, drucken Sie a -.

Ａ²ηＷ¬‹θη«

η stellt die Anzahl der Karten dar, die zum Erstellen der nächsten Ebene benötigt werden, zunächst 2. Eine while-Schleife wird wiederholt, solange genügend Karten für die Ebene vorhanden sind.

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

Drucken Sie die linke Hälfte der nächsten Ebene. (Ich wollte die rechte Hälfte drucken, konnte sie aber aus irgendeinem Grund nicht richtig wiedergeben.) Die Anzahl der -s ist ein Drittel der Anzahl der Karten in der Ebene, abgerundet. (Siehe auch meine Antwort auf Teil 1.)

Ａ⁻θηθＡ⁺³ηη»

Subtrahieren Sie die Anzahl der Karten von der eingegebenen Nummer und addieren Sie drei Karten zu der Anzahl, die für die nächste Ebene erforderlich ist.

‖Ｍ

Spiegeln Sie das Haus so weit. (Damit wird auch die -in --für den Fall von 1 - Karte.)

Ｍ÷η³→

Bewegen Sie den Cursor rechts neben das Haus.

Ｆθ

Wiederholen Sie dies für jede verbleibende Karte (falls vorhanden).

≡﹪鳦

Wenn die Karte Modulo 3 ist:

¹«↗←\/»

1, dann drucken Sie ein Paar Karten;

²«↑Ｐ²»

2, dann drucken Sie eine horizontale Karte;

«

Andernfalls überspringen Sie die Karte (da zu diesem Zeitpunkt ein Paar benötigt wird).

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

Erläuterung (167-Byte-Version)

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)

Probieren Sie es online aus!

• Das fühlt sich unnötig lang an, aber ich sehe im Moment nichts zu entfernen ... zögern Sie nicht, Vorschläge zu kommentieren

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

Probieren Sie es online aus!