Первый завершенный предшественником куб 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, отразив предыдущую половину и добавив фиксированный узор косых черт и пробелов вокруг нее:

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

Таким образом, алгоритм рисовать куб из размера п является

1. Получите линии для верхней половины куба размера n-1 .
2. Зеркально отразите каждую строку (перелистывая /s и \s), а также pad ////и \вокруг.
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)

Попробуйте онлайн!

Stax , 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. (Пятый ряд взят из предыдущего куба.)

Ｍ⁴→

Перейти к началу следующего куба.

‖Ｔ»

Отражение по горизонтали готово к следующему кубу.

‖Ｍ↓

Зеркально отразите все вертикально, чтобы завершить куб.