Bei Herausforderungen wie Ausgabe mit der gleichen Länge wie der Code und Ausgabe mit der doppelten Länge des Codes erstellen dachte ich an eine separate, aber ähnliche Herausforderung.

Die Aufgabe besteht darin, eine Ausgabe zu erzeugen. Dies kann entweder eine Zeichenfolge, eine Liste von Zeichen oder das Standardausgabeformat Ihres Programms sein. Ihre Ausgabe muss jedoch unabhängig von der Eingabe immer dieselbe Länge haben. Und was noch wichtiger ist, die Ausgabe sollte für verschiedene Eingaben unterschiedlich sein .

Eingang

Eine einzelne ganze Zahl $n$ , deren Bereiche durch die Wahl der Sprache bestimmt werden. Wenn Ihre Sprache Ganzzahlen variabler Länge hat, ist der Bereich .$-2^{31} \leq n < 2^{31}$

Ausgabe

Eine Zeichenfolge oder eine Liste von Zeichen oder ein Ausdruck auf STDOUT oder STDERR. Sie dürfen nur eine dieser Methoden anwenden. Die Länge der Ausgabe sollte unabhängig von der Eingabe gleich sein. Sie können jedoch selbst festlegen, welche Länge dies ist. Die Ausgabe darf weder Ziffern 0-9noch Minuszeichen enthalten- . Die Ausgabe sollte deterministisch sein .

Sie sollten in der Lage sein, zu beweisen, dass es für jede Ausgabe nur eine mögliche Eingabe gibt , entweder durch einen formalen Beweis, ein Argument oder eine Brute-Force-Suche.

Dies ist eine Code-Golf-Frage, also entfernen Sie alle überflüssigen Bytes. Alle Sprachen sind willkommen, je mehr desto besser!

JavaScript (ES8), 33 Byte

Erwartet die Eingabe im Bereich sicherer JS-Ganzzahlen: $-2^{53}\le n < 2^{53}$ .

Gibt eine Zeichenfolge mit 76 Zeichen zurück.

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

Probieren Sie es online!

Wie?

Schritt 1

Die Eingabe wird zunächst in binär umgewandelt. Dadurch bleibt das führende Minuszeichen für negative Zahlen erhalten.

Beispiele:

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

Schritt 2

Die resultierende Zeichenfolge ist in base-64 codiert.

Dies bedeutet, dass jeder Block mit 1 bis 3 Zeichen in einen neuen Block mit 4 Zeichen umgewandelt wird. Diese Konvertierung ist sicher, da keiner der resultierenden Blöcke die verbotenen Symbole (Ziffern oder Minuszeichen) enthält.

3-stellige Blöcke

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

Ein einzelner abschließender Block mit 1 oder 2 Zeichen muss codiert werden, wenn die Länge der Binärzeichenfolge kein Vielfaches von 3 ist:

1-Zeichen-Blöcke

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

2-stellige Blöcke

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

Schritt 3

Die endgültige Ausgabe wird mit Leerzeichen aufgefüllt.

Python 3 , 49 39 Bytes

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

Probieren Sie es online!

-10 Bytes dank negativer Sieben

Wandelt die Ganzzahl in Hexadezimal um und stellt Leerzeichen bis zu 9 Zeichen voran. Verdoppelt dann den ASCII-Code jedes Zeichens in der Zeichenfolge (einige erstrecken sich außerhalb von ASCII in Unicode, aber Python verarbeitet dies problemlos) und gibt eine Liste von Zeichen aus.

Dies funktioniert, weil jede Ziffer, einschließlich -, einem anderen ASCII-Zeichen zugeordnet ist. Keine ganzen Zahlen zwischen -2147483648und 2147483648sind gleich. Wenn Sie sie also in hexadezimale und vorangestellte Leerzeichen konvertieren, sind sie nicht gleich. Das Zuordnen zu verschiedenen Codepunkten führt dann nicht zu Kollisionen. Es gibt also immer noch keine zwei Werte im Bereich, die zu gleichen Ausgaben führen.

Python 3 , 59 56 47 Bytes

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

Probieren Sie es online!

-3 Bytes dank Jitse

-9 Bytes dank negativer Sieben

Gleicher Algorithmus, jedoch mapanstelle einer forSchleife.

05AB1E , 11 5 Bytes

тjÇ·ç

-6 Bytes , die den Ansatz von @Stephen portieren , also stelle sicher, dass du ihn positiv bewertest!

