x +: xs     // xs 앞에 x를 포함하는 새로운 벡터를 붙인다.
xs :+ x     // xs 뒤에 x를 포함하는 새로운 벡터를 붙인다.

// Array
val xs = Array(1, 2, 3, 44)
xs map (x => x * 2)
// res0 : Array[Int] = Array(2, 4, 6, 88)

// String
val s = "Hello World"
s filter (c => c.isUpper)
// res1: String = HW

val r: Range = 1 until 5    // 1, 2, 3, 4
val s: Range = 1 to 5     // 1, 2, 3, 4, 5
1 to 10 by 3          // 1, 4, 7, 10
6 to 1 by -2          // 6, 4, 2

val a: Vector[Double] = Vector(1.0, 2.0, 3.0)
val b: Vector[Double] = Vector(3.0, 4.0, 5.0)

def scalarProduct(xs: Vector[Double], ys: Vector[Double]): Double =
  (xs zip ys).map(xy => xy._1 * xy._2).sum

scalarProduct(a, b)

def scalarProduct2(xs: Vector[Double], ys: Vector[Double]): Double =
  (xs zip ys).map{ case (x, y) => x * y }.sum

scalarProduct2(a, b)

{case p1 => e1 ... case pn => en}

// 위와 동일
x => x match { case p1 => e1 ... case pn => en }

def isPrime(n: Int): Boolean = (2 until n) forall (x => (n % x) != 0)

val n = 7
(1 until n) map (i => (1 until i) map (j => (i, j)))

// result
res0: scala.collection.immutable.IndexedSeq[scala.collection.immutable.IndexedSeq[(Int, Int)]] = Vector(Vector(), Vector((2,1)), Vector((3,1), (3,2)), Vector((4,1), (4,2), (4,3)), Vector((5,1), (5,2), (5,3), (5,4)), Vector((6,1), (6,2), (6,3), (6,4), (6,5)))

(xss foldRight Seq[Int]())(_ ++ _)

// equvalently
xss.flatten

// so, 원래식 포함해서 아래와 같이 나타낼 수 있다.
((1 until n) map (i => (1 until i) map (j => (i, j)))).flatten

// 아래의 법칙을 이용하면
xs flatMap f = (xs map f).flatten

// 더 간단해질 수 있다.
(1 until n) flatMap (i => (1 until i) map (j => (i, j)))

// result
res0: scala.collection.immutable.IndexedSeq[(Int, Int)] = Vector((2,1), (3,1), (3,2), (4,1), (4,2), (4,3), (5,1), (5,2), (5,3), (5,4), (6,1), (6,2), (6,3), (6,4), (6,5))

// 두 합이 prime인것만 추려야함, 이전 챕터에서 만든 isPrime 이용
(1 until n) flatMap (i => (1 until i) map (j => (i, j))) filter (pair => isPrime(pair._1 + pair._2))

// result
res0: scala.collection.immutable.IndexedSeq[(Int, Int)] = Vector((2,1), (3,2), (4,1), (4,3), (5,2), (6,1), (6,5))

case class Person(name: String, age: Int)

// 20살 이상인 사람만 가져오고 싶을때
for (p <- persons if p.age > 20) yield p.name

// 아래와 같음
persons filter (p => p.age > 20) map (p = > p.name)

for (s) yield e

for {
  i <- 1 until n
  j <- 1 until i
  if isPrime(i+j)
} yield (i, j)

def scalarProduct(xs: Vector[Double], ys: Vector[Double]): Double =
  (for ((x, y) <- xs zip ys) yield x * y).sum

def queens(n: Int): Set[List[Int]] = {
  def placeQueens(k: Int): Set[List[Int]] =
    if (k == 0) Set(List())
     else
      for {
        queens <- placeQueens(k - 1)
        col <- 0 until n
        if isSafe(col, queens)
      } yield col :: queens

  placeQueens(n)
}

def isSafe(col: Int, queens: List[Int]): Boolean = {
  val row = queens.length
  val queensWithRow = (row -1 to 0 by -1) zip queens
  queensWithRow forall {
    case (r, c) => col != c && math.abs(col - c) != row - r
  }
}

def show(queens: List[Int]) = {
  val lines =
    for (col <- queens)
    yield Vector.fill(queens.length)("* ").updated(col, "X ").mkString
  "\n" + (lines mkString "\n")
}

(queens(8) take 3 map show) mkString "\n"

res0: String =
* * X * * * * *
X * * * * * * *
* * * * * * X *
* * * * X * * *
* * * * * * * X
* X * * * * * *
* * * X * * * *
* * * * * X * *

* * * * * X * *
* * X * * * * *
X * * * * * * *
* * * * * * * X
* * * X * * * *
* X * * * * * *
* * * * * * X *
* * * * X * * *

* * * * X * * *
* X * * * * * *
* * * * * * * X
X * * * * * * *
* * * X * * * *
* * * * * * X *
* * X * * * * *
* * * * * X * *

// key를 이용해 value를 가져올때
capitalOfCountry("andorra")   // exception 발생

