Gibi zorluklarla koduyla aynı uzunlukta Çıktı ve iki kez kodunun uzunluğunu çıkışını oluştur , ben ayrı, ancak benzer zorluk düşündüm.

Görev bir çıktı üretmek. Bir dize, bir karakter listesi veya programınızın varsayılan çıktı biçimi ne olabilir. Ancak, çıktıdan bağımsız olarak, çıktınız her zaman aynı uzunlukta olmalıdır. Daha da önemlisi, çıktı farklı girdiler için farklı olmalıdır .

Giriş

Dil seçimi ile aralıkları belirlenen tek bir tam sayı $n$ . Dilinizde değişken uzunluktaki tamsayılar varsa, aralık $-2^{31} \leq n < 2^{31}$ .

Çıktı

Bir dize veya karakter listesi veya STDOUT veya STDERR'ye yazdır. Bu yöntemlerden sadece birini kullanabilirsiniz. Çıktı, girişe bakılmaksızın aynı uzunlukta olmalıdır, ancak hangi uzunluğu tanımlayacağınız size bağlıdır. Çıktı, rakam karakterlerini 0-9veya eksi işaretini içeremez- . Çıktı deterministik olmalıdır .

Bunu kanıtlamak gerekir her çıkış için tek olası girdi orada resmi bir kanıtı, bir bağımsız değişken ya da bir kaba kuvvet arama tarafından ya.

Bu bir kod golf sorusudur, bu yüzden yabancı baytları temizleyin. Tüm diller kabul edilir, daha iyi!

JavaScript (ES8), 33 bayt

Güvenli JS tam sayıları aralığındaki girişi bekler : $-2^{53}\le n < 2^{53}$ .

76 karakterden oluşan bir dize döndürür.

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

Çevrimiçi deneyin!

Nasıl?

Aşama 1

Giriş önce ikiliye dönüştürülür. Bu, negatif sayılar için baştaki eksi işaretini korur.

Örnekler:

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

Adım 2

Elde edilen dize base-64'te kodlandı.

Bu, 1 ila 3 karakterden oluşan her bloğun 4 karakterlik yeni bir bloğa dönüştürüleceği anlamına gelir. Bu dönüştürme güvenlidir, çünkü sonuçtaki blokların hiçbiri yasak sembolleri içermez (rakam veya eksi işareti).

3 karakterlik bloklar

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

İkili dizenin uzunluğu 3'ün katı değilse, 1 veya 2 karakterlik tek bir son blok kodlanmalıdır:

1 karakterlik bloklar

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

2 karakterlik bloklar

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

Aşama 3

Son çıktı, takip eden boşluklarla doldurulur.

Python 3 , 49 39 bayt

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

Çevrimiçi deneyin!

Negatif yedi sayesinde -10 bayt

Tam sayıyı onaltılık alana dönüştürür ve toplam 9 karaktere kadar boşluklar hazırlar. Ardından, dizedeki her karakterin ASCII kodunu ikiye katlar (bazıları ASCII'nin dışından Unicode'a kadar uzanır, ancak Python bunu iyi işler), bir karakter listesi çıkarır.

Bu çalışır çünkü dahil her basamak - , farklı bir ASCII karakteriyle eşleştiriliyor. Arasında hiçbir tamsayılar -2147483648ve 2147483648onaltılık dönüştürerek ve prepending alanlarda onları eşit yapmazdım yüzden eşittir. Ardından, onları farklı kod noktalarına eşlemek çarpışmalara yol açmaz, bu nedenle aralıkta eşit çıktılara yol açan iki değer yoktur.

Python 3 , 59 56 47 bayt

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

Çevrimiçi deneyin!

-3 bayt sayesinde Jitse

-9 bayt sayesinde Negatif yedi

Aynı algoritma, ancak mapbir fordöngü yerine kullanarak .

05AB1E , 11 5 bayt

тjÇ·ç

-Stephen'in yaklaşımını taşıyan 6 bayt , bu yüzden onu güçlendirdiğinizden emin olun!

