Se le dará un entero positivo Ncomo entrada. Su tarea es construir un Semi-Zigzag, de Nlados, cada uno de longitud N. Dado que es relativamente difícil describir claramente la tarea, aquí hay algunos ejemplos:

• 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
  

• Un caso de prueba más grande con N = 9

Como puede ver, un Semi-Zigzag está hecho de líneas diagonales y horizontales alternas, y siempre comienza con una línea diagonal superior izquierda a inferior derecha. Tenga en cuenta que los caracteres en las líneas horizontales están separados por un espacio.

Reglas

• Usted puede elegir cualquier no está en blanco personaje en lugar de O, incluso puede ser inconsistente.

• Puede generar / devolver el resultado como una Cadena o como una lista de Cadenas, cada una representando una línea .

• Es posible que tenga una nueva línea al final o al final.

• Se aplican las lagunas predeterminadas .

• Puede tomar entrada y proporcionar salida por cualquier medio estándar .

• Si es posible, agregue un enlace de prueba a su envío. Voy a votar cualquier respuesta que muestre los esfuerzos de golf y tenga una explicación.

• Este es el código de golf , por lo que gana el código más corto en bytes en cada idioma .

Carbón de leña , 24 bytes

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

Pruébalo en línea!

-5 gracias 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 , 157153 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)

Pruébalo en línea!

• n*3/2*~-n+1 es el ancho de cada línea: ⌊3n / 2⌋ · (n − 1) + 1 caracteres.
• La cadena q*n+s*(4*n-6)representa las filas superior e inferior. Si lo repetimos y cortamos [2*(n-1):], obtenemos la fila superior; si cortamos [5*(n-1):]obtenemos la fila inferior. De ahí la definición de py las llamadas a p(2)y p(5). Pero dado que necesitamos la repetición y el corte de longitud de línea para todas las demás líneas de todos modos, reutilizamos pen el bucle.
• La i*s+s+o+…es solo una expresión aburrida para las filas del medio.
• n>1>p(5)n≯1provocará un cortocircuito si p(5)no se evalúa. Por lo tanto, es la abreviatura 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)&

• #es el número de entrada para una función anónima (finalizada por la final &).
• m=" "&~Array~{#,#^2-#+1};crea una matriz de caracteres de espacio del tamaño correcto rellenando una matriz de dimensiones dadas #,#^2-#+1con las salidas de la función anónima constante "generar un espacio" " "&.
• Do[foo,{j,#},{i,#}]es un par de bucles anidados DO, donde joscila entre 1a #y en el interior de que los irangos de 1a #.
• m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X"establece la parte correspondiente de la matriz para que sea el carácter Xbasado en jy i. El -iutiliza la indexación negativa para salvar bytes desde #-i+1. (Olvidé escribir Mod[j,4]como j~Mod~4en la versión original de este código). Jenny_mathy señaló que podemos usar el residuo modular para indexar directamente en la lista (en lugar de usar Switch) para guardar 9 bytes, y JungHwan Min señaló que no ' No es necesario usarlo, ReplacePartya que podemos establecer una parte de una matriz y que 1[i,#,-i][[j~Mod~4]]utiliza el comportamiento extraño y la generalidad de [[foo]]guardar bytes sobre{1,i,#,-i}[[j~Mod~4+1]]
• Dado que Meta estableció que una lista de caracteres es una cadena (como señaló JungHwan Min ) no necesitamos asignar ninguna función a través de las filas de la matriz de caracteres, ya que ya es una lista de "cadenas".

Puede probar esto en el sandbox de Wolfram Cloud pegando código como el siguiente y presionando Shift + Enter o el 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 gracias 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;}

Devuelve un vector de cadenas

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

Utiliza el nuevo modo de lienzo:

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

Utiliza la codificación 05AB1E . Pruébalo en línea!

Explicación:

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 la entrada 6 , esto proporciona los siguientes argumentos (en el mismo orden) para el lienzo:

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

Para explicar lo que hace el lienzo, elegimos el primer conjunto de argumentos de la lista anterior.

El número 6 determina la longitud de la cadena que se escribirá en el lienzo. El relleno se usa para escribir en el lienzo, que en este caso es O. Se ejecuta cíclicamente a través de la cadena de relleno. La dirección de la cadena está determinada por el argumento final, la dirección. Las direcciones son:

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

Esto significa que el 3 establece la dirección hacia el sureste , que también se puede probar en línea .

SOGL V0.12 , 36 bytes

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

Pruébalo aquí!

La idea básica es para cada número del rango de entrada elegir agregar una parte diagonal u horizontal punteada, en cuyo caso cambiará la matriz para facilitar la adición. Explicación:

╝                                     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

Si no se permitiera la entrada de 1, entonces ο.∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№también funcionaría. Si se permitieran números aleatorios flotando .∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№también funcionaría. Si no fuera flojo e implementado ‼, }F2%?podría ser reemplazado ‼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}," "]&

Devuelve un SparseArrayobjeto de Strings. Para visualizar el resultado, puede agregarlo Grid@. Lanza un error por caso 1, pero es seguro ignorarlo.

Explicación

j=i=1

Establecer iy ja 1.

k=#-1

Establecer kcomo entrada - 1.

l=k#+1

Establecer lenk*input + 1

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

Iterar ltiempos, empezando por 0, incrementándose 1cada vez ...

j+=Im@i

Agregue el componente imaginario de ia j...

k∣#&&(i*=I)

Si la iteración actual es divisible por k, multiplique ipor la unidad imaginaria ...

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

Cree un Ruleobjeto que cambie el elemento en la posición {j, current iteration + 1}a"o"

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

Cree un SparseArrayobjeto utilizando los Ruleobjetos generados , con dimensión {input, l}, utilizando " "como en blanco.

¡Pruébalo en Wolfram Sandbox!

Python 3 , 228 226 224 215 197 195 bytes

-11 bytes Gracias a @Mr. Xcoder

-2 bytes Gracias 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))

Pruébalo en línea!

Explicación y código menos golfizado:

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

Pruébalo en línea!

Gracias a @Lynn: arreglé los espacios entre Os en segmentos horizontales del zigzag, ¡pero costó muchos bytes!

Algunas explicaciones:

• res una fila de la salida: tiene el 0 y y y y y 0 x x x 0 y ...formato, el número xy ydependiendo de la fila y la inicialn
• para la fila superior, x='0'yy=' '
• para las filas del medio, x=' ' yy=' '
• para la fila inferior, x=' ' yy='0'
• take(div(3*n)2*(n-1)+1) corta una fila infinita en el lugar correcto
• cada salida tiene una fila superior y una fila inferior excepto cuando n=1: take nmaneja 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)

Pruébalo en línea!