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.


  • Restrictions
    • Standard 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


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%
  • \$\begingroup\$ Are single-character quines allowed? \$\endgroup\$ – Nathan Merrill Sep 7 '16 at 21:59
  • \$\begingroup\$ @NathanMerrill Yes, single character (and other unary) solutions are allowed. However, their output still needs to be randomly chosen. \$\endgroup\$ – NonlinearFruit Sep 7 '16 at 22:03
  • \$\begingroup\$ How shall I find the occurences of characters in a file if I am not allowed to read it? \$\endgroup\$ – Titus Sep 7 '16 at 22:38
  • 1
    \$\begingroup\$ Is this code-golf? \$\endgroup\$ – OldBunny2800 Sep 7 '16 at 23:54
  • 1
    \$\begingroup\$ @VolAnd No. The probability of each character appearing is based on the character frequency. If you flip a coin twice and it lands on heads once, it doesn't have to hand on tails the second time. \$\endgroup\$ – wizzwizz4 Sep 8 '16 at 6:29

19 Answers 19


CJam, 14 bytes


Try it online!


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.

Jelly, 13 bytes


Try it online!

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.

Perl, 59 bytes


I used an existing quine as a basis and modified it to print random characters from the source contents.


Save as faux-source-code.pl and run using:

perl faux-source-code.pl

Produces something like the following:


In a brief test, ~3% of the results of the program eval successfully. I'm not sure what that says about Perl...

  • \$\begingroup\$ Ahah, that comment about the 3% of successful eval! Nice one! ;-) \$\endgroup\$ – Dada Sep 30 '16 at 19:42
  • \$\begingroup\$ @Dada Seriously! The submissions in the answer genuinely work! I was pretty impressed... \$\endgroup\$ – Dom Hastings Sep 30 '16 at 19:45
  • \$\begingroup\$ Hopefully, from what I've seen, it just comes from the output being a entire single quoted string (with ' or q//, q{} etc) ! \$\endgroup\$ – Dada Sep 30 '16 at 19:52
  • \$\begingroup\$ @Dada Yeah, or a regex match. Made me chuckle though! :) \$\endgroup\$ – Dom Hastings Sep 30 '16 at 21:11
  • 1
    \$\begingroup\$ Happy to see you golfing again btw! :) \$\endgroup\$ – Dada Sep 30 '16 at 21:20

Japt, 22 bytes

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

Test it online!

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

Pyth, 16 Bytes


try it online!

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

PHP, 71 140 110 124 140 120 bytes


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.

  • 1
    \$\begingroup\$ The probability of each character is its frequency in the original source code. I may be wrong, but it doesn't look like this entry meets this requirement. \$\endgroup\$ – ETHproductions Sep 7 '16 at 22:34
  • \$\begingroup\$ Oh I missed that point. Back to the editor. How can this be done without reading the code? \$\endgroup\$ – Titus Sep 7 '16 at 22:35
  • \$\begingroup\$ Using this, I got a syntax error, unexpected '<'. But I'm not familiar with PHP, how do I test this? \$\endgroup\$ – NonlinearFruit Sep 8 '16 at 1:00
  • \$\begingroup\$ @NonlinearFruit: Did you use the -d flag? This is supposed to be saved to a file and then called with php or php-cgi without any flags. Maybe you can use a heredoc. \$\endgroup\$ – Titus Sep 8 '16 at 1:49
  • \$\begingroup\$ @NonlinearFruit: ... or just remove the leading <? for usage with -d. \$\endgroup\$ – Titus Sep 8 '16 at 12:56

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)

  • 1
    \$\begingroup\$ This is a quine-like challenge, without input or reading your source code (suppose it is n characters long), you need to print n random characters. Where the probability of a symbol c being chosen is equal to (number of times c occurs in your solution) / n. \$\endgroup\$ – NonlinearFruit Sep 8 '16 at 16:05
  • \$\begingroup\$ So more like this? exec("""s = 'from random import choice; print "".join([choice(s) for c in s])'; exec(s)""") \$\endgroup\$ – user59421 Sep 8 '16 at 16:23
  • \$\begingroup\$ You haven't included the single quotes yet, and you don't need the square brackets within the join. \$\endgroup\$ – mbomb007 Sep 8 '16 at 16:36
  • \$\begingroup\$ Thanks - and right, I got a little caught up in the rush of nudging closer to the solution \$\endgroup\$ – user59421 Sep 8 '16 at 16:37
  • 1
    \$\begingroup\$ Here you go: s='''from random import*;print"".join(choice(s)for c in s+"s='';''exec s''")''';exec s. I wish I'd thought of that. \$\endgroup\$ – mbomb007 Sep 8 '16 at 16:41

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.


Wolfram Language/Mathematica, 109 Bytes


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.


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


Test it out at TryItOnline

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.

  • 1
    \$\begingroup\$ @NonlinearFruit Oops - I updated to add a missed character from my string but did not update to 44 - thanks! \$\endgroup\$ – Jonathan Allan Sep 7 '16 at 23:03

