Вывод с одинаковой длиной всегда

26

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

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

вход

Единственное целое число n , диапазоны которого определяются выбором языка. Если ваш язык имеет целые числа переменной длины, диапазон составляет 231n<231 .

Выход

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

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

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

maxb
источник
4
Должна ли программа теоретически работать на любой вклад? Или достаточно использовать метод, который работает только для указанного диапазона (ограниченного ), не обязательно из-за языковых ограничений, но из-за ограничений метода? ±231
г-н Xcoder
4
@ Mr.Xcoder, как вы могли бы выбрать длину, если вам приходилось работать с целыми числами произвольной длины?
Стивен
2
@ Mr.Xcoder Вы должны только доказать, что он работает для этого диапазона. Это правило должно помочь таким языкам, как Python, где числа могут быть тысячами цифр. Без этого правила было бы намного сложнее как для Python, так и для производных Python (которые включают в себя множество языков игры в гольф).
максимум
11
Если в языке нет целых чисел переменной длины, но он может поддерживать значения, превышающие , мы можем использовать ограниченный диапазон - 2 31n < 2 31 ? 231231n<231
Арно
2
@Arnauld максимальный диапазон - 32-битные целые числа со знаком, независимо от ограничений языка. Язык может только уменьшить этот диапазон.
максимум

Ответы:

15

JavaScript (ES8), 33 байта

Ожидается ввод в диапазоне безопасных целых чисел JS: 253n<253 .

Возвращает строку из 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

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

Arnauld
источник
1
Знаете ли вы, что эти конкретные комбинации символов не содержат чисел при преобразовании в base64, или вы обнаружили это экспериментально?
Томаш Зато - Восстановить Монику
@ TomášZato Это было уверенное предположение, основанное на том факте, что это очень маленькая кодировка в нижней части таблицы ASCII.
Арно
10

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цикла.

Стивен
источник
2
Вы можете сбрить 3 байта в mapподходе, заменив list( ... )на[* ... ]
Jitse
3
Вы можете создать дополненную строку с"%9x"%i
минус семь
@ negativeseven спасибо, это действительно гениально
Стивен
1
Может оставаться в ASCII и на 39 байтах в Python 2, используя`4e9+n`
Джонатан Аллан
8

05AB1E , 11 5 байтов

тjÇ·ç

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

Выходы списка до 100 символов, с 100(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<0 либо «b», если 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)
Кевин Круйссен
источник
7

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

Эта программа требует ячейки, где cnN , но если вы хотите получить согласованные результаты, убедитесь, что cn<256

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

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

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

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


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

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

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

Кшиштоф Шевчик
источник
Бесконечный вывод не допускается
Джо Кинг
@ Шутя это было заявлено после того, как я сделал этот ответ. Но если вы действительно обижены этим, я могу просто отказаться от вызова и объявить первый ответ неконкурентным
Кшиштоф Шевчик
5

Python 3 , 39 байт

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

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

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

минус семь
источник
5

Желе , 4 байта

œ?ØẠ

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

-2223N<222352!>2224

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

Как?

œ?ØẠ - 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
Джонатан Аллан
источник
5

Рубин , 27 байт

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

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

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

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

histocrat
источник
3
Смешно. Ваш вывод намного смешнее, чем мой.
manatwork
4

Желе , 6 байт

Ø%+ṃØA

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

Поскольку в Jelly есть целые числа произвольной длины, эта монадическая ссылка принимает целое число в диапазоне ±231и возвращает длину 7 буквенной строки. Это работает путем добавления232 и затем распаковывать в заглавные буквы.

Ник Кеннеди
источник
4

C (gcc) , 38 байт

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

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

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

Г. Слипен
источник
Умный подход, похожий на заполнение ответа Brainfuck байтами NUL.
максимум
Я не уверен, что программа, которая не завершается, действительно в пределах спецификации ... но если это так, 28 байт? f(a){putchar(a&1);f(a/2);}
Г. Слипен
Я сделал исключение для Malbolge, но в целом программа должна завершиться. Иметь «бесконечность» в качестве длины - это немного обмануть.
максимум
3

