Problem

Gegeben eine positive ganze Zahl nwon < 100

Geben Sie ein Rautenmuster wie folgt aus:

Eingang n=1

/\/\
\/\/

Eingabe n=2:

 /\      /\
//\\/\/\//\\
\\//\/\/\\//
 \/      \/

Eingabe n=3:

  /\                /\
 //\\  /\      /\  //\\
///\\\//\\/\/\//\\///\\\
\\\///\\//\/\/\\//\\\///
 \\//  \/      \/  \\//
  \/                \/

Eingabe n=4:

   /\                              /\
  //\\    /\                /\    //\\
 ///\\\  //\\  /\      /\  //\\  ///\\\
////\\\\///\\\//\\/\/\//\\///\\\////\\\\
\\\\////\\\///\\//\/\/\\//\\\///\\\\////
 \\\///  \\//  \/      \/  \\//  \\\///
  \\//    \/                \/    \\//
   \/                              \/

Und so weiter.

Regeln

• Programm und Funktion erlaubt.
• Leerzeichen dürfen nachgestellt werden.
• Führende Leerzeichen in Zeilen ohne /oder mit \Erlaubnis.
• Nachgestellte und führende Zeilenumbrüche sind erlaubt.
• Kürzester Code in Bytes gewinnen

Das ist wahrscheinlich ziemlich verwandt

SOGL V0.12 , 24 Bytes

ā.∫ā;∫ \*+}ø┼↔±╬¡;øΚ┼}╬³

Probieren Sie es hier aus!

Erläuterung:

ā                         push an empty array (the main canvas)
 .∫                  }    iterate over the input, pushing 1-indexed iteration
   ā;                       push an empty array below the iteration
     ∫    }                 iterate over the iteration counter
       \*                     push current iteration amount of slashes
         +                    append those to the 2nd array
           ø┼               append nothing (so it'd space the array to a square)
             ↔±             reverse horizontally (swapping slashes)
               έ           quad-palindromize with 0 overlap and swapping characters as required
                 ;          get the canvas ontop
                  øΚ        prepend to it an empty line (so the now bigger romb would be one up)
                    ┼       append horizontally the canvas to the current romb
                      ╬³  palindromize horizontally with no overlap and swapping characters

Kohle , 30 27 Bytes

Ｆ⁺¹Ｎ«Ｆι«Ｆ⁴«↙⁻ικ↑⟲Ｔ»←»Ｍι←»‖Ｍ

Probieren Sie es online!Link ist eine ausführliche Version des Codes. Erklärung: Die Zeichenprimitive von Charcoal können einen Diamanten nicht ganz zeichnen, da die diagonalen Bewegungen auf Quadraten derselben Parität bleiben. Bearbeiten: Die neue Lösung besteht darin, eine Seite eines Diamanten zu zeichnen und dann die gesamte Leinwand zu drehen, um die nächste Seite zu zeichnen, sodass ein Diamant in einer Schleife gezeichnet werden kann. Diese Schleife ist dann in einer Schleife enthalten, um alle inneren Diamanten für jeden Diamanten zu zeichnen. Die äußerste Schleife zeichnet alle Diamanten nebeneinander. Zum Schluss wird das Bild gespiegelt.

Beachten Sie, dass Charcoal inzwischen erweitert wurde und ein weiteres Byte mit gespeichert werden kann Increment.

APL (Dyalog) , 70 69 66 Bytes

B←{'/\ '['\/'⍳⍺⍺⍵]}
C←⊢,⌽B
C(⊢⍪⊖B)⊃,/{C⊖A↑⊖' /'[⍵≤∘.+⍨⍳⍵+1]}¨⌽⍳A←⎕

Probieren Sie es online!

Nimmt man an ⎕IO←0, was auf vielen Systemen Standard ist, so ist das Programm 0-indiziert.

Dies ist ein Handel, der Eingaben über STDIN entgegennimmt.

Erläuterung

(etwas veraltet)

Beachten Sie, dass dies ⍺das linke Argument, ⍵das rechte Argument und ⍺⍺der linke Operator ist.

Bist eine Funktion, die beim Spiegeln der Diamanten hilft. Die Zeichenfolge wird als rechtes Argument und die Umkehrfunktion als linkes Argument verwendet (also Bein Operator).

B←{'/\ '['\/'⍳⍺⍺⍵]}
              ⍺⍺⍵            Apply ⍺⍺ on ⍵
         '\/'⍳               Find the index of the reflected string in '\/' (if the character is not found in `'\/'`, then return an index out of the bounds of the string, ie `2` if the character is a space)
   '/\ '[        ]           Use these indexes on '/\ ' to reflect the '/\' characters

Und jetzt gehen wir zum Hauptteil des Programms.

A←⎕              Assign the input to variable A
⍳                Create a range 0 .. A-1
⌽                Reverse it so that it becomes A-1 .. 0
¨                For each element do (the right argument is the element):
 ⍳⍵+1             Create a range 0 .. ⍵
 ∘.+⍨             Create an addition table using the range to result in a matrix like so:
                   0+0 0+1 0+2 .. 0+⍵
                   1+0 1+1 1+2 .. 1+⍵
                   2+0 2+1 2+2 .. 2+⍵
                   ...
                   ⍵+0 ⍵+1 ⍵+2 .. ⍵+⍵
 ⍵≤              The elements of the matrix that are greater than or equal to the ⍵,
                 this creates a triangle matrix that looks like this:
                   0 0 .. 0 1
                   0 0 .. 1 1
                   ..
                   1 1 .. 1 1
 ' /'[...]       Index it in ' /' to get a character matrix
                 (ie replace 0s with spaces and 1s with '/'s)
 ⊖               Flip this vertically
 A↑              Pad the top spaces

Dies ist erforderlich, um sicherzustellen, dass alle für jedes Element im Bereich erstellten Dreiecke ⌽⍳Adieselbe Höhe haben, damit sie später miteinander verkettet werden können.

 ⊖               Flip the matrix vertically again to go back to the original state
 (⊢,  )          Concatenate it with
    ⌽B           itself, but flipped horizontally
,/              Concatenate all triangles formed by the range operator
⊃               The resulting matrix is nested, so this operator "un-nests" it

Jetzt ist der obere linke Teil des Musters fertig. Alles was übrig bleibt, ist es vertikal und dann horizontal zu spiegeln.

(⊢⍪⊖B)          Concatenate the resulting matrix with itself but flipped vertically
                (the vertically flipped matrix is concatenated below of the original matrix)
                Now the left part of the pattern is complete
(⊢,⌽B)         Concatenate the resulting matrix with itself flipped horizontally

Und das ist es! Die Ausgabe ist eine Zeichenmatrix mit /\s und Leerzeichen.

05AB1E , 47 43 41 35 34 33 32 Bytes

'/×ηηvy∞.C.Bø€∞¹NαGð.ø}})øíJ.B»∞

Probieren Sie es online!

(-4 Bytes dank @Emigna, der 3 Verbesserungen vorgeschlagen hat)

Diese Erklärung galt für die frühere Version, seitdem gab es einige Iterationen.

>                                          # [2]
 '/×                                       # ['//']
    η                                      # ['/','//']
     €η                                    # [['/'], ['/', '//']]
       vy                    }             # {For each element...}
         ∞                                 # Mirror horizontally.
          ¶¡                               # Split mirror on newlines.
            N£                             # Shave each diamond down a layer.
              .C                           # Horizontal center.
                .B                         # Pad for the transpose.
                  ø                        # Transpose.
                   €∞                      # Mirror each (vertically).
                     ¹NαFð.ø}              # Pad each list for transpose (verticaly).
                              )            # Wrap back to list...
                               €.B         # Pad each horizontally.
                                  ¦        # Remove the random numbers?
                                   ø       # Back to horizontal...
                                    €R     # Reverse to get correct order.
                                      J    # Join, no spaces.
                                       »   # Join newlines.
                                        ∞  # Final horizontal mirror.

