Créer un triangle de stars en utilisant uniquement la récursivité

J'ai besoin d'écrire une méthode qui est appelée comme printTriangle(5);. Nous avons besoin de créer une méthode itérative et récursive de la méthode (sans itération). La sortie doit ressembler à ceci:

*
**
***
****
*****

Ce code fonctionne avec l'itératif, mais je ne peux pas l'adapter pour être récursive.

public void printTriangle (int count) {
    int line = 1;
    while(line <= count) {
        for(int x = 1; x <= line; x++) {
            System.out.print("*");
        }
        System.out.print("\n");
        line++;
    }
}

Je note que vous ne pouvez pas utiliser n'importe quelle classe les variables de niveau ou externes méthodes.

Est-ce un devoir?
Les espaces ne sont pas valides caractères en Java noms de méthode. Vous devrez l'appeler like_printTriangle(5)
Oui, il est. C'est la première fois en 22 chapitres, j'ai eu aucun problème. @mobrule: Ce que cela a à voir avec quoi que ce soit? Une chose que j'ai essayé a été formaté à l'aide de la chaîne, mais il semble que Java ne prend pas en charge personnalisée les caractères de remplissage.
Pourquoi avez-vous combiner une boucle while et pour la boucle dans la version itérative? Il sera beaucoup plus propre (et peut-être plus facile de convertir à la récursion) avec deux boucles for imbriquées).
Je pourrais, mais mon professeur dit qu'il veut la clarté sur les performances (je pense qu'il est juste paresseux).
Voir aussi: stackoverflow.com/questions/2498039/...

InformationsquelleAutor Alec Gorge | 2010-04-26

java recursion

16

Avis dans votre démarche itérative qui vous avez deux compteurs: la première est que ligne vous êtes sur line, et la deuxième est ce que la position sur la ligne que vous êtes sur x. Vous pouvez créer une fonction récursive qui prend deux paramètres et les utilise comme imbriquée compteurs, y et x. Où vous décrémenter x jusqu'à ce qu'il atteigne 0, décrémenter y et x = y, jusqu'à ce que x et y sont égales à 0.

Vous pouvez également remarquer que chaque ligne successive dans le triangle est la ligne précédente, plus une étoile. Si votre récursive de la fonction renvoie une chaîne d'étoiles pour la ligne précédente, la ligne suivante est toujours de cette chaîne, plus une étoile de plus. Ainsi, votre code pourrait être quelque chose comme:
```
public String printTriangle (int count) {
    if( count <= 0 ) return "";

    String p = printTriangle(count - 1);
    p = p + "*";
    System.out.println(p);

    return p;
 }
```
- wow. Je ne peux pas croire que je n'ai pas pensé à ça. Je pense a été jeté hors parce que je suppose que c'est dû retourner à vide, car il n'avait pas de sens pour retourner quoi que ce soit. Bon travail et merci! Aussi, la grande explication.
- +1 Ici est la bonne solution. Très intelligent! 🙂 Un pas pertinent d'amélioration: les deux instructions d'impression, pourraient être remplacés par un seul System.out.println(p);
- nice. et +1 à la prof pour une bonne question 🙂
- +1 pour être beaucoup plus élégant que ma solution 🙂 belle utilisation de la valeur retournée.
InformationsquelleAutor Michael Petito
4

Vous pouvez convertir une boucle récursive de la fonction comme ceci:
```
void printStars(int count) {
    if (count == 0) return;

    System.out.print("*");
    printStars(count - 1);
}
printStars(5);    //Prints 5 stars
```
Vous devriez être en mesure de faire un similaires de la fonction d'impression des lignes.
- qui affiche 1 ligne. l'assignation est pour un ensemble de triangle dans la méthode 1. C'est pourquoi il est source de confusion pour moi.
- Vous pouvez toujours déposer les cours?
- ensuite, vous avez juste besoin de savoir où pour imprimer le saut de ligne
- Vous avez besoin de faire un distinct fonction récursive qui appelle printStars.
- Il n'y a rien de mal avec cette méthode particulière. Si nous avons été autorisés à utiliser 2 méthodes pour la solution il n'y aurait pas de problème. Mais nous ne pouvons utiliser 1. Avec cela, j'aurais besoin d'une autre méthode qui appelle printStars, puis imprime \n augmente alors le nombre d'étoiles imprimées pour la ligne suivante, ce qui n'est pas autorisé.
- Je vois, je n'avais pas réalisé que. Vous pouvez faire de la méthode de prendre deux paramètres – starCount et lineCount – et l'appel lui-même pour la ligne suivante après avoir fini de la ligne courante.
- La question dit qu'il doit être appelé comme printTriangle(5) qui est en quelque sorte de règles ayant 2 paramètres.
- Comme Eyal posté, argument/surcharge de la méthode permet de résoudre ce problème, mais c'est un peu exagéré. Nous allons le voir.
InformationsquelleAutor SLaks

Exemple en python (juste pour le plaisir de prototypage, mais j'espère que l'idée passe à travers):

#!/usr/bin/env python

def printTriangle(n):
    if n > 1:
        printTriangle(n - 1)
    # now that we reached 1, we can start printing out the stars 
    # as we climb out the stack ...
    print '*' * n

if __name__ == '__main__':
    printTriangle(5)

De sortie ressemble à ceci:

$ python 2717111.py
*
**
***
****
*****

