Vous recevrez un entier positif Nen entrée. Votre tâche consiste à construire un semi-zigzag, de Ncôtés, chacun de longueur N. Puisqu'il est relativement difficile de décrire clairement la tâche, voici quelques exemples:

• 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 cas de test plus grand avec N = 9

Comme vous pouvez le voir, un semi-zigzag est composé de lignes diagonales et horizontales alternées, et il commence toujours par une ligne diagonale de haut en bas à gauche en bas à droite. Notez que les caractères sur les lignes horizontales sont séparés par un espace.

Règles

• Vous pouvez choisir une non-espaces blancs caractère au lieu de O, il peut même être incompatible.

• Vous pouvez afficher / renvoyer le résultat sous forme de chaîne ou de liste de chaînes, chacune représentant une ligne .

• Vous pouvez avoir une nouvelle ligne de fin ou de début.

• Les échappatoires par défaut s'appliquent.

• Vous pouvez prendre des entrées et fournir des sorties par n'importe quel moyen standard .

• Si possible, veuillez ajouter un lien de test à votre soumission. Je vais voter pour toute réponse qui montre les efforts de golf et a une explication.

• C'est le code-golf , donc le code le plus court en octets dans chaque langue gagne!

Fusain , 24 octets

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

Essayez-le en ligne!

-5 merci à 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 octets

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)

Essayez-le en ligne!

• n*3/2*~-n+1 est la largeur de chaque ligne: ⌊3n / 2⌋ · (n − 1) + 1 caractères.
• La chaîne q*n+s*(4*n-6)représente les lignes supérieure et inférieure. Si nous le répétons et coupons, [2*(n-1):]nous obtenons la rangée du haut; si nous coupons, [5*(n-1):]nous obtenons la ligne du bas. D'où la définition de pet les appels à p(2)et p(5). Mais comme nous avons de toute façon besoin de la répétition et du découpage de la longueur de ligne pour toutes les autres lignes, nous les réutilisons pdans la boucle.
• Le i*s+s+o+…est juste une expression ennuyeuse pour les rangées du milieu.
• n>1>p(5)court-circuitera si n≯1, causant p(5)de ne pas être évalué. Par conséquent, c'est un raccourci pour if n>1:p(5).

Mathematica, 126 125 121 121 112 104 89 86 octets

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

• #est le numéro d'entrée pour une fonction anonyme (terminé par la finale &).
• m=" "&~Array~{#,#^2-#+1};crée une matrice de caractères d'espace de la bonne taille en remplissant un tableau de dimensions données #,#^2-#+1avec les sorties de la fonction anonyme constante "sortie d'un espace" " "&.
• Do[foo,{j,#},{i,#}]est une paire de boucles imbriquées, où Do est jcompris entre 1à #et à l' intérieur de ce que les iplages de 1à #.
• m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X"définit la partie correspondante de la matrice comme étant le caractère Xbasé sur jet i. Le -iutilise une indexation négative pour enregistrer les octets #-i+1. (J'ai oublié d'écrire Mod[j,4]comme j~Mod~4dans la version originale de ce code.) Jenny_mathy a souligné que nous pouvons utiliser le résidu modulaire pour indexer directement dans la liste (plutôt que d'utiliser Switch) pour économiser 9 octets, et JungHwan Min a souligné que nous ne l'avons pas fait '' t besoin d'utiliser ReplacePartcar nous pouvons définir une partie d'un tableau et qui 1[i,#,-i][[j~Mod~4]]utilise le comportement étrange et la généralité de [[foo]]pour enregistrer des octets sur{1,i,#,-i}[[j~Mod~4+1]]
• Puisque la méta a établi qu'une liste de caractères est une chaîne (comme l'a souligné JungHwan Min ), nous n'avons pas besoin de mapper de fonction sur les lignes de la matrice de caractères car c'est déjà une liste de "chaînes".

Vous pouvez tester cela dans le sandbox Wolfram Cloud en collant du code comme le suivant et en appuyant sur Maj + Entrée ou sur le pavé numérique Entrée:

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

-87 octets grâce à 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;}

Renvoie un vecteur de chaînes

Mathematica, 179 octets

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

modifier pour @JungHwanMin

05AB1E , 21 20 19 octets

Code

Utilise le nouveau mode canevas:

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

Utilise l' encodage 05AB1E . Essayez-le en ligne!

Explication:

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

Pour l'entrée 6 , cela donne les arguments suivants (dans le même ordre) pour le canevas:

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

Pour expliquer ce que fait le canevas, nous choisissons le premier ensemble d'arguments dans la liste ci-dessus.

Le nombre 6 détermine la longueur de la chaîne qui sera écrite dans le canevas. Le remplissage est utilisé pour écrire sur la toile, ce qui est le cas dans ce cas O. Il parcourt cycliquement la chaîne de remplissage. La direction de la chaîne est déterminée par l'argument final, la direction. Les directions sont:

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

Cela signifie que le 3 définit la direction vers le sud-est , qui peut également être essayée en ligne .

SOGL V0.12 , 36 octets

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

Essayez-le ici!

L'idée de base est de choisir pour chaque numéro de la plage d'entrée l'ajout d'une partie diagonale ou horizontale en pointillés, auquel cas il retournera le tableau pour un ajout plus facile. Explication:

╝                                     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 l'entrée de 1 n'était pas autorisée, ο.∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№cela fonctionnerait aussi. Si des nombres aléatoires flottants étaient autorisés, .∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№cela fonctionnerait aussi. Si je n'étais pas paresseux et implémenté ‼, }F2%?pourrait être remplacé par ‼pour -4 octets

Mathematica, 106 87 octets

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

Renvoie un SparseArrayobjet de Strings. Pour visualiser la sortie, vous pouvez ajouter Grid@. Lance une erreur pour la casse 1, mais il est sûr de l'ignorer.

Explication

j=i=1

Réglez iet jsur 1.

k=#-1

Réglez ksur entrée - 1.

l=k#+1

Réglez lsurk*input + 1

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

Itérer les ltemps, à partir de 0, en incrémentant à 1chaque fois ...

j+=Im@i

Ajoutez le composant imaginaire de ià j...

k∣#&&(i*=I)

Si l'itération courante est divisible par k, multipliez ipar l'unité imaginaire ...

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

Créer un Ruleobjet qui change l'élément à sa position {j, current iteration + 1}en"o"

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

Créez un SparseArrayobjet en utilisant les Ruleobjets générés , avec dimension {input, l}, en utilisant " "comme blanc.

Essayez-le sur Wolfram Sandbox!

Python 3 , 228 226 224 215 197 195 octets

-11 octets Merci à @Mr. Xcoder

-2 octets Merci à @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))

Essayez-le en ligne!

Explication et code moins golfé:

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 octets

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

Essayez-le en ligne!

Grâce à @Lynn: correction des espaces entre Os sur les segments horizontaux du zigzag, mais cela a coûté beaucoup d'octets!

Quelques explications:

• rest une ligne de la sortie: elle a le 0 y y y y y 0 x x x 0 y ...format, le nombre xet yselon la ligne et l'initialen
• pour la rangée du haut, x='0'ety=' '
• pour les rangées du milieu, x=' 'ety=' '
• pour la rangée du bas, x=' 'ety='0'
• take(div(3*n)2*(n-1)+1) coupe une ligne infinie au bon endroit
• chaque sortie a une ligne supérieure et une ligne inférieure sauf lorsque n=1: take ngère ce cas.

Python 2 , 155 151 146 146 137 octets

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)

Essayez-le en ligne!