Sortie avec la même longueur toujours

26

Avec des défis comme Output avec la même longueur que le code et Create output deux fois la longueur du code , j'ai pensé à un défi séparé, mais similaire.

La tâche consiste à produire une sortie. Il peut s'agir d'une chaîne, d'une liste de caractères ou du format de sortie par défaut de votre programme. Cependant, votre sortie doit toujours être de la même longueur, quelle que soit l'entrée. Et plus important encore, la sortie doit être différente pour différentes entrées .

Contribution

Un seul entier n , dont les plages sont déterminées par le choix de la langue. Si votre langue a des entiers de longueur variable, la plage est 231n<231 .

Sortie

Une chaîne ou une liste de caractères, ou une impression vers STDOUT ou STDERR. Vous ne pouvez utiliser qu'une de ces méthodes. La sortie doit être de la même longueur quelle que soit l'entrée, mais c'est à vous de définir de quelle longueur il s'agit. La sortie peut ne pas contenir les caractères numériques 0-9ou le signe moins- . La sortie doit être déterministe .

Vous devriez pouvoir prouver que pour chaque sortie, il n'y a qu'une seule entrée possible , soit par une preuve formelle, un argument ou une recherche par force brute.

Ceci est une question de code de golf, donc rase tous les octets étrangers. Toutes les langues sont les bienvenues, mieux c'est!

maxb
la source
4
Le programme devrait-il en théorie fonctionner pour n'importe quel apport? Ou suffit-il d'utiliser une méthode qui ne fonctionne que pour la plage spécifiée (délimitée par ), pas nécessairement en raison de limitations de langue mais de limitations de méthode? ±231
M. Xcoder
4
@ Mr.Xcoder comment pourriez-vous choisir une longueur si vous deviez travailler pour des entiers de longueur arbitraire?
Stephen
2
@ Mr.Xcoder Vous devez seulement prouver que cela fonctionne pour cette gamme. Cette règle consiste à aider des langages tels que Python, où les nombres peuvent être des milliers de chiffres. Sans cette règle, ce serait beaucoup plus difficile pour Python et les dérivés Python (qui incluent de nombreux langages de golf).
max
11
Si une langue n'a pas d'entiers de longueur variable mais peut prendre en charge des valeurs supérieures à , sommes-nous autorisés à utiliser la plage restreinte - 2 31n < 2 31 ? 231231n<231
Arnauld
2
@Arnauld la plage maximale est des entiers signés 32 bits, quelles que soient les limites de la langue. La langue ne peut que diminuer cette plage.
max

Réponses:

15

JavaScript (ES8), 33 octets

Attend l'entrée dans la plage d' entiers JS sûrs : 253n<253 .

Renvoie une chaîne de 76 caractères.

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

Essayez-le en ligne!

Comment?

Étape 1

L'entrée est d'abord convertie en binaire. Cela préserve le signe moins de tête pour les nombres négatifs.

Exemples:

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

Étape 2

La chaîne résultante est codée en base-64.

Cela signifie que chaque bloc de 1 à 3 caractères sera transformé en un nouveau bloc de 4 caractères. Cette conversion est sûre car aucun des blocs résultants ne contient les symboles interdits (chiffres ou signe moins).

Blocs à 3 caractères

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

Un seul bloc final de 1 ou 2 caractères doit être codé si la longueur de la chaîne binaire n'est pas un multiple de 3:

Blocs à 1 caractère

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

Blocs à 2 caractères

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

Étape 3

La sortie finale est remplie d'espaces de fin.

Arnauld
la source
1
Saviez-vous déjà que ces combinaisons particulières de caractères ne contiennent aucun nombre lors de leur conversion en base64, ou l'avez-vous découvert expérimentalement?
Tomáš Zato - Réintègre Monica
@ TomášZato C'était une supposition confiante, basée sur le fait qu'il s'agit d'un très petit jeu de caractères dans la partie inférieure du tableau ASCII.
Arnauld
10

Python 3 , 49 39 octets

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

Essayez-le en ligne!

-10 octets grâce à sept négatifs