CJam , 65 63 Bytes

q~_,:)_W%\+f{_2*S*a@2$-*\_,f{)'/*\Se[_W%'/'\er+}_W%Wf%+1$++}zN*

Probieren Sie es online!

Erläuterung

In dieser Erklärung beziehe ich mich auf die eingegebene Nummer als n.

q~        e# Read and eval the input (push n to the stack).
_,        e# Copy it an get the range [0 .. n-1].
:)        e# Increment each element to get [1 .. n].
_W%       e# Copy it and reverse it.
\+        e# Prepend the reverse to the original range, resulting in [n n-1 .. 1 1 .. n-1 n].
f{        e# Map over each number x in the range using n as an extra parameter:
 _2*S*a   e#  Push a string containing n*2 spaces, and wrap it in an array.
 @2$-     e#  Push n-x.
 *        e#  Repeat the space string from before n-x times.
 \        e#  Bring x back to the top.
 _,       e#  Copy it and get the range [0 .. x-1].
 f{       e#  Map over each number y in this range, using x as an extra parameter:
  )       e#   Increment y.
  '/*     e#   Repeat '/' y times.
  \Se[    e#   Pad the resulting string to length x by adding spaces to the left.
  _W%     e#   Copy the result and reverse it.
  '/'\er  e#   Replace '/' with '\' in that.
  +       e#   Concatenate to the other string. This forms one row of one diamond.
 }        e#  (end map, now we have the top half of a diamond of size x)
 _W%      e#  Copy the half-diamond and reverse it.
 Wf%      e#  Reverse each row.
 +        e#  Concatenate to the top half. Now we have a full diamond of size x.
 1$++     e#  Put the spaces from before at the beginning and end. This is to pad the top
          e#  and bottom of the smaller diamonds.
}         e# (end map)
z         e# Transpose.
N*        e# Join with newlines. Implicit output.

Python 2 , 152 147 143 140 Bytes

^{-1 Byte dank musicman523}

n=input()
r=range(n)
r+=r[::-1]
for x,i in enumerate(r):a,b='/\\\/'[i<x::2];s=' '*(n+~i);print''.join((s+a*n)[:n-j]+(b*-~i+s)[j:]for j in r)

Probieren Sie es online!

Dies funktioniert, indem die inneren Spalten des größten Diamanten zerkleinert werden [0,..,n,n,..,0], um die Anzahl der zu entfernenden Spalten zu steuern.

Pyth, 35 32 Bytes

j.tsm+Jm.[yQS*"\/"k\ Sd_M_Js__BS

Testsuite

Fertig, um zu sehen, wie sich meine und @ LeakyNuns Ansätze unterscheiden würden.

Dyalog APL, 46

{⊃,/⍵∘{'/ \'[2+((-⍪⊖)⌽,-)(-⍺)↑∘.≥⍨⍳⍵]}¨(⌽,⊢)⍳⍵}

Pyth , 49 Bytes

LC.tb)L+_b.rb"\/"js_,J'MsMCyMy_Mm'Myd._._*\/Q__MJ

Probieren Sie es online!

V , 38 Bytes

Àá/Àá\ò2ÙlX$xòÍî
òYGpVæHÄÓ¯¨¯*Ü*©Ü/ ± 

Probieren Sie es online!