scala高階函數練習題

/** 練習題目1
  * 編寫函數values(fun:(Int)=>Int,low:Int,hight:Int)
  *
  * 該函數輸出一個集合，對應給定區間內給定的給定函數的輸入和輸出，R比如values(x=>x*x,-5,5)
  * 應該產出一個對偶集合（-5，25），（-4，16），（-3，9）...（5，25）
  * */

    def values(fun:(Int)=>Int,low:Int,hight:Int):ArrayBuffer[(Int,Int)]={
      var buffer = new ArrayBuffer[(Int,Int)]()
      var arr1 = List[(Int,Int)]()
      for (i <- low to hight){
        arr1 = (i,fun(i))::arr1
        buffer.+=((i,fun(i)))
        //println(buffer.mkString("",",",""))
      }
      buffer
    }
    def pingfang(x:Int): Int ={
      x*x
    }

    //方法轉函數。。。。這兒就使用到了
    var buffer = values(pingfang _,-5,5)
    println(buffer.mkString("",",",""))

/** 練習題目2
  * 如何使用reduceLeft函數得到數組中的最大元素
  * */

      def getReduceLeftMax(array: Array[Int]): Int = {
        var arr1 = Array(2, 3, 5, 7, 2, 9, 1)
        arr1.reduceLeft((a:Int,b:Int)=>if (a>b)a else b)

      }

/** 練習題目3
  * 用to和reduceLeft實現階乘函數，不得使用循環或者遞歸
  * */

    def jiecheng():Int={
      var arr2 = Array(1,2,3,4)
      var res  = arr2.reduceLeft(_ * _)
      res

      //也可以這樣寫
      (1 to 10).reduceLeft(_ * _)
    }
    println(jiecheng)

/** 練習題目3。1
  *
  * 前一個實現需要處理一個特殊的情況，即n<1的情況。如何使用foldLeft來避免這個情況
  * */

    def jiecheng2():Int={
      var arr3 = Array(0,1,2,3,4)
      var res1 = (1 to -10).foldLeft(1)(_ * _)
      res1
    }

/** 練習題目4
  * 編寫函數largest(fun:(Int)=>Int,inputs:Seq[Int]),
  * 輸出在給定輸入序列中給定函數的最大值。
  * 舉例來說，largest(x=>10*x-x*x,1 to 10)應該返回25.不得使用循環或遞歸
  * */

    def largest(fun:(Int)=>Int,inputs:Seq[Int]):Int={
      inputs.map(fun).sortWith(_ > _).head
    }
    println(largest((x:Int)=>x*x,1 to 10))

/**
  * 練習題目5
  * 修改前一個函數，返回最大的輸出對應的輸入。
  * 舉例來說,largestAt(fun:(Int)=>Int,inputs:Seq[Int])應該返回5。不得使用循環或遞歸
  * */

    def largestAt(fun:(Int)=>Int,inputs:Seq[Int]):Int={
      var res = inputs.map((x:Int)=>{(x,fun(x))}).sortWith((a,b)=>{a._2>b._2}).head
      res._1
    }
    println(largestAt((x:Int)=>x*x,1 to 10))

/**練習題目6
  *
  * 重點思考！！！！
  * 每一步都需要仔細的思考@@@
  * 要得到一個序列的對偶很容易，比如：
  * var pairs = (1 to 10) zip (11 to 20)
  * 假定你想要對這個序列做某中操作—比如，給對偶中的值求和，但是你不能直接使用:
  * pairs.map(_ + _)
  * 函數_ + _ 接受兩個Int作爲參數，而不是(Int,Int)對偶。
  * 編寫函數adjustToPair,該函數接受一個類型爲(Int,Int)=>Int的函數作爲參數，
  * 並返回一個等效的, 可以以對偶作爲參數的函數。舉例來說就是:adjustToPair(_ * _)((6,7))應得到42。
  * 然後用這個函數通過map計算出各個對偶的元素之和
  *
  * 柯里化的參數列表
  * */

    //柯里化前
    def adjustToPair1(fun:(Int,Int)=>Int,tup:(Int,Int)):Int={
      fun(tup._1,tup._2)
    }

    //柯里化    注意寫法
    def adjustToPair(fun:(Int,Int)=>Int)(t:(Int,Int)):Int={
      fun(t._1,t._2)
    }

    println(adjustToPair(_ *_)((6,7)))

    var pairs = (1 to 10) zip (11 to 20)
    println(pairs.map(t=>{
      adjustToPair(_ + _)(t._1,t._2)
    }))

/** 練習題目7
  * 在12.8節中，你看到了用於兩組字符串數組的corresponds方法。
  * 做出一個對該方法的調用，讓它幫我們判斷某個字符串數組裏的所有元素的長度是否和某個給定的整數數組相對應
  * */

    val a = Array("ads","df","aadc")
    val b = Array(3,2,4)
    val c = Array(3,2,1)

    println(a.corresponds(b)(_.length == _))
    println(a.corresponds(c)(_.length == _))

/** 練習題目8
  * 題目需求，將a,b經過f1或者f2函數的結果作爲 線性函數的y = k*x的k值，
  * 返回線性函數y=k*x
  * */

   def call(a: Int,b:Int,f1:(Int,Int)=>Int,f2:(Int,Int)=>Int):(Int)=>Int={
      var k = 0
      if (a > 0){
        k = f1(a,b)
      } else{
        k = f2(a,b)
      }
      (x:Int)=>k*x
    }
    println(call(1,2,(a:Int,b:Int)=>a+b,(a:Int,b:Int)=>a*b)(3))