Elemente in array umkehren

[agent0013]

Hallo,
ich habe so eine aufgabe:

Vervollständigen Sie das folgende Programm, so dass es die Reihenfolge der Werte in array umkehrt und sie ausgibt.
Im Programms gibt es nur ein Array und seine Werte werden durch eine etwas trickreiche Programmierung umgekehrt.

class ArrayUmkehren1
{

public static void main ( String[] args )
{
int[] array = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};

// Daten umkehren
for ( int j = 0; j < seien Sie vorsichtig hier; j++)
{

}

// neuen Daten ausgeben
for ( int j = 0; j < array.length; j++)
{

}
}
}

ich weiß nur 2 möglichkeiten:

int temp = array.length - 1;
array[0] = temp - array[0];
array[1] = temp - array[1];
.
.
array[13] = temp - array[13];

und

for (int j = array.length - 1; j >= 0; j++)

aber die aufgabenstellung verlangt etwas anderes und ich komme irgendwie nicht drauf.. könnte mir jemand ein tipp geben?
danke

 

[Guardi]

Mein Tipp:
Schaue dir die gängigen Sortier-Algorithmen an, z.B. den BubbleSort.
Damit lässt sich die Aufgabe einfach lösen.

 

[Final_Striker]

Du läufst über das Array und vertauscht 1 und 14, 2 und 13, 3 und 12 usw. Wenn du bei der Mitte angekommen bist, hast du das Array umgedreht.

 

[agent0013]

normalerweise müsste es so funktionieren oder?

for (int j = 0; j < array.length - 1; j++)
{
	if (array[j] < array[j + 1])
	{
		temp = array[j + 1];
		array[j + 1] = array[j];
		array[j] = temp;
	}
}

aber als ausgabe bekomme ich:

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 1

was fählt da?

 

[Dekker]

normalerweise müsste es so funktionieren oder?

for (int j = 0; j < array.length - 1; j++)
{
	if (array[j] < array[j + 1])
	{
		temp = array[j + 1];
		array[j + 1] = array[j];
		array[j] = temp;
	}
}

aber als ausgabe bekomme ich:

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 1

was fählt da?

Du willst den Array auf jeden fall umdrehen, wofür also die if?

for (int j = 0; j < array.length/2; j++)
{
	temp = array[j];
	array[j] = array[(array.length - (1+j))];
	array[(array.length - (1+j))] = temp;
	
}

Jetzt nicht ausprobiert aber so in der art sollte es funktionieren.

Edit: Schleifenbedingung war bs, jetzt stimmts.

 

[Final_Striker]

Du musst die 1 und die 14 vertauschen.

[c]if (array[j] < array[j + 1])
{
...
}[/c]

Hier vertauscht du 1 und 2.

 

[Nightmares]

		int[] b = new int[5];
		b[0] = 0;
		b[1] = 1;
		b[2] = 2;
		b[3] = 3;
		b[4] = 4;

		// test ausgabe
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);
		}

		int left = 0;
		int right = b.length - 1;
		int temp;

		// zwei zähler
		// solange links kleiner als rechts ist rückst du von beiden 
		// seiten weiter zur mitte und vertauscht
		while (left < right) {
			temp = b[left];
			b[left] = b[right];
			b[right] = temp;
			left++;
			right--;
		}

		// test ausgabe
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);
		}

Best regards
Nightmares

 

[Crian]

Alternativ kopierst du rückwärts in ein zweites Array.

 

[Nightmares]

Geht auch, is aber wahrscheinlich weniger effizient...

 

[agent0013]

hallo,
das hab ich jetzt so hingekriegt:

int temp;
		
for (int j = 0; j < array.length; j++)
{
	temp = array.length;
	array[j] = temp - j;
}

//  test ausgabe
for (int j = 0; j < array.length; j++)
{
	System.out.println(array[j]);
}

ich hoffe,daß es richtig ist und verbirgt dahinten nichts,was ich nicht sehen kann..
danke trotzdem für eure hilfe!

 

