Her kaynak kod karakteri için bir rastgele karakter (aşağıda gösterildiği gibi) çıktı. Her karakterin olasılığı, orijinal kaynak kodundaki frekansıdır. Böylece çıktı, bir sıfıra benzeyen sahte kaynak kodu olacaktır.

Şartname

• Kısıtlamalar
  • Standart quine kısıtlamaları geçerlidir. Boş program veya işlev yok. Ayrıca kendi kaynağınızı okumak da yok.
• Çıktı
  • Çıktıdaki karakter sayısı, kaynak koddaki karakter sayısı ile aynı olmalıdır.
  • Her çıkış karakteri rastgele seçilmelidir
  • Herhangi bir karakter seçme olasılığı eşittir (occurrences in source) / (length of source)
  • Bu, tek bir çözümün bile “rastgele” 1olasılıkla seçmesi gerektiği anlamına gelir 1. Bu, çıktının zor kodlanamayacağı anlamına gelir.
• Kazanan
  • Bu kod golf, yani en az bayt kazanıyor

Örnek

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 bayt

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

Çevrimiçi deneyin!

açıklama

Her karakter tam olarak iki kez görünür, bu yüzden karakterlerin olasılıkları aynı olmalıdır.

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

Jöle , 13 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Mevcut bir quine'i temel olarak kullandım ve kaynak içerikten rastgele karakterler yazdırmak için değiştirdim.

kullanım

Farklı kaydet faux-source-code.plve kullanarak çalıştır:

perl faux-source-code.pl

Aşağıdaki gibi bir şey üretir:

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

Kısa bir testte, program sonuçlarının ~% 3'ü evalbaşarıyla gerçekleştirildi. Perl hakkında ne yazdığından emin değilim.

Japt , 22 bayt

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

Çevrimiçi test edin!

Nasıl çalışır

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

smO+N"m1NOs+6"16

çevrimiçi deneyin!

Her kömürü iki kez içerir, bu nedenle olasılık, her birinin yalnızca bir keresinde olduğu gibi olur.

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 bayt

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

koşmak php -d

1. tırnak işaretleri olmadan kodu içeren bir dize oluşturur
2. ve bir kez kullanarak tırnak işareti birleştirirord
   (dize ikiye katlar ve iki tırnak eklerdim gibi aynı olasılık);
3. daha sonra ondan rasgele karakterler elde etmek için dizenin iki katı uzunluğunda döngü oluşturur.

Muhtemelen daha fazla golf oynayabilir, fakat şimdiye kadar boşuna olan değerlendirmelerdeki denemelerim.
Muhtemelen burada daha derine gitmeyeceğim.

Python 2,8 bayt

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

Bütün gerçek bu almakla hak uzakta mbomb007 gider - sayesinde Yardımlarınız (ve ters eğik çizgiler hakkında pointer) için

Ruby, 47 bayt

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

Bu standart evalquine dayanmaktadır :

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

En kısa quine'den daha uzun bir bayt, ancak genellikle genelleştirilmiş quines için daha iyi bir seçimdir, çünkü kaynak kod dizgisinde yapılan herhangi bir hesaplamanın kopyalanması gerekmez. Her zamanki quine'de, her ek hesaplamanın ana dizginin içine ve dışına gitmesi gerektiğine rağmen, bu tür bir kesik için yalnızca ana dizginin içinde ihtiyaç duyulur.

Kodun gerçekte yaptığı gibi: kaynak kodun tamamını temsil eden bir dize elde ettikten sonra, sadece rastgele bir karakter seçeriz (rastgele bir dizin seçerek) 47 kez ve her karakteri ayrı ayrı yazdırırız.

Wolfram Dili / Mathematica, 109 Bayt

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

örnek çıktı:

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

Ah bu köşeli ayraçlar.

Jöle, 44 bayt

(Ben değilim eğer doğru tüm kuralları yorumlanır umut oldukça emin "taşıma yükü" şey meta içinde ne ya bu meydan okumaya bile alakalı ise).

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

TryItOnline'da test edin

Bu, karakterlerin seçileceği bir dize oluşturur. İlk dize, açık ve kapalı tırnak işaretleri dışında kullanılan tüm karaktere sahiptir . Daha sonra bu dizgiyi iki katına çıkarır ve sıralardan gelen açık ve kapalı tırnakların her birini birleştirir (bu nedenle diğer karakterleri ikiye katlama ihtiyacı). Son olarak, art arda oluşan dizgeden rasgele karakterleri programın uzunluğuna alır.

Pyke, 35 bayt

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

Burada dene!

Kontrol etmek için: sonuncuyu kaldırın Hve sonuçta elde edilen karakter dizisi her karakterin doğru sayısını içerir (ekstra H)

Bu genelleştirilmiş bir kınayı veya aslında bir kınayı KULLANMAYIN. Kaynaktaki tüm karakterleri içeren bir dize oluşturabilmeye dayanır. Olmalıdır herhangi bir kod için bunu yapmak mümkün ama her karakter logaritmik kod boyutunu artırır. Kaynakta bir karaktere izin verilen tek sayı 2 veya 7'dir.

Ruby, 81 67 bayt

Martin'in çözümünden bazı püf noktaları çalarak bir demet bayt kurtardı

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

Her seferinde rastgele seçim yapmak zorunda olduğunuzu bilmiyordum; Bir karıştırmanın hile yapacağını düşünmüştüm. Bu muhtemelen golf olabilir, ama bulabildiğim en kısa şey.

