scala-problem41-50

P46 Truth tables for logical expressions
요구
코드

P47 Truth tables for logical expressions 2
요구
코드

P49 Gray code
요구
코드

P50 Huffman code
요구
코드

* 성명 * 이 시 리 즈 는 다음 과 같 습 니 다.http://aperiodic.net/phil/scala/s-99/ 대부분의 내용 이 원문 과 같 아 일부 자신의 코드 를 넣 었 다.권리 침해 가 있 으 면 즉시 본인 에 게 연락 하 세 요.본인 은 즉시 관련 내용 을 삭제 할 것 이다.
P46 (**) Truth tables for logical expressions.
요구 하 다.
Define functions and, or, nand, nor, xor, impl, and equ (for logical equivalence) which return true or false according to the result of their respective operations; e.g. and(A, B) is true if and only if both A and B are true.

scala> and(true, true)
res0: Boolean = true

scala> xor(true. true)
res1: Boolean = false

A logical expression in two variables can then be written as an function of two variables, e.g: (a: Boolean, b: Boolean) => and(or(a, b), nand(a, b))
Now, write a function called table2 which prints the truth table of a given logical expression in two variables.

scala> table2((a: Boolean, b: Boolean) => and(a, or(a, b)))
A     B     result
true  true  true
true  false true
false true  false
false false false

코드
요구 에 따라 호출 방법, 예 를 들 어 4. 567914. 는 도구 방법 이 아 닌 도구 방법 과 같 기 때문에 이 를 object 의 방법 으로 정의 하면 된다.

object S99Logic {

    def and(a: Boolean, b: Boolean): Boolean = (a, b) match {
        case (true, true) => true
        case _            => false
    }

    def or(a: Boolean, b: Boolean): Boolean = (a, b) match {
        case (false, false) => false
        case _              => true
    }

    def not(a: Boolean): Boolean = !a

    def nand(a: Boolean, b: Boolean): Boolean = not(and(a, b))

    def nor(a: Boolean, b: Boolean): Boolean = not(or(a, b))

    def equ(a: Boolean, b: Boolean): Boolean = or(and(a, b), and(not(a), not(b)))

    def xor(a: Boolean, b: Boolean): Boolean = not(equ(a, b))

    def impl(a: Boolean, b: Boolean): Boolean = or(not(a), b)

    def table2(f: (Boolean, Boolean) => Boolean) {
        println("A B result")
        for (
            a <- List(true, false);
            b <- List(true, false)
        ) {
            printf("%-5s %-5s %-5s
", a, b, f(a, b))
        }
    }

}

P47 (*) Truth tables for logical expressions (2).
요구 하 다.
Continue problem P46 by redefining and, or, etc as operators. (i.e. make them methods of a new class with an implicit conversion from Boolean.) not will have to be left as a object method.

scala> table2((a: Boolean, b: Boolean) => a and (a or not(b)))
A     B     result
true  true  true
true  false true
false true  false
false false false

코드
요구 에 따라 불 값 은 식 을 이 유형의 대상 으로 바 꾸 어 접두사 조작 자 를 지원 합 니 다.

class S99Logic(a: Boolean) {
    import S99Logic._

    def and(b: Boolean): Boolean = (a, b) match {
        case (true, true) => true
        case _            => false
    }
    def or(b: Boolean): Boolean = (a, b) match {
        case (true, _) => true
        case (_, true) => true
        case _         => false
    }

    def equ(b: Boolean): Boolean = (a and b) or (not(a) and not(b))
    def xor(b: Boolean): Boolean = not(a equ b)
    def nor(b: Boolean): Boolean = not(a or b)
    def nand(b: Boolean): Boolean = not(a and b)
    def impl(b: Boolean): Boolean = not(a) or b
}
object S99Logic {
    implicit def boolean2S99Logic(a: Boolean): S99Logic = new S99Logic(a)
    //...
}

P49 (**) Gray code.
요구 하 다.
그레이 코드
An n-bit Gray code is a sequence of n-bit strings constructed according to certain rules. For example,

n = 1: C(1) = ("0", "1").
n = 2: C(2) = ("00", "01", "11", "10").
n = 3: C(3) = ("000", "001", "011", "010", "110", "111", "101", "100").

Find out the construction rules and write a function to generate Gray codes.

scala> gray(3)
res0 List[String] = List(000, 001, 011, 010, 110, 111, 101, 100)

See if you can use memoization to make the function more efficient.
코드
P50 (*) Huffman code.
호 프 만 코드
요구 하 다.
First of all, consult a good book on discrete mathematics or algorithms for a detailed description of Huffman codes! We suppose a set of symbols with their frequencies, given as a list of (S, F) Tuples. E.g. ((“a”, 45), (“b”, 13), (“c”, 12), (“d”, 16), (“e”, 9), (“f”, 5)). Our objective is to construct a list of (S, C) Tuples, where C is the Huffman code word for the symbol S.

scala> huffman(List(("a", 45), ("b", 13), ("c", 12), ("d", 16), ("e", 9), ("f", 5)))
res0: List[String, String] = List((a,0), (b,101), (c,100), (d,111), (e,1101), (f,1100))

코드