Array multiplikations Problem

Status
Nicht offen für weitere Antworten.

Dieter

Mitglied
ich hab folgendes Problem:

eine beliebige Zahl mit 10000 Stellen wird als Array (int[10000] ) abgespeichert. Nun möchte ich diesen Array mit einer beliebigen int zahl (zb. 354) multiplizieren.
Das Ergebnis soll in dem Ausgansarray wieder abgespeichert werden.


Java:
public void arrayMult(int[] a, int zahl){

// Array durchlaufen
for (int i = 0; i < a.length-1; i++){
  // Jetzt müssen die einzelnen Ziffern im Array mit der Zahl multipliziert werden, und anschließend evt. ein Übertrag stattfinden.

// ???
}

}
 

tfa

Top Contributor
Und wo ist jetzt das Problem? Die Lösung steht doch schon da! Einfach in einer Schleife alle ints multiplizieren und dann (von rechts nach links) die Überträge behandeln.
 

Schandro

Top Contributor
Nun möchte ich diesen Array mit einer beliebigen int zahl (zb. 354) multiplizieren.
Soll jedes einzelne Element des Arrays mit 354 multipliziert werden? Oder was?
wenn ja, schreib in die Schleife:
myArray = myArray * 354;
 
Zuletzt bearbeitet:

Dieter

Mitglied
das Ergebnis soll wieder in einem Array Stehn. Wobei in jeder Zelle des Arrays nur 1 Ziffer (< 10) stehen soll. Das Gesammte Array[10000] soll 1 Zahl darstellen.

bsp.:

int[] a = new int[10000]
a[0] = 0;
a[1] = 4;
a[2] = 8;

wenn ich nun mein Array a * 5 dann soll in einem neuen array (oder das alte überschreiben)

a[0] = 2
a[1] = 4
a[3] = 0

stehen....
 

Oli

Top Contributor
Ok,

dann ist aber mal grundsätlich anzumerken, dass eine Lösung nur möglich ist, wenn das erste Feld die Einer
darstellt, das zweite die Zehner usw...

int[] a = new int[10000]
a[2] = 0;
a[1] = 4;
a[0] = 8;

a * 5

a[3] = 2
a[2] = 4
a[1] = 0


Also wenn du eine Zahl mit 10000 Stellen hat (des ist ja auch superrealistisch) und du diese Zahl multiplizieren willt, dann reicht es nicht jede einzelne "Ziffer" in dem Array mit der zahl zu multiplitieren sondern du muss das so aufbauen wie man das in der Schule gelernt hat:

123456 * 123
-------------
123456
246912
370368
-------------
15185088

So und da das ist dann schon wieder etwas komplizierter... du musst dir für jede Stelle die Multiplikation merken und dann auch noch für den Rechts - Shift bei der Addition sorgen.

Auf Grund der Tatsache, dass du scheinbar nur Arrays verwenden darfst, ergibt eine schöne verschachtelte Schleife.

Nun und nochmals. Der Sinn des ganzen erschließt sich mir immer noch nicht. ( Zahl mit 10000 Stellen? )

Oh. könnte aber auch unsere Staatsverschuldung sein ;-)

Grüße

[EDIT]

Die automatische Formatierung wirft die Leerstellen raus, nun du wirst aber wisssen wie man in der 3. Klasse das Multiplizieren gelernt hat oder?
 

Michael...

Top Contributor
Man kann ja die schriftliche Multiplikation einfach nachbilden das Ergebnis in ein int oder long speichern und dessen Stellen entsprechend in das Array übertragen.
Da das ganze allerdings nach einer Hausaufgabe klingt, vermute ich mal das man da anders vorgehen sollte.
 

Oli

Top Contributor
Hallo Michael,

also ich glaube nicht das long eine 10000 - Stellige Zahl speichern kann
 

faetzminator

Gesperrter Benutzer
ich würde das etwa so realisieren:
Java:
int overflow = 0;
for (int i = array.length - 1; i >= 0; i--) {
    int sum = array[i] * 354 + overflow;
    array[i] = sum % 10;
    overflow = sum - array[i];
}
Anm.:
1. hier könnte es einen Überlauf von int geben...
2. wenn das Array nicht genügend Stellen für die neue Zahl hat, werden die vordersten Stellen einfach abgeschnitten.
 

Michael...

