ด้วยความท้าทายเช่นเอาท์พุทที่มีความยาวเท่ากันกับรหัสและสร้างผลลัพธ์ที่มีความยาวเป็นสองเท่าของรหัสฉันคิดว่าเป็นเรื่องท้าทาย แต่ก็คล้ายกัน

ภารกิจคือสร้างเอาต์พุต มันอาจเป็นสตริงรายการของตัวละครหรืออะไรก็ตามที่เป็นรูปแบบเอาต์พุตเริ่มต้นของโปรแกรมของคุณ อย่างไรก็ตามเอาต์พุตของคุณจะต้องมีความยาวเท่ากันเสมอไม่ว่าอินพุตจะเป็นเท่าใด และที่สำคัญกว่าการส่งออกควรจะแตกต่างกันสำหรับปัจจัยการผลิตที่แตกต่างกัน

อินพุต

จำนวนเต็มเดียว$n$ช่วงที่พิจารณาจากการเลือกภาษา หากภาษาของคุณมีจำนวนเต็มความยาวผันแปรช่วงคือ$-2^{31} \leq n < 2^{31}$วันที่ 31

เอาท์พุต

สตริงหรือรายการของตัวละครหรือพิมพ์ไปยัง STDOUT หรือ STDERR คุณสามารถใช้หนึ่งในวิธีการเหล่านี้เท่านั้น เอาต์พุตควรมีความยาวเท่ากันโดยไม่คำนึงถึงอินพุต แต่ก็ขึ้นอยู่กับคุณที่จะกำหนดความยาวที่เป็น การส่งออกอาจไม่ประกอบด้วยอักขระหลัก0-9-หรือเครื่องหมายลบ เอาต์พุตควรถูกกำหนดไว้

คุณควรจะสามารถพิสูจน์ได้ว่าสำหรับทุกผลลัพธ์มีเพียงหนึ่งอินพุตที่เป็นไปได้ไม่ว่าจะโดยการพิสูจน์อย่างเป็นทางการการโต้แย้งหรือการค้นหาที่โหดร้าย

นี่เป็นคำถามเกี่ยวกับการเล่นกอล์ฟดังนั้นควรกำจัดไบต์ที่ไม่เกี่ยวข้องออกไป ยินดีต้อนรับทุกภาษายิ่งดียิ่งขึ้น!

JavaScript (ES8), 33 ไบต์

คาดว่าอินพุตในช่วงของจำนวนเต็ม JS ที่ปลอดภัย : $-2^{53}\le n < 2^{53}$ 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"

บล็อกสุดท้ายของ 1 หรือ 2 ตัวอักษรจะต้องได้รับการเข้ารหัสหากความยาวของสตริงไบนารีไม่ได้เป็นหลายเท่าของ 3:

บล็อก 1 ตัว

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

บล็อก 2 ตัวอักษร

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

ขั้นตอนที่ 3

ผลลัพธ์สุดท้ายจะถูกเสริมด้วยช่องว่างต่อท้าย

Python 3 , 49 39 ไบต์

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

ลองออนไลน์!

-10 ไบต์ขอบคุณที่ลบเจ็ด

แปลงจำนวนเต็มเป็นเลขฐานสิบหกและเพิ่มช่องว่างรวมทั้งหมด 9 อักขระ จากนั้นดับเบิลโค้ด ASCII ของอักขระแต่ละตัวในสตริง (บางตัวขยายภายนอก ASCII ไปเป็น Unicode แต่ Python จัดการได้ดี) ส่งออกรายการอักขระ

สิ่งนี้ใช้ได้เพราะทุกหลักรวมถึง-ถูกแมปกับอักขระ ASCII ที่แตกต่างกัน ไม่มีจำนวนเต็มระหว่าง-2147483648และ2147483648เท่ากันดังนั้นการแปลงให้เป็นเลขฐานสิบหกและช่องว่างที่เตรียมไว้จะไม่ทำให้เท่ากัน จากนั้นการแมปไปยัง codepoints ที่แตกต่างกันจะไม่นำไปสู่การชนกันดังนั้นจึงไม่มีค่าสองค่าในช่วงที่นำไปสู่ผลลัพธ์ที่เท่ากัน

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 bytes porting วิธีการของ@Stephenดังนั้นอย่าลืม upvote เขา!

