Keluarkan satu karakter acak untuk setiap karakter kode sumber (seperti yang diilustrasikan di bawah). Probabilitas setiap karakter adalah frekuensi dalam kode sumber asli. Dengan demikian output akan menjadi kode sumber palsu yang menyerupai quine.

Spesifikasi

• Batasan
  • Batasan quine standar berlaku. Tidak ada program atau fungsi kosong. Juga tidak membaca sumber Anda sendiri.
• Keluaran
  • Jumlah karakter yang dihasilkan harus persis jumlah karakter dalam kode sumber
  • Setiap karakter keluaran harus dipilih secara acak
  • Probabilitas memilih karakter apa pun sama dengan (occurrences in source) / (length of source)
  • Ini berarti bahwa bahkan solusi unary perlu 'secara acak' memilih 1dengan probabilitas 1. Yang mengatakan bahwa output tidak dapat dikodekan dengan keras.
• Kemenangan
  • Ini adalah kode golf, byte paling sedikit menang

Contoh

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*

Cobalah online!

Penjelasan

Setiap karakter muncul tepat dua kali, sehingga probabilitas karakter harus sama.

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

Jelly , 13 byte

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

Cobalah online!

Bagaimana itu bekerja

“;⁾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

Saya menggunakan quine yang ada sebagai dasar dan memodifikasinya untuk mencetak karakter acak dari konten sumber.

Pemakaian

Simpan sebagai faux-source-code.pldan jalankan menggunakan:

perl faux-source-code.pl

Menghasilkan sesuatu seperti berikut:

$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==/[email protected]'}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}

Dalam tes singkat, ~ 3% dari hasil program evalberhasil. Saya tidak yakin apa yang dikatakan tentang Perl ...

Japt , 22 byte

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

Uji secara online!

Bagaimana itu bekerja

"+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

Pyth, 16 Bytes

smO+N"m1NOs+6"16

coba online!

Berisi masing-masing char dua kali karena itu probabilitasnya sama seperti jika masing-masing hanya ada di sana sekali.

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)];

jalankan bersama php -d

1. membuat string yang berisi kode tanpa tanda kutip
2. dan menyatukan tanda kutip sekali menggunakan ord
   (probabilitas yang sama seolah-olah saya akan menggandakan string dan menambahkan dua tanda kutip);
3. kemudian lilitkan dua kali panjang string untuk mendapatkan karakter acak darinya.

Mungkin bisa bermain golf lebih jauh, tetapi upaya saya di eval mana sia-sia sejauh ini.
Saya mungkin tidak akan masuk lebih dalam di sini.

Python 2, 88 byte

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

Semua manfaat aktual dalam mencapai sejauh ini adalah mbomb007 - terima kasih atas bantuan Anda (dan petunjuk tentang backslash)

Ruby, 47 byte

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

Ini didasarkan pada standar evalquine:

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

Ini byte lebih panjang dari quine terpendek, tetapi biasanya pilihan yang lebih baik untuk quine umum, karena setiap perhitungan yang dilakukan pada string kode sumber tidak perlu diduplikasi. Sedangkan di quine biasa, setiap perhitungan tambahan harus masuk ke dalam dan di luar string utama, itu hanya diperlukan di dalam string utama untuk jenis quine ini.

Adapun apa kode sebenarnya: setelah mendapatkan string yang mewakili seluruh kode sumber, kami cukup memilih karakter acak (dengan memilih indeks acak) 47 kali dan mencetak setiap karakter secara terpisah.

Bahasa Wolfram / Mathematica, 109 Bytes

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

keluaran sampel:

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

Oh tanda kurung itu.

Jelly, 44 byte

Saya harap saya telah menafsirkan semua aturan dengan benar (saya tidak cukup yakin apa yang "membawa payload" hal yang di meta atau jika itu bahkan relevan dengan tantangan ini).

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

Uji di TryItOnline

Ini membangun string untuk memilih karakter. String awal memiliki semua karakter yang digunakan kecuali tanda kutip buka dan tutup. Kemudian menggandakan string itu dan merangkai salah satu dari masing-masing kutipan buka dan tutup dari ordinals (maka kebutuhan untuk menggandakan karakter lain). Terakhir itu berulang kali memilih karakter acak dari string yang dikomposisikan ke panjang program.

Pyke, 35 byte

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

Coba di sini!

Untuk memeriksa: hapus final Hdan string yang dihasilkan berisi jumlah yang tepat dari setiap karakter (dengan tambahan H)

Ini TIDAK menggunakan quine umum atau bahkan quine sama sekali. Itu bergantung pada mampu membuat string yang berisi semua karakter di sumber. Ini harus dapat melakukannya untuk kode apapun tetapi masing-masing karakter logaritmik meningkatkan ukuran kode. Satu-satunya frekuensi karakter yang diizinkan dalam sumber adalah 2 atau 7

Ruby, 81 67 byte

Menyelamatkan banyak byte dengan mencuri beberapa trik dari solusi Martin

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

Saya tidak menyadari bahwa Anda harus memilih secara acak setiap waktu; Saya pikir shuffle akan melakukan trik. Ini mungkin bisa golf, tapi itu yang terpendek yang bisa saya dapatkan.

