Sie erhalten eine positive Ganzzahl Nals Eingabe. Ihre Aufgabe ist es, einen Halbzickzack mit NSeiten zu bauen, von denen jede Länge hat N. Da es relativ schwierig ist, die Aufgabe klar zu beschreiben, sind hier einige Beispiele:

• 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
  

• Ein größerer Testfall mit N = 9

Wie Sie sehen, besteht ein Halbzickzack aus abwechselnden diagonalen und horizontalen Linien und beginnt immer mit einer diagonalen Linie von links oben nach rechts unten. Beachten Sie, dass die Zeichen in den horizontalen Linien durch ein Leerzeichen getrennt sind.

Regeln

• Sie können eine beliebige Nicht-Leerzeichen wählen Charakter statt O, es kann sogar widersprüchlich sein.

• Sie können das Ergebnis als String oder als Liste von Strings ausgeben / zurückgeben, die jeweils eine Zeile darstellen .

• Möglicherweise haben Sie eine nachgestellte oder führende Zeile.

• Es gelten Standardlücken .

• Sie können die Eingabe und Ausgabe mit jedem Standardmittelwert vornehmen .

• Wenn möglich, fügen Sie Ihrer Einreichung einen Testlink hinzu. Ich stimme jeder Antwort zu, die Golfbemühungen zeigt und eine Erklärung hat.

• Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes in jeder Sprache !

Kohle , 24 Bytes

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

Probieren Sie es online!

-5 danke an 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)

Probieren Sie es online!

• n*3/2*~-n+1 ist die Breite jeder Zeile: ⌊3n / 2⌋ · (n − 1) + 1 Zeichen.
• Die Zeichenfolge q*n+s*(4*n-6)repräsentiert die oberen und unteren Zeilen. Wenn wir es wiederholen und in Scheiben schneiden, erhalten [2*(n-1):]wir die oberste Reihe; Wenn wir schneiden, erhalten [5*(n-1):]wir die unterste Reihe. Daher die Definition pund die Aufrufe von p(2)und p(5). Da wir jedoch die Wiederholung und das Schneiden der Zeilenlänge für alle anderen Zeilen benötigen, verwenden wir sie pin der Schleife erneut.
• Das i*s+s+o+…ist nur ein langweiliger Ausdruck für die mittleren Reihen.
• n>1>p(5)Wird kurzgeschlossen, wenn n≯1, was p(5)dazu führt , dass nicht ausgewertet wird. Daher ist es eine Abkürzung für 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)&

