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

#
 #
  #
   #
    #
   #
  #
 #
  #
   #
  #

Ви можете замінити #будь-яким послідовним символом, який не є пробілом. Доступний пробіл пробілів у кожному рядку та дозволений останній рядок.

Зигзаг починається з стовпця 1і для кожного рядка рухається праворуч на один стовпець, доки він не досягне стовпця n(де nвхід). Потім він рухається ліворуч 2, потім праворуч n-1, потім ліворуч 3, при цьому два межі сходяться до тих пір, поки зигзаг не закінчиться в середній колоні ( (n+1)/2).

Випробування

Наведений вище приклад - тестовий випадок для 5.

Далі є окремі тестові випадки:

3
#
 #
  #
 #

7
#
 #
  #
   #
    #
     #
      #
     #
    #
   #
  #
 #
  #
   #
    #
     #
    #
   #
  #
   #
    #
   #

1

#

C (gcc) , 89 байт

f(n,a,b){puts("0");for(a=n;--a>n/2;)for(b=n-2*a;b<=2*a-n;)printf(" %*d\n",a-abs(b++),0);}

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

Працює, аналізуючи послідовність числа пробілів як (для n = 7):

          0
1 2 3 4 5 6 5 4 3 2 1
    2 3 4 5 4 3 2
        3 4 3

А для n = 3:

  0
1 2 1

Ми можемо бачити, що середнє число ( aу коді) походить від [n-1, n / 2). Тоді різниця між першим числом і середнім числом:

a  n  b  2a-n
-------------
6  7  5  5
5  7  3  3
4  7  1  1
2  3  1  1

Отже, якщо ми bпроходимо через [- (2a-n), 2a-n], a-abs(b)дамо нам бажану послідовність. Це по суті те, що робить код.

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

ＦＮ«↗ι‖»/

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Редагувати: Збережено 2 байти завдяки @dzaima за вказівку, що мені не потрібно використовувати #s.

Python 2 , 78 байт

l=range(1,input())
print 8
for i in l:
 for i in l:print' '*i+'8'
 l=l[-2::-1]

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

Желе , 14 байт

ṖṖṚ$ÐĿẎ0;⁶ẋp1Y

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

Повна програма.

Використання 1.

-1 завдяки Джонатану Аллану .
-1 завдяки Джонатану Аллану .

Haskell , 72 байти

g[]=[]
g a=a++g(reverse$init a)
r="#":map(' ':)r
("#":).g.tail.(`take`r)

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

Ми визначаємо нескінченний список, rякий є діагоналлю #s, що починається з верхнього лівого кута.

Потім ми визначаємо функцію, gяка виконує основний обсяг роботи. gвізьме список і кілька разів поверне його назад і видалить його перший елемент, поки список не буде порожнім, а потім з'єднає результат кожної дії.

Наша основна функція тут - безтокова функція. Ця функція починається, беручи nелементи з нескінченного списку r, потім відбиває перший елемент і застосовується g. Нарешті, ми маємо додати #назад до початку, це тому, що характеристики цього питання трохи дивні, я не впевнений, чому перша діагональ завжди на одну довшу, ніж повинна бути, але так, ми маємо додати аа #.

SOGL V0.12 , 19 байт

┘.»∫«I╝:±jk+jl0;±Iž

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

05AB1E , 22 байти

i8ë<LZFD¨R})˜0¸ìε8sú}»

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

Використання 8.

05AB1E , 6 байт

LN71SΛ

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

     Λ     use the canvas function with

L          a range list [1 .. input] as lengths for each path 

 N         a "0" as character to be printed 
           (N is the index variable used by loops. If there was no loop yet, its
           default value is 0. By using N, I avoid an extra space between 0 and 71)

  71S      and the directions 7 and 1 (NW and NE), that alternate automatically until
           the range list is finished.

CJam , 29 байт

ri,(;_,{_);W%}*]e_0\+Sf*8f+N*

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

Використання 8.

Pyth, 23 байти

8JStQKdVQjbm+*\ d8J=_PJ

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

JavaScript, 127 байт

Обчислює мету ( g), щоб дістатися. Коли ця мета буде досягнута, поверніться до наступної мети. Також використовує трюк, щоб уникнути використання Math.round(), додаючи 0.5до кожного нерівного числа.

f=n=>{c=0;for(i=0;i<n;i++){m=i/2;g=i%2==0?n-m:m+1.5;while(c!=g){c>g?c--:c++;console.log(' '.repeat(c-1)+'#'+' '.repeat(n-c))}}}

f=n=>{c=0;for(i=0;i<n;i++){m=i/2;g=i%2==0?n-m:m+1.5;while(c!=g){c>g?c--:c++;console.log(' '.repeat(c-1)+'#'+' '.repeat(n-c))}}}

f(5);

Haskell, 74 байти

f[x]=[x]
f s=s++tail(f$reverse$tail s)
g n=f[(' '<$[2..x])++"#"|x<-[1..n]]

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

Як це працює:

    [(' '<$[2..x])++"#"|x<-[1..n]]     -- build the first diagonal, e.g. for n=3:
                                         -- ["#", " #", "  #"]
  f                                      -- call f, which is

f s = s ++                               -- the input list, followed by
           tail                          -- all but the first element of
                f                        -- a recursive call with
                  reverse                -- the reverse of
                          tail s         -- all but the first element of the input 
                                         -- list
