과제 진행하기

1. 아직 FP가 익숙하지는 않으니, 기존에 짜던 대로 문제를 해결한다.

2. FP로 문제를 접근하여 해결하자.

함수형 이전

해답

const getTime = (time) => {
  return time
    .split(':')
    .reduce((acc, cur, index) => acc + (!index ? 60 * +cur : +cur), 0);
};

function solution(plans) {
  const result = [];

  const sortedPlans = plans
    .map(([name, time, period]) => [name, getTime(time), +period])
    .sort((a, b) => a[1] - b[1]);

  const stack = [];

  sortedPlans.forEach((plan, index) => {
    let breakTime = index > 0 ? plan[1] - sortedPlans[index - 1][1] : 0;

    while (stack.length) {
      const [nowName, nowTime, nowPeriod] = stack.pop();

      const remainTime = nowPeriod - breakTime;

      if (remainTime <= 0) {
        breakTime -= nowPeriod;
        result.push(nowName);
      } else {
        stack.push([nowName, nowTime, remainTime]);
        break;
      }
    }

    stack.push(plan);
  });

  while (stack.length) {
    const now = stack.pop();
    result.push(now[0]);
  }

  return result;
}

고민

1. while문과 for문이 많이 혼합되어 있다 → 어떻게 함수형으로 제어할 수 있을까?

2. 비즈니스 로직(과제를 진행하는 조건)과 일반적인 유틸 함수로 기능할 수 있는 로직(예컨대 이러한 비슷한 로직으로 반복하는 것을 스택으로 처리하는 로직)을 분리할 수 있을까?

3. 함수형으로 풀이를 할 때, 조건문으로 인한 블록 스코프의 참조로 인해 함수형 풀이가 쉽지 않다. 어떻게 해결할 수 있을까?

FP로 풀이

1. 재귀를 사용하여 for과 while를 사용하지 않고 해결

2. stack과 result를 반환하는 콜백 역시 closure를 이용함으로써 유연하게 받을 수 있도록 처리

3. flag를 함수로 넘겨주는 방식을 통해 스코프를 flat하게 가져가면서도 원하는 데이터를 변수에 담을 수 있었다.

const getTime = (time) => {
  return time
    .split(':')
    .reduce((acc, cur, index) => acc + (!index ? 60 * +cur : +cur), 0);
};

const getSortedPlans = (plans) => {
  return plans
    .map(([name, time, period]) => [name, getTime(time), +period])
    .sort((a, b) => a[1] - b[1]);
};

const isNoLength = (arr) => !arr.length;

const getArrangedProgress = (
  result, // 결과
  stack, // 진행 미룬 과제들
  breakTime, // 자투리시간
  getNextResult,
  getNextStack
) => {
  if (isNoLength(stack)) {
    return { result, stack };
  }

  const lastItem = stack.at(-1);

  const [nowName, nowTime, nowPeriod] = lastItem;

  const remainTime = nowPeriod - breakTime; // 미룬 과제에서의 시간 - 현재 뜨는 시간

  const nextResult = getNextResult(result, remainTime <= 0, nowName);
  const nextStack = getNextStack(stack, remainTime > 0, [
    nowName,
    nowTime,
    remainTime,
  ]);

  if (remainTime > 0) {
    return { breakTime: breakTime - nowPeriod, result, stack: nextStack };
  }

  return getArrangedProgress(
    nextResult,
    nextStack,
    breakTime - nowPeriod,
    getNextResult,
    getNextStack
  );
};

const getNextResult = (result, flag, name) => {
  return flag ? [...result, name] : result;
};

const getNextStack = (stack, flag, item) => {
  return stack.slice(0, -1).concat(flag ? [item] : []);
};

const progress = (
  sortedPlans,
  index,
  result,
  stack,
  getNextResult,
  getNextStack
) => {
  if (index === sortedPlans.length) {
    return result.concat([...stack].reverse().map((v) => v[0]));
  }

  const breakTime =
    index > 0 ? sortedPlans[index][1] - sortedPlans[index - 1][1] : 0;

  const { result: nextResult, stack: nextStack } = getArrangedProgress(
    result,
    stack,
    breakTime,
    getNextResult,
    getNextStack
  );

  return progress(
    sortedPlans,
    index + 1,
    nextResult,
    [...nextStack, sortedPlans[index]],
    getNextResult,
    getNextStack
  );
};

