Grosses einmaleins 5er Block Ausgabe

[jaykop]

Hallo,

ich habe hier einen Code der das Einmaleins von 11*11 bis 11*20 ausgibt in 5er Blöcken nebeneinander. Jedoch versuche ich dies so weit zu ändern das es bei jedem einmal eins die man eingibt immer nur 5er Blöcke nebeneinander ausgibt. z.B wären das ja bei Einmaleins von 11*11 bis 11*25 genau 3 reihen in 5er Blöcken. Hätte da einer vielleicht einen Ansatz wie man das realisieren könnte? oder habt ihr vielleicht Verbesserungsvorschläge zu dem aktuellen Code.

    public static void main(String[] args) {

        int einmaleins = 20;
        int i;
        int zw;
        int erg;
        int j = 0;

        // einmaleins Tabelle bis 11*15 START
        for (i = 11; einmaleins >= i; i++) {
            zw = einmaleins - 5;
            for (j = 11; zw >= j; j++) {
                erg = i * j;
                System.out.print(i + " * " + j + " = " + erg + "\t");
            }
            System.out.println();
        }
        // einmaleins Tabelle bis 11*15 ENDE

        // Absatz nach 5er Block START
        System.out.println();
        System.out.println();
        // Absatz nach 5er Block ENDE

        // einmaleins Tabelle bis 11*20 START
        if (i > einmaleins) {
            for (i = 11; einmaleins >= i; i++) {
                zw = einmaleins - 5;
                for (j = zw + 1; einmaleins >= j; j++) {
                    erg = i * j;
                    System.out.print(i + " * " + j + " = " + erg + "\t");
                }
                System.out.println();
            }
        }
        // einmaleins Tabelle bis 11*20 ENDE
    }

..::AUSGABE::..

11 * 11 = 121	11 * 12 = 132	11 * 13 = 143	11 * 14 = 154	11 * 15 = 165	
12 * 11 = 132	12 * 12 = 144	12 * 13 = 156	12 * 14 = 168	12 * 15 = 180	
13 * 11 = 143	13 * 12 = 156	13 * 13 = 169	13 * 14 = 182	13 * 15 = 195	
14 * 11 = 154	14 * 12 = 168	14 * 13 = 182	14 * 14 = 196	14 * 15 = 210	
15 * 11 = 165	15 * 12 = 180	15 * 13 = 195	15 * 14 = 210	15 * 15 = 225	
16 * 11 = 176	16 * 12 = 192	16 * 13 = 208	16 * 14 = 224	16 * 15 = 240	
17 * 11 = 187	17 * 12 = 204	17 * 13 = 221	17 * 14 = 238	17 * 15 = 255	
18 * 11 = 198	18 * 12 = 216	18 * 13 = 234	18 * 14 = 252	18 * 15 = 270	
19 * 11 = 209	19 * 12 = 228	19 * 13 = 247	19 * 14 = 266	19 * 15 = 285	
20 * 11 = 220	20 * 12 = 240	20 * 13 = 260	20 * 14 = 280	20 * 15 = 300	


11 * 16 = 176	11 * 17 = 187	11 * 18 = 198	11 * 19 = 209	11 * 20 = 220	
12 * 16 = 192	12 * 17 = 204	12 * 18 = 216	12 * 19 = 228	12 * 20 = 240	
13 * 16 = 208	13 * 17 = 221	13 * 18 = 234	13 * 19 = 247	13 * 20 = 260	
14 * 16 = 224	14 * 17 = 238	14 * 18 = 252	14 * 19 = 266	14 * 20 = 280	
15 * 16 = 240	15 * 17 = 255	15 * 18 = 270	15 * 19 = 285	15 * 20 = 300	
16 * 16 = 256	16 * 17 = 272	16 * 18 = 288	16 * 19 = 304	16 * 20 = 320	
17 * 16 = 272	17 * 17 = 289	17 * 18 = 306	17 * 19 = 323	17 * 20 = 340	
18 * 16 = 288	18 * 17 = 306	18 * 18 = 324	18 * 19 = 342	18 * 20 = 360	
19 * 16 = 304	19 * 17 = 323	19 * 18 = 342	19 * 19 = 361	19 * 20 = 380	
20 * 16 = 320	20 * 17 = 340	20 * 18 = 360	20 * 19 = 380	20 * 20 = 400

 

[SlaterB]

du brauchst um deine Doppel-Schleife mit i und j nur eine weitere Schleife herumzulegen,
z.B. für k, welches bei 11 oder sonstigen Startwert beginnt und immer um 5 ansteigt, das ist erlaubt statt ++

