Erste Schritte Hausaufgaben-Prob. - Iterative Prog. Zahlen aufsummieren, wenn durch k>0 teilbar.

[Foxtrot]

Hallo liebes Board!

Studiere nun Wirtschaftsinformatik und mache gerade meine ersten Schritte in Java. Doch leider hänge ich seit ca. 2,5 Stunden an folgenden Problem:

Aufgabe:
Zahlen von m bis einschließlich n aufsummieren, falls diese durch k>0 teilbar sind.

Z.B.:
int sumDivisible (int m, int n, int k) -> m= 1, n=10, k=3; -> 3 + 6 + 9 = 18
(da 3, 6, 9 ohne Rest durch 10 teilbar).

Folgendes habe ich bereits geschrieben:

public static void main(String[] args) {
// 3 + 6 + 9 = 18

int start = 1;
int wert = start - 1;

for(int i=wert; i<10; i++) {
wert = wert + 1;

if((wert % 3) == 0) {
int ok = wert;
System.out.println(ok);
...

Ich "filtere" somit die 3 benötigten Zahlen (3, 6, 9) heraus. - Jetzt müsste ich diese aber irgendwie summieren, damit ich auf das Ergebnis 18 komme.

Hat jemand eine Idee? - Würde mir sehr helfen!

Danke!

 

[klauskarambulut]

Zahlen von m bis einschließlich n aufsummieren, falls diese durch k>0 teilbar sind.
Schritt 1:

//Zahlen von m bis einschließlich n
for(int zahl = m; zahl <=n; zahl++) {

}

Schritt 2:

for(int zahl = m; zahl <=n; zahl++) {
  //falls durch k>0 teilbar
  if(zahl % k == 0) {
    // hier kommt das rein, was in diesem Fall passieren soll
  }
}

Schritt 3:

// startwert auf den aufsummiert werden soll
int summe = 0;
for(int zahl = m; zahl <=n; zahl++) {
  if(zahl % k == 0) {
    // aufsummieren
    summe = summe + zahl;
  }
}

Schritt 4:

public static void main(String...args) {
//  Werte für n,m,k setzen
  int n = ?;
  int m = ?;
  int k = ?;
  int summe = 0;
  for(int zahl = m; zahl <=n; zahl++) {
    if(zahl % k == 0) {
      summe = summe + zahl;
    }
  }
  System.out.println("Summe: "+summe);
}

Schritt 5:

public static void main(String...args) {
  int n = ?;
  int m = ?;
  int k = ?;
  // Funktion extrahieren
  int result = sumDivisible (m, n, k);

  System.out.println("Summe: "+result);
}

public static int sumDivisible(int m, int n, int k) {  
  int summe = 0;
  for(int zahl = m; zahl <=n; zahl++) {
    if(zahl % k == 0) {
      summe = summe + zahl;
    }
  }
  return summe;
}

 

[Foxtrot]

Hallo klauskarambulut!

Das ging ja richtig schnell! - Vielen, vielen Dank!!

Ergebnisse stimmen jetzt alle überein!

LG

 

[strußi]

eigentlich kannst du alle zahlen die >k sind aufsummieren da nicht steht, ohne rest teilbar ;-)
am besten gibst du beide lösungen ab

 

[klauskarambulut]

Wenn man noch Klugscheißen möchte, dann kann man auch noch sowas machen.

  public static int sumDivisibleAlt(int m, int n, int k) {
        int from = (m + ((k - (m % k)) % k)) / k;
        int to = (n - (n % k)) / k;
        if (from > to) {
            return 0;
        }
        int diff = to - from + 1;
        return (diff * (to + from) * k) / 2;
    }

Anhand des Beispiels 1, 10 und 3 unter Anwendung grundlegender mathematischer Kenntnisse und der Gaußschen Summenformel. (Früher wohl Realschulniveau)

ist 3 + 6 + 9 nichts anderes als k ( 1+ 2 + 3)

1 + 2 + 3 ist mit der Gaußschen Summenformel berechenbar.

Jetzt muss man nur noch die erste und die letzte Teilbare Zahl finden, wobei modulo hilft und diese durch 3 Teilen und bekommt damit die from und to Werte.

Testen ob es überhaupt was zum Summieren gibt.
Zahlen via Gauß aufsummieren und mit k multiplizieren und man hat das korrekte Ergebnis in Windeseile.

Gegengetestet via Property-Based-Testing mit einer Million Varianten
Läuft immer sauber durch. Spart man sich also die Schleife, was um einiges besser performt.

public class Summs {

    public static void main(String[] args) {
        java.util.Random r = new java.util.Random();
        for (int i = 0; i < 1000000; i++) {
            int m = r.nextInt(10000);
            int n = r.nextInt(10000);
            int k = r.nextInt(100)+1;

            int rA = sumDivisible(m, n, k);
            int rB = sumDivisibleAlt(m, n, k);
            if (rA != rB) {
                System.out.printf("Error for %d %d %d expected<%d> got <%d>%n", m, n, k, rA, rB);
            }
        }

    }

    public static int sumDivisible(int m, int n, int k) {
        int summe = 0;
        for (int zahl = m; zahl <= n; zahl++) {
            if (zahl % k == 0) {
                summe = summe + zahl;
            }
        }
        return summe;
    }

    public static int sumDivisibleAlt(int m, int n, int k) {
        int from = (m + ((k - (m % k)) % k)) / k;
        int to = (n - (n % k)) / k;
        if (from > to) {
            return 0;
        }
        int diff = to - from + 1;
        return (diff * (to + from) * k) / 2;
    }
}

200 Mio. Iteration laufen bei mir mit dem schleifenlosen Ansatz in knapp 6 Sekunden durch.

 

[MWin123]

eigentlich kannst du alle zahlen die >k sind aufsummieren da nicht steht, ohne rest teilbar ;-)

Eine ganze Zahl ist durch eine andere ganze Zahl teilbar, wenn bei der Division kein Rest verbleibt, also die „Geteilt-Rechnung aufgeht“.
https://de.wikipedia.org/wiki/Teilbarkeit