Перший завершений попередником куб Ascii (PAC 1) - це простий куб довжиною сторони 1 і виглядає так:

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

ПКК 2 являє собою геометричну форму таким чином, що його поєднання з його попередником (The PAC 1 ) завершує довжина сторони куба 2:

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

Оскільки задній огляд є дещо нудним, нас цікавить лише перегляд спереду .

Те ж саме стосується PAC 3 : з деяким візуальним мисленням PAC 2 можна повернути і підключити до PAC 3, щоб утворити суцільний кут довжиною 3 куба:

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

І так з PAC 4 :

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

Завдання:

Напишіть повну програму або функцію, яка приймає натуральне число n як вхідне і повертає або друкує відповідний вид спереду PAC n точно так, як показано вище. Допустимий додатковий простір білого кольору.

Це код-гольф , тому намагайтеся використовувати якомога менше байтів мовою, яку ви обрали.

JavaScript (ES6), 229 байт

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>

Пакетна, 559 432 400 байт

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

Пояснення: нижню половину куба малюють, відбиваючи верхню половину. Далі половинки розбиваються на сім шість три частини смужки , як показано на цій схемі, що показує верхню половину:

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. Відступ (який зменшує кожен рядок) і лівий трикутник, який збільшує кожен інший ряд
2. Середній скорочується зигзагоподібний трикутник, з невеликим трикутником по чергових сторонах кожен інший ряд
3. Правий трикутник, який збільшується синхронно з лівим

Редагувати. Збережено понад 20% за рахунок покращення коду, який відображав верхню до нижньої половини. Збережено майже 10%, об’єднавши ліву дві та середні три смужки.

Полотно , 36 байт

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

Спробуйте тут!

SOGL V0.12 , 32 байти

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

Спробуйте тут!

Просте пояснення:
1. повторіть для кожного з 1..x
2. зробіть ⌐форму з шириною i*4+1та висотою = (0-indexed)i // 2
3. накладіть її так, щоб вона виглядала як ⦧
4. додайте форму "\" до горизонталі
5. вставіть попередній крок всередині того, що перевернуто 6. після всього, дзеркально вертикально

повна програма:

ø                                 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 байт

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

Анонімна функція в останньому рядку бере цілий аргумент і дає рядки для друку для куба такого розміру.

Ідея полягає у використанні рекурсії для отримання більших кубів з менших. Давайте подивимося на верхню половину куба розміром 1. Потім ми отримаємо верхню половину куба розміром 2, відобразивши попередню половину і додамо фіксований зразок косої риски та пробіли навколо неї:

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

Отже алгоритм намалювати куб розміром n є

1. Отримайте лінії для верхньої половини куба розміром n-1 .
2. Дзеркало кожної лінії (перегортаючи /s і \s), та накладку ////та \навколо.
3. Додайте два рядки з малюнком ////ⁿ плюс /\і / \.
4. Дзеркало отриманих ліній, щоб отримати повний куб.
5. Лінії прокладки з відповідною кількістю пробілів.

Рубі , 174 167 169 167 байт

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

Спробуйте в Інтернеті!

створює масив n*4рядків, заповнених пробілами, потім перезаписує їх послідовно меншими кубиками.

Коментований код

->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 байт

Нарешті суб 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])))

Прийоми:

Ця функція використовується для обміну все \з /і навпаки
трохи довго в python2 - працює тільки з юнікод
Виїзд це за те, як він працює

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

Створює нові верхні два ряди для кожної ітерації.
Зараз я не можу знайти компактний спосіб отримання цих рядків із попередньої ітерації

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

Зворотно поверніть всі рядки попередньої ітерації та підкачки

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

Скопіюйте верхню половину, перевернуту на рядки, поміняйте місцями нахили

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

Акуратний метод для центральної оббивки пасмами

l.center(8*n)

Спробуйте в Інтернеті!

Стакс , 36 байт

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

Запустіть і налагоджуйте його

Цей підхід ітераційно формує верхню половину результату. Він виконує основний блок заданої кількості разів. У цьому блоці кожен рядок відображається з дзеркальним відображенням та додає префікс та суфікс. Два останніх рядки додаються окремо. Коли всі рядки побудовані, вони розташовуються по центру, а потім дзеркально відображається вертикально.

Ось програму розпаковують, не розгортають і коментують.

{               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

Виконати цей

Haskell, 193 байт

Довше переможця, але підхід може бути цікавим - використовує навіть cosі pi:)

Код:

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

Виконайте це так:

mapM_ putStrLn (f 4)

Ця програма в основному 'малює' багато алмазів, як цей:

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

Функція i s e f'малює' один діамант розміром s, де e, fзнаходяться (abs$z-y)(abs$z+y-1).

Функція wпереміщує алмази, намальовані i на правильні місця. headВикористовуваний у його визначенні відповідальний за перегляд лише самого верхнього шару.

Спробуйте тут

Вугілля деревне , 42 байти

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення:

ＦＮ«

Намалюйте кубики від найменшого до найбільшого. (Малюнок від найбільшого до найменшого означав, що я закінчив дзеркальне зображення для непарних чисел, які коштують занадто багато байтів для виправлення.)

↗×⊗⊕ι/

Роздрукуйте рядок /s. (Це стане \s s справа, але малюнок виконано дзеркально, тому що це гольфіст для дзеркала в кінці циклу.)

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

Роздрукуйте два верхні ряди \s. (Намалювання всіх \s в одному полігоні означало, що курсор опинився в незручному положенні, яке коштувало занадто багато байтів для виправлення.)

Ｇ←⁴↘⊕⊗ι→⁴\

Роздрукуйте ліві чотири ряди \s. (П'ятий ряд походить від попереднього куба.)

Ｍ⁴→

Перехід до початку наступного куба.

‖Ｔ»

Відбийте горизонтально готовий для наступного куба.

‖Ｍ↓

Дзеркало все вертикально, щоб завершити куб.