С такими задачами, как « Вывод» такой же длины, что и код, и « Создать вывод в два раза длиннее кода» , я подумал об отдельной, но схожей задаче.

Задача состоит в том, чтобы произвести вывод. Это может быть строка, список символов или любой другой формат вывода вашей программы по умолчанию. Однако ваш вывод всегда должен быть одинаковой длины, независимо от ввода. И что более важно, выходные данные должны быть разными для разных входов .

вход

Единственное целое число $n$ , диапазоны которого определяются выбором языка. Если ваш язык имеет целые числа переменной длины, диапазон составляет $-2^{31} \leq n < 2^{31}$ .

Выход

Строка или список символов, или печать в STDOUT или STDERR. Вы можете использовать только один из этих методов. Выходные данные должны быть одинаковой длины независимо от входных данных, но вы сами должны определить, какая это длина. Вывод может не содержать цифр 0-9или знака минус- . Выход должен быть детерминированным .

Вы должны быть в состоянии доказать, что для каждого выхода есть только один возможный вход , либо формальным доказательством, аргументом, либо перебором.

Это кодовый вопрос о гольфе, так что сбрите все лишние байты. Все языки приветствуются, чем больше, тем лучше!

JavaScript (ES8), 33 байта

Ожидается ввод в диапазоне безопасных целых чисел JS: $-2^{53}\le n < 2^{53}$ .

Возвращает строку из 76 символов.

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

Попробуйте онлайн!

Как?

Шаг 1

Вход сначала преобразуется в двоичный. Это сохраняет ведущий знак минус для отрицательных чисел.

Примеры:

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

Шаг 2

Результирующая строка кодируется в base-64.

Это означает, что каждый блок из 1-3 символов будет превращен в новый блок из 4 символов. Это преобразование безопасно, потому что ни один из полученных блоков не содержит запрещенных символов (цифр или знака минус).

3-символьные блоки

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

Один конечный блок из 1 или 2 символов должен быть закодирован, если длина двоичной строки не кратна 3:

1-символьные блоки

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

2-символьные блоки

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

Шаг 3

Конечный результат дополняется завершающими пробелами.

Python 3 , 49 39 байт

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

Попробуйте онлайн!

-10 байт благодаря отрицательной семерке

Преобразует целое число в шестнадцатеричное и добавляет пробелы до 9 символов. Затем удваивает ASCII-код каждого символа в строке (некоторые распространяются за пределы ASCII в Unicode, но Python прекрасно справляется с этим), выводя список символов.

Это работает, потому что каждая цифра, в том числе - , отображается на другой символ ASCII. Нет целых чисел между -2147483648и 2147483648равны, поэтому преобразование их в шестнадцатеричные и предшествующие пробелы не сделает их равными. Затем отображение их на разные кодовые точки не приводит к коллизиям, поэтому в диапазоне по-прежнему нет двух значений, которые приводят к одинаковым выходным данным.

Python 3 , 59 56 47 байт

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

Попробуйте онлайн!

-3 байта благодаря Джитсе

-9 байт благодаря отрицательной семерке

Тот же алгоритм, но с использованием mapвместо forцикла.

05AB1E , 11 5 байтов

тjÇ·ç

-6 байтов, переносящих подход @Stephen, так что убедитесь, что его голосовали!

