Herausforderung :

nAls Eingabe wird eine Ganzzahl angegeben . Erstellen Sie einen Diamanten, der 2x der angegebenen Zahl entspricht n.

Eingabe:

Die Eingabe ist eine Ganzzahl nund 2 <n ≤ 3000.

Ausgabe :

Die Ausgabe erfolgt als Zeichenfolge und in Form eines Diamanten, der +zu Beginn aus einer Additionslinie besteht, die nusing anzeigt+

Beispiele:

D (3):

+++
  +
 +++
+++++
+++++
 +++
  +

D (5):

+++++
    +
   +++
  +++++
 +++++++
+++++++++
+++++++++
 +++++++
  +++++
   +++
    +

D (6): 

++++++
     +
    +++
   +++++
  +++++++
 +++++++++
+++++++++++
+++++++++++
 +++++++++
  +++++++
   +++++
    +++
     +

Gewinnkriterien:

Dies ist Code-Golf, so dass der kürzeste Code in Bytes für jede Programmiersprache gewinnt.

Brainfuck , 151 139 Bytes

,[.[<]<+[>>]++++[-<++++++++>],]<[<]<<<++++++++++.>>[[>]>[-<+>]>[-<+>]>>[.>>]<<[<]<<.<<[..<<]<.>>-]>[[>]>[.>>]<<[<<]>.>>[..>>]<<,<[<]<<.>>>]

Probieren Sie es online!

Nimmt Eingaben über Unär, mit +s als Zählmarken ( vom Poster erlaubt ). Beschlossen, dies zu überarbeiten, da ich dachte, der alte war etwas länger als es sein könnte (obwohl dies auch ist!).

Alte Version (151 Bytes):

>--[>+<++++++]<[->+>.<<]++++++++[-<+<++++>>]<++>>[<<.>>-[-<+<<.>>>]<[->+<]>>>+[-<.>>+<]>+[-<+>]<<<]>>[<<<<.>>[-<+<<.>>>]<[->+<]>+>>-[-<.>>+<]>-[-<+>]<]

Probieren Sie es online!

Übernimmt die Eingabe als Startzelle. Ich konnte mir keine Möglichkeit vorstellen, die erste Hälfte für die zweite zu nutzen, daher gibt es für jede eine Schleife.

Wie es funktioniert:

 >--[>+<++++++]  Create 43 ('+') two space to the left of n
 <[->+>.<<]      Print n '+'s while preserving n
 ++++++++[-<+<++++>>]<++  Create 32 (' ') and 10 ('\n')
                         Tape: 32 10 0 n 43 t
 >>
 [ Loop over the first half of the diamond
   <<.>>         Print a newline
   -[-<+<<.>>>]  Decrement n and print n spaces
   <[->+<]       Restore n
   >>>+[-<.>>+<] Increment t and print t '+'s
   >+[-<+>]<<<   Increment t again and restore it
]>>
[ Loop over the second half
  <<<<.>>        Print a newline
  [-<+<<.>>>]<   Print n spaces
  [->+<]>+       Restore and increment n
  >>-[-<.>>+<]   Decrement t and print t '+'s
  >-[-<+>]<      Decrement t again and restore it
]

Und nur zum Spaß:

+++++++++
        >
       --[
      >+<++
     ++++]<[
    ->+>.<<]+
   +++++++[-<+
  <++++>>]<++>>
 [<<.>>-[-<+<<.>
>>]<[->+<]>>>+[-<
.>>+<]>+[-<+>]<<<
 ]>>[<<<<.>>[-<+
  <<.>>>]<[->+<
   ]>+>>-[-<.>
    >+<]>-[-<
     +>]<]++
      +++++
       +++
        +

Probieren Sie es online!

Canvas , 9 Bytes

+×Ｏ｛+×］±╪

Probieren Sie es hier aus!

Erklärung (einige Zeichen wurden ersetzt, um monospace auszusehen):

