Étant donné un seul entier impair positif en entrée, renvoyez un zigzag convergent sous forme de liste de chaînes, liste de listes de caractères ou chaîne séparée par des sauts de ligne, sous cette forme:

#
 #
  #
   #
    #
   #
  #
 #
  #
   #
  #

Vous pouvez remplacer #par n'importe quel caractère non blanc cohérent. Les espaces de fin sur chaque ligne sont autorisés et les retours à la ligne de fin sont autorisés.

Le zig-zag commence à la colonne 1et pour chaque ligne se déplace vers la droite d'une colonne, jusqu'à ce qu'il atteigne la colonne n(où nest l'entrée). Ensuite, il se déplace de gauche à 2, puis de droite à n-1, puis de gauche à 3, avec les deux bornes convergeant jusqu'à ce que le zigzag se termine dans la colonne du milieu ( (n+1)/2).

Cas de test

L'exemple ci-dessus est le cas de test pour 5.

Voici des cas de test individuels:

3
#
 #
  #
 #

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

1

#

C (gcc) , 89 octets

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

Essayez-le en ligne!

Fonctionne en analysant la séquence du nombre d'espaces comme (pour n = 7):

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

Et pour n = 3:

  0
1 2 1

Nous pouvons voir que le nombre du milieu ( adans le code) va de [n-1, n / 2). Ensuite, la différence entre le premier nombre et le nombre du milieu est:

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

Donc, si nous btraversons [- (2a-n), 2a-n], a-abs(b)nous donnerons la séquence souhaitée. C'est essentiellement ce que fait le code.

Fusain , 10 8 octets

ＦＮ«↗ι‖»/

Essayez-le en ligne! Le lien est vers la version détaillée du code. Edit: enregistré 2 octets grâce à @dzaima pour avoir souligné que je n'ai pas à utiliser #s.

Python 2 , 78 octets

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

Essayez-le en ligne!

Gelée , 14 octets

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

Essayez-le en ligne!

Programme complet.

Les usages 1 .

-1 merci à Jonathan Allan .
-1 merci à Jonathan Allan .

Haskell , 72 octets

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

Essayez-le en ligne!

Nous définissons une liste infinie rétant la diagonale de #s à partir du coin supérieur gauche.

On définit ensuite une fonction g qui fait le gros du travail. gprendra une liste et l'inversera à plusieurs reprises et supprimera son premier élément jusqu'à ce que la liste soit vide, puis concaténera le résultat de chaque action.

Notre fonction principale ici est une fonction sans point. Cette fonction commence par prendre des néléments de la liste infinie r, puis coupe le premier élément et applique g. Enfin, nous devons ajouter un #retour au début, c'est parce que les spécifications de la question sont un peu bizarres, je ne sais pas pourquoi la première diagonale est toujours une plus longue qu'elle ne devrait l'être, mais c'est le cas, nous devons donc ajoutez aa #.

SOGL V0.12 , 19 octets

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

Essayez-le ici!

05AB1E , 22 octets

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

Essayez-le en ligne!

Utilise8 .

05AB1E , 6 octets

LN71SΛ

Essayez-le en ligne!

     Λ     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 octets

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

Essayez-le en ligne!

Utilise8 .

Pyth, 23 octets

8JStQKdVQjbm+*\ d8J=_PJ

Essayez-le ici.

JavaScript, 127 octets

Calcule l'objectif ( g) à atteindre. Lorsque cet objectif est atteint, retournez-vous au prochain objectif. Utilise également une astuce pour éviter d'utiliser Math.round()en ajoutant 0.5à chaque nombre inégal.

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 octets

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

Essayez-le en ligne!

Comment ça marche:

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

Chaque appel récursif fajoute la diagonale suivante.

Husk , 19 octets

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

Essayez-le en ligne!

Explication

Cela semble un peu maladroit.

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 octets

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

Essayez-le en ligne!

Rétine , 71 octets

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

Essayez-le en ligne! Explication: Les trois premières étapes convertissent l'entrée en la forme :> :où le nombre de caractères entre les :s est le numéro d'entrée. Les deux dernières étapes font ensuite rebondir le >(ou <, en se déplaçant vers la gauche) entre le :s. La quatrième étape boucle le rebond, imprimant à chaque fois les parties requises de la chaîne. Le ;empêche la chaîne d'être imprimée après la boucle.

05AB1E , 16 octets

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

Essayez-le en ligne!

Explication

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

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

Produit la séquence numérique sous-jacente en inversant et en laissant tomber la tête d'un vecteur jusqu'à ce qu'elle soit vide.

PHP, 65 octets

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

Exécuter en tant que pipe avec -nFou tester en ligne .

explication:

première itération: $nest NULL, donc --$nn'a aucun effet et est évaluée à NULL
-> set $net $dà l'argument pré-décrémenté
1. incrémenter $xpour pair $d, décrémenter pour impair$d
2. imprimerX , une nouvelle ligne et des $xespaces

itérations supplémentaires: décrément $n; quand il frappe 0, réinitialiser$n (et$d ) à l'argument pré-décrémenté

finale: imprimez-en une de plus X.

Japt , 31 octets

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

Solution récursive qui renvoie un tableau de lignes.

Essayez-le en ligne! en utilisant le -Rdrapeau pour joindre la sortie aux sauts de ligne.

Python 2, 159 145 141 141 136 octets

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

Il y a déjà eu des versions assez sympas de Python à ce problème mais je pensais que je posterais toujours mon horrible one-liner. (Mais sans point-virgule!)

Modifier: 14 octets vers le bas, en utilisant la somme au lieu de la compréhension de la double liste

Edit: Juste remarqué en python 2, vous pouvez utiliser l'entrée au lieu de raw_input. J'ai toujours utilisé ce dernier.

Mathematica, 142 102 bytes (independent)

Cette solution a une saveur mathématique:

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

Cela calcule essentiellement le segment dans lequel nous nous trouvons (en inversant la fonction de nombre triangulaire), puis en se déplaçant vers la gauche ou la droite en ajoutant une puissance de -1.

Vous pouvez le tester sur le Wolfram Code Sandbox en collant le code comme UnitVector[#,1-Sum[(-1)^Floor[#+1/2-Sqrt[9/4+#*#-#-2x]],{x,k}]]~Table~{k,0,#(#-1)/2}/.{0->" ",1->"X"}&@6//MatrixFormet en appuyant sur Maj + Entrée ou Entrée du pavé numérique ou en cliquant sur Gear -> "Evaluer la cellule".

Cela se trouve être de la même longueur que mon port incorrect d'origine de la solution Python 2 d' Erik (ce port donne la sortie pour une entrée plus élevée):

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