Với những thách thức như Đầu ra có cùng độ dài với mã và Tạo đầu ra gấp đôi độ dài của mã , tôi nghĩ đến một thử thách riêng nhưng tương tự.

Nhiệm vụ là tạo ra một đầu ra. Nó có thể là một chuỗi, một danh sách các ký tự hoặc bất cứ định dạng đầu ra mặc định nào của chương trình của bạn. Tuy nhiên, đầu ra của bạn phải luôn có cùng độ dài, bất kể đầu vào. Và quan trọng hơn, đầu ra phải khác nhau cho các đầu vào khác nhau .

Đầu vào

Một số nguyên duy nhất , các phạm vi được xác định bởi sự lựa chọn ngôn ngữ. Nếu ngôn ngữ của bạn có số nguyên có độ dài thay đổi, phạm vi là .$n$$-2^{31} \leq n < 2^{31}$

Đầu ra

Một chuỗi hoặc một danh sách các ký tự, hoặc một bản in sang STDOUT hoặc STDERR. Bạn chỉ có thể sử dụng một trong những phương pháp này. Đầu ra phải có cùng độ dài bất kể đầu vào là gì, nhưng tùy thuộc vào bạn để xác định độ dài đó là gì. Đầu ra có thể không chứa các ký tự chữ số 0-9hoặc dấu trừ- . Đầu ra phải có tính quyết định .

Bạn sẽ có thể chứng minh rằng đối với mỗi đầu ra chỉ có một đầu vào khả dĩ , bằng một bằng chứng chính thức, một đối số hoặc một tìm kiếm vũ phu.

Đây là một câu hỏi golf mã, vì vậy hãy loại bỏ bất kỳ byte ngoại lai nào. Tất cả các ngôn ngữ đều được chào đón, càng nhiều càng tốt!

JavaScript (ES8), 33 byte

Yêu cầu đầu vào trong phạm vi số nguyên JS an toàn : .$-2^{53}\le n < 2^{53}$

Trả về một chuỗi gồm 76 ký tự.

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

Hãy thử trực tuyến!

Làm sao?

Bước 1

Đầu vào đầu tiên được chuyển đổi thành nhị phân. Điều này bảo tồn dấu trừ hàng đầu cho số âm.

Ví dụ:

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

Bước 2

Chuỗi kết quả được mã hóa trong cơ sở-64.

Điều đó có nghĩa là mỗi khối từ 1 đến 3 ký tự sẽ được chuyển thành một khối mới gồm 4 ký tự. Chuyển đổi này là an toàn vì không có khối kết quả nào chứa các ký hiệu bị cấm (chữ số hoặc dấu trừ).

Khối 3 ký tự

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

Một khối cuối cùng gồm 1 hoặc 2 ký tự phải được mã hóa nếu độ dài của chuỗi nhị phân không phải là bội số của 3:

Khối 1 ký tự

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

Khối 2 ký tự

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

Bước 3

Đầu ra cuối cùng được đệm với dấu cách.

Python 3 , 49 39 byte

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

Hãy thử trực tuyến!

-10 byte nhờ bảy âm

Chuyển đổi số nguyên thành thập lục phân và thêm khoảng trắng tối đa 9 ký tự. Sau đó, nhân đôi mã ASCII của từng ký tự trong chuỗi (một số mở rộng ra bên ngoài ASCII thành Unicode, nhưng Python xử lý tốt), đưa ra danh sách các ký tự.

Điều này hoạt động vì mọi chữ số, bao gồm -, được ánh xạ tới một ký tự ASCII khác nhau. Không có số nguyên nào giữa -2147483648và 2147483648bằng nhau, do đó, chuyển đổi chúng thành không gian thập lục phân và chuẩn bị trước sẽ không làm cho chúng bằng nhau. Sau đó, ánh xạ chúng tới các điểm mã khác nhau không dẫn đến xung đột, do đó vẫn không có hai giá trị trong phạm vi dẫn đến đầu ra bằng nhau.

Python 3 , 59 56 47 byte

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

Hãy thử trực tuyến!

-3 byte nhờ Jitse

-9 byte nhờ bảy âm

Cùng một thuật toán, nhưng sử dụng mapthay vì một forvòng lặp.

05AB1E , 11 5 byte

тjÇ·ç

-6 byte porting cách tiếp cận của @Stephen , vì vậy hãy đảm bảo nâng cấp anh ấy!

