Phức tạp đơn giản

17

Đầu ra

                  # # # # # ##### ## #         
                  ## #### ####### # # ###        
                #### ## ## # ### #######        
                # # # # ##### ### # #        
                # # ### ##### ##### # # # #        
                ####### ### # ### # ## ####        
                ## # # ### # ####### ##          
                 # ## ##### ##### # # #          
                ## # # # # #####  
                 # ## ## ####### # #  
                 ####### #### ## # ###
                ### # # # # # ##### 
                    # # # # ### ##### #     
                    #### ####### ### # ##    
                    ## ## # # #######    
                     # # ## ##### # #    
    # # ##### ## # #                     
    ####### # # ## ##                    
    ## # ### ####### ####                    
     # ##### ### # # # #                    
 ##### # # # # # ###                
### # ## #### #######                 
  # ####### ## ## #                 
  ##### # # # # ###                
          # # # ##### ##### ## #                 
          ## ####### # ### # # ###                
        #### ## # ### # ### #######                
        # # # ##### ##### ### # #                
        # # ### ##### # # # #                
        ####### ### # ## ## ####                
        ## # # ####### #### ##                  
         # ## ##### # # # # # #                  
                                          #                     
                                          ##                    
                                        ####                    
                                        # #                    
                                        # # ###                
                                        #######                 
                                        ## #                 
                                         # ##                
                                 ##### ## #                 
                                ### # # ##                
                                  # ### #######                
                                  ##### ### # #                
                                  # # #                
                                  ## ####                
                                #### ##                  
                                # # #                  
                                  # # # # # #####  
                                  ## #### ####### #  
                                #### ## ## # ###
                                # # # # ##### 
                                # # ### ##### ##### #     
                                ####### ### # ### # ##    
                                ## # # ### # #######    
                                 # ## ##### ##### # #    
                                ## # #     
                                 # ## ##    
                                 ####### ####    
                                ### # # # #    
                                    # # # # ###
                                    #### ####### 
                                    ## ## # 
                                     # # ##

Trailing space cho phép. Giải pháp ngắn nhất chiến thắng.

gợi ý0

gợi ý1:

gợi ý1

cảm ơn @Tahg đã sửa lỗi1

code-golf  ascii-art  kolmogorov-complexity 
— ngn
nguồn
8
@ngn đầu ra chỉ thách thức mà không có bất kỳ lời giải thích nào về cách dữ liệu được hình thành thường được tán thành (xem codegolf.stackexchange.com/q/126037 ), vì câu trả lời đầu tiên có xu hướng thổi bay phần "bí ẩn"
— Uriel
16
Cá nhân tôi không thích những thử thách như thế này trong đó việc tìm ra quy tắc / công thức là một phần của nhiệm vụ. Bên cạnh đó, một khi một người tìm thấy nó, tất cả những người khác chỉ có thể theo dõi nó, vậy tại sao không đăng bài ngay từ đầu?
— Luis Mendo
11
@LuisMendo Đó là một cuộc tranh luận thú vị. Code golf ở dạng tinh khiết nhất là về "thực hiện một giải pháp đã biết một cách cô đọng". Câu đố ở dạng tinh khiết nhất của họ là về việc tìm kiếm một giải pháp - việc thực hiện không liên quan hoặc được coi là công việc bận rộn. Một lựa chọn sẽ là đăng "mánh khóe" trong spoilers. Bằng cách đó, những người chơi golf mã thuần để tấn công vấn đề như một thử thách chơi gôn, và những người thích cả hai thử thách chơi gôn và giải đố có thể tránh được việc tìm kiếm và giải quyết cả hai.
— Giô-na
5
Tôi nghĩ phần "bí ẩn" là thứ mà tôi chắc chắn có thể nhìn thấy nhiều hơn. Mặc dù một câu trả lời có thể tìm ra mánh khóe cho nó, phần còn lại của nó vẫn là một thử thách chơi gôn mã thông thường ... Và nó cung cấp một thử thách tốt cho những ai muốn tìm ra mô hình ngay từ đầu.
— hoàn toàn là
3
@ H.PWiz, tôi không chắc chắn rằng + 26 / -7 thực sự "được đón nhận". Nó trông giống như "nhận được kém hơn nhưng đã đạt được HNQ đủ nhanh để có được một số điểm sai lệch".
— Peter Taylor

Câu trả lời:

11

SOGL V0.12 , 17 16 14 byte

 #6{³IIč▓┼;I+§

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

Ở lần cập nhật sau, č▓có thể loại bỏ 12 byte - chuyển đổi ToS từ một mảng các ký tự thành một chuỗi nhiều dòng thành một chuỗi các chuỗi - [["#","#"],[" ","#"]] -> ["##"," #"]-, bởi vì ┼- nối thêm - không xử lý tốt các mảng các ký tự - mà Itạo ra, bởi vì nó được sử dụng để xoay mảng quá. Trong SOGL, một mảng các ký tự phải là = mảng chuỗi, nhưng nhiều thứ chưa hỗ trợ điều đó ..

