Rekursive swapArray Methode

Diskutiere Rekursive swapArray Methode im Java Basics - Anfänger-Themen Bereich.
Bitte aktiviere JavaScript!
J

jono

Hallo zusammen,
die Aufgabe lautet:
Java:
Gegeben ist die Signatur der Methode swapArray in Functionality.java.

Implementieren Sie eine REKURSIVE Methode, die zwei Index-Werte und zwei Integer-Arrays erhält.
Die Methode soll von dem Index "from" (inklusive) bis zum Index "to" (inklusive) die Werte an den gleichen Indexstellen aus den beiden Arrays tauschen. Der Rückgabewert ist die tatsächliche Anzahl der Vertauschungen.
Bsp.:
Mit den Arrays
  a = new int[]{5, 1, 2, 8, 6, 9}
  b = new int[]{42, 34, 68, 21, 12, 47, 82}
liefert der Aufruf swapArray(1, 4, a, b); den Wert 4, da es vier Vertauschungen gibt.
Nach dem Aufruf sehen die Arrays wie folgt aus:
a = [5, 34, 68, 21, 12, 9]
b = [42, 1, 2, 8, 6, 47, 82]

Folgende Spezialfälle sind zu beachten:
- Wenn einer der Arrays null ist, so wird 0 zurückgegeben
- Wenn "from" negativ, größer als "to" oder größer als die Länge eines Arrays ist, so wird 0 zurückgegeben.
- Wenn "to" größer als die Länge-1 des kleinsten Arrays ist, so wird die Länge-1 des kleinsten Arrays für "to" verwendet.
- "from" und "to" sind inklusive, d.h. die Werte an den Indexstellen "from" und "to" müssen ebenfalls getauscht werden.
Dazu habe ich folgenden Quellcode:
Java:
public class Functionality {
 public static int swapArray(int i, int j, int[] a, int[] b) {
  if (a == null || b == null) {
   return 0;
  }
  if (i < 0 && i > j || i > a.length || i > b.length) {
   return 0;
  }
  if (a.length < b.length) {
   if (i > a[1]) {
    i = a[1];
   }
   if (b.length < a.length) {
    if (i > b[1]) {
     i = b[1];
    }
   }
   for (j = 0; j < b.length; j++) {
    for (i = 0; i < a.length; i++) {
     a[i] = b[j];
     b[j] = a[i];
    i = j;
    j = i;
    }
   }
  }
  swapArray();
  return
 }
}
Mein Problem ist:
Bei den beiden for-Schleifen wird zwar irgendwo das tauschen erfüllt, aber ich durchdringe einfach nicht, wie
ich jetzt das from-to Problem lösen kann.
 
mihe7

mihe7

Mein Problem ist:
Dein Problem ist, dass man bei Dir auch nach Wochen nicht erkennen kann, dass Du irgendein Verständnis für die Programmierung entwickelt hättest.

Bei den beiden for-Schleifen wird zwar irgendwo das tauschen erfüllt,
Wenn die beiden for-Schleifen das Tauschen erfüllen, fress ich 'nen Besen.

aber ich durchdringe einfach nicht, wie
ich jetzt das from-to Problem lösen kann.
Du durchdringst schon nicht, dass man swapArray() nicht ohne Parameter aufrufen kann, dass Du keine for-Schleife brauchst/haben sollst (Rekursion!) und wie man zwei Elemente in Arrays tauscht.

Wenn Du da wirklich weitermachen willst, löse folgende Aufgaben:
1. schreibe eine rekursive Methode, die die Zahlen von i bis 10 (jeweils inkl.) ausgibt.
Java:
public static void zeigeZahlen(int i) { ... }
2. erweitere die Methode um den Parameter j, so dass alle Zahlen von i bis j (jeweils inkl.) ausgegeben weren
Java:
public static void zeigeZahlen(int i, int j) { ... }
3. erweitere die Methode derart, dass die Anzahl der ausgegebenen Zahlen(i bis j) zurückgegeben wird:
Java:
public static int zeigeZahlen(int i, int j) { ... }
 
J

jono

