Der erste vom Vorgänger fertiggestellte Ascii-Würfel (PAC 1) ist ein einfacher Würfel mit der Seitenlänge 1 und sieht folgendermaßen aus:

 /////\
/////  \
\\\\\  /
 \\\\\/

Der PAC 2 hat eine geometrische Form, sodass durch die Kombination mit seinem Vorgänger (dem PAC 1 ) ein Würfel der Seitenlänge 2 entsteht:

      front                back
   /////////\           /////////\
  /////////  \         /////////  \
 /////\\\\\   \       /////////    \
/////  \\\\\   \     /////////      \
\\\\\  /////   /     \\\\\\\\\      /
 \\\\\/////   /       \\\\\\\\\    /
  \\\\\\\\\  /         \\\\\\\\\  /
   \\\\\\\\\/           \\\\\\\\\/

Da die Rückseite -Blick irgendwie langweilig ist, sind wir nur im Interesse Front -Blick.

Gleiches gilt für den PAC 3 : Mit einigem visuellen Denken kann der PAC 2 gedreht und in den PAC 3 eingesteckt werden , um einen festen Würfel mit Seitenlänge 3 zu bilden:

     /////////////\
    /////////////  \
   /////\\\\\\\\\   \
  /////  \\\\\\\\\   \
 /////   /////\\\\\   \
/////   /////  \\\\\   \
\\\\\   \\\\\  /////   /
 \\\\\   \\\\\/////   /
  \\\\\  /////////   /
   \\\\\/////////   /
    \\\\\\\\\\\\\  /
     \\\\\\\\\\\\\/

Und so weiter mit PAC 4 :

       /////////////////\
      /////////////////  \
     /////\\\\\\\\\\\\\   \
    /////  \\\\\\\\\\\\\   \
   /////   /////////\\\\\   \
  /////   /////////  \\\\\   \
 /////   /////\\\\\   \\\\\   \
/////   /////  \\\\\   \\\\\   \
\\\\\   \\\\\  /////   /////   /
 \\\\\   \\\\\/////   /////   / 
  \\\\\   \\\\\\\\\  /////   /
   \\\\\   \\\\\\\\\/////   /
    \\\\\  /////////////   /
     \\\\\/////////////   /
      \\\\\\\\\\\\\\\\\  /
       \\\\\\\\\\\\\\\\\/

Aufgabe:

Schreiben Sie ein vollständiges Programm oder eine vollständige Funktion, die eine positive ganze Zahl n als Eingabe verwendet und die entsprechende Vorderansicht von PAC n genau wie oben gezeigt zurückgibt oder ausgibt . Zusätzliches Leerzeichen am Ende ist zulässig.

Das ist Code-Golf , also versuchen Sie, so wenig Bytes wie möglich in der Sprache Ihrer Wahl zu verwenden.

JavaScript (ES6), 229 Byte

f=
(n,l=n*4+1,r=1,i=n*2,g=a=>` / \\ /
`.replace(/./g,c=>c.repeat(a.pop())))=>n?g([r,,l,--i])+g([r,2,l,--i])+f(n-1,l-1?1:r-4,r-1?1:l-4).replace(/(\S).*(.)/g,r-1?`$1   $&$2$2$2$2`:`$1$1$1$1$&   $2`)+g([r,2,l,,,i])+g([r,,l,,,i+1]):``

<input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o>

Batch, 559 432 400 Bytes

@echo off
set m=
for /l %%i in (1,1,%1)do call set m=  %%m%%
call:c "%m:~2%" %m: =//%/\
exit/b
:c
setlocal
set m=%~1%2%~3
echo  %m%
echo %m:/\=/  \%
set s=%~1
if "%s:~,1%"=="/" goto g
set t=%2
set t=%t:~3,-3%
if %t:~,1%==/ (call:c "%s:~2%////" /\%t:/=\% "   \%~3")else call:c "%s:~2%/   " %t:\=/%/\ "\\\\%~3"
:g
set m=%m:/=-%
set m=%m:\=/%
set m=%m:-=\%
echo %m:\/=\  /%
echo  %m%

