_{Це дотично пов'язане з моїм прагненням винайти езотеричну мову програмування .}

Таблиця двійкових чисел 0 .. 15 може бути використана для реалізації Універсальної бінарної функції за допомогою операцій індексації. Враховуючи два 1-бітні входи X і Y, усі 16 можливих функцій можуть бути закодовані в 4-бітовий опкод.

X Y  F|0 1 2 3 4 5 6 7 8 9 A B C D E F
- -    - - - - - - - - - - - - - - - -  
0 0    0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 1    0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
1 0    0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
1 1    0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
       -     -   - -   -   -   -   - -
       0    ~X  ~Y ^   &   Y   X   | 1
      ZERO    NOT-Y   AND         OR
          NOT-X   XOR              ONE

Отже цей набір з 16 функцій можна застосувати до двійкових входів як функції

U (f, x, y): (f >> ((x << 1) | y)) & 1 ,

або

U (f, x, y): (f / 2 ^ (x × 2 + y))% 2 ,

або з індексуванням або матричним розподілом.

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

Мета:

Створити цей точний текст:

0101010101010101
0011001100110011
0000111100001111
0000000011111111

Це воно! Виграє найкоротший код.

J, 10 (13?) Символів

|.|:#:i.16

Список номерів:

   i.16
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15`

до двійкового:

   #:i.16
0 0 0 0
0 0 0 1
0 0 1 0
0 0 1 1
0 1 0 0
0 1 0 1
0 1 1 0
0 1 1 1
1 0 0 0
1 0 0 1
1 0 1 0
1 0 1 1
1 1 0 0
1 1 0 1
1 1 1 0
1 1 1 1

Перенести:

   |:#:i.16
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

Реверс:

   |.|:#:i.16
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1

Чи потрібно видаляти пробіли? Дивлячись на інший J відповідь здається нам , тому ми повинні додати 3 -х символів та запозичувати 1":від відповіді Яну .

Пітон 2, 40

for n in 1,2,4,8:print 8/n*('0'*n+'1'*n)

APL (14)

Припустимо ⎕IO=0(це налаштування):

⎕D[⊖(4⍴2)⊤⍳16]

Пояснення:

• ⍳16: числа [0,16)
• (4⍴2)⊤: кодуйте кожне число в базі 2 за допомогою 4 цифр
• ⊖: горизонтальний реверс (таким чином, MSB закінчується вгорі)
• ⎕D[... ]: виберіть ці значення, з ⎕Dяких є рядок 0123456789. (Числова матриця відображається з пробілами між значеннями, символьна матриця - ні. Отже, це перетворює кожен числовий біт в одну з символів '0' '1').

Желе , 42 7 байт (неконкуренто)

⁴ḶBUz0Y

Спробуйте в Інтернеті!

Дякуємо Деннісу за допомогу. Ось перше повідомлення, ось останнє (також відбулися інші дискусії). З його допомогою я, мабуть, (майже) зафіксував партитуру.

/// , 51 байт

Спробуйте в Інтернеті

/a/0101/aaaa
/b/0011/bbbb
/z/0000//o/1111/zozo
zzoo

GolfScript ( 18 17 15 символів)

(З подякою Говарда)

16,zip{','-~n}%

Я не розумію, чому 10-знакова

16,zip{n}/

не працює; Я підозрюю, що помилка в стандартному інтерпретаторі призводить до непідтримуваних типів у стеці.

Альтернатива на 18 символів, яку я повністю розумію:

4,{2\?.2,*$8@/*n}%

Більш математичний підхід трохи довший, на 28 символів:

4,{2.@??)2.4??.@/+2base(;n}/

Багато з цього - для базової конверсії та нульового прокладки. Без цього воно падає до 19 символів,

4,{2.@??)2.4??\/n}/

з виходом

21845
13107
3855
255

CJam - 16

4,{G,f{\m>2%}N}/

Еквівалентний код Java (як пояснення):

public class Lookup {
    public static void main(final String... args) {
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 16; ++j) {
                System.out.print((j >> i) % 2);
            }
            System.out.println();
        }
    }
}

Javascript (ECMA6), 67

s=(k,n)=>n-.5?s((k<<n/2)^k,n/2)+"0".repeat(n)+k.toString(2)+"\n":"" 

Щоб скористатися цим, зателефонуйте

s(255,8)

Бітшіфт!
А також XOR і трохи рекурсії.

Перше, що слід помітити, це те, що якщо ми візьмемо будь-який рядок, і ви змістить його (# безперервного 0) / 2 вліво, ми отримаємо хороший XOR, щоб отримати наступний рядок.

Наприклад,

0000000011111111 //line 4
0000111111110000 //shifted 4 to the left

XOR ці побіжно дають нам

0000111100001111 //XOR'ed. This is line 3!

що є наступним рядком вгору (рядок 3).
Застосовуючи той самий процес для рядка 3, зсуваємо 2 вліво і отримуємо ...

0000111100001111
0011110000111100

XOR'ed дає

0011001100110011

що є рядком 2.
Зауважте, що сума, яку ми зміщуємо вдвічі, наполовину.
Тепер ми просто називаємо цю функцію рекурсивно, з 2 аргументами. Ціле значення цього рядка і N, на скільки нам потрібно зрушити. Коли ми повторюємось, просто передайте зміщене значення XOR'ed і n / 2.

"0".repeat(n)

полягає в прокладці 0 на початку кожного рядка, оскільки ToString виводить 0 з початку.

J, 21 символ

1":<.2|(2^i.4)%~/i.16

• i.16 - це список 0..15
• 2^i.4 список (1,2,4,8)
• %~/ створює таблицю поділів, де лівий аргумент утворює рядки, але є правим аргументом поділу
• 2| обчислює залишок після ділення [кожної комірки] на дві
• <. поверхи, які мають значення 0 або 1
• 1": формати таблиці з одним символом на комірку

GolfScript, 19 символів

Ще один підхід GolfScript

4,{2\?{&!!}+16,%n}%

Рубін (44)

Нудно і довго: Просто друкуємо 0-підкладені двійкові представлення чисел.

[21845,13107,3855,255].map{|i|puts"%016b"%i}

Постскрипт 108 177 126 77 74 70

[43690 52428 61680 65280]
{16{dup 2 mod =only 2 idiv}repeat<>=}forall

Перевернуті значення для більш простого модулювання виключення методу.

151 131 119

Застосування більш APL- підходу. редагування: замінено нарізання рядків та масив масивів на індексацію та for-петлі.

[[0 1 15{}for]{16 add 2 5 string cvrs}forall]4 
-1 1{0 1 15{2 index exch get 1 index 1
getinterval =only}for pop<>=}for

Відступ:

[[0 1 15{}for]{16 add 2 5 string cvrs}forall]
4 -1 1{ % [] i
    0 1 15{ % [] i j
        2 index exch get % [] i [](j)
        1 index 1  % [] i [](j) i 
        getinterval  % [] i [](j)<i>
        =only  % [] i
    }for 
    pop<>= % []
}for

Повторне виконання функцій, що використовуються у виграшному J відповіді, призводить до цього (з великим кодом підтримки ).

-1 16 i + #: |: |.{{==only}forall()=}forall

iось 1-заснований вектор, описаний в Елементарних функціях Іверсона , звідси і -1 ... +продукувати 0 .. 15.

Perl (36 + 1)

+1 say, як завжди. дубль 0- це не помилка :)

map say((00x$_,1x$_)x(8/$_)),1,2,4,8

JavaScript (ECMA6), 108

Спробуйте інший підхід тут. Навіть незважаючи на те, що було рекомендовано використовувати бінарні оператори, я дозволив собі подати це рішення, оскільки виклик також є складним числом, і я думав - як я можу зменшити кількість коду, що представляє ці значення ...? Основи .

['gut','a43','2z3','73'].forEach(n=>{a=parseInt(n,36).toString(2);
alert(('00000000'+a).substr(a.length-8))})

(Перерва лінії для зручності).

Прикро, що мені довелося возитися з прокладкою з провідними нулями, але суть цього коду є просто відображенням цільового бінарного результату в Базі 36, які є саме тими gut, a43, 2z3, 73значеннями.

Примітка. Я розумію, що це не буде десь поруч з переможною відповіддю, а лише заради ідеї ...

Розкидає , 44 байти

 aaaa
bbbb
zozo
zzoo o1111 z0000 b0011 a0101

Відповідь Седріка перенесена на Spreads.

MATL ( неконкурентоспроможний ), 8 байт

16:qYB!P

Спробуйте в Інтернеті!

Пояснення

16:    % Generate range [1 2 ... 16]
q      % Subtract 1, element-wise
YB     % Convert to binary. Gives a 16×4 char array. Each original number is a row
!      % Transpose
P      % Reverse vertically. Implicitly display

CJam ( неконкурентоспроможний ), 10 9 байт

Дякуємо @Dennis за 1 байт!

Y4m*zW%N*

Спробуйте в Інтернеті!

Пояснення

Y     e# Push 2
4     e# Push 4
m*    e# Cartesian power of 2 (interpreted as [0 1]) with exponent 4
z     e# Zip
W%    e# Reverse the order of rows
N*    e# Join with newlines. Implicitly display

JavaScript (ES6), 58 52 байти

Будує рядок рекурсивно.

f=(n=64)=>n--?f(n)+(!n|n&15?'':`
`)+(n>>(n>>4)&1):''

Як це працює

Ця рекурсія ґрунтується на тому, що схема складається з вертикального бінарного зображення представлених нібелів 0x0 до 0xF:

  0101010101010101 bit #0 <- Y = 0
  0011001100110011 bit #1
  0000111100001111 bit #2
  0000000011111111 bit #3 <- Y = 3
  ----------------
  0123456789ABCDEF
  ^              ^
X = 0          X = 15

Таким чином, кожне положення (X, Y) в цій схемі може бути виражений в вигляді Y-го біта X: X & (1 << Y). Ми також можемо ізолювати цей біт з: (X >> Y) & 1. Замість того , щоб відстежувати X і Y, ми ітерація по одній змінної в nдіапазоні від 0 до 63. Таким чином, формула набуває такого вигляду : (n >> (n >> 4)) & 1. Насправді простіше відібрати від 63 до 0, тому рядок побудований у зворотному порядку. Іншими словами, символ n-1 додається зліва від символу n .

Як зауваження, рекурсія тут не приносить нічого, крім коротшого коду.

Без рядкових рядків код становить 35 байт:

f=(n=64)=>n--?f(n)+(n>>(n>>4)&1):''

Нам потрібно ще 17 байт, щоб вставити рядкові рядки. Це може бути скорочено до 14 байт, якщо прийнятний провід рядків буде прийнятним.

Демо

f=(n=64)=>n--?f(n)+(!n|n&15?'':`
`)+(n>>(n>>4)&1):''

console.log(f());

Bash + coreutils, 65 байт

Не найкоротший, але і не найдовший:

for i in {1,2,4,8};{ eval echo \$\[\({0..15}\&$i\)/$i];}|tr -d \ 

(Останній символ - пробіл)

Спробуйте в Інтернеті .

NARS2000 APL, 22

"01"[⊖1+(4⍴2)⊤(⍳16)-1]

Отриманий з відповіді APL marinus, яка, здається, не працює на NARS2000.

Генерувати вектор

      ⍳16
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

Перехід до нуля

      (⍳16)-1
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Створити форму для кодування

      (4⍴2)
2 2 2 2

Кодування

      (4⍴2)⊤(⍳16)-1
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1

Налаштуйте для індексації на основі 1

      1+(4⍴2)⊤(⍳16)-1
1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2
1 1 1 1 2 2 2 2 1 1 1 1 2 2 2 2
1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2
1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2

Зворотна первинна вісь

      ⊖1+(4⍴2)⊤(⍳16)-1
1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2
1 1 2 2 1 1 2 2 1 1 2 2 1 1 2 2
1 1 1 1 2 2 2 2 1 1 1 1 2 2 2 2
1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2

Покажчик

      "01"[⊖1+(4⍴2)⊤(⍳16)-1]
0101010101010101
0011001100110011
0000111100001111
0000000011111111

C, 73 символів

i;main(){for(;i<64;)i&15||puts(""),putchar(48|1&~0xFF0F0F33335555>>i++);}

Це лише загальне рішення для виведення 64 біт у чотирьох 16-бітових блоках; вам просто потрібно змінити номер0xFF0F0F33335555 щоб вивести іншу послідовність бітів.

спрощений і невольфний:

int main() {
    int i;
    for(i = 0; i < 64; i++) {
        if(i % 16 == 0) {
            puts("");
        }
        int bit = ~0xFF0F0F33335555 >> i;
        bit &= 1;
        putchar('0' + bit);
    }
}

Хаскелл, 73

Yikes, 73 символи! Я не можу для любові до бога отримати це все менше.

r=replicate
f n=r(div 8n)("01">>=r n)>>=id
main=mapM(putStrLn.f)[1,2,4,8]

Справжня сумна частина цього полягає в тому, що якби ви повторювали вихід за допомогою bash, вам знадобиться лише 74 символи.

JavaScript (ES5) 69

for(x="";4>x;x++){z="";for(n=0;16>n;)z+=1-!(n++&1<<x);console.log(z)}

інка2 ,33 27 24

4 16#(,`2|(~16)%.2^~4){D

Це ґрунтується на відповіді Яна Дворака . inca2 може виконати це станом на вчорашні виправлення. Технічно недійсна, оскільки мова була винайдена після запитання, але винахід мови було частиною моєї мети в питанні питання. Тож ось дещо окупності в подяку до інших відповідей. :)

