我想要的是：

非常简单，我想要一个基于文本的显示，要求输入n，然后在显示上显示该值！但是有一个陷阱。每个“真实”“像素”（填充的像素）都必须用该数字表示n。

范例：

系统会为您提供输入n。您可以假设n将是一个数字

Input: 0
Output:
000
0 0
0 0
0 0
000

Input: 1
Output:
  1
  1 
  1
  1
  1

Input: 2
Output:
222
  2
222
2
222

Input: 3
Output:
333
  3
333
  3
333

Input: 4
Output:
4 4
4 4
444
  4
  4

Input: 5
Output:
555
5  
555
  5
555

Input: 6
Output:
666
6    
666
6 6
666

Input: 7
Output:
777
  7
  7
  7
  7

Input: 8
Output:
888
8 8
888
8 8
888

Input: 9
Output:
999
9 9
999
  9
999

挑战：

在上面做尽可能少的字节。

我只会接受符合所有要求的答案。

只要数字显示正确，周围的空格是可选的。

另外，小于75字节是我的投票，是最低的接受，但是我可以随时更改接受的答案，因此不要灰心回答。

SOGL V0.12，30 个字节

■'τč▲Β►║⁰ΡāQšJ┘tXdnοO¹‘'¹n.w3n

在这里尝试！ 压缩的字符串■'τč▲Β►║⁰ΡāQšJ┘tXdnοO¹‘是

  ŗ  ŗ  ŗ  ŗ  ŗŗŗŗ  ŗŗŗŗŗ  ŗŗŗŗŗŗ  ŗŗŗŗ  ŗŗŗŗŗ ŗŗ ŗŗŗŗ  ŗ  ŗŗŗŗŗ  ŗŗŗ  ŗŗŗŗŗŗŗŗ  ŗŗŗŗ ŗŗŗŗŗŗŗ  ŗ  ŗ  ŗ  ŗŗŗŗŗ ŗŗŗŗŗ ŗŗŗŗŗŗŗŗ ŗŗŗŗ  ŗŗŗŗŗŗŗŗ ŗŗ ŗŗ ŗŗŗŗ

这是（以1开头，以0结束）数字，逐行，从数字到数字。其余的部分

...‘             push the compressed string, replacing the ŗs with pop - the input
    '¹n          split into chunks of 15
       .w        push the (1-indexed, wrapping) input-th item of that array
             3n  split into chunks of 3
                 implicitly output the array, line by line

JavaScript（ES6），88个字节

f=
n=>`019
2 3
459
6 7
889`.replace(/\d/g,c=>[2,18,142,96,130,131,698,4,146][c]>>n&1?` `:n)

<input type=number min=0 max=9 oninput=o.textContent=f(this.value)><pre id=o>

数字编码哪些正方形包含给定数字的空格，例如，左下角的值为146，因为1、4和7不使用它，并且146 =2¹+2⁴+2⁷。

05AB1E，40 39 38字节

•Y¤ŸèK'¦ú’ò™^N•4B5ô¹èvð¹«5714yè8+b¦Sè,

在线尝试！

说明

•Y¤ŸèK'¦ú’ò™^N•            # the compressed string "318975565561233953387608032537"

4B                         # convert to base-4
  5ô                       # split into strings of size 5
    ¹è                     # get the string at index <input>
      v                    # for each digit y in string
          5714yè           # get the digit in 5714 at index y
                8+         # add 8
                  b        # convert to binary
                   ¦       # remove the leading 1
       𹫠         Sè     # with each digit in the binary number, 
                           # index into the string " <input>"   
                      ,    # print with newline

Japt，43个字节

"Ýûÿ©ÿßY÷ß"®c s4äëAU ¬£2839¤ë4X÷d0S1U

包含一些不可打印的内容。在线尝试！

提示：13字节的压缩数据，9字节的数据进行解压缩，21字节的数据形成输出。

说明