+×O{+×]±╪
+×         repeat "+" input times
  O        output that
   {  ]    map over 1..input
    +×       repeat "+" that many times
       ±   interpret the array as a 2D string, and reverse it
        ╪  quad-palindromize with 1 horizontal overlap and 0 vertical overlap

Python 3 , 95 94 75 Bytes

def f(n):a=[' '*(n+~i)+'+'*(i-~i)for i in range(n)];return['+'*n]+a+a[::-1]

Probieren Sie es online!

Mein erster Golfversuch, Verbesserungsvorschläge sind willkommen.

BEARBEITEN: 1 Byte dank Kevin Cruijssen gespeichert

BEARBEITEN: Missverständnisse über die Anzahl der Bytes beseitigt

BEARBEITEN: Dank Jo King und user202729 viel mehr Bytes gespart

05AB1E , 14 Bytes

'+×sL·<'+×∊.c»

Probieren Sie es online!

Erläuterung

'+×              # push "+" repeated <input> times
   sL            # push range [1 ... input]
     ·<          # multiply each element by 2 and decrement (x*2-1)
       '+×       # replace each number with the corresponding number of "+"'s
          ∊      # mirror vertically
           .c    # center
             »   # join with the "+"-row created at the start

Auch 14 Bytes: L‚˜'+×ćs.∞∊.c»

Python 3 , 79 78 Bytes

def f(n):x=[('++'*i+'+').center(n*2)for i in range(n)];return[n*'+']+x+x[::-1]

Probieren Sie es online!

Dank dieser Tipps zum Golfen antworte Python , um mich über die .centerFunktion zu informieren . Gibt eine Liste von Zeichenfolgen zurück.

R , 135 110 96 Bytes

function(n){cat("+"<n,"
",sep="")
for(i in c(1:n,n:1))cat(" "<n-i,"+"<2*i-1,"
",sep="")}
"<"=rep

Probieren Sie es online!

@ JayCe mit dem finalen Schnitt.

Die repFunktion wird zu einem bestehenden Infixoperator zugeordnet, wie <oder ^so , dass rep("+", n)entspricht , "<"("+", n)die unter Verwendung schrieben werden kann <als Infixoperator wie in "+" < nauf und verkürzt "+"<n.

Kohle , 15 Bytes

Ｇ→→↙Ｎ+↓‖Ｍ↑×⊕ⅈ+‖

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｇ→→↙Ｎ+

Drucken Sie ein umgekehrtes Dreieck mit +der Höhe der Eingabe und fast der doppelten Breite.

↓

Bewegen Sie den Cursor nach unten, damit er nach der Reflektion auf der zusätzlichen Zeile landet.

‖Ｍ↑

Machen Sie ein Spiegelbild des Dreiecks.

×⊕ⅈ+

Zeichnen Sie die zusätzliche Linie mit der aktuellen Spalte, um zu vermeiden, dass Sie die Eingabe erneut lesen müssen.

‖

Reflektieren Sie die Ausgabe so, dass die zusätzliche Linie nach links zeigt.

Stax , 11 Bytes

ñ1┌╙@↔g+┤a☻

Führen Sie es aus und debuggen Sie es

Python 3 , 76 75 Bytes

lambda n:['+'*n]+[' '*(n+~i)+'+'*(i-~i)for i in[*range(n),*range(n)[::-1]]]

Probieren Sie es online!

QB64, 82 79 Bytes

INPUT n
?STRING$(n,43):FOR a=1TO 2*n:d=a-(a>n)*2*(n-a):?SPC(n-d);STRING$(2*d-1,43):NEXT

JavaScript (Node.js) , 106 bis 105 Byte

• danke an @Kevin Cruijssen für die Reduzierung um 1 Byte

n=>[...Array(n*2+1)].map((_,i)=>" ".repeat(i?i>n?i+~n:n-i:0)+"+".repeat(i?i>n?4*n-2*i+1:i*2-1:n)).join`
`

Probieren Sie es online!

________________________________________________

Zweiter Ansatz

JavaScript (Node.js) , 105 100 99 98 Byte

• danke an @Kevin Cruijssen für die Reduzierung um 1 Byte
• Dank an @ovs für die Reduzierung um 1 Byte

n=>[X="+"[r="repeat"](n),...x=[...X].map((_,i)=>" "[r](n+~i)+"+"[r](i-~i)),...x.reverse()].join`
`

Probieren Sie es online!

Japt -R , 18 17 Bytes

õÈ+Y î+Ãû ê1 iUî+

Probieren Sie es online!

PowerShell , 55 Byte

param($l)'+'*$l;1..$l+$l..1|%{" "*($l-$_)+'+'*($_*2-1)}

Probieren Sie es online!

J , 29 Bytes

'+'(,]\(}:@|."1,.])@,]\.)@$~]

Probieren Sie es online!

Erläuterung:

'+'$~] - generates the line at the start, which is a seed for the diamond:

   '+'$~]  3
+++

]\,]\. - finds the prefixes (]\) and suffixes (]\.) of the line, making "half" the diamond 

   '+'(]\,]\.)@$~] 3
