Xuất ra một hộp đẹp

17

Thách thức của bạn là xuất chính xác hộp sau:

..................................................
..................................................
..                                              ..
..                                              ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..                                              ..
..                                              ..
..................................................
..................................................

Hộp có chiều cao và chiều rộng 50, không gian rộng hai.

Bạn phải viết một hàm hoặc chương trình xuất hoặc trả về một chuỗi và không nhận đầu vào.

Ít byte nhất sẽ thắng!

code-golf  ascii-art  kolmogorov-complexity 
— Pavel
nguồn
4
Bất kỳ lý do tại sao +hộp trong cùng chỉ có 1 lớp ở trên cùng và dưới cùng? Điều đó sẽ làm cho câu trả lời dựa trên thuật toán dài hơn một chút, vì điều đó có nghĩa là hai lớp trong cùng không chính xác.
— Sản xuất ETH
@Pavel OK. Bỏ phiếu kín rút lại :)
— Chấn thương kỹ thuật số
4
Tại sao hạn chế về một chương trình hoàn chỉnh?
— Rɪᴋᴇʀ
1
@Pavel tại sao? Nó thêm thực sự không có gì để thách thức.
— Rɪᴋᴇʀ
1
@Pavel ..... không. Ý tôi là vâng, một số người có điều đó, nhưng đó không phải là một yêu cầu / tiêu chuẩn cho các thách thức KG.
— Rɪᴋᴇʀ

Câu trả lời:

14

J , 25 byte

