Xuất một ký tự ngẫu nhiên cho mỗi ký tự của mã nguồn (như minh họa bên dưới). Xác suất của mỗi ký tự là tần số của nó trong mã nguồn gốc. Do đó, đầu ra sẽ là mã nguồn giả giống như một quine.

Đặc điểm kỹ thuật

• Hạn chế
  • Hạn chế quine tiêu chuẩn áp dụng. Không có chương trình hoặc chức năng trống. Cũng không đọc nguồn của riêng bạn.
• Đầu ra
  • Số lượng ký tự đầu ra phải chính xác là số lượng ký tự trong mã nguồn
  • Mỗi ký tự đầu ra nên được chọn ngẫu nhiên
  • Xác suất chọn bất kỳ nhân vật nào bằng (occurrences in source) / (length of source)
  • Điều này có nghĩa là ngay cả một giải pháp đơn phương cũng cần phải 'chọn ngẫu nhiên' 1với xác suất 1. Điều đó có nghĩa là đầu ra không thể được mã hóa cứng.
• Chiến thắng
  • Đây là mã golf, vì vậy ít byte nhất sẽ thắng

Thí dụ

Program           Frequency           Probability           Possible Output
-------           ---------           -----------           ---------------           
 a@!@              a - 1               a - 25%               @@a@
                   ! - 1               ! - 25%
                   @ - 2               @ - 50%

Program           Frequency           Probability           Possible Output
-------           ---------           -----------           ---------------
caBaDBcDaBDB       a - 3               a - 25%               aaaBBBBccDDD
                   B - 4               B - 33%
                   c - 2               c - 17%
                   D - 3               D - 25%

CJam , 14 byte

