Scala练习题

一、Scala基础

【1】在Scala REPL中，计算3的平方根,然后再对该值求平方。现在，这个结果与3相差多少？

【2】如何检测一个变量是val还是var?

看它的值能否被修改，能修改类型为var，否则为val

【3】Scala允许你用数字去乘一个字符串，去REPL中试一下"crazy"*3。这个操作做什么？在Scaladoc中如何找到这个操作?

从代码可以推断,*是"crazy"这个字符串所具有的方法，但是Java中的String可没这个方法，很明显。此方法在StringOps中

【4】10 max 2的含义是什么？max方法定义在哪个类中？

可以看出,此方法返回两个数字中较大的那个。此方法Java中不存在，所以在RichInt中
【5】用BigInt计算2的1024次方

【6】在Scala中如何获取字符串“Hello”的首字符和尾字符？

二、控制结构和函数

【1】一个数字如果为正数，则它的signum为1;如果是负数,则signum为-1;如果为0,则signum为0.编写一个函数来计算这个值

var signum1 = (num:Long)=>{
    if(num>0)
      1
    else if(num==0)
      0
    else -1
  }

【2】一个空的块表达式{}的值是什么？类型是什么？
在REPL中就能看出来了

scala> val t = {}
t: Unit = ()
可以看出，它的值是()类型是Unit

【3】针对下列Java循环编写一个Scala版本

Java：
for(int i=10;i>=0;i–-)System.out.println(i);
scala:
for(i<-10.to(0,-1)){
      println(i)
    }

【4】编写一个过程countdown(n:Int)，打印从n到0的数字

var countdown=(x:Int)=> {
      for(i<-x.to(0,-1)) println(i)
    }
    countdown(10)

【5】编写一个for循环,计算字符串中所有字母的Unicode代码（toLong方法）的乘积。举例来说，"Hello"中所有字符串的乘积为9415087488L

var sum:Long = 1
    for(i<-"Hello") sum*=(i.toLong)
    println(sum)

【6】同样是解决前一个练习的问题，请用StringOps的foreach方式解决

var sum:Long = 1
    "Hello".foreach(sum*=_.toLong)
    println(sum)

【7】编写一个函数product(s:String)，计算字符串中所有字母的Unicode代码（toLong方法）的乘积

def product(s:String)={
    var sum:Long = 1
    "Hello".foreach(sum*=_.toLong)
    sum
  }

【8】把7练习中的函数改成递归函数

def product(s:String):Long={
    var sum:Long = 1
    if(s.length!=0)
      s.head.toLong*product(s.substring(1))
    else 1
  }

【9】编写函数计算 ,其中n是整数，使用如下的递归定义:

def product(x:Double,n:Int):Double={
    if(x==0)
      1
    else if(x>0) x*product(x,n-1)
    else x/product(x,-n)
  }

三、数据结构

【1】编写一段代码，将a设置为一个n个随机整数的数组，要求随机数介于0和n之间。

def randomArray(n:Int)={
    val ints: Array[Int] = new Array[Int](n)
    for (i <- 0.to(ints.length-1)) {
      ints(i)=Random.nextInt(n)
    }
    ints
  }
 
  def randomArray(n:Int)={
    for (i <- 0.to(n-1)) yield{
      Random.nextInt(n)
    }
  }

【2】编写一个循环，将整数数组中相邻的元素置换。比如Array(1, 2, 3, 4, 5)置换后为Array(2, 1, 4, 3, 5)

def main(args: Array[String]): Unit = {
    println(swapArray(Array(1, 2, 3, 4, 5)).toList)
  }
  def swapArray(array: Array[Int])={
    var t = 0
    for(i<-1.to(array.length-1,2)){
      t = array(i)
      array(i)=array(i-1)
      array(i-1)=t
    }
    array
  }

【3】给定一个整数数组，产出一个新的数组，包含原数组中的所有正值，以原有顺序排列，之后的元素是所有零或负值，以原有顺序排列。

def main(args: Array[String]): Unit = {
    println(rankSpe(Array(1, 2, 3, -1, 0, 4, -3)).toList)
  }
  def rankSpe(array: Array[Int])={
    val newArray1 = new ArrayBuffer[Int]()
    val newArray2 = new ArrayBuffer[Int]()
    array.foreach(x=>{
      if(x>0)
        newArray1.append(x)
      else newArray2.append(x)
    })
    newArray1++newArray2
  }

【4】创建一个由java.util.TimeZone.getAvailableIDs返回的时区集合，并只显示以America/前缀开头的时区，并且有序。

