프로그래머스 : 완주하지 못한 선수 ( 함수형 프로그래밍 + 지연실행)

문제

1. 일반 코드

function solution(participant, completion) 
{
    participant.sort()
    completion.sort()
   return participant.filter((name,i) =>{
        if(name !== completion[i])
            return true;
    })[0]
 }

2.지연실행 코드

const go = (...list) => reduce((a, f) => f(a), list);

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

const reduce = curry((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 L = {};

// 일정 길이만큼 가져온다. (현재는 사용X)
L.range = function* (l) {
  let i = -1;
  while (++i < l) {
    yield i;
  }
};

// 배열만큼을 순회한다. (현재는 사용X)
L.map = curry(function* (f, iter) {
  for (const a of iter) yield f(a);
});

// 해당 값과 index 값을 배열로 받아온다.
L.arrAndIdx = curry(function* (f, iter) {
  var index = 0;
  for (const a of iter)
    if (f(a)) {
      yield [a, index++];
    }
});

// 함수를 만족하는 filter 값을 가져온다.
L.realFilter = curry(function* (f, iter) {
  for (const a of iter) {
          if (f(a)) {
            yield f(a);
          }
  }
});

//원하는 갯수만큼 지연 값을 가져온다
const take = curry((l, iter) => {
  let res = [];
  for (const a of iter) {
    res.push(a);
    if (res.length == l) return res;
  }
});

function solution(participant, completion) 
{
    participant.sort()
    completion.sort()
    
    return go(
                participant,
                L.arrAndIdx((n) => n),
                L.realFilter((n) => {
                if(n[0] !== completion[n[1]])
                    return n[0];
                 }),
                take(1)
            )[0];
 }

기존배열에서 배열과 idx를 받아온 후(L.arrAndIdx)
filter를 통해 해당 배열 값과 그때 해당하는 인덱스 값이 같이 않는 때의 값(L.realFilter)을
하나 리턴(take(1))한다.

3. 지연코드 수정

객체형태로 처리

const go = (...list) => reduce((a, f) => f(a), list);
const pipe = (...fs) => (a) => go(a, ...fs);
const curry = (f) => (a, ..._) =>
  _.length ? f(a, ..._) : (..._) => f(a, ..._);

const reduce = curry((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 L = {};

// 일정 길이만큼 가져온다. (현재는 사용X)
L.range = function* (l) {
  let i = -1;
  while (++i < l) {
    yield i;
  }
};

// 배열만큼을 순회한다. (현재는 사용X)
L.map = curry(function* (f, iter) {
  for (const a of iter) yield f(a);
});

// 해당 값과 index 값을 객체로 받아온다.
L.arrAndIdx = curry(function* (f, iter) {
  var index = 0;
  for (const a of iter)
    if (f(a)) {
      yield {val : a, idx : index++};
    }
});

// 함수를 만족하는 filter 값을 가져온다.
L.realFilter = curry(function* (f, iter) {
  for (const a of iter) {
          if (f(a)) {
            yield f(a);
          }
  }
});

//원하는 갯수만큼 지연 값을 가져온다
const take = curry((l, iter) => {
  let res = [];
  for (const a of iter) {
    res.push(a);
    if (res.length == l) return res;
  }
});


function solution(participant, completion) 
{
    participant.sort()
    completion.sort()
    
    return go(
                participant,
                L.arrAndIdx((n) => n),
                L.realFilter((n) => {
                if(n.val !== completion[n.idx])
                    return n.val;
                 }),
                take(1)
            )[0];
 }

4. 지연코드 수정 (pipe 추가)

const go = (...list) => reduce((a, f) => f(a), list);
const pipe = (...fs) => (a) => go(a, ...fs);
const curry = (f) => (a, ..._) =>
  _.length ? f(a, ..._) : (..._) => f(a, ..._);

const reduce = curry((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 L = {};

// 일정 길이만큼 가져온다. (현재는 사용X)
L.range = function* (l) {
  let i = -1;
  while (++i < l) {
    yield i;
  }
};

// 배열만큼을 순회한다. (현재는 사용X)
L.map = curry(function* (f, iter) {
  for (const a of iter) yield f(a);
});

// 해당 값과 index 값을 객체로 받아온다.
L.arrAndIdx = curry(function* (f, iter) {
  var index = 0;
  for (const a of iter)
    if (f(a)) {
      yield {val : a, idx : index++};
    }
});

// 함수를 만족하는 filter 값을 가져온다.
L.realFilter = curry(function* (f, iter) {
  for (const a of iter) {
          if (f(a)) {
            yield f(a);
          }
  }
});

//원하는 갯수만큼 지연 값을 가져온다
const take = curry((l, iter) => {
  let res = [];
  for (const a of iter) {
    res.push(a);
    if (res.length == l) return res;
  }
});


function solution(participant, completion) 
{
    participant.sort()
    completion.sort()
    
    const result = pipe(
                        L.arrAndIdx((n) => n),
                        L.realFilter((n) => {
                            if(n.val !== completion[n.idx])
                                return n.val;
                            }),
                        take(1)
                  )
    
    return result(participant)[0];
 }

실행 결과

1. 일반

2. 지연

문제 자체는 별반 차이는 안난다.