Sorun

Olumlu bir tamsayı verilen nyerden < 100

Aşağıdaki gibi bir elmas deseni çıktılar:

Giriş n=1

/\/\
\/\/

Giriş n=2:

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

Giriş n=3:

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

Giriş n=4:

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

Ve bunun gibi.

kurallar

• Program ve fonksiyona izin verildi.
• İzleyen boşluk boşluğuna izin verildi.
• Hiçbir hatlarda boşluk Lider /veya \izin verdi.
• İzleyen ve önde gelen yeni hatlara izin verilir.
• Bayt cinsinden en kısa kod kazanır

Bu muhtemelen oldukça ilgili

SOGL V0.12 , 24 bayt

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

Burada dene!

Açıklama:

ā                         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

Kömür , 30 27 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama: Kömürün çizim ilkelleri bir elmas çizemez çünkü köşegen hareketler aynı paritedeki kareler üzerinde kalır. Düzenleme: Yeni çözüm bir elmasın bir tarafını çizmek ve daha sonra tüm tarafını döndürerek bir sonraki tarafı çizmeye hazır hale getirerek bir elmasın bir halka halinde çizilmesine izin verir. Bu döngü daha sonra, her bir elmas için tüm iç elmasları çizmek için bir ilmek içine yerleştirilir. En dıştaki halka birbirine bitişik tüm elmasları çizer. Sonunda görüntü yansıtılır.

Kömürün o zamandan beri uzatıldığını ve başka bir bayt kullanılarak kaydedilebileceğini unutmayın Increment.

APL (Dyalog) , 70 69 66 bayt

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

Çevrimiçi deneyin!

Var ⎕IO←0ki, birçok sistemde standarttır, bu nedenle program 0 dizinlidir.

Bu STDIN üzerinden girdi alan bir takas.

açıklama

(biraz modası geçmiş)

Bunun ⍺sol argüman, ⍵doğru argüman ve ⍺⍺sol işleç olduğuna dikkat edin.

Belmasların aynalanmasına yardımcı olan bir fonksiyondur. Dizeyi doğru argüman, tersini de sola döndürür ( Bbir operatördür).

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

Ve şimdi programın ana kısmına gidiyoruz.

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

Bu, aralıktaki her eleman için yaratılan tüm üçgenlerin ⌽⍳Aaynı yüksekliğe sahip olmasını sağlamak için gereklidir, böylece daha sonra birbirleriyle birleştirilebilirler.

 ⊖               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

Şimdi kalıbın sol üst kısmı tamamlanmıştır. Geriye kalan tek şey onu dikey ve sonra yatay olarak çevirmek.

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

Ve bu kadar! Çıktı, /\s ile karakter matrisi ve boşluklarla doldurulur.

05AB1E , 47 43 41 35 34 33 32 bayt

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

Çevrimiçi deneyin!

(3 iyileştirme öneren @Emigna sayesinde -4 bayt)

Bu açıklama önceki versiyon içindi, o zamandan beri birkaç tekrarlama oldu.

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

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

Çevrimiçi deneyin!

açıklama

Bu açıklamada, giriş numarasına olarak atıfta bulunacağım 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 bayt

^{Musicman523 sayesinde -1 bayt}

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)

Çevrimiçi deneyin!

Bu [0,..,n,n,..,0], kaldırmak için sütun miktarını kontrol etmek için kullanarak daha küçük olanları yapmak için en büyük elmasun iç sütunlarını keserek çalışır .

Pyth, 35 32 bayt

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

Test odası

Benim ve @ LeakyNun yaklaşımlarının nasıl farklı olacağını görmek için yapılır.

Dyalog APL, 46

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

Pyth , 49 bayt

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

Çevrimiçi deneyin!

V , 38 bayt

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

Çevrimiçi deneyin!