Gibt eine Liste von bis zu 100 Zeichen, mit $100-(\text{input length})$ Menge @(doppelten Raum Codepoint), und allen -0123456789abgebildet Z`bdfhjlnpr( das Doppelte der ASCII - Codepunkte).

Probieren Sie es online aus.

Erläuterung:

 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)

Ursprüngliche 11- Byte- Antwort:

Ķ×AIdè«žIj

Versuchen Sie es online (begrenzt auf 1000statt 2147483648).

Erläuterung:

Die Ausgabelänge beträgt immer 2.147.483.648 Zeichen. Es wird $2147483648-|n|-1$ ausgegeben n | - 1 Anzahl Leerzeichen, angefügt mit $|n|$Anzahl der Zeilenumbrüche, denen entweder ein 'a' angehängt wird, wenn $n\lt0$ oder ein 'b', wenn $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

Für dieses Programm sind Zellen erforderlich, bei denen $c_n \in \mathbb{N}$ ist. Wenn Sie jedoch konsistente Ergebnisse wünschen, müssen Sie sicherstellen, dass $c_n < 256$

Die Ausgabe ist unabhängig von der eingegebenen Nummer eindeutig ( $-\infty \lt n \lt \infty$ ). Wenn die Ganzzahl kürzer ist, füllt das Programm die Ausgabe mit genau $\infty$ Bytes auf, sodass die Länge immer gleich ist.

Diese Antwort ist eine kleine Lücke in der Herausforderung, da sie nicht besagt, dass die Ausgabe endlich sein muss.

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

Probieren Sie es online!

Original, 28-Byte-Antwort:

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

Dieser füllt die Ausgabe auf genau $2^8 - 1$ Bytes auf. Der Mechanismus zur Umrechnung von Zahlen funktioniert hier genauso. Dieses Programm setzt dasselbe wie das obige Programm voraus.

Python 3 , 39 Bytes

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

Probieren Sie es online!

Schaltet sie die gegebene Anzahl in eine binäre String - Darstellung (mit Leerzeichen aufgefüllt), dann die Zeichen bildet , (space)-01um caabmit der str.translateFunktion.

Gelee , 4 Bytes

œ?ØẠ

Ein monadischer Link, der eine Ganzzahl akzeptiert, die eine Liste mit 52 Zeichen ergibt.

Der Eingabebereich kann bis zu etwas mehr als $-2^{223} \leq n \lt 2^{223}$ seit $52!>2^{224}$ betragen ! > 2 224 .

Probieren Sie es online!

Wie?

œ?ØẠ - Link: integer, n
  ØẠ - alphabet (Jelly's longest built-in character list containing no digits
     -           or hyphen) = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
œ?   - permutation at index (n) if all 52! permutations were written out
     - in lexicographical order.
     - This indexing is modular so when n = -x we fetch the (52!-x)th entry.

So...

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

Ruby , 27 Bytes

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

Probieren Sie es online!

('%34b'%n)Wandelt eine Ganzzahl in ihre Binärdarstellung um und ..1gibt dabei eine negative Zahl an (dies soll ein unendlich langes Präfix von 1 darstellen). Füllt diese Zahl mit Leerzeichen auf 34 Zeichen auf. Dann ersetzen wir das 0s durch 'a' und das 1s durch 'h', um die Maniacal Base 2-Darstellung zu erstellen: Zeichenfolgen wie "haaahahahaaha" werden mit Leerzeichen und manchmal vorangestellt ... Da hier jeder Schritt invertierbar ist, ist dies 1: 1.

Bearbeiten: Lassen Sie den Datensatz zeigen, dass @manatwork diese identische Lösung zuerst gepostet hat. Hoppla. Ich hätte mich erfrischen sollen.

Gelee , 6 Bytes

Ø%+ṃØA

Probieren Sie es online!

Da Jelly Ganzzahlen beliebiger Länge hat, nimmt diese monadische Verknüpfung eine Ganzzahl im Bereich von $±2^{31}$ und gibt eine alphabetische Zeichenfolge der Länge 7 zurück. Es funktioniert durch Hinzufügen von $2^{32}$ und anschließendes Dekomprimieren der Basis in Großbuchstaben.

C (gcc) , 38 Bytes

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

Probieren Sie es online!

Dies erweitert jedes Bit der Eingabe-Ganzzahl in ein Byte, das entweder 0 oder 1 ist (beides nicht druckbare Zeichen, aber es gibt keine Regel dagegen). Die Ausgabe ist also immer 32 Byte und garantiert eindeutig.

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

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

Probieren Sie es online!

Haskell, 31 Bytes

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

Probieren Sie es online!

Wird 2^60zur Eingabe hinzugefügt , sodass die resultierende Zahl für den gesamten Eingabebereich die gleiche Anzahl von Ziffern enthält. Verwandle dich in eine Zeichenkette und verschiebe jedes Zeichen 10 Stellen nach rechts in der ASCII-Reihenfolge ( 0-> :... 9-> C).

C # (Visual C # Interactive Compiler) , 52 Byte

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

Probieren Sie es online!

Ein anderer Ansatz zur Lösung von ac # nutzt die Tatsache, dass der c # -Modul für negative Zahlen negativ ist. Ich nehme an, Sie könnten ein oder zwei Bytes sparen, wenn Sie nicht angezeigte Zeichen ('\ 0' usw.) zulassen, indem Sie das aktualisieren +65..., um den Zeichenwert nicht auf einen für Menschen lesbaren Wert zu versetzen.

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

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

Probieren Sie es online!

Vorher:

Perl 5 -p , 29 Bytes

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

Probieren Sie es online!

Wandelt die Zahl seiner 64 - Bit - Binärdarstellung, dann transliterates 0und 1zu aund bverbunden.

T-SQL, 73 70 61 Bytes

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

Ich ersetze nur direkt die Ziffern (und -) durch Buchstaben, nachdem STRdie ganze Zahl auf 11 Zeichen aufgefüllt wurde. Es ist keine Konvertierung in hex oder binär erforderlich.

TRANSLATE wurde in SQL 2017 eingeführt.

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

BEARBEITEN : 3 Byte wurden eingespart, indem das manuelle Auffüllen durch eine Konvertierung in CHAR (11) ersetzt wurde. Hierbei handelt es sich um ein Zeichenformat mit fester Breite, bei dem automatisch Leerzeichen eingefügt werden.

BEARBEITEN 2 : 9 Bytes mit der STR()Funktion anstelle von gespeichert CAST. STRwandelt eine Zahl in eine Textzeichenfolge um, die auf die angegebene Länge aufgefüllt ist.

APL (Dyalog Unicode) , 28 Byte

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

Probieren Sie es online!

Einfaches Dfn, wobei ein ganzzahliges Argument verwendet wird. Verwendet ⎕IO←0.

TIO verlinkt zu einem Testfall von -2^10bis 2^10. Der 0~⍨Teil entfernt das Duplikat 0aus den Argumenten.

Wie:

{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

Ich denke das ist richtig. Inspiriert von Stephens Python-Lösung, freut +1ihn das.

¤ùI cÑ

Versuch es

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

Probieren Sie es online!

Perl 6 , 12 Bytes

*~|('@'x 11)

Probieren Sie es online!

Anonym Welches Lambda auch immer, das eine Zahl annimmt und mit 11 @s ODER verknüpft . Dies ordnet die Ziffern pqrstuvwxyund den Bindestrich zu und füllt mdann die Zeichenkette mit @s auf 11 Zeichen auf

Perl 5 (-p), 9 Bytes

$_^=A x$=

Probieren Sie es online!

Bitwxise-xor der Eingabe mit dem String AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.

Wolfram Language (Mathematica) , 44 33 Bytes

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

Versuchen Sie es mit einer kleineren Domain

-2 danke an Greg Martin

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

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

Stax , 6 Bytes

11){Hm

Führen Sie es aus und debuggen Sie es

Verfahren:

1. Eingabe mit linkem Pad auf 11 Zeichen.
2. Verdoppeln Sie jedes ASCII-Zeichen, das kein Leerzeichen ist.

PHP , 64 54 Bytes

-10 Bytes durch Verwendung der strtrFunktion anstelle des manuellen Ersetzens von Zeichen.

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

Probieren Sie es online!

Der größte int-Wert, der in PHP derzeit möglich 9223372036854775807ist und 19 Stellen lang ist, wird unter Berücksichtigung des Minuszeichens in negativen Zahlen 20 sein. Der obige Code ersetzt das Minuszeichen ( -) durch das AZeichen und jede Ziffer von 0bis 9durch ein Zeichen von Dbis Mund füllt dann die Zeichenfolge rechts mit einem Leerzeichen auf, damit sie immer 20 Zeichen lang ist. Der Ausgang für die Eingabe beispielsweise -9876543210ist "AMLKJIHGFED " .

Der Ausgang ist einzigartig für jeden Integer - Eingang und Sie können durch Entfernen alle Leerzeichen an den Eingang zurück und ersetzt Amit -und ersetzen Dzu Mmit 0zu 9.

PHP , 44 Bytes

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

Probieren Sie es online!

Dies ist dieselbe Idee wie Arnauld's Antwort . Konvertiert die Eingabe in Binär und konvertiert sie anschließend in Base-64. Füllt es außerdem -9223372036854775807mit einem Leerzeichen auf 88 Zeichen auf (die größte Länge beträgt 88 Zeichen), um in der Ausgabe immer die gleiche Länge zu erhalten.

Retina 0.8.2 , 21 Bytes

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

Probieren Sie es online! Immer gibt 11 Zeichen aus dem Bereich n.. z. Erläuterung:

T`p`l

Übersetzen Sie die druckbaren ASCII-Zeichen in Kleinbuchstaben. Diese Karten -zu nund 0.. 9zu q.. z. (Es ist wirklich ein Glück, dass die Ziffern die 16. bis 25. druckbaren ASCII-Zeichen sind!)

$
10$*o

10 os anhängen . Da die Eingabe zwischen 1 und 11 Zeichen hat, gibt es jetzt zwischen 11 und 21 Zeichen.

!`.{11}

