Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Kleinste - durch Zahlenreihe von 1 bis 10 - teilbare Zahl. (Schleifen)

Die kleinste positive Zahl, die durch alle Zahlen von 1 bis 10 ohne Rest teilbar ist, ist die 2520.

Schreibe ein Programm mit der die kleinste positive Zahl ermittelt werden kann, die durch alle Zahlen von 1 bis 20 ohne Rest teilbar ist.

5 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

Kommentare (5)

Tobi93 2. Mai 2014 16:17   reply report
Was durch 20 teilbar ist, ist auch durch 10 und 5 teilbar.
Was durch 18 teilbar ist, ist auch durch 9 und 3 teilbar.

Führt man diesen Gedanken etwas weiter, sieht man, dass man nicht wirklich die Teilbarkeit durch die Zahlenreihe von 1 bis 20 überprüfen muss, sondern, dass es ausreicht, wenn man die Teilbarkeit von 11 bis 20 überprüft.

Die gesuchte Zahl hat bei mir einen Initialwert von 21 (Zahlenreihenmaximum + 1). Die Schleife läuft von 11 bis 20 (einschließlich). Falls die gesuchte Zahl nicht teilbar ist durch die aktuelle Zahl in der Zahlenreihe, inkrementiere ich die gesuchte Zahl nicht nur um 1, sondern addiere zusätzlich die aktuelle Zahl hinzu, bei der die Überprüfung fehlschlug.
Beispiel:
gesuchte_zahl = 21
aktueller_teiler = 11
21 % 11 != 0, also:
gesuchte_zahl = gesuchte_zahl + aktueller_teiler + 1
gesuchte_zahl = 33
Danach wird aus der Schleife gesprungen.
Matze8787 1. März 2014 09:43   reply report
Coole Aufgabe, hat Spaß gemacht zu lösen.
crouser 4. Februar 2014 14:45   reply report
gressly
crouser
Also man könnte es jetzt genau nehmen und sagen, dass du falsch liegst. Die kleinste Zahl die nicht negativ ist wäre Null, die kleinste Zahl die positiv ist wäre wohl die 2520, auch wenn ich es nicht überprüft habe, gehe ich davon aus dass das, was in den Angaben steht richtig sein dürfte. Wenn mans dann sehr genau nimmt müsste man eigentlich sagen dass diese Aufgabe so nicht möglich ist, da negative Zahlen, desto größer sie im Zeichenwert werden, immer kleiner werden. Insofern würde diese Aufgabe wohl ins Unendliche gehen.

Stimmt, so genau habe ich es nicht genommen, als ich die Aufgabe gelöst habe. Müsste wohl "die kleinste positive natürliche Zahl" heißen.

Ich hab das in meiner Lösung mal etwas weiträumiger gestaltet. Dementsprechend auch die Zeilenanzahl. Entschuldigung für mein Deutsch/Englisch gemisch bei den Variablennamen.
gressly 4. Februar 2014 13:58   reply report
crouser
Also man könnte es jetzt genau nehmen und sagen, dass du falsch liegst. Die kleinste Zahl die nicht negativ ist wäre Null, die kleinste Zahl die positiv ist wäre wohl die 2520, auch wenn ich es nicht überprüft habe, gehe ich davon aus dass das, was in den Angaben steht richtig sein dürfte. Wenn mans dann sehr genau nimmt müsste man eigentlich sagen dass diese Aufgabe so nicht möglich ist, da negative Zahlen, desto größer sie im Zeichenwert werden, immer kleiner werden. Insofern würde diese Aufgabe wohl ins Unendliche gehen.

Stimmt, so genau habe ich es nicht genommen, als ich die Aufgabe gelöst habe. Müsste wohl "die kleinste positive natürliche Zahl" heißen.
crouser 4. Februar 2014 12:49   reply report
Also man könnte es jetzt genau nehmen und sagen, dass du falsch liegst. Die kleinste Zahl die nicht negativ ist wäre Null, die kleinste Zahl die positiv ist wäre wohl die 2520, auch wenn ich es nicht überprüft habe, gehe ich davon aus dass das, was in den Angaben steht richtig sein dürfte. Wenn mans dann sehr genau nimmt müsste man eigentlich sagen dass diese Aufgabe so nicht möglich ist, da negative Zahlen, desto größer sie im Zeichenwert werden, immer kleiner werden. Insofern würde diese Aufgabe wohl ins Unendliche gehen.