Выходы списка до 100 символов, с $100-(\text{input length})$ количество @( в два раза пространство элемент кода), и все -0123456789преобразуется вZ`bdfhjlnpr (два раза ASCII кодовых).

Попробуйте онлайн.

Объяснение:

 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)

Оригинальный 11- байтовый ответ:

Ķ×AIdè«žIj

Попробуйте онлайн (ограничено 1000вместо2147483648 ).

Объяснение:

Длина вывода всегда составляет 2 147 483 648 символов. Он выведет $2147483648-|n|-1$ количество пробелов, дополненных $|n|$количество новых строк с добавлением либо «a», если $n\lt0$ либо «b», если $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)

бред , 48 29 28 16 13 байт

Эта программа требует ячейки, где $c_n \in \mathbb{N}$ , но если вы хотите получить согласованные результаты, убедитесь, что $c_n < 256$

Очевидно, что вывод будет уникальным независимо от того, какое число вы введете ( $-\infty \lt n \lt \infty$ ). Если целое число короче, программа будет дополнять вывод, чтобы точно соответствовать $\infty$ байтами, поэтому длина всегда одинакова.

Этот ответ немного запутывает задачу, поскольку в нем не говорится, что результат должен быть конечным.

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

Попробуйте онлайн!

Оригинал, ответ 28 байт:

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

Этот будет дополнять вывод до $2^8 - 1$ байтов. Механизм преобразования чисел здесь работает так же. Эта программа предполагает то же, что и программа выше.

Python 3 , 39 байт

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

Попробуйте онлайн!

Включает заданное число в двоичное строковое представление (дополненное пробелами), затем отображает символы (space)-01в caabс str.translateфункцией.

Желе , 4 байта

œ?ØẠ

Монадическая ссылка, принимающая целое число, которое выдает список из 52 символов.

$-2^{223} \leq n \lt 2^{223}$$52!>2^{224}$

Попробуйте онлайн!

Как?

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

Так...

-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

Рубин , 27 байт

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

Попробуйте онлайн!

('%34b'%n)Преобразует целое число в его двоичное представление, используя ..1для обозначения отрицательного числа (это означает, что он представляет бесконечно длинный префикс 1 с), и подставляет это значение до 34 символов, используя пробелы. Затем мы заменяем 0s на 'a', а 1s на 'h', чтобы создать представление маниакальной базы 2: строки типа "haaahahahaaha" с добавлением пробелов и иногда ... Поскольку каждый шаг здесь обратим, это 1: 1.

Изменить: Пусть запись покажет, что @manatwork опубликовал это идентичное решение первым. К сожалению. Я должен был освежиться.

Желе , 6 байт

Ø%+ṃØA

Попробуйте онлайн!

Поскольку в Jelly есть целые числа произвольной длины, эта монадическая ссылка принимает целое число в диапазоне $±2^{31}$и возвращает длину 7 буквенной строки. Это работает путем добавления$2^{32}$ и затем распаковывать в заглавные буквы.

C (gcc) , 38 байт

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

Попробуйте онлайн!

Это расширяет каждый бит входного целого числа в байт, равный 0 или 1 (оба являются непечатаемыми символами, но против этого правила нет). Таким образом, вывод всегда составляет 32 байта и гарантированно будет уникальным.

C # (интерактивный компилятор Visual C #) , 35 байт

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

Попробуйте онлайн!

Haskell, 31 байт

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

Попробуйте онлайн!

Добавляет 2^60к вводу, чтобы полученное число имело одинаковое количество цифр для всего диапазона ввода. Превратитесь в строку и сдвиньте каждый символ на 10 позиций вправо в порядке ASCII ( 0-> :... 9-> C).

C # (интерактивный компилятор Visual C #) , 52 байта

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

Попробуйте онлайн!

Другой подход к решению ac # использует тот факт, что модуль c # отрицателен для отрицательных чисел. Я полагаю, что вы могли бы сбрить один или два байта, если разрешите не отображаемые символы ('\ 0' и т. Д.), Обновив, +65...чтобы не смещать значение символа до значения, удобного для чтения человеком.

Perl 5 -MDigest::MD5=md5_hex -p , 23 байта

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

Попробуйте онлайн!

Ранее:

Perl 5 -p , 29 байт

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

Попробуйте онлайн!

Преобразует число в его 64-битное двоичное представление, затем транслитерирует 0и 1в aи b, соответственно.

T-SQL, 73 70 61 байт

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

Я просто заменяю цифры (и -) буквами, после того, STRкак целые числа дополняются до 11 символов. Нет преобразования в шестнадцатеричный или двоичный код не требуется.

TRANSLATE был введен в SQL 2017

Ввод осуществляется через уже существующую таблицу $t$ с колонкой INT $n$В соответствии с нашими правилами IO . Диапазон типа INTданных в SQL$-2^{31} \leq n < 2^{31}$,

РЕДАКТИРОВАТЬ : Сохранены 3 байта путем замены заполнения вручную преобразованием в CHAR (11), который является символьным форматом фиксированной ширины, который автоматически дополняется пробелами.

РЕДАКТИРОВАТЬ 2 : Сохранено 9 байтов с использованием STR()функции вместо CAST. STRпреобразует число в текстовую строку, дополненную до указанной длины.

APL (Dyalog Unicode) , 28 байт

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

Попробуйте онлайн!

Простой Dfn, принимая целочисленный аргумент. Пользы⎕IO←0 .

TIO ссылается на контрольный пример от -2^10до 2^10. 0~⍨Часть удаляет дубликаты 0из аргументов.

Как:

{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 байт

Я думаю, что это правильно. Вдохновлен решением Стивена Python, поэтому, пожалуйста, +1ему.

¤ùI cÑ

Попытайся

¤ùI cÑ     :Implicit input of integer
¤          :Convert to binary string
 ù         :Left pad with spaces
  I        :  To length 64
    c      :Map codepoints
     Ñ     :  Multiply by 2

Мальболге , 2708 байт

Этот ответ очень обманчив, потому что он всегда выдает одинаковое количество ввода, равное $\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

Попробуйте онлайн!

Perl 6 , 12 байт

*~|('@'x 11)

Попробуйте онлайн!

Аноним Любая лямбда, которая принимает число и строку ИЛИ с 11 @с. Это отображает цифры на pqrstuvwxyи тир m, затем подушечки строки из 11 символов с @с

Perl 5 (-p), 9 байт

$_^=A x$=

Попробуйте онлайн!

Bitwxise-xor ввода со строкой AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.

Wolfram Language (Mathematica) , 44 33 байта

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

Попробуйте это с меньшим доменом

-2 спасибо Грегу Мартину

Печать >> , за которой следует строковое представление из 523069747202 символов списка$13!+n$ Nulls дополняется Trues на длину$14!$и перевод строки. Работает на домене$[-13!,14!-13!)$, который является надмножеством $[-2^{31},2^{31})$,

Учитывая размер вывода, я включил тестовый пример с меньшей областью $[-2^4,2^4)$ вместо

Stax , 6 байт

11){Hm

Запустите и отладьте его

Процедура:

1. Ввод левой панели до 11 символов.
2. Удвойте каждый не пробельный символ ascii.

PHP , 64 54 байта

-10 байт, используя strtrфункцию вместо ручной замены символов.

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

Попробуйте онлайн!

Наибольшее возможное значение int в PHP на данный момент 9223372036854775807 19 цифр, с учетом знака минус в отрицательных числах, это будет 20. Приведенный выше код заменяет знак минус ( -) на Aсимвол, а каждая цифра от 0до 9на символ от Dдо Mа затем дополняет строку справа пробелом, чтобы всегда иметь длину 20 символов. Например, выход для ввода -9876543210- "AMLKJIHGFED ".

Выходной сигнал является уникальным для каждого целого числа входных и вы можете получить обратно на вход, удаляя все пробелы, заменяя Aс -и заменить Dна Mс 0к 9.

PHP , 44 байта

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

Попробуйте онлайн!

Это та же идея, что и ответ Арно . Преобразует ввод в двоичный файл, а затем преобразует его в base-64. Также дополняет его до 88 символов (наибольшая длина для -9223372036854775807которых составляет 88 символов) с пробелом справа, чтобы всегда получать одинаковую длину в выводе.

Сетчатка 0.8.2 , 21 байт

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

Попробуйте онлайн! Всегда выводит 11 символов из диапазона n.z . Объяснение:

T`p`l

Переведите печатные символы ASCII в строчные буквы. Это -соответствует nи 0.. 9чтобы q..z . (Это действительно повезло, что цифры от 16 до 25 печатных символов ASCII!)

$
10$*o

Добавить 10 oс. Так как ввод будет содержать от 1 до 11 символов, теперь от 11 до 21 символа.

!`.{11}

