Con desafíos como Salida con la misma longitud que el código y Crear salida dos veces la longitud del código , pensé en un desafío separado pero similar.

La tarea es producir una salida. Puede ser una cadena, una lista de caracteres o el formato de salida predeterminado de su programa. Sin embargo, su salida siempre debe tener la misma longitud, independientemente de la entrada. Y lo más importante, la salida debería ser diferente para diferentes entradas .

Entrada

Un número entero $n$ , cuyos rangos están determinados por la elección del idioma. Si su idioma tiene enteros de longitud variable, el rango es $-2^{31} \leq n < 2^{31}$ .

Salida

Una cadena o una lista de caracteres, o una impresión en STDOUT o STDERR. Solo puede usar uno de estos métodos. La salida debe tener la misma longitud independientemente de la entrada, pero depende de usted definir qué longitud es. La salida puede no contener los caracteres de dígitos 0-9o el signo menos- . La salida debe ser determinista .

Debería poder demostrar que para cada salida solo hay una entrada posible , ya sea mediante una prueba formal, un argumento o una búsqueda de fuerza bruta.

Esta es una pregunta de código de golf, así que elimine los bytes extraños. Todos los idiomas son bienvenidos, ¡cuanto más mejor!

JavaScript (ES8), 33 bytes

Espera la entrada en el rango de enteros JS seguros : $-2^{53}\le n < 2^{53}$ .

Devuelve una cadena de 76 caracteres.

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

Pruébalo en línea!

¿Cómo?

Paso 1

La entrada se convierte primero a binario. Esto conserva el signo menos inicial para números negativos.

Ejemplos:

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

Paso 2

La cadena resultante está codificada en base-64.

Significa que cada bloque de 1 a 3 caracteres se convertirá en un nuevo bloque de 4 caracteres. Esta conversión es segura porque ninguno de los bloques resultantes contiene los símbolos prohibidos (dígitos o signo menos).

Bloques de 3 caracteres

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

Se debe codificar un único bloque final de 1 o 2 caracteres si la longitud de la cadena binaria no es múltiplo de 3:

Bloques de 1 carácter

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

Bloques de 2 caracteres

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

Paso 3

La salida final se rellena con espacios finales.

Python 3 , 49 39 bytes

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

Pruébalo en línea!

-10 bytes gracias a siete negativos

Convierte el entero en hexadecimal y antepone espacios de hasta 9 caracteres en total. Luego, dobla el código ASCII de cada carácter en la cadena (algunos se extienden fuera de ASCII en Unicode, pero Python lo maneja bien), generando una lista de caracteres.

Esto funciona porque cada dígito, incluyendo - , se asigna a un carácter ASCII diferente. No hay enteros entre -2147483648y 2147483648son iguales, por lo que convertirlos a espacios hexadecimales y anteriores no los haría iguales. Luego, asignarlos a diferentes puntos de código no conduce a colisiones, por lo que todavía no hay dos valores en el rango que conduzcan a salidas iguales.

Pitón 3 , 59 56 47 bytes

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

Pruébalo en línea!

-3 bytes gracias a Jitse

-9 bytes gracias a siete negativos

Mismo algoritmo, pero usando en maplugar de un forbucle.

05AB1E , 11 5 bytes

тjÇ·ç

-6 bytes portando el enfoque de @Stephen , ¡así que asegúrate de votarlo!

