Geben Sie für jedes Zeichen des Quellcodes ein zufälliges Zeichen aus (siehe Abbildung unten). Die Wahrscheinlichkeit für jedes Zeichen ist die Häufigkeit im ursprünglichen Quellcode. Die Ausgabe wird also ein gefälschter Quellcode sein, der einem Quine ähnelt.

Spezifikation

• Beschränkungen
  • Es gelten die Standardbedingungen für Quines . Keine leeren Programme oder Funktionen. Auch keine eigene Quelle lesen.
• Ausgabe
  • Die Anzahl der ausgegebenen Zeichen sollte genau der Anzahl der Zeichen im Quellcode entsprechen
  • Jedes Ausgabezeichen sollte zufällig ausgewählt werden
  • Die Wahrscheinlichkeit, ein beliebiges Zeichen zu wählen, ist gleich (occurrences in source) / (length of source)
  • Dies bedeutet, dass selbst eine unäre Lösung mit hoher 1Wahrscheinlichkeit eine zufällige Auswahl treffen muss 1. Das heißt, dass die Ausgabe nicht fest codiert werden kann.
• Gewinnen
  • Dies ist Codegolf, so dass nur wenige Bytes gewinnen

Beispiel

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*

Probieren Sie es online!

Erläuterung

Jedes Zeichen erscheint genau zweimal, daher sollten alle Wahrscheinlichkeiten der Zeichen gleich sein.

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

Jelly , 13 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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

Ich habe ein vorhandenes Quine als Basis verwendet und es modifiziert, um zufällige Zeichen aus dem Quellinhalt zu drucken.

Verwendung

Speichern unter faux-source-code.plund ausführen mit:

perl faux-source-code.pl

Erzeugt so etwas wie folgendes:

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

In einem kurzen Test waren ~ 3% der Ergebnisse des Programms evalerfolgreich. Ich bin mir nicht sicher, was das über Perl aussagt ...

Japt , 22 Bytes

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

Testen Sie es online!

Wie es funktioniert

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

versuche es online!

Enthält jedes Zeichen zweimal, daher ist die Wahrscheinlichkeit dieselbe, als ob jedes Zeichen nur einmal darin wäre.

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

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

renn mit php -d

1. Erstellt eine Zeichenfolge, die den Code ohne Anführungszeichen enthält
2. und verkettet das Anführungszeichen einmal mit ord
   (gleiche Wahrscheinlichkeit, als würde ich die Zeichenfolge verdoppeln und zwei Anführungszeichen hinzufügen);
3. Schleifen Sie dann über die doppelte Länge der Zeichenfolge, um zufällige Zeichen daraus zu erhalten.

Kann möglicherweise weiter golfen werden, aber meine Versuche auf eval waren bisher vergeblich.
Ich werde hier wahrscheinlich nicht tiefer gehen.

Python 2, 88 Bytes

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

Der eigentliche Verdienst, so weit zu kommen, geht an mbomb007 - danke für Ihre Hilfe (und den Hinweis auf Backslashes)

Ruby, 47 Bytes

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

Dies basiert auf der Standard- evalQuine:

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

Es ist ein Byte länger als das kürzeste Quine, aber normalerweise die bessere Wahl für verallgemeinerte Quines, da die Berechnung der Quellcode-Zeichenfolge nicht dupliziert werden muss. Während im normalen Quine jede zusätzliche Berechnung sowohl innerhalb als auch außerhalb des Hauptstrings erfolgen muss, wird sie für diese Art von Quine nur innerhalb des Hauptstrings benötigt.

Was der Code tatsächlich tut: Nachdem wir eine Zeichenfolge erhalten haben, die den gesamten Quellcode darstellt, wählen wir einfach 47 Mal ein zufälliges Zeichen aus (indem wir einen zufälligen Index auswählen) und drucken jedes Zeichen einzeln aus.

Wolfram Language / Mathematica, 109 Bytes

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

Beispielausgabe:

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 diese eckigen Klammern.

