Với bất kỳ số nguyên 16 bit không dấu nào, hãy chuyển đổi dạng thập phân (ví dụ, số cơ sở 10) thành lưới 4 x 4 ASCII của bit, với bit có ý nghĩa nhất (MSB) ở phía trên bên trái, bit có ý nghĩa thấp nhất (LSB) tại dưới cùng bên phải, đọc qua và sau đó xuống (như văn bản tiếng Anh).

Ví dụ

Đầu vào: 4242

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

Đầu vào: 33825

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

Yêu cầu cụ thể

1. Đầu vào phải ở dạng thập phân (cơ số 10), tuy nhiên bạn có thể chuyển đổi thành nhị phân theo bất kỳ cách nào bạn muốn (bao gồm sử dụng ngôn ngữ tích hợp, nếu có).

2. Định dạng bảng đầu ra phải khớp chính xác . Điều này có nghĩa là bạn phải sử dụng các ký tự ASCII cụ thể ( -, +và |) cho các đường lưới của bảng như được hiển thị, bên trong mỗi ô là 3 ký tự và các bit thực được biểu thị #trong khi false được biểu thị bằng khoảng trắng ( ).

3. Khoảng trắng hàng đầu hoặc dấu là không được phép. Dòng mới cuối cùng là bắt buộc .

4. Thứ tự bit phải phù hợp với các ví dụ như mô tả.

Phụ cấp

1. Đầu vào phải là số cơ sở 10 trên dòng lệnh, đầu vào tiêu chuẩn hoặc đầu vào của người dùng, nhưng không được mã hóa cứng vào mã nguồn của bạn.

Có thể mã ngắn nhất rõ ràng nhất giành chiến thắng! :-)

J, 26 byte

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

Một động từ ẩn danh. Rất may, J rất giỏi vẽ hộp. Hãy thử xem:

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

Như một số nhà bình luận đã đề cập, cách J vẽ các hộp phụ thuộc vào hệ thống: trên một số nền tảng, mã này sẽ hoạt động theo cài đặt mặc định, nhưng trên các nền tảng khác, các hộp sẽ được vẽ bằng các ký tự vẽ dòng Unicode. (Các lệnh 9!:6và9!:7 cho phép bạn truy vấn và đặt các ký tự để vẽ các giá trị được đóng hộp tương ứng.)

JavaScript (ES6), 102

... Hoặc 96 sử dụng returnthay vì console.log.

Kiểm tra chạy đoạn mã dưới đây trong trình duyệt tuân thủ 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 byte

&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-:#^_$>^

Để chạy chương trình ...

1. Đi đến phiên dịch trực tuyến .
2. Dán mã này vào hộp văn bản lớn.
3. Nhấn vào đây Show.
4. Nhập số mong muốn trong Inputhộp.
5. Nhấn vào đây Run. (Hoặc thay đổi Slowthành thứ gì đó như 5 mili giây rồi bấm Show.)
6. Ta-da!

Đầu ra cho 4242:

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

Đầu ra cho 33825:

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

Giải trình

Ôi trời, tôi đã có được những gì? Thôi, đi đây! (Mã không liên quan được thay thế bằng .s.)

Phần 1: Nhận đầu vào (lưu trữ trong 0,0) và tính 32768 (lưu trữ trong 1,0).

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

Phần 2: In ra "+ --- + --- + --- + ---".

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

Phần 3: In "+" và một dòng mới và kiểm tra xem (1,0) có phải là 0 (tức là chúng ta đã hoàn thành). Nếu vậy, chấm dứt. Nếu không, tiếp tục.

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

Phần 4: Nhận các chữ số nhị phân của đầu vào, cập nhật (0,0) và (1,0) khi chúng ta đi cùng. In những điều đúng. Tôi lợi dụng hành vi bao bọc của Befunge.

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

Phần 5: In một dòng mới và quay lại phần in "+ --- + --- + --- + --- +". Thủ thuật quấn quanh được sử dụng.

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

Ta-da!

Julia, 156 143 byte

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

Ung dung:

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

Dùng thử trực tuyến

Python 2, 157 153 151 146 byte

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+'+'

Cảm ơn Morgan Thrapp vì đã lưu 4 byte và Jonathan Frech đã lưu 5.

Sử dụng

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

Ruby, 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

cảm ơn vì @ w0lf vì đã lưu một số ký tự.

GNU sed + dc, 116

Điểm bao gồm +1 cho các -rcờ để 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/

Đầu ra thử nghiệm:

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

Cách khác:

Sed tinh khiết, 146

Bạn có thể nghĩ rằng việc gian lận sử dụng sedphần mở rộng GNU của mình để tránh dclệnh. Trong trường hợp đó, chúng ta có thể làm điều này một chút khác nhau, theo câu trả lời meta này . Tất nhiên câu hỏi nêu rõ rằng đầu vào phải ở cơ sở 10, nhưng ở đây tôi đang cố gắng tuyên bố rằng chúng ta có thể ghi đè lên đó để sedtrả lời và sử dụng unary (cơ sở 1) thay thế.

:
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/

Đầu ra thử nghiệm

Sử dụng printfđể tạo chuỗi unary cần thiết:

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

C ++ 11, 193 191 190 176 172 byte

Giải pháp đầu tiên của tôi về codegolf từ trước đến giờ, vì vậy đừng đổ lỗi cho tôi.

#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?"|":"+");}}

Bị đánh cắp

#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 ? "|" : "+");
    }
}

Phiên bản trước

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