Ja, ich versuche jetzt die Aufgabe zu lösen.
Und mir ist bewusst, dass man diese ohne Parameter nicht aufrufen kann.
Außerdem habe ich das mit der Rekursion noch nicht ganz drauf, erstes mal halt.
Und ich finde, dass du Nicht einfach behaupten kannst, ich hätte nach Wochen kein Verständnis
dafür entwickelt, finde ich etwas überzogen, ich bekomme jetzt einige Aufgaben alleine hin zumindest
und habe auch vieles verstanden? Kannst du doch daraus jetzt nicht ableiten. und jede Aufgabe war
von der Thematik her eine neue auch wenn sich Dinge in anderen Themen überschneiden, trotzdem
ist deine Aussage sehr oberflächlich
 
J

jono

mit den for schleifen war ich mir auch nicht sicher, deshalb wollte ich ja auch mal nachfragen, um zu wissen ob das bullshit ist.
Aber was sagst du denn was die for Schleife hier in mit den Anweisungen in dem Fall hier macht ? Würde mich echt mal
interessieren.
 
J

jono

Das return ist natürlich auch noch offen, ist auch klar dass das so nicht fertig wäre
 
mihe7

mihe7

du Nicht einfach behaupten kannst, ich hätte nach Wochen kein Verständnis
dafür entwickelt
Zum einen habe ich das nicht behauptet, ich habe geschrieben, dass man es nicht erkennen kann. Zum anderen wäre eine solche Behauptung auch nicht aus der Luft gegriffen; ich erinnere mich z. B. an den 2D-Array-Thread. Wenn Du Dir Deinen Code anschaust, würdest Du sagen, dass dieser von irgendeinem Verständnis bzgl. der Arrays zeugt?

jede Aufgabe war
von der Thematik her eine neue auch wenn sich Dinge in anderen Themen überschneiden, trotzdem
ist deine Aussage sehr oberflächlich
Mit dem feinen Unterschied, dass die neue Thematik in Deinem Code gar keine Rolle spielt: Du hast eine iterative "Lösung" für ein Problem angegeben, das vom Schwierigkeitsgrad her knapp über dem Kopieren eines Arrays in ein anderes liegt. Diese Lösung enthält nicht einfach nur ein, zwei Fehler - was durchaus vorkommen kann - sondern ist dermaßen falsch (s. u.), dass man nicht mal erahnen kann, welche Idee dahinterstecken könnte.

Aber was sagst du denn was die for Schleife hier in mit den Anweisungen in dem Fall hier macht ? Würde mich echt mal
interessieren.
Erstens bekommst Du i und j übergeben, die Du dann mal eben auf 0 setzt und iterierst dann über das gesamte Array. Zweitens auch noch verschachtelt. Drittens kopierst Du mit dem Code im Rumpf der inneren Schleife einen Wert von Array b, Position j, nach Array a, Position i. Anschließend kopierst Du den Wert, den Du eben kopiert hast, wieder zurück. Mal abgesehen davon, dass der zweite Schritt vollkommen überflüssig ist, wird der Wert von a[i] verloren bleiben. Viertens kopierst Du dann j nach i, was dazu führt, dass die innere Schleife niemals terminiert, wenn a wenigstens zwei Elemente enthält.
 
J

jono

Java:
public class Functionality{
 
    public static void swapArray(int[] dataA, int[] dataB, int from, int to) {
        if (from > to || dataA.length <= from || dataB.length <= from)
            return;
        int tmp = dataB[from];
        dataB[from] = dataA[from];
        dataA[from] = tmp;
        swapArray(dataA, dataB, ++from, to);
       
    }
   
}
Im Prinzip so ? Nur wie erhalte ich jetzt die Anzahl

:rolleyes:
 
J

jono

Dann müsste ich ja void durch int ersetzen und das "return;" auch mit einem int rückgabetyp umändern?
 
J

jono

Java:
public class Functionality{
 
    public static int swapArray(int[] dataA, int[] dataB, int from, int to) {
     if(dataA == null || dataB == null) return 0;
     
        if (from < 0 && from > to || dataA.length < from || dataB.length < from)
            return 0;
        int tmp = dataB[from];
        dataB[from] = dataA[from];
        dataA[from] = tmp;
        swapArray(dataA, dataB, ++from, to);
       
    }
   
}
Muss vor das swapArray noch ein return?
 
J

jono

Also wird halt vorgeschlagen vom Programm, aber ich meiner Intuition nach macht es nicht wirklich Sinn.
Ich muss doch jetzt irgendwie noch die Anzahl der Vertauschungen definieren, oder?
 
