为源代码的每个字符输出一个随机字符（如下所示）。每个字符的概率就是其在原始源代码中的出现频率。因此，输出将是类似于quine的伪造源代码。

规格

• 限制条件
  • 适用标准藜麦约束。没有空的程序或函数。也没有阅读自己的资料。
• 输出量
  • 输出的字符数应与源代码中的字符数完全相同
  • 每个输出字符应随机选择
  • 选择任何字符的概率等于 (occurrences in source) / (length of source)
  • 这意味着即使是一元解决方案也需要“随机”选择1概率1。也就是说，输出不能被硬编码。
• 获奖
  • 这是代码高尔夫球，所以最少的字节获胜

例

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个字节

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

在线尝试！

说明

每个字符正好出现两次，因此字符的概率应全部相同。

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

果冻，13 个字节

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

在线尝试！

怎么运行的

“;⁾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个字节

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

我使用现有的奎因作为基础，并对其进行了修改以从源内容中打印随机字符。

用法

另存为faux-source-code.pl并使用以下命令运行：

perl faux-source-code.pl

产生如下内容：

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

在简短测试中，程序结果的〜3％eval成功。我不确定Perl怎么说？

Japt，22字节

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

在线测试！

怎么运行的

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

smO+N"m1NOs+6"16

在线尝试！

每个字符包含两次，因此概率与每个字符仅出现一次相同。

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字节

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

与 php -d

1. 创建一个包含不带引号的代码的字符串
2. 并使用一次连接引号ord
   （与我将字符串加倍并加上两个引号的可能性相同）；
3. 然后遍历字符串长度的两倍以从中获取随机字符。

可能可以打得更远，但是到目前为止，我的评估还没有成功。
我可能不会在这里更深入。

Python 2，88个字节

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

达到这一目标的所有实际优点都归于mbomb007-感谢您的帮助（以及有关反斜杠的指针）

Ruby，47个字节

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

这基于标准evalquine：

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

它比最短的Quines长一个字节，但通常是广义Quines的更好选择，因为对源代码字符串进行的任何计算都不需要重复。而在通常的奎因中，每一个额外的计算都需要在主字符串的内部和外部进行，而对于这种奎因，仅在主字符串内部需要进行。

至于代码的实际作用：在获得代表整个源代码的字符串后，我们只需选择一个随机字符（通过选择随机索引）47次，然后分别打印每个字符。

Wolfram语言/ Mathematica，109字节

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

样本输出：

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

哦那些方括号。

果冻，44个字节

我希望我正确地解释了所有规则（我不太确定元数据中的“携带有效载荷”是什么，或者它是否与此挑战相关）。

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

在TryItOnline上进行测试

这将构造一个字符串以从中选择字符。初始字符串具有所有使用的字符，但右引号和右引号除外。然后将其加倍并连接顺序号中每个打开和关闭引号之一（因此需要将其他字符加倍）。最后，它反复地从组成的字符串到程序的长度中选择随机字符。

Pyke，35个字节

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

在这里尝试！

要检查：删除最后一个H，结果字符串包含每个字符的正确编号（带有额外的H）

这根本不使用广义的quine，或者根本不使用quine。它依赖于能够创建包含源中所有字符的字符串。它应该能够对任何代码执行此操作，但是每个字符都以对数形式增加代码大小。源中允许字符的唯一次数是2或7

Ruby，81 67字节

通过窃取Martin解决方案中的一些技巧来节省大量字节

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

我没有意识到您每次都必须随机选择。我以为洗牌可以解决问题。这也许可以打高尔夫球，但这是我能得到的最短的时间。

经过一些修改的标准Ruby quine，因此可以打印出经过改编的字符串。我很伤心，因为花了大约十五分钟的时间才能弄清楚格式化的怪癖，然后才意识到我还是在潜意识里偷了它。

我认为可以缩短字符串混洗，但是我不知道如何。一旦考虑了一下，我也许还可以将格式设置得更短一些。帮助将不胜感激。

在线尝试！

C，125字节

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个字节，但不包含任何字符串的quine代码

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

为了计算字符，我的解决方案需要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个字节

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

注意：由于使用，因此仅在Firefox中有效uneval。

样品运行：

)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字节

我在源代码中的字符串中使用每个字符正确的次数，然后将字符串乘以2以包含自身。程序为该代码中的每个字符从该字符串中打印一个随机字符（长度是硬编码的。）

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

在线尝试

我避免了像瘟疫这样的反斜杠。一旦代码包含\n或\"，您就会遇到问题，因为该字符串尚不包含反斜杠，因此您还必须添加反斜杠，但要在一个单独的字符串中加上一个更大的数字，因为它需要两个反斜杠来表示一个反斜杠。 （\\）。

输出示例：

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'

我得说，这让我想起了FlogScript。

PowerShell v2 +，175个字节

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

在PowerShell中基内斯吮吸，因为字符串替换分隔符{}也分别表示循环和诸如此类的东西，所以你需要使用一堆的char在S -f运营商，其腌的代码。

类似于我的《每行Quine》答案。基本上，我们从0到循环，174并且每次迭代都重新计算该Quine $d，将其转换为char-array，然后Random从输入中拉出一个统一选择的元素。根据定义，这给出了(occurrences in source) / (length of source)所需的概率。这些字符被封装在括号中，然后-join一起返回一个字符串。

例

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

（是的，这是输出中的换行符-当包含换行符的字符串被char-array'd时，该`n字符被视为字符，因为-array char只是字节码的数组，因此它也具有1/175被选中的机会。）

Dyalog APL，20 字节

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

f←{... }将f定义为

(,⎕CR'f')listified（ ,）Ç haracter（表）- [R epresentation（⎕CR的）˚F（'f'）

[?⍴⍨20]索引为（[... ]）随机数至（?）自身重复次数（⍴⍨）为20

让我们运行一次（带有虚拟参数）几次：

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

很好，但是分配正确吗？让我们在10,000个虚拟参数上运行它，看看每个字符出现了多少次：

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

显然，f其'出现频率是其他字符的两倍，就像原始源代码中一样。

我们是怎么做的？

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

⍳1E4 生成前10,000个整数

f¨对每个数字运行f

∊ 将所有伪喹纳平整为单个200,000个字符的字符串

⌸是一个高阶函数，对于右侧数据中的每个唯一字符，将左侧元素的唯一元素作为左侧参数提供给左侧函数，并将该字符出现的索引作为右侧参数提供给左侧函数。左侧功能是

{⍺ , 1E¯4× ⍴⍵}

⍺ 左参数，即唯一字符

, 其次是

1E¯4× 1×10⁻⁴次

⍴⍵ 右参数的形状（出现索引），即出现多少次

最后，⌸将所有内容放到一张桌子中。

C＃，277个 280 268字节。

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

取消高尔夫：

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

相当确定这可以正常工作。

样本输出：

    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字节

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

输出示例：

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

该程序随机输出136个字符。

整个源代码（较少的引号）包含在一个字符串中，该程序将输出引号的概率确定为2/136，否则将随机输出其他67个字符之一。

程序中的字符串中每个字符都有两次出现。从字符串输出字符的概率为134/136。在字符串中选择特定字符的概率为1/67。因此，在字符串中输出字符的机会为134/136 * 1/67 = 2/136。程序中每个字符串字符都有两次出现，因此在程序中每次出现一个字符的概率为1/136。

字符串中符号的顺序无关紧要。