24 Lösung(en)

package ch.programmieraufgaben.iteration;

/**
 * Programmieraufgaben.ch  Web Code:  047j-o2x5
 * @author Philipp Gressly (phi@gressly.ch)
 */
/*
 * History: first Implementation: Feb 4, 2014
 * Bugs   :
 */
public class Kleinste_durch_1_bis_20_teilbare_Zahl {
  public static void main(String[] args) {
    new Kleinste_durch_1_bis_20_teilbare_Zahl().top();
  }
  
  void top() {
     long zahl = 11;
     while(! teilbarDurchAlle(zahl)) {
         zahl = zahl + 1;
     }
     System.out.println("Die kleinste Zahl, welche durch alle Zahlen von 1 bis 20 teilbar ist, lautet: " + zahl);
  }
  
  boolean teilbarDurchAlle(long zahl) {
     int teiler = 2; // durch 1 ist sie sowieso teilbar
     while(teiler <= 20) {
        if(0 != zahl % teiler) {
            return false;
        }
        teiler = teiler + 1;
     }
     return true;
  }
  
}  // end of class Kleinste_durch_1_bis_20_teilbare_Zahl
                

Lösung von: Philipp Gressly Freimann (SANTIS Training AG)

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

public class KTZx_y {

    private boolean show = false;

    // Ermittelt die kleinste teilbare Zahl
    private long ermittleKTZ(ArrayList<Integer> zahlenbereich) {
        // true wenn Zahl gefunden
        boolean zahl;
        // Anzahl der Einträge im Zahlenbereich
        int length = zahlenbereich.size();
        // o wird so lange erhöht bis es die gesuchte Zahl ist
        for (long o = 1; o > -1; o++) {
            zahl = true;
            /*
             * Überprüft ob das momentane o die gesuchte Zahl ist. Wenn nicht
             * wird weiter generiert
             */
            for (int i = 0; i < length; i++) {
                if (zahlenbereich.get(i) == 0) {
                    continue;
                }
                if (o % zahlenbereich.get(i) != 0) {
                    zahl = false;
                    break;
                }
            }
            // Gibt o wieder, wenn zahl true ist
            if (zahl) {
                return o;
            }
            // Gibt die zuletzt generierte Zahl aus wenn show true
            if (show) {
                System.out.println(o);
            }
        }
        /*
         * Tritt nicht ein, muss aber weil java nicht erkennt, dass die erste
         * Schleife eine Dauerschleife ist, die solange läuft, bis die Zahl
         * gefunden wurde.
         */
        return 0;
    }

    // Liest eine Integer ein
    private int readInt() {
        try {
            // Eingelesen
            return new Scanner(System.in).nextInt();
        } catch (Exception e) {
            // Wenn ungültige Eingabe
            return 0;
        }
    }

    // Hauptmethode
    public static void main(String[] args) {
        // Objekt der Klasse (kleinste teilbare Zahl)
        KTZx_y ktz = new KTZx_y();

        // Liest die kleinste und die größte Zahl durch die geteilt werden soll
        // ein
        System.out.println("Kleinste Zahl durch die Teilbar sein soll:");
        int kleinste = ktz.readInt();
        System.out.println("Größte Zahl durch die Teilbar sein soll:");
        int groesste = ktz.readInt();

        // Lässt Benutzer entscheiden, ob er die generierten Zahlen sehen möchte
        System.out.println("Sollen die generierten Zahlen ausgegeben werden? Y/N");
        if (new Scanner(System.in).nextLine().toUpperCase().equals("Y")) {
            ktz.show = true;
        }
        // Beinhaltet die Ganzzahlen des Zahlenbereiches der Teiler
        ArrayList<Integer> zahlenbereich = new ArrayList<Integer>();

        // Füllt die Liste mit den Ganzzahlen
        for (; kleinste < groesste + 1; kleinste++) {
            zahlenbereich.add(kleinste);
        }

        // Gibt das Ergebniss aus
        System.out.println("Die kleinste positive Zahl, die sich durch diesen Zahlenbereich Teilen lässt, ist: "
                + ktz.ermittleKTZ(zahlenbereich));

        // Wartet auf einen Enterdruck um dem Benutzer Lesezeit einzuräumen
        try {
            System.out.println("Enter zum beenden");
            System.in.read();
        } catch (Exception e) {
        }
    }
}

                

Lösung von: Sebastian Littel ()

