Wyjście zawsze o tej samej długości

26

Przy wyzwaniach takich jak Dane wyjściowe o tej samej długości co kod i Utwórz dane wyjściowe dwukrotnie dłuższe niż kod , pomyślałem o osobnym, ale podobnym wyzwaniu.

Zadanie polega na wytworzeniu wyniku. Może to być ciąg znaków, lista znaków lub dowolny domyślny format wyjściowy programu. Jednak dane wyjściowe muszą zawsze być tej samej długości, niezależnie od danych wejściowych. Co ważniejsze, dane wyjściowe powinny być różne dla różnych danych wejściowych .

Wkład

Pojedyncza liczba całkowita n , której zakres zależy od wyboru języka. Jeśli twój język ma liczby całkowite o zmiennej długości, zakres wynosi 231n<231 .

Wydajność

Ciąg znaków lub lista znaków albo wydruk do STDOUT lub STDERR. Możesz użyć tylko jednej z tych metod. Dane wyjściowe powinny być tej samej długości niezależnie od danych wejściowych, ale to od Ciebie zależy, która to długość. Dane wyjściowe nie mogą zawierać cyfr 0-9lub znaku minus- . Wynik powinien być deterministyczny .

Powinieneś być w stanie udowodnić, że dla każdego wyjścia istnieje tylko jeden możliwy wkład , albo poprzez formalny dowód, argument lub przeszukanie brutalnej siły.

To pytanie do kodu golfowego, więc zetrzyj wszelkie zewnętrzne bajty. Wszystkie języki są mile widziane, im więcej, tym lepiej!

maxb
źródło
4
Czy program powinien teoretycznie działać na jakikolwiek wkład? Czy może wystarczy zastosować metodę, która działa tylko dla określonego zakresu (ograniczona ), niekoniecznie z powodu ograniczeń językowych, ale ograniczeń metodycznych? ±231
Pan Xcoder
4
@ Mr.Xcoder, jak możesz wybrać długość, jeśli musiałbyś pracować dla liczb całkowitych o dowolnej długości?
Stephen
2
@ Mr.Xcoder Musisz tylko udowodnić, że działa dla tego zakresu. Ta reguła ma pomóc w językach takich jak Python, gdzie liczby mogą składać się z tysięcy cyfr. Bez tej zasady byłoby znacznie trudniej zarówno dla Pythona, jak i pochodnych Pythona (które obejmują wiele języków golfowych).
maxb
11
Jeśli język nie ma liczb całkowitych o zmiennej długości, ale może obsługiwać wartości większe niż , czy możemy użyć ograniczonego zakresu - 2 31n < 2 31 ? 231231n<231
Arnauld
2
@Arnauld maksymalny zakres to 32-bitowe liczby całkowite ze znakiem, niezależnie od ograniczeń języka. Język może tylko zmniejszyć ten zakres.
maksymalnie

Odpowiedzi:

15

JavaScript (ES8), 33 bajty

Oczekuje danych wejściowych w zakresie bezpiecznych liczb całkowitych JS: 253n<253 .

Zwraca ciąg 76 znaków.

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

Wypróbuj online!

W jaki sposób?

Krok 1

Dane wejściowe są najpierw konwertowane na binarne. Zachowuje to wiodący znak minus dla liczb ujemnych.

Przykłady:

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

Krok 2

Powstały ciąg jest zakodowany w standardzie 64.

Oznacza to, że każdy blok od 1 do 3 znaków zostanie przekształcony w nowy blok 4 znaków. Ta konwersja jest bezpieczna, ponieważ żaden z powstałych bloków nie zawiera niedozwolonych symboli (cyfr lub znaku minus).

Bloki 3-znakowe

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

Jeden końcowy blok 1 lub 2 znaków musi zostać zakodowany, jeśli długość ciągu binarnego nie jest wielokrotnością 3:

Bloki 1-znakowe

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

Bloki 2-znakowe

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

Krok 3

Ostateczny wynik jest wypełniony końcowymi spacjami.

Arnauld
źródło
1
Czy wiesz już, że te konkretne kombinacje postaci nie zawierają liczb po konwersji na base64, czy też dowiedziałeś się eksperymentalnie?
Tomáš Zato - Przywróć Monikę
@ TomášZato To był pewny przypuszczenie, oparty na fakcie, że jest to bardzo mały zestaw znaków w dolnej części tabeli ASCII.
Arnauld,
10

