ความท้าทายของฉันนั้นค่อนข้างยากและไม่ดึงดูดเลย ดังนั้นนี่คือสิ่งที่ง่ายและสนุก

ลำดับของ Alcuin

ลำดับของ Alcuin A(n)ถูกกำหนดโดยการนับสามเหลี่ยม คือจำนวนของรูปสามเหลี่ยมที่มีด้านจำนวนเต็มและปริมณฑลA(n) nลำดับนี้เรียกว่าหลังจาก Alcuin of York

องค์ประกอบแรก ๆ ของลำดับนี้เริ่มต้นด้วยn = 0:

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

ยกตัวอย่างเช่นA(9) = 3เพราะสามเหลี่ยมเฉพาะกับด้านจำนวนเต็มและปริมณฑล9มี1 - 4 - 4, และ3 - 3 - 3 2 - 3 - 4คุณสามารถดูสามเหลี่ยมที่ถูกต้องทั้งสามด้านล่าง

มีรูปแบบที่ค่อนข้างน่าสนใจในลำดับนี้ A(2*k) = A(2*k - 3)เช่น

สำหรับข้อมูลเพิ่มเติมดูA005044ใน OEIS

ท้าทาย

แต่ความท้าทายของคุณเกี่ยวกับการแทนเลขฐานสองของตัวเลขเหล่านี้ ถ้าเราแปลงเลขลำดับเป็นเลขฐานสองให้วางไว้ในเวกเตอร์คอลัมน์แล้วเรียงแถวมันจะสร้างภาพไบนารีที่น่าสนใจทีเดียว

ในภาพต่อไปนี้คุณสามารถดูแทน binary A(0), A(1), ..., A(149)ของตัวเลขลำดับ ในคอลัมน์แรกคุณสามารถดูการแทนค่าไบนารีของA(1)ในคอลัมน์ที่สองการแทนค่าA(1)และอื่น ๆ

คุณสามารถเห็นรูปแบบการทำซ้ำบางอย่างในภาพนี้ มันยังมีลักษณะ kinda เช่น fractals, A(600), A(601), ..., A(899)ถ้าคุณมองหาตัวอย่างในภาพที่มีหมายเลขลำดับ

งานของคุณคือการสร้างภาพดังกล่าว ฟังก์ชั่นของคุณสคริปต์ของคุณจะได้รับสองจำนวนเต็มและจะมีการสร้างภาพไบนารีของลำดับ0 <= m < n Alcuin ของ A(m), A(m+1), A(m+2), ..., A(n-2), A(n-1)ดังนั้นอินพุต0, 150จะสร้างภาพแรกคืออินพุท600, 900ของภาพที่สอง

คุณสามารถใช้รูปแบบกราฟิกยอดนิยมที่คุณต้องการ สมมติว่ารูปแบบที่สามารถแปลงเป็น png ใช้ทุกimage.online-convert.com หรือคุณอาจแสดงภาพบนหน้าจอ ไม่อนุญาตให้นำแถวสีขาวมาด้วย!

นี่คือรหัสกอล์ฟ ดังนั้นรหัสที่สั้นที่สุด (เป็นไบต์) จึงชนะ

J ( 52 45 (เพจรหัส 437))

สิ่งนี้จะได้รับอนุญาต (ฉันคิดว่า)

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

ฐานสิบหก

(ไม่มีอะไรพิเศษจริง ๆ จัตุรัสสีดำคือ DB ₁₆หรือ 219 ₁₀ในเพจรหัส 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.)

การใช้

ผลลัพธ์นี้เป็นดังนี้ (แท็กรหัสทำให้ยุ่งเหยิงโดยการเพิ่มช่องว่างระหว่างบรรทัด):

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

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

ในคอนโซล J มาตรฐานไม่มีช่องว่างระหว่างบรรทัดดังนั้นฉันจึงเรียกกฎ 'อีกวิธีหนึ่งคุณอาจแสดงภาพบนหน้าจอ' (มันไม่มีที่ไหนบอกว่าภาพนี้จะต้องถูกแสดงเป็นรูปแบบภาพที่เหมาะสมภายใน)

แก้ไข: Jconsole (ตรงข้ามกับ JQT) ใช้ codepage 437 เป็นค่าเริ่มต้นและ DOES เรนเดอร์สี่เหลี่ยมอย่างถูกต้องเมื่อใช้พวกมันจากสตริง

Mathematica, 126 122 121 89 ไบต์

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

ฟังก์ชันนี้กำหนดฟังก์ชันที่ไม่มีชื่อโดยใช้จำนวนเต็มสองจำนวนเป็นพารามิเตอร์และแสดงภาพบนหน้าจอ มันแปลงแต่ละตารางเป็นพิกเซลเดียว แต่ถ้าคุณชอบคุณสามารถซูมเข้าได้

ตอนนี้ฉันใช้สูตรที่ชัดแจ้งในบทความ OEIS ( สูตรแรกในส่วน Mathematica ต้องขอบคุณ David Carraher ที่ชี้ให้เห็นว่า) ตอนนี้มันเร็วอย่างเห็นได้ชัด

นี่คือรหัสเยื้องกับความคิดเห็นไม่กี่:

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

นี่คือผลลัพธ์สำหรับ0, 600:

CJam ( 56 55 53 ตัวอักษร) / GolfScript (64 ตัวอักษร)

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*

ทั้งสร้างผลผลิตในรูปแบบ NetPBM และเป็นพอร์ตหลักของกันและกัน

การผ่า

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

Pyth - 101 60 59

ขาออก .pbmมีโอกาสที่จะเล่นกอล์ฟได้มากขึ้น

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

โชคดีมากเพราะฉันจะแปลเป็น Pyth

คำอธิบายมาถัดไป ตอนนี้ดูรหัส Python ที่เทียบเท่ากัน

มันใช้อัลกอริทึม OEIS เพื่อคำนวณลำดับและจากนั้นแปลงเป็นไบนารี่, วางตัวเลข, ทำการหมุนเมทริกซ์, และจัดรูปแบบมันเป็นpbmภาพ เนื่องจากฉันไม่ได้ใช้กำลังดุร้ายมันเร็วอย่างไม่น่าเชื่อ

         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

นี่คือ600,900ตัวอย่าง:

ลองมันนี่เกมออนไลน์

R - 127 125

ฉันไม่แน่ใจว่าสิ่งนี้สอดคล้องกับกฎทั้งหมดหรือไม่ มันไม่ได้ส่งออกภาพไปยังไฟล์ แต่มันจะสร้างแรสเตอร์และพล็อตไปยังอุปกรณ์ส่งออก

ผมพบว่าสูตรเดียวกับมาร์ติน แต่ที่นี่

มันใช้ฟังก์ชั่นที่ไม่มีชื่อ

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

เรียกใช้ดังนี้

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)

สร้างพล็อตต่อไปนี้

Python 2 + PIL , 255 184

รุ่นแรกของฉันใช้ PIL เพื่อแสดงภาพ:

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

รุ่นใหม่เพียงสร้างภาพ PPM b & w ใน 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

รหัส:

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

คำอธิบาย:

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

ผลลัพธ์:

ใช่ผลที่ได้คือคว่ำ แต่นั่นเป็นเพราะ0,0ในjs canvasอยู่ด้านบนซ้าย : 3

การสาธิต:

สาธิตบน jsfiddle