Em desafios como Saída com o mesmo tamanho do código e Criar saída com o dobro do tamanho do código , pensei em um desafio separado, mas semelhante.

A tarefa é produzir uma saída. Pode ser uma string, uma lista de caracteres ou qualquer que seja o formato de saída padrão do seu programa. No entanto, sua saída deve sempre ter o mesmo comprimento, independentemente da entrada. E mais importante, a saída deve ser diferente para diferentes entradas .

Entrada

Um único número inteiro , cujos intervalos são determinados pela escolha do idioma. Se o seu idioma tiver números inteiros de comprimento variável, o intervalo será .$n$$-2^{31} \leq n < 2^{31}$

Saída

Uma sequência ou uma lista de caracteres ou uma impressão em STDOUT ou STDERR. Você pode usar apenas um desses métodos. A saída deve ter o mesmo comprimento, independentemente da entrada, mas cabe a você definir qual o comprimento. A saída pode não conter os caracteres de dígito 0-9ou o sinal de menos- . A saída deve ser determinística .

Você deve poder provar que, para cada saída, existe apenas uma entrada possível , seja por uma prova formal, um argumento ou uma busca por força bruta.

Esta é uma questão de código de golfe, portanto, retire todos os bytes estranhos. Todos os idiomas são bem-vindos, quanto mais, melhor!

JavaScript (ES8), 33 bytes

Espera a entrada no intervalo de inteiros JS seguros : .$-2^{53}\le n < 2^{53}$

Retorna uma sequência de 76 caracteres.

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

Experimente online!

Quão?

Passo 1

A entrada é primeiro convertida em binário. Isso preserva o sinal de menos à esquerda para números negativos.

Exemplos:

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

Passo 2

A sequência resultante é codificada na base-64.

Isso significa que cada bloco de 1 a 3 caracteres será transformado em um novo bloco de 4 caracteres. Essa conversão é segura porque nenhum dos blocos resultantes contém os símbolos proibidos (dígitos ou sinal de menos).

Blocos de 3 caracteres

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

Um único bloco final de 1 ou 2 caracteres deve ser codificado se o comprimento da cadeia binária não for múltiplo de 3:

Blocos de 1 caractere

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

Blocos de 2 caracteres

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

etapa 3

A saída final é preenchida com espaços à direita.

Python 3 , 49 39 bytes

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

Experimente online!

-10 bytes graças a sete negativos

Converte o número inteiro em hexadecimal e precede espaços com até 9 caracteres no total. Em seguida, duplica o código ASCII de cada caractere na string (alguns se estendem para fora do ASCII em Unicode, mas o Python lida com isso), produzindo uma lista de caracteres.

Isso funciona porque cada dígito, inclusive -, é mapeado para um caractere ASCII diferente. Nenhum número inteiro entre -2147483648e 2147483648é igual, portanto, convertê-los em espaços hexadecimais e anteriores não os tornaria iguais. Em seguida, o mapeamento para diferentes pontos de código não leva a colisões, portanto ainda não existem dois valores no intervalo que levam a saídas iguais.

Python 3 , 59 56 47 bytes

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

Experimente online!

-3 bytes graças ao Jitse

-9 bytes graças a sete negativos

O mesmo algoritmo, mas usando em mapvez de um forloop.

05AB1E , 11 5 bytes

тjÇ·ç

-6 bytes portando a abordagem de @Stephen , por isso não deixe de votar nele!

