16位二进制网格

29

给定任何无符号的16位整数，请将其十进制形式（即，以10为基数）转换为其位的4x4 ASCII网格，其中最高有效位（MSB）在左上方，最低有效位（LSB）在右下，先阅读然后再向下阅读（如英文文本）。

例子

输入：4242

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

输入：33825

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

具体要求

  1. 输入必须为十进制（以10为基数），但是您可以根据需要将其转换为二进制（包括使用内置语言）。

  2. 输出表格式必须完全匹配 。这表示您必须对表网格线使用特定的ASCII字符（-，+和|），如图所示，每个单元格的内部为3个字符，真位由表示，#而假位由空格（）表示。

  3. 不允许前导或尾随空格。最终换行需要。

  4. 位顺序必须与所述示例匹配。

津贴

  1. 输入必须在命令行，标准输入或用户输入中以10为基数，但不得硬编码为源代码。

愿最清晰最短的代码获胜！:-)

code-golf  ascii-art  base-conversion  binary 
— type_outcast
source
1
— Sp3000
2
第一句话听起来让我感到困惑，它说“转换其十进制形式 ”。根据文章的其余部分和示例，输入看起来像是十进制形式，但是您必须将值的二进制形式转换为网格。
— Reto Koradi
1
@RetoKoradi您基本上是正确的，但问题确实需要您将十进制数转换为二进制网格。没有明确的要求使用二进制数，只需要一个可能的实现细节。
— type_outcast
以10为底数作为函数参数编写函数是否算作用户输入？
— Alex A.
2
由于您说给定的数字是“无符号的16 位整数”，因此按定义它是二进制形式。当我第一次阅读此内容时，实际上听起来好像输入将以二进制形式给出。到最后一切都变得清晰起来。但是至少对我而言，第一段实际上根本没有解决问题。
— Reto Koradi

Answers:

21

J，26个字节

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

匿名动词。幸运的是，J非常擅长绘制盒子。让我们尝试一下：

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

正如一些评论者提到的那样，J绘制框的方式取决于系统：在某些平台上，此代码将在默认设置下工作，而在其他平台上，框将使用Unicode线条画字符绘制。（命令9!:6和9!:7允许您查询和设置字符以分别绘制带有框的值。）

— 林恩
source
您（或其他任何人）是否知道对高尔夫计分的盒子绘图命令是否达成共识？我个人认为使用代码高尔夫的假设是，解决方案可以在运行该解决方案语言的大多数系统上运行，对吗？在所有（或几乎所有）J安装上输出正确的盒子的解决方案是什么样的？顺便说一句，我真的很喜欢您的解决方案！我的大脑仍在努力，这正是我喜欢编码高尔夫的原因。
— type_outcast
5
@type_outcast对于代码高尔夫挑战，我们不需要可移植性。只要它可以在一个平台上以某种实现方式工作，它就是有效的。
— 丹尼斯2015年
感谢@Dennis的回复。我很高兴自己的推定是错误的，因为我（仍然）真的很喜欢毛里斯的解决方案！:-)
— type_outcast
14

JavaScript（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>
展开摘要

— edc65
source
6
是“JavaScripy”一些奇怪的JavaScript / Python的混搭？;-)
— Digital Trauma 2015年
6
@DigitalTrauma当然。但是由于世界还没有为这个新的发展做好准备（tvtropes.org/pmwiki/pmwiki.php/Main/TheWorldIsNotReady），所以我将使用JavaScript
— edc65
太酷了，这适用于Edge！
— Arturo TorresSánchez2015年
必须...不...单击... tvtropes ...
— RK。
14

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。（或更改Slow为5毫秒左右，然后单击Show。）
  6. -

4242的输出：

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

33825的输出：

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

说明

哦，天哪，我深深地陷入了什么？好吧，去！（不正确的代码被替换为.。）

第1部分：获取输入（存储在0,0中）并计算32768（存储在1,0中）。

&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*,^  ......... ...>
................ ...
 .........      .....
........
.................._$>^

-

— El'endia Starman
source
10

朱莉娅156个 143字节

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

在线尝试

— 亚历克斯·A
source
10

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

感谢Morgan Thrapp节省了4个字节，并感谢Jonathan Frech节省了5个字节。

用法

$ python test.py
33825
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
— 扎克·盖茨
source
如果'+---'*4输入变量，则可以节省两个字节；如果这样做，则可以节省两个字节j=''.join
— Morgan Thrapp
没问题！我实际上正在研究一个非常相似的解决方案。
— Morgan Thrapp 2015年
@downvoter关心解释吗？
— 扎克·盖茨
由于您不使用Python 3，因此可以替换int(input())为input()并保存五个字节。
— 乔纳森·弗雷希
9

红宝石，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保存了一些字符。

— hm
source
1
如果使用?符号（例如：?|而不是'|'）编写文字字符，则可以节省一些字节。这适用于除空间以外的所有内容。
— Cristian Lupascu 2015年
@ w0lf我发现它?\s适用于空间，但是在这里实际上没有帮助。
— Mhmd
7

GNU sed + dc，116