Kết quả đầu ra một danh sách lên đến 100 ký tự, với $100-(\text{input length})$ số lượng @(tăng gấp đôi điểm mã không gian), và tất cả các -0123456789ánh xạ tới Z`bdfhjlnpr(tăng gấp đôi codepoints ASCII).

Hãy thử trực tuyến.

Giải trình:

 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)

Câu trả lời gốc 11 byte :

Ķ×AIdè«žIj

Hãy thử trực tuyến (giới hạn 1000thay vì 2147483648).

Giải trình:

Độ dài đầu ra luôn dài 2.147.483.648 ký tự. Nó sẽ xuất $2147483648-|n|-1$ lượng không gian, được thêm vào $|n|$Lượng dòng mới, nối với một trong hai một 'a' nếu $n\lt0$ hoặc 'b' nếu $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

Chương trình này yêu cầu các ô, trong đó $c_n \in \mathbb{N}$ , nhưng nếu bạn muốn có kết quả nhất quán, hãy đảm bảo rằng $c_n < 256$

Đầu ra rõ ràng sẽ là vấn đề không độc đáo gì số bạn sẽ nhập ( $-\infty \lt n \lt \infty$ ). Nếu số nguyên ngắn hơn, chương trình sẽ loại bỏ đầu ra để khớp chính xác $\infty$ byte, do đó độ dài luôn giống nhau.

Câu trả lời này là một chút khập khiễng thách thức, vì nó không nói rằng đầu ra phải là hữu hạn.

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

Hãy thử trực tuyến!

Câu trả lời gốc, 28 byte:

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

Cái này sẽ đệm đầu ra chính xác là $2^8 - 1$ byte. Cơ chế chuyển đổi số hoạt động tương tự ở đây. Chương trình này giả định giống như chương trình trên.

Python 3 , 39 byte

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

Hãy thử trực tuyến!

Biến số lượng nhất định vào một chuỗi đại diện nhị phân (đệm với không gian), sau đó bản đồ các nhân vật (space)-01đến caabvới str.translatechức năng.

Thạch , 4 byte

œ?ØẠ

Liên kết đơn âm chấp nhận một số nguyên mang lại danh sách 52 ký tự.

Phạm vi đầu vào có thể lên tới hơn $-2^{223} \leq n \lt 2^{223}$ kể từ $52!>2^{224}$ .

Hãy thử trực tuyến!

Làm sao?

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

Vì thế...

-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'}

Hãy thử trực tuyến!

('%34b'%n)Chuyển đổi một số nguyên thành biểu diễn nhị phân của nó, sử dụng ..1để chỉ ra một số âm (điều này có nghĩa là đại diện cho một tiền tố dài vô hạn 1 giây) và các phần đệm bên trái này có tới 34 ký tự sử dụng khoảng trắng. Sau đó, chúng tôi thay thế 0s bằng 'a' và 1s bằng 'h' để tạo Đại diện cho Cơ sở 2 điên rồ: các chuỗi như "haaahahahaaha" được thêm vào khoảng trắng và đôi khi ... Vì mỗi bước ở đây là không thể đảo ngược nên đây là 1: 1.

Chỉnh sửa: Hãy để bản ghi cho thấy @manatwork đăng giải pháp giống hệt này trước. Rất tiếc. Tôi nên làm mới.

Thạch , 6 byte

Ø%+ṃØA

Hãy thử trực tuyến!

Vì Jelly có các số nguyên độ dài tùy ý, liên kết đơn âm này lấy một số nguyên trong phạm vi $±2^{31}$ và trả về một chuỗi dài 7 chữ cái. Nó hoạt động bằng cách thêm $2^{32}$ và sau đó giải nén vào chữ in hoa.

C (gcc) , 38 byte

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

Hãy thử trực tuyến!

Điều này mở rộng từng bit của số nguyên đầu vào thành một byte bằng 0 hoặc 1 (cả hai ký tự không thể in được, nhưng không có quy tắc nào chống lại điều đó). Vì vậy, đầu ra luôn là 32 byte và được đảm bảo là duy nhất.

C # (Trình biên dịch tương tác Visual C #) , 35 byte

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

Hãy thử trực tuyến!

Haskell, 31 byte

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

Hãy thử trực tuyến!

Thêm 2^60vào đầu vào để số kết quả có cùng số lượng chữ số cho toàn bộ phạm vi đầu vào. Biến thành một chuỗi và dịch chuyển mỗi ký tự 10 vị trí sang phải theo thứ tự ASCII ( 0-> :... 9-> C).

C # (Trình biên dịch tương tác Visual C #) , 52 byte

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

Hãy thử trực tuyến!

Cách tiếp cận khác nhau đối với giải pháp ac #, lợi dụng thực tế là mô đun c # âm đối với số âm. Tôi cho rằng bạn có thể tắt một hoặc hai byte nếu bạn cho phép các ký tự không hiển thị ('\ 0', v.v.) bằng cách cập nhật +65...để không bù giá trị ký tự thành thứ gì đó có thể đọc được.

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

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

Hãy thử trực tuyến!

Trước đây:

Perl 5 -p , 29 byte

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

Hãy thử trực tuyến!

Chuyển đổi số thành biểu diễn nhị phân 64 bit của nó, sau đó chuyển ngữ 0và 1sang avà b, tương ứng.

T-SQL, 73 70 61 byte

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

Tôi chỉ trực tiếp thay thế các chữ số (và -) bằng các chữ cái, sau khi STRđệm số nguyên thành 11 ký tự. Không cần chuyển đổi sang hex hoặc nhị phân.

TRANSLATE đã được giới thiệu trong SQL 2017.

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

EDIT : Đã lưu 3 byte bằng cách thay thế phần đệm thủ công bằng chuyển đổi thành CHAR (11), đây là định dạng ký tự có chiều rộng cố định tự động đệm với khoảng trắng.

EDIT 2 : Đã lưu 9 byte bằng cách sử dụng STR()chức năng thay vì CAST. STRchuyển đổi một số thành một chuỗi văn bản được đệm theo chiều dài được chỉ định.

APL (Dyalog Unicode) , 28 byte

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

Hãy thử trực tuyến!

Dfn đơn giản, lấy một đối số nguyên. Công dụng ⎕IO←0.

TIO liên kết đến một trường hợp thử nghiệm từ -2^10đến 2^10. Phần 0~⍨loại bỏ trùng lặp 0từ các đối số.

Làm sao:

{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

Tôi nghĩ rằng điều này là đúng. Lấy cảm hứng từ giải pháp Python của Stephen vì vậy xin vui lòng +1anh ta.

¤ùI cÑ

Thử nó

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

Hãy thử trực tuyến!

Perl 6 , 12 byte

*~|('@'x 11)

Hãy thử trực tuyến!

Vô danh Bất cứ lambda nào lấy một số và chuỗi OR nó với 11 @s. Điều này ánh xạ các chữ số đến pqrstuvwxyvà dấu gạch ngang m, sau đó đệm chuỗi thành 11 ký tự với @s

Perl 5 (-p), 9 byte

$_^=A x$=

Hãy thử trực tuyến!

Bitwxise-xor của đầu vào với chuỗi AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.

Ngôn ngữ Wolfram (Mathicala) , 44 33 byte

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

Hãy thử nó với một miền nhỏ hơn

-2 nhờ Greg Martin

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

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

Stax , 6 byte

11){Hm

Chạy và gỡ lỗi nó

Thủ tục:

1. Nhập pad trái vào 11 ký tự.
2. Nhân đôi mỗi nhân vật ascii không gian.

PHP , 64 54 byte

-10 byte bằng cách sử dụng strtrchức năng thay vì thay thế ký tự thủ công.

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

Hãy thử trực tuyến!

Giá trị int lớn nhất có thể có trong PHP hiện tại là 922337203685477580719 chữ số, xét đến dấu trừ trong số âm, nó sẽ là 20. Đoạn mã trên thay thế dấu trừ ( -) bằng Aký tự và mọi chữ số từ 0đến 9một ký tự từ Dđến Mvà sau đó đệm chuỗi bên phải bằng ký tự khoảng trắng để luôn làm cho nó dài 20 ký tự. Ví dụ, đầu ra cho đầu vào -9876543210là "AMLKJIHGFED ".

Đầu ra là duy nhất cho mỗi đầu vào số nguyên và bạn có thể lấy lại cho các đầu vào bằng cách loại bỏ tất cả không gian, thay thế Avới -và thay thế Dđể Mvới 0tới 9.

PHP , 44 byte

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

Hãy thử trực tuyến!

Đây là ý tưởng tương tự như câu trả lời của Arnauld . Chuyển đổi đầu vào thành nhị phân, và sau đó chuyển đổi nó thành cơ sở 64. Ngoài ra, đệm tới 88 ký tự (độ dài lớn nhất -9223372036854775807là 88 ký tự) với ký tự khoảng trắng ở bên phải để luôn có cùng độ dài ở đầu ra.

Võng mạc 0.8.2 , 21 byte

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

Hãy thử trực tuyến! Luôn kết quả đầu ra 11 ký tự từ phạm vi n.. z. Giải trình:

T`p`l

Dịch các ký tự ASCII có thể in sang các chữ cái viết thường. Bản đồ này -để nvà 0.. 9để q.. z. (Thật may mắn khi các chữ số là ký tự ASCII thứ 16 đến 25 có thể in được!)

$
10$*o

Nối 10 os. Vì đầu vào sẽ có từ 1 đến 11 ký tự, hiện tại có từ 11 đến 21 ký tự.

!`.{11}