Top Contributor
arrrg! Da habe ich doch glatt die 10000 übersehen:autsch:

Naja, dann brauch mal halt ein zweites Array zu dem man die Zwischenergebnisse aus der "schriftlichen Multilplikation" immer "zuaddiert"
 

Oli

Top Contributor
Richtig des hab ich ja geschrieben. Und nen Mechanismus der den Rechtsschift bei der schriftlichen Multiplikation berücksichtigt.
 

Schandro

Top Contributor
Ranbemerkung: du kannst statt nem Array auch "BigInteger" bzw. "BigDecimal" nehmen, die können beliebig große Zahlen aufnehmen. Außerdem kannst du mit denen dann auch noch rechnen.
 
Zuletzt bearbeitet:

Marco13

Top Contributor
Ich würde dir empfehlen, das ganze so flexibel zu halten, dass du nachher die Basis (10) noch ändern kanns. 10 Macht ja eigentlich keinen Sinn. Wenn schon, dann sollte es 32768 sein. Aber das nur nebenbei. @faetzminator: Sieht schön einfach aus. (Und du weißt, was für Lösungen gilt, die schön einfach aussehen? ;) )
 

Oli

Top Contributor
ARadauer: hm, bei einem Multiplikator >10 unmöglich, würde ich sagen... :)

Schandro: Da ich denke, dass das ne Hausaufgabe ist, wird es wohl nicht erlaubt sein, diese Datentypen zu verwenden... Naja und die implementieren diese Aufgabe ja im Prinzip.
 

Oli

Top Contributor
Marco13: Und die Methode macht nicht das was der Themenstarter wollte. Der macht sich grad auch irgendwie rar. Scheinbar hat er sein Problem gelöst ;-)
 

faetzminator

Gesperrter Benutzer
@ Marco13:

hmm, ich hatte mir den von dir erwähnten Fehler bereits selber überlegt (ein Mal % und ein Mal / müsste es sein), und natürlich hast du recht, folgender Code wäre korrekt:
Java:
public static void calc(int[] array, int mult, int base) {
    int overflow = 0;
    for (int i = array.length - 1; i >= 0; i--) {
        int sum = array[i] * mult + overflow;
        array[i] = sum % base;
        overflow = sum / base;
    }
}

Edit: Das zweite von mir angesprochene Problem wird durch den folgenden Code gelöst, ebenfalls wird ein neues Array zurückgegeben und nicht die Referenz verwendet
Java:
public static int[] calc(int[] inp, int mult, int base) {
    int array[] = new int[inp.length];
    System.arraycopy(inp, 0, array, 0, inp.length);
    int overflow = 0;
    for (int i = array.length - 1; i >= 0; i--) {
        int sum = array[i] * mult + overflow;
        array[i] = sum % base;
        overflow = sum / base;
    }
    while (overflow > 0) {
        int newArr[] = new int[array.length + 1];
        System.arraycopy(array, 0, newArr, 1, array.length);
        array = newArr;
        array[0] = overflow % base;
        overflow /= base;
    }
    return array;
}

PS: Merkt hier irgendwer, dass mir langweilig ist?
 
Zuletzt bearbeitet:

Marco13

Top Contributor
Und da sieht man auch, warum "base" eine Zweierpotenz sein sollte (und sinnvollerweise natürlich die größte, die mit sich selbst multipliziert noch kleiner als Integer.MAX_VALUE ist): Die % und / könnte man dann mit bitoperationen machen.
 

faetzminator

Gesperrter Benutzer
so, ich hab mir nun mal ein paar Minuten genommen, um das halbwegs auszuprogrammieren. Nur die Methode mult(int, int[], int) könnte noch einen Überlauf generieren, ansonsten hab ich den folgenden (relativ unschönen) Code geschrieben:

Java:
public static void main(String[] args) {
	int[] array = { 2, 6 };
	print(array);
	print(mult(array, new int[] { 1, 3 }));
}

public static void print(int[] array) {
	for (int i = 0; i < array.length; i++) {
		System.out.print(array[i]);
	}
	System.out.println();
}

public static int[] mult(int[] inp, int[] mult) {
	return mult(inp, mult, 10);
}

