Você receberá um número inteiro positivo Ncomo entrada. Sua tarefa é construir um semi-ziguezague, de Nlados, cada um de comprimento N. Como é relativamente difícil descrever claramente a tarefa, aqui estão alguns exemplos:

• N = 1:

  O
  

• N = 2:

  O
   OO
  

• N = 3:

  OO
   OO
    OOO
  

• N = 4:

  OOOOO
   OO
    OO
     OOOO
  

• N = 5:

  OOOOOO
   OOO
    OOO
     OOO
      OOOOOO
  

• N = 6:

  OOOOOOO
   OOO
    OOO
     OOO
      OOO
       OOOOOOOOOOOO
  

• N = 7:

  OOOOOOOOO
   OOOO
    OOOO
     OOOO
      OOOO
       OOOO
        OOOOOOOOOOOOOO
  

• Um caso de teste maior com N = 9

Como você pode ver, um semi-ziguezague é feito de linhas diagonais e horizontais alternadas e sempre começa com uma linha diagonal do canto superior esquerdo para o inferior direito. Observe que os caracteres nas linhas horizontais são separados por um espaço.

Regras

• Você pode escolher qualquer caractere que não seja um espaço em branco em vez de O, pode até ser inconsistente.

• Você pode gerar / retornar o resultado como uma String ou como uma lista de Strings, cada uma representando uma linha .

• Você pode ter uma nova linha à direita ou à direita.

• Aplicam-se lacunas padrão .

• Você pode receber e fornecer saída por qualquer média padrão .

• Se possível, adicione um link de teste ao seu envio. Votarei qualquer resposta que mostre os esforços no golfe e tenha uma explicação.

• Isso é código-golfe , então o código mais curto em bytes em todos os idiomas vence!

Carvão , 24 bytes

ＦＮ«↶§7117ι×⁺#× ﹪ι²⁻Ｉθ¹»#

Experimente online!

-5 graças a Neil .

AST:

Program
├Ｆ: For
│├Ｎ: Input number
│└Program
│ ├↶: Pivot Left
│ │└§: At index
│ │ ├'7117': String '7117'
│ │ └ι: Identifier ι
│ └Print
│  └×: Product
│   ├⁺: Sum
│   │├'#': String '#'
│   │└×: Product
│   │ ├' ': String ' '
│   │ └﹪: Modulo
│   │  ├ι: Identifier ι
│   │  └2: Number 2
│   └⁻: Difference
│    ├Ｉ: Cast
│    │└θ: Identifier θ
│    └1: Number 1
└Print
 └'#': String '#'

Python 2 , 157 153 bytes

n=input()
o,s=q='O '
def p(k,t=q*n+s*(4*n-6)):print(t*n)[k*~-n:][:n*3/2*~-n+1]
p(2)
for i in range(n-2):p(0,i*s+s+o+s*(4*n-7-2*i)+o+s*(2*n+i-2))
n>1>p(5)

Experimente online!

• n*3/2*~-n+1 é a largura de cada linha: n3n / 2⌋ · (n − 1) + 1 caracteres.
• A sequência q*n+s*(4*n-6)representa as linhas superior e inferior. Se repetirmos e cortarmos [2*(n-1):], obteremos a linha superior; se cortarmos [5*(n-1):], obteremos a linha inferior. Daí a definição pe as chamadas para p(2)e p(5). Porém, como precisamos repetir e cortar o comprimento da linha para todas as outras linhas, reutilizamos po loop.
• A i*s+s+o+…é apenas uma expressão chata para as linhas do meio.
• n>1>p(5)irá n≯1causar um curto-circuito se , fazendo p(5)com que não seja avaliado. Portanto, é uma abreviação de if n>1:p(5).

Mathematica, 126 125 121 112 104 89 86 bytes

