Last 8 updates

          import random
          class Organism:
          def init(self, id, energy):
          self.id = id
          self.energy = energy
          
          def move(self):
          self.energy -= 1
          
          def eat(self, resource):
          self.energy += resource.consume()
          
          def is_alive(self):
          return self.energy > 0
          
          class Resource:
          def init(self, quantity):
          self.quantity = quantity
          
          def consume(self):
          consumed = min(self.quantity, 5)
          self.quantity -= consumed
          return consumed
          
          class Ecosystem:
          def init(self, num_organisms, num_resources):
          self.organisms = [Organism(i, random.randint(10, 20)) for i in range(num_organisms)]
          self.resources = [Resource(random.randint(5, 10)) for _ in range(num_resources)]
          
          def simulate_step(self):
          for organism in self.organisms:
            if organism.is_alive():
                organism.move()
                if random.random() < 0.5:
                    resource = random.choice(self.resources)
                    organism.eat(resource)
          
          def get_status(self):
          alive_organisms = sum(1 for o in self.organisms if o.is_alive())
          total_resources = sum(r.quantity for r in self.resources)
          return f"Alive Organisms: {alive_organisms}, Total Resources: {total_resources}"
          
          
              ecosystem = Ecosystem(10, 5)
              for step in range(10):
                  ecosystem.simulate_step()
                  print(f"Step {step}: {ecosystem.get_status()}")
          

          import random
          
          class Organism:
          def init(self, genome):
          self.genome = genome
          self.fitness = self.evaluate_fitness()
          
          def evaluate_fitness(self):
          return sum(self.genome)  # Simple fitness: sum of genome bits
          
          def mutate(self, mutation_rate=0.1):
          for i in range(len(self.genome)):
            if random.random() < mutation_rate:
                self.genome[i] = 1 - self.genome[i]  # Flip bit
          
          class Population:
          def init(self, size, genome_length):
          self.organisms = [Organism([random.randint(0, 1) for _ in range(genome_length)]) for _ in range(size)]
          
          def evolve(self, selection_rate=0.5, mutation_rate=0.1):
          self.organisms.sort(key=lambda o: o.fitness, reverse=True)
          survivors = self.organisms[:int(len(self.organisms) * selection_rate)]
          new_generation = []
          for org in survivors:
            child = Organism(org.genome[:])
            child.mutate(mutation_rate)
            new_generation.append(child)
          self.organisms = new_generation
          
          def get_best_fitness(self):
          return max(o.fitness for o in self.organisms)
          
          
          population = Population(20, 10)
          for generation in range(10):
          population.evolve()
          print(f"Generation {generation}: Best Fitness: {population.get_best_fitness()}")