Jelly, 44 Bytes

Ich hoffe, ich habe alle Regeln richtig interpretiert (ich bin mir nicht ganz sicher, was die "Carry Payload" -Sache in Meta ist oder ob sie für diese Herausforderung überhaupt relevant ist).

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

Testen Sie es bei TryItOnline

Dadurch wird eine Zeichenfolge erstellt, aus der Zeichen ausgewählt werden können. Die Anfangszeichenfolge enthält alle verwendeten Zeichen außer der Anführungszeichen zum Öffnen und Schließen. Anschließend wird diese Zeichenfolge verdoppelt und jeweils eines der offenen und geschlossenen Anführungszeichen aus Ordnungszahlen verkettet (daher müssen die anderen Zeichen verdoppelt werden). Zuletzt wählt es wiederholt zufällige Zeichen aus der zusammengesetzten Zeichenfolge zur Länge des Programms aus.

Pyke, 35 Bytes

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

Probieren Sie es hier aus!

Zur Kontrolle: Entfernen Sie das Finale H und die resultierende Zeichenfolge enthält die richtige Nummer für jedes Zeichen (mit dem Extra H).

Dies verwendet KEIN verallgemeinertes Quine oder überhaupt ein Quine. Es setzt voraus, dass eine Zeichenfolge erstellt werden kann, die alle Zeichen in der Quelle enthält. Dies sollte für jeden Code möglich sein, wobei jedoch jedes Zeichen die Codegröße logarithmisch erhöht. Die einzige Anzahl von Malen, die ein Zeichen in der Quelle erlaubt ist, ist 2 oder 7

Ruby, 81 67 Bytes

Sparte eine Menge Bytes, indem er einige Tricks aus Martins Lösung stahl

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

Mir war nicht klar, dass du jedes Mal zufällig auswählen musstest; Ich dachte, ein Shuffle würde es schaffen. Dies kann wahrscheinlich Golf gespielt werden, aber es ist das kürzeste, was ich bekommen kann.

Standard Ruby Quine mit ein paar Modifikationen, damit die gemischte Saite ausgedruckt wird. Ich bin traurig, weil es ungefähr fünfzehn Minuten gedauert hat, bis ich festgestellt habe, dass ich es trotzdem unbewusst gestohlen habe.

Ich denke, das Mischen der Saiten kann verkürzt werden, aber ich weiß nicht wie; Ich könnte auch in der Lage sein, die Formatierung zu verkürzen, wenn ich etwas darüber nachgedacht habe. Hilfe wäre dankbar.

Probieren Sie es 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 für golfenen, aber keinen Quine-Code, der eine Zeichenfolge annimmt

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

Während zum Zählen der Zeichen meine Lösung 86 benötigte:

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

Hinweis: Funktioniert aufgrund der Verwendung von nur in Firefox uneval.

Probeläufe:

)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

Ich verwende jedes Zeichen in meinem Quellcode innerhalb der Zeichenfolge so oft, wie es richtig ist, und multipliziere die Zeichenfolge dann mit zwei, um sich selbst einzuschließen. Das Programm druckt für jedes Zeichen im Code ein zufälliges Zeichen aus dieser Zeichenfolge (die Länge ist fest codiert.)

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

Probieren Sie es online aus

Ich vermied Rückschläge wie die Pest. Sobald der Code \noder enthält \", haben Sie ein Problem, da der String noch keine Backslashes enthält. Sie müssen diese ebenfalls hinzufügen, jedoch in einem separaten String multipliziert mit einer höheren Zahl, da zwei Backslashes erforderlich sind, um einen darzustellen ( \\).

Beispielausgabe:

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'

Ich muss sagen, es erinnert mich an FlogScript.

PowerShell v2 +, 175 Byte

$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 sind zum Kotzen, weil die Trennzeichen für Zeichenfolgenersetzungen {}auch Schleifen und so weiter bezeichnen. Daher müssen Sie eine Reihe von chars im -fOperator verwenden, die den Code aufblähen.

