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개 밖에 없다고 가정하겠습니다.

---

내 풀이 방식

const twoSum = (nums, target) => {
  let resultArr = [];
  for (let i in nums) {
    let findNum = Math.abs(target - nums[i]);
    if (nums.indexOf(findNum) !== -1 && nums.indexOf(findNum) !== Number(i)) {
      resultArr.push(Number(i), nums.indexOf(findNum));
      return resultArr;
    } 
  }
}

let numArr = [4, 9, 11, 14];
console.log(twoSum(numArr, 13));

또는

const twoSum = (nums, target) => {
  for (let i in nums) {
    let findNum = Math.abs(target - nums[i]);
    if (nums.indexOf(findNum) !== -1 && nums.indexOf(findNum) !== Number(i)) {
      return [Number(i), nums.indexOf(findNum)];
    } 
  }
}

let numArr = [4, 9, 11, 14];
console.log(twoSum(numArr, 13));

1. 빈 배열 추가,
2. for in 문 사용해 반복
3. 첫번째 요소에서 target에 첫번째 요소를 뺀 값(절대값으로 변환)을 할당한 findNum 변수 생성
4. 배열에서 findNum이 -1이 아니라면 (배열에 찾는 요소가 없으면 -1 반환)
5. 그리고 findNum의 인덱스가 자기 자신이 아니라면
6. 빈 배열에 첫번째 인덱스, 그리고 인덱스 추가
7. fon in 문 사용해서 인덱스 반환하면 string형으로 출력

---

짝궁 솔미님

const twoSum = (nums, target) => {
  for(let i in nums) {
    let j = i + 1;
    for(let j in nums){
      if(nums[i] + nums[j] === target) {
        return [Number(i), Number(j)];
     }
   }
  }
}

1. for 문 2개 사용
2. 첫번째 반복문 요소1개, 안쪽 반복의 시작위치는 첫번째 반복보다 1 큰 수로 시작 (자기자신 포함 X)
3. 첫번째 반복문의 요소와, 안쪽 반복의 요소를 더한 값이 target과 같으면
4. 배열 반환

솔루션 가이드

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];
       }
    }
  }
}

---

2번

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

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

예들 들어,
x: 1234
return: 4321

x: -1234
return: -4321

x: 1230
return: 321

---

풀이 - 1

const reverse = x => {
  if (x >= 0) {
    return Number(x.toString().split("").reverse().join(""));
  } else {
    let absNum = Math.abs(x);
    return Number(absNum.toString().split("").reverse().join("")) * -1;
  }
}

console.log(reverse(-1234));

1. 인자로 전달받은 x >= 0 이면
2. x를 문자열로 형변환해서
3. split("") 메서드로 (공백없이) 쪼개면 배열로 변환되는데
4. reverse() 메서드로 요소의 순서를 반전시킨 다음에
5. join("") 메서드로 공백없이 합친 다음에
6. 숫자로 다시 형변환 시켜 return
7. 인자로 전달받은 x < 0 이면 (음수 이면)
8. x를 절대값으로 변환시킨 다음에
9. 2 ~ 5 를 똑같이 진행한 다음에
10. -1을 곱한 수를 반환

풀이 - 2

const reverse = x => {
  let returnNum = parseInt(x.toString().split("").reverse().join(""));
  return x >= 0 ? returnNum : -returnNum;
}

console.log(reverse(-1234));

1. returnNum이란 변수를 선언해서
2. 인자로 전달받은 x를 문자열로 형변환해서
3. split("") 메서드로 (공백없이) 쪼개면 배열로 변환되는데
4. reverse() 메서드로 요소의 순서를 반전시킨 다음에
5. join("") 메서드로 공백없이 합친 다음에
6. parseInt로 문자열인 숫자를 10진법 숫자로 형변환한 다음에
7. returnNum에 할당시키고
8. 삼항연산자를 사용하여
9. x >= 0이면 (?) returnNum을 그대로 return 하고
10. 아니면 (:) -returnNum을 반환한다

---

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;
}

---

3번

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

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

예를 들어,
str = "abcabcabc"
return은 3
=> 'abc' 가 제일 길기 때문

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

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

내 답

const getLengthOfStr = str => {
  let findStr = [];
  let findLength = [];
  let findIndexStart = 0;
  let findIndexLast = str.length-1

  // 앞에서 부터
  for (let i = findIndexStart; i < str.length; i++) {
    if (findStr.indexOf(str[i]) === -1) {
      findStr.push(str[i]);
    } else {
      findIndexStart = i
      findLength.push(findStr.length)
      findStr = findStr.splice(findStr.length)
      findStr.push(str[i])
    }
  }

  findLength.push(findStr.length);
  
  // 뒤에서 부터
  for (let i = findIndexLast; i >= 0; i--) {
    if (findStr.indexOf(str[i]) === -1) {
      findStr.push(str[i]);
    } else {
      findIndexLast = i
      findLength.push(findStr.length)
      findStr = findStr.splice(findStr.length) // i+1 해도 같은 결과
      findStr.push(str[i])
    }
  }
  
  findLength.push(findStr.length);
  
  //최종 값 구하기
  return Math.max.apply(null, findLength);
}

console.log(getLengthOfStr("abcabcabc"));

console.log(getLengthOfStr("aaaaa"));

console.log(getLengthOfStr("sttrg"));

console.log(getLengthOfStr("abcdefghcijklmnop"));

내 답 결과

3
1
3
14

• splice() : MDN 자료
• apply() : MDN 자료

엄청 복잡하게 풀었다
맨처음에 앞 쪽에서 순차적으로 짤랐을때만 생각했는데 오류가 떠서 확인해보니
뒤 쪽에서도 짜른거로 검사해봐야된다는걸 알았다