[AmunRa]

Ich weis nicht was du jetzt machen willst, aber der Code vertuscht nicht die Element im Array


Dein Code aus einem deiner Vorherigen post war ja eh richtig, nur die if Bedingung hättest du entfernen müssen

 

[agent0013]

ich will nur die elemente rückwerts ausgeben,mehr nichts

 

[AmunRa]

ein Array rückwerts ausgeben:

for (int i= array.length-1;i>=0;i++){
   System.out.println(array[i]);
}

Ein Array umkehren:

for (int i = 0; i < array.length/2; i++)
{
    temp = array[i];
    array[i] = array[(array.length - 1-i)];
    array[(array.length - 1-i)] = temp;
    
}

 

[agent0013]

gut,danke, aber wie heist jetzt der code,was ich geschrieben habe?

 

[AmunRa]

nimmst den Startwert des Arrays, = der ist die Länge des Arrays und zähst dann Rückwärts und speicherst diese Werte ins Array.

Also wenn du ein Array der Länge 5 hast speicherst du die Wert 5,4,3,2,1

 

[agent0013]

übrigens,ich hab hier zweite aufgabe:

Schreiben Sie jetzt ein weiteres Programm, das zwei Arrays verwendet. Das erste Array array wird nicht geändert. Das zweite Array ziel bekommt die Elemente von array in umgekehrter Reihenfolge.

class ArrayUmkehren2
{

public static void main ( String[] args )
{
int[] array = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};
int[] ziel =

// die Daten von array in umgekehrter Reihenfolge nach ziel kopieren
for ( int j = 0; j < be careful here; j++)
{

}

// Ergebnis ausgeben
for ( int j = 0; j < ziel.length; j++)
{

}

}
}

und das hab ich so gemacht:

int[] array = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};
		int[] ziel = {14,13,12,11,10,9,8,7,6,5,4,3,2,1};
		
		for (int j = 0; j < array.length; j++)
		{
			array[j] = ziel[j];
		}
		for (int j = 0; j < ziel.length; j++)
		{
			System.out.println(array[j]);
		}

ich will nur sicher gehen,daß ich wenigstens das richtig gemacht habe.

 

[AmunRa]

Leider hast du diese auch nicht korrekt gemacht.

du gibst ja die Werte deines Arrays ziel bereits vor. daher muss man nichts mehr einfügen.


betrachten wir jetzt mal gemeinsam das ganze von Vorne.

du bekommst ein Array vorgegeben bei

und sollst nun ein Array ziel erzeugen bei dem Alle Elemente des ersten arrays platz haben.


Wie kann man das wohl machen? (SChreib mal nur für dieses Problem eine Lösung, die sowohl für das

Array array= {1,2,3,4};

als auch für das

Array array= {3,5,2,1,5,4,2,1,4,6,3,1};

 

[chalkbag]

Das erste Array array wird nicht geändert. Das zweite Array ziel bekommt die Elemente von array in umgekehrter Reihenfolge.

Also eher nein.
das Zielarray ist leer und wird nur mit der Länge von dem ersten array angelegt, also

int[] ziel = int[array.length];

Und dann befüllt du das ziel-array mit den Daten, wie du es eigentlich bei der vorangegangen Aufgabe schon gemacht hast.

[edit] zu langsam

 

[agent0013]

ich probiere erstmal!! :rtfm:

 

[Dekker]

Nur mal so als Frage, warum führst du die Programme eigentlich nicht selbst aus anstatt immer zu fragen ob das jetzt richtig ist? Das dürftest du mit deiner Ausgabe ja selbst erkennen können, dafür sind die System.out.println(blub) ja im Endeffekt da in deinen Aufgaben.

 

[BigBiber89]

Was mir als erstes in den Sinn kommen würde:

Integer[] array = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};

List<Integer> temp = new LinkedList<Integer>(Arrays.asList(array));

Collections.reverse(temp);

array = temp.toArray(new Integer[0]);

 

[Dekker]

