Day 1

twoSum함수에 숫자배열과 '특정 수'를 인자로 넘기면,
더해서 '특정 수'가 나오는 index를 배열에 담아 return해 주세요.

nums: 숫자 배열
target: 두 수를 더해서 나올 수 있는 합계
return: 두 수의 index를 가진 숫자 배열

예를 들어,

nums은 [4, 9, 11, 14]
target은 13 

nums[0] + nums[1] = 4 + 9 = 13 이죠?

그러면 [0, 1]이 return 되어야 합니다.

• 가정
  target으로 보내는 합계의 조합은 배열 전체 중에 2개 밖에 없다고 가정하겠습니다.

My Solution

const twoSum = (nums, target) => {
	let set1 = new Set();
	for (i in nums) {
	  if (nums.includes(target-nums[i])) {
	    set1.add(parseInt(i))
	    set1.add(nums.indexOf(target-nums[i]))
	  }
	}
	let answer = [...set1]
	return answer
}

twoSum([4,9,11,14], 13)

Model Solution

function twoSum(nums, target) {
  for (let i = 0; i < nums.length-1; i++) {
    for (let j = i+1; j < nums.length; j++) {
       if (nums[i] + nums[j] === target) {
         return [i, j];
       }
    }
  }
}

Day 2

reverse 함수에 정수인 숫자를 인자로 받습니다.
그 숫자를 뒤집어서 return해주세요.

x: 숫자
return: 뒤집어진 숫자를 반환!

예들 들어,

x: 1234
return: 4321

x: -1234
return: -4321

x: 1230
return: 321

My Solution

const reverse = x => {
  let answer = ""
  let s = Math.abs(x).toString()
  for (i=s.length-1; i>=0; i--){
    answer = answer + s[i]
  }
  x<0 ? answer = '-' + answer : answer
	return parseInt(answer)
}

Model Solution

function reverse(x) {
  let minus = false;
  
  if (x < 0) {
      x *= -1;
      minus = true;
  }
  
  let numText = x.toString();
  let result = '';
  
  for (let i = numText.length-1; i >= 0; i--) {
      result += numText[i];
  }
  
  result = minus ? result * -1 : Number(result);
  
  return result;
}

Day 3

String 형인 str 인자에서 중복되지 않은 알파벳으로 이루어진 제일 긴 단어의 길이를 반환해주세요.

str: 텍스트
return: 중복되지 않은 알파벳 길이 (숫자 반환)

예를 들어,

str = "abcabcabc"
return은 3
=> 'abc' 가 제일 길기 때문

str = "aaaaa"
return은 1
=> 'a' 가 제일 길기 때문

str = "sttrg"
return은 3
=> 'trg' 가 제일 길기 때문

My Solution

const getLengthOfStr = str => {
	let slicedStr = [];
	let lastStr = 0;
	
	for (i in str) {
		if (slicedStr.indexOf(str[i]) === -1) {
			slicedStr.push(str[i]);
			
			if (lastStr < slicedStr.length) {
				lastStr = slicedStr.length;
			}
	  } else {
		  slicedStr = slicedStr.slice(slicedStr.indexOf(str[i]) + 1);
		  slicedStr.push(str[i]);
	  }
  }
  console.log(lastStr)
 return lastStr;
}

Model Solution

function getLengthOfStr(s) {
    let strArr = [];
    let prevStrArr = [];
    console.log(s)
    for (let i = 0; i < s.length; i++) {
      
      console.log('=======================', i);
      
        let ss = s.slice(i, i+1);
        console.log(' 검사 ss ==> ', ss);
        for (let j = 0; j < strArr.length; j++) {
            if (ss === strArr[j]) {
                
                if (prevStrArr.length < strArr.length) {
                    prevStrArr = strArr.slice();
                    console.log('prevStrArr에 저장', prevStrArr);
                }
                
                strArr = strArr.splice(j+1, strArr.length);
                console.log('자르고 다시 시작 strArr', strArr, j)
                             //splice arr 자르는 함수
                break;
            }
        }
        
        strArr.push(ss);
        console.log('추가한 후 strArr', strArr);
    }
    
    return Math.max(strArr.length, prevStrArr.length);
}

console.log(getLengthOfStr('taaaytts'));

Day 4

숫자인 num을 인자로 넘겨주면, 뒤집은 모양이 num과 똑같은지 여부를 반환해주세요.

num: 숫자
return: true or false (뒤집은 모양이 num와 똑같은지 여부)

예를 들어,

num = 123
return false 
=> 뒤집은 모양이 321 이기 때문

num = 1221
return true 
=> 뒤집은 모양이 1221 이기 때문

num = -121
return false 
=> 뒤집은 모양이 121- 이기 때문

num = 10
return false 
=> 뒤집은 모양이 01 이기 때문

My Solution

const sameReverse = num => {
  const stringNum = String(num)
  let reversedNum = stringNum.split("").reverse().join("");
  return stringNum === reversedNum
}

Model Solution

function sameReverse(num) {
  let xStrArr = (num + '').split('');
  let strLength = xStrArr.length;
  let arr = [];
  
  for (let i = 0; i < strLength; i++) {
      arr.push(xStrArr.pop());
  } 
  console.log(Number(arr.join('')))
  return num === Number(arr.join(''));
}

console.log(sameReverse(1234567887654321));

Day 5

strs은 단어가 담긴 배열입니다.
공통된 시작 단어(prefix)를 반환해주세요.

예를 들어

strs = ['start', 'stair', 'step']
return은 'st'

strs = ['start', 'wework', 'today']
return은 ''

My Solution

const getPrefix = strs => {
	let answer = "";
	let standard = 0
	const newlst = strs.sort()
	if (strs.length === 0) {
		return answer
		} else {
			standard = newlst[0].length;
			if (newlst[0].length > newlst[newlst.length-1].length) {
				standard = newlst[newlst.length-1].length;	
			}
		}
	for (i=0; i<standard; i++) {
    console.log(newlst, standard, newlst[0][i], newlst[newlst.length-1][i])
    if (newlst[0][i] === newlst[newlst.length-1][i]) {
      answer += newlst[0][i]
    } else {
      return answer
    }
	}
	return answer
}

Model Solution

function getPrefix(strs) {
    if (strs.length === 0) return ''; 
    
    let prefix = strs[0];
    
    for (let i = 1; i < strs.length; i++) {
        while (strs[i].indexOf(prefix) !== 0) {
            prefix = prefix.substring(0, prefix.length - 1);
        }
    }
    
    return prefix;
}

/* 또는
function getPrefix(strs) {
  if (strs.length === 0) return '';
  
  let strArr = strs[0].split('');
  let idx = 0;
  let stop = false;
  
  for (let i = 0; i < strArr.length; i++) {
      let char = strArr[i];
      
      for (let j = 0; j < strs.length; j++) {
          let thisStrArr = strs[j].split('');
          
          if (char !== thisStrArr[i]) {
              idx = i-1;
              stop = true;
              break;
          }
      }     
      
      if (stop) break;
  }
  
  if (!stop) {
      idx = strArr.length - 1;
  }
  
  return strArr.slice(0, idx+1).join('');
}
*/