对于诸如Output的长度与代码相同的挑战以及Create output的长度是代码长度的两倍的挑战，我想到了一个单独的但相似的挑战。

任务是产生输出。它可以是字符串，字符列表，也可以是程序的默认输出格式。但是，无论输入如何，您的输出必须始终为相同的长度。更重要的是，对于不同的输入，输出应该是不同的。

输入项

单个整数$n$，其范围由语言选择确定。如果您的语言具有可变长度整数，范围是$-2^{31} \leq n < 2^{31}$。

输出量

字符串或字符列表，或打印到STDOUT或STDERR。您只能使用以下方法之一。无论输入如何，输出都应具有相同的长度，但是由您决定是哪个长度。输出中可能不包含数字字符0-9或减号-。输出应该是确定性的。

您应该能够通过形式证明，自变量或蛮力搜索来证明每个输出只有一个可能的输入。

这是一个代码问题，因此请删除所有多余的字节。欢迎所有语言，越多越好！

JavaScript（ES8），33个字节

预计的范围内的输入安全 JS整数：$-2^{53}\le n < 2^{53}$。

返回76个字符的字符串。

n=>btoa(n.toString(2)).padEnd(76)

在线尝试！

怎么样？

步骤1

输入首先转换为二进制。这将保留负数的前导负号。

例子：

• 123 → "1111011"
• -77 → "-1001101"

第2步

结果字符串以base-64编码。

这意味着每个1到3个字符的块将变成一个新的4个字符的块。这种转换是安全的，因为结果块中都不包含禁止的符号（数字或减号）。

3个字符的块

"-10" -> "LTEw" | "011" -> "MDEx"
"-11" -> "LTEx" | "100" -> "MTAw"
"000" -> "MDAw" | "101" -> "MTAx"
"001" -> "MDAx" | "110" -> "MTEw"
"010" -> "MDEw" | "111" -> "MTEx"

如果二进制字符串的长度不是3的倍数，则必须对单个1或2个字符的最终块进行编码：

1个字符的块

"0"   -> "MA==" | "1"   -> "MQ=="

2个字符的块

"-1"  -> "LTE=" | "10"  -> "MTA="
"00"  -> "MDA=" | "11"  -> "MTE="
"01"  -> "MDE=" | 

第三步

最终输出用尾随空格填充。

Python 3中，49 39个字节

lambda i:[chr(ord(x)*2)for x in"%9x"%i]

在线尝试！

-10字节归功于负七

将整数转换为十六进制，并在空格前最多添加9个字符。然后，将字符串中每个字符的ASCII码加倍（有些扩展到ASCII之外，变成了Unicode，但是Python可以很好地处理），输出一个字符列表。

之所以可行，-是因为每个数字（包括）都映射到不同的ASCII字符。-2147483648和之间没有整数2147483648相等，因此将它们转换为十六进制和前置空格将不会使它们相等。然后，将它们映射到不同的代码点不会导致冲突，因此在该范围内仍然没有两个值导致相等的输出。

Python 3中，59个 56 47字节

lambda i:[*map(lambda x:chr(ord(x)*2),"%9x"%i)]

在线尝试！

-3个字节，感谢Jitse

-9字节归功于负七

相同的算法，但使用map而不是for循环。

05AB1E，11 5 字节

тjÇ·ç

-6个字节移植@Stephen的方法，因此请确保对他进行投票！