Extrahieren Sie die ersten 11 Zeichen. Da es weniger als 22 Zeichen gibt, wird dies nur einmal zutreffen.

Kohle , 9 Bytes

◧⍘﹪ＮＸχχαχ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Gibt immer 10 Leerzeichen und Großbuchstaben aus. Erläuterung:

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

Probieren Sie es 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$

Das ist nah genug an 1 für mich.

Brainfuck , 20 bis 19 Bytes

-1 Byte danke an Krzysztof Szewczyk

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

Probieren Sie es online!

Gibt die Zahl mit jeder Ziffer und jedem Bindestrich aus, die auf 255 abzüglich ihres Ordnungswerts abgebildet sind, und wird mit NUL-Bytes auf 255 Zeichen aufgefüllt.

R , 40 37 Bytes

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

Probieren Sie es online!

Eine Alternative zu Robin Ryders Antwort ; das ist bestimmt deterministisch.

Dies wandelt die Eingabe in einen rawVektor von 32 Bytes um, wobei jedes Byte eine Hex-Zahl ist 00oder 01die Bits der ganzen Zahl darstellt. Wir zwingen uns dann zu einem, logicalindem wir mit vergleichen 0, also 00wird auf FALSEund 01auf abgebildet TRUE. Dann müssen wir einen einzelnen Buchstaben aus jedem entfernen, um eine FALSEAusgabe gleicher Länge zu gewährleisten, die willkürlich ausgewählt werden soll S. Das Ergebnis wird (mit Leerzeichen) für eine Länge von 169 gedruckt.

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)

