부호없는 16 비트 정수가 주어지면 10 진수 형식 (즉, 10 진수 )을 4x4 ASCII 격자 비트로 변환하고 최상위 왼쪽에 MSB (최고 비트), LSB (최하위 비트)를 오른쪽 아래에서 영어 텍스트와 같이 읽은 다음 아래로 읽습니다.

예

입력 : 4242

+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| # |   |   | # |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+

입력 : 33825

+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+

특정 요구 사항

1. 입력 은 10 진수 (base-10) 여야 하지만 원하는 방식으로 바이너리를 변환 할 수 있습니다 (사용 가능한 경우 언어 내장 기능 사용 포함).

2. 출력 테이블 형식은 정확히 일치해야합니다 . 이 방법을 사용하면 특정 ASCII 문자 (사용해야합니다 -, +그리고 |그림과 같이 테이블 그리드 라인)을, 각 셀의 내부가 3 자이며 진정한 비트에 의해 표현되는 #동안 거짓이 공백으로 표시됩니다 ( ).

3. 선행 또는 후행 공백은 허용되지 않습니다. 최종 개행이 필요합니다 .

4. 비트 순서는 설명 된 예와 일치해야합니다.

참작

1. 입력은 명령 행, 표준 입력 또는 사용자 입력에서 10 진수 여야 하지만 소스 코드에 하드 코드 되지 않아야합니다.

월 깨끗한 짧은 코드 승리! :-)

J, 26 바이트

