Biorąc pod uwagę jedną dodatnią nieparzystą liczbę całkowitą jako dane wejściowe, zwróć zbieżny zygzak jako listę ciągów, listę znaków lub ciąg oddzielony znakiem nowej linii w następującej formie:

#
 #
  #
   #
    #
   #
  #
 #
  #
   #
  #

Możesz zastąpić #dowolną spójną spacją. Końcowe białe znaki w każdej linii są dozwolone i dozwolona jest nowa linia końcowa.

Zygzak zaczyna się od kolumny 1i dla każdego wiersza przesuwa się w prawo o jedną kolumnę, aż do kolumny n(gdzie njest wejście). Następnie przesuwa się w lewo do 2, następnie w prawo do n-1, a następnie w lewo do 3z dwoma zbiegającymi się granicami, aż zygzak kończy się w środkowej kolumnie ( (n+1)/2).

Przypadki testowe

Powyższy przykład to przypadek testowy dla 5.

Poniżej przedstawiono indywidualne przypadki testowe:

3
#
 #
  #
 #

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

1

#

C (gcc) , 89 bajtów

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);}

Wypróbuj online!

Działa poprzez analizę sekwencji liczby spacji jako (dla n = 7):

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

A dla n = 3:

  0
1 2 1

Widzimy, że środkowa liczba ( aw kodzie) biegnie od [n-1, n / 2). Następnie różnica między pierwszą liczbą a liczbą środkową wynosi:

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

Tak więc, jeśli bprzejdziemy przez [- (2a-n), 2a-n], a-abs(b)da nam pożądaną sekwencję. Zasadniczo to robi kod.

Węgiel drzewny , 10 8 bajtów

ＦＮ«↗ι‖»/

Wypróbuj online! Link jest do pełnej wersji kodu. Edycja: Zaoszczędziłem 2 bajty dzięki @dzaima za wskazanie, że nie muszę używać #s.

Python 2 , 78 bajtów

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

Wypróbuj online!

Galareta , 14 bajtów

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

Wypróbuj online!

Pełny program

Używa 1 .

-1 dzięki Jonathan Allan .
-1 dzięki Jonathan Allan .

Haskell , 72 bajty

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

Wypróbuj online!

Definiujemy nieskończoną listę rbędącą przekątną #s zaczynającą się od lewego górnego rogu.

Następnie definiujemy funkcję g która wykonuje ciężar pracy. gpobiera listę i wielokrotnie ją odwraca i usuwa pierwszy element, aż lista będzie pusta, a następnie konkatenuje wynik każdej akcji.

Naszą główną funkcją jest tutaj funkcja bez punktów. Ta funkcja zaczyna się od pobrania nelementów z nieskończonej listy r, następnie przycina pierwszy element i stosuje się g. Na koniec musimy #cofnąć się do początku, ponieważ specyfikacja pytania jest trochę dziwna, nie jestem pewien, dlaczego pierwsza przekątna jest zawsze dłuższa niż powinna, ale tak jest, więc musimy dodaj aa #.

SOGL V0.12 , 19 bajtów

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

Wypróbuj tutaj!

05AB1E , 22 bajty

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

Wypróbuj online!

Zastosowania8 .

05AB1E , 6 bajtów

LN71SΛ

Wypróbuj online!

     Λ     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 bajtów

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

Wypróbuj online!

Zastosowania8 .

Pyth, 23 bajty

8JStQKdVQjbm+*\ d8J=_PJ

Wypróbuj tutaj.

JavaScript, 127 bajtów

Oblicza cel ( g) do osiągnięcia. Po osiągnięciu tego celu przejdź do następnego celu. Używa także sztuczki, której należy unikać Math.round(), dodając 0.5do każdej nierównej liczby.

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 bajty

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

Wypróbuj online!

Jak to działa:

    [(' '<$[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

Każde wywołanie rekurencyjne fdołącza następną przekątną.

Łuska , 19 bajtów

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

Wypróbuj online!

Wyjaśnienie

To trochę niezręczne.

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.

Python 3 , 82 bajty

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

Wypróbuj online!

Retina , 71 bajtów

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

Wypróbuj online! Objaśnienie: Pierwsze trzy etapy przekształcają dane wejściowe na postać, w :> :której liczba znaków między :s jest liczbą wejściową. Ostatnie dwa etapy następnie odbijają >(lub <, przy ruchu w lewo) między :s. Czwarty etap zapętla odbicie, za każdym razem drukując wymagane części sznurka. ;Zatrzymuje ciąg znaków jest wydrukowany po pętli.

05AB1E , 16 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

K (Kona), 27 bajtów

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

Tworzy bazową sekwencję numeryczną poprzez wielokrotne odwracanie i upuszczanie główki wektora, aż będzie pusty.

PHP, 65 bajtów

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

Uruchom jako potok -nFlub przetestuj go online .

wyjaśnienie:

pierwsza iteracja: $njest NULL, więc --$nnie ma wpływu i ocenia na NULL
-> set $ni $dna wstępnie zmniejszoną wartość argumentu
1. przyrost $xparzysty $d, spadek nieparzysty $d
2. druk X, nowy wiersz i$x spacje

dalsze iteracje: dekrementacja $n; gdy trafi 0, zresetuj $n(i $d) do wstępnie zmniejszonego argumentu

finał: wydrukuj jeszcze jeden X.

Japt , 31 bajtów

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

Rozwiązanie rekurencyjne, które zwraca tablicę wierszy.

Wypróbuj online! używając -Rflagi do łączenia wyników z nowymi liniami.

Python 2, 159 145 141 136 bajtów

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

Ten problem był już całkiem niezły w Pythonie, ale pomyślałem, że nadal będę publikować moją okropną wersję jedno-liniową. (Bez średników!)

Edycja: 14 bajtów w dół, używając sumy zamiast podwójnej listy

Edycja: Zauważyłem w Pythonie 2, że możesz używać danych wejściowych zamiast raw_input. Zawsze używałem tego drugiego.

Mathematica, 142 102 bajty (niezależne)

To rozwiązanie ma mathowy smak:

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

To w zasadzie oblicza, w którym odcinku się znajdujemy (odwracając funkcję liczby trójkątnej), a następnie przesuwa się w lewo lub w prawo, dodając moc -1.

Możesz go przetestować w piaskownicy kodu Wolfram , wklejając kod jak UnitVector[#,1-Sum[(-1)^Floor[#+1/2-Sqrt[9/4+#*#-#-2x]],{x,k}]]~Table~{k,0,#(#-1)/2}/.{0->" ",1->"X"}&@6//MatrixFormi naciskając Shift + Enter lub Numpad Enter lub klikając Gear -> „Oceń komórkę”.

Zdarza się, że ma taką samą długość jak mój oryginalny niepoprawny port rozwiązania Erik's Python 2 (ten port daje wynik dla wejścia o jeden wyższy):

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