Bình thường, 37 byte

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

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Giải trình:

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 byte

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

Tôi chắc chắn có thể chơi gôn, nhưng đó là một khởi đầu tôi đoán. Tạo hàng trên cùng, sau đó với mỗi 4 bit, nó tạo một hàng chẵn và sao chép hàng lẻ trước đó.

Hãy thử trực tuyến .

Python 2, 122 121 120 byte

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

-1 byte nhờ 4**8+thủ thuật gọn gàng của @ xnor . Việc in chính được thực hiện bằng cách lặp 9 lần, chọn hàng thích hợp cho số lẻ / chẵn.

Con trăn 2, 94

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

Ý tưởng là lấy mẫu

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

ngoại trừ %sthay cho chỗ trống và thực hiện thay thế tuple. Các tuple trông giống như

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

Nó được tạo ra bằng cách lấy các chữ số từ đầu vào nhị phân và thêm ký hiệu tương ứng vào phía trước của bộ dữ liệu. Một biểu thức với bộ dữ liệu rõ ràng cho chiều dài bằng nhau.

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

Cảm ơn Sp3000 cho 2 byte.

PowerShell, 203 188 182 byte

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

_{Chỉnh sửa - đã lưu 15 byte bằng cách thay đổi thứ tự |được vẽ, vì vậy chúng ta có thể kết .TrimEnd("|")xuất đầu ra và thay vào đó chuyển đổi vòng lặp for thành một khối mã con tạo ra một mảng}

_{Edit2 - đã lưu 6 byte khác bằng cách loại bỏ nhu cầu lưu vào $obiến và chỉ xuất ra với-join'' trực tiếp.}

Ôi trời ơi.

Vẽ trong PowerShell là khó . Làm việc với các chữ số nhị phân trong PowerShell là khó .

Sử dụng tích hợp cho [convert]số nguyên đầu vào thành biểu diễn chuỗi ở dạng nhị phân, sau đó truyền lại thành một [int64]để chúng ta có thể gọi .ToString()lại để thêm / đệm số lượng 0 thích hợp. (Lưu ý rằng tạo một chuỗi các chuỗi và nối chúng@(,"0"*16)-join'' ngắn hơn 1 ký tự so với chuỗi ký tự "0000000000000000")

Sau đó, thực hiện 1..16|%{...}kiểm tra vòng lặp đơn giản cho từng chữ số để xây dựng mảng đầu ra của chúng tôi, cuối cùng-join'' kết hợp lại với nhau.

Trước đó, 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''

Trước đó, 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('|')

Javascript (ES6), 216 207 byte

Xác định một hàm ẩn danh.

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)

Cảm ơn ETHproductions cho lời khuyên!

CJam, 62 byte

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

Hãy thử trực tuyến .

Bình thường, 50 byte

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

Giải thích sẽ phải đợi đến một lần khác, tôi sẽ đăng bài này trên điện thoại của mình!

Hồng ngọc, 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}

Thuật toán

In một dải phân cách ngang

Lặp lại 20 lần (19..0)

Nếu số vòng lặp không chia cho 5, hãy chuyển đổi thành một số trong phạm vi 16..0 bằng cách nhân với 4/5. In một khoảng trắng (ascii 32) hoặc #(ascii 32 + 3 = 35) trước| và theo sau là khoảng trắng.

Nếu số vòng lặp chia cho 5, hãy in một kết thúc |, dòng mới và một bộ chia ngang giống hệt với đầu tiên.

Perl, 103 byte

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

Rất nhiều chuỗi lặp lại để tạo ra một mạng lưới các xs, chuyển đổi các đầu vào nhị phân và sau đó s///các xs #hoặc $"( ) tùy thuộc vào lá cờ ở vị trí quy định ( $x).

PHP, 159 byte

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";}

Sử dụng:

php bingrid16.php 4242

Không có gì lạ mắt, chỉ cần vũ phu buộc kết xuất.

Tôi đã thử một góc khác bằng cách sử dụng các mảng thay vì các vòng lặp, nhưng nó dài hơn ở mức 224 byte:

<?=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)));

Perl 5 , 85 84 byte

84 83 byte mã + -pcờ

-1 byte sau khi Dom nhắc tôi sử dụng một dòng mới

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

Hãy thử trực tuyến!

c99 263 byte

đánh gôn

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

vô dụng:

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

Tôi chỉ thích trình bày một biến thể dịch chuyển một chút và cảm thấy đây là lần đầu tiên nó phù hợp (thậm chí nó làm tôi tốn một số byte, nhưng C không thể sử dụng byte này ngay cả khi có cơ hội nên tôi không quan tâm) sử dụng argc / argv

Hồng ngọc, 95

Nod sang Mhmd để chuyển đổi Chuỗi ngắn gọn, nhưng tôi muốn thử sử dụng các phương thức chuỗi thay vì phương thức số.

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

Ruby, 93

Một phiên bản ngắn hơn một chút chỉ sử dụng các hoạt động số.

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

C # 227 byte

Chơi gôn

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;}}

Chỉ định:

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;
    }
}

Lần đầu tiên tôi đang thử một cái gì đó như thế này, lời khuyên sẽ được chào đón!

Python 3, 145 144 byte

Nội tuyến:

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()))

Với dòng mới:

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()))

Chỉnh sửa: Tanks @manatwork để lưu 1 byte

Kotlin , 192 byte

{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()}

Làm đẹ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()
}

Kiểm tra

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 byte

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

Hãy thử trực tuyến!