取消程式码：

"Ýûÿ©ÿßY÷ß"®   c s4à ¤  ëAU ¬ £  2839¤  ë4Xà ·  d0S1U
"Ýûÿ©ÿßY÷ß"mZ{Zc s4} s2 ëAU q mX{2839s2 ë4X} qR d0S1U

共有4种不同的行可能性：（#代表一个数字）

#  
  #
# #
###

因此，每个数字可以存储为一组5个以4为基数的数字。由于每个数字然后可以存储在10位中，因此总计为100位，对应于13个字节。我将跳过压缩过程，而是说明解压缩过程。

mZ{Zc s4} 

mZ{     }  // Replace each character Z in the compressed string with the following:
   Zc      //   Take the char-code of Z.
      s4   //   Convert to a base-4 string.

解压缩后，13字节的压缩字符串如下所示：

3131332333332111200122213333313321011121213133133133

请注意，如果任何4位数字以开头，这将失败0，因为在运行时，前导零将被保留s4。我们可以通过0只代表#  3次来表示一次来解决此问题，而这些都不会出现在4位数字开始时。

s2         // Slice off the first two chars of the result.

好的，因此，为了使我们的50位数字的字符串以4个块的形式很好地压缩，我们必须添加两个额外的数字。将它们添加到字符串的开头意味着我们可以用一跳将它们切掉¤。

ëAU        // Take every 10th (A) char in this string, starting at index <input> (U).

令人尴尬的是，Japt缺乏将字符串拆分为长度X的切片的内置函数。但是，它确实具有用于获取每个Xth字符的内置函数，因此我们可以通过先对所有顶行进行编码然后存储所有数据，然后对这些数据进行存储所有第二行，依此类推

现在，我们有了5位数字字符串，对我们要创建的数字进行编码，例如32223for 0。

q mX{2839s2 ë4X} qR
q                    // Split the resulting string into chars.
  mX{          }     // Replace each char X with the result of this function:
     2839s2          //   Convert the magic number 2839 to a binary string.
            ë4X      //   Take every 4th char of this string, starting at index X.
                 qR  // Join the result with newlines.

要解释魔幻数字，请参考四个不同的行。如果更换#用1和 用0，你会得到

100
001
101
111

对此进行转置，然后合并为单个字符串，可以提供给我们101100010111。转换为小数，voilà，您将获得2839。反转过程将映射到数字0123到上面显示的四个二进制行中。

快完成了！现在剩下要做的就是添加空格和数字：

d0S1U      // In the resulting string, replace 0 with " " (S) and 1 with <input> (U).

并且，隐式输出将处理其余部分。很抱歉，这个解释太长了，但是在不使它难以理解的情况下，我看不出有任何真正的高尔夫方法（如果可以理解的话...）

的JavaScript（ES6），115个 111字节

将输入作为字符串。

n=>'02468'.replace(/./g,c=>(n+n+n+`   ${n} `+n).substr([126,341,36,68,327.5,66,98,340,102,70][n]*4>>c&6,3)+`
`)

怎么运行的

模式编码

这四个不同的模式"XXX"，"X.."，"..X"和"X.X"可被压缩为"XXX...X.X"与提取的这种方式：

XXX...X.X
^^^        --> XXX  (id = 0 / pointer = 0)
  ^^^      --> X..  (id = 1 / pointer = 2)
    ^^^    --> ..X  (id = 2 / pointer = 4)
      ^^^  --> X.X  (id = 3 / pointer = 6)

通过将输入数字替换n为"X"并使用实际空格，可以得到表达式：

n+n+n+`   ${n} `+n

数字编码

使用上面定义的模式标识符，每个数字可以由5 * 2 = 10位的数量表示。

例如：

XXX  -->  0 *   1 =   0
X.X  -->  3 *   4 =  12
XXX  -->  0 *  16 =   0
..X  -->  2 *  64 = 128
XXX  -->  0 * 256 =   0
                    ---
                    140

