Programmieren lernen

(defun e-sieb (n)
  "Berechnet die Primzahlen von 2 bis n mit dem Sieb von Erathosthenes."
  (labels 
    ((e (primzahlen sieb)
       (if (> (length sieb) 0)
           (e (cons (car sieb) primzahlen) (cdr (mark (car sieb) sieb)))
           (sort primzahlen #'<))))
    (e nil (range 2 n))))


(defun  mark (n sieb)
  (remove-if #'(lambda (x)
                     (and (>= x (* n n)) (= 0 (rem x n))))
                 sieb))
                

Lösung von: Stefan Meichtry (Erwachsenenbildung)

// Autor:				Andy Großhennig
// Solution for task:	Primzahlen bis 1000 (Felder)
// Guideline:			"Sieb des Eratosthenes"

#include <iostream>

using namespace std;

// Function: Fill a array with numbers from 0 to 1000
void setNumbers(int iarrNumbers[])
{
	for(int i = 0;i < 1001;i++)
	{
		iarrNumbers[i] = i;
	}
}

// Function: Filter primes out of the array and save them into a vector
void getPrim()
{
	int iarrNumbers[1001];		//Array from 0 to 1000
	vector <int> ivecPrimes;	//Vector for primes

	setNumbers(iarrNumbers);

	// Loop: Go through the array
	for(int i = 2;i < 1001;i++)
	{
		int j = 4;

		// If: Check for prime and add them to the vector
		if(iarrNumbers[i] != 0)
		{
			ivecPrimes.push_back(i);
		}

		// Loop: Exclude the multiple of the already checked numbers and set them to 0
		while(j <= 1000)
		{
			if(j % i == 0)
			{
				iarrNumbers[j] = 0;
			}
			j++;
		}
	}

	// Loop: Go through the vector and show the contents
	for(int i = 0;i < ivecPrimes.size();i++)
	{
		cout << ivecPrimes[i] << "\t";
	}
}

int main()
{
	getPrim();

	cout << "\n\n";
	system("Pause");
	return 0;
}
                

Lösung von: Andy Großhennig (Bundeswehr)

Type TAprime = array[1..N] of boolean;

procedure checkEratosthenes(var vprime: TAprime); 
var 
  i,k: LONGINT;
BEGIN
  FOR i:= 2 TO N DO vprime[i]:= TRUE;
  FOR i:= 2 TO trunc(sqrt(N)) DO BEGIN
    k:= i;
    IF vprime[i] = TRUE THEN REPEAT
      k:= k+i;
      if k < N then
      vprime[k]:= FALSE;
    UNTIL k >= N;
  END;
END;

maXbox:
050_pas_primetester_thieves.txt

//PASCAL
                

Lösung von: Max Kleiner (BFH)

class SiebVonEratosthenes(object):
    def __init__(self, maximum):
        self.maximum = maximum
    def main(self):
        i = 2
        liste = list()
        primZahlen = list()
        while i < self.maximum:
            liste.append(i)
            i += 1
        while liste[0]**2 <= liste[-1]:
            if liste[0] % liste[0] == 0:
                primZahlen.append(liste[0])
            liste = [x for x in liste if x%liste[0] != 0]
        print(primZahlen + liste)
                

Lösung von: Viktor Reib ()

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>

int32_t* prime_sieve( int32_t* size, const int32_t n );

int main(){

	int32_t* list;
	int32_t size;
	int32_t i;

	list = prime_sieve( &size, 1000 );	
	
	for( i = 0; i <= size - 1; ++i )
		printf( "%d\n", list[ i ] );

	free( list );

	return 0;

}
//Rückgaben sind das Array mit den Primzahlen und die Größe des Selbigen
int32_t* prime_sieve( int32_t* size, const int32_t n ){
	//Ist n < 2 gibt es keine Primzahlen zwischen 0 und n
	if( n < 2){
		*size = 0;
		return NULL;
	}

	bool list[n + 1];
	int32_t i;			//Schleifenindex
	int32_t mul;			//Faktor zur Berechnung der Vielfachen der Primzahlen
	int32_t multiple;		//Vielfache der Primzahlen
	int32_t prime_count;		//Anzahl der Primzahlen
	int32_t prime_list_index;	//Index für die Primzahlenliste
	int32_t* res;			//Ergebnis
	
	// Initialisierungen
	prime_count = 0; 

	list[0] = false;
	list[1] = false;

	for(i = 2; i <= n; ++i)
		list[i] = true;
	//Sieben der Primzahlen
	for(i = 2; i <= n; ++i){
		//ist eine Primzahl gefunden werden alle Vielfachen von ihr als nicht prim gekennzeichnet
		if( list[i] ){
			++prime_count;
			mul = 2;	
			while((multiple = mul * i) <= n){
				list[multiple] = false;	
				++mul;
			}
		
		}
	}
	//Reservierung des Speichers für das Ergbenis auf dem Heap
	res = (int32_t*) malloc( prime_count * sizeof( int32_t ) );	

	prime_list_index = 0;
	//schreiben der Primzahlen in die Ergebnisliste
	for( i = 2; i <= n; ++i ){
		if( list[i] ){
			res[prime_list_index] = i;
			++prime_list_index;
		}
	}
	//Rückgabe der Ergebnisse
	*size = prime_count;
	return res;

}
                

Lösung von: reeman :3 (TU Ilmenau)

package programmierenuebungen;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 *
 * @author MadDeer
 */
public class getPrimes {
    
    private List<Integer> values;
    
    public getPrimes(int range){
        values = new ArrayList();
        //Liste befüllen
        for (int a = 2; a <= range; a++){
            values.add(a);
        }
        //berechnen
        calculatePrimes();
    }
    
    private void calculatePrimes(){
        int index = 0;
        boolean changed = true; //Abbruchbedingung
        while(changed){ //solange ausführen, bis sich nichts mehr geändert hat
            int check = values.get(index); //zu prüfende Zahl
            int size = values.size();
            for(int a = (values.indexOf(check)+1); a < values.size(); a++){
                if (values.get(a) % check == 0){
                    values.remove(values.get(a));
                }
            }
            index++;
            if (size == values.size()){
                changed = false;
            }
        }
    }
    
    public List<Integer> getReturns(){
        return values;
    }
    
    public static void main (String[] args){
        //Benutzereingabe holen
        Scanner scanner = new Scanner(System.in);
        System.out.print("Bis zu welchem Bereich sollen Primzahlen gefunden werden? ");
        int range = Integer.parseInt(scanner.nextLine());
        //Berechnung starten und ausgeben
        for(int erg: new getPrimes(range).getReturns()){
            System.out.println("Die Zahl " + erg + " ist eine Primzahl.");
        }
    }
}
                

Lösung von: Mad Deer (FH Ulm)

function sieveOfEratosthenes(max) {
   var numbers = [], 
       primes = [],
       x = 2;
   
   for(x; x <= max; x++) numbers.push(x);
   
   while (numbers.length > 0) {
      primes.push(numbers.shift());
      for (x = 0; x <= numbers.length; x++)
         if (numbers[x] % primes[primes.length - 1] == 0) numbers.splice(x, 1);      
   }
   return primes;   
}

console.log(sieveOfEratosthenes(1000));
                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

/**
 * 2016-03-02
 * @author Sam Yiming Miao
 */
package ch.toastgott.programmieraufgaben;

public class Primzahlen {
	public static void main(String[] args) {
		int divisor = 1;
		int figure = 2;
		while (figure <= 1000) {
			if (figure%divisor == 0) {
				if (figure == divisor) {
					System.out.println(figure);
					figure++;
					divisor = 1;
				} else {
					if (divisor == 1) {
						divisor++;
					} else {
						figure++;
						divisor = 1;
					}
				}
			} else {
				divisor++;
			}
		}
	}
}
                

Lösung von: Sam Yiming Miao (Schule ist gut genug)

package ch.FastByte22.Programmieraufgaben;

/**
 * 
 * 02.03.2016
 * 
 * @author David Wu
 *
 */
public class PrimzahlBis1000 {
    public static void main(String[] args) {
	boolean prim[]=new boolean[1001];
	//Setzen aller Werte auf Prim
	for(int i=0;i<prim.length;i++) {
	    prim[i]=true;
	}
	//Filterung,Makierung der Nichtprimzahlen
	for(int i=2;i<=500;i++) {
	    int a=i*2;
	    prim[a]=false;
	}
	for(int i=2;i<=333;i++) {
	    int a=i*3;
	    prim[a]=false;
	}
	for(int i=2;i<=200;i++) {
	    int a=i*5;
	    prim[a]=false;
	}
	for(int i=2;i<=142;i++) {
	    int a=i*7;
	    prim[a]=false;
	}
	//Ausgabe der Nichtmakierten    
	for(int i=2;i<prim.length;i++) {
	    if(prim[i]) {
		int a=i;
		System.out.print(a+" ");
	    }
	}
    }

}

                

Lösung von: David Wu (Gut-genug.com)

L=[i for i in range(2,1000)]
sieb=L[:]
for a in range(2,len(L)):
    for b in sieb:
        if b!=a and b%a==0: sieb.remove(b)
for a in sieb: print(a)
                

Lösung von: rob ert (tub)

// C++ 14 | VS-2022
#include <iostream>
#include <vector>
using vb = std::vector<bool>;

auto sieve(vb &v) {
	for (size_t i{ 2 }; i < sqrt(v.size()); ++i) 
		for (size_t k{ i * i }; k < v.size(); k += i)
			v[k] = true;
}

auto print(const vb &v) {
	for (size_t i{ 2 }; i < v.size(); i++)
		if(!v[i]) std::cout << i << " ";
}

int main() {
	auto vec{ vb(1'000, false) };
	sieve(vec);
	print(vec);
}
                

Lösung von: Jens Kelm (@JKooP)

// NET 7.x | C# 11.x | VS-2022
static void Sieve(ref List<bool> r_lst) {
	for (var i = 2; i < Math.Sqrt(r_lst.Count); i++)
		for (var k = i * i; k < r_lst.Count; k += i)
			r_lst[k] = true;
}
var nums = new List<bool>(new bool[1000]);
Sieve(ref nums);
for (var i = 2; i < nums.Count; i++)
	if(!nums[i]) Console.WriteLine(i);
                

Lösung von: Jens Kelm (@JKooP)