Produz uma lista de até 100 caracteres, com uma quantidade de $100-(\text{input length})$ de @(o dobro do ponto de código do espaço) e todos -0123456789mapeados para Z`bdfhjlnpr(o dobro dos pontos de código ASCII).

Experimente online.

Explicação:

 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)

Resposta original de 11 bytes :

Ķ×AIdè«žIj

Experimente online (limitado a em 1000vez de 2147483648).

Explicação:

O comprimento da saída sempre tem 2.147.483.648 caracteres. Ele produzirá $2147483648-|n|-1$ quantidade de espaços, anexada com $|n|$quantidade de novas linhas, anexada com um 'a' se $n\lt0$ ou 'b' se $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

Este programa requer células, onde $c_n \in \mathbb{N}$ , mas se você deseja resultados consistentes, verifique se $c_n < 256$

A saída será obviamente única, independentemente do número que você digitar ( $-\infty \lt n \lt \infty$ ). Se o número inteiro for menor, o programa preencherá a saída para corresponder exatamente a $\infty$ bytes, portanto o comprimento é sempre o mesmo.

Essa resposta está um pouco ultrapassando o desafio, pois não afirmava que a saída deveria ser finita.

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

Experimente online!

Resposta original de 28 bytes:

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

Este irá preencher a saída com exatamente $2^8 - 1$ bytes. O mecanismo de conversão de números funciona da mesma maneira aqui. Este programa assume o mesmo que o programa acima.

Python 3 , 39 bytes

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

Experimente online!

Transforma o número fornecido em uma representação de sequência binária (preenchida com espaços) e mapeia os caracteres (space)-01para caabcom a str.translatefunção

Gelatina , 4 bytes

œ?ØẠ

Um link monádico que aceita um número inteiro que gera uma lista de 52 caracteres.

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

Experimente online!

Quão?

œ?ØẠ - 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.

Tão...

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

Ruby , 27 bytes

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

Experimente online!

('%34b'%n)Converte um número inteiro em sua representação binária, usando ..1para indicar um número negativo (isto significa representar um prefixo infinitamente longo de 1s), e o coloca à esquerda em 34 caracteres usando espaços. Em seguida, substituímos 0s por 'a' e 1s por 'h' para criar a representação da base maníaca 2: strings como "haaahahahaaha" são precedidos por espaços e algumas vezes ... Como cada passo aqui é invertível, é 1: 1.

Editar: deixe o registro mostrar que a @manatwork postou esta solução idêntica primeiro. Opa Eu deveria ter me refrescado.

Gelatina , 6 bytes

Ø%+ṃØA

Experimente online!

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

C (gcc) , 38 bytes

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

Experimente online!

Isso expande cada bit do número inteiro de entrada em um byte que é 0 ou 1 (que são caracteres não imprimíveis, mas não há regra contra isso). Portanto, a saída é sempre de 32 bytes e garantida como única.

C # (compilador interativo do Visual C #) , 35 bytes

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

Experimente online!

Haskell, 31 bytes

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

Experimente online!

Adiciona 2^60à entrada para que o número resultante tenha a mesma quantidade de dígitos para todo o intervalo de entrada. Transforme-se em uma string e mude cada caractere 10 lugares para a direita na ordem ASCII ( 0-> :... 9-> C).

C # (compilador interativo do Visual C #) , 52 bytes

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

Experimente online!

Uma abordagem diferente da solução ac # aproveita o fato de que o módulo c # é negativo para números negativos. Suponho que você poderia cortar um byte ou dois se você permitir caracteres não exibidos ('\ 0' e assim por diante) atualizando o +65...para não compensar o valor do caractere para algo legível por humanos.

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

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

Experimente online!

Anteriormente:

Perl 5 -p , 29 bytes

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

Experimente online!

Converte o número em sua representação binária de 64 bits, depois translitera 0e 1para ae b, respectivamente.

T-SQL, 73 70 61 bytes

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

Estou apenas substituindo diretamente os dígitos (e -) por letras, depois STRo número inteiro é preenchido com 11 caracteres. Nenhuma conversão para hexadecimal ou binária é necessária.

TRANSLATE foi introduzido no SQL 2017.

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

EDIT : economizou 3 bytes substituindo o preenchimento manual por uma conversão para CHAR (11), que é um formato de caractere de largura fixa que preenche automaticamente os espaços.

EDIT 2 : salvou 9 bytes usando a STR()função em vez de CAST. STRconverte um número em uma sequência de texto preenchida no comprimento especificado.

APL (Dyalog Unicode) , 28 bytes

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

Experimente online!

Dfn simples, usando um argumento inteiro. Usos ⎕IO←0.

O TIO vincula a um caso de teste de -2^10para 2^10. A 0~⍨parte remove a duplicata 0dos argumentos.

Quão:

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

Japonês , 6 bytes

Eu acho que isso está certo. Inspirado na solução Python de Stephen, então, por favor +1.

¤ùI cÑ

Tente

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

Malbolge , 2708 bytes

$\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

Experimente online!

Perl 6 , 12 bytes

*~|('@'x 11)

Experimente online!

Anônimo Qualquer que seja o lambda que pega um número e string ORs com 11 @s. Isso mapeia os dígitos para pqrstuvwxye o traço para m, em seguida, preenche a string com 11 caracteres com @s

Perl 5 (-p), 9 bytes

$_^=A x$=

Experimente online!

Bitwxise-xor da entrada com a sequência AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.

Wolfram Language (Mathematica) , 44 33 bytes

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

Experimente com um domínio menor

-2 graças a Greg Martin

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

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

Stax , 6 bytes

11){Hm

Execute e depure

Procedimento:

1. Entrada do teclado esquerdo para 11 caracteres.
2. Duplique cada caractere ascii não espacial.

PHP , 64 54 bytes

-10 bytes usando a strtrfunção em vez da substituição manual de caracteres.

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

Experimente online!

O maior valor int possível no PHP a partir de agora é 9223372036854775807que tem 19 dígitos, considerando o sinal de menos em números negativos, será 20. O código acima substitui o sinal de menos ( -) pelo Acaractere e todos os dígitos de 0para 9com um caractere de Daté Me, em seguida, aperta a corda à direita com caracteres de espaço para sempre ter 20 caracteres. Por exemplo, a saída para entrada de -9876543210é "AMLKJIHGFED ".

A saída é exclusiva para cada entrada inteira e você pode retornar à entrada removendo todos os espaços, substituindo Apor -e substituindo Dpor Mcom 0por 9.

PHP , 44 bytes

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

Experimente online!

Essa é a mesma idéia que a resposta de Arnauld . Converte a entrada em binário e depois em base-64. Também possui 88 caracteres (o comprimento maior -9223372036854775807corresponde a 88 caracteres), com o caractere de espaço à direita para obter sempre o mesmo comprimento na saída.

Retina 0.8.2 , 21 bytes

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

Experimente online! Sempre envia 11 caracteres da gama n.. z. Explicação:

T`p`l

Converta os caracteres ASCII imprimíveis em letras minúsculas. Isso mapeia -para ne 0.. 9para q.. z. (É realmente uma sorte que os dígitos tenham entre 16 e 25 caracteres ASCII imprimíveis!)

$
10$*o

Acrescente 10 os. Como a entrada terá entre 1 e 11 caracteres, agora existem entre 11 e 21 caracteres.

!`.{11}

