코플릿 - 알고리즘

알고리즘 2번

function computeWhenDouble(interestRate) {
// 복리 계산식 : 원리합계(S) = 원금 (P) x ( 1 + 이율(i) ) ^ n
let 원금 = 1;
let 년 = 0;
let 이율 = 1 + interestRate / 100;

while (원금 < 2) { // <=는 while이 2배가 되고 나서 한 번 더 돌아서 안됨, 2배가 되기 직전까지 돌아야함.
    원금 = 원금 * 이율;
    년++;
  }
  return 년;
}

알고리즘 3번

function powerOfTwo(num) {
  if(num === 1) {
    return true;
  }
  
  let pow = 2;
  while(pow < num) {
    pow = pow * 2;
  }
  return pow === num;
}

알고리즘 6번

function letterCapitalize(str) {
  let arr = str.split(' ');
  for(let i = 0; i < arr.length; i++) {
    if(arr[i].length > 0) { // 연속된 공백이 존재할 수 있음
      arr[i] = arr[i][0].toUpperCase() + arr[i].slice(1); // 공백에 slice(1)하면 공백 사라짐
    }
  }
  result = arr.join(' ');
  return result;
}

알고리즘 7번

function convertListToObject(arr) {
  let obj = {};
    for(let i = 0; i < arr.length; i++) {
      if(arr[i].length > 0) { //arr[i]의 길이가 0인 경우 무시, 빈 배열을 입력받은 경우, 빈 객체를 리턴
      if(obj[arr[i][0]] === undefined) { // 중복되는 키의 경우 초기의 값을 사용, obj안에 arr[i][0]가 정의(중복)되지 않았을 때만
        obj[arr[i][0]] = arr[i][1];
        }
      }
    }
   return obj;
  }

알고리즘 10번

function insertDash(str) {
  let result = str[0];
  for(let i = 1; i < str.length; i++) {
      if(str[i - 1] % 2 && str[i] % 2) { // Number를 안 씌우고 나눠도 됨, 0 false 1 true, i = 0, str[i] % 2 && str[i + 1]로하면 str[0]이 두번 더해짐
      result = result + '-';
    }
      result = result + str[i] // else로 하면 안됨
  }
  return result;
}

다른 풀이

function insertDash(str) {
  let arr = str.split('');
  let result = [arr[0]];
  for(let i = 1; i < arr.length; i++) {
    if(arr[i - 1] % 2 && arr[i] % 2) {
      result.push('-');
    }
    result.push(arr[i]);
  }
  return result.join('');
}

밑에 식은 연속된 홀수의 앞에 '-'를 넣어주기 땜에 틀림, 7(i)-9(i+1)와 9(i)-3(i+1)의 앞에 '-'를 넣어줌

알고리즘 11번

function removeExtremes(arr) {
  let shortLen = 20;
  let longLen = 0;
  let shortIdx = 0;
  let longIdx = 0;

  for(let i = 0; i < arr.length; i++) {
    if(arr[i].length <= shortLen) { // 가장 짧은 문자열이 다수일 경우, 나중에 위치한 문자열을 제거
      shortLen = arr[i].length;
      shortIdx = i;
    }
    if(arr[i].length >= longLen) { // 가장 긴 문자열이 다수일 경우, 나중에 위치한 문자열을 제거
      longLen = arr[i].length;
      longIdx = i;
    }
  }

  let result = [];
  for(let i = 0; i < arr.length; i++) {
    if(i !== longIdx && i !== shortIdx) {
      result.push(arr[i]);
    }
  }
  return result;
}

알고리즘 13번

* 답아님 *
function readVertically(arr) {
  let temp = [];
  for(let i = 0; i <arr.length; i++) { // i는 0,1
    let str = arr[i];
    for(let j = 0; j < str.length; j++) { //j는 0,1,2,3,4
      if(temp.length === j) {
        temp.push(str[j]); 
        
      // 여기까지 하면 temp는 ["h(temp[0])", "e", "l", "l", "o"]
      
      } else {
        temp[j] = temp[j] + '-' + str[j]; // --> temp[0]은'h' + '-' + str[0]는 'w'
      }
    }
  }
  return temp;
}

// let input = [
  'hello',
  'wolrd',
];

readVertically(input); --> ["h-w", "e-o", "l-l", "l-r", "o-d"]

* 답 *
function readVertically(arr) {
  let temp = [];
  for(let i = 0; i < arr.length; i++) {
    let str = arr[i];
    for(let j = 0; j < str.length; j++) {
      if(temp.length === j) { // arr[0] --> 'hello'는 다 들어감, 여기까진 temp에 'hello'만 들어있는 상태
        temp.push(str[j]);
      } else { // arr[0]인 경우가 아니면(else) temp[0]에 arr[1]를 더해줌
        temp[j] = temp[j] + str[j];
      }
    }
  }
  let result = '';
  for(let i = 0; i < temp.length; i++) {
    result = result + temp[i];
  }
  return result;
}

다른 풀이

function readVertically(arr) {
  let temp = [];
  for(let i = 0; i < arr.length; i++) {
    for(let j = 0; j < arr[i].length; j++) {
      if(temp.length === j) {
        temp.push(arr[i][j]);
      } else {
        temp[j] = temp[j] + arr[i][j];
      }
    }
  }
  let result = '';
  for(let i = 0; i < temp.length; i++) {
    result = result + temp[i]
  }
  return result;
}

알고리즘 14번