public static int[] mult(int[] inp, int[] mult, int base) {
	int array[] = new int[inp.length];
	System.arraycopy(inp, 0, array, 0, inp.length);
	int[] overflow = { 0 };
	for (int i = array.length - 1; i >= 0; i--) {
		int[] sum = add(mult(array[i], mult, base), overflow, base);
		array[i] = sum[sum.length - 1];
		overflow = new int[sum.length - 1];
		System.arraycopy(sum, 0, overflow, 0, sum.length - 1);
	}
	while (overflow.length > 0 && overflow[overflow.length - 1] > 0) {
		int[] tmp = new int[array.length + 1];
		System.arraycopy(array, 0, tmp, 1, array.length);
		array = tmp;
		array[0] = overflow[overflow.length - 1];
		tmp = new int[overflow.length - 1];
		System.arraycopy(overflow, 0, tmp, 0, tmp.length);
		overflow = tmp;
	}
	return array;
}

public static int[] mult(int inp, int[] mult, int base) {
	int array[] = new int[mult.length];
	System.arraycopy(mult, 0, array, 0, mult.length);
	int overflow = 0;
	for (int i = mult.length - 1; i >= 0; i--) {
		int sum = inp * mult[i] + overflow;
		array[i] = sum % base;
		overflow = sum / base;
	}
	while (overflow > 0) {
		int[] tmp = new int[array.length + 1];
		System.arraycopy(array, 0, tmp, 1, array.length);
		array = tmp;
		array[0] = overflow % base;
		overflow /= base;
	}
	return array;
}

public static int[] add(int[] a, int[] b, int base) {
	int length = a.length > b.length ? a.length : b.length;
	int[] array = new int[length];
	System.arraycopy(a.length == length ? a : b, 0, array, 0, length);
	int shortArr[] = a.length == length ? b : a;
	int overflow = 0;
	for (int i = array.length - 1; i >= 0; i--) {
		int index = i + shortArr.length - length;
		int val = index >= 0 ? shortArr[index] : 0;
		int sum = array[i] + val + overflow;
		array[i] = sum % base;
		overflow = sum / base;
	}
	while (overflow > 0) {
		int[] tmp = new int[array.length + 1];
		System.arraycopy(array, 0, tmp, 1, array.length);
		array = tmp;
		array[0] = overflow % base;
		overflow /= base;
	}
	return array;
}
 

faetzminator

Gesperrter Benutzer
Er rechnet:lol::lol::lol:

Edit: Ob du es glaubst / Ob ihr es glaubt, es funktioniert wirklich :) es ist noch ein wenig unschön, aber nehmen wir mal folgende Rechnung als Beispiel (mein Output):
Code:
12345678901234567890123456789 * 12345678901234567890 = 152415787532388367503429357750190519987501905210
Der Rechner gibt da so was aus:
Code:
1.5241578753239e+47
Funktioniert also. Dann die Geschwindigkeit...:
Code:
12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 * 12345678901234567890 = 152415787532388367503429357750342935775034293577503429357750342935775034293577503429357750342935775034293577503429357750342935775034293577503429357750190519987501905210
0ms
(ich habs selber nicht geglaubt und ein Thread.sleep() dazwischen gemacht, und dann ist es exakt diese Zeit.)
 
Zuletzt bearbeitet:

Marco13

Top Contributor
Jo, so eine Vermutung hatte ich schon. Es ging nur darum, dass das ziemlich kompliziert aussieht (im Vergleich zum anderen Codeschnispel, den du gepostet hattest). Also, speziell das mit dem Overflow und der While-Schleife und den vielen ArrayCopys... Man kann eigentlich schon im Voraus SEHR genau abschätzen, wie viele Stellen gebraucht werden: Bei einer Multiplikation kommt man bei Zahlen mit a und b Stellen immer mit a+b Stellen aus...

Und bezüglich der Rechenzeit: Wenn er da 0ms zu brauchen scheint, sagt das ja garnichts. Dann nimmt man einfach mehrere, größere Zahlen, und lässt das ganze auch ein paarmal durchlaufen - wobei solche Microbenchmarks IMMER heikel sind, aber mit dieser Strategie wird es zumindest einigermaßen verläßlich.

Apropos verläßlich: Deine Lösung liefert verläßlich ein falsches Ergebnis, wenn das Endergebnis die Ziffer 0 enthält ;)

