Desafío:

Dado un entero ncomo entrada. Crea un diamante que sea 2 veces el número dado n.

Entrada:

La entrada es entera ny 2 <n ≤ 3000.

Salida:

Salida será una cadena y será en forma de un diamante que consiste +en una línea de adición a la proyección de inicio nutilizando+

Ejemplos:

D (3):

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

D (5):

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

D (6): 

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

Criterios ganadores:

Este es el código de golf, por lo que gana el código más corto en bytes para cada lenguaje de programación.

brainfuck , 151 139 bytes

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

Pruébalo en línea!

Toma entrada vía unario, con + s como marcas de conteo ( permitidas por el póster ). Decidí reelaborar esto, ya que pensé que el viejo era un poco más largo de lo que podría ser (¡aunque este también lo es!).

Versión anterior (151 bytes):

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

Pruébalo en línea!

Toma la entrada como la celda inicial. No se me ocurrió una manera de aprovechar la primera mitad para ayudar con la segunda, por lo que hay un ciclo para cada uno de ellos.

Cómo funciona:

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

Y solo por diversión:

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

Pruébalo en línea!

Lienzo , 9 bytes.

+×Ｏ｛+×］±╪

Pruébalo aquí!

Explicación (algunos caracteres han sido reemplazados para parecer monoespaciales):

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

Pruébalo en línea!

Mi primer intento de jugar al golf, cualquier sugerencia de mejora es bienvenida.

EDITAR: guardado 1 byte gracias a Kevin Cruijssen

EDITAR: eliminó los malentendidos sobre el recuento de bytes

EDITAR: ahorró muchos más bytes gracias a Jo King y al usuario202729

05AB1E , 14 bytes

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

Pruébalo en línea!

Explicación

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

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

Pitón 3 , 79 78 bytes

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

Pruébalo en línea!

Gracias a estos consejos para jugar golf, Python responde por informarme sobre la .centerfunción. Devuelve una lista de cadenas.

R , 135110 96 bytes

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

Pruébalo en línea!

@ JayCe con el corte final.

La repfunción se asigna a un operador infijo existente, tal <o como ^eso rep("+", n)es equivalente a lo "<"("+", n)que se puede escribir usando <como operador infijo como en "+" < ny acortado a "+"<n.

Carbón de leña , 15 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｇ→→↙Ｎ+

Imprima un triángulo invertido de +s la altura de la entrada y casi el doble del ancho.

↓

Mueva el cursor hacia abajo para que caiga en la línea adicional después del reflejo.

‖Ｍ↑

Haz una imagen especular del triángulo.

×⊕ⅈ+

Dibuje la línea adicional usando la columna actual para evitar tener que volver a leer la entrada.

‖

Refleje la salida para que la línea adicional apunte a la izquierda.

Stax , 11 bytes

ñ1┌╙@↔g+┤a☻

Ejecutar y depurarlo

Python 3 , 76 75 bytes

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

Pruébalo en línea!

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) , 106105 bytes

• gracias a @Kevin Cruijssen por reducir en 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`
`

Pruébalo en línea!

________________________________________________

Segundo enfoque

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

• gracias a @Kevin Cruijssen por reducir en 1 byte
• gracias a @ovs por reducir en 1 byte

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

Pruébalo en línea!

Japt -R , 18 17 bytes

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

Pruébalo en línea!

PowerShell , 55 bytes

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

Pruébalo en línea!

J , 29 bytes

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

Pruébalo en línea!

Explicación:

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

^{Guardado 3 bytes gracias a nimi !}

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

Pruébalo en línea!

Ruby , 71 61 bytes

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

Pruébalo en línea!

PHP, 103 bytes

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

Ejecute como pipe con `-nR´ o pruébelo en línea .

PowerShell , 58 bytes

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

Pruébalo en línea!

Simplemente un bucle hacia arriba y hacia abajo, cada iteración genera el número apropiado de espacios y luego el número apropiado de signos más. 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)

Pruébalo en línea!

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

Sé que puede ser mucho más pequeño que esto;) Greetz mangas

sed 4.2.2 , 69

La puntuación incluye +1 para la -ropción de sed.

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

Pruébalo en línea!

Ruby , 59 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Versión legible:

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

Una función anónima que toma la entrada como un número unario con +marcas de conteo y salidas a la consola.

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

Pruébalo en línea!

Versión alternativa, 117 bytes

Una respuesta de función anónima que toma la entrada como un entero decimal y las salidas a la consola.

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

Pruébalo en línea!

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

Pruébalo en línea!

Actualicé mi respuesta gracias a @JoKing

APL (Dyalog Unicode) , ^{SBCS de} 25 bytes

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

Pruébalo en línea!

Explicación:

⍪∘⊖⍨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();}

Definitivamente se puede jugar un poco más, pero es un comienzo.

Explicación:

Pruébalo en línea.

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

Intentalo

Explicación

                     :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

Adjunto , 62 bytes

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

Pruébalo en línea!

Una lambda que toma el entero como argumento.

Ejemplo

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

Según nuestras reglas de IO , la entrada se toma a través de la tabla t preexistente con un campo entero 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

Bucle de conteo manual, no muy "similar a SQL". Formateado:

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