function superIncreasing(arr) {
  let sum = arr[0]; 
  // sum과 i를 0으로 하면 arr[0]값이 마이너스 일 때는 false를 리턴함, ex.[-2247, 1093, 1064]
  for(let i = 1; i < arr.length; i++) {
    if(sum >= arr[i]) {
      return false;
    }
    sum = sum + arr[i]; // --> false가 아니면 arr[i]를 더해줌, sum을 if문 위에 쓰면 arr[i]를 더하므로 틀림
  }
  return true;
}

알고리즘 16번

// ????
function isIsogram(str) {
  let cache = {};
  let upperStr = str.toUpperCase();

  for(let i = 0; i < str.length; i++) {
    if(cache[upperStr[i]]) {
      return false;
    }
    cache[upperStr[i]] = true;
  }
  return true;
}

다른 풀이

function isIsogram(str) {
  let arr = [];
  for(let i = 0; i < str.length; i++) {
    let letter = str.charAt(i).toLowerCase();
    
    if(!arr.includes(letter)) {
      arr.push(letter);
    }
  }
  if(arr.length === str.length) {
    return true;
  }
  return false;
}
// let letter = str.toLowerCase();하면 통째로 소문자로 바꿔주므로 charAt(i)로 한글자씩 바꿔줘야함.

알고리즘 17번

참고 참고2 참고3

function computeSquareRoot(num) {
  let count = 0;
  let estimate = 1;
  while(true) {
    count++;
    if(count === 1000) {
      return Number(estimate.toFixed(2));
    }
    estimate = (estimate + (num / estimate)) / 2;
  }
  return estimate;
}

다른 풀이

function computeSquareRoot(num) {
  let diff = 0.001;
  let base = 1;
    while(base * base < num) {
      base = base + diff;
    }
    if(base * base > num) {
      base = base - diff;
    } else { 
      return base;
    }
  return Number(base.toFixed(2));
}

다른 풀이2

function computeSquareRoot(num) {
  const diffs = [1, 0.1, 0.01, 0.001];
  let base = 1;
  for (let i = 0; i < diffs.length; i++) {
    while (base * base < num) {
      base = base + diffs[i];
    }

    if (base * base === num) {
      return base;
    } else {
      base = base - diffs[i];
    }
  }
  return Number(base.toFixed(2));
}

알고리즘 18번

function numberSearch(str) {
  let sumArr = [];
  let strArr = [];
  
  if(str.length === 0) {
    return 0;
  }

  for(let i = 0; i < str.length; i++) {
      if(isNaN(str[i]) === false) {
        sumArr.push(Number(str[i]));
      } else {
        strArr.push(str[i]);
      }
    }

    let sum = sumArr.reduce((a, b) => (a + b));
    return Math.round(sum / strArr.length);
  }
  
// 공백은 sumArr에 숫자 0으로 들어감 그러므로 이 풀이에서는 공백 처리를 안해줘도 되지만

다른 풀이

function numberSearch(str) {
  let digits = '0123456789';

  if(str === '') {
    return 0;
  }

  let sum = 0;
  let pureStr = ''
  for(let i = 0; i < str.length; i++) {
    if(digits.includes(str[i])) {
      sum = sum + Number(str[i]);
    } else if(str[i] !== ' ') { // 이 풀이에서는 공백 처리를 해줬음
      pureStr = pureStr + str[i];
    }
  }
  return Math.round(sum / pureStr.length);
}

알고리즘 19번

function decryptCaesarCipher(str, secret) {
  let alpha = 'abcdefghijklmnopqrstuvwxyz';
  let result = '';
  for(let i = 0; i < str.length; i++) {
    if(str[i] === ' ') {
      result = result + ' ';
    } else {
      ⭐️ let asis = alpha.indexOf(str[i]);
      ⭐️ let tobe = (asis - secret + alpha.length) % alpha.length;
      result = result + alpha[tobe];
    }
  }
  return result;
}

알고리즘 20번

function compressString(str) {
  // 연속되는 문자를 기록하기 위한 변수
  // 첫 번째 문자로 초기화
  let before = str[0];

  // 동일한 문자의 반복 횟수
  let count = 1;

  // 정답으로 리턴할 문자열
  let result = '';

  // 마지막 부분이 연속된 문자일 경우를 위해 dummy 문자 추가
  str = str + ' ';
  for (let i = 1; i < str.length; i++) {
    // 동일한 문자가 반복될 경우
    if (before === str[i]) {
      count++;
    } else {
      // 이전과 다른 문자일 경우,
      // 반복된 횟수가 3 이상일 경우에만 압축을 한다.
      if (count >= 3) {
        result = result + `${count}${before}`;
      } else {
        result = result + before.repeat(count);
      }
      before = str[i];
      count = 1;
    }
  }

  return result;
}

다른 풀이

function compressString(str) {
  let before = str[0];
  let count = 1;
  let result = '';

  for(let i = 1; i <= str.length; i++) { ⭐️
    if(before === str[i]) {
      count++;
    } else { 🔥 이 블럭 안에서
      if(count >= 3) {
        result = result + count + before;
      } else {
        result = result + before.repeat(count);
      }
      before = str[i]; // 🔥 이 부분에서 before를 str[i]로 전환해주는 이유는 다시 경우에 맞게 result에 넣어줘야 하기 때문
      count = 1;
    } 🔥 이 블럭 안에서
  }
  return result;
}

// 만약 length가 3, let i = 1, i < str.length이면
// i는 1, 2
// 그러나 let i = 1이고, i <= str.length이면 ⭐️
// i는 1, 2, 3
// 여기서 인덱스 3은 더미문자이다. 왜냐면 length가 3이므로 
//i의 인덱스는 0, 1, 2까지 밖에 존재하지 않는다.