English Study - 5

The EU is trying to jumpstart the peace process: 유럽연합은 그 평화협상에 힘을 불어넣으려 하고 있다.
Her whole demeanor is a facade: 그녀가 하는 모든 행동은 가식이에요.
It was surprising how he could bang out an essay: 그가 에세이를 단숨에 쓸 수 있어서 놀라웠다.
She kept him dangling for a week before making her decision: 그녀는 결정을 내리지 않고 일주일동안 그의 애를 태웠다.
The tank became bogged down in mud: 그 탱크가 진창에 빠지고 말았다.
procrastinator: 질질끄는 사람, 꾸물거리는 사람
curmudgeon: 괴팍한 사람

English Study - 4

To prescribe a course of antibiotics: 일련의 항생제 치료를 처방하다.
You shouldn't tinker with anything unless you know what you are doing: 무엇이든 확실히 모르면 만지려고 해서는 안됩니다.
I worked at a pharmaceutical company in Minneapolis: 저는 미네아폴리스에 있는 한 제약회사에서 일했습니다.
They refused to comply with the UN resolution: 그들은 유엔 결의사항에 따르기를 거부했다.
antimicrobial: 항균성의, 항균제
It's cruel to keep animals in confined spaces: 동물을 사방이 막힌 좁은 공간에 두는 것은 잔인한 짓이다.
They have introduced a new system whereby all employees must undergo regular training: 그들은 (그에따라) 모든 직원들이 반드시 정기적인 교육을 받아야 하는 새로운 시스템을 도입했다.
I felt we were off to greener pastures: 나는 우리가 더 나은 환경으로 나왔다는 기분이 들었다.
Sheep and cows were grazing in the pasture: 양과 소들이 목장에서 풀을 뜯고 있다.
rancher: 대규모 목장 주인

English Study - 3

The administration was tainted with scandal: 그 행정부는 스캔들로 오명을 얻었다.
Your ideas jar with mine: 네 생각은 내 생각과 일치하지 않는다.
She was obviously disoriented and highly upset: 그녀는 분명히 혼란스러워했고 무지 화났었어.
We are in dire need of your help: 우리는 당신의 도움이 절실히 필요합니다.
A bout of work: 한차례의 일
She poked him in the ribs with her elbow: 그녀가 그의 옆구리를 팔꿈치로 쿡 찔렀다.
She prodded him in the ribs to wake him up: 그녀는 그의 잠을 깨우려고 그의 옆구리를 쿡 찔렀다.
She is by no means an inexperienced teacher: 그녀는 결코 경험없는 교사가 아니다.
Peek a boo: 까꿍놀이(어린아이 앞에서 얼굴을 가렸다가 까꿍(Peekaboo!)하면서 얼굴을 보여주며 어르는 것)
The woman is shooing away the flies: 여자가 파리를 쉬이하며 내쫓고 있다.
The team reclaimed the title from their rivals: 그 팀은 경쟁팀에게서 타이틀을 되찾았다.

Countdown Problem

Programming in Haskell의 Chapter. 11 Countdown Problem의 요약

- Countdown Problem
여러 개의 수들과 목표로 하는 결과값이 주어지면, 주어진 여러 개의 수들로부터 원하는 숫자를 골라 덧셈, 뺄셈, 곱셈, 나눗셈 및 괄호를 써서 식을 만들어, 그 만들어진 식의 계산 결과가 목표로 하는 결과값과 같도록 하는 문제(주어진 숫자들은 많아야 한 번씩만 식에 나타나야 하며, 계산 중간값을 포함한 계산에 쓰이는 모든 수들은 반드시 양의 정수여야 한다.).
예를 들어, 1,3,7,10,25,50로부터 765를 결과값으로 계산하기를 생각해보자. (1 + 50) * (5 - 10) 가 가능한 식의 하나가 될 것이다.

- 문제 풀이

네가지 수치 연산을 나타내는 타입을 다음과 같이 정의한다.
data Op = Add | Sub | Mul | Div

연산을 수행하는 함수 apply를 다음과 같이 정의한다.
apply               :: Op -> Int -> Int -> Int
apply Add x y = x + y
apply Sub x y = x - y
apply Mul x y = x * y
apply Div x y = x `div` y

