[Question]
  [
Output one random character for each character of source code (as illustrated below). The probability of each character is its frequency in the original source code. Thus the output will be fake source code resembling a quine.
# Specification
* **Restrictions**
	+ Standard [quine](/questions/tagged/quine "show questions tagged 'quine'") constrains apply. No empty programs or functions. Also no reading your own source.
* **Output**
	+ The number of characters output should be exactly the number of characters in the source code
	+ *Each* output character should be randomly choosen
	+ The probability of choosing any character is equal to `(occurrences in source) / (length of source)`
	+ This means that even a unary solution needs to 'randomly' choose `1` with probability `1`. Which is to say that the output can't be hard coded.
* **Winning**
	+ This is code golf, so fewest bytes wins
# Example
```
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%
```
  
[Answer]
# [Perl 5](https://www.perl.org/), 54 bytes
```
$_=q{print$_[rand@_]for@_="\$_=q{$_};eval"=~/./g};eval
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3rawuqAoM69EJT66KDEvxSE@Ni2/yCHeVikGLKcSX2udWpaYo2Rbp6@nnw7h/P8PAA "Perl 5 – Try It Online")
Produces output like:
```
_anr_;q.=fn_}v"_eo_f=n\di{nqde}[;}}o}t==@$@$=nvr$}/r=.
"q}=g{;}=[av$a}a__l[q@@;$;_}./@__a.ne=@@i_}_aet.=$=_o"
/arr_r]po{{l_=;__e"_et=="@vr__a_}@nl"ll~$=~_q~d"=v$~$/
q/@=_$__{f{vl;.]@=__=@lpapr}da@eeg_[$@lr\_{{pq$$$vrq=/
=v{[_l=p{{={/n$nv$n[_/aev_v=@on}la;}q{_otr$oaglve$.a_}
_aa;@r='{{=@{ntf;;.if}f}a$;$g/n;g;_}rroaqra=;}l.gre[t'
```
In a brief test, ~3-4% of the results of the program `eval` successfully. I'm not sure what that says about Perl...
[Answer]
## [CJam](http://sourceforge.net/projects/cjam/), 14 bytes
```
{{E*`mR}`mR}E*
```
[Try it online!](http://cjam.tryitonline.net/#code=e3tFKmBtUn1gbVJ9RSo&input=)
### Explanation
Each character appears exactly twice, so the probabilities of the characters should all be the same.
```
{           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*
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 13 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
“;⁾vṾWṁ$X€”vṾ
```
[Try it online!](http://jelly.tryitonline.net/#code=4oCcO-KBvnbhub5X4bmBJFjigqzigJ124bm-&input=)
### How it works
```
“;⁾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.
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 22 bytes
```
"+Q ²£ZgMqB"+Q ²£ZgMqB
```
[Test it online!](http://ethproductions.github.io/japt/?v=master&code=IitRILKjWmdNcUIiK1EgsqNaZ01xQg==&input=)
### How it works
```
"+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
```
[Answer]
# Pyth, 16 Bytes
```
smO+N"m1NOs+6"16
```
[**try it online!**](https://pyth.herokuapp.com/?code=smO%2BN%22m1NOs%2B6%2216&debug=0)
Contains each char twice therefore the probability is the same as if each was only in there once.
```
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
```
[Answer]
# PHP, ~~71~~ ~~140~~ ~~110~~ ~~124~~ ~~140~~ 120 bytes
```
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)];
```
run with `php -d`
1. creates a string containing the code without the quotation marks
2. and concatenates the quotation mark *once* using `ord`  
(same probability as if I would double the string and add two quotes);
3. then loops over twice the length of the string to get random characters from it.
Can possibly be golfed further, but my attempts on eval where futile so far.  
I will probably not go deeper here.
[Answer]
**Python 2, 88 bytes**
```
s='''from random import*; print "".join(choice(s) for c in "s='"+s+"';exec s")''';exec s
```
All *actual* merit in getting this far goes to mbomb007 - thanks for your help (and the pointer about backslashes)
[Answer]
## Ruby, 47 bytes
```
eval r="47.times{$><<('eval r=%p'%r)[rand 47]}"
```
This is based on the standard `eval` quine:
```
eval r="$><<'eval r=%p'%r"
```
It's a byte longer than the shortest quine, but it's usually the better choice for generalised quines, because any computation done on the source code string does not need to be duplicated. Whereas in the usual quine, every additional computation needs to go both inside and outside the main string, it is only needed inside the main string for this kind of quine.
As for what the code actually does: after obtaining a string representing the entire source code, we simply select a random character (by selecting a random index) 47 times and print each character separately.
[Answer]
# Wolfram Language/Mathematica, 109 Bytes
```
Function[Print[StringJoin[RandomChoice[StringSplit[StringJoin[ToString[FullForm[Slot[0]]],"[]"],""],109]]]][]
```
sample output:
```
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 those square brackets. 
[Answer]
# JavaScript, 128 bytes
```
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]))
```
Note: only works in Firefox due to the use of `uneval`.
Sample runs:
```
)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
```
[Answer]
# Jelly, 44 bytes
I hope I have interpreted all the rules correctly (I'm not *quite* sure what the "carry payload" thing is in meta or if it's even relevant to this challenge).
```
“ẋ2;8220Ọ;8221ỌXµ44Ð¡Ḋ”ẋ2;8220Ọ;8221ỌXµ44Ð¡Ḋ
```
Test it out at [**TryItOnline**](http://jelly.tryitonline.net/#code=4oCc4bqLMjs4MjIw4buMOzgyMjHhu4xYwrU0NMOQwqHhuIrigJ3huosyOzgyMjDhu4w7ODIyMeG7jFjCtTQ0w5DCoeG4ig&input=)
This constructs a string from which to choose characters. The initial string has all the character used *except* the open and close quotes. It then doubles that string and concatenates *one of each* of the open and close quotes from ordinals (hence the need to double the other characters). Lastly it repeatedly picks random characters from the composed string to the length of the program.
[Answer]
## Pyke, 35 bytes
```
35F\";"\\+3322 5**F;H)s"\"2*+2* H)s
```
[Try it here!](http://pyke.catbus.co.uk/?code=35F%5C%22%3B%22%5C%5C%2B3322+5%2a%2aF%3BH%29s%22%5C%222%2a%2B2%2a+H%29s)
To check: remove the final `H` and the resulting string contains the right number of each character (with the extra `H`)
This does NOT use a generalised quine or in fact a quine at all. It relies on being able to create a string containing all the characters in the source. It *should* be able to do it for any code but each character logarithmically increases code size. The only number of times a character is allowed in the source is 2 or 7
[Answer]
## Ruby, ~~81~~ 67 bytes
*Saved a bunch of bytes by stealing some tricks from Martin's solution*
```
s="s=%p;67.times{$><<(s%%s)[rand 67]}";67.times{$><<(s%s)[rand 67]}
```
I didn't realize that you had to randomly select every time; I thought a shuffle would do the trick. This can probably be golfed, but it's the shortest I could get it.
[Standard Ruby quine](https://codegolf.stackexchange.com/a/80/31541) with a few modifications so it prints out the shuffled string. I'm sad because it took like fifteen minutes to figure out the formatting quirks before I realized that I was subconsciously stealing it anyway.
I think the string shuffling can be shortened but I don't know how; I might also be able to finagle the formatting into being shorter once I put some thought into it. Help would be appreciated.
[Try it online!](https://ideone.com/ClUmW2)
[Answer]
**C, 125 bytes**
```
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 bytes for golfed but not quine code taking any string**
```
l,i;f(char*s){l=i=strlen(s);while(i--)putchar(s[rand()%l]);}
```
While for counting characters my solution needed 86:
```
c[256];i;f(char*s){i=256;while(*s)c[*s++]++;while(--i)while(c[i]?c[i]--:0)putchar(i);}
```
[Answer]
# C, 136 bytes
```
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);}
```
Example 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"]
```
This program outputs 136 characters randomly.
The entire source code (less " quotation marks) is contained in a string. The program determines the probability of outputting a quotation mark as 2/136, otherwise outputting one of the other 67 characters randomly.
There are two occurrences of each character in the string in the program. The probability of outputting a character from the string is 134/136. The probability of choosing a specific character in the string is 1/67. So the chance of outputting a character in the string is 134/136 \* 1/67 = 2/136. There are two occurrences of each string character in the program, so there is a 1/136 probability of outputting a character for each occurrence in the program.
The order of symbols inside the string doesn't matter.
[Answer]
# [R](https://www.r-project.org/), 174 bytes
```
cat(sample(el(dimnames(a<-table(c("\n",el(strsplit(scan(,""),"")))))),174,T,a),sep="")
cat(sample(el(dimnames(a<-table(c("\n",el(strsplit(scan(,""),"")))))),174,T,a),sep="")
```
[Try it online!](https://tio.run/##K/r/PzmxRKM4MbcgJ1UjNUcjJTM3LzE3tVgj0Ua3JDEJKJisoRSTp6QDlCsuKSouyMkEKk9OzNPQUVLSBGEw0DE0N9EJ0UnU1ClOLbAFinLRyNj//wE "R – Try It Online")
The function `sample` performs discrete random sampling. Itcan take as 4th argument a vector `prob` of probabilities. The vector `prob` does not need to be normalized (i.e. it does not need to sum to 1): here, we use a vector of counts, and `sample` does the renormalizing.
The 2 lines are identical. The 1st line does the hard work, and reads the contents of the 2nd line to get the counts of each character. So here, the vector of probabilities `a` actually sums to 87=174/2. Note the special treatment of the newline, which `scan` does not read. I can't think of a way of avoiding this without having to add more bytes to handle quotation marks.
[Answer]
# Python 3, ~~134~~ 132 bytes
I use every character in my source code within the string the correct number of times, then multiply the string by two to include itself. The program prints a random character from that string for each character in the code (the length is 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='')
```
[**Try it online**](http://ideone.com/hzVgV2)
I avoided backslashes like the plague. As soon as the code contains `\n` or `\"`, you have a problem, because the string doesn't contain backslashes yet, so you have to add those also, but in a separate string multiplied by a higher number, because it takes two backslashes to represent one (`\\`).
### Example 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'
```
I gotta say, it reminds me of FlogScript.
[Answer]
## PowerShell v2+, 175 bytes
```
$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 in PowerShell suck, because the string replacement delimiters `{}` also denote loops and whatnot, so you need to use a *bunch* of `char`s in the `-f` operator, which bloats the code.
Similar-ish to my [Quine on Every Line](https://codegolf.stackexchange.com/a/57648/42963) answer. Basically we loop from `0` to `174` and each iteration re-calculate the quine `$d`, cast it as a `char`-array, and pull out a `Random` element chosen uniformly from the input. By definition, this gives probability `(occurrences in source) / (length of source)` as required. Those characters are encapsulated in parens and `-join`ed together back into a string.
### Example
```
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
```
(Yes, that's a newline in the output -- when a string containing a newline is `char`-array'd, the ``n` is treated as a character, since a `char`-array is just an array of byte codes, so it also has a 1/175th chance of being selected.)
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), 20 [bytes](http://meta.codegolf.stackexchange.com/a/9429/43319)
```
f←{(,⎕CR'f')[?⍴⍨20]}
```
`f←{`...`}` define **f** as
`(,⎕CR'f')` listified (`,`) **C**haracter (table) **R**epresentation (`⎕CR`) of **f** (`'f'`)
`[?⍴⍨20]` indexed with (`[`...`]`) random-up-to (`?`) repeat-itself-times (`⍴⍨`) of twenty
Let us run it (with a dummy argument) a few times:
```
      f⍬
)0'0](⍨(([],}⎕))⎕'f2
      f⍬
{'['}f[←R[)2←?}⍨]}C2
      f⍬
,,⍨←?2}⍴?'⍨}C,'{⎕(C0
```
Fine, but is the distribution correct? Let us run it on 10,000 dummy arguments and see how many times each character occurs:
```
      {⍺ , 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
```
Clearly, `f` and `'` occur twice as often as the other characters, just like in the original source code.
How did we do it?
```
{⍺ , 1E¯4× ⍴⍵}⌸ ∊ f¨ ⍳1E4`
```
`⍳1E4` generates the first 10,000 integers
`f¨` runs **f** on each of those numbers
`∊` flattens all the pseudo-quines into a single 200,000-character string
`⌸` is a higher-order function which for each unique character in the right side data, feeds the left-side function the unique element as left-argument and the indices where that character occurs as right-argument. The left-side function is
```
{⍺ , 1E¯4× ⍴⍵}
```
`⍺` left-argument, i.e. the unique character
`,` followed by
`1E¯4×` 1×10⁻⁴ times
`⍴⍵` the shape of the right-argument (the occurrence indices), i.e.how many times it occurs
Finally, `⌸` puts it all together in a table.
[Answer]
# C#, ~~277~~ ~~280~~ 268 bytes.
```
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)]);
    }
}
```
Pretty sure this works correctly.
Sample output:
```
    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
```
[Answer]
# [Julia 1.0](http://julialang.org/), 50 bytes
```
(a=:(print.(rand("(a=:($(a)))|>eval", 50))))|>eval
```
[Try it online!](https://tio.run/##fVBLTsMwEN37FCPDwpZCSRbdRHJvwCpLQMiKp8GVcaKx03bBATgLx@IiwU6VqCCEF6P5@H1mDqOzujpPQZE@cc4noVUtBrI@bgRpbwSfO7dCSynfd3jUjhewLeVaTgn2WNXozV31DDdA@NYfESJp66zvIAVkbKZ0XgTJGvWAUW8GTQFzvYwky3Si@b/DDO716OJLiKYfIyi4JEyQKeBEMnUIjSVslz8Zte8JLFgPVV2VZckgvYU8WWfsN@anjGSt65PdxM8uqoTazJJNTN46ya49rmrh6@Mzm8tyy9wWwEHtIN2R@jGduE0xCqWElUXWunfou/gqcl6AsZ2NQW1Typ8i4Hmo/4aGFRiuYfN@0zc "Julia 1.0 – Try It Online")
based on this quine:
```
(a=:(print("(a=:($(a)))|>eval")))|>eval
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/XyPR1kqjoCgzr0RDCcxW0UjU1NSssUstS8xRgrP@/wcA "Julia 1.0 – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 136 bytes
```
a=scan(,"");cat(intToUtf8(sample(rep(c(10,utf8ToInt(a)),2),136,T)))
a=scan(,"");cat(intToUtf8(sample(rep(c(10,utf8ToInt(a)),2),136,T)))
```
[Try it online!](https://tio.run/##K/r/P9G2ODkxT0NHSUnTOjmxRCMzryQkP7QkzUKjODG3ICdVoyi1QCNZw9BApxQoGJLvmVeikaipqWOkqWNobKYToqmpyUUNM/7/BwA "R – Try It Online")
The "read-a-second-copy-and-sample-from-it" approach is shamefully copied from [Robin Ryder's answer](https://codegolf.stackexchange.com/a/231716/95126): please upvote that one.
Here, however, rather than counting the instances of each character and using this to weight the sampling, we just sample uniformly from the full set of characters (including repetitions).
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 75 bytes
```
exec(a:='from random import*;print(*choices("exec(a:=%r)"%a,k=75),sep="")')
```
[Try it online!](https://tio.run/##K6gsycjPM7YoKPr/P7UiNVkj0cpWPa0oP1ehKDEvBUhl5hbkF5VoWRcUZeaVaGglZ@RnJqcWayjBFKsWaSqpJupk25qbauoUpxbYKilpqmv@/w8A "Python 3.8 (pre-release) – Try It Online")
]