J

jono

Java:
/root/autocorrectorBNQIZIdir/PublicTests.java:15: error: incompatible types: int cannot be converted to int[]        
 assertEquals(4, Functionality.swapArray(1, 4, a, b));

/root/autocorrectorBNQIZIdir/PublicTests.java:28: error: incompatible types: int cannot be converted to int[]        
 assertEquals(1, Functionality.swapArray(3, 3, a, b));

/root/autocorrectorBNQIZIdir/PublicTests.java:41: error: incompatible types: int cannot be converted to int[]        
assertEquals(6, Functionality.swapArray(1, 400, a, b));

/root/autocorrectorBNQIZIdir/PublicTests.java:50: error: incompatible types: int cannot be converted to int[]        
assertEquals(0, Functionality.swapArray(0, 0, a, b));

/root/autocorrectorBNQIZIdir/PublicTests.java:54: error: incompatible types: int cannot be converted to int[]      
  assertEquals(0, Functionality.swapArray(0, 0, c, d));

/root/autocorrectorBNQIZIdir/PublicTests.java:62: error: incompatible types: int cannot be converted to int[]        
assertEquals(0, Functionality.swapArray(-2, 3, a, b));

/root/autocorrectorBNQIZIdir/PublicTests.java:63: error: incompatible types: int cannot be converted to int[]       
assertEquals(0, Functionality.swapArray(4, 3, a, b));

/root/autocorrectorBNQIZIdir/PublicTests.java:64: error: incompatible types: int cannot be converted to int[]        
assertEquals(0, Functionality.swapArray(9, 12, a, b));
Das sind die Fehlermeldungen.
 
J

JustNobody

Also es ist doch der Methodenkopf vorgegeben worden:
Java:
 public static int swapArray(int i, int j, int[] a, int[] b) {
(So habe ich zumindest den ersten Satz der Aufgabe verstanden ("Gegeben ist die Signatur der Methode swapArray in Functionality.java.")

Also ist es schon eine gute Leistung, diesen vorgegebenen Part anzupassen. (Und der Fehler besagt ja auch nichts anderes. Er versucht die Methode aufzurufen nur der erste Parameter ist nun ein int und der kann er nicht in ein array von Ints umwandeln ....

Und ein paar einfache Hinweise, die Du wirklich beherzigen solltest:
a) Wenn eine Methode einen Wert zurück gibt, dann nutz ihn auch. Es gibt nur sehr selten den Fall, dass dies anders ist.
b) Als Anfänger solltest Du NIEMALS den ++ Operator innerhalb von anderen Statements aufrufen. Du hast Probleme, Code zu übersehen und dann ist sowas garantiert Kontraproduktiv. Ein swapArray(dataA, dataB, ++from, to) ist also etwas, das in meinen Augen schlicht idiotisch ist!
c) Parameter sind eine Eingabe und sollten nicht verändert werden. Das ist evtl. am Anfang etwas blöd, vor allem wenn es scheint, als ob da schon fast dazu aufgefordert wird (".. so wird ... für "to" verwendet.") Das ist aber ähnlich blöd wie der Punkt b. Wenn Du eine Eingabe bereinigen musst, dann hab einen Parameter eingabe und von mir aus eine Variable bereinigteEingabe.

Das einfach einmal als kleine Hilfestellung ... über den Punkt c) mag man ja gerne diskutieren wollen, aber a und b solltest Du beherzigen. Und wenn Du bei a) einen Rückgabewert nicht nutzt, dann hab eine gute Begründung dafür parat, warum Du diesen hier einfach weg wirfst.
 
J

jono

Ja, dann hab ich doch richtig gedacht, dass es, steht ja auch da dass int nicht in int[] komvertiert werden kann. Hatte ich übrigens auch schon geändert
 
R

Rahza

Wie in der Aufgabe vorgegeben wurde, soll für den Fall, dass das Array null ist, 0 zurückgegeben werden.

Hierzu eine allgemeine Frage:
Reicht bei sowas die Abfrage if (array == null)?
Oder sollte auch array.length == 0 bzw. die Tatsache, dass array==null für alle i gesprüft werden?
 
Zuletzt bearbeitet:
J

jono

