Мої виклики, як правило, трохи жорсткі та непривабливі. Тож тут щось легке та веселе.

Послідовність Алкуїна

Послідовність Алькайна A(n) визначається підрахунком трикутників. A(n)- кількість трикутників із цілими сторонами та периметром n. Ця послідовність називається після Алькуїна Йоркського.

Перші кілька елементів цієї послідовності, починаючи з 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. 3 дійсні трикутники ви можете побачити нижче.

У цій послідовності є досить цікавий зразок. Наприклад A(2*k) = A(2*k - 3).

Для отримання додаткової інформації див. A005044 на сайті OEIS.

Виклик

Але ваше завдання полягає у двійковому представленні цих чисел. Якщо ми перетворимо кожен номер послідовності у його двійкове представлення, помістимо їх у вектори стовпців і вирівняємо їх, це створить досить цікаву бінарну картину.

На наступному малюнку ви можете побачити двійкове представлення порядкових чисел A(0), A(1), ..., A(149). У першому стовпці ви можете побачити двійкове подання A(1), у другому стовпчику представлення A(1)тощо.

На цьому малюнку ви можете побачити якусь повторювану схему. Це навіть виглядає як фрактали, якщо ви шукаєте, наприклад, зображення із порядковими номерами 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 немає проміжків між рядками, тому я називаю правило "Або ви можете відображати зображення на екрані". (Ніде не було сказано, що це зображення повинно бути представлене як розбірливий формат зображення всередині)

EDIT: Jconsole (на відміну від JQT) використовує кодову сторінку 437 за замовчуванням, і НЕ відображає прямокутники правильно, використовуючи їх із рядка.

Mathematica, 126 122 121 89 байт

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

Це визначає неназвану функцію, яка приймає два цілі числа як параметри та відображає зображення на екрані. Він розміщує кожен квадрат як один піксель, але якщо вам це подобається, ви можете насправді збільшити масштаб.

Зараз я використовую чітку формулу, подану в статті OEIS (перша в розділі Mathematica, завдяки Девід Карраер за те, що вказав на це). Зараз це також палає швидко.

Ось відступний код з кількома коментарями:

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.

Піт - 101 60 59

Виходи a .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 у 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