Pozitif bir tamsayı alan bir program veya işlev yazın.

N 1 olduğunda, çıktı

/\
\/

N 2 olduğunda, çıktı

/\/\
\/ /
/ /
\/

N, 3 olduğunda, çıktı

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

N 4 olduğunda, çıktı

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

Daha büyük N için desen devam eder, her N arttırıldığında yeni bir katman eklenir.

• "Çıktı", eğik çizgi desenini yazdırmak veya dizge olarak döndürmek anlamına gelir.
• Çıktıdaki tek bir son satırın girilmesine izin verilir.
• Çıktıdaki izleyen boşluklara izin verilir, ancak baştaki boşluklara izin verilmez.

Bayt cinsinden en kısa kod kazanır.

Pyth, 25 bayt

j_+t.iJ*R"/ "SQ+L\\J*Q"/\

Çevrimiçi deneyin: Gösteri veya Test Paketi

Açıklama:

j_+t.iJ*R"/ "SQ+L\\J*Q"/\   implicit: Q = input number
             SQ             create the list [1, 2, ..., Q]
       *R"/ "               repeat "/ " accordingly to this numbers
      J                     assign this list of strings to J
               +L\\J        create a 2nd list, which contains the same strings
                            as in J, just with a "\" prepended
    .i                      interleave these two lists
   t                        remove the first element
                    *Q"/\   repeat the string "/\" Q times
  +                         append it to the list
 _                          reverse it
j                           print each string on a separate line

CJam, 32 30 29 28 bayt

ri_"/\ /"2/f*)@,\f>+_z..e>N*

Burada test et.

Reto'ya CJam'ın cevabını golf atmaya yardım etmeye çalışıyordum ama onunla hiçbir ilgisi olmayan bir çözüm buldum, bu yüzden kendim de gönderebilirim diye düşündüm.

açıklama

Bu, çıkışın simetrisini kullanır. Özellikle, çıktının devriyle aynı olduğu gerçeği.

İlk önce, ilk N+1satırları üretiriz, ancak sol kenarı olmadan:

ri       e# Read input and convert to integer N.
_        e# Duplicate.
"/\ /"2/ e# Push an array with two strings: ["/\" " /"]
f*       e# Repeat each of the two strings N times. That gives the first two rows.
)        e# Detach the second row.
@,       e# Pull up the other copy of N and turn into range [0 1 ... N-1].
\f>      e# For each element i in that range, discard the first i characters of
         e# the second row.
+        e# Add all those lines back to the first row.

Şimdi aşağıdaki ızgarayı temsil eden bir dizi dizgimiz var:

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

Bunun devrik gibi görünüyor:

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

Birlikte bunlar, ihtiyacımız olan tüm boşluk olmayan karakterlere sahip. Artık iki ASCII ızgarasını bir bir araya getirerek, karşılık gelen her karakter çiftinden en fazlasını alarak Dennis'in rad ucunu kullanabiliriz. İki şebekenin farklı olduğu tüm pozisyonlarda, biri boşluk bırakacak (ya da hiçbir şey olmayacak) ve diğeri aradığımız karaktere sahip olacaktır. Bir vektörlü işlemdeki bir liste diğerinden daha uzun olduğunda, daha uzun listenin ek öğeleri basitçe tutulur; bu tam olarak aradığımız şeydir. Diğer durumlarda, boşluksuz karakter her zaman iki karakterin maksimumunda olacaktır:

_z   e# Duplicate the grid and transpose it.
..e> e# For each pair of characters in corresponding positions, pick the maximum.
N*   e# Join the lines by linefeed characters.

Japt , 46 44 41 40 bayt

Uo-U £Y?"\\/"sYv)+" /"pU-Y/2 :"/\\"pU} ·

Çevrimiçi deneyin!

Ungolfed ve açıklama

Uo-U mXYZ{Y?"\\/"sYv)+" /"pU-Y/2 :"/\\"pU} qR

