स्रोत कोड के प्रत्येक चरित्र के लिए एक यादृच्छिक चरित्र आउटपुट (जैसा कि नीचे सचित्र है)। प्रत्येक स्रोत की संभावना मूल स्रोत कोड में इसकी आवृत्ति है। इस प्रकार उत्पादन नकली स्रोत कोड होगा जो एक क्वीन जैसा होता है।

विशिष्टता

प्रतिबंध
- मानक क्वीन बाधाएं लागू होती हैं। कोई खाली कार्यक्रम या कार्य नहीं। इसके अलावा अपने स्वयं के स्रोत को नहीं पढ़ना।
उत्पादन
- स्रोत कोड में वर्णों की संख्या ठीक वर्णों की संख्या होनी चाहिए
- प्रत्येक आउटपुट चरित्र को बेतरतीब ढंग से चुना जाना चाहिए
- किसी भी पात्र को चुनने की संभावना बराबर होती है (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%

code-golf random quine

— NonlinearFruit
स्रोत

क्या एकल-वर्ण की अनुमति है?

— नाथन मेरिल

@NathanMerrill हाँ, एकल वर्ण (और अन्य unary) समाधानों की अनुमति है। हालांकि, उनके उत्पादन को अभी भी बेतरतीब ढंग से चुना जाना चाहिए।

— NonlinearFruit

यदि मुझे इसे पढ़ने की अनुमति नहीं है, तो मुझे किसी फ़ाइल में वर्णों की घटनाएँ कैसे मिलेंगी?

— टाइटस

1

क्या यह कोड-गोल्फ है ?

— OldBunny2800

1

@VolAnd नंबर प्रत्येक चरित्र की संभावना चरित्र आवृत्ति पर आधारित है। यदि आप एक सिक्के को दो बार फ्लिप करते हैं और यह एक बार सिर पर लैंड करता है, तो इसे दूसरी बार पूंछ पर हाथ नहीं लगाना पड़ता है।

— wizzwizz4

8

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*

— मार्टिन एंडर
स्रोत

7

जेली , 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.

— डेनिस
स्रोत

6

पर्ल, 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सफलतापूर्वक। मुझे यकीन नहीं है कि पर्ल के बारे में क्या कहना है ...

— डोम हेस्टिंग्स
स्रोत

आह, कि सफल के 3% के बारे में टिप्पणी eval! अच्छा है! ;-)

— दादा

@ दादा गंभीरता से! जवाब में प्रस्तुतियाँ वास्तव में काम करती हैं! मैं बहुत प्रभावित हुआ ...

— डोम हेस्टिंग्स

उम्मीद है, मैंने जो देखा है, वह सिर्फ आउटपुट से एक पूरे उद्धृत स्ट्रिंग ( 'या q//, q{}आदि) से आता है!

— दादा

@ दादा हां, या एक रेगेक्स मैच। हालांकि मुझे चकली बना दिया! :)

— डोम हेस्टिंग्स

1

आपको फिर से btw गोल्फ देखने के लिए खुश! :)

— दादा

4

जाप , 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

— ETHproductions
स्रोत

4

पायथ, 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

— KarlKastor
स्रोत

3

PHP, 71 140 110 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

उद्धरण चिह्नों के बिना कोड युक्त एक स्ट्रिंग बनाता है
और एक बार उपयोग करते हुए उद्धरण चिह्न ord
को समाप्‍त कर देता है (जैसा कि मैं स्ट्रिंग को दोगुना कर दूंगा और दो उद्धरण जोड़ूंगा);
इसके बाद यादृच्छिक वर्ण प्राप्त करने के लिए स्ट्रिंग की लंबाई पर दो बार लूप करता है।

संभवत: इसे और आगे बढ़ाया जा सकता है, लेकिन जहाँ अभी तक निरर्थक है, वहां मेरी कोशिशें जारी हैं।
मैं शायद यहां ज्यादा गहराई में नहीं जाऊंगा।