f[x]=[x]                                 -- base case: stop if the input list a
                                         -- singleton list

Кожен рекурсивний дзвінок fдодає наступну діагональ.

Лушпиння , 19 байт

mo`:'#R' ∫`Ṙ¢e1_1tṫ

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

Пояснення

Це відчуває себе трохи незграбно.

mo`:'#R' ∫`Ṙ¢e1_1tṫ  Input is n (e.g. 5)
                  ṫ  Range from input to 1: [5,4,3,2,1]
                 t   Drop first element: [4,3,2,1]
             e1_1    The list [1,-1]
            ¢        repeated infinitely: [1,-1,1,-1,..
          `Ṙ         Clone with respect to the list above: [1,1,1,1,-1,-1,-1,1,1,-1]
         ∫           Cumulative sum: [0,1,2,3,4,3,2,1,2,3,2]
mo                   For each element k (e.g. 3) do this:
      R'             Repeat space k times: "   "
  `:'#               Append '#': "   #"
                     Print implicitly separated by linefeeds.

Пітон 3 , 82 байти

def z(n):l=range(1,n);print(8);exec("[print(' '*i+'8')for i in l];l=l[-2::-1];"*n)

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

Сітківка , 71 байт

.+
$* 
^
:>
 $
:
;{*T`:<>`_#
( ) >(:)|( )<
$1<$2$3
(:)( )<|>( )
$2$1$3>

Спробуйте в Інтернеті! Пояснення: Перші три етапи перетворюють вхід у форму, :> :де число символів між :s є вхідним номером. Останні два етапи потім відскакують >(або <, рухаючись ліворуч) між :s. Четвертий етап замикає відмов, друкуючи необхідні частини рядка кожен раз. ;Зупиняє рядок з друкується після циклу.

05AB1E , 16 байт

Î<L¤F¦})˜Ôð×X«»

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

Пояснення

Î<L               # push 0 and range [1 ... input-1]
   ¤              # get the last element of the list
    F             # that many times do
     Â            # bifurcate
      ¦           # remove the head
       })˜        # end loop and wrap in flattened list
          Ô       # remove consecutive duplicates
           ð×     # repeat space a number of times corresponding to each number in the list
             X«   # append 1 to each
               »  # join on newline

К (Кона), 27 байт

`0:{|x$"#"}'1,,/{1_|x}\-2-!

Створює нижню числову послідовність шляхом багаторазового перевертання і опускання головки вектора до порожнього.

PHP, 65 байт

<?while(--$n||$n=$d=--$argn)echo str_pad("X
",2+$x-=$d&1?:-1);?>X

Запустити як трубу -nFабо випробувати його в Інтернеті .

пояснення:

Перша ітерація: $nє NULL, тому --$nне має ефекту і оцінює на NULL
-> встановлення $nта $dпопередньо зменшений аргумент
1. приріст $xдля парного $d, зменшення для непарного $d
2. друку X, нового рядка та $xпробілів

подальші ітерації: декремент $n; коли він потрапляє 0, скидайте $n(і $d) на попередньо зменшений аргумент

фінал: надрукуйте ще один X.

Japt , 31 байт

Ç+V ç +QÃê ¯-2 c´U?ß´UVÄ :Vç +Q

Рекурсивне рішення, яке повертає масив рядків.

Спробуйте в Інтернеті! використовуючи -Rпрапор для приєднання виводу з новими рядками.

Python 2, 159 145 141 136 байт

print"".join([" "*p+"#\n"for p in(lambda l:[sum(l[:i])for i in range(len(l))])(sum([i*[1-i%2*2]for i in range(input())[::-1]],[])+[1])])

У цій проблемі вже були досить приємні версії Python, але я подумав, що все-таки викладу свій жахливий однокласник. (Хоча без крапки з комою!)

Редагувати: 14 байт вниз, використовуючи суму замість розуміння подвійного списку

Редагувати: Щойно помічено в python 2, ви можете використовувати введення замість raw_input. Я завжди просто використовував останнє.

Mathematica, 142 102 байти (незалежно)

Цей розчин має матовий аромат:

UnitVector[#,1-Sum[(-1)^Floor[#+1/2-Sqrt[9/4+#*#-#-2x]],{x,k}]]~Table~{k,0,#(#-1)/2}/.{0->" ",1->"X"}&

Це в основному обчислює, в якому сегменті ми знаходимося (шляхом перевертання функції трикутного числа), а потім переміщення вліво або вправо, додаючи потужність -1.

Ви можете перевірити його на коробці Wolfram Code , вставивши такий код, як UnitVector[#,1-Sum[(-1)^Floor[#+1/2-Sqrt[9/4+#*#-#-2x]],{x,k}]]~Table~{k,0,#(#-1)/2}/.{0->" ",1->"X"}&@6//MatrixFormі натиснути Shift + Enter або Numpad Enter або натиснути Gear -> "Оцінити клітинку".

Це буває такої ж довжини, як і мій оригінальний неправильний порт рішення Erik's Python 2 (Цей порт дає вихід на вхід на один вище):

(Print[X];l=Range@#;Do[Do[Print[StringRepeat[" ",l[[j]]]<>"X"],{j,Length@l}];l=l[[-2;;1;;-1]],{i,#}])&