scala高阶函数练习

1.编写函数values(fun:(Int)=>Int,low:Int,hight:Int)该函数输出一个集合，对应给定区间内给定的给定函数的输入和输出比如values(x=>x*x,-5,5)应该产出一个对偶集合（-5，25）（-4，16）（-3，9)…（5，25）

package scala

import scala.collection.mutable.ListBuffer

/** 练习题目1
  * 编写函数values(fun:(Int)=>Int,low:Int,hight:Int)
  * 该函数输出一个集合，对应给定区间内给定的给定函数的输入和输出
  * 比如values(x=>x*x,-5,5)
  * 应该产出一个对偶集合（-5，25），（-4，16），（-3，9）...（5，25）
  * */
object gaijie1 {
  def values(fun:(Int)=>Int,low:Int,high:Int):ListBuffer[(Int,Int)]={
    var list = new ListBuffer[(Int,Int)]
    for (i<- low to -1) list.append((i,i*i))
    for (i<- 1 to high) list.append((i,i*i))
    list
  }
  def main(args: Array[String]): Unit = {
    values(x=>x*x ,-5,5).foreach(print)
  }
}

2.如何用reduceLeft得到数组中的最大元素

package scala
//如何用reduceLeft得到数组中的最大元素?
object gaojie2 {
  def main(args: Array[String]): Unit = {
    val arr = (1 to 20).toArray
    //遍历数组拿两个元素出来比较每次返回大的元素直到全部遍历完
    println(arr.reduceLeft((a,b)=>if (a>b) a else b))
  }
}

3.用to和reduceLeft实现阶乘函数,不得使用循环或递归

package scala
//用to和reduceLeft实现阶乘函数,不得使用循环或递归
object gaojie3 {
  def main(args: Array[String]): Unit = {
    def jiechen(a:Int):Int= if (a>=0)(1 to a).reduce(_*_) else (1 to -a).reduce(_*_)*math.pow(-1,-a).toInt
    println(jiechen(5))
    println(jiechen(-5))
  }
}

4.编写函数largest(fun:(Int)=>Int,inputs:Seq[Int]),输出在给定输入序列中给定函数的最大值,举例来说:largest(x=>10x-xx,1 to 10)应该返回25,不得使用循环或递归

package scala
/** 练习题目4
  * 编写函数largest(fun:(Int)=>Int,inputs:Seq[Int]),
  * 输出在给定输入序列中给定函数的最大值。
  * 举例来说，largest(x=>10*x-x*x,1 to 10)应该返回25.不得使用循环或递归
  * */
object gaojie4 {
  def largest(f:(Int)=>Int,inputs:Seq[Int]):Int = inputs.map(x=>f(x)).max
  def main(args: Array[String]): Unit = {
    println(largest(x=>10*x-x*x,1 to 10))
  }
}

5.修改前一个函数,返回最大的输出对应的输入,举例来说,largestAt(fun:(Int)=>Int,inputs:Seq[Int])应该返回5

package scala
//修改前一个函数，返回最大的输出对应的输入。
//举例来说,largestAt(fun:(Int)=>Int,inputs:Seq[Int])应该返回5不得使用循环或递归
object gaojie5 {
  def largest(f:(Int)=>Int,inputs:Seq[Int]):Int = inputs.reduce((a,b)=>if (f(a)>f(b)) a else b)
  def main(args: Array[String]): Unit = {
    println(largest(x=>10*x-x*x,1 to 10))
  }
}

6.对一个Tuple2[Int,Int]类型的数组将2元组元素求和返回一个新数组

package scala
object gaojie6 {
  //原函数
//  def adjustToPair(f:Tuple2[Int,Int]=>Int,a:Tuple2[Int,Int]):Int= f(a._1,a._2)
  //柯里化后函数
  def adjustToPair(f:Tuple2[Int,Int]=>Int)(a:Tuple2[Int,Int]):Int= f(a._1,a._2)
  //元组元素相乘返回一个数
  def f1(t: Tuple2[Int,Int]): Int = t._1*t._2
  //元组元素相加返回一个数
  def f2(t: Tuple2[Int,Int]): Int = t._1+t._2
  def main(args: Array[String]): Unit = {
    //压缩成2元组
    var pairs = (1 to 10) zip (11 to 20)
    //打印测试数据
    println(adjustToPair(f1)((6,7)))
    //打印各元组的和
    pairs.map(x=>adjustToPair(f2)(x)).foreach(println)
  }
}

//更简单的做法
def main(args: Array[String]): Unit = {
  ((1 to 10) zip (11 to 20)).map(x=>x._1+x._2).foreach(println)
}

7.做出一个对corresponds方法的调用,让它帮我们判断某个字符串数组里的元素的长度是否和某个给定的整数数组的元素相对应

package scala
/*
* 做出一个对corresponds方法的调用，让它帮我们判断某个字符串数组里的所有元素的长度
* 是否和某个给定的整数数组相对应
*/
object gaojie7 {
  def main(args: Array[String]): Unit = {
    val arr1 = Array("abc","love","you")
    val arr2 = Array(3,4,3)
    val arr3 = Array(3,5,4)
    println(arr1.corresponds(arr2)(_.length==_)) //true
    println(arr1.corresponds(arr3)(_.length==_)) //false
  }
}

8.将a,b经过f1或者f2函数的结果作为 线性函数的y = k * x的k值,返回线性函数y=k * x

package scala
/*
* 将a,b经过f1或者f2函数的结果作为 线性函数的y = k*x的k值，
* 返回线性函数y=k*x
*/
object gaojie8 {
  def f1(a:Int,b:Int):Int = a+b
  def f2(a:Int,b:Int):Int = a*b
  def trans(f:(Int,Int)=>Int,a:Int,b:Int,x:Int):Int = f(a,b)*x
  def main(args: Array[String]): Unit = {
    println(trans(f1,1,5,5))//1+5=6 6*5 =30
    println(trans(f2,1,5,5))//1*5*5=25
  }
}