Quine Ruby standar dengan beberapa modifikasi sehingga mencetak string yang dikocok. Aku sedih karena butuh lima belas menit untuk mencari tahu format pemformatan sebelum aku sadar bahwa aku secara tidak sadar mencuri itu.

Saya pikir pengocokan tali dapat diperpendek tetapi saya tidak tahu caranya; Saya juga mungkin bisa mengubah format menjadi lebih pendek setelah saya memikirkannya. Bantuan akan dihargai.

Cobalah online!

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 untuk golf tetapi tidak mengambil kode quine string

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

Sedangkan untuk menghitung karakter, solusi saya membutuhkan 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]))

Catatan: hanya berfungsi di Firefox karena penggunaan uneval.

Sampel berjalan:

)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

Saya menggunakan setiap karakter dalam kode sumber saya dalam string beberapa kali dengan benar, kemudian mengalikan string dengan dua untuk memasukkan dirinya sendiri. Program ini mencetak karakter acak dari string itu untuk setiap karakter dalam kode (panjangnya adalah hard-coded.)

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

Cobalah online

Saya menghindari serangan balik seperti wabah. Segera setelah kode berisi \natau \", Anda memiliki masalah, karena string belum mengandung garis miring terbalik, jadi Anda harus menambahkannya juga, tetapi dalam string terpisah dikalikan dengan angka yang lebih tinggi, karena dibutuhkan dua garis miring terbalik untuk mewakili satu ( \\).

Contoh output:

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'

Harus saya katakan, ini mengingatkan saya pada 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 di PowerShell mengisap, karena pembatas string pengganti {}juga loop masing menunjukkan dan yang lainnya, sehingga Anda perlu menggunakan banyak dari chars di -foperator, yang bloats kode.

Mirip-ish dengan jawaban Quine on Every Line saya . Pada dasarnya kita loop dari 0ke 174dan setiap iterasi menghitung ulang quine $d, melemparkannya sebagai char-array, dan mengeluarkan Randomelemen yang dipilih secara seragam dari input. Menurut definisi, ini memberikan probabilitas (occurrences in source) / (length of source)sesuai kebutuhan. Karakter-karakter tersebut dienkapsulasi dalam parens dan -joindisatukan kembali menjadi string.

Contoh

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

(Ya, itu adalah baris baru dalam output - ketika string yang mengandung baris baru adalah char -array'd, `ndiperlakukan sebagai karakter, karena char-array hanya array kode byte, sehingga juga memiliki 1/175 kemungkinan terpilih.)

Dyalog APL , 20 byte

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

f←{... }tentukan f sebagai

(,⎕CR'f')listified ( ,) C haracter (table) R epresentation ( ⎕CR) of f ( 'f')

[?⍴⍨20]diindeks dengan ( [... ]) random-up-to ( ?) repeat-itself-times ( ⍴⍨) sebanyak dua puluh

Mari kita jalankan (dengan argumen dummy) beberapa kali:

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

Baik, tetapi apakah distribusinya benar? Mari kita jalankan di 10.000 argumen dummy dan lihat berapa kali setiap karakter muncul:

      {⍺ , 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

Jelas, fdan 'terjadi dua kali lebih sering dari karakter lain, sama seperti dalam kode sumber asli.

Bagaimana kami melakukannya?

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

⍳1E4 menghasilkan 10.000 bilangan bulat pertama

f¨berjalan f pada masing-masing angka-angka itu

∊ meratakan semua pseudo-quines menjadi string 200.000 karakter tunggal

⌸adalah fungsi tingkat tinggi yang untuk setiap karakter unik di data sisi kanan, mengumpankan fungsi sisi kiri elemen unik sebagai argumen kiri dan indeks di mana karakter tersebut muncul sebagai argumen kanan. Fungsi sisi kiri adalah

{⍺ , 1E¯4× ⍴⍵}

⍺ argumen-kiri, yaitu karakter unik

, diikuti oleh

1E¯4× 1 × 10⁻⁴ kali

⍴⍵ bentuk argumen-kanan (indeks kemunculan), yaitu berapa kali itu terjadi

Akhirnya, ⌸letakkan semuanya dalam sebuah tabel.

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)]);}}

Tidak Disatukan:

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)]);
    }
}

Cukup yakin ini berfungsi dengan benar.

Output sampel:

    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);}

Contoh output:

;%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"]

Program ini menghasilkan 136 karakter secara acak.

Seluruh kode sumber (kurang "tanda kutip) terkandung dalam sebuah string. Program ini menentukan probabilitas mengeluarkan tanda kutip sebagai 2/136, jika tidak, mengeluarkan salah satu dari 67 karakter lainnya secara acak.

Ada dua kemunculan setiap karakter dalam string dalam program. Probabilitas mengeluarkan karakter dari string adalah 134/136. Probabilitas memilih karakter tertentu dalam string adalah 1/67. Jadi peluang menghasilkan karakter dalam string adalah 134/136 * 1/67 = 2/136. Ada dua kemunculan setiap karakter string dalam program, sehingga ada 1/136 probabilitas menghasilkan karakter untuk setiap kemunculan dalam program.

Urutan simbol di dalam string tidak masalah.