$100-(\text{input length})$@-0123456789Z`bdfhjlnpr

在线尝试。

说明：

 j     # Prepend spaces in front of the (implicit) input-integer to make it of length:
т      # 100
  Ç    # Convert each character to its unicode value
   ·   # Double each
    ç  # And convert it back to a character
       # (after which the resulting list is output implicitly)

原始的11 个字节的答案：

Ķ×AIdè«žIj

在线尝试（仅限于，1000而不是2147483648）。

说明：

$2147483648-|n|-1$$|n|$$n\lt0$$n\geq0$

Ä            # Get the absolute value of the (implicit) input-integer
 ¶×          # And have a string with that many newline characters
   A         # Push the lowercase alphabet
    Id       # Check if the input is non-negative (>=0) (1 if truthy; 0 if falsey)
      è      # Use that to index into the alphabet (so "a" for <0 and "b" for >=0)
       «     # Append that to the newline-string we created earlier
          j  # And prepend spaces to make the string of a length:
        žI   # 2147483648 (this has been replaced with `₄`/1000 in the TIO)
             # (after which the result is output implicitly)

brainfuck，48 29 28 16 13字节

$c_n \in \mathbb{N}$$c_n < 256$

$-\infty \lt n \lt \infty$$\infty$

这个答案有点挑战，因为它没有说明输出必须是有限的。

+[,[->-<]>.+]

在线尝试！

28字节原始答案：

->,[[->-<]>.[-]<<->,]<[<.>-]

$2^8 - 1$

Python 3，39个字节

lambda n:f"{n:33b}".translate("abc"*99)

在线尝试！

将给定的数字转换为二进制字符串表示形式（用空格填充），然后使用函数将字符映射(space)-01到。caabstr.translate

果冻，4 字节

œ?ØẠ

一个接受整数的单子链接，该整数产生52个字符的列表。

$-2^{223} \leq n \lt 2^{223}$$52!>2^{224}$

在线尝试！

怎么样？

œ?ØẠ - Link: integer, n
  ØẠ - alphabet (Jelly's longest built-in character list containing no digits
     -           or hyphen) = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
œ?   - permutation at index (n) if all 52! permutations were written out
     - in lexicographical order.
     - This indexing is modular so when n = -x we fetch the (52!-x)th entry.

所以...

-2147483648 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONIGCDAMLJKFEHB
-2147483647 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONIGCDAMLJKFHBE
-2147483646 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONIGCDAMLJKFHEB
-2147483645 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONIGCDAMLJKHBEF
    ...
         -4 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDACB
         -3 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDBAC
         -2 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDBCA
         -1 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCAB
          0 zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA
          1 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
          2 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxzy
          3 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwyxz
          4 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwyzx
    ...
 2147483644 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmrtxwznoqpsvyu
 2147483645 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmrtxwznoqpsyuv
 2147483646 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmrtxwznoqpsyvu
 2147483647 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmrtxwznoqpusvy

红宝石，27个字节

->n{('%34b'%n).tr'01','ah'}

在线尝试！

('%34b'%n)将整数转换为二进制表示形式，..1用于表示负数（表示无限长的前缀1s），并使用空格将其左填充为34个字符。然后，将0s 替换为“ a”，将1s替换为“ h”以创建Maniacal Base 2表示形式：诸如“ haaahahahaaha”之类的字符串，有时带有空格..。由于此处的每个步骤都是可逆的，因此这是1：1。

编辑：让记录显示@manatwork首先发布了相同的解决方案。哎呀。我应该刷新了。

果冻，6个字节

Ø%+ṃØA

在线尝试！

$±2^{31}$$2^{32}$

C（gcc），38个字节

f(a,i){for(i=32;i--;putchar(a>>i&1));}

在线尝试！

这会将输入整数的每一位扩展为0或1（都是不可打印的字符，但没有针对此的规则）的字节。因此输出始终为32个字节，并保证是唯一的。

C＃（Visual C＃交互式编译器），35字节

x=>$"{x,11}".Select(n=>(char)(n+n))

在线尝试！

Haskell，31个字节

map(\d->[d..]!!10).show.(+2^60)

在线尝试！

添加2^60到输入中，以使所得的数字在整个输入范围内具有相同数量的数字。变成一个字符串，然后将每个字符按ASCII顺序（0-> :...- 9> C）右移10个位置。

C＃（Visual C＃交互式编译器），52字节

x=>(new char[32]).Select(y=>(char)(x%2+65+(x/=2)*0))

在线尝试！

ac＃解决方案的不同方法利用了以下事实：对于负数，c＃模数为负。我想如果允许不显示字符（'\ 0'，依此类推），可以通过更新，+65...使字符值不偏移到人类可读的范围内，从而减少一两个字节。

Perl 5、23 -MDigest::MD5=md5_hex -p个字节

$_=md5_hex$_;y/0-9/k-t/

在线尝试！

先前：

Perl 5，29 -p个字节

$_=sprintf'%064b',$_;y/01/ab/

在线尝试！

数转换为它的64位二进制表示，则音译0和1向a和b分别。

T-SQL，73 70 61字节

SELECT TRANSLATE(STR(n,11),'-0123456789','ABCDEFGHIJK')FROM t

-在STR将整数填充为11个字符之后，我只是用字母直接替换数字（和）。无需转换为十六进制或二进制。

TRANSLATE 是在SQL 2017中引入的。

$t$$n$INT$-2^{31} \leq n < 2^{31}$

编辑：通过将手动填充替换为CHAR（11）转换，节省了3个字节，这是一种固定宽度的字符格式，会自动填充空格。

编辑2：使用函数代替节省9个字节。将数字转换为填充为指定长度的文本字符串。STR()CASTSTR

APL（Dyalog Unicode），28字节

{11↑' Z'[⍵≤0],⎕A[⍎¨'¯'~⍨⍕⍵]}

在线尝试！

简单的Dfn，采用整数参数。用途⎕IO←0。

TIO链接到一个测试案例-2^10来2^10。该0~⍨部分0从参数中删除重复项。

怎么样：

{11↑' Z'[⍵≤0],⎕A[⍎¨'¯'~⍨⍕⍵]} ⍝ Dfn
              ⎕A[         ]  ⍝ Index the Uppercase Alphabet with
                        ⍕⍵   ⍝ String representation of the argument
                   '¯'~⍨     ⍝ Without the character ¯
                 ⍎¨          ⍝ Executing each digit back into integers
             ,               ⍝ Prepend
    ' Z'[   ]                ⍝ A character from the string ' Z' indexed by
         ⍵≤0                 ⍝ Argument ≤ 0. Returns 1 if true, else 0.
                             ⍝ This will prepend a whitespace to positive numbers, and a Z otherwise.
 11↑                         ⍝ Take the first 11 characters, padding with whitespace.

Japt，6个字节

我认为这是对的。受到Stephen的Python解决方案的启发，所以请+1他。

¤ùI cÑ

试试吧

¤ùI cÑ     :Implicit input of integer
¤          :Convert to binary string
 ù         :Left pad with spaces
  I        :  To length 64
    c      :Map codepoints
     Ñ     :  Multiply by 2

Malbolge，2708字节

$\infty$

bP&A@?>=<;:9876543210/.-,+*)('&%$T"!~}|;]yxwvutslUSRQ.yx+i)J9edFb4`_^]\yxwRQ)(TSRQ]m!G0KJIyxFvDa%_@?"=<5:98765.-2+*/.-,+*)('&%$#"!~}|utyrqvutsrqjonmPkjihgfedc\DDYAA\>>Y;;V886L5322G//D,,G))>&&A##!7~5:{y7xvuu,10/.-,+*)('&%$#"yb}|{zyxwvutmVqSohmOOjihafeHcEa`YAA\[ZYRW:U7SLKP3NMLK-I,GFED&%%@?>=6;|9y70/4u210/o-n+k)"!gg$#"!x}`{zyxZvYtsrqSoRmlkjLhKfedcEaD_^]\>Z=XWVU7S6QPON0LKDI,GFEDCBA#?"=};438y6543s1r/o-&%*k('&%e#d!~}|^z]xwvuWsVqponPlOjihgIeHcba`B^A\[ZY;W:UTSR4PI2MLKJ,,AFE(&B;:?"~<}{zz165v3s+*/pn,mk)jh&ge#db~a_{^\xwvoXsrqpRnmfkjMKg`_GG\aDB^A?[><X;9U86R53ONM0KJC,+FEDC&A@?!!6||3876w4-tr*/.-&+*)('&%$e"!~}|utyxwvutWlkponmlOjchg`edGba`_XW\?ZYRQVOT7RQPINML/JIHAFEDC&A@?>!<;{98yw5.-ss*/pn,+lj(!~ff{"ca}`^z][wZXtWUqTRnQOkNLhgfIdcFaZ_^A\[Z<XW:U8SRQPOHML/JIHG*ED=%%:?>=~;:{876w43210/(-,+*)('h%$d"ca}|_z\rqYYnsVTpoRPledLLafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(DCB%@?"=<;|98765.3210p.-n+$)i'h%${"!~}|{zyxwvuXVlkpSQmlOjLbafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(D'%A@?"=<}:98y6543,1r/.o,+*)j'&%eez!~a|^tsx[YutWUqjinQOkjMhJ`_dGEaDB^A?[><X;9U86R53O20LKJ-HG*ED'BA@?>7~;:{y7x5.3210q.-n+*)jh&%$#"c~}`{z]rwvutWrkpohmPkjihafI^cba`_^A\[>YXW:UTS5QP3NM0KJ-HGF?D'BA:?>=~;:z8765v32s0/.-nl$#(ig%fd"ca}|_]yrqvYWsVTpSQmPNjMKgJHdGEa`_B]\?ZY<WVUTMR5PO20LK.IHA))>CB%#?87}}49zx6wu3tr0qo-nl*ki'hf$ec!~}`{^yxwvotsrUponQlkMihKIe^]EEZ_B@\?=Y<:V97S64P31M0.J-+GFE(C&A@?8=<;:{876w43s10qo-&%kk"'hf$ec!b`|_]y\ZvYWsVTpSQmlkNiLgf_dcba`C^]\?ZY;WV97SLK33HM0.J-+G*(D'%A$">!};|z8yw543t1r/(-,+*)(i&%fd"!~}|_t]xwvutslqTonmPkjLhKIeHFbEC_^A?[TSX;9UT7R4JIN1/K.,H+)E(&B%#?"~<}{987x/4ussr)p-,m*)ihh}$#d!awv{^\x[YuXVrUSonQlNdchKIeHFbaD_AWV[><X;988MRQ4O1GFK.,++@ED'B$:9>!};:9zy0wuut1*/p-,mk#"hh}$#"cb}v{^\\[vunWrqTonmOkjMLgf_HcbE`_A]@>ZY<:VONS64P31M0.J-+G*(D'%A$">!}||3876wv321*/p-,mk#"'hf$ec!b`|{^y[qpuXVUUjonQOkdchKIeHFbEC_B@\?=Y<:VUT76QPONG0KJ-HGFED'%A:9!!6;:9zy654321*q.-n+*j(ig%fd"ca}`^]]rwvYtVlkpSQmPNMMbgfIdF\[`_^A@[ZYXWVUNS6443NMLKJIHG@)DC&A@?!=<}|98765432+r/.-,+k#('&%e{dy~}|uzsx[vuXsrqpoRPledLLafedGF[`C^]\?ZY;W:8T7544INM0.JCBG*(''<A@#!=65:{yxx/43tr0)(-nlkk"'&ge#zy~a_^^sxwZXtmlqTRQQfkjMKg`_dcbEZ_B]\?=SRW:8T75Q42N1/KJ-+G@?D'%A$">!};|z87x5u-,1rp.-n+k#"'hfeez!~}`_t]xwvYtsUTTinmPNjcbgJHdGEa`_BW\?ZY<WVUTS64PIH00EJIH+*?(&&;@#!!~5:{87xv.-2sq/.om+$#(ig%$e"bxw|_]y\ZvuXsUkjoRPOOdihKfH^]bEC_^A\>TS;;PUTS65JO2MLK.,BA))>CBA$9>!}}|3z765v32r0/p-m%$)jh&ge#"c~`vuz][ZZotsVqSihmPNMMbgfIdF\[`CA@@UZY<W9ONS6433HML/J,BAF)'&&;@?"=}549zx6wutt+0/.on%l)('h%$d"ca}`^z][wvYtVlkpSQmPNjiLJf_^cFDCCX]\?=YRQV9766KPO20LEDI,*))>CB%#?87<}{9zx6wu3tr0/.o&m*)('&%fA/cQ>_^;]87%54"32pRA-yejih:s_GGFDDC^{i[T<XQ9b8r_5]O20Li-zB*SdQPO%##]nml43V1TvS@cs0/_'JJH#jhg%BTd!xw_{t99J6$tV21SBR@?kjcbtJ%^F"DD21]@[xfw;)9Nqq5Jmm~LKWVyx@E't&%:]][~YkF8hgv.tssOMp:&ml6Fi&D1T"y?,O<^s\7vX#Wr2}|Rzl+j<bK`r$F"4ZCk|\?-=RQ

