[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](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest code in bytes for each programming language wins.
  
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~151~~ 139 bytes
```
,[.[<]<+[>>]++++[-<++++++++>],]<[<]<<<++++++++++.>>[[>]>[-<+>]>[-<+>]>>[.>>]<<[<]<<.<<[..<<]<.>>-]>[[>]>[.>>]<<[<<]>.>>[..>>]<<,<[<]<<.>>>]
```
[Try it online!](https://tio.run/##RY1RCoBACEQP5K4nkLmIzEcFQQR9BJ3f3HYrPxxmfOp8TtuxXsseUVzdaOIAJcurySiw0NrQvkhEAXcQjfsFnnmCD62pmo2WYeXgX8CIdkO7L2MF6SL6ixs "brainfuck – Try It Online")
Takes input via unary, with `+`s as tally marks ([allowed by the poster](https://codegolf.stackexchange.com/questions/162798/diamond-creator/162810#comment394423_162798)). 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!](https://tio.run/##bYxBCoBQCEQPJHaCYS4iLioIImgRdH5T/182C3FmfG7Pet7Hu18hpaCqUdBGHKYULoDLlClGSzpqGrCQ2nltHBA817rOqEyD2aGKZPr2B5Lxa1I6KY/4AA "brainfuck – 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!](https://tio.run/##VY9LCgMxDEP3PkX2wTmB0EVCFtNCoRRmUej5M1Y@pfUiyMhPsW/v43k@PvdX73mXpVXcyr0uyYw9oNGGaTgzC9CGtWKqQy2kyQa9lipQSJcpZXJq4GgkxVjY6gYfJmApvOAGuVOlN6pPA5ixZW49MtSvZWO2fU/7O/P34tz7BQ "brainfuck – Try It Online")
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 9 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
+×Ｏ｛+×］±╪
```
[Try it here!](https://dzaima.github.io/Canvas/?u=KyVENyV1RkYyRiV1RkY1QislRDcldUZGM0QlQjEldTI1NkE_,i=NQ__,v=2)
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]
# [Python 3](https://docs.python.org/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!](https://tio.run/##FYoxDkIhEAWvsh2L5Bt/7DCeBClIBF2LB9nwCxuvjjDVTDLt298V1zGeuVBhWJ/uwZA5MdxPrDNuqmxTS1USEpAmvPI8401zPxRhPYguuRS83/Y4mgo6mwfM@VMFXHi1oB2d7WLslz8 "Python 3 – 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]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 14 bytes
```
'+×sL·<'+×∊.c»
```
[Try it online!](https://tio.run/##MzBNTDJM/f9fXfvw9GKfQ9ttQIxHHV16yYd2//9vCgA "05AB1E – 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]
# [Python 3](https://docs.python.org/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!](https://tio.run/##FcpBDsIgEEbhq7CbgYmN1R3GkyALo6C4@GkmNKGnx/btXvItW/tWXMd4p2wyw/p@D0wi5IqQkJ1eCS0pw11srmqKKTD6xCftON40tVUR4HYbpUsP3p/mOBYtaEwP0PSrBZz5@IJlbWyPxnz@Aw "Python 3 – Try It Online")
Thanks to this [Tips for golfing Python](https://codegolf.stackexchange.com/a/98613/76162) answer for informing me about the `.center` function. Returns a list of strings.
[Answer]
# [R](https://www.r-project.org/), ~~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!](https://tio.run/##Tcs7DoAgDADQnVOQTq3CgIMDgcMYYpMu1aBOxrPjZ3J/rza2yTc@tOyyKCqdZdoRekjqwIDb5jUDkOGlolhRWzBEdRoD0SftI724dwyd@PBfl4EEuc5rYxyp3Q "R – 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]
# [Charcoal](https://github.com/somebody1234/Charcoal), 15 bytes
```
Ｇ→→↙Ｎ+↓‖Ｍ↑×⊕ⅈ+‖
```
[Try it online!](https://tio.run/##RYyxCsJAEER7vyKk2sNY2iStTcBICAq28dwkB3e7Yd1E/PrzENFqZh4zY6deLPc@xpb9a2SCsnPjpEX20wM/6YhDsjXNi56WcEMBU2T5NjfVpuEV4VNKocPBo9XGibBAeZkTa8WRwtkFfEBNVjAgKd7hCuZ78h@CqWLcx93q3w "Charcoal – 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]
# [Stax](https://github.com/tomtheisen/stax), 11 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
ñ1┌╙@↔g+┤a☻
```
[Run and debug it](https://staxlang.xyz/#p=a431dad3401d672bb46102&i=9&a=1)
[Answer]
# [Python 3](https://docs.python.org/3/), ~~76~~ 75 bytes
```
lambda n:['+'*n]+[' '*(n+~i)+'+'*(i-~i)for i in[*range(n),*range(n)[::-1]]]
```
[Try it online!](https://tio.run/##PcixDoIwEAbgV@l2d60YiVsTn6R0KNHCGf1LGhYWXr3I4vblW7Z1Lri3/BjaJ33HZzLwgRxZRBfIkGW4XcWdxdr9mEs1ahTB1oTpxZDLX8H7ro8xtqUqVqYBdH0XBWfubyLSDg "Python 3 – Try It Online")
[Answer]
## 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]
# [J](http://jsoftware.com/), ~~29~~ 22 bytes
-7 bytes thanks to Jonah!
```
' +'{~#&1,]>:[:+/~|@i:
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/1RW01avrlNUMdWLtrKKttPXrahwyrf5rcqUmZ@QrpCmY/gcA "J – Try It Online")
### Original solution:
# [J](http://jsoftware.com/), 29 bytes
```
'+'(,]\(}:@|."1,.])@,]\.)@$~]
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/1bXVNXRiYzRqrRxq9JQMdfRiNR2AfD1NB5W62P@aXApcqckZ@QppCsYwhimMYWjC9R8A "J – 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]
# [Scala](http://www.scala-lang.org/), ~~95~~ 94 bytes
saved 1 byte(s) thanks to the comment.
---
Golfed version. [Try it online!](https://tio.run/##JY3BCsIwDIbve4rQU2phbB4nEzx68DQ8qYc4O6l2UbtuIGO@@mwVEgjf/4evq8nS/DjfdO1hR4ZhnC@6gQa52LKX5TiQBSoxg569scAybemJplwLEAv8GMVSCRXO5cKoXMrUPyr9WoXFiEOqKEzq9KBdp6c5AYiGNsiQ3LUrYOMcvQ@Vd4avJ1nAno2HEsbQBIh@p7veRtRgnskffoayt4z/KG3v/3cURxYyVqZkSuYv)
```
def f(n:Int)={val a=(0 until n).map(i=>" "*(~i+n)+"+"*(2*i+1)).toSeq;Seq("+"*n)++a++a.reverse}
```
Ungolfed version.
```
object Main {
  def f(n: Int): Array[String] = {
    val a = (0 until n).map(i => " "*(n-1-i) + "+"*(2*i+1)).toArray
    Array("+"*n) ++ a ++ a.reverse
  }
  def main(args: Array[String]): Unit = {
    val result = f(10)
    println(result.mkString("\n"))
  }
}
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 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!](https://tio.run/##XY3NCoMwEITvPkXwlLg1VNtehCh9jlKaYLWs2I2oFHrpq6dW/KEedhiY@XYq8zJd3mLTh2TvhSuVI5VepJTntjVvTkEMkbjKp2k4v@1QqNRnvmyLpjA9xwxTyhA@lFCIyV6AD5vwGFAYBwhRgkEcRgkJISuLpD3tckudrQtZ2wcv@UEopQHAY2y4nwFYlU2JFoP@g6cJHAsjzOb2gq6fNm4Jl/YMj2PuCw "JavaScript (Node.js) – Try It Online")
## \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
Second approach
# [JavaScript (Node.js)](https://nodejs.org), 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!](https://tio.run/##XY3PCsMgDIfvfQrxpGT1MnZMn6NQZEpnh6XTYkvZaa/unOsftkN@JOT7kl4vemqDHefS@ZuJHUaHVVMjBdoEpMGMRs9UMsdPQognNilrKR56ZOx6shwrShKZAHhZDlmTzJZp@BoimMWEyTAuRe@tU4WKrXeTH4wY/J117MwRFQAUhKT6NABHknWjeMpf8bKKGcgy2ehdPS79dftypzc5P4tv "JavaScript (Node.js) – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt) `-R`, ~~18~~ 17 bytes
```
õÈ+Y î+Ãû ê1 iUî+
```
[Try it online!](https://tio.run/##y0osKPn///DWwx3akQqH12kfbj68W@HwKkOFzFAg7/9/YwXdIAA)
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 55 bytes
```
param($l)'+'*$l;1..$l+$l..1|%{" "*($l-$_)+'+'*($_*2-1)}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/vyCxKDFXQyVHU11bXUslx9pQT08lR1slR0/PsEa1WklBSQsoqasSr6kNUqChEq9lpGuoWfv//39jAA "PowerShell – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), ~~85~~ 82 bytes
Saved 3 bytes thanks to [nimi](https://codegolf.stackexchange.com/users/34531/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!](https://tio.run/##y0gszk7Nyfn/P08x2TbaUE8vL9bOLpkrTSGvpsJGN1ojTzdTU1FJQUlbWyNTy0jXEMjRVqrJBEqB1cbalublZOalFqvkgSSsKrS1i1LLUouKUxUq/ucmZuYp2Cqk5HMpQEBBaUlwSZFPnoKKQpqCMVZRU6yiZv8B "Haskell – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/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!](https://tio.run/##Lcs7DsIwEEXRnlVYrublJzkRjSNWkqRA2IGhGEf2NKzeoIju6kj3@OgryVRriLsJVOCPzKJkW9sUzHpbzmQMjygaM41N6R32lA0bFpPv8ozkuh93I7b5f69ih3diIW118b53G1ADTbgEuqJ@AQ "Python 3 – 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]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~9~~ 8 bytes
```
Dη€û.C∊»
```
[Try it online!](https://tio.run/##yy9OTMpM/f/f5dz2R01rDu/Wc37U0XVo9///2mAAAA "05AB1E – Try It Online") Takes input in unary with `+` as a tally mark; allowed as per [OP's comment](https://codegolf.stackexchange.com/questions/162798/diamond-creator?page=2&tab=oldest#comment394399_162798).
```
Dη€û.C∊»  # full program
       »  # join...
D         # implicit input...
       »  # and...
 η        # prefixes of...
D         # implicit input...
  €       # with each element...
   û      # concatenated with...
          # (implicit) current element in list...
   û      # reversed excluding the first character...
    .C    # with...
          # (implicit) each element...
    .C    # centered by spaces to length of longest element in this list (extra space on the left if unequal spaces)...
      ∊   # mirrored vertically...
       »  # by a newline
          # implicit output
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~71~~ 61 bytes
```
->n{[?+*n]+(a=(1..n).map{|x|?\s*(n-x)+?+*(x+x-1)})+a.reverse}
```
[Try it online!](https://tio.run/##DcoxDoAgDADArzi2NjQhzuhD1AENTEgIqMGAb0dvvnhtT7OqidGXeaLerwRagWT2yIcOpeY6LakHLzLSHyBTFhJfJM3R3CYm87ZwnamzvGvnYMD2AQ "Ruby – Try It Online")
[Answer]
# 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](http://sandbox.onlinephpfunctions.com/code/3199ee83cc4499000c1f8a1fbc808ef40170311d).
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 58 bytes
```
param($n)'+'*$n;1..$n+$n..1|%{" "*($n-$_)+"+"*$_+"+"*--$_}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/vyCxKDFXQyVPU11bXUslz9pQT08lT1slT0/PsEa1WklBSQsoqasSr6mtpK2kpRIPpnSBArX///83AwA "PowerShell – 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]
# [F# (Mono)](http://www.mono-project.com/), 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!](https://tio.run/##JY1NCoMwEEb3PcUQEBPThKZ7pXdwaV0ISUpBJ7aTggXvnk5x93h8P5HMkjCVtAaE/ks5LGUOGTxge4I/ZaY@v5/4kLWuz6gOTayzxOZqHJvBWYvjbUBrwTC7ce/68LIxzV7GD8IEm@kmTSsP5SjuWDUkJOqN65JgU0rykSoe3AX2Do4cgqhIlB8 "F# (Mono) – Try It Online")
[Answer]
# 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]
# [sed 4.2.2](https://www.gnu.org/software/sed/), 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!](https://tio.run/##K05N@f8/g6tS31BfW5@rgKuCq1jfMMZJX0E/HSFoBRRUiNHW19bW1i/gKgGJJAKFYrSBYgogkUQuoCmGQPAvv6AkMz@v@L9uEQA "sed 4.2.2 – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 59 bytes
```
->i{[?+*i,b=(1..i).map{|c|' '*(i-c)+?+*(2*c-1)},b.reverse]}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6zOtpeWytTJ8lWw1BPL1NTLzexoLomuUZdQV1LI1M3WVMbKK1hpJWsa6hZq5OkV5RallpUnBpb@7@gtKRYIS3aOPY/AA "Ruby – Try It Online")
[Answer]
# [Yabasic](http://www.yabasic.de), 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!](https://tio.run/##q0xMSizOTP7/3zOvoLRESalYhSvP1ic1T6NYRZPLHshzyy9SyLTVzVMIyVfI48qydUwq1sjU5PJMU8hUAMll2xoBZbLslRSUrP1SK0qs7H0zU1SA2rWLVXQMdYy0NPJ0szS1DTW5QLL//2trawMA "Yabasic – 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!](https://tio.run/##q0xMSizOTP7/3zOvoLRESSmPyy2/SCHT1jAkXyFPoVjFtlhFW0lbyS@1ooTLvlgFKqubpwCS58qydUwq1sjU5PJMU8hUAMll2xoBZbLslRSUrEGarOx9M1NUNICmFKvoGOoYaWnk6WZpahtqcoFk//83BgA "Yabasic – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 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!](https://tio.run/##NYxBDsIgFESv4g7Ip41N3H2/l3DrhgASLAKhxNQYz46VpKvJZN6bh3qpRRef6xCTsa0pWunyccRukWEh/pRR0OVai49uzCXVVN/ZjsVmq@qoVQgdwZkYMAxU@CxXAQ41GWIM76lwT0f0AOcVNWwAOzC5Dl7An91jmDZJmn3vvX/BtKPdcQJ1iksKdgzJ8QAajMBvU/wk2g8 "JavaScript (Node.js) – Try It Online")
Updated my answer thanks to **@JoKing**
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 25 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
```
⍪∘⊖⍨c,⍨⌽1↓[2]c←↑,\⎕←⎕/'+'
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKM97f@j3lWPOmY86pr2qHdFsg6QeNSz1/BR2@Roo9jkR20THrVN1Il51DcVxOybqq@urQ7S9p8zjcuY61HvGi4gwwTGMIUxzEAMAA "APL (Dyalog Unicode) – 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]
# [Canvas](https://github.com/dzaima/Canvas) (v8), ~~8~~ 5 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
［］↔╪∔
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjNCJXVGRjNEJXUyMTk0JXUyNTZBJXUyMjE0,i=KysrKys_,v=8)
Takes input as unary using `+` as tally.
The other Canvas answer here uses v2.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `j`, 6 bytes
```
¦ʁøĊmJ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJqIiwiIiwiwqbKgcO4xIptSiIsIiIsIisrKysrKyJd)
## How?
```
¦ʁøĊmJ
¦      # Prefixes of implicit input
 ʁ     # Palindromize each
  øĊ   # Center
    m  # Mirror each
     J # Join the (implicit) input with this
```
]