Dengan tantangan seperti Keluaran dengan panjang yang sama dengan kode dan Buat keluaran dua kali panjang kode , saya memikirkan tantangan terpisah, tetapi serupa.

Tugasnya adalah menghasilkan output. Ini bisa berupa string, daftar karakter, atau apa pun format output default program Anda. Namun, output Anda harus selalu sama, terlepas dari inputnya. Dan yang lebih penting, output harus berbeda untuk input yang berbeda .

Memasukkan

Bilangan bulat tunggal $n$ , rentangnya ditentukan oleh pilihan bahasa. Jika bahasa Anda memiliki bilangan bulat panjang variabel, kisarannya adalah $-2^{31} \leq n < 2^{31}$ .

Keluaran

String atau daftar karakter, atau cetak ke STDOUT atau STDERR. Anda hanya dapat menggunakan salah satu metode ini. Keluaran harus memiliki panjang yang sama terlepas dari input, tetapi terserah Anda untuk menentukan panjang yang mana. Output mungkin tidak mengandung karakter digit 0-9, atau tanda minus- . Outputnya harus deterministik .

Anda harus dapat membuktikan bahwa untuk setiap output hanya ada satu input yang mungkin , baik dengan bukti formal, argumen, atau pencarian brute-force.

Ini adalah pertanyaan kode golf, jadi hilangkan byte yang tidak tersedia. Semua bahasa dipersilakan, semakin banyak semakin baik!

JavaScript (ES8), 33 byte

Mengharapkan input dalam kisaran integer JS aman : $-2^{53}\le n < 2^{53}$ .

Mengembalikan string 76 karakter.

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

Cobalah online!

Bagaimana?

Langkah 1

Input pertama dikonversi ke biner. Ini mempertahankan tanda minus utama untuk angka negatif.

Contoh:

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

Langkah 2

String yang dihasilkan dikodekan dalam basis-64.

Ini berarti bahwa setiap blok 1 hingga 3 karakter akan diubah menjadi blok baru 4 karakter. Konversi ini aman karena tidak ada blok yang dihasilkan yang mengandung simbol terlarang (angka atau tanda minus).

Blok 3 karakter

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

Blok terakhir tunggal 1 atau 2 karakter harus dikodekan jika panjang string biner bukan kelipatan 3:

Blok 1 karakter

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

Blok 2 karakter

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

Langkah 3

Hasil akhir diisi dengan spasi tambahan.

Python 3 , 49 39 byte

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

Cobalah online!

-10 byte berkat negatif tujuh

Mengubah bilangan bulat menjadi heksadesimal, dan menambahkan spasi hingga total 9 karakter. Kemudian, gandakan kode ASCII dari setiap karakter dalam string (beberapa meluas di luar ASCII menjadi Unicode, tetapi Python menanganinya dengan baik), menghasilkan daftar karakter.

Ini berfungsi karena setiap digit, termasuk -, dipetakan ke karakter ASCII yang berbeda. Tidak ada bilangan bulat di antara -2147483648dan 2147483648yang sama, jadi mengonversinya menjadi ruang heksadesimal dan tidak bergantung akan membuat mereka sama. Kemudian, memetakannya ke titik-titik kod yang berbeda tidak mengarah ke tabrakan, jadi masih tidak ada dua nilai dalam rentang yang menghasilkan output yang sama.

Python 3 , 59 56 47 byte

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

Cobalah online!

-3 byte berkat Jitse

-9 byte berkat negatif tujuh

Algoritma yang sama, tetapi menggunakan mapbukan forloop.

05AB1E , 11 5 byte

тjÇ·ç

-6 byte porting pendekatan @Stephen , jadi pastikan untuk meng - upgrade - nya!

