Programmieren lernen

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 G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

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

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

grenze = 20
start = grenze
gesuchteZahl = grenze
treffer = False

while True:
    while gesuchteZahl % start == 0:
        start -= 1
        if start == 0:
            print(gesuchteZahl)
            treffer = True
            break
    if treffer:
        break
    gesuchteZahl += grenze
    start = grenze
                

Lösung von: Peter Pan (Home Office)

using System;

// Programmieraufgaben.ch Aufgaben-Code: 047j-o2x5

namespace TeilerChecker
{
    class Program
    {
        static void Main()
        {
            // Variablen deklarieren
            int[] lookingFor = new int[2] { 1, 20 }; // Bereich der Zahlen die geprüft werden sollen. E.g. Aufgabenstellung 1-20.
            ulong currentTest = 0;
            bool stillLooking = true;
            bool currentAttempt;

            // Berechnung
            Console.WriteLine($"Es wird die erste Zahl gesucht, die durch alle Zahlen von {lookingFor[0]} bis {lookingFor[1]} teilbar ist.\nDies kann eine kurze Zeit beanspruchen.");
            while(stillLooking)
            {
                currentTest++;
                currentAttempt = true;

                // Überprüfen, ob aktuelle Prüfzahl durch die gesuchten Zahlen teilbar ist.
                for (ulong runs = (ulong)lookingFor[0]; currentAttempt && runs <= (ulong)lookingFor[1]; runs++)
                {
                    currentAttempt = (currentTest % runs == 0);
                }
                stillLooking = !currentAttempt;
            }

            // Ausgabe
            Console.Clear();
            Console.WriteLine($"Die erste Zahl, die durch alle Zahlen von {lookingFor[0]} bis {lookingFor[1]} teilbar ist: {currentTest:N0}");
            Console.ReadKey();
        }
    }
}

                

Lösung von: Howard Dennis King (IT-Schule Stuttgart)

import math
print(math.lcm(*range(1,21)))
                

Lösung von: Name nicht veröffentlicht

// C++ 14 | VS-2022
#include <iostream>
#include <vector>
#include <numeric>

// lcm table-method -> https://en.wikipedia.org/wiki/Least_common_multiple
long long lcm(int begin, int end) {
	std::vector<int> v;
	for (auto i{ begin }; i <= end; i++) v.push_back(i);
	for (auto it_a{ v.begin() + 1 }; it_a != v.end(); ++it_a)
		for (auto it_b{ it_a + 1 }; it_b != v.end(); ++it_b)
			if (*it_b % *it_a == 0) *it_b /= *it_a;
	return std::accumulate(v.begin(), v.end(), 1LL, std::multiplies<long long>());
}

int main() {
    std::cout << lcm(1, 10) << "\n";
    std::cout << lcm(1, 20) << "\n";
}
                

Lösung von: Jens Kelm (@JKooP)

' VBA

Function LCM(first As Integer, last As Integer) As Long
    Dim arr() As Variant
    Dim i As Integer, m As Integer, n As Integer
    ReDim arr(last - first)
    
    For i = LBound(arr) To UBound(arr)
        arr(i) = first
        first = first + 1
    Next i
    
    For m = LBound(arr) To UBound(arr)
        For n = m + 1 To UBound(arr)
            If arr(n) Mod arr(m) = 0 Then arr(n) = arr(n) \ arr(m)
        Next n
    Next m
    
    LCM = WorksheetFunction.Product(arr)
    
End Function

Sub Main()
    Debug.Print LCM(1, 10), LCM(1, 20)
End Sub

                

Lösung von: Jens Kelm (@JKooP)