[알고리즘 특강2] 내가 작성한 코드와 비교해보자.

• 나는 Number를 이용해서 풀었다.
• +로 문자를 숫자로 바꿀 수 있지만, 명시적이지 않은 방법. 하지만, 생각하지 못한 방법이어서 재밌었다.
• parseInt도 스트링을 integer타입으로 바꿔줌.

---

• 나는 indexOf를 사용했다.
• findIndex도 특정 조건문에 해당되는 아이템의 index를 반환하는 메소드라는 것을 새롭게 알았다.

---

 function solution(n) {
   let answer = "";
   for (let i = 1; i <= n; i++){
     answer += (i % 2 === 0) ? "박" : "수"
   }
   return answer
 }

- 내가 작성한 코드이다.

 

- 어떤 분은 repeat이라는 메소드를 사용했다. 

 

---

function solution(s) {
  let length = s.length;
  let mid = Math.floor(length / 2);
  return  (length % 2 === 0) ? s[mid - 1] + s[mid] : s[mid]
}

- 나의 코드이다.

 

• 삼항연산자를 사용한 접근은 좋았으나, s.length는 상수임으로 let보다는 const를 사용하면 좋았을 것이다.
• 앞으로 변하지 않을 값인 상수를 선언할 때는 습관적으로 let이 아닌 cosnt를 주로 사용하도록 해야겠다.
• 변수명! 항상 값과 관련있게 신중하게 정하기!!
•  어떤 분이 substr을 사용해서 신박한 코드를 작성해주셨는데, 그 메소드는 사라져가는 메소드여서 사용을 권장하시지 않았다. 코드를 짤 때 그런 디테일한 부분까지 고려해서 검색하고, 확인해보는 것도 좋을 것 같다. 

<스니펫>

사용자 코드 조각(vsCOde), javascript.json

튜터님 팁: 길게 쓰기 귀찮은 코드들을 단축키로 만들어 써보자...

 

