_{นี้จะเกี่ยวข้องกับการสัมผัสในการแสวงหาของฉันที่จะคิดค้นการเขียนโปรแกรมภาษาลึกลับ}

ตารางของเลขฐานสอง 0 .. 15 สามารถนำมาใช้ในการใช้งานฟังก์ชั่นยูนิเวอร์แซลไบนารีโดยใช้การจัดทำดัชนี กำหนดอินพุต 1 บิตสองตัว X และ Y ฟังก์ชันที่เป็นไปได้ทั้ง 16 ฟังก์ชันสามารถเข้ารหัสใน opcode 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":จากคำตอบของแจน

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

Jelly , 42 7 ไบต์ (ไม่ใช่การแข่งขัน)

⁴ḶBUz0Y

ลองออนไลน์!

ขอบคุณเดนนิสสำหรับความช่วยเหลือของเขา นี่คือข้อความแรกที่นี่เป็นครั้งสุดท้าย (การอภิปรายอื่น ๆ ยังเกิดขึ้น) ด้วยความช่วยเหลือของเขาฉันเห็นได้ชัด (เกือบ) สแควร์รูทคะแนน

/// , 51 ไบต์

ลองออนไลน์

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

GolfScript ( 18 17 15 ตัวอักษร)

(ขอบคุณฮาวเวิร์ด)

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

ฉันไม่เข้าใจว่าทำไม 10-char

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)

Bitshift!
และยังมีแฮคเกอร์และการเรียกซ้ำอีกเล็กน้อย

สิ่งแรกที่ควรสังเกตคือถ้าเรารับสายใด ๆ และคุณเลื่อนไปทางซ้าย (# ของ 0 ต่อเนื่อง) / 2 ทางซ้ายเราจะได้ XOR ที่ดีเพื่อให้ได้บรรทัดถัดไป

ตัวอย่างเช่น,

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

แฮคเกอร์ให้เราหน่อย

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

ซึ่งเป็นบรรทัดถัดไปขึ้น (บรรทัดที่ 3)
ใช้กระบวนการเดียวกันกับบรรทัดที่ 3 เลื่อนไปทางซ้าย 2 และเราจะได้ ...

0000111100001111
0011110000111100

XOR'ed ให้

0011001100110011

ซึ่งก็คือบรรทัดที่ 2
โปรดสังเกตว่าจำนวนเงินที่เราเลื่อนครึ่งหนึ่งในแต่ละครั้ง
ตอนนี้เราเรียกฟังก์ชันนี้ซ้ำโดยมี 2 อาร์กิวเมนต์ ค่าจำนวนเต็มของบรรทัดนี้และ N ซึ่งเป็นจำนวนที่เราต้องการเปลี่ยน เมื่อเราเรียกซ้ำอีกครั้งจะผ่านค่า XOR ที่เปลี่ยนแล้วและ n / 2

"0".repeat(n)

คือการ pad 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

กลับรายการค่าสำหรับง่ายmod-ปิดวิธี

151 131 119

การใช้มากขึ้นAPLวิธี -ish แก้ไข:แทนที่การสับสตริงและการซิปแถวด้วยการทำดัชนีและ for-loops

[[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 ตามที่อธิบายไว้ในเวกเตอร์ Iverson ของฟังก์ชั่นประถมศึกษาจึงจะผลิต-1 ... +0 .. 15

Perl (36 + 1)

+1 สำหรับsayตามปกติ double 0ไม่ใช่ typo :)

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

JavaScript (ECMA6), 108

ลองใช้แนวทางอื่นที่นี่ แม้ว่าจะได้รับการสนับสนุนให้ใช้ตัวดำเนินการแบบไบนารี แต่ฉันอนุญาตให้ฉันส่งโซลูชันนี้เนื่องจากความท้าทายคือkolmogorov- ความซับซ้อนและฉันคิดว่า - ฉันจะลดจำนวนรหัสที่แสดงค่าเหล่านั้นได้อย่างไร ... ? ฐาน

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

(ตัวแบ่งบรรทัดเพื่อความสะดวก)

มันเป็นความอัปยศที่ฉันต้องยุ่งกับ padding กับศูนย์นำหน้า แต่จุดของรหัสนี้เป็นเพียงการแสดงผลไบนารีเป้าหมายในฐาน 36 ซึ่งเป็นสิ่งที่แน่นอน gut, a43, 2z3, 73ค่า

หมายเหตุ: ฉันรู้ว่ามันจะไม่อยู่ใกล้กับคำตอบที่ชนะ แต่เพื่อความคิด ...

Sprects , 44 ไบต์

 aaaa
bbbb
zozo
zzoo o1111 z0000 b0011 a0101

คำตอบของ Cedric ที่ส่งไปยัง Sprects

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

มันทำงานอย่างไร

การเรียกซ้ำนี้ขึ้นอยู่กับความจริงที่ว่ารูปแบบนั้นทำจากการแสดงไบนารีแนวตั้งของ nibbles 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-TH บิตของ X & (1 << Y)X: (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 ไบต์เพิ่มเติมเพื่อแทรก linebreaks สิ่งนี้อาจสั้นลงถึง 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);
    }
}

Haskell, 73

ใช่ 73 ตัวอักษร! ฉันไม่สามารถทำให้ความรักของพระเจ้าเล็กลงได้

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

ส่วนที่น่าเศร้าจริง ๆ เกี่ยวกับเรื่องนี้คือถ้าคุณต้องก้องเอาท์พุทโดยใช้ทุบตีคุณจะต้องมีเพียง 74 ตัวอักษร

JavaScript (ES5) 69

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

inca2 ,33 27 24

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

นี้จะขึ้นอยู่กับคำตอบของ Dvorak ม.ค. 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 => reshape" นั้นเงอะงะจริงๆ: แผนที่จะต้องฉลาดกว่า แก้ไข: แก้ไขข้อผิดพลาดอนุญาตให้กำจัด parens

แยกการแปลงฐานเป็นฟังก์ชันแยกต่างหาก N:x|y%.x^~1+[]/x.yจะให้ค่านี้19 รุ่นถ่าน16ตัว

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

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

inca2, 2

U0

Pyth 24/26

วิธีที่สั้นที่สุดคือคำตอบของ grc แปลเป็น Pyth ซึ่งฉันรู้สึกว่าถูกดังนั้นฉันจึงใช้วิธีของตัวเอง:

ของฉัน: 26 ตัวอักษร

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

grc's: 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 (แลมบ์บ็อต), 47 ไบต์

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

kinda cheaty เพราะมันใช้transposeจาก Data.List และreplicateMจาก 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(_) - แยกสตริงออกเป็นอาร์เรย์ถ่าน
• map(x->_,0:15) - ทำเช่นนี้สำหรับ 16 หลักแรกในช่วง
• hcat(_...) - Splat และ concatenate ในแนวนอนเป็นเมทริกซ์

ค 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 ไบต์

การแปลของคำตอบแบบหลามของ @ grc โกน 12 ไบต์จากการแปลต้นฉบับผ่านการใช้rep()'s eachและlengthข้อโต้แย้ง (และการจับคู่โต้แย้งบางส่วน) และโดยการจดจำว่าเทียบเท่ากับ0:1c(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 bytes):

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

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