Zorluklarım biraz zor ve çekici olma eğilimindedir. İşte burada kolay ve eğlenceli bir şey.

Alcuin dizisi

Alcuin'in sırası A(n) üçgenleri sayarak tanımlanır. A(n)tamsayı kenarları ve çevresi olan üçgen sayısıdır n. Bu sıraya York Alcuin denir.

Bu dizinin ilk birkaç öğesi, ile başlar n = 0:

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

Örneğin A(9) = 3, çünkü çevre tamsayı kenarları ve sadece üçgenler 9vardır 1 - 4 - 4, 3 - 3 - 3ve 2 - 3 - 4. Aşağıdaki 3 geçerli üçgeni görebilirsiniz.

Bu dizide oldukça ilginç bir desen var. Mesela A(2*k) = A(2*k - 3).

Daha fazla bilgi için, bkz. OEIS hakkında A005044 .

Meydan okuma

Ama senin zorluğun bu sayıların ikili temsili hakkında. Her sıra numarasını ikili gösterimine dönüştürürsek, sütun vektörlerine koyar ve sıralarsak, oldukça ilginç bir ikili resim oluşturur.

Aşağıdaki resimde sıra numaralarının ikili temsilini görebilirsiniz A(0), A(1), ..., A(149). İlk sütunda ikili temsili A(1), ikinci sütunda temsili A(1)vb. Görebilirsiniz .

Bu resimde bir çeşit yinelenen desen görebilirsiniz. Örneğin sıra numaralarına sahip görüntüye bakarsanız, fraktallara benziyor A(600), A(601), ..., A(899).

İşiniz böyle bir görüntü oluşturmaktır. Fonksiyonunuz, betiğiniz iki tamsayı alacaktır 0 <= m < nve Alcuin'in dizisinin ikili görüntüsünü oluşturmak zorundadır A(m), A(m+1), A(m+2), ..., A(n-2), A(n-1). Böylece giriş 0, 150ilk resmi, giriş 600, 900ikinci resmi oluşturur.

İstediğiniz popüler grafik formatlarını kullanabilirsiniz. Diyelim ki image.online-convert.com kullanılarak png'ye dönüştürülebilen her format . Alternatif olarak, görüntüyü ekranda görüntüleyebilirsiniz. Önde gelen beyaz sıralara izin verilmez!

Bu kod golfü. Böylece en kısa kod (bayt cinsinden) kazanır.

J ( 52 45 (Kod sayfası 437))

Buna izin verilecek (sanırım)

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

Onaltılık dökümü

(Gerçekten özel bir şey yok, siyah kare kod sayfası 437'de DB ₁₆ veya 219 _10'dur .)

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

kullanım

Bu çıktı (Kod etiketleri satırlar arasına boşluk ekleyerek karışır):

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

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

Standart J konsolunda çizgiler arasında boşluk yoktur, bu yüzden 'Alternatif olarak görüntüyü ekranda görüntüleyebilirsiniz' kuralını çağırıyorum. (Hiçbir yerde bu görüntünün dahili olarak mantıklı bir görüntü formatı olarak temsil edilmesi gerektiği söylenmedi)

DÜZENLEME: Jconsole (JQT yerine) varsayılan olarak 437 kod sayfasını kullanır ve dikdörtgenleri bir dizeden kullanırken doğru şekilde DOĞRULAR.

Mathematica 126 122 121 89 bayt

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

Bu, iki tamsayıyı parametre olarak alan ve görüntüyü ekranda görüntüleyen adsız bir işlevi tanımlar. Her kareyi tek bir piksel olarak çizer, ancak isterseniz aslında yakınlaştırabilirsiniz.

Şimdi OEIS makalesinde (Mathematica bölümünde birincisi, David Carraher bunu işaret için teşekkürler) verilen açık bir formül kullanıyorum . Şimdi de çok hızlı.

İşte birkaç yorum içeren girintili kod:

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

İşte çıktı 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*

Her ikisi de NetPBM formatında çıktı üretir ve esasen birbirlerinin bağlantı noktalarıdır.

teşrih

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

CJam 56 -> 53 için Optimizer'a teşekkürler .

Pyth - 101 60 59

Çıktılar a .pbm. Muhtemelen daha fazla golf olabilir.

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

Oldukça dinsiz çünkü Pyth'e tercüme edeceğim.

Bir sonraki açıklama gelecek. Şimdi eşdeğer Python koduna bakın.

Diziyi hesaplamak için OEIS algoritmasını kullanır ve sonra ikiliye dönüştürür, sayıları doldurur, bir matris dönüşü yapar ve bir pbmgörüntüye biçimlendirir . Kaba kuvvet kullanmadığım için inanılmaz hızlı.

         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

İşte 600,900örnek:

Burada çevrimiçi deneyin .

R - 127 125

Bunun kurallara tamamen uyup uymadığından emin değilim. Bir görüntüyü bir dosyaya vermez, ancak bir raster oluşturur ve bir çıktı aygıtına çizer.

Martin ile aynı formülü buldum, ama burada .

Adsız bir işlev kullanır.

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

Aşağıdaki gibi çalıştırı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)))(0,600)

Aşağıdaki grafiği üretir

Python 2 + PIL , 255 184

İlk sürümüm bir resmi göstermek için PIL kullandı:

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

Yeni sürüm sadece stdout'ta siyah beyaz PPM görüntüsü üretir:

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

Kod:

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

Açıklama:

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

Sonuç:

Evet sonucu ters olmakla çünkü en 0,0bir üzerinde js canvassol üst olduğunu. : 3

Demo:

Jsfiddle hakkında demo