$100-(\text{input length})$ miktarında @(boşluk kod -0123456789noktasını iki katına çıkarır) ve tümü ile eşlenen 100 karakterden oluşan bir liste çıkarır .Z`bdfhjlnpr iki katına (ASCII kod noktalarını iki katına çıkarır) çıkarır.

Çevrimiçi deneyin.

Açıklama:

 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)

Orijinal 11 baytlık cevap:

Ķ×AIdè«žIj

Çevrimiçi olarak deneyin (sınırlı1000 yerine 2147483648).

Açıklama:

Çıktı uzunluğu her zaman 2.147.483.648 karakter uzunluğundadır. $2147483648-|n|-1$ çıktı verecek - | n | - 1 adet boşluk eklenmiş $|n|$$n\lt0$ ise 'a' ya da $n\geq0$ ise 'b' olarak eklenen yeni satırların miktarı .

Ä            # 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 bayt

Bu program $c_n \in \mathbb{N}$ hücrelerini gerektirir , ancak tutarlı sonuçlar istiyorsanız, c n < 256 olduğundan emin olun.$c_n < 256$

Hangi rakamı gireceğiniz önemli değil, çıktı açıkça benzersiz olacaktır ( $-\infty \lt n \lt \infty$ ). Tamsayı daha kısaysa, program çıktısını tam olarak $\infty$ byte'a uyacak şekilde düzenler , böylece uzunluk her zaman aynı olur.

Bu cevap, çıktının sınırlı olması gerektiğini söylemediği için mücadeleyi biraz zorlaştırıyor.

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

Çevrimiçi deneyin!

Orijinal, 28 baytlık cevap:

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

Bu, bir olacak ped çıkışı tam olarak olmak $2^8 - 1$ bayt. Sayı dönüştürme mekanizması burada aynı şekilde çalışır. Bu program yukarıdaki program ile aynı varsayılmaktadır.

Python 3 , 39 bayt

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

Çevrimiçi deneyin!

(Boşluklarla takviye) bir ikili dize temsil içine verilen sayı, sonra da karakterleri eşler açar (space)-01etmek caabile str.translatefonksiyonu.

Jöle , 4 bayt

œ?ØẠ

Tek karakterli bir bağlantı, 52 karakterlik bir liste veren bir tamsayıyı kabul eder.

Giriş aralığı, 52'den bu yana $-2^{223} \leq n \lt 2^{223}$ biraz daha fazla olabilir ! > 2 224 .$52!>2^{224}$

Çevrimiçi deneyin!

Nasıl?

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

Yani...

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

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

Çevrimiçi deneyin!

('%34b'%n)Bir tam sayıyı, ..1negatif bir sayı belirtmek için kullanarak ikili gösterime dönüştürür (bu, 1'lerin sonsuz uzunluğundaki bir önekini ifade etmek içindir) ve boşlukları kullanarak bunu 34 karaktere bırakmak için kullanılır. Daha sonra Maniacal Base 2 Temsilini yaratmak için s'leri 0'a' ve 1s'leri 'h' ile değiştiririz: boşluklarla ve bazen hazırlanmış "haaahahahaaha" gibi dizeler ... Buradaki her adım tersinir olduğu için bu 1: 1'dir.

Düzenleme: Kaydın önce @ manatwork'ün bu özdeş çözümü gönderdiğini göstermesine izin verin. Hata. Yenilenmeliydim.

Jöle , 6 bayt

Ø%+ṃØA

Çevrimiçi deneyin!

$±2^{31}$$2^{32}$

C (gcc) , 38 bayt

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

Çevrimiçi deneyin!

Bu, giriş tamsayısının her bir bitini, 0 veya 1 olan bir baytta genişletir (her ikisi de yazdırılamayan karakterlerdir, ancak buna karşı bir kural yoktur). Bu yüzden çıktı her zaman 32 bayttır ve benzersiz olması garanti edilir.

C # (Visual C # Etkileşimli Derleyici) , 35 bayt

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

Çevrimiçi deneyin!

Haskell, 31 bayt

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

Çevrimiçi deneyin!

Girdiye eklenir 2^60, böylece sonuçta elde edilen sayı, tüm girdi aralığı için aynı sayıda haneye sahip olur. Bir dizgiye dönün ve her karakteri ASCII sırasına göre 10 yere sağa kaydırın ( 0->: ... 9-> C) .

C # (Visual C # Etkileşimli Derleyici) , 52 bayt

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

Çevrimiçi deneyin!

Ac # çözümüne farklı yaklaşım, c # modülünün negatif sayılar için negatif olması gerçeğinden yararlanır. Sanırım +65...karakter değerini, okunabilir bir karaktere mahsup etmeyecek şekilde güncelleyerek karakter dışı karakterlere ('\ 0' vb.) İzin verirseniz bir veya iki bayt tıraş edebilirsiniz .

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

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

Çevrimiçi deneyin!

Önceden:

Perl 5 -p , 29 bayt

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

Çevrimiçi deneyin!

Onun 64 bitlik ikilik gösterime dönüştürür numarası, daha sonra çevirisi şu 0ve 1etmek ave bsırasıyla.

T-SQL, 73 70 61 bayt

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

Tam sayıyı 11 karaktere kadar doldurduktan -sonra rakamları (ve ) doğrudan harflerle değiştiriyorum STR. Onaltılı veya ikiliye dönüştürme gerekmez.

TRANSLATE SQL 2017'de tanıtıldı.

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

EDIT : Manuel dolguyu, otomatik olarak boşluklarla dolduran sabit genişlikli bir karakter biçimi olan CHAR'a (11) dönüştürerek değiştirerek 3 bayt kurtardı.

2 EDIT : yerine işlevini kullanarak 9 bayt kaydedildi . bir sayıyı belirtilen uzunlukta yastıklı bir metin dizgisine dönüştürür.STR()CASTSTR

APL (Dyalog Unicode) , 28 bayt

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

Çevrimiçi deneyin!

Basit Dfn, bir tamsayı argümanı alarak. Kullanır ⎕IO←0.

TIO bir test durumu bağlantılar -2^10için 2^10. 0~⍨Bölüm yinelenen kaldırır 0Tartışmalarınızın.

Nasıl:

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

Ben düşünüyorum bu doğru. Stephen'ın Python çözümünden esinlenildi, o yüzden lütfen +1onu.

¤ùI cÑ

Dene

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

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

Çevrimiçi deneyin!

Perl 6 , 12 bayt

*~|('@'x 11)

Çevrimiçi deneyin!

Anonim Bir numara alan ve 11 @s ile YEDEKLENEN lambda . Bu, rakamları pqrstuvwxyve göstergeyi eşleştirir m, ardından dizgiyi @s ile 11 karaktere çıkarır

Perl 5 (-p), 9 bayt

$_^=A x$=

Çevrimiçi deneyin!

Dize ile girişin Bitwxise-xor AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.

Wolfram Dili (Mathematica) , 44 33 bayt

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

Daha küçük bir etki alanıyla deneyin

-2 Greg Martin'e teşekkürler

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

Çıktının boyutu göz önüne alındığında, daha küçük etki alanı olan bir test durumu dahil ettim.$[-2^4,2^4)$

Stax , 6 bayt

11){Hm

Koş ve hata ayıkla

Prosedür:

1. Sol tuş girişi 11 karakterdir.
2. Boşluk olmayan ascii karakterlerinin her ikisini de ikiye katlayın.

PHP , 64 54 bayt

strtrManuel karakter değiştirme yerine fonksiyonu kullanarak -10 bayt .

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

Çevrimiçi deneyin!

Bugün itibarıyla PHP olası büyük tam sayı değeri olan 9223372036854775807negatif sayılar eksi işareti dikkate alındığında, 19 basamak uzunluğunda olan bu yerine geçer, eksi işareti (yukarıdaki kod 20. olacak -olan) Agelen karakter ve her rakam 0için 9bir karakter ile Dhiç Mve sonra her zaman 20 karakter uzunluğunda yapmak için dizgiyi sağdaki boşluk karakteriyle doldurun. Örneğin, giriş çıkışı -9876543210olan "AMLKJIHGFED " .

Çıktı, her tamsayı girişi için benzersizdir ve sen, tüm boşlukları kaldırarak değiştirerek girişine geri alabilirsiniz Aile -ve değiştirilmesi Diçin Mbirlikte 0için 9.

PHP , 44 bayt

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

Çevrimiçi deneyin!

Bu, Arnauld'un cevabıyla aynı fikir . Girişi ikiliye dönüştürür ve ardından base-64'e dönüştürür. Ayrıca -9223372036854775807çıktıda her zaman aynı uzunluğu elde etmek için sağdaki boşluk karakteriyle 88 karaktere (en büyük uzunluk 88 karakter).

Retina 0.8.2 , 21 bayt

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

Çevrimiçi deneyin! Her zaman aralığından 11 karakterleri çıktılar n.. z. Açıklama:

T`p`l

Yazdırılabilir ASCII karakterlerini küçük harflere çevirin. Bu -,… nve 0.. 9ile qeşleşir z. (Rakamların, yazdırılabilir ASCII karakterlerinin 16 ila 25'inci olması gerçekten şanslı!)

$
10$*o

10 osn ekleyin . Giriş 1 ile 11 karakter arasında olacağından, şimdi 11 ile 21 karakter arasında var.

!`.{11}