Extraia os 11 primeiros caracteres. Como existem menos de 22 caracteres, isso corresponderá apenas uma vez.

Carvão , 9 bytes

◧⍘﹪ＮＸχχαχ

Experimente online! Link é a versão detalhada do código. Sempre gera 10 espaços e letras maiúsculas. Explicação:

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

R , 37 bytes

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

Experimente online!

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

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

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

que está perto o suficiente para 1 para mim.

brainfuck , 20 19 bytes

-1 byte graças a Krzysztof Szewczyk

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

Experimente online!

Gera o número com cada dígito e traço mapeado para 255 menos seu valor ordinal, preenchido com 255 caracteres com bytes NUL.

R , 40 bytes 37

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

Experimente online!

Uma alternativa à resposta de Robin Ryder ; isso é certamente determinístico.

Isso converte a entrada em um rawvetor de 32 bytes, cada byte sendo um número hexadecimal 00ou 01representando os bits do número inteiro. Em seguida, coagimos a a logicalcomparando com 0, portanto, 00é mapeado para FALSEe 01para TRUE. Em seguida, precisamos remover uma única letra de cada uma FALSEpara garantir uma saída de igual comprimento, selecionada arbitrariamente para ser S. O resultado é impresso (com espaço) para um comprimento de 169.

Zsh , 43 bytes

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

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

Experimente online!

Essa solução long longultrapassa os limites dos números inteiros do Zsh trabalhando apenas com caracteres. Eu preenchi apenas 30 caracteres para facilitar a leitura, mas a substituição 30por 99permitirá que esse método funcione em todos os números de -1E99+1até 1E100-1.

O efeito de interpretar os códigos decimais como hexadecimais são os seguintes:

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}

Experimente online!

Declara x como um número binário, preenchido com zero para uma largura de 66. Em seguida, mapeia 0→ ae 1→ b. Também mapeamos 2e -para a, uma vez que esses caracteres são impressos em [[-]][base]#[num]notação. Para ver a $xaparência antes da substituição e os limites do Zsh na análise de tipos inteiros, verifique a saída Debug no link TIO.

Java (JDK) , 42 bytes

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

Experimente online!

Primeiro, isso cria a representação hexadecimal da entrada, preenchida à esquerda com espaços que fornecem a mesma restrição de comprimento (8 caracteres), remove o sinal de menos e mantém cada saída intermediária exclusiva.

Isso fornece uma sequência com 17 caracteres possíveis diferentes: 0123456789abcdefe espaço.

Cada caractere é transmitido e mapeado adicionando 64 ao seu ponto de código, se for um dígito ou um espaço. Efetivamente, isso resulta no seguinte mapeamento: 0123456789abcdef<space>para o pqrstuvwxyabcdef`qual possui 17 caracteres diferentes, portanto, dois números não resultarão na mesma saída.

Bash , 30 bytes

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

Experimente online!

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