Output daftar hingga 100 karakter, dengan $100-(\text{input length})$ jumlah @(dua kali lipat dari codepoint ruang), dan semua -0123456789dipetakan ke Z`bdfhjlnpr(dua kali lipat pada codepoint ASCII).

Cobalah online.

Penjelasan:

 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)

Jawaban 11 byte asli :

Ķ×AIdè«žIj

Cobalah online (terbatas 1000bukan 2147483648).

Penjelasan:

Panjang keluaran selalu sepanjang 2.147.483.648 karakter. Ini akan menampilkan $2147483648-|n|-1$ jumlah ruang, ditambahkan dengan $|n|$jumlah baris baru, ditambahkan dengan 'a' jika $n\lt0$ atau 'b' jika $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 byte

Program ini membutuhkan sel, di mana $c_n \in \mathbb{N}$ , tetapi jika Anda ingin hasil yang konsisten, pastikan bahwa $c_n < 256$

Output jelas akan menjadi unik, apa pun nomor yang akan Anda masukkan ( $-\infty \lt n \lt \infty$ ). Jika integer lebih pendek, program akan mengeluarkan output agar sama persis dengan $\infty$ byte, sehingga panjangnya selalu sama.

Jawaban ini agak melonggarkan tantangan, karena tidak menyatakan bahwa output harus terbatas.

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

Cobalah online!

Asli, jawaban 28 byte:

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

Yang ini akan pad output menjadi tepat $2^8 - 1$ byte. Mekanisme konversi angka berfungsi sama di sini. Program ini mengasumsikan sama dengan program di atas.

Python 3 , 39 byte

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

Cobalah online!

Ternyata angka ke dalam string representasi biner (diisi dengan spasi), kemudian memetakan karakter (space)-01untuk caabdengan str.translatefungsi.

Jelly , 4 byte

œ?ØẠ

Tautan monadik yang menerima bilangan bulat yang menghasilkan daftar 52 karakter.

Kisaran input mungkin hingga agak lebih dari $-2^{223} \leq n \lt 2^{223}$ sejak $52!>2^{224}$ .

Cobalah online!

Bagaimana?

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

Begitu...

-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 byte

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

Cobalah online!

('%34b'%n)Mengubah bilangan bulat ke dalam representasi binernya, gunakan ..1untuk menunjukkan angka negatif (ini dimaksudkan untuk mewakili awalan 1s yang tak terhingga panjang), dan menempatkan kiri ini ke 34 karakter menggunakan spasi. Lalu kita ganti 0huruf s dengan 'a' dan 1s dengan 'h' untuk membuat Representasi Pangkalan 2 Maniacal: string seperti "haaahahahaaha" diawali dengan spasi dan kadang-kadang ... Karena setiap langkah di sini tidak dapat dibalik, ini adalah 1: 1.

Sunting: Biarkan catatan menunjukkan bahwa @manatwork memposting solusi identik ini terlebih dahulu. Ups. Seharusnya aku menyegarkan.

Jeli , 6 byte

Ø%+ṃØA

Cobalah online!

Karena Jelly memiliki bilangan bulat panjang yang berubah-ubah, tautan monadik ini mengambil bilangan bulat dalam kisaran $±2^{31}$ dan mengembalikan string alfabet 7 panjang. Ia bekerja dengan menambahkan $2^{32}$ dan kemudian basis dekompresi ke dalam huruf kapital.

C (gcc) , 38 byte

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

Cobalah online!

Ini memperluas setiap bit dari integer input ke dalam byte yang bernilai 0 atau 1 (yang keduanya merupakan karakter yang tidak dapat dicetak, tetapi tidak ada aturan yang menentangnya). Jadi output selalu 32 byte, dan dijamin unik.

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

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

Cobalah online!

Haskell, 31 byte

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

Cobalah online!

Menambah 2^60input sehingga jumlah yang dihasilkan memiliki jumlah digit yang sama untuk seluruh rentang input. Ubah menjadi string dan geser setiap karakter 10 tempat ke kanan dalam urutan ASCII ( 0-> :... 9-> C).

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

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

Cobalah online!

Pendekatan berbeda terhadap solusi ac #, mengambil keuntungan dari kenyataan bahwa modulus c # negatif untuk bilangan negatif. Saya kira Anda bisa memotong satu atau dua byte jika Anda mengizinkan karakter non-tampilan ('\ 0', dan seterusnya) dengan memperbarui +65...untuk tidak mengimbangi nilai karakter ke sesuatu yang dapat dibaca manusia.

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

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

Cobalah online!

Sebelumnya:

Perl 5 -p , 29 byte

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

Cobalah online!

Bertobat nomor untuk 64 bit representasi biner, maka transliterates 0dan 1untuk adan bmasing-masing.

T-SQL, 73 70 61 byte

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

Saya hanya langsung mengganti digit (dan -) dengan huruf, setelah STRmengisi integer menjadi 11 karakter. Tidak perlu konversi ke hex atau biner.

TRANSLATE diperkenalkan di SQL 2017.

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

EDIT : Disimpan 3 byte dengan mengganti padding manual dengan konversi ke CHAR (11), yang merupakan format karakter lebar tetap yang secara otomatis mengisi dengan spasi.

EDIT 2 : Disimpan 9 byte dengan menggunakan STR()fungsi alih-alihCAST . STRmengonversi angka menjadi string teks yang diisi hingga panjang yang ditentukan.

APL (Dyalog Unicode) , 28 byte

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

Cobalah online!

Dfn sederhana, mengambil argumen integer. Penggunaan⎕IO←0 .

TIO menghubungkan ke suatu test case dari -2^10ke 2^10. Bagian 0~⍨menghapus duplikat0 dari argumen.

Bagaimana:

{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 byte

Saya pikir ini benar. Terinspirasi oleh solusi Python Stephen jadi tolong +1dia.

¤ùI cÑ

Cobalah

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

$\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

Cobalah online!

Perl 6 , 12 byte

*~|('@'x 11)

Cobalah online!

Anonim Apapun lambda yang mengambil angka dan merangkai OR dengan 11 @detik. Ini memetakan digit ke pqrstuvwxydan tanda hubung ke m, lalu mengisi string dengan 11 karakter dengan @s

Perl 5 (-p), 9 byte

$_^=A x$=

Cobalah online!

Bitwxise-xor dari input dengan string AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.

Bahasa Wolfram (Mathematica) , 44 33 byte

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

Cobalah dengan domain yang lebih kecil

Terima kasih Greg Martin

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

Mengingat ukuran output, saya sudah memasukkan test case dengan domain yang lebih kecil $[-2^4,2^4)$ sebagai gantinya

Stax , 6 byte

11){Hm

Jalankan dan debug itu

Prosedur:

1. Masukan pad kiri hingga 11 karakter.
2. Gandakan setiap karakter ascii tanpa spasi.

PHP , 64 54 byte

-10 byte dengan menggunakan strtrfungsi alih-alih penggantian karakter manual.

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

Cobalah online!

Nilai int terbesar yang mungkin ada dalam PHP saat ini 9223372036854775807adalah 19 digit, mengingat tanda minus dalam angka negatif, itu akan menjadi 20. Kode di atas menggantikan tanda minus ( -) dengan Akarakter dan setiap digit dari 0hingga 9dengan karakter dari Dhingga Mdan kemudian bantalan string di sebelah kanan dengan karakter spasi untuk selalu membuatnya sepanjang 20 karakter. Misalnya, output untuk input -9876543210adalah "AMLKJIHGFED ".

Output adalah unik untuk setiap masukan integer dan Anda dapat kembali ke input dengan menghapus semua spasi, menggantikan Adengan -dan menggantiD untuk Mdengan 0ke 9.

PHP , 44 byte

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

Cobalah online!

Ini ide yang sama dengan jawaban Arnauld . Mengubah input menjadi biner, dan kemudian mengubahnya menjadi basis-64. Juga memasukkannya ke 88 karakter (panjang terbesar -9223372036854775807adalah 88 karakter) dengan karakter spasi di sebelah kanan untuk selalu mendapatkan panjang yang sama dalam output.

Retina 0.8.2 , 21 byte

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

Cobalah online! Selalu menampilkan 11 karakter dari jangkauan n..z . Penjelasan:

T`p`l

Terjemahkan karakter ASCII yang dapat dicetak ke huruf kecil. Peta ini -untuk ndan 0.. 9untuk q.. z. (Sangat beruntung bahwa digit-digit tersebut adalah karakter ASCII yang dapat dicetak dari tanggal 16 hingga 25!)

$
10$*o

Tambahkan 10 os. Karena input akan memiliki antara 1 dan 11 karakter, sekarang ada antara 11 dan 21 karakter.

!`.{11}

