Ti verrà dato un numero intero positivo Ncome input. Il tuo compito è costruire un semi-zigzag, di Nlati, ciascuno di lunghezza N. Dal momento che è relativamente difficile descrivere chiaramente l'attività, ecco alcuni esempi:

• 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 di prova più grande con N = 9

Come puoi vedere, un semi-zigzag è fatto di linee diagonali e orizzontali alternate e inizia sempre con una linea diagonale superiore sinistra a quella inferiore destra. Prendi nota che i caratteri sulle linee orizzontali sono separati da uno spazio.

Regole

• Si può scegliere qualsiasi non-spazio bianco carattere invece di O, può anche essere incoerente.

• È possibile generare / restituire il risultato come stringa o come elenco di stringhe, ognuna delle quali rappresenta una riga .

• Potresti avere una nuova riga finale o iniziale.

• Si applicano scappatoie predefinite .

• Puoi prendere input e fornire output con qualsiasi media standard .

• Se possibile, aggiungi un link di prova alla tua richiesta. Valuterò qualsiasi risposta che mostri gli sforzi del golf e abbia una spiegazione.

• Questo è code-golf , quindi vince il codice più breve in byte in ogni lingua !

Carbone , 24 byte

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

Provalo online!

-5 grazie 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 byte

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)

Provalo online!

• n*3/2*~-n+1 è la larghezza di ogni riga: ⌊3n / 2⌋ · (n − 1) + 1 caratteri.
• La stringa q*n+s*(4*n-6)rappresenta le righe superiore e inferiore. Se lo ripetiamo e tagliamo [2*(n-1):]otteniamo la riga superiore; se tagliamo [5*(n-1):]otteniamo la riga inferiore. Da qui la definizione di pe le chiamate a p(2)e p(5). Ma dal momento che abbiamo bisogno della ripetizione e del taglio della lunghezza delle linee per tutte le altre linee, riutilizziamo comunque pnel ciclo.
• Il i*s+s+o+…è solo un'espressione noioso per le righe di mezzo.
• n>1>p(5)cortocircuita se n≯1, facendo sì p(5)che non venga valutato. Quindi, è una scorciatoia per if n>1:p(5).

Mathematica, 126 125 121 112 104 89 86 byte

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

• #è il numero di input per una funzione anonima (terminata dalla finale &).
• m=" "&~Array~{#,#^2-#+1};crea una matrice di caratteri spaziali della giusta dimensione riempiendo un array di dimensioni date #,#^2-#+1con gli output della costante funzione anonima "output a space" " "&.
• Do[foo,{j,#},{i,#}]è una coppia di anelli nidificati do, dove jvaria da 1a #ed all'interno di tale ivaria da 1a #.
• m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X"imposta la parte corrispondente della matrice come carattere in Xbase a je i. Il -iutilizza indicizzazione negativo per salvare byte da #-i+1. (Ho dimenticato di scrivere Mod[j,4]come j~Mod~4nella versione originale di questo codice.) Jenny_mathy ha sottolineato che possiamo usare il residuo modulare per indicizzare direttamente l'elenco (piuttosto che usare Switch) per salvare 9 byte, e JungHwan Min ha sottolineato che non lo abbiamo fatto Non è necessario utilizzare ReplacePartpoiché è possibile impostare una parte di un array e che 1[i,#,-i][[j~Mod~4]]utilizza il comportamento dispari e la generalità di [[foo]]per salvare byte su{1,i,#,-i}[[j~Mod~4+1]]
• Poiché meta ha stabilito che un elenco di caratteri è una stringa (come sottolineato da JungHwan Min ) non è necessario mappare alcuna funzione tra le righe della matrice di caratteri poiché è già un elenco di "stringhe".

Puoi provarlo nella sandbox di Wolfram Cloud incollando il codice come segue e premendo Maiusc + Invio o il tastierino numerico Invio:

(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 byte

-87 byte grazie 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;}

Restituisce un vettore di stringhe

Mathematica, 179 byte

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

modifica per @JungHwanMin

05AB1E , 21 20 19 byte

Codice

Utilizza la nuova modalità tela:

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

Utilizza la codifica 05AB1E . Provalo online!

Spiegazione:

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

Per l'input 6 , ciò fornisce i seguenti argomenti (nello stesso ordine) per il canvas:

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

Per spiegare cosa fa la tela, scegliamo la prima serie di argomenti dall'elenco sopra.

Il numero 6 determina la lunghezza della stringa che verrà scritta nell'area di disegno. Il filler viene utilizzato per scrivere sulla tela, che in questo caso è O. Scorre ciclicamente la stringa di riempimento. La direzione della stringa è determinata dall'argomento finale, la direzione. Le indicazioni sono:

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

Ciò significa che il 3 imposta la direzione verso sud-est , che può anche essere provato online .

SOGL V0.12 , 36 byte

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

Provalo qui!

L'idea di base è di scegliere per ogni numero dell'intervallo di input l'aggiunta di una parte tratteggiata diagonale o orizzontale, nel qual caso ruoterà l'array per facilitare l'aggiunta. Spiegazione:

╝                                     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 l'ingresso di 1 non fosse consentito, allora ο.∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№funzionerebbe anche. Se fossero consentiti .∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№anche numeri casuali che fluttuano intorno , funzionerebbe. Se non fossi pigro e implementato ‼, }F2%?potrebbe essere sostituito con ‼-4 byte

Mathematica, 106 87 byte

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

Restituisce un SparseArrayoggetto di Strings. Per visualizzare l'output, è possibile aggiungere Grid@. Genera un errore per caso 1, ma è sicuro da ignorare.

Spiegazione

j=i=1

Impostare ie jsu 1.

k=#-1

Imposta ksu input - 1.

l=k#+1

Imposta lsuk*input + 1

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

Iterate lvolte, a partire da 0, incrementando di 1volta in volta ...

j+=Im@i

Aggiungi il componente immaginario di ia j...

k∣#&&(i*=I)

Se l'attuale iterazione è divisibile per k, moltiplica iper l'unità immaginaria ...

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

Crea un Ruleoggetto che cambi l'elemento in posizione {j, current iteration + 1}in"o"

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

Crea un SparseArrayoggetto usando gli Ruleoggetti generati , con dimensione {input, l}, usando " "come vuoto.

Provalo su Wolfram Sandbox!

Python 3 , 228 226 224 215 197 195 byte

-11 byte Grazie a @Mr. Xcoder

-2 byte Grazie 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))

Provalo online!

Spiegazione e codice meno golfato:

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 byte

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

Provalo online!

Grazie a @Lynn: risolti gli spazi tra le Os sui segmenti orizzontali dello zigzag, ma è costato molti byte!

Alcune spiegazioni:

• rè una riga dell'output: ha il 0 y y y y y 0 x x x 0 y ...formato, il numero di xe in ybase alla riga e all'inizialen
• per la riga superiore x='0'ey=' '
• per le file centrali x=' 'ey=' '
• per la riga inferiore x=' 'ey='0'
• take(div(3*n)2*(n-1)+1) taglia una fila infinita nel posto giusto
• ogni output ha una riga superiore e una riga inferiore tranne quando n=1: take ngestisce questo caso.

Python 2 , 155 151 146 137 byte

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)

Provalo online!