— टाइटस
स्रोत

1

The probability of each character is its frequency in the original source code.मैं गलत हो सकता हूं, लेकिन ऐसा नहीं लगता कि यह प्रविष्टि इस आवश्यकता को पूरा करती है।

— ETHproductions

ओह, मैं उस बिंदु से चूक गया। वापस संपादक के पास। कोड को पढ़े बिना यह कैसे हो सकता है?

— टाइटस

का उपयोग करते हुए इस , मैं एक मिल गया syntax error, unexpected '<'। लेकिन मैं PHP से परिचित नहीं हूं, मैं यह कैसे परीक्षण करूं?

— नॉनलाइनयरफोर्स

@NonlinearFruit: क्या आपने -d ध्वज का उपयोग किया है? यह किसी फ़ाइल में सहेजा जाना है और फिर किसी झंडे के साथ phpया उसके php-cgiबिना कॉल किया जाना चाहिए । शायद आप एक हेरेडोक का उपयोग कर सकते हैं।

— टाइटस

@NonlinearFruit: ... या इसके <?साथ उपयोग के लिए अग्रणी निकालें -d।

— टाइटस

3

पायथन 2, 88 बाइट्स

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

यह प्राप्त करने में सभी वास्तविक योग्यता mbomb007 को जाती है - आपकी मदद के लिए धन्यवाद (और बैकस्लैश के बारे में सूचक)

— user59421
स्रोत

1

यह एक क्वीन जैसी चुनौती है, बिना इनपुट या अपने स्रोत कोड को पढ़े (मान लीजिए कि यह nवर्ण लंबा है), आपको nयादृच्छिक अक्षरों को प्रिंट करने की आवश्यकता है । जहां किसी प्रतीक के cचुने जाने की संभावना बराबर होती है (number of times c occurs in your solution) / n।

— नॉनलाइनयरफोर्स

इस तरह से और अधिक? exec("""s = 'from random import choice; print "".join([choice(s) for c in s])'; exec(s)""")

— user59421

आपने अभी तक एकल उद्धरणों को शामिल नहीं किया है, और आपको चौकोर कोष्ठकों की आवश्यकता नहीं है join।

— mbomb007

धन्यवाद - और सही, मैं हल करने के लिए करीब nudging की भीड़ में थोड़ा पकड़ा

— user59421

1

यहाँ तुम जाओ s='''from random import*;print"".join(choice(s)for c in s+"s='';''exec s''")''';exec s:। काश मैं ऐसा सोचता।

— mbomb007

3

रूबी, 47 बाइट्स

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

यह मानक evalक्वीन पर आधारित है :

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

यह सबसे छोटी रानी की तुलना में लंबे समय तक बाइट है, लेकिन आमतौर पर सामान्यीकृत quines के लिए यह बेहतर विकल्प है, क्योंकि स्रोत कोड स्ट्रिंग पर किए गए किसी भी गणना की नकल करने की आवश्यकता नहीं है। जबकि सामान्य क्वीन में, प्रत्येक अतिरिक्त गणना को मुख्य स्ट्रिंग के अंदर और बाहर दोनों में जाने की आवश्यकता होती है, यह केवल इस तरह के क्वीन के लिए मुख्य स्ट्रिंग के अंदर की आवश्यकता होती है।

कोड वास्तव में क्या करता है: पूरे स्रोत कोड का प्रतिनिधित्व करने वाले एक स्ट्रिंग को प्राप्त करने के बाद, हम बस एक यादृच्छिक चरित्र का चयन करते हैं (एक यादृच्छिक सूचकांक का चयन करके) 47 बार और प्रत्येक वर्ण को अलग से प्रिंट करें।

— मार्टिन एंडर
स्रोत

3

वोल्फ्राम भाषा / गणितज्ञ, 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

अरे वो चौकोर कोष्ठक।

— चू Y
स्रोत

2

जेली, 44 बाइट्स