完整列表是：

[252, 682, 72, 136, 655, 132, 196, 680, 204, 140]

但是，将这些值除以2可以节省两个字节。因此，我们存储：

[126, 341, 36, 68, 327.5, 66, 98, 340, 102, 70]

演示版

let f =

n=>'02468'.replace(/./g,c=>(n+n+n+`   ${n} `+n).substr([126,341,36,68,327.5,66,98,340,102,70][n]*4>>c&6,3)+`
`)

console.log(f('0'))
console.log(f('1'))
console.log(f('2'))
console.log(f('3'))
console.log(f('4'))
console.log(f('5'))
console.log(f('6'))
console.log(f('7'))
console.log(f('8'))
console.log(f('9'))

Bash + GNU utils，114

• @SophiaLechner节省了2个字节

这里可能还有更多压缩的机会，但这是一个开始：

dc<<<4o16iEAC00CDF33AC373DEF00EEFB3p|fold -5|sed "$[$1+1]!d
s/0/  x\n/g
s/1/x\n/g
s/2/x x\n/g
s/3/xxx\n/g
y/x/$1/"

说明

每个数字的每一行都是以下四种模式之一：

  x
x
x x
xxx

通过标记这些0-3，每个数字可以用5个基数4的数字表示。例如0将会是32223，数字的完整列表在base-4中被编码为32223000003031330303223003130331323300003232332303。这用十六进制编码为EAC00CDF33AC373DEF00EEFB3。

• dc将十六进制转换EAC00CDF33AC373DEF00EEFB3为4 进制。
• fold 每行放置5个基数4位数字
• sed：
  • 删除行号为n + 1的所有输入行（sed 1索引行）
  • x将给定数位的每一行的基数4位数转换为（es）的模式，以及每行末尾的换行符
  • 将xes 音译为数字n。

在线尝试。

MATL，45 43字节

'V~4;LR`I-D2q (z%eI)P-nc'F TFZa15eiZ)5eGV*c

在线尝试！

说明

'V~4;LR`I-D2q (z%eI)P-nc' % Compressed string using printable ASCII except '
F TFZa                    % Decompress (change of base) into alphabet [1 0]
15e                       % Reshape into 15-row matrix. Each column contains the
                          % art for one digit, packed in column-major order
iZ)                       % Take input number and pick the corresponding column.
                          % Indexing is 1-based and modular, so 0 is at the end
5e                        % Reshape into a 5-row matrix. This already looks like
                          % the number, with active pixels as 1 and inactive as 0
GV                        % Push input number again. Convert to string, of one char
*                         % Multiply, element-wise. The previous char is
                          % interpreted as its ASCII code. This changes 1 into the 
                          % ASCII code of the input digit, and leaves 0 as is
c                         % Convert to char. Implicitly display. Char 0 is shown as
                          % a space

视网膜，166个 164 163字节

底部第三行的两个空格

0
0addda
d
0 0
1
1b1b1b1b1b1
2
2ab2a2b222
3
3ab3ab3a
4
44 44 4ab4b4
5
55ab555b5a
6
66ab6a 6a
7
7ab7b7b7b7
8
88a 8a8 8a
9
99a 9ab9a
(\d)a
$1$1$1$1
^.

b
  
.{3}
$+¶

在线尝试！

@Okx解决方案的改进版本

Pyth 82 85 91 100字节

Km?dC+48Q\ m.&C@"w$kn<^_d\x7f~"Qdj1906486293414135453684485070928 128V5p.)Kp.)K.)K

我第一个挑战就是可能打很多高尔夫球。

批处理文件，8 + 184字节

这是我的强制性批处理解决方案。不幸的是，完成此操作的标准方法是分批处理超过300个字节，因此我们采用了便宜得多的策略。

@type %1

在当前目录中，我设置了10个文件，从0到9命名。每个文件都是各自的5x3像素网格。例如：