+  
++ 
+++
+++
++ 
+  

}:@|."1,.] - makes the other "half" of the diamond by reversing each line (|."1)
and dropping its last '+' (}:) and stitches the first half to it (,.])

 '+'(]\(}:@|."1,.])@,]\.)@$~] 3
  +  
 +++ 
+++++
+++++
 +++ 
  +  

, - prepends the initial line to the diamond

'+'(,]\(}:@|."1,.])@,]\.)@$~] 3
+++  
  +  
 +++ 
+++++
+++++
 +++ 
  +  

Haskell , 85 82 Bytes

^{3 Bytes gespart dank nimi !}

n!c=[1..n]>>c
f n|x<-[(n-i)!" "++(i*2-1)!"+"|i<-[1..n]]=unlines$n!"+":x++reverse x

Probieren Sie es online!

Ruby , 71 61 Bytes

->n{[?+*n]+(a=(1..n).map{|x|?\s*(n-x)+?+*(x+x-1)})+a.reverse}

Probieren Sie es online!

PHP, 103 Bytes

for(;$i++<$argn;$s.="
".str_pad(str_pad("",$i*2-1,"+",2),$argn*2-1," ",2))echo"+";echo"$s
",strrev($s);

Laufen Sie als Pipe mit -nR oder versuchen Sie es online .

PowerShell , 58 Byte

param($n)'+'*$n;1..$n+$n..1|%{" "*($n-$_)+"+"*$_+"+"*--$_}

Probieren Sie es online!

Einfach eine Auf- und Ab-Schleife, wobei jede Iteration die entsprechende Anzahl von Leerzeichen und dann die entsprechende Anzahl von Pluszeichen ausgibt. Ho-hum.

F # (Mono) , 123 Bytes

let d n=
 let t n=String('+',n)
 let s n=t(n*2-1)
 [1..n]@[n.. -1..1]|>Seq.fold(fun a x->a+sprintf"\n%*s"(n+x-1)(s x))(t n)

Probieren Sie es online!

PHP 102 Bytes

for($r=str_pad;$i++<$a;$s.="\n".$r($r("",$i*2-1,"+",2),$a*2-1," ",2))echo"+";echo"$s\n",strrev($s);

Ich weiß, es kann viel kleiner sein;) Greetz Mangas

sed 4.2.2 , 69

Das Ergebnis enthält +1 für die -rOption zum Sedieren.

h
y/1/+/
p
x
s/1\B/ /g
y/1/+/
p
:
s/ \+/+++/p
t
p
:a
s/\+\+/ /p
ta
d

Probieren Sie es online!

Ruby , 59 Bytes

