Comment prendre une décision sans instruction "si" ?

Question

Je suis un cours de Java et nous n'avons pas encore officiellement appris les instructions if. En étudiant, j'ai vu cette question :

Écrivez une méthode appelée pay qui accepte deux paramètres : un nombre réel pour le salaire d'un TA, et un nombre entier pour le nombre d'heures que le TA a travaillé cette semaine. La méthode doit retourner le montant à payer au TA. Par exemple, l'appel pay(5,50, 6) devrait donner 33,0. Le TA doit recevoir une rémunération pour "heures supplémentaires" égale à 1,5 fois le salaire normal pour toutes les heures au-delà de 8. Par exemple, l'appel paye(4.00, 11) devrait donner (4.00 * 8) + (6.00 * 3) ou 50.0.

Comment résoudre ce problème sans utiliser les instructions if ? Pour l'instant, j'ai réussi, mais je suis bloqué sur la rémunération régulière :

public static double pay (double salary, int hours) {

     double pay = 0;

     for (int i = hours; i > 8; i --) {
         pay += (salary * 1.5);
     }
}

Answer 1

Pour éviter l'utilisation directe de déclarations de contrôle de flux comme if o while vous pouvez utiliser Math.min y Math.max . Pour ce problème particulier, l'utilisation d'une boucle ne serait pas non plus efficace.

Ils peuvent techniquement utiliser des instructions if ou l'équivalent, mais il en va de même pour beaucoup d'autres appels à la bibliothèque standard que vous faites déjà :

public static double pay (double salary, int hours) {
     int hoursWorkedRegularTime = Math.min(8, hours);
     int hoursWorkedOverTime = Math.max(0, hours - 8);
     return (hoursWorkedRegularTime * salary) +
            (hoursWorkedOverTime  * (salary * 1.5));
}

Answer 2

Puisque vous avez utilisé une boucle for, voici une solution qui consiste à utiliser deux boucles for.

public static double pay (double salary, int hours) {

    double pay = 0;

    for (int i = 0; i < hours && i < 8; i++) {
        pay += salary;
    }
    for (int i = 8; i < hours; i++) {
        pay += (salary * 1.5);
    }

    return pay;
}

Il s'agit d'additionner le salaire pour les heures normales jusqu'à 8, puis le salaire pour les heures supplémentaires, ces dernières étant payées à 1,5 * salaire.

S'il n'y a pas d'heures supplémentaires, la deuxième boucle for ne sera pas saisie et n'aura aucun effet.

Answer 3

Il y a plusieurs façons de procéder, mais il est difficile de savoir ce qui est autorisé (si vous ne pouvez même pas utiliser la fonction if ).

Je recommande d'utiliser un while boucle :

double pay = 0;
while (hoursWorked > 8) {
    pay += (salary * 1.5);
    hoursWorked--;
}
pay += (hoursWorked * salary);

La raison pour laquelle cela fonctionne est que cela décrémente votre hoursWorked à une valeur qui est garantie comme étant inférieure ou égale à 8 (en supposant que hoursWorked y salary sont toutes deux supérieures à 0 ). Si hoursWorked <= 8 alors il n'entrera jamais dans le while boucle.

Answer 4

Si vous voulez vraiment faire du bricolage, vous pouvez utiliser des opérateurs binaires :

int otherHours = hours - 8;
int multiplier = (~otherHours & 0x80000000) >>> 31;
otherHours *= multiplier;

return otherHours * 0.5 * salary + hours * salary;

Donc, en gros, si otherHours est négatif, il ne devrait pas y avoir de surpaiement. Pour ce faire, nous sélectionnons le bit de signe de otherHours et le décale vers le bit le moins significatif (avec un remplissage de 0) pour signifier soit 1 soit 0. Après l'avoir d'abord nié (si le bit de signe est 1, le multiplicateur doit être 0).

Quand vous multipliez cela avec otherHours il sera 0 dans le cas où il y a moins de 8 heures, afin de ne pas soustraire accidentellement une rémunération, lors du calcul final.

Answer 5

Pour mémoire, voici une solution assez proche de l'endroit où vous avez été arrêté :

public static double pay (double salary, int hours) {
     double pay = salary * hours;
     for (int i = hours; i > 8; i --) {
         pay += salary * 0.5;
     }
}