('   ';' # '){~4 4$_16{.#:

익명의 동사. 고맙게도 J는 상자 그리기에 매우 능숙합니다. 사용해 봅시다 :

   f =. ('   ';' # '){~4 4$_16{.#:
   f 4242
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| # |   |   | # |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+

일부 주석 작성자가 언급했듯이 J가 상자를 그리는 방식은 시스템에 따라 다릅니다. 일부 플랫폼에서는이 코드가 기본 설정에서 작동하지만 다른 코드에서는 유니 코드 선 그리기 문자를 사용하여 상자가 그려집니다. (명령 9!:6을9!:7 사용하면 각각 상자 값을 그릴 문자를 쿼리하고 설정할 수 있습니다.)

자바 스크립트 (ES6), 102

... 또는 96 return대신을 사용 합니다 console.log.

EcmaScript 6 호환 브라우저에서 아래 스 니펫을 테스트하십시오.

f=n=>{for(o=h=`
+---+---+---+---+
`,z=16;z--;n/=2)o=(z&3?'':h+'|')+` ${' #'[n&1]} |`+o;console.log(o)}

// TEST
console.log=x=>O.innerHTML=x+O.innerHTML

function test(n) { f(n); console.log(n); }

<input id=I value=4680><button onclick='test(+I.value)'>-></button>
<pre id=O></pre>

Befunge -93, 196 218 바이트

&00p12*v>>4>"---+",v v <
v*:*:*:<   | :-1,,,< #
>:*2/10p^  >"+",25*,10g|
     > #v^#         $< @
 25*,^  >4" |",,v ,*<>
v>"#",00g10g-00p 10g
 |`-1g01g00     <>48^
v>" ",10g
>2/10p>"| ",,1-:#^_$>^

프로그램을 실행하려면 ...

1. 온라인 통역사로 이동하십시오 .
2. 이 코드를 큰 텍스트 상자에 붙여 넣습니다.
3. 를 클릭하십시오 Show.
4. Input상자에 원하는 숫자를 입력하십시오 .
5. 를 클릭하십시오 Run. 또는 Slow5 밀리 초와 같은 것으로 변경 한 다음을 클릭하십시오 Show.
6. 타다!

4242의 출력 :

+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| # |   |   | # |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+

33825에 대한 출력 :

+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+

설명

오 세상에, 내가 무엇을 얻었습니까? 글쎄, 여기 간다! 관련없는 코드는 .s 로 바뀝니다 .

1 부 : 입력을 받고 (0,0에 저장) 32768 (1에 저장)을 계산하십시오.

&00p12*v>
v*:*:*:< 
>:*2/10p^

파트 2 : "+ --- + --- + --- + ---"를 인쇄합니다.

>4>"---+",v
  | :-1,,,<

3 부 : "+"와 줄 바꿈을 인쇄하고 (1,0)이 0인지 확인하십시오 (예 : 완료). 그렇다면 종료하십시오. 그렇지 않으면 계속하십시오.

 ........... v <
   | ....... # 
   >"+",25*,10g|
v.#         $< @
>4" |",,v ...

제 4 부 : 우리가 진행함에 따라 (0,0)과 (1,0)을 업데이트하여 입력의 이진수를 가져옵니다. 올바른 것을 인쇄하십시오. Befunge의 랩 어라운드 동작을 이용합니다.

 .....  >4" |",,v ,*<.
v>"#",00g10g-00p 10g
 |`-1g01g00     <>48^
v>" ",10g
>2/10p>"| ",,1-:#^_...

5 부 : 줄 바꿈을 인쇄하고 "+ --- + --- + --- + --- +"를 인쇄하는 부분으로 돌아갑니다. 랩 어라운드 트릭이 사용됩니다.

     > #.^.         .. .
 25*,^  ......... ...>
................ ...
 .........      .....
........
.................._$>^

타다!

줄리아, 156143 바이트

n->(p=println;l="+"*"---+"^4;for i=1:4 p(l,"\n| ",join([j>"0"?"#":" "for j=reshape(split(lpad(bin(n),16,0),""),4,4)[:,i]]," | ")," |")end;p(l))

언 골프 드 :

function f(n::Int)
    # Convert the input to binary, padded to 16 digits
    b = lpad(bin(n), 16, 0)

    # Split b into a 4x4 matrix
    m = reshape(split(b, ""), 4, 4)

    # Store the line separator for brevity
    l = "+" * "---+"^4

    # Print each column of the matrix as a row
    for i = 1:4
        println(l, "\n| ", join([j > "0" ? "#" : " " for j = m[:,i]], " | "), " |")
    end

    # Print the bottom of the table
    println(l)
end

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

파이썬 2 157 153 151 146 바이트

J=''.join;R='+---'*4;i=format(input(),'016b')
print J(R+'+\n|'+J(' '+('#'if int(l)else' ')+' |'for l in i[n*4:-~n*4])+'\n'for n in range(4)),R+'+'

4 바이트를 절약 한 Morgan Thrapp와 5를 절약 한 Jonathan Frech에게 감사드립니다.

용법

$ python test.py
33825
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+

루비, 118 114

b="%016b"%gets
l=?++"---+"*4
1.upto(16){|i|puts l if i%4==1
print"| #{b[i-1]==?0?' ':?#} "
puts ?|if i%4<1}
puts l

일부 문자를 저장해 준 @ w0lf에게 감사합니다.

GNU sed + dc, 116

점수는 다음에 대한 -r플래그에 +1을 포함 합니다 sed.

s/.*/dc -e2o&p/e
:
s/^.{,15}$/0&/;t
s/./| & /g
s/.{16}/\n+---+---+---+---+\n&|/g
y/01/ #/
s/\n([-+]+)(.*)/\1\2\n\1/

테스트 출력 :

$ { echo 4242 ; echo 33825 ; } | sed -rf 16bitgrid.sed
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+
| # |   |   | # |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
$ 

또는

순수한 sed, 146

명령 sed을 평가하기 위해 GNU 확장을 사용하는 것이 바람을 피우고 있다고 생각할 수도 있습니다 dc. 이 경우이 메타 답변 에 따르면 약간 다르게 할 수 있습니다 . 물론 질문에는 입력 이 10 진 이어야한다고 명시되어 있지만 여기서는 sed대답을 무시하고 단항 (기본 1)을 사용할 수 있다고 주장하려고합니다 .

:
s/11/</g
s/<([ #]*)$/< \1/
s/1/#/
y/</1/
t
:a
s/^.{,15}$/0&/;ta
s/./| & /g
s/.{16}/\n+---+---+---+---+\n&|/g
y/01/ #/
s/\n([-+]+)(.*)/\1\2\n\1/

테스트 출력

printf필요한 단항 문자열 생성에 사용 :

$ printf "%33825s" | tr ' ' 1 | sed -rf 16bitgrid.sed 
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
$ 

C ++ 11 193 191 190 176 172 바이트

codegolf에 대한 나의 첫 번째 해결책은 나를 탓하지 마십시오.

#include<iostream>
int n,j,i=65536;int main(){std::cin>>n;for(;j<9;){for(int k:{0,0,0,0})if(j%2)printf("| %s",n&(i/=2)?"# ":"  ");else printf("+---");puts(j++%2?"|":"+");}}

언 골프

#include <iostream>
int n, i = 65536, j;

int main()
{
    std::cin >> n;

    for (; j < 9;)
    {
        for(int k:{0,0,0,0})
        {
            if (j % 2)
            {
                printf("| %s", n & (i /= 2) ? "# " : "  ");
            }
            else
            {
                printf("+---");
            }
        }
        puts(j++ % 2 ? "|" : "+");
    }
}

이전 버전

#include <iostream>
using namespace std;

int n, i = 65536, j;
int main()
{
    cin >> n;

    for (; j < 9;)
    {
        for(int k:{0,0,0,0})
        {
            if (j % 2)
            {
                cout << "| " << (n & (i /= 2) ? "# " : "  ");
            }
            else
            {
                cout << "+---";
            }
        }
        cout << (j++ % 2 ? "|\n" : "+\n");
    }
}

Pyth, 37 바이트

Jj*3\-*5\+JVc4_m@" #".>Qd16jd.i*5\|NJ

온라인으로 사용해보십시오 : 데모 또는 테스트 스위트

설명:

Jj*3\-*5\+J
  *3\-                       the string "---"
      *5\+                   the string "+++++"
 j                           join second by first string: 
                                "+---+---+---+---+"
J                            save in J
          J                  print J

Vc4_m@" #".>Qd16jd.i*5\|NJ
    m         16             map each d in [0, 1, ..., 15] to:
          .>Qd                 input number Q shifted to the right by d
     @" #"                     and take the ^th char in " #" (modulo 2)
   _                         reverse this list of chars
 c4                          split into 4 groups
V                            for each group N in ^:
                    *5\|       the string "|||||"
                  .i    N      interleave ^ with N
                jd             join chars with spaces and print
                         J     print J

CJam, 43 41 바이트

'+5*'-3**N+ri2bG0e[4/{" #"f='|5*.\S*N2$}/

확실히 골프를 칠 수 있지만, 그것은 시작이라고 생각합니다. 맨 위 행을 생성 한 다음 4 비트마다 짝수 행을 작성하고 이전 홀수 행을 복사합니다.

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

파이썬 2 122 121 120 바이트

n=bin(4**8+input())[3:]
i=0
exec"print'| %s |'%' | '.join(' #'[x>'0']for x in n[:4])*i or'+---'*4+'+';n=n[4*i:];i^=1;"*9

@xnor의 깔끔한 4**8+트릭 덕분에 -1 바이트 . 메인 인쇄는 홀수 / 짝수에 적합한 행을 선택하여 9 회 반복하여 수행됩니다.

파이썬 2, 94

n=input()
s=();exec"s=(' #'[n%2],)+s;n/=2;"*16
a='+---'*4+'+\n'
print(a+'| %s '*4+'|\n')*4%s+a

아이디어는 패턴을 취하는 것입니다

+---+---+---+---+
| _ | _ | _ | _ |
+---+---+---+---+
| _ | _ | _ | _ |
+---+---+---+---+
| _ | _ | _ | _ |
+---+---+---+---+
| _ | _ | _ | _ |
+---+---+---+---+

제외 %s블랭크 대신 튜플과 대체를 수행한다. 튜플은 다음과 같습니다

('#', ' ', ' ', ' ', ' ', '#', ' ', ' ', ' ', ' ', '#', ' ', ' ', ' ', ' ', '#')

이진수로 입력에서 숫자를 빼고 해당 기호를 튜플의 앞면에 추가하여 만듭니다. 명시적인 튜플이있는 표현식은 길이가 같습니다.

%tuple(' #'[c>'0']for c in bin(input()+4**8)[3:])

2 바이트에 대한 Sp3000 덕분입니다.

PowerShell을 203 188 182 바이트

param($a)$l="+---+---+---+---+";$l;$b=([int64][convert]::ToString($a,2)).ToString(@(,"0"*16)-join'');@(1..16|%{if($b[$_-1]-eq'1'){"| # "}else{"|   "};if($_%4-eq0){"|`n$l`n"}})-join''

_{편집- |그려진 순서를 변경하여 15 바이트를 절약 하므로 .TrimEnd("|")출력을 덤프 하고 for 루프를 배열을 생성하는 서브 코드 블록으로 변환 할 수 있습니다}

_{Edit2- $o변수 에 저장하지 않고 -join''직접 출력하여 6 바이트를 절약했습니다 .}

멍청이.

PowerShell에서 그리기는 어렵습니다 . PowerShell에서 이진수로 작업하는 것은 어렵습니다 .

[convert]입력 정수에 내장을 사용 하여 이진의 문자열 표현을 사용한 다음 다시 다시 캐스팅 하여 적절한 수의 0을 앞에 추가 / 패드하기 위해 [int64]다시 호출 할 수 있습니다 .ToString(). (문자열 배열을 만들고 결합하는 @(,"0"*16)-join''것은 리터럴 문자열보다 1 문자 짧습니다 "0000000000000000")

그런 다음 1..16|%{...}각 숫자를 간단히 for-loop 검사하여 출력 배열을 구성한 다음 마지막 -join''으로 다시 배열 합니다.

이전, 188

param($a)$l="+---+---+---+---+";$l;$b=([int64][convert]::ToString($a,2)).ToString(@(,"0"*16)-join'');$o=@(1..16|%{if($b[$_-1]-eq'1'){"| # "}else{"|   "};if($_%4-eq0){"|`n$l`n"}});$o-join''

이전 203

param($a)$l="+---+---+---+---+`n|";$o=$l;$b=([int64][convert]::ToString($a,2)).ToString(@(,"0"*16)-join'');1..16|%{if($b[$_-1]-eq'1'){$o+=" # |"}else{$o+="   |"};if($_%4-eq0){$o+="`n$l"}};$o.TrimEnd('|')

자바 (ES6) 216 207 바이트

익명 함수를 정의합니다.

i=>(","+("0".repeat(16)+i.toString(2)).slice(-16).split``.map((v,l,a)=>l%4<1?"| "+a.slice(l,l+4).map(v=>v?"#":" ").join` | `+" |":"").filter(v=>!!v).join`,`+",").replace(/,/g, `
+---+---+---+---+
`).slice(1)

팁을위한 ETHproductions에 감사합니다!

CJam, 62 바이트

"+---|   "4/{4*_c+N+}%4*_0=]sqi2bG0e[ee{~{_9*\4%5*-K+'#t0}&;}/

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

Pyth, 50 바이트

j.i*5]<3*5"+---"ms.i*5\|dc4mj@" #"qd\1*2\ .[Z16.BQ

설명은 다른 시간까지 기다려야합니다. 전화에 이것을 게시하고 있습니다!

루비, 102

n=gets.to_i
print j="+---"*4+"+
" 
19.downto(0){|i|print i%5>0?"| #{((n>>i*4/5)%2*3+32).chr} ":"|
"+j}

연산

수평 칸막이 인쇄

20 회 반복 (19..0)

루프 번호가 5로 나누지 않으면 4/5를 곱하여 16..0 범위의 숫자로 변환하십시오. 공백이 뒤에 오는 공백 (ascii 32) 또는 #(ascii 32 + 3 = 35)를 인쇄합니다 |.

루프 번호가 5로 나뉘면 종료 |, 줄 바꿈 및 첫 번째와 동일한 가로 구분선을 인쇄하십시오.

펄, 103 바이트

$_=(($l='+---'x4 .'+
').'| x 'x4 .'|
')x4 .$l;@n=(sprintf'%016b',<>)=~/./g;s/x/$n[$x++]?'#':$"/eg;print

문자열의 반복의 제비의 격자 만들 x이진과에 입력을 변환들 에의 하거나 ( ) 지정된 위치에있는 플래그에 따라 ( ).s///x#$"$x

PHP, 159 바이트

bingrid16.php:

<?$r=10;while(--$r){if($r%2){echo str_repeat('+---',4).'+';}else{$c=9;echo'|';while(--$c){echo' '.($c%2?'|':($argv[1]&pow(2,$r*2+$c/2-5)?'#':' '));}}echo"\n";}

용법:

php bingrid16.php 4242

멋진 것은 아니며 렌더링을 무차별 적으로 적용했습니다.

루프 대신 배열을 사용하여 다른 각도를 시도했지만 224 바이트가 더 길었습니다.

<?=implode(array_map(function($r)use($argv){return($r%2?str_repeat('+---',4).'+':'|'.implode(array_map(function($c)use($r,$argv){return' '.($c%2?'|':($argv[1]&pow(2,$r*2+$c/2-5)?'#':' '));},range(8,1))))."\n";},range(9,1)));

펄 5 , 85 84 바이트

84 83 바이트 코드 + -p플래그

Dom이 줄 바꿈을 사용하도록 상기시킨 후 -1 바이트

say$\='+'."---+"x4,"
| ",map y/01/ #/r.' | ',/./g for(sprintf"%016b",$_)=~/..../g}{

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

c99 263 바이트

골프 :

main(int argc,char **argv){short i=atoi(argv[argc-1]);char *t="| # ", *f="|   ",*a[16],**p=a,*b="+---+---+---+---+\r\n";while(p<a+16){if((i|0x8000)==i)(*(p++))=t;else(*(p++))=f;i<<=1;}for(p=a;p<a+16;p+=4)printf("%s%s%s%s%s|\n",b,*p,p[1],p[2],p[3]);printf("%s",b);}

언 골프 :

main(int argc, char **argv)
{
    short i=atoi(argv[argc -1]);
    char *t ="| # ", *f="|   ",*a[16],**p=a,*b="+---+---+---+---+\r\n";

    while (p<a+16)
    {
        if((i|32768)==i)
            (*(p++))=t;
        else
            (*(p++))=f;

        i<<=1;
    }

    for (p=a;p<a+16;p+=4)
        printf("%s%s%s%s%s|\n",b,*p,p[1],p[2],p[3]);
    printf("%s",b);
}

나는 조금 변화하는 변형을 제시하고 이것이 argc를 사용하는 것이 적절하다는 것을 느꼈다. / argv

루비, 95

간결한 문자열 변환을 위해 Mhmd로 끄덕이지만 숫자 방법 대신 문자열 방법을 사용하고 싶었습니다.

->i{puts g='+---'*4+?+;("%016b"%i).scan(/.{4}/){puts$&.gsub(/./){"| #{$&<?1?' ':?#} "}+"|
"+g}}

루비, 93

숫자 연산 만 사용하는 약간 짧은 버전입니다.

->i{n=g='+---'*4+"+
";15.downto(0){|m|n+="| #{[' ',?#][1&i>>m]} "
n+="|
"+g if m%4<1}
puts n}

C # 227 바이트

골프 :

class B{public static string G(short v){string s="",b=System.Convert.ToString(v,2).PadLeft(16,'0');for(int i=9;i>0;){s+=i--%2!=0?"+---+---+---+---+\n":"| "+b[i*2+1]+" | "+b[i*2]+" | "+b[i*2-1]+" | "+b[i*2-2]+" |\n";}return s;}}

톱니 모양:

class B
{
    public static string G(short v)
    {
        string s="",b=System.Convert.ToString(v, 2).PadLeft(16,'0');
        for(int i=9;i>0;)
            s+=i--%2!=0?"+---+---+---+---+\n":"| "+b[i*2+1]+" | "+b[i*2]+" | "+b[i*2-1]+" | "+b[i*2-2]+" |\n";
        return s;
    }
}

이런 식으로 처음 시도하면 팁을 환영합니다!

파이썬 3, 145144 바이트

인라인 :

a="|";b="+"+"---+"*4+"\n";r=0,1,2,3;(lambda x:print(b+b.join(a+a.join(" %s "%'# '[x&2**(i+j*4)<1]for i in r)+a+"\n"for j in r)+b))(int(input()))

줄 바꿈으로 :

a="|"
b="+"+"---+"*4+"\n"
r=0,1,2,3
lambda x:print(b+b.join(a+a.join(" %s "%'# '[x&2**(i+j*4)<1]for i in r)+a+"\n"for j in r)+b)
x(int(input()))

편집 : 1 바이트를 저장하기위한 탱크 @manatwork

코 틀린 , 192 바이트

{val v=it.toString(2).padStart(16,'0')
fun p(){(0..3).map{print("+---")}
println("+")}
(0..3).map{p()
v.subSequence(it*4,(it+1)*4).map{print("| ${if(it>'0')'#' else ' '} ")}
println("|")}
p()}

미화

{
    val v = it.toString(2).padStart(16, '0')
    fun p() {
        (0..3).map { print("+---") }
        println("+")
    }
    (0..3).map {
        p()
        v.subSequence(it *4, (it +1) *4).map {print("| ${if (it > '0') '#' else ' '} ")}
        println("|")
    }
    p()
}

테스트

var b:(Int) -> Unit =
{val v=it.toString(2).padStart(16,'0')
fun p(){(0..3).map{print("+---")}
println("+")}
(0..3).map{p()
v.subSequence(it*4,(it+1)*4).map{print("| ${if(it>'0')'#' else ' '} ")}
println("|")}
p()}

fun main(args: Array<String>) {
    b(255)
}

05AB1E , 45 바이트

bDg16αúS4ôεεð.ø}õ.ø'|ý}õ.ø…+--3F.∞}¶.øý10„# ‡

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