Trích xuất 11 ký tự đầu tiên. Vì có ít hơn 22 ký tự, điều này sẽ chỉ khớp một lần.

Than , 9 byte

◧⍘﹪ＮＸχχαχ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Luôn xuất ra 10 khoảng trắng và chữ in hoa. Giải trình:

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

Hãy thử trực tuyến!

$26!=4\cdot 10^{26}$

$2^{32}\approx 4\cdot 10^9$$4\cdot 10^{26}$$10^{-17}$$2^{32}$

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

đủ gần 1 cho tôi.

Brainfuck , 20 19 byte

-1 byte nhờ Krzysztof Szewchot

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

Hãy thử trực tuyến!

Xuất ra số với mỗi chữ số và dấu gạch ngang được ánh xạ tới 255 trừ đi giá trị thứ tự của chúng, được đệm thành 255 ký tự với các byte NUL.

R , 40 37 byte

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

Hãy thử trực tuyến!

Một thay thế cho câu trả lời của Robin Ryder ; điều này chắc chắn là quyết định

Điều này chuyển đổi đầu vào thành một rawvectơ 32 byte, mỗi byte là một số hex 00hoặc 01đại diện cho các bit của số nguyên. Sau đó chúng tôi ép buộc để một logicalbằng cách so sánh với 0, vì vậy 00được ánh xạ tới FALSEvà 01đến TRUE. Sau đó, chúng ta cần xóa một chữ cái duy nhất từ ​​mỗi chữ cái FALSEđể đảm bảo đầu ra có độ dài bằng nhau, được chọn tùy ý S. Kết quả được in (có khoảng trắng) cho chiều dài 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)