分数包括+1的-r标志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命令是一种欺骗。在这种情况下，根据此meta-answer，我们可以做些不同的事情。当然，问题明确指出必须以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 
+---+---+---+---+
| # |   |   |   |
+---+---+---+---+
|   | # |   |   |
+---+---+---+---+
|   |   | # |   |
+---+---+---+---+
|   |   |   | # |
+---+---+---+---+
$
— 数字创伤
source
好东西。这看起来与我作为Perl解决方案（作为私有概念验证）提出的解决方案很相似，同时又对问题进行了微调。
— type_outcast
@type_outcast顺便说一句，完全可以发布您自己的解决方案作为答案:)
— Digital Trauma
我知道:-)我没有花很多时间打高尔夫球，因为我更加专注于提出一个好问题，但是如果我可以打高尔夫球到至少一半的程度，我可能会重新审视并发布它。目前，我在寻找其他所有人的答案时玩得很开心。
— type_outcast
6

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");
    }
}
— 泽雷格斯
source
提示：0x10000为65536，前缀为“ 0x”，十六进制始终长于十进制
— edc65
提示2：您应避免using namespace std在生产代码中使用。它在这里也没有用。
— edc65
@ edc65 dec-> hex是个好主意，我一直认为hex的表示形式更短，但是忘记了0x。using namespace std节省了几个字节，因为我没有前缀cout和cin使用std::。即使使用也using std::cout;无济于事。
— Zereges
嘿，Zreges。您可以删除include和库之间的空格。并删除main函数的返回类型。
— wendelbsilva
C++不支持auto int。
— Zereges
6

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
— 雅库比
source
5

CJam，43 41字节

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

绝对可以打高尔夫球，但这是一个开始。生成第一行，然后为每4位创建一个偶数行并复制前一个奇数行。

在线尝试。

— Sp3000
source
4

Python 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

-1个字节感谢@xnor的巧妙4**8+技巧。通过循环9次来完成主要打印，然后为奇/偶选择适当的行。

— Sp3000
source
我认为这bin(4**8+input())[3:]可以节省一个字节format
— xnor
@xnor哦，这很整洁:)
— Sp3000
4

Python 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:])

感谢Sp3000提供2个字节。

— 异或
source
4

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变量并仅输出的方式，又节省了6个字节-join''。

。

使用PowerShell 很难。在PowerShell中使用二进制数字很难。

使用内置函数[convert]将输入整数转换为二进制字符串表示形式，然后将其重铸为a，[int64]以便我们可以重新调用.ToString()以在适当数量的零之前添加/填充。（请注意，创建字符串数组并将其连接起来@(,"0"*16)-join''比文字字符串短1个字符"0000000000000000"）

然后，进行简单的for-loop 1..16|%{...}检查每个数字以构建我们的输出数组，然后最后将-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('|')
— AdmBorkBork
source
1
我希望这是一个“有趣的尝试”。:-) +1为您解释；它有助于我对PowerShell的有限了解。
— type_outcast
3

Javascript（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的提示！

— 阿德罗维兹
source
干得好！由于您正在使用ES6，因此有一些提示：1.每当需要将字符串用作函数的唯一参数时，都可以使用模板字符串，如下所示：.join` | `​2.您还可以使用模板字符串来插值：i=>`,${"0".repeat....join`,`},`.replace...3您可以在此线程上找到更多的ES6技巧。
— ETHproductions 2015年
这似乎已经停止工作，但是通过打更多的高尔夫，我可以得到197的正确结果：i=>`,${("0".repeat(16)+i.toString(2)).slice(-16).split``.map((v,l,a)=>l%4?"":"| "+a.slice(l,l+4).map(v=>' #'[v]).join` | `+" |").filter(v=>v).join`,`},`.replace(/,/g,`<line break>+---+---+---+---+<line break>`).slice(1)
— ETHproductions 2015年
2
("0".repeat(16)+i.toString(2)).slice(-16) ->(65536|i).toString(2).slice(1)
— edc65
保持确切的逻辑，这可以打到169，请参阅jsfiddle.net/76fp7aw6
— edc65
2

Pyth，50个字节

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

解释将不得不等到下一次，我将其发布在手机上！

— ok
source
2

露比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，则打印一个终止符|，换行符和与第一个相同的水平分隔符。

— Level River St
source
2

Perl，103个字节

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

大量字符串重复生成xs 的网格，将输入转换为二进制，然后s///将xs转换为#or $"（），具体取决于指定位置（$x）的标志。

— 唐·黑斯廷斯
source
2

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)));
— 栗子
source
2

Perl 5中，85 84个字节

84 83个字节的代码+ -p标志

Dom提醒我使用换行符后为-1个字节

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

在线尝试！

— Xcali
source
不错，比我的方法好得多！文字换行符也可以节省您一个额外的字节$/！
— Dom Hastings
1

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是合适的（甚至花了我一些字节，但是C即使有机会也无法以字节为单位进行挑战，所以我不在乎） / argv

— 扎比斯
source
1

红宝石，95岁

向Mhmd致意，以进行简明的字符串转换，但我想尝试使用字符串方法而不是数字方法。

->i{puts g='+---'*4+?+;("%016b"%i).scan(/.{4}/){puts$&.gsub(/./){"| #{$&<?1?' ':?#} "}+"|
"+g}}
— 不是那个查尔斯
source
1

露比（93）

仅使用数字运算的简短版本。

->i{n=g='+---'*4+"+
";15.downto(0){|m|n+="| #{[' ',?#][1&i>>m]} "
n+="|
"+g if m%4<1}
puts n}
— 不是那个查尔斯
source
1

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

第一次尝试这种操作时，欢迎您提示！

— 蒽醌类
source
首先，我计算了286个字节，您可以删除缩进空间。
— 蓝色
您如何计算呢？我一直在属性中查看文件大小，但是我不确定这是否是这样做的方法！没有缩进，我的大小降到了230个字节！
— anthonytimmers
使用诸如mothereff.in/byte-counter之类的东西，或者如果您使用的是Linux，请使用wc命令
— Blue
1

Python 3、145 144字节

排队：

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

编辑：Tanks @manatwork用于保存1个字节

— 巴辛塔格
source
1
根据gnibbler的技巧，硬编码r=0,1,2,3比用r=range(4)。生成硬编码短1个字符。
— manatwork's
0

Kotlin，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)
}
— Jrtapsell
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.