ส่งออกรายการได้สูงสุด 100 ตัวอักษรโดยมี$100-(\text{input length})$จำนวน@(เป็นสองเท่าของ codepoint อวกาศ) และ-0123456789แมปทั้งหมดZ`bdfhjlnpr (codepoints ASCII สองครั้ง)

ลองออนไลน์

คำอธิบาย:

 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)

คำอธิบาย:

ความยาวผลลัพธ์มีความยาว 2,147,483,648 อักขระเสมอ มันจะออก$2147483648-|n|-1$จำนวนช่องว่างต่อท้ายด้วย$|n|$ปริมาณของการขึ้นบรรทัดใหม่ท้ายด้วยทั้ง 'a' ถ้า$n\lt0$หรือ 'b' ถ้า$n\geq0$ 0

Ä            # 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ไปcaabด้วยstr.translateฟังก์ชั่น

เยลลี่ขนาด 4 ไบต์

œ?ØẠ

ลิงก์ monadic ยอมรับจำนวนเต็มซึ่งให้รายการของ 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

Ruby , 27 ไบต์

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

ลองออนไลน์!

('%34b'%n)แปลงจำนวนเต็มเป็นการแทนเลขฐานสองโดยใช้..1เพื่อระบุจำนวนลบ (ซึ่งหมายถึงการแสดงคำนำหน้ายาวไม่สิ้นสุดของ 1s) และใช้แผ่นด้านซ้ายเหลือ 34 อักขระโดยใช้ช่องว่าง จากนั้นเราก็มาแทนที่0S กับ 'a' และ1s ด้วย 'H' เพื่อสร้างฐานความบ้าคลั่ง 2 ตัวแทน: สตริงเช่น "haaahahahaaha" ..ใช้ได้กับพื้นที่และบางครั้ง เนื่องจากทุกขั้นตอนที่นี่กลับด้านนี่เป็น 1: 1

แก้ไข: ให้บันทึกแสดงให้เห็นว่า @manatwork โพสต์โซลูชั่นที่เหมือนกันนี้ก่อน อุ่ย ฉันควรจะรีเฟรช

Jelly, 6 bytes

Ø%+ṃØA

Try it online!

Since Jelly has arbitrary length integers, this monadic link takes an integer in the range $±2^{31}$ and returns a length 7 alphabetic string. It works by adding $2^{32}$ and then base decompressing into the capital letters.

C (gcc), 38 bytes

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

Try it online!

This expands each bit of the input integer into a byte that is either 0 or 1 (which are both unprintable characters, but there is no rule against that). So the output is always 32 bytes, and guaranteed to be unique.

C# (Visual C# Interactive Compiler), 35 bytes

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

Try it online!

Haskell, 31 bytes

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

Try it online!

Adds 2^60 to the input so that the resulting number has the same amount of digits for the whole input range. Turn into a string and shift each character 10 places to the right in the ASCII order (0 -> : ... 9 -> C).

C# (Visual C# Interactive Compiler), 52 bytes

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

Try it online!

Different approach to a c# solution, takes advantage of the fact that c# modulus is negative for negative numbers. I suppose you could shave off a byte or two if you allow non-display characters ('\0', and so on) by updating the +65... to not offset the character value to something human readable.

Perl 5 -MDigest::MD5=md5_hex -p, 23 bytes

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

Try it online!

Previously:

Perl 5 -p, 29 bytes

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

Try it online!

Converts the number to its 64 bit binary representation, then transliterates 0 and 1 to a and b, respectively.

T-SQL, 73 70 61 bytes

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

I'm just directly replacing the digits (and -) with letters, after STR pads the integer to 11 characters. No conversion to hex or binary is necessary.

TRANSLATE was introduced in SQL 2017.

Input is via a pre-existing table $t$ with INT column $n$, per our IO rules. Range of the INT datatype in SQL is $-2^{31} \leq n < 2^{31}$.

EDIT: Saved 3 bytes by replacing manual padding with a conversion to CHAR(11), which is a fixed-width character format that automatically pads with spaces.

EDIT 2: Saved 9 bytes by using STR() function instead of CAST. STR converts a number to a text string padded to the specified length.

APL (Dyalog Unicode), 28 bytes

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

Try it online!

Simple Dfn, taking an integer argument. Uses ⎕IO←0.

TIO links to a test case from -2^10 to 2^10. The 0~⍨ part removes the duplicate 0 from the arguments.

How:

{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 bytes

I think this is right. Inspired by Stephen's Python solution so please +1 him.

¤ùI cÑ

Try it

¤ù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 bytes

This answer is super cheaty, because it always produces the same amount of input, which is equal to $\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

Try it online!

Perl 6, 12 bytes

*~|('@'x 11)

Try it online!

Anonymous Whatever lambda that takes a number and string ORs it with 11 @s. This maps the digits to pqrstuvwxy and the dash to m, then pads the string out to 11 characters with @s

Perl 5 (-p), 9 bytes

$_^=A x$=

Try it online!

Bitwxise-xor of the input with the string AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.

Wolfram Language (Mathematica), 44 33 bytes

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

Try it with a smaller domain

-2 thanks to Greg Martin

Prints >> , followed by the 523069747202-character string representation of a list of $13!+n$ Nulls padded by Trues to a length of $14!$, and a newline. Works on the domain $[-13!,14!-13!)$, which is a superset of $[-2^{31},2^{31})$.

Given the size of the output, I've included a test case with a smaller domain of $[-2^4,2^4)$ instead

Stax, 6 bytes

11){Hm

Run and debug it

Procedure:

1. Left pad input to 11 characters.
2. Double each non-space ascii character.

PHP, 64 54 bytes

-10 bytes by using strtr function instead of manual character replacement.

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

Try it online!

Largest int value possible in PHP as of now is 9223372036854775807 which is 19 digits long, considering the minus sign in negative numbers, it will be 20. The code above replaces minus sign (-) with the A character and every digit from 0 to 9 with a character from D to M and then pads the string in the right with space character to always make it 20 characters long. For example, the output for input of -9876543210 is "AMLKJIHGFED ".

The output is unique for each integer input and you can get back to the input by removing all spaces, replacing A with - and replacing D to M with 0 to 9.

PHP, 44 bytes

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

Try it online!

This is same idea as Arnauld's answer. Converts the input to binary, and then converts it to base-64. Also pads it to 88 characters (largest length is for -9223372036854775807 which is 88 characters) with space character at right to always get same length in the output.

Retina 0.8.2, 21 bytes

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

Try it online! Always outputs 11 characters from the range n..z. Explanation:

T`p`l

Translate the printable ASCII characters to the lowercase letters. This maps - to n and 0..9 to q..z. (It's really fortunate that the digits are the 16th to the 25th printable ASCII characters!)

$
10$*o

Append 10 os. Since the input will have between 1 and 11 characters, there are now between 11 and 21 characters.

!`.{11}