Haskell, 31 байт

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

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

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

Ними
источник
1
Он обрабатывает отрицательные числа?
максимум
@maxb: нет, но теперь это исправлено.
Ними
3

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

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

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

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

Эндрю Баумер
источник
44? - Я вывожу непечатаемые символы (что кажется нормальным), но вы можете преобразовать в печатные, добавив 65, как ваш текущий ответ.
Дана
1
42 - На этот раз с печатными символами :)
Дана
3

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, соответственно.

Xcali
источник
5
И вы подтвердили, что нет коллизий для всех действительных входных данных?
Спарр
... и что ни один хэш md5 не выдает случайно цифру?
AlexR
Забыли про требование исключать цифры. Я обновился, чтобы учесть это.
Xcali
2

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-231N<231,

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

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

BradC
источник
2

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.
Ж. Салле
источник
2

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
мохнатый
источник
2

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

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

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

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

Кшиштоф Шевчик
источник
1
Учитывая, что это Малболж, я мог бы позволить этому скатиться ... Фантастическая работа!
максимум
2

Perl 6 , 12 байт

*~|('@'x 11)

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

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

Джо Кинг
источник
2

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

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

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

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

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

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

attinat
источник
Приятно :) Я думаю , что вы можете сохранить два байта, изменяя 2^31и 2^32к 13!и 14!соответственно. В связи с потерей некоторой «краткости» на выходе ....
Грег Мартин
1

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

night2
источник
1

Сетчатка 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 символов, он будет совпадать только один раз.

Нил
источник
1

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

◧⍘﹪NXχχαχ

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

   N        Input as a number
  ﹪         Modulo
     χ      10
    X       To power
      χ     10
 ⍘     α    Convert to base 26 using uppercase letters
◧       χ   Left pad to length 10
Нил
источник
1

R , 37 байт

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

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

Похоже, что результат является случайным, но это не так! Ввод используется в качестве начального числа генератора псевдослучайных чисел, и затем мы получаем один из26!знак равно41026перестановки алфавита. Вывод всегда имеет длину 51 (26 букв + 25 пробелов).

Все еще существует проблема обеспечения того, чтобы все результаты были разными. Мы заканчиваем с2324109 перестановки (из 41026). Если мы притворимся, что перестановки распределены случайным образом равномерно, то вероятность того, что все перестановки различны, можно вычислить, следуя тем же вычислениям, что и для задачи дня рождения . Вероятность того, что 2 конкретных выхода идентичны10-17Таким образом, первое приближение вероятности того, что все 232 выходы отличаются

1-ехр(-264/26!)0.99999998

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

Робин Райдер
источник
Хотя да, статистически маловероятно, что есть столкновение, это не означает, что это невозможно, поскольку вопрос задается
Джо Кинг
2
Мне нравится расчет вероятности. Я думаю, что вы могли бы пройти через все 4 миллиарда входных данных, если вы действительно хотите проверить наличие коллизий, но если вы не хотите делать это, я мог бы позволить этому скользить. Как и сейчас, вы представили убедительный аргумент, и если кто-то найдет контрпример, вам придется изменить свое представление.
максимум
1

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

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

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

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

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

Джо Кинг
источник
1
Вы можете сохранить один байт:-[>,[->-<]>.[-]<<-]
Кшиштоф Шевчик
1

R , 40 37 байт

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

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

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

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

Giuseppe
источник
1

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. Затем отображает 0aи 1b. Мы также сопоставляем 2и -a, так как эти символы печатаются в [[-]][base]#[num]нотации. Чтобы увидеть, как $xвыглядит до замены, а также ограничения Zsh в разборе целочисленных типов, проверьте выходные данные отладки в ссылке TIO.

GammaFunction
источник
1

Java (JDK) , 42 байта

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

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

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

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

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

Оливье Грегуар
источник
1

Баш , 30 байт

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

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

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

maxb
источник