Convertit l'entier en hexadécimal et ajoute des espaces jusqu'à 9 caractères au total. Ensuite, double le code ASCII de chaque caractère de la chaîne (certains s'étendent en dehors de l'ASCII en Unicode, mais Python le gère correctement), produisant une liste de caractères.

Cela fonctionne car chaque chiffre, y compris -, est mappé sur un caractère ASCII différent. Aucun entier entre -2147483648et 2147483648n'est égal, donc les convertir en espaces hexadécimaux et en préfixe ne les rendrait pas égaux. Ensuite, les mapper à différents points de code ne conduit pas à des collisions, il n'y a donc toujours pas deux valeurs dans la plage qui conduisent à des sorties égales.

Python 3 , 59 56 47 octets

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

Essayez-le en ligne!

-3 octets grâce à Jitse

-9 octets grâce à sept négatifs

Même algorithme, mais en utilisant mapau lieu d'une forboucle.

Stephen
la source
2
Vous pouvez raser 3 octets dans l' mapapproche en remplaçant list( ... )par[* ... ]
Jitse
3
Vous pouvez créer la chaîne rembourrée avec"%9x"%i
négatif sept
@negativeseven merci, c'est vraiment du génie
Stephen
1
Pourrait rester dans ASCII et à 39 octets en Python 2 en utilisant`4e9+n`
Jonathan Allan
8

05AB1E , 11 5 octets

тjÇ·ç

-6 octets portant l'approche de @Stephen , alors assurez-vous de lui donner un vote positif!

Génère une liste de 100 caractères maximum, avec 100(input length) quantité de @(double le point de code de l'espace), et tous -0123456789mappés surZ`bdfhjlnpr (double les points de code ASCII).

Essayez-le en ligne.

Explication:

 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)

Réponse originale de 11 octets :

Ķ×AIdè«žIj

Essayez-le en ligne (limité à 1000au lieu de 2147483648).

Explication:

La longueur de sortie comporte toujours 2 147 483 648 caractères. Il produira 2147483648|n|1 nombre d'espaces, accompagné de |n|nombre de sauts de ligne, avec soit un 'a' si n<0 ou 'b' si n0 .

Ä            # 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)
Kevin Cruijssen
la source
7

enculé , 48 29 28 16 13 octets

Ce programme nécessite des cellules, où cnN , mais si vous voulez des résultats cohérents, assurez-vous que cn<256

La sortie sera évidemment unique quel que soit le nombre que vous entrerez ( <n< ). Si l'entier est plus court, le programme remplira la sortie pour correspondre exactement à octets, donc la longueur est toujours la même.

Cette réponse échappe un peu au défi, car elle ne précise pas que la sortie doit être finie.

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

Essayez-le en ligne!


Réponse originale de 28 octets:

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

Celui-ci remplira la sortie à exactement 281 octets. Le mécanisme de conversion des nombres fonctionne de la même manière ici. Ce programme suppose la même chose que le programme ci-dessus.

Krzysztof Szewczyk
la source
La sortie infinie n'est pas autorisée
Jo King
@JoKing ceci a été déclaré après avoir fait cette réponse. Mais si vous vous sentez vraiment blessé par cela, je peux simplement me retirer du défi et déclarer la première réponse comme non concurrente
Krzysztof Szewczyk
5

Python 3 , 39 octets

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

Essayez-le en ligne!

Active le nombre donné dans une représentation de chaîne binaire (complétée par des espaces), puis mappe les caractères (space)-01à caabla str.translatefonction.

sept négatif
la source
5

Gelée , 4 octets

œ?ØẠ

Un lien monadique acceptant un entier qui donne une liste de 52 caractères.

-2223n<222352!>2224

Essayez-le en ligne!

Comment?

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

Alors...

-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
Jonathan Allan
la source
5

Rubis , 27 octets

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

Essayez-le en ligne!

('%34b'%n)Convertit un entier en sa représentation binaire, en utilisant ..1pour indiquer un nombre négatif (cela est censé représenter un préfixe infiniment long de 1), et laisse ce pavé gauche à 34 caractères en utilisant des espaces. Ensuite, nous remplaçons le 0s par «a» et le 1s par «h» pour créer la représentation Maniacal Base 2: des chaînes comme «haaahahahaaha» précédées d'espaces et parfois ... Puisque chaque étape ici est inversible, c'est 1: 1.