मुझे आशा है कि मैंने सभी नियमों की सही तरीके से व्याख्या की है (मुझे यकीन नहीं है कि मेटा में "कैरी पेलोड" क्या है या यदि यह इस चुनौती के लिए भी प्रासंगिक है)।

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

इसे TryItOnline पर देखें

यह एक स्ट्रिंग का निर्माण करता है जिसमें से पात्रों का चयन करना है। प्रारंभिक स्ट्रिंग में खुले और करीबी उद्धरणों को छोड़कर सभी वर्ण होते हैं । इसके बाद यह स्ट्रिंग दोगुनी हो जाती है और ऑर्डिनल्स के खुले और करीबी उद्धरणों में से प्रत्येक को समेटता है (इसलिए अन्य वर्णों को दोगुना करने की आवश्यकता होती है)। अंत में यह बार-बार रचित स्ट्रिंग से प्रोग्राम की लंबाई तक यादृच्छिक वर्ण चुनता है।

— जोनाथन एलन
स्रोत

1

@ नोनलीनियर भर्ती ओह - मैंने अपनी स्ट्रिंग से एक मिस्ड चरित्र जोड़ने के लिए अपडेट किया, लेकिन 44 में अपडेट नहीं किया - धन्यवाद!

— जोनाथन एलन

2

पाइके, 35 बाइट्स

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

यहाँ यह कोशिश करो!

जांच करने के लिए: अंतिम निकालें Hऔर परिणामस्वरूप स्ट्रिंग में प्रत्येक वर्ण की सही संख्या होती है (अतिरिक्त के साथ H)

यह एक सामान्यीकृत क्वीन का उपयोग नहीं करता है या वास्तव में एक क्वीन का उपयोग नहीं करता है। यह स्रोत के सभी पात्रों से युक्त एक स्ट्रिंग बनाने में सक्षम होने पर निर्भर करता है। यह किसी भी कोड के लिए करने में सक्षम होना चाहिए, लेकिन प्रत्येक वर्ण लॉगरिदमिक रूप से कोड आकार बढ़ाता है। किसी वर्ण को स्रोत में 2 या 7 बार अनुमति दी जाती है

— नीला
स्रोत

2

रूबी, 81 67 बाइट्स

मार्टिन के समाधान से कुछ चालें चोरी करके बाइट्स का एक गुच्छा बचाया

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

मुझे महसूस नहीं हुआ कि आपको हर बार बेतरतीब ढंग से चयन करना था; मुझे लगा कि कोई फेरबदल कर देगा। यह शायद गोल्फ हो सकता है, लेकिन यह सबसे छोटा है जो मुझे मिल सकता है।

कुछ संशोधनों के साथ स्टैण्डर्ड रूबी क्वीन इसलिए यह शिल्ड स्ट्रिंग को प्रिंट करती है। मुझे दुःख है क्योंकि पंद्रह मिनट लगने से पहले ही मुझे पता चल गया कि इससे पहले कि मैं अवचेतन रूप से चोरी कर रहा था, स्वरूपण की विचित्रताओं का पता लगा सकता था।

मुझे लगता है कि स्ट्रिंग फेरबदल को छोटा किया जा सकता है लेकिन मुझे नहीं पता कि कैसे; एक बार जब मैंने इसमें कुछ सोचा था, तो मैं प्रारूपण को छोटा करने में सक्षम हो सकता हूं। मदद की सराहना की जाएगी।

इसे ऑनलाइन आज़माएं!

— निधि मोनिका का मुकदमा
स्रोत

मुझे लगता है (मेरे सीजेएम की तरह) जवाब, यह आधार के रूप में एक मानक क्वीन का उपयोग करने के लिए आवश्यक नहीं है। मेरे CJam समाधान का एक सीधा बंदरगाह 64 बाइट्स देता है:64.times{$><<"64.times{$><<.inspect[rand 32]}".inspect[rand 32]}

— मार्टिन

