[Question]
  [
With challenges like [Output with the same length as the code](https://codegolf.stackexchange.com/questions/121056/output-with-the-same-length-as-the-code) and [Create output twice the length of the code](https://codegolf.stackexchange.com/questions/59436/create-output-twice-the-length-of-the-code/), I thought of a separate, but similar challenge. 
The task is to produce an output. It can either be a string, a list of characters, or whatever is the default output format of your program. However, your output must always be the same length, regardless of the input. And more importantly, **the output should be different for different inputs**.
## Input
A single integer \$n\$, the ranges of which is determined by the choice of language. If your language has variable length integers, the range is \$-2^{31} \leq n < 2^{31}\$.
## Output
A string or a list of characters, or a print to STDOUT or STDERR. You may only use one of these methods. The output should be of the same length regardless of the input, but it is up to you to define which length that is. **The output may not contain the digit characters `0-9`, or the minus sign `-`**. **The output should be deterministic**. 
You should be able to prove that **for every output there is only one possible input**, either by a formal proof, an argument, or a brute-force search. 
This is a code golf question, so shave off any extraneous bytes. All languages are welcome, the more the better!
  
[Answer]
# JavaScript (ES8), 33 bytes
Expects the input in the range of [safe](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER) JS integers: \$-2^{53}\le n < 2^{53}\$.
Returns a string of 76 characters.
```
n=>btoa(n.toString(2)).padEnd(76)
```
[Try it online!](https://tio.run/##dY7fa8IwEMff81ccvjSHTbCtOkFacBBlg3Ww7mEwhqQ/oh2aSNIK@@trnAOf9nLHfb53x@dbnqWrbHvqmDZ1M6h00GlWdkZSzTtTdLbVOxoj8pOsha7pwxyHawwpOEgzeOyVaixX1hypgzEEAd7vglK6Zj4NkJDlJ4tDYFEIkxB89UMUJ1cSJ9NZCHl/LP2fl9XHtlitxfYpfxcb8eYX/kmAQfRFuDJWyGpPtZchAJXRzhwafjA76tnN5089WqAHI5bByPfn4jXn7tezVT9UUY2IBIcL "JavaScript (Node.js) – Try It Online")
## How?
### Step 1
The input is first converted to binary. This preserves the leading minus sign for negative numbers.
Examples:
* `123` → `"1111011"`
* `-77` → `"-1001101"`
### Step 2
The resulting string is encoded in base-64.
It means that each block of 1 to 3 characters will be turned into a new block of 4 characters. This conversion is safe because none of the resulting blocks contain the forbidden symbols (digits or minus sign).
**3-character blocks**
```
"-10" -> "LTEw" | "011" -> "MDEx"
"-11" -> "LTEx" | "100" -> "MTAw"
"000" -> "MDAw" | "101" -> "MTAx"
"001" -> "MDAx" | "110" -> "MTEw"
"010" -> "MDEw" | "111" -> "MTEx"
```
A single final block of 1 or 2 characters has to be encoded if the length of the binary string is not a multiple of 3:
**1-character blocks**
```
"0"   -> "MA==" | "1"   -> "MQ=="
```
**2-character blocks**
```
"-1"  -> "LTE=" | "10"  -> "MTA="
"00"  -> "MDA=" | "11"  -> "MTE="
"01"  -> "MDE=" | 
```
### Step 3
The final output is padded with trailing spaces.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~49~~ 39 bytes
```
lambda i:[chr(ord(x)*2)for x in"%9x"%i]
```
[Try it online!](https://tio.run/##RYwxDsIwEAR7v@LKW4ugOOki8RKgMASTk4wdXVwEPm9IEdFMMdLM/C5TTn0Np0uN/nUbPclwvk/KWUdeYTuErLSSJFqKsuD4CRIjO4drnVVS4cAdWUu9A8xumr@D2Q6yHdSn54Mb17YH@gGDoT0QoH4B "Python 3 – Try It Online")
*-10 bytes thanks to [negative seven](https://codegolf.stackexchange.com/users/86422/negative-seven)*
Converts the integer to hexadecimal, and prepends spaces up to 9 characters total. Then, doubles the ASCII code of each character in the string (some extend outside of ASCII into Unicode, but Python handles it fine), outputting a list of characters.
This works because every digit, including `-`, is mapped to a different ASCII character. No integers between `-2147483648` and `2147483648` are equal, so converting them to hexadecimal and prepending spaces would not make them equal. Then, mapping them to different codepoints does not lead to collisions, so there are still no two values in the range which lead to equal outputs.
# [Python 3](https://docs.python.org/3/), ~~59~~ ~~56~~ 47 bytes
```
lambda i:[*map(lambda x:chr(ord(x)*2),"%9x"%i)]
```
[Try it online!](https://tio.run/##RYvLCoMwEADv@YpFEHaDgo9TA35J6yGtRhdqEhYP6denHhQvAzMw8bevwffZDa/8tdt7ssDmqTcb8dRkPqtgkAkT6Y6qonykomQacxT2OzrsQGvoWyJ1lfpupFwQYGAPYv0yY902TQUHyCi4BibKfw "Python 3 – Try It Online")
*-3 bytes thanks to [Jitse](https://codegolf.stackexchange.com/users/87681/jitse)*
*-9 bytes thanks to [negative seven](https://codegolf.stackexchange.com/users/86422/negative-seven)*
Same algorithm, but using `map` instead of a `for` loop.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~11~~ 5 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
тjÇ·ç
```
-6 bytes porting [*@Stephen*'s approach](https://codegolf.stackexchange.com/a/190135/52210), so make sure to upvote him!
Outputs a list of up to 100 characters, with \$100-(\text{input length})\$ amount of `@` (double the space codepoint), and all `-0123456789` mapped to `Z`bdfhjlnpr` (double the ASCII codepoints).
[Try it online.](https://tio.run/##yy9OTMpM/f//YlPW4fZD2w8v//9f19AAAA)
**Explanation:**
```
 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)
```
---
**Original 11 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) answer:**
```
Ä¶×AIdè«žIj
```
[Try it online](https://tio.run/##yy9OTMpM/f//cMuhbYenO3qmHF5xaPWjppas//91DQ0A) (limited to `1000` instead of `2147483648`).
**Explanation:**
The output length is always 2,147,483,648 characters long. It will output \$2147483648-|n|-1\$ amount of spaces, appended with \$|n|\$ amount of newlines, appended with either an 'a' if \$n\lt0\$ or 'b' if \$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)
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~48~~ ~~29~~ ~~28~~ ~~16~~ 13 bytes
This program requires cells, where \$ c\_n \in \mathbb{N} \$, but if you want consistent results, make sure that \$ c\_n < 256 \$
Output will obviously be unique no matter what number will you enter (\$ -\infty \lt n \lt \infty \$). If the integer is shorter, the program will pad out the output to match exactly \$ \infty \$ bytes, so the length is always the same.
This answer is a bit loopholing the challenge, as it didn't state that output has to be finite.
```
+[,[->-<]>.+]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fO1onWtdO1ybWTk879v9/XUMjYxNTM3MLSzjDYKSJAQA "brainfuck – Try It Online")
---
Original, 28 byte answer:
```
->,[[->-<]>.[-]<<->,]<[<.>-]
```
This one will pad the output to be exactly \$ 2^8 - 1 \$ bytes. The number conversion mechanism works the same here. This program assumes the same as the program above.
[Answer]
# [Python 3](https://docs.python.org/3/), 39 bytes
```
lambda n:f"{n:33b}".translate("abc"*99)
```
[Try it online!](https://tio.run/##VY3LDoIwEEXX8hWTrlpEAtQXJHwJElOgaA0U0o4LY/x2bHVhXExOcmbu3PmB10nzpS9PyyDGphOgi548dcF58yIxGqHtIFBSIpqWhHnOFjXOk0Fwm24aA5QWz62w0kIJVRJBGsHGTxaG3PEDL9KMb3f7wzFPalhD9Y3HHkoj/Ttn0E8GFCjtWy6SZgmrg8BL9PLXWQSr2fi8RUORxeZ2t0hT94gAYRH0TrLlDQ "Python 3 – Try It Online")
Turns the given number into a binary string representation (padded with spaces), then maps the characters `(space)-01` to `caab` with the [`str.translate`](https://docs.python.org/3/library/stdtypes.html?highlight=translate#str.translate) function.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
œ?ØẠ
```
A monadic Link accepting an integer which yields a list of 52 characters.
The input range may be up to somewhat more than \$-2^{223} \leq n \lt 2^{223}\$ since \$52!>2^{224}\$.
**[Try it online!](https://tio.run/##y0rNyan8///oZPvDMx7uWvD//39dI0MTcxMLYzMTCwA "Jelly – Try It Online")**
### How?
```
œ?ØẠ - 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.
```
So...
```
-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
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 38 bytes
```
f(a,i){for(i=32;i--;putchar(a>>i&1));}
```
[Try it online!](https://tio.run/##S9ZNT07@r5yZl5xTmpKqYFNckpKZr5dhx4UQysnMzSwpBor9T9NI1MnUrE7LL9LItDU2ss7U1bUuKC1Jzkgs0ki0s8tUM9TUtK79n5lXopCbmJmnoalQzcWZpmGgaa0AATDF6jF56prWIDlDPHJGeOQ8/ULifR0jgCpwyHn6YZXThVuIJlf7HwA "C (gcc) – 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.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 27 bytes
```
->n{('%34b'%n).tr'01','ah'}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6vWkNd1dgkSV01T1OvpEjdwFBdRz0xQ732f7SxiaGOLogwszAxN7M0MTXRMdLSMgYKgqlYvdzEguqazBqFAoW06MzY2v8A "Ruby – Try It Online")
`('%34b'%n)` Converts an integer into its binary representation, using `..1` to indicate a negative number (this is meant to represent an infinitely-long prefix of 1s), and left-pads this out to 34 characters using spaces. Then we replace the `0`s with 'a' and the `1`s with 'h' to create the Maniacal Base 2 Representation: strings like "haaahahahaaha" prepended with spaces and sometimes `..`. Since every step here is invertible this is 1:1.
Edit: Let the record show that @manatwork posted this identical solution first. Oops. I should've refreshed.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
Ø%+ṃØA
```
[Try it online!](https://tio.run/##y0rNyan8///wDFXthzubD89w/G/9qGGOgq6dwqOGudaH28E8jZzUvPSSDKiQjwpQcK4ml5GWsaGftcrR3YfbHzWtifwPAA "Jelly – 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. 
[Answer]
## Haskell, 31 bytes
```
map(\d->[d..]!!10).show.(+2^60)
```
[Try it online!](https://tio.run/##y0gszk7NyfmfZhvzPzexQCMmRdcuOkVPL1ZR0dBAU684I79cT0PbKM7MQBMon5mnYKuQks@loFBQWhJcUuSTp6CikKZgaGCARQirmMH/f8lpOYnpxf91kwsKAA "Haskell – 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`).
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 35 bytes
```
x=>$"{x,11}".Select(n=>(char)(n+n))
```
[Try it online!](https://tio.run/##Sy7WTS7O/O9Wmpdsk5lXouPpmleam1qUmJSTapOckVhkZ5dm@7/C1k5FqbpCx9CwVkkvODUnNblEI8/WTgOkQFMjTztPU/O/NVdAEdAAjTQNQ01NBMcSmaOLIgUk9XwTK8ISc0pTMcQz82Di/wE "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 52 bytes
```
x=>(new char[32]).Select(y=>(char)(x%2+65+(x/=2)*0))
```
[Try it online!](https://tio.run/##Sy7WTS7O/O9Wmpdsk5lXoqPg6ZpXmptalJiUk2qTnJFYZGeXZvu/wtZOIy@1XAEkEG1sFKupF5yak5pcolEJlAAJampUqBppm5lqa1To2xppahloav635gooAhqpkaZhaGSoqYng6loaGKAIGBobmwP5/wE "C# (Visual C# Interactive Compiler) – 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.
[Answer]
# [Perl 5](https://www.perl.org/) `-MDigest::MD5=md5_hex -p`, 23 bytes
```
$_=md5_hex$_;y/0-9/k-t/
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3jY3xTQ@I7VCJd66Ut9A11I/W7dE//9/Qy4jLl1DLl0jLoN/@QUlmfl5xf91fV0y01OLS6ysfF1MYfr@6xbkAAA "Perl 5 – Try It Online")
Previously:
### [Perl 5](https://www.perl.org/) `-p`, 29 bytes
```
$_=sprintf'%064b',$_;y/01/ab/
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3ra4oCgzryRNXdXAzCRJXUcl3rpS38BQPzFJ//9/Qy4jLl1DLl0jLoN/@QUlmfl5xf91C3IA "Perl 5 – Try It Online")
Converts the number to its 64 bit binary representation, then transliterates `0` and `1` to `a` and `b`, respectively.
[Answer]
# 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`](https://docs.microsoft.com/en-us/sql/t-sql/functions/translate-transact-sql?view=sql-server-2017) was introduced in SQL 2017.
Input is via a pre-existing table \$t\$ with INT column \$n\$, [per our IO rules](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/5341#5341). 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.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 28 bytes
```
{11↑' Z'[⍵≤0],⎕A[⍎¨'¯'~⍨⍕⍵]}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT/@v8ahvql/wo941mnogZrCrXqizr4t6Un6FQn6egm6aLYgssS0pSk1Vf9S1ODUvMSknNdjRJwTIAap3jlQvTswpUdfkAnI8/R@1TTD4X21o@KhtorpClHr0o96tjzqXGMTqAGUdgby@QyvUD61Xr3vUu@JR71SgbGzt/zSgJqAMRH9X86H1xkDdIKcEOQPJEA/P4P@PelelHVqh8ahnr@6j3s1GWoYGmjoaMBYA "APL (Dyalog Unicode) – 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.
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 6 bytes
I *think* this is right. Inspired by Stephen's Python solution so please `+1` him.
```
¤ùI cÑ
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=pPlJIGPR&footer=aSI6ICJpTs75IGdUsA&input=WwotOTAwNzE5OTI1NDc0MDk5MgotOTAwNzE5OTI1NDc0MDk5MQotMTAsLTksLTgsLTcsLTYsLTUsLTQsLTMsLTIsLTEKMAoxLDIsMyw0LDUsNiw3LDgsOSwxMAo5MDA3MTk5MjU0NzQwOTkwCjkwMDcxOTkyNTQ3NDA5OTEKXS1tUg)
```
¤ùI cÑ     :Implicit input of integer
¤          :Convert to binary string
 ù         :Left pad with spaces
  I        :  To length 64
    c      :Map codepoints
     Ñ     :  Multiply by 2
```
[Answer]
# [Malbolge](https://github.com/TryItOnline/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!](https://tio.run/##tZZXj6PsEoR/iwMe53HAAeNxNs45B8A5YZzAOfz1/brBs7Mr7cW5OXdISKVS9dPVrzhcj7br@fTXr1HZEI2EQ19BOkD5fV4P6XY5HZ92m9ViNhk/DIS@rtW8ng@avV7Op6MsrRu1asV@vViWpiw1nTAjcsBzbB/@VismYx1@sqIm5chlM9cLc0oMCT4S1n4FPaq63eaymP9U1ynqR/l62KP6Yb/absSysFou5rPpZNxPJDrRaD8U6tB00@/35j1ulyv1@ZmwWlMmU8hgiOp0Gt/LE7hffZfT8Wj927tOex09H/eb6l1s7mvbhVgqgfpwNk2Pk8MBqve6nWor0PDV8rmyu1jI52wZa4pJJgwEgcl46Qd19Tk@ySMms7VtLIJJq5nP0fvlOUD17qmD3mvbqrgWVvlFDr0nhwlMJtT9areaoO6tlEtFRz6XUNXjsagOknnSpNt/xdwl5wHUDYRZQO9T3QST4W4sem9Jzf1uuymv0fs8A95Hw0GMU7zT4B1yJ8sZF3jPWq1RJmk0xOhAWPsKPu@3m9PrObklyH23sYqCabUwzEF99Bryd64P6ts2eN9VN@JMWBVy8wGfSvWHCVAP90LBNk01/N6qx10qFmCqcasFvSMzGo338XDDVM@kTT7gVA3fuU@/p6rk3loL4F0E7@PFfDCdpMA73271w5B7pVmq@6qVcgZy/8xm0tFv9ZAmSN8p//UMzEiS4t2yXhk1r9nsrh0PnwNIpnfutuVWY1@vbioloZgHZjKTMTPs8koywTYk4wciy6W0qp4yJxNfBBGAqb7owF3xrvBufDOzIPQTVH/wt/5h3@lspGZ9t62W19NJPj@cZVLjUXIQa7fC4XonGGhSMFWy7HYWHPaszZIyG2GqhMI7MKPwjuo7OzCjNy1R/a4k8yay3YRkahVMJj/6X9Q/iKii/oRtUpixAjP2LXpfITPTm@Y1fHCydOl1jpjMaonJrAqL7ICfpJL/mKoLiMzalGQ@Ypi7D5OBbVK979G7GZnBbRq/kHf2oEz1AFNdqLsK3jkkUsk91GkrRHoquE0ORZ0Jo/o79xsmc3K7JNzVzVqvMy7nxOydO4tN0Glh7pBMuYhEZtPofcDHWGQmCNtUL1Q9ZcW7HZiBJoDcdWG/7/kkqdvFez665YNjD7u6NguQ@0w/HWvQO4e5b2FXG0BkZS0UlotcZsqxyWSXj0X64a9/5A7bpBDpx458MyM5Ud1ACIL2rT4aoPd@98f7Wigu8/MZP8Fk4pzinW6hej7ndqf/mqpeG9I86ccNeSfdMkz1TeTSgMkgM7zMvht4X1c7Mo/e08woGedxqvUaThW2icxmis7PnN2atpiwCSAZpQmAyAu0mCQdTDubVTSblovFUw89MzyfsAmAmXbz0KhhMsXJ@K0OLRZtNVVm/P5CtUKWnCkG1C2WCDKjD1DoPUDdro7z8Sg7YVdBXdBpFXXtePRE9X7vdNy0Dop3JBKTSSPvfJSNhLqYe6n4D96VZN49A8z8qP/kDlPt7XfgvdGA6wG8//YOyfyeKiSjNHDqTWQS1QMUtJjiXb18ZpX31Q@RA45F3jvye1fLxUJhhD3D9HvIewQaGPsdvZPK9cCeiZjeHQm7@vi@q5aDcpsEndLv98kVO/IGuwpNgA380zPQkUzvh5mAv@7zkCR0JCQTj0EyHx/BaESn@fLi5bvAVJF3kxF4RyKx329X6HeOky7YkSIwU61UvvsdiETeQf2rVlXVK6QLmcHcI@G/iIQmONqgZ5QWU3NXeuY5UImEy9eo15cb3NXx6GdXW793FaeaSTscSUjGYg4bDQYavGvwaoP6Cd4E0h5aTLSoTQDXY3Q5v7cJkmkIK0imVJrArs7SHKvy3g/VazRdRnVPtoSXz26NqU0Q1SORz4f7pvbMwQHMiIT@ffmgxQanI1yPbheaAN4Ey8XfU41HI5EGeqcUInFX4XqAOmP6QO94tT3vnpFlC7TYdkOs/7ge6m36k5nVMp@d8dyYScTjbcwdLx/l83pzSosl4U1g/mkx3NXfLQbqBlG9q7Po57gS4jma9fsID6l1u3bVqO06hQYOSHC1mUQizt2XvXqwXaFG/gPvYVF9abvFzLUJwE/odCwcYtLddNZPtcgYGpj/yGbTutViTsTqE83lzN9lisp69XLT5azFqpGwAFOVswTHaBMJl5ON9C6zM22iivu9JyuKr3yu1bxeIskP2UAEWLb36giMfzE/2WVJKhV2AYO49jJLQ8JZ117D1lKQk/q@U1vXOriej@ptbVkFR7nBQc9oyW5cePTDtq9q5dcvm8PpcpMer89P/b8@/wM "Malbolge – Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 12 bytes
```
*~|('@'x 11)
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPtfq65GQ91BvULB0FDzvzVXTmZearGdnZ5aGpAoTqy0/m/ApWtoZGxiamZuYWnAhWACAA "Perl 6 – 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
[Answer]
# [Perl 5](https://www.perl.org/) (-p), 9 bytes
```
$_^=A x$=
```
[Try it online!](https://tio.run/##K0gtyjH9/18lPs7WUaFCxfb/fwMuQy5DI2MTUzNzC0sDLl1DLl0jQxNzEwtjMxMLLjjT/F9@QUlmfl7xf92CHAA "Perl 5 – Try It Online")
Bitwxise-xor of the input with the string `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~44~~ 33 bytes
```
Echo@Table[Or[i>#+13!,],{i,14!}]&
```
[Try it with a smaller domain](https://tio.run/##y00syUjNTSzJTE78n2b73zU5I98hJDEpJzXavyg6005Z2yjORCdWpzpTxyjOtDZW7X@aA1iNspq@Q1BiXnpqtK6hmY6haex/AA)
-2 thanks to [Greg Martin](https://codegolf.stackexchange.com/questions/190133/output-with-the-same-length-always/190160?noredirect=1#comment455098_190160)
Prints `>>` , followed by the 523069747202-character string representation of a list of \$13!+n\$ `Null`s padded by `True`s 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
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 6 bytes
```
11){Hm
```
[Run and debug it](https://staxlang.xyz/#c=11%29%7BHm&i=0%0A-1%0A1%0A-2147483648%0A2147483647&a=1&m=2)
**Procedure:**
1. Left pad input to 11 characters.
2. Double each non-space ascii character.
[Answer]
# [PHP](https://php.net/), ~~64~~ 54 bytes
-10 bytes by using `strtr` function instead of manual character replacement.
```
<?=str_pad(strtr($argn,'-0123456789',ADEFGHIJKLM),20);
```
[Try it online!](https://tio.run/##K8go@P/fxt62uKQoviAxRQNIlxRpqCQWpefpqOsaGBoZm5iamVtYqus4uri6uXt4enn7@GrqGBloWv//r2tpZGRsbG5kYGxmYWpibm5qYWD@L7@gJDM/r/i/rhsA "PHP – 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](https://php.net/), 44 bytes
```
<?=str_pad(base64_encode(decbin($argn)),88);
```
[Try it online!](https://tio.run/##BcFLCoAgFADAy7RQSBD/UdGua4g/yo2Kev5eM@1tAMd1jtltcxF5N5ISNpVQY0IxBZ8LWlx/CsarMXgHIBtjnGtGuTJSaC0N1V9tM9cygNw/ "PHP – Try It Online")
This is same idea as **[Arnauld's answer](https://codegolf.stackexchange.com/a/190138/81663)**. 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.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 21 bytes
```
T`p`l
$
10$*o
!`.{11}
```
[Try it online!](https://tio.run/##K0otycxL/P8/JKEgIYdLhcvQQEUrn0sxQa/a0LD2/39dI0MTcxMLYzMTCwA "Retina 0.8.2 – 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 `o`s. 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.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 9 bytes
```
◧⍘﹪ＮＸχχαχ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRCMgMcUnNa1EwymxODW4BCiUruGbn1Kak6/hmVdQWuJXmpuUWqShqaMQkF8OZBga6CgYGmgC@YmaEJb1//@6RoYm5iYWxmYmFv91y3IA "Charcoal – 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
```
[Answer]
# [R](https://www.r-project.org/), 37 bytes
```
set.seed(scan())
cat(sample(LETTERS))
```
[Try it online!](https://tio.run/##K/r/vzi1RK84NTVFozg5MU9DU9M6ObFEozgxtyAnVcPHNSTENShYU/O/oZGxiel/AA "R – 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](https://en.wikipedia.org/wiki/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.
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~20~~ 19 bytes
*-1 byte thanks to Krzysztof Szewczyk*
```
-[>,[->-<]>.[-]<<-]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fN9pOJ1rXTtcm1k4vWjfWxkY3FihoaGRsYmpmbmFpAAA "brainfuck – 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.
[Answer]
# [R](https://www.r-project.org/), ~~40~~ 37 bytes
```
cat(gsub("S","",intToBits(scan())>0))
```
[Try it online!](https://tio.run/##K/r/PzmxRCO9uDRJQylYSUdJSSczryQk3ymzpFijODkxT0NT085AU/O/wX8A "R – Try It Online")
An alternative to [Robin Ryder's answer](https://codegolf.stackexchange.com/a/190188/67312); 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.
[Answer]
# [Zsh](https://www.zsh.org/), 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!](https://tio.run/##bYzBCoMwEETv@xULDbUeAslGjd3S/kjtQTRFITSgpZUWv91az5nL8B7DfMZueXe9dzi4ukXfP9wJ2wDuVXsc3ROlRPG3yz0M2OBBfA8jc7qWZ6OYFad6nlPXdAGrahLXXXNbNkrOWxLY6LInFBMyCg1tWP8UaJAaCCSBVmRsBkciYywpU5R5Zm1eqiLiLIKMLSPSxmQJPw "Zsh – 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](https://www.zsh.org/), 46 bytes
```
integer -i2 -Z66 x=$1
<<<${${x//[02-]/a}//1/b}
```
[Try it online!](https://tio.run/##jY7NSsQwFEb3eYoPpvgDhrRpp61aXfkUiot0emkDMZEkdarDPHutjIiLLuauLoePw/kKw7wftCF4Uh2MtnSPzjH6UAaBIjhH8kNnbSP15MG1BH8uS0wPScaapkkOyWES4iWV/FWooxCZaI8z7QaHxwuJZMIdlmXnFknKMsYzJhmXLEtlXhXsVso8r2Sal/W2qKptnZYrrMJyGxjlewoRuixuoOxnHLTtT9RDB0Q/2p2K1K0o6pPib4KrQIQnascebozvY0RLxu2vGV9r4utRG4Q3ZcxvFOKglifYy/ivha/HnNXyDQ)
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.
[Answer]
# [Java (JDK)](http://jdk.java.net/), 42 bytes
```
n->"".format("%8x",n).chars().map(i->i|64)
```
[Try it online!](https://tio.run/##ZZFvS8MwEMbf71MchUEiaTBuzulcYS8UBs43QxFEJHbtzGzTkqRzQ/fZ6/XP5mAv0rve73IPz2Ul19JfLb5KleaZcbDCf144lfC40KFTmeZno84JtM5EMq1QXnwkKoQwkdbCTCoNPx2AtmqddBjWmVpAiozMnVF6@foG0iwtrVsB7lul26l20TIyDOO8FggghnGp/cDzeJyZVDridYcbj2nKw09pLKE8lTlRfqB@B31ajuqBSjuUcJF1FsatCMA5A8HggkGPQZ/BJYMBgysGQwbXiCqMXGCDwA6BLQJ7xIDt728qXn334RD/k6PsOBXtDB@LPir4vf3U1jOfTV7enycPT3cnYPrYgLq@axziMgi6rD3eNE7pweh8a12U8qxwPMd1uxiXJoQFP4Cu7WqP1RcY6OgbmgchMZd5nmxJBSh32cQYuSWUVUsbUtqI7jrV2ZV/ "Java (JDK) – 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.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 30 bytes
```
echo $1|md5sum|tr '0-9-' 'A-K'
```
[Try it online!](https://tio.run/##S0oszvj/PzU5I19BxbAmN8W0uDS3pqRIQd1A11JXXUHdUddb/f///7qGRsZGhkYA "Bash – 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. 
]