Извлеките первые 11 символов. Поскольку в нем менее 22 символов, он будет совпадать только один раз.

Древесный уголь , 9 байт

◧⍘﹪ＮＸχχαχ

Попробуйте онлайн! Ссылка на подробную версию кода. Всегда выводит 10 пробелов и заглавных букв. Объяснение:

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

R , 37 байт

set.seed(scan())
cat(sample(LETTERS))

Попробуйте онлайн!

Похоже, что результат является случайным, но это не так! Ввод используется в качестве начального числа генератора псевдослучайных чисел, и затем мы получаем один из$26!=4\cdot 10^{26}$перестановки алфавита. Вывод всегда имеет длину 51 (26 букв + 25 пробелов).

Все еще существует проблема обеспечения того, чтобы все результаты были разными. Мы заканчиваем с$2^{32}\approx 4\cdot 10^9$ перестановки (из $4\cdot 10^{26}$). Если мы притворимся, что перестановки распределены случайным образом равномерно, то вероятность того, что все перестановки различны, можно вычислить, следуя тем же вычислениям, что и для задачи дня рождения . Вероятность того, что 2 конкретных выхода идентичны$10^{-17}$Таким образом, первое приближение вероятности того, что все $2^{32}$ выходы отличаются

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

что достаточно близко к 1 для меня.