कोई बात नहीं, इसे मानक क्वीन पर आधारित करना कम है, लेकिन आपको eval-based quine का उपयोग करना होगा:eval r="47.times{$><<('eval r=%p'%r)[rand 47]}"

— मार्टिन

@MartinEnder अपने स्वयं के उत्तर देने के लिए पर्याप्त अलग है, मुझे लगता है। यदि आप असहमत हैं, तो इसे मेरा में संपादित करने के लिए स्वतंत्र महसूस करें, लेकिन इस बीच मैं खान में कुछ बाइट्स बचाने के लिए आपसे कुछ ट्रिक्स चुरा लूंगा।

— निधि मोनिका का मुकदमा

2

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

सी, गोल्फ के लिए 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);}

— VOLAND
स्रोत

यह नहीं होना चाहिए? शायद मुझे इस क्विज के नियम समझ नहीं आ रहे हैं। मेरी fस्ट्रिंग और मानक आउटपुट के लिए प्रिंट लेती है: स्ट्रिंग वर्णों का कोई भी अनुक्रम हो सकता है।

— VolAnd

@NonlinearFruit संभावनाओं की गणना नहीं की गई है, लेकिन अभिव्यक्ति rand()%LENGTH_OF_STRINGद्वारा दिए गए सामान्य वितरण के साथ उस चरित्र की संभावना के अनुसार चरित्र लेते हैं rand()। शायद, मुझे quineC .... के लिए दृष्टिकोण समझ में नहीं आता है

— VolAnd

+1 नया समाधान लगभग सही है। sबस शामिल करने की जरूरत है char*s="";। मुझे लगता है कि ऐसा कुछ char*s="char*s=l,i;f(){l=i=strlen(s);while(i--)putchar(s[rand()%l]);};+''"+'""'ऐसा होगा (लेकिन मैं सी से परिचित नहीं हूं)।

— NonlinearFruit

यदि उत्तर अपनी वर्तमान स्थिति में मान्य नहीं है, तो उसे हटा दिया जाना चाहिए।

— mbomb007

@ mbomb007 क्या आप अपने निर्णय की व्याख्या कर सकते हैं और संभवतः सलाह देने के लिए आ सकते हैं?

— VolAnd

2

जावास्क्रिप्ट, 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]))

नोट: केवल फ़ायरफ़ॉक्स के उपयोग के कारण काम करता है 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

— ETHproductions
स्रोत

मैं अब वास्तव में हैरान हूं कि यह पर्ल में अधिक वैध कोड का उत्पादन करता है जितना कि यह जेएस में दिखता है! यहाँ उतने मज़ेदार शब्द नहीं हैं, सिवाय इसके gtraoanकि लगभग एक कराह मुझे लगता है ...

— डोम हेस्टिंग्स

1

@DomHastings खैर, पर्ल जेएस की तुलना में विराम चिह्न का एक हिस्सा है;)

— ETHproductions

निश्चित रूप से! यह विराम चिह्नों के विस्फोट से अधिक विराम चिह्नों के कारखाने में है! लेकिन मुझे काफी पसंद है!

— डोम हेस्टिंग्स 21

क्या "दिखाने की संभावना है?

— नॉनलाइनयरफ्रूट 21

1

@NonlinearFruit यप। पहले, दूसरे और अंतिम उदाहरण के आउटपुट में कम से कम एक है।

— ETHproductions

1

पायथन 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 की याद दिलाता है।

— mbomb007
स्रोत

1

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

PowerShell चूसना में Quines, क्योंकि स्ट्रिंग रिप्लेसमेंट delimiters {}भी लूप और व्हाट्सएप को निरूपित करते हैं, इसलिए आपको ऑपरेटर में एस के एक गुच्छा का उपयोग करने की आवश्यकता है , जो कोड को ब्लॉट करता है।char-f