class Prog
{
	static boolean check(int x)
	{
		for(int i = 2; i <= 20; i++)
			if(x%i != 0)return false;
		return true;
	}
	
	public static void main(String args[])
	{
		int i = 1;
		while(!check(i))i++;
		System.out.println("Ergebnis: " + i);
	}
}
                

Lösung von: Christian :) (Hochschule Merseburg)

def teilbar(zahl,teilers):
    # pruefe ob I:zahl durch alle zahlen bis I:teilers teilbar ist
    for el in range(teilers):
        if float(zahl) % float(el+1)==0:
            pruef=1
        else:
            return 0
    return pruef
            
def kleinsteTeilbare(zahl):
    temp=2.0
    while teilbar(temp,zahl)!=1:
        temp+=1
    return int(temp)

n=10

print "die kleinste Zahl, die durch die Zahlen von 1 bis " + str(n) + " teilbar ist, lautet: " + str(kleinsteTeilbare(n))

                

Lösung von: Uwe Hernandez Acosta (TU Dresden)

#include <iostream>
#include <stdlib.h>

#define LENGTH 20

int main (int argc, const char* argv[]) {
    std::cout << "Hey, trying to find the smallest number which can be devided through 1 to " << LENGTH << "..." << std::endl;
    
    if (argc != 1) {
        std::cout << "Unexpected Parameters: Exiting..." << std::endl;
        return EXIT_FAILURE;
    }
    
    bool foundNumber = false;
    int matches = 0;
    
    for (int i = 1; foundNumber != true; i++) {
        for (int j = 1; j <= LENGTH; j++) {
            if (i % j == 0){
                matches++;
                
                if (matches == LENGTH) {
                    foundNumber = true;
                    std::cout << "Found the number: " << i << std::endl;
                }
            }
        }
        matches = 0;
    }
    
    return EXIT_SUCCESS;
}
                

Lösung von: Matthias Sayler (Valeo)

; nicht LISP sondern Clojure
(first
	(filter
		(fn [x]
			(and
				(> x 0)
				(every?
					(fn [y] (zero? (rem x y)))
					(range 20 0 -1)
				)
			)
		)
		(range)
	)
)
                

Lösung von: Name nicht veröffentlicht

// Autor: Tobias B.
public class SmallestMultiple {

	public static void main(String[] args) {
		System.out.println(getSmallestMultipleOfRange(11, 20));
	}


	public static int getSmallestMultipleOfRange(int start, int end) {
		int     multiple = end + 1;
		boolean found    = false;

		while (!found) {
			found = true;

			for (int number = start; number <= end; ++number) {
				if (multiple % number != 0) {
					multiple += number + 1;
					found = false;
					break;
				}
			}
		}

		return multiple;
	}
}
                

Lösung von: Name nicht veröffentlicht


//F#

let maxDiv = 20
let mutable num = 1

let chkDiv num =
    seq {1..maxDiv}
    |> Seq.forall 
        (fun x -> num % x = 0)

while not <| (chkDiv num) 
    do num <- num + 1
    
printfn "Number Found : %d" num
                

Lösung von: Vural Acar ()

class Zahlenreihe { 
     def berechnung(i){
     for (j in 2..10)
       if  (i % j != 0) 
           return false             
     return true        
     }
}
def zahlenreihe = new Zahlenreihe()
def i=1
while (zahlenreihe.berechnung(i) != true) 
    i++
println i
                

Lösung von: Sebastian Obst (HS Albstadt / Sigmaringen)


public class kleinsteTeilbare 
{
	public static void main(String[] args)
	{
		int num = 1;
		int count = 0;
		
		do
		{
			count = 0;
			for(int i = 1; i < 20; i++)
			{				
				if(num % i != 0) break;
				else count++;
			}
			
			if(count == 19) 
			{
				System.out.println(num); 
				break;
			}
			
			num++;
		}while(true);

	}
}

                

Lösung von: Daniel Hu (Ludwig-Geissler-Schule )

/**
 * Die kleinste positive Zahl, die durch alle Zahlen von 1 bis 10 ohne Rest
 * teilbar ist, ist die 2520. Schreibe ein Programm mit der die kleinste
 * positive Zahl ermittelt werden kann, die durch alle Zahlen von 1 bis 20 ohne
 * Rest teilbar ist.
 * 
 * @author rober_000
 *
 */

public class kleinste_teilbare_Zahl {

