Viết chương trình hoặc hàm lấy số nguyên dương N.

Khi N là 1, đầu ra

/\
\/

Khi N là 2, đầu ra

/\/\
\/ /
/ /
\/

Khi N là 3, đầu ra

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

Khi N là 4, đầu ra

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

Đối với N lớn hơn, mẫu tiếp tục, một lớp mới được thêm vào mỗi khi N được tăng lên.

• "Đầu ra" có nghĩa là in mẫu gạch chéo hoặc trả lại dưới dạng chuỗi.
• Một dòng mới duy nhất trong đầu ra được cho phép.
• Không gian lưu trữ trong đầu ra được cho phép nhưng không gian hàng đầu thì không.

Mã ngắn nhất tính bằng byte thắng.

Bình thường, 25 byte

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

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Giải trình:

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 byte

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

Kiểm tra nó ở đây.

Tôi đã cố gắng giúp Reto đánh golf câu trả lời CJam của anh ấy nhưng cuối cùng lại có một giải pháp không liên quan gì đến anh ấy, vì vậy tôi nghĩ rằng tôi cũng có thể tự mình đăng nó.

Giải trình

Điều này làm cho việc sử dụng tính đối xứng của đầu ra. Đặc biệt, thực tế là đầu ra giống như chuyển vị của nó.

Đầu tiên, chúng ta tạo các N+1dòng đầu tiên , nhưng không có cạnh trái:

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.

Bây giờ chúng ta đã có một chuỗi các chuỗi biểu thị lưới sau:

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

Sự hoán vị của nó trông như thế này:

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

Cùng nhau, chúng có tất cả các nhân vật không phải không gian mà chúng ta cần. Bây giờ chúng ta có thể sử dụng mẹo rad của Dennis để kết hợp hai lưới ASCII thành một, bằng cách lấy tối đa của mỗi cặp ký tự tương ứng. Ở tất cả các vị trí mà hai lưới khác nhau, một lưới sẽ có một khoảng trắng (hoặc không có gì cả) và cái còn lại sẽ có ký tự mà chúng ta đang tìm kiếm. Khi một danh sách trong hoạt động véc tơ dài hơn danh sách khác, các yếu tố bổ sung của danh sách dài hơn sẽ chỉ được giữ lại, đó chính là thứ chúng tôi đang tìm kiếm. Trong các trường hợp khác, ký tự không phải khoảng trắng sẽ luôn là mức tối đa của hai ký tự:

_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 byte

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

Hãy thử trực tuyến!

Ung dung và giải thích

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

Cốt lõi của chương trình tạo một danh sách các U * 2mục, ánh xạ từng hàng vào một hàng của mẫu, sau đó nối chúng với các dòng mới:

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.

Đối với bản thân mẫu, đây là cách tôi đã chia nhỏ nó:

/\/\/\/\

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

Như bạn có thể thấy ở đây, điều này bây giờ chia thành ba mẫu đơn giản. Cái đầu tiên là dễ nhất, được tạo bằng mã này:

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

Bây giờ cho nửa bên trái. Các chỉ số lạ nên ánh xạ tới \/và thậm chí là /, vì vậy chúng tôi sử dụng mã này:

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

Điều này làm cho nửa bên phải dễ dàng hơn; tất cả những gì chúng ta cần làm là lặp lại  /một vài lần:

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

Đề nghị chào mừng!

GNU Sed, 59

Điểm bao gồm +2 cho các tùy chọn '-nr' thành sed.

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

Đầu vào trong unary theo câu trả lời meta này .

Đầu ra thử nghiệm:

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

CJam, 36 35 34 byte

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

Dùng thử trực tuyến

Cảm ơn @NinjaBearMonkey đã chỉ ra thêm ;.

Mặc dù điều này có vẻ không phù hợp, tôi đã thử một vài lựa chọn khác và chúng không kết thúc ngắn hơn.

Giải trình:

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 byte

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