这些字节数为：

19 0
19 1
17 2
19 3
19 4
17 5
17 6
19 7
19 8
19 9
Total - 184

仍然击败Java。

Ruby，94个字节

->n{20.times{|i|print i%4>2?$/:[" ",n]["_Q_@@_]UWUU_GD_WU]_U]AA__U_WU_"[n*3+i%4].ord>>i/4&1]}}

取消测试程序

f=->n{
  20.times{|i|                           #4 characters * 5 rows = 20
    print i%4>2?$/:                      #If i%4=3 print a newline else
    [" ",n][                             #either a space if the expression below is 0 or the digit n if 1.
      "_Q_@@_]UWUU_GD_WU]_U]AA__U_WU_"[  #bitmap data for digits, one character for each column
        n*3+i%4].ord>>i/4&1              #Select the correct character for the column, convert to ascii code,
    ]                                    #rightshift to find the correct bit for the row, 
  }                                      #use & to isolate the bit: 0 or 1
}

f[gets.to_i]

PHP，115字节

for(;$i<5;)echo strtr(sprintf("%03b\n","1754"[[425,0,465,273,26,285,413,1,409,281][$argn]/4**$i++%4]),[" ",$argn]);

在线尝试！

展开式

for(;$i<5;)
  echo strtr(
    sprintf("%03b\n",  # make a binary
      "1754"[[425,0,465,273,26,285,413,1,409,281][$argn]/4**$i++%4])
    ,[" ",$argn]); # replace 0 with space and 1 with the input

编码 在线尝试！

视网膜，125字节

.
A$&¶B$&¶C$&¶D$&¶E$&
([ACE][235689]|A0|E0|C4|A7)(?<=(.))
$2$2$2
(B[0489]|D[068]|A4|C0)(?<=(.))
$2 $2
D2
2
B5
5
B6
6
[A-E]
  

在线尝试！（删除标题中的测试套件以测试各个输入数字。）最后一行包含两个空格。

PowerShell中，126 120 113 109 101

$n="$args"
-split'ϽϭϿ·ͱ Ο·ͽͼϿ·Ņ ϻ·ͭͭϿ'|%{-join($_[0..2]|%{"$n·"[!($_-band1-shl$n)]})}

Unicode很有趣。字符也比数字短。上面的代码包含U + 0000两次，因此不能直接复制（尽管可以在文件中正常工作）。可以复制以下代码：

$n="$args"
-split"ϽϭϿ ͱ`0Ο ͽͼϿ Ņ`0ϻ ͭͭϿ"|%{-join($_[0..2]|%{"$n "[!($_-band1-shl$n)]})}

我们丢失了三个字节，因为在开始时需要UTF-8签名。否则，该字符串将不起作用。

视网膜，190字节

0
000¶aaa000
a
0 0¶
1
aaaaa
a
b1¶
2
ab2¶a2¶a
a
222¶
3
ab3¶ab3¶a
a
333¶
4
4 4¶4 4¶444¶b4¶b4
5
a5b¶ab5¶a
a
555¶
6
a6¶a6 6¶a
a
666¶
7
777aaaa
a
¶b7
8
a8 8¶a8 8¶a
a
888¶
9
a9 9¶ab9¶a
a
999¶
b
  

最后一行有两个空格，但是SE不想渲染它：/已修复！

在线尝试！

爪哇8，278个 214 210 204字节

n->("A"+n+"\nB"+n+"\nC"+n+"\nD"+n+"\nE"+n).replaceAll("([ACE][235689]|A0|E0|C4|A7)(?<=(.))","$2$2$2").replaceAll("(B[0489]|D[068]|A4|C0)(?<=(.))","$2 $2").replaceAll("D2|B5|B6",n).replaceAll("[A-E]","  ")

的港口 @Neil的Retina答案的。将输入作为String。

在这里尝试。