Python 3 , 49 39 bajtów

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

Wypróbuj online!

-10 bajtów dzięki ujemnej siódemce

Konwertuje liczbę całkowitą na szesnastkową i wstawia spacje do 9 znaków łącznie. Następnie podwaja kod ASCII każdego znaku w ciągu (niektóre wychodzą poza ASCII do Unicode, ale Python radzi sobie z tym dobrze), wyświetlając listę znaków.

Działa to, ponieważ każda cyfra, w tym -, jest odwzorowana na inny znak ASCII. Brak liczb całkowitych pomiędzy -2147483648i2147483648 są równe, więc konwersja ich na spacje szesnastkowe i poprzedzające nie spowodowałoby, że byłyby równe. Następnie odwzorowanie ich na różne punkty kodowe nie prowadzi do kolizji, więc nadal nie ma dwóch wartości w zakresie, które prowadzą do równych wyników.

Python 3 , 59 56 47 bajtów

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

Wypróbuj online!

-3 bajty dzięki Jitse

-9 bajtów dzięki ujemnej siódemce

Ten sam algorytm, ale używa mapzamiast forpętli.

Stephen
źródło
2
Możesz ogolić 3 bajty w mappodejściu, zastępując list( ... )je[* ... ]
Jitse
3
Możesz utworzyć wyściełany ciąg za pomocą"%9x"%i
ujemny siedem
@negativeseven dziękuję, to naprawdę genialne
Stephen
1
Może pozostawać w obrębie ASCII i przy 39 bajtach w Pythonie 2 przy użyciu`4e9+n`
Jonathan Allan
8

05AB1E , 11 5 bajtów

тjÇ·ç

-6 bajtów przenoszących podejście @Stephen , więc pamiętajcie o jego głosowaniu!

