Générez un caractère aléatoire pour chaque caractère du code source (comme illustré ci-dessous). La probabilité de chaque caractère est sa fréquence dans le code source d'origine. Ainsi, la sortie sera un faux code source ressemblant à un quine.

spécification

• Restrictions
  • Des contraintes de quine standard s'appliquent. Aucun programme ou fonction vide. Pas non plus de lecture de votre propre source.
• Sortie
  • Le nombre de caractères émis doit être exactement le nombre de caractères dans le code source
  • Chaque caractère de sortie doit être choisi au hasard
  • La probabilité de choisir un caractère est égale à (occurrences in source) / (length of source)
  • Cela signifie que même une solution unaire doit choisir «au hasard» 1avec probabilité 1. Cela signifie que la sortie ne peut pas être codée en dur.
• Gagnant
  • C'est le golf de code, donc le moins d'octets gagne

Exemple

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 octets

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

Essayez-le en ligne!

Explication

Chaque caractère apparaît exactement deux fois, donc les probabilités des caractères doivent toutes être identiques.

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

Gelée , 13 octets

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

Essayez-le en ligne!

Comment ça marche

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

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

J'ai utilisé une quine existante comme base et l'ai modifiée pour imprimer des caractères aléatoires à partir du contenu source.

Usage

Enregistrer sous faux-source-code.plet exécuter en utilisant:

perl faux-source-code.pl

Produit quelque chose comme ceci:

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

Dans un bref test, ~ 3% des résultats du programme ont evalréussi. Je ne sais pas ce que cela dit sur Perl ...

Japt , 22 octets

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

Testez-le en ligne!

Comment ça marche

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

smO+N"m1NOs+6"16

essayez-le en ligne!

Contient chaque caractère deux fois donc la probabilité est la même que si chacun n'y était qu'une fois.

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 octets

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

courir avec php -d

1. crée une chaîne contenant le code sans les guillemets
2. et concatène le guillemet une fois en utilisant ord
   (même probabilité que si je doublais la chaîne et ajoutais deux guillemets);
3. boucle ensuite sur deux fois la longueur de la chaîne pour en obtenir des caractères aléatoires.

Peut éventuellement être golfé plus loin, mais mes tentatives sur eval ont été vaines jusqu'à présent.
Je n'irai probablement pas plus loin ici.

Python 2, 88 octets

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

Tout le mérite réel d'aller aussi loin revient à mbomb007 - merci pour votre aide (et le pointeur sur les contre-obliques)

Rubis, 47 octets

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

Ceci est basé sur le evalquine standard :

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

C'est un octet plus long que le quine le plus court, mais c'est généralement le meilleur choix pour les quines généralisés, car tout calcul effectué sur la chaîne de code source n'a pas besoin d'être dupliqué. Alors que dans le quine habituel, chaque calcul supplémentaire doit aller à l'intérieur et à l'extérieur de la chaîne principale, il n'est nécessaire qu'à l'intérieur de la chaîne principale pour ce type de quine.

Quant à ce que fait réellement le code: après avoir obtenu une chaîne représentant tout le code source, nous sélectionnons simplement un caractère aléatoire (en sélectionnant un index aléatoire) 47 fois et imprimons chaque caractère séparément.

Wolfram Language / Mathematica, 109 octets

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

exemple de sortie:

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 ces crochets.

Gelée, 44 octets

J'espère avoir interprété toutes les règles correctement (je ne suis pas tout à fait sûr de ce que la chose « charge utile carry » est en méta ou si elle est encore pertinente à ce défi).

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

Testez-le sur TryItOnline

Cela construit une chaîne parmi laquelle choisir les caractères. La chaîne initiale a tous les caractères utilisés sauf les guillemets ouverts et fermés. Il double ensuite cette chaîne et concatène l' une de chacune des guillemets ouverts et fermés des ordinaux (d'où la nécessité de doubler les autres caractères). Enfin, il sélectionne à plusieurs reprises des caractères aléatoires de la chaîne composée jusqu'à la longueur du programme.

Pyke, 35 octets

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

Essayez-le ici!

Pour vérifier: supprimez la finale Het la chaîne résultante contient le bon numéro de chaque caractère (avec le supplément H)

Cela n'utilise PAS de quine généralisé ou en fait un quine du tout. Il repose sur la possibilité de créer une chaîne contenant tous les caractères de la source. Il devrait pouvoir le faire pour n'importe quel code, mais chaque caractère augmente logarithmiquement la taille du code. Le seul nombre de fois où un personnage est autorisé dans la source est 2 ou 7

Rubis, 81 67 octets

Enregistré un tas d'octets en volant quelques astuces de la solution de Martin

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

Je ne savais pas que vous deviez sélectionner au hasard à chaque fois; Je pensais qu'un shuffle ferait l'affaire. Cela peut probablement être joué au golf, mais c'est le plus court possible.