Erläuterung: Die untere Hälfte des Würfels wird durch Spiegelung der oberen Hälfte gezeichnet. Die Hälften sind weiter in sieben, sechs und drei Streifenteile unterteilt, wie in diesem Diagramm gezeigt, das die obere Hälfte zeigt:

1       12/////////////////\233
1      12/////////////////  \233
1     ////12/\\\\\\\\\\\\\23   \3
1    ////12/  \\\\\\\\\\\\\23   \3
1   /////   12/////////\23\\\\   \3
1  /////   12/////////  \23\\\\   \3
1 /////   ////12/\\\\\23   \\\\\   \3
1/////   ////12/  \\\\\23   \\\\\   \3

1. Der Einzug (der jede Zeile verkleinert) und das linke Dreieck, das jede zweite Zeile vergrößert
2. Das mittlere schrumpfende Zick-Zack-Dreieck, wobei sich das kleine Dreieck in jeder zweiten Reihe abwechselt
3. Das rechte Dreieck, das sich synchron mit dem linken vergrößert

Bearbeiten: Mehr als 20% gespart durch Verbesserung des Codes, der die obere bis untere Hälfte widerspiegelt. Einsparung von fast 10% durch Zusammenführen der linken zwei und mittleren drei Streifen.

Canvas , 36 Bytes

；Ｘø；｛１ｘ／╋
ø╶｛«５⁸２²４×⁸²«１╋²«＼＋；↔５３╋｝═

Probieren Sie es hier aus!

SOGL V0.12 , 32 Bytes

ø.∫4*I└*2∙f«5└*∙+¼F«╝┼;↔±53╬5}╬±

Probieren Sie es hier aus!

Einfache Erklärung:
1. Iterierte für jede 1..x
2. Stellen Sie eine ⌐Form mit der Breite i*4+1und Höhe = (0-indexed)i // 2
3. pad es so aussieht wie es ⦧
4. append a „\“ -Form auf , die horizontal
5. Setzen der vorherigen Schritt in diesem umgekehrten 6. nach allem vertikal spiegeln

Volles Programm:

ø                                 push an empty string - starting stage
 .∫                          }    iterate over 1..input
   4*                               multiply the 1-indexed counter by 4
     I                              and add 1
      └*                            repeat "/" that many times
        2∙                          and repeat vertically twice. Top 2 lines are done
          f«                        push the 0-indexed counter floor divided by 2
            5└*                     push "/" repeated 5 times
               ∙                    and repeat that vertically by the result of the "f«"
                +                   add vertically, creating a "⌐" shape
                 ¼                  prepend each next line with one less space than the above
                  F«                push 1-indexed counter floor divided by 2
                    ╝               create a "\" diagonal that long
                     ┼              and append it horizontally. Shell is done of this hexagon
                      ;↔±           get the previous item on the stack and reverse it horizontally
                         53╬5       and at [5;3] insert the previous result in this
                              ╬±  once everything's done, mirror vertically to finish the hexagon

Haskell , 232 227 224 187 183 180 175 Bytes

m '/'='\\'
m '\\'='/'
m c=c
r=reverse
k=map
n?s=('/'<$[1..4*n])++s
f 0=[]
f n=n?"/\\":n?"/  \\":[1?k m(r s)++"   \\"|s<-f$n-1]
s="":k(' ':)s
((++).r<*>k(k m)).zipWith(++)s.r.f

Die anonyme Funktion in der letzten Zeile verwendet ein ganzzahliges Argument und gibt die Zeilen an, die für einen Würfel dieser Größe gedruckt werden sollen.

Die Idee ist, mithilfe der Rekursion größere Würfel aus kleineren zu ziehen. Schauen wir uns die obere Hälfte eines Würfels der Größe 1 an. Dann erhalten wir die obere Hälfte eines Würfels der Größe 2, indem wir die vorherige Hälfte spiegeln und ein festes Muster aus Schrägstrichen und Leerzeichen hinzufügen:

                                         ///////// \
                                        ///////// \
     ///// \ ==> / \\\\\ ==> //// / \\\\\    \
    ///// \ / \\\\\ //// / \\\\\    \

