_{이것은 난해한 프로그래밍 언어 를 발명 하려는 나의 탐구와 관련이 있습니다 .}

이진수 0 .. 15의 테이블을 사용하여 인덱싱 작업을 사용하여 범용 이진 함수를 구현할 수 있습니다. 2 개의 1 비트 입력 X와 Y가 주어지면 16 개의 가능한 모든 기능을 4 비트 opcode로 인코딩 할 수 있습니다.

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":하고 Jan의 답변 에서 빌려야합니다 .

파이썬 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. (숫자 행렬은 값 사이에 공백으로 표시되고 문자 행렬은 표시되지 않습니다. 따라서 각 숫자 비트를 char 중 하나로 변환합니다 '0' '1').

Jelly , 42 7 바이트 (비경쟁)

⁴ḶBUz0Y

온라인으로 사용해보십시오!

도움을 주신 Dennis에게 감사합니다. 여기 에 첫 번째 메시지 가 있고 마지막 메시지가 있습니다 (다른 토론도 발생했습니다). 그의 도움으로, 나는 거의 (거의) 점수를 제곱했다.

/// , 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();
        }
    }
}

자바 스크립트 (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 값과 n / 2를 전달하십시오.

"0".repeat(n)

toString은 선행 0을 취하기 때문에 각 줄의 시작 부분에 0을 채우는 것입니다.

J, 21 자

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

• i.16 0..15의 목록입니다
• 2^i.4 목록입니다 (1,2,4,8)
• %~/ 왼쪽 인수가 행을 형성하지만 나누기에 대한 올바른 인수 인 분할 테이블을 생성합니다.
• 2| [각 셀]을 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 -ish 접근 방식을 적용합니다 . 편집 : 문자열 자르기와 배열 압축을 색인 및 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.

펄 (36 + 1)

say평소와 같이 +1 이중 0은 오타가 아닙니다 :)

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

자바 스크립트 (ECMA6), 108

다른 접근법을 시도 중입니다. 이진 연산자를 사용하도록 권장되었지만 샬럿이 kolmogorov-complexity 이기 때문에이 솔루션을 제출하도록 허용했으며 어떻게 생각합니까? 그 값을 나타내는 코드의 양을 어떻게 줄일 수 있습니까? 기지 .

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

(편의를 위해 줄 바꿈).

선행 0으로 패딩을 망쳐 놓아야하는 것은 부끄러운 일이지만이 코드의 요점은 Base 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 바이트

1 바이트 할인을 위해 @Dennis에게 감사드립니다!

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

자바 스크립트 (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)는 X :의 Y 번째 비트로 표현 될 수 있습니다 X & (1 << Y). 이 비트를 다음과 같이 분리 할 수도 있습니다 (X >> Y) & 1. X와 Y를 추적하지 않고 n0에서 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());

배쉬 + 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]

NARS2000에서는 작동하지 않는 marinus의 APL 답변에서 파생되었습니다.

벡터 생성

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

0부터 시작으로 변경

      (⍳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++);}

이것은 4 개의 16 비트 블록으로 64 비트를 출력하는 일반적인 솔루션입니다. 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

이케, 73 문자! 나는 신의 사랑을 위해 이것을 더 작게 얻을 수 없습니다.

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

이것에 대한 진짜 슬픈 부분은 bash를 사용하여 출력을 반향하려면 74 문자 만 필요하다는 것입니다.

자바 스크립트 (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

이것은 Jan 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 함수는 지원하지 않으며 더미 인수를 제공해야합니다.

잉카 2, 2

U0

Pyth 24/26

가장 짧은 방법은 Pyth 로 번역 된 grc의 대답 이었습니다.

광산 : 26 자

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

grc : 24 자

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

C ++ 130

16 진수를 이진수로 변환

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

하스켈 (Lambdabot), 47 바이트

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

Kinda cheaty 는 Data.List에서 transpose 를 사용하기 때문에 하고 Control.Monad에서 replicateM 을 기본적으로 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) -4자를 채워서 int를 2 진 정수로 변환합니다.
• 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 바이트

@grc의 python answer의 번역. rep()의 each및 length인수 (및 부분 인수 일치)를 사용하고를 기억 하여 원래 번역에서 12 바이트를 제거 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))

@Gareth의 J 응답을 다음과 같이 변환 할 수도 있습니다 (34 바이트).

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

그러나 기본 R의 일부가 아닌 함수를 사용하고 사양과 같이 정확한 인쇄 텍스트로 포맷하기 어려운 행렬을 출력합니다.