Виведіть один випадковий символ для кожного символу вихідного коду (як показано нижче). Імовірність кожного символу - це його частота в вихідному вихідному коді. Таким чином, вихід буде підробленим вихідним кодом, що нагадує квінку.

Специфікація

• Обмеження
  • Застосовуються стандартні обмеження з хином . Немає порожніх програм або функцій. Також немає читання власного джерела.
• Вихід
  • Кількість виведених символів має бути рівною кількістю символів у вихідному коді
  • Кожен вихідний символ повинен бути вибраний випадковим чином
  • Ймовірність вибору будь-якого персонажа дорівнює (occurrences in source) / (length of source)
  • Це означає, що навіть одинакове рішення потрібно «випадковим чином» вибирати 1з вірогідністю 1. Що означає, що висновок не може бути сильно кодованим.
• Перемога
  • Це кодовий гольф, тому виграє найменше байтів

Приклад

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 байт

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

Спробуйте в Інтернеті!

Пояснення

Кожен символ з'являється рівно двічі, тому ймовірність символів повинна бути однаковою.

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

Желе , 13 байт

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

Спробуйте в Інтернеті!

Як це працює

“;⁾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 байт

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

Я використовував існуючу quine як основу та модифікував її для друку випадкових символів із вихідного вмісту.

Використання

Зберегти як faux-source-code.plі запустити за допомогою:

perl faux-source-code.pl

Виробляє щось на зразок наступного:

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

У короткому тесті ~ 3% результатів програми evalуспішно. Я не впевнений, що це говорить про Perl ...

Japt , 22 байти

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

Перевірте це в Інтернеті!

Як це працює

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

Піт, 16 байт

smO+N"m1NOs+6"16

спробуйте в Інтернеті!

Містить кожну таблицю двічі, тому ймовірність така ж, як якщо б кожен був лише один раз.

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 байт

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

бігати з php -d

1. створює рядок, що містить код без лапок
2. і об'єднує лапки один раз за допомогою ord
   (така ж ймовірність, як якщо б я подвоїв рядок і додав два лапки);
3. потім петлі перевищують вдвічі більше довжини рядка, щоб отримати з нього випадкові символи.

Можливо, можна пограти далі в гольф, але мої спроби на eval, де поки що марні.
Я, мабуть, не заглиблюватись сюди.

Python 2, 88 байт

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

Вся справжня заслуга в досягненні цього далеко йде на mbomb007 - дякую за вашу допомогу (і вказівник про відкоси)

Рубін, 47 байт

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

Це засновано на стандартній evalквині:

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

Це байт довший, ніж найкоротший quine, але, як правило, кращий вибір для узагальнених quines, тому що будь-які обчислення, виконані у рядку вихідного коду, не потрібно дублювати. Якщо у звичайній лайці, кожен додатковий обчислення повинен проходити як всередині, так і зовні основної струни, то для цього виду лайки це потрібно лише всередині основної струни.

Що стосується того, що насправді робить код: після отримання рядка, що представляє весь вихідний код, ми просто вибираємо випадковий символ (вибравши випадковий індекс) 47 разів і друкуємо кожен символ окремо.

Мова Вольфрама / Математика, 109 байт

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

вибірка вибірки:

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

О, ці квадратні дужки.

Желе, 44 байти

Я сподіваюся, що я правильно інтерпретував усі правила (я не зовсім впевнений, що таке мета "переносити корисний вантаж" у мета або якщо це навіть стосується цього виклику).

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

Перевірте це на TryItOnline

Це будує рядок, з якого вибирати символи. У початковому рядку є всі використовувані символи, крім лапок відкритого та закритого. Потім він подвоює цей рядок і об'єднує один із відкритих і закритих цитат з ординарних запитів (звідси необхідність подвоїти інші символи). Нарешті, він неодноразово підбирає випадкові символи зі складеного рядка до довжини програми.

Пайк, 35 байт

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

Спробуйте тут!

Щоб перевірити: видаліть остаточний, Hа результуюча рядок містить потрібне число кожного символу (із додатковим H)

Це НЕ використовує узагальнену квінку або насправді хіну взагалі. Він покладається на те, що зможе створити рядок, що містить усі символи в джерелі. Він повинен мати можливість це робити для будь-якого коду, але кожен символ логарифмічно збільшує розмір коду. Єдина кількість дозволів символу у джерелі - це 2 або 7

Рубі, 81 67 байт

Зберегли купу байтів, вкравши декілька хитрощів з рішення Мартіна

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

Я не усвідомлював, що вам доведеться щоразу вибирати випадковим чином; Я думав, що змішання зробить свою справу. Можливо, це може бути гольф, але це найкоротший, який я міг би отримати.