echo'. + '{~4|>./~2#|i:12

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

Giải trình

echo'. + '{~4|>./~2#|i:12
                     i:12  Range from -12 to 12.
                    |      Take absolute values,
                  2#       duplicate every element,
                /~         compute "multiplication table"
              >.           using maximum,
            4|             take mod 4 of every element,
    '. + '{~               index into this string,
echo                       print char matrix for everyone to see.
— Zgarb
nguồn
Tôi nghĩ rằng bạn có thể để lại tiếng vang.
— Conor O'Brien
@ ConorO'Brien Oh, quy tắc đầu ra đã thay đổi. ... Hmm, nhưng nếu tôi loại bỏ echo, nó thậm chí sẽ không phải là một hàm, chỉ là một giá trị. Mặc dù J không có chức năng đối số nào.
— Zgarb
Tôi nghĩ rằng điều đó được cho phép theo bản chất thay thế của J. Trong mọi trường hợp, các hàm hằng có thể được coi là không đối số.
— Conor O'Brien
11

C, 115 byte

#define M(x,y)x<(y)?x:y
f(i){for(i=2549;i;i--)putchar(i%51?". + "[(M(i%51-1,M(50-i%51,M(i/51,49-i/51))))/2%4]:10);}

Xác định một hàm f(gọi là f();) in chuỗi thành STDOUT.

— Lynn
nguồn
9

C, 535 478 477 byte

Bây giờ đó là rất nhiều golf: - /

i;main(j){for(;++i<51;puts(""))for(j=0;++j<51;)putchar(i<3|i>48?46:j<3|j>48?46:i>4&i<47&j>4&j<47?i<7|(i>44&i<47)|(j>2&j<7)|(j>44&j<47)?43:j>8&j<43&((i>8&i<11)|(i>40&i<43))?46:i>9&i<41&((j>8&j<11)|(j>40&j<43))?46:i>13&i<37&((j>12&j<15)|(j>36&j<39))?43:((i>12&i<15)|(i>36&i<39))&j>12&j<39?43:i>17&i<33&((j>16&j<19)|(j>32&j<35))?46:((i>16&i<19)|(i>32&i<35))&j>16&j<35?46:i>21&i<29&((j>20&j<23)|(j>28&j<31))?43:((i>20&i<23)|(i>28&i<31))&j>20&j<31?43:i>24&i<27&j>24&j<27?46:32:32);}

Đây là đầu ra;

..................................................
..................................................
..                                              ..
..                                              ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..                                              ..
..                                              ..
..................................................
..................................................
— sứt mẻ
nguồn
2
Thánh shit. Tôi ngưỡng mộ sự cống hiến của bạn.
— Rɪᴋᴇʀ
Tôi đã thay đổi hạn chế, các hàm trả về một chuỗi được cho phép ngay bây giờ.
— Pavel
Tôi mới nhận ra rằng tôi có thể chơi một vài byte bằng cách viết lại các vòng lặp for(;i++<51;và bây giờ tôi tắt một vòng ở mọi nơi: - /
— cleblanc
@cleblanc++i
— dkudriavtsev
MFW Tôi bắt đầu cố gắng hiểu điều này: i.imgur.com/TLV9gJ4.png +1
— Bạch tuộc ma thuật Urn
6

Haskell, 72 byte

q=(\n->[n,n]).abs=<<[-12..12]
unlines[[". + "!!mod(max x y)4|y<-q]|x<-q]

@ Giải pháp của Zgarb trong Haskell. Tôi cũng đã cố gắng xây dựng hộp bằng cách thêm các lớp xung quanh lõi ["..",".."], nhưng nó dài hơn 9 byte (81 byte).

e!b=e:e:b++[e,e];s#c=(c!)<$>(c<$s!!0)!s
unlines$foldl(#)["..",".."]" + . + . + ."
— nimi
nguồn
5

Xếp chồng, không biên dịch, 35 byte

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

ε'.'3$' + .'2*tostr*+$surroundfold

Ung dung:

'' '.  ++  ..  ++  ..  ++  ..' $surround fold

Khá đơn giản. surroundlà một hàm bao quanh một thực thể với một thực thể điền. Ví dụ, (0) 1 surroundlà ((1 1 1) (1 0 1) (1 1 1)). $surroundlà surroundmột chức năng, không được đánh giá. foldlấy một giá trị ban đầu, sau đó một cái gì đó để gấp lại, sau đó là một hàm. Trong trường hợp này, surroundlà folded, bao quanh chuỗi trống ban đầu ''(tương đương ε) với mỗi ký tự của chuỗi.

'.'3$' + .'2*tostr*+

Đây là lần đầu tiên tạo một chuỗi ký tự $' + .', khi nhân với một số, lặp lại mỗi ký tự. Điều này để lại cho chúng tôi : ++ ... Điều này sau đó được đúc thành một chuỗi. Sau đó, chúng tôi lặp lại ba lần chuỗi này, và cuối cùng trả trước một ., cho chúng tôi chuỗi mong muốn.

Một cách tiếp cận khác nhau cho 39 byte:

' .'3$' + .'2*tostr*+toarr$surround#\out

#\được chèn và lấy char ban đầu của chuỗi làm giá trị bắt đầu. Nó cũng chỉ hoạt động trên Mảng.

— Conor O'Brien
nguồn
Làm thế nào là không thành phần này, thách thức đã tăng lên chỉ một vài giờ trước.
— Pavel
@Pavel Tôi luôn luôn làm việc về điều này
— Conor O'Brien
4

JavaScript (ES6), 117 byte

f=(n=12,c=`. + `[n%4],t=c.repeat(n*4+2))=>n?t+`
${t}
${f(n-1).replace(/^|$/gm,c+c)}
${t}
`+t:`..
..`
console.log(f())
Mở rộng đoạn trích

Giải pháp không lợi nhuận đã đưa tôi 128 byte:

console.log([...Array(100)].map((_,i,a)=>a.map((_,j)=>`. + `[j=j>50?j-50:51-j,(i>j?i:j)%8>>1],i=i>50?i-50:51-i).join``).join`\n`)

Trường hợp \nđại diện cho nhân vật dòng chữ mới.

— Neil
nguồn
4

C, 97 byte

i,x,y;main(){for(;i<2550;putchar(++i%51?". + "[(x*x<y*y?y:x)&3]:10))x=i%51/2-12,y=i/102-12;}
— orlp
nguồn
3

Thạch , 18 byte

12ŒRAx2»þ`ị“ + .”Y

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

Cách tiếp cận tương tự như câu trả lời J của Zgarb: 12ŒRAlà abs([-12 … 12]), x2lặp lại mọi yếu tố hai lần, »þ`tạo một bảng tối đa, ị“ + .”lập chỉ mục theo chu kỳ thành một chuỗi và Ytham gia theo dòng mới.

— Lynn
nguồn
3

05AB1E , 39 35 33 byte

•â3fM~•3B…012… .+‡.pvyD¤sg25s-׫«})«»

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

•â3fM~•3B                               # Push 1100220011002200110022001
         …012… .+‡                      # Push ..  ++  ..  ++  ..  ++  .
                  .p                    # All prefixes of the above string.
                    vy            }     # For each prefix.
                      D¤sg25s-×         # Repeat the last letter until length is 25.
                               «Â«      # Concat, bifurcate, concat.
                                   )«» # Wrap to array, bifurcate, concat, print.

Phiên bản 33 Byte hiện đã mát hơn vì Emigna đã nhận xét tiết kiệm cho tôi 2 byte:

". + "DøJ3×'.«.pvy¤25yg-׫«})«»

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

— Bạch tuộc ma thuật Urn
nguồn
1
". + "DøJ3×'.«.pvy¤25yg-׫«})«»cho 33 byte.
— Emigna
… .+•â3fM~•3BSè.pvy¤25yg-׫«})«»cho 34 byte trên "phiên bản mát hơn".
— Emigna
Cool không phải là lựa chọn chính xác của từ haha. "Ít Ghetto", có lẽ?
— Bạch tuộc ma thuật Urn
Tôi thích việc bạn sử dụng lệnh tiền tố. Xuất sắc!
— Emigna
1
@Emigna các tiền tố tạo thành một hình tam giác, nếu bạn hoán chuyển hình tam giác và xoay nó, sau đó kết hợp nó với các tiền tố ban đầu, bạn có thể có thể cạo các byte. Đó là kế hoạch chính mà tôi không thể có được.
— Bạch tuộc ma thuật Urn
2