apply를 적용하기 전에 그 결과가 양의 정수인지 알아보는 함수 valid를 다음과 같이 정의한다.
valid                 :: Op -> Int -> Int -> Bool
valid (Add x y) = x <= y
valid (Sub x y) = x > y
valid (Mul x y) = x /= 1 && y /=1 && x <= y
valid (Div x y) = y /= 1 && x `mod` y == 0

덧셈의 경우 (Add 3 2)와 (Add 2 3)은 결과가 같기 때문에 하나만 계산하면 되고, 곱셈의 경우 x나 y가 1인 경우나 나눗셈의 경우 y가 1인 경우는 1인 값이 없는 경우와 같다. 따라서 이러한 경우는 더이상 계산하지 않고 유효하지 않은 값으로 처리한다.

이제 수식을 나타내는 타입을 아래와 같이 정의한다.
data Expr = Val Int | App Op Expr Expr

이 타입을 써서 식이 주어졌을 때 식의 결과 값을 돌려주는 eval 함수를 정의한다.
eval                   :: Expr -> [Int]
eval (Val n)      = [n | n > 0]
eval (App o l r) = [apply o l r | x <- eval l, y <- eval r, valid o x y]

성공하면 한원소 리스트를 값으로 돌려주고, 실패의 경우는 빈 리스트를 값으로 돌려준다.

이제 가능한 모든 식을 통해 결과를 찾는 함수를 정의해보자.
solutions        :: [Int] -> Int -> [Expr]
solutions ns n = [e | ns <- choices ns, (e, m) <- results ns, m == n]

이 식의 구현은 다음과 같이 생각할 수 있다. 양의 정수가 주어지면 이것으로 0개 이상의 수를 취하여 만들 수 있는 모든 부분 집합을 생성한다(choices). 이 부분 집합에 가능한 모든 계산 식을 적용한다(results ns). 이 계산 식의 값이 결과 값과 같으면 이 계산 식은 답이 된다.

그럼 먼저 choices를 정의해 보자.
이 함수는 주어진 리스트의 부분 집합을 만들고 이를 순서를 바꾸어 가능한 모든 수를 만들어 내면 된다. 부분 집합을 만드는 함수를 subs라 하고 부분 집합의 순서를 바꾸는 함수를 perms라 하면 choices는 아래와 같이 정의 된다.
choices     :: [a] -> [[a]]
choices xs = concat (map perms (subs xs))

subs []       = [[]]
subs (x:xs) = yss ++ map (x:) yss
                     where yss = subs xs

perms          :: [a] -> [[a]]
perms []       = [[]]
perms (x:xs) = concat (map (interleave x) (perms xs))

interleave              :: a -> [a] -> [[a]]
interleave x []       = [[x]]
interleave x (y:ys) = (x:y:ys) : map (y:) (interleave x ys)

식을 생성하는 과정 중에 결과 값이 양의 정수가 아닐 수가 있다. 이 경우에는 바로 유효하지 않은 식으로 처리하면 된다. 이것을 위해 제대로 된 값을 가지는 식과 그 값을 순서쌍으로 묶은 아래의 타입을 정의하자.
type Result = (Expr, Int)

results       :: [Int] -> [Result]
results []   = []
results [n] = [(Val n, n) | n > 0]
results ns  = [res | (ls, rs) <- split ns, lx <- results ls, ry <- results rs, res <- combine lx ry]

-- 하나의 리스트를 두 개의 비어 있지 않은 리스트로 나눈다.
split           :: [a] -> [([a], [a])]
split []       = []
split [_]     = []
split (x:xs) = ([x], xs) : [(x:ls, rs) | (ls, rs) <- split xs]

- 주어진 두 식의 가능한 모든 연산을 적용하여 유효한 식을 돌려준다.
combine                 :: Result -> Result -> [Result]
combine (l,x) (r,y) = [(App o l r, apply o x y) | o <- ops, valid o x y]

ops :: [Op]
ops = [Add, Sub, Mul, Div]

English Study - 2