// 대신에 get을 사용한다.
capitalOfCountry get "andorra"  // None

trait Option[+A]
case class Some[+A](value: A) extend Option[A]
object None extend Option[Nothing]

def showCapital(country: String) = capitalOfCountry.get(country) match {
  case Some(capital) => capital
  case None => "missing data"
}

// sorted
val fruit = List("apple", "pear", "orange", "pineapple")
fruit.sortWith (_.length < _.length)  // List("pear", "apple", "orange", "pineapple")
fruit.sorted    // List("apple", "orange", "pear", "pineapple")

// groupBy
fruit groupBy (_.head)
// Map(p -> List(pear, pineapple)),
//     a -> List(apple),
//     o -> List(orange))

class Poly(val terms: Map[Int, Double]) {
  def + (other: Poly) = new Poly(terms ++ other.terms)
  override def toString =
    (for ((exp, coeff) <- terms.toList.sorted.reverse) yield coeff+"x^"+exp) mkString " + "
}

val p1 = new Poly(Map(1 -> 2.0, 3 -> 4.0, 5 -> 6.2))
val p2 = new Poly(Map(0 -> 3.0, 3 -> 7.0))
p1 + p2

p1: Poly = 6.2x^5 + 4.0x^3 + 2.0x^1
p2: Poly = 7.0x^3 + 3.0x^0
res0: Poly = 6.2x^5 + 7.0x^3 + 2.0x^1 + 3.0x^0

def + (other: Poly) = new Poly(terms ++ (other.terms map adjust))
def adjust(term: (Int, Double)): (Int, Double) = {
  val (exp, coeff) = term
  terms get exp match {
    case Some(coeff1) => exp -> (coeff + coeff1)
    case None => exp -> coeff
  }
}

p1: Poly = 6.2x^5 + 4.0x^3 + 2.0x^1
p2: Poly = 7.0x^3 + 3.0x^0
res0: Poly = 6.2x^5 + 11.0x^3 + 2.0x^1 + 3.0x^0

class Poly(terms0: Map[Int, Double]) {
  def this(bindings: (Int, Double)*) = this(bindings.toMap)
  val terms = terms0 withDefaultValue 0.0
  def + (other: Poly) = new Poly(terms ++ (other.terms map adjust))
  def adjust(term: (Int, Double)): (Int, Double) = {
    val (exp, coeff) = term
    exp -> (coeff + terms(exp))
  }

  override def toString =
    (for ((exp, coeff) <- terms.toList.sorted.reverse) yield coeff+"x^"+exp) mkString " + "
}

val p1 = new Poly(1 -> 2.0, 3 -> 4.0, 5 -> 6.2)
val p2 = new Poly(0 -> 3.0, 3 -> 7.0)
p1 + p2
p1.terms(8)

def + (other: Poly) =
  new Poly((other.terms foldLeft terms)(addTerm))

def addTerm(terms: Map[Int, Double], term: (Int, Double)): Map[Int, Double] = {
  val (exp, coeff) = term
  terms + (exp -> (coeff + terms(exp)))
}

val mnemonics = Map(
       '2' -> "ABC", '3' -> "DEF", '4' => "GHI", '5' -> "JKL",
       '6' -> "MNO", '7' -> "PQRS", '8' -> "TUV", '9' -> "WXYZ")

val in = Source.fromURL("http://lamp.epfl.ch/files/content/sites/lamp/files/teaching/progfun/linuxwords.txt")
val words = in.getLines.toList filter (word => word forall (chr => chr.isLetter))

val mnem = Map(
  '2' -> "ABC", '3' -> "DEF", '4' -> "GHI", '5' -> "JKL",
  '6' -> "MNO", '7' -> "PQRS", '8' -> "TUV", '9' -> "WXYZ")

val charCode: Map[Char, Char] =
  for ((digit, str) <- mnem; ltr <- str) yield ltr -> digit

/**
 * 파라미터로 들어온 문자열을 charCode로 변경함
 * @param word
 * @return
 */
def wordCode(word: String): String =
  word.toUpperCase map charCode

  wordCode("Java")  // res0: String = 5282

/**
 * A map form digit strings to the words that represent them,
 * e,g. "5282" -> List("Java", "Kata", "Lava", ...)
 * Note: A missing number should map to the empty set, e,g. "11111" -> List()
 */
val wordsForNum: Map[String, Seq[String]] =
  words groupBy wordCode withDefaultValue Seq()

/**
 * Return all ways to encode a number as a list of words
 */
def encode(number: String): Set[List[String]] =
  if (number.isEmpty) Set(List())
  // 1 to number.length는 IndexedReq 타입이므로 Set 타입으로 변경해준다
  else {
    for {
      split <- 1 to number.length
      word <- wordsForNum(number take split)
      rest <- encode(number drop split)
    } yield word :: rest
  }.toSet

encode("7225247386")

def translate(number: String): Set[String] =
  encode(number) map(_ mkString " ")

translate("7225247386")