Wie hättest du es dann gemacht statt des ++-Operators?
Gute Frage @Rahza, habe ich mich auch gefragt
 
J

jono

Aber laut meiner Fehlermeldung dürfte es nicht so sein
@JustNobody Wie ist das denn jetzt mit dem Rückgabetyp?
Java:
return swapArray(++from, to, dataA, dataB);
Wenn ich das zurückgebe, reicht das ja noch nicht aus.
Vielleicht eine kleine Hilfestellung wie ich darauf komme, was genau ich jetzt zurückgeben muss?
Verstehe was dahintersteckt, nur wie ich die Anzahl der Vertauschungen jetzt definiere ist mir ziemlich
unersichtlich
 
Zuletzt bearbeitet:
J

JustNobody

Also was willst Du übergeben? Doch den Wert aus der variable plus 1. Also könnte man das auch entsprechend so schreiben. Die Variable ist nicht anzupassen und du musst Dir keine Gedanken machen, was da übergeben wird bezüglich ++variable / variable-- .... Und vor allem soll ja nur so ein Wert übergeben werden und nicht der Wert geändert werden. Also wenn der Wert nicht geändert werden soll, dann mach das auch nicht.

Und was die Rückgabe ist: Was wird denn da zurück gegeben?

Wir füllen einmal eine Kiste mit Äpfeln. Uns interessiert die Anzahl an Äpfel, die da hinein getan werden. Die Kiste geht von Person zu Person. Jede legt einen Apfel hinein und gibt die Kiste weiter. Das geht bis diese bei einer Person landet, die gar keine Äpfel hat und somit keinen Apfel hinein tun kann.
Also gibt diese die Kiste zurück und sagt: 0 Äpfel.
Nun auf dem Rückweg nimmt jeder die gefüllte Kiste entgegen incl. eine Information ....
...
Wenn jetzt eine Person die Kiste mit der Aussage "x Äpfel" bekommt diese dann weiter gibt: Was sagt diese Person?

Wenn Du das verstanden hast, dann kannst Du es etwas Anwenden. Wenn Du da noch Probleme hast, dann lass die Personen die Äpfel nicht auf dem Hinweg sondern auf dem Rückweg in die Kiste legen ...

==> Einfache angewandte Rekursion ...
 
J

jono

JustNobody's Hilfestellung konnte ich nicht wirklich auf die Aufgabe übertragen. @mihe7
Sag einfach mal, nicht dass du den Kaffee gleich nicht mehr schlucken kannst.^^
 
R

Rahza

Habe nun folgenden Code:
Code:
public class Functionality {
    
    public static int swapArray(int from, int to, int[] a, int[] b) {
        if (a==null||b==null||from<0||from>to||from>a.length||from>b.length) {
            return 0;
        }
        
        if(to>a.length||to>b.length) {
            if(a.length<b.length) {
                to=a.length;
            }else {to=b.length;}
        }
        int count =0;
        int temp;
        temp = b[from];
        b[from] = a[from];
        a[from] = temp;
        count++;
        swapArray(from+1,to,a,b);
        return count;
    }
}
 
R

Rahza

Folgende Fehlermeldung erhalte ich:
Code:
JUnit version 4.12
.E...E.
Time: 0.007
There were 2 failures:
1) testNormalfall(PublicTests)
java.lang.AssertionError: expected:<4> but was:<1>
    at org.junit.Assert.fail(Assert.java:88)
    at org.junit.Assert.failNotEquals(Assert.java:834)
    at org.junit.Assert.assertEquals(Assert.java:645)
    at org.junit.Assert.assertEquals(Assert.java:631)
    at PublicTests.testNormalfall(PublicTests.java:15)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.base/java.lang.reflect.Method.invoke(Method.java:566)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:52)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runners.Suite.runChild(Suite.java:128)
    at org.junit.runners.Suite.runChild(Suite.java:27)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:115)
    at org.junit.runner.JUnitCore.runMain(JUnitCore.java:77)
    at org.junit.runner.JUnitCore.main(JUnitCore.java:36)