(m=" "&~Array~{#,#^2-#+1};Do[m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X",{j,#},{i,#}];m)&

• #é o número de entrada para uma função anônima (finalizada pela final &).
• m=" "&~Array~{#,#^2-#+1};cria uma matriz de caracteres de espaço do tamanho certo preenchendo uma matriz de determinadas dimensões #,#^2-#+1com as saídas da função anônima constante "output a space" " "&.
• Do[foo,{j,#},{i,#}]é um par de loops aninhados, onde jvaria de 1para #e dentro dele ivaria de 1para #.
• m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X"define a parte correspondente da matriz como o caractere Xbaseado em je i. O -iusa indexação negativa para salvar bytes de #-i+1. (Eu esqueci de escrever Mod[j,4]como j~Mod~4na versão original deste código.) Jenny_mathy apontou que podemos usar o resíduo modular para indexar diretamente na lista (ao invés de usar Switch) para salvar 9 bytes, e JungHwan Min apontou que não ' Não é necessário usar, ReplacePartpois podemos definir uma parte de uma matriz e que 1[i,#,-i][[j~Mod~4]]usa o comportamento e a generalidade ímpares [[foo]]para salvar bytes{1,i,#,-i}[[j~Mod~4+1]]
• Como o meta estabeleceu que uma lista de caracteres é uma string (como JungHwan Min apontou ), não precisamos mapear nenhuma função nas linhas da matriz de caracteres, pois ela já é uma lista de "string" s.

Você pode testar isso na caixa de proteção Wolfram Cloud colando código como o seguinte e pressionando Shift + Enter ou o teclado numérico Enter:

(m=" "&~Array~{#,#^2-#+1};Do[m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X",{j,#},{i,#}];m)&@9//MatrixForm

C ++, 321 234 bytes

-87 bytes graças a Zacharý

#include<vector>
#include<string>
auto z(int n){std::vector<std::string>l;l.resize(n,std::string(n*n+n/2*(n-1),32));l[0][0]=79;int i=0,j,o=0;for(;i<n;++i)for(j=1;j<n;++j)l[i%4?i%4-1?i%4-2?0:n-j-1:n-1:j][i*n+j-i+(o+=i%2)]=79;return l;}

Retorna um vetor de strings

Mathematica, 179 bytes

Rotate[(c=Column)@(t=Table)[{c@(a=Array)[" "~t~#<>(v="o")&,z,0],c@t[t[" ",z-1]<>v,z-1],c@a[t[" ",z-2-#]<>v&,z-1,0],c@t[v,z-Boole[!#~Mod~4<1]-1]}[[i~Mod~4+1]],{i,0,(z=#)-1}],Pi/2]&

editar para @JungHwanMin

05AB1E , 21 20 19 bytes

Código

Usa o novo modo de tela:

Fx<)Nè'ONÉúR3212NèΛ

Usa a codificação 05AB1E . Experimente online!

Explicação:

F                      # For N in range(0, input)
 x<)                   #   Push the array [input, 2 × input - 1]
    Nè                 #   Retrieve the Nth element
      'ONÉúR           #   Push "O" if N is odd, else "O "
            3212Nè     #   Retrieve the Nth element of 3212
                  Λ    #   Write to canvas

Para a entrada 6 , isso fornece os seguintes argumentos (na mesma ordem) para a tela:

[<num>, <fill>, <patt>]
[6,     'O',     3]
[11,    'O ',    2]
[6,     'O',     1]
[11,    'O ',    2]
[6,     'O',     3]
[11,    'O ',    2]

Para explicar o que a tela faz, escolhemos o primeiro conjunto de argumentos da lista acima.

O número 6 determina o comprimento da sequência que será gravada na tela. O preenchimento é usado para escrever na tela, que neste caso é O. Percorre ciclicamente a cadeia de preenchimento. A direção da string é determinada pelo argumento final, a direção. As instruções são:

7  0  1
 \ | /
6- X -2
 / | \
5  4  3

Isso significa que o 3 define a direção para o sudeste , o que também pode ser tentado online .

SOGL V0.12 , 36 bytes

╝.H∫2\?.╝}F2%?№@.┌Ο};1w⁄Hh1ž}.4%1>?№

Experimente aqui!

A idéia básica é escolher para cada número do intervalo de entrada a adição de uma parte pontilhada na diagonal ou na horizontal; nesse caso, ele girará a matriz para facilitar a adição. Explicação:

╝                                     get a diagonal from the bottom-left corner with the length of the input - the starting canvas
 .H∫                        }         for each number in the range [1,inp-1] do, pushing counter
    2\?  }                              if it divides by 2, then
       .╝                                 create another diagonal of the input
          F2%                           push counter % 2
             ?     }                    if that [is not 0]
              №                           reverse the current canvas upside down
               @.┌Ο                       get an alternation of spaces and dashes with the dash amount of the input length
                    ;                   get the canvas on top of the stack
                     1w⁄                get its 1st element length
                        H               decrease it
                         h              swap the bottom 2 items - the canvas is now at the bottom and the current addition ontop
                          1             push 1
                           ž            at 1-indexed coordinates [canvasWidth-1, 1] in the canvas insert the current part made by the Ifs
                             .4%1>?   if input%4 > 1
                                   №    reverse the array vertically

Se a entrada de 1 não fosse permitida, ο.∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№também funcionaria. Se números aleatórios flutuando ao redor fossem permitidos .∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№, também funcionariam. Se eu não fosse preguiçoso e implementado ‼, }F2%?poderia ser substituído ‼por -4 bytes

Mathematica, 106 87 bytes

SparseArray[j=i=1;k=#-1;Array[{j+=Im@i;k∣#&&(i*=I);j,#+1}->"o"&,l=k#+1,0],{#,l}," "]&

Retorna um SparseArrayobjeto de Strings. Para visualizar a saída, você pode anexar Grid@. Lança um erro para o caso 1, mas é seguro ignorar.

Explicação

j=i=1

Defina ie jpara 1.

k=#-1

Defina kpara entrada - 1.

l=k#+1

Defina lcomok*input + 1

Array[ ..., l= ...,0]

Iterar lvezes, começando em 0, incrementando a 1cada vez ...

j+=Im@i

Adicionar o componente imaginário ida j...

k∣#&&(i*=I)

Se a iteração atual é divisível por k, multiplique ipela unidade imaginária ...

{... j,#+1}->"o"

Crie um Ruleobjeto que altera o elemento na posição {j, current iteration + 1}para"o"

SparseArray[ ...,{#,l}," "]

Crie um SparseArrayobjeto usando os Ruleobjetos gerados , com dimensão {input, l}, usando " "como em branco.

Experimente na Wolfram Sandbox!

Python 3 , 228 226 224 215 197 195 bytes

-11 bytes Graças a @Mr. Xcoder

-2 bytes Graças a @Mr. Xcoder

def f(n,s=range):
 x=y=t=c=0;z=[]
 for i in s(n*n-n+2):c+=i%(n-(2<=n))<1;z+=[[x,y]];t=max(t,x);x+=2-c%2;y+=[-1,1][c%4<3]*(c%2)
 return'\n'.join(''.join(' O'[[k,j]in z]for k in s(t))for j in s(n))

Experimente online!

Explicação e código com menos golfe:

def f(n):
 x=y=t=c=0;z=[]                       #initialize everything
 for i in range(n*n-n+2):             #loop n*n-n+2 times which is the numberr of 'o's expected
    c+=i%[~-n,n]<n-1                  #if one cycle has been completed, increase c by 1, if n>1.                                            
    z+=[[x,y]]                        #add [x,y] to z(record the positions of 'o')
    t=max(t,x)                        #trap maximum value of x-coordinate(to be used later while calculatng whole string)
    r=[[2,0],[1,1],[2,0],[1,-1]][c%4] #r gives direction for x and y to move, adjust it as per c i.e. cycles
    x+=r[0];y+=r[1]                   #yield newer values of x and y 
 return '\n'.join(''.join(' o'[[k,j]in z]for k in range(t))for j in range(n)) #place space or 'o' accordingly as per the recorded posititons in z

Haskell , 197 bytes

a n c=take(2*n)$cycle$c:" "
r i n x y=take(div(3*n)2*(n-1)+1)$(' '<$[1..i])++(cycle$"O "++(a(2*n-i-3)y)++"O "++(a(n+i-2)x))
z n=take n$(r 0 n 'O' ' '):[r i n ' ' ' '|i<-[1..n-2]]++[r(n-1)n ' ' 'O']

Experimente online!

Graças a @Lynn: corrigimos os espaços entre Os nos segmentos horizontais do zigue-zague, mas custavam muitos bytes!

Algumas explicações:

• ré uma linha da saída: possui o 0 y y y y y 0 x x x 0 y ...formato, o número xe, ydependendo da linha e da inicialn
• para a linha superior x='0'ey=' '
• para as linhas do meio x=' 'ey=' '
• para a linha inferior x=' 'ey='0'
• take(div(3*n)2*(n-1)+1) corta uma linha infinita no lugar certo
• toda saída tem uma linha superior e uma linha inferior, exceto quando n=1: take nlida com este caso.

Python 2 , 155 151 146 137 bytes

m=input()
n=m-1
r=range(n+2)
for L in zip(*[' '*i+'O'+n*' 'for i in(r+[n,m]*~-n+r[-2::-1]+([m,0]*n)[:-1])*m][:1+3*m/2*n]):print''.join(L)

Experimente online!