Saída de um caractere aleatório para cada caractere do código fonte (conforme ilustrado abaixo). A probabilidade de cada caractere é sua frequência no código fonte original. Assim, a saída será um código-fonte falso, semelhante a um quine.

Especificação

• Restrições
  • Aplicam-se restrições de quine padrão . Não há programas ou funções vazios. Também não é possível ler sua própria fonte.
• Saída
  • O número de caracteres de saída deve ser exatamente o número de caracteres no código-fonte
  • Cada caractere de saída deve ser escolhido aleatoriamente
  • A probabilidade de escolher qualquer caractere é igual a (occurrences in source) / (length of source)
  • Isso significa que mesmo uma solução unária precisa escolher 'aleatoriamente' 1com probabilidade 1. O que significa que a saída não pode ser codificada.
• Ganhando
  • Isso é código de golfe, então o menor número de bytes ganha

Exemplo

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 bytes

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

Experimente online!

Explicação

Cada caractere aparece exatamente duas vezes, portanto, as probabilidades dos caracteres devem ser as mesmas.

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

Gelatina , 13 bytes

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

Experimente online!

Como funciona

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

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

Usei um quine existente como base e modifiquei-o para imprimir caracteres aleatórios a partir do conteúdo de origem.

Uso

Salve como faux-source-code.ple execute usando:

perl faux-source-code.pl

Produz algo como o seguinte:

$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==/[email protected]'}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}

Em um breve teste, ~ 3% dos resultados do programa foram evalbem-sucedidos. Não sei o que isso diz sobre Perl ...

Japonês , 22 bytes

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

Teste online!

Como funciona

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

smO+N"m1NOs+6"16

experimente online!

Contém cada caractere duas vezes, portanto, a probabilidade é a mesma que se cada um estivesse lá apenas uma vez.

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

correr com php -d

1. cria uma sequência contendo o código sem as aspas
2. e concatena as aspas uma vez usando ord
   (mesma probabilidade como se eu dobrasse a string e adicionasse duas aspas);
3. em seguida, passa o loop duas vezes o comprimento da string para obter caracteres aleatórios.

Possivelmente pode ser jogado ainda mais, mas minhas tentativas de avaliar foram inúteis até agora.
Provavelmente não irei mais fundo aqui.

Python 2, 88 bytes

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

Todo o mérito real de chegar até aqui vai para mbomb007 - obrigado por sua ajuda (e o ponteiro sobre as barras invertidas)

Ruby, 47 bytes

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

Isso é baseado no padrão evalquine:

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

É um byte mais longo que o menor quine, mas geralmente é a melhor escolha para quines generalizados, porque qualquer cálculo feito na cadeia de código-fonte não precisa ser duplicado. Enquanto no quine usual, todo cálculo adicional precisa ir dentro e fora da string principal, só é necessário dentro da string principal para esse tipo de quine.

Quanto ao que o código realmente faz: após obter uma string que representa o código fonte inteiro, simplesmente selecionamos um caractere aleatório (selecionando um índice aleatório) 47 vezes e imprimimos cada caractere separadamente.

Wolfram Language / Mathematica, 109 bytes

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

saída de amostra:

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 aqueles colchetes.

Geléia, 44 bytes

Espero ter interpretado todas as regras corretamente (eu não estou bastante certo de que a coisa "carry payload" está na meta ou se é mesmo relevante a este desafio).

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

Teste-o em TryItOnline

Isso constrói uma cadeia de caracteres para escolher caracteres. A cadeia inicial possui todo o caractere usado, exceto as aspas de abertura e fechamento. Em seguida, ele dobra essa sequência e concatena uma de cada uma das aspas abertas e fechadas dos ordinais (daí a necessidade de duplicar os outros caracteres). Por fim, ele seleciona repetidamente caracteres aleatórios da sequência composta até o tamanho do programa.

Pyke, 35 bytes

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

Experimente aqui!

Para verificar: remova a final He a sequência resultante contém o número certo de cada caractere (com o número extraH )

Isso NÃO usa uma solução generalizada ou, de fato, uma solução. Ele conta com a capacidade de criar uma sequência contendo todos os caracteres na fonte. Ele deve poder fazer isso para qualquer código, mas cada caractere aumenta logaritmicamente o tamanho do código. O único número de vezes que um caractere é permitido na fonte é 2 ou 7

Ruby, 81 67 bytes

Economizou um monte de bytes roubando alguns truques da solução de Martin

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

Eu não percebi que você tinha que selecionar aleatoriamente todas as vezes; Eu pensei que um shuffle faria o truque. Provavelmente isso pode ser jogado no golfe, mas é o menor tempo possível.