2) testToZuGross(PublicTests)
java.lang.ArrayIndexOutOfBoundsException: Index 7 out of bounds for length 7
    at Functionality.swapArray(Functionality.java:18)
    at Functionality.swapArray(Functionality.java:22)
    at Functionality.swapArray(Functionality.java:22)
    at Functionality.swapArray(Functionality.java:22)
    at Functionality.swapArray(Functionality.java:22)
    at Functionality.swapArray(Functionality.java:22)
    at Functionality.swapArray(Functionality.java:22)
    at PublicTests.testToZuGross(PublicTests.java:41)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.base/java.lang.reflect.Method.invoke(Method.java:566)
    at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:52)
    at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
    at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
    at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runners.Suite.runChild(Suite.java:128)
    at org.junit.runners.Suite.runChild(Suite.java:27)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
    at org.junit.runner.JUnitCore.run(JUnitCore.java:115)
    at org.junit.runner.JUnitCore.runMain(JUnitCore.java:77)
    at org.junit.runner.JUnitCore.main(JUnitCore.java:36)

FAILURES!!!
Tests run: 5,  Failures: 2
Der Public-Test:
Code:
import static org.junit.Assert.*;

import org.junit.Test;

public class PublicTests {

    @Test
    public void testNormalfall() {
        int[] a = {8, 2, 7, 4, 1, 6, 3};
        int[] b = {23, 56, 21, 12, 87, 34, 1};
        
        int[] c = {8, 56, 21, 12, 87, 6, 3};
        int[] d = {23, 2, 7, 4, 1, 34, 1};
        
        assertEquals(4, Functionality.swapArray(1, 4, a, b));
        assertArrayEquals(a, c);
        assertArrayEquals(b, d);
    }
    
    @Test
    public void testFromGleichTo() {
        int[] a = {8, 2, 7, 4, 1, 6, 3};
        int[] b = {23, 56, 21, 12, 87, 34, 1};
        
        int[] c = {8, 2, 7, 12, 1, 6, 3};
        int[] d = {23, 56, 21, 4, 87, 34, 1};
        
        assertEquals(1, Functionality.swapArray(3, 3, a, b));
        assertArrayEquals(a, c);
        assertArrayEquals(b, d);
    }
    
    @Test
    public void testToZuGross() {
        int[] a = {8, 2, 7, 4, 1, 6, 3 , 9};
        int[] b = {23, 56, 21, 12, 87, 34, 1};
        
        int[] c = {8, 56, 21, 12, 87, 34, 1, 9};
        int[] d = {23, 2, 7, 4, 1, 6, 3};
        
        assertEquals(6, Functionality.swapArray(1, 400, a, b));
        assertArrayEquals(a, c);
        assertArrayEquals(b, d);
    }
    
    @Test
    public void testNullTest() {
        int[] a = null;
        int[] b = {23, 56, 21, 12, 87, 34, 1};
        assertEquals(0, Functionality.swapArray(0, 0, a, b));
        
        int[] c = {8, 2, 7, 4, 1, 6, 3};
        int[] d = null;
        assertEquals(0, Functionality.swapArray(0, 0, c, d));
    }
    
    @Test
    public void testFrom() {
        int[] a = {8, 2, 7, 4, 1, 6, 3};
        int[] b = {23, 56, 21, 12, 87, 34, 1};
        
        assertEquals(0, Functionality.swapArray(-2, 3, a, b));
        assertEquals(0, Functionality.swapArray(4, 3, a, b));
        assertEquals(0, Functionality.swapArray(9, 12, a, b));
    }

}
 
R

Rahza

Ich gehe davon aus, dass bei jedem rekursiven Aufruf die Count-Variable wieder auf 0 gesetzt wird und daher keine Zählung stattfindet.
Bei dem zweiten Fehler habe ich das nicht ganz verstanden
 
mihe7

mihe7

JustNobody's Hilfestellung konnte ich nicht wirklich auf die Aufgabe übertragen. @mihe7
Sag einfach mal, nicht dass du den Kaffee gleich nicht mehr schlucken kannst.^^
Das war nicht zu übersehen :)

Wenn Dir Dein Nachbar eine Kiste gibt und sagt, er habe 25 Äpfel in die Kiste gelegt und Du weißt, dass Du einen Apfel in die Kiste gelegt hast, wie viele Äpfel haben dann Du und Dein Nachbar gemeinsam in die Kiste gelegt?
 
J

jono

