2021년 1월 12일 복기

HA5를 복기 해보려고 한다.

어찌저찌 풀었지만

조금 어려운 감이 없지 않아 있다.

지난번에도 앞의건 살짝 참조를 했는데

function test5(arr) {
  let newArr = [];
  arr.map(function(el){ /// map을 통하여서 el를 순회한다. 1번째 arr 제거 
    let obj = {};
    el.reduce(function(acc , val){ /// reduce를 통하여서 property를 순회 2번째 arr 제거
      obj[val[0]] = val[1] // 객체로 만들어준다.
    },0)
    newArr.push(obj); // 새로 담아준다. 왜??
  })
  let sortArr = newArr.sort(function(a,b){
    if(a.age > b.age) {
      return 1
    } if(a.age <b.age) {
      return -1
    }
  });
  console.log(sortArr)
  let nameArr =[];
  for(let i=0; i <sortArr.length; i++) {
    let firstname = sortArr[i].firstName;
    let lastname = sortArr[i].lastName;
    if(firstname && lastname) {
      nameArr.push(firstname +' ' +lastname)
    }
    if(!lastname) {
      nameArr.push(firstname);
    }
    if(!firstname) {
      nameArr.push(lastname);
    }
  }
  return nameArr;
}

일단 이렇게 풀었다. 배열을 객체로 담아주는게 넘 어려웠다. 다시 풀어보려고 한다.

참고 사이트

https://medium.com/@soyoung823/pre-test-3f8de7dd69a0

function test5(arr) {
  let namelist = [];
  let myObj = {};
  for(let i = 0 ; i<arr.length; i++){
    let personal = createdArr(arr[i]); //['firstName', 'Joe','age', 42,'gender', 'male',last, Mary]
    let obj = createdObj(personal); //let obj = {42: Joe} 
    Object.assign(myObj, obj); //하나로 합치기 {} + {42: Joe}
  }// {36: Mary Jenkins, 40: Mary Jenkins, 42: Kim}
  for(let keys in myObj){
    namelist.push(myObj[keys]); //최종배열안에 결과값 넣어주기
  }
  return namelist;
}
function createdObj(result){
  let obj = {};
  let name = ''; //name => 사람이름을 그냥넣으면 상관없이없다, 사람이름 중간에 띄어씌기 전에 뭐가 들어왔는지 기억해야한다
  let alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  let count = 0;
  for(let i = 0; i<result.length; i++){
    if(alpha.indexOf(result[i][0]) !== -1){  //맞다면
      if(name !== ''){ //안에 존재 한다면 
        name += ' ';
      }
      name += result[i];
      count++;
      if(count === 2){
        break;
      }
    }
  }
  for(let i=0; i<result.length; i++){
    if(typeof result[i] === 'number'){ //
          obj[result[i]] = name; //{42: Joe}
        }
  }
  return obj;
}
function createdArr(arr) {
  return arr.reduce(function (result, item) {
    if (Array.isArray(item)) {
      const flattened = createdArr(item);
      return [...result, ...flattened];
    } else {
      return [...result, item];
    }
  }, []);
}

페어분과 하면서 간단하게 풀렸다...

function test5(arr) {
  let newArr = [];
  for(let i=0; i<arr.length ; i++) {
    let newObj ={};
    for(let j=0; j<arr[i].length; j++) {
      newObj[arr[i][j][0]] = arr[i][j][1]
    }
    newArr.push(newObj);
  }
  return newArr;
}

0: {firstName: "Joe", age: 42, gender: "male"}
1: {firstName: "Mary", lastName: "Jenkins", age: 36, gender: "female"}
2: {lastName: "Kim", age: 40, gender: "female"}

간단하게 나온다.

하지만 배열이 여러겹 있는 경우는 안되므로

function createdArr(arr) {
  return arr.reduce(function (result, item) {
    if (Array.isArray(item)) {
      const flattened = createdArr(item);
      return [...result, ...flattened];
    } else {
      return [...result, item];
    }
  }, []);
}

이 경우를 써야한다.

재귀 함수 쓰임 정리

function flattenArr(arr) {
  // TODO: for문을 사용해서 arr[i]에 접근하고
  let newArr =[];
  for(let i =0; i < arr.length; i++) {
    if(Array.isArray(arr[i])) {
      let recursive = flattenArr(arr[i]);
      newArr.push(...recursive)
    }
    else {
      newArr.push(arr[i]);
    }
  }
  return newArr;
}


function flattenArr(arr) {
  return arr.reduce(function (result, item) {
    if (Array.isArray(item)) { // 배열이면 
      const flattened = flattenArr(item);// 
      return [...result,...flattened];
    } else {
      return [...result, item];
    }
  }, []);
}


function flattenArr(arr) {
  // base case
  if (arr.length === 0) {
    return [];
  }

  // recursive case
  const initStr = arr[0];
  const newArr = arr.slice(1);
  if (Array.isArray(head)) { ////// h
    return flattenArr([...initStr, ...newArr]);/// return을 재귀로 하고 
    ///// ...newArr을 spread syntax로 펴준다? ... newArr이 array이므로 하나 펴준다.
  } else {
    return [head].concat(flattenArr(tail));
  }
  

TEST6를 리뷰해보았다.

function test6() {
let count =0;
function fibo(n) {
  if(n<2) return n;
  return fibo(n-1) +fibo(n-2);
}

return function () {
  count++
  return fibo(count-1);
}
}

function test6() {
  let count = 0;
  return function fibonacci(){
    if(count === 0){
      count++;
      return 0;
    }
    else if(count === 1){
      count++;
      return 1;
    }
    else{
      let arr = [];
      for(let i = 0; i<count+1; i++){
        if(i<=1){
          arr[i] = i;
        }
        else{
          arr[i] = arr[i-2]+arr[i-1];
        }
      }
      count++;
      return arr[count-1];
    }
  }
  // TODO: 여기에 코드를 작성합니다.
}

function test7(arr, num) {
  // TODO: 여기에 코드를 작성하세요
  // recursive니까 recursive에 맞는 함수를 작성한 다음에 다시 실행시켜주면 된다.

  // 이거를 처음에 어떻게 접근해야하나요????

  let newArr=[];
  for(let i =0; i < arr.length; i++) {
    if(arr[i].id === num) {
      return arr[i];
    }
    else if(Array.isArray(arr[i].children)) {
      let nextArr = arr[i].children
      newArr = newArr.concat(nextArr);
    }
  }
  if(newArr.length >0) {
    return test7(newArr, num)
  }
  return null;
}

function test7(arr, id) {
  let result = null;
  for(let el of arr){
    if(el.id === id){
      return el;
    }
    else if (Array.isArray(el.children)){
      result = test7(el.children, id);
>       if(result !== null){
>         return result;
>       }
    }
  }
  return result;
  // TODO: 여기에 코드를 작성합니다.
}

기본값을 null로 설정해주고 return 되면 null이 나오니까! 중간에 null을 넣어주는 것보다 초기값에 설정해주는 것이 훨씬 효율적이다.

function test7(arr, id) {
  let initVal = null;
  for(let el of arr){
    if(el.id === id){
      return el;
    }
    else if (Array.isArray(el.children)){
      let recursive = test7(el.children, id);
      if(recursive !== null){
        return recursive;
      }
    }
  }
  return initVal;
}
``