Quine padrão do Ruby com algumas modificações, para que ele imprima a sequência embaralhada. Estou triste porque demorou quinze minutos para descobrir as peculiaridades da formatação antes de perceber que eu estava subconscientemente roubando de qualquer maneira.

Acho que o embaralhamento das cordas pode ser reduzido, mas não sei como; Talvez eu também consiga reduzir o tamanho da formatação depois de pensar um pouco. Ajuda seria apreciada.

Experimente online!

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 para código golfado, mas não para quine, usando qualquer string

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

Enquanto para contar caracteres, minha solução precisava de 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 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]))

Nota: só funciona no Firefox devido ao uso de uneval.

Amostras de execuções:

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

Uso cada caractere no meu código-fonte dentro da string o número correto de vezes e multiplico a string por dois para incluir a si mesma. O programa imprime um caractere aleatório dessa sequência para cada caractere no código (o comprimento é codificado).

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

Experimente online

Evitei barras como a praga. Assim que o código contiver \nou \", você tiver um problema, porque a string ainda não contém barras invertidas, você deverá adicioná-las também, mas em uma string separada multiplicada por um número maior, porque são necessárias duas barras invertidas para representar uma ( \\)

Exemplo de saída:

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'

Eu tenho que dizer, isso me lembra o 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 em PowerShell chupar, porque os delimitadores de substituição de string {}também laços denotam e outros enfeites, então você precisa usar um monte de chars no -foperador, que incha o código.

Semelhante à minha resposta Quine on Every Line . Basicamente, fazemos um loop de 0para 174e cada iteração recalcula o quine $d, o charprojeta como um array e extrai um Randomelemento escolhido uniformemente da entrada. Por definição, isso fornece probabilidade (occurrences in source) / (length of source)conforme necessário. Esses caracteres são encapsulados em parênteses e -joinreunidos novamente em uma sequência.

Exemplo

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

(Sim, é uma nova linha na saída - quando uma string que contém uma nova linha é char-array'd, `né tratada como um caractere, uma vez que a char-array é apenas uma matriz de códigos de bytes, por isso também possui 1/175 chance de ser selecionado.)

Dyalog APL , 20 bytes

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

f←{... }defina f como

(,⎕CR'f')listified ( ,) C haracter (tabela) R ePresentation ( ⎕CR) de f ('f' )

[?⍴⍨20]indexado com ( [... ]) ?tempos aleatórios até ( ) repetir a si próprio (⍴⍨ ) de vinte

Vamos executá-lo (com um argumento fictício) algumas vezes:

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

Tudo bem, mas a distribuição está correta? Vamos executá-lo com 10.000 argumentos fictícios e ver quantas vezes cada caractere ocorre:

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

Claramente, fe 'ocorrem duas vezes mais que os outros caracteres, assim como no código-fonte original.

Como fizemos isso?

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

⍳1E4 gera os primeiros 10.000 números inteiros

f¨executa f em cada um desses números

∊ nivela todos os pseudoquinos em uma única cadeia de 200.000 caracteres

⌸é uma função de ordem superior que, para cada caractere exclusivo nos dados do lado direito, alimenta a função do lado esquerdo do elemento exclusivo como argumento à esquerda e os índices em que esse caractere ocorre como argumento à direita. A função do lado esquerdo é

{⍺ , 1E¯4× ⍴⍵}

⍺ argumento à esquerda, ou seja, o caractere único

, Seguido por

1E¯4× 1 × 10⁻⁴ vezes

⍴⍵ a forma do argumento correto (os índices de ocorrência), ou seja, quantas vezes ocorre

Finalmente, ⌸coloca tudo junto em uma tabela.

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

Certamente isso funciona corretamente.

Saída de amostra:

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

Exemplo de saída:

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

Este programa gera 136 caracteres aleatoriamente.

O código fonte inteiro (menos "aspas) está contido em uma seqüência de caracteres. O programa determina a probabilidade de gerar aspas como 2/136, caso contrário, gera um dos outros 67 caracteres aleatoriamente.

Existem duas ocorrências de cada caractere na cadeia de caracteres do programa. A probabilidade de gerar um caractere a partir da string é 134/136. A probabilidade de escolher um caractere específico na sequência é 1/67. Portanto, a chance de gerar um caractere na sequência é 134/136 * 1/67 = 2/136. Existem duas ocorrências de cada caractere de seqüência de caracteres no programa, portanto, existe uma probabilidade 1/136 de gerar um caractere para cada ocorrência no programa.

A ordem dos símbolos dentro da string não importa.