Problema

Dado un entero positivo ndonden < 100

Salida de un patrón de diamante de la siguiente manera:

Entrada n=1

/\/\
\/\/

Entrada n=2:

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

Entrada n=3:

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

Entrada n=4:

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

Y así.

Reglas

• Programa y función permitidos.
• Espacio en blanco al final permitido.
• Espacio en blanco inicial en líneas sin /o \permitidas.
• Nuevas líneas finales y principales permitidas.
• El código más corto en bytes gana

Esto probablemente está bastante relacionado

SOGL V0.12 , 24 bytes

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

Pruébalo aquí!

Explicación:

ā                         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

Carbón , 30 27 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación: Las primitivas de dibujo del carbón no pueden dibujar un diamante, porque los movimientos diagonales permanecen en cuadrados de la misma paridad. Editar: La nueva solución es dibujar un lado de un diamante y luego rotar todo el lienzo listo para dibujar el siguiente lado, permitiendo que un diamante se dibuje en un bucle. Este bucle está contenido en un bucle para dibujar todos los diamantes internos para cada diamante. El bucle más externo dibuja todos los diamantes adyacentes entre sí. Finalmente la imagen se refleja.

Tenga en cuenta que el carbón vegetal se ha extendido desde entonces y que se puede guardar otro byte utilizando Increment.

APL (Dyalog) , 70 69 66 bytes

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

Pruébalo en línea!

Asume ⎕IO←0, que es estándar en muchos sistemas, por lo que el programa está indexado en 0.

Este es un tradfn que recibe información a través de STDIN.

Explicación

(un poco anticuado)

Tenga en cuenta que ⍺es el argumento izquierdo, ⍵es el argumento derecho y ⍺⍺es el operador izquierdo.

BEs una función que ayuda a reflejar los diamantes. Toma la cadena como el argumento derecho y la función inversa como la izquierda (también lo Bes un operador).

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

Y ahora vamos a la parte principal del programa.

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

Esto es necesario para garantizar que todos los triángulos creados para cada elemento en el rango ⌽⍳Atengan la misma altura para que luego puedan concatenarse entre sí.

 ⊖               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

Ahora la parte superior izquierda del patrón está completa. Todo lo que queda es voltearlo verticalmente y luego horizontalmente.

(⊢⍪⊖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

¡Y eso es! La salida es una matriz de caracteres con /\sy rellena con espacios.

05AB1E , 47 43 41 35 34 33 32 bytes

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

Pruébalo en línea!

(-4 bytes gracias a @Emigna que sugirió 3 mejoras)

Esta explicación fue para la versión anterior, ha habido algunas iteraciones desde entonces.

>                                          # [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*

Pruébalo en línea!

Explicación

En esta explicación, me referiré al número de entrada como 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 gracias a 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)

Pruébalo en línea!

Esto funciona cortando las columnas internas del diamante más grande para hacer las más pequeñas, utilizando [0,..,n,n,..,0]para controlar la cantidad de columnas que se eliminarán.

Pyth, 35 32 bytes

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

Banco de pruebas

Hecho para ver cómo diferirían los enfoques de mi y @ LeakyNun.

Dyalog APL, 46

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

Pyth , 49 bytes

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

Pruébalo en línea!

V , 38 bytes

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

Pruébalo en línea!