Pyke, 35 bytes

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

Try it here!

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


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 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!

  • \$\begingroup\$ I think (like my CJam) answer, it's not necessary to use a standard quine as the basis. A direct port of my CJam solution gives 64 bytes: 64.times{$><<"64.times{$><<.inspect[rand 32]}".inspect[rand 32]} \$\endgroup\$ – Martin Ender Sep 9 '16 at 8:44
  • \$\begingroup\$ Nevermind, basing it on a standard quine is shorter, but you'll have to use the eval-based quine: eval r="47.times{$><<('eval r=%p'%r)[rand 47]}" \$\endgroup\$ – Martin Ender Sep 9 '16 at 8:53
  • \$\begingroup\$ @MartinEnder That's different enough to merit its own answer, I think. If you disagree, feel free to edit it into mine, but in the mean time I'll just steal a few tricks from yours to save a few bytes in mine. \$\endgroup\$ – Fund Monica's Lawsuit Sep 9 '16 at 14:05

C, 125 bytes


C, 60 bytes for golfed but not quine code taking any string


While for counting characters my solution needed 86:

  • \$\begingroup\$ It should not? Perhaps I do not understand the rules of this quiz. My f takes string and prints to standard output: string can be any sequence of characters. \$\endgroup\$ – VolAnd Sep 8 '16 at 12:01
  • \$\begingroup\$ @NonlinearFruit Probabilities not calculated but expression rand()%LENGTH_OF_STRING take character according to probability of that character with normal distribution provided by rand(). Perhaps, I do not understand quine approach for C.... \$\endgroup\$ – VolAnd Sep 12 '16 at 9:03
  • \$\begingroup\$ +1 The new solution is nearly correct. s just needs to contain char*s="";. I think something like this char*s="char*s=l,i;f(){l=i=strlen(s);while(i--)putchar(s[rand()%l]);};+''"+'""' would do it (but I am not familiar with C). \$\endgroup\$ – NonlinearFruit Sep 12 '16 at 16:08
  • \$\begingroup\$ If the answer is not valid in its current state, then it should be deleted. \$\endgroup\$ – mbomb007 Sep 28 '16 at 13:29
  • \$\begingroup\$ @mbomb007 Could you explain your judgment and possibly provide come advice? \$\endgroup\$ – VolAnd Sep 29 '16 at 5:47

JavaScript, 128 bytes


Note: only works in Firefox due to the use of uneval.

Sample runs:

  • \$\begingroup\$ I'm now really surprised that this produced more valid code in Perl than it appears it would in JS! Not as many fun words here, except gtraoan which is nearly a groan I guess... \$\endgroup\$ – Dom Hastings Nov 2 '16 at 21:04
  • 1
    \$\begingroup\$ @DomHastings Well, Perl is more of a mash of punctuation than JS ;) \$\endgroup\$ – ETHproductions Nov 2 '16 at 21:06
  • \$\begingroup\$ Definitely! It's more of a mess of punctuation than an explosion in a punctuation factory! but I quite like that! \$\endgroup\$ – Dom Hastings Nov 2 '16 at 21:09
  • \$\begingroup\$ Does " have a probability of showing up? \$\endgroup\$ – NonlinearFruit Nov 2 '16 at 21:11
  • 1
    \$\begingroup\$ @NonlinearFruit Yup. There's at least one in the first, second, and last example outputs. \$\endgroup\$ – ETHproductions Nov 2 '16 at 21:12

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

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.


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 chars in the -f operator, which bloats the code.

Similar-ish to my Quine on Every Line 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 -joined together back into a string.


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


Dyalog APL, 20 bytes


f←{...} define f as

(,⎕CR'f') listified (,) Character (table) Representation (⎕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:


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

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.


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


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

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
  • \$\begingroup\$ @NonlinearFruit Thanks, missed that space. Also means I can't use a foreach loop which adds a few bytes :(. However, I think I do have " included correctly with those two escaped quotes in the string, since they appear in the output a few times, unless I'm missing their use somewhere else. \$\endgroup\$ – Yodle Sep 9 '16 at 14:05
  • \$\begingroup\$ Ahh, I thought they didn't count if they were in the string, my bad. Will fix in a bit. \$\endgroup\$ – Yodle Sep 9 '16 at 14:17
  • \$\begingroup\$ Okay, \'s now appear as well! \$\endgroup\$ – Yodle Sep 9 '16 at 14:26
  • 1
    \$\begingroup\$ Hm, interesting problem then. Can't just keep adding \\ or I'll always be one short. I'll use the ascii code for \ instead. \$\endgroup\$ – Yodle Sep 9 '16 at 14:46
  • \$\begingroup\$ Does (new Random()).Next(0,134)] work? It would save a couple bytes. \$\endgroup\$ – NonlinearFruit Sep 12 '16 at 16:10

C, 136 bytes


Example output:


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.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.