Стандартний Ruby quine з кількома модифікаціями, щоб він друкував перетасований рядок. Мені сумно, бо знадобилося п’ятнадцять хвилин, щоб розібратися у форматуваннях диваків, перш ніж я зрозумів, що я все одно підсвідомо краду.

Я думаю, що перетасування струн можна скоротити, але я не знаю як; Можливо, я також зможу завершити формат, щоб він був коротшим, як тільки я подумав про це. Допомога буде вдячна.

Спробуйте в Інтернеті!

C, 125 байт

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 байтів для гольфу, але не вдавайте код з будь-якого рядка

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

Хоча для підрахунку символів моєму рішення потрібно 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 байт

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

Примітка. У Firefox працює лише завдяки використанню uneval.

Проби:

)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

Пітон 3, 134 132 байт

Я використовую кожен символ у своєму вихідному коді в рядку правильну кількість разів, а потім помножую рядок на два, щоб включити себе. Програма друкує випадковий символ із цього рядка для кожного символу коду (довжина жорстко закодована.)

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

Спробуйте в Інтернеті

Я уникав нахилів, як чума. Як тільки код містить \nабо\" вас виникає проблема, оскільки рядок ще не містить зворотних косого рису, тож вам доведеться додати і їх, але в окремий рядок, помножений на більшу кількість, тому що для репрезентації одного зворотного косого риса потрібні два зворотні риски. ( \\).

Приклад виводу:

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'

Треба сказати, що це нагадує мені FlogScript.

PowerShell v2 +, 175 байт

$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 в PowerShell смокче, тому що заміни рядків роздільники {}також позначають петлю і етажерки, так що вам потрібно використовувати зв'язку з charз в-f операторі, який роздуває код.

Схожий на мій відповідь Quine on Every Line . В основному ми робимо цикл від 0до174 переходимо кожної ітерації, заново обчислюємо quine, виводимо $dїї як- charмасив і витягуємо Randomз вхідного елементу рівномірно вибраний елемент. За визначенням, це дає ймовірність у (occurrences in source) / (length of source)міру необхідності. Ці символи інкапсульовані у паролях та-join разом в рядок.

Приклад

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

(Так, це новий рядок у висновку - коли рядок, що містить новий рядок, є- charмасив, `nце трактується як символ, оскільки- charмасив - це лише масив байтових кодів, тому він також має 1/175-й шанс бути обраним.)

Діалог APL , 20 байт

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

f←{... }визначте f як

(,⎕CR'f')listified ( ,) C Характер (таблиця) R epresentation ( ⎕CR) of f ( 'f')

[?⍴⍨20]індексується з ( [... ]) випадковим ?повтором до ( ) повторенням-часом ( ⍴⍨) двадцяти

Давайте кілька разів запустимо його (з фіктивним аргументом):

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

Добре, але чи правильний розподіл? Давайте запустимо його на 10000 фіктивних аргументів і подивимося, скільки разів кожен символ трапляється:

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

Зрозуміло, fі' трапляються вдвічі частіше, ніж інші символи, як і в оригінальному вихідному коді.

Як ми це зробили?

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

⍳1E4 генерує перші 10 000 цілих чисел

f¨працює п по кожному з цих чисел

∊ згладжує всі псевдокіни в єдиний рядок 200 000 символів

⌸- це функція вищого порядку, яка для кожного унікального символу в даних правого боку подає лівій функції унікальний елемент як аргумент зліва, а індекси, де цей символ зустрічається як правий аргумент. Ліва функція є

{⍺ , 1E¯4× ⍴⍵}

⍺ аргумент зліва, тобто унікальний символ

, слідом за ним

1E¯4× 1 × 10⁻⁴ разів

⍴⍵ форма правильного аргументу (індекси зустрічальності), тобто скільки разів це відбувається

Нарешті, ⌸кладе це все разом у таблицю.

C #, 277 280 268 байт.

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

Безголівки:

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

Досить впевнений, що це працює правильно.

Вибірка зразка:

    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 байт

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

Приклад виводу:

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

Ця програма виводить 136 символів випадковим чином.

Весь вихідний код (менше "лапок") міститься в рядку. Програма визначає ймовірність виведення лапки як 2/136, в іншому випадку виводить один з інших 67 символів випадковим чином.

У рядку програми є два входження кожного символу. Ймовірність виведення символу з рядка становить 134/136. Імовірність вибору конкретного символу в рядку становить 1/67. Тож шанс виведення символу в рядку дорівнює 134/136 * 1/67 = 2/136. У програмі є два входження кожного символу рядка, тому існує ймовірність 1/136 виведення символу для кожної зустрічі в програмі.

Порядок символів всередині рядка не має значення.