I could never cram in all that she does in a day: 나 같으면 결코 그녀가 하루만에 하는 그 모든 일을 한꺼번에 다 하지는 못할 것이다.
He keeps putting off going to the dentist: 그는 치과에 가는 일을 계속 미루고 있다.
There's just a vibe in the air right now: 바로 지금 분위기 딱 좋다.
Close your eyes and lay back when you want to sleep: 잠자고 싶을 때는 눈을 감고 긴장을  풀어라.

Water Pouring Problem

Coursera의 Functional Programming in Scala에서 설명한
the Water Pouring Problem의 코드 설명

/**
 * the Water Pouring Problem
 *   정해진 용량의 컵에 물을 따라서 원하는 용량의 물을 가지고 있는 glass 만들기.
 * 예를 들어 4와 7의 용량을 가질 수 있는 두개의 컵을 가지고
 * 6의 용량을 가지도록 하는 방법은?
 */
class Pouring(capacity: Vector[Int]) {
  // States
  type State = Vector[Int]
  val initialState = capacity map (x => 0)
  // Moves
  //   State를 변경한다.
  trait Move {
    def change(state: State): State
  }
  // 컵을 비운다.
  case class Empty(glass: Int) extends Move {
    def change(state: State) = state updated (glass, 0)
  }
  // 컵을 채운다.
  case class Fill(glass: Int) extends Move {
    def change(state: State) = state updated (glass, capacity(glass))
  }
  // 다른 컵에 따른다.
  case class Pour(from: Int, to: Int) extends Move {
    def change(state: State) = {
      val amount = state(from) min (capacity(to) - state(to)) // 넘치지 않도록 하기위한 양
      state updated (from, state(from) - amount) updated (to, state(to) + amount)
    }
  }
  val glasses = 0 until capacity.length
  // 옮겨갈 수 있는 상태들
  // 예를 들어 아래와 같이 할 경우
  //   val problem = new Pouring(Vector(4, 7))
  //   problem.moves
  // 결과는 아래와 같이 된다.
  //   Vector(Empty(0), Empty(1), Fill(0), Fill(1), Pour(0,1), Pour(1,0))
  val moves =
    (for (g <- glasses) yield Empty(g)) ++
    (for (g <- glasses) yield Fill(g)) ++
      (for (from <- glasses; to <- glasses if from != to) yield Pour(from, to))
  // Paths: sequences of moves
  // history: 최신 move가 앞에 오는 list.
  class Path(history: List[Move], val endState: State) {
    def extend(move: Move) = new Path(move :: history, move change endState)
    // move를 순서대로 보여준 후 --> state 변경에 따른 마지막 state 출력
    override def toString = (history.reverse mkString " ") + " --> " + endState
  }
  val initialPath = new Path(Nil, initialState)
  // explored를 통해 이미 방문한 state는 제거한다.
  def from(paths: Set[Path], explored: Set[State]): Stream[Set[Path]] =
    if (paths.isEmpty) Stream.empty
    else {
      val more = for {
        path <- paths
        next <- moves map path.extend
        if !(explored contains next.endState)
      } yield next
      paths #:: from(more, explored ++ (more map (_.endState)))
    }
  val pathSets = from(Set(initialPath), Set(initialState))
  // 예를들어
  //   val problem = new Pouring(Vector(4, 7))
  //   problem.solution(6)
  // 결과는
  //   Fill(1) Pour(1,0) Empty(0) Pour(1,0) Fill(1) Pour(1,0) --> Vector(4, 6)
  // state의 변화를 적어보면
  //   (0, 7) -> (4, 3) -> (0, 3) -> (3, 0) -> (3, 7) -> (4, 6)
  def solution(target: Int): Stream[Path] =
    for {
      pathSet <- pathSets
      path <- pathSet
      if path.endState contains target
    } yield path
}

English Study - 1

A quirky sense of humour: 별난 유머 감각
To put it in a nutshell, we're bankrupt: 간단 명료하게 말하면, 우린 파산했어.
upholster a room: 실내를 장식하다.
He exerted all his authority to make them accept the plan: 그는 그들이 그 계획을 받아들이도록 모든 권한을 행사했다.
isometric: 정적 수축의(운동이 몸 전체를 움직이지 않고 근육을 움직이게 하는)
cardiovascular: 심혈관의