Wypisz jeden losowy znak dla każdego znaku kodu źródłowego (jak pokazano poniżej). Prawdopodobieństwo każdego znaku to jego częstotliwość w oryginalnym kodzie źródłowym. Tak więc wynikiem będzie fałszywy kod źródłowy przypominający quine.

Specyfikacja

• Ograniczenia
  • Obowiązują standardowe ograniczenia quine . Brak pustych programów lub funkcji. Również brak czytania własnego źródła.
• Wydajność
  • Liczba znaków wyjściowych powinna być dokładnie liczbą znaków w kodzie źródłowym
  • Każdy znak wyjściowy powinien być wybierany losowo
  • Prawdopodobieństwo wyboru dowolnej postaci jest równe (occurrences in source) / (length of source)
  • Oznacza to, że nawet jedno rozwiązanie musi „losowo” dokonać wyboru 1z prawdopodobieństwem 1. To znaczy, że wyjście nie może być zakodowane na stałe.
• Zwycięski
  • To jest kod golfowy, więc wygrywa najmniej bajtów

Przykład

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 bajtów

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

Wypróbuj online!

Wyjaśnienie

Każda postać pojawia się dokładnie dwa razy, więc prawdopodobieństwa postaci powinny być takie 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*

Galaretka , 13 bajtów

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

Wypróbuj online!

Jak to działa

“;⁾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 bajtów

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

Jako podstawy użyłem istniejącego quinu i zmodyfikowałem go, aby drukować losowe znaki z treści źródłowej.

Stosowanie

Zapisz jako faux-source-code.pli uruchom używając:

perl faux-source-code.pl

Tworzy coś takiego:

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

W krótkim teście ~ 3% wyników programu evalpowiodło się. Nie jestem pewien, co to mówi o Perlu ...

Japt , 22 bajty

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

Przetestuj online!

Jak to działa

"+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 bajtów

smO+N"m1NOs+6"16

spróbuj online!

Zawiera każdy znak dwa razy, dlatego prawdopodobieństwo jest takie samo, jakby każdy był tam tylko raz.

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 bajtów

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

Biegnij z php -d

1. tworzy ciąg zawierający kod bez cudzysłowu
2. i łączy znak cudzysłowu raz przy użyciu ord
   (takie samo prawdopodobieństwo, jak gdybym podwoił ciąg i dodałbym dwa cudzysłowy);
3. następnie zapętla ponad dwukrotnie długość łańcucha, aby uzyskać z niego losowe znaki.

Być może można grać w golfa dalej, ale moje próby ewaluacji były jak dotąd daremne.
Prawdopodobnie nie będę tu wchodził głębiej.

Python 2, 88 bajtów

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

Wszystko rzeczywiste zasługi w coraz to daleko idzie mbomb007 - dzięki za pomoc (i wskaźnika o ukośniki)

Ruby, 47 bajtów

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

Jest to oparte na standardowym evalquine:

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

Jest to bajt dłuższy niż najkrótszy quine, ale zwykle jest lepszym wyborem dla uogólnionych quines, ponieważ wszelkie obliczenia wykonane na łańcuchu kodu źródłowego nie muszą być duplikowane. Podczas gdy w zwykłym quine, każde dodatkowe obliczenie musi przejść zarówno wewnątrz jak i na zewnątrz głównego ciągu, jest ono potrzebne tylko w głównym ciągu dla tego rodzaju quine.

Co do tego, co faktycznie robi kod: po uzyskaniu ciągu reprezentującego cały kod źródłowy, po prostu wybieramy losowy znak (wybierając losowy indeks) 47 razy i drukujemy każdy znak osobno.

Wolfram Language / Mathematica, 109 bajtów

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

próbka wyjściowa:

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

Och, te nawiasy kwadratowe.

Galaretka, 44 bajty

Mam nadzieję, że poprawnie zinterpretowałem wszystkie reguły (nie jestem do końca pewien, co kryje się w metodzie „noś ładunek”, czy może ma to związek z tym wyzwaniem).

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

Przetestuj to w TryItOnline

Konstruuje ciąg, z którego można wybierać znaki. Początkowy ciąg znaków zawiera wszystkie użyte znaki oprócz cudzysłowów otwierających i zamykających. Następnie podwaja ten ciąg i konkatenuje jeden z każdego otwartego i zamkniętego cudzysłowu z rzędnych (stąd potrzeba podwojenia pozostałych znaków). Wreszcie wielokrotnie wybiera losowe znaki ze skomponowanego ciągu na długość programu.

Pyke, 35 bajtów

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

Wypróbuj tutaj!

Aby sprawdzić: usuń końcowy, Ha wynikowy ciąg zawiera odpowiednią liczbę każdego znaku (z dodatkowym H)

NIE używa to uogólnionego quinu ani w ogóle quinu. Polega na możliwości utworzenia ciągu zawierającego wszystkie znaki w źródle. To powinno być w stanie to zrobić dla dowolnego kodu, ale każda postać logarytmicznie zwiększa rozmiaru kodu. Jedyną liczbą dozwolonych znaków w źródle jest 2 lub 7

Rubin, 81 67 bajtów

Zaoszczędził sporo bajtów, kradnąc kilka sztuczek z rozwiązania Martina

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

Nie zdawałem sobie sprawy, że za każdym razem musisz losowo wybierać; Myślałem, że tasowanie wystarczy. To może być gra w golfa, ale jest to najkrótszy czas, jaki udało mi się zdobyć.

