Le premier cube Ascii terminé par un prédécesseur (PAC 1) est un cube simple dont la longueur du côté est 1 et se présente comme suit:

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

Le PAC 2 est une forme géométrique telle que sa combinaison avec son prédécesseur (le PAC 1 ) complète un cube de côté 2:

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

Parce que la vision arrière est assez ennuyeuse, nous ne sommes intéressés que par la vue de face .

Il en va de même pour le CIP 3 : avec quelques réflexions visuelles, le CIP 2 peut être retourné et branché au CIP 3 pour former un cube de 3 cm de côté solide:

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

Et ainsi de suite avec PAC 4 :

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

Tâche:

Ecrivez un programme complet ou une fonction qui prend un entier positif n en entrée et renvoie ou affiche la vue de face correspondante de PAC n exactement comme indiqué ci-dessus. Un espace blanc de fuite supplémentaire est acceptable.

C'est du code-golf , alors essayez d'utiliser le moins d'octets possible dans la langue de votre choix.

JavaScript (ES6), 229 octets

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>

Lot, 559 432 400 octets

@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%

Explication: La moitié inférieure du cube est dessinée en reflétant la moitié supérieure. Les moitiés sont ensuite divisées en sept six trois bandes , conformément à ce diagramme représentant la moitié supérieure:

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. L'indentation (qui diminue chaque ligne) et le triangle de gauche, qui augmente chaque ligne
2. Le triangle de zigzag qui rétrécit au milieu, avec le petit triangle sur les côtés alternés tous les deux rangs
3. Le triangle rectangle, qui augmente en synchronisation avec le gauche

Edit: Economisé plus de 20% en améliorant le code qui reflétait le haut vers le bas. Épargné de près de 10% en fusionnant les bandes de deux et trois médianes.

Toile , 36 octets

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

Essayez-le ici!

SOGL V0.12 , 32 octets

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

Essayez-le ici!

Explication simple:
1. Effectuez
une itération pour chacun des éléments 1..x 2. Créez une ⌐forme avec la largeur i*4+1et la hauteur = (0-indexed)i // 2
3. Remplissez-la de manière à ce qu'elle ressemble à ⦧
4. ajoutez une forme "\" à celle-ci horizontalement
5. insérez l'étape précédente à l'intérieur de ce 6. inversé après tout, miroir verticalement

programme complet:

ø                                 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 180 175 octets

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

La fonction anonyme dans la dernière ligne prend un argument entier et génère les lignes à imprimer pour un cube de cette taille.

L'idée est d'utiliser la récursivité pour dessiner des cubes plus gros à partir de petits. Regardons la moitié supérieure d'un cube de taille 1. Ensuite, nous obtenons la moitié supérieure d'un cube de taille 2 en reflétant l'ancienne moitié et en ajoutant un motif fixe de barres obliques et d'espaces autour de lui:

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

Donc, l'algorithme pour dessiner un cube de taille n est

1. Obtenez les lignes pour la moitié supérieure du cube de taille n-1 .
2. Miroir chaque ligne (en retournant /s et \s), pad ////et \autour.
3. Ajoutez deux lignes avec le motif ////ⁿ plus /\et / \.
4. Mettez en miroir les lignes résultantes pour obtenir le cube complet.
5. Lignes de pavé avec le nombre approprié d'espaces.

Ruby , 174 167 169 167 octets

->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*$/}

Essayez-le en ligne!

crée un tableau de n*4chaînes remplies d'espaces, puis le remplace par des cubes de plus en plus petits.

Code commenté

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

Enfin sous 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])))

Des trucs:

Cette fonction est utilisée pour échanger toutes \avec /et vice versa
un peu long en python2 - fonctionne uniquement avec unicode
Découvrez ce pour la façon dont cela fonctionne

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

Génère de nouvelles deux premières lignes pour chaque itération
Pour l'instant, je ne trouve pas de moyen compact de recevoir ces lignes de l'itération précédente.

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

Inverser toutes les lignes de l'itération précédente et échanger les barres obliques

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

Copier la moitié supérieure, inversée par des lignes, permuter les barres obliques

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

Méthode soignée pour les chaînes de rembourrage central

l.center(8*n)

Essayez-le en ligne!

Stax , 36 octets

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

Exécuter et déboguer

Cette approche construit la moitié supérieure de la sortie de manière itérative. Il exécute le bloc principal le nombre de fois spécifié. Dans ce bloc, chaque ligne est mise en miroir et son préfixe et son suffixe sont ajoutés. Les deux premières lignes sont ajoutées séparément. Lorsque toutes les lignes sont construites, elles sont centrées, puis le bas est mis en miroir verticalement.

Voici le programme déballé, non-golfé et commenté.

{               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

Exécuter celui-ci

Haskell, 193 octets

Plus long que le gagnant, mais l'approche peut être intéressante - utilise même coset 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

Exécutez-le comme ceci:

mapM_ putStrLn (f 4)

Ce programme "dessine" de nombreux diamants comme celui-ci:

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

La fonction i s e f"dessine" un diamant de taille s, où e, fsont (abs$z-y)(abs$z+y-1).

Fonction wdéplace les diamants tirés par i pour corriger les lieux. headutilisé dans sa définition est chargé d'examiner uniquement la couche la plus élevée.

Essayez-le ici

Charbon de bois , 42 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

ＦＮ«

Dessine les cubes du plus petit au plus grand. (Dessiner du plus grand au plus petit signifiait que je me retrouvais avec une image en miroir pour les nombres impairs qui coûtait trop d'octets à corriger.)

↗×⊗⊕ι/

Imprimer une ligne de /s. (Cela deviendra le \s sur la droite, mais le dessin est fait en miroir car il est plus golfeur de refléter à la fin de la boucle.)

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

Imprimer les deux premières lignes de \s. (Dessiner tous les \s dans un polygone signifiait que le curseur se retrouvait dans une position inconfortable, ce qui coûtait trop d'octets à réparer.)

Ｇ←⁴↘⊕⊗ι→⁴\

Imprimer les quatre rangées de gauche de \s. (La cinquième ligne provient du cube précédent.)

Ｍ⁴→

Déplacer au début du prochain cube.

‖Ｔ»

Réfléchis horizontalement, prêt pour le prochain cube.

‖Ｍ↓

Miroir tout verticalement pour compléter le cube.