Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Primzahlen bis 1000 (Felder)

Es sollen mithilfe des Sieb des Eratosthenes alle Primzahlen bis 1000 gefunden und ausgegeben werden.

Sieb des Eratosthenes: Sieb des Eratosthenes (Wikipedia)

Hinweis: Um die Nicht-Primzahlen im Feld zu markieren, braucht man eine Schleife von 2 bis 31. Die Vielfachen dieser Zahlen grenzen die Primzahlen ein.

2 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

Kommentare (2)

gressly 29. Dezember 2012 21:43   reply report
Viele Lösungen zu dieser Aufgabe auf
http://rosettacode.org/wiki/Sieve_of_Eratosthenes
gressly 29. Dezember 2012 21:40   reply report
Beinahe die selbe Aufgabe ist bereits vorhanden (bei den noch nicht freigegebenen Aufgaben).
Was ist der Nutzen, diese Aufgabe nochmals zu erwähnen?
Ohne triftigen Grund, werde ich mir erlauben, die Aufgabe ersatzlos zu streichen.

10 Lösung(en)

(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)

Verifikation/Checksumme:

2,3,5,7,11,13,17,19,23,29,31,37; 41; 43; 47; 53; 59; 61; 67; 71; 73; 79; 83; 89; 97; 101; 103; 107; ....

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 1
Schwierigkeit: Mittel
Webcode: s7eb-mkfk
Autor: ()

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen