अपनी पसंदीदा भाषा में एक यादृच्छिक कार्यक्रम बनाएं [बंद]

21

हम सभी ने बेतरतीब ढंग से उत्पन्न इनपुट का उपयोग करके परीक्षण संकलक के बारे में सुना। आपका कार्य अपनी पसंदीदा भाषा में एक वैध कार्यक्रम (बिना अपरिभाषित व्यवहार सहित) उत्पन्न करने के लिए एक कार्यक्रम लिखना है। जनरेटिंग प्रोग्राम लैंग्वेज को जेनरेट प्रोग्राम लैंग्वेज के समान नहीं होना चाहिए।

आपके प्रोग्राम को एक पूर्णांक प्राप्त होगा जो तर्क के रूप में आप अपने यादृच्छिक संख्या जनरेटर के लिए बीज के रूप में उपयोग कर सकते हैं। उत्पन्न कार्यक्रमों को संरचनात्मक रूप से अलग होना चाहिए (अलग-अलग बीज दिए गए हैं) न केवल अलग-अलग चर नाम या स्थिरांक।

उदाहरण:

$ ./generate 1
int main() { return 0; }

$ ./generate 2
#include <math.h>
int main() { return (int) pow(4, 3); }

कृपया अपने उत्तरों में कुछ आउटपुट शामिल करें।

सबसे छोटा समाधान जीतता है। मैं वोटों की संख्या के आधार पर एक छोटा सा बोनस दूंगा, इसलिए कृपया सबसे रचनात्मक समाधानों को वोट करें।