Hab' das ganze mal erweitert, um einer alternative Implementierung "mult2", die etwas weniger rumkopiert um einen kleinen test (trotzdem würde ich keine der beiden Implementierungen für die Kontoverwaltung einer Bank empfehlen - meine ist auch eher schnell runtergeschrieben) und besagten Microbenchmark - eine echte Vergleichbarkeit ist allerdings nicht gegeben, solange unterschiedliche Ergebnisse rauskommen.

So. Und jetzt ist meine Mittagspause eigentlich auch schon rum :rolleyes:

Code:
// Von http://www.java-forum.org/java-basics-anfaenger-themen/83464-array-multiplikations-problem-2.html#post520557
// Erweitert um mult2 + test + benchmark

import java.util.*;
import java.math.*;

class ArrayMulTest2
{
    private static Random random = new Random(0);

    public static void main(String[] args)
    {
        test();
        //benchmark();
    }

    private static void test()
    {
        for (int a=2; a<5; a++)
        {
            for (int b=2; b<5; b++)
            {
                int input[] = generateRandomNumber(a,10);
                int factor[] = generateRandomNumber(b,10);

                int resultMult[] = mult(input, factor);
                int resultMult2[] = mult2(input, factor, 10);

                BigInteger i = bigIntegerBase10(input);
                BigInteger f = bigIntegerBase10(factor);
                BigInteger r = i.multiply(f);
                BigInteger m = bigIntegerBase10(mult(input, factor, 10));
                BigInteger m2 = bigIntegerBase10(mult2(input, factor, 10));
                System.out.println("input      "+i);
                System.out.println("factor     "+f);
                System.out.println("mult       "+m);
                System.out.println("mult2      "+m2);
                System.out.println("BigDecimal "+r);
                if (!m.equals(r))  System.out.println("--- mult failed ---");
                if (!m2.equals(r)) System.out.println("--- mult2 failed ---");
            }
        }
    }


    private static void benchmark()
    {
        int runs = 10;
        for (int digits = 1000; digits <= 5000; digits+=1000)
        {
            int input[] = generateRandomNumber(digits,10);
            int factor[] = generateRandomNumber(digits,10);

            long s, before, after;

            s = 0;
            before = System.nanoTime();
            for (int i=0; i<runs; i++)
            {
                int result[] = mult(input, factor);
                s += result.length;
            }
            after = System.nanoTime();
            System.out.println(s+" mult  "+((after-before)/1000000));


            s = 0;
            before = System.nanoTime();
            for (int i=0; i<runs; i++)
            {
                int result[] = mult2(input, factor, 10);
                s += result.length;
            }
            after = System.nanoTime();
            System.out.println(s+" mult2 "+((after-before)/1000000));
        }


    }



    private static BigInteger bigIntegerBase10(int array[])
    {
        String s = "";
        for (int i=0; i<array.length; i++)
        {
            s += array[i];
        }
        return new BigInteger(s);
    }



    private static int[] generateRandomNumber(int digits, int base)
    {
        int a[] = new int[digits];
        for (int i=0; i<digits; i++)
        {
            a[i] = 1+random.nextInt(base-1);
        }
        return a;
    }


    private static int[] mult2(int input[], int factor[], int base)
    {
        int result[] = new int[input.length+factor.length];
        int ii = 0;
        for (int i = factor.length - 1; i >= 0; i--, ii++)
        {
            int overflow = 0;
            int ij = 0;
            for (int j=input.length-1; j >= 0; j--, ij++)
            {
                int k = result.length - 1 - ii - ij;
                int r = factor[i] * input[j] + overflow;

                //System.out.println("mul "+input[j]+" with "+factor[i]+" add "+overflow+" result at "+k+" is "+r);

                result[k] += r;
                overflow = result[k] / base;
                result[k] -= ((overflow << 3) + (overflow << 1));


                //System.out.println("result now ");
                //print(result);
            }
            int index = 1;
            while (overflow > 0)
            {
                int k = result.length - 1 - ii - (input.length - 1) - index;
                result[k] += overflow;
                overflow = result[k] / base;
                result[k] -= ((overflow << 3) + (overflow << 1));
                index++;

                //System.out.println("result now after overflow ");
                //print(result);
            }

        }
        return result;
    }