Also mein Gefühl sagt mir, du hast auf jeden Fall falsch geantwortet, aber wenn eine Kiste mit x Äpfeln weitergegeben wird, verändert sich die Variable x sich nicht
 
J

JustNobody

Du hast die Info, dass ich dir X Äpfel gegeben habe und du weißt, dass du einen Apfel hinzu gefügt hast ....

Und statt Äpfel tauschen wir Elemente. Du hast 1 Element getauscht und bekommst gesagt, wie viele Elemente im weiteren Vorgehen getauscht wurden ... wie viele Elemente wurden dann getauscht?

Also das sind Basis Vorgehen bei Rekursion. Mach anschauliche Beispiele mit Rekursion. So ein massives Problem bedeutet, dass du mehr Übung brauchst.
 
mihe7

mihe7

Dein Nachbar sagt Dir, er hat x Elemente getauscht, Du weißt, Du hast 1 Element getauscht. Wie viele Elemente wurden dann insgesamt getauscht?
 
J

jono

Java:
1) testToZuGross(PublicTests) java.lang.ArrayIndexOutOfBoundsException: Index 7 out of bounds for length 7
Wie kann ich diesen Fehler jetzt noch beseitigen?
 
J

jono

Java:
return swapArray(to-from + 1, to, a, b);
So?^^Aber ich kann es mir nur so erklären, denn es muss ja in der Rekursivmethode vorkommen ...
 
J

JustNobody

Hmm ... welche Croudfunding Plattform ist denn gut, um Spenden einzusammeln? Ich denke es ist langsam Zeit, dass @mihe7 einen neuen Tisch und eine neue Tastatur bekommt.... Und wie sah es bisher mit den Arztrechnungen aus? Zahlt die noch die Krankenkasse oder gibt es da schon Probleme?

@jono Hast Du überhaupt eine Vorstellung, was Du da machst? Hast Du Dir da mal eine Skizze gemacht oder so?
Wenn man so etwas lösen will, dann braucht man eine klare Vorstellung vom Problem. Ohne die kann man es nicht lösen!
 
J

jono

Ich habe eine klare Vorstellung zum Problem, ich habe mir zwar keine Skizze gemacht, habe es nicht für unbedingt nötig empfunden. Ich hätte es total logisch gefunden einfach return to-from zurückzugeben direkt nach der Rekursivmethode , nach dem Motto jedes Mal, wenn diese aufgerufen wurde, gibt er die Anzahl der Vertauschungen zurück.
 
J

JustNobody

Bei einer Rekursion hast Du in der Regel ein f(n) das mit einem f(n-1) ausgedrückt werden soll.

In diesem Fall wäre das ein f(n) = f(n-1) + 1 (Wenn man die Abbruchbedingung weg lässt und ignoriert.)

Somit wäre bei der Rekursiven Ausdrucksweise halt ein einfaches return swapArray(......) + 1;

Wenn Du das Ergebnis direkt berechnen kannst, dann macht es aber wenig Sinn. Dann kann man gleich hinschreiben f(n) = n oder so. Da spart man sich dann gleich ganz viel...

Aber bei der Rekursion spart man sich sowas. Das ist hier in diesem Beispiel auch etwas blöd, denn aus Clean Code Sicht ist das eine Methode, die sowohl etwas berechnet / zurückgibt als auch eben etwas verändert.
 
L

lennero

Ehrlich gesagt musst du nur die Teilprobleme in mihe7's post #2 lösen. Dann sollte alles klar sein.

Ohne die Grenzfälle ist das ein Vierzeiler.
 
mihe7

mihe7

Ich habe eine klare Vorstellung zum Problem, ich habe mir zwar keine Skizze gemacht, habe es nicht für unbedingt nötig empfunden.
Grober Fehler. Ein Bild sagt mehr als tausend Worte.

Ich hätte es total logisch gefunden einfach return to-from zurückzugeben direkt nach der Rekursivmethode , nach dem Motto jedes Mal, wenn diese aufgerufen wurde, gibt er die Anzahl der Vertauschungen zurück.
Wie gesagt: das wäre die Alternative, die im konkreten Fall funktionieren würde. Was aber, wenn der Tausch der Elemente einer Bedingung unterliegt, z. B. Elemente nur dann getauscht werden sollen, wenn das Element im Array a größer als das Element im Array b ist? Dann funktioniert from-to+1 nicht mehr.
 