MATL , 21 byte

'. + '[]25:"TTYaQ]2/)

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

'. + '    % Push this string
[]        % Push empty array. This will be used as "seed"
25:"      % Do the following 25 times
  TTYa    %   Extend the array with a frame of zeros
  Q       %   Add 1 to each entry
]         % End
2/        % Divide by 2
)         % Index modularly into the string. Non-integer indices are rounded
          % Implicitly display
— Luis Mendo
nguồn
2

Ruby, 77 byte

-623.upto(676){|i|print i%26>0?". + "[[(i%26-13).abs,(i/52).abs].max%4]*2:$/}
— Cấp sông St
nguồn
Tôi nghĩ bạn có thể thay thế biểu thức chỉ mục bằng [i%26-13,i/52].map(&:abs).max%4(lưu một byte)
— Conor O'Brien
1

Haskell, 385 byte 

    b 0 = ["..", ".."]
b n = f:f:s:s:m (b (n - 1)) ++s:s:f:f:[]
    where f = replicate (8*n+2) $ d
          s = l++replicate ((8*n)-6) ' ' ++r
          m (x:xs) = map (\x -> l ++ x ++ r ) $ t
          l = d:d:' ':' ':[]
          r = reverse l
          t = b (n - 1)
          d :: Char
          d | n `mod` 2 == 0 = '.'
            | n `mod` 2 == 1 = '+'
main = mapM_ putStrLn $ b 6

Vòng đầu tiên của môn đánh gôn ở đây ... mong muốn được thấy người khác giải quyết bài này như thế nào.

Đầu ra:

