Créateur de diamants +

27

Défi :

Étant donné un entier nen entrée. Créez un diamant qui est 2x le nombre donné n.

Contribution :

L'entrée est un entier net 2 <n ≤ 3000.

Sortie:

La sortie sera une chaîne et elle sera sous la forme d'un diamant composé d' +une ligne d'addition au début indiquant l' nutilisation de+

Exemples :

D (3):

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

D (5):

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

D (6): 

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

Critères gagnants:

C'est le code-golf donc le code le plus court en octets pour chaque langage de programmation gagne.

code-golf ascii-art geometry Muhammad Salman
la source
1
Pouvons-nous prendre nunaire?
Adám
3
… En utilisant +comme marque de pointage ?
Adám
1
Pouvez-vous ajouter un cas de test où nest pair?
Shaggy
2
@Shaggy: pourquoi pas. Je vais ajouter cela tout de suite. Merci
Muhammad Salman
1
@ Adám voici le méta-post sur les E / S unaires
Digital Trauma

Réponses:

33

brainfuck , 151 139 octets

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

Essayez-le en ligne!

Prend entrée via unaire, avec +s comme marques de pointage ( autorisé par l'affiche ). J'ai décidé de retravailler cela, car je pensais que l'ancien était un peu plus long qu'il ne pouvait l'être (même si celui-ci l'est aussi!).

Ancienne version (151 octets):

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

Essayez-le en ligne!

Prend l'entrée comme cellule de départ. Je ne pouvais pas penser à un moyen de tirer parti de la première moitié pour aider avec la seconde, donc il y a une boucle pour chacun d'eux.

Comment ça marche:

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

Et juste pour le plaisir:

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

Essayez-le en ligne!

Jo King
la source
2
Vous avez obtenu mon vote pour le juste pour le fun. Réponse cool
Muhammad Salman
15

Canevas , 9 octets

+×Ｏ｛+×］±╪

Essayez-le ici!

Explication (certains caractères ont été remplacés pour paraître monospaces):

+×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
dzaima
la source
12

Python 3 , 95 94 75 octets

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

Essayez-le en ligne!

Ma première tentative de golf, toute suggestion d'amélioration est la bienvenue.

EDIT: sauvé 1 octet grâce à Kevin Cruijssen

EDIT: suppression d'un malentendu sur le nombre d'octets

EDIT: sauvé beaucoup plus d'octets grâce à Jo King et user202729

maxb
la source
5
Bienvenue chez PPCG! :)
Shaggy
1
De plus, si vous passez à Python 2, vous print'\n'.join(['+'*n]+a+a[::-1])pouvez l'utiliser sans parenthèses pour économiser 2 octets supplémentaires. +1 de moi cependant. Belle première réponse. :)
Kevin Cruijssen
1
Les soumissions peuvent être soit un programme complet (rien dans l'en-tête / pied de page) ou une fonction (qui doit définir une fonction (ou une référence, dans le cas d'une fonction anonyme telle que lambda)).
user202729
2
Et, 2*i+1 == i+i+1 == i-(-i-1) == i-~i.
user202729
2
Grande première réponse. bien joué.
ElPedro
8

05AB1E , 14 octets

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

Essayez-le en ligne!

Explication

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

Aussi 14 octets: L‚˜'+×ćs.∞∊.c»

Emigna
la source
1
'+×s·ÅÉ'+×∊.C»utiliser ÅÉest un autre
Magic Octopus Urn
@MagicOctopusUrn: Ma pensée initiale utilisait ÅÉmais je l'ai rejetée parce que je ne pensais pas utiliser ·pour le faire fonctionner.
Emigna
5

Python 3 , 79 78 octets

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

Essayez-le en ligne!

Merci à cette astuce pour jouer au golf en Python pour m'avoir informé de la .centerfonction. Renvoie une liste de chaînes.

