Những thách thức của tôi có xu hướng hơi khó khăn và không hấp dẫn. Vì vậy, ở đây một cái gì đó dễ dàng và vui vẻ.

Trình tự của Alcuin

Trình tự của Alcuin A(n) được xác định bằng cách đếm các hình tam giác. A(n)là số lượng tam giác có cạnh nguyên và chu vi n. Trình tự này được gọi sau Alcuin of York.

Một vài yếu tố đầu tiên của chuỗi này, bắt đầu bằng n = 0:

0, 0, 0, 1, 0, 1, 1, 2, 1, 3, 2, 4, 3, 5, 4, 7, 5, 8, 7, 10, 8, ...

Chẳng hạn A(9) = 3, vì các tam giác duy nhất có các cạnh nguyên và chu vi 9là 1 - 4 - 4, 3 - 3 - 3và 2 - 3 - 4. Bạn có thể thấy 3 hình tam giác hợp lệ dưới đây.

Có một số mô hình khá thú vị trong chuỗi này. Chẳng hạn A(2*k) = A(2*k - 3).

Để biết thêm thông tin, xem A005044 trên OEIS.

Thử thách

Nhưng thách thức của bạn là về đại diện nhị phân của những con số này. Nếu chúng ta chuyển đổi từng số thứ tự thành biểu diễn nhị phân của nó, đặt chúng vào các vectơ cột và sắp xếp chúng theo thứ tự, nó sẽ tạo ra một bức tranh nhị phân khá thú vị.

Trong hình dưới đây, bạn có thể thấy biểu diễn nhị phân của các số thứ tự A(0), A(1), ..., A(149). Trong cột đầu tiên, bạn có thể thấy biểu diễn nhị phân của A(1), trong cột thứ hai biểu diễn A(1), v.v.

Bạn có thể thấy một số kiểu lặp lại trong hình này. Nó thậm chí trông giống như fractals, nếu bạn tìm ví dụ ở hình ảnh với các số thứ tự A(600), A(601), ..., A(899).

Công việc của bạn là tạo ra một hình ảnh như vậy. Hàm của bạn, tập lệnh của bạn sẽ nhận được hai số nguyên 0 <= m < nvà nó phải tạo ra hình ảnh nhị phân của chuỗi Alcuin A(m), A(m+1), A(m+2), ..., A(n-2), A(n-1). Vì vậy, đầu vào 0, 150tạo ra hình ảnh đầu tiên, đầu vào 600, 900hình ảnh thứ hai.

Bạn có thể sử dụng bất kỳ định dạng đồ họa phổ biến nào bạn muốn. Giả sử mọi định dạng có thể được chuyển đổi sang png bằng image.online-convert.com . Ngoài ra, bạn có thể hiển thị hình ảnh trên màn hình. Không có hàng trắng hàng đầu được phép!

Đây là mã golf. Vì vậy, mã ngắn nhất (tính bằng byte) sẽ thắng.

J ( 52 45 (Codepage 437))

Điều này sẽ được cho phép (tôi nghĩ)