брейкфук , 20 19 байт

-1 байт благодаря Кшиштофу Шевчику

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

Попробуйте онлайн!

Выводит число с каждой цифрой и тире, сопоставленные 255 минус их порядковое значение, дополненное до 255 символов с байтами NUL.

R , 40 37 байт

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

Попробуйте онлайн!

Альтернатива ответу Робина Райдера ; это, безусловно, детерминированный.

Это преобразует входные данные в rawвектор из 32 байтов, каждый из которых представляет собой шестнадцатеричное число 00или 01представляет биты целого числа. Затем мы принуждать к logicalпутем сравнения 0, поэтому 00отображается FALSEи 01в TRUE. Затем нам нужно удалить по одной букве из каждой, FALSEчтобы гарантировать вывод одинаковой длины, произвольно выбранный как S. Результат печатается (с пробелом) на длину 169.

Zsh , 43 байта

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)

Попробуйте онлайн!

Это решение обходит long long пределы целых чисел Zsh, работая только с символами. Для удобства чтения я добавил только 30 символов, но замена 30на 99этот метод позволит работать со всеми числами от -1E99+1до1E100-1 .

Эффект интерпретации десятичных кодов как шестнадцатеричных заключается в следующем:

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 байтов

integer -i2 -Z66 x=$1
<<<${${x//[02-]/a}//1/b}

Попробуйте онлайн!

Объявляет x как двоичное число, дополненное нулями до ширины 66. Затем отображает 0→ aи 1→ b. Мы также сопоставляем 2и -a, так как эти символы печатаются в [[-]][base]#[num]нотации. Чтобы увидеть, как $xвыглядит до замены, а также ограничения Zsh в разборе целочисленных типов, проверьте выходные данные отладки в ссылке TIO.

Java (JDK) , 42 байта

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

Попробуйте онлайн!

Во-первых, это создает шестнадцатеричное представление ввода, дополненное слева пробелами, которое обеспечивает такое же ограничение длины (8 символов), удаляет знак минуса и сохраняет каждый промежуточный вывод уникальным.

Это дает строку с 17 различными возможными символами: 0123456789abcdefи пробел.

Затем каждый символ передается и отображается путем добавления 64 к его кодовой точке, если это цифра или пробел. По сути, это приводит к следующему сопоставлению: 0123456789abcdef<space>с pqrstuvwxyabcdef`17 различными символами, поэтому никакие два числа не приведут к одинаковому результату.

Баш , 30 байт

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

Попробуйте онлайн!

Чтобы доказать, что вывод уникален, я просто погуглил столкновения MD5 и не нашел результатов в целых числах между $-2^{31}$ а также $2^{31}$, Чтобы избежать появления запрещенных символов в выходных данных, просто переведите эти символы в заглавные буквы. Выходные данные всегда имеют одинаковую длину по определению и гарантированно не содержат никаких запрещенных символов.