mihe7

mihe7

Java:
return swapArray(......) + 1;
Also so?
Ja, das wäre die Lösung (ich erwähne mal vorsichtshalber dazu, dass die Punkte durch sinnvolle Parameter ersetzt werden müssen :p), die Dir aber nichts bringt, so lange Du den Sinn bzw. das Prinzip nicht verstehst.
 
J

jono

Den Sinn verstehe ich jetzt, nur solche Fälle wie:
Java:
Was aber, wenn der Tausch der Elemente einer Bedingung unterliegt, z. B. Elemente nur dann getauscht werden sollen, wenn das Element im Array a größer als das Element im Array b ist? Dann funktioniert from-to+1 nicht mehr.
sind meiner Auffassung doch dann gar nicht relevant bei dieser Aufgabenstellung, weshalb ich es als sinnvoll erachtet hätte.
2.
Java:
return swapArray(from + 1, to, a, b) + 1;
Dann so, aber trotzdem noch Fehlermeldung.
 
mihe7

mihe7

sind meiner Auffassung doch dann gar nicht relevant bei dieser Aufgabenstellung, weshalb ich es als sinnvoll erachtet hätte.
Anforderungen ändern sich schneller als Du tippen kannst. Es wäre ein leichtes, die Bedingung in die Aufgabenstellung einzufügen - z. B in einer Folgeaufgabe...

Dann so, aber trotzdem noch Fehlermeldung.
Meinst Du die ArrayIndexOutOfBoundsException? Wenn Du alles verstanden hast, solltest Du das Problem in einer Minute selbst beheben können.
 
J

jono

Java:
if(to >= a.length || to >= b.length) return 0;
Könnte das ein richtiger Ansatz sein? Denn die ArrayIndexOutOfBoundsException tritt auf, wenn versucht wird ein Array mit einem ungültigen Index anzusprechen, woraus ich schlussfolgern kann, dass die to-Indexzahl nicht der Arraylänge entsprechen darf bzw. größer sein darf. Zwar klappt es so nicht, aber müsste doch vom Gedanke her korrekt sein ?
 
J

jono

Java:
public class Functionality {
 public static int swapArray(int from, int to, int[] a, int[] b) {
  if (a == null || b == null)
   return 0;
  if (from < 0 || from > to || a.length < from || b.length < from)
   return 0;
  if (to >= a.length || to >= b.length)
   return 0;
  int tmp = b[from];
  b[from] = a[from];
  a[from] = tmp;
  return swapArray(from + 1, to, a, b) + 1;
 }
}
 
S

Snaer

Java:
  if (to >= a.length || to >= b.length)
   return 0;
Das entspricht nicht dem gegebenen "Spezialfall"
Wenn "to" größer als die Länge-1 des kleinsten Arrays ist, so wird die Länge-1 des kleinsten Arrays für "to" verwendet.

Und falls du diesen meintest
Wenn "from" negativ, größer als "to" oder größer als die Länge eines Arrays ist, so wird 0 zurückgegeben.

Dieser bezieht sich auf from nicht auf to.
 
J

jono

Okay, habe den Spezialfall völlig außer Acht gelassen, damit hat sich das Thema dann schon geklärt...
 
R

Rahza

Grober Fehler. Ein Bild sagt mehr als tausend Worte.


Wie gesagt: das wäre die Alternative, die im konkreten Fall funktionieren würde. Was aber, wenn der Tausch der Elemente einer Bedingung unterliegt, z. B. Elemente nur dann getauscht werden sollen, wenn das Element im Array a größer als das Element im Array b ist? Dann funktioniert from-to+1 nicht mehr.
Das funktioniert doch schon nicht mehr, wo from=0 und to=0, weil dann das richtige Ergebnis 0 ist, aber 1 ausgegeben werden würde
 
Zuletzt bearbeitet:
D

DerRetter

Hey Jono,

könntest du mir vllt. sagen, wie du den Spezialfall

"Wenn "to" größer als die Länge-1 des kleinsten Arrays ist, so wird die Länge-1 des kleinsten Arrays für "to" verwendet. "

gelöst hast?
 
Thema: 

Rekursive swapArray Methode

Passende Stellenanzeigen aus deiner Region:
Anzeige

Neue Themen

Anzeige

Anzeige
Oben