हर लाइन जवाब पर मेरे Quine के समान । मूल रूप से हम पाश0 के लिए 174और प्रत्येक यात्रा फिर से कैलकुलेट Quine $d, एक के रूप में यह डाली char-array, और एक को बाहर खींच Randomतत्व इनपुट से समान रूप से चुना गया है। परिभाषा के अनुसार, यह (occurrences in source) / (length of source)आवश्यकतानुसार संभाव्यता देता है । उन पात्रों को Parens में एनकैप्सुलेट किया गया है और -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 वां भी है चुने जाने का मौका।)

— AdmBorkBork
स्रोत

1

दिल्लोग एपीएल , 20 बाइट्स

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

f←{... }परिभाषित करें रूप में च

(,⎕CR'f')सूचीबद्ध ( ,) सी हैचर (तालिका) आर epretation ( ⎕CR) की एफ ( 'f')

[?⍴⍨20]( [... ]) यादृच्छिक-अप-टू (के साथ अनुक्रमित )? ) दोहराने-ही-बार (⍴⍨ बीस) का

हमें इसे (एक डमी तर्क के साथ) कुछ बार चलाएं:

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

ठीक है, लेकिन क्या वितरण सही है? आइए हम इसे 10,000 डमी तर्क पर चलाते हैं और देखते हैं कि प्रत्येक वर्ण कितनी बार होता है:

      {⍺ , 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⁻⁴ बार

⍴⍵ सही-तर्क (घटना सूचकांकों) का आकार, अर्थात कई बार ऐसा होता है

अंत में, ⌸यह सब एक साथ एक तालिका में रखता है।

— एडम
स्रोत

1

सी #, 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

— Yodle
स्रोत

@NonlinearFruit धन्यवाद, वह स्थान चूक गया। इसका मतलब यह भी है कि मैं एक फ़ॉरच लूप का उपयोग नहीं कर सकता, जो कुछ बाइट्स जोड़ता है :( हालांकि, मुझे लगता है कि मेरे पास "है" स्ट्रिंग में बच गए उन दो उद्धरणों के साथ सही रूप से शामिल है, क्योंकि वे आउटपुट में कुछ बार दिखाई देते हैं, जब तक कि मैं ' मुझे उनका उपयोग कहीं और याद आ रहा है।

— योडल

आह, मुझे लगा कि अगर वे स्ट्रिंग में हैं, तो मेरी गिनती खराब नहीं है। थोड़े में तय करेंगे।

— Yodle

ठीक है, अब भी दिखाई देते हैं!

— Yodle

1

हम्म, दिलचस्प समस्या तब। बस \\ नहीं जोड़ सकते हैं या मैं हमेशा एक छोटा रहूँगा। मैं इसके बजाय ascii कोड का उपयोग करूँगा।

— Yodle

(new Random()).Next(0,134)]काम करता है ? यह एक युगल बाइट्स को बचाएगा।

— नॉनलाइनरफोर्स

1

सी, 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 संभावना है।

स्ट्रिंग के अंदर प्रतीकों का क्रम मायने नहीं रखता है।

अशुद्ध स्रोत कोड

विशिष्टता

उदाहरण

CJam , 14 बाइट्स

व्याख्या

जेली , 13 बाइट्स

यह काम किस प्रकार करता है

पर्ल, 59 बाइट्स

प्रयोग

जाप , 22 बाइट्स

यह काम किस प्रकार करता है

पायथ, 16 बाइट्स

PHP, 71 140 110 110 124 140 120 बाइट्स

रूबी, 47 बाइट्स

वोल्फ्राम भाषा / गणितज्ञ, 109 बाइट्स

जेली, 44 बाइट्स

पाइके, 35 बाइट्स

रूबी, 81 67 बाइट्स

जावास्क्रिप्ट, 128 बाइट्स

पायथन 3, 134 132 बाइट्स

उदाहरण आउटपुट:

PowerShell v2 +, 175 बाइट्स

उदाहरण

दिल्लोग एपीएल , 20 बाइट्स

सी #, 277 280 268 बाइट्स।

सी, 136 बाइट्स