Die Wieselparade

.
Abbildung 1: Ein Altaiwiesel. Karunakar Rayker / CC BY-SA 2.0 (US)

Gerade fiel mir ein, dass voriges Jahr ein Beitrag auf Panda’s Thumb war,  in dem dazu aufgerufen wurde eigene Versionen von Dawkins Wiesel-Algorithmus zu schreiben und zu veröffentlichen.

Obwohl ich da schon seit über 10 Jahren mich nicht mehr daran gesetzt hatte etwas zu programmieren (und auch vor 10 Jahren sicherlich kein Virtuose darin war), reizte mich die Herausforderung. Leider hatte ich letztes Jahr noch keine Möglichkeit das Resultat auch ins Netz zu stellen.

Das hole ich nun hiermit nach🙂

# weasel program in Python
# should display "METHINHS IT IS LIKE A WEASEL"

# Importing random classes
import random

# Defining variables
aim = „METHINK IT IS LIKE A WEASEL“ #Defining the aim
pop = []
i = 0
c = 0
mutrate = raw_input(„Please set mutation rate (in %):“) # sets mutation rate in %
mutrate = int(mutrate)
size = raw_input(„Please enter offspring size:“) # setting offspring size
size = int(size)

def umwandel(var): # Converts a list into a string
a = „“
c = 0
while c <= 26:
a = a + (var[c])
c = c + 1
return a

def convert(var): # Converts a string into a list
a = []
c = 0
while c <= 26:
a += [var[c]]
c = c + 1
return a

def zufall(): # Generates a random letter
alphabet = „ABCDEFGHIJKLMNOPQRSTUVWXYZ “
random.seed()
a = random.randrange(0, 27, 1)
b = alphabet[a]
return b

def generate(): # Generates a random string of 28 letters
c = 0
word = „“
while c <= 26:
word += (zufall())
c = c + 1
return word

def mutate(var,mutrate): # mutates each letters in a string of 27 elements with a (mutrate) % likelihood
c = 0
while c <= 26:
random.seed()
a = random.randrange(1,100,1)
if a <= mutrate:
b = zufall()
var = convert(var)
var[c] = b
var = umwandel(var)
c = c + 1
return var

def fittnes(var1,var2): # Compares the level of similarity between 2 strings of 28 elements
c = 0 # The result is an integer
i = 0
while c <= 26:
if var1[c] == var2[c]:
i = i + 1
c = c + 1
return i

def population(var): # Generates a list of strings with (var) random elements
c = 1
b = []
while c <= var:
b += [generate()]
c = c +1
return b

def selection(aim,pop,size): # Selects the element of a list which has the most similarities with a given aim
z = 0
a = „“
f = 0
while z <= size-1: b = pop[z] i = fittnes(aim,b) if i > f:
f = i
a = pop[z]
z = z + 1
return a,f

def offspring(mother,mutrate,size): # Generates a list of mutations from ‚mother‘ with ’size‘ elements
c = 1
children = []
while c <= size:
children += [mutate(mother,mutrate)]
c = c + 1
return children

# Main program

pop = population(size) # Setting a starting population
mother = selection(aim,pop,size) # picks the element from the starting population with the most similarities to the aim
print „Generation “ + str(c)
print „Best fit:“ + mother[0] + “ Similarities:“ + str(mother[1])
print

while i < 27: # loop will run till a complete match
c = c + 1 # counts the generations
pop = offspring(mother[0],mutrate,size) # a new generation will be generated from the last run’s ‚best fit
mother = selection(aim,pop,size) # this generation’s ‚best fit‘
print „Generation “ + str(c)
print „Best fit:“ + mother[0] + “ Similarities:“ + str(mother[1])
print
i = mother[1]

Hinterlasse einen Kommentar

Eingeordnet unter Evolution

Schreibe einen Kommentar

Trage deine Daten unten ein oder klicke ein Icon um dich einzuloggen:

WordPress.com-Logo

Du kommentierst mit Deinem WordPress.com-Konto. Abmelden / Ändern )

Twitter-Bild

Du kommentierst mit Deinem Twitter-Konto. Abmelden / Ändern )

Facebook-Foto

Du kommentierst mit Deinem Facebook-Konto. Abmelden / Ändern )

Google+ Foto

Du kommentierst mit Deinem Google+-Konto. Abmelden / Ändern )

Verbinde mit %s