[yulrang] 25.01.19

yulrang/01_Array/01_Slice_array.js

@@ -0,0 +1,8 @@
+function solution(numbers, num1, num2) {
+  var answer = [];
+
+  for(let i = num1; i <= num2; i++){
+      answer.push(numbers[i]);
+  }
+  return answer;
+}

yulrang/01_Array/02_Length_of_array_items.js

@@ -0,0 +1,9 @@
+function solution(strlist) {
+  var answer = [];
+
+  for(let i=0; i<strlist.length; i++){
+      answer.push(strlist[i].length);    
+  }
+
+  return answer;
+}

yulrang/01_Array/03_Shift_array.js

@@ -0,0 +1,16 @@
+function solution(numbers, direction) {
+  var answer = [];
+  if (direction === "left") {
+      for(let i=1; i<numbers.length; i++) {
+          answer.push(numbers[i])
+      }
+      answer.push(numbers[0]);
+  }
+  if (direction === "right") {
+      answer.push(numbers[numbers.length-1]);
+      for(let i=0; i<numbers.length-1; i++) {
+          answer.push(numbers[i])
+      }
+  }
+  return answer;
+}

yulrang/01_Array/04_Number_of_duplicated_item.js

@@ -0,0 +1,7 @@
+function solution(array, n) {
+  var answer = 0;
+  var filteredArr = array.filter((el) => el === n);
+  answer = filteredArr.length;
+
+  return answer;
+}

yulrang/01_Array/05_Remove_lowest_number.js

@@ -0,0 +1,7 @@
+function solution(arr) {
+  if (arr.length === 1) {
+      return [-1];
+  }
+
+  return arr.filter((el) => el !== Math.min(...arr));
+}

yulrang/01_Array/06_Sum_of_matrix.js

@@ -0,0 +1,12 @@
+function solution(arr1, arr2) {
+  var answer = new Array(arr1.length);
+
+  for(let i=0; i<arr1.length; i++) {
+      answer[i] = new Array(arr1[i].length);
+      for(let j=0; j<arr1[i].length; j++) {
+          answer[i][j] = arr1[i][j] + arr2[i][j];
+      }
+  }
+
+  return answer;
+}

yulrang/01_Array/07_Multiple_number.js

@@ -0,0 +1,12 @@
+function solution(arr, divisor) {
+  var answer = [];
+
+  arr.forEach((el) => {
+      if(el % divisor === 0) answer.push(el);
+  })
+  answer.sort((a,b) => a-b);
+
+  if(answer.length === 0) return [-1];
+
+  return answer;
+}

yulrang/02_Stack/01_Reverse_string.js

@@ -0,0 +1,5 @@
+function solution(my_string) {
+  var answer = '';
+  answer = my_string.split('').reverse().join('');
+  return answer;
+}

yulrang/02_Stack/02_Ctrl_Z.js

@@ -0,0 +1,15 @@
+function solution(s) {
+  var answer = 0;
+  let arr = s.split(' ');
+  let newArr = [];
+
+  for(let i=0; i<arr.length; i++) {
+      if( arr[i] !== 'Z' ) {
+          newArr.push(arr[i]);
+      } else {
+          newArr.pop(arr[i-1])
+      }
+  }
+  answer = newArr.reduce((acc, cur) => acc + Number(cur), 0);
+  return answer;
+}

yulrang/02_Stack/03_English.js

@@ -0,0 +1,22 @@
+function solution(numbers) {
+  var answer = 0;
+  const numberObj = {
+      zero : 0,
+      one : 1,
+      two : 2,
+      three : 3,
+      four : 4,
+      five : 5,
+      six : 6,
+      seven : 7,
+      eight : 8,
+      nine : 9,
+  }
+
+  for ( const num in numberObj ){
+      numbers = numbers.replaceAll(num, numberObj[num]);    
+  }
+  answer = Number(numbers);
+
+  return answer;
+}

yulrang/02_Stack/04_Calculate_string.js

