Got it, let's tackle this genetic algorithm problem step by step. I'll walk you through designing the fitness function, generating the binary population, and even throw in a full Python implementation example since that's super practical for prototyping.

First, let's codify your requirements into a clear, computable rule—this is the core of your GA's selection pressure:

• Full 1s string: Optimal fitness (we'll assign a maximum value like 1.0 to make it the clear top choice)
• Full 0s string: Second-best fitness (a value slightly lower than full 1s, e.g., 0.9—so it's better than any mixed string but not as good as all 1s)
• Mixed 0s/1s strings: Fitness decreases as the number of 1s increases (and increases as the number of 0s increases). A simple linear approach works perfectly here: calculate fitness as the ratio of 0s to total string length.

Mathematically, for a binary string s of length n:

if s == '1' * n:
    fitness = 1.0
elif s == '0' * n:
    fitness = 0.9
else:
    count_ones = s.count('1')
    fitness = (n - count_ones) / n  # Equivalent to count_zeros / n

This setup strictly enforces the hierarchy you want: all 1s > all 0s > mixed strings with more 0s > mixed strings with more 1s.

Generating a population of binary strings is straightforward—we'll randomly create pop_size individuals, each of length string_length. In Python, the random module makes this trivial:

import random

def generate_binary_population(pop_size, string_length):
    population = []
    for _ in range(pop_size):
        # Randomly pick '0' or '1' for each position in the string
        individual = ''.join(random.choice(['0', '1']) for _ in range(string_length))
        population.append(individual)
    return population

Putting it all together, here's a complete script that generates a population, calculates fitness for each individual, and prints the results:

import random

def generate_binary_population(pop_size, string_length):
    population = []
    for _ in range(pop_size):
        individual = ''.join(random.choice(['0', '1']) for _ in range(string_length))
        population.append(individual)
    return population

def calculate_fitness(individual):
    n = len(individual)
    if individual == '1' * n:
        return 1.0
    elif individual == '0' * n:
        return 0.9
    else:
        count_ones = individual.count('1')
        return (n - count_ones) / n

# Example usage
if __name__ == "__main__":
    POPULATION_SIZE = 10
    STRING_LENGTH = 8
    
    # Generate a random population
    pop = generate_binary_population(POPULATION_SIZE, STRING_LENGTH)
    
    # Calculate and display fitness for each individual
    print("Population & Fitness Values:")
    for idx, ind in enumerate(pop):
        fit = calculate_fitness(ind)
        print(f"Individual {idx+1}: {ind} | Fitness: {fit:.3f}")

• If you want stronger selection pressure for the full 1s string, you could bump its fitness to a higher value (like 2.0) instead of 1.0—just make sure the relative hierarchy stays intact.
• For larger populations or longer strings, using bit arrays instead of strings might be more efficient, but strings are totally fine for prototyping.
• When you add selection, crossover, and mutation to your GA, consider adjusting mutation rates to avoid accidentally breaking high-fitness individuals (like the full 1s string) too often.

内容的提问来源于stack exchange，提问作者Lemongrab