(미해결)항해3주차 자바스크립트 프로그래머스 - 분수의 덧셈

 

기약분수?

분모와 분자 사이의 공약수가 1뿐이어서 더 이상 약분되지 않는 분수

분수식을 공통인수로 나누게 되면 기약 분수가 된다.

​기약분수란 더 이상 분자와 분모가 서로소 상태여서 약분할 수 없는 분수를 말해요.

그러니까 아주 쉽게 더이상 나눌 수 없는 상태.

내가 생각한 풀이 순서

1. 분모가 같아야 한다

2. 분자끼리 더한다

3. 분모와 분자를 최대공약수로 나누어 준다.

 

 

다른 이의 풀이

function solution(denum1, num1, denum2, num2) {
    var N =num1*num2;
    var D = (denum1*num2)+(denum2*num1)

    var arrN=[];
    var arrD=[];

    for(let i=1; i<=N; i++){
        if((N%i)==0){
            arrN.push(N/i);
        }
    }
    for(let i=1; i<=D; i++){
        if(D%i==0){
            arrD.push(D/i);
        }
    }
    var overlapNum=arrN.filter(x=>arrD.includes(x))[0]

    N=N/overlapNum
    D=D/overlapNum

    var answer = [D,N];
    return answer;
}​

 

function solution(denum1, num1, denum2, num2) {
    var answer = [];
    const gcd = (a, b) => a % b === 0 ? b : gcd(b, a % b);
    const lcm = (a, b) => a * b / gcd(a, b);
    const c = lcm(num1,num2)
    const d = denum1 * (c / num1) + denum2 * (c / num2)
    const e = gcd(c,d)

    return [d/e,c/e]
}​

function solution(denum1, num1, denum2, num2) {
    let numerator = denum1 * num2 + denum2 * num1;
    let denominator = num1 * num2;

    let numerator_factor = [];
    let denominator_factor = [];

    while(true) {
        for(let i = 0; i <= numerator; i++) {
            if (i !== 1 && numerator % i === 0) {
                numerator_factor.push(i);
            }
        }

        for(let j = 0; j <= denominator; j++) {
            if (j !== 1 && denominator % j === 0) {
                denominator_factor.push(j);
            }
        }

        const [factor] = numerator_factor.filter(it => denominator_factor.includes(it));

        if (factor === undefined) {
            break;
        }

        numerator /= factor;
        denominator /= factor;

        numerator_factor = [];
        denominator_factor = [];
    }

    console.log(numerator_factor);
    console.log(denominator_factor);

    return [numerator, denominator]
}

 

function solution(denum1, num1, denum2, num2) {
var answer = [0, 0];
// 분자
let first = num1 * denum2 + num2 * denum1;
// 분모
let second = num1 * num2;

// 최대공약수
let gcd = (a, b) => (a % b === 0 ? b : gcd(b, a % b));
let min = gcd(first, second);

// 분자 / 최대공약수
answer[0] = first / min;

// 분모 / 최대공약수
answer[1] = second / min;

return answer;
}

function solution(denum1, num1, denum2, num2) {
  var answer = [0, 0];
  let first = num1 * denum2 + num2 * denum1;
  let second = num1 * num2;
  let gcd = (a, b) => (a % b === 0 ? b : gcd(b, a % b));
  let min = gcd(first, second);
  answer[0] = first / min;
  answer[1] = second / min;

  return answer;
}

function fnGCD(a, b){
    return (a%b)? fnGCD(b, a%b) : b;
}

function solution(denum1, num1, denum2, num2) {
    let denum = denum1*num2 + denum2*num1;
    let num = num1 * num2;
    let gcd = fnGCD(denum, num); //최대공약수

    return [denum/gcd, num/gcd];
}

gcd 함수를 만들고 연산자의 특성을 이용한 풀이

최대공약수를 간략하게 구하는 방법

const solution = (denum1, num1, denum2, num2) => {
    let [ denum, num ] = [denum1 * num2 + denum2 * num1, num2 * num1]

    while(true) {
        let isContinue = false

        const min = denum < num ? denum : num

        for (let i=2; i<=min; i++) {
            if (denum % i === 0 && num % i === 0) {
                denum = denum / i
                num = num / i
                isContinue = true
                break
            }
        }

        if (!isContinue) {
            break
        }
    }

    return [ denum, num ]
}

