# Untitled

unknown
plain_text
2 years ago
3.1 kB
2
Indexable
Never
import random
import numpy as np
temp = temp.split()
p_count = int(temp[0])
target_run = int(temp[1])
#print(p_count)
#print(target_run)
dict_1 = {}
player_arr = []

for i in range(p_count):
#print(i)
x = x.split()
#print(x)
dict_1[i] = int(x[1])
player_arr.append(x[0])
#print(dict_1)

print(dict_1)
print(player_arr)

def select_individual():
indv = []

for i in range(p_count):
t = random.randint(0, 1)
indv.append(t)
#f = fitness(indv,player_arr)
#sort(f)

#print(indv)
return indv

def generate_population():
population = []
for i in range(4):
population.append(select_individual())

return population

def fitness(indv,dict_1,target_run):
#print('individual child:',indv)
#print(type(indv))
count_achieved_run = 0
if type(indv)== list:
for i in range(len(indv)):
if (indv[i] == 1):
count_achieved_run += dict_1[i]

fit = abs(target_run - count_achieved_run)

return fit

def mutation(child):
mutation_probability = 0.2
random_probabilty =  random.uniform(0, 0.5)
#random_probabilty = np.random.random(0,0.5)
#random_probabilty = round(random_probabilty,2)
#print("random probabilty",random_probabilty)

if (mutation_probability >= random_probabilty):
idx = random.randint(0, 7)
print('index',idx)
if(child[idx] == 0):
child[idx] = 1
else:
child[idx] = 0

return child

def crossover(x,y):
x = str(x)
y = str(y)
new_child = []
idx = random.randint(0, 8)
#print(x,y)
new_child.append( x[0:idx+1:] )
new_child.append( y[idx+1::] )

return new_child

def find_parent(fit_arr):
f_arr = fit_arr
p_arr = {}
#print("fit array before sorting:", fit_arr)

p_arr  = dict( sorted(fit_arr.items()) )
#print("fit array after sort:", p_arr)

p_arr.popitem()

#print("p_arr:",p_arr)

x = random.choice(list(p_arr.values()))
y = random.choice(list(p_arr.values()))

if(x == y):
find_parent(f_arr)
else:
#print("parent:","x:",x,"y:",y)
return (x,y)

def GA(dict_1, n, target_run): # n is max gen count

flag = False

p = generate_population()

for j in range(n):
fit_arr = {}
for i in p:
f = fitness(i,dict_1,target_run)
fit_arr[f] = i
if ( f == target_run):
child = i
flag = True
break

for i in range(len(p)):
parent_1,parent_2 = find_parent(fit_arr)

print("t  & z:",parent_1,parent_2)
#parent_1 = t[0]
#parent_2 = t[1]
child = crossover(parent_1,parent_2)
muted_child = mutation(child)
#f = fitness(i,player_arr,target_run)

if(len(p) < 4):
p.append(child)
elif( (i == 0) or len(p)>= 4):
p = []

if(flag == True):
return child
else:
return -1

ans = GA(dict_1, 1, target_run)
print(ans)