Emette un carattere casuale per ogni carattere del codice sorgente (come illustrato di seguito). La probabilità di ogni carattere è la sua frequenza nel codice sorgente originale. Quindi l'output sarà falso codice sorgente simile a un quine.

specificazione

• restrizioni
  • Si applicano i vincoli Quine standard . Nessun programma o funzione vuoto. Inoltre, non leggere la tua fonte.
• Produzione
  • Il numero di caratteri in uscita dovrebbe essere esattamente il numero di caratteri nel codice sorgente
  • Ogni carattere di output deve essere scelto casualmente
  • La probabilità di scegliere un personaggio è uguale a (occurrences in source) / (length of source)
  • Ciò significa che anche una soluzione unaria deve scegliere 'casualmente' 1con probabilità 1. Vale a dire che l'output non può essere hard coded.
• vincente
  • Questo è il golf del codice, quindi vince meno byte

Esempio

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 byte

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

Provalo online!

Spiegazione

Ogni personaggio appare esattamente due volte, quindi le probabilità dei personaggi dovrebbero essere tutte uguali.

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

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

Provalo online!

Come funziona

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

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

Ho usato un quine esistente come base e l'ho modificato per stampare caratteri casuali dal contenuto sorgente.

uso

Salva come faux-source-code.pled esegui usando:

perl faux-source-code.pl

Produce qualcosa di simile al seguente:

$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==/t@dl.fe'}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 un breve test, ~ 3% dei risultati del programma ha evalavuto successo. Non sono sicuro di ciò che dice di Perl ...

Japt , 22 byte

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

Provalo online!

Come funziona

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

smO+N"m1NOs+6"16

provalo online!

Contiene ogni carattere due volte, quindi la probabilità è la stessa di se ognuno fosse solo una volta.

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 byte

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

Corri con php -d

1. crea una stringa contenente il codice senza le virgolette
2. e concatena le virgolette una volta usando ord
   (stessa probabilità che se raddoppiassi la stringa e aggiungessi due virgolette);
3. quindi scorre oltre il doppio della lunghezza della stringa per ottenere caratteri casuali da essa.

Può essere ulteriormente giocato a golf, ma i miei tentativi di valutazione sono stati inutili finora.
Probabilmente non approfondirò qui.

Python 2, 88 byte

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

Tutto il merito effettivo di arrivare così lontano va a mbomb007 - grazie per il tuo aiuto (e il puntatore sulle barre rovesciate)

Rubino, 47 byte

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

Questo si basa sullo standard evalquine:

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

È un byte più lungo del quine più corto, ma di solito è la scelta migliore per i quine generalizzati, poiché non è necessario duplicare qualsiasi calcolo eseguito sulla stringa del codice sorgente. Mentre nel solito quine, ogni calcolo aggiuntivo deve andare sia all'interno che all'esterno della stringa principale, è necessario solo all'interno della stringa principale per questo tipo di quine.

Per quanto riguarda ciò che fa effettivamente il codice: dopo aver ottenuto una stringa che rappresenta l'intero codice sorgente, selezioniamo semplicemente un carattere casuale (selezionando un indice casuale) 47 volte e stampiamo ogni carattere separatamente.

Wolfram Language / Mathematica, 109 byte

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

uscita campione:

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 quelle parentesi quadre.

Gelatina, 44 byte

Spero di aver interpretato correttamente tutte le regole (non sono del tutto sicuro di cosa sia la meta "carry payload" in meta o se sia rilevante per questa sfida).

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

Provalo su TryItOnline

Questo costruisce una stringa da cui scegliere i caratteri. La stringa iniziale ha tutto il carattere utilizzato tranne le virgolette di apertura e chiusura. Quindi raddoppia quella stringa e concatena una delle virgolette aperte e chiuse dagli ordinali (da qui la necessità di raddoppiare gli altri caratteri). Infine, seleziona ripetutamente caratteri casuali dalla stringa composta per la lunghezza del programma.

Pyke, 35 byte

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

Provalo qui!

Per verificare: rimuovere il finale He la stringa risultante contiene il numero giusto di ciascun carattere (con il supplementoH )

Questo NON usa un quine generalizzato o di fatto un quine. Si basa sulla possibilità di creare una stringa contenente tutti i caratteri nel sorgente. Si dovrebbe essere in grado di farlo per qualsiasi codice, ma ogni personaggio aumenta la dimensione del codice in modo logaritmico. L'unico numero di volte in cui un personaggio è ammesso nella sorgente è 2 o 7

Rubino, 81 67 byte

Ho salvato un sacco di byte rubando alcuni trucchi dalla soluzione di Martin

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

Non mi rendevo conto che dovevi selezionare casualmente ogni volta; Ho pensato che uno shuffle avrebbe fatto il trucco. Probabilmente questo può essere giocato a golf, ma è il più corto che ho potuto ottenere.

