text:
Output with the same length always
With challenges like Output with the same length as the code and 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!

Should the program in theory work for any input? Or does it suffice to use a method that only works for the specified range (bounded by $\pm 2^{31}$), not necessarily due to language limitations but method limitations?

@Mr.Xcoder how could you pick a length if you had to work for arbitrary length integers?

@Stephen I guess it would be impossible given that the unicode set is limited in length. But I just wanted to clarify that aspect, maybe I'm missing something.

@Mr.Xcoder You must only prove that it works for that range. This rule is to help languages such as Python, where numbers can be thousands of digits. Without that rule, it'd be much harder for both Python, and Python derivatives (which includes a lot of golfing languages).

@Arnauld As Mr. Xcoder says, you must avoid all digits in your output. The approach that you take is up to you. If could be transliteration, substitution, dictionary fetching, or something that I haven't thought of. I wanted to leave it quite open, to leave room for creativity.

If a language doesn't have variable length integers but can support values larger than $2^{31}$, are we allowed to use the restricted range $-2^{31}\le n<2^{31}$?

Can we take input as a string?

@Arnauld the maximum range is 32 bit signed integers, regardless of the limitations of the language. The language can only decrease that range.

@Shaggy if your language doesn't separate strings and ints, i guess you could. But input should be an integer. Otherwise it'd be too trivial in some languages (I can think of a 3-byter in mathgolf).

Aww… I was gonna hash the input…

@Hippopotomonstrosesquipedalian as long as the hash output is unique for the range [-2^31, 2^31) and doesn't contain any digits, go for it!

JavaScript (ES8), 33 bytes
Expects the input in the range of safe JS integers: \$-2^{53}\le n < 2^{53}\$.
Returns a string of 76 characters.
n=>btoa(n.toString(2)).padEnd(76)

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.

Did you already know that these particular combinations of character contain no numbers when converted to base64, or did you find out experimentally?

@TomášZato That was a confident guess, based on the fact that it is a very small charset in the lower part of the ASCII table.

Python 3, 49 39 bytes
lambda i:[chr(ord(x)*2)for x in"%9x"%i]

Try it online!
-10 bytes thanks to 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, 59 56 47 bytes
lambda i:[*map(lambda x:chr(ord(x)*2),"%9x"%i)]

Try it online!
-3 bytes thanks to Jitse
-9 bytes thanks to negative seven
Same algorithm, but using map instead of a for loop.

You can shave off 3 bytes in the map approach by replacing list( ... ) with [* ... ]

You could create the padded string with "%9x"%i

@negativeseven thank you, that is really genius

Could stay within ASCII and at 39 bytes in Python 2 using \4e9+n``

05AB1E, 11 5 bytes
тjÇ·ç

-6 bytes porting @Stephen's approach, 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.
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 answer:
Ä¶×AIdè«žIj

Try it online (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)

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!

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.

Infinite output is not allowed

@JoKing this was stated after I made this answer.
But if you really feel hurt by this, I can simply opt out of challenge and declare first answer as non-competing

Python 3, 39 bytes
lambda n:f"{n:33b}".translate("abc"*99)

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 function.

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

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 0s with 'a' and the 1s 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.

Lol. Your output is much funnier than mine.

Jelly, 4 bytes
œ?ØẠ

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!
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

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.

Clever approach, similar to the Brainfuck response padding with NUL bytes.

I'm not sure a program that doesn't terminate is really within specs... but if it is, 28 bytes? f(a){putchar(a&1);f(a/2);}

I made an exception for Malbolge, but in general the program should terminate. Having "infinity" as the length is a bit of a cheat.

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

Does it handle negative numbers?

@maxb: no, but now it's fixed.

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# (Visual C# Interactive Compiler), 35 bytes
x=>$"{x,11}".Select(n=>(char)(n+n))

Try it online!

Crashes for x = int.MinValue as it can't be negated.

@Hand-E-Food Fixed by changing to an entirely different version

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.

And you have confirmed there are no collisions for all valid inputs?

... and that no md5 hash produces a digit character by chance?

Forgot about the requirement to exclude digits.  I've updated to accommodate that.

9 bytes, 0 risk of MD5 collision.

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.

44? - I am outputting non-printable characters (which seems ok) but you could convert to printable by adding 65 like your current answer.

42 - This time with printable characters :)

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

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

Nice :) I think you can save two bytes by changing 2^31 and 2^32 to 13! and 14! respectively. At the loss of some "brevity" in the output....

Perl 5 (-p), 9 bytes
$_^=A x$=

Try it online!
Bitwxise-xor of the input with the string AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.

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!

With it being Malbolge, I might let that slide... Fantastic job!

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

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.

