function getPeriodStart(quotients, remainders, quotient, remainder) {
    let index = -1;
    for (let i = 0; i < quotients.length; i++) {
        if (quotients[i] !== quotient) continue;
        if (remainders[i] !== remainder) continue;
        index = i;
        break;
    }
    return index;
}

function rational(a, b) {
    let periodStart = -1;
    let quotients = [];
    let remainders = [];
    while (a !== 0 && periodStart === -1) {
        let quotient = Math.trunc(a / b);
        if (quotient >= 1) a -= quotient * b; // 'a' acts as a remainder now
        periodStart = getPeriodStart(quotients, remainders, quotient, a);
        remainders.push(a);
        quotients.push(quotient);
        a *= 10;
    }
    if (periodStart !== -1) {
        let max = Math.max(1, periodStart);
        return `${quotients[0]}.${quotients.slice(1, max).join('')}(${quotients.slice(max, quotients.length - 1).join('')})`;
    }
    return `${quotients[0]}.${quotients.slice(1).join('')}`;
}

 function rational(a, b) {
    let div_res = a / b;
    let subs = div_res.toString().split('.')[1];
    for (let j = 0; j < subs.length - 1; j++) {
        for (let i = j + 1; i < subs.length; i++) {
            if (subs.slice(j, i) == subs.slice(i, i + i - j)) {
                return (String(div_res | 0) + "." + subs.slice(0, j) + "(" + subs.slice(j, i) + ")");
            }
        }
    }
    return String(div_res);
}

function findRepeating(st) {
    if(st.length == 1)
        return st;
    let s = "";
    for(x of st) {
        if(st.replace(s+x, "").includes(s+x)) {
            s += x;
        }
    }
    return s;
}

function rational(a, b) {
    let r = (a / b).toString();
    let rp = d = r.split(".")[1];
    while(rp.length > 1 && findRepeating(rp) != rp && findRepeating(rp) != "") {
        rp = findRepeating(rp);
    }
    if(rp && rp != d) {
        d = d.slice(0, d.indexOf(rp));
        d += `(${rp})`
        r = r.split(".")[0]+"."+d;
    }
    return r;
}

 function rational(a, b) {
    let res = "";

    let mp = new Map();
    mp.clear();

    let rem = a % b;

    while (rem != 0 && !mp.has(rem)) {
        mp.set(rem, res.length);
        rem *= 10;

        let res_part = Math.floor(rem / b);
        res += res_part.toString();

        rem = rem % b;
    }

    if (rem == 0) return (a / b).toString();
    else return "0." + res.slice(0, res.indexOf(res.substr(mp.get(rem)))) + "(" + res.substr(mp.get(rem)) + ")";
}

 function rational(a, b){
    let str = String (a/b);
    let res = [];
    let p = "";
    for (let i = 2; i        if (res.includes(str[i])){
            p = res.slice(res.indexOf(str[i])).join('');
            if (str.includes(p, i)) break;
        }
        res.push(String (str[i]));
    }
    if (p == "") return String (a/b);
    else return ("0."+res.slice(0, res.length - p.length).join('')+'('+p+')');
}

 function rational(a, b) {
    let res = Math.floor(a/b) + '.';
    a %= b;
    const dig = [];
    const A = {};
    let zero = false;
    for (let i=0; !(a in A); i++) {
        if (a == 0) zero = true;
        A[a] = i;
        a *= 10;
        dig.push(Math.floor(a/b));
        a %= b;
    }   
    res += dig.slice(0, A[a]).join('');
    if (!zero) res += '(' + dig.slice(A[a]).join('') + ')';
    return res;
}

 function rational(a, b){
    let rem = (a/b).toString().split('.')[1];

    for (let i = 0; i < rem.length - 1; i++){
        for(let j = i + 1; j < rem.length; j++){
            if (rem.slice(i, j) == rem.slice(j, j + j - i)){
                let right = (a/b).toString().split('.')[0] + '.';
                let left = rem.slice(0, i) + "(" + rem.slice(i, j) + ")";

                return  right + left;
            }
        }
    }
    
    return (a/b).toString();
}

 function rational(a, b) {
    let rationalNumber = a / b, period;

    rationalNumber = rationalNumber.toString();
    let arrayOfNumbers = rationalNumber.slice(rationalNumber.indexOf(".") + 1, rationalNumber.length - 1)

    for(let i = 0; i < arrayOfNumbers.length; i++){
        if(arrayOfNumbers.indexOf(arrayOfNumbers[i], i + 1) != -1){
            period = arrayOfNumbers.slice(i, arrayOfNumbers.indexOf(arrayOfNumbers[i], i + 1))
            
            if(period == arrayOfNumbers.slice(arrayOfNumbers.indexOf(arrayOfNumbers[i], i + 1), arrayOfNumbers.indexOf(arrayOfNumbers[i], i + 1) + period.length)){
                rationalNumber = rationalNumber.slice(0, rationalNumber.indexOf(".") + 1) + arrayOfNumbers.slice(0, i) + '(' + period + ')';
                break;
            }
        }
    }

    return rationalNumber;
}

 function getPeriodStart(quotients, remainders, quotient, remainder) {
    let index = -1;
    for (let i = 0; i < quotients.length; i++) {
        if (quotients[i] !== quotient) continue;
        if (remainders[i] !== remainder) continue;
        index = i;
        break;
    }
    return index;
}