Salidas de una lista de hasta 100 caracteres, con $100-(\text{input length})$ cantidad de @(el doble del punto de código espacio), y todo -0123456789asignada a Z`bdfhjlnpr(el doble de los puntos de código ASCII).

Pruébalo en línea.

Explicación:

 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)

Respuesta original de 11 bytes :

Ķ×AIdè«žIj

Pruébelo en línea (limitado a en 1000lugar de 2147483648).

Explicación:

La longitud de salida es siempre 2.147.483.648 caracteres de longitud. Saldrá $2147483648-|n|-1$ cantidad de espacios, junto con $|n|$cantidad de nuevas líneas, agregada con una 'a' si $n\lt0$ o 'b' si $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 requiere celdas, donde $c_n \in \mathbb{N}$ , pero si desea resultados consistentes, asegúrese de que $c_n < 256$

Obviamente, la salida será única, independientemente del número que ingrese ( $-\infty \lt n \lt \infty$ ). Si el entero es más corto, el programa rellenará la salida para que coincida exactamente $\infty$ bytes, por lo que la longitud es siempre la misma.

Esta respuesta es un poco desafiante al desafío, ya que no indicó que la salida tiene que ser finita.

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

Pruébalo en línea!

Respuesta original de 28 bytes:

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

Éste rellenará la salida para que sea exactamente $2^8 - 1$ bytes. El mecanismo de conversión de números funciona igual aquí. Este programa asume lo mismo que el programa anterior.

Python 3 , 39 bytes

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

Pruébalo en línea!

Convierte el número dado en una representación de cadena binaria (rellena con espacios), luego asigna los caracteres (space)-01a caabcon la str.translatefunción.

Jalea , 4 bytes

œ?ØẠ

Un enlace monádico que acepta un número entero que produce una lista de 52 caracteres.

El rango de entrada puede ser hasta algo más de $-2^{223} \leq n \lt 2^{223}$ ya que $52!>2^{224}$.

Pruébalo en línea!

¿Cómo?

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

Asi que...

-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

Rubí , 27 bytes

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

Pruébalo en línea!

('%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.

Jelly, 6 bytes

Ø%+ṃØA

Try it online!

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

C (gcc), 38 bytes

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

Try it online!

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

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

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

Try it online!

Haskell, 31 bytes

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

Try it online!

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

C # (compilador interactivo de Visual C #) , 52 bytes

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

Pruébalo en línea!

Un enfoque diferente para la solución ac # aprovecha el hecho de que el módulo c # es negativo para los números negativos. Supongo que podría eliminar un byte o dos si permite caracteres que no se muestran ('\ 0', etc.) actualizando +65...para no compensar el valor del carácter a algo legible por humanos.

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

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

Pruébalo en línea!

Previamente:

Perl 5 -p, 29 bytes

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

Try it online!

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

T-SQL, 73 70 61 bytes

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

Solo estoy reemplazando directamente los dígitos (y -) con letras, después de STRrellenar el entero a 11 caracteres. No es necesaria la conversión a hexadecimal o binario.

TRANSLATE se introdujo en SQL 2017.

La entrada es a través de una tabla preexistente $t$ con columna INT $n$, según nuestras reglas de IO . El rango del INTtipo de datos en SQL es$-2^{31} \leq n < 2^{31}$.

EDITAR : guardado 3 bytes reemplazando el relleno manual con una conversión a CHAR (11), que es un formato de caracteres de ancho fijo que se rellena automáticamente con espacios.

EDIT 2 : guardado 9 bytes mediante el uso de la STR()función en lugar de CAST. STRconvierte un número en una cadena de texto rellenada a la longitud especificada.

APL (Dyalog Unicode) , 28 bytes

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

Pruébalo en línea!

Dfn simple, tomando un argumento entero. Usos ⎕IO←0.

TIO se vincula a un caso de prueba de -2^10a 2^10. La 0~⍨parte elimina el duplicado 0de los argumentos.

Cómo:

{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

Creo que esto es correcto Inspirado en la solución Python de Stephen, así que por favor +1.

¤ùI cÑ

Intentalo

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

Esta respuesta es súper engañosa, porque siempre produce la misma cantidad de entrada, que es igual a $\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

Pruébalo en línea!

Perl 6 , 12 bytes

*~|('@'x 11)

Pruébalo en línea!

Anónimo Cualquiera que sea la lambda que tome un número y la cadena OR con 11 @s. Esto asigna los dígitos pqrstuvwxyy el guión a m, luego rellena la cadena a 11 caracteres con @s

Perl 5 (-p), 9 bytes

$_^=A x$=

Pruébalo en línea!

Bitwxise-xor de la entrada con la cadena AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.

Wolfram Language (Mathematica) , 44 33 bytes

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

Pruébalo con un dominio más pequeño

-2 gracias a Greg Martin

Imprime >> , seguido de la representación de cadena de 523069747202 caracteres de una lista de$13!+n$ Nulls acolchado por Trues hasta una longitud de$14!$, y una nueva línea. Funciona en el dominio.$[-13!,14!-13!)$, que es un superconjunto de $[-2^{31},2^{31})$.

Dado el tamaño de la salida, he incluido un caso de prueba con un dominio más pequeño de $[-2^4,2^4)$ en lugar

Stax , 6 bytes

11){Hm

Ejecutar y depurarlo

Procedimiento:

1. Entrada del pad izquierdo a 11 caracteres.
2. Duplica cada carácter ascii no espacial.

PHP , 64 54 bytes

-10 bytes usando la strtrfunción en lugar del reemplazo manual de caracteres.

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

Pruébalo en línea!

El valor int más grande posible en PHP a partir de ahora es de 922337203685477580719 dígitos, considerando el signo menos en números negativos, será 20. El código anterior reemplaza el signo menos ( -) con el Acarácter y cada dígito de 0a 9con un carácter de Da My luego rellena la cadena a la derecha con un espacio para que siempre tenga 20 caracteres de longitud. Por ejemplo, la salida para la entrada de -9876543210es "AMLKJIHGFED " .

La salida es único para cada entrada de número entero y se puede obtener de nuevo a la entrada mediante la eliminación de todos los espacios, reemplazando Acon -y sustituir Da Mla 0de 9.

PHP , 44 bytes

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

Pruébalo en línea!

Esta es la misma idea que la respuesta de Arnauld . Convierte la entrada a binario y luego la convierte a base-64. También lo agrega a 88 caracteres (la longitud más grande es para -922337203685477580788 caracteres) con el espacio en blanco a la derecha para obtener siempre la misma longitud en la salida.

Retina 0.8.2 , 21 bytes

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

Pruébalo en línea! Siempre da salida a 11 caracteres de la gama n.. z. Explicación:

T`p`l

Traduzca los caracteres ASCII imprimibles a las letras minúsculas. Este mapas -a ne 0.. 9a q.. z. (¡Es realmente afortunado que los dígitos sean los caracteres ASCII imprimibles del 16 al 25!)

$
10$*o

Añadir 10 os. Como la entrada tendrá entre 1 y 11 caracteres, ahora hay entre 11 y 21 caracteres.

!`.{11}

