Bei einer positiven ungeraden Ganzzahl als Eingabe wird ein konvergierender Zickzack als Liste von Zeichenfolgen, Liste von Zeichenlisten oder durch Zeilenumbrüche getrennte Zeichenfolge in der folgenden Form zurückgegeben:

#
 #
  #
   #
    #
   #
  #
 #
  #
   #
  #

Sie können durch ein #beliebiges konsistentes Zeichen ohne Leerzeichen ersetzen . Leerzeichen in jeder Zeile dürfen nachgestellt werden, und ein Zeilenumbruch ist zulässig.

Der Zick-Zack beginnt bei der Spalte 1und bewegt sich für jede Zeile um eine Spalte nach rechts, bis die Spalte erreicht ist n(wo nist die Eingabe). Dann bewegt es sich nach links 2, dann nach rechts n-1und dann nach links 3, wobei die beiden Begrenzungen zusammenlaufen, bis der Zickzack in der mittleren Spalte endet ( (n+1)/2).

Testfälle

Das obige Beispiel ist der Testfall für 5.

Es folgen einzelne Testfälle:

3
#
 #
  #
 #

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

1

#

C (gcc) , 89 Bytes

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

Probieren Sie es online!

Analysiert die Folge der Anzahl der Leerzeichen wie folgt (für n = 7):

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

Und für n = 3:

  0
1 2 1

Wir können sehen, dass die mittlere Zahl ( aim Code) von [n-1, n / 2] läuft. Dann ist der Unterschied zwischen der ersten und der mittleren Zahl:

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

Wenn wir also b[- (2a-n), 2a-n] durchlaufen haben a-abs(b), erhalten wir die gewünschte Sequenz. Dies ist im Wesentlichen das, was der Code tut.

Kohle , 10 8 Bytes

ＦＮ«↗ι‖»/

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Edit: 2 Bytes gespart dank @dzaima für den Hinweis, dass ich kein #s verwenden muss.

Python 2 , 78 Bytes

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

Probieren Sie es online!

Jelly , 14 Bytes

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

Probieren Sie es online!

Volles Programm.

Verwendet 1.

-1 Danke an Jonathan Allan .
-1 Danke an Jonathan Allan .

Haskell , 72 Bytes

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

Probieren Sie es online!

Wir definieren eine unendliche Liste rals die Diagonale von #s beginnend in der oberen linken Ecke.

Wir definieren dann eine Funktion, gdie den Hauptteil der Arbeit erledigt. gNimmt eine Liste und kehrt sie wiederholt um und entfernt ihr erstes Element, bis die Liste leer ist. Verketten Sie dann das Ergebnis jeder Aktion.

Unsere Hauptfunktion ist hier eine punktfreie Funktion. Diese Funktion beginnt mit der Übernahme von nElementen aus der unendlichen Liste r, schneidet dann das erste Element und wird angewendet g. Als letztes müssen wir #dem Anfang ein Zurück hinzufügen , weil die Spezifikationen für die Frage etwas seltsam sind. Ich bin mir nicht sicher, warum die erste Diagonale immer länger ist, als sie sein sollte, aber so ist es, also müssen wir aa hinzufügen #.

SOGL V0.12 , 19 Bytes

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

Probieren Sie es hier aus!

05AB1E , 22 Bytes

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

Probieren Sie es online!

Verwendet 8.

05AB1E , 6 Bytes

LN71SΛ

Probieren Sie es 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 Bytes

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

Probieren Sie es online!

Verwendet 8.

Pyth, 23 Bytes

8JStQKdVQjbm+*\ d8J=_PJ

Probieren Sie es hier aus.

JavaScript, 127 Bytes

Berechnet das zu erreichende Ziel ( g). Wenn dieses Ziel erreicht ist, drehe dich zum nächsten Ziel um. Verwendet auch einen Trick, um die Verwendung zu vermeiden, Math.round()indem 0.5zu jeder ungeraden Zahl hinzugefügt wird.

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 Bytes

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

Probieren Sie es online!

Wie es funktioniert:

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

Bei jedem rekursiven Aufruf fwird die nächste Diagonale angehängt.

Schale , 19 Bytes

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

Probieren Sie es online!

Erläuterung

Das fühlt sich etwas klobig an.

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 Bytes

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

Probieren Sie es online!

Retina , 71 Bytes

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

Probieren Sie es online! Erläuterung: In den ersten drei Schritten wird die Eingabe in die Form konvertiert, in der :> :die Anzahl der Zeichen zwischen den Zeichen :die Eingabenummer ist. Die letzten beiden Stufen hüpfen dann mit dem >(oder <, wenn Sie sich nach links bewegen) zwischen den :s. In der vierten Stufe wird der Sprung wiederholt, wobei jedes Mal die erforderlichen Teile der Zeichenfolge gedruckt werden. Das ;hält die Zeichenfolge nach der Schleife gedruckt wird.

05AB1E , 16 Bytes

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

Probieren Sie es online!

Erläuterung

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

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

Erzeugt die zugrunde liegende numerische Sequenz, indem der Kopf eines Vektors wiederholt umgedreht und abgelegt wird, bis er leer ist.

PHP, 65 Bytes

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

Laufen Sie als Pipe mit -nFoder testen Sie es online .

Erläuterung:

erste Iteration: $nist NULL, --$nhat also keine Auswirkung und wertet NULL
-> setze $nund $ddekrementiere Argument
1. inkrementiere $xfür gerade $d, dekrementiere für ungerade $d
2. Xdrucke, eine neue Zeile und$x Leerzeichen

weitere Iterationen: Dekrementierung $n; Wenn es trifft 0, setzen Sie zurück $n(und$d ) auf das vordekrementierte Argument zurück

Finale: Drucke noch einen X.

Japt , 31 Bytes

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

Rekursive Lösung, die ein Array von Zeilen zurückgibt.

Probieren Sie es online! Verwenden Sie das -RFlag, um die Ausgabe mit Zeilenumbrüchen zu verbinden.

Python 2, 159 145 141 136 Bytes

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

Es gab bereits nette Python-Versionen zu diesem Problem, aber ich dachte, ich würde immer noch meinen schrecklichen Einzeiler posten. (Ohne Semikolon!)

Bearbeiten: 14 Bytes nach unten, wobei die Summe anstelle des doppelten Listenverständnisses verwendet wird

Bearbeiten: Gerade in Python 2 bemerkt, können Sie Eingabe anstelle von raw_input verwenden. Ich habe immer nur Letzteres verwendet.

Mathematica, 142 102 Bytes (unabhängig)

Diese Lösung hat einen mathematischen Geschmack:

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

Dies berechnet im Grunde genommen, in welchem ​​Segment wir uns befinden (durch Invertieren der Dreieckszahlfunktion) und bewegt sich dann nach links oder rechts, indem eine Potenz von -1 addiert wird.

Sie können es in der Wolfram Code Sandbox testen, indem Sie Code wie einfügen UnitVector[#,1-Sum[(-1)^Floor[#+1/2-Sqrt[9/4+#*#-#-2x]],{x,k}]]~Table~{k,0,#(#-1)/2}/.{0->" ",1->"X"}&@6//MatrixFormund Umschalt + Eingabetaste oder Ziffernblock-Eingabetaste drücken oder auf Zahnrad -> "Zelle auswerten" klicken.

Dies ist zufällig die gleiche Länge wie mein ursprünglicher falscher Port von Eriks Python 2-Lösung (Dieser Port gibt die Ausgabe für eine Eingabe um eins höher):

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