import java.util.Random;
import java.io.*;

public class Start {

	public static void main(String[] args) {
		float pm = 0;
		float pc = 0;
		int mi = 0;
		//Ausgabedatei zum schreiben öffnen.
		try {
				PrintWriter daten = new PrintWriter("daten.dat");
		for(pc = (float)0.1; pc < 0.95; pc = pc + (float)0.05){
			for(pm = (float)0.00; pm <= 0.05; pm = pm + (float)0.005)
			{
				System.out.println("PC: " + pc + " PM: " + pm);
				daten.print(pc + " " + pm + " ");
					for(int o = 0; o < 10; o++)
					{
						HauptBit a = new HauptBit();
						int i = 0;
						a.uebergabe(args,pc,pm);
						a.make_genom();
						for (i = 0; i < (int)a.max_generations && a.fett == false; i++) 
						{
							for(int h = 0; h < a.genecnt * a.pc; h++)
							{
								a.cross((a.zufall(a.genecnt)), a.zufall(a.genecnt), a.zufall(a.genelen));
								//a.transpos((a.zufall(a.genecnt)), a.zufall(a.genecnt), a.zufall(a.genelen), a.zufall(a.genelen));
							}
								a.mutate();
								a.fitness();
								a.fitsort();
								a.replic_sh();
								//System.out.println("Durchläufe: " + a.max);
						}
						mi = mi + i;
					}
					mi = mi/10;
					System.out.println("\nDurchläufe: " + mi);
					daten.print(mi+"\n");
					mi = 0;
				}	
			daten.print("\n");
			}
		daten.close();
	    } 
		catch (FileNotFoundException e) 
		{
				e.printStackTrace();
		}
	}
}

-----------------------------------------

import java.util.*;

public class HauptBit {
	String[] auswahl;

	String[] repvalue = new String[2];

	BitSet[] gene, hf;

	int[] fit;

	boolean fett;

	float pc = 0, pm = 0, initrate = 0, replication_scheme = 0, max_generations = 0;

	int genecnt, genelen, repanz, repproz, max = 0;

	boolean protect_best = true;

	public void uebergabe(String[] args, float upc, float upm) {

		for (int i = 0; i < args.length; i++) {
			auswahl = args[i].split("=");
			pc = upc;
			pm = upm;
			if (args[i].startsWith("initrate")) {
				initrate = Float.parseFloat(auswahl[1]);
			}

			if (args[i].startsWith("genecnt")) {
				genecnt = Integer.parseInt(auswahl[1]);
			}

			if (args[i].startsWith("genelen")) {
				genelen = Integer.parseInt(auswahl[1]);
			}

			if (args[i].startsWith("replication_scheme")) {
				repvalue = auswahl[1].split("x");
				repanz = Integer.parseInt(repvalue[0]);
				repproz = Integer.parseInt(repvalue[1]);
			}

			if (args[i].startsWith("max_generations")) {
				max_generations = Float.parseFloat(auswahl[1]);
			}
			// Werte 1 für ja, 0 für nein
			if (args[i].startsWith("protect_best")) 
			{
				if (auswahl[1].equals("1")) {
					protect_best = true;
					//System.out.println("PROTECT BEST!!!");
			} 
			else 
			{
				protect_best = false;
			}
		}
	}
}

	public int zufall(int z) {
		int rw = 0;
		Random rd = new Random(System.nanoTime());
		rw = Math.abs(rd.nextInt(z));
		return rw;
	}

	public void make_genom() {

		gene = new BitSet[genecnt];

		for (int x = 0; x < genecnt; x++) {
			BitSet seq = new BitSet();

			for (int j = 0; j < ((genelen) * (initrate)); j++) {
				int zz = zufall(genelen);
				if (seq.get(zz) == false) {
					seq.set(zz, true);
				} 
				else {
					j--;
				}
			}
			//System.out.println(bitaus(seq));
			gene[x] = (BitSet) seq.clone();
		}
	}

	public void cross(float gen1, float gen2, float pos) {
		if (protect_best && gen1 == 0 && fit == null) {
			// ProtectBest
		} 
		else {
			BitSet g1 = new BitSet();
			BitSet g2 = new BitSet();
			int p = (int) pos;
			g1 = gene[(int) gen1].get(p, genelen - 1);
			g2 = gene[(int) gen2].get(p, genelen - 1);
			for (int i = 0; i < genelen; i++) {
				gene[(int) gen1].set(p + i, g2.get(i));
				gene[(int) gen2].set(p + i, g1.get(i));
			}
		}
	}
	
	public void transpos(float gen1, float gen2, float pos1, float pos2) {
		if (protect_best && (gen2 == 0) && fit == null) {
			// ProtectBest
		} 
		else {
			BitSet g1 = new BitSet();
			int p1 = (int)pos1;
			int p2 = (int)pos2;
			if(p1 > p2){p2 = (zufall(genelen-p1))+p1;}
			g1 = gene[(int) gen1].get(p1,p2);
				for (int i = 0; i < p2-p1; i++) 
				{
					gene[(int) gen2].set(p1 + i, g1.get(i));
				}		
			}
	}

	public void mutate() {
		int zz = 0, zz2 = 0;
		
		for (int i = 1; i <= (genelen * genecnt * pm); i++) {
			zz = zufall(genecnt);
			zz2 = zufall(genelen);
			if (protect_best && zz == 0 && fit == null) {
				i--;
			} 
			else 
			{
					gene[zz].flip(zz2);
			}
		}
	}

	public void fitness() {
		fit = new int[genecnt];
		int c = 0;
		for (int j = 0; j < genecnt; j++) {
			c = gene[j].cardinality();
			fit[j] = c;
			bestfit(fit[j]);
			if (fit[j] == genelen) {
				fett = true;
			}
		}
	}

	public void fitsort() {
		hf = new BitSet[genecnt];
		int max = 0, ind = 0;
		for (int j = 0; j < genecnt; j++) {
			max = 0;
			for (int i = 0; i < genecnt; i++) {
				if (fit[i] > max) {
					max = fit[i];
					ind = i;
				}
			}
			hf[j] = (BitSet) gene[ind].clone();
			fit[ind] = 0;
		}
		for (int u = 0; u < genecnt; u++) {
			gene[u] = (BitSet) hf[u].clone();
		}
	}

	public int bestfit(int fit) {
		if (fit > max) {
			max = fit;
		}
		return max;
	}

	public void replic_sh() {
		hf = new BitSet[genecnt];
		//Kopieren in Hilfsarray
		for (int z = 0; z < genecnt; z++) {
			hf[z] = (BitSet) gene[z].clone();
		}
		int u = 0, r = 0;
		//repanz für die ersten 20 z.B.
		if (genecnt < repanz) {
			System.out.println("Replikation nicht möglich!!! Genanzahl kleiner als Auswahlanzahl!!!");
		}
		else {
			for (int j = 0; j < repanz; j++) {
				for (int i = 0; i < (genecnt / repanz); i++) {
					hf[i + u] = (BitSet) gene[j].clone();
				}
				r++;
				u = (genecnt / repanz) * r;
			}
			for (int z = 0; z < genecnt; z++) {
				gene[z] = (BitSet) hf[z].clone();
			}
		}
	}
//Ausgabe der Sequenz als String
	public String bitaus(BitSet bs) {
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < genelen; i++) {
			if (bs.get(i) == true) {
				sb.append("1");
			} else {
				sb.append("0");
			}
		}
		return sb.toString();
	}

}