Пояснення:

4 16#(,`2|(~16)%.2^~4){D
          (~16)               integers 0 .. 15 
                 2^~4         first 4 powers of 2: 1 2 4 8
          (~16)%.2^~4         division table
        2|                    mod 2 (and floor)
       `                      transpose
      ,                       ravel
     (               ){D      map to chars '0'..'9'
4 16#                         reshape to 4x16

Деякі дужки повинні бути непотрібними, але, мабуть, є деякі проблеми з моїм тлумаченням граматики. І "ravel => map => переформатувати" насправді незграбно: карта повинна бути розумнішою. Редагувати: виправлення помилок дозволяють видалити паролі.

Факторинг базового перетворення на окрему функцію N:x|y%.x^~1+[]/x.yдає це19 16 char версія.

4 16#(,`2N~16){D

І хоча я тут все одно обманюю, я пішов вперед і зробив це вбудованою функцією. Але, незважаючи на те, що це ніладієва функція (не вимагає аргументу), немає підтримки ніладичних функцій, і вона повинна поставлятися з фіктивним аргументом.

інка2, 2

U0

Піф 24/26

Найкоротший метод був GRC в відповідь переведений на Pyth , який я відчував був дешевий , тому я зробив свій власний метод:

Шахта: 26 символів

 mpbjk*/8dS*d[0 1)[1 2 4 8

grc: 24 символи

Fd[1 2 4 8)*/8d+*\0d*\1d

C ++ 130

Перетворює шістнадцятковий у двійковий

#define B std::bitset<16>
#define C(x) cout<<x<<endl;
void main(){
B a(0xFF),b(0xF0F),c(0x3333),d(0x5555);
C(d)C(c)C(b)C(a)
}

Haskell (Lambdabot), 47 байт

unlines$reverse$transpose$replicateM 4['1','0']

Якийсь хитрий, оскільки він використовує транспонирование з Data.List і реплікаціюM з Control.Monad, однак обидва завантажуються за замовчуванням від Lambdabot.

Крім того, я впевнений, що є місце для вдосконалення, просто хотів поділитися ідеєю

Джулія (39 байт)

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

hcat(map(x->collect(bin(x,4)),0:15)...)

Повертається

[0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 
 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 
 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1]  

Пояснення:

• bin(x,4) - Перетворити int в двійкове ціле число з прокладкою до 4 символів.
• collect(_) - Розділити рядок на масив char.
• map(x->_,0:15) - Зробіть це для перших 16 цифр у діапазоні.
• hcat(_...) - Плеска та горизонтальне з'єднання в матрицю.

С 83 77 76 74 71

x;f(n){for(;x<4;x++,puts(""))for(n=0;n<16;)putchar(49-!(n++&(1<<x)));}

Досить прямо.

x;
f(n){
    for(;x<4;x++,puts(""))
        for(n=0;n<16;)
            putchar(49-!(n++&(1<<x)));
}

R, 53 41 байт

Переклад відповіді python @ grc. Поголив 12 байт від оригінального перекладу за допомогою використання rep()s eachта lengthаргументів (і часткового збігу аргументів), а також запам'ятовуючи 0:1це, що еквівалентно c(0,1).

for(n in 2^(0:3))print(rep(0:1,e=n,l=16))

for(n in 2^(0:3))print(rep(c(rep(0,n),rep(1,n)),8/n))

Ви також можете спробувати переклад J-відповіді @ Gareth приблизно так (34 байти):

t(e1071::bincombinations(4))[4:1,]

Однак він використовує функцію, яка не є частиною базової R, і виводить матрицю, яку важко відформатувати в точний друкований текст, як у специфікації.