• #ist die Eingabenummer für eine anonyme Funktion (abgeschlossen durch das Finale &).
• m=" "&~Array~{#,#^2-#+1};erstellt eine Matrix von Leerzeichen mit der richtigen Größe, indem ein Array #,#^2-#+1mit den angegebenen Dimensionen mit den Ausgaben der konstanten anonymen Funktion "Ausgabe eines Leerzeichens" gefüllt wird " "&.
• Do[foo,{j,#},{i,#}]ist ein Paar verschachtelter do-Schleifen, bei denen der jBereich von 1bis #und innerhalb des iBereichs von 1bis liegt #.
• m[[1[i,#,-i][[j~Mod~4]],j#-#+i+1-j]]="X"Setzt den entsprechenden Teil der Matrix als Zeichen Xbasierend auf jund i. Das -iverwendet negative Indizierung, um Bytes von zu speichern #-i+1. (Ich habe vergessen, Mod[j,4]wie j~Mod~4in der Originalversion dieses Codes zu schreiben .) Jenny_mathy wies darauf hin, dass wir den modularen Rest verwenden können, um die Liste direkt zu indizieren (anstatt zu verwenden Switch), um 9 Bytes zu sparen, und JungHwan Min wies darauf hin, dass wir dies nicht getan haben. Es muss nicht verwendet werden, ReplacePartda wir einen Teil eines Arrays festlegen können, und dies 1[i,#,-i][[j~Mod~4]]nutzt das seltsame Verhalten und die Allgemeingültigkeit von [[foo]], um Bytes zu sparen{1,i,#,-i}[[j~Mod~4+1]]
• Da Meta feststellte, dass eine Liste von Zeichen eine Zeichenfolge ist (wie JungHwan Min betonte ), müssen wir keine Funktion über die Zeilen der Zeichenmatrix zuordnen, da es sich bereits um eine Liste von "Zeichenfolgen" handelt.

Sie können dies in der Wolfram Cloud-Sandbox testen, indem Sie den folgenden Code einfügen und UMSCHALT + EINGABETASTE oder die NUM-TASTE drücken:

(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 dank 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;}

Gibt einen Vektor von Strings zurück

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

für @JungHwanMin bearbeiten

05AB1E , 21 20 19 Bytes

Code

Verwendet den neuen Canvas-Modus:

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

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Erläuterung:

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

Für Eingabe 6 werden die folgenden Argumente (in derselben Reihenfolge) für die Zeichenfläche angegeben:

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

Um zu erklären, was die Zeichenfläche tut, wählen Sie die erste Gruppe von Argumenten aus der obigen Liste.

Die Zahl 6 bestimmt die Länge der Zeichenfolge, die in die Zeichenfläche geschrieben wird. Der Füllstoff wird verwendet, um auf die Leinwand zu schreiben, was in diesem Fall der Fall ist O. Es läuft zyklisch durch den Füllstring. Die Richtung der Zeichenkette wird durch das letzte Argument, die Richtung, bestimmt. Die Richtungen sind:

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

Dies bedeutet, dass die 3 die Richtung nach Südosten vorgibt , was auch online versucht werden kann .

SOGL V0.12 , 36 Bytes

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

Probieren Sie es hier aus!

Die Grundidee besteht darin, für jede Nummer des Eingabebereichs entweder einen diagonalen oder einen horizontal gepunkteten Teil hinzuzufügen. In diesem Fall wird das Array gedreht, um das Hinzufügen zu vereinfachen. Erläuterung:

╝                                     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

Wenn die Eingabe von 1 nicht erlaubt wäre, ο.∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№würde das auch funktionieren. Wenn zufällige Zahlen erlaubt .∫2%?.╝}F2\?№@.┌Ο};1w⁄Hh1ž}.4%1>?№wären, würde das auch funktionieren. Wenn ich nicht faul und implementiert wäre ‼, }F2%?könnte durch ‼-4 Bytes ersetzt werden

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}," "]&

Gibt ein SparseArrayObjekt von Strings zurück. Um die Ausgabe zu visualisieren, können Sie sie anhängen Grid@. Wirft einen Fehler für case 1, den Sie aber ignorieren können.

Erläuterung

j=i=1

Stellen Sie iund jauf 1.

k=#-1

Auf kEingang - 1 einstellen.

l=k#+1

Stellen Sie laufk*input + 1

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

Iteriere die lZeiten, beginnend mit 0, inkrementiere 1jedes Mal um ...

j+=Im@i

Fügen Sie die imaginäre Komponente der izu j...

k∣#&&(i*=I)

Wenn die aktuelle Iteration durch teilbar ist k, multiplizieren Sie imit der imaginären Einheit ...

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

Erstellen Sie ein RuleObjekt, das das Element an der Position {j, current iteration + 1}in ändert"o"

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

Erstellen Sie ein SparseArrayObjekt unter Verwendung der generierten RuleObjekte mit Bemaßung {input, l}und " "als Leerzeichen.

Probieren Sie es auf Wolfram Sandbox!

Python 3 , 228 226 224 215 197 195 Bytes

-11 Bytes Vielen Dank an @Mr. Xcoder

-2 Bytes Dank an @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))

Probieren Sie es online!

Erklärung und weniger Golf Code:

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

Probieren Sie es online!

Dank @Lynn: Die Abstände zwischen Os in horizontalen Segmenten des Zickzacks wurden korrigiert , aber es kostete eine Menge Bytes!

Einige Erklärungen:

• rist eine Zeile der Ausgabe: Sie hat das 0 y y y y y 0 x x x 0 y ...Format, die Anzahl xund yhängt von der Zeile und der Initiale abn
• für die oberste Reihe x='0'undy=' '
• für die mittleren Reihen x=' 'undy=' '
• für die unterste Reihe x=' 'undy='0'
• take(div(3*n)2*(n-1)+1) schneidet eine unendliche Reihe an der richtigen Stelle
• Jede Ausgabe hat eine obere und eine untere Zeile, außer wenn n=1: take ndiesen Fall behandelt.

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)

Probieren Sie es online!