Ich glaube solche Lösungen sind in diesen Fällen für den Allerwertesten. Es ist offensichtlich, dass er die Aufgabe anhand des Codegerüstes das ihm gegeben wurde und das er in seinen Posts mit angegeben hat lösen soll.

 

[Firephoenix]

übrigens,ich hab hier zweite aufgabe:

Schreiben Sie jetzt ein weiteres Programm, das zwei Arrays verwendet. Das erste Array array wird nicht geändert. Das zweite Array ziel bekommt die Elemente von array in umgekehrter Reihenfolge.

class ArrayUmkehren2
{

public static void main ( String[] args )
{
int[] array = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};
int[] ziel =

// die Daten von array in umgekehrter Reihenfolge nach ziel kopieren
for ( int j = 0; j < be careful here; j++)
{

}

// Ergebnis ausgeben
for ( int j = 0; j < ziel.length; j++)
{

}

}
}

und das hab ich so gemacht:

int[] array = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};
		int[] ziel = {14,13,12,11,10,9,8,7,6,5,4,3,2,1};
		
		for (int j = 0; j < array.length; j++)
		{
			array[j] = ziel[j];
		}
		for (int j = 0; j < ziel.length; j++)
		{
			System.out.println(array[j]);
		}

ich will nur sicher gehen,daß ich wenigstens das richtig gemacht habe.

Hi,
hast du dich vor dem schreiben der 1. Zeile eigentlich länger als 10 Sekunden mit dem Problem beschäftigt?
Die Lösung sieht eher so aus wie "ich werf einfach Code der richtig aussieht an irgendwelche Stellen und frag dannach ob es passt solange bis am Ende alles gut ist".

Und der Code ist wirklich noch in einer Kategorie bei der ich von jemandem komplett ohne Java-Kenntnisse davon ausgehen kann, dass er mir folgende Fragen beantworten kann:
-Was macht die Zeile

array[j] = ziel[j];

du weißt dem array an Position j den Wert von ziel an Position j zu.
Drehst du damit das Array um und speicherst du die Werte in Ziel????
-Was gibt diese Zeile aus?

System.out.println(array[j]);

Richtig, dein array. Wo sollen deine Ergebnisse stehen? in ziel.

Von daher bringt dein

ich probiere erstmal!!

dir garnichts, auch wenn du Jahrelang weiterprobierst, eher wirft nen Affe ein Puzzel in die Luft und setzt es dabei perfekt zusammen...

Mach dir klar wie Arrays funktionieren, wo genau die Werte stehen, wie du wo rankommst, wie man Variablen Werte zuweist.
Und bevor du dann die erste Zeile Code schreibst überleg dir erstmal was du eigentlich machen willst.
Dann kannst du nämlich auch selbst mal deine Ergebnisse prüfen (Testen gehört zum Programmieren dazu). Und wenn sie nicht passen schaust du dir nochmal deinen Code an und überlegst was der eigentlich macht und ob es das ist was du haben willst (Code im Kopf durchlaufen ist auch eine Grundfertigkeit die man sich aneignen sollte). Und erst wenn du dann nichts findest macht es wirklich Sinn hier nachzufragen, ansonsten wirst du nie etwas dazulernen sondern das hier wird immer auf dem Niveau so weitergehen.
Gruß

 

[agent0013]

Mach dir klar wie Arrays funktionieren, wo genau die Werte stehen, wie du wo rankommst, wie man Variablen Werte zuweist.

hi, ich bin relativ anfänger.ich lerne von java-tutorial,aber entweder verstehe ich nicht richtig gut oder steht es dort nicht ausreichend,wie arrays funktionieren.. auf jeden fall,ich muss von der andere literatur auch mal was lesen.

Nur mal so als Frage, warum führst du die Programme eigentlich nicht selbst aus anstatt immer zu fragen ob das jetzt richtig ist? Das dürftest du mit deiner Ausgabe ja selbst erkennen können, dafür sind die System.out.println(blub) ja im Endeffekt da in deinen Aufgaben.