Stax, 6 bytes
11){Hm

Run and debug it
Procedure:

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

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.

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

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.

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.

You can save one byte: -[>,[->-<]>.[-]<<-]

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.

While yes, it's statistically unlikely that there's a collision, that doesn't mean it's impossible as the question asks for

I like the probability calculation. I guess you could run through all 4 billion inputs if you really wanted to check for collisions, but if you don't feel like doing that I might let it slide. As it is now, you've presented a compelling argument, and if anyone finds a counterexample, you'd have to modify your submission.

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.

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.


text:
The Lucky House
There's a minigame in Super Mario 3D World known as the Lucky House. It consists of a slot machine with 4 blocks.

Each block may be one of 5 different icons (Flower, Leaf, Bell, Cherry or Boomerang) and the goal of the player is to get as many identical icons as possible (see a video).
The player is rewarded with coins, which in turn may be converted into extra lives. Your task is to compute the number of extra lives won.
Depending on the number of icons that match, the amount of coins rewarded are as follows:

No matches - 10 coins
One pair - 100 coins
Two pairs - 200 coins
Three-of-a-kind - 300 coins
Four-of-a-kind - 777 coins

You win one extra life (1UP) every 100 coins. Therefore, you're guaranteed to win exactly 1UP with one pair, 2UP with two pairs and 3UP with 3-of-a-kind. However, the number of lives won with no matches or 4-of-a-kind depends on your initial coin stock.
Source: Super Mario Wiki
Input
You're given the initial coin stock \$0 \le c < 100\$ and a list of four values \$[v_1,v_2,v_3,v_4]\$ representing the final icons on the slot machine.
Output
The number of extra lives won: \$0\$, \$1\$, \$2\$, \$3\$, \$7\$ or \$8\$.
Rules

You may take the icons in any reasonable format: e.g. as a list, as a string or as 4 distinct parameters.
Each icon may be represented by either a single-digit integer or a single character. Please specify the set of icons used in your answer. (But you don't have to explain how they're mapped to Flower, Leaf, Bell, etc., because it doesn't matter at all.)
You are not allowed to remap the output values.
This is code-golf.

Test cases
In the following examples, we use a list of integers in \$[1..5]\$ to represent the icons.
coins  icons      output   explanation
-------------------------------------------------------------------------
  0    [1,4,2,5]    0      no matches  ->  0 +  10 =  10 coins -> nothing
 95    [3,1,2,4]    1      no matches  -> 95 +  10 = 105 coins -> 1UP
 25    [2,3,4,3]    1      one pair    -> 25 + 100 = 125 coins -> 1UP
 25    [4,5,5,4]    2      two pairs   -> 25 + 200 = 225 coins -> 2UP
  0    [2,5,2,2]    3      3-of-a-kind ->  0 + 300 = 300 coins -> 3UP
 22    [1,1,1,1]    7      4-of-a-kind -> 22 + 777 = 799 coins -> 7UP
 23    [3,3,3,3]    8      4-of-a-kind -> 23 + 777 = 800 coins -> 8UP
 99    [3,3,3,3]    8      4-of-a-kind -> 99 + 777 = 876 coins -> 8UP

Are we allowed to input the coin count as a float from 0 to 0.99? I'd guess not, but asking just in case.

@Grimy No, only an integer (or a string representing this integer). Sorry for the late answer.

x86-16 Assembly, 56 41 39 bytes
Binary:
00000000: b103 33ed ac8b fe51 f2ae 7503 45eb f983  ..3....Q..u.E...
00000010: fd03 7504 80c2 4d43 03dd 59e2 e592 7502  ..u...MC..Y...u.
00000020: 040a 3c64 7201 43                        ..<dr.C

Unassembled:
B1 03           MOV  CL, 3              ; set up loop counter for 3 digits
            DIGIT_LOOP:
33 ED           XOR  BP, BP             ; clear digit matches counter in BP
AC              LODSB                   ; load next digit char into AL
8B FE           MOV  DI, SI             ; start searching at next char
51              PUSH CX                 ; save outer digit loop counter
            MATCH_LOOP:
F2/ AE          REPNZ SCASB             ; search until digit in AL is found
75 03           JNZ  CHECK_FOUR         ; is end of search?
45              INC  BP                 ; if not, a match was found, increment count
EB F9           JMP  MATCH_LOOP         ; continue looping
            CHECK_FOUR:
83 FD 03        CMP  BP, 3              ; is four of a kind?
75 04           JNE  SCORE_DIGIT        ; if not, add number of matches to 1UP's
80 C2 4D        ADD  DL, 77             ; add 77 to coin count
43              INC  BX                 ; +1 1UP extra for four-of-a-kind
            SCORE_DIGIT:
03 DD           ADD  BX, BP             ; Add number of matches to total, set ZF if 0
59              POP  CX                 ; restore outer digit loop position
E2 E5           LOOP DIGIT_LOOP         ; keep looping
92              XCHG DX, AX             ; coin count to AX for shorter compare
75 02           JNZ  FINAL_SCORE        ; if 1UPs > 0, no consolation prize
04 0A           ADD  AL, 10             ; award 10 coins
            FINAL_SCORE:
3C 64           CMP  AL, 100            ; is coin score over 100?
72 01           JB   DONE               ; if not, no extra 1UP
43              INC  BX                 ; otherwise, increment 1UP
            DONE:

Input starting coin count in DX, SI pointing to start of "icon" bytes (which can be '1'-'5', or any byte value).  Output the number of 1UP's in BX.
Explanation:
The input of four bytes is iterated and compared to the remaining bytes to the right, counting the number of matches. The scores for each type of match are awarded and add up to the total. Since a four-of-a-kind is also three-of-a-kind and also a one-pair, the value of each score type can be decomposed as follows:

3 matches = 4 1UP's + 77 coins
2 matches = 2 1UP's
1 match = 1 1UP

Examples:
[2, 2, 2, 2] (four-of-a-kind) = 7 1UP's + 77 coins
2 [2, 2, 2] = 3 matches = 4 1UP's + 77 coins
   2 [2, 2] = 2 matches = 2 1UP's
      2 [2] = 1 match   = 1 1UP

[2, 5, 2, 2] (three-of-a-kind) = 3 1UP's
2 [5, 2, 2] = 2 matches = 2 1UP's
   5 [2, 2] = 0 matches
      2 [2] = 1 match   = 1 1UP

[4, 5, 5, 4] (two pair) = 2 1UP's
4 [5, 5, 4] = 1 match   = 1 1UP
   5 [5, 4] = 1 match   = 1 1UP
      5 [4] = 0 matches

[2, 3, 4, 3] (one pair) = 1 1UP
2 [3, 4, 3] = 0 matches
   3 [4, 3] = 1 match   = 1 1UP
      4 [3] = 0 matches

If number of earned 1UP's is 0 at the end, 10 coins are awarded. If total coins are greater than 100, an additional 1UP is awarded.
Here is a test program for PC DOS that includes extra routines to handle the integer value I/O:

Download and test LUCKY.COM for DOS.

Jelly,  23 22 20  19 bytes
-1 thanks to Erik the Outgolfer (use ³ in place of ȷ2) also used in newer version twice
-1 thanks to Grimy (subtract one before summing instead of subtracting four afterwards)
Maybe beatable?
ċⱮ`’SṚḌH×³«777»⁵+:³

A dyadic Link accepting a list and an integer which yields an integer.
Try it online! Or see a test-suite.
How?
ċⱮ`’SṚḌH×³«777»⁵+:³ - Link: list a, integer n   e.g. [x,x,x,x], 22
 Ɱ`                 - map across a with:
ċ                   -   count occurrences in a       [4,4,4,4]
   ’                - decrement                      [3,3,3,3]
    S               - sum (call this s)              12
     Ṛ              - reverse (implicit toDigits)    [2,1]
      Ḍ             - un-decimal                     21
       H            - halve                          10.5
         ³          - 100                           100
        ×           - multiply                     1050
           777      - 777                           777
          «         - minimum                       777
               ⁵    - 10                             10
              »     - maximum                       777  (handles 0 -> 10)
                +   - add (n)                       799
                  ³ - 100                           100
                 :  - integer division                7

How the hand evaluation works for each type of hand:
           Hand:    no-pair     pair        2-pair      trips       4-of-a-kind
(sorted) counts:    [1,1,1,1]   [1,1,2,2]   [2,2,2,2]   [1,3,3,3]   [4,4,4,4]
      decrement:    [0,0,0,0]   [0,0,1,1]   [1,1,1,1]   [0,2,2,2]   [3,3,3,3]
            sum:    0           2           4           6           12
       reversed:    [0]         [2]         [4]         [6]         [2,1]
     un-decimal:    0           2           4           6           21
         halved:    0           1           2           3           10.5
      times 100:    0           100         200         300         1050
    min(x, 777):    0           100         200         300         777
     max(x, 10):    10          100         200         300         777

Alternative 20: ĠẈị“¡ıKĖ‘S×4+E{»⁵+:³

You can replace ȷ2 with ³ by assuming the program the function is in doesn't take command-line arguments, although that's not what I think you mean by "beatable". :P

Thanks Erik, and yeah that's not how I thought it would be beaten ^^

-1 byte (thanks to Grimy in my 05AB1E port) by first decreasing the counts by 1 before summing. Instead of first summing, and decreasing by 4: ċⱮ`’SṚḌH×³«777»⁵+:³

Thanks @KevinCruijssen will update later (nice job once again Grimy!)

Zsh, 117 ... 60 bytes
-13 by using a different criterion for differentiation, -9 by combining cases, -28 by changing the case statement to a nested arithmetic ternary, -4 thanks to @JonathanAllan, -1 by optimizing the ternaries, -2 because I accidentally used echo when adding Jonathan's optimization.
Takes coin count on stdin, and block inputs as arguments. Arguments can be numbers, characters, or even strings: ./foo.zsh flower leaf flower boomerang
read c
for i;for j;((a+=i<j))
<<<$[!a?7+(c>22):a-6?6-a:c>89]

Try it online:
117
104
95
67
63
62

60
Here's the magic from the 67 byte answer:
read coins
for block                  # for each element
  (( a+=${#${@:#$block}} ))
#          ${@:#$block}      remove all elements which don't match
#       ${#            }     count the remaining elements
# (( a+=                 ))  add that number to the total
<<<$[a?(a-12?6-a/2:coins>89):7+(coins>22)]
#    a?                     :7+(coins>22)  4*0 (all elements match all elements)
#      (a-12?     :coins>89)               4*3 (all elements match exactly one)
#      (a-12?6-a/2         )               3*1 + 1*3 ->  6, 6 -  6/2 -> 3
#                                          2*2 + 2*2 ->  8, 6 -  8/2 -> 2
#                                          2*3 + 2*2 -> 10, 6 - 10/2 -> 1

Python 2, 96 91 89 bytes
-2 bytes thanks to @Kevin Cruijssen
lambda x,a,b,c,d:(x+(100*sum((a==b,a==c,a==d,b==c,b==d,c==d))or 10)+177*(a==b==c==d))/100

Try it online!

Ah. I missed that. Thanks.

You can remove one pair of parenthesis around (100*sum((a==b,a==c,a==d,b==c,b==d,c==d)) for -2 bytes.

C# (Visual C# Interactive Compiler), 123 106 90 bytes
a=>b=>(a+("Ĭ̉Èd\n"[(b=b.GroupBy(x=>x,(o,p)=>p.Count())).Count()*(b.Max()==3?0:1)]))/100

A port of my python answer, which is derived from @Dat's answer.
Try it online!

PHP, 153 127 bytes
@640KB made some really clever changes to shorten it further:
function($c,$s){for(;++$x<6;$n+=$m>3?777:($m>2?300:($m>1)*100))for($m=!$y=-1;++$y<5;$m+=$s[$y]==$x);return($c+($n?:10))/100|0;}

Try it online!

Hi @XMark, welcome to CGCC! Nice submission! I golfed it a bit more and got you -26 bytes 127 bytes, TIO. Keep 'em coming!

Python 3, 68 bytes
def f(c,a):x=sum(map(a.count,a))//2;return[c//90,x-2,7+(c>22)][x//3]

Try it online!
A Python port of my C port of my Bash port of my Zsh answer, re-golfed with help from the "Tips for golfing in Python" page.
Last port, I swear... I'm running out of languages I'm comfortable golfing in. I was curious how this strategy compared to the other Python answers. Again, there's probably some way to beat this.
This one turned out surprisingly good, so I added a table below summarizing what's happening so others can port or improve this.
Type          Example  map(a.count,a)  sum(__)   x=__//2  x//3   array lookup
----------------------------------------------------------------------------
none         [1,2,3,4]    [1,1,1,1]        4       2       0      c//90
pair         [1,1,2,3]    [2,2,1,1]        6       3       1      x-2 -> 1
two pair     [1,3,1,3]    [2,2,2,2]        8       4       1      x-2 -> 2
3-of-a-kind  [1,3,1,1]    [3,1,3,3]       10       5       1      x-2 -> 3
4-of-a-kind  [3,3,3,3]    [4,4,4,4]       16       8       2      7+(c>22)

Python 3.8 (pre-release), 63 bytes
Praise the := walrus!

lambda c,a:[2+c//90,x:=sum(map(a.count,a))//2,9+(c>22)][x//3]-2

Try it online!

Python 2, 63 bytes
lambda x,l:int([3,1,7.77,2,.1][sum(map(l.count,l))%14%5]+x/1e2)

Try it online!
I had the same idea as GammaFunction to use sum(map(l.count,l)) as a "fingerprint". But, instead of using an arithmetic formula on the result, I use a lookup table, first squishing the value to 0 through 4 using a mod chain %14%5. Dividing all the point values by 100 saved a few bytes.

62 bytes in Python 3?

or 61 bytes with a single mod.

(Ah... Didn't notice that it's actually what Embodiment of Ignorance is doing.)

Perl 6, 48 44 bytes
{*/100+((0,0,1,3,7.77)[.Bag{*}].sum||.1)+|0}

Try it online!
Curried function f(icons)(coins).

Python 3, 126 111 108 103 bytes
def f(c,a):x=sorted([a.count(i)for i in set(a)]);return([300,777,200,100,10][len(x)*(x[-1]!=3)]+c)//100

Try it online!

80 bytes with python 3.8: https://tio.run/##jZFfTsQgEMafyylwn2AlLpRt3DbhyWN0ecC2GzfZQkMxqTfQu3gLffROFftPNmmiZEK@GX7fwITmxT0ZzQ@N7U/i2F9U/VgqWBCVIWNLtPl8/3r7eC2PepNfKo26TOTbWjVI3RXmWTvSVg4pjCXeolp1qMM3gvvstsC7HaO0d1XrHlRbtVDAHEC/xn1QlMCcEbgnMCYwkZIsR3RQUyFwpIm3cALZYNmHFjZZogCPf3AP8uES/i/cg8kQV93jFZyOzZPhLXFI87Xm8TjtFCF@v4bzcdIpQvywgqfpnziQAJyMhfOXwLNedJuByPgvOqG5klPpg8AwZxKDyHpsKTLfM2rsWTtk8KzsoowQvwnuvwE

@EmbodimentofIgnorance You removed so many bytes that you might as well write your own answer

Perl 5 -pF, 46 bytes
map$q+=$$_++,@F;$_=0|<>/100+($q>5?7.77:$q||.1)

Try it online!
First of input is the spin result, using any 5 unique ASCII letters, except q (I suggest abcde).  The second line of input is the current coin count.
How?
-F     # CLI option splits the input into individual characters in @F
map
   $q+=   # $q holds the result of the calculation here
          # possible values are 0,1,2,3,6
   $$_    # This interprets $_ as a variable reference, thus if $_ is 'a', this variable is $a
   ++     # increment after adding it to $q
,@F;      # iterate over the elements of @F
$_=0|     # force the result to be an integer
   <>/100 # divide the current coin count by 100
   +($q>5?7.77  # if $q is over 5, then there must have been 4 of a kind
   :$q||.1)     # otherwise, use $q, unless it is 0, then use .1
-p        # CLI option implicitly outputs $_

All of the numbers involved are divided by 100, so the program is counting the number of lives (including partial ones) currently earned.  The trick to this solution is in the map.  If the possible entries are abcde, then each of $a, $b, $c, $d, and $e hold the count of the number of times this character had previously been seen.  That gets added to a running total ($q) each time a character is seen.  The running total is bumped up if there is a four of a kind (effectively a 177 coin bonus).

Can you include explanation of how this works, please?

@msh210  I've tried to add one as best I can.  Please feel free to ask questions about it.

Python 3.8 (pre-release), 78 bytes
lambda c,a:(ord("Ĭ̉Èd\n"[len(x:=[*map(a.count,{*a})])*(max(x)!=3)])+c)//100

Dat's answer, but golfed more.
Try it online!

PHP, 89 84 bytes
foreach(count_chars($argv[2])as$a)$b+=[2=>1,3,7.77][$a];echo$argv[1]/100+($b?:.1)|0;

Try it online!
Input from command line, output to STDOUT:
$ php lucky.php 99 3333
8

$ php lucky.php 0 2522
3

$ php lucky.php 0 abaa
3

JavaScript (Node.js), 64 bytes
c=>a=>[,7.77,a.sort()[1]-a[2]?2:3,1,.1][new Set(a).size]+c*.01|0

Try it online!
I figured there had to be at least one JavaScript answer to an Arnauld challenge!
The concept here is mainly to use the number of distinct elements as a lookup key.

1 unique => 4 of a kind
2 unique => 2 pair or 3 of a kind
3 unique => 1 pair
4 unique => no matches

In order to distinguish between 2 pair and 3 of a kind, the input array is sorted and the middle 2 elements are compared.

Bash, 76 75 71 70 bytes
-4 thanks to @JonathanAllan, -1 by rearranging the ternary.
read c
for i;{ for j;{ ((a+=i<j));};}
echo $[!a?7+(c>22):a-6?6-a:c>89]

Bash port of my Zsh answer.
Try it online!
Try it online!
Try it online!
Try it online!

Save 4 using less-than in place of not-equal here too.

@JonathanAllan This even saves 4 on my Zsh answer, thanks.

Stax, 23 bytes
¿^∩û:¶á☺ⁿ£z⌐└≤♂EM¥t(,5╓

Run and debug it
This program uses any arbitrary set of 5 integers for icons.
Procedure:

Add up the number of occurrences of each element.
Divide by 2 and then mod 7.
The result is a number from 1..5.  Use this to look up the coin prize in a fixed array.
Add to the initial coin count.
Divide by 100.

Here's the output from an experimental stack state visualizer I've been working on for the next release of stax.  This is an unpacked version of the same code with the stack state added to comments.
c               input:[2, 3, 4, 3] 25 main:[2, 3, 4, 3]
{[#m            input:[2, 3, 4, 3] 25 main:[1, 2, 1, 2]
|+              input:[2, 3, 4, 3] 25 main:6
h7%             input:[2, 3, 4, 3] 25 main:3
":QctI*12A"!    input:[2, 3, 4, 3] 25 main:[300, 777, 10, 100, 200] 3
@               input:[2, 3, 4, 3] 25 main:100
a+              main:125 [2, 3, 4, 3]
AJ/             main:1 [2, 3, 4, 3]

Run this one

C (gcc), 92 84 82 81 79 78 bytes
-1 by x+=(..!=..) -5 by returning via assignment, -4 thanks to Jonathan Allan by replacing != with <, which saves bytes elsewhere, -1 by rearranging the ternary.
From @ceilingcat: -2 by declaring i and x outside the function, -1 by setting x=i and decrementing x instead.
i,x;f(c,a)int*a;{for(i=x=16;i--;)x-=a[i/4]>=a[i%4];c=x?x-6?6-x:c>89:7+(c>22);}

Another port of my Zsh answer. I'm unfamiliar with C golfing, there's probably another trick somewhere in here to reduce it further.
92
84
82
81
79
Try it online!

Save 4 using less than in place of not equal: x+=a[i/4]<a[i%4];c=x?(x-6?6-x:c>89):7+(c>22);

Scala, 88 bytes
(c,v)=>(Seq(777,300,200,100,0,10)((v.groupBy(x=>x).map(_._2.size+1).product-5)/2)+c)/100

Try it online!

PowerShell, 114 107 bytes
-7 bytes thanks to mazzy
param($n,$l)((((0,.1,1)[+($x=($l|group|% c*t|sort))[2]],2,3)[$x[1]-1],7.77)[$x[0]-eq4]+".$n")-replace'\..*'

Try it online!
A big ol' PowerShell-flavored ternary operation built upon grouping and sorting the counts of the input list. The sort is needed because we leverage the fact that the grouped list gets shorter the more repeats there are. In fact, here's all the possible values:
(1,1,1,1)
(1,1,2)
(2,2)
(1,3)
(4)

Truncating to an int is still expensive.
Unrolled:
param($n,$l)
$x=$l|group|% c*t|sort
(((                      #Start building a list...
   (0,.1,1)[+$x[2]],     #where spot 0 holds dummy data or handles no match and 1 pair
    2,3)[$x[1]-1],       #Overwrite the dummy data with 2-pair or 3-o-k
   7.77)[$x[0]-eq4]      #OR ignore all that and use spot 1 because it's a 4-o-k
   +".$n"                #Use that value and add CoinCnt via int-to-string-to-decimal
)-replace'\..*'          #Snip off the decimal part

is an empty string allowed instead 0? Try it online!

another variant Try it online!

Charcoal, 30 bytes
≔⊘ΣＥη№ηιηＩ⌊⁺∕θ¹⁰⁰∨⁻η∕²∨›⁸η⁹∕¹χ

Try it online! Link is to verbose version of code. Takes input as the number of coins and an array of any Python comparable values as icons. Explanation:
≔⊘ΣＥη№ηιη

Shamelessly steal @GammaFunction's trick of computing half the sum of counts.
⁻η∕²∨›⁸η⁹

Subtract 2 from the sum, thus resulting in the values 0, 1, 2, 3 appropriately, but for 4-of-a-kind, divide the 2 by 9 first, resulting in 7.777....
∨...∕¹χ

But if the result is 0, then there were no matches, so replace it with 0.1 instead. (Using a literal doesn't help me here because I would need a separator.)
Ｉ⌊⁺∕θ¹⁰⁰...

Divide the initial coins by 100 and add on the winnings, then floor the result and cast to string for implicit output.

R, 102, 91, 81 bytes
f=function(b,v,s=table(v))(477*any(s>3)+b+10*all(s<2))%/%100+sum(s==2)+3*any(s>2)

Managed to drop 11 bytes (and fix a bug) thanks to @Giuseppe.
Managed a further 10 inspired by by @Giuseppe's /10 idea.
Ungolfed
f=function(b,v){
  s = table(v)          #included in fn inputs
  a = b+10*all(s<2)     #covers all different case
  a = a+477*any(s>3)    #Covers 4 of a kind
  d = sum(s==2)+3*any(s>2) #covers 1 and 2 pair, 3 of a kind.
  a%/%100+d         #sum appropriate values
}

Try it online!

This doesn't seem to pass the last test case

but if you can figure out why that is, you can remove the as.factor() and the f= to get it to 88 bytes.

Ah -- good catch, I seem to have done my math wrong. And top tip on table -- i'm not as familiar with it as I ought to be -- I started with summary(as.factor(v)). I prefer to leave the f=. I don't feel like the code is complete without it, but I realize thats a style choice.

If you say so. This is 87 bytes, including the f=; feel free to put a TIO link into you answer :-)

I like the split out. As I was toying with it, I figured out that sum(s==2) helps a lot. But it required re-writing everything else, and the /10 no longer saved space (I don't think)

Wolfram Language (Mathematica), 54 bytes
⌊{,.1,1,2,3,,,7.77}[[Total[Counts@#2^2]/2]]+.01#⌋&

Try it online!

Pyth, 32 bytes
AQ-@[+K2/G90J/sm/HdH2+9>G22)/J3K

Try it online!
Inspired by GammaFunction's solution. Takes input as [coins, [icons]].
AQ                               # Q is the input. Set G := Q[0], H := Q[1]
    [                      )     # Construct a list from the following entries:
     +K2/G90                     # [0] (K:=2) + G/90 (/ is integer division)
            J                    # [1] J:=
              s                  #        reduce on + (
               m   H             #          map entries of H as d on (
                /Hd              #            number of occurences of d in H ) )
             /      2            #                                               / 2
                     +9>G22      # [2] 9 + (G > 22)
   @                        /J3  # Take element at position J/3
  -                            K # Subtract K (=2)

PowerShell, 94 bytes
param($n,$l)$r=@{2=100;3=300;4=777}[($l|group|% c*t)]|?{$_;$n+=$_}
+(($n+10*!$r)-replace'..$')

Try it online!
Unrolled:
param($nowCoins,$values)
$groupCounts=$values|group|% count
$rewardedCoins=@{2=100;3=300;4=777}[$groupCounts]|?{
    $_                          # output matched only
    $nowCoins+=$_               # and accumulate
}
$nowCoins+=10*!$rewardedCoins   # add 10 coins if no rewarded conis
+($nowCoins-replace'..$')       # truncate last two digits

APL+WIN, 42 bytes
Prompts for icons followed by coin stock.
  ⌊(.01×⎕)+.1⌈+/1 3 7.77×+⌿(+⌿⎕∘.=⍳5)∘.=1↓⍳4

Try it online! Courtesy of Dyalog Classic

Retina 0.8.2, 72 bytes
O`\D
(\D)\1{3}
777¶
(\D)\1\1
300¶
(\D)\1
100¶
\D{4}
10¶
\d+\D*
$*
1{100}

Try it online! Link includes test cases. Takes input as 4 printable ASCII non-digits followed by the initial number of coins in digits. Explanation:
O`\D

Sort the non-digits so that identical symbols are grouped together.
(\D)\1{3}
777¶

Four-of-a-kind scores 777.
(\D)\1\1
300¶

Three-of-a-kind scores 300.
(\D)\1
100¶

Each pair scores 100, so two pairs will score 200.
\D{4}
10¶

If there were no matches then you still win!
\d+\D*
$*

Convert the values to unary and take the sum.
1{100}

Integer divide the sum by 100 and convert back to decimal.

Retina, 56 bytes
(\D)\1{3}
777¶
w`(\D).*\1
100¶
\D{4}
10¶
\d+\D*
*
_{100}

Try it online! Link includes test cases. Takes input as 4 printable ASCII non-digits followed by the initial number of coins in digits. Explanation:
(\D)\1{3}
777¶

Four-of-a-kind scores 777.
w`(\D).*\1
100¶

Each pair scores 100. The w takes all pairs into consideration, so that they can be interleaved, plus three-of-a-kind can be decomposed into three pairs, thus automagically scoring 300.
\D{4}
10¶

If there were no matches then you still win!
\d+\D*
*

Convert the values to unary and take the sum.
_{100}

Integer divide the sum by 100 and convert back to decimal.

05AB1E, 20 19 18  bytes
D¢<OR;т*777T)Åm+т÷

Port of @JonathanAllan's Jelly answer, so make sure to upvote him!!
-2 bytes thanks to @Grimy.
Takes the list of icons as first input (being [1,2,3,4,5]), and the amount of coins as second input.
Try it online or verify all test cases. (The test suite uses T‚à+ instead of TMI+, which is an equal bytes alternative.)
Explanation:
D                   # Duplicate the first (implicit) input-list
 ¢                  # Count the amount of occurrences in itself
  <                 # Decrease each count by 1
   O                # Sum these
    R               # Reverse it
     ;              # Halve it
      т*            # Multiply by 100
        777         # Push 777
           T        # Push 10
            )       # Wrap all three values into a list
             Åm     # Get the median of these three values
               +    # Add the second (implicit) input to it
                т÷  # And integer-divide it by 100
                    # (after which the result is output implicitly)

@Grimy Ah, of course. Thanks! I suggested the same golf in the Jelly answer (crediting you of course). :)

Also, 777‚ßTMI can be 777T)Åm.

Cheaty 17 (takes the coin count as a float, which i'm pretty sure is not allowed)

@Grimy So 0.90 is 90 coins in that case? Since the coin input is guaranteed to be in the range [0,99], you could ask OP whether he'd allow it or not.

Yup, 0.90 means 90 coins. I asked the OP about it. In any case, here's another non-cheaty 18.

8051 Assembly (compiles to 158 bytes)
This is a VEEEEEEEEEERRY naive approch, this is yet untested and ungolfed but im pretty confident that works. Things to consider are:
1) the 8051 is an accumulator machine ie. it needs mov instructions that other architectures may not need at all.
2) the 8051 is an 8bit machine therefor there has to be done some trickery for the numbers >255 which makes for more code and is therefor a disadvantage of the platform over the others.
CSEG AT 0000H

coinStackOnes equ 0xf3
coinStackTens equ 0xf4
coinStackHundreds equ 0xf5 ; leave one byte as guard so that if that gets corrupted it doesnt really matter

values1 equ 0xf7
values2 equ 0xf8
values3 equ 0xf9
values4 equ 0xfa

numOfFlowers equ 0xfb
numOfLeaf equ 0xfc
numOfBell equ 0xfd
numOfCherry equ 0xfe
numOfBoomerang equ 0xff

flower equ 1
leaf equ 2
bell equ 3
cherry equ 4
boomerang equ 5

numOfHeartsReceived equ 0xf1

mov r1, #4
mov r0, numOfFlowers
clearNumOfRegs: mov @r0, #0d
        inc r0
        djnz r1, clearNumOfRegs
;if you reach this all numOfXXXX registers are zeroed

mov r0, #values1
mov r1, #flower

mov a, #6 ; innercounter
mov b, #5 ; outercounter
checkfornextpossibleitem:   mov r2, a; backup countervar
                mov a, @r0 ; store given value in a
                xrl a, @r1 ; xor a with item
                jnz nextItem ; if value!=item -> nextitem
                mov a, #numOfFlowers ;if you end up here a=0 (ie value == item) --> generate addr for numOfReg <-- load a with addr for numOfFlowers
                add a, r1 ; since items are only numbers you can add the item to get the addr for numOfReg a=addr(numOfReg)
                xch a, r1 ; change the item with the addr as r1 is indirect register
                inc @r1 ; increment numOfRegister
                xch a, r1; r1 = item
                ;next item
                nextItem:   inc r1 ; increment item
                        mov a, r2 ; restore counter
                        dec a; decrement counter
                        cjne a, #0, checkfornextpossibleitem
                        ;if you reach this you have successfully tested one value against all items and therefor the next value must be tested
                        mov a, #6; reset the innercounter
                        dec b; decrement the outercounter
                        inc r0; increment the register that points to the value-under-test
                        xch a,b; cjne works with a but not with b therefor exchange them
                        cjne a, #0, here ; do the comparison; if you dont jump here you have tested all values
                        jmp howManyPairsDoIHave; if you didnt jump above you have the now the number of flowers and so on
                        here:   xch a,b ; and change back
                            jmp checkfornextpossibleitem ; check the next value
howManyPairsDoIHave:    mov r0,#0; store numOfPairsHere initialize with zeros
            mov r1, numOfFlowers;
            mov b, #6; use as counter to know when you went through all numOfRegisters
analyseNumOfRegister:   mov a, @r1 ; load the numOfregister for some math
            xrl a, #2; a will contain zero if numOfXXX = 2
            jnz numOfXXXWasNot2; if you do not jump here you have 2 XXX therefor
            inc r0; increment the number of pairs
            jmp nextNumOfRegister; continiue with the next one
            numOfXXXWasNot2:    mov a, @r1; restore the number of XXX and try the next magic value
                        xrl a, #3; will contain zero if you have a three of a kind
                        jnz no3XXX; if you dont jump here however you have a three of a kind
                        jz add300Coins
                        no3XXX:     mov a, @r1; restore number of XXX
                                xrl a, #4; a will contain zero if 4 of a kind
                                jnz nextNumOfRegister; if you numOfXXX!=4 you can only continiue trying to find something in the next numof register
                                jz add777Coins; if you didnt jump above how ever you will have to add the 777 coins as you detected a 4 of a kind
nextNumOfRegister:  inc r0; move pointer to the next numofregister
            djnz b, analyseNumOfRegister; if you havent already analysed all numofregisters then continue
            ; if you have however you end up here so you will have to take a look at the numOfPairs
            cjne r0, #1, tryIf2Pairs; test if you have 1 pair if not try if you have 2
            jmp add100Coins; if you have 1 pair however add the 100 coins
            tryIf2Pairs:    cjne r0, #2, youMustHave0Pairs; test if you have 2 pairs if not you can be sure to have 0 of them
                    jmp add200Coins; if you have 2 pairs however add them
youMustHave0Pairs:  ; add 10 coins
            inc coinStackTens
            mov a, coinStackTens
            cjne a, #10d, howManyHearts ; if your tens digit isnt outta range continue with the calculation of the number of hearts
            inc coinStackHundreds; if it is outta range do correct that
            mov coinStackTens, #0
            jmp howManyHearts;
add100Coins:    inc coinStackHundreds; here the digit can not possibly have an invalid value...
        jmp howManyHearts
add200Coins:    mov a, coinStackHundreds
        add a, #2
        mov coinStackHundreds, a
        jmp howManyHearts ; also here no invalid values possible
add300Coins:    mov a, coinStackHundreds
        add a, #3
        mov coinStackHundreds, a
        jmp howManyHearts ; same again
add777Coins:    mov r0, #coinStackOnes
        mov r2, #3
add7:       mov a, r0
        mov r1, a
        mov a, @r0
        add a, #7
        mov b, a; b contains the possibly invalid version of the ones digit
        da a; if you have an invalid value its lower nibble gets corrected this way
        anl a, 0x0f; and the higher one gets corrected this way
        xch a,b; a and b must be swapped in order to make subb work ie b contains now the corrected value and a has the maybe faulty value
        subb a,b; returns zero if all the corrections had no effect therefor the next digit can be increased by 7
        jz nextDigit
        inc r1
        inc @r1
        nextDigit:  inc r0
                djnz r2, add7;

howManyHearts:  mov numOfHeartsReceived, coinStackHundreds
loop_forever:   sjmp loop_forever
        END

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Levenshtein Neighbours
Most square numbers have at least 1 different square number with which their Levenshtein distance is exactly 1. For a given square \$x\$, each square that meets this condition is called a Levenshtein neighbour of \$x\$. For example, \$36\$ is a Levenshtein neighbour of \$16\$, as only 1 edit (\$1 \to 3\$) is required. However, \$64\$ is not a Levenshtein neighbour of \$16\$, as it requires a minimum of 2 edits. Numbers that have leading 0s (\$2025 \to 025\$) are not Levenshtein neighbours.
Your task is to take a square number as input and to output, in any reasonable format, the complete list of it's Levenshtein neighbours. You may include repeat neighbours in the list, if you wish, but you may not include the original input, as it isn't a Levenshtein neighbour of itself.
Any reasonable format should include some sort of separator between the outputs, such as , or a newline, and can output characters with the corresponding Unicode value (i.e. brainfuck) rather than the numbers themselves. The order of the output doesn't matter.
This input will always be a square number, greater than \$0\$. Your program should have no theoretical limit, but if it fails for large numbers for practical reasons (e.g. beyond 32-bit numbers), that's completely fine.
If the input does not have any Levenshtein neighbours, the output must clearly reflect this, such as outputting nothing, an empty array/string, a negative integer, \$0\$, etc.
This is code-golf, so the shortest code in bytes wins.
Test cases
These are the results for the squares of \$1\$ through to \$20\$:
  1: 4, 9, 16, 81
  4: 1, 9, 49, 64
  9: 1, 4, 49
 16: 1, 36, 169, 196
 25: 225, 256, 625
 36: 16, 361
 49: 4, 9
 64: 4
 81: 1, 841
100: 400, 900, 1600, 8100
121: 1521
144: 1444
169: 16, 1369
196: 16, 1296, 1936
225: 25, 625, 1225, 2025, 4225, 7225
256: 25
289: 2809
324: 3249
361: 36, 961
400: 100, 900, 4900, 6400

In addition, 1024 does not have any neighbours, so is a good test case.

Does changing the first digit to a leading zero count as a neighbor?

More interesting would be what the neighbours of 2025 are.

If a number is a neighbor in more than one way, can we include in multiple times in the output?

Unless I'm missing something, 32 * 32 = 1024 has no square Levenshtein neighbours.

@xnor Changing the first digit to a leading zero, or removing a digit to result in a leading 0 does not count as a neighbour. The 81 test case removes the 8, rather than substituting it for a 0. Yes, you may include repeat neighbours if you wish

@xnor Yes, I believe you are right, 1024 does not have any Levenshtein neighbours, I'll edit that example in

For all statements of the form "For all...", if a counterexample can be found, then this is a rigorous disproof of the statement. (But if I'm wrong, I'll accept a counterexample as a rigorous disproof.)

@cairdcoinheringaahing What would constitute a rigorous disproof? The code I wrote found 32 to give an empty list, as did many numbers. I could list all the neighbors I guess and say they're not squares.

Hmm, I don't think I can define a 'rigorous proof' well enough, so I guess I'll remove the bounty :/ @xnor

@cairdcoinheringaahing That's fine, I don't think it would really be fair to have a bounty for "Who's the fastest to write code that solves the challenge and run it on some numbers?"

Specific counterexamples asides, I can also give a heuristic argument to expect that not all squares have a square neighbor. A number x has a number of neighbors proportional to its digit length, so asymptotically log(x) up to a constant, whereas the density of squares around x's size is 1/sqrt(x) up to a constant. Since log(x) grows much slower than sqrt(x), for large x, the expected number of square neighbors goes to zero. So, in fact, any large square is a counterexample with high probability.

May we include the original number in the output? For example 49 -> 4, 9, 49.

@RobinRyder I'm going to say no, as it isn't a Levenshtein neighbour of itself

05AB1E,  11 10  6 bytes
-4 thanks to Grimy !! (square first rather than looking for squares saves 3; use 10^n saves 1)
°Lnʒ.L

Takes an integer, outputs a, possibly empty, list
Try it online! - This is crazy-slow due to the °, so no point trying it even for 9.
Or Try a slightly faster version - This one adds eight instead with 8+ then uses the same approach.
How?
°Lnʒ.L - f(integer)    stack = n
°      - push 10^n             10^n
 L     - range                 [1,2,3,...,10^n]
  n    - square                [1,4,9,...,10^2n]
   ʒ   - filter keep if == 1:
    .L -   Levenshtein distance

The 9s« in your 11-byter could have been 9ì. Nice to-the-point answer, though! +1 from me.

Slower 7: т+Lnʒ.L. Ridiculously slow 6: °Lnʒ.L. Infinitely slow 5: ∞nʒ.L.

@Grimy Thanks - why on earth did I not think to square first :/. Is that infinite one acceptable for a "show all" question? (I see we can submit generators as function submissions, but if there is no coded stop point then we cannot know when it's given us the final value).

I don't think ∞nʒ.L is acceptable as an answer because submissions have to terminate. Unrelated: your TIO link for the 7-byte version uses 9ì, which is ~100x slower than T+ for large numbers. My comment used т+ (add 100) to be safe, but it turns out 8+ is enough in all cases.

@Grimy oops, thanks. I figured 100 was overkill since 1 only needs to check the first 9 squares.

Retina 0.8.2, 142 138 bytes
.?
$'¶$`#$&$'¶$`#$'¶$`$&
#
0$%'¶$%`1$%'¶$%`2$%'¶$%`3$%'¶$%`4$%'¶$%`5$%'¶$%`6$%'¶$%`7$%'¶$%`8$%'¶$%`9
A`^0
Dr`
\d+
$*
-2G`(\b1|11\1)+\b
%`1

Try it online! Explanation:
.?
$'¶$`#$&$'¶$`#$'¶$`$&

For each digit, try a) removing it b) preceding it with a different
digit c) changing it to a different digit. For now, the different digit is marked with a #.
#
0$%'¶$%`1$%'¶$%`2$%'¶$%`3$%'¶$%`4$%'¶$%`5$%'¶$%`6$%'¶$%`7$%'¶$%`8$%'¶$%`9

For each potential different digit, substitute each possible digit.
A`^0

Remove numbers that now begin with zero.
Dr`

Remove all duplicated numbers. (This just leaves the lines blank.)
\d+
$*

Convert to unary.
-2G`(\b1|11\1)+\b

Keep all square numbers except the last (which is always the input number).
%`1

Convert the remaining numbers back to decimal.

R, 42 41 bytes
-1 byte with the bound \$(9n)^2\$.
function(n,y=(1:(9*n))^2)y[adist(n,y)==1]

Try it online!
All Levenshtein neighbours of \$n\$ are smaller than \$91n\$ (That bound is attained, for example, by \$1\to 91\$ or \$100\to9100\$). Here, I am using instead the bound \$(9n)^2=81n^2\$. For \$n>1\$, \$81n^2>91n\$ so we are fine. For \$n=1\$, this bound misses one Levenshtein neighbour: \$1\to91\$; since \$91\$ is not a square, we are fine.
Lists all square numbers between \$1\$ and \$(9n)^2\$, and keeps those with Levenshtein distance equal to 1.

Python 2, 173 167 149 148 147 144 139 138 bytes
lambda n,I=int:{(I(I(v)**.5)**2==I(v))*I(v)for v in[`n`[:i]+`j-1`[:j]+`n`[i+k:]or 0for j in range(11)for i in range(n)for k in 0,1]}-{0,n}

Try it online!
19+3+5+1=28! bytes thx to Jonathan Allan.

Save 48.  [p for p in...]is redundant. We can return a set (or duplicates). '0'<v[:1] can be '1'<=v. It's much slower but range(len(a)+1) can be range(n). Use a variable for i and i+1 slices to avoid the sum. Use a lambda. EDIT save 48 from your previous.

@Jonathan Allan: I'd already made some of the same changes; but definitely appreciate the 18 bytes!

Another one

@Jonathan Allan: Nice! It's now barely readable :).

Ooh - three more :)

...and another six!

@Jonathan Allan: Lol, I'm just gonna stop updating - I can't keep up! :)

I really think that's all I have (I saved one more above in an edit though)

Oracle SQL, 93 bytes
select level*level from t where utl_match.edit_distance(x,level*level)=1connect by level<10*x

Test in SQL*PLus.
SQL> set heading off
SQL> with t(x) as (select 225 from dual)
  2  select level*level from t where utl_match.edit_distance(x,level*level)=1connect by level<10*x
  3  /

         25
        625
       1225
       2025
       4225
       7225

6 rows selected.

Jelly, 53 38 bytes
D;Ɱ⁵ṭJœP,œṖjþ⁵Ẏṭ@ḢF${ʋʋ€$ƲẎ%⁵1ị$ƇḌÆ²Ƈḟ

Try it online!
There’s no built-in for Levenshtein distance so generates all possible 1-distance edits and then excludes those with leading zero and keeps only perfect squares. Doesn’t filter duplicates (as permitted).

JavaScript (V8),  129 125  123 bytes
Takes input as a string. Prints the Levenshtein neighbours to STDOUT.
s=>{for(t=9+s;t;t--)(t+='')**.5%1||(g=m=>m*n?1+g(m,--n)*(g(--m)-(s[m]==t[n++]))*g(m):m+n)(s.length,n=t.length)-1||print(t)}

Try it online!
Commented
s => {                        // s = input
  for(                        // loop:
    t = 9 + s;                //   start with t = '9' + s
    t;                        //   repeat while t > 0
    t--                       //   decrement t after each iteration
  )                           //
    (t += '')                 //   coerce t to a string
    ** .5 % 1 ||              //   abort if t is not a square
    ( g =                     //   g is a recursive function to test whether the
                              //   Levenshtein distance between s and t is exactly 1
      m =>                    //   m = pointer into s (explicit parameter)
                              //   n = pointer into t (defined in the global scope)
        m * n ?               //     if both m and n are greater than 0:
          1 +                 //       add 1 to the final result and add the product of:
          g(m, --n) * (       //         - a recursive call with m and n - 1
            g(--m) -          //         - a recursive call with m - 1 and n - 1
            (s[m] == t[n++])  //           minus 1 if s[m - 1] = t[n - 1]
          ) *                 //
          g(m)                //         - a recursive call with m - 1 and n
        :                     //       else:
          m + n               //         stop recursion and return m + n
    )(s.length, n = t.length) //   initial call to g with m = s.length, n = t.length
    - 1 ||                    //   abort if the final result is not 1
    print(t)                  //   otherwise, print t
}                             //

I knew SpiderMonkey had print() but I didn't realise Node had it as well...

@Neil Actually, it doesn't exist in Node. I think this version is just a shell build of V8 -- which is much closer to the browser version.

PHP, 62 bytes
for(;$argn*92>$n=++$i**2;levenshtein($argn,$n)==1&&print$n._);

Try it online!
This script prints Levenshtein neighbors of input separated by _ with a trailing separator, and if no neighbors are found, prints nothing.
Happily PHP has a built-in for Levenshtein distance! This script loops over all square numbers from 1 to input * 91, since all valid Levenshtein neighbors (distance of 1) are in that range. Then prints every number in that range which has a Levenshtein distance of 1 with the input.

Wolfram Language (Mathematica), 62 59 bytes
f@n_:=Select[Range[9n]^2,EditDistance@@ToString/@{n,#}==1&]

Try it online!
Using the bound from the R answer.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/