Hãy thử trực tuyến!

Giải pháp này vượt qua long longgiới hạn số nguyên của Zsh bằng cách chỉ làm việc với các ký tự. Tôi chỉ đệm nó đến 30 ký tự để dễ đọc, nhưng thay thế 30bằng 99sẽ cho phép phương thức này hoạt động trên tất cả các số từ -1E99+1đến 1E100-1.

Hiệu quả của việc diễn giải mã thập phân là thập lục phân như sau:

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}

Hãy thử trực tuyến!

Khai báo x dưới dạng số nhị phân, không đệm đến chiều rộng 66. Sau đó ánh xạ 0→ avà 1→ b. Chúng tôi cũng lập bản đồ 2và -đến một, vì các ký tự đó được in theo [[-]][base]#[num]ký hiệu. Để xem giao $xdiện trước khi thay thế và giới hạn của Zsh trong phân tích cú pháp các kiểu số nguyên, hãy kiểm tra đầu ra Gỡ lỗi trong liên kết TIO.

Java (JDK) , 42 byte

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

Hãy thử trực tuyến!

Đầu tiên, điều này tạo ra biểu diễn thập lục phân của đầu vào, được đệm bên trái với các khoảng trắng cung cấp cùng một ràng buộc độ dài (dài 8 ký tự), loại bỏ dấu trừ và giữ cho mỗi đầu ra trung gian duy nhất.

Điều này cung cấp một chuỗi với 17 ký tự có thể khác nhau: 0123456789abcdefvà khoảng trắng.

Sau đó, mỗi ký tự được truyền phát và ánh xạ bằng cách thêm 64 vào điểm mã của nó nếu đó là một chữ số hoặc khoảng trắng. Một cách hiệu quả, kết quả này trong các bản đồ sau: 0123456789abcdef<space>để pqrstuvwxyabcdef`trong đó có 17 nhân vật khác nhau, vì vậy không có hai số sẽ dẫn đến việc cùng công suất.

Bash , 30 byte

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

Hãy thử trực tuyến!

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