Испытание:Вечный вопрос

Курсы Функции
118

мой способ)

Сводка 
let getProfitableDeposit = function (deposit, term, simpleInterest, capInterest) {
  simpleInterest /= 100;
  capInterest /= 100;
  
  
  let MonthAmount = deposit;
  for (let i = 1; i <= term; i++) {
  MonthAmount += (capInterest / 12) * MonthAmount;
  }
  let cap = Math.floor(MonthAmount);
 
  earnedInterest = (simpleInterest / 12) * term * deposit;
  let simple = Math.floor(deposit + earnedInterest);

if (cap > simple) {
  return ('Выбирай капитализацию. Получишь ' + cap);
} else {
  return ('Выбирай обычный вклад. Получишь ' + simple)
  }
}
119
Решение

let calculateDeposit = function (startDepo, percent, period, isCapitalization) {
let depo = startDepo
if (isCapitalization) {
for (let i = 1; i <= period ; i++) {
depo += depo * percent / 100 / 12
}
} else {
depo += startDepo * percent / 100 / 12 * period
}

return Math.floor(depo)
};

let getProfitableDeposit = function (startDepo, period, easyPercent, hardPercent) {
let normalDepoProfit = calculateDeposit(startDepo, easyPercent, period, false)
let capitalizationDepoProfit = calculateDeposit(startDepo, hardPercent, period, true)

if (normalDepoProfit > capitalizationDepoProfit) {
return 'Выбирай обычный вклад. Получишь ’ + normalDepoProfit
} else {
return 'Выбирай капитализацию. Получишь ’ + capitalizationDepoProfit
}
}

120

Решение
var getProfitableDeposit = function(deposit, depositTime, betIsNotCapitalization, betIsCapitalization) {

var Capitalization = calculateDeposit(deposit, betIsCapitalization,depositTime,true);

var NotCapitalization = calculateDeposit(deposit,betIsNotCapitalization,depositTime,false);

if(Capitalization > NotCapitalization){
return 'Выбирай капитализацию. Получишь ’ + Capitalization;
}
else {
return 'Выбирай обычный вклад. Получишь ’ + NotCapitalization;
}
}

let calculateDeposit = function (startSum, percent,time, capitalization) {
percent /= 100;
if(capitalization) {
for(var i = 1; i <= time; i++) {
startSum += startSum * (percent/12);
}
}
else {
startSum += startSum * (percent/12*time);
}
return Math.floor(startSum);
}

121

Рабочий код, можно изменить переменные по вкусу и употребить )))

let calculateDeposit = function (deposit, percent, months, capitalization) {
  
  let summa;
  
  if(capitalization){
    let capDeposit = 0;
    
    for(let i = 1; i <= months; i++){
      capDeposit += (deposit + capDeposit) / 100 * percent / 12; 
    }
    summa = deposit + capDeposit; 
  }else{
    summa = (deposit / 100 * percent / 12 * months) + deposit;
  }
  return Math.floor(summa);
};

let getProfitableDeposit = function(deposit, months, procent, procentCapital){
  
  let result;
  
  let normalDeposit = calculateDeposit(deposit, procent, months, false); 
  
  let capitDeposit = calculateDeposit(deposit, procentCapital, months, true); 
  
  if(normalDeposit > capitDeposit){
    result = 'Выбирай обычный вклад. Получишь ' + normalDeposit;
  }else{
    result = 'Выбирай капитализацию. Получишь ' + capitDeposit;
  }
  return result;
}
1 лайк
122

Да, на самом деле всё просто, если сделал предыдущее задание)

Мой код 
function calculateDeposit (deposit, percentYears, contributionPeriod, capitalization) {
    percentYears /= 100;
    percentYears /= 12;
    let depositArr = [];
    let result;
  if (capitalization === false) {
    percentYears *= contributionPeriod;
    result = deposit + deposit * percentYears;
    return Math.floor(result);
  } else {
      for (let i = 0; i <= contributionPeriod; i++) {
        depositArr[0] = deposit;
        depositArr[i] = depositArr[i-1] + depositArr[i-1] * percentYears;
      }
      result = depositArr[depositArr.length - 1];
      return Math.floor(result);
    }
};

function getProfitableDeposit(deposit, contributionPeriod, percentBetSimple, percentBetCapitalization) {

  let simple = calculateDeposit (deposit, percentBetSimple, contributionPeriod, false);
  let capitalize = calculateDeposit (deposit, percentBetCapitalization, contributionPeriod, true);
  
  if (simple > capitalize) {
    return 'Выбирай обычный вклад. Получишь ' + simple;
  } else {
      return 'Выбирай капитализацию. Получишь ' + capitalize;
    }

}
123

Перестаём писать return где попало:

function getProfitableDeposit(initial, term, percentSimple, percentCap) {
  let resultSimple = calculateDeposit(initial, percentSimple, term, false);
  let resultCap = calculateDeposit(initial, percentCap, term, true);
  let offer = '';
  
  if (resultSimple > resultCap) offer = `Выбирай обычный вклад. Получишь ${resultSimple}`;
  else offer = `Выбирай капитализацию. Получишь ${resultCap}`;
  
  return offer;
}

Вспомогательная:

Спойлер 
let calculateDeposit = function (initial, percent, term, isCap) {
  let result = initial;
  percent = percent / 100;
  const monthPercent = percent / 12;
  
  if (isCap) {
    
    while (term) {
      result += result * monthPercent;
      term--;
    }
    
  } else {
    result += initial * (monthPercent * term);
  }
  
  return Math.floor(result);
};
124 
const calculateDeposit = function (initialDepositAmount, percentPerAnnum, timeOfDeposit, isWithCapitalization) {
  let totalSum = initialDepositAmount;
  const percentForMonth = percentPerAnnum * 0.01 / 12 * timeOfDeposit * totalSum;
  
  if (!isWithCapitalization) {
    totalSum += percentForMonth; 
  }
  
  if (isWithCapitalization) {
    for (let i = 0; i < timeOfDeposit; i++) {
      totalSum = totalSum + (percentPerAnnum * 0.01 / 12) * totalSum; 
    }  
  }
  
  return Math.floor(totalSum);
};

const getProfitableDeposit = (
    initialDeposit, 
    timeOfDeposit, 
    simpleRate, 
    rateWithCapitalization
  ) => {
  
  if (simpleRate) {
    const incomeWithSimpleRate = calculateDeposit(initialDeposit, simpleRate, timeOfDeposit, false);
    const incomeWithCapitalization = calculateDeposit(initialDeposit, rateWithCapitalization, timeOfDeposit, true);
    if (incomeWithSimpleRate > incomeWithCapitalization) {
      return 'Выбирай обычный вклад. Получишь ' + incomeWithSimpleRate;
    } else {
      return 'Выбирай капитализацию. Получишь ' + incomeWithCapitalization;
    }
  }
  
  if (rateWithCapitalization) {
    let incomeWithSimpleRate = calculateDeposit(initialDeposit, simpleRate, timeOfDeposit, fasle);
    let incomeWithCapitalization = calculateDeposit(initialDeposit, rateWithCapitalization, timeOfDeposit, true);
    if (incomeWithSimpleRate > incomeWithCapitalization) {
      return 'Выбирай обычный вклад. Получишь ' + incomeWithSimpleRate;
    } else {
      return 'Выбирай капитализацию. Получишь ' + incomeWithCapitalization;
    }
  }    
}

*/