function rational(a, b) {
    let periodStart = -1;
    let quotients = [];
    let remainders = [];
    while (a !== 0 && periodStart === -1) {
        let quotient = Math.trunc(a / b);
        if (quotient >= 1) a -= quotient * b; // 'a' acts as a remainder now
        periodStart = getPeriodStart(quotients, remainders, quotient, a);
        remainders.push(a);
        quotients.push(quotient);
        a *= 10;
    }
    if (periodStart !== -1) {
        let max = Math.max(1, periodStart);
        return `${quotients[0]}.${quotients.slice(1, max).join('')}(${quotients.slice(max, quotients.length - 1).join('')})`;
    }
    return `${quotients[0]}.${quotients.slice(1).join('')}`;
}

 function rational(a, b) {
    let number = '' + (a / b);
    let right = number.slice(2);

    for (let i = 0; i < right.length - 1; i++) {
        for (let j = i + 1; j < ((right.length / 2) | 0); j++) {
            if (right.slice(i, j) == right.slice(j, j + j - i)) {
                return `${'' + (number | 0)}.${right.slice(0, i)}(${right.slice(i, j)})`;
            }
        }
    }
    return number;
}

 function rational(a, b) {
  let result = '0.';
  let k = 0;
  let len = 9;
  while (a !== 0 && k < len) {
    for (let p = 1; p <= 6; ++p) {
      let num = a * Math.pow(10, p);
      let ostatoc = Math.trunc(num / b).toString().padStart(p, '0')
      if (a === num % b) {
        return `${result}(${ostatoc})`;
      }
    }
    k++;
    a *= 10;
    result += Math.trunc(a / b);
    a = a % b;
  }
  return result;
}

 function getPeriodStart(quotients, remainders, quotient, remainder) {
    let index = -1;
    for (let i = 0; i < quotients.length; i++) {
        if (quotients[i] !== quotient) continue;
        if (remainders[i] !== remainder) continue;
        index = i;
        break;
    }
    return index;
}

function rational(a, b) {
    let periodStart = -1;
    let quotients = [];
    let remainders = [];
    while (a !== 0 && periodStart === -1) {
        let quotient = Math.trunc(a / b);
        if (quotient >= 1) a -= quotient * b; // 'a' acts as a remainder now
        periodStart = getPeriodStart(quotients, remainders, quotient, a);
        remainders.push(a);
        quotients.push(quotient);
        a *= 10;
    }
    if (periodStart !== -1) {
        let max = Math.max(1, periodStart);
        return `${quotients[0]}.${quotients.slice(1, max).join('')}(${quotients.slice(max, quotients.length - 1).join('')})`;
    }
    return `${quotients[0]}.${quotients.slice(1).join('')}`;
}

 function rational(a, b) { 
    let result = '0.'; 
    
    let k = 0; 
    const len = 10;
    while (a !== 0 && k < len) {
      for (let i = 1; i < 10; i++) { 
        const num = a * Math.pow(10, i); 
        const rest = Math.trunc(num / b).toString().padStart(i, '0') 
         
        if (a === num % b) { 
          return result + '(' + rest + ')'; 
        } 
      } 
    
      k++;
      a *= 10; 
      result += Math.trunc(a / b); 
      a = a % b; 
    } 
    return result; 
}

 function rational (a, b) {
    let result = '0.';
    let c = 0;
    let length = 9; 
    while (a !== 0 && c < length) {
        for (let i = 1; i <= 6; i++) {
            let num = a * Math.pow(10, i);
            let ostatoc = Math.trunc(num / b).toString().padStart(i,'0')
            if (a === num % b) {
                return `${result}(${ostatoc})`;
            }
        }
        c++;
        a *= 10;
        result += Math.trunc(a / b);
        a = a % b;
    }
    return result;
}

 function rational(a, b) 
{
  let result = "";
  if (a < b) 
  {
    result = "0.";
  } 
  else 
  {
    result += Math.trunc(a / b);
    a = a % b;
    if (a > 0) 
    {
        result += ".";
    }
  }
 
  let k = 0;
  const len = 14; 
  while (a !== 0 && k < len) 
  {
    for (let p = 1; p < 7; ++p) 
    {
      const num = a * Math.pow(10, p);
      const ostatoc = Math.trunc(num / b).toString().padStart(p, '0')
      if (a === num % b) 
      {
        return `${result}(${ostatoc})`;
      }
    }
 
    k++;
    a *= 10;
    result += Math.trunc(a / b);
    a = a % b;
  }
  return result;
}

 function getPeriodStart(quotients, remainders, quotient, remainder) {
    let index = -1;
    for (let i = 0; i < quotients.length; i++) {
        if (quotients[i] !== quotient) continue;
        if (remainders[i] !== remainder) continue;
        index = i;
        break;
    }
    return index;
}

