Construye un semi-zigzag

29

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 , por lo que gana el código más corto en bytes en cada idioma .

Sr. Xcoder
fuente
1
Sandbox Post .
Sr. Xcoder
¿Tenemos que poner espacios entre O que sean horizontales?
HatsuPointerKun
1
@HatsuPointerKun Tenga en cuenta que los caracteres en las líneas horizontales están separados por un espacio. - Sí, tienes que poner espacios.
Sr. Xcoder
1
Ah, sí. Debería aprender a leer. Gracias
HatsuPointerKun
1
@JohnHamilton Las respuestas deberían funcionar teóricamente para cualquier número dado como entrada. No deben preocuparse por lo que puede contener una pantalla.
Sr. Xcoder

Respuestas:

10

Carbón de leña , 24 bytes

FN«↶§7117ι×⁺#× ﹪ι²⁻Iθ¹»#

Pruébalo en línea!

-5 gracias a Neil .

AST:

Program
├F: For
│├N: Input number
│└Program
│ ├↶: Pivot Left
│ │└§: At index
│ │ ├'7117': String '7117'
│ │ └ι: Identifier ι
│ └Print
│  └×: Product
│   ├⁺: Sum
│   │├'#': String '#'
│   │└×: Product
│   │ ├' ': String ' '
│   │ └﹪: Modulo
│   │  ├ι: Identifier ι
│   │  └2: Number 2
│   └⁻: Difference
│    ├I: Cast
│    │└θ: Identifier θ
│    └1: Number 1
└Print
 └'#': String '#'
Erik el Outgolfer
fuente
Fue demasiado fácil para Charcoal :)
Mr. Xcoder
@ Mr.Xcoder Esto realmente se siente poco golfista ... no estoy seguro de cómo jugarlo.
Erik the Outgolfer
El OP dijo que el carácter puede ser cualquiera y no necesita ser coherente, por lo que estaba buscando algo en la línea de FN§⟦↘→↗→⟧ι⁻Iθ¹→(15 bytes solamente), pero las listas de direcciones no parecen funcionar correctamente en Charcoal. Una pena.
Charlie
@CarlosAlejo también lo intentó pero desafortunadamente no funciona.
Erik the Outgolfer
1
@CarlosAlejo FN✳§⟦↘→↗→⟧ι⁻θ¹Otrabajará después de que Dennis tire, siendo enviado a la dirección
solo ASCII
7

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).
Lynn
fuente
Wow, una solución increíble, muy inteligente. Te ganaste mi
voto a favor
Wow, nunca supe que Python tenía un corto circuito en comparaciones como esa, +1.
Zacharý
6

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
Marcas.
fuente
1
¡Muy agradable! puede reemplazar StringJoin con "" <> # y guardar 4 bytes
J42161217
@ Jenny_mathy Gracias por el consejo! Eso parece bastante útil.
Mark S.
2
También puede reemplazar Switch [...] con {1, i, #, - i} [[j ~ Mod ~ 4 + 1]] y guardar 9 bytes!
J42161217
1
En realidad no necesitas ReplacePartaquí. m=ReplacePart[...]puede ser m[[{1,i,#,-i}[[j~Mod~4+1]],j#-#+i+1-j]]="X": puede Setuna Partde una lista. Eso elimina 15 bytes.
JungHwan Min
1
{1,i,#,-i}[[j~Mod~4+1]]También puede ser 1[i,#,-i][[j~Mod~4]]. Este truco funciona porque [[0]]devuelve el Headde una expresión.
JungHwan Min
4

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

HatsuPointerKun
fuente
Lo reduje
Zacharý
Corrección, lo reduje a 239 bytes : repl.it/JpJ2/1
Zacharý
Perdón por el spam, 234 bytes: repl.it/JpJ2/3
Zacharý
1
¿Qué puedo decir, excepto que de nada!
Zacharý
@ Zacharý muchas gracias señor
HatsuPointerKun
4

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

J42161217
fuente
¡No esperaba que fuera tan corto, bien hecho!
Sr. Xcoder
Solo una pregunta: ¿Se Mod[z,4]==0puede reemplazar con Mod[z,4]<1?
Sr. Xcoder
Sí, puedo jugar algunas cosas ...
J42161217
3
No se sabe muy bien Mathematica, pero se puede sustituir Mod[#,4]con #~Mod~4de -1 bytes?
Sr. Xcoder
1
Vaya ... accidentalmente rechazado. ¿Podrías editar la respuesta para que pueda darle la vuelta?
JungHwan Min
4

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 .

Adnan
fuente
También tenga en cuenta que el modo de lienzo está en desarrollo y es muy inestable
Adnan el
: O 05AB1E está mutando a Carbón (también esto está batiendo Carbón O_o)
Solo ASCII
@ Solo ASCII Sí, vi el surgimiento de todos los idiomas basados ​​en ASCII (carbón, SOGL, V, etc.) y vi 05AB1E hundirse en el fondo, así que tuve que hacer algo al respecto: p
Adnan
¿Copiaste carbón? : P 05ab1e incluso tiene un lienzo y una impresión direccional (aunque el carbón solo admite este estilo de impresión con longitud a través de Python)
Solo ASCII
2

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

dzaima
fuente
2

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!

JungHwan Min
fuente
1
hay algo mal con el caso n = 3
J42161217
1
n = 2, 4,5,6 también tienen problemas de corrección, pero creo que esto funciona para 7 y superiores. Tengo curiosidad: ¿existe un precedente en cuanto a si un SparseArraycuenta como una matriz? Se puede visualizar usando Grido MatrixForm, pero normalmente no lo consideraría como "una lista de cadenas" aquí. Si una matriz 2D de caracteres es suficiente, eso corta 8 bytes de mi solución (12 antes de la ayuda de Jenny_mathy), por ejemplo.
Mark S.
1
@Marcas. Además, una serie de cadenas está bien por meta consenso . Si algo no está claro, pregunte al OP (ya que él / ella hace las reglas, no nosotros). Una simple búsqueda de "SparseArray" en este sitio ofrece abundantes SparseArrayrespuestas, por lo que supongo que está bien.
JungHwan Min
1
@Marcas. Además, esta página tiene muchos trucos para jugar al golf en Mathematica.
JungHwan Min
1
@JungHwanMin Edité mi respuesta como usted preguntó
J42161217
2

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
officialaimm
fuente
1
Muy buen trabajo. ¡Felicidades!
Sr. Xcoder
@ Mr.Xcoder Gracias. Debo decir que este fue difícil, especialmente tuvo problemas para identificar el rango correcto.
officialaimm
1
215 bytes , if 2>n:return'o'es bastante redundante. Hice una solución con en c+=i%[~-n,n][2>n]<1lugar de c+=i%~-n<1.
Sr. Xcoder
1
Perdón por la mejora muy tardía, 195 bytes
Sr. Xcoder
1

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.
jferard
fuente
Muy bien golfizado! Puedes dejar un par de esos espacios, creo. Y replicate n xpuede ser reemplazado por x<$[1..n]. Además, su respuesta carece de espacios entre Os en segmentos horizontales del zigzag.
Lynn
@ Lynn gracias! con los espacios en segmentos horizontales, mi método se vuelve engorroso, pero de todos modos quería arreglar el código ...
jferard
Puede ahorrar bastante utilizando operadores y eliminando espacios innecesarios, consulte aquí .
ბიმო
1

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!

TFeld
fuente
@ Mr.Xcoder Ahh. Ya lo veo.
TFeld
@ Mr.Xcoder Corregido ahora.
TFeld
`L`[2::5]''.join(L)
Llego