Quine Ruby standard avec quelques modifications pour qu'il imprime la chaîne mélangée. Je suis triste parce qu'il a fallu quinze minutes pour comprendre les bizarreries de formatage avant de réaliser que je le volais inconsciemment de toute façon.

Je pense que le réarrangement des cordes peut être raccourci mais je ne sais pas comment; Je pourrais également être en mesure de préciser la mise en forme pour être plus courte une fois que j'y ai réfléchi. De l'aide serait appréciée.

Essayez-le en ligne!

C, 125 octets

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 octets pour le code golfé mais pas quine prenant n'importe quelle chaîne

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

Alors que pour compter les caractères, ma solution avait besoin 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 octets

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

Remarque: ne fonctionne que dans Firefox en raison de l'utilisation de uneval .

Exemples de cycles:

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

J'utilise chaque caractère de mon code source dans la chaîne le bon nombre de fois, puis je multiplie la chaîne par deux pour l'inclure. Le programme imprime un caractère aléatoire à partir de cette chaîne pour chaque caractère du code (la longueur est codée en dur.)

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

Essayez-le en ligne

J'ai évité les contre-obliques comme la peste. Dès que le code contient \nou \", vous avez un problème, car la chaîne ne contient pas encore de barres obliques inverses, vous devez donc les ajouter également, mais dans une chaîne distincte multipliée par un nombre plus élevé, car il faut deux barres obliques inverses pour en représenter une ( \\).

Exemple de sortie:

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'

Je dois dire que cela me rappelle FlogScript.

PowerShell v2 +, 175 octets

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

Les quines dans PowerShell sont nulles, car les délimiteurs de remplacement de chaîne {}indiquent également des boucles et autres, donc vous devez utiliser un tas de chars dans le-f opérateur, ce qui gonfle le code.

Similaire à ma réponse Quine on Every Line . Fondamentalement, nous bouclons de 0à 174et chaque itération recalcule le quine $d, le chartransforme en un tableau et extrait un Randomélément choisi uniformément de l'entrée. Par définition, cela donne la probabilité (occurrences in source) / (length of source)requise. Ces caractères sont encapsulés entre parenthèses et édités -joinensemble dans une chaîne.

Exemple

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

(Oui, c'est une nouvelle ligne dans la sortie - quand une chaîne contenant une nouvelle ligne est char-array'd, la `nest traitée comme un caractère, car une char-array est juste un tableau de codes d'octets, donc elle a aussi un 1 / 175e chance d'être sélectionné.)

Dyalog APL , 20 octets

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

f←{... }définir f comme

(,⎕CR'f')listified ( ,) C haracter (table) R epresentation ( ⎕CR) of f ( 'f')

[?⍴⍨20]indexé avec ( [... ]) aléatoire jusqu'à (? ) répéter-fois-fois ( ⍴⍨) de vingt

Lançons-le (avec un argument factice) plusieurs fois:

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

Très bien, mais la distribution est-elle correcte? Exécutons-le sur 10 000 arguments fictifs et voyons combien de fois chaque caractère se produit:

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

De toute évidence, fet' se produisent deux fois plus souvent que les autres caractères, tout comme dans le code source d'origine.

Comment avons-nous fait ça?

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

⍳1E4 génère les 10 000 premiers entiers

f¨exécute f sur chacun de ces nombres

∊ aplatit toutes les pseudo-quines en une seule chaîne de 200 000 caractères

⌸est une fonction d'ordre supérieur qui, pour chaque caractère unique dans les données de droite, alimente la fonction de gauche l'élément unique en argument de gauche et les indices où ce caractère apparaît comme argument de droite. La fonction de gauche est

{⍺ , 1E¯4× ⍴⍵}

⍺ argument de gauche, c'est-à-dire le caractère unique

, suivi par

1E¯4× 1 × 10⁻⁴ fois

⍴⍵ la forme de l'argument de droite (les indices d'occurrence), c'est-à-dire combien de fois il se produit

Enfin, ⌸met tout cela ensemble dans une table.

C #, 277 280 268 octets.

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

Non golfé:

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

Je suis sûr que cela fonctionne correctement.

Exemple de sortie:

    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 octets

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

Exemple de sortie:

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

Ce programme génère 136 caractères au hasard.

Le code source entier (moins les "guillemets) est contenu dans une chaîne. Le programme détermine la probabilité de sortie d'un guillemet comme 2/136, sinon la sortie au hasard d'un des 67 autres caractères.

Il y a deux occurrences de chaque caractère dans la chaîne du programme. La probabilité de sortir un caractère de la chaîne est 134/136. La probabilité de choisir un caractère spécifique dans la chaîne est de 1/67. La probabilité de sortie d'un caractère dans la chaîne est donc 134/136 * 1/67 = 2/136. Il y a deux occurrences de chaque caractère de chaîne dans le programme, il y a donc une probabilité de 1/136 de sortir un caractère pour chaque occurrence du programme.

L'ordre des symboles à l'intérieur de la chaîne n'a pas d'importance.