..................................................
..................................................
..                                              ..
..                                              ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..                                              ..
..                                              ..
..................................................
..................................................
— thương hiệu
nguồn
3
1) Bạn có hàng tấn khoảng trắng không cần thiết. 2) đặt tất cả các định nghĩa hàm trong wheremột dòng và sử dụng ;để phân tách. 3) f:f:[]là f:[f] and d: '': '': [] `là d:" ". 4) mcó một tham số nhưng không sử dụng nó. Nội tuyến mvà t. 5) xác định một chức năng mới #để thay thế replicate: c#x=c<$[1..8*n+x]và gọi nó như d#2và ' '#(-6). 6) mod 2 == 0có thể được thay thế bằng even, hoặc lật bài kiểm tra và sử dụng oddvà người chơi gôn otherwise: 1<2. ...
— nimi
2
... Tất cả trong tất cả : b n=f:f:s:s:map(\x->l++x++r)(b$n-1)++s:s:f:[f]where f=d#2;s=l++' '#(-6)++r;l=d:d:" ";r=reverse l;d|odd n='+'|1<2='.';c#x=c<$[1..8*n+x].
— nimi
1

Octave, 53 byte

 '.  ++  .'(mod(bsxfun(@max,x=[24:-1:0 0:24],x'),8)+1)

Tạo mẫu lặp lại từ 1 đến 8 từ trung tâm ra ngoài và sử dụng nó làm chỉ mục để trích xuất các phần tử của . ++ .

Dùng thử trực tuyến!

— rahnema1
nguồn
1

Bash, 191 byte

echo H4sIAGUcgFgAA73VOw7AIAyD4b2n6F6J+x+v6k5CnPy1F6ZPAvNaS80li4/cUvrkKWdGapOak3O5DDmVS5G8XI5k5ZIkLpclUbk02ZfLk125f5B4JIljLY59cZwxx31x3H3HO5aFIo7/pZIpqWZClHSJmg55AeBhTxb2CQAA|base64 -d|gunzip

Có thể có thể nhỏ hơn, nhưng nhỏ hơn các nỗ lực thuật toán của tôi.

— cổ họng
nguồn
1

C #, 203 byte

Hoàn thành, chương trình dễ đọc:

using System;
public class P
{
    public static void Main(string[] a)
    {
        Func<string> f = () =>
        {
            var z = 25;
            var t = "";
            Func<int, string> c = (q) => q % 4 == 0 ? ".." : (q % 4 != 2 ? "  " : "++");
            for (var y = 0; y < z; y++)
            {
                var l = "";
                for (var x = 0; x < z; x++)
                        l += ((y > z / 2) ? (x >= y | x < z - y) : (x < y | x >= z - y)) ? c(x):c(y);
                l += "\n";
                t += l + l;
            }
            return t;
        };

        Console.Write(f());
        Console.ReadKey();
    }
}

Chức năng đánh gôn :

()=>{var z=25;var t="";Func<int,string>c=(q)=>q%4==0?"..":(q%4!=2?"  ":"++");for(var y=0;y<z;y++){var l="";for(var x=0;x<z;x++)l+=((y>z/2)?(x>=y|x<z-y):(x<y|x>=z-y))?c(x):c(y);l+="\n";t+=l+l;}return t;};
— CSharpie
nguồn
1

05AB1E , 33 byte

14G" . +"NL¤¸13N-.׫€D¨Â«èD})¨Â«»

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

Giải trình

14G                               # for N in [1 ... 13]
   " . +"                         # push this string
         NL                       # push range [1 ... N]
           ¤¸13N-.×               # push a list of 13-N repetitions 
                                  # of the last element of the above range
                   «              # concatenate the two ranges
                    €D            # duplicate each element
                      ¨           # remove the last element
                       «         # concatenate a reversed copy to the list
                         è        # use the elements of the list to index into the string
                          D       # duplicate the resulting string
                           }      # end loop
                            )     # wrap the strings in a list
                             ¨    # remove the last element
                              «  # concatenate a reversed copy
                                » # join the list on newlines
— Biểu tượng
nguồn
Giải thích sắp tới?
— Pavel
@Pavel: tất nhiên rồi! :)
— Emigna
1

PowerShell , 171 151 byte

($x=(1..12|%{' . +'[$_%4]}|%{($a+=$_+$_)})+"$a."|%{$c=if(++$i%2){('+','.')[($b=!$b)]}else{' '};$_.PadRight(25,$c)}|%{,($_+-join$_[25..0])*2});$x[23..0]

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

Ho-hum trả lời. Tôi chắc chắn có một cách ngắn hơn (với độ dài của các câu trả lời khác, tôi tự tin), nhưng điều này cho thấy một số thủ thuật gọn gàng.

Giải trình:

1..12|%{' . +'[$_%4]}tạo ra một chuỗi các chuỗi (có độ dài một ký tự), theo đúng mẫu chúng ta cần. Hãy thử trực tuyến!

Sau đó, chúng tôi thêm vào |%{($a+=$_+$_)})+"$a."đó lấy mảng và mở rộng nó sang một bên dựa trên hàng trước đó. Hãy thử trực tuyến!

Những chuỗi đó sau đó được gửi vào một vòng lặp , |%{$c=if(++$i%2){('+','.')[($b=!$b)]}else{' '};$_.PadRight(25,$c)}. Mỗi lần lặp, chúng ta sẽ chọn đúng ký tự (dấu cộng, dấu chấm hoặc dấu cách), sau đó sử dụng .PadRighthàm để điền vào số lượng ký tự phù hợp. Hãy thử trực tuyến!

Bây giờ, chúng ta có nền tảng của góc trên bên phải. Chúng ta cần đảo ngược từng chuỗi |%{,($_+-join$_[($z=25..0)])*2}và nối chúng lại với nhau để có thể có được đỉnh của khối. Điều này được thực hiện với -joinlệnh và lập chỉ mục lạc hậu 25..0. Ngoài ra, chúng tôi gói gọn các chuỗi trong một mảng ,(...)và làm cho chúng tăng gấp đôi *2để chúng tôi có được toàn bộ đầu. Hãy thử trực tuyến!

Đó là tất cả được lưu trữ $xvà đóng gói trong parens để nó đặt các chuỗi trên đường ống. Cuối cùng, chúng tôi đảo ngược$x (chắc chắn sẽ bắn ra hàng giữa trùng lặp trùng lặp, nếu không chúng tôi sẽ có bốn ..ở giữa) và để lại những người trên đường ống. Một ẩn ẩn Write-Outputmột dòng mới giữa các chuỗi, vì vậy chúng tôi nhận được nó miễn phí.

— AdBorkBork
nguồn
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.