Python 2中，174个是125字节

lambda n:'\n'.join('xxx  x x'[int(i):][:3]for i in oct(0x3028000adba93b6b0000c0ad36ebac30180c0)[:-1][n::10]).replace('x',`n`)

在线尝试！

PowerShell中，159个 135 128 118字节

param($n);0..4|%{("$n$n$n","$n $n","  $n","$n  ")['01110333330203002020110220302003010022220101001020'[$_+($n*5)]-48]}

当前答案：删除无关的变量命名

在线尝试！

我必须看看我是否可以从其他答案中得到一些技巧：P

编辑通过调用兆字符串变得更聪明

EDIT2切换为使用数字字符串索引$a以节省7个字节。尽管我喜欢下面的代码（135个字节）中以前的动态变量名称调用

param($n);$a="$n$n$n";$b="$n $n";$c="  $n";$d="$n  ";$r="abbbadddddacadaacacabbaccadacaadabaaccccababaabaca";0..4|%{gv $r[$_+($n*5)]-v}

木炭，61 38字节

Ｅ§⪪”{⊞¶↙⬤\→*'K«-aRＱ¹νÀ⁰”⁵Ｎ⭆421⎇＆ＩιＩλθ 

在线尝试！链接是详细版本的代码。注意：尾随空格。说明：

Ｅ§⪪”{⊞¶↙⬤\→*'K«-aRＱ¹νÀ⁰”⁵Ｎ

将（压缩的）字符串分成5组，在输入给定的索引处取一个，然后映射组中的字符（始终为1、4、5或7）。

⭆421⎇＆ＩιＩλθ 

使用输入的字符和空格作为数字，将字符从10位转换为3位2位。然后将5个结果隐式打印在单独的行上。

通用端口有点无聊，所以这是一个更加惯用的61字节答案：

ＧＨ✳✳§⟦⟦↑L↓¬⟧⟦↓↓⟧⟦T↓→⟧⟦T→¬⟧⟦↑↑¬↑⟧⟦←↓T⟧⟦T↑L⟧⟦→↓↓⟧⟦+L↓⟧⟦+↓T⟧⟧Ｎ³θ

在线尝试！没有详细的版本，因为分解器无法理解普通多边形内的方向甚至多方向列表。说明：

     ⟦...⟧      Array of paths, see below
          Ｎ     Input as an integer
    §           Index into the array
  ✳✳            Treat the element as direction data
           ³    Length of each segment (including 1 character overlap)
            θ   Draw using the input character
ＧＨ              Draw a path

每个路径都是使用方向列表（←↑→↓）指定的。四个可用的快捷方式保存字节：Lpresents ↑→，¬presents ↓←，Tpresents，→↓←while，+presentations →↓←↑，尽管必须至少保留一个箭头才能将该列表识别为方向列表（例如TT，不能用于3）。

果冻，35 32字节

Ṿ⁶,“SÐ~ẈoI9Ẇ¦Y./,0&Ƥɓ€ọ’ṃs15ị@s3

在线尝试！或全部看到它们。

与dzaima的方法相同。

Perl -Mbigint -pa 5，101个字节

$_=sprintf"%16b",0xf79ef7dee492f3def39eb792e79ee7ce4924f6de>>16*$_&65535;eval"y/01/ @F/";s/...\K/\n/g

在线尝试！

Python 3，119字节

lambda n:(3*f"%s%s{n}\n%s %s\n")[:30]%(*[n if i//(2**n)%2else" "for i in[1021,1005,881,927,893,892,325,1019,877,877]],)

在线尝试！

每个“像素”均表示为整数，其中每个2的幂表示像素是否为实心。这利用了三个右上角始终是数字的事实。

JavaScript（ES8），87个字节

n=>`019
2 3
459
6 7
889`.replace(/\d/g,c=>[2,18,142,96,130,131,698,4,146][c]>>n&1?' ':n)