{{E*`mR}`mR}E*

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

Giải trình

Mỗi nhân vật xuất hiện chính xác hai lần, vì vậy xác suất của các nhân vật nên giống nhau.

{           e# Repeat this block 14 times.
  {E*`mR}   e# Push this (nonsensical) block.
  `         e# Stringify it, giving the string "{E*`mR}", which contains each of the
            e# seven characters once.
  mR        e# Select one of the characters at random.
}E*

Thạch , 13 byte

“;⁾vṾWṁ$X€”vṾ

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

Làm thế nào nó hoạt động

“;⁾vṾWṁ$X€”vṾ  Main link. No arguments.

“;⁾vṾWṁ$X€”    Set the argument and return value to the string s := ';⁾vṾWṁ$X€'.
            Ṿ  Uneval; construct a string representation of s.
               This yields r := '“;⁾vṾWṁ$X€”'.
           v   Dyadic eval; evaluate s with argument r.


 ;⁾vṾWṁ$X€     Evaluated link (s). Argument: r

  ⁾vṾ          Yield 'vṾ'.
 ;             Concatenate r with 'vṾ'.
               This yields t := '“;⁾vṾWṁ$X€”vṾ', i.e., the original source code.
       $       Combine the previous two links into a monadic chain.
     W           Wrap; yield ['“;⁾vṾWṁ$X€”vṾ'].
      ṁ          Mold; repeat ['“;⁾vṾWṁ$X€”vṾ'] once for each charcter in t.
        X€     Random each; select a character, uniformly at random, of each
               of the 13 repetitions of t.

Perl, 59 byte

$_=q{$_.='$_=q{};eval';@a=/./g;s/./$a[rand@a]/g;print};eval

Tôi đã sử dụng một quine hiện có làm cơ sở và sửa đổi nó để in các ký tự ngẫu nhiên từ nội dung nguồn.

Sử dụng

Lưu dưới dạng faux-source-code.plvà chạy bằng cách sử dụng:

perl faux-source-code.pl

Sản xuất một cái gì đó như sau:

$d='=a{f.gng$d._{{{ag{ed{aa;ae/r$no{a]_q}/$;_}lrq=r_=;_;=$'
vptr.q'ap.vaa@}@{iel];na;f.o/qon/fa}ie;=e{/a}/ag.$vaiqa_gv'
$_..'daq;.;/./.@._ogd;@aapqirv/;nrp=}@$}a/i;vq;.l.l@i}g]qq'
va==/t@dl.fe'}ar.l@n;_tve@=n$;$}$.l'p{a@qv._qag@dgr_$/.$/;v
q{/@d;@a;a_=g_r$r/.qar{=[gnr';@;$qgvad;$===/$//i]}g[tr@@.q}

Trong một thử nghiệm ngắn, ~ 3% kết quả của chương trình evalthành công. Tôi không chắc những gì nói về Perl ...

Japt , 22 byte

"+Q ²£ZgMqB"+Q ²£ZgMqB

Kiểm tra nó trực tuyến!

Làm thế nào nó hoạt động

"+Q ²£ZgMqB"+Q ²£ZgMqB  // Implicit: B = 11
"+Q ²£ZgMqB"            // Take this string.
            +Q          // Append a quotation mark.
               ²        // Double the result.
                £       // Replace each char in the result Z with
                 Zg     //  the char in Z at index
                   MqB  //   random integer in the range [0, 11).
                        // Implicit: output last expression

Bình, 16 byte

smO+N"m1NOs+6"16

thử trực tuyến!

Chứa mỗi char hai lần do đó xác suất giống như thể mỗi lần chỉ ở đó một lần.

smO+N"m1NOs+6"16     #
   +N"m1NOs+6"       # Add a quotation mark to the string: "m1NOs+6
  O                  # random choice from the string
 m            16     # do this 16 times.
s                    # join the list into a string

PHP, 71 140 110 124 140 120 byte

for($i=2*$n=strlen($s='for($i=2*$n=strlen($s=.chr(39));$i--;)echo$s[rand(0,$n-1)];'.chr(39));$i--;)echo$s[rand(0,$n-1)];

chạy với php -d

1. tạo một chuỗi chứa mã mà không có dấu ngoặc kép
2. và nối dấu ngoặc kép một lần bằng cách sử dụng ord
   (cùng xác suất như thể tôi sẽ nhân đôi chuỗi và thêm hai dấu ngoặc kép);
3. sau đó lặp qua hai lần chiều dài của chuỗi để lấy các ký tự ngẫu nhiên từ nó.

Có thể có thể chơi gôn xa hơn, nhưng những nỗ lực của tôi về eval nơi vô ích cho đến nay.
Tôi có lẽ sẽ không đi sâu hơn ở đây.

Python 2, 88 byte

s='''from random import*; print "".join(choice(s) for c in "s='"+s+"';exec s")''';exec s

Tất cả công đức thực sự trong việc đạt được điều này đến với mbomb007 - cảm ơn sự giúp đỡ của bạn (và con trỏ về dấu gạch chéo ngược)

Ruby, 47 byte

eval r="47.times{$><<('eval r=%p'%r)[rand 47]}"

Điều này dựa trên tiêu chuẩn eval:

eval r="$><<'eval r=%p'%r"

Đó là một byte dài hơn so với quine ngắn nhất, nhưng nó thường là lựa chọn tốt hơn cho các quine tổng quát, bởi vì bất kỳ tính toán nào được thực hiện trên chuỗi mã nguồn không cần phải sao chép. Trong khi trong quine thông thường, mọi tính toán bổ sung cần phải đi cả bên trong và bên ngoài chuỗi chính, chỉ cần bên trong chuỗi chính cho loại quine này.

Đối với những gì mã thực sự làm: sau khi có được một chuỗi đại diện cho toàn bộ mã nguồn, chúng ta chỉ cần chọn một ký tự ngẫu nhiên (bằng cách chọn một chỉ mục ngẫu nhiên) 47 lần và in riêng từng ký tự.

Ngôn ngữ Wolfram / Mathicala, 109 Byte

Function[Print[StringJoin[RandomChoice[StringSplit[StringJoin[ToString[FullForm[Slot[0]]],"[]"],""],109]]]][]

đầu ra mẫu:

niPi[no,ili[Siu[,Sdoio9nthg"t ginuu[1[o]"i,icgi[0TncrS"[ln"o0]r,i][Jon[[et]0"]m [ri"a[]motrin,iFoFnultnnno,Jl

Ôi những dấu ngoặc vuông.

Thạch, 44 byte

Tôi hy vọng tôi đã giải thích tất cả các quy tắc một cách chính xác (tôi không khá chắc chắn về "carry tải trọng" Vấn đề là ở meta hoặc nếu nó thậm chí còn liên quan đến thách thức này).

“ẋ2;8220Ọ;8221ỌXµ44СḊ”ẋ2;8220Ọ;8221ỌXµ44СḊ

Kiểm tra nó tại TryItOnline

Điều này xây dựng một chuỗi để chọn các ký tự. Chuỗi ban đầu có tất cả các ký tự được sử dụng ngoại trừ dấu ngoặc kép mở và đóng. Sau đó, nó nhân đôi chuỗi đó và nối một trong các dấu ngoặc kép mở và đóng từ các lệnh (do đó cần phải tăng gấp đôi các ký tự khác). Cuối cùng, nó liên tục chọn các ký tự ngẫu nhiên từ chuỗi tổng hợp đến độ dài của chương trình.

Pyke, 35 byte

35F\";"\\+3322 5**F;H)s"\"2*+2* H)s

Hãy thử nó ở đây!

Để kiểm tra: xóa chuỗi cuối cùng Hvà chuỗi kết quả chứa đúng số của mỗi ký tự (có thêm H)

Điều này KHÔNG sử dụng một quine tổng quát hoặc trong thực tế một quine cả. Nó phụ thuộc vào việc có thể tạo một chuỗi chứa tất cả các ký tự trong nguồn. Nó sẽ có thể làm điều đó cho bất kỳ mã nào, nhưng mỗi ký tự logarit tăng kích thước mã. Số lần duy nhất một ký tự được phép trong nguồn là 2 hoặc 7

Ruby, 81 67 byte

Đã lưu một loạt byte bằng cách ăn cắp một số thủ thuật từ giải pháp của Martin

s="s=%p;67.times{$><<(s%%s)[rand 67]}";67.times{$><<(s%s)[rand 67]}

Tôi đã không nhận ra rằng bạn phải chọn ngẫu nhiên mỗi lần; Tôi nghĩ rằng một shuffle sẽ làm điều đó. Điều này có thể có thể được chơi golf, nhưng nó là ngắn nhất tôi có thể nhận được nó.

Tiêu chuẩn Ruby quine với một vài sửa đổi để nó in ra chuỗi xáo trộn. Tôi buồn vì phải mất mười lăm phút để tìm ra các quirks định dạng trước khi tôi nhận ra rằng dù sao tôi cũng đã đánh cắp nó trong tiềm thức.

Tôi nghĩ việc xáo trộn chuỗi có thể được rút ngắn nhưng tôi không biết làm thế nào; Tôi cũng có thể chỉnh sửa định dạng thành ngắn hơn một khi tôi suy nghĩ về nó. Trợ giúp sẽ được đánh giá cao.

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

C, 125 byte

char*s="char*s;l,i;f(){l=i=strlen(s);while(i--)putchar(s[rand()%l]);}";l,i;f(){l=i=strlen(s);while(i--)putchar(s[rand()%l]);}

C, 60 byte cho golf nhưng không mã quine lấy bất kỳ chuỗi nào

l,i;f(char*s){l=i=strlen(s);while(i--)putchar(s[rand()%l]);}

Trong khi đếm các ký tự, giải pháp của tôi cần 86:

c[256];i;f(char*s){i=256;while(*s)c[*s++]++;while(--i)while(c[i]?c[i]--:0)putchar(i);}

JavaScript, 128 byte

a=";a+=uneval(a);alert(a.replace(/./g,_=>a[Math.random()*64|0]))a=";a+=uneval(a);alert(a.replace(/./g,_=>a[Math.random()*64|0]))

Lưu ý: chỉ hoạt động trong Firefox do sử dụng uneval.

Chạy mẫu:

)a(rgc=d6m_a4uar=hp(lll(,d=m=dee(M(gtraoan0)(M(aaaa(M]c)e)/M()/u//M6_n/a"*unea(/>atugrn(a=nav"|;)|=)/,ataa,aaangtue;am)t0;|ctoa/
=lvct;eee,,a.e=6r0;);Mtaaoa.aeea4)a[r.6]e/ll+l.)=)|a[(c"rao4ea/=_acaMh=veerva"a(_(d(l)lgn.;rM">=ea40a*).e(h(laa6r)4a)rhlar=t(ta[
[rt]ll]n))aota.e)g;>ae*;..4tt];l[;].*lnr4(mnM|alg(a.ag(.=e(a>>aa>.hga;a/pat+elc];apc=(ag)tao.).ll4u)dah]r(ul)>lr;,)ret(e/g(=_c*r
M.r)_;.a(lraalg("mac>dmrlr"0/ah(a()ead|/0a(m.|u0)(a(0_[dn)a]/raal;eata)a.ataeaa*l)=ra()la=(a)*aaea>n;.a.)ca)orM(tm*a,a=)p;(>r)aa

Python 3, 134 132 byte

Tôi sử dụng mỗi ký tự trong mã nguồn của mình trong chuỗi số lần chính xác, sau đó nhân chuỗi đó với hai lần để bao gồm chính nó. Chương trình in một ký tự ngẫu nhiên từ chuỗi đó cho mỗi ký tự trong mã (độ dài được mã hóa cứng.)

from random import*
for i in[0]*134:print(choice("""from random import*
for i in[0]*134:print(choice(""*""2""),end='')"""*2),end='')

Dùng thử trực tuyến

Tôi tránh được dấu gạch chéo ngược như bệnh dịch hạch. Ngay khi mã chứa \nhoặc \", bạn gặp sự cố, vì chuỗi chưa chứa dấu gạch chéo ngược, do đó bạn phải thêm các mã đó, nhưng trong một chuỗi riêng được nhân với số cao hơn, vì phải có hai dấu gạch chéo ngược để biểu thị một ( \\).

Ví dụ đầu ra:

i(tc*"3]i o''r=,,,h34t"r
ri"](fco t)niap)t "it2nc0o  npoi3'"nto(*4 i(ido' r*4f"oi]d rm ,i"eif)m"d
m emi
dfr n*p 3*(i""r1d"dr menc hio'

Tôi phải nói rằng, nó làm tôi nhớ đến FlogScript.

PowerShell v2 +, 175 byte

$d='$d={0}{1}{0}{2}-join(0..174|%{3}[char[]]($d-f [char]39,$d,"`n",[char]123,[char]125)|Random{4})'
-join(0..174|%{[char[]]($d-f [char]39,$d,"`n",[char]123,[char]125)|Random})

Quines trong PowerShell hút, bởi vì delimiters chuỗi thay thế {}cũng vòng biểu thị và không có điều gì, vì vậy bạn cần phải sử dụng một loạt các chars trong -fđiều hành, mà bloats mã.

Tương tự như câu trả lời Quine của tôi trên mỗi dòng . Về cơ bản, chúng ta lặp từ 0đến 174và mỗi lần lặp lại tính toán lại quine $d, đặt nó dưới dạng char-array và rút ra một Randomphần tử được chọn thống nhất từ ​​đầu vào. Theo định nghĩa, điều này đưa ra xác suất (occurrences in source) / (length of source)theo yêu cầu. Những ký tự đó được gói gọn trong các ô và chỉnh -joinlại thành một chuỗi.

Thí dụ

PS C:\Tools\Scripts\golfing> .\faux-souce-code.ps1
}}[${hr[`ini}}] [5i,=[]0,j2($=n4(dm]jh]jc]]7
}..j"rnj9|fn,4r]{9]('["jdh0}$rd,-f,a.c"}{h1 ]5d,),0n5|nh(]73a9da4aRi[5}a}430}}rd$,$r)-hhr%or79-R.R-`'r'aa|=1f0][|[{7}do1]$ja0 rd{h

(Vâng, đó là một dòng mới trong đầu ra - khi một chuỗi chứa một dòng mới được char-array'd thì `nđược coi là một nhân vật, vì một char-array chỉ là một mảng của các mã byte, vì vậy nó cũng có một 1/175 cơ hội được chọn.)

APL Dyalog , 20 byte

f←{(,⎕CR'f')[?⍴⍨20]}

f←{... }xác định f là

(,⎕CR'f')liệt kê ( ,) C haracter (bảng) R epresentation ( ⎕CR) của f ('f' )

[?⍴⍨20]được lập chỉ mục với ( [... ]) ngẫu nhiên lên (? ) lặp lại chính nó ( ⍴⍨) của hai mươi

Hãy để chúng tôi chạy nó (với một đối số giả) một vài lần:

      f⍬
)0'0](⍨(([],}⎕))⎕'f2
      f⍬
{'['}f[←R[)2←?}⍨]}C2
      f⍬
,,⍨←?2}⍴?'⍨}C,'{⎕(C0

Tốt, nhưng phân phối có đúng không? Chúng ta hãy chạy nó trên 10.000 đối số giả và xem mỗi nhân vật xảy ra bao nhiêu lần:

      {⍺ , 1E¯4× ⍴⍵}⌸ ∊ f¨ ⍳1E4
C 0.9952
⎕ 0.9996
' 1.9777
f 2.004 
← 1.0018
⍨ 1.0173
0 1.0213
] 1.0049
[ 0.9988
2 0.9943
{ 0.9895
) 1.0093
R 1.0054
, 1.0029
? 0.9943
} 0.9861
⍴ 1.0032
( 0.9944

Thông suốt, f và 'xảy ra thường xuyên gấp đôi so với các ký tự khác, giống như trong mã nguồn ban đầu.

chúng tôi đã làm nó như thế nào?

{⍺ , 1E¯4× ⍴⍵}⌸ ∊ f¨ ⍳1E4`

⍳1E4 tạo ra 10.000 số nguyên đầu tiên

f¨chạy f trên mỗi số đó

∊ làm phẳng tất cả các chuỗi giả thành một chuỗi 200.000 ký tự

⌸là một hàm bậc cao hơn, cho mỗi ký tự duy nhất trong dữ liệu bên phải, cung cấp cho hàm bên trái phần tử duy nhất là đối số bên trái và các chỉ số trong đó ký tự đó xuất hiện dưới dạng đối số phải. Hàm bên trái là

{⍺ , 1E¯4× ⍴⍵}

⍺ đối số trái, tức là ký tự duy nhất

, theo dõi bởi

1E¯4× 1 × 10⁻⁴ lần

⍴⍵ hình dạng của đối số đúng (các chỉ số xuất hiện), iehow nhiều lần nó xảy ra

Cuối cùng, ⌸đặt tất cả lại với nhau trong một bảng.

C #, 277 280 268 byte.

using System;class a{static void Main(){var s="using System;class a{static void Main(){var s=\"x5Cx5C\x5C\x5C\";Random d=new Random();for(int i=0;i++<268;)Console.Write(s[d.Next(0,134)]);}}";Random d=new Random();for(int i=0;i++<268;)Console.Write(s[d.Next(0,134)]);}}

Ung dung:

using System;
class a
{
    static void Main()
    {
        var s="using System;class a{static void Main(){var s=\"x5Cx5C\x5C\x5C\";Random d=new Random();for(int i=0;i++<268;)Console.Write(s[d.Next(0,134)]);}}";
        Random d=new Random();
        for(int i=0;i++<268;)
            Console.Write(s[d.Next(0,134)]);
    }
}

Khá chắc chắn rằng điều này hoạt động chính xác.

Đầu ra mẫu:

    fn;i)(]ns;<ftt08et]i+ii8]m[W}dr{rmte,)t edayid 2s cmsee\;ta["e n;o}]iolys;t sftoR{.=g vs8;(sd isWrecn++iia]iuf"avs\i<{ee vfs[ensin\s i]0a(We.0ns R(2roo=ldxil\{t(o"aistt.;.  r w"m1];idi}Ctitiindnn;M[,[+0(,o"]mca[rmnm)<;n"8ReaystinRsanr([(d,n\.ateiR sd.=[=;ttn.;wna)cCt[=+t{Wxs(\}rg

C, 136 byte

main(a){for(a=136;a--;)rand()%68?putchar("main(a){for(a=136;a--;)rand()%68?putchar([rand()%67]):putchar(34);}"[rand()%67]):putchar(34);}

Ví dụ đầu ra:

;%7c(u)"r4-hd)nnr-%n6;6(4or(n4(6(a:=a3r-:()hp(:aa%;4rru}h;(a()3mh3rdi7));a-u36:r3on[4?p((]6n6?()-6t736unhr%:[%[[d(p:[ru)-n(6r=:](p-})8"]

Chương trình này xuất ra 136 ký tự ngẫu nhiên.

Toàn bộ mã nguồn (ít "dấu ngoặc kép) được chứa trong một chuỗi. Chương trình xác định xác suất xuất ra dấu ngoặc kép là 2/136, nếu không thì xuất ngẫu nhiên một trong 67 ký tự khác.

Có hai lần xuất hiện của mỗi ký tự trong chuỗi trong chương trình. Xác suất xuất ra một ký tự từ chuỗi là 134/136. Xác suất chọn một ký tự cụ thể trong chuỗi là 1/67. Vì vậy, cơ hội xuất ra một ký tự trong chuỗi là 134/136 * 1/67 = 2/136. Có hai lần xuất hiện của mỗi ký tự chuỗi trong chương trình, do đó, có xác suất 1/136 xuất ra một ký tự cho mỗi lần xuất hiện trong chương trình.

Thứ tự của các ký hiệu bên trong chuỗi không quan trọng.