	public static void main(String[] args) {
		int i = 1;
		while (!check(i)) {
			i++;
		}
		System.out.println(i);

	}

	private static boolean check(int x) {
		for (int i = 2; i <= 10; i++) {
			if (x % i != 0) {
				return false;
			}
			
		}
		return true;

	}

}

                

Lösung von: Robert König (Universität Passau)

 static class Program
    {
       

        static void Main()
        {
            for (int i = 19000000; i != 0; i=i+19)
            {
                int teiler = 0;
                for (int ii = 1; ii <= 20; ii++)
                {

                    if (i%ii != 0)
                    {
                        break;
                    }
                    else teiler++;
                }
                if (teiler>=20)
                {
                   Console.WriteLine(i);
                    Console.ReadLine();
                }
            }
        }

    }
                

Lösung von: Name nicht veröffentlicht

function checkTeiler ()
	{
		//pruefwert auf falsch setzen
		$pruefwert	= false;
		$zahl = 1;
		
		while ($pruefwert == false)
		{
			//solange keine Lösung existiert
			for ($i = 11;$i <21;)
			{
				if ($zahl % $i == 0)
				{
					$i++;					
				}
				
				else 
				{
					$i = 11;
					$zahl++;
				}
				
			}
                        //Lösung gefunden
			$pruefwert = true;
		}
                //Zahl formatiert ausgeben
		echo number_format($zahl, 0 ,",", ".");
		
	}
                

Lösung von: Name nicht veröffentlicht

public class smallestNumber {

	public static void main(String[] args) {
		int candidate = 19, inspector = 1;
		while (inspector < 20) {
			if (candidate % inspector != 0) {
				candidate += 19;
				inspector = 1;
				continue;
			}
			inspector++;
		}
		System.out.println(candidate);
	}
}

                

Lösung von: Frieder Moßmann (-)

my ($number,$check) = (0,0);
while(1){
    ++$number;
    $check=0;
    for(1..10){
        unless($number%$_==0){++$check;last;}
    } 
    last unless($check);
}
print "$number\n";
                

