Diamond creator +

Question

Challenge :

Given an integer n as input. Create a diamond that is 2x the given number n.

Input :

Input is integer n and 2 < n ≤ 3000.

Output :

Output will be a string and it will be in form of a diamond consisting of + with an addition line at the start showing n using +

Examples :

D(3) :

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

D(5) :

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

D(6) : 

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

Winning Criteria :

This is code-golf so shortest code in bytes for each programming language wins.

Answer 1

brainfuck, 151 139 bytes

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

Try it online!

Takes input via unary, with +s as tally marks (allowed by the poster). Decided to rework this, as I thought the old one was a bit longer than it could be (though this one is too!).

Old Version (151 bytes):

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

Try it online!

Takes input as the starting cell. I couldn't think of a way to leverage the first half to help with the second, so there's a loop for each of them.

How It Works:

 >--[>+<++++++]  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
]

And just for fun:

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

Try it online!

Answer 2

Canvas, 9 bytes

+×Ｏ｛+×］±╪

Try it here!

Explanation (some characters have been replaced to look monospace):

+×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

Answer 3

Python 3, 95 94 75 bytes

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

Try it online!

---

My first attempt at some golfing, any suggestions for improvement are welcome.

EDIT: saved 1 byte thanks to Kevin Cruijssen

EDIT: removed misunderstanding about byte count

EDIT: Saved many more bytes thanks to Jo King and user202729

Answer 4

05AB1E, 14 bytes

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

Try it online!

Explanation

'+×              # 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

Also 14 bytes: L‚˜'+×ćs.∞∊.c»

Answer 5

Python 3, 79 78 bytes

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

Try it online!

Thanks to this Tips for golfing Python answer for informing me about the .center function. Returns a list of strings.

Answer 6

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

Try it online!

@JayCe with the final cut.

The rep function is assigned to an existing infix operator, such as < or ^ so that rep("+", n) is equivalent to "<"("+", n) which can be written out using < as an infix operator as in "+" < n and shortened to "+"<n.

Answer 7

Charcoal, 15 bytes

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

Try it online! Link is to verbose version of code. Explanation:

Ｇ→→↙Ｎ+

Print an inverted triangle of +s the height of the input and almost twice the width.

↓

Move the cursor down so it lands on the additional line after the reflection.

‖Ｍ↑

Make a mirror image of the triangle.

×⊕ⅈ+

Draw the additional line using the current column to avoid having to read the input again.

‖

Reflect the output so that the additional line points to the left.

Answer 8

Python 3, 76 75 bytes

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

Try it online!

Answer 9

Stax, 11 bytes

ñ1┌╙@↔g+┤a☻

Run and debug it

Answer 10

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

Answer 11

JavaScript (Node.js), 106 105 bytes

• thanks to @Kevin Cruijssen for reducing by 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`
`

Try it online!

________________________________________________

Second approach

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

• thanks to @Kevin Cruijssen for reducing by 1 byte
• thanks to @ovs for reducing by 1 byte

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

Try it online!

Answer 12

J, 29 bytes

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

Try it online!

Explanation:

'+'$~] - 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
+++  
  +  
 +++ 
+++++
+++++
 +++ 
  +  

Answer 13

Haskell, 85 82 bytes

^{Saved 3 bytes thanks to nimi!}

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

Try it online!

Answer 14

Japt -R, 18 17 bytes

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

Try it online!

Answer 15

PowerShell, 55 bytes

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

Try it online!

Answer 16

Ruby, 71 61 bytes

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

Try it online!

Answer 17

PHP, 103 bytes

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

Run as pipe with `-nR´ or try it online.

Answer 18

PowerShell, 58 bytes

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

Try it online!

Simply a loop-up and -down, each iterating outputting the appropriate number of spaces and then the appropriate number of plus signs. Ho-hum.

Answer 19

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)

Try it online!

Answer 20

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);

Ik know it can be much smaller than this ;) Greetz mangas

Answer 21

Yabasic, 102 bytes

An anonymous function that takes input as a unary number with + tally marks and outputs to the console.

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

Try it online!

Alternate Version, 117 bytes

An anonymous function answer that takes input as a decimal integer and outputs to the console.

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

Try it online!

Answer 22

sed 4.2.2, 69

Score includes +1 for the -r option to sed.

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

Try it online!

Answer 23

Ruby, 59 bytes

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

Try it online!

Answer 24

JavaScript (Node.js), 183 bytes

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);}

Try it online!

Updated my answer thanks to @JoKing

Answer 25

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

Try it online!

Readable 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)))

Answer 26

APL (Dyalog Unicode), 25 bytes^SBCS

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

Try it online!

Explanation:

⍪∘⊖⍨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

Answer 27

Japt -R, 18 16 bytes

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

Try it

---

Explanation

                     :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

Answer 28

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

Can definitely be golfed some more, but it's a start.

Explanation:

Try it online.

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

Answer 29

Attache, 62 bytes

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

Try it online!

A lambda which takes the integer as an argument.

Example

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>

Answer 30

T-SQL, 152 bytes

Per our IO rules, input is taken via pre-existing table t with a integer field 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

Manual counting loop, not very "SQL-like". Formatted:

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

Answer 31

V, 20 bytes

é+ÄÀ­ñ>GMÙX2é+ÄHñÄÒ+

Try it online!

Hexdump:

00000000: e92b c4c0 adf1 3e47 4dd9 5832 e92b c448  .+....>GM.X2.+.H
00000010: f1c4 d22b                                ...+

Explanation:

é+                      " Insert a '+' character
  Ä                     " Duplicate this line
   À­                   " 'arg' - 1 times...
     ñ          ñ       " Repeat the following code:
      >G                "   Indent every line
        M               "   Move to the center line
         Ù              "   Duplicate this line
          X             "   Delete the first character of it (the space)
           2é+          "   Insert two '+' characters
              Ä         "   Duplicate this new line we made
               H        "   Return to the first line
                 Ä      " After the loop is over, duplicate the top line
                  Ò+    " Replace every character on this line with a '+'

Answer 32

Excel VBA, 89 bytes

Anonymous VBE immediate window function that takes input as a unary number with + tally marks from range [A1] (ie [A1]="++++") that outputs to the VBE immediate window.

?[A1]:n=[Len(A1)]:For i=-n To n:i=i-(i=0):j=Abs(i):?Spc(j-1)Mid([A1&A1],1,2*(n-j)+1):Next

Alternate Version, 96 bytes

Anonymous VBE immediate window function that takes input as a decimal number from range [A1] that outputs to the VBE immediate window.

?[Rept("+",A1)]:For i=[-A1]To[A1]:i=i-(i=0):[B1]=Abs(i):?Spc([B1]-1)[Rept("+",2*(A1-B1)+1)]:Next

Answer 33

Phooey, 82 bytes

&.@@($c43-1)&>&1<[-1$c10@[-1$c32]&>@[-1$c43]&+2<][!$c10@[-1$c32]&+1>-2@[-1$c43]&<]

Try it online!

Phooey is an extended form of Foo, adding input, sane loops, and some helper functions.

Answer 34

Swift, 218 169 bytes

Sadly, I could not use map instead of for loops, since it timed out.

func r(i:Int)->String{var l="";for j in(0...i*2){for k in(0..<i*2-1){l+=j==0&&k<i||j>0&&(j>i ?j-i-1:i-j)...(j>i ?i*3-1-j:i+j-2)~=k ?"+":" "};if j<i*2{l+="\n"}};return l}

Prettyfied:

func r(i: Int) -> String {
    var l = "";

    for j in (0 ... i * 2) {
        for k in (0 ..< i * 2 - 1) {
            l += (j == 0 && k < i) ||
            (j > 0 && (j > i ? j - i - 1 : i - j) ... (j > i ? i * 3 - 1 - j : i + j - 2) ~= k) ? "+" : " "
        }

        if j < i * 2 {
            l += "\n"
        }
    }

    return l
}

Try it online!

Answer 35

Retina, 35 bytes

¶<,-2`\+
 
\+` (\++)$
$&$%"$1++
^O`

Takes unary + as input

Try it online!

Answer 36

Jelly, 18 17 14 13 bytes