function solution(denum1, num1, denum2, num2) {
    function gcd(a, b) {
        while (b != 0) {
            let r = a%b;
            a = b;
            b = r;
            };
        return a;
        }

    let denum = denum1*num2 + denum2*num1;
    let num = num1*num2;
    let g = gcd(denum, num);

    return [denum/g, num/g];
}

unction solution(denum1, num1, denum2, num2) {
    var answer = [];

    const getGCD = (a, b) => (a % b === 0) ? b : getGCD(b, a % b);

    let lcm = (num1 * num2) / getGCD(num1, num2);
    let denum = denum1 * (lcm / num1) + denum2 * (lcm / num2);

    answer = [denum, lcm];

    let t = getGCD(denum, lcm);
    console.log(t)

    answer = [denum/t, lcm/t];

    return answer;
}

function solution(denum1, num1, denum2, num2) {
    var up_num = denum1 * num2 + denum2 * num1;
    var down_num = num1 * num2;

    for(let i = 2, j = up_num > down_num?parseInt(up_num/2+1):parseInt(down_num/2+1);
        i < j; i++){
        if(up_num%i===0 && down_num%i===0){
            up_num = up_num / i;
            down_num = down_num / i;
            i--;
        }
    }
    var answer = [up_num, down_num];
    return answer;
}

const gcd = (num1, num2) => {
  return num2 === 0 ? num1 : gcd(num2, num1 % num2);
};

function solution(denum1, num1, denum2, num2) {
  const num = num1 * num2;
  const denum = num1 * denum2 + num2 * denum1;

  const gcd_num = gcd(denum, num);

  return [Math.floor(denum / gcd_num), Math.floor(num / gcd_num)];
}

function solution(denum1, num1, denum2, num2) {
    let n = Math.min(num1, num2);
    while (n%num1!==0||n%num2!==0) n++;

    let s = n/num1*denum1+n/num2*denum2;
    for (let i = n; i > 1; i--) {
        if (s%i===0 && n%i===0) {
            s/=i;
            n/=i;
        }
    }
    return [s,n];
}

function ucd(num1, num2) {
    const gcd = (a, b) => a % b === 0 ? b : gcd(b, a % b);
    const lcm = (a, b) => a * b / gcd(a, b);
    return [gcd(num1, num2), lcm(num1, num2)];
}

function solution(denum1, num1, denum2, num2) {
    // 최소공배수
    const ucdVal = ucd(num1, num2)
    const x = ucdVal[1] / num1
    const y = ucdVal[1] / num2
    console.log(ucdVal, x, y)

    let upper = denum1*x + denum2*y
    let bottom = num1*x

    const ucdSec = ucd(upper, bottom)
    upper /= ucdSec[0]
    bottom /= ucdSec[0]

    return [upper, bottom]
}

function solution(denum1, num1, denum2, num2) {
    const denum = (denum1 * num2) + (denum2 * num1);
    const num = num1 * num2;
    const gcd = (p, q) => {
        if (q === 0) return p;
        return gcd(q, p % q);
    }
    const g = gcd(denum, num);
    return [denum / g, num / g];
}

function solution(denum1, num1, denum2, num2) {
    var answer = [];
    answer[0] = denum1*num2;
    answer[1] = num1*num2;
    answer[0] += denum2*num1;
    function uclid(a,b){
        var r = a%b;
        if(r===0)return b;
        else return uclid(b,r);
    } 
    var max= Math.max(...answer);
    var min= Math.min(...answer);
    var g = uclid(max,min);
    answer[0] /=g;
    answer[1] /=g;
    return answer;
}

function solution(denum1, num1, denum2, num2) {
    var answer = [];



    //분모 최소공배수(x) 구하기
    var i = 1;
    while(true){
      if((i % num1 === 0) && (i % num2 === 0)){
        break;
      }
      i++;

    }
    var mom = i;

    var son = denum1*parseInt(mom/num1) + denum2*parseInt(mom/num2);


    //분모와 분자의 최대공약수(y) 구하기
    var i = 1;
    while(i <= mom && i <= son) {
        if (mom % i === 0 && son % i === 0) {
            var y = i;
        }
        i++;
    }
    son = son / y;
    mom = mom / y;


answer.push(son);
answer.push(mom);    



    return answer;
}