Programın çekirdeği bir U * 2öğe listesi yapar , her birini desenin bir satırına eşler, sonra onları yeni çizgilerle birleştirir:

Uo-U    // Build an array of all integers in the range [-U, U).
mXYZ{   // Map each item X and index Y in this array with the following function.
 ...
} qR    // Join the resulting array with newlines.

Desene gelince, işte bunu nasıl parçaladım:

/\/\/\/\

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

Burada görebileceğiniz gibi, bu şimdi üç basit örüntüye dönüşüyor. Birincisi bu kodla oluşturulan en kolay olanı:

Y? ... :  // If Y, the current index, is 0,
"/\\"pU   // return the pattern "/\" repeated U*2 times.

Şimdi sol yarısı için. Tek indeksler ile eşleşmeli \/, hatta /bu kodu kullanmalıyız:

"\\/"s  // Otherwise, slice the pattern "\/" at 
Yv)     //  if Y is even, 1; otherwise, 0.

Bu doğru yarı yolda kolaylaştırır; Yapmamız gereken tek şey  /birkaç kez tekrarlamak :

" /"p  // Repeat the pattern " /"
U-Y/2  //  floor(U - (Y/2)) times.

Önerilerinizi bekliyoruz!

GNU Sed, 59

Puan '-nr' seçenekleri için +2 içerir sed.

s|1|/\\|gp
y|/\\| /|
s| |\\|p
:
s|\\(..)|\1|p
s|/ |\\|p
t

Bu meta cevaba göre unary olarak yazınız .

Test çıkışı:

$ sed -nrf slantcake.sed <<< 111
/\/\/\
\/ / /
/ / /
\/ /
/ /
\/
$ 

CJam, 36 35 34 bayt