Edit: Laissez le dossier montrer que @manatwork a publié cette solution identique en premier. Oops. J'aurais dû me rafraîchir.

histocrate
la source
3
Lol. Votre sortie est beaucoup plus drôle que la mienne.
manatwork
4

Gelée , 6 octets

Ø%+ṃØA

Essayez-le en ligne!

Étant donné que Jelly a des entiers de longueur arbitraire, ce lien monadique prend un entier dans la plage ±231et renvoie une chaîne alphabétique de longueur 7. Cela fonctionne en ajoutant232 puis décompressez la base en majuscules.

Nick Kennedy
la source
4

C (gcc) , 38 octets

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

Essayez-le en ligne!

Cela étend chaque bit de l'entier d'entrée en un octet qui est soit 0 soit 1 (qui sont tous deux des caractères non imprimables, mais il n'y a pas de règle contre cela). Ainsi, la sortie est toujours de 32 octets et garantie d'être unique.

G. Sliepen
la source
Approche intelligente, similaire au remplissage de réponse Brainfuck avec octets NUL.
maxb
Je ne suis pas sûr qu'un programme qui ne se termine pas soit vraiment conforme aux spécifications ... mais si c'est le cas, 28 octets? f(a){putchar(a&1);f(a/2);}
G. Sliepen
J'ai fait une exception pour Malbolge, mais en général le programme devrait se terminer. Avoir "l'infini" comme longueur est un peu une triche.
maxb
4

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

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

Essayez-le en ligne!

Incarnation de l'ignorance
la source
Se bloque x = int.MinValuecar il ne peut pas être annulé.
Hand-E-Food
1
@ Hand-E-Food Fixé en passant à une version entièrement différente
Incarnation de l'ignorance
3

Haskell, 31 octets

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

Essayez-le en ligne!

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

nimi
la source
1
Does it handle negative numbers?
maxb
@maxb: no, but now it's fixed.
nimi
3

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.

Andrew Baumher
la source
44? - I am outputting non-printable characters (which seems ok) but you could convert to printable by adding 65 like your current answer.
dana
1
42 - This time with printable characters :)
dana
3

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.

Xcali
la source
5
And you have confirmed there are no collisions for all valid inputs?
Sparr
... and that no md5 hash produces a digit character by chance?
AlexR
Forgot about the requirement to exclude digits. I've updated to accommodate that.
Xcali
2

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

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.

BradC
la source
2

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.
J. Sallé
la source
2

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
Shaggy
la source
2

Malbolge, 2708 bytes

This answer is super cheaty, because it always produces the same amount of input, which is equal to .

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!

Krzysztof Szewczyk
la source
1
With it being Malbolge, I might let that slide... Fantastic job!
maxb
2

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

Jo King
la source
2

Perl 5 (-p), 9 bytes

$_^=A x$=

Try it online!

Bitwxise-xor of the input with the string AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.

Grimmy
la source
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 [231,231).

Given the size of the output, I've included a test case with a smaller domain of [24,24) instead

attinat
la source
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....
Greg Martin
1

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.

Night2
la source
1

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.

Neil
la source
1

Charcoal, 9 bytes

◧⍘﹪NXχχαχ

Try it online! Link is to verbose version of code. Always outputs 10 spaces and uppercase letters. Explanation:

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

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!=41026 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 2324109 permutations (out of 41026). 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 1017, so a first order approximation of the probability that all 232 outputs are distinct is

1exp(264/26!)0.99999998

which is close enough to 1 for me.

Robin Ryder
la source
While yes, it's statistically unlikely that there's a collision, that doesn't mean it's impossible as the question asks for
Jo King
2
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.
maxb
1

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.

Jo King
la source
1
You can save one byte: -[>,[->-<]>.[-]<<-]
Krzysztof Szewczyk
1

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.

Giuseppe
la source
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)

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

GammaFunction
la source
1

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.

Olivier Grégoire
la source
1

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

maxb
la source