@@ -0,0 +1,21 @@
+function solution(my_string) {
+  var answer = 0;
+  let newArr = [];
+  my_string.split(' ').forEach((el, idx, arr) => {
+      if(idx === 0) {
+          newArr.push(Number(el));
+      }
+      if(el === '+' || el === '-') {
+          newArr.push(Number(arr[idx + 1]))
+          if (el === '+'){
+              answer = newArr[0] + newArr[1];
+          } else {
+              answer = newArr[0] - newArr[1];
+          }
+          newArr = [];
+          newArr.push(answer);
+      }
+  })
+  answer = newArr[0];
+  return answer;
+}

yulrang/02_Stack/05_KaKao_game.js

@@ -0,0 +1,26 @@
+function solution(board, moves) {
+  let answer = 0;
+  let basket = [];
+
+  const runBasket = () => {
+      for(let i=basket.length-1; i>0; i--) {
+          if(basket[i] === basket[i-1]) {
+              basket.splice(i-1, 2);
+              answer += 2;
+          }
+      }
+  }
+
+  for(let i=0; i<moves.length; i++) {
+      for(let j=0; j<board[0].length; j++) {
+          if(board[j][moves[i]-1] !== 0){
+              basket.push(board[j][moves[i]-1]);            
+              board[j][moves[i]-1] = 0;
+              runBasket();
+              break;
+          }
+      }
+  }
+
+  return answer;
+}

yulrang/02_Stack/06_Correct_pair.js

@@ -0,0 +1,17 @@
+function solution(s){
+  var answer = true;
+  let pairArr = [];
+
+  s.split('').forEach((el) => {
+      if(el === '(') {
+          pairArr.push(el);
+      } else if(el === ')' && pairArr.includes('(')) {
+          pairArr.pop();
+      } else
+          pairArr.push('-');
+  })
+
+  answer = pairArr.length === 0 ? true : false;
+
+  return answer;
+}

yulrang/02_Stack/07_Dart_game.js

@@ -0,0 +1,54 @@
+function solution(dartResult) {
+  var answer = 0;
+  let scoreArr = [];
+
+  dartResult.split('').forEach((el, idx, arr) => {
+      switch(el){
+          case 'S':
+              scoreArr[scoreArr.length-1] = Math.pow(scoreArr[scoreArr.length-1], 1);
+                  break;
+          case 'D':
+              scoreArr[scoreArr.length-1] = Math.pow(scoreArr[scoreArr.length-1], 2);
+                  break;
+          case 'T':
+              scoreArr[scoreArr.length-1] = Math.pow(scoreArr[scoreArr.length-1], 3);
+                  break;
+          case '1': 
+              if(arr[idx+1] === '0') scoreArr.push(10);
+              else scoreArr.push(1);
+              break;
+          case '0':
+              if(arr[idx-1] !== '1') scoreArr.push(0);
+              break;
+          case '*':
+              break;
+          case '#':
+              break;
+          default :
+              scoreArr.push(Number(el));
+              break;
+      }
+  })
+
+  dartResult.split('').forEach((el, idx, arr) => {
+      let targetIdx = 0;
+
+      if(idx >= 6) targetIdx = 2;
+      else if(idx >= 4 && idx < 6) targetIdx = 1;
+      else targetIdx = 0;
+
+      switch(el){
+          case '*':
+              scoreArr[targetIdx] = scoreArr[targetIdx] * 2;
+              scoreArr[targetIdx - 1] = scoreArr[targetIdx - 1] * 2;
+                  break;
+          case '#':
+              scoreArr[targetIdx] = scoreArr[targetIdx] * (-1);
+                  break;
+      }
+  });
+
+  answer = scoreArr.reduce((acc, cur) => acc + cur, 0);
+
+  return answer;
+}

yulrang/03_Queue/01_Number_of_pair.js

@@ -0,0 +1,13 @@
+function solution(n) {
+  var answer = 0;
+  let answerArr = [];
+
+  for(let i = 1; i <= n; i++) {
+      if(n % i === 0)
+          answerArr.push([i, n/i]);
+  }
+
+  answer = answerArr.length;
+
+  return answer;
+}

yulrang/03_Queue/02_Position_of_dot.js

@@ -0,0 +1,10 @@
+function solution(dot) {
+  var answer = 0;
+
+  if(dot[0] > 0){
+      answer = dot[1] > 0 ? 1 : 4;
+  } else if(dot[0] < 0) {
+      answer = dot[1] > 0 ? 2 : 3;
+  }
+  return answer;
+}

yulrang/03_Queue/03_Login.js

