Thử thách :

Cho một số nguyên nlàm đầu vào. Tạo một viên kim cương gấp 2 lần số đã cho n.

Đầu vào :

Đầu vào là số nguyên nvà 2 <n 3000.

Đầu ra:

Đầu ra sẽ là một chuỗi và nó sẽ ở dạng một viên kim cương bao gồm +một dòng bổ sung khi bắt đầu hiển thị nbằng cách sử dụng+

Ví dụ:

D (3):

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

D (5):

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

D (6): 

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

Tiêu chí chiến thắng:

Đây là mã golf để mã ngắn nhất tính theo byte cho mỗi ngôn ngữ lập trình sẽ thắng.

Brainfuck , 151 139 byte

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

Hãy thử trực tuyến!

Đưa đầu vào qua unary, với +s là dấu kiểm đếm ( được cho phép bởi người đăng ). Quyết định làm lại cái này, vì tôi nghĩ cái cũ dài hơn một chút so với nó (mặc dù cái này cũng vậy!).

Phiên bản cũ (151 byte):

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

Hãy thử trực tuyến!

Lấy đầu vào là ô bắt đầu. Tôi không thể nghĩ ra cách tận dụng nửa đầu để giúp với phần hai, vì vậy có một vòng lặp cho mỗi người trong số họ.

Làm thế nào nó hoạt động:

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

Và chỉ để cho vui:

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

Hãy thử trực tuyến!

Canvas , 9 byte

+×Ｏ｛+×］±╪

Hãy thử nó ở đây!

Giải thích (một số ký tự đã được thay thế để tìm kiếm không gian):

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

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

Hãy thử trực tuyến!

Nỗ lực đầu tiên của tôi tại một số môn đánh gôn, mọi đề xuất cải tiến đều được hoan nghênh.

EDIT: đã lưu 1 byte nhờ Kevin Cruijssen

EDIT: xóa bỏ hiểu lầm về số byte

EDIT: Đã lưu nhiều byte hơn nhờ Jo King và user202729

05AB1E , 14 byte

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

Hãy thử trực tuyến!

Giải trình

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

Ngoài ra 14 byte: L‚˜'+×ćs.∞∊.c»

Python 3 , 79 78 byte

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

Hãy thử trực tuyến!

Nhờ vào Mẹo này để chơi gôn Python trả lời đã thông báo cho tôi về .centerchức năng. Trả về một danh sách các chuỗi.

R , 135 110 96 byte

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

Hãy thử trực tuyến!

@JayCe với lần cắt cuối cùng.

Các repchức năng được gán cho một nhà điều hành ghi hiện có, chẳng hạn như <hay ^để rep("+", n)tương đương với "<"("+", n)đó có thể được viết bằng cách sử dụng <như một nhà điều hành ghi như trong "+" < nvà rút ngắn xuống còn "+"<n.

Than , 15 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｇ→→↙Ｎ+

In một tam giác ngược có +chiều cao của đầu vào và gần gấp đôi chiều rộng.

↓

Di chuyển con trỏ xuống để nó nằm trên dòng bổ sung sau khi phản chiếu.

‖Ｍ↑

Tạo một hình ảnh phản chiếu của hình tam giác.

×⊕ⅈ+

Vẽ dòng bổ sung bằng cột hiện tại để tránh phải đọc lại đầu vào.

‖

Phản ánh đầu ra để các dòng bổ sung chỉ về bên trái.

Stax , 11 byte

ñ1┌╙@↔g+┤a☻

Chạy và gỡ lỗi nó

Python 3 , 76 75 byte

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

Hãy thử trực tuyến!

QB64, 82 79 byte

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 105 byte

• cảm ơn @Kevin Cruijssen vì đã giảm 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`
`

Hãy thử trực tuyến!

Giới thiệu

Cách tiếp cận thứ hai

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

• cảm ơn @Kevin Cruijssen vì đã giảm 1 byte
• cảm ơn @ovs đã giảm 1 byte

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

Hãy thử trực tuyến!

Japt -R , 18 17 byte

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

Hãy thử trực tuyến!

PowerShell , 55 byte

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

Hãy thử trực tuyến!

J , 29 byte

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

Hãy thử trực tuyến!

Giải trình:

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

^{Đã lưu 3 byte nhờ nimi !}

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

Hãy thử trực tuyến!

Ruby , 71 61 byte

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

Hãy thử trực tuyến!

PHP, 103 byte

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

Chạy như đường ống với `-nR, hoặc thử trực tuyến .

PowerShell , 58 byte

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

Hãy thử trực tuyến!

Đơn giản chỉ là một vòng lặp và xuống, mỗi lần lặp xuất ra số lượng khoảng trống thích hợp và sau đó là số dấu cộng thích hợp. Hồ-hum.

F # (Mono) , 123 byte

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)

Hãy thử trực tuyến!

PHP 102 byte

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

Tôi biết nó có thể nhỏ hơn thế này nhiều;) Greetz mangas

sed 4.2.2 , 69

Điểm bao gồm +1 cho -rtùy chọn để sed.

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

Hãy thử trực tuyến!

Ruby , 59 byte

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

Hãy thử trực tuyến!

Python 3 , 98 byte

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

Hãy thử trực tuyến!

Phiên bản dễ đọc:

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 byte

Một hàm ẩn danh lấy đầu vào là một số đơn vị có +dấu kiểm và đầu ra cho bàn điều khiển.

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

Hãy thử trực tuyến!

Phiên bản thay thế, 117 byte

Một câu trả lời hàm ẩn danh lấy đầu vào là số nguyên thập phân và xuất ra bàn điều khiển.

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Đã cập nhật câu trả lời của tôi nhờ @JoKing

APL (Dyalog Unicode) , 25 byte ^SBCS

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

Hãy thử trực tuyến!

Giải trình:

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

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

Chắc chắn có thể được chơi gôn nhiều hơn, nhưng đó là một sự khởi đầu.

Giải trình:

Hãy thử trực tuyến.

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 byte

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

Thử nó

Giải trình

                     :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

Tùy viên , 62 byte

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

Hãy thử trực tuyến!

Một lambda lấy số nguyên làm đối số.

Thí dụ

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 byte

Theo quy tắc IO của chúng tôi , đầu vào được lấy thông qua bảng t có sẵn với trường số nguyên 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

Vòng lặp đếm thủ công, không giống "SQL". Định dạng:

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