    public static void print(int[] array)
    {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]);
        }
        System.out.println();
    }

    public static int[] mult(int[] inp, int[] mult) {
        return mult(inp, mult, 10);
    }

    public static int[] mult(int[] inp, int[] mult, int base) {
        int array[] = new int[inp.length];
        System.arraycopy(inp, 0, array, 0, inp.length);
        int[] overflow = { 0 };
        for (int i = array.length - 1; i >= 0; i--) {
            int[] sum = add(mult(array[i], mult, base), overflow, base);
            array[i] = sum[sum.length - 1];
            overflow = new int[sum.length - 1];
            System.arraycopy(sum, 0, overflow, 0, sum.length - 1);
        }
        while (overflow.length > 0 && overflow[overflow.length - 1] > 0) {
            int[] tmp = new int[array.length + 1];
            System.arraycopy(array, 0, tmp, 1, array.length);
            array = tmp;
            array[0] = overflow[overflow.length - 1];
            tmp = new int[overflow.length - 1];
            System.arraycopy(overflow, 0, tmp, 0, tmp.length);
            overflow = tmp;
        }
        return array;
    }

    public static int[] mult(int inp, int[] mult, int base) {
        int array[] = new int[mult.length];
        System.arraycopy(mult, 0, array, 0, mult.length);
        int overflow = 0;
        for (int i = mult.length - 1; i >= 0; i--) {
            int sum = inp * mult[i] + overflow;
            array[i] = sum % base;
            overflow = sum / base;
        }
        while (overflow > 0) {
            int[] tmp = new int[array.length + 1];
            System.arraycopy(array, 0, tmp, 1, array.length);
            array = tmp;
            array[0] = overflow % base;
            overflow /= base;
        }
        return array;
    }

    public static int[] add(int[] a, int[] b, int base) {
        int length = a.length > b.length ? a.length : b.length;
        int[] array = new int[length];
        System.arraycopy(a.length == length ? a : b, 0, array, 0, length);
        int shortArr[] = a.length == length ? b : a;
        int overflow = 0;
        for (int i = array.length - 1; i >= 0; i--) {
            int index = i + shortArr.length - length;
            int val = index >= 0 ? shortArr[index] : 0;
            int sum = array[i] + val + overflow;
            array[i] = sum % base;
            overflow = sum / base;
        }
        while (overflow > 0) {
            int[] tmp = new int[array.length + 1];
            System.arraycopy(array, 0, tmp, 1, array.length);
            array = tmp;
            array[0] = overflow % base;
            overflow /= base;
        }
        return array;
    }


}
 

faetzminator

Gesperrter Benutzer
Man kann eigentlich schon im Voraus SEHR genau abschätzen, wie viele Stellen gebraucht werden: Bei einer Multiplikation kommt man bei Zahlen mit a und b Stellen immer mit a+b Stellen aus...

Natürlich ist das korrekt, aber wie kriegt man die genaue Anzahl? ich spiel gerade mit dem Gedanken um (a + b - 1), das wär dann sicher ne tolle Erweiterung.
 

Marco13

Top Contributor
Nun, was heißt "die genaue Anzahl"? Anders formuliert: Sicher sein kann man erst, wenn man festgestellt hat, dass einer der Faktoren nicht 0,0,0,0,0,0,0,...,0 ist ... :rolleyes: Prinzipiell kann man zwar die Anzahl der Stellen für eine bestimmte Zahl zu einer bestimmten Basis genau ausrechnen, aber erstens dürfte man dafür erstmal eine Logarithmusfunktion für die Array-Zahlen schreiben, und zweitens ist man mit a+b immer auf der sicheren Seite, und wenn keine der Zahlen führende nullen hat, ist der Array höchstens um 1 zu groß. Bei einer 10000stelligen Zahl ist das verschmerzbar :)
 
Status
Nicht offen für weitere Antworten.
Ähnliche Java Themen
  Titel Forum Antworten Datum