@@ -0,0 +1,18 @@
+function solution(id_pw, db) {
+  var answer = '';
+
+  for(const pair of db){
+      if(pair[0] !== id_pw[0]) {
+          answer = "fail";
+      } else {
+          if(pair[1] !== id_pw[1]){
+              answer = "wrong pw";
+          }
+          else {
+              answer = "login";
+          } 
+          break;
+      }
+  }
+  return answer;
+}

yulrang/03_Queue/04_Unusual_sort.js

@@ -0,0 +1,7 @@
+function solution(numlist, n) {
+  var answer = [];
+
+  answer = numlist.sort((a,b) => (Math.abs(n-a) - Math.abs(n-b)) || (b-a));
+
+  return answer;
+}

yulrang/03_Queue/05_Card_queue.js

@@ -0,0 +1,20 @@
+function solution(cards1, cards2, goal) {
+  var answer = '';
+
+  for(let i=0; i<goal.length; i++) {
+      if(cards1[0] === goal[i] || cards2[0] === goal[i]){
+          if(cards1[0] === goal[i]){
+              cards1.shift();
+          }
+          if(cards2[0] === goal[i]){
+              cards2.shift();
+          }
+          answer = "Yes";
+      } else {
+          answer = "No";
+          break;
+      }
+  }
+
+  return answer;
+}

yulrang/03_Queue/06_Park_game.js

@@ -0,0 +1,59 @@
+function solution(park, routes) {
+  let pathArr = [];
+  const WIDTH = park[0].length;
+  const HEIGHT = park.length;
+
+  for(let rowIdx = 0; rowIdx < park.length; rowIdx++){
+      const row = park[rowIdx].split("");
+      if(row.includes("S")){
+          const columnIdx = park[rowIdx].indexOf("S");
+          pathArr.push([columnIdx, rowIdx]);
+          break;
+      }
+  }
+
+
+  for(let i = 0; i<routes.length; i++) {
+      const DIRECTION = routes[i].split(' ')[0];
+      const AMOUNT = Number(routes[i].split(' ')[1]);
+      let blockPos = [-1, -1];
+      let x = pathArr[pathArr.length-1][0];
+      let y = pathArr[pathArr.length-1][1];
+
+      if (DIRECTION === "E") {
+          blockPos = [park[y].indexOf("X", x), y];
+          x = pathArr[pathArr.length-1][0] + AMOUNT;
+          y = pathArr[pathArr.length-1][1];
+      } else if (DIRECTION === "W"){
+          blockPos = [park[y].lastIndexOf("X", x), y];
+          x = pathArr[pathArr.length-1][0] - AMOUNT;
+          y = pathArr[pathArr.length-1][1];
+      } else if (DIRECTION === "S"){
+          blockPos = [x, park.findIndex((row, idx) => idx >= y && row[x] === "X")];
+          x = pathArr[pathArr.length-1][0];
+          y = pathArr[pathArr.length-1][1] + AMOUNT;
+      } else if (DIRECTION === "N"){
+          blockPos = [x, park.slice(0, y).reverse().findIndex((row, idx) => row[x] === "X")];
+          if (blockPos[1] !== -1) blockPos[1] = y - blockPos[1] - 1;
+          x = pathArr[pathArr.length-1][0];
+          y = pathArr[pathArr.length-1][1] - AMOUNT;
+      }
+
+      if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT){
+          continue;
+      }
+      if(!blockPos.includes(-1)){
+          if((y === blockPos[1] && x >= blockPos[0] && pathArr[pathArr.length > 1 ? pathArr.length-2 : 0][0] < blockPos[0]) || 
+             (y === blockPos[1] && x <= blockPos[0] && pathArr[pathArr.length > 1 ? pathArr.length-2 : 0][0] > blockPos[0]) ||
+             (x === blockPos[0] && y >= blockPos[1] && pathArr[pathArr.length > 1 ? pathArr.length-2 : 0][1] < blockPos[1]) ||
+              (x === blockPos[0] && y <= blockPos[1] && pathArr[pathArr.length > 1 ? pathArr.length-2 : 0][1] > blockPos[1]) ) {
+              continue;
+          }
+      }
+
+      pathArr.push([x, y]);
+  }
+
+  return pathArr[pathArr.length-1].reverse();
+}
+