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

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

• ограничения
  • Применяются стандартные ограничения по квине . Нет пустых программ или функций. Также нет чтения вашего собственного источника.
• Выход
  • Количество выводимых символов должно соответствовать количеству символов в исходном коде.
  • Каждый выходной символ должен быть выбран случайным образом
  • Вероятность выбора любого персонажа равна (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

Я использовал существующую квину в качестве основы и изменил ее для печати случайных символов из исходного содержимого.

использование

Сохранить как 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

Pyth, 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"

Это на байт длиннее самой короткой квин, но обычно это лучший выбор для обобщенных квин, потому что любые вычисления, выполняемые для строки исходного кода, не должны дублироваться. В то время как в обычной квине все дополнительные вычисления должны проходить как внутри, так и снаружи главной строки, они нужны только внутри основной строки для этого вида квин.

Что касается того, что код на самом деле делает: после получения строки, представляющей весь исходный код, мы просто выбираем случайный символ (путем выбора случайного индекса) 47 раз и печатаем каждый символ отдельно.

Wolfram Language / Mathematica, 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 байтов для игры в гольф, но не код quine, берущий любую строку

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

Python 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и каждая итерация пересчитывает квинну, преобразует $dее как char-array и извлекает 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новая строка в выходных данных - когда строка, содержащая новую строку, является -array'd, `nона обрабатывается как символ, так как char-array - это просто массив байтовых кодов, поэтому он также имеет 1/175. шанс быть выбранным.)

Dyalog APL , 20 байтов

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

f←{... }определить f как

(,⎕CR'f')listified ( ,) С haracter (таблица) R epresentation ( ⎕CR) из F ( 'f')

[?⍴⍨20]индексируется с помощью ( [... ]) random-up-to ( ?) repeat -self-times (⍴⍨ ) из двадцати

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

      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 генерирует первые 10000 целых

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

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

Уверен, это работает правильно.

Пример вывода:

    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 вывода символа для каждого вхождения в программе.

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