Extract the first 11 characters. Since there are fewer than 22 characters, this will only match once.

Charcoal, 9 bytes

◧⍘﹪ＮＸχχαχ

Try it online! Link is to verbose version of code. Always outputs 10 spaces and uppercase letters. Explanation:

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

R, 37 bytes

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

Try it online!

Looks like the output is random, but it isn't! The input is used as the seed of the Pseudo-Random Number Generator, and we then get one of the $26!=4\cdot 10^{26}$ permutations of the alphabet. The output is always of length 51 (26 letters + 25 spaces).

There is still the issue of insuring that all the outputs are different. We end up with $2^{32}\approx 4\cdot 10^9$ permutations (out of $4\cdot 10^{26}$). If we pretend that the permutations are distributed uniformly at random, then the probability that all the permutations are different can be computed following the same calculations as for the Birthday problem. The probability that 2 specific outputs are identical is $10^{-17}$, so a first order approximation of the probability that all $2^{32}$ outputs are distinct is

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

which is close enough to 1 for me.

brainfuck, 20 19 bytes

-1 byte thanks to Krzysztof Szewczyk

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

Try it online!

Outputs the number with each digit and dash mapped to 255 minus their ordinal value, padded out to 255 characters with NUL bytes.

R, 40 37 bytes

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

Try it online!

An alternative to Robin Ryder's answer; this is certainly deterministic.

This converts the input to a raw vector of 32 bytes, each byte being a hex number 00 or 01 representing the bits of the integer. We then coerce to a logical by comparing to 0, so 00 is mapped to FALSE and 01 to TRUE. Then we need to remove a single letter from each FALSE to guarantee equal-length output, arbitrarily selected to be S. Result is printed (with space) for a length of 169.

Zsh, 43 bytes

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)

Try it online!

This solution gets around the long long limits of Zsh's integers by working with only characters. I only padded it to 30 characters for readability, but replacing 30 with 99 will allow this method to work on all numbers from -1E99+1 to 1E100-1.

The effect of interpreting the decimal codes as hexadecimal are as follows:

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 bytes

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

Try it online!

Declares x as a binary number, zero-padded to a width of 66. Then maps 0→a and 1→b. We also map 2 and - to a, since those characters are printed in [[-]][base]#[num] notation. To see what $x looks like before replacement, and Zsh's limits in parsing integer types, check the Debug output in the TIO link.

Java (JDK), 42 bytes

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

Try it online!

First, this creates the hexadecimal representation of the input, left-padded with spaces which provides the same length constraint (8 characters-long), removes the minus sign, and keeps each intermediate output unique.

This gives a string with 17 different possible characters: 0123456789abcdef and space.

Then each character is streamed and mapped by adding 64 to its codepoint if it's a digit or a space. Effectively, this results in the following mapping: 0123456789abcdef<space> to pqrstuvwxyabcdef` which has 17 different characters, so no two numbers will result in the same output.

Bash, 30 bytes

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

Try it online!

To prove that output is unique, I just googled for MD5 collisions, and found no results within the integers between $-2^{31}$ and $2^{31}$. To avoid having forbidden characters in the output, just translate the characters in question to be upper case letters. Output is always the same length by definition, and guaranteed to not contain any forbidden characters.