Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

[Berserker]

I made a self-modifying Python program.

Code: [Select]

A = 1

selfname = 'program.py'

print 'Self-modifying program'
print 'This program has been started '+str(A)+' times.'

# Read the program into a list
prog = [line.rstrip() for line in open(selfname)]

# Modify the first line
prog[0] = "A = "+str(A+1)

# Write the modified program back to the file
out = open(selfname,'w')
for line in prog:
    out.write(line + '\n')

out.close()

raw_input("Press any key to quit.")



[alfie275]

SKYNET!!! Kill it with fire!!!!!

[timmeh]

SKYNET!!! Kill it with fire magma!!!!!

Fix'd, this is the DF forum after all

That's awesome though Berserker!  What would be really crazy would be making the program recursive.  I.E. It starts itself again after it modifies itself, until A==5 or something.  I'll have to get python set back up on my computer once I get it back from repairs, I can think of some really weird things to do with that sort of program...

[Berserker]

Executing code on someone else's computer.

[alfie275]

This program would probably break itself on first run:

Code: [Select]

selfname = 'program.py'
import random

print 'Self-modifying program'


# Read the program into a list
prog = [line.rstrip() for line in open(selfname)]

max = random.randrange(0, 5)
num = 0
while num < max:
# Modify a random line
line = random.randrange(0,len(prog)
prog[line][random.randrange(0,len(prog[line]))] = random.randrange(32,125)
num = num + 1

# Write the modified program back to the file
out = open(selfname,'w')
for line in prog:
    out.write(line + '\n')

out.close()

raw_input("Press any key to quit.")

[/quote]

[eerr]

This program would probably break itself on first run:

Code: [Select]

selfname = 'program.py'
import random

print 'Self-modifying program'


# Read the program into a list
prog = [line.rstrip() for line in open(selfname)]

max = random.randrange(0, 5)
num = 0
while num < max:
# Modify a random line
line = random.randrange(0,len(prog)
prog[line][random.randrange(0,len(prog[line]))] = random.randrange(32,125)
num = num + 1

# Write the modified program back to the file
out = open(selfname,'w')
for line in prog:
    out.write(line + '\n')

out.close()

raw_input("Press any key to quit.")



[/quote]
Yet with a minimum of modification it probably meets the skynet possibilities minimum (tm)

[Alexhans]

qwertyuiopas, I'm curious about this... http://www.bay12games.com/forum/index.php?topic=46025.msg915819#msg915819
I don't really understand what is it supposed to do and how would it work.

Executing code on someone else's computer.

This is so cool... I need to learn sockets and TCP/IP sometime (amongst other networking stuff).

[Berserker]

Here is a program that lets the user write itself:

Code: [Select]

print '1. Modify this program'
print '2. Run this program'
choice = int(raw_input('> '))

selfname = 'writeself.py'

if choice == 1:
    # Read the first 22 lines into a list
    prog = [line.rstrip() for line in open(selfname)][:21]

    # Let the user write the rest
    line = raw_input()
    while line != 'end':
        prog.append(' '*4+line)
        line = raw_input()

    f = open(selfname, 'w')
    map(lambda x: f.write(x+'\n'), prog)
    f.close()

if choice == 2:
    # Choice 1 starts editing from here
    pass


[qwertyuiopas]

qwertyuiopas, I'm curious about this... http://www.bay12games.com/forum/index.php?topic=46025.msg915819#msg915819
I don't really understand what is it supposed to do and how would it work.

It's more of a fragment, also looks somewhat sloppy, but it DOES get around having to either use a goto or copy code unnessecarily.

[winner]

a c++ program I wrote to study positive assortive breeding, it runs from the command line.

Spoiler (click to show/hide)

Code: [Select]

#include <iostream>
#include <ctime>
#include <cstring>
#include <math.h>
using namespace std;
/*******************************/
const int numCreatures = 50;
const int numGene= 900;
struct creature
{
bool a[numGene];
string color;
int number;
int sum;
string sex;
};
/*******************************/
int srand ();
void init();
void sort();
void breed();
double Diversity();
void print();
/*******************************/
creature pop[numCreatures];
/*******************************/
int main ()
{
int div[16];
int array[numCreatures];
srand ( time(NULL) );
for(int j=0; j<1; j++) // number of tests
{
init();
for(int k=0; k<8; k++) //this times x is the number of generations
{
div[k]=Diversity(); //records the genetic diversity percent  every so often
for(int i=0; i<8; i++) // does x steps at a time
{
sort();
print(); //comment out this line to avoid seeing the individuals
breed();
}
}
for(int y=0; y<16;y++)
{
cout<< div[y]<< "       "; //prints the percent genetic diversity array
}
cout << endl;
}
}
/*******************************/
void init()
{
int a;
for(int i=0; i < numCreatures; i++) //loop once for each creature in the list
{
pop[i].sum=0; // clear their phenotype
for(int j=0; j<numGene; j++) //loop through their genes
{
pop[i].a[j] = rand()%2; //assigning either 0 or one to each gene
pop[i].sum += pop[i].a[j]; //and summing them up.
}
if(rand()%2)
pop[i].sex = "\033[49m"; //50% of the time make them male and bold
else
pop[i].sex = "\033[47m"; //the other 50% make them female and normal
switch(rand()%7) //assign them a random color.
{
case 0:
pop[i].color="\033[30m";
break;
case 1:
pop[i].color="\033[31m";
break;
case 2:
pop[i].color="\033[32m";
break;
case 3:
pop[i].color="\033[33m";
break;
case 4:
pop[i].color="\033[34m";
break;
case 5:
pop[i].color="\033[35m";
break;
case 6:
pop[i].color="\033[36m";
break;
}
}
}
/*******************************/
void sort()
{
int num;
creature num2;
for(int i=0; i<numCreatures; i++)
{
num = i;
for(int j = i+1; j<numCreatures ; j++) //sort from highest value to lowest value
{
if(pop[j].sum >= pop[num].sum)
num = j;
}
num2=pop[i];
pop[i]=pop[num];
pop[num]=num2;
}
}
/*******************************/
void breed()
{
creature best;
for(int i=0; i<numCreatures;i++)
{
best =pop [ (i+1)%numCreatures ];
for(int j=0; j < numCreatures; j++)
{
if (  fabs( pop[i].sum - best.sum ) > fabs( pop[i].sum - pop[j].sum )  ) //if the difference between you and your current best is larger than you and this creature
if (pop[i].sex != pop[j].sex) //and it is the opposite sex
{
best = pop[j];
best.number = j;
}
}
pop[i].color = best.color; //what's you daddy's color
pop[i].number = best.number; //who's your daddy?
pop[i].sum=0;
for(int j=0; j<numGene; j++)
{
if(rand()%2 == 0) //50% of the time trade a gene
pop[i].a[j]=best.a[j];
if(rand()%128) // 1/x of the time mutate
pop[i].a[j] = rand()%2;
pop[i].sum += pop[i].a[j]; //get your new phenotype
}
if(rand()%2) //50% of the time be male
pop[i].sex="\033[49m";
else
pop[i].sex="\033[47m";

switch(rand()%400) // occasionally mutate your color so that ancestry shows up visually
{        
case 0:
pop[i].color="\033[30m";
break;
case 1:
pop[i].color="\033[31m";
break;
case 2:
pop[i].color="\033[32m";
break;
case 3:
pop[i].color="\033[33m";
break;
case 4:
pop[i].color="\033[34m";
break;
case 5:
pop[i].color="\033[35m";
break;
case 6:
pop[i].color="\033[36m";
break;
}
}
}
/*******************************/
double Diversity()
{
double diversity=0;
int a,c;
c = numCreatures / 2;
for(int i=0; i<numGene; i++)
{
a=0;
for(int j=0; j<numCreatures; j++) //measure the genetic diversity of the population
{
a+=pop[j].a[i];
}
diversity += c - fabs(a-c);
}
return 100*diversity/(c*numGene); //turns it into a percentage
}
/*******************************/
void print()
{
int temp=pop[0].sum;
for(int i=0; i<numCreatures; i++)
{
cout << pop[i].sex <<pop[i].color << pop[i].sum<<" ";
temp=pop[i].sum;
}
cout <<"\033[30m"<<endl;
}
/*******************************/

[alway]

I have a genetic algorithm I wrote in TI Basic on my TI84 Plus Silver calculator which find a min or max for a function (or the zero point if you put in the absolute value of the function). Although it takes a few minutes to come up with the ideal solution.

That was my lesson in why variables should always be named descriptively (I used somewhere around 25 or 26 of the available letters, since variable names are 1 character long on the calculator). And why you should never use TI Basic to program anything.

[Bricks]

How did that work, alway?  Did you take a population of test points and then "evolve" them?

[alway]

Yep, took a population of I think 8 points (stored in matrices, limiting the number available, since the calculator only has 10 available, at least 2 of which needed to be kept empty for use in the selection stage to avoid programming headach or unintentional loss of specimens), ran em through the function provided and used that number to do fitness testing, highest/lowest 3 were caried on to next step. These three were then reproduced with one another; one decimal place was a single gene, with it being programmed for 4 decimals of accuracy, making it 5 total genes. Reproduction involved cloning of the top 3, then mutating those clones, as well as combining pairs of the three w/ mutation. It had elitism as well, keeping a copy of the best solution unmutated.
3 best: A, B, C
after reproduction: A, Am, Bm, Cm, ABm, ACm, BCm, ABCm*

It did have some major problems though brought about by the way it was programmed. Since each decimal was a gene, going from 0.9999 to a correct solution of 1 is improbable; likewise, from .0999 to .1, ect are also improbable. However, I never bothered fixing it since it runs to slowly on a calculator to be of much practical use anyway, except in very rare cases. One generation takes about 1 to 2 seconds to go through, which is why it takes so long to find a solution.

The way I wrote it, the genetic algorithm itself is a massive multi-hundred line code, with the function being tested put into a seperate program for ease of access. Without too much alteration, it could probably be used for other genetic algorithm-y purposes, albiet ones which would take a very long time.

Oh, and I nearly forgot another experiment I carried out with it... You see, it was taking quite a while to come up with the correct answers, as I have stated before. So, I rigged up a much more simple genetic algorithm which would run that genetic algorithm over and over, modifying its mutation rate. Overall, it took about 8 hours to run through it completely, but by the end of running it three times the ideal mutation rate was nearly identical(margin of difference of about 2%), and so I now use that as my mutation rate (about 26% btw, although it would certainly vary from one GA to another). 

*threesome on a calculator, bow chicka bow wow

[Lord Dullard]

I've just recently started learning Python this week. As a little trial for myself, I wrote a tiny program that takes a year (any year will work, it doesn't matter if it's one, four, or twenty digits long) and turns it into a Roman numeral.

For those without Python, it's here as a compiled executable (22kb).

For those who are interested in the code:

Spoiler (click to show/hide)

"""A relatively simple program that converts standard Gregorian years into Roman numerals.

Any integer should theoretically work."""

__author__ = "David Hagar (dm.hagar@gmail.com)"
__version__ = "Roman Numeral Converter v0.1"
__date__ = "2009/12/21"
__copyright__ = "Copyright (c) 2009 David Hagar"

#Check for errors in the date the user has entered.
def checkDate():
    try:
        global odate
        int(odate)
        #If the integer is negative, make it positive.
        odate = odate.strip('-')
        if odate == '0':
            #If they enter '0', lecture them a bit.
            print 'Technically, there is no Roman equivalent to 0.\nHowever, the word for \'nothing\' - \'nulla\' - can be written as N.'
        else:
            convertDate()
    except ValueError:
        #If it's not an integer, exit the program.
        print 'That\'s not an integer. Exiting.'
        exit

def convertDate():
    global fdate
    olist = list(odate)   
    print 'The Roman numerical equivalent of', odate, 'is thus:'
    doYears(olist[-1])
    if len(olist) > 1:
        doDecades(olist[-2])
        if len(olist) > 2:
            doCenturies(olist[-3])
            if len(olist) > 3:
                doMillenia(olist[:-3])
            else:
                doMillenia('0')
        else:
            doDecades('0')
            doCenturies('0')
    else:
        doDecades('0')
        doCenturies('0')
        doMillenia('0')
    print fdate
    raw_input()

def doYears(years):
    global fdate
    years = int(years)
    if years == 1:
        years = 'I'
    if years == 2:
        years = 'II'
    if years == 3:
        years = 'III'
    if years == 4:
        years = 'IV'
    if years == 5:
        years = 'V'
    if years == 6:
        years = 'VI'
    if years == 7:
        years = 'VII'
    if years == 8:
        years = 'VIII'
    if years == 9:
        years = 'IX'
    fdate = years

def doDecades(decades):
    global fdate
    decades = int(decades)
    if decades == 0:
        decades = ''
    if decades == 1:
        decades = 'X'
    if decades == 2:
        decades = 'XX'
    if decades == 3:
        decades = 'XXX'
    if decades == 4:
        decades = 'XL'
    if decades == 5:
        decades = 'L'
    if decades == 6:
        decades = 'LX'
    if decades == 7:
        decades = 'LXX'
    if decades == 8:
        decades = 'LXXX'
    if decades == 9:
        decades = 'XC'
    fdate = decades + fdate

def doCenturies(centuries):
    global fdate
    centuries = int(centuries)
    if centuries == 0:
        centuries = ''
    if centuries == 1:
        centuries = 'C'
    if centuries == 2:
        centuries = 'CC'
    if centuries == 3:
        centuries = 'CCC'
    if centuries == 4:
        centuries = 'CD'
    if centuries == 5:
        centuries = 'D'
    if centuries == 6:
        centuries = 'DC'
    if centuries == 7:
        centuries = 'DCC'
    if centuries == 8:
        centuries = 'DCCC'
    if centuries == 9:
        centuries = 'CM'
    fdate = centuries + fdate

def doMillenia(millenia):
    global fdate
    millenia = int(''.join(millenia))
    if millenia == 0:
        millenia = ''
    else:
        millenia = 'M' * millenia
    fdate = millenia + fdate

if __name__ == "__main__":
    fdate = ''
    #Have the user enter a date.
    print __copyright__
    print __version__
    print __date__
    odate = raw_input('\nInput a Gregorian date: ')
    checkDate()
    pass

Before anyone points it out to me, I know this code is remarkably inefficient. For example, I could have turned the functions to parse years, decades, and centuries into a single more all-purpose function quite easily (by adding just a few more variables to it). I also could have eliminated quite a lot of the code using regular expressions. However, I can't really be bothered to mess with it anymore - this was just a very simple exercise for me to see if I could master the language syntax.

If it helps anyone who's trying to learn, or if anyone would like to practice on it by slimming it down, feel free.

[shengii]

Simple Dice Rolling Program.
Kind of messy if you decide to go above ~20 sides.

Spoiler: Source code (click to show/hide)

Code: [Select]

#include <iostream>
#include <string>

#define MAX_SIDES 250000

using std::cout;
using std::cin;
using std::endl;
using std::string;

int genrand(int min, int max) {
    if (max < 10) {
        return (rand() >> 8) % (max - min + 1) + min;
    } else {
        return rand() % (max - min + 1) + min;
    }
}

int main() {
    srand((unsigned)time(0)); // Seeds random number generator
    //
    string input = "1d1"; // Input from the user
    //
    // is parsed to get
    //
    int numDice = 1; // Number of dice to roll
    int numSide = 1; // Number of sides on each dice
    //
    // and is recorded with
    //
    int numVal[MAX_SIDES]; // Number of rolls that ended up on each side (ex: five 1's, two 2's, zero 3's, etc.)
    long total = 0;        // Total value of all rolls
    //
    while (true) {
        cout << "Roll ";
        cin >> input;
        numDice = atoi(input.substr(0, input.find("d")).c_str());
        numSide = atoi(input.substr(input.find("d") + 1, input.length()).c_str());
        if (input[0] == 'd') {
            numDice = 1;
        }
        if (numDice < 0 || numSide < 1 || numSide > MAX_SIDES) {
            cout << "Invalid Input.\n\n";
        } else {
            // Clear previous rolls
            for (int i = 0; i < MAX_SIDES; i++) {
                numVal[i] = 0;
            }
            total = 0;

            // Roll the dice
            for (int roll = 0; roll < numDice; roll++) {
                numVal[genrand(1, numSide) - 1]++;
            }

            // Calculate sum of all rolls and display each roll
            for (int i = 1; i <= numSide; i++) {
                cout << "Number of " << i << "'s - " << numVal[i - 1] << '\n';
                total += numVal[i - 1] * i;
            }

            // Display total
            cout << "Sum - " << total << "\n\n";
        }
    }

    return 0;
}