Faux Source Code

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

CJam, 14 bytes

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

Try it online!

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 2

Jelly, 13 bytes

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

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.

Answer 3

Perl, 59 bytes

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

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

Usage

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

perl faux-source-code.pl

Produces something like the following:

$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==/[e-mail]'}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}

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

Answer 4

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

Answer 5

Pyth, 16 Bytes

smO+N"m1NOs+6"16

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

Answer 6

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 7

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 8

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 9

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 10

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

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 11

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

Answer 12

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 13

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!

Answer 14

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 15

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.

Answer 16

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.

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 17

Dyalog APL, 20 bytes

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

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:

      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 18

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 19

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.