Ich versuche mich auf eine Prüfung vorzubereiten, also dachte ich, ich würde ins Internet gehen und einige Rekursionsbeispiele finden. Jetzt fand ich folgende Aufgabe: Sie sollten eine printSequence-Methode codieren, wobei die Ausgabe für n = 3
wie folgt aussehen sollte 1
12
123
12
1

Und für n = 5
1
12
123
1234
12345
1234
123
12
1

Jetzt bin ich ziemlich neu in der Idee der Rekursion, also tut mir leid, dass ich etwas für eine so einfache Aufgabe gefragt habe. Aber ich kann mir nicht vorstellen, wie ich das lösen soll. Ich habe es geschafft, so etwas für n = 3
zu drucken 123
12
1

Aber ich kann einfach nicht verstehen, wie man den oberen Teil macht.

public static int printSequence(int n){
    if (n >= 1){
        for (int i = 1; i <= n; i++)
            System.out.print(i);          
        System.out.println();
        return printSequence(n-1);  
    }   
    return 0;
}

Es mag sein, dass meine Idee völlig falsch ist, aber wie gesagt, ich kann mir einfach keinen anderen Weg vorstellen, wie das geht.

0
LetsFailNoob 19 Jän. 2019 im 21:59

6 Antworten

Beste Antwort

Dies macht genau das, was Sie wollen:

   //This is the method that will be called from some other class
   public static int printSequence(int n){
       return printSequence(1, n);
   }

   /*We define this method, because the following code snippet
    is used multiple times in the method 'printSequence(int, int)'
    This method will simply print the numbers 1 - length*/
   private static void printLooper (int length){
        for(int i=1; i<=length; i++)
            System.out.print(i);
        System.out.print("\n");
    }

    /*This method has the logic. We give it 2 integers as parameters:
     int start and int end. I think the names of the parameters are self-explanatory*/
    private static int printSequence(int start, int end){
        /*This is the TERMINATING condition, so it is placed first.
         This part is really important. Always be aware of what type of recursion
         you are using. More on this later..*/
        if ( end == 1 ) {
            printLooper(end);
            return 0;
        }

        //OK. So, if start is less than end, then print 1 - start
        if (start < end){
            printLooper(start);
            //then return method recursively, with start INCREMENTED by one
            return printSequence(start+1, end);
        }

        /*Now, if start is equal to end, print number 1 - start, but this time,
        return the method recursively with end DECREMENTED by one*/
        else if (start == end){
            printLooper(start);
            return printSequence(start, end-1);
        }

        /*Now if start is larger than end, then that means that we need to start
         printing the lower part of the 'number tree'. So, call printLooper()
         to print 1 - end.*/
        else if (start > end){
            printLooper(end);
            return printSequence(start, end-1);
        }
        return 0;
    }

Informationen zu Rekursionstypen und warum es wichtig ist zu wissen, welche Art von Funktion Sie schreiben, finden Sie unter Tutorial.

1
Soutzikevich 19 Jän. 2019 im 19:57

Es gibt wahrscheinlich einen saubereren Weg, dies zu tun, aber ein einfacher Weg besteht darin, eine andere Funktion zu erstellen und dort Standardparameter zu übergeben:

  1. Sie überprüfen, ob Ihr aktueller Iterationswert i größer als n ist, und beenden dann.
  2. Wenn i == n, drucken Sie nur eine Zeichenfolge (den Gipfel oder Ihre Pyramide).
  3. In anderen Fällen drucken Sie Zeilen vor und nach allen enthaltenen Iterationen.

Beispielsweise:

public static int printRecursive(int n, String line, int i) {
     if (i > n) {
        return 0;
    }
    System.out.println(line);
    if (i == n) {
        return 0;
    }
    printRecursive(n, line + " " + (++i), i);
    System.out.println(line);
    return 0;
 }

 public static int printSequence(int n){
    return printRecursive(n, "1", 1);
 }
1
andnik 19 Jän. 2019 im 19:30