def main(args: Array[String]): Unit = {
    val strings: Array[String] = TimeZone.getAvailableIDs()
    var tmp: Array[String] =for (elem <- strings if(elem.startsWith("America/"))) yield{
      elem.drop(8)
    }
    val tmp1: Array[String] = tmp.sorted
    println(tmp1.toList)
  }

【5】设置一个映射，其中包含你想要的一些装备，以及它们的价格。然后根据这个映射构建另一个新映射，采用同一组键，但是价格上打9折。

def main(args: Array[String]): Unit = {
    val stringToDouble: Map[String, Double] = Map(("无尽", 1999.0), ("回响", 2000), ("反甲", 1000))
    val map2 = stringToDouble.map(x => (x._1, x._2 * 0.9))
    println(map2)
  }

【6】编写一段WordCount函数，统计传入的字符串中单词的个数

def main(args: Array[String]): Unit = {
    println("i have an apple i have a pen".split(" ")
    .groupBy(x => x).map(x => (x._1, x._2.size)))
  }

【7】重复上一个练习，使统计后的单词有序

println("i have an apple i have a pen".split(" ").groupBy(x => x).map(x => (x._1, x._2.size)).toList.sorted)

【8】重复前一个练习，使用java.util.TreeMap进行实现，并使之适用于Scala API

object Work01 {
  def main(args: Array[String]): Unit = {
    val stringToInt: Map[String, Int] = "i have an apple i have a pen".split(" ").groupBy(x => x).map(x => (x._1, x._2.size))
    val map: util.TreeMap[String, Int] = new util.TreeMap()
    for (elem <- stringToInt) {
      map.put(elem._1, elem._2)
    }
    val strings: util.Set[String] = map.keySet()
    var value: util.Iterator[String] = strings.iterator()
    while (value.hasNext) {
      val str: String = value.next()
      val i: Int = map.get(str)
      println(s"$str:${i}")
    }
  }
}

【9】编写一个函数 minmax(values:Array[Int]), 返回数组中最小值和最大值的对偶

object Work01 {
  def main(args: Array[String]): Unit = {
    val tuple: (Int, Int) = minmax(Array(1, 2, 3, 4, 5))
    println(tuple)
  }
  def minmax(values:Array[Int]) ={
    (values.max,values.min)
  }
}

【10】编写一个函数indexes，给定字符串，产出一个包含所有字符下标的映射。举例来说：indexes(“Mississippi”)应返回一个映射，让’M’对应集{0}，‘i’对应集{1，4，7，10}，依次类推。使用字符到可变集的映射，注意下标的集应该是有序的

object Work01 {
  def main(args: Array[String]): Unit = {
    println(indexes("Mississippi"))

  }
  def indexes(str:String)={
    var t = 0
    str.map(x=>{
      t+=1
      (x,t-1)
    }).groupBy(_._1).map(x=>{
      (x._1,x._2.map(_._2).toList.sorted)
    })
  }
}

【11】编写一个函数，从一个整型链表中去除所有的零值。

object Work01 {
  def main(args: Array[String]): Unit = {
    println(removeAllZero(List(1, 2, 3, 0, 3, 0, 2, 1, 0)))
  }
  def removeAllZero(list: List[Int]) ={
    list.filter(x=>{
      x!=0
    })
  }
}

【12】编写一个函数，接受一个字符串的集合，以及一个从字符串到整数值的映射。返回整形的集合，其值为能和集合中某个字符串相对应的映射的值。举例来说，给定Array(“Tom”,”Fred”,”Harry”)和Map(“Tom”->3,”Dick”->4,”Harry”->5)，返回Array(3,5)。提示：用flatMap将get返回的Option值组合在一起

object Work01 {
  def main(args: Array[String]): Unit = {
    println(fun1(Array("Tom", "Fred", "Harry"), Map("Tom" -> 3, "Dick" -> 4, "Harry" -> 5)).mkString(","))
  }
  def fun1(str:Array[String],map:Map[String,Int]) ={
    str.flatMap(map.get(_))
  }
}

【13】实现一个函数，作用与mkStirng相同，提示：使用reduceLeft实现试试

 def mymkString(set:Iterator[Any],regex:String)={
    set.reduceLeft(_.toString + regex + _.toString)
  }

【14】编写一个函数，将Double数组转换成二维数组。传入列数作为参数。具体来说，传入Array(1,2,3,4,5,6)和3列，返回Array(Array(1,2,3), Array(4,5,6))

def ArrayToDoubleArray(array: Array[Int],n:Int)={
    val ints  = new Array[Int](n)
    var len = 0
    if(array.length%n==0){
      len = array.length/n
    }else len= array.length/n +1
    var result = Array.ofDim[Int](len,n)
    for(i<-0.to(array.length-1)){
      result(i/n)(i%n)=array(i)
    }
    result
  }