function solution(plans) {
  return progress(
    getSortedPlans(plans),
    0,
    [],
    [],
    getNextResult,
    getNextStack
  );
}

차후 고민

• 매개변수로 받는 파라미터가 굉장히 많아 헷갈린다. 어떻게 이를 효과적으로 처리할 수 있을까

• Monad, Currying, Pipe, Composition과 같은 함수형 프로그래밍 로직을 어떻게 추가적으로 곁들일 수 있을까

느낀 점

1. 반복문이 얼마나 간편했으며, 또 달콤했는지를 깨달은 한편, 결국 반복문을 사용한다는 것은 스코프의 depth 역시 깊어지게 만든다. 이는 계속하여 상위 스코프에 등록된 변수를 참조할 가능성을 높이므로 side effect를 만들 가능성을 높인다는 것을 느꼈다.

2. 하지만 함수형을 통해 재귀함수로 구현한다는 것은 하여금 쉬운 문제를 어렵게 다가간다는 느낌을 받았다. 만약 함수 내에서 오직 반복문만 실행시키고 return시키는 정도는 용납할 수 있지 않을까?

3. 간단한 로직이면 함수형으로도 충분히할 수 있을 것 같다. 하지만 로직이 복잡해질 수록, 이를 구현하기까지의 과정이 굉장히 고통스럽다. 실제로 스택을 이중으로 반복문 처리했던 로직을 재귀함수 내에서 재귀를 돌리는 것 자체가 내게 굉장한 부하를 주었다.

진짜진짜최종

const L = {};

const curry =
  (f) =>
  (a, ..._) =>
    _.length ? f(a, ..._) : (...__) => f(a, ...__);

const reduce = curry(function reduce(f, acc, iter) {
  if (!iter) {
    iter = acc[Symbol.iterator]();
    acc = iter.next().value;
  }

  for (const a of iter) {
    acc = f(acc, a);
  }

  return acc;
});

const go = (...args) => reduce((acc, f) => f(acc), args);
const pipe =
  (f, ...fs) =>
  (...as) =>
    go(f(...as), ...fs);

const sortedArray = curry(function sortedArr(compareCallback, iter) {
  return [...iter].sort(compareCallback);
});

L.map = curry(function* map(f, iter) {
  for (const a of iter) {
    yield f(a);
  }
});

const take = curry((len, iter) => {
  const res = [];
  for (const a of iter) {
    res.push(a);

    if (res.length === len) return res;
  }

  return res;
});

const takeAll = take(Infinity);

const map = curry(pipe(L.map, takeAll));

function getTime(time) {
  return time
    .split(':')
    .reduce((acc, cur, idx) => (idx ? acc + +cur : acc + +cur * 60), 0);
}

const format = (plan) => [plan[0], getTime(plan[1]), Number(plan[2])];

function progress(prevResult, plan) {
  const { stack, result, lastAt } = prevResult;

  const nextResult = {
    stack: [...stack],
    result: [...result],
    lastAt,
  };

  while (nextResult.stack.length) {
    const prev = nextResult.stack.pop();

    const [prevSubject, prevStartAt, prevRemainTime] = prev;

    const diff = plan[1] - nextResult.lastAt;

    if (prevRemainTime <= diff) {
      nextResult.result.push(prevSubject);
      nextResult.lastAt += prevRemainTime;
    } else {
      nextResult.stack.push([prevSubject, prevStartAt, prevRemainTime - diff]);
      break;
    }
  }

  return {
    ...nextResult,
    stack: [...nextResult.stack, plan],
    lastAt: plan[1],
  };
}

function finishAssignment(plans) {
  return reduce(
    progress,
    {
      stack: [],
      result: [],
      lastAt: 0,
    },
    plans
  );
}

const reverseMap = curry(function reverse(f, iter) {
  const arr = [...iter];
  const len = arr.length;

  const res = [];

  for (let i = len - 1; i >= 0; i -= 1) {
    res.push(arr[i]);
  }

  return go(res, map(f));
});

const filterStack = pipe(
  reverseMap((v) => v[0]),
  takeAll
);

const merge = curry((iter1, iter2) => {
  const res = [];

  for (const a of iter1) {
    res.push(a);
  }

  for (const b of iter2) {
    res.push(b);
  }

  return res;
});

function solution(plans) {
  const { stack, result } = go(
    plans,
    map(format),
    sortedArray((a, b) => a[1] - b[1]),
    finishAssignment
  );
    
  console.log({ stack, result })

  return merge(result, filterStack(stack));
}