Der Algorithmus zum Zeichnen eines Würfels der Größe n lautet also

1. Holen Sie sich die Linien für die obere Würfelhälfte der Größe n-1 .
2. Spiegeln Sie jede Zeile (durch Umdrehen von /s und \s) und füllen Sie ////und \um.
3. Stellen Sie zwei Zeilen mit dem Muster ////ⁿ plus /\und voran / \.
4. Spiegeln Sie die resultierenden Linien, um den vollen Würfel zu erhalten.
5. Zeilen mit der entsprechenden Anzahl von Leerzeichen auffüllen.

Ruby , 174 167 169 167 Bytes

->n{a=(1..m=n*4).map{' '*m}
(-n..0).map{|i|(-2*i).times{|k|a[y=k+2*j=n+i][m+~k+i*2,2+k*2-s=4*i]=?/*(1-~j%2*s)+'  '*k+?\\*(1-j%2*s)
a[~y]=a[y].tr('/\\','\\\\/')}}
a*$/}

Probieren Sie es online!

Erstellt eine Reihe von n*4Zeichenfolgen, die mit Leerzeichen gefüllt sind, und überschreibt sie dann mit immer kleineren Würfeln.

Kommentierter Code

->n{a=(1..m=n*4).map{' '*m}                 #make an array of n*4 strings of n*4 spaces (up to centreline of final output)
  (-n..0).map{|i|                           #iterate through cube sizes from n down to 0 (i is negative -n to 0)
    (-2*i).times{|k|                        #iterate through the number of lines in the top half of the cube
      a[y=k+2*j=n+i][m+~k+i*2,2+k*2-s=4*i]= #overwrite the correct part of the correct line
      ?/*(1-~j%2*s)+'  '*k+?\\*(1-j%2*s)    #with the correct string of the form "/spaces\" with an additional -4*i symbols on one side
      a[~y]=a[y].tr('/\\','\\\\/')          #copy the current line from top half into bottom half, subsituting / for \ and vice versa
    }
  }
a*$/}                                       #return the elements of the array a, concatenated with newlines $/

Python 2 , 254 234 226 203 201 199 Bytes

Endlich unter 200!

P=[];n=0
M=lambda r:(u''+r).translate({47:92,92:47})
exec r"n+=1;q='/'*4;P=[q*n+'/\\',q*n+'/  \\']+[q+'%s   \\'%M(r[::-1])for r in P];"*input()
print'\n'.join(l.center(8*n)for l in(P+map(M,P[::-1])))

Tricks:

Diese Funktion Swap verwendet wird , alle \mit /und umgekehrt
ein bisschen lang in Python2 - funktioniert nur mit Unicode -
Check out diese , wie es funktioniert

M=lambda r:(u''+r).translate({47:92,92:47})

Erzeugt neue oberste zwei Zeilen für jede Iteration
. Derzeit kann ich keine kompakte Möglichkeit finden, diese Zeilen aus der vorherigen Iteration zu erhalten

P=[q*n+'/\\',q*n+'/  \\']

Kehren Sie alle Zeilen der vorherigen Iteration um und tauschen Sie Schrägstriche aus

[q+'%s   \\'%M(r[::-1])for r in P]

Kopieren Sie die obere Hälfte in umgekehrter Reihenfolge und tauschen Sie die Schrägstriche aus

P+map(M,P[::-1])

Gepflegte Methode zum Auffüllen von Saiten in der Mitte

l.center(8*n)

Probieren Sie es online!

Stax , 36 Bytes

äª.$u>↓Z╙╝B↨EXª¡╜?Xáhç∙╩p/♂ù⌠r↨c⌐f/*

Führen Sie es aus und debuggen Sie es

Dieser Ansatz baut die obere Hälfte der Ausgabe iterativ auf. Der Hauptblock wird so oft ausgeführt, wie angegeben. In diesem Block wird jede Zeile gespiegelt und mit einem Präfix und einem Suffix versehen. Die beiden obersten neuen Zeilen werden separat hinzugefügt. Wenn alle Zeilen erstellt sind, werden sie zentriert und der Boden vertikal gespiegelt.

Hier ist das Programm entpackt, ungolfed und kommentiert.

{               begin block to repeat
  iHYH^H'\*     make a string of '\' characters and set the Y register
                  pseudo-code: push(((y = (i * 2)) * 2 + 1) * 2 * '\')
                  given the 0-based iteration index `i`, let y = 2 * i
                  and push a string consisting of (i*8 + 2) backslashes
  2M            split the string into to equal size (i*4 + 1) substrings
  ~+            push array to input stack and concatenate
                  on the first iteration, this is a no-op
                  subsequently, it prepends the array to the result so far
  {             begin a block to use for mapping
    4'\*+       append 4 backslashes to this element
    :R          "brace-wise" reverse
                  this reverses the string AND the slashes in it
    |YH3+92&    write 92 to index (++y * 2 + 3) in the array
                  this puts the trailing backslash at the correct position
                  this will be an out of bounds index, so the string will grow
                  92 is the character code for backslash 
  m             execute map using block
}*              repeat block specified number of times
|C              vertically center all rows
{               begin block for output mapping
  Q             output this line without popping
  :Rr           "brace-wise" reverse, and then actually reverse
                  net effect is to swap forward and backward slashes
m               execute map using block
rm              reverse array, and output all rows

Führen Sie dieses aus

Haskell, 193 Bytes

Länger als der Gewinner, aber der Ansatz kann interessant sein - verwendet sogar cosund pi:)

Code:

i s e f|max e f>s=""|max e f<s=" "|e==s="\\"|1<2="/"
w n y x=head$do{d<-[1..n];o<-[-2*d..2*d];z<-[(cos(pi*(n-d)))*o+x];i(2*d)(abs$z-y)(abs$z+y-1)}++" "
n!h=h<$>[1-2*n..2*n]
f n=((2*n)!)<$>n!w n

Führen Sie es so aus:

mapM_ putStrLn (f 4)

Dieses Programm 'zeichnet' im Grunde viele Diamanten wie diesen:

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

Funktion i s e f'zeichnet' einen Diamanten der Größe s, wo e, fsind (abs$z-y)(abs$z+y-1).

Die Funktion wbewegt die gezogenen Diamanten i , um Stellen zu korrigieren. headIn seiner Definition wird nur die oberste Ebene betrachtet.

Probieren Sie es hier aus

Holzkohle , 42 Bytes

ＦＮ«↗×⊗⊕ι/↓↘Ｇ↖²→⊕×⁴⊕ι↘²\Ｇ←⁴↘⊕⊗ι→⁴\Ｍ⁴→‖Ｔ»‖Ｍ↓

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

ＦＮ«

Zeichne die Würfel vom kleinsten zum größten. (Das Zeichnen vom Größten zum Kleinsten bedeutete, dass ich ein Spiegelbild für ungerade Zahlen erhielt, deren Behebung zu viele Bytes kostete.)

↗×⊗⊕ι/

Drucken Sie eine Zeile mit /s. (Dies wird das \s auf der rechten Seite sein, aber die Zeichnung wird gespiegelt ausgeführt, da es am Ende der Schleife besser ist, sie zu spiegeln.)

↓↘Ｇ↖²→⊕×⁴⊕ι↘²\

Drucken Sie die oberen beiden Reihen von \s. (Das Zeichnen aller \s in einem Polygon bedeutete, dass sich der Cursor an einer unangenehmen Position befand, deren Behebung zu viele Bytes kostete.)

Ｇ←⁴↘⊕⊗ι→⁴\

Drucken Sie die linken vier Zeilen von \s. (Die fünfte Reihe stammt aus dem vorherigen Würfel.)

Ｍ⁴→

Gehe zum Anfang des nächsten Würfels.

‖Ｔ»

Horizontal spiegeln, bereit für den nächsten Würfel.

‖Ｍ↓

Spiegele alles vertikal, um den Würfel zu vervollständigen.