İlk 11 karakteri çıkarın. 22'den az karakter olduğundan, bu yalnızca bir kez eşleşir.

Mangal kömürü , 9 bayt

◧⍘﹪ＮＸχχαχ

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Her zaman 10 boşluk ve büyük harf çıkarır. Açıklama:

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

R , 37 bayt

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

Çevrimiçi deneyin!

$26!=4\cdot 10^{26}$ alfabenin permütasyonu. Çıktı daima 51 uzunluktadır (26 harf + 25 boşluk).

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

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

Bu benim için 1'e yeterince yakın.

brainfuck , 20 19 bayt

Krzysztof Szewczyk sayesinde -1 bayt

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

Çevrimiçi deneyin!

Her basamaklı sayı ve çıktının 255 eksi sıralı değerine eşlenmiş, tire, NUL bayt ile 255 karaktere kadar çıkar.

R , 40 37 bayt

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

Çevrimiçi deneyin!

Robin Ryder'ın cevabına bir alternatif ; bu kesinlikle deterministik.

Bu, girişi rawher biri onaltılık bir sayı olan 00ya 01da tamsayının bitlerini temsil eden 32 baytlık bir vektöre dönüştürür . Sonra bir etmek zorlamak logicaliçin karşılaştırarak 0böylece, 00eşleştirilmiş FALSEve 01için TRUE. Daha sonra FALSEkeyfi olarak seçilen eşit uzunlukta çıktıyı garanti altına almak için her birinden tek bir harf çıkarmamız gerekir S. Sonuç 169 uzunluğunda (boşlukla) yazdırılır.