Lösung von: Paul Scheinast (http://scheinast.eu)

function getLeastMultiple(num) {
   var factors = [],
       x, y;
   // faktoren auffüllen [1 .. x]
   for (x = 0; x < num; x++) factors[x] = x + 1;
   // faktoren kürzen (von links nach rechts)
   for (x = 1; x < factors.length; x++)
      for (y = x + 1; y < factors.length; y++) 
         if(factors[y] % factors[x] == 0) factors[y] /= factors[x];      
   // faktoren aufmultiplizieren und zurückgeben
   return eval(factors.join("*"));
}

console.log(getLeastMultiple(prompt("Obergrenze:")));
                

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

namespace Uebung_20TeilbareZahl
{
    class Program
    {
        static void Main(string[] args)
        {
            int zahl = 0;
            bool x = true;
            while(x == true){
                zahl++;
                for (int i = 1; i <= 20; i++)
                {
                    if (zahl % i != 0)
                    {
                        break;
                    }
                    else if (zahl % i == 0 && i == 20)
                    {
                        x = false;
                        break;
                    }
                }
            }
            Console.WriteLine(zahl);
            Console.ReadKey();
        }
    }
}

                

Lösung von: Loris Leuenberger (BiCT AG)

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

import java.util.Scanner;

public class KleinstesGemeinsamesProdukt {
	public static void main(String[] args) {	
		int biggestfactor = 20;
		int candidate = 1;
		while (true) {
			if (candidate%biggestfactor == 0) {
				biggestfactor--;
				if (biggestfactor == 0) {
					System.out.print("Das kleinste gemeinsame Produkt der Zahlen 1 bis ");
					System.out.println("20 ist " + candidate + ".");					
					break;
				}
			} else {
				candidate++;
				biggestfactor = 20;
			}
		}
	}
}
                

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

package ch.FastByte22.Programmieraufgaben;
/**
 * 
 * @author David Wu
 *
 */
public class KleinsteZahl {
    public static void main(String[] args) {
	int zahl = 1;
	boolean a = false;
	while (true) {
	    for (int i = 1; i <= 20; i++) {
		if (zahl % i == 0) {
		    a=true;
		}else {
		    a=false;
		    break;
		}
	    }
	    if (a) {
		break;
	    }
	    zahl++;
	}
	System.out.println(zahl);
    }
}

                

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

Module Module1
    Sub Main()
        Dim count As Integer = 0
        Dim max As Integer = 25
        Dim rightCounter As Integer = 0

        Console.WriteLine("Berechne...")
        While True
            count += 1
            rightCounter = 0

            For i As Integer = 1 To max
                If count Mod i = 0 Then
                    If rightCounter = max - 1 Then
                        Console.WriteLine("Ergebniss: " & count)
                        Exit While
                    Else
                        rightCounter += 1
                    End If
                Else
                    rightCounter = 0
                    Exit For
                End If
            Next
        End While

        Console.ReadLine()
    End Sub
End Module
                

Lösung von: Elias Zech (Optics Balzers)

<?php
$zahl=1;
$re = 10;
while(true){
  $i=11;
  while($i <= $re){
    if(($zahl % $i) == 0){
      $i++;
    }
    else{
      //echo("break");
      break;
    }
  }
  if($i-1==$re){break;}
  $zahl++;
}
echo($zahl);
?>
                

Lösung von: Max Möckel ()

/*
 Die kleinste positive Zahl, die durch alle Zahlen von 1 bis 10 ohne Rest teilbar ist, ist die 2520.
 
 Schreibe ein Programm mit der die kleinste positive Zahl ermittelt werden kann, die durch alle Zahlen von 1 bis 20 ohne Rest teilbar ist.
 
 Lösung = 232792560
 
 */
#include<stdio.h>

int main()
{
    for(int i = 1;i <= 300000000;i++)
    {
        if(
           i % 1 == 0 &&
           i % 2 == 0 &&
           i % 3 == 0 &&
           i % 4 == 0 &&
           i % 5 == 0 &&
           i % 6 == 0 &&
           i % 7 == 0 &&
           i % 8 == 0 &&
           i % 9 == 0 &&
           i % 10 == 0 &&
           i % 11 == 0 &&
           i % 12 == 0 &&
           i % 13 == 0 &&
           i % 14 == 0 &&
           i % 15 == 0 &&
           i % 16 == 0 &&
           i % 17 == 0 &&
           i % 18 == 0 &&
           i % 19 == 0 &&
           i % 20 == 0
           )
        {
            printf("|%d|\n", i);
            return 0;
        }
        
    }
    printf("Nichts gefunden!\n");
    return 1;
}

                

Lösung von: Carlo con_carne ()

'03.06.2017 - Powerbasic 10

''2 Lösungswege....

#COMPILE EXE
#DIM ALL

FUNCTION PBMAIN () AS LONG
    DIM Teiler(2 TO 10) AS QUAD
    DIM Teilbar AS BYTE
    DIM Zahl AS QUAD
    DIM i AS BYTE

''_________VARIANTE 1________
'Teiler durchrechnen und markieren ob Teilbar oder nicht
DO WHILE Teilbar < 1
    INCR Zahl
    FOR i = LBOUND(Teiler) TO UBOUND(Teiler)
        IF Zahl MOD i <> 0 THEN
            Teilbar = 0
            EXIT FOR
        ELSE
            Teilbar = 1
        END IF
    NEXT i
LOOP

MSGBOX FORMAT$(Zahl),,EXE.NAME$


''Variablen zurücksetzen für
Teilbar = 0
Zahl = 0

''_________VARIANTE 2________
'hochzählen, bei wievielen Operationen die Teilbarkeit gegeben ist.
'Wenn mit Anzahl Berechnungen übereinstimmend -> Treffer
    DO WHILE Teilbar < UBOUND(Teiler)-1
        INCR zahl
        Teilbar = 0
        FOR i = LBOUND(Teiler) TO UBOUND(Teiler)
            IF Zahl MOD i = 0 THEN
                INCR Teilbar
            ELSE
                EXIT FOR
            END IF
        NEXT i
    LOOP


MSGBOX FORMAT$(Zahl),,EXE.NAME$

END FUNCTION


                

Lösung von: Markus Sägesser (keine)

#!/usr/bin/env python3


def divBy(a, b):
    return a % b == 0

n = 20

while True:
    for i in range(1, 21):
        if not divBy(n, i):
            break
    else:
        break

    n += 20


print (n)
                

Lösung von: Osh Gnacknak ()

Verifikation/Checksumme:

1-10: 2520

1-20: 232792560

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 1
Schwierigkeit: Mittel
Webcode: 047j-o2x5
Autor: ()

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen