function solveEquation(equation) {

  let numbers = equation.match(/\d+/g);

  if (equation[0] == '-') {
    numbers[0] *= -1;
  }

  const quadrat = 'x^2';
  if (equation[equation.indexOf(quadrat) + 4] == '-') {
    numbers[2] *= -1;
  }

  const arg = '* x ';
  if (equation[equation.indexOf(arg) + 4] == '-') {
    numbers[3] *= -1;
  }

  let a = numbers[0];
  let b = numbers[2];
  let c = numbers[3];
  let diskriminant = (b*b) - (4*a*c);

  var answers = [];

  if (diskriminant == 0) {
    let xOne = Math.round(-b/2/a);
    answers.push(xOne);
  }
  else if (diskriminant > 0) {
    let xOne = Math.round((-b + Math.sqrt(diskriminant)) / 2 / a);
    let xTwo = Math.round((-b - Math.sqrt(diskriminant)) / 2 / a);
    answers.push(xOne);
    answers.push(xTwo);
    console.log(answers[0]);
    console.log(answers[1]);
    if (xOne > xTwo) {
      let q = answers[0];
      answers[0] = answers[1];
      answers[1] = q;
    }
  }

  return answers;

}

function solveEquation(equation) {
  // your implementation
  let D, x1, x2;
  let arr = equation.split(' ');
  let a = arr[0];
  let b = arr[3] + arr[4];
  let c = arr[7] + arr[8];
  let result = [];

  D = b * b - 4 * a * c;

  if (D > 0) {
    x1 = Math.round((-b + Math.sqrt(D)) / (2 * a));
    x2 = Math.round((-b - Math.sqrt(D)) / (2 * a));
  }
  if (D == 0) {
    x1 = Math.round(-b / (2 * a));
  }
  if (D < 0) {
    return "no roots";
  }
  
  if (x1 > x2) {
    result.push(x2, x1);
  } else {
    result.push(x1, x2);
  }

  return result;
}

function solveEquation(equation) {
  var arr = equation.split(' ');
  var a = arr[0];

  if (arr[3] == '-')
  {
    var b = (arr[3] + arr[4])
  }
  else
  {
    b = arr[4]
  }

  if (arr[7] == '-')
  {
    var c = (arr[7] + arr[8])
  }
  else
  {
    c = arr[8]
  }

  var d = Math.pow(b, 2) - 4 * a * c;
  var x1 = Math.round((-b + Math.sqrt(d)) / (2 * a));
  var x2 = Math.round((-b - Math.sqrt(d)) / (2 * a));

  var res = [];
  res.push(x1);
  res.push(x2);

  if (x1 > x2)
    res.reverse();
  return res;
}

function solveEquation(equation) {
  var coefficientArray = equation.split(" ");
  
  var a = parseInt(coefficientArray[0]);
  var b = parseInt(coefficientArray[4]) * (coefficientArray[3] == '+' ? 1 : -1) / a;
  var c = parseInt(coefficientArray[8]) * (coefficientArray[7] == '+' ? 1 : -1) / a;

  var discriminantSqrt = Math.sqrt(b*b - 4*c);

  x1 = ((b*(-1) + discriminantSqrt) / 2);
  x2 = ((b*(-1) - discriminantSqrt) / 2);

  if(x1 < x2) {
    return [x1, x2];
  } else {
    return [x2, x1];
  }
}

function makeExchange(currency) {
    if(currency > 10000) {
        return {error: "You are rich, my friend! We don't have so much coins for exchange"};
    }
    if(currency <= 0) {
        return {};
    }

    /*
    Coins used will be half-dollars, quarters, dimes, nickels, and pennies, worth 50¢, 25¢, 10¢, 5¢ and 1¢, respectively.
    They'll be represented by the strings H, Q, D, N and P.
    The argument passed in will be an integer representing the value in cents.
    The return value should be an object with the symbols as keys, and the numbers of coins as values.
    Coins that are not used should not be included in the object.
    makeExchange(1)  --> {"P":1}
    makeExchange(43) --> {"Q":1,"D":1,"N":1,"P":3}
    makeExchange(91) --> {"H":1,"Q":1,"D":1,"N":1,"P":1}
    */

    var currenyAfterHalfDollars = currency % 50;
    var halfDollars = (currency - currenyAfterHalfDollars) / 50;
    var currecyAfterQuarters = currenyAfterHalfDollars % 25;
    var quarters = (currenyAfterHalfDollars - currecyAfterQuarters) / 25;
    var currencyAfterDimes = currecyAfterQuarters % 10;
    var dimes = (currecyAfterQuarters - currencyAfterDimes) / 10;
    var currencyAfterNickels = currencyAfterDimes % 5;
    var nickels = (currencyAfterDimes - currencyAfterNickels) / 5;
    var pennies = currencyAfterNickels;

    var resultArray = {};
    if(halfDollars != 0) {
        resultArray.H = halfDollars;
    }
    if(quarters != 0) {
        resultArray.Q = quarters;
    }
    if(dimes != 0) {
        resultArray.D = dimes;
    }
    if(nickels != 0) {
        resultArray.N = nickels;
    }
    if(pennies != 0) {
        resultArray.P = pennies;
    }

    return resultArray;
}