Zsh , 43 bayt

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)

Çevrimiçi deneyin!

Bu çözüm long long, sadece karakterlerle çalışarak Zsh'nin tamsayılarının sınırlarını aşar. Okunabilmesi için yalnızca 30 karaktere kadar doldurdum, ancak bununla değiştirmek 30, 99bu yöntemin ila arasındaki tüm sayılar üzerinde çalışmasını -1E99+1sağlayacaktır 1E100-1.

Ondalık kodları onaltılık olarak yorumlamanın etkisi aşağıdaki gibidir:

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 bayt

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

Çevrimiçi deneyin!

66. Daha sonra haritalar bir ikili sayı x kabuledilebilir bir genişliğe sıfır dolgulu 0→ ave 1→ b. Ayrıca harita 2ve -bu karakterler basılmış olduğundan, bir karşı [[-]][base]#[num]gösterimde. $xDeğiştirme işleminden önce nasıl göründüğünü ve Zsh'nin tamsayı türlerini ayrıştırmadaki sınırlarını görmek için TIO bağlantısındaki Hata Ayıklama çıktısını kontrol edin.

Java (JDK) , 42 bayt

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

Çevrimiçi deneyin!

İlk olarak, girişin onaltılık gösterimini yaratır, aynı uzunluk sınırlamasını (8 karakter uzunluğunda) sağlayan boşluklarla sol dolgulu, eksi işaretini kaldırır ve her ara çıkışı benzersiz tutar.

Bu, 17 farklı karakterden oluşan bir karakter dizisi verir: 0123456789abcdef ve boşluk.

Daha sonra her karakter, basamak veya boşluksa kod noktasına 64 ekleyerek çizilir ve eşlenir. Etkili olarak, bu şu haritalama 0123456789abcdef<space>ile pqrstuvwxyabcdef`sonuçlanır : 17 karaktere sahip olan, böylece iki sayı aynı çıktıyla sonuçlanmaz.

Bash , 30 bayt

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

Çevrimiçi deneyin!

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