Scala 趣题 12

package pzs

object Pz012 extends App {
  case class RomanNumeral(symbol: String, value: Int)
  implicit object RomanOrdering extends Ordering[RomanNumeral] {
    def compare(a: RomanNumeral, b: RomanNumeral) = a.value compare b.value
  }

  import collection.immutable.SortedSet
  val numerals = SortedSet(RomanNumeral("M", 1000), 
      RomanNumeral("C", 100), RomanNumeral("X", 10), 
      RomanNumeral("I", 1), RomanNumeral("D", 500), 
      RomanNumeral("L", 50), RomanNumeral("V", 5))

  println("Roman numeral symbols for 1 5 10 50 100 500 1000:")
  for (num <- numerals; sym = num.symbol) { print(s"${sym} ") }
  println()
  numerals map { _.symbol } foreach { sym => print(s"${sym} ") }
}

解释：

SortedSet中的元素，本来就是有顺序的。RomanNumeral的排序规则是按它的value的大小，字符串的排序规则是按照字典顺序

numerals map { _.symbol } // 已经是一个字符串的有序集合了

Since RomanNumerals are ordered by their values, iterating over the sorted set of numerals will return them in that order and result in the representations being printed according to the value.

Mapping the numerals to their symbols will result in a sorted set of Strings which, naturally enough, will be ordered lexicographically. Iterating over them will thus return them in that order.

时间： 2024-10-13 02:34:53

Scala 趣题 12的相关文章

Scala 趣题 17 隐式参数和偏函数

输出是多少? implicit val z1 = 2 def addTo(n: Int) = { def add(x: Int)(y: Int)(implicit z: Int) = x + y + z add(n) _ } val addTo1 = addTo(1) println( addTo1(2)) 原题为 implicit val z1 = 2 def addTo(n: Int) = { def add(x: Int)(y: Int)(im

Scala 趣题 20

package pzs object Pz020 extends App { var x = 0 def counter = { x += 1; x } def add(a: Int)(b: Int) = a + b val adder1 = add(counter)(_) val adder2 = add(counter) _ println("x = " + x) println(adder1(10)) println("x = "

Scala 趣题 22 函数重写，位置参数，参数名

class C { def sum(x: Int = 1, y: Int = 2): Int = x + y } class D extends C { override def sum(y: Int = 3, x: Int = 4): Int = super.sum(x, y) } val d: D = new D val c: C = d c.sum(x = 0) d.sum(x = 0) Explanation Scala uses the

Scala 趣题 4

A { foo: Int = (+ foo + + ) } B A { : Int = (+ + + ) } C B { = (+ + + ) } C Explanation Notice that bar is a val that is overridden in C. The Scala compiler will only initialize vals once, so since bar will be initialized in C it is not initi

Scala 趣题 5 The missing list

回忆下Scala的集合框架, 可能有助于理解下面的题目两个sum的结果一样吗? sumSizes(collections: [[_]]): Int = sumSizes(((, ), (, ))) sumSizes(((, ), (, ))) Explanation Even though collections.map would appear to map an iterable to another "nice" iterable, since the Collections

Scala 趣题 21 x.type ?

class X val x = new X val y = x: x.type object Overload { def foo(arg: Any) = 1 def foo(arg: x.type) = 2 } println(Overload.foo(x)) println(Overload.foo(y: y.type)) Explanation If the method Overload.foo(x) is invoked, then over

Scala 趣题 16 return 语句

value = ? def value: Int = { def one(x: Int): Int = { return x; 1} val two = (x: Int) => { return x; 2 } 1 + one(2) + two(3) } println(value) 解释有点复杂 Explanation Scala does not complain about unreachable code, therefore the code

Scala 趣题 14 当自己调自己的时候

真是无奇不有, 下面的两个println语句哪个抛空指针,那个输出8 ? val s1: String = s1 println(s1.length) val s2: String = s2 + s2 println(s2.length) 解释: String类型默认被初始化成nulll null引用出现在字符串的位置按照语言规范默认被转化成字符串"null" Explanation The definitions of the values s1 and s2 are

Scala 趣题 18 偏函数对默认参数的影响

下面程序结果会是什么? package pzs object Pz018 extends App { def invert(v3: Int)(v2: Int = 2, v1: Int = 1) { println(v1 + ", " + v2 + ", " + v3); } def invert3 = invert(3) _ invert3(v1 = 2) invert3(v1 = 2, v2 = 1) } 解释 eta展开,丢失了默认参