T Array verkleinern Java Basics - Anfänger-Themen 2
J Array aus Numberfield Eingaben Java Basics - Anfänger-Themen 7
D Array List mit Objekten sortieren Java Basics - Anfänger-Themen 2
onlyxlia Anzahl Random Zahlen mit Scanner abfragen und in Array speichern Java Basics - Anfänger-Themen 10
Ü Java Array - Buchstaben als Zahlen ausgeben Java Basics - Anfänger-Themen 22
Ü Zweidimensionales Array in der ersten Zeile deklarieren Java Basics - Anfänger-Themen 13
Thomas Uppe 2D Array Reihenfolge vermischen Java Basics - Anfänger-Themen 4
T array auslesen Java Basics - Anfänger-Themen 2
Nitrogames Variablen Variable aus JOptionPane Abfrage in Array einfügen Java Basics - Anfänger-Themen 4
moini Auf Array aus Superklasse zugreifen? Java Basics - Anfänger-Themen 2
J ArrayList in 2D-Array konvertieren. Java Basics - Anfänger-Themen 48
M NullPointerException: Cannot read the array length because "this.Kinder" is null Java Basics - Anfänger-Themen 1
P Wieso kann ich als Index für einen Array einen Char angeben? Java Basics - Anfänger-Themen 3
Finn_lol Fehlermeldung bei Schleife mit Array Java Basics - Anfänger-Themen 4
Proxy Chars vor array übergabe toLowerUpcase Java Basics - Anfänger-Themen 14
iAmFaiinez Primzahlen Tester ohne Array Java Basics - Anfänger-Themen 4
S array 2 dimensional treppe Java Basics - Anfänger-Themen 3
S Array 2x2 Blöcke mit 0 und 1 Java Basics - Anfänger-Themen 10
C Array von Klassen Java Basics - Anfänger-Themen 2
julian0507 2Dim-Array Spaltensummen Java Basics - Anfänger-Themen 1
XWing Doppelte Zahlen im Array Java Basics - Anfänger-Themen 8
melisax Java 2D-Array Tabelle Java Basics - Anfänger-Themen 4
melisax Java Array Wert an bestimmtem Index angeben Java Basics - Anfänger-Themen 14
W Items löschen aus String Array vom Custom Base Adapter Java Basics - Anfänger-Themen 2
Proxy Stack erweitern mit neuem Array falls der alte voll ist!? Java Basics - Anfänger-Themen 5
E Array, nächste Zahl zur 5 ausgeben, wie? Java Basics - Anfänger-Themen 42
J Array.list vergleichen Java Basics - Anfänger-Themen 1
W Java-Code mit Array Java Basics - Anfänger-Themen 14
D Reflections & Generisches Array Java Basics - Anfänger-Themen 4
T Array Java Basics - Anfänger-Themen 2
T Array Java Basics - Anfänger-Themen 15
T Wörteranzahl im Array zählen Java Basics - Anfänger-Themen 9
Ostkreuz Zweidimensionaler Array Index Java Basics - Anfänger-Themen 2
S String Array Buchstaben um einen gewissen Wert verschieben Java Basics - Anfänger-Themen 4
R Images aus einem Array ausgeben Java Basics - Anfänger-Themen 3
R 2d Array individuell machen Java Basics - Anfänger-Themen 4
D 2D Char Array into String Java Basics - Anfänger-Themen 2
J Array Median bestimmen Java Basics - Anfänger-Themen 6
S Array Maximum bestimmen mit for und foreach Java Basics - Anfänger-Themen 7
S Prüfen ob ein zweidimensionales Array rechteckig ist Java Basics - Anfänger-Themen 4
N Array Java Basics - Anfänger-Themen 1
J Array Mittleren Wert bestimmen Java Basics - Anfänger-Themen 2
D OOP Array einem Objekt zuweisen Java Basics - Anfänger-Themen 2
O Zahlen aus einem char-array per char + Zeichen addieren Java Basics - Anfänger-Themen 2
S leeres Array statt Null Pointer Exception ausgeben Java Basics - Anfänger-Themen 20
S Inhalte aus Array vergleichen und Max ausgeben Java Basics - Anfänger-Themen 3
M 2d array ohne längen anlegen Java Basics - Anfänger-Themen 4
S Bestimmte werte aus einem Array löschen Java Basics - Anfänger-Themen 2
S Ausgeben wie oft ein Wert in einem Array vorkommt Java Basics - Anfänger-Themen 7
E Reihenfolge der Werte umdrehen (mittels statischem int-Array Java Basics - Anfänger-Themen 3
O 2 Dimensionales Array Java Basics - Anfänger-Themen 6
M Bubble Sort - Int[] Array sortieren Java Basics - Anfänger-Themen 2
javaBoon86 Array mehrere Dimensionen Java Basics - Anfänger-Themen 10
B Array nach Elementwerten sortieren? Java Basics - Anfänger-Themen 1
B Explizit Array definieren geht nicht? Java Basics - Anfänger-Themen 14
D Kleinste Zahl in Array finden die vorher noch errechnet werden müssen. Java Basics - Anfänger-Themen 4
L Gegebenes Array sortieren, indem zufällige Zahlenpaare aus Array ausgewählt werden Java Basics - Anfänger-Themen 14
Say 2-DIM Array Code lesen und verstehen Java Basics - Anfänger-Themen 5
N Array beim erstellen mit Werten füllen Java Basics - Anfänger-Themen 6
C Java Array Struktur, welche ist wann besser? Java Basics - Anfänger-Themen 12
Temsky34 Array IndexOf nicht verfügbar Java Basics - Anfänger-Themen 18
belana wie am besten 2D Array von String to Integer Java Basics - Anfänger-Themen 18
S Array mit Methode löschen Java Basics - Anfänger-Themen 2
J Java To String Methode, Array mit For-Schleife Java Basics - Anfänger-Themen 2
E Durch Muster in Array iterieren Java Basics - Anfänger-Themen 3
L Frage zum Array Java Basics - Anfänger-Themen 1
C 2D Array Ausgabe mit for-Schleife i,j Java Basics - Anfänger-Themen 4
D Methode: Array Reihenfolge tauschen Java Basics - Anfänger-Themen 3
julian0507 Array aus Methode in anderer Methode sichtbar machen Java Basics - Anfänger-Themen 10
P Array vom Typ Klasse Java Basics - Anfänger-Themen 18
Lion.King Array deklarieren und initialisieren Java Basics - Anfänger-Themen 5
P Array-Objekte-Aufruf Java Basics - Anfänger-Themen 22
A CSv.Datei einlesen und die werte in zweidemosional Int Array speichern Java Basics - Anfänger-Themen 9
M Methoden Zweidimensionaler Array mit Setter Methode ändern Java Basics - Anfänger-Themen 4
AkiJou Zeile in 2d Array löschen Java Basics - Anfänger-Themen 2
LilliCherry Array in einer Zeile ausgeben Java Basics - Anfänger-Themen 6
A Elemente in einem Array Java Basics - Anfänger-Themen 5
A Vorkommende Farben ermittel und als Array zurückgeben Java Basics - Anfänger-Themen 7
AhmadSlack Array Java Basics - Anfänger-Themen 7
Jambolo Kartenhand Array Java Basics - Anfänger-Themen 14
ravenz Schleife mit for über String Array „zahlen“und prüfen ob Wert „a“ oder „b“ oder „c“ entspricht (mittels || ) Java Basics - Anfänger-Themen 4
S Eine Variable in einem Array speichern Java Basics - Anfänger-Themen 5
T Methode, die prüft ob in einem Int-Array maximal 2 Zahlen enthalten sind, die größer als ihr Vorgänger sind Java Basics - Anfänger-Themen 5
T String Array Fehler beim Index Java Basics - Anfänger-Themen 3
krgewb byte-Array, das ein Bild repräsentiert Java Basics - Anfänger-Themen 1
1 Array rekursiv durchlaufen Java Basics - Anfänger-Themen 8
I Methoden Wieso wird mein Array "a" verändert und meine Variable "a" nicht? Java Basics - Anfänger-Themen 4
EykS 3D Druckdatei basierend auf 3D Array? Java Basics - Anfänger-Themen 3
sserio Array funktioniert nicht Java Basics - Anfänger-Themen 2
sserio Iterierung über ein zweidimensionales Array Java Basics - Anfänger-Themen 16
sserio Zweidimensionales Array [][] wird untereinander ausgegeben Java Basics - Anfänger-Themen 14
Chris.089 2 Werte im Array tauschen Java Basics - Anfänger-Themen 6
D EinMalEins mithilfe einer for-Schleife und Array Java Basics - Anfänger-Themen 1
L Unbekanntes Problem mit 2d Array Java Basics - Anfänger-Themen 6
L Gridmuster in einem Array Java Basics - Anfänger-Themen 2
sgtcoopa Array übergeben Schleife Java Basics - Anfänger-Themen 0
B Compiler-Fehler Array aus Objekten übergeben Java Basics - Anfänger-Themen 7
padde479 Array Multiplikation der ersten n Zahlen Java Basics - Anfänger-Themen 7
G zweidimensionales int Array sortieren Java Basics - Anfänger-Themen 57
W Array ausgeben Java Basics - Anfänger-Themen 29

Ähnliche Java Themen

Neue Themen


Oben