ri_"/\\"*N@,W%{'\'/@" /"*+_N\N}/;;

Çevrimiçi deneyin

Ekstra işaret için @NinjaBearMonkey teşekkürler ;.

Bu nispeten kararsız görünüyor olsa da, birkaç seçenek daha denedim ve daha kısa sürede sonuçlanmadı.

Açıklama:

ri_     Get input, convert to integer, and copy.
"/\\"   Pattern for first line.
*N      Repeat N times, and add a newline.
@,      Rotate N to top, and create [0 .. N-1] sequence.
W%      Invert sequence to [N-1 .. 0].
{       Loop over counts, creating two lines for each.
  '\      Leading character for first in pair of lines. Rest will be the same
          for both lines.
  '/      First character for repeated part.
  @       Rotate count to top.
  " /"    Repetitive pattern.
  *       Replicate it by count.
  +       Concatenate with '/.
  _       Copy whole thing for use as second in pair of lines.
  N\      Put a newline between the pair of lines.
  N       Add a newline after second line.
}/      End of loop over counts.
;;      Created an extra line, get rid of it.

Python 2,80 bayt

n=input()
print"/\\"*n
for i in range(n*2,1,-1):print"\\"*(1-i%2)+"/ "*(i/2+i%2)

Mathematica, 123 122 121 bayt

""<>(#<>"
"&/@Normal@SparseArray[{{i_,j_}/;2∣(i+j)&&i+j<2#+3->"/",{i_,j_}/;i~Min~j<2&&2∣i~Max~j->"\\"},{2#,2#}," "])&

Muhtemelen daha da golf oynayabilirdi.

Java - 141 bayt

Tabii ki en kısa değil, ama bir Java çözümü olması güzel:

String a(int a){String s="";int b=-1,c,e;for(a*=2;++b<a;){for(c=-1;++c<a;)s+=(e=b+c)>a?" ":e%2==0?"/":b==0||c==0?"\\":" ";s+="\n";}return s;}

Ungolfed

String a(int a){
    String s ="";
    int b=-1,c,e;
    for (a*=2;++b < a;){
        for (c = -1 ; ++c < a ;)
            s+= (e=b+c)>a?" ": e%2==0? "/" : b==0||c==0? "\\" : " ";
        s+="\n";
    }
    return s;
}

Giriş

System.out.println(a(5));

Çıktı

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

Pyth, 30 Bayt

*"/\\"QVr*2Q1+*\\!%N2*s.DN2"/ 

Burada dene .

JavaScript, 128 125 123 114 bayt

n=>{r='';for(i=0;i<n;i++)r+='/\\';for(j=0;j<2*n-1;j++){r+='\n'+(j%2?'':'\\');for(i=n-j/2;i>0;i--)r+='/ '}return r}

De-golf (ayrıca ES5'e çevrilmiş) + demo:

function c(n) {
    r = '';
    for (i = 0; i < n; i++) r += '/\\';
    for (j = 0; j < 2 * n - 1; j++) {
        r += '\n' + (j % 2 ? '' : '\\');
        for (i = n - j / 2; i > 0; i--) r += '/ '
    }
    return r
}

alert(c(prompt()));

Ruby, 50 bayt

->n{s='/\\'*n
n.times{|i|puts s,?\\+s='/ '*(n-i)}}

Test programında:

f=->n{s='/\\'*n
n.times{|i|puts s,?\\+s='/ '*(n-i)}}
f[gets.to_i]

Döngü, her yineleme için i = 0 - i = n-1 arasında 2 satır yazdırır.

İkinci sırayı daima '\'ni olayları izler '/ '.

İlk satır önceki yinelemenin ikinci satırıyla aynıdır, ancak '\'eksik olanla (bu nedenle sönceki yinelemenin ikinci satırını yazdırırken bu değeri saklarız .)

Tek istisna, sıfırlama işlemi tarafından işlenen sıfırlamadır. s için '/\'*n.

Javascript (ES6), 107 104 100 98 97 91 90 bayt

p=>{s=`/\\`.repeat(p++)+`
`;for(i=p;i>2;s+='\\'+o+o)o=`/ `.repeat(--i)+`
`;return s+'\\/'}

Buraya ilk gönderi!

Kullanım için kullanılır ama şimdi kullanır , Ruby'nin benzerArray(len).join(str) String.repeat(len)operator*(str,len) .

Ungolfed:

len => {
    var str = `/\\`.repeat(len++) + '\n';

    for (var i = len, mid; i > 2; str += '\\' + mid + mid) {
        mid = `/ `.repeat(--i) + '\n';
    }

    return str + '\\/';
}

: Sayesinde
107 => 104 bayt: @insertusernamehere
97 => 90 byte: @ user81655

Python 2, 66 bayt

n=input();b=1
print'/\\'*n
while~-n+b:print'\\'*b+'/ '*n;b^=1;n-=b

Oldukça basit. Değer satırdaki nsayıdır ve satırın başlayıp başlamayacağını belirtir . Değeri 0 ile 1 arasında değişir ve her ikinci adımda azalır. Çirkin sonlandırma koşulu ne zaman durur . Bir döngünün alternatifi, çok sayıda kaçmaya ihtiyaç duyma sorununu doğurabilirdi ./b\bnn=1, b=0exec"'\\\\'"

Bu yaklaşımı, tek bir sayı kullanmaktan daha kısa buldum k=2*n+b. Bu 68 bayttır:

k=2*input()+1
print k/2*"/\\"
while k>2:print k%2*'\\'+k/2*'/ ';k-=1

Alternatif bir strateji print, üst sıra için ayrı bir yoldan kaçınırdı, ancak özlü bir yol görmedim.

Minkolang 0.14 , 46 bayt

Bunun golf olabileceğine eminim, ama saat 4 oldu ve yatmam gerekiyor.

n$z"/\"z$D$OlOz[" /"zi-$Dlr$d"\"zi1+-3&5$X$O].

Burada dene.

açıklama

n$z               Take number from input (n) and store it in the register (z)
   "/\"           Push these characters (in reverse)
       z$D        Push register value and duplicate the whole stack that many times
          $O      Output whole stack as characters
            lO    Output newline

z                                   Push n from register
 [                                  Open for loop that repeats n times
  " /"                              Push these characters (in reverse)
      zi-                           n - loop counter
         $D                         Pop k and duplicate whole stack k times
           l                        Push 10 (for newline)
            r                       Reverse stack
             $d                     Duplicate whole stack
               "\"                  Push this character
                  zi1+-             0 if n = loop counter + 1, truthy otherwise
                       3&           Do the next three characters if top of stack is 0
                         5$X        Dump the bottom-most five items of the stack
                            $O      Output whole stack as characters
                              ].    Close for loop and stop

Toplu iş, 121 bayt

@echo off
set/an=%1-1
if %1==1 (echo /\%2) else call %0 %n% /\%2
set a=/\%2
echo \%a:\= %
if not \%2==\ echo %a:\= %

Veya birliğin kabul edilebilir olması durumunda, 107 bayt:

@echo off
set a=%1
echo %a:1=/\%
:a
echo \%a:1=/ %
set a=%a:~1%
if not %a%1==1 echo / %a:1=/ %&goto a

Uygun sayıda 1s ile çağırın.

Matlab, 122 bayt

M=2*input('');
z=zeros(M);[y,x]=ndgrid(1:M);
z(~mod(x+y,2)&x+y<M+3)=1;v=2-mod(1:M,2);
z(1,:)=v;z(:,1)=v;disp([15*z.^2+32,''])

Haskell, 99 bayt

Eşit uzunlukta iki çözüm.

Çağrı f.

f n=mapM_ putStrLn$[[x?y|x<-[0..2*n-y-0^y]]|y<-[0..2*n-1]]
x?y|mod(x+y)2==0='/'|x*y==0='\\'|0<1=' '

ve

f n=mapM_ putStrLn$[[x?y|x<-[y..2*n-0^y]]|y<-[0..2*n-1]]
x?y|mod x 2==0='/'|mod y x==0='\\'|0<1=' '

Haskell, 96

f=g.(*2)
g m=unlines$t m(c"/\\"):[t n l|(n,l)<-zip[m,m-1..2]$c['\\':p,p]]
p=c"/ "
c=cycle
t=take

Bu aslında mevcut Haskell çözümüne karşı rekabetçi değil çünkü bir dize basmak yerine döndürerek 5 karakter kaydeder. Yalnızca sonsuz kalıp yaklaşımının koordinat temelli yaklaşımla karşılaştırmasını göstermek için yazıyorum. Notlar:

• p uzunluğu hiçbir değişiklik için inline edilebilir.
• [t n l|(n,l)<-...]2 tasarruf sağlar (map(uncurry t)$...).

Seylan, 100

String s(Integer n)=>"\n".join{"/\\".repeat(n),for(i in 2*n+1..3)"\\".repeat(i%2)+"/ ".repeat(i/2)};

Bu, join(adlandırılmış argümanlar olmadan, bunun yerine yinelenebilir bir anlama olmadan) için bir "adlandırılmış argüman listesi" ve birkaç kullanım String.repeat(aslında bunlardan biri anlamına gelir "sadece garip olanları içerir.i .

biçimlendirilmiş:

String s(Integer n) =>
        "\n".join{
            "/\\".repeat(n),
            for (i in 2*n + 1 .. 3)
                "\\".repeat(i % 2)
                        + "/ ".repeat(i / 2)
        };

PHP, 117 bayt

<?$n=$argv[1];$r=str_repeat;echo$r("/\\",$n);for(;$i++<$n*2-1;)echo"\n".($i%2?"\\":'').$r("/ ",$n-floor(($i-1)/2));?>

Bildirimlerin kapatıldığını ve girişin komut satırından alındığını varsayar.

Ungolfed:

<?php
error_reporting(E_ALL & ~E_NOTICE);

$n = $argv[1];
$r='str_repeat';
echo $r("/\\",$n);
for(;$i++<$n*2-1;){
    echo"\n".(($i%2)?"\\":'') . $r("/ ",$n-floor(($i-1)/2));
}
?>

Yorumlarınızı bekliyoruz :)