ich hab es natürlich probiert und hab auch gedacht,daß es richtig ist,aber ist eben nicht.wenn ich es hier nicht geschrieben hätte,hätte ich es auch vllt nie erfahren..
danke trotzdem für eure komentare und kritik und was auch immer....

 

[Firephoenix]

Hi,
hier ein Link wie Arrays aufgebaut sind:
Tutorial / Java Grundlagen / Arrays

Dann zu der Aufgabe:

Schreiben Sie jetzt ein weiteres Programm, das zwei Arrays verwendet. Das erste Array array wird nicht geändert. Das zweite Array ziel bekommt die Elemente von array in umgekehrter Reihenfolge.

Du hast also ein Array namens "array" und ein Array namens "ziel".
Deine Aufgabe ist es, die elemente aus array in ziel zu packen.
Da beide arrays gleich viele Elemente enthalten sind sie logischerweise gleich lang (genauer gesagt ist Ziel exakt so lang wie array.
Ein int-Array einer bestimmten größe erzeugt man mit new int[größe] und die länge eines Arrays fragt man mit array.length ab.
Du kannst also mit

int[] ziel = new int[array.length];

Ein Array erzeugen, das soviel Speicherfelder bereitstellt wie array hat.

Dann musst du die Elemente übertragen, dazu bietet sich eine Schleife an.
Der Schleifenzähler fängt bei 0 an.
Du willst das erste Element von Array an die letzte Position von ziel verfrachten.
Die erste Position ist 0, die Zielposition wäre länge-1 (da das array auch bei 0 anfängt).
Im zweiten Schritt ist der Schleifenzähler 1
und du willst Position 1 aus array in ziel an länge-1-1 packen (das erste in das vorletzte)
dann bei Schritt 2 Position 2 aus array in ziel an Position länge-1-2 usw.

Abstrakt kannst du also einen Schritt so formulieren:
Bei Schritt i Speichere Position i aus array an Position array.length-1-i in ziel.
die Zuweisung dabei sieht so aus:

ziel[array.length]-1-i = array[i];

Jetzt noch eine Schleife außenrum und du erhälst

for(int i = 0; i < array.length; i++){
ziel[array.length]-1-i = array[i];
}

Zu der Ausgabe habe ich dir ja den Ansatz im vorigen Post schon gegeben.
Die Schleife läuft einmal über das ziel-array, was liegt also näher als jedes Element aus dem ziel-array auszugeben?

Ich hab das ganze hier mal eingesetzt (die Schleifenvariablen heißen hier zwar j, aber das ändert am Programmablauf nichts)

public static void main ( String[] args )
{
	int[] array = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};
	int[] ziel = new int[array.length];

		// die Daten von array in umgekehrter Reihenfolge nach ziel kopieren
		for ( int j = 0; j < array.length; j++)
		{
			ziel[array.length-1-j] = array[j];
		}

	// Ergebnis ausgeben
	for ( int j = 0; j < ziel.length; j++)
	{
		System.out.println(ziel[j]);
	}

}

Gruß

 

[happen]

ich gebe auch noch meine zum Besten:

        int[] array = {1, 2, 3, 4, 5, 6, 7};
        for (int i = 0; i < array.length / 2; i++) {
            final int j = array.length - 1 - i;
            array[i] -= array[j];
            array[j] += array[i];
            array[i] = array[j] - array[i];
        }
        System.out.println(Arrays.toString(array));

..und warum funktionierst?

 

[Firephoenix]

ich gebe auch noch meine zum Besten:

        int[] array = {1, 2, 3, 4, 5, 6, 7};
        for (int i = 0; i < array.length / 2; i++) {
            final int j = array.length - 1 - i;
            array[i] -= array[j];
            array[j] += array[i];
            array[i] = array[j] - array[i];
        }
        System.out.println(Arrays.toString(array));

..und warum funktionierst?

Hi,
keine uninteressante Lösung für das Archiv, ich kann mir allerdings nicht vorstellen, das du damit dem TO wirklich helfen wirst, da die Methode schwerer nachzuvollziehen ist und vor allen Dingen nicht innerhalb der Vorgegebenen Schleifen seiner Übung arbeitet.