1. 중복없는 단어를 넣기 위한 빈 배열 선언
2. 맨 처음 배열의 길이를 구하는 빈 배열 선언
3. 앞쪽 반복문 시작하는 숫자 변수 선언, 뒤쪽 반복문 시작하는 숫자 변수 선언
4. 단어 앞에서 부터 비교 시작
5. 맨처음 반복을 시작할 숫자는 findIndexStart = 0 시작해서 단어의 길이보다 작을때까지 반복
6. 값을 비교할 맨처음 빈 배열에서 단어의 i번째 요소가 배열에 없으면
7. 중복없는 단어 배열에 추가
8. 중복없는 단어 배열에 중복값이 생기면 else 블록으로 넘어와서
9. 다시 반복문 시작 숫자는 중복인 요소의 index로 재할당
10. 지금까지 중복 없는 단어 배열의 길이를 길이 배열에 추가
11. 중복없는 단어 배열 slice 함수로 초기화 아직 잘모르겠다 할때마다 값이 바뀜...
12. 초기화된 중복없는 단어 배열에 중복값이없던 요소 추가
13. 중복값 다음 요소부터 다시 반복 시작
14. 똑같은 방식으로 진행해서 단어 앞에서 부터의 길이를 구한 배열과,
15. 단어 뒤에서 부터의 길이를 구한 배열의 최대값을 return

---

솔루션 모델

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'));

솔루션 모델 결과

taaaytts
======================= 0
 검사 ss ==>  t
추가한 후 strArr [ 't' ]
======================= 1
 검사 ss ==>  a
추가한 후 strArr [ 't', 'a' ]
======================= 2
 검사 ss ==>  a
prevStrArr에 저장 [ 't', 'a' ]
자르고 다시 시작 strArr [] 1
추가한 후 strArr [ 'a' ]
======================= 3
 검사 ss ==>  a
자르고 다시 시작 strArr [] 0
추가한 후 strArr [ 'a' ]
======================= 4
 검사 ss ==>  y
추가한 후 strArr [ 'a', 'y' ]
======================= 5
 검사 ss ==>  t
추가한 후 strArr [ 'a', 'y', 't' ]
======================= 6
 검사 ss ==>  t
prevStrArr에 저장 [ 'a', 'y', 't' ]
자르고 다시 시작 strArr [] 2
추가한 후 strArr [ 't' ]
======================= 7
 검사 ss ==>  s
추가한 후 strArr [ 't', 's' ]
3

---

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 이기 때문

내답

const sameReverse = num => {
  let reverseNum = num.toString().split("").reverse().join("");
  return (num.toString() === reverseNum) ? true : false;
}

//sameReverse(123);
//sameReverse(1221);
//sameReverse(-121);
sameReverse(10);

결과

false

1. 비교할 변수에
2. 인자로 전달받은 숫자를 문자로 변환, 자르고, 뒤집어서, 합친뒤 비교 변수에 할당
3. 정확한 검사를 위해
4. 인자로 전달받은 숫자를 문자로 변환시켜 비교 변수와 같으면 true 반환 다르면 false 반환

---

모델 솔루션

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));

모델 솔루션 결과

1234567887654321
true

---

5번

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

예를 들어
strs = ['start', 'stair', 'step']
return은 'st'

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

솔미님 답

const getPrefix = strs => {
  let prefix = strs[0];
  if(strs.length < 1) {
    return '';
  }
  for(i = 0; i < strs.length; i++) {
    for(j = 0; j < prefix.length; j++) {
      if(strs[i][j] !== prefix[j]) {
        prefix = strs[i].slice(0, j);
      }
    }
  }
  return prefix;
}

console.log(getPrefix(['start', 'stair', 'step']));
console.log();
console.log(getPrefix(['start', 'wework', 'today']));
console.log();

결과

st

---

모델 솔루션

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;
}

console.log(getPrefix(['start', 'stair', 'step']))

/* 또는
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('');
}
*/

결과

st

• substring() : MDN 참고

모델솔루션 1번 방법이 이해가 제일 잘된다
아직 감이 잘 안잡히므로 코드를 그대로 풀어쓴다면
1. 인자로 전달받은 배열의 길이가 0과 같다면 '' 빈 값 return
2. 공통된 시작 단어를 찾아야되니 비교값인 prefix 변수에 배열의 첫번째 요소 할당
3. 첫번째 반복문(for loop) 시작
-> 인자로 전달받은 배열의 첫번째 요소를 비교값에 할당했으니 두번째 요소부터 시작
4. 값 비교를 위해 두번째 반복문(while loop) 시작
-> 하나하나 풀어 써보자
-> str[1]은 stair 이고 prefix는 start, stair.indexOf(start) 가 0과 같지 않다면,
즉 처음 시작에 포함되어 있지 않다면
5. prefix에 prefix는 0부터 4(prefix.length-1) substring (0~3 인덱스에 해당하는 요소 추출) 한다
-> prefix = star
-> while 반복 들어가서 stair.indexOf(star) 은 0이 아니니 조건 true로
-> prefix = sta (0부터 3(prefix.length-1) substring (0~2 인덱스에 해당하는 요소 추출)
-> while 반복 들어가서 stair.indexOf(sta) === 0 이므로 조건 false로 다음 반복으로 넘어감
6. str[2]은 step 이고 prefix는 sta
-> while 반복 들어가서 step.indexOf(sta) 는 0이 아니니 조건 True로
-> prefix = st (0부터 2(prefix.length-1) substring (0~1 인덱스에 해당하는 요소 추출)
-> while 반복 들어가서 stair.indexOf(st) === 0 이므로 조건 false로 모든 반복 종료