Hier ist ein Code, der Ihnen helfen könnte. Der Code lautet wie folgt. Es ist ziemlich selbsterklärend. Aber ich werde eine detaillierte Erklärung hinzufügen, wenn es Ihnen kompliziert erscheint.

public static int printSequence(int n) {
    return printSequence(1, n); //start printing upper triangle (1 to n)
}

public static int printSequence(int currentNumber, int lastNumber){
    for (int i = 1; i <= currentNumber; i++)
        System.out.print(i);          
    System.out.println();

    if(currentNumber<lastNumber) //if in upper triangle
        return printSequence(currentNumber+1, lastNumber);

    if(currentNumber>lastNumber) //if in lower triangle
        return printSequence(currentNumber-1, lastNumber);

    if(currentNumber==lastNumber) { //if the end of a triangle is reached

        if(lastNumber==1) {  //if the end of lower triangle is reached, exit the method
            return 0;
        } else {
            return printSequence(lastNumber-1, 1); //if the end of upper triangle is reached, start the lower triangle ( n-1 to 1)
        }

    }
    return 0;
}
1
Tanmoy Krishna Das 19 Jän. 2019 im 19:34

Ich denke, diese Lösung könnte funktionieren, aber sie verwendet 2 Funktionen. Jede Funktion enthält eine Rekursion:

public static void printSequence(int n){
    printSequenceHelp1(1, n - 1);
    for (int i = 1; i <= n; i++)
        System.out.print(i);          
    System.out.println();
    printSequenceHelp2(n - 1);  
}

public static void printSequenceHelp1(int k, int n){
    if (k <= n){
        for (int i = 1; i <= k; i++)
            System.out.print(i);          
        System.out.println();
        printSequenceHelp1(k + 1, n);
    }   
}

public static void printSequenceHelp2(int n){
    if (n >= 1){
        for (int i = 1; i <= n; i++)
            System.out.print(i);          
        System.out.println();
        printSequenceHelp2(n - 1);  
    }   
}

Ich bin mir ziemlich sicher, dass es eine elegantere Lösung mit nur einer Funktion gibt. Ich werde versuchen, daran zu denken, wenn ich es finde, werde ich es hier posten.

1
Netanel 19 Jän. 2019 im 19:52

Eine rekursive Lösung

public static int printSequence(int n,int count){
    if(count == 2*n){
        return 0;
    }
    else{
        if(count<=n){
            int i=1;
            while(i<=count)
            {
                System.out.print(i);
                i++;
            }
            System.out.println();
            return printSequence(n,count+1);
        }
        else{
            int i=1;
            while(i<=n-(count-n)) 
            {
                System.out.print(i);
                i++;
            }
            System.out.println();
            return printSequence(n,count+1);
        }
    }
}

PrintSequence (n, 1);

1
Sanath Kumar 19 Jän. 2019 im 19:59

Das scheint zu funktionieren. Anmerkungen:

  • Anstatt printSequence selbst rekursiv zu sein, akzeptiert es nur das Limit (n) und fungiert als Wrapper, um die rekursive Methode ab 1 aufzurufen.
  • Die rekursive Methode akzeptiert die aktuelle Zeichenfolge als Argument, sodass der Code die Zeichenfolge nicht jedes Mal von 1 rekonstruieren muss, sondern nur die letzte Ziffer anfügt.
  • Fehlerprüfung zum Auslösen einer Ausnahme, wenn das (anfängliche) Argument außerhalb des Bereichs liegt.
public static void main(String[] args) {
    printSequence(5);  // test value
}

private static void printSequence(int n) {
    if (n < 1 || n > 9) {
        throw new IllegalArgumentException("Argument must be in the range 1 to 9 inclusive.");
    }
    doRecursion(1, "", n);  // call recursive method with initial values
}

private static void doRecursion(Integer counter, String currentString, int limit) {
    String newString = currentString + counter.toString();
    System.out.println(newString);
    if (counter < limit) {
        doRecursion(counter + 1, newString, limit);
        System.out.println(newString);
    }
}
1
Gord Thompson 19 Jän. 2019 im 20:24