Das deutsche Python-Forum

Code: Alles auswählen

    while True:
        current_prime = primes.next()
        yield current_prime
        primes = (q for q in primes if not current_prime.divides(q))

Code: Alles auswählen

(q for q in primes if not current_prime.divides(q))

Code: Alles auswählen

def funk(primes,current_prime):
    return (q for q in primes if not current_prime.divides(q))

while True:
     current_prime = primes.next()
     yield current_prime
     primes =funk(primes,current_prime)

Code: Alles auswählen

(q for q in primes if not current_prime.divides(q))

Code: Alles auswählen

def generator():
    for q in primes:
        if not current_prime.divides(q): yield q
generator()

Code: Alles auswählen

def generator(primes,current_prime):
    for q in primes:
        if not current_prime.divides(q): yield q

def numbers():
    i = 2
    while True:
        yield i
        i += 1

def my_primes():
    primes = numbers()
    while True:
        current_prime = primes.next()
        yield current_prime
        primes = generator(primes,current_prime)

Code: Alles auswählen

def my_primes():
    primes = numbers()
    while True:
        current_prime = primes.next()
        yield current_prime
        primes = (q*q for q in primes if not current_prime.divides(q))

Code: Alles auswählen

#include <inttypes.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

/* ---------------------------------------------------------------
 * Iterator base type.
 */
struct Iterator;

typedef uint32_t (*next_func_t) (struct Iterator*);

typedef struct Iterator {
    next_func_t next;
} Iterator;

/* ---------------------------------------------------------------
 * Simple counter type.
 */
typedef struct {
    Iterator base_type;
    uint32_t current;
} Counter;

uint32_t Counter_next(Counter *counter)
{
    return counter->current++;
}

void Counter_init(Counter *counter, uint32_t start_value)
{
    counter->base_type.next = (next_func_t) Counter_next;
    counter->current = start_value;
}

/* ---------------------------------------------------------------
 * Dividable filter type.
 */
typedef struct Filter {
    Iterator base_type;
    Iterator *previous;
    uint32_t prime;
} Filter;

uint32_t Filter_next(Iterator *iterator)
{
    uint32_t i;
    Filter *filter = (Filter*) iterator;
    
    while (true) {
        i = filter->previous->next(filter->previous);
        if (i % filter->prime) return i;
    }
}

Iterator* Filter_create(Iterator *previous, uint32_t prime)
{
    Filter *result = (Filter*) malloc(sizeof(*result));
    
    result->base_type.next = Filter_next;
    result->previous = previous;
    result->prime = prime;
    
    return (Iterator*) result;
}

/* ---------------------------------------------------------------
 * Here's the action.  :-)
 */
int main(void)
{
    Counter numbers;
    Iterator *primes;
    uint32_t prime;

    Counter_init(&numbers, 2);
    primes = (Iterator*) &numbers;
    while (true) {
        prime = primes->next(primes);
        printf("%d,", prime);
        primes = Filter_create(primes, prime);
    }
}