Can't have more than 2 in 5

"Dans le cas où quelqu'un tomberait sur le même problème que moi"
Et bien pour lui, voici ce qu'il pourrait faire :

System.out.print("Entrez le nombre de nuits que vous comptez rester : ");
int nbTotal = scanner.nextInt();

int base = (nbTotal / 7) * 2;
int mod = nbTotal % 7;
int min = (mod == 6) ? base + 1 : base;
int max = (mod < 2) ? base + mod : base + 2;

System.out.print("Entrez le nombre de nuits qui tombent le week-end (entre " + min + " et " + max + ") : ");
int nbWeekEnd = scanner.nextInt();

if (nbWeekEnd < min) {
    System.err.println("Pas assez de nuits qui tombent le week-end");
} else if (nbWeekEnd > max) {
    System.err.println("Trop de nuits qui tombent le week-end");
} else {
    System.out.println("Ok");
}

Petite explication : on a forcément 2 nuits de week-end pour chaque semaine complète (c'est la base du calcul), auquel on peut rajouter 0, 1 ou 2 nuits selon le nombre de jours restants.

Le nombre minimum de nuits à rajouter est 0 (car on peut tomber sur des nuits dans la semaine), sauf s'il y a 6 jours restants, dans ce cas il y a toujours au moins 1 nuit qui tombe sur le week-end.

Quand au nombre maximum de nuits à rajouter c'est 2, sauf bien sûr s'il y a moins de 2 nuits restantes.

Je poste aussi le code complet, question que les plus braves d'entre vous compreniez peut-être mieux :)

 

do{
            sousTotal=0; //Réinitialiser nos variable de prix
            total=0; //Reset prices variable
            System.out.println("Bien le bonjour, bienvenue chez HotelHub.");
            do{
                try {//try catch pour éviter les erreurs de variable type.
                    Scanner scanner = new Scanner(System.in);
                    System.out.println("Entrez le nombre de nuit que vous comptez rester : ");
                    jourS = scanner.nextInt();
                    System.out.println("Entrez le nombre de nuit de fin de semaine : ");
                    jourFds = scanner.nextInt();

                    //Verif du nombre de jourFDS ne dépasse pas par tranche de 7jours

                    if(jourFds >= 2 || jourS >= 5 || jourS > 0 || jourFds > 0){
                        if(jourFds > jourS){
                            System.out.println("Pas OK");
                            continue;
                        }
                        else if(jourFds > 2 && !(jourFds > jourS)){
                            jourOK=true;
                            break;
                        }else if (jourFds <= 2 || jourS > 0 || jourFds >= 2){
                            jourOK=true;
                            break;
                        }else if(jourS == 0 && jourFds == 0){
                            System.out.println("Pas OK");
                            continue;
                        }else{
                            System.out.println("Pas OK");
                            continue;
                        }
                    }else{
                        System.out.println("Pas Ok");
                        continue;
                    }

                    //Catch except

                } catch (Exception e) {
                    System.out.println("Il semble que vos demande soient invalide. veuillez réessayer...");
                }
            }while(true);

Bonsoir

commençons par ton premier if

if(jourFds >= 2 || jourS >= 5 || jourS > 0 || jourFds > 0)

Je change l'ordre pour que ça soit plus parlant (et comme ce sont des OU ça donne le même résultat)

if(jourFds >= 2 || jourFds > 0  || jourS >= 5 || jourS > 0)

Si jourFds vaut

• 3, la première condition est valide, c'est un OU, donc le résultat sera vrai peu importe la suite.
• 2, idem
• 1, la première condition est invalide, on passe à la suivante, qui elle est valide, donc le résultat sera vrai peu importe la suite, par contre, on constate que:
  • 3 aurait aussi validé cette condition
  • 2 de même

Donc tester si une valeur est >= 2 ou >0 revient à tester si elle est > 0.

Donc, sans même réfléchir à l'énoncé, ce if peut se simplifier de cette façon

if(jourFds > 0 || jourS > 0)

Ensuite, on te demande de vérifier que pour X jours de semaine, il y a toujours au maximum Y jours de fin de semaine.

Et que ce rapport est 2 pour 5.

Je pense qu'en divisant un nombre de jours par l'autre tu devrais arriver à vérifier cette hypothèse.

Bonjour,

"Je me doute bien que c'est à 90% inutile et que la réponse doit être très simple"

En effet, ça ressemble à un problème de maths niveau collège.

Dans ton exemple, tu restes 25 jours, soit 3 semaines et 4 jours. Donc tu auras obligatoirement 3 week-end, éventuellement un 4è selon le jour d'arrivée, soit entre 6 et 8 jours.

On pourrait affiner mais en gros il faut juste diviser par 7 et accepter une tolérance de 2 jours.

public static boolean jours(int y, int x){ //Methods to verify that there is maximum of Y(2) per X(5) + exceptions. 
        if(y < 0 && x < 0 || x == 0 && y > 2 || x > 0 && y == 0){
            if(x > 0 && y == 0){
                return true;
            }else{
                return false;
            }
        }else if(x%5==0 && y%2==0){
            return true;
        }else if(x > 0 && x <= 5 && y > 0 && y <= 2){
            return true;
        }else{
            return false;
        }
    }

Voici la solution à laquelle je suis arrivé, dit moi ce que tu en pense ! :)

"voici l'énoncé : Nombre de jours de fin de semaine -­> Maximum 2 nuits de fin de semaine par tranche de 7 jours"

C'est donc bien ce que je disais dans ma réponse :

"On pourrait affiner mais en gros il faut juste diviser par 7 et accepter une tolérance de 2 jours."

Pour calculer le nombre de jours de week-end possibles il faut commencer par connaître le nombre de semaines.

Donc si dans ton algorithme tu n'as pas de division par 7 c'est que tu t'es trompé quelque part. Or dans les différents codes que tu as proposé tu n'as jamais ni de division, ni de 7...

Bonjour 

donc KX avait raison, tu n'avais pas donné ton énoncé mais ton interprétation de celui-ci.

Et du coup, je t'ai proposé de diviser par 5 alors que non.

L'idée est que tu découpes ton nombre total de jours en paquets de 7.

Si tu n'as que des paquets de 7, alors tu as des semaines entières et donc le nombre de jours de week-end est fixe.

Si tu as un paquet incomplet, il faut que tu détermines combien tu peux avoir de jours de week-end dans ce paquet. Ces jours viendront en plus des semaines complètes.

Dans le cas où quelqu'un tomberait sur le même problème que moi, je poste ici la solution que j'ai trouvé et qui est fonctionnelle :)

public static boolean jours(int y, int x){ //Methods to verify that there is maximum of Y(2) per 7d - X(5)... + exceptions. 
        int z = 0; //Variable de calcul 
        if ((x%5>=0) && y > 2 && !(y >= x)){ //Verifie que x est divisable par 5 et supérieur à 0,  
                                               y est supérieur a 2 et que y n'est pas supérieur a x
            z = x / 5;
            if(y%2==0){ //Divise y par 2 pour faire une comparaison plus tard avec z.
                if((z * 2)==y){
                    return true;
                }
            }else{
                if((z+2)==y){
                    return true;
                }
                return false;
            }
        }else{
            if(x <= 5 && y <= 2){
                return true;
            }else{
                return false;
            }
        }
        return false;
    }