function rational(a, b) {
    let periodStart = -1;
    let quotients = [];
    let remainders = [];
    while (a !== 0 && periodStart === -1) {
        let quotient = Math.trunc(a / b);
        if (quotient >= 1) a -= quotient * b; // 'a' acts as a remainder now
        periodStart = getPeriodStart(quotients, remainders, quotient, a);
        remainders.push(a);
        quotients.push(quotient);
        a *= 10;
    }
    if (periodStart !== -1) {
        let max = Math.max(1, periodStart);
        return `${quotients[0]}.${quotients.slice(1, max).join('')}(${quotients.slice(max, quotients.length - 1).join('')})`;
    }
    return `${quotients[0]}.${quotients.slice(1).join('')}`;
}

 function rational(a, b)
{
    let num = a/b, period
    num = num.toString()
    let arr = num.slice(num.indexOf('.') + 1, num.length-1)
    for(let i=0; i< arr.length; i++)
    {
        if(arr.indexOf(arr[i], i + 1) !=-1)
        {
            period = arr.slice(i, arr.indexOf(arr[i], i+1))
                if(period == arr.slice(arr.indexOf(arr[i], i+1), arr.indexOf(arr[i], i+1) + period.length))
            {
                num = num.slice(0, num.indexOf('.') + 1) + arr.slice(0, i) + '('+period+')'
                break
            }
        }
    }    
    return num
}

 function rational2(c, d, e, j) {
    let index = -1;
    for (let i = 0; i < c.length; i++) {
        if (c[i] !== e) {
        continue;
        }
        if (d[i] !== j) { 
        continue;
        }
        index = i;
        break;
    }
    return index;
}