innen drin musst du dann natürlich so umbauen, dass mit k statt mit festen Werten gearbeitet wird,

um 10 Zeilen untereinander zu bekommen benutzt du eine Schleife,
was ist jetzt bei x 10er-Blöcken anders?
alles strukturierte kann in Schleifen wiederholt werden

 

[jaykop]

mit drei schleifen kriege ich das irgend wie nicht hin deswegen habe ich bei dem ersten Beitrag das Problem nur so gelöst das es wenigsten das von 11*11 bis 11*20 in 5er Blöcken anzeigt. Für andere Multiplikationen fünktioniert der code halt nicht.

Mein bisheriger stand mit der Schleife:

    public static void main(String[] args) {

        int einmaleins = 20;
        int i = 11;
        int zw;
        int erg;
        int j = 0;
        int k = 0;

        // einmaleins Tabelle
        for (k = i; einmaleins >= k; k += 5) {
            if (k % 5 == 0) {
                for (; k >= i;i++) {
                    for (j = 11; k >= j;++j) {
                        erg = i * j;
                        System.out.print(i + " * " + j + " = " + erg + "\t");
                    }
                    
                    System.out.println();
                }

            } else {
                zw = k % 5;
                k -= zw;
            }

        }}}

Ausgabe:

11 * 11 = 121	11 * 12 = 132	11 * 13 = 143	11 * 14 = 154	11 * 15 = 165	
12 * 11 = 132	12 * 12 = 144	12 * 13 = 156	12 * 14 = 168	12 * 15 = 180	
13 * 11 = 143	13 * 12 = 156	13 * 13 = 169	13 * 14 = 182	13 * 15 = 195	
14 * 11 = 154	14 * 12 = 168	14 * 13 = 182	14 * 14 = 196	14 * 15 = 210	
15 * 11 = 165	15 * 12 = 180	15 * 13 = 195	15 * 14 = 210	15 * 15 = 225	
16 * 11 = 176	16 * 12 = 192	16 * 13 = 208	16 * 14 = 224	16 * 15 = 240	16 * 16 = 256	16 * 17 = 272	16 * 18 = 288	16 * 19 = 304	16 * 20 = 320	
17 * 11 = 187	17 * 12 = 204	17 * 13 = 221	17 * 14 = 238	17 * 15 = 255	17 * 16 = 272	17 * 17 = 289	17 * 18 = 306	17 * 19 = 323	17 * 20 = 340	
18 * 11 = 198	18 * 12 = 216	18 * 13 = 234	18 * 14 = 252	18 * 15 = 270	18 * 16 = 288	18 * 17 = 306	18 * 18 = 324	18 * 19 = 342	18 * 20 = 360	
19 * 11 = 209	19 * 12 = 228	19 * 13 = 247	19 * 14 = 266	19 * 15 = 285	19 * 16 = 304	19 * 17 = 323	19 * 18 = 342	19 * 19 = 361	19 * 20 = 380	
20 * 11 = 220	20 * 12 = 240	20 * 13 = 260	20 * 14 = 280	20 * 15 = 300	20 * 16 = 320	20 * 17 = 340	20 * 18 = 360	20 * 19 = 380	20 * 20 = 400

 

[SlaterB]

das mit dem if/else ist nicht gut, jeder Schleifendurchlauf von k hat seinen Sinn, soll auch was schaffen

zudem hast du die i-Schleife etwas kaputt gemacht, i wird nie mehr zurückgesetzt? das kann ja nirgendwo hinführen

so dachte ich mir das als erste Variante:

public class Test {
    public static void main(String[] args)  {
        int einmaleins = 25;
        int start = 11;

        // einmaleins Tabelle
        for (int k = 11; einmaleins >= k; k += 5)  {
            for (int i = 11; einmaleins >= i; i++)     {
                for (int j = k; j <= k + 5; j++)  {
                    int erg = i * j;
                    System.out.print(i + " * " + j + " = " + erg + "\t");
                }
                System.out.println();
            }
            System.out.println();
        }
    }
}

falls mal nicht genau ganze 5er-Zeilen zu füllen sind sondern am Ende vielleicht nur 1-4, muss man natürlich noch weiter verbessern,

dass ich Variablen wie zw gestrichen habe heißt nicht dass sie nie mehr reinkommen dürfen,
im Moment waren sie doch aber reichlich überflüssig,
alles läßt sich von den konkreten Randzahlen (start besser als i, einmaleins) und k berechnen

Schleifenvariablen wann immer möglich genau im Schleifenkopf deklarieren,
das verhindert automatisch manche verrückte Verwendung wie das i in deinem letzten Code