function makeExchange(currency) {
    if (currency <= 0) return {};
    if (currency >= 10000)
      return {error: "You are rich, my friend! We don't have so much coins for exchange"};

    var obj = {};
    if (currency >= 50)
    {
      obj.H = Math.floor(currency / 50);
      currency = currency % 50;
    }

    if (currency >= 25)
    {
      obj.Q = Math.floor(currency / 25);
      currency = currency % 25;
    }

    if (currency >= 10)
    {
      obj.D = Math.floor(currency / 10);
      currency = currency % 10;
    }

    if (currency >= 5)
    {
      obj.N = Math.floor(currency / 5);
      currency = currency % 5;
    }

    if (currency >= 1)
    {
      obj.P = Math.floor(currency / 1);
      currency = currency % 1;
    }

    return obj;
  }

function makeExchange(currency) {

  let highLimit = 10000;
  let lowLimit = 0;

  if (currency <= lowLimit)
    return {};
  else if (currency > highLimit)
    return {error: "You are rich, my friend! We don't have so much coins for exchange"};


  let nominalsOfCoins = {
    H: 50,
    Q: 25,
    D: 10,
    N: 5,
    P: 1
  };
  let coins = {
    H: 0,
    Q: 0,
    D: 0,
    N: 0,
    P: 0
  };

  let sumOfCoins = 0;
  for (var nominal in nominalsOfCoins) {
    if (currency >= nominalsOfCoins[nominal]) {
      sumOfCoins = currency - currency % nominalsOfCoins[nominal];
      coins[nominal] += sumOfCoins / nominalsOfCoins[nominal];
      currency -= sumOfCoins;
    }
    else delete coins[nominal];
  }

  return coins;

}

function check(str, bracketsConfig) {

  let stack = [];

  let pair;

  let isOpened;

  for (let strIndex = 0; strIndex < str.length; strIndex++) {

    isOpened = false;
    pair = false;

    for (let confIndex = 0; confIndex < bracketsConfig.length; confIndex++) {
      if (str[strIndex] === bracketsConfig[confIndex][0]) {

        if (str[strIndex] === bracketsConfig[confIndex][1] && str[strIndex] === stack[stack.length-1]) {
          pair = true;
          break;
        }
        else {
          stack.push(str[strIndex]);
          isOpened = true;
          break;
        }
      }
    }

    if ( !isOpened ) {

      let lastOpened = stack.pop();
      for (let k = 0; k < bracketsConfig.length; k++) {
        if (lastOpened === bracketsConfig[k][0] && str[strIndex] === bracketsConfig[k][1])
          pair = true;
      }
      if ( !pair )
        return pair;
    }
  }

  return pair;

}

function check(str, bracketsConfig) {
  var bracketStack = [];
  var currentChar;
  
  for(let i = 0; i < str.length; i++) {
    currentChar = str.charAt(i);
    for(let j = 0; j < bracketsConfig.length; j++) {

      if(currentChar == bracketsConfig[j][0] && bracketsConfig[j][0] == bracketsConfig[j][1]) {
        if(currentChar == bracketStack[bracketStack.length -1]) {
          bracketStack.pop();
        } else {
          bracketStack.push(currentChar);
        }
      } else {
        if(currentChar == bracketsConfig[j][0]) {
          bracketStack.push(currentChar);
        } else if(currentChar == bracketsConfig[j][1]) {
          if(bracketStack.pop() != bracketsConfig[j][0]) {
            return false;
          }
        }
      }
    }
  }
  if(bracketStack.length != 0) {
    return false;
  }
  return true;
}

function check(str, bracketsConfig) {
  str = str.split('');
  var strLength = str.length;

  while (strLength > 1) {
    for (var i = 0; i < str.length; i++) {
      for (var j = 0; j < bracketsConfig.length; j++) {
          if ((str[i] == bracketsConfig[j][0]) &&
              (str[i+1] == bracketsConfig[j][1])) {
            str.splice(i,2);
          }
      }
    }

    strLength -= 2;

    if (str.length == 0)
      return true;
  }
  return false;
}

function getZerosCount(number) {
  /*var zeroes = 0;
  var poweredFive = 5; 
  var i = 1;
  
  while(number/poweredFive > 1) {
    zeroes += (number - number % poweredFive) / poweredFive;
    poweredFive = Math.pow(5, ++i);
  }
  return zeroes;*/

  var zeroes = 0;
  var base = 10;
  var primerArray = [];
  var primer = 2;
  var restBase = base;
  var isPrimer = true;
  while(primer <= base) {
    primerArray.forEach(element => {
        if((primer % element) == 0) {
          isPrimer = false;
        }
    });
    if(isPrimer && (restBase%primer == 0)) {
      primerArray.push(primer);
    }
    isPrimer = true;
    primer++;    
  }
  primer = primerArray.pop();
  
  while(number/primer > 1) {
    zeroes += (number - number % primer) / primer;
    number /= primer;
  }
  
  return zeroes;
}

function getZerosCount(number) {
  var res = 0;
  var nRes = 0;
  var i = 5;
  while (i < number)
  {
      nRes = Math.floor(number / i);
      res += nRes;
      i *= 5;
  }
  return res;
}

function getZerosCount(number) {
  // your implementation
  let count = 0;

  while (number > 0) {
    number = Math.floor(number / 5);
    count += number;
  }

  return count;
}