Ekstrak 11 karakter pertama. Karena jumlahnya kurang dari 22 karakter, ini hanya akan cocok sekali.

Arang , 9 byte

◧⍘﹪ＮＸχχαχ

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Selalu menghasilkan 10 spasi dan huruf besar. Penjelasan:

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

R , 37 byte

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

Cobalah online!

Sepertinya outputnya acak, tetapi tidak! Input digunakan sebagai seed dari Pseudo-Random Number Generator, dan kami kemudian mendapatkan salah satunya$26!=4\cdot 10^{26}$permutasi alfabet. Outputnya selalu panjang 51 (26 huruf + 25 spasi).

Masih ada masalah mengasuransikan bahwa semua output berbeda. Kita berakhir dengan$2^{32}\approx 4\cdot 10^9$ permutasi (dari $4\cdot 10^{26}$). Jika kita berpura-pura bahwa permutasi didistribusikan secara seragam secara acak, maka probabilitas bahwa semua permutasi berbeda dapat dihitung dengan mengikuti perhitungan yang sama seperti untuk masalah Ulang Tahun . Probabilitas bahwa 2 output spesifik identik adalah$10^{-17}$, jadi perkiraan urutan pertama dari probabilitas itu semua $2^{32}$ output yang berbeda adalah

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

yang cukup dekat dengan 1 untuk saya.