[:|:' █'{~[:#:[:([:<.48%~*:+24+6*]*2|])(}.i.)

Đổ lục giác

(Không có gì đặc biệt, hình vuông màu đen là DB ₁₆ hoặc 219 ₁₀ trong codepage 437.)

0000: 5b 3a 7c 3a 27 20 db 27 7b 7e 5b 3a 23 3a 5b 3a   [:|:' .'{~[:#:[:
0010: 28 5b 3a 3c 2e 34 38 25 7e 2a 3a 2b 32 34 2b 36   ([:<.48%~*:+24+6
0020: 2a 5d 2a 32 7c 5d 29 28 7d 2e 69 2e 29            *]*2|])(}.i.)

Sử dụng

Điều này xuất ra như sau (Các thẻ mã làm rối nó bằng cách thêm khoảng trắng giữa các dòng):

   A=:[:|:' █'{~[:#:[:([:<.48%~*:+24+6*]*2|])(}.i.)
   0 A 100
                                                                             █ █████████████████████                                          
                                                     █ ██████████████████████ █              █ █████                          
                                     █ ██████████████ █          █ ██████████ █      █ ██████ █                   
                         █ ██████████ █      █ ██████ █    █ ████ █    █ ████ █  █ ██ █  █ ██ █  █ █  
                 █ ██████ █    █ ████ █  █ ██ █  █ ██ █  █  █  █  █  █  ██ ██ ██  ██  ██  ██  ██  ██
           █ ████ █  █ ██ █  █  █  █  ██  ██  ██  ██  ██  █  █  █  █ ██ █  █ ████ █                               
       █ ██ █  █  ██  ██  ██  █  █ ██ █                █ ██ █  █  ██  ██  ██  █  █ ██ █                                   
   █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █    
   2000 A 2100
████████████████████████████████████████████████████████████████████████████████████████████████████

████████████████████████████████████████████████████████████████████████████████████████████████████
                                                                             █ █████████████████████
                             █ ██████████████████████████████████████████████ █
     █ ██████████████████████ █                      █ ██████████████████████ █
█████ █          █ ██████████ █          █ ██████████ █          █ ██████████ █          █ █████████
 ████ █    █ ████ █    █ ████ █    █ ████ █    █ ████ █    █ ████ █    █ ████ █    █ ████ █    █ ███
█  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █
██  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █ ██ ██ █
 █ ██ ██ ██ ██ ██ █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  █  ██ ██ ██ ██ ██  █  █
  ██ ██ ██  █  █  ██ ██ ██  █  █  █  █  █  █  █  █  █  █  █  █  █  █ ██ ██ ██ █  █  █  █ ██ █  █ ██
 █ ██ █  █ ██ █  █ ██ █  █ ██ █  █  █  █  █  █  █  █  █  █  ██ ██ ██  █  █  ██  ██ ██ ██  ██  ██  ██
  ██  ██  ██  ██  ██  ██  ██  ██ ██ ██  █  █  █  █  █  █ ██ █  █ ██ █  █ ████ █    █ ██████ █
█ █                        █ ████ █  █ ██ █  █  █  █  ██  ██  ██  ██  ██  █  █  █  █ ██ █  █ ████ █
 █ ██ █                █ ██ █  █  ██  ██  ██  █  █ ██ █                █ ██ █  █  ██  ██  ██  █  █ █
██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██  ██ ██ █        █ ██ ██

Trong bảng điều khiển J tiêu chuẩn, không có khoảng cách giữa các dòng, vì vậy tôi gọi quy tắc 'Ngoài ra, bạn có thể hiển thị hình ảnh trên màn hình.' (Không nơi nào nói rằng hình ảnh này phải được thể hiện dưới dạng định dạng hình ảnh hợp lý trong nội bộ)

EDIT: Jconsole (trái ngược với JQT) sử dụng codepage 437 làm mặc định và DOES hiển thị hình chữ nhật chính xác khi sử dụng chúng từ một chuỗi.

Toán học, 126 122 121 89 byte

Image[1-Thread@IntegerDigits[l=Round[(#+3#~Mod~2)^2/48]&/@Range@##,2,⌈2~Log~Max@l⌉]]&

Điều này xác định một hàm không tên lấy hai số nguyên làm tham số và hiển thị hình ảnh trên màn hình. Nó vẽ mỗi ô vuông dưới dạng một pixel, nhưng nếu bạn thích, bạn thực sự có thể phóng to.

Bây giờ tôi đang sử dụng một công thức rõ ràng được đưa ra trong bài viết OEIS ( công thức đầu tiên trong phần Mathicala, cảm ơn David Carraher đã chỉ ra điều đó). Bây giờ cũng nhanh như vậy.

Đây là mã thụt lề với một vài bình luận:

Image[1-Thread@IntegerDigits[   (* 3. Convert each number to padded binary, transpose
                                      invert colours, and render as Image. *)
    l = Round[
      (#+3#~Mod~2)^2/48
    ] & /@ Range@##,            (* 1. Turn input into a range and get the Alcuin
                                      number for each element. *)
    2,
    ⌈2~Log~Max@l⌉               (* 2. Determine the maximum number of binary digits. *)
]] &

Đây là đầu ra cho 0, 600:

CJam ( 56 55 53 ký tự) / GolfScript (64 ký tự)

Camam

"P1"q~,>{_1&3*+_*24+48/}%_:e>2b,\2_$#f+2fbz(,@@:~~]N*

GolfScript:

"P1"\~,>{.1&3*+.*24+48/}%.$-1=2base,\{2.$?+2base}%zip(,@@{~}/]n*

Cả hai đều tạo đầu ra ở định dạng NetPBM và về cơ bản chúng là các cổng của nhau.

Mổ xẻ

CJam                 GolfScript           Explanation

"P1"                 "P1"\                NetPBM header
q~,>                 ~,>                  Create array [m .. n-1]
{_1&3*+_*24+48/}%    {.1&3*+.*24+48/}%    Map the sequence calculation
_:e>2b,\             .$-1=2base,\         Compute image height H as highest bit
                                          in largest number in sequence
2_$#f+2fb            {2.$?+2base}%        Map sequence to bits, ensuring that
                                          each gives H bits by adding 2^H
z(,@@                zip(,@@              Transpose and pull off dummy row to use
                                          its length as the "width" in the header
:~~                  {~}/                 Flatten double array and dump on stack
]N*                  ]n*                  Separate everything with whitespace

Cảm ơn Trình tối ưu hóa cho CJam 56 -> 53.

Bình - 101 60 59

Đầu ra a .pbm. Có thể có khả năng được chơi golf nhiều hơn.

Km.B/++24*dd**6%d2d48rvzQJCm+*\0-eSmlkKlddK"P1"lhJlJjbmjbdJ

Rất vô dụng vì tôi sẽ dịch sang Pyth.

Giải thích tiếp theo. Ngay bây giờ hãy nhìn vào mã Python tương đương.

Nó sử dụng thuật toán OEIS để tính toán chuỗi và sau đó nó chuyển đổi thành nhị phân, đệm các số, thực hiện xoay vòng ma trận và định dạng nó thành một pbmhình ảnh. Vì tôi không sử dụng vũ lực, nó cực kỳ nhanh.

         K=
 m          rvzQ      Map from eval input to eval input
  .B                  Binary rep
   /      48          Divided by 48
    ++                Triple sum      
     24               Of 24,
     *dd              Square of d
     **               Triple product
      6               6
      %d2             Modulo d%2
      d               Var d
J                     Set J=
 C                    Matrix rotation from columns of row to rows of columns
  m           K       Map K (This does padding)
   +                  String concat
    *                 String repeat
     \0               "0"
     -     ld         Subtract the length of the column from
      eS              The max
       mlkK           Of all the column lengths
    d                 The column
"P1"                  Print header "P1"
l                     Length of
 hJ                   First row
lJ                    Number of columns
jb                    Join by linebreaks
 m  J                 Map on to J
  jb                  Joined columns by linb
   d

Dưới đây là 600,900ví dụ:

Hãy thử nó ở đây trực tuyến .

R - 127 125

Tôi không chắc chắn nếu điều này tuân thủ các quy tắc hoàn toàn. Nó không xuất hình ảnh ra một tệp, nhưng nó tạo ra một raster và vẽ nó cho một thiết bị đầu ra.

Tôi tìm thấy công thức tương tự như Martin, nhưng ở đây .

Nó sử dụng một chức năng không tên.

require(raster);function(m,n)plot(raster(mapply(function(n)rev(as.integer(intToBits(round((n+n%%2*3)^2/48)))),m:n),0,n,0,32))

Chạy như sau

require(raster);(function(m,n)plot(raster(mapply(function(n)rev(as.integer(intToBits(round((n+n%%2*3)^2/48)))),m:n),0,n,0,32)))(0,600)

Sản xuất cốt truyện sau

Python 2 + PIL , 255 184

Phiên bản đầu tiên của tôi đã sử dụng PIL để hiển thị hình ảnh:

i,R,B=input,range,lambda x:bin((x*x+6*x*(x%2)+24)/48)[2:]
def F(k,v):i.load()[k]=v
a,b=i(),i();h=len(B(b));from PIL import Image;i=Image.new('P',(b-a,h))
[F((x-a,y),int(B(x).zfill(h)[y])) for x in R(a,b) for y in R(h)]
i.putpalette([255]*3+[0]*3)
i.show()

Phiên bản mới chỉ tạo ra hình ảnh PPM b & w trên thiết bị xuất chuẩn:

i,R,B=input,range,lambda x:bin((x*x+6*x*(x%2)+24)/48)[2:]
def p(s):print s
a,b=i(),i();h=len(B(b));p('P1 %i %i'%(b-a,h))
[p(' '.join([B(x).zfill(h)[y] for x in R(a,b)])) for y in R(h)]

JAVASCRIPT - 291

Mã số:

(function(a,b,c){c.width=b;t=c.getContext('2d');t.strokeStyle='black';for(i=a;i<=b;i++){g=(Math.floor(((i*i)+6*i*(i%2)+24)/48)>>>0).toString(2);l=g.length;for(j=0;j<l;j++){if(g[l-1-j]=='1'){t.rect(i-a,j,1,1);t.fill();}}}document.body.appendChild(c);})(0,300,document.createElement('canvas'))

Giải trình:

(function (a, b, c) {
    //setting canvas width
    c.width = b;
    //get context 2d of canvas
    t = c.getContext('2d');
    //setting storke style.
    t.strokeStyle = 'black';
    //looping from a to b
    for (i = a; i <= b; i++) {
        //calculating A(i) and converting it to a binary string
        g = (Math.floor(((i * i) + 6 * i * (i % 2) + 24) / 48) >>> 0).toString(2);
        //looping through that string
        for (j = 0; j < g.length; j++) {
            //since canvas is upside down and the first digit is actually the last digit:
            if (g[g.length - 1 - j] == '1') {
                //we create the 1 by 1 rect
                t.rect(i - a, j, 1, 1);
                //we draw the rect
                t.fill();
            }
        }
    }
    //we append everything to the body
    document.body.appendChild(c);
    //parameters are put here
})(0, 300, document.createElement('canvas'))

Kết quả:

Vâng, kết quả bị đảo lộn, nhưng đó là vì 0,0trên js canvascùng là bên trái. : 3

Bản giới thiệu:

Bản demo trên jsfiddle