How to make a decision without an if statement

Question

I'm taking a course in Java and we haven't officially learned if statements yet. I was studying and saw this question:

Write a method called pay that accepts two parameters: a real number for a TA's salary, and an integer for the number hours the TA worked this week. The method should return how much money to pay the TA. For example, the call pay(5.50, 6) should return 33.0. The TA should receive "overtime" pay of 1.5 times the normal salary for any hours above 8. For example, the call pay(4.00, 11) should return (4.00 * 8) + (6.00 * 3) or 50.0.

How do you solve this without using if statements? So far I've got this but I'm stuck on regular pay:

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

     double pay = 0;

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

Answer 1

To avoid direct use of flow control statements like if or while you can use Math.min and Math.max. For this particular problem using a loop would not be efficient either.

They may technically use an if statements or the equivalent, but so do a lot of your other standard library calls you already make:

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

Since you've used a for loop, here's a solution just using two for loops.

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;
}

This sums the salary for the regular hours up to 8, and then sums the salary for the overtime hours, where the overtime hours are paid at 1.5 * salary.

If there are no overtime hours, the second for loop will not be entered and will have no effect.

Answer 3

There's a few ways you can go about this, but it's hard to know what's allowed (if you can't even use if).

I would recommend using a while loop:

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

The reason why this works is it decrements your hoursWorked to a value that is guaranteed to be less than or equal to 8 (assuming hoursWorked and salary are both greater than 0). If hoursWorked <= 8, then it will never enter the while loop.

Answer 4

If you really want to get hacky, you could use bitwise operators:

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

return otherHours * 0.5 * salary + hours * salary;

So basically, if otherHours is negative, there should be no overpay. We do this by selecting the sign bit of otherHours and shifting it to the least significant bit (with 0 padding) to mean either 1 or 0. After first negating it (if sign bit is 1, multiplier should be 0).

When you multiply this with otherHours it will be 0 in the case there are less than 8 hours, so as not to accidentally subtract any pay, when doing the final calculation.

Answer 5

Just for the record, here is a solution quite close to where you were stopped :

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

Answer 6

You can simply use a ternary operator ?::

 pay = hours*salary + ((hours > 8) ? (hours-8)*salary*0.5 : 0); 

— pay a standard salary for the whole time worked, plus 50% for time above 8 hours (if any).

Answer 7

A cast to int can be abused for this purpose.

Note that the function

f(x) = 10/9 - 1/(x+1) = 1 + 1/9 - 1/(x+1)

is between 0 and 1 (exclusive) for 0 <= x < 8 and between 1 and 1.2 for x >= 8. Casting this value to int results 0 for x < 8 and in 1 for x >= 8.

This can be used in the calculation of the result:

public static double pay(double salary, int hours) {
    int overtime = (int)(10d/9d - 1d/(hours+1));
    return salary * (hours + 0.5 * overtime * (hours - 8));
}

Answer 8

Here's a way to do it using truncation from integer division, something that you probably have learnt at the start of java courses. Essentially the solution is a one liner that does not need if, loops, comparisons, libraries.

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

    //Pay all hours as overtime, and then subtract the extra from the first 8 hours
    double p1 = (hours * 1.5 * salary) - (4 * salary); 

    //In the case where the TA works for less than 8 hours, 
    //subtract all the extra so that ultimately, pay = salary * hours
    double p2 = (hours * 0.5 * salary) - (4 * salary); 

    //When theres no overtime worked, m equals to 1. 
    //When there are overtime hours, m is equals to 0.
    int m = (8 + 7) / (hours + 7);

    //When there are overtime hours, pay is simply equal to p1. 
    //When there are no overtime hours, p2 is subtracted from p1.
    return p1 - m*p2; 
}

Answer 9

A solution which does not use any conditional(implicit or explicit)

Practically, you need to calculate hours * rate but if you have overtime then you need to add a bonus of the form overtime_hours * overtime_rate

in pseudo-code:

//you need to return:
hours * rate + is_overtime * overtime_time * overtime_rate

where