在线尝试！

Perl 6、12个字节

*~|('@'x 11)

在线尝试！

匿名接受数字并将其与11或进行字符串运算的任何lambda @。这会将数字映射到pqrstuvwxy，将破折号映射到m，然后使用@s 将字符串填充为11个字符

Perl 5（-p），9个字节

$_^=A x$=

在线尝试！

输入字符串的bitwxise-xor AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA。

Wolfram语言（Mathematica），44 33字节

Echo@Table[Or[i>#+13!,],{i,14!}]&

尝试使用较小的域

-2感谢Greg Martin

>> $13!+n$ NullTrue$14!$$[-13!,14!-13!)$$[-2^{31},2^{31})$

$[-2^4,2^4)$

Stax，6个字节

11){Hm

运行并调试

程序：

1. 左键盘输入为11个字符。
2. 将每个非空格ASCII字符加倍。

PHP，64 54字节

通过使用strtr功能代替手动字符替换为-10个字节。

<?=str_pad(strtr($argn,'-0123456789',ADEFGHIJKLM),20);

在线尝试！

最大可能的INT在PHP截至目前值是9223372036854775807其为19位长，考虑到负数减号，这将是20以上内容替换减号（该代码-与）A字符和每个数字从0到9与从字符D到M然后在右边用空格字符填充字符串，使其始终长20个字符。例如，输出为输入-9876543210是 "AMLKJIHGFED "。

输出是每个整数输入唯一的，你可以通过删除所有的空格，替换回去的输入A与-和更换D，以M与0对9。

PHP，44字节

<?=str_pad(base64_encode(decbin($argn)),88);

在线尝试！

这和Arnauld的答案是一样的。将输入转换为二进制，然后将其转换为base-64。还要将其填充为88个字符（最大长度为-922337203685477580788个字符），并在右边添加空格以始终在输出中获得相同的长度。

视网膜0.8.2，21字节

T`p`l
$
10$*o
!`.{11}

在线尝试！始终输出从范围11个字符n.. z。说明：

T`p`l

将可打印的ASCII字符转换为小写字母。该地图-以n和0.. 9到q.. z。（非常幸运的是，这些数字是可打印的ASCII字符的第16至25位！）

$
10$*o

追加10 os。由于输入将包含1至11个字符，因此现在包含11至21个字符。

!`.{11}

提取前11个字符。由于少于22个字符，因此只能匹配一次。

木炭，9字节

◧⍘﹪ＮＸχχαχ

在线尝试！链接是详细版本的代码。始终输出10个空格和大写字母。说明：

   Ｎ        Input as a number
  ﹪         Modulo
     χ      10
    Ｘ       To power
      χ     10
 ⍘     α    Convert to base 26 using uppercase letters
◧       χ   Left pad to length 10

R，37个字节

set.seed(scan())
cat(sample(LETTERS))

在线尝试！

$26!=4\cdot 10^{26}$

$2^{32}\approx 4\cdot 10^9$$4\cdot 10^{26}$$10^{-17}$$2^{32}$

$1-\exp(-2^{64}/26!)\approx0.99999998$

对我来说足够接近1

Brainfuck，20 19字节

-1个字节，感谢Krzysztof Szewczyk

-[>,[->-<]>.[-]<<-]

在线尝试！

输出将每个数字和破折号映射为255减去序数值的数字，并用NUL字节填充为255个字符。

R，40 37字节

cat(gsub("S","",intToBits(scan())>0))

在线尝试！

罗宾·赖德的答案的替代方案；这当然是确定性的。

这会将输入转换raw为32个字节的向量，每个字节为一个十六进制数字00或01代表整数的位。然后，我们强迫的logical，通过比较0，因此00被映射到FALSE和01到TRUE。然后，我们需要从每个字母中删除一个字母FALSE以保证等长输出，可以任意选择为S。结果打印（带有空格）的长度为169。

Zsh，43个字节

for c (${(s::)${(l:30::0:)1}})echo \\x$[#c]

               ${(l:30:0:)1}                 # left-pad with zeroes to 30 characters
        ${(s::)             }                # split characterwise
 for c (                     )               # for each character
                                      $[#c]  # get character code (in decimal)
                              echo \\x$[#c]  # interpret as hex code, print (with newline)

在线尝试！

该解决方案long long通过仅处理字符来绕过Zsh整数的限制。为了便于阅读，我仅将其填充了30个字符，但是将其替换30为99可使该方法适用于从-1E99+1到的所有数字1E100-1。

将十进制代码解释为十六进制的效果如下：

0 => 48 => H    1 => 49 => I    2 => 50 => P    3 => 51 => Q
4 => 52 => R    5 => 53 => S    6 => 54 => T    7 => 55 => U
8 => 56 => V    9 => 57 => W    - => 45 => E

Zsh，46个字节

integer -i2 -Z66 x=$1
<<<${${x//[02-]/a}//1/b}

在线尝试！

将x声明为二进制数，将其零填充到宽度66。然后映射0→ a和1→ b。我们还映射2和-一个，因为这些字符在印刷[[-]][base]#[num]符号。要查看$x替换前的外观以及解析整数类型时Zsh的限制，请检查TIO链接中的“调试”输出。

Java（JDK），42个字节

n->"".format("%8x",n).chars().map(i->i|64)

在线尝试！

首先，这将创建输入的十六进制表示，并用空格左填充，以提供相同的长度约束（8个字符长），删除负号，并使每个中间输出保持唯一。

这给出了一个字符串，其中包含17个可能的字符：0123456789abcdef和空格。

然后，通过在其代码点上添加64（如果是数字或空格）来传输和映射每个字符。有效地，这会导致以下映射：0123456789abcdef<space>以pqrstuvwxyabcdef`具有17个不同的字符，因此，没有两个数将导致相同的输出。

Bash，30个字节

echo $1|md5sum|tr '0-9-' 'A-K'

在线尝试！

$-2^{31}$$2^{31}$