Answer:
she loaned 750 dollars.
it took her 9 months to repay it.
it was 275 days since she took out the loan.
the interest rate was 47% per year compounded daily.
the daily interest rate would be 47% / 365 / 100 = .0012876712 per day.
this assumes 365 days in a year, which is the standard assumption that i know of.
the future value of 750 for 275 days would be based on the formula of f = p * (1 + r) ^ n
f is the future value
p is the present value
r is the interest rate per time period (days in this case)
n is the number of time periods (days in this case).
the formula becomes:
f = 750 * (1 + .0012876712) ^ 275
solve for f to get:
f = 1068.440089.
that's the future value of the loan.
it's what she owes.
the interest rate on the loan is that value minus 750 = 318.440089.
that's how much extra she needs to pay in addition to whatever fees she was charged.
Ice cream sandwich definitely
is there an answer selection?
Answer:
The power function can be written as a recursive function (using Java) as follows:
- static int power(int x, int n)
- {
- if(n == 0){
- return 1;
- }
- else {
- return power(x, n-1 ) * x;
- }
- }
Explanation:
A recursive function is a function that call itself during run time.
Based on the question, we know x to the 0th power is 1. Hence, we can just create a condition if n = 0, return 1 (Line 3 - 5).
Next, we implement the logic "x to the nth power can be obtained by multiplying x to the n-1'th power with x " from the question with the code: return power(x, n-1 ) * x in the else block. (Line 6 -8)
In Line 7, power() function will call itself recursively by passing x and n-1 as arguments. Please note the value of n will be reduced by one for every round of recursive call. This recursive call will stop when n = 0.
Just imagine if we call the function as follows:
int result = power(2, 3);
What happen will be as follows:
- run Line 7 -> return power(2, 2) * 2
- run Line 7 -> return power(2, 1) * 2
- run Line 7 -> return power(1, 0) * 2
- run Line 4 -> return 1 (Recursive call stop here)
Next, the return value from the inner most recursive call will be return to the previous call stack:
- power(1, 0) * 2 -> 1 * 2
- power(2, 1) * 2 -> 1 * 2 * 2
- power(2, 2) * 2 -> 1 * 2 * 2 * 2 - > 8 (final output)