Salida con la misma longitud siempre


26

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 norte , cuyos rangos están determinados por la elección del idioma. Si su idioma tiene enteros de longitud variable, el rango es -231norte<231 .

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!


44
¿Debería el programa, en teoría, funcionar para alguna entrada? ¿O es suficiente usar un método que solo funcione para el rango especificado (limitado por ), no necesariamente debido a las limitaciones del idioma sino a las limitaciones del método? ±231
Sr. Xcoder

44
@ Mr.Xcoder, ¿cómo podría elegir una longitud si tuviera que trabajar para enteros de longitud arbitraria?
Stephen

2
@ Mr.Xcoder Solo debe probar que funciona para ese rango. Esta regla es para ayudar a lenguajes como Python, donde los números pueden tener miles de dígitos. Sin esa regla, sería mucho más difícil para Python y derivados de Python (que incluye muchos lenguajes de golf).
maxb

11
Si un idioma no tiene enteros de longitud variable pero puede admitir valores mayores que , ¿podemos usar el rango restringido - 2 31n < 2 31 ? 231-231norte<231
Arnauld

2
@Arnauld el rango máximo es de enteros con signo de 32 bits, independientemente de las limitaciones del idioma. El idioma solo puede disminuir ese rango.
maxb

Respuestas:


15

JavaScript (ES8), 33 bytes

Espera la entrada en el rango de enteros JS seguros : -253norte<253 .

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.


1
¿Sabía que estas combinaciones particulares de caracteres no contienen números cuando se convierten a base64, o lo descubrió experimentalmente?
Tomáš Zato - Restablece a Mónica el

@ TomášZato Esa fue una suposición segura, basada en el hecho de que es un juego de caracteres muy pequeño en la parte inferior de la tabla ASCII.
Arnauld

10

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.


2
Puede reducir 3 bytes en el mapenfoque reemplazando list( ... )con[* ... ]
Jitse

3
Podría crear la cadena acolchada con"%9x"%i
negativo siete

@negativeseven gracias, eso es realmente genial
Stephen

1
Podría permanecer dentro de ASCII y a 39 bytes en Python 2 usando`4e9+n`
Jonathan Allan

8

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-(longitud de entrada) 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-El |norteEl |-1 cantidad de espacios, junto con El |norteEl |cantidad de nuevas líneas, agregada con una 'a' si norte<0 0 o 'b' si norte0 0 .

Ä            # Get the absolute value of the (implicit) input-integer
 ¶×          # And have a string with that many newline characters
   A         # Push the lowercase alphabet
    Id       # Check if the input is non-negative (>=0) (1 if truthy; 0 if falsey)
      è      # Use that to index into the alphabet (so "a" for <0 and "b" for >=0)
       «     # Append that to the newline-string we created earlier
          j  # And prepend spaces to make the string of a length:
        žI   # 2147483648 (this has been replaced with `₄`/1000 in the TIO)
             # (after which the result is output implicitly)

7

brainfuck , 48 29 28 16 13 bytes

Este programa requiere celdas, donde donortenorte , pero si desea resultados consistentes, asegúrese de que donorte<256

Obviamente, la salida será única, independientemente del número que ingrese ( -<norte< ). Si el entero es más corto, el programa rellenará la salida para que coincida exactamente 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 28-1 bytes. El mecanismo de conversión de números funciona igual aquí. Este programa asume lo mismo que el programa anterior.


La salida infinita no
Jo King

@JoKing esto se dijo después de que hice esta respuesta. Pero si realmente te sientes lastimado por esto, simplemente puedo optar por salir del desafío y declarar la primera respuesta como no competitiva
Krzysztof Szewczyk


5

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 -2223norte<2223 ya que 52!>2224.

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

5

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.


3
Lol. Your output is much funnier than mine.
manatwork

4

Jelly, 6 bytes

Ø%+ṃØA

Try it online!

Since Jelly has arbitrary length integers, this monadic link takes an integer in the range ±231 and returns a length 7 alphabetic string. It works by adding 232 and then base decompressing into the capital letters.


4

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.


Enfoque inteligente, similar al relleno de respuesta Brainfuck con bytes NUL.
maxb

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);}
G. Sliepen

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


3

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


1
Does it handle negative numbers?
maxb

@maxb: no, pero ahora está arreglado.
nimi

3

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.


44? - Estoy imprimiendo caracteres no imprimibles (lo que parece estar bien) pero puede convertirlos en imprimibles agregando 65 como su respuesta actual.
dana

1
42 - Esta vez con caracteres imprimibles :)
dana

3

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.


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

... y que ningún hash md5 produce un carácter de dígito por casualidad?
AlexR

Olvidé el requisito de excluir dígitos. He actualizado para acomodar eso.
Xcali


2

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 norte, según nuestras reglas de IO . El rango del INTtipo de datos en SQL es-231norte<231.

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.


2

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.

2

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

2

Malbolge , 2708 bytes

Esta respuesta es súper engañosa, porque siempre produce la misma cantidad de entrada, que es igual a .

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!


1
Siendo Malbolge, podría dejarlo pasar ... ¡Fantástico trabajo!
maxb

2

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



2

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 de13!+norte Nulls acolchado por Trues hasta una longitud de14!, y una nueva línea. Funciona en el dominio.[-13!,14!-13!), que es un superconjunto de [-231,231).

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


Agradable :) creo que se puede guardar dos bytes cambiando 2^31y 2^32a 13!y 14!, respectivamente. A la pérdida de cierta "brevedad" en la salida ...
Greg Martin


1

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.


1

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.


1

Carbón de leña , 9 bytes

◧⍘﹪NXχχαχ

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:

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

1

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 los26!=4 41026permutaciones 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 con2324 4109 9 permutaciones (fuera de 4 41026) 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 es10-17, entonces una aproximación de primer orden de la probabilidad de que todos 232 las salidas son distintas es

1-exp(-264/ /26!)0.99999998

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


Si bien sí, es estadísticamente improbable que haya una colisión, eso no significa que sea imposible, ya que la pregunta lo pide
Jo King

2
Me gusta el cálculo de probabilidad. Supongo que podría ejecutar los 4 mil millones de entradas si realmente quisiera verificar las colisiones, pero si no tiene ganas de hacerlo, podría dejarlo pasar. Tal como está ahora, ha presentado un argumento convincente, y si alguien encuentra un contraejemplo, tendría que modificar su envío.
maxb


1

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.


1

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 0ay 1b. 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.


1

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.


1

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 -231 y 231. 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.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.