Ähnlich wie meine Quine on Every Line- Antwort. Grundsätzlich durchlaufen wir eine Schleife von 0bis 174und berechnen bei jeder Iteration den Quine neu $d, charwandeln ihn in ein -array um und ziehen ein Randomeinheitlich ausgewähltes Element aus der Eingabe heraus. Per Definition ergibt dies die (occurrences in source) / (length of source)erforderliche Wahrscheinlichkeit . Diese Zeichen sind in parens und eingekapselt-join zu einer Zeichenfolge zusammengefasst.

Beispiel

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

(Ja, das ist eine neue Zeile in der Ausgabe. Wenn eine Zeichenfolge, die eine neue charZeile enthält, -array'd ist , `nwird das als Zeichen behandelt, da ein char-array nur ein Array von Byte-Codes ist, also auch ein 1 / 175th Chance ausgewählt zu werden.)

Dyalog APL , 20 Bytes

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

f←{... }definiere f als

(,⎕CR'f')listified ( ,) C HARACTER (Tabelle) R ePresentation ( ⎕CR) von f ('f' )

[?⍴⍨20]indiziert mit ( [...] ) zufälligen bis zu ( ?) Wiederholungszeiten ( ⍴⍨) von zwanzig

Lassen Sie es uns ein paar Mal (mit einem Scheinargument) ausführen:

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

Gut, aber ist die Verteilung korrekt? Lassen Sie es uns mit 10.000 Dummy-Argumenten ausführen und sehen, wie oft jedes Zeichen vorkommt:

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

Deutlich, f und 'doppelt so häufig wie die anderen Zeichen, genau wie im ursprünglichen Quellcode.

Wie haben wir das gemacht?

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

⍳1E4 generiert die ersten 10.000 ganzen Zahlen

f¨Läuft f auf jede dieser Zahlen

∊ Fasst alle Pseudo-Quines zu einer einzigen Zeichenfolge mit 200.000 Zeichen zusammen

⌸ist eine Funktion höherer Ordnung, die für jedes eindeutige Zeichen in den Daten auf der rechten Seite das eindeutige Element als linkes Argument und die Indizes, in denen dieses Zeichen vorkommt, als rechtes Argument an die Funktion auf der linken Seite weitergibt. Die linke Funktion ist

{⍺ , 1E¯4× ⍴⍵}

⍺ linkes Argument, dh das eindeutige Zeichen

, gefolgt von

1E¯4× 1 × 10⁻⁴ mal

⍴⍵ Die Form des rechten Arguments (die Vorkommensindizes) gibt an, wie oft es vorkommt

Zum Schluss wird ⌸alles in einer Tabelle zusammengefasst.

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

Ziemlich sicher, dass dies richtig funktioniert.

Beispielausgabe:

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

Beispielausgabe:

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

Dieses Programm gibt 136 Zeichen nach dem Zufallsprinzip aus.

Der gesamte Quellcode (weniger "Anführungszeichen") ist in einer Zeichenfolge enthalten. Das Programm bestimmt die Wahrscheinlichkeit, ein Anführungszeichen als 2/136 auszugeben, andernfalls wird eines der anderen 67 Zeichen zufällig ausgegeben.

Es gibt zwei Vorkommen jedes Zeichens in der Zeichenfolge im Programm. Die Wahrscheinlichkeit, ein Zeichen aus der Zeichenkette auszugeben, beträgt 134/136. Die Wahrscheinlichkeit, ein bestimmtes Zeichen in der Zeichenfolge auszuwählen, beträgt 1/67. Die Wahrscheinlichkeit, ein Zeichen in der Zeichenfolge auszugeben, beträgt 134/136 * 1/67 = 2/136. Es gibt zwei Vorkommen jedes Zeichenstrings im Programm, daher besteht eine Wahrscheinlichkeit von 1/136, dass für jedes Vorkommen im Programm ein Zeichen ausgegeben wird.

Die Reihenfolge der Symbole in der Zeichenfolge spielt keine Rolle.