Probieren Sie es online!

Diese Lösung long longumgeht die Grenzen von Zshs ganzen Zahlen, indem nur mit Zeichen gearbeitet wird. Ich habe es aus Gründen der Lesbarkeit nur auf 30 Zeichen aufgefüllt, aber durch Ersetzen 30durch 99kann diese Methode auf alle Zahlen von -1E99+1bis angewendet werden 1E100-1.

Die Auswirkungen der Interpretation der Dezimalcodes als Hexadezimal sind wie folgt:

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}

Probieren Sie es online!

Deklariert x als Binärzahl, mit einer Breite von 66 aufgefüllt. Ordnet dann 0→ aund 1→ zu b. Wir ordnen auch 2und a -zu, da diese Zeichen in [[-]][base]#[num]Notation gedruckt werden. $xÜberprüfen Sie die Debug-Ausgabe im TIO-Link, um zu sehen, wie es vor dem Ersetzen aussieht und welche Grenzen Zsh beim Parsen von Ganzzahltypen hat.

Java (JDK) , 42 Byte

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

Probieren Sie es online!

Zunächst wird die hexadezimale Darstellung der Eingabe erstellt, die links mit Leerzeichen aufgefüllt ist, die die gleiche Längenbeschränkung (8 Zeichen lang) bietet, das Minuszeichen entfernt und jede Zwischenausgabe eindeutig hält.

Dies ergibt eine Zeichenkette mit 17 verschiedenen möglichen Zeichen: 0123456789abcdef und Leerzeichen.

Dann wird jedes Zeichen gestreamt und zugeordnet, indem dem Codepunkt 64 hinzugefügt werden, wenn es sich um eine Ziffer oder ein Leerzeichen handelt. Tatsächlich führt dies zu der folgenden Zuordnung: 0123456789abcdef<space>Zu pqrstuvwxyabcdef`dieser Zuordnung gehören 17 verschiedene Zeichen, sodass keine zwei Zahlen zur gleichen Ausgabe führen.

Bash , 30 Bytes

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

Probieren Sie es online!

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