Extrae los primeros 11 caracteres. Como hay menos de 22 caracteres, esto solo coincidirá una vez.

Carbón de leña , 9 bytes

◧⍘﹪ＮＸχχαχ

Pruébalo en línea! El enlace es a la versión detallada del código. Siempre genera 10 espacios y letras mayúsculas. Explicación:

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

Pruébalo en línea!

Parece que la salida es aleatoria, ¡pero no lo es! La entrada se utiliza como semilla del generador de números pseudoaleatorios, y luego obtenemos uno de los$26!=4\cdot 10^{26}$permutaciones del alfabeto. La salida siempre es de longitud 51 (26 letras + 25 espacios).

Todavía existe el problema de asegurar que todos los resultados sean diferentes. Terminamos con$2^{32}\approx 4\cdot 10^9$ permutaciones (fuera de $4\cdot 10^{26}$) Si pretendemos que las permutaciones se distribuyen uniformemente al azar, entonces la probabilidad de que todas las permutaciones sean diferentes se puede calcular siguiendo los mismos cálculos que para el problema de cumpleaños . La probabilidad de que 2 salidas específicas sean idénticas es$10^{-17}$, entonces una aproximación de primer orden de la probabilidad de que todos $2^{32}$ las salidas son distintas es

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

que está lo suficientemente cerca de 1 para mí.

brainfuck , 20 19 bytes

-1 byte gracias a Krzysztof Szewczyk

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

Pruébalo en línea!

Emite el número con cada dígito y guión mapeado a 255 menos su valor ordinal, rellenado a 255 caracteres con bytes NUL.

R , 40 37 bytes

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

Pruébalo en línea!

Una alternativa a la respuesta de Robin Ryder ; Esto es ciertamente determinista.

Esto convierte la entrada a un rawvector de 32 bytes, cada byte es un número hexadecimal 00o 01representa los bits del entero. A continuación, coaccionar a una logicalmediante la comparación de 0, por lo que 00se asigna a FALSEy 01a TRUE. Luego, necesitamos eliminar una sola letra de cada una FALSEpara garantizar una salida de igual longitud, seleccionada arbitrariamente para ser S. El resultado se imprime (con espacio) para una longitud 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)

Pruébalo en línea!

Esta solución supera los long longlímites de los enteros de Zsh trabajando solo con caracteres. Sólo dirigí a 30 caracteres para facilitar la lectura, pero sustituyendo 30con 99permitiré que este método funcione en todos los números de -1E99+1a 1E100-1.

El efecto de interpretar los códigos decimales como hexadecimales es el siguiente:

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}

Pruébalo en línea!

Declara x como un número binario, rellenado con ceros hasta un ancho de 66. Luego asigna 0→ ay 1→ b. También asignamos 2y -a a, ya que esos caracteres están impresos en [[-]][base]#[num]notación. Para ver cómo se $xve antes del reemplazo y los límites de Zsh para analizar tipos enteros, verifique la salida de depuración en el enlace TIO.

Java (JDK) , 42 bytes

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

Pruébalo en línea!

Primero, esto crea la representación hexadecimal de la entrada, rellena a la izquierda con espacios que proporciona la misma restricción de longitud (8 caracteres de longitud), elimina el signo menos y mantiene cada salida intermedia única.

Esto proporciona una cadena con 17 caracteres posibles diferentes: 0123456789abcdefy espacio.

Luego, cada personaje se transmite y se asigna agregando 64 a su punto de código si es un dígito o un espacio. Efectivamente, esto da como resultado la siguiente asignación: 0123456789abcdef<space>a la pqrstuvwxyabcdef`que tiene 17 caracteres diferentes, por lo que no habrá dos números que den como resultado la misma salida.

Bash , 30 bytes

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

Pruébalo en línea!

Para demostrar que la salida es única, busqué en Google las colisiones MD5 y no encontré resultados dentro de los enteros entre $-2^{31}$ y $2^{31}$. Para evitar tener caracteres prohibidos en la salida, simplemente traduzca los caracteres en cuestión como letras mayúsculas. La salida siempre tiene la misma longitud por definición, y se garantiza que no contiene caracteres prohibidos.