Wyświetla listę do 100 znaków o długości 100(input length) liczbą@ (podwójny kodowy spacji) i wszystkie są -0123456789mapowane naZ`bdfhjlnpr (podwoić codepoints ASCII).

Wypróbuj online.

Wyjaśnienie:

 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)

Oryginalna odpowiedź 11 bajtów :

Ķ×AIdè«žIj

Wypróbuj online (ograniczone do 1000zamiast 2147483648).

Wyjaśnienie:

Długość wyjściowa wynosi zawsze 2 147 483 648 znaków. Będzie wyjście 2147483648|n|1 ilość spacji, uzupełniona o |n|ilość nowych linii, dołączonych albo z „a”, jeśli n<0 lub „b”, jeśli 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
źródło
7

pieprzenie mózgu , 48 29 28 16 13 bajtów

Ten program wymaga komórek, w których cnN , ale jeśli chcesz uzyskać spójne wyniki, upewnij się, że cn<256

Wyjście będzie oczywiście unikalne bez względu na to, jaką liczbę wprowadzisz ( <n< ). Jeśli liczba całkowita jest krótsza, program wypisze wynik tak, aby pasował dokładnie do bajtów, więc długość jest zawsze taka sama.

Ta odpowiedź jest nieco kłopotliwa, ponieważ nie stwierdzono, że dane wyjściowe muszą być skończone.

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

Wypróbuj online!


Oryginalna, 28-bajtowa odpowiedź:

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

Ten pad wyjście być dokładnie 281 bajtów. Mechanizm konwersji liczb działa tutaj tak samo. Ten program zakłada to samo co powyżej.

Krzysztof Szewczyk
źródło
Nieskończona wydajność nie
Jo King
@JoKing to zostało stwierdzone po udzieleniu tej odpowiedzi. Ale jeśli naprawdę czujesz się zraniony, mogę po prostu zrezygnować z wyzwania i zadeklarować pierwszą odpowiedź jako niekonkurującą
Krzysztof Szewczyk,
5

Python 3 , 39 bajtów

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

Wypróbuj online!

Okazuje dany numer w binarnej reprezentacji smyczkowy (spacjami), a następnie odwzorowuje znaki (space)-01do caabz str.translatefunkcji.

ujemna siódemka
źródło
5

Galaretka , 4 bajty

œ?ØẠ

Monadyczny link akceptujący liczbę całkowitą, która daje listę 52 znaków.

Zakres wejściowy może wynosić nawet nieco więcej niż 2223n<2223 od 52!>2224 .

Wypróbuj online!

W jaki sposób?

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

Więc...

-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
źródło
5

Rubinowy , 27 bajtów

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

Wypróbuj online!

('%34b'%n)Konwertuje liczbę całkowitą na jej reprezentację binarną, używając ..1do wskazania liczby ujemnej (ma to oznaczać nieskończenie długi prefiks 1s), i lewy dopełnia ją do 34 znaków za pomocą spacji. Następnie zamieniamy 0s na „a” i1 s na „h”, aby utworzyć reprezentację Maniacal Base 2: ciągi takie jak „haaahahahaaha” poprzedzone spacjami, a czasem.. . Ponieważ każdy krok tutaj jest odwracalny, jest to 1: 1.

Edycja: Niech rekord pokazuje, że @manatwork opublikował najpierw to samo rozwiązanie. Ups Powinienem się odświeżyć.

histocrat
źródło
3
Lol. Twój wynik jest znacznie zabawniejszy niż mój.
manatwork
4

C (gcc) , 38 bajtów

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

Wypróbuj online!

Rozwija każdy bit wejściowej liczby całkowitej do bajtu, który ma wartość 0 lub 1 (które są znakami niemożliwymi do wydrukowania, ale nie ma żadnej reguły przeciw temu). Wyjście ma więc zawsze 32 bajty i gwarantuje unikalność.

G. Sliepen
źródło
Sprytne podejście, podobne do wypełnienia odpowiedzi Brainfuck z bajtami NUL.
maxb
Nie jestem pewien, czy program, który się nie kończy, jest naprawdę zgodny ze specyfikacją ... ale jeśli tak, to 28 bajtów? f(a){putchar(a&1);f(a/2);}
G. Sliepen
Zrobiłem wyjątek dla Malbolge, ale ogólnie program powinien się zakończyć. Posiadanie „nieskończoności” jako długości jest trochę oszustwem.
maxb
4

C # (interaktywny kompilator Visual C #) , 35 bajtów

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

Wypróbuj online!

Wcielenie ignorancji
źródło
Awarie, x = int.MinValueponieważ nie można tego zanegować.
Hand-E-Food
1
@ Hand-E-Food Naprawiono przejście na zupełnie inną wersję
Embodiment of Ignorance
3

Haskell, 31 bajtów

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

Wypróbuj online!

Dodaje 2^60do danych wejściowych, aby wynikowa liczba miała taką samą liczbę cyfr dla całego zakresu wejściowego. Zamień na ciąg i przesuń każdy znak o 10 miejsc w prawo w kolejności ASCII ( 0-> :... 9-> C).

nimi
źródło
1
Czy obsługuje liczby ujemne?
maxb
@maxb: nie, ale teraz jest naprawione.
nimi
3

C # (interaktywny kompilator Visual C #) , 52 bajty

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

Wypróbuj online!

Inne podejście do rozwiązania ac # wykorzystuje fakt, że moduł c # jest ujemny dla liczb ujemnych. Przypuszczam, że możesz zgolić bajt lub dwa, jeśli zezwolisz na wyświetlanie znaków („\ 0” itd.), Aktualizując opcję, +65...aby nie kompensować wartości znaku na coś czytelnego dla człowieka.

Andrew Baumher
źródło
44? - Wysyłam znaki niedrukowalne (co wydaje się być w porządku), ale możesz przekonwertować na drukowalne, dodając 65, podobnie jak twoja obecna odpowiedź.
dana
1
42 - Tym razem z postaciami do druku :)
dana
3

Perl 5 -MDigest::MD5=md5_hex -p , 23 bajtów

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

Wypróbuj online!

Poprzednio:

Perl 5 -p , 29 bajtów

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

Wypróbuj online!

Konwertuje liczbę na 64-bitową reprezentację binarną, a następnie dokonuje transliteracji 0oraz odpowiednio 1do ai b.

Xcali
źródło
5
I potwierdziłeś, że nie ma kolizji dla wszystkich ważnych danych wejściowych?
Sparr
... i że żaden hasz md5 nie tworzy postaci cyfrowej przez przypadek?
AlexR
Zapomniałem o wymogu wykluczania cyfr. Zaktualizowałem, aby to uwzględnić.
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
źródło
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é
źródło
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
źródło
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
źródło
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
źródło
2

Perl 5 (-p), 9 bytes

$_^=A x$=

Try it online!

Bitwxise-xor of the input with the string AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.

Grimmy
źródło
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
źródło
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
źródło
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
źródło
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
źródło
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
źródło
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
źródło
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
źródło
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
źródło
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
źródło
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
źródło