->i{[?+*i,b=(1..i).map{|c|' '*(i-c)+?+*(2*c-1)},b.reverse]}

Probieren Sie es online!

Python 3 , 98 Bytes

def d(s):print("+"*s);t=[("+"*i).center(2*s-1)for i in range(1,2*s,2)];print("\n".join(t+t[::-1]))

Probieren Sie es online!

Lesbare Version:

def diamond(size):
    print(size * "+")
    top = [("+" * i).center(2*size - 1) for i in range(1, 2*size, 2)]
    print("\n".join(top))
    print("\n".join(reversed(top)))

Yabasic , 102 Bytes

Eine anonyme Funktion, die Eingaben als unäre Zahlen mit annimmt + Zählmarken und an die Konsole ausgibt.

Input""s$
n=Len(s$)
?s$
For i=-n To n
j=Abs(i)
If i For k=2To j?" ";Next:?Mid$(s$+s$,1,2*(n-j)+1)
Next

Probieren Sie es online!

Alternative Version, 117 Byte

Eine anonyme Funktionsantwort, die Eingaben als Dezimalzahl akzeptiert und an die Konsole ausgibt.

Input""n
For i=1To n s$=s$+"+"Next
?s$
For i=-n To n
j=Abs(i)
If i For k=2To j?" ";Next:?Mid$(s$+s$,1,2*(n-j)+1)
Next

Probieren Sie es online!

JavaScript (Node.js) , 183 Byte

a=x=>{g='\n';r=(m,n)=>String.prototype.repeat.call(m,n);k='+';l=r(k,x)+g;c=d='';for(i=0;i++<x;c+=r(' ',x-i)+r(k,i)+r(k,i-1)+g,d+=r(' ',i-1)+r(k,x+1-i)+r(k,x-i)+g);console.log(l+c+d);}

Probieren Sie es online!

Meine Antwort wurde dank @JoKing aktualisiert

APL (Dyalog Unicode) , 25 Byte ^SBCS

⍪∘⊖⍨c,⍨⌽1↓[2]c←↑,\⎕←⎕/'+'

Probieren Sie es online!

Erläuterung:

⍪∘⊖⍨c,⍨⌽1↓[2]c←↑,\⎕←⎕/'+'  ⍝ Full program
                       ⎕/'+'  ⍝ Get input from user as N, replicate '+' N times
                    ⎕←        ⍝ Print above string
                  ,\           ⍝ Find all prefixes of above string, e.g. '+','++','+++' etc.
                 ↑             ⍝ Mix the above into a matrix - right-pads with spaces as needed
               c←              ⍝ Assign above matrix to 'c' for 'corner'
          1↓[2]                ⍝ Drop the first column
        ⌽                     ⍝ Reverse the resulting matrix
     c,⍨                      ⍝ Append 'c' to above - this gives us the top half
⍪∘⊖⍨                         ⍝ Take the above, flip it about the horizontal axis,
                              ⍝ and append it to itself

Java 8, 159 Bytes

n->{String r="",N="\n",t=r;for(int i=n,j,k;i-->0;t+="+",r+=i>0?N:"")for(j=-n;++j<n;r+=k<n?"+":" ")k=i+(j<0?-j:j);return t+N+r+N+new StringBuffer(r).reverse();}

Kann definitiv noch mehr golfen, aber es ist ein Anfang.

Erläuterung:

Probieren Sie es online aus.

n->{                    // Method with integer parameter and String return-type
  String r="",          //  Result-String, starting empty
         N="\n",        //  Temp-String for new-line to save bytes
         t=r;           //  First-line String, starting empty
  for(int i=n,j,k;i-->0 //  Loop `i` in the range (n,0]
      ;                 //    After every iteration:
       t+="+",          //     Append a "+" to the first-line String
       r+=i>0?N:"")     //     Add a new-line if this isn't the last iteration of `i` yet
    for(j=-n;++j<n;     //   Inner loop `j` in the range (-n,n]
        r+=             //     After every iteration, append the result with:
           k<n?         //      If `k` is smaller than the input `n`:
            "+"         //       Append a "+"
           :            //      Else:
            " ")        //       Append a space instead
      k=i+(j<0?-j:j);   //    Set `k` to `i` plus the absolute value of `j`
  return t+N            //  Return the first-line String plus new-line,
         +r+N           //   plus the result-String plus new-line,
         +new StringBuffer(r).reverse();}
                        //   plus the result-String again reversed