Jo King
la source
Le pied de page n'est-il pas inclus dans le nombre d'octets? Dans ce cas, ma solution est de 58 octets
maxb
@maxb Si vous utilisez une fonction, il est généralement correct de renvoyer la sortie sous forme de liste de lignes
Jo King
@JoKing: Hum voudra peut-être faire une nouvelle vérification? TRY
Muhammad Salman
@JoKing: Il échoue.
Muhammad Salman le
1
@ MuhammadSalman 1. Vous testez ma fonction pour n = 3 par rapport au retour pour n = 5, 2. Vous avez une nouvelle ligne de fin dans le test, et 3. Mon code a des espaces de fin sur chaque ligne. Vous devriez peut-être juste regarder la sortie la prochaine fois
Jo King
4

R , 135110 96 octets

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

Essayez-le en ligne!

@JayCe avec la coupe finale.

La repfonction est assignée à un opérateur infixe existant, par exemple <ou ^si rep("+", n)c'est équivalent à ce "<"("+", n)qui peut être écrit en utilisant <comme un opérateur infixe comme dans "+" < net raccourci à "+"<n.

ngm
la source
1
Enregistrez 25 octets et faites-en une fonction.
JayCe
Donc totalement votre réponse :) Super code original!
JayCe
Il y a des espaces ici qui peuvent être supprimés, et utiliser "+"directement au lieu de les enregistrer car zéconomise quelques octets! Essayez-le ici
Giuseppe
1
@ngm @Giuseppe En plus de l'amélioration de Giuseppe, remplacez <pour repobtenir moins de 100 caractères! Ici
JayCe
3

Fusain , 15 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｇ→→↙Ｎ+

Imprime un triangle inversé de +s la hauteur de l'entrée et presque deux fois la largeur.

↓

Déplacez le curseur vers le bas pour qu'il se pose sur la ligne supplémentaire après la réflexion.

‖Ｍ↑

Faites une image miroir du triangle.

×⊕ⅈ+

Tracez la ligne supplémentaire à l'aide de la colonne actuelle pour éviter d'avoir à relire l'entrée.

‖

Reflète la sortie de sorte que la ligne supplémentaire pointe vers la gauche.

Neil
la source
3

QB64, 82 79 octets

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
Corwin Fjeldstrom
la source
3
Bienvenue chez PPCG! Il s'agit d'une excellente première soumission, et je l'ai ajoutée à la liste des solutions publiées alors que QBasic est la langue du mois . Si vous le souhaitez, vous pouvez améliorer cette réponse en ajoutant une courte explication. Profitez de votre temps ici!
DLosc
2

JavaScript (Node.js) , 106 105 octets

  • merci à @Kevin Cruijssen pour avoir réduit d'un octet
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`
`

Essayez-le en ligne!

________________________________________________

Deuxième approche

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

  • merci à @Kevin Cruijssen pour avoir réduit d'un octet
  • merci à @ovs pour avoir réduit de 1 octet
n=>[X="+"[r="repeat"](n),...x=[...X].map((_,i)=>" "[r](n+~i)+"+"[r](i-~i)),...x.reverse()].join`
`

Essayez-le en ligne!

DanielIndie
la source
2
Par convention, vous devriez avoir votre soumission la plus courte en haut de votre message si vous avez plusieurs approches. Cela permet à d'autres personnes de tenter facilement le défi, de rechercher leur langue et de voir comment elles se comparent à votre meilleure réponse (et sont nécessaires pour que les tableaux de bord fonctionnent correctement sur les défis qui ont des tableaux de bord)
Taylor Scott,
2

PowerShell , 55 octets

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

Essayez-le en ligne!

Tor
la source
1
Excellente réponse mais le personnage devrait être à la +place de x. Vous pouvez également rendre votre réponse un peu plus conviviale pour la communauté en utilisant Essayez-le en ligne! et en ajoutant un lien vers votre réponse
Taylor Scott
1
Derp - je ne peux pas croire que je n'ai pas vu ça. Merci!
Tor
2

J , 29 octets

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

Essayez-le en ligne!

Explication:

'+'$~] - 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
+++  
  +  
 +++ 
+++++
+++++
 +++ 
  +
Galen Ivanov
la source
1

PHP, 103 octets

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