function rational(a, b) {
    let flag = -1;
    let c = [];
    let d = [];
    while (a !== 0 && flag === -1) {
        let e = Math.trunc(a / b);
        if (e >= 1) a -= e * b; // 'a' acts as a j now
        flag = rational2(c, d, e, a);
        d.push(a);
        c.push(e);
        a *= 10;
    }
    if (flag !== -1) {
        let max = Math.max(1, flag);
        return `${c[0]}.${c.slice(1, max).join('')}(${c.slice(max, c.length - 1).join('')})`;
    }
    return `${c[0]}.${c.slice(1).join('')}`;
}

 function rational(a, b) {
    let result = '';
    if (a < b) {
        result = '0.';
    } else {
        result += Math.trunc(a / b);
        a = a % b;
        if (a > 0) result += '.';
    }

    let c = 0;
    const len = 20;
    while (a !== 0 && c < len) {
        for (let p = 1; p < 10; ++p) {
            const num = a * Math.pow(10, p);
            const residue = Math.trunc(num / b).toString().padStart(p, '0')
            if (a === num % b) {
                return `${result}(${residue})`;
            }
        }

        c++;
        a *= 10;
        result += Math.trunc(a / b);
        a = a % b;
    }
    return result;
}

 function rational(a, b){
    let str = ''
    let arr = []
    while (a){
        a *= 10
        if (arr.includes(a)){
            str = str.split('')
            str.splice(arr.indexOf(a), 0, '(')
            str = str.join('') + ')'
            break
        }
        arr.push(a)
        str = str + Math.floor(a/b)
        a -= b * Math.floor(a/b)
    }
    return '0.' + str
}

 function rational(a, b) {
  let result = '0.';
  let k = 0;
  const len = 9;
  while (a !== 0 && k < len) {
    for (let p = 1; p <= 6; ++p) {
      const num = a * Math.pow(10, p);
      const ostatoc = Math.trunc(num / b).toString().padStart(p, '0')
      if (a === num % b) {
        return `${result}(${ostatoc})`;
      }
    }
    k++;
    a *= 10;
    result += Math.trunc(a / b);
    a = a % b;
  }
  return result;
}

 function rational(a, b)
{
    let q = a/b;
    let arr = [];
    let output = '0.';
    for(;;)
    {
        q*=10;
        if(arr.indexOf(Math.floor(q,1)),arr.indexOf(Math.floor(q,1))!=-1) break;
        arr.push(Math.floor(q,1))
        q = q-Math.floor(q,1);   
    }
    let t = ''
    if(arr[arr.length-1]==arr[arr.length-2]) arr.pop();
    for(let i =0;i< arr.indexOf(Math.floor(q,1));i++)
    {
        output+=arr[i];               
    }
    t +='(';
    for(let i = arr.indexOf(Math.floor(q,1));i< arr.length;i++)
    {
        t+=arr[i];
    }
    t +=')';
    if(t=='(0)') return output;
    return output+t;
}

 function rational(a, b) {
  let result = '0.';
  let k = 0;
  let len = 9;
  while (a !== 0 && k < len) {
    for (let p = 1; p <= 6; ++p) {
      let num = a * Math.pow(10, p);
      let ostatoc = Math.trunc(num / b).toString().padStart(p, '0')
      if (a === num % b) {
        return `${result}(${ostatoc})`;
      }
    }
    k++;
    a *= 10;
    result += Math.trunc(a / b);
    a = a % b;
  }
  return result;
}

 function rational(a, b) {
  let remainder = a % b;
  let quotient = (a - remainder) / b;
  let decimal = quotient + ".";
  let remainders = [remainder];

  while (remainder !== 0) {
    remainder *= 10;
    quotient = (remainder - (remainder % b)) / b;
    remainder = remainder % b;
    decimal += quotient;

    // check for repeating decimals
    if (remainders.includes(remainder)) {
      let repeatStart = remainders.indexOf(remainder);
      let repeat = decimal.slice(repeatStart + 2);
      return decimal.slice(0, repeatStart + 2) + "(" + repeat + ")";
    } else {
      remainders.push(remainder);
    }
  }

  return decimal;
}

 function rational(a, b) {
    let res = "";

    let mp = new Map();
    mp.clear();

    let rem = a % b;

    while (rem != 0 && !mp.has(rem)) {
        mp.set(rem, res.length);
        rem *= 10;

        let res_part = Math.floor(rem / b);
        res += res_part.toString();

        rem = rem % b;
    }

    if (rem == 0) return (a / b).toString();
    else return "0." + res.slice(0, res.indexOf(res.substr(mp.get(rem)))) + "(" + res.substr(mp.get(rem)) + ")";
}

 function rational(a, b) {
    let div = a / b;
    let part = div.toString().split('.')[1];
    for (let j = 0; j < part.length - 1; j++) {
        for (let i = j + 1; i < part.length; i++) {
            if (part.slice(j, i) == part.slice(i, i + i - j)) {
                return (String(div | 0) + "." + part.slice(0, j) + "(" + part.slice(j, i) + ")");
            }
        }
    }
    return String(div);
}

 function rational (a, b) {
    let res = '0.';
    let c = 0;
    let length = 9; 
    while (a !== 0 && c < length) {
        for (let i = 1; i <= 6; i++) {
            let num = a * Math.pow(10, i);
            let ostatoc = Math.trunc(num / b).toString().padStart(i,'0')
            if (a === num % b) {
                return `${res}(${ostatoc})`;
            }
        }
        c++;
        a *= 10;
        res += Math.trunc(a / b);
        a = a % b;
    }
    return res;
}

 function rational(a, b) { 
    let result = '0.'; 
    
    let k = 0; 
    const len = 10;
    while (a !== 0 && k < len) {
      for (let i = 1; i < 10; i++) { 
        const num = a * Math.pow(10, i); 
        const rest = Math.trunc(num / b).toString().padStart(i, '0') 
         
        if (a === num % b) { 
          return result + '(' + rest + ')'; 
        } 
      } 
    
      k++;
      a *= 10; 
      result += Math.trunc(a / b); 
      a = a % b; 
    } 
    return result; 
}

 function rational(numerator, denominator){

    const result = [0, '.'];
    addDecimal(numerator, denominator,  result);
    return result.join('');
};

function addDecimal(numerator, denominator, result) {

    let idx = 0; 
    const carries = {};
    while (numerator !== 0 && !(numerator in carries)) {
        carries[numerator] = idx++;
        numerator *= 10;
        const nextDigit = Math.floor(numerator / denominator);
        result.push(nextDigit.toString());
        numerator %= denominator;
    }
    
    if (numerator in carries) {
        addParens(carries[numerator], result);
    }
}

function addParens(decimalIdx, result) {
    result.splice(2 + decimalIdx, 0, '('); 
    result.push(')');
}