Tantangan saya cenderung sedikit keras dan tidak menarik. Jadi di sini sesuatu yang mudah dan menyenangkan.

Urutan Alcuin

Urutan Alcuin A(n) didefinisikan dengan menghitung segitiga. A(n)adalah jumlah segitiga dengan sisi bilangan bulat dan keliling n. Urutan ini disebut setelah Alcuin of York.

Beberapa elemen pertama dari urutan ini, dimulai dengan n = 0adalah:

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

Misalnya A(9) = 3, karena satu-satunya segitiga dengan sisi bilangan bulat dan perimeter 9adalah 1 - 4 - 4, 3 - 3 - 3dan 2 - 3 - 4. Anda dapat melihat 3 segitiga yang valid di bawah.

Ada beberapa pola yang cukup menarik dalam urutan ini. Misalnya A(2*k) = A(2*k - 3).

Untuk informasi lebih lanjut, lihat A005044 tentang OEIS.

Tantangan

Tetapi tantangan Anda adalah tentang representasi biner dari angka-angka ini. Jika kita mengonversi setiap nomor urut ke representasi binernya, memasukkannya ke dalam vektor kolom dan membariskannya, itu menciptakan gambar biner yang cukup menarik.

Dalam gambar berikut ini Anda dapat melihat representasi biner dari nomor urut A(0), A(1), ..., A(149). Di kolom pertama Anda bisa melihat representasi biner A(1), di kolom kedua representasi A(1), dan seterusnya.

Anda dapat melihat semacam pola berulang dalam gambar ini. Bahkan terlihat seperti fraktal, jika Anda melihat misalnya pada gambar dengan nomor urut A(600), A(601), ..., A(899).

Tugas Anda adalah menghasilkan gambar seperti itu. Fungsi Anda, skrip Anda akan menerima dua bilangan bulat 0 <= m < n, dan harus menghasilkan gambar biner dari urutan Alcuin A(m), A(m+1), A(m+2), ..., A(n-2), A(n-1). Jadi input 0, 150menghasilkan gambar pertama, input 600, 900gambar kedua.

Anda dapat menggunakan format grafis populer yang Anda inginkan. Katakanlah setiap format yang dapat dikonversi ke png menggunakan image.online-convert.com . Atau, Anda dapat menampilkan gambar di layar. Tidak ada baris putih terdepan yang diizinkan!

Ini adalah kode-golf. Jadi kode terpendek (dalam byte) menang.

J ( 52 45 (Codepage 437))

Ini akan diizinkan (saya pikir)

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

Hex dump

(Tidak ada yang istimewa sebenarnya, kotak hitam adalah DB ₁₆ atau 219 ₁₀ dalam 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.)

Pemakaian

Ini menghasilkan sebagai berikut (Tag kode mengacaukannya dengan menambahkan spasi di antara baris):

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

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

Di konsol J standar, tidak ada spasi di antara baris, jadi saya sebut aturan 'Atau, Anda dapat menampilkan gambar di layar.' (Tidak ada yang mengatakan bahwa gambar ini harus direpresentasikan sebagai format gambar yang masuk akal secara internal)

EDIT: Jconsole (sebagai kebalikan dari JQT) menggunakan codepage 437 sebagai default, dan DOES membuat persegi panjang dengan benar saat menggunakannya dari string.

Mathematica, 126 122 121 89 byte

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

Ini mendefinisikan fungsi yang tidak disebutkan namanya mengambil dua bilangan bulat sebagai parameter dan menampilkan gambar di layar. Memplot setiap kotak sebagai satu piksel, tetapi jika Anda suka, Anda sebenarnya dapat memperbesar.

Saya sekarang menggunakan formula eksplisit yang diberikan dalam artikel OEIS (yang pertama di bagian Mathematica, terima kasih kepada David Carraher karena menunjukkannya). Ini juga sangat cepat sekarang.

Ini kode indentasi dengan beberapa komentar:

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. *)
]] &

Ini adalah output untuk 0, 600:

CJam ( 56 55 53 karakter) / GolfScript (64 karakter)

CJam:

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

GolfScript:

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

Keduanya menghasilkan output dalam format NetPBM, dan mereka pada dasarnya adalah port satu sama lain.

Pembedahan

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

Terima kasih kepada Pengoptimal untuk CJam 56 -> 53.

Pyth - 101 60 59

Output a .pbm. Kemungkinan bisa bermain golf lebih banyak.

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

Sangat ungolfed karena saya akan menerjemahkan ke Pyth.

Penjelasan selanjutnya datang. Sekarang lihat kode Python yang setara.

Ia menggunakan algoritma OEIS untuk menghitung urutan dan kemudian mengubahnya menjadi biner, mengisi angka-angka, melakukan rotasi matriks, dan memformatnya menjadi pbmgambar. Karena saya tidak menggunakan kekerasan, ini sangat cepat.

         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

Berikut ini 600,900contohnya:

Coba di sini online .

R - 127 125

Saya tidak yakin apakah ini sepenuhnya mematuhi aturan. Itu tidak menampilkan gambar ke file, tetapi itu membuat raster dan plot ke perangkat output.

Saya menemukan formula yang sama dengan Martin, tetapi di sini .

Ini menggunakan fungsi yang tidak disebutkan namanya.

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))

Jalankan sebagai berikut

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)

Menghasilkan plot berikut

Python 2 + PIL , 255 184

Versi pertama saya menggunakan PIL untuk menampilkan gambar:

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()

Versi baru hanya menghasilkan gambar PPM b & w di stdout:

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

Kode:

(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'))

Penjelasan:

(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'))

Hasil:

Ya hasilnya terbalik, tapi itu karena 0,0di js canvaskiri atas. : 3

Demo:

Demo di jsfiddle