Exécuter en tant que pipe avec `-nR´ ou l' essayer en ligne .

Titus
la source
1

PowerShell , 58 octets

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

Essayez-le en ligne!

Simplement une boucle vers le haut et vers le bas, chaque itération produisant le nombre approprié d'espaces, puis le nombre approprié de signes plus. Ho-hum.

AdmBorkBork
la source
1

F # (Mono) , 123 octets

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)

Essayez-le en ligne!

Henrik Hansen
la source
4
Bienvenue chez PPCG.
Muhammad Salman le
Cela ne semble pas fonctionner. De plus, les entrées doivent provenir de STDIN, d'un fichier ou d'un argument de fonction. Nous n'autorisons pas les variables pré-affectées en entrée.
mbomb007
@ mbomb007 Pouvez-vous l'approuver maintenant?
Henrik Hansen
@HenrikHansen: Pourquoi cela donne-t-il une erreur? /home/runner/code.fs(2,10): error FS0039: The value or constructor 'String' is not defined. Cannot open assembly 'code.exe': No such file or directory.
Muhammad Salman le
1
@HenrikHansen: J'ai suggéré une modification. Jetez un coup d'œil
Muhammad Salman
1

PHP 102 octets

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

Je sais que ça peut être beaucoup plus petit que ça;) Greetz mangas

mangas
la source
Bienvenue chez PPCG!
Muhammad Salman le
Votre code semble produire une erreur lorsque j'essaye de l'exécuter?
Muhammad Salman le
Pourquoi avez-vous suggéré cela comme un montage séparé? Cela n'a aucun sens.
Nissa
@StephenLeppik: Oups, probablement une erreur de ma part. Soory
Muhammad Salman
1

Python 3 , 98 octets

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

Essayez-le en ligne!

Version lisible:

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)))
SlayerGames44
la source
Beaucoup mieux :) J'ai formaté votre entrée pour qu'elle ressemble à d'autres réponses. Vous souhaitez visiter tio.run, il formate votre réponse pour vous et permet aux autres de reproduire facilement votre code.
JayCe
1

Yabasic , 102 octets

Une fonction anonyme qui prend l'entrée comme un nombre unaire avec des +marques de pointage et des sorties vers la 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

Essayez-le en ligne!

Version alternative, 117 octets

Une réponse de fonction anonyme qui prend l'entrée sous la forme d'un entier décimal et renvoie à la 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

Essayez-le en ligne!

Taylor Scott
la source
Fonctions anonymes? Ils ressemblent à des programmes entiers pour moi ...
Ørjan Johansen
@ ØrjanJohansen ce terme, pour Yabasic, signifie seulement qu'ils ne sont pas encapsulés comme une subroutine définie par l'utilisateur , ne font partie d'aucune bibliothèque et ne peuvent donc pas être appelés discrètement comme les fonctions intégrées peuvent l'être (par exemple Abs(x)). Vous pouvez en lire un peu plus ici si vous le souhaitez.
Taylor Scott
1

JavaScript (Node.js) , 183 octets

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

Essayez-le en ligne!

Mise à jour de ma réponse grâce à @JoKing

NTCG
la source
@JoKing désolé, mon erreur, je viens de mettre à jour ma réponse, merci mon ami.
NTCG
@JoKing, merci pour votre temps
NTCG
1

APL (Dyalog Unicode) , 25 octets SBCS

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

Essayez-le en ligne!

Explication:

⍪∘⊖⍨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
voidhawk
la source
1↓[2]-> 0 1↓ou encore mieux: c,⍨⌽1↓[2]c←->⍉(⊖⍪1↓⊢)⍉
ngn
0

Java 8, 159 octets

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

Peut certainement être joué au golf un peu plus, mais c'est un début.

Explication:

Essayez-le en ligne.

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
Kevin Cruijssen
la source
0

Japt -R , 18 16 octets

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

Essayez-le

Explication

                     :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
Hirsute
la source
0

Attaché , 62 octets

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

Essayez-le en ligne!

Un lambda qui prend l'entier comme argument.

Exemple

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>
Conor O'Brien
la source
0

T-SQL, 152 octets

Selon nos règles d'E / S , l'entrée est effectuée via une table préexistante t avec un champ entier 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

Boucle de comptage manuelle, pas très "semblable à SQL". Formaté:

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
BradC
la source