Je soupçonne que ce serait considéré comme de l'itération.
Bien que valide, cela n'aide pas beaucoup pour java 🙂

InformationsquelleAutor miku

2

Vous pouvez aussi le faire avec un seul (pas très élégant) la récursivité,comme suit:
```
public static void printTriangle (int leftInLine, int currLineSize, int leftLinesCount) {
    if (leftLinesCount == 0)
        return;
    if (leftInLine == 0){ //Completed current line?
        System.out.println();
        printTriangle(currLineSize+1, currLineSize+1, leftLinesCount-1);
    }else{
        System.out.print("*");
        printTriangle(leftInLine-1,currLineSize,leftLinesCount);
    }
}

public static void printTriangle(int size){
    printTriangle(1, 1, size);
}
```
L'idée est que la méthode params représenter le dessin complet de l'état.

Noter que la taille doit être supérieure à 0.
- Pour des raisons de compréhension simple de la récursivité, il pourrait être plus clair à l'utilisation récursive de la méthode d'assistance pour l'impression de chaque ligne. Cela fonctionne aussi, mais. 🙂
- Merci, cela fonctionne. J'avais peur que je pourrais avoir à aller à un multiple de l'argument de la méthode parce que mon professeur me dit de mauvaises méthodes de surcharge est (je pense qu'il est assez utile). J'espère qu'il l'accepte. @Justin est d'être une méthode. C'est l'étirement, mais il est assez proche.
InformationsquelleAutor Eyal Schneider
0

Vous pouvez le faire comme ceci:

La méthode obtient le nombre d'étoiles comme un paramètre. Appelons n.

Puis c':
1. appelle récursivement à n-1.
2. affiche une ligne avec n étoiles.
Assurez-vous de ne rien faire si n == 0.
- L'impression d'une ligne avec n étoiles implique itération, à moins que définies de manière récursive séparément.
InformationsquelleAutor Ilya Kogan

package playground.tests;

import junit.framework.TestCase;

public class PrintTriangleTest extends TestCase {
    public void testPrintTriangle() throws Exception {
        assertEquals("*\n**\n***\n****\n*****\n", printTriangleRecursive(5, 0, 0));
    }

    private String printTriangleRecursive(int count, int line, int character) {
        if (line == count)
            return "";
        if (character > line)
            return "\n" + printTriangleRecursive(count, line + 1, 0);
        return "*" + printTriangleRecursive(count, line, character + 1);
    }

}

InformationsquelleAutor Carl Manaster

    void trianglePrint(int rows){
            int static currentRow = 1;
            int static currentStar = 1;

            //enter new line in this condition
            //(star > currentrow)  

            if (currentStar > currentRow ){
                currentStar = 1;
                currentRow++;
                cout << endl;
            }

            if (currentRow > rows){
                return; //finish
            }

            cout << "*";
            currentStar++;

            trianglePrint(rows);
        }

en fait ,C'est en C++ :")
vous pouvez utiliser le même concept avec une autre langue 😉

InformationsquelleAutor Fareed Alnamrouti

-1

Je pense que cela devrait fonctionner... non testés sur le dessus de ma tête.
```
public void printTriangle(int count)
{    
    if (count == 0) return;
    printTriangle(count - 1);
    for (int x = 1; x <= count; x++) { 
        System.out.print("*"); 
    }
    System.out.print("\n"); 
}
```
- On utilise à cette itération.
- cool le logo de l'homme. !!
- -1 L'OP demandé pour une méthode récursive (sans itération).
- Ya je n'avais pas remarqué le "tout itération' partie... je ne pense pas que vous pouvez utiliser plus d'une méthode, mais bien l'accepter de répondre a fait 🙁
- ainsi, la surcharge de méthode est aussi proche que je pense que nous allons nous en sortir.
InformationsquelleAutor Kelsey
-1

Donc, vous devez créer un petit bloc. Quelles sont les informations qui bloquent besoin? Juste le maximum. Mais la récursivité besoin de savoir ce que la ligne de son sur... vous vous retrouvez avec un constructeur comme:
```
public void printTriangle (int current, int max)
```
Maintenant, utilisez-les pour mettre le reste de la récursivité ensemble:
```
public void printTriangle (int current, int max)
{ 
    if (current <= max) 
    { 
         //Draw the line of stars...
         for (int x=0; x<current; x++)
         {
             System.out.print("*")
         }
         //add a newline
         System.out.print("\n"); 

         //Do it again for the next line, but make it 1-bigger
         printTriangle(current + 1, max);
    } 
} 
```
Maintenant, tout ce que vous avez à faire, c'est lancer:
```
printTriangle(1, 5);
```
- mais il a l'itération. Il a besoin d'avoir absolument aucune itération.
- Cela implique d'itération.
- Ah.. Raté la partie. Dans ce cas, vous avez juste besoin d'avoir un deuxième itératif de la fonction ... bien que la signalées comme "réponse" est assez sacrément intelligent.
InformationsquelleAutor Jerry

-1

je pense que cela devrait le faire

public void printTriangle (int count) {
   if(count >= 0) {
      printTriangle(count-1);
          for(int i = 0; i < count; i++) {
              System.out.print("*" + " ");
          }
      System.out.println(); 
   }
}

Il est encore itératif

InformationsquelleAutor Razakii

Vous devez vous connecter pour publier un commentaire.