Quino Ruby standard con alcune modifiche in modo da stampare la stringa mescolata. Sono triste perché ci sono voluti quindici minuti per capire le stranezze di formattazione prima di rendermi conto che lo stavo inconsciamente rubando comunque.

Penso che lo shuffling delle stringhe possa essere abbreviato ma non so come; Potrei anche essere in grado di rendere più breve la formattazione per essere più breve una volta che ci ho pensato. L'aiuto sarebbe apprezzato.

Provalo online!

C, 125 byte

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 byte per il codice golf ma non quine che accetta una stringa

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

Mentre per contare i caratteri la mia soluzione aveva bisogno di 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 byte

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: funziona solo in Firefox grazie all'uso di uneval.

Esecuzioni campione:

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

Uso ogni carattere nel mio codice sorgente all'interno della stringa il numero corretto di volte, quindi moltiplico la stringa per due per includersi. Il programma stampa un carattere casuale da quella stringa per ogni carattere nel codice (la lunghezza è hardcoded.)

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

Provalo online

Ho evitato i contraccolpi come la peste. Non appena il codice contiene \no \", hai un problema, perché la stringa non contiene ancora barre rovesciate, quindi devi aggiungere anche quelle, ma in una stringa separata moltiplicata per un numero più alto, perché sono necessarie due barre rovesciate per rappresentarne una ( \\).

Esempio di 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'

Devo dire che mi ricorda 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})

Le query in PowerShell fanno schifo, perché i delimitatori di sostituzione delle stringhe {}indicano anche loop e quant'altro, quindi è necessario utilizzare un gruppo di chars nell'operatore -f, che gonfia il codice.

Simile alla mia risposta Quine on Every Line . Fondamentalmente eseguiamo il loop da 0a 174e ogni iterazione ricalcola il quine $d, lo lancia come un chararray e estrae unRandom elemento scelto uniformemente dall'ingresso. Per definizione, questo dà probabilità (occurrences in source) / (length of source)come richiesto. Quei personaggi sono incapsulati in parentesi e -joinricomposti in una stringa.

Esempio

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

(Sì, questa è una nuova riga nell'output - quando una stringa che contiene una nuova riga è char-array, `nviene trattata come un carattere, poiché un char-array è solo un array di codici byte, quindi ha anche un 1/75 possibilità di essere selezionato.)

Dyalog APL , 20 byte

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

f←{... }definire f come

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

[?⍴⍨20]indicizzato con ( [... ]) random-up-to (? ) repeat-stessa-volte ( ⍴⍨) di venti

Eseguiamolo (con un argomento fittizio) alcune volte:

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

Bene, ma la distribuzione è corretta? Eseguiamolo su 10.000 argomenti fittizi e vediamo quante volte si verifica ogni personaggio:

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

Chiaramente, f e si 'verificano due volte più spesso degli altri caratteri, proprio come nel codice sorgente originale.

Come l'abbiamo fatto?

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

⍳1E4 genera i primi 10.000 numeri interi

f¨corre f su ciascuno di quei numeri

∊ appiattisce tutte le pseudo-quine in una singola stringa di 200.000 caratteri

⌸è una funzione di ordine superiore che per ciascun carattere univoco nei dati del lato destro, alimenta la funzione del lato sinistro l'elemento univoco come argomento di sinistra e gli indici in cui quel carattere si presenta come argomento di destra. La funzione sul lato sinistro è

{⍺ , 1E¯4× ⍴⍵}

⍺ argomento sinistro, ovvero il carattere unico

, seguito da

1E¯4× 1 × 10⁻⁴ volte

⍴⍵ la forma dell'argomento giusto (gli indici di occorrenza), ovvero quante volte si verifica

Infine, ⌸mette tutto insieme in un tavolo.

C #, 277 280 268 byte.

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

Abbastanza sicuro che funzioni correttamente.

Uscita campione:

    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 byte

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

Esempio di 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"]

Questo programma genera casualmente 136 caratteri.

L'intero codice sorgente (meno "virgolette) è contenuto in una stringa. Il programma determina la probabilità di emettere un segno di virgolette come 2/136, altrimenti emette uno degli altri 67 caratteri in modo casuale.

Esistono due occorrenze di ciascun carattere nella stringa nel programma. La probabilità di emettere un carattere dalla stringa è 134/136. La probabilità di scegliere un carattere specifico nella stringa è 1/67. Quindi la possibilità di emettere un carattere nella stringa è 134/136 * 1/67 = 2/136. Esistono due occorrenze di ciascun carattere stringa nel programma, quindi esiste una probabilità 1/136 di emettere un carattere per ogni occorrenza nel programma.

L'ordine dei simboli all'interno della stringa non ha importanza.