”+ẋṄ¹Ƥz⁶ŒBṚ;$

Try it online!

-1 byte thanks to Erik the Outgolfer

”+ẋṄ¹Ƥz⁶ŒBṚ;$
”+                  '+' literal
  ẋ                 repeat this <input> number of times: '+++'
   Ṅ                print this string + a new line
    ¹Ƥ              get the prefixes: ['+', '++', '+++']
      z             transpose and fill with...
       ⁶            space (' '). yields ['+++', ' ++', '  +']
        ŒB         palindromize each row: ['+++++', ' +++ ', '  +  ']
          Ṛ;$      reverse and append with itself.

Answer 37

R, 141 139 137 135 126 bytes

Another approach borrowing from the other R answer to this challenge by ngm as well as this other answer from Kirill L.:

function(n)cat(c(g(n),format(sapply(c(1:n,n:1),function(i)g(2*i-1)),j="c",w=2*n-1)),sep="
")
g=function(x)intToUtf8(rep(43,x))

Try it online!

Below a fully recursive solution growing the initial line and the diamond at each step:

function(n)cat("
",intToUtf8(rbind(t(f(n)[c(1:n,n:1),-1]),13)),sep="")
f=function(n)"if"(n,{cat("+");rbind(cbind(32,f(n-1),32),43)},43)

Try it online!

Answer 38

CJam, 34 bytes

q~:X,'+X*n{_X-~' *\2*)'+*+}%_W%+:n

Try it online!

Still wrapping my head around CJam, could probably be improved.

Answer 39

MY-BASIC, 126 bytes

An anonymous function that takes input as a unary number with + tallys

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

Try it online!

Answer 40

uBASIC, 114 bytes

0input"",s$:n=len(s$):?s$:fork=2ton:t$=t$+" ":nextk:fork=0-nton:f=abs(k):iffthen?mid$(t$+s$+s$,n-f+1,2*n-f)
1nextk

Try it online!

Answer 41

C (gcc), 111 bytes

Rather than having two loops (one for [0..i-1] and [i-i..0]), I loop for 2*i iterations and compute the offsets from 0 for the first half and from 2*i for the last half. printf() takes care of the spacing!

f(i,j,k){char s[9999];for(memset(s,43,j=2*i+1),k=-1;printf("%*.*s\n",i+k,~k?2*k+1:i,s),--j;)k=(j>i)?2*i-j:j-1;}

Try it online!

Answer 42

Oracle SQL, 166 bytes

select decode(x,1,lpad('x',n,'x'),lpad(' ',n-y,' ')||lpad('x',2*y-1,'x'))from(select level x,abs(trunc((level-2)/n)*(2*n+1)+1-level)y,n from t connect by level<2*n+2)

Test in SQL*PLus (This table is used as an input create table t(n) as select 5 from dual)

SQL> set pages 0 lines 2000 feedback off
SQL> select decode(x,1,lpad('x',n,'x'),lpad(' ',n-y,' ')||lpad('x',2*y-1,'x'))
  2  from(select level x,abs(trunc((level-2)/n)*(2*n+1)+1-level)y,n from t connect by level<2*n+2)
  3  /
xxxxx
    x
   xxx
  xxxxx
 xxxxxxx
xxxxxxxxx
xxxxxxxxx
 xxxxxxx
  xxxxx
   xxx
    x

Answer 43

C# (Visual C# Interactive Compiler), 105 bytes

n=>new int[2*n+1].Select((_,i)=>new String('+',i<1?n:i>n?4*n-2*i+1:2*i-1).PadLeft(i<1?0:i>n?3*n-i:n+i-1))

Try it online!

The idea is to create an enumerator with length equal to the number of returned lines. Iterate over the enumerator and return strings of + characters with varying padding dependent upon the current index in the enumeration.

// n is the diamond size
n=>
  // create an array to iterate over
  new int[2*n+1]
  // this version of select includes an index
  .Select((_,i)=>
    // create the diamond body
    new String('+',i<1?n:i>n?4*n-2*i+1:2*i-1)
    // pad according
    .PadLeft(i<1?0:i>n?3*n-i:n+i-1))