Funktionieren tut das ganze deswegen:
seinen i,j die Werte zum tauschen:
nehmen wir
i = i - j
j = j + i - j = i
i = j - i = (i)-(i-j) = j
und wir haben getauscht.

Gruß

 

[Dekker]

ich hab es natürlich probiert und hab auch gedacht,daß es richtig ist,aber ist eben nicht.wenn ich es hier nicht geschrieben hätte,hätte ich es auch vllt nie erfahren..
danke trotzdem für eure komentare und kritik und was auch immer....

Und genau da liegt ein ganz anderes Problem. Wie kann man etwas Programmieren wenn man nicht mal weiß wie das Ergebnis am Ende aussehen sollte? Ich wollte dich damit weder beleidigen noch sonst etwas, aber nachdem was du hier schreibst war meine Frage doch garnicht mal so unötig.

Merk dir eins, beim programmieren sollte man niemals einfach mal so anfangen und bissle Code hinklatschen und kucken was am Ende rauskommt.

1. Problem verstehen
2. Auf Papier schrittweise überlegen wie das Problem gelöst werden kann (gerade als Anfänger besser als direkt los zu programmieren; es geht dabei nicht darum den Code auf Papier zu schreiben sondern wirklich in Stichpunkten Schritt für Schritt den Ablauf des gewünschten Programmes aufschreiben)
3. Lösung nach den Überlegungen aus Schritt 2 Programmieren
4. Testen: falls Ergebnis nicht das erwartete ist -> wieder zu Schritt 2, andern falls bist du fertig.

Bei dir hat es hier aber dann wohl schon bei Schritt 1 gehapert, wie also soll da was vernünftiges rauskommen?

 

[Landei]

Was ist an einem Array schwer zu verstehen? Im Prinzip nichts weiter als eine Reihe Spinde mit Nummern ("Indexe") drauf, angefangen bei 0. Und da kann man Zeugs reinstopfen und wieder herausholen. Wenn du ein Array mit Zahlen hast, darfst du natürlich die "reingestopfte" Zahl nicht mit der "Spindnummer" verwechseln. Man muss noch aufpassen, dass man nichts überschreibt (wenn man etwas in einen bereits belegten Spind legt, landet das alte Zeug im Müll), was man später noch braucht. Das sind aber schon alle "Schwierigkeiten" hier.

So, nun stell dir vor da sind zehn Spinde mit der Nummer 0 bis 9, wie vertauschst du die Inhalte, dass sie eine umgekehrte Reihenfolge bekommen? Wie genau läuft eine Vertauschung ab, ohne dass man etwas überschreibt?

 

[Crian]

Und man muss vorher genug Spinde aufstellen.

Wenn da zehn Spinde stehen und man das Glas in den elften stellt, fällt es zu Boden und geht kaputt.

 

[Landei]

Dann kommt der Hausmeister mit dem komischen Namen ArrayOutOfBoundsException und wischt es weg...

 

[2XS]

@Firephoenix: Für die tolle und ausführliche Lösung musste ich Dir einfach auch ein "Danke" spendieren, obwohl ich mit dem Problem überhaupt gar nichts am Hut habe.


Grüße,

Andy

 

[happen]

Hi,
keine uninteressante Lösung für das Archiv, ich kann mir allerdings nicht vorstellen, das du damit dem TO wirklich helfen wirst, da die Methode schwerer nachzuvollziehen ist und vor allen Dingen nicht innerhalb der Vorgegebenen Schleifen seiner Übung arbeitet.

Funktionieren tut das ganze deswegen:
seinen i,j die Werte zum tauschen:
nehmen wir
i = i - j
j = j + i - j = i
i = j - i = (i)-(i-j) = j
und wir haben getauscht.

Gruß

Es funktioniert auch mit dem ^-Operator: java - question on reverse array - Stack Overflow
(noch eine Lösung)