{
  "for loop": {
    "prefix": "fl",
    "body": ["for(let i=0; i<n; i++){", " ", "}"],
    "description": "create for loop"
  },
  "for loop j version": {
    "prefix": "flj",
    "body": [
      "for(let i=0; i<n; i++){",
      "  for(let j=0; j<n; j++){",
      " ",
      "  }",
      "}"
    ],
    "description": "create for loop"
  },
  "for loop - 3": {
    "prefix": "fl3",
    "body": [
      "for(let i=0; i<n; i++){",
      "  for(let j=0; j<n; j++){",
      "    for(let k=0; k<n; k++){",
      " ",
      "    }",
      "  }",
      "}"
    ],
    "description": "create for loop - 3"
  },
  "for loop -4": {
    "prefix": "fl4",
    "body": [
      "for(let i=0; i<n; i++){",
      "  for(let j=0; j<n; j++){",
      "    for(let k=0; k<n; k++){",
      "      for(let l=0; l<n; l++){",
      " ",
      "      }",
      "    }",
      "  }",
      "}"
    ],
    "description": "create for loop - 4"
  },
  "ifElse": {
    "prefix": "ie",
    "body": [
      "if() {",
      "",
      "}",
      "else {",
      "",
      "}"
    ],
    "description": "create if else"
  },
  "ifElesifelse": {
    "prefix": "iee",
    "body": [
      "if() {",
      "",
      "}",
      "elseif() {",
      "",
      "}",
      "else {",
      "",
      "}"
    ],
    "description": "create if elseif else"
  },
  "isOdd": {
    "prefix": "io",
    "body": [
      "i % 2 === 1"
    ],
    "description": "create check odd number"
  },
  "const n": {
    "prefix": "cn",
    "body": ["const n = arr.length"],
    "description": "create const n"
  },
  "const m": {
    "prefix": "cm",
    "body": ["const m = arr[0].length"],
    "description": "create const m"
  },
  "console.info": {
    "prefix": "ci",
    "body": ["console.info()"],
    "description": "create console info"
  },
  "console.table": {
    "prefix": "ct",
    "body": ["console.table()"],
    "description": "create console table"
  },
  "console.info-basic": {
    "prefix": "cib",
    "body": ["console.info('i',i,'j',j,'arr',arr)"],
    "description": "create console basic info"
  },
  "console.info-solution": {
    "prefix": "cis",
    "body": ["console.info(solution())"],
    "description": "create console info(solution)"
  },
  "console.info-json-parse-arr": {
    "prefix": "cij",
    "body": ["console.info('arr',JSON.parse(JSON.stringify(arr)))"],
    "description": "create console info(solution)"
  },
  "isValid": {
    "prefix": "iv",
    "body": ["const isValid = (x,y) => x>=0 && x<n && y>=0 && y<m"],
    "description": "isValid"
  },
  "arr-sort": {
    "prefix": "as",
    "body": ["arr.sort((a,b)=>a-b)"],
    "description": "arr-sort"
  },
  "arr-sort-2": {
    "prefix": "as2",
    "body": [
      "arr.sort((a, b) => {",
      "if (a[0] === b[0]) return a[1] - b[1]",
      "else return a[0] - b[0]",
      "})"
    ],
    "description": "arr-sort"
  },
  "Number.MAX": {
    "prefix": "max",
    "body": ["let answer=Number.MAX_SAFE_INTEGER;"],
    "description": "create MAX"
  },
  "Number.MIN": {
    "prefix": "min",
    "body": ["let answer=Number.MIN_SAFE_INTEGER;"],
    "description": "create MIN"
  },
  "check array": {
    "prefix": "a1",
    "body": ["let ch = Array.from({length:n+1}, ()=>0)"],
    "description": "create checkbox array"
  },
  "graph array": {
    "prefix": "a2",
    "body": ["let graph = Array.from(Array(n+1), ()=>Array(n+1).fill(0))"],
    "description": "create graph array"
  },
  "graph array example": {
    "prefix": "gae",
    "body": [
      "let exArr = [",
      "  [(0, 0), (0, 1), (0, 2)],",
      "  [(1, 0), (1, 1), (1, 2)],",
      "  [(2, 0), (2, 1), (2, 2)]",
      "];"
    ],
    "description": "create graph array example"
  },

  "direction x,y-4": {
    "prefix": "dxy",
    "body": ["let dx = [0,0,1,-1]", "let dy = [-1,1,0,0]"],
    "description": "create dxy-4"
  },
  "direction x,y-8": {
    "prefix": "dxy8",
    "body": [
      "let dx=[-1, -1, 0, 1, 1, 1, 0, -1]",
      "let dy=[0, 1, 1, 1, 0, -1, -1, -1]"
    ],
    "description": "create dxy-8"
  },
  "function solution": {
    "prefix": "fs",
    "body": ["function solution(){", "  let answer", "  return answer", "}"],
    "description": "create function"
  },
  "arrow function solution": {
    "prefix": "afs",
    "body": ["let solution = () => {", " ", "}"],
    "description": "create function"
  },
  "DFS": {
    "prefix": "dfs",
    "body": [
      "function DFS(){",
      "  if(){",
      "  ",
      "  }else{",
      "  ",
      "  }",
      " }",
      " DFS()"
    ],
    "description": "create DFS"
  },
  "BFS": {
    "prefix": "bfs",
    "body": [
      "function BFS () {",
      "const queue = []",
      "queue.push()",
      "while(queue.length){",
      "",
      " }",
      "}"
    ],
    "description": "create BFS"
  },
  "dxyfl": {
    "prefix": "dxyfl",
    "body": [
      "for (let i = 0; i < arr.length; i++) {",
      " let nx = x + dx[i]",
      " let ny = y + dy[i]",
      " if (isValid(nx,ny) && ) {",
      "",
      "  }",
      "}"
    ],
    "description": "create dxyfl"
  },

  "isPrime": {
    "prefix": "ip",
    "body": [
      "function isPrime(num) {",
      "  if (num < 2) return false",
      "  if (num === 2) return true",
      "  for (let i = 2; i <= Math.sqrt(num); i++) {",
      "    if (num % i === 0) return false",
      "  }",
      " return true",
      "}"
    ],
    "description": "create isPrime"
  },
  "addExample": {
    "prefix": "ae",
    "body": [
      "let arr1=",
      "let arr2=",
      "let arr3=",
      "",
      "console.info(solution(arr1))",
      "console.info(solution(arr2))",
      "console.info(solution(arr3))"
    ],
    "description": "create isPrime"
  },
  "while": {
    "prefix": "wh",
    "body": ["let tmp = 0", "", "while(tmp<100){", "tmp++", "}"],
    "description": "create while"
  },
  "checkSolutionTemplate": {
    "prefix": "cst",
    "body": [
      "function isEqual(expected, actual) {",
      "  if (expected === actual) {",
      "    return true;",
      "  }",
      "",
      "  if (typeof expected === \"object\" && typeof actual === \"object\") {",
      "    return JSON.stringify(expected) === JSON.stringify(actual);",
      "  }",
      "",
      "  return false;",
      "}",
      "",
      "function checkSolution(solutionFunc, ...args) {",
      "  const expected = args.pop(); // 마지막 인자는 예상 답안",
      "  const actual = solutionFunc(...args);",
      "  const result = isEqual(expected, actual) ? \"정답\" : \"오답\";",
      "  const color = isEqual(expected, actual) ? \"\\x1b[32m\" : \"\\x1b[31m\"; // 초록: 정답, 빨강: 오답",
      "",
      "  console.info(\"%s%s\\x1b[0m, 기대: %s, 받음: %s\", color, result, expected, actual);",
      "}"
    ],
    "description": "create check solution"
  },
  "checkSolution": {
    "prefix": "cs",
    "body": [
      "checkSolution(solution)"
    ],
    "description": "create check solution"
  },
}

 

- 절차형 vs  선언형: 가독성 성능 더 좋음-

- 피해야하는 코딩 스타일: 안티 패턴 => 안티패턴을 피하고, 일관성에 집중해주어야함.

 

 

브루투포스(Brute force) (완전탐색)

📌 모든 가능한 경우의 수를 탐색하여 정답을 얻어내는 방식!

• 특징
  • 가능한 모든 경우를 일일이 확인하여 문제를 해결한다
  • 로직은 단순하지만 가장 확실한 방법이다
• 장점
  • 구현이 간단하고 직관적임
  • 모든 경우의 수를 확인하므로 답의 정확성이 보장 됨
• 단점
  • 문제에서 주어진 값의 크기가 커지면 비효율적이 될 수 있습니다.

---

 

개발자로서 성장하기 위해 내가 명심할 것 정리:

 

hard skill(기술적 역량): 

• 그냥 생각없이 코딩하는 것이 아닌 로직과 코드에 대한 의도를 생각하기
• 구현하는 기술, 스택에 목적과 근거 가지기
• 더 좋은 방법이 있는지 고민하기
• 깃에 커밋할 때도 신중하게 좋은 description으로 커밋하기.
• 그때 그때 배운 것, 느낀 것 기록하기 -> til 작성

 

soft skill(협업, 소통 역량):

• 예쁘게 말하기
• 전달하고자 하는 바를 명확하게 말하기
• 데이터 또는 기술적인 근거를 바탕으로 소통하기
• 동문서답 X!, 말 이해되게 말하기!
• 두괄식으로 말하기. (결론 먼저 말하고, 필요 시 부연설명하기)