Birkaç değişiklikle Standard Ruby quine , böylece karıştırılan dizeyi yazdırır. Üzgünüm çünkü bilinçaltı olarak yine de çaldığımı fark etmeden önce biçimlendirme tuhaflıklarını anlamak on beş dakika sürdü.

Kordon karıştırmanın kısaltılabileceğini düşünüyorum ama nasıl yapacağımı bilmiyorum; Ayrıca, üzerine biraz düşündüğümde biçimlendirmeyi daha kısa hale getirebilirim. Yardım takdir edilecektir.

Çevrimiçi deneyin!

C, 125 bayt

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, golf için 60 bayt ama herhangi bir dize alarak quine kodu değil

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

Karakterleri saymak için benim çözümüm 86ya ihtiyaç duyuyordu:

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

JavaScript, 128 bayt

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

Not: kullanımı nedeniyle yalnızca Firefox'ta çalışır uneval.

Örnek çalışır:

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

Kaynak kodumdaki her karakteri dizgi içinde doğru sayıda kullanıyorum, sonra dizgiyi iki ile çarpıyorum. Program koddaki her karakter için bu dizgeden rastgele bir karakter yazdırır (uzunluk sabit kodlanmıştır).

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

Çevrimiçi deneyin

Veba gibi ters eğik çizgilerden uzak durdum. Kod içerdiği andan itibaren \nveya \"bir sorunla karşılaşırsınız, çünkü dize henüz ters eğik çizgi içermediğinden, bunları da eklemeniz gerekir; ( \\).

Örnek çıktı:

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'

Söylemeliyim ki, bana FlogScript'i hatırlatıyor.

PowerShell v2 +, 175 bayt

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

String değiştirme sınırlayıcı çünkü PowerShell Quines, emmek {}bir kullanmaya gerek de göstermektedirler döngüler ve etajer, böylece demet içinde charyer s -fkodunu bloats operatörü.

Her Çizgideki Quine cevabımla benzer . Temel 0olarak 174, her bir yinelemeden döngüye dönersek, kesirini yeniden hesaplar, $donu bir chardizi olarak atarız ve Randomgirişten eşit şekilde seçilen bir eleman çıkarırız . Tanım olarak, bu (occurrences in source) / (length of source)gerektiği gibi olasılık verir . Bu karakterler parens içinde kapsüllenir ve -jointekrar bir dizge haline getirilir.

Örnek

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

(Evet, bu çıktıda yeni bir charsatırdır - yeni bir satır içeren bir dize -array'd olduğunda, `nbir karakter olarak kabul edilir, çünkü char-array sadece bir bayt kodları dizisidir, bu yüzden 1/175 Seçme şansı.)

Dyalog APL , 20 bayt

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

f←{... }tanımla f olarak

(,⎕CR'f')listified ( ,) ° C haracter (tablo) R ePresentation ( ⎕CR) arasında f ( 'f')

[?⍴⍨20]( [... ]) ile rasgele-yukarı (? ) ile tekrarlanır⍴⍨ ) ile yirmi yedinci )

Birkaç kez (kukla bir argümanla) çalıştıralım:

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

Tamam, dağıtım doğru mu? 10.000 yapay argüman üzerinde çalışalım ve her karakterin kaç kez gerçekleştiğini görelim:

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

Açıkça fve' sadece orijinal kaynak kodunda gibi diğer karakterler olarak iki kat daha sık görülür.

Bunu nasıl yaptık?

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

⍳1E4 ilk 10.000 tam sayıyı üretir

f¨bu sayıların her biri üzerinde f çalışır

∊ tüm sözde sorguları tek bir 200.000 karakterlik dizgede düzleştirir

⌸sağdaki verilerdeki her benzersiz karakter için, soldaki işlevi benzersiz öğeyi sol argüman olarak besleyen ve o karakterin sağ argüman olarak gerçekleştiği dizinleri besleyen bir üst düzey işlevdir. Sol taraf işlevi

{⍺ , 1E¯4× ⍴⍵}

⍺ sol argüman, yani benzersiz karakter

, bunu takiben

1E¯4× 1 × 10⁻⁴ kez

⍴⍵ sağ argümanın şekli (oluşum indeksleri), yani birçok kez gerçekleştiği

Sonunda, ⌸hepsini bir masaya koyar.

C #, 277 280 268 bayt.

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

Ungolfed:

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

Bunun doğru şekilde çalıştığına eminim.

Örnek çıktı:

    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 bayt

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

Örnek çıktı:

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

Bu program rastgele 136 karakter çıkarır.

Kaynak kodun tamamı (daha az "tırnak işaretleri" bir dizgede bulunur. Program, bir tırnak işaretini 2/136 olarak belirleme olasılığını belirler, aksi takdirde diğer 67 karakterden birini rastgele çıkarır.

Programdaki dizgede her karakterin iki örneği vardır. Dizeden bir karakter çıktısı olasılığı 134/136'dır. Dize belirli bir karakter seçme olasılığı 1/67'dir. Böylece dizgede bir karakter çıkma şansı 134/136 * 1/67 = 2/136'dır. Programdaki her bir karakter karakterinin iki örneği vardır, bu nedenle programdaki her örnek için bir karakter çıktısı olasılığı 1/136 vardır.

Dizenin içindeki sembollerin sırası önemli değildir.