is_overtime = ceiling ( x / (x+1))  # this will be zero when x == 0, in rest 1 
x = integer_division(hours, 8)   # x == 0 if no overtime, in rest a positive integer
overtime_time = hours - 8
overtime_rate = (1.5 - 1) * rate = 0.5 * rate

Answer 10

(((hours/8)-1)*8 + hours%8)*salary*0.5 + (hours*salary)
                   overtime*salary*0.5 + (hours*salary)

(((   11/8 -1)*8 +    11%8)*     4*0.5 + (   11*     4) = 50
((      1  -1)*8 +       3)*         2 +             44 = 50
((          0)*8 +       3)*         2 +             44 = 50
((             0 +       3)*         2 +             44 = 50
                                     6 +             44 = 50

So suppose we have (17 hours, 4 salary)

(((17/8)-1)*8 + 17%8)*4*0.5 + 17*4 = 86
(    (2 -1)*8 +    1)*4*0.5 +   68 = 86
           (8 +    1)*2     +   68 = 86
                    9*2     +   68 = 86
                     18     +   68 = 86

17-8=9 is overtime

9*4*1.5 + 8*4 = 9*6 + 32 = 54 + 32 = 86

Answer 11

You could creatively use a while statement as an if statement

while(hours > 8){
  return ((hours - 8) * salary * 1.5) + (8 * salary);
}
return hours * salary;

Answer 12

Plenty of good and more efficient answers already, but here's another simple option using a while loop and the ternary operator:

double pay = 0.0;

while(hours > 0){
    pay += hours > 8 ? wage * 1.5 : wage;
    hours--;
}       
return pay;

Answer 13

Using tanh to decide whether the hours are below 8 or not:

public static double pay (double salary, int hours) {
    int decider = (int)(tanh(hours - 8) / 2 + 1);

    double overtimeCompensation = 1.5;
    double result = salary * (hours * (1 - decider) + (8 + (hours - 8) * overtimeCompensation) * decider);
    return result;
}

The decider variable is 0 when hours is less than 8, otherwise 1. The equation basically contains two parts: the first hours * (1 - decider) would be for hours < 8, and (8 + (hours - 8) * overtimeCompensation) * decider for when hours >= 8. If hours < 8, then 1 - decider is 1 and decider is 0, so using the equations first part. And if hours >= 8, 1 - decider is 0 and decider is 1, so the opposite happens, the first part of the equation is 0 and the second is multiplied by 1.

Answer 14

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

    int extra_hours = hours - 8;
    extra_hours = extra_hours > 0 ? extra_hours : 0;


    double extra_salary = (salary * 1.5) * extra_hours;
    double normal_salary = extra_hours > 0 ? salary * 8 : salary * hours;

    return normal_salary + extra_salary;
}

Answer 15

You can use ternary operator.

public static double pay(double salary, int hours){ //get the salary and hours return hours>8?(1.5*hours-4)*salary:hours*salary; }

Answer 16

Some programming languages have explicit pattern-matching features. So for example, in XSLT, a given template will fire if the node being processed matches a given XPATH query better than other templates in your programme.

This kind of "declarative" programming is a level of abstraction higher than what you have in Java, but you still have the switch statement, which gives you the ability to control your flow with a "matching" approach rather than using explicit if-else constructs.

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

 double pay = 0;

 for (int i = hours; i > 0;i--){ 
     switch (i){
         case 1:
         case 2:
         case 3: 
         case 4: 
         case 5:
         case 6:
         case 7:            
            pay += (salary);
            break;
         default:
            pay += (salary * 1.5);
            break;
     }
 }
 return pay;
}

Having said that, for your specific example, what you really do need is an if statement. The switch approach will work, but it's a bit contrived.

Answer 17

In Tsql

DECLARE @amount float = 4.00 , @hrs int = 11

DECLARE @overtime int , @overeight bit

SET @overeight = ((@hrs/8) ^ 1)

SET @overtime = CEILING((@hrs%8) / ((@hrs%8) + 1.0)) * ~@overeight

--SELECT @hrs * @amount

SELECT ((@hrs-(@hrs%8 * ~@overeight)) * @amount) + ( @overtime * (@hrs%8 * (@amount * 1.5)))

(from Valentin above)