brainfuck , 20 19 byte

-1 byte terima kasih kepada Krzysztof Szewczyk

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

Cobalah online!

Menghasilkan angka dengan setiap digit dan tanda hubung yang dipetakan ke 255 dikurangi nilai ordinalnya, diisi hingga 255 karakter dengan NUL byte.

R , 40 37 byte

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

Cobalah online!

Alternatif jawaban Robin Ryder ; ini tentu saja deterministik.

Ini mengubah input ke rawvektor 32 byte, setiap byte menjadi angka hex 00atau 01mewakili bit integer. Kami kemudian memaksa ke logicaldengan membandingkan 0, sehingga 00dipetakan ke FALSEdan 01ke TRUE. Maka kita perlu menghapus satu huruf dari masing FALSE- masing untuk menjamin output dengan panjang yang sama, dipilih secara sewenang-wenang S. Hasilnya dicetak (dengan spasi) untuk panjang 169.

Zsh , 43 byte

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)

Cobalah online!

Solusi ini mengatasi long longbatasan bilangan bulat Zsh dengan bekerja hanya dengan karakter. Saya hanya menambahkannya ke 30 karakter agar mudah dibaca, tetapi menggantinya 30dengan 99akan memungkinkan metode ini bekerja pada semua angka dari -1E99+1hingga 1E100-1.

Efek menafsirkan kode desimal sebagai heksadesimal adalah sebagai berikut:

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 byte

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

Cobalah online!

Menyatakan x sebagai angka biner, nol-empuk hingga lebar 66. Kemudian peta 0→ adan 1→ b. Kami juga memetakan 2dan -ke, karena karakter tersebut dicetak dalam [[-]][base]#[num]notasi. Untuk melihat $xseperti apa sebelum penggantian, dan batas Zsh dalam mem-parsing tipe integer, periksa output Debug di tautan TIO.

Jawa (JDK) , 42 byte

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

Cobalah online!

Pertama, ini menciptakan representasi heksadesimal dari input, diisi dengan spasi yang memberikan batasan panjang yang sama (panjang 8 karakter), menghilangkan tanda minus, dan membuat setiap output intermediate unik.

Ini memberikan string dengan 17 karakter berbeda yang mungkin: 0123456789abcdef dan ruang.

Kemudian setiap karakter di-stream dan dipetakan dengan menambahkan 64 ke codepoint-nya jika itu digit atau spasi. Secara efektif, hasil ini dalam pemetaan berikut: 0123456789abcdef<space>untuk pqrstuvwxyabcdef`yang memiliki 17 karakter yang berbeda, sehingga tidak ada dua angka akan menghasilkan output yang sama.

Bash , 30 byte

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

Cobalah online!

Untuk membuktikan bahwa output itu unik, saya hanya mencari Google untuk tabrakan MD5, dan tidak menemukan hasil di antara bilangan bulat $-2^{31}$ dan $2^{31}$. Untuk menghindari karakter terlarang dalam output, cukup terjemahkan karakter yang dimaksud menjadi huruf besar. Output selalu sama panjangnya dengan definisi, dan dijamin tidak mengandung karakter yang dilarang.