function solution(denum1, num1, denum2, num2) {
    function gcdFunc(newDenum, newNum) {
        return newNum ? gcdFunc(newNum, newDenum % newNum) : newDenum;
    }

    if (num1 === num2) {
        newNum = num1;
        newDenum = denum1 + denum2;
        let gcd = gcdFunc(newDenum, newNum);
        return [newDenum / gcd, newNum / gcd];
    } else {
        newNum = num1 * num2;
        denum1 = (newNum / num1) * denum1;
        denum2 = (newNum / num2) * denum2;
        newDenum = denum1 + denum2;
        let gcd = gcdFunc(newDenum, newNum);
        return [newDenum / gcd, newNum / gcd];
    }
}

function solution(denum1, num1, denum2, num2) {
    var answer = [];
    function gcd(a, b) {
        while (b !== 0){
            let r = a % b
            a = b
            b = r
        }
        return a
    }
    const denum =  denum1 * num2 + denum2 * num1
    const num = num1* num2
    const g = gcd(denum ,num)


    return [denum/g,num/g];
}

function solution(denum1, num1, denum2, num2) {
    var answer = [];

    //num의 최소공배수 구하기
    let lcmRslt = lcm(num1, num2);

    answer = Array(2).fill().map((v,i) => {
        if(i == 0) {
            return denum1 * (lcmRslt / num1) + denum2 * (lcmRslt / num2)
        } else 
            return num1 * (lcmRslt / num1)
    });

    while (gcd(answer[0], answer[1]) > 1) {

        let gcdRslt = gcd(answer[0], answer[1]);
        answer[0] /= gcdRslt;
        answer[1] /= gcdRslt;

    }

    return answer;

}

//최소공배수
const lcm = (num1, num2) => {
    return (num1 * num2) / gcd(num1, num2);
}

//최대공약수
const gcd = (num1, num2) => {

    while (num2 > 0) {
        let temp = num2;
        num2 = num1 % num2;
        num1 = temp;
    }

    return num1;
}

let getGCD = (num1, num2) => {
  let gcd = 1;

  for (let i = 2; i <= Math.min(num1, num2); i++) {
    if (num1 % i === 0 && num2 % i === 0) {
      gcd = i;
    }
  }

  return gcd;
};

// denum : 분자
// num : 분모
function solution(denum1, num1, denum2, num2) {
  let arr = [];
  const result_denom = denum1 * num2 + denum2 * num1; // 분자
  const result_num = num1 * num2; // 분모

  // 최대공약수 : 공통된 약수 중 가장 큰 수
  // 최대 공약수로 분모 분자 나누기
  const GCD = getGCD(result_denom, result_num);

  const rdnom = result_denom / GCD;
  const rnom = result_num / GCD;

  arr.push(rdnom);
  arr.push(rnom);
  return arr;
}

function solution(denum1, num1, denum2, num2) {

    const multiple = commonMultiple(num1, num2);
    const num1Multiple = multiple / num1;
    const num2Multiple = multiple / num2;

    //분자
    const numerator = (denum1 * num1Multiple) + (denum2 * num2Multiple);

    //최대공약수
    const denominator = commonDivisor(numerator, multiple);

    // console.log(numerator, multiple, "->", denominator);

    return [numerator/denominator, multiple/denominator];
}

function commonMultiple(num1, num2) {
    const max = num1 > num2 ? num1 : num2;
    const min = num1 > num2 ? num2 : num1;

    let number = 1;

    while((max * number) % min != 0){
        if((max * number) % min)
            number++;
    }

    return max * number;
}

function commonDivisor(num1, num2) {

    let max, min;

    if(num1 > num2) {
        max = num1; min = num2;
    } 
    else {
        max = num2; min = num1;
    }

    while(max % min >= 0){
        const r = max % min;
        max = min;
        min = r;
    }

    return max;
}

function isPrime(num) {
    const div = [];
    for(let i=2; i*i<=num; i++) {
        if(num % i == 0)
            return false;
    }
    return true;
}