0
votes

Comment coder sous Hourglass en utilisant la récursivité de manière plus propre?

Récemment, j'ai rencontré un petit quiz sur le codage d'un sablier en utilisant récursif en java.

Voici la partie de codage que j'ai faite.

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

La sortie est attendue comme ci-dessous dépend des arguments passés dans

 public class Demo {
        int initialInput = 0;
        int noOfAsteriskForNextLine= 0 ;
        int noOfSpace =1;
        Boolean isReversed = false;`enter code here`
        public static void main (String[] args){
            Demo d = new Demo();
            d.run();
        }
        public void printLineOfAsterisk(int noOfAsterisk){
            if(initialInput== 0){
                initialInput=noOfAsterisk;
            }

            if(noOfAsteriskForNextLine==0){
                noOfAsteriskForNextLine=noOfAsterisk;
            }

                for(int i=0;i<noOfSpace;i++){
                System.out.print(" ");
            }
            for(int i=0;i<noOfAsterisk;i++){
                System.out.print(" *");
            }
            System.out.print("\n");
                     if(isReversed&&initialInput==noOfAsterisk){
                return;
            }
            if(isReversed||noOfAsteriskForNextLine==1){
                isReversed =true;
                noOfAsteriskForNextLine++;
                noOfSpace--;
             printLineOfAsterisk(noOfAsteriskForNextLine);

            }else{
            noOfSpace++;
            noOfAsteriskForNextLine--;
            printLineOfAsterisk(noOfAsteriskForNextLine);
        }
    }
        public void run(){
            printLineOfAsterisk(4);
        }

    }

java recursion

2 commentaires

Est-ce ce que vous entendez par sablier? "***** \ n *** \ n * \ n *** \ n *****"?

Notre site sœur, Code Review , pourrait être un meilleur endroit pour cette question, comme leur portée concerne spécifiquement les améliorations apportées au code qui fonctionne déjà.

3 Réponses :

0
votes

Voici une solution rapide et sale utilisant Java 11 String.repeat :

public void hourglass(int noOfAsterisk)
{
    for(int i = 1; i < noOfAsterisk*2; i++)
    {
        int lineCt = 1+Math.max(i-noOfAsterisk, noOfAsterisk-i);
        System.out.println(repeat(" ",noOfAsterisk-lineCt+noOfSpace)+repeat("* ",lineCt).trim());
    }
}

Appel:

public String repeat(String str, int times)
{
    StringBuilder sb = new StringBuilder();
    for(int i = 0; i < times; i++)
    {
        sb.append(str);
    }
    return sb.toString();
}

0 commentaires

1
votes

Essayez celui-ci. Ici, offset est simplement non. d'espaces à donner avant les étoiles. Initialement, la fonction sera appelée avec offset = 0 ce qui signifie que dans la première ligne aucun espace ne doit être imprimé.

starCount est le no. d'étoiles à imprimer dans la ligne après l'impression des espaces.

incrément est juste d'augmenter ou de diminuer le no. d'espaces et d'étoiles qui est initialement 1 signifiant que le no. d'espaces dans la prochaine itération sera incrémenté de 1 et non. des étoiles seront décrémentées de 1.

Reportez-vous aux commentaires dans le code pour plus d'explications

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

Résultat:

import java.util.*;

public class Main
{
        public static void hourGlass(int offset, int starCount, int increment) {
              // This is the terminating condition. 
              // If offset is negative and increment is also negative, it means that no. of spaces were positive before this function call.
              // This implies that the lower half of the hourglass is completed,
              // So just return from here without executing anything
              if(offset < 0 && increment < 0)
                     return;

              // Print spaces
              for(int i=0; i<offset; i++) 
                     System.out.print(" ");
              // Print stars with a space 
              for(int i=0; i<starCount; i++) 
                     System.out.print("* ");
              // Print a new line 
              System.out.println();

              // If no. of stars is 1, then it means the upper half is completed.
              // So, here the increment is set to -1 
              // So that from next recursive call onwards stars will increase and spaces will decrease by 1
              if(starCount == 1)
                     increment = -1;

              // Call this function recursively
              hourGlass(offset + increment, starCount - increment, increment);
        }

        public static void main(String[] args)
        {
               // first argument is no. of spaces which will be zero initially
               // second arguments is number of starts, change it according to your need
               // third argument is just to increment/decrement stars & spaces
               Main.hourGlass(0, 5, 1);
        }
}

0 commentaires

0
votes

Voici ce que vous pourriez rechercher:

public class Hourglass {

    public static void main(String[] args) {
        hourglass(Integer.parseInt(args[0]), 0);
    }

    private static void hourglass(int size, int offset) {
        // print top line
        printHourglassLine(size, offset);
        if (size > 1) {
            // recursive call
            hourglass(size - 1, offset + 1);
            // print bottom line
            printHourglassLine(size, offset);
        }
    }

    private static void printHourglassLine(int size, int offset) {
        System.out.println(" ".repeat(offset) + "* ".repeat(size));
    }
}

Comme vous pouvez le voir, l'astuce consiste à imprimer une ligne du sablier avant et après l'appel de votre fonction récursive. De cette façon, vous le rendez symétrique, comme il se doit. C'est comme l'imprimer du bas et du haut en même temps.

Si vous n'utilisez pas java 11, vous aurez besoin d'un constructeur de chaînes ou similaire dans printHourglassLine (), mais la structure du code sera être pareil.

0 commentaires