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

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

Приклади:

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

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

Будь ласка, включіть у відповідь пару результатів.

Виграє найкоротше рішення. Я дам невеликий бонус, виходячи з кількості голосів, тому, будь ласка, проголосуйте за найбільш креативні рішення.

Python → Brainf * 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 Символи : стиснення оператора if у циклі while.
• 255 → 233 Персонажі : Реалізовано пропозиції JBernardo з коментарів.
• 233 → 223 Персонажі : Реалізовано пропозицію Т.еко з коментарів.
• 223 → 185 Персонажі : Реалізовано кілька пропозицій щодо зменшення пробілів у коментарях.

Приклади

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

Власне, з'ясування того, що роблять результати BF , залишається читачеві вправою.

Python -> Piet, 385 345 char

З цим можна створити будь-яку програму Piet. Я міг просто зупинитися на випадкових пікселях, але хотів зробити "цікаві" програми. Функція mмалює піксель кольором і рекурсивно крокує до кожного з цих пікселів-сусідів. Є кращі способи намалювати випадкові краплі, але це налаштовано на припинення в розумній кількості кроків, тому це досить добре для гольфу. Функція R(w,h,n)малює n випадкових крапель на ( w x h ) біле зображення і друкує результат у форматі PPM.

Я особливо пишаюся тим, як генерую кольори - для випадкового вибору 0 <= c < 20,

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

- це десятковий код для дійсного кольору в палітрі Piet за допомогою однодорожного коду сірого кольору . Тобто кожен колір представлений 3 суміжними бітами, і кожен фрагмент '0003...0'[c:c+3]являє собою інший колір. Оскільки це не повний список з 27 слів на 3 букви, я дуже пощастив у пошуку коду Грея.

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 символів довше) ... хоча я не зовсім впевнений, чому (і не страшно схильний це з'ясувати).

Python -> Python, 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

Python -> HQ9 +: 108 символів

import random
def g(): return ''.join([random.choice(['H','Q','9','+']) for x in range(random.randint(1,9))])

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

Безумовно

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

scala: 1543 (scala => scala)

У мене є змінні (x, y, z), функції (mul, add, neg, 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

Perl -> оболонка: 66 символів

@ p = розділити (':', $ ENV {PATH});
@ c = `ls @p [@ARGV [0]]`;
print @c [rand ($ # c)];

Можливо, трохи поза темою, але, можливо, так.

s153254 @ helios: / home / s153254 / lab $ perl code.p 1
telnet
s153254 @ helios: / home / s153254 / lab $ perl code.p 2
in.rlogind
s153254 @ helios: / home / s153254 / lab $ perl code.p 2
df
s153254 @ helios: / home / s153254 / lab $ perl code.p 3
svenv

Ruby → Brainfuck ( 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

Випускає виконувану програму brainfuck.

Начебто безсоромний зрив ESultanik, тому я буду йому вдячний за цю ідею.

• Змінено .zero? до == 0

Javascript -> Brainf * ck: 119 символів

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

Зразок вводу / виводу:

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

Код, безумовно, може бути коротшим, але деякі речі, IMHO, зробили б його менш цікавим. Але якщо хтось інший придумає коротшу програму, я скорочу більше.

Python -> Python, 148 символів

Довше, ніж інші записи Python за рахунок того, щоб бути (суб'єктивно) трохи цікавішим.

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__

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

Пітон -> Фрактран (117)

import random as r,sys
r.seed(int(sys.argv[1]))
z=r.randint
print','.join(`z(1,99)`+'/'+`z(1,99)`for q in[0]*z(1,99))

Мова виробника ігор -> Arduino або Ti84-Basic, 6 ³ символи

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 виводить випадкові речі з випадковими інтервалами, випадковим чином пропускаючи випадкові речі.

Програма Ti-Basic малює горизонтальні лінії, як божевільні.

Також є бонус - згенеровані програми вже в гольф! Не впевнений, чи це було б корисно ...

Perl -> HQ9 + (42 символи)

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

Приклад введення

4264532623562346

Вихідні дані

Q

JavaScript -> Javascript (44 символи)

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

І, маючи 43 символи, він може виконати створену програму, а не відображати її джерело:

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

Приклади:

Насіння: 5
Виконано 3 рази:

alert("2.335241624386981")
alert("0.4577956395223737")
alert("0.8359265828039497")