From 4856536a29606810f0f8ce9cf05efcfee31e48eb Mon Sep 17 00:00:00 2001
From: Karol Piotrowski <karpio7@st.amu.edu.pl>
Date: Tue, 26 May 2020 21:34:44 +0000
Subject: [PATCH] =?UTF-8?q?Prze=C5=9Blij=20pliki=20do=20''?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 gmo.cpp | 294 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 294 insertions(+)
 create mode 100644 gmo.cpp

diff --git a/gmo.cpp b/gmo.cpp
new file mode 100644
index 0000000..c644d1e
--- /dev/null
+++ b/gmo.cpp
@@ -0,0 +1,294 @@
+#include <stdio.h>
+#include <cstdlib> 
+#include <iostream>
+#include <ctime>
+#include <string>
+#include <math.h>
+#include<bits/stdc++.h>
+#include <algorithm>
+#include <utility>
+using namespace std;
+
+string generateValue() {
+	
+	char trash[100];
+	string x = itoa(rand() % 1000,trash,10);
+	if (x.size() == 2) {
+		x = "0" + x;
+	}
+	else if (x.size() == 1) {
+		x = "00" + x;
+	}
+	
+	return x;
+	
+}
+
+
+string generateVegetable() {
+	
+	string taste = generateValue(); 
+	string colour = generateValue();
+	string size = generateValue();
+	
+	return taste + colour + size;
+	
+}
+
+
+void generatePopulation(string * population,int length) {
+	
+	int i;
+	for(i=0;i<length;i++) {
+		population[i] = generateVegetable();
+	}
+}
+
+
+int power(int x, int y) {
+	
+  if (y == 0) return 1;
+  if (y == 1) return x;
+  
+  int temp = power(x, y/2);
+  if (y%2 == 0) return temp * temp;
+  else return x * temp * temp;
+}
+
+
+int stringToInt(string str,int size) {
+	
+	int x = 0;
+	int i;
+	reverse(str.begin(),str.end());
+	
+	for(i=0;i<size;i++) {
+		x += (str[i] - '0') * power(10,i);
+	}
+	
+	reverse(str.begin(),str.end());
+	
+	return x;	
+}
+
+
+int fitness(string vegetable) {
+	
+	int taste = stringToInt(vegetable.substr(0,3),3);
+	int colour = stringToInt(vegetable.substr(3,3),3);
+	int size = stringToInt(vegetable.substr(6,3),3);
+	
+	return (taste+colour+size)/3;
+}
+
+
+bool comparePair(const pair<int, string>&i, const pair<int, string>&j)
+{
+   	return i.first > j.first;
+}
+
+    
+void ranking(string * population,string * parents, int populationSize, int parentsNumber) {
+	
+	int i;
+	pair <int,string> fitnessTable[populationSize];
+	for(i=0;i<populationSize;i++) { 
+		fitnessTable[i] =  make_pair(fitness(population[i]),population[i]);
+	}
+	
+	sort(fitnessTable,fitnessTable+populationSize,comparePair);
+	
+	for(i=0;i<parentsNumber;i++) {
+		parents[i] = fitnessTable[i].second;
+	}	
+}
+
+
+bool exists(int len, int * array, int element) {
+	
+	int i;
+	for(i=0;i<len;i++) {
+		if (array[i] == element) return true;
+	}
+	return false;
+}
+
+
+void selection(string * population,string * parents, int populationSize, int parentsNumber) {
+	
+	int i,j,k;
+	pair <int,string> fitnessTable[populationSize];
+	for(i=0;i<populationSize;i++) { 
+		fitnessTable[i] =  make_pair(fitness(population[i]),population[i]);
+	}
+	
+	sort(fitnessTable,fitnessTable+populationSize,comparePair);
+	
+	int roulette;
+	int taken[parentsNumber];
+	int sum = 0;
+	for(i=0;i<parentsNumber;i++) {
+		for(j = populationSize - 1;j>=0;j--) {
+			if(not exists(parentsNumber,taken,j)) {
+				sum += 	fitnessTable[j].first;
+				fitnessTable[j].first = sum;
+			}
+			
+		}
+		roulette = rand() % fitnessTable[0].first;
+		j = 0;
+		while(exists(parentsNumber,taken,j)) {
+			j += 1;
+		}
+		while(roulette > fitnessTable[j].first and j<populationSize) {
+			if(not exists(parentsNumber,taken,j)) {
+				roulette -= fitnessTable[j].first;
+			}
+			j+=1;
+		}
+		parents[i] = fitnessTable[j].second;
+		taken[i] = j;
+	}
+	
+	
+		
+}
+
+
+int newton(int n,int k) {
+	
+	if (k==0 or n==k) return 1;
+	else return newton(n-1,k-1) + newton(n-1,k);
+}
+
+
+string mutate(string child) {
+	
+	int d3 = rand() % 3;
+	string mutation = generateValue();
+	switch(d3) {
+		case 0:
+			child = mutation + child.substr(3,6);
+			break;
+		case 1:
+			child = child.substr(0,3) + mutation + child.substr(6,3);
+			break;
+		case 2:
+			child = child.substr(0,6) + mutation;
+			break;
+	}
+	
+	return child;
+}
+
+
+string cross(string parent[2]) {
+	
+	int i;
+	string child = "";
+	for(i=0;i<3;i++) {
+		child += parent[rand() % 2].substr(i*3,3);
+	}
+	if (child == parent[0] or child == parent[1]) {
+		string other;
+		if (child == parent[0]) other = parent[1];
+		else other = parent[0];
+		int d3 = rand() % 3;
+		switch(d3) {
+			case 0:
+				child = other.substr((rand() % 3)*3,3) + child.substr(3,6);
+				break;
+			case 1:
+				child = child.substr(0,3) + other.substr((rand() % 3)*3,3) + child.substr(6,3);
+				break;
+			case 2:
+				child = child.substr(0,6) + other.substr((rand() % 3)*3,3);
+				break;
+		}
+	}
+	int d1000 = rand() % 1000;
+	if (rand() % 100 == 0) {
+		child = mutate(child);
+	}
+	return child;
+}
+
+
+void crossover(string * parents,string * nextGen,int parentsNumber,int nextGenSize) {
+	
+	int counter = 0;
+	int i,j;
+	for(i=0;i<parentsNumber;i++) {
+		if (counter >= nextGenSize) {
+			break;
+		}
+		else {
+			nextGen[counter] = parents[i];
+		counter +=1;
+		}
+	}
+	while(counter < nextGenSize) {
+		for(i=0;i<parentsNumber;i++) {
+			if (counter >= nextGenSize) {
+				break;
+			}
+			else {
+				for(j=i;j<parentsNumber;j++) {
+					if (counter >= nextGenSize) {
+					break;
+					}
+					else {
+						string couple[2];
+						couple[0] = parents[i];
+						couple[1] = parents[j];
+						nextGen[counter] = cross(couple);
+						counter += 1;
+					}
+				}
+			}
+		}
+	}
+}
+
+
+string * genetic_algorithm(string * population, int populationSize, int parentsNumber) {
+	
+	int iteration,i;
+	for(iteration=0;iteration<5;iteration++) {
+		string * parents = new string[parentsNumber];
+		selection(population,parents,populationSize,parentsNumber);
+		
+		string * nextGen = new string[populationSize];
+		crossover(parents,nextGen,parentsNumber,populationSize);
+		
+		delete[] population;
+		
+		population = new string[populationSize];
+		for(i=0;i<populationSize;i++) {
+			population[i] = nextGen[i];
+		}
+		delete[] nextGen;
+	}
+	string vegetablesForPlanting[20];
+	ranking(population,vegetablesForPlanting,populationSize,20);
+	
+	return vegetablesForPlanting;
+}
+int main() {
+	
+	
+	srand(time(0));
+	
+	int populationSize = 500;
+	int parentsNumber = populationSize - 5;
+	string * population = new string[populationSize];
+	
+	generatePopulation(population,populationSize);
+	
+	string * vegetablesForPlanting = genetic_algorithm(population, populationSize, parentsNumber);
+	
+	
+	
+	
+	return 0;
+}