Toán học, 123 122 121 byte

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

Có lẽ có thể được chơi golf hơn nữa.

Java - 141 byte

Tất nhiên không phải là ngắn nhất, nhưng thật tuyệt khi có một giải pháp Java:

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

Bị đánh cắp

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

Đầu vào

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

Đầu ra

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

Bình, 30 byte

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

Hãy thử nó ở đây .

JavaScript, 128 125 123 114 byte

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 (cũng được chuyển đổi thành ES5) + bản 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 byte

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

Trong chương trình thử nghiệm:

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

Vòng lặp in 2 hàng cho mỗi lần lặp từ i = 0 đến i = n-1.

Hàng thứ hai luôn được '\'theo sau bởi sự cố ni '/ '.

Hàng đầu tiên giống như hàng thứ hai của lần lặp trước, nhưng '\'bị thiếu (vì vậy chúng tôi lưu trữ giá trị này skhi chúng tôi in hàng thứ hai của lần lặp trước.)

Ngoại lệ duy nhất là lặp đi lặp lại không, mà được xử lý bằng cách khởi tạo sđến '/\'*n.

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

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

Bài viết đầu tiên ở đây!

Được sử dụng để sử dụng nhưng bây giờ sử dụng , tương tự như của Ruby .Array(len).join(str) String.repeat(len)operator*(str,len)

Ung dung:

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

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

    return str + '\\/';
}

Cảm ơn:
107 => 104 byte: @insertusernamehere
97 => 90 byte: @ user81655

Python 2, 66 byte

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

Khá đơn giản. Giá trị nlà số lượng /trên dòng và bcho biết dòng bắt đầu bằng \. Giá trị của các bthay thế giữa 0 và 1, và ngiảm mỗi bước thứ hai. Các điều kiện chấm dứt xấu xí dừng lại khi n=1, b=0. Sự thay thế của mộtexec vòng lặp sẽ có vấn đề cần rất nhiều lối thoát cho "'\\\\'".

Tôi đã ngạc nhiên khi thấy cách tiếp cận này ngắn hơn so với sử dụng một số duy nhất k=2*n+b. Đây là 68 byte:

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

Một chiến lược thay thế sẽ tránh một sự tách biệt printcho dòng trên cùng, nhưng tôi đã không thấy một cách ngắn gọn.

Chồn 0,14 , 46 byte

Tôi chắc chắn điều này có thể được đánh gôn, nhưng đã 4 giờ sáng và tôi cần đi ngủ.

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

Hãy thử nó ở đây.

Giải trình

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

Hàng loạt, 121 byte

@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:\= %

Hoặc nếu unary được chấp nhận, 107 byte:

@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

Gọi với số lượng thích hợp là 1s.

Matlab, 122 byte

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 byte

Hai giải pháp có độ dài bằng nhau.

Gọi 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=' '

và

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

Điều này không thực sự cạnh tranh với giải pháp Haskell hiện tại vì nó tiết kiệm 5 ký tự bằng cách quay lại thay vì in một chuỗi. Tôi chỉ đăng nó để cho thấy cách tiếp cận mô hình vô hạn so với cách tiếp cận dựa trên tọa độ. Ghi chú:

• p có thể được nội tuyến để không thay đổi chiều dài.
• [t n l|(n,l)<-...]tiết kiệm hơn 2 (map(uncurry t)$...).

Ceylon, 100

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

Điều này có một "danh sách đối số được đặt tên" cho join(không có bất kỳ đối số được đặt tên nào, nhưng thay vào đó là một sự hiểu biết lặp lại) và một số cách sử dụng String.repeat(một trong số đó thực sự có nghĩa là "chỉ bao gồm cho lẻi ").

Định dạng:

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

PHP, 117 byte

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

Giả sử các thông báo bị tắt và đầu vào được lấy từ dòng lệnh.

Ung dung:

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

Bình luận được chào đón :)