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);
}
}
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));
}
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.
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.
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.
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;
}
}
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).
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));
}
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;
}
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
(((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
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;
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;
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.
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;
}
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;
}
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.
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)
Related
Hi I'm trying to make a method that gives you change in Hundreds, Fifties, Twenties, Tens, Fives, ones as well as quarters dimes and nickels. the user gives input and its supposed to look something like this: 6.87 1 five 1 one 3 quarters 1 dime 2 pennies
So far I have this as my code:
import java.util.Scanner;
/**
*
* #author Cjespinomartine
*/
public class Assignment04 {
public static void main(String[]args) {
Scanner stdin = new Scanner(System.in);
System.out.println("Enter your amount");
double amount = stdin.nextDouble();
double remainder = Math.round(amount * 100);
double hundreds = remainder / 1000;
remainder = remainder / 1000;
double fifties = remainder / 500;
remainder = remainder / 500;
double twenties = remainder / 200;
remainder = remainder % 200;
/*
double fives = remainder / 5;
remainder = remainder % 5;
double ones = remainder / 1;
remainder = remainder % 1;
double quarters = remainder / .25;
remainder = remainder % .25;
double dimes = remainder / .10;
remainder = remainder %10;
double nickels = remainder / .5;
remainder = remainder % .5;
double pennies = remainder;
*/
System.out.println(hundreds + "hundred/s");
System.out.println(fifties + "fiftie/s");
System.out.println(twenties + "twentie/s");
/* System.out.println(fives + "five/s");
System.out.println(ones + "one/s");
System.out.println(quarters + "quarter/s");
System.out.println(dimes + "dime/s");
System.out.println(nickels + "nickel/s");
System.out.println(pennies + "cent/s");
*/
}
}
It doesn't give out change in order it just gives out hundreds. I commented some of the change because I'm trying to get the math right. I think the assignment required if and else if so if it does can you help me out with where I put it. any help will mean a lot i'm very stuck thank you.
There are a few things wrong.
The first issue is your initial handling of remainder – you're multiplying by 100, so if input is 1274.56, you end up with 127456 (ignoring floating point problems which are valid but I'll stay focused on this first point). The output of Math.round() is either an int or long, but definitely not a double so you're adding confusion for yourself by storing it as a double – instead, store the result as long. From there, when you calculate hundreds, you need to divide by 10,000 not 1,000. Also, store that as an int, not a double. Here's what that would look like:
long remainder = Math.round(1274.56 * 100);
int hundreds = (int) remainder / 10000;
System.out.println("hundreds: " + hundreds);
The above prints out "12" for hundreds, which is what you want.
The second issue is how you're calculating remainder. You want everything that's "left over" from the prior calculation which you do by using % (modulus operator), and also use 10,000 instead of 1,000. For the hundreds case, it would be this:
remainder = remainder % 10000;
System.out.println("remainder: " + remainder);
The above code would print this:
remainder: 7456
This should give you enough to get the rest of your math working properly.
remainder = remainder / 1000; is wrong. What you want is the remainder after you've taken out all the hundreds. remainder = remainder % 1000; -looks like the commented out ones are correct...
Also don't use floating point types for money. Google will give you a thousand reasons why.
I'm attempting to rewrite the following if statement as a conditional statement.
if (hours > 40)
wages *= 1.5;
else
wages *= 1;
Here is my attempt that works, but I don't think I used the multiplication compound assignment operator correctly or at all.
int hours = 50, wages = 20;
System.out.println("Wages = " + (hours > 40 ? wages * 1.5: wages * 1));
If what you want to do is multiply the wages variable with either 1.5 or 1 depending on this condition hours > 40 the following should work for you:
int hours = 50, wages = 20;
wages *= hours > 40 ? 1.5 : 1;
System.out.println("Wages = " + wages);
Output
Wages = 30
wages *= hours > 40 ? 1.5 : 1;
Okay so I am new to Java. I have a program that calculates the compound value after asking the user for a savings amount and an annual interest rate. I'm having trouble getting it into a for loop but I feel like I'm somewhat close? The hard part in my mind is understanding how to get the last months total into the new calculation.
Here's my formula for the compound value currently:
firstMonth = savingAmount * (1 + monthlyInterestRate);
secondMonth = (savingAmount + firstMonth) * (1 + monthlyInterestRate);
thirdMonth = (savingAmount + secondMonth) * (1 + monthlyInterestRate);
fourthMonth = (savingAmount + thirdMonth) * (1 + monthlyInterestRate);
fifthMonth = (savingAmount + fourthMonth) * (1 + monthlyInterestRate);
sixthMonth = (savingAmount + fifthMonth) * (1 + monthlyInterestRate);
It is ugly obviously and it should be in a for-loop. Again the savingAmount is user input and the annualInterestRate is user input. The the monthlyInterestRate is annualInterestRate/12.
Here is the for-loop I have so far.
for (int i = 1; i <= 6; i++ );
{
sixthMonth = savingAmount * Math.pow(1+monthlyInterestRate, 6);
}
I am still learning for-loops but doesn't my code say it adds up while it is less than or equal to 6? And while those are true to do the formula I provided. No you don't have to answer the question but if you could lead me in the right direction that'd be great. So how would I start to convert it? Feel free to ask for more info if needed.
Try this:
for (int i = 1; i <= 6; i++) {
monthAmount = (savingAmount + monthAmount) * (1 + monthlyInterestRate);
}
This should get you to the same answer.
You were on the right track, but this will allow you to use the previous months amount in the formula. This code will also work for however long you want the loop to run for.
I would actually recommend using the compound interest formula A = P (1 + r/n) ^ nt.
A - final amount with compound growth
P - principal investment
r - annual interest rate
n - number of times the interest is compounded per time period
t - number of time periods compounded
So you could then reduce all of this to:
amount = savingAmount * Math.pow(1 + monthlyInterestRate/timesCompoundedPerMonth,
timesCompoundedPerMonth * monthsCompounded);
Compound Interest Formula - Explained
I would recommending storing the amounts in a list for easy lookup if you want to see how much savings you will have at each month.
public static void main(String args[]) {
double savingsAmount = 543.23;
double annualInterestRate = 0.85; // %
double monthlyInterestRate = annualInterestRate / 12;
List<Double> savings = new ArrayList<Double>();
savings.add(savingsAmount); // month 0
int monthsInTheFuture = 6;
double compoundInterest = 1 + monthlyInterestRate;
for (int i = 1; i <= monthsInTheFuture; i++) {
double previousSavings = savings.get(i-1);
double nextSavings = previousSavings * compoundInterest;
savings.add(nextSavings);
}
System.out.println(savings);
}
I'm attempting to calculate how much tax a user should pay, based on wage. For example, calculating 20% in the first if loop, this will be saved in generaltax:
int generalTax = 0;
int userGrossPay = 50000;
if (userGrossPay <= 10600) {generalTax += 0;}
else if (((userGrossPay >= 10600) && (userGrossPay <= 31785))) { generalTax = ((20/100) * userGrossPay); }
else if (((userGrossPay >= 31786) && (userGrossPay <= 150000))) { generalTax = ((40/100) * userGrossPay); System.out.println(generalTax);}
else if (userGrossPay > 150001) {generalTax = ((45/100) * userGrossPay); }
else{System.out.println("error");};
userGrossPay -= generalTax;
System.out.println(userGrossPay);
However generalTax pay is for some reason always stuck as 0 and is not properly updating on each iteration.
Your problem is that you are always adding 0 or assigning 0 to generalTax.
For example, (20/100) * userGrossPay is 0, since 20/100 is 0 due to int division. Change it too 0.2 * userGrossPay or 20.0/100 * userGrossPay. Similarly change all other places where you divide two integers.
This is caused by integer division.
If you mix floating data type with integer, it will give you a data conversion by promotion.
For example:
int num = 5;
System.out.println(num / 2); //Gives you 2
System.out.println(num / 2.0); //Gives you 2.5
System.out.println(num * 2); //Gives you 10
System.out.println(num * 2.0); //Gives you 10.0
System.out.println(num + 2.5); //Gives you 7.5
If all operands in the operation are integers, your output will be integer as well. This is how you got into an integer division accidentally.
((20/100) * userGrossPay);
I see that you already accepted Eran's answer and understood what went wrong, I am here to give you some additional information.
I am currently trying to develop a compound interest calculator that includes monthly contributions. I have successfully been able to get the compound interest calculation working without the monthly contributions using the following line of code, but cannot figure out what the formula should be when adding monthly contributions.
double calculatedValue = (principalValue * Math.pow(1 + (interestRateValue/numberOfCompoundsValue), (termValue * numberOfCompoundsValue)));
When trying to get the calculated value with contributions I changed the way this is done. See the following code how I approached this.
//The starting principal
double principalValue = 5000;
//Interest rate (%)
double interestRateValue = 0.05;
//How many times a year to add interest
int numberOfCompoundsValue = 4;
//The number of years used for the calculation
double termValue = 30;
//The monthly contribution amount
double monthlyContributionsValue = 400;
//How often interest is added. E.g. Every 3 months if adding interest 4 times in a year
int interestAddedEveryXMonths = 12/numberOfCompoundsValue;
//The total number of months for the calculation
int totalNumberOfMonths = (int)(12 * termValue);
for(int i = 1; i <= totalNumberOfMonths; i++)
{
principalValue += monthlyContributionsValue;
if(i % interestAddedEveryXMonths == 0)
{
principalValue += (principalValue * interestRateValue);
}
}
I figured this should do what I am after. Every month increase the principal by the contribution amount and if that month equals a month where interest should be added then calculate the interest * the interest rate and add that to the principal.
When using the values above I expect the answer $355,242.18 but get $10511941.97, which looks better in my bank account but not in my calculation.
If anyone can offer me some help or point out where I have gone wrong that would be much appreciated.
Thanks in advance
Your problem is here:
principalValue += (principalValue * interestRateValue);
You're adding a full year's interest every quarter, when you should be adding just a quarter's interest. You need to scale that interest rate down to get the right rate.
Here's an example:
class CashFlow {
private final double initialDeposit;
private final double rate;
private final int years;
private final double monthlyContribution;
private final int interestFrequency;
CashFlow(double initialDeposit, double rate, int years,
double monthlyContribution, int interestFrequency) {
if ( years < 1 ) {
throw new IllegalArgumentException("years must be at least 1");
}
if ( rate <= 0 ) {
throw new IllegalArgumentException("rate must be positive");
}
if ( 12 % interestFrequency != 0 ) {
throw new IllegalArgumentException("frequency must divide 12");
}
this.initialDeposit = initialDeposit;
this.rate = rate;
this.years = years;
this.monthlyContribution = monthlyContribution;
this.interestFrequency = interestFrequency;
}
public double terminalValue() {
final int interestPeriod = 12 / interestFrequency;
final double pRate = Math.pow(1 + rate, 1.0 / interestPeriod) - 1;
double value = initialDeposit;
for ( int i = 0; i < years * 12; ++i ) {
value += monthlyContribution;
if ( i % interestFrequency == interestFrequency - 1 ) {
value *= 1 + pRate;
}
}
return value;
}
}
class CompoundCalc {
public static void main(String[] args) {
CashFlow cf = new CashFlow(5000, 0.05, 30, 400, 3);
System.out.println("Terminal value: " + cf.terminalValue());
}
}
with output:
run:
Terminal value: 350421.2302849443
BUILD SUCCESSFUL (total time: 0 seconds)
which is close to the $355k value you found.
There are a number of different conventions you could use to get the quarterly rate. Dividing the annual rate by 4 is a simple and practical one, but the pow(1 + rate, 1 / 4) - 1 method above is more theoretically sound, since it's mathematically equivalent to the corresponding annual rate.
After some brief testing I've come to the conclusion that either you have:
miscalculated the value you want ($355,242.18)
OR
incorrectly asked your question
The calculation you've described that you want ($5000 start + $400 monthly contributions for 30 years + interest every 3 months) is found by the code you've provided. The value that it gives ($10,511,941.97) is indeed correct from what I can see. The only other suggestions I can offer are to only use double if you need to (for example termValue can be an int) AND when ever you know the value is not going to change (for example interestRateValue) use final. It will help avoid any unforeseen error in larger programs. I hope this helps you figure out your interest calculator or answers any questions you have.
static void Main(string[] args)
{
double monthlyDeposit;
double rateOfInterest;
double numberOfCompounds;
double years;
double futureValue = 0;
double totalAmount = 0;
Console.WriteLine("Compound Interest Calculation based on monthly deposits");
Console.WriteLine("Monthly Deposit");
monthlyDeposit = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Rate Of Interest");
rateOfInterest = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Number of Compounds in a year");
numberOfCompounds = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Number of year");
years = Convert.ToDouble(Console.ReadLine());
futureValue = monthlyDeposit;
for (int i = 1; i <= years * 12; i++)
{
totalAmount = futureValue * (1 + (rateOfInterest / 100) / 12);
if (i == years * 12)
futureValue = totalAmount;
else
futureValue = totalAmount + monthlyDeposit;
}
Console.WriteLine("Future Value is=" + futureValue);
Console.ReadLine();
}
//Output
Compound Interest Calculation based on monthly Deposits
Monthly Deposit
1500
Rate Of Interest
7.5
Number of Compounds in a year
12
Number of year
1
Future Value is=18748.2726237313