Giải trình:

 #            push "#"
  6{          6 times do
    ³           create 3 total copies of ToS
     II         rotate clockwise twice
       č▓       normalize as explained above
         ┼      append horizontally
          ;     get the 3rd copy ontop
           I    rotate clockwise
            +   append vertically
             §  reverse horizontally
— dzaima
nguồn
1
chờ xem nó hoạt động thế nào
— Conor O'Brien
@ ConorO'Brien vừa thêm một lời giải thích: p
— dzaima
ồ tuyệt vời `` `` ``
— Conor O'Brien
22

JavaScript (ES6), 233 217 213 198 182 170 163 122 byte

f=_=>[...Array(64)].map((_,x,a)=>a.map(g=(i=(n=64,x),j)=>(n>>=1)?i&n?j&n?g(j,i):` `:j&n?g(i,~j):g(~i,j):`#`).join``).join`
`
document.write(`<pre>${f()}</pre>`)
Mở rộng đoạn trích

Chỉnh sửa: Đã lưu 14 18 byte nhờ @Shaggy. Đã lưu 3 byte nhờ @ngn. Đã lưu thêm 12 byte nhờ hai người làm việc cùng nhau. Đã lưu 41 byte bằng cách đánh cắp các quan sát của @ user202729 rằng các khu vực sử dụng phản xạ thay vì quay. Ung dung:

function f() {
    var s = '';
    for (var i = 0; i < 64; i++) {
        for (var j = 0; j < 64; j++) {
            var x = i, y = j, c = '#'; // Default to #
            // Each non-blank quadrant maps to to the original
            // image by doubling and a reflection. Repeat
            // this six times unless we hit the blank quadrant.
            for (var n = 0; n < 6; n++) {
                if (x >= 32) {
                    if (y >= 32) {
                        // Bottom right quarter is a diagonal reflection
                        var t = x - 32;
                        x = y - 32;
                        y = t;
                    } else {
                        // Bottom left quarter is blank
                        c = ' ';
                        break;
                    }
                } else {
                    if (y >= 32) {
                       // Top right corner is a horizontal reflection
                       y = 63 - y;
                    } else {
                       // Top left corner is a vertical reflection
                       x = 31 - x;
                    }
                }
                x *= 2;
                y *= 2;
            }
            s += c;
        }
        s += '\n';
    }
    return s;
}
— Neil
nguồn
Bạn có cần phải đếm f=ở đây? Nhân tiện, thực hiện.
— Xù xì
— Shaggy
1
Bạn không cần f=số byte, nhưng đoạn mã không hoạt động mà không có nó.
1
@Neil Bất kỳ cơ hội nào bạn có thể thêm một lời giải thích hoặc một phiên bản không có ý thức?
— Giô-na
1
@Jonah Tôi hy vọng bạn thấy rằng hữu ích.
— Neil
11

LOGO, 375 341 297 295 278 + 3 byte

Thêm 3 byte vì -pcờ, cho phép chế độ phối cảnh theo mặc định, do đó không cần chạy perspectivelệnh, tiết kiệm tổng thể 9 byte.

Sử dụng FMSLogo trên Windows với định dạng dòng mới Unix (LF) (FMSLogo có vấn đề với phân tích định dạng dòng mới CR)

to R
rt 90
end
to g :w :l
R fd 2*:l R bk :l up 180
run :w
R run :w
fd 2*:l R bk :l run :w
fd 2*:l up 180
end
to h
pu
ask -1[setxyz 0 0 870]g[g[g[g[g[g[rt 45 fd .7 pd fd 0 pu bk .7 lt 45]1]2]4]8]16]32
repeat 64[sety 64-# repeat 64[setx #-1 type if pixel=[0 0 0]""#["\ ]](pr)]
end

Thật không may, không có "Hãy thử trực tuyến!" liên kết vì tôi không thể tìm thấy bất kỳ chế độ phối cảnh hỗ trợ phiên dịch trực tuyến.

Ý tưởng: Vẽ một hình ảnh của hình ảnh, sau đó lấy các pixel từ hình ảnh và in ra như đầu ra.

Phân tích hình ảnh thành các phần lặp lại đơn giản:

.

Hãy sử dụng các gợi ý ở trên. Tuy nhiên, vì LOGO không hỗ trợ phản chiếu, chúng tôi chỉ có thể mô phỏng điều đó bằng cách vào perspectivechế độ 3D ( ) và xoay rùa 180 độ quanh một trục song song với màn hình máy tính.

Điều này xác định một hàm trợ giúp g, đưa ra 2 tham số l(độ dài cạnh hình ảnh) và w(thủ tục được sử dụng để vẽ hình ảnh), vẽ 3 bản sao của hình ảnh phản chiếu của nó. (xem gợi ý trong câu hỏi) Quy trình hthực hiện quy trình chính.

— người dùng202729
nguồn
Bạn có thể có thể bỏ qua một số khoảng trắng như 90 fd-> 90fdvà lưu một vài byte.
— Jonathan Frech
@JonathanFrech Thật không may, FMSLogo không hỗ trợ điều đó.
— dùng202729
Tại sao papert hỗ trợ nó sau đó?
— Jonathan Frech
2
Đây có phải là câu trả lời duy nhất thực sự khai thác mô hình hơn là đóng gói bit?
— Giô-na
2
@Jonah Giải pháp JS trước tiên là khai thác mô hình, mặc dù nó thực hiện theo một cách thú vị - với các phép toán số học và bit mô-đun thay vì ma trận nối. Giải pháp LOGO này cũng thú vị và độc đáo với phương pháp đọc pixel. Tôi không biết đủ LOGO để hiểu mã nhưng đánh giá theo mô tả, nó lặp đi lặp lại các mẫu nhất định mà không đi sâu vào cấu trúc của fractal (mà tôi đã đưa ra trong gợi ý1).
— ngn
8

Python 2 , 205 195 ... 145 144 142 144 byte

g=lambda n,i,j,*_:g(n/2,*[~i,j,i,~j][2*(j&n>0)-(i&n>0):])if n*(i&n<=j&n)else'# '[i&n>0]
r=range(64)
for j in r:print''.join(g(32,j,i)for i in r)

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

Lấy cảm hứng từ câu trả lời JS của Neil .

— TFeld
nguồn
n>>1là n/=2.
— Jonathan Frech
ađược định nghĩa và sau đó được sử dụng một lần. Thay thế tham chiếu của nó bằng giá trị của nó có thể tiết kiệm bốn byte.
— Jonathan Frech
Tôi đã bỏ qua một sự đơn giản hóa hữu ích - thay vì thực hiện mọi thứ bằng cách sử dụng các phép quay, thay vào đó tôi nên sử dụng các phản xạ. Nó đã tiết kiệm cho tôi 41 byte trên câu trả lời của tôi!
— Neil
Tôi nghĩ bạn có thể lưu hai byte bằng cách đơn giản hóa [...[x],...[x]][z]lựa chọn của bạn .
— Jonathan Frech
1
@totallyhuman Đủ công bằng
— TFeld
7

Haskell, 126 125 113 106 103 byte

e=[]:e
z=zipWith
r=reverse
m s=z(++)(r s++map(' '<$)s)$map r s++foldr(z(:))e s
unlines$m$m$m$m$m$m["#"]

Một triển khai trực tiếp của gợi ý1 trong spoiler.

Hàm mtạo ra lần lặp tiếp theo. Các chức năng chính áp dụng m6 lần. Chi tiết về m:

m s=                          -- s is the current pattern
     zipWith(++)              -- concatenate pairwise the lines of
                (r s)++       --    the lines of s in reverse order, followed by
                map(' '<$)s   --    each char in s replaced by a space
                              -- and
                map r s++     --    each line of s reversed, followed by
                foldr ... s   --    the transposition of s


e=[]:e;foldr(zipWith(:))e     -- this right fold transposes a matrix

Chỉnh sửa: @ngn đã lưu một byte và @Laikoni khác 3. Cảm ơn!

— nimi
nguồn
n$n$n$n$n$n["#"]ngắn hơn iterate n["#"]!!6:)
— ngn
@ngn: phát hiện tốt. Cảm ơn rất nhiều!
— nimi
Bạn có thể sử dụng e=[]:e;foldr(zipWith(:))ethay vì import Data.List;transposevà sau đó rút ngắn zipWith.
— Laikoni
6

Java 7, 259 238 237 200 byte

void f(){char[][]o={{35}},n;for(int s=1,x,y;s<64;s*=2,o=n)for(n=new char[64][64],x=s;x-->0;)for(y=0;y<s;n[s+y++][x]=32)n[s+~y][x]=n[y][2*s+~x]=n[s+x][s+y]=o[y][x];for(char[]b:o)System.out.println(b);}

Đã lưu 2 byte bằng cách xóa {} trên vòng x, cảm ơn ngn
Đã lưu 19 byte từ các thay đổi gán khác nhau, cảm ơn Jonathan đã
lưu 24 byte để in so với trả về (không biết điều này được cho phép) và đã
lưu 13 byte để thay đổi vòng lặp, cảm ơn

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

Thử thách đầu tiên của tôi và tôi nghĩ là đáng kính đối với Java. Sử dụng gợi ý 1, (đó là sai btw, nhưng tôi không thể viết bình luận). Nó có thể có thể được chơi gôn hơn nữa, đường chuyền này về cơ bản là như vậy, mà không cần in ấn đẹp.

— Tahg
nguồn
Tôi không chắc có phải do sự khác biệt về phiên bản hay không, nhưng tôi đã kiểm tra mã của bạn trên TIO bằng Java 8 và nó in các ký tự null thay vì dấu cách.
— Jonathan Frech
Nó chắc chắn đã làm, cảm ơn vì đã chú ý. Rõ ràng, Java khá hài lòng với việc hiển thị null dưới dạng khoảng trắng trong Chuỗi của nó.
— Tahg
Bạn có thể lưu một byte bằng cách xóa s=1khỏi vòng lặp for của bạn và thay thế int s,t,x,y;bằng int s=1,t,x,y;.
— Jonathan Frech
1
n[s-1-y][x]=o[y][x];n[y][t-1-x]=o[y][x];-> n[s-1-y][x]=n[y][t-1-x]=o[y][x];.
— Jonathan Frech
2
ma trận biến đổi phù hợp là [[V, H], [_, T]] (Hoặc đó hoặc có một số khác biệt tinh tế trong thuật toán của bạn, nhưng đó là những gì tôi cần)
— Tahg
3

Python 2, 586 byte

import zlib,base64 as b
print zlib.decompress(b.b64decode('eJyVVlsOwzAI++8pJuX+d1zXDGLAUKi0pUp52ATcfj7+Wni3dF2/677ZO1dw+z/Zd3+rJU4SdkVHMcYQS9OuJVGio4N61p31+TGoQkco6eqoU6gSWdBJRrQhjhIdvLQ6YhNrqrEtUsu8yEbjmRqUWXlgYbl5EHfLC7cDQl4sxxAhO4wUv7fFPTx22sUWqOeEJ544Z3vn9FPU+ZmdHtCak6Fk3hfCx0FkOC8DF4YvmgoFMnCEwW2cDBkzftoiGy4GZaNhM8VYSl3YMEV7ctxsjLQKRCHZ3IB6+ATZpKSKmEyGrqZvEHY8lEQBWf8zbuAg0eypWG6nRqTLIzM+NPQa2faN89FlxhMY2vcTKDP7579fl0rmIpJ+grTvSyis798ghb4vM0CuVgbM1SFdvukjnFnfR1Gt3vAEngd6lGrIDdfkDU/ARwl+ecMHf5SzIzct8KhsqHANZ0FqFbpXdad5qH2DzOHJIHGM2pz26oug9i2+EBpX+cXQCpBA7/tne01lLb4wviHjtJE='))

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

Python 2, 1032 1025 byte

Tôi thích cái này hơn Nhưng nó dài hơn nhiều. Nó có thể được đánh golf xuống nhưng không cần điều đó. Cách tiếp cận chính thức ngắn hơn nhiều.

-7 cảm ơn Jonathan Frech

print''.join(' '*int(x)if'/'<x<'@'else("#"*(ord(x)-64),"\n")[x<"#"]for x in'99A9A2A4A2A1E2B4A9!99B8D4G2A3A4B8!88D8B6B4A2C1G8!88A2A9A7A4E1C1A2A8!88A2A1C1E3E4A9A2A8!88G1C2A2C2A4B8D8!88B4A3A2C2A2G8B55!98A4B2E3E1A2A9A55!88B4A559A9A2A1E2!98A4B99B8G2A2!98G88D8B4A2C!88C1A2A88A2A9A4E1!992A2A88A2A1C1E4A5!992D88G1C2A4B4!992B99B4A3A2G4!777A559A4B2E1A2A4!4A2A1E2B4A559A777!4G2A3A4B99B992!4B4A2C1G88D992!5A4E1C1A2A88A2A569!1E4A9A2A88A2A1C88!C2A4B8D88G98!2A2G8B99B4A89!2E1A2A9A559A4B88!55A9A2A1E3E2B4A98!55B8G2A2C2A3A4B88!8D8B4A2C2A2C1G88!8A2A9A4E3E1C1A2A88!8A2A1C1E4A7A9A2A88!8G1C2A4B6B8D88!8B4A3A2G4D8B99!9A4B2E1A2A4A2A9A99!99996A777!99996B992!99994D299!99994A2A992!99994A2A1C88!99994G98!99994B4A98!99995A4B88!9996E2B4A89!9995C2A3A4B88!9997A2C1G88!9997E1C1A2A88!9997A9A2A88!9997B8D88!9995D8B99!9995A2A9A99!9997A9A2A4A2A1E2!9997B8D4G2A2!9995D8B6B4A2C!9995A2A9A7A4E1!9995A2A1C1E3E4A5!9995G1C2A2C2A4B4!9995B4A3A2C2A2G4!9996A4B2E3E1A2A4!9995B4A559A5!9996A4B99B4!9996G88D4!9995C1A2A88A2A4!9999A2A88A2A1C!9999D88G1!9999B99B4A1!99991A559A4B')

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

— Simon
nguồn
Câu hỏi cho phép [t]railing spaces, mặc dù giải pháp của bạn bỏ qua một số không gian.
— Jonathan Frech
cho phép dấu cách có nghĩa là tôi không phải xuất chúng. Đúng không? Nó sẽ tiết kiệm byte theo cách tiếp cận thứ hai của tôi. Lần đầu tiên, nó đã được thực hiện bởi vì tôi đã xóa các dấu cách trong khi lưu tệp của mình ...
— Simon
Tôi không biết chắc chắn, nhưng tôi giải thích nó là cho phép thêm không gian, không cho phép thiếu không gian.
— Jonathan Frech
x=='!'->x<'#'
— Jonathan Frech
if x.isdigit()->if"/"<x<"@"
— Jonathan Frech
3

Toán học, 112 90 byte

Cảm ơn Jonathan Frech đã giúp tiết kiệm 2 byte!

""<>Nest[{{(r=Reverse)@#,r/@#},{" "+0#,#}}~Flatten~{{1,3},{2,4}}&,{{"#"}},6]~Riffle~"
"

Hãy thử trực tuyến!(Toán học)

Vì một số lý do, Mathics in các khoảng trắng hàng đầu trong tất cả các dòng trừ dòng đầu tiên khi in chuỗi đa dòng. Ngoài ra Mathics không hỗ trợ toán tử .

Giải trình:

  • {{Reverse@#,Reverse/@#},{" "+0#,#}}: Biểu diễn ngược chiều ngang, ngược chiều dọc, thay thế tất cả bằng " "và chuyển vị ( là toán tử chuyển vị trong Mathicala), tương ứng với các cách khác nhau để phản chiếu hoặc xoay hình ảnh.
  • ~Flatten~{{1,3},{2,4}} : Làm phẳng các kích thước cụ thể.
  • Nest[ ... ,{{"#"}},6] : Áp dụng chức năng bên trong để {{"#"}} 6 lần.
  • ~Riffle~"<literal newline character>" : Riffle một ký tự dòng mới giữa mỗi dòng.
  • ""<> : Tham gia tất cả các chuỗi với nhau.
— người dùng202729
nguồn
Bạn có thể xác định thay thế Reversebằng Rvà xác định R=Reverse;để lưu hai byte.
— Jonathan Frech
2

C # (.NET Core) , 1016 1002 980 955 byte

Đã lưu 14 byte nhờ Kevin Cruijssen!
Đã lưu 47 byte nhờ Jonathan Frech!

o=>{foreach(var l in new[]{35223185965568,52841249260288,0xf00c0c277f00,0x9004043ee900,0x977c7c200900,0xfee4e4300f00,0xc22727f00c00,73934616658944,0xc2000020097c,73667282210788,0x7f0000f00c27,0xe9000090043e,9895614577696,0xf0000fee430,0xc0000c227f0,4398050918032,325982355457<<21,1092065689603<<20,835235872783<<20,291765223433<<20,0x7c20090000970000,-15289957744513<<17,21955973480545<<17,68788263321667<<16,68799053409<<17,206425089091<<16,0xf00c27277f0000,618546478825<<16,650622541833<<16,0xfee430300f0000,208473439235<<18,72203117569<<18,1<<21,3<<20,15<<20,9<<20,9895936,127<<17,97<<17,67<<16,15969<<17,3829596160,662634496,16105<<16,8201<<16,806289408,4027318272,9217L<<18,537463164,806293476,4027321383,2416182334,2541517856,4276413488,3257346032,1128152720,3254779936,1124073520,2130706672,3909091472,150995095,251658494,201326786,67108931})System.Console.WriteLine(System.Convert.ToString(l,2).PadLeft(64,'0').Replace('0',' ').Replace('1','#'));}

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

Giải trình

Định dạng của đầu ra được lưu trữ bên trong một dãy các số 64 bit đã ký, phù hợp hoàn hảo vì mỗi dòng dài 64 ký tự. Không gian trống được đại diện bởi 0và #được đại diện bởi1 .

Các số sau đó được chuyển đổi thành chuỗi nhị phân của chúng, các số 0 được đệm trái cho đến khi chuỗi rộng 64 ký tự và sau đó các ký tự 0và 1được thay thế bằng  và #.

Mã được lưu trữ bên trong một hàm lamba, cụ thể hơn là a System.Func<string>.

Một số hằng số trong long[]được rút ngắn bằng cách thực hiện một số dịch chuyển bit.

— Ian H.
nguồn
Không có một không gian không cần thiết trong long[] n=new[]?
— Jonathan Frech
@JonathanFrech À bạn nói đúng, hình như nó lẻn vào đó bằng cách nào đó.
— Ian H.
1
Bạn sẽ tiết kiệm được 4 byte bằng cách không phải chỉ định ký tự đệm.
— Neil
1
Chà, nếu lkhông cần theo dõi, bạn có thể tiết kiệm được nhiều byte hơn nữa .
— Jonathan Frech
1
Có vẻ như đáy của cái này bị lỗi.
— Xù xì
2

Than , 42 byte

#↓##ＦＥ⁵Ｘ²ι«‖↑Ｊ⁻×³ι¹±⁰ψ⟲ＯＯ⁴ײι⟲ＣＪ⁰±φＴ×⁴ι×⁴ι

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Sẽ là 25 byte nếu điều này hoạt động:

#ＦＥ⁷Ｘ²ι«‖↑⟲Ｃ→⁴⟲ＣＪ⁰±φＴιι

Giải trình:

#↓##

Tạo thủ công đệ quy đầu tiên, vì không thể xoay quanh (1, 0,5). (Xoay như vậy sẽ chỉ có ý nghĩa nếu nó là 180 °.)

ＦＥ⁵Ｘ²ι«

Lặp lại năm quyền hạn đầu tiên của 2 (1, 2, 4, 8, 16).

‖↑

Phản chiếu vải theo chiều dọc. Điều này hoàn thành quý trên cùng bên trái của kết quả.

Ｊ⁻×³ι¹±⁰ψ⟲ＯＯ⁴ײι

Xoay khung vẽ 180 ° quanh một nửa điểm ở phía bên tay phải. Bản sao kết thúc ở vị trí chính xác cho quý trên cùng của kết quả.

⟲Ｃ

Xoay khung vẽ 90 ° quanh góc dưới bên phải. Bản sao của góc trên cùng bên phải kết thúc ở vị trí chính xác cho góc dưới bên phải của kết quả. Bản sao của góc trên cùng bên trái là không liên quan.

Ｊ⁰±φＴ×⁴ι×⁴ι

Cắt vải theo kích thước chúng ta muốn. Việc cắt bắt đầu ở con trỏ hoặc trên cùng bên trái của khung vẽ, tùy theo góc dưới cùng bên phải. Do đó, con trỏ được gửi đến (0, -1000) để đảm bảo rằng nó không can thiệp vào phần trang trí.

— Neil
nguồn
1

Perl 5 , 452 byte

Mã 451 byte + 1 cho -p .

Đóng gói tất cả dữ liệu vào chuỗi, thay vì ăn cắp câu trả lời đúng của @ Neil .

$_=unpack"B*","\x00\x00\x20\x09\x09\x7c\xc2\x33\x00\x30\x0f\x0f\xe4\x43\x33\x00\xf0\x0c\x0c\x27\x7f\x33\x00\x90\x04\x04\x3e\xe9\x33\x00\x97\x7c\x7c\x20\x09\x33\x00\xfe\xe4\xe4\x30\x0f\x33\x00\xc2\x27\x27\xf0\x0c\x33\x00\x43\x3e\x3e\x90\x04\x33\x00\xc2\x00\x00\x20\x09\x7c\x00\x00\x43\x00\x00\x30\x0f\xe4\x00\x00\x7f\x00\x00\xf0\x0c\x27\x00\x00\xe9\x00\x00\x90\x04\x3e\x00\x00\x09\x00\x00\x97\x7c\x20\x00\x00\x0f\x00\x00\xfe\xe4\x30\x00\x00\x0c\x00\x00\xc2\x27\xf0\x00\x00\x04\x00\x00\x43\x3e\x90\x09\x7c\xc2\x00\x00\x20\x00\x00\x0f\xe4\x43\x00\x00\x30\x00\x00\x0c\x27\x7f\x00\x00\xf0\x00\x00\x04\x3e\xe9\x00\x00\x90\x00\x00\x7c\x20\x09\x00\x00\x97\x00\x00\xe4\x30\x0f\x00\x00\xfe\x00\x00\x27\xf0\x0c\x00\x00\xc2\x00\x00\x3e\x90\x04\x00\x00\x43\x33\x00\x20\x09\x7c\x7c\xc2\x33\x00\x30\x0f\xe4\xe4\x43\x33\x00\xf0\x0c\x27\x27\x7f\x33\x00\x90\x04\x3e\x3e\xe9\x33\x00\x97\x7c\x20\x20\x09\x33\x00\xfe\xe4\x30\x30\x0f\x33\x00\xc2\x27\xf0\xf0\x0c\x33\x00\x43\x3e\x90\x90\x04\x37\x00\x20\x37\x00\x30\x37\x00\xf0\x37\x00\x90\x37\x00\x97\x37\x00\xfe\x37\x00\xc2\x37\x00\x43\x36\x00\x7c\xc2\x36\x00\xe4\x43\x36\x00\x27\x7f\x36\x00\x3e\xe9\x36\x00\x20\x09\x36\x00\x30\x0f\x36\x00\xf0\x0c\x36\x00\x90\x04\x36\x00\x20\x09\x09\x7c\x34\x00\x30\x0f\x0f\xe4\x34\x00\xf0\x0c\x0c\x27\x34\x00\x90\x04\x04\x3e\x34\x00\x97\x7c\x7c\x20\x34\x00\xfe\xe4\xe4\x30\x34\x00\xc2\x27\x27\xf0\x34\x00\x43\x3e\x3e\x90\x34\x00\xc2\x00\x00\x20\x34\x00\x43\x00\x00\x30\x34\x00\x7f\x00\x00\xf0\x34\x00\xe9\x00\x00\x90\x34\x00\x09\x00\x00\x97\x34\x00\x0f\x00\x00\xfe\x34\x00\x0c\x00\x00\xc2\x34\x00\x04\x00\x00\x43"=~s/[3-9](.)/$1x$&/ger;y/01/ #/;s/.{64}/$&
/g

Đầu ra có thể đảo ngược từ xxdcho tệp 451 byte:

00000000: 245f 3d75 6e70 6163 6b22 422a 222c 2200  $_=unpack"B*",".
00000010: 0020 0909 7cc2 3300 300f 0fe4 4333 00f0  . ..|.3.0...C3..
00000020: 0c0c 277f 3300 9004 043e e933 0097 7c7c  ..'.3....>.3..||
00000030: 2009 3300 fee4 e430 0f33 00c2 2727 f00c   .3....0.3..''..
00000040: 3300 433e 3e90 0433 00c2 0000 2009 7c00  3.C>>..3.... .|.
00000050: 0043 0000 300f e400 007f 0000 f00c 2700  .C..0.........'.
00000060: 00e9 0000 9004 3e00 0009 0000 977c 2000  ......>......| .
00000070: 000f 0000 fee4 3000 000c 0000 c227 f000  ......0......'..
00000080: 0004 0000 433e 9009 7cc2 0000 2000 000f  ....C>..|... ...
00000090: e443 0000 3000 000c 277f 0000 f000 0004  .C..0...'.......
000000a0: 3ee9 0000 9000 007c 2009 0000 9700 00e4  >......| .......
000000b0: 300f 0000 fe00 0027 f00c 0000 c200 003e  0......'.......>
000000c0: 9004 0000 4333 0020 097c 7cc2 3300 300f  ....C3. .||.3.0.
000000d0: e4e4 4333 00f0 0c27 277f 3300 9004 3e3e  ..C3...''.3...>>
000000e0: e933 0097 7c20 2009 3300 fee4 3030 0f33  .3..|  .3...00.3
000000f0: 00c2 27f0 f00c 3300 433e 9090 0437 0020  ..'...3.C>...7. 
00000100: 3700 3037 00f0 3700 9037 0097 3700 fe37  7.07..7..7..7..7
00000110: 00c2 3700 4336 007c c236 00e4 4336 0027  ..7.C6.|.6..C6.'
00000120: 7f36 003e e936 0020 0936 0030 0f36 00f0  .6.>.6. .6.0.6..
00000130: 0c36 0090 0436 0020 0909 7c34 0030 0f0f  .6...6. ..|4.0..
00000140: e434 00f0 0c0c 2734 0090 0404 3e34 0097  .4....'4....>4..
00000150: 7c7c 2034 00fe e4e4 3034 00c2 2727 f034  || 4....04..''.4
00000160: 0043 3e3e 9034 00c2 0000 2034 0043 0000  .C>>.4.... 4.C..
00000170: 3034 007f 0000 f034 00e9 0000 9034 0009  04.....4.....4..
00000180: 0000 9734 000f 0000 fe34 000c 0000 c234  ...4.....4.....4
00000190: 0004 0000 4322 3d7e 732f 5b33 2d39 5d28  ....C"=~s/[3-9](
000001a0: 2e29 2f24 3178 2426 2f67 6572 3b79 2f30  .)/$1x$&/ger;y/0
000001b0: 312f 2023 2f3b 732f 2e7b 3634 7d2f 2426  1/ #/;s/.{64}/$&
000001c0: 0a2f 67                                  ./g

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

— Dom Hastings
nguồn
1

Jq 1.5 , 538 535 488 476 byte

Đây là một đại diện đơn giản. Tôi chưa thử mã hóa ưa thích nào.Thay thế 0,0 cặp bằng chức năng Z.

Một lần nữa xin cảm ơn Jonathan Frech vì đã giúp loại bỏ 3 byte!

def B:recurse(if.>0then./2|floor else empty end)|.%2;def S:256+.|[B]|reverse[2:]|map(if.>0then"#"else" "end)|join("");def Z:0,0;[[Z,3,1,1,4,5,2],[1,4,5,2,2,3,Z],[Z,Z,2,3,Z],[Z,Z,3,1,1,4]]as$m|[[],[9,15,12,4,124,228,39,62],[Z,Z,Z,Z,124,228,39,62,32,48,240,144],[32,48,240,144,151,254,194,67,194,67,127,233,9,15,12,4],[124,228,39,62,32,48,240,144,32,48,240,144,151,254,194,67],[194,67,127,233,9,15,12,4,9,15,12,4,124,228,39,62]]as$c|$m[]|range(16)as$l|map($c[.][$l]|S)|join("")

Số lượng nhân vật

$ wc -c picture.jq
 476 picture.jq

Chạy mẫu

$ jq -Mnr -f picture.jq
                  #         #  #    #  # #####  ##    #         
                  ##        ####    #######  #   #    ##        
                ####        ##      ##    #  ### #######        
                #  #         #       #    ##### ### #  #        
                #  # ### #####   #####    #         #  #        
                ####### ###  #  ###  #    ##        ####        
                ##    #   #  ###  #  #######        ##          
                 #    ##  #####   ##### #  #         #          
                ##    #                   #         #  # #####  
                 #    ##                  ##        #######  #  
                 #######                ####        ##    #  ###
                ### #  #                #  #         #    ##### 
                    #  #                #  # ### #####    #     
                    ####                ####### ###  #    ##    
                    ##                  ##    #   #  #######    
                     #                   #    ##  ##### #  #    
    #  # #####  ##    #                   #                     
    #######  #   #    ##                  ##                    
    ##    #  ### #######                ####                    
     #    ##### ### #  #                #  #                    
 #####    #         #  #                #  # ###                
###  #    ##        ####                #######                 
  #  #######        ##                  ##    #                 
  ##### #  #         #                   #    ##                
          #         #  # #####   #####  ##    #                 
          ##        #######  #  ###  #   #    ##                
        ####        ##    #  ###  #  ### #######                
        #  #         #    #####   ##### ### #  #                
        #  # ### #####    #       #         #  #                
        ####### ###  #    ##      ##        ####                
        ##    #   #  #######    ####        ##                  
         #    ##  ##### #  #    #  #         #                  
                                          #                     
                                          ##                    
                                        ####                    
                                        #  #                    
                                        #  # ###                
                                        #######                 
                                        ##    #                 
                                         #    ##                
                                 #####  ##    #                 
                                ###  #   #    ##                
                                  #  ### #######                
                                  ##### ### #  #                
                                  #         #  #                
                                  ##        ####                
                                ####        ##                  
                                #  #         #                  
                                  #         #  #    #  # #####  
                                  ##        ####    #######  #  
                                ####        ##      ##    #  ###
                                #  #         #       #    ##### 
                                #  # ### #####   #####    #     
                                ####### ###  #  ###  #    ##    
                                ##    #   #  ###  #  #######    
                                 #    ##  #####   ##### #  #    
                                ##    #                   #     
                                 #    ##                  ##    
                                 #######                ####    
                                ### #  #                #  #    
                                    #  #                #  # ###
                                    ####                ####### 
                                    ##                  ##    # 
                                     #                   #    ##
— jq170727
nguồn
1
Ba không gian có thể bỏ qua trong B: recvà 16) as $l|.
— Jonathan Frech
1
if.==0then" "else"#"end-> if.>0then"#"else" "end.
— Jonathan Frech
1

Python 2 , 174 164 154 byte (dựa trên các hoạt động ma trận)

  • -10 byte nhờ ngn.
  • -10 byte nhờ Jonathan Frech.
from numpy import*
s=[['#']]
exec'b=fliplr(s);s=vstack((hstack((flipud(s),b)),hstack((eye(len(s)),rot90(b)))));'*6
s[s>'#']=' '
for l in s:print''.join(l)

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

— mdahmoune
nguồn
import *-> import*; in s.tolist()->in s
— ngn
1
— Jonathan Frech
0

JavaScript (Node.js) , 1233 byte

_=>` 18# 9# 2# 4# 2# #5 2#2 4#
 18#2 8#4 4#7 2# 3# 4#2
 16#4 8#2 6#2 4# 2#3 #7
 16# 2# 9# 7# 4#5 #3 # 2#
 16# 2# #3 #5 3#5 4# 9# 2#
 16#7 #3 2# 2#3 2# 4#2 8#4
 16#2 4# 3# 2#3 2# 2#7 8#2
 17# 4#2 2#5 3#5 # 2# 9#
 16#2 4# 19# 9# 2# #5
 17# 4#2 18#2 8#7 2#
 17#7 16#4 8#2 4# 2#3
 16#3 # 2# 16# 2# 9# 4#5
 20# 2# 16# 2# #3 #5 4#
 20#4 16#7 #3 2# 4#2
 20#2 18#2 4# 3# 2#7
 21# 19# 4#2 2#5 # 2#
 4# 2# #5 2#2 4# 19#
 4#7 2# 3# 4#2 18#2
 4#2 4# 2#3 #7 16#4
 5# 4#5 #3 # 2# 16# 2#
 #5 4# 9# 2# 16# 2# #3
#3 2# 4#2 8#4 16#7
 2# 2#7 8#2 18#2 4#
 2#5 # 2# 9# 19# 4#2
 10# 9# 2# #5 3#5 2#2 4#
 10#2 8#7 2# 2#3 2# 3# 4#2
 8#4 8#2 4# 2#3 2# 2#3 #7
 8# 2# 9# 4#5 3#5 #3 # 2#
 8# 2# #3 #5 4# 7# 9# 2#
 8#7 #3 2# 4#2 6#2 8#4
 8#2 4# 3# 2#7 4#4 8#2
 9# 4#2 2#5 # 2# 4# 2# 9#
 42#
 42#2
 40#4
 40# 2#
 40# 2# #3
 40#7
 40#2 4#
 41# 4#2
 33#5 2#2 4#
 32#3 2# 3# 4#2
 34# 2#3 #7
 34#5 #3 # 2#
 34# 9# 2#
 34#2 8#4
 32#4 8#2
 32# 2# 9#
 34# 9# 2# 4# 2# #5
 34#2 8#4 4#7 2#
 32#4 8#2 6#2 4# 2#3
 32# 2# 9# 7# 4#5
 32# 2# #3 #5 3#5 4#
 32#7 #3 2# 2#3 2# 4#2
 32#2 4# 3# 2#3 2# 2#7
 33# 4#2 2#5 3#5 # 2#
 32#2 4# 19#
 33# 4#2 18#2
 33#7 16#4
 32#3 # 2# 16# 2#
 36# 2# 16# 2# #3
 36#4 16#7
 36#2 18#2 4#
 37# 19# 4#2`.replace(/(.)(\d+)/g,(_,c,n)=>c.repeat(n))

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

— hoàn toàn phi thường
nguồn
Ôi, vấn đề bây giờ là gì? Erm ... tôi có thiếu thứ gì không?
— hoàn toàn là
1
Tôi đã không downvote, nhưng, fyi, nó có thể được nén nhiều hơn bằng cách sử dụng này .
Tôi cũng không, nhưng đây không phải là tinh thần của câu hỏi. Mẫu được tạo ra, có lẽ, bằng một số thủ tục đệ quy đơn giản. Thách thức là xác định quy tắc, tại thời điểm đó giải pháp của bạn sẽ cực kỳ ngắn.
— Giô-na
1
Chuyển đổi sang cơ sở 36 để tiết kiệm ~ 50 byte.
— Xù xì
2
Tôi hoàn toàn nhận thức được rằng đây không phải là giải pháp tối ưu hay giải pháp ngắn nhất hay thông minh nhất. Tôi chỉ đơn giản là thử sử dụng một thuật toán và nó đã trở thành thứ này. Tuy nhiên, đây là một giải pháp hoàn toàn hợp lệ và do đó không xứng đáng được đánh giá thấp. Các giải pháp nhàm chán không nên được nâng cấp nhưng chúng cũng không nên bị hạ cấp.
— hoàn toàn là
0

C # (.NET Core) , 976 969 byte

o=>{foreach(var l in new[]{35223185965568,52841249260288,0xf00c0c277f00,0x9004043ee900,0x977c7c200900,0xfee4e4300f00,0xc22727f00c00,73934616658944,0xc2000020097c,73667282210788,0x7f0000f00c27,0xe9000090043e,9895614577696,0xf0000fee430,0xc0000c227f0,4398050918032,0x97cc20000200000,0xfe44300003<<20,0xc277f0000f<<20,0x43ee900009<<20,0x7c20090000970000,-0x1bcff0ffff020000,0x27f00c0000c20000,0x3e90040000430000,9017629528424448,0x300fe4e4430000,0xf00c27277f0000,0x90043e3ee90000,0x977c2020090000,0xfee430300f0000,0xc227f0f00c0000,0x433e9090040000,2097152,3145728,15728640,9437184,9895936,16646144,12713984,4390912,2093088768,3829596160,662634496,1055457280,537460736,806289408,4027318272,2416181248,537463164,806293476,4027321383,2416182334,2541517856,4276413488,3257346032,1128152720,3254779936,1124073520,2130706672,3909091472,150995095,251658494,201326786,67108931})System.Console.WriteLine(System.Convert.ToString(l,2).PadLeft(64).Replace('0',' ').Replace('1','#'));}

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

— đại từ của tôi là monicareinstate
nguồn
Xin chào, chào mừng đến với PPCG! Điều này trông gần giống hệt như câu trả lời C # .NET của @IanH .. Vì vậy, nếu bạn có bất kỳ cải tiến nào cho anh ấy, hãy đưa ra nhận xét thay vì tạo một câu trả lời mới gần giống hệt như vậy. Đối với câu hỏi của bạn, bạn có thể sử dụng <s>969</s>để gạch bỏ các byte trước đó.
— Kevin Cruijssen
4
Tôi không có danh tiếng cần thiết để bình luận.
— đại từ của tôi là monicareinstate
Xin đừng cố gắng phá vỡ các yêu cầu đại diện.
— Xù xì
2
Điều này có nghĩa là trong PPCG tôi không thể cố gắng giúp đỡ người khác nếu danh tiếng của tôi quá thấp?
— đại từ của tôi là monicareinstate
3
@Shaggy để công bằng, stackexchange là một chút khắc nghiệt đối với người mới, chúng ta đừng làm khó họ hơn bằng cách giả sử ác ý quá nhanh
— ngn
0

C # (Lõi .NET) , 739 byte

_=>{var r="";for(int i=0,j,k=0;i<626;i++)for(j=0;j++<@"4#+#$#&#$##'$$&#=$*&&)$#%#&$:&*$($&#$%#):#$#+#)#&'#%##$#:#$##%#'%'&#+#$#:)#%$#$%$#&$*&:$&#%#$%$#$)*$=#&$$'%'##$#+#<$&#5#+#$##'5#&$4$*)$#5)2&*$&#$%2%##$#2#$#+#&'7#$#2#$##%#'&#;&2)#%$#&$:$4$&#%#$);#5#&$$'##$#*#$##'$$&#5#;)$#%#&$4$:$&#$%#)2&;#&'#%##$#2#$#7'&#+#$#2#$##%2%$#&$*&2)5#$)*$4$&#5'##$#+#5#&$<#+#$##'%'$$&#=$*)$#$%$#%#&$:&*$&#$%$#$%#):#$#+#&'%'#%##$#:#$##%#'&#)#+#$#:)#%$#&$($*&:$&#%#$)&&*$=#&$$'##$#&#$#+#^#a$^&^#$#^#$##%Z)[$&#\#&$S'$$&#S%$#%#&$T#$%#)T'#%##$#T#+#$#T$*&R&*$T#$#+#V#+#$#&#$##'F$*&&)$#D&*$($&#$%B#$#+#)#&'C#$##%#'%'&#G)#%$#$%$#&$F$&#%#$%$#$)G#&$$'%'##$#F$&#5#H#&$4$G)2&F%##$#2#$#J#$#2#$##%F&2)G$4$&#H#5#&$"[i]-34;){r+=i%2<1?' ':'#';if(++k%64<1)r+='\n';}return r;}

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

Sử dụng cách tiếp cận tương tự là câu trả lời khác này .

— Charlie
nguồn
0

K (ngn / k) , 32 31 27 byte

6{,[|x;""x],'(+|+x),+x}/"#"

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

6{ }/ 6 lần làm

+x hoán vị

|x đảo ngược theo chiều dọc

+|+x đảo ngược theo chiều ngang

, nối theo chiều dọc

,' nối theo chiều ngang

,[A;B]cũng giống như A,B. nó giúp tránh các dấu ngoặc đơn xung quanh Avà xung quanh toàn bộ biểu thức

""xsử dụng các yếu tố xnhư là các chỉ số trong chuỗi trống. Lập chỉ mục ngoài giới hạn tạo ra khoảng trắng, vì vậy biểu thức này sẽ trả về ma trận tất cả các không gian, có cùng kích thước vớix

— ngn
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.