Japt -R , 18 16 Bytes

õ_ç+ êÃê1 û i+pU

Versuch es

Erläuterung

                     :Implicit input of integer U
õ                    :Range [1,U]
 _    Ã              :Pass each Z through a function
  ç+                 :  Repeat "+" Z times
     ê               :  Palindromise
       ê1            :Mirror
          û          :Centre pad each element to the length of the longest element
            i        :Prepend
             +pU     :  "+" repeated U times
                     :Implicitly join with newlines and output

Attache , 62 Bytes

{"+"*_+lf+UnGrid!Bounce=>"+ "[Table[`>,1:_]|>~`'#Reverse|>@N]}

Probieren Sie es online!

Ein Lambda, das die Ganzzahl als Argument verwendet.

Beispiel

A> n := 3
3
A> Table[`>,1:n]
 false false false
  true false false
  true  true false
A> Table[`>,1:n]|>~`'#Reverse
  true  true false
  true false false
 false false false
 false false false
  true false false
  true  true false
A> Table[`>,1:n]|>~`'#Reverse|>@N
 1 1 0
 1 0 0
 0 0 0
 0 0 0
 1 0 0
 1 1 0
A> "+ "[Table[`>,1:n]|>~`'#Reverse|>@N]
 " " " " "+"
 " " "+" "+"
 "+" "+" "+"
 "+" "+" "+"
 " " "+" "+"
 " " " " "+"
A> Bounce=>"+ "[Table[`>,1:n]|>~`'#Reverse|>@N]
 " " " " "+" " " " "
 " " "+" "+" "+" " "
 "+" "+" "+" "+" "+"
 "+" "+" "+" "+" "+"
 " " "+" "+" "+" " "
 " " " " "+" " " " "
A> UnGrid!Bounce=>"+ "[Table[`>,1:n]|>~`'#Reverse|>@N]
"  +  \n +++ \n+++++\n+++++\n +++ \n  +  "
A> lf+UnGrid!Bounce=>"+ "[Table[`>,1:n]|>~`'#Reverse|>@N]
"\n  +  \n +++ \n+++++\n+++++\n +++ \n  +  "
A> "+"*n+lf+UnGrid!Bounce=>"+ "[Table[`>,1:n]|>~`'#Reverse|>@N]
"+++\n  +  \n +++ \n+++++\n+++++\n +++ \n  +  "
A> Print[_]
+++
  +
 +++
+++++
+++++
 +++
  +
["+++\n  +  \n +++ \n+++++\n+++++\n +++ \n  +  "]
A>

T-SQL, 152 Bytes

Gemäß unseren E / A-Regeln erfolgt die Eingabe über die bereits vorhandene Tabelle t mit einem ganzzahligen Feld n .

DECLARE @n INT,@ INT=1,@k INT=1SELECT @n=n FROM t
PRINT REPLICATE('+',@n)a:PRINT SPACE(@n-@)+REPLICATE('+',2*@-1)IF @=@n SET @k-=1SET @+=@k IF @>0GOTO a

Manuelle Zählschleife, nicht sehr "SQL-ähnlich". Formatiert:

DECLARE @n INT,@ INT=1,@k INT=1
SELECT @n=n FROM t
PRINT REPLICATE('+',@n)
a:
    PRINT SPACE(@n-@)+REPLICATE('+',2*@-1)
    IF @=@n SET @k-=1
    SET @+=@k
IF @>0 GOTO a