Dado um único número inteiro ímpar positivo positivo como entrada, retorne um ziguezague convergente como uma lista de cadeias, lista de listas de caracteres ou cadeia de caracteres separada por nova linha, desta forma:

#
 #
  #
   #
    #
   #
  #
 #
  #
   #
  #

Você pode substituir #por qualquer caractere que não seja um espaço em branco consistente. O espaço em branco à direita em cada linha é permitido e uma nova linha à direita é permitida.

O zig-zag começa na coluna 1e, para cada linha, move uma coluna para a direita, até atingir a coluna n(onde nestá a entrada). Em seguida, ele se move para a esquerda 2, depois para a direita e para a n-1esquerda 3, com os dois limites convergindo até o zigue-zague terminar na coluna do meio ( (n+1)/2).

Casos de teste

O exemplo acima é o caso de teste para 5.

A seguir, são casos de teste individuais:

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

Experimente online!

Trabalha analisando a sequência do número de espaços como (para n = 7):

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

E para n = 3:

  0
1 2 1

Podemos ver que o número do meio ( ano código) é executado a partir de [n-1, n / 2). Então, a diferença entre o primeiro número e o número do meio é:

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

Portanto, se passarmos bpor [- (2a-n), 2a-n], a-abs(b)nos fornecerá a sequência desejada. Isso é essencialmente o que o código faz.

Carvão , 10 8 bytes

ＦＮ«↗ι‖»/

Experimente online! Link é a versão detalhada do código. Edit: Salvo 2 bytes graças a @dzaima por apontar que não preciso usar #s.

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]

Experimente online!

Gelatina , 14 bytes

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

Experimente online!

Programa completo.

Usos 1.

-1 graças a Jonathan Allan .
-1 graças a Jonathan Allan .

Haskell , 72 bytes

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

Experimente online!

Definimos uma lista infinita rcomo a diagonal de #s começando no canto superior esquerdo.

Em seguida, definimos uma função gque faz o peso do trabalho. gpegará uma lista e a reverterá repetidamente e removerá seu primeiro elemento até que a lista esteja vazia e concatenará o resultado de cada ação.

Nossa função principal aqui é uma função sem ponto. Essa função começa pegando nelementos da lista infinita r, depois corta o primeiro elemento e aplica-se g. Por último, precisamos adicionar um #retorno ao início, porque as especificações da pergunta são um pouco estranhas, não sei por que a primeira diagonal é sempre uma mais longa do que deveria, mas é, então precisamos adicione aa #.

SOGL V0.12 , 19 bytes

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

Experimente aqui!

05AB1E , 22 bytes

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

Experimente online!

Usos 8.

05AB1E , 6 bytes

LN71SΛ

Experimente 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*

Experimente online!

Usos 8.

Pitão, 23 bytes

8JStQKdVQjbm+*\ d8J=_PJ

Experimente aqui.

JavaScript, 127 bytes

Calcula a meta ( g) para chegar. Quando esse objetivo for alcançado, vire-se para o próximo objetivo. Também usa um truque para evitar o uso Math.round()adicionando 0.5a todos os números desiguais.

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

Experimente online!

Como funciona:

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

Cada chamada recursiva facrescenta a próxima diagonal.

Casca , 19 bytes

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

Experimente online!

Explicação

Isso parece um pouco desajeitado.

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)

Experimente online!

Retina , 71 bytes

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

Experimente online! Explicação: Os três primeiros estágios convertem a entrada no formato em :> :que o número de caracteres entre os :é o número de entrada. Os dois últimos estágios retornam >(ou <, ao mover para a esquerda) entre os :s. O quarto estágio dá laços no salto, imprimindo as partes necessárias da corda a cada vez. O ;pára a cadeia de ser impresso após o loop.

05AB1E , 16 bytes

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

Experimente online!

Explicação

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

Produz a sequência numérica subjacente, revertendo e soltando repetidamente a cabeça de um vetor até ficar vazia.

PHP, 65 bytes

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

Execute como tubo -nFou teste-o online .

explicação:

primeira iteração: $nis NULL, portanto --$nnão tem efeito e avalia como NULL
-> definir $ne $dpré-decrementar o argumento
1. incremento $xpara par $d, decremento para ímpar $d
2. impressão X, uma nova linha e $xespaços

iterações adicionais: decremento $n; quando for atingido 0, redefina $n(e $d) o argumento pré-decrementado

final: imprima mais uma X.

Japonês , 31 bytes

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

Solução recursiva que retorna uma matriz de linhas.

Experimente online! usando o -Rsinalizador para unir a saída às novas linhas.

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

Já houve versões bastante agradáveis ​​do Python para esse problema, mas eu pensei que ainda publicaria minha péssima linha. (Sem ponto e vírgula!)

Editar: 14 bytes abaixo, usando soma em vez de compreensão de lista dupla

Edit: Acabei de notar no python 2 que você pode usar input em vez de raw_input. Eu sempre usei o último.

Mathematica, 142 102 bytes (independente)

Esta solução tem um sabor matemático:

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

Isso basicamente calcula em qual segmento estamos (invertendo a função numérica triangular) e depois movendo para a esquerda ou para a direita adicionando uma potência de -1.

Você pode testá-lo na Wolfram Code Sandbox colando código como UnitVector[#,1-Sum[(-1)^Floor[#+1/2-Sqrt[9/4+#*#-#-2x]],{x,k}]]~Table~{k,0,#(#-1)/2}/.{0->" ",1->"X"}&@6//MatrixForme pressionando Shift + Enter ou Numpad Enter ou clicando em Gear -> "Evaluate Cell".

Isso tem o mesmo comprimento que a minha porta incorreta original da solução Python 2 do Erik (essa porta fornece a saída para uma entrada mais alta):

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