Standardowy rubinowy quine z kilkoma modyfikacjami, dzięki czemu drukuje przetasowany ciąg. Jest mi smutno, ponieważ zajęło mi to piętnaście minut, aby zrozumieć dziwactwa związane z formatowaniem, zanim zdałem sobie sprawę, że i tak podświadomie je kradnę.

Myślę, że tasowanie strun można skrócić, ale nie wiem jak; Być może uda mi się też skrócić czas formatowania, gdy się nad tym zastanowię. Pomoc będzie mile widziana.

Wypróbuj online!

C, 125 bajtów

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 bajtów dla kodu w golfa, ale nie quine, biorąc dowolny ciąg

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

Podczas gdy do liczenia znaków moje rozwiązanie wymagało 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 bajtów

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

Uwaga: działa tylko w przeglądarce Firefox ze względu na użycie uneval.

Przykładowe przebiegi:

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

Używam każdego znaku w kodzie źródłowym w ciągu znaków poprawną liczbę razy, a następnie mnożę ciąg przez dwa, aby uwzględnić go. Program drukuje losowy znak z tego ciągu dla każdego znaku w kodzie (długość jest zakodowana na stałe).

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

Wypróbuj online

Unikałem ukośników jak zarazy. Jak tylko kod zawiera \nlub \"masz problem, ponieważ ciąg nie zawiera jeszcze odwrotnych ukośników, więc musisz je również dodać, ale w osobnym ciągu pomnożonym przez większą liczbę, ponieważ potrzeba dwóch odwrotnych ukośników, aby reprezentować jeden ( \\).

Przykładowe dane wyjściowe:

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'

Muszę powiedzieć, że przypomina mi FlogScript.

PowerShell v2 +, 175 bajtów

$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 w PowerShell ssać, ponieważ ogranicznikami zamiennych ciąg {}też oznaczać pętle i etażerka, więc trzeba użyć kilka z charS w-f operatora, który bloats kod.

Podobne do mojego Quine on Every Line . Zasadniczo zapętlamy od 0do 174i każda iteracja ponownie oblicza quine $d, rzuca ją jako chartablicę i wyciąga Randomelement wybrany równomiernie z wejścia. Z definicji daje to prawdopodobieństwo (occurrences in source) / (length of source)zgodnie z wymaganiami. Znaki te są zamknięte w parens i-join łączone z powrotem w ciąg.

Przykład

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

(Tak, to nowa linia w danych wyjściowych - gdy jest ciąg zawierający nową linię char linię -array'd, `njest traktowany jako znak, ponieważ char-array jest tylko tablicą kodów bajtów, więc ma również 1 / 175th szansa na wybór).

Dyalog APL , 20 bajtów

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

f←{... }zdefiniuj f jako

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

[?⍴⍨20]indeksowane za pomocą ( [...] ) random-up-to (? ) repeat-yourself-times ( ⍴⍨) dwudziestu

Uruchommy to (z fałszywym argumentem) kilka razy:

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

Dobrze, ale czy dystrybucja jest prawidłowa? Uruchommy go na 10.000 fałszywych argumentach i zobaczmy, ile razy występuje każda postać:

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

Wyraźnie, f i 'występują dwa razy częściej niż inne znaki, tak jak w oryginalnym kodzie źródłowym.

Jak to zrobiliśmy?

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

⍳1E4 generuje pierwsze 10 000 liczb całkowitych

f¨działa f na każdej z tych liczb

∊ spłaszcza wszystkie pseudo-quiny w pojedynczy ciąg 200 000 znaków

⌸jest funkcją wyższego rzędu, która dla każdego unikalnego znaku w danych po prawej stronie przekazuje funkcji po lewej stronie unikalny element jako lewy argument, a indeksy, w których znak ten występuje jako prawy argument. Funkcja po lewej stronie to

{⍺ , 1E¯4× ⍴⍵}

⍺ lewy argument, tj. unikalny znak

, śledzony przez

1E¯4× 1 × 10⁻⁴ razy

⍴⍵ kształt właściwego argumentu (wskaźniki występowania), tj. ile razy występuje

Na koniec ⌸składa wszystko w stół.

C #, 277 280 268 bajtów.

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

Nie golfowany:

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

Jestem pewien, że to działa poprawnie.

Przykładowe dane wyjściowe:

    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 bajtów

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

Przykładowe dane wyjściowe:

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

Ten program generuje losowo 136 znaków.

Cały kod źródłowy (mniej „znaków cudzysłowu) jest zawarty w ciągu. Program określa prawdopodobieństwo wygenerowania znaku cudzysłowu na 2/136, w przeciwnym razie losowo wyśle ​​jeden z pozostałych 67 znaków.

W programie występują dwa wystąpienia każdego znaku w ciągu. Prawdopodobieństwo wyprowadzenia znaku z łańcucha wynosi 134/136. Prawdopodobieństwo wyboru określonego znaku w ciągu wynosi 1/67. Zatem szansa na wyprowadzenie znaku w ciągu wynosi 134/136 * 1/67 = 2/136. Istnieją dwa wystąpienia każdego znaku w programie, więc istnieje prawdopodobieństwo 1/136 wyprowadzenia znaku dla każdego wystąpienia w programie.

Kolejność symboli w ciągu nie ma znaczenia.