code-golf  generation 
— एलेक्ज़ेंड्रु
स्रोत
2
ओपन-एंडेड विकास के साथ आनुवंशिक एल्गोरिदम विकसित करने के लिए सही कार्य। मैंने हमेशा सोचा है कि यह कैसे किया जा सकता है।
— मेलमोकब
1
मुझे लगता है कि एक निश्चित विनिर्देश की कमी यह एक बुरा प्रश्न बनाती है। "संरचनात्मक रूप से अलग" व्याख्या के लिए खुला है, और कुछ व्याख्याओं में यह एक बहुत ही सरल समस्या है।
— पीटर टेलर
1
सभी को वास्तव में करने की ज़रूरत है एक कार्यक्रम है जो किसी दिए गए BNF व्याकरण (यह तुच्छ है) से एक यादृच्छिक वाक्य उत्पन्न कर सकता है। फिर किसी अन्य प्रोग्रामिंग भाषा और पूफ के लिए व्याकरण में बस प्लग करें : उस भाषा में एक वैध कार्यक्रम। यह किसी भी संदर्भ-मुक्त भाषा के लिए काम करेगा (जो दुर्भाग्य से पर्ल से बाहर निकलता है)।
— अगस्त को ESultanik
2
main(seed) { return 4; // Chosen by dice roll - Guaranteed to be random } संदर्भ
— नील
1
नील: बस ध्यान दें: शायद यहाँ हर कोई xkcd को जानता है, विशेष रूप से जुड़ा हुआ। वे शायद यादृच्छिक संख्याओं पर दिलबर्ट को भी जानते हैं। और यहाँ इसकी कोई प्रासंगिकता नहीं है क्योंकि यह एक यादृच्छिक संख्या के साथ एक कार्यक्रम के लिए पूछ रहा है, न केवल एक यादृच्छिक संख्या।
— जॉय

जवाबों:

18

पायथन → ब्रेनफ़ * ck (185 223 233 255 285 287 303 वर्ण)

कोड

import random as r,sys
r.seed(int(sys.argv[1]))
c=list('<>.,+-')+['']
n=9/r.random()
def b():
 global n
 s=''
 while n>0:n-=1;o=r.choice(c);s+=o if o else'[%s]'%b()
 return s
print b()
  • 303 → 287 वर्ण : हटाया गया math.ceil(यह वास्तव में आवश्यक नहीं है)।
  • 287 → 285 वर्ण : शाखा ऑपरेटर को निरूपित करने के लिए एक खाली स्ट्रिंग पर स्विच किया गया।
  • 285 → 255 वर्ण : जबकि लूप में दिए गए कथन को संघनित किया गया है।
  • 255 → 233 वर्ण : टिप्पणियों से JBernardo के सुझावों को लागू किया गया।
  • 233 → 223 वर्ण : टिप्पणियों से लागू किया गया tjko का सुझाव।
  • 223 → 185 वर्ण : टिप्पणियों से कुछ व्हाट्सएप कटौती सुझावों को लागू किया।

उदाहरण

$ python generate.py 1
-->,,+-<<-,-<,->[[<<,[.>.<>,,>>>,.<-,+>[[<.-+[.-+.+[-,+<>-.>,++.,,-,.,<<+[+]]]]]]]]
$ python generate.py 2
[<<--+.+++>]
$ python generate.py 3
,.++<<->>[,-,+>+[,-+<-+.<[,-[+[.-,[[<<>[,+.]]]]]]]]

वास्तव में यह पता लगाना कि परिणामी बीएफ कार्यक्रम क्या करते हैं, पाठक को एक अभ्यास के रूप में छोड़ दिया जाता है।

— ESultanik
स्रोत
तुम भी उपयोग कर सकते हैंif o: s+=0(NL)else: s+='['+b()+']'
— अलेक्जेंड्रू
@Alexandru: धन्यवाद! मैंने यह खो दिया। आपका कोड ठीक काम नहीं करता था, लेकिन इससे मुझे इसे छोटा करने में मदद मिली।
— १
3
क्या इसका मतलब यह है कि ब्रेनफक आपकी पसंदीदा भाषा है?
— 2
1
ऐसा नहीं है कि यह एक समस्या है, लेकिन आउटपुट कोड संभवतः अनंत लूप का कारण होगा।
— पीटर ओल्सन
6
@ पेटर, सच है, लेकिन इस बात से बचना कि रैंडम जनरेशन के इस तरीके का इस्तेमाल करना हॉल्टिंग प्रॉब्लम को हल करने के बराबर है!
— ESultanik
17

पायथन -> पीट, 385 345 चार

इसके साथ किसी भी Piet कार्यक्रम को उत्पन्न करना संभव है। मैं बस यादृच्छिक पिक्सेल पर रोक सकता था, लेकिन मैं "दिलचस्प" कार्यक्रम बनाना चाहता था। फ़ंक्शन mएक पिक्सेल रंग को पेंट करता है, और उस पिक्सेल पड़ोसियों में से प्रत्येक में पुनरावृत्ति करता है। यादृच्छिक बूँदें खींचने के लिए बेहतर तरीके हैं, लेकिन यह उचित संख्या में चरणों को समाप्त करने के लिए तैयार है, इसलिए यह गोल्फ के लिए पर्याप्त है। फ़ंक्शन n ( w x h ) श्वेत चित्र पर n यादृच्छिक ब्लब्स R(w,h,n)खींचता है , और PPM प्रारूप में परिणाम प्रिंट करता है।

के एक यादृच्छिक चुनाव के लिए - मैं कैसे मैं रंग उत्पन्न की विशेष रूप से गर्व है 0 <= c < 20,

`[0,192,255][int(x)]`for x in'0002212220200101121100'[c:c+3]

एकल ट्रैक ग्रे कोड के माध्यम से पीट पैलेट में एक वैध रंग के लिए दशमलव कोड है । यही है, प्रत्येक रंग को 3 आसन्न बिट्स द्वारा दर्शाया जाता है, और प्रत्येक टुकड़ा '0003...0'[c:c+3]एक अलग रंग का प्रतिनिधित्व करता है। चूंकि यह 3 अक्षरों पर 27 शब्दों की पूरी सूची नहीं है, इसलिए मुझे वास्तव में ग्रे कोड ढूंढने में सफलता मिली।

from random import*
r=randint
def R(w,h,n):
 M=[6]*h*w
 def m(x,y,c,d):M[y%h*w+x%w]=c;t=r(0,15)*(r(0,d)<2);t&8and m(x+1,y,c,d+1);t&4and m(x-1,y,c,d+1);t&2and m(x,y+1,c,d+1);t&1and m(x,y-1,c,d+1)
 while n:m(r(0,w),r(0,h),r(0,19),0);n-=1
 print"P3 %s %s 255 "%(w,h)+' '.join(`[0,192,255][int(x)]`for c in M for x in'0002212220200101121100'[c:c+3])

नमूना आउटपुट, कमांड द्वारा उत्पन्न R(30,40,500)

यादृच्छिक पीट कार्यक्रम

आयात के बिना, मैं इसे एक उचित (अर्धविराम-मुक्त) 1-लाइनर के रूप में भी लिख सकता हूं:

import random
R=(lambda P,I,E,T:lambda w,h,n:E(w,h,I(w,h,n,lambda z,c,d,t:sum((((z,c),)*t*T(0,1)or m((z[0]+a,z[1]+b),c,d+1,T(0,d)>1)for a,b in((0,1),(1,0),(-1,0),(0,-1))),()))))(range,lambda w,h,n,m:dict(sum((m((T(0,w),T(0,h)),T(0,19),0,0)for _ in P(n)),())),lambda w,h,M:"P3 %s %s 255 "%(w,h)+' '.join(' '.join(`(x&1)*255+(x&2)*96`for x in map(int,'0001121110100202212200'[c:c+3]))for c in(M[z]if z in M else 6for z in((x,y)for y in P(h)for x in P(w)))),random.randint)

लेकिन यह हास्यास्पद रूप से धीमा है (और लगभग 100 वर्ण लंबा) ... हालांकि मुझे पूरी तरह से यकीन नहीं है कि (और यह पता लगाने के लिए बहुत इच्छुक नहीं है)।

— boothby
स्रोत
9

पायथन -> पायथन, 135 वर्ण

import random,sys
random.seed(int(sys.argv[1]))
R=range(9)
print'print 1'+''.join(random.choice('+*')+'%d'%random.choice(R)for x in R)

इस तरह थोड़ा यादृच्छिक अभिव्यक्ति मूल्यांकन उत्पन्न करता है:

> ./genprogram.py 1
print 1+7*2+4*7+0*3*0+6+8
> ./genprogram.py 2
print 1*8+0*6*2*5*1+3*8*4
> ./genprogram.py 3
print 1+4+5*0+7+2*4*4*1*7
> ./genprogram.py 4
print 1+0+1+3*7*1*2+0+8*7
— कीथ रान्डेल
स्रोत
8

पायथन -> एचक्यू 9 +: 108 चार्ट

import random
def g(): return ''.join([random.choice(['H','Q','9','+']) for x in range(random.randint(1,9))])
— zhazam
स्रोत
6

PHP, 352 वर्ण

PHP में PHP कोड उत्पन्न करता है।

मैंने तय किया कि मुझे लंबाई के बारे में ज्यादा परवाह नहीं है, लेकिन इसके बजाय समाधान का एक दिलचस्प और विविध सेट चाहता था। यह मेरा जवाब है।

कोड

<?php mt_srand(0+$argv[1]);$r=mt_rand(1,100);$s="\$i=rand(1,$r);";while($r>0){$s.='$i';if(!($r%10))$s.='*=2;';if(!($r%9))$s.='++;';if(!($r%8))$s.='=pow($i,rand(1,$i));';if(!($r%7))$s.='--;';if(!($r%6))$s.='=substr($i,0,2);';if(!($r%5))$s.='/=2;';if(!($r%4))$s.='+=4;';if(!($r%3))$s.='*=-1;';$r-=mt_rand(1,5);}$s.='var_dump($i);';echo"<?php $s
";

Ungolfed

<?php
mt_srand(0+$argv[1]);
$r = mt_rand(1,100);
$s = "\$i=rand(1,$r);";
while ($r > 0)
{
    if (!($r%10)) $s .= '$i*=2;';
    if (!($r%9))  $s .= '$i++;';
    if (!($r%8))  $s .= '$i=pow($i,rand(1,$i));';
    if (!($r%7))  $s .= '$i--;';
    if (!($r%6))  $s .= '$i=substr($i,0,2);';
    if (!($r%5))  $s .= '$i/=2;';
    if (!($r%4))  $s .= '$i+=4;';
    if (!($r%3))  $s .= '$i*=-1;';
    $r -= mt_rand(1,5);
}
$s .= 'var_dump($i);';
echo "<?php $s
";

उदाहरण

> php r.php 1
<?php $i=rand(1,58);$i*=-1;$i=pow($i,rand(1,$i));$i=substr($i,0,2);$i+=4;$i*=-1;$i=pow($i,rand(1,$i));$i=substr($i,0,2);$i+=4;$i*=-1;$i*=2;$i/=2;$i+=4;$i/=2;$i*=-1;$i*=2;$i/=2;$i=substr($i,0,2);$i*=-1;var_dump($i);
> php r.php 2
<?php $i=rand(1,57);$i*=-1;$i+=4;$i--;$i=substr($i,0,2);$i*=-1;$i*=-1;$i--;$i+=4;$i/=2;$i++;$i=substr($i,0,2);$i*=-1;$i=pow($i,rand(1,$i));$i+=4;$i--;$i=substr($i,0,2);$i+=4;$i*=-1;$i--;$i+=4;var_dump($i);
— rintaun
स्रोत
2
क्या आप कृपया एक आउटपुट उदाहरण शामिल कर सकते हैं?
— अलेक्जेंड्रू
5

scala: 1543 (scala => scala)

मेरे पास चर (x, y, z), फ़ंक्शन (mul, add, negative, abs), मान और संतुलित कोष्ठक हैं। 

<!--code:language-scala-->
object FormelBauer {
    val fun = List (" mul10 (", " add1 (", " neg (", " abs (")
    val ops = List (" * ", " + ", " - ", " / ")
    def c(maxLen: Int, m: Int) : String = {
        def f()= new StringBuffer (fun (r.nextInt (fun.length)))
        def w()= new StringBuffer ("" + (r.nextInt (180) - 90))
        def v()= new StringBuffer ("" + ('x' + r.nextInt (3)).toChar)
        def o()= new StringBuffer (ops (r.nextInt (ops.length)))
        def g(t: Int, b: Int, d: List [Char]) : StringBuffer ={
            var a = d.filterNot (x => if (b > 0) x == '.' else x == ')')
            if (b > m) a = a.filterNot (_ == 'k')
            if (b > m) a = a.filterNot (_ == 'f')
            if (t > maxLen) a = a.filterNot (_ == '+')
            val elem = r.nextInt (a.length)
            val start = a(elem)
            start match {
                case '.' => new StringBuffer ("")
                case 'f' => f.append(g (t + 1, b + 1, List ('(', '8', 'x')))
                case '(' => new StringBuffer ("(").append   (g (t + 1, b + 1, List ('(', '8', 'x')))
                case '8' => w.append(g (t + 1, b, List ('.', ')', '+')))
                case 'x' => v.append(g (t + 1, b, List ('.', ')', '+')))
                case ')' => new StringBuffer (") ").append  (g (t + 1, b -1, List ('.', ')', '+')))
                case '+' => o.append(g (t + 1, b, List ('f', '(', '8', 'x')))
        }}
        (g (0,0,List('f','(','8','x'))).toString
    }
import util._
  var r : Random = _    
    def main (as: Array [String]) : Unit = {
      val s=as(0).toInt
        r=new Random(s) 
        "xyz".map(c=>println("val "+c+"="+(c+r.nextInt(s))))
        println("""def mul10(i:Int)=10*i
def add1(i:Int)=i+1
def neg(i:Int)= -i
def abs(i:Int)=if(i<0)-i else i
"""+c(45,5))}
}

जैसा कि आप देखते हैं, यह बहुत गोल्फ नहीं है। क्योंकि, यह मुझे अन्य समाधानों के करीब नहीं पहुंचाएगा, लेकिन एक समस्या यह है, कि अधिक भिन्नता से अधिक खर्च होता है। उदाहरण के लिए, 3 चर, 4 कार्य आसानी से कम किए जा सकते हैं।

कुछ नमूने उत्पन्न करना:

for i in {1..7} ; do scala FormelBauer $i; echo; done

val x=120
val y=121
val z=122
def mul10(i:Int)=10*i
def add1(i:Int)=i+1
def neg(i:Int)= -i
def abs(i:Int)=if(i<0)-i else i
(y)  / 79

val x=121
val y=121
val z=123
def mul10(i:Int)=10*i
def add1(i:Int)=i+1
def neg(i:Int)= -i
def abs(i:Int)=if(i<0)-i else i
 add1 ((((78 +  neg (z * z) )  / x) ) )  + -23 - ((-83)  * y) 

val x=122
val y=123
val z=122
def mul10(i:Int)=10*i
def add1(i:Int)=i+1
def neg(i:Int)= -i
def abs(i:Int)=if(i<0)-i else i
x / -71 - (y) 

val x=122
val y=124
val z=125
def mul10(i:Int)=10*i
def add1(i:Int)=i+1
def neg(i:Int)= -i
def abs(i:Int)=if(i<0)-i else i
x

val x=122
val y=123
val z=126
def mul10(i:Int)=10*i
def add1(i:Int)=i+1
def neg(i:Int)= -i
def abs(i:Int)=if(i<0)-i else i
-24 + z

val x=121
val y=121
val z=124
def mul10(i:Int)=10*i
def add1(i:Int)=i+1
def neg(i:Int)= -i
def abs(i:Int)=if(i<0)-i else i
 abs (z) 

val x=123
val y=126
val z=126
def mul10(i:Int)=10*i
def add1(i:Int)=i+1
def neg(i:Int)= -i
def abs(i:Int)=if(i<0)-i else i
 add1 (-62 - 30 * (-68)  /  neg (x - 69 + 33 / 45 + x * x)  -  abs (-18 * (y + x)  /  neg (x)  - y)  *  abs ((61) ) )  + (y)

सबसे लंबे समय तक परीक्षण:

add1 (-62 - 30 * (-68)  /  neg (x - 69 + 33 / 45 + x * x)  -  abs (-18 * (y + x)  /  neg (x)  - y)  *  abs ((61) ) )  + (y)

res6: Int = -5425

— अज्ञात उपयोगकर्ता
स्रोत
5

पर्ल -> खोल: 66 वर्ण

@ पी = विभाजन ( ':', $ ENV {पथ});
@ c = `ls @p [@ARGV [0]]`;
प्रिंट @c [रैंड ($ # c)];

संभवतः थोड़ा बंद विषय है, लेकिन शायद ऐसा है।

s153254 @ हेलिओस: / होम / s153254 / प्रयोगशाला $ perl code.p 1
टेलनेट
s153254 @ हेलिओस: / होम / s153254 / प्रयोगशाला $ perl code.p 2
in.rlogind
s153254 @ हेलिओस: / होम / s153254 / प्रयोगशाला $ perl code.p 2
df
s153254 @ हेलिओस: / होम / s153254 / प्रयोगशाला $ perl code.p 3
svenv
— एंथोनी
स्रोत
4

रूबी → ब्रेनफक ( 110 107 वर्ण)

s="";m=%w:< > . , + -:;rand(99).downto(r=0){s<<(rand(40)==0? (r+=1)&&'[%s':'%s')%m.shuffle[0]};p(s<<']'*r)

प्रयोग

$ ruby bf.rb

एक निष्पादन योग्य ब्रेनफक प्रोग्राम का उत्पादन करता है।

ESultanik की एक बेशर्म चीरफाड़ की तरह, तो मैं उसे इस विचार के लिए श्रेय दूंगा।

  • बदल गया है। से == ०
— incluye
स्रोत
3

जावास्क्रिप्ट -> ब्रेनफ * ck: 119 वर्ण

s=prompt();a=["+","-",">","<",".",",","[-]"];i=0;b="";while(i++<s*s){b+=a[Math.floor(((Math.random()*s)%1)*7)]}alert(b)

नमूना I / O:

10
.--.+,-><->.<+.[-].->.>[-][-]<+,[-]>><-[-]>,,>>[-].-+<[-]+>,<[-][-]<<[-]<[-]+,+[-][-][-].-[-],[-]>.<<[-]-..<-.->.++,>+-[-],.[-]..+,<-[-].+-[-]
11
,..[-]--,[-].,[-]>[-]->..[-]<,<..>[-]<>++-.[-].,,<[-].<+<[-]>-->[-]+-[-]+>-[-][-]>-,[-]->>-,-..++<+,,-,.,[-]->[-]<,+[-][-]+.,-,>+->.[-],.>..,++,.[-],+[-]-,.,--.--,

कोड निश्चित रूप से कम हो सकता है, लेकिन कुछ चीजें, IMHO, इसे कम दिलचस्प बना देंगी। लेकिन अगर कोई और छोटा कार्यक्रम लेकर आता है, तो मैं और कटौती करूंगा।

— पीटर ओल्सन
स्रोत
2

पायथन -> अजगर, 148 वर्ण

(अधिक) थोड़ा और दिलचस्प होने की कीमत पर अन्य पायथन प्रविष्टियों की तुलना में लंबा।

import sys as s,random as r
w,o=s.stdout.write,__builtins__
r.seed(s.argv[1])
w('print\\')
for i in'\n....':n=r.choice(dir(o));o=getattr(o,n);w(i+n)

यह बिल्ट-इन ऑब्जेक्ट की एक गहरी नेस्टेड विशेषता को प्रिंट करता है।

$ python randprog.py 1
print\
round.__setattr__.__delattr__.__init__.__class__
— Fraxtil
स्रोत
2

PowerShell, PowerShell - 43 का निर्माण

कीथ के समाधान की भावना में:

-join(0.."$input"|%{'-','+'|random;random})

जोड़ और घटाव के यादृच्छिक भाव उत्पन्न करता है:

PS> -join(0..(random 9)|%{'-','+'|random;random 9})
+2-0-0+3-7
PS> -join(0..(random 9)|%{'-','+'|random;random 9})
-7+1+7+1-5+2+8
PS> -join(0..(random 9)|%{'-','+'|random;random 9})
-1+7+7-0-6-0-2
PS> -join(0..(random 9)|%{'-','+'|random;random 9})
+2-6-5+3-2+7
PS> -join(0..(random 9)|%{'-','+'|random;random 9})
-6
— एक छोटा सा सिक्का
स्रोत
एक gcm|random -c @args|% na*
— पॉवर्सशेल
2

गेम मेकर लैंग्वेज -> Arduino या Ti84- बेसिक, 6 3 अक्षर

a=argument0;if a mod 2{return("void setup(){Serial.begin(9600);}void loop(){Serial.print"+string(a*random(9))+";delay("+string(floor(random(999)))+")}"}else{return(":Lbl A:Horizontal "+string(a*random(9))+":Goto A")}

स्पष्टीकरण:

a=argument0 इनपुट को चर में डालता है a

if a mod 2 मूल रूप से, आधा मौका Arduino, आधा Ti-Basic 84 होगा

Arduino प्रोग्राम यादृच्छिक अंतराल पर यादृच्छिक सामान, यादृच्छिक रूप से यादृच्छिक चीजों को छोड़ देता है।

टीआई-बेसिक प्रोग्राम पागलों की तरह क्षैतिज रेखाएँ खींचता है।

इसके अलावा, एक बोनस है - उत्पन्न कार्यक्रम पहले से ही गोल्फ हैं! यकीन नहीं होता कि मददगार होगा ...

— Timtech
स्रोत
1

Perl -> HQ9 + (42 वर्ण)

$a="HQ9+";for(1..<>%4){chop$a}print chop$a

उदाहरण इनपुट

4264532623562346

उत्पादन

Q
— PhiNotPi
स्रोत
1

जावास्क्रिप्ट -> जावास्क्रिप्ट (44 अक्षर)

alert('alert("'+Math.random()*prompt()+'")')

और 43 वर्णों के साथ , यह उत्पन्न स्रोत को प्रदर्शित करने के बजाय इसे निष्पादित कर सकता है।

eval('alert("'+Math.random()*prompt()+'")')

उदाहरण:

बीज: 5
निष्पादित 3 बार:

alert("2.335241624386981")
alert("0.4577956395223737")
alert("0.8359265828039497")
— user1886419
स्रोत
बीज कहां है?
— दरवाज़े
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.