【scala】练习题

import scala.collection.mutable.ArrayBuffer

object Test_day01 {


  def main(args: Array[String]): Unit = {

    //    for循环（1-20）
    //1、请写出for循环，i 表示循环的变量，Range生成0-20的数字，请循环打印出0-19这些数字。
    //    for (i<- Range(0,21)){
    //      breakable{
    //        if (i==20)break()
    //        println(i)
    //      }
    //    }

    //2、请写出for循环，i 表示循环的变量，Range生成0-20的数字，请循环打印出0-20内的奇数。
    //    for (i<- Range(0,21) if i%2==1)println(i)

    //3、请写出for循环，i 表示循环的变量，Range生成0-20的数字，请循环打印出0-20内的偶数不包括20。
    //    for (i<- Range(0,20)){
    //      if (i%2==0)
    //        breakable{
    //          if (i==20) break()
    //          println(i)
    //        }
    //    }

    //4、请写出for循环，i 表示循环的变量，Range生成0-20的数字，请循环打印出0-20这些数字。
    //    for (i<- Range(0,21)){
    //      println(i)
    //    }

    //5、请写出for循环，i 表示循环的变量，Range生成0-20的数字，请循环打印出0-20内的偶数包括20。
    //        for (i<- Range(0,21)){
    //          if (i%2==0)
    //          println(i)
    //        }

    //6、请写出for循环，i 表示循环的变量，until方式生成0-20的数字，请循环打印出0-19这些数字。
    //    for (i<- 0 until 21){
    //      breakable{
    //        if (i==20)break()
    //        println(i)
    //      }
    //    }

    //7、请写出for循环，i 表示循环的变量，until方式生成0-20的数字，请循环打印出0-20中的奇数。
    //    for(i<- 0 until 21){
    //      if (i%2==1)println(i)
    //    }

    //8、请写出for循环，i 表示循环的变量，until方式生成0-20的数字，请循环打印出0-20内的偶数。
    //    for (i<- 0 until 20){
    //      if (i%2==0)println(i)
    //    }

    //9、请使用嵌套for循环打印出3行3列的内容全为0的矩阵
    //    for (i<- 1 to 3; j<- 1 to 3){
    //      print(0)
    //      if (j==3)println()
    //    }

    //10、请使用嵌套for循环打印出5行6列内容全为*的矩阵
    //    for (i<- 1 to 3; j<- 1 to 3){
    //      print("*")
    //     if (j==3)println()
    //    }

    //11、请使用嵌套for循环打印出九九乘法表
    //    for (i<- 1 to 9; j<- 1 to i){
    //      print(i + "*" + j + "=" + i*j + "  ")
    //      if (i==j)println()
    //    }

    //12、请使用for循环，i 表示循环的变量，使用to 生成0-10的数字,在for表达式中使用守卫当i=5时不打印
    //    for (i<- 0 to 10 if i!=5){
    //      println(i)
    //    }

    //13、请使用for循环，i 表示循环的变量，使用to 生成0-10的数字,在for表达式中使用守卫当i为偶数时打印
    //    for (i<- 0 to 10 if i%2==0)println(i)

    //14、请使用for循环，i 表示循环的变量，使用to 生成0-10的数字,在for表达式中使用守卫当i为奇数时打印
    //    for (i<- 0 to 10 if i%2==1)println(i)

    //15、请使用for循环，i 表示循环的变量，使用to 生成0-10的数字，使用yield把生成的数字变成之前的5倍
    //    println(
    //      for (i<- 0 to 10)yield i*5
    //    )

    //16、请使用for循环，i 表示循环的变量，使用to 生成0-10的数字，使用yield把生成的数字在之前的基础上减一
    //    println(
    //      for(i<- 0 to 10)yield i-1
    //    )

    //17、请使用for循环，i 表示循环的变量，使用to 生成0-10的数字，使用yield把生成的数字在之前的基础上加一
    //    println(
    //      for(i<- 0 to 10)yield i+1
    //    )

    //18、请使用for循环，i 表示循环的变量，使用to 生成0-10的数字，使用yield把生成的数字在之前的基础每个偶数变成之前的2倍
    //        println(
    //          for(i<- 0 to 10 if %2==0)yield i*2
    //        )

    //19、请使用for循环，i 表示循环的变量，使用to 生成0-10的数字，使用yield把生成的数字在之前的基础每个奇数变成之前的5倍
    //        println(
    //          for(i<- 0 to 10 if %2==1)yield i*5
    //        )

    //20、请使用while循环，i 表示循环的变量，打印出0-10的数字
//    var i = 0
//    while (i<=10){
//      println(i)
//      i = i+1
//    }



    //方法（21-30）
    //以下10道题目需要倒入两个包
    //import scala.io.StdIn
    //import scala.util.control.Breaks
    //21. 编写一个方法method1，输入分数之后能够打印出不及格（小于60分）、及格（60-80）、良好（80-90）、优秀（大于90）
    def method1(score: Int): Unit = {
      if (score < 60) println("不及格")
      if (score >= 60 && score < 80) println("及格")
      if (score >= 80 && score < 90) println("及格")
      if (score >= 90) println("优秀")
    }
//    method1(60)

//22. 编写一个方法method2，输入名字，判断该名字是否为laowang，如果是返回true，如果不是返回false（不使用return）
    def method2(name:String): Boolean = {
      if (name.equals("laowang")) true
      else  false
    }
//   println( method2("laowang"))
//   println( method2("laowang1"))

//23. 编写一个方法method3，要求能够输入一个大于0的数字参数，能够打印1到该数字范围内的所有数。（2种方式）
    def method3(num:Int): Unit = {
  //1.
    if (num>0){
      for(i<- 1 to num)println(i)
    }
  //2.
      for(i<- 1 to num if num>0)println(i)
    }
//    method3(5)

//24. 编写一个方法method4，要求能够输入一个大于0的数字参数，能够打印1到该数字范围内的所有偶数。
  def method4(num:Int): Unit = {
    for(i<- 1 to num  if i%2==0)println(i)
  }
//    method4(10)

//25. 编写一个方法method5，要求能够输入一个大于0的数字参数，能够打印1到该数字范围内的所有奇数，并且该奇数不能被5整除。
  def method5(num:Int): Unit = {
    for(i<- 1 to num if i>0 if i%5!=0)println(i)
  }
//    method5(11)

//26. 编写一个方法method6，要求可以输入任意多个参数(数字类型)，将每个参数乘以100后放入数组并返回该数组。
//如：2, 4, 6 返回 Array(200, 400, 600)。
  def method6(num:Int*): ArrayBuffer[Int] = {
    var arr = new ArrayBuffer[Int]()
    for(i<- num ){
      arr+=i*100
    }
    arr
  }
//    println(method6(1,2,3,4))

//27. 编写一个方法method7，要求输入一个数字，如果数字大于150则抛出异常，并捕获该异常，捕获异常后打印The number is greater than 150。
//提示：throw new Exception("The number is greater than 150")

    def method7(num:Int): Unit = {
      if (num>150)throw new Exception("The number is greater than 150")
//      try {
//        num
//      } catch {
//        case num>150 =>println("The number is greater than 150")
//      }
    }
//   println(method7(151))

//28. 编写一个方法method8，要求传入两个参数，默认值分别为10,15，返回两个参数的乘积。
    def method8(a:Int=10,b:Int=15): Int=a*b
//    println(method8())

//29. 定义一个名为method9的方法，有三个参数，前两个为数字类型，最后一个参数为f1函数（该函数类型参数接受两个数字类型参数，返回值也是数字类型），该method9方法返回值为数字类型。定义一个函数f1两个参数分别为x,y都为数字类型，执行返回结果是两个参数的和
    var function = (a:Int,b: Int) => a+b
    def method9(x:Int,y:Int,f1:(Int,Int)=>Int): Int={
      f1(x,y)
  }
//    println(method9(10,20,function))

//30. 编写一个方法method10，要求有两个参数，两个参数都为大于0的数字，要求能够打印1到第一个参数数字范围内的所有数，在打印过程中遇到与第二个参数相乘大于200就停止。
    def method10(a:Int,b:Int): Unit = {
      for (i<- 1 to a if a>0 if b>0 if i*b<=200){
        println(i)
      }
    }
//    method10(10,40)

//数组（31-40）
//31、定义一个数组arr1内容为1-10
     var arr1 = ArrayBuffer(1,2,3,4,5,6,7,8,9,10)

//32、使用filter过滤器,过滤出来偶数
    var arrA = arr1.filter(_%2==0)
//    for (i<- arrA)println(i)

//33、使用map把arr1数组中每一个元素都取出来放到一个全新数组
    var arr2 = ArrayBuffer[Int]()
    for (i<- arr1){
      arr2 += i
    }
//    for (i<-arr2)println(i)
//34、使用foreach打印出arr1数组中的元素
//    arr1.foreach(num=>println(num))

//35、翻转数组arr1
    arr1.reverse
//    for (i<-arr1.reverse)println(i)

//36、修改数组arr1中下标为0的数据为100
//    arr1(0)=100

//37、删除arr1数组下标为0的数据
//    arr1 -= (arr1(0))

//38、arr1数组从下标2开始,删除3个元素
//    for(i<- 0 to arr1.length-1){
//      if (i>=2 && i<2+3){
//        arr1-=arr1(i)
//      }
//    }

//39、插入数据到arr1数组, 第一个参数是开始的位置,插入50,66,77
//    var arrY = ArrayBuffer[Int]()
//    arrY += 50
//    arrY ++= arr1
//    arrY+=66
//    arrY+=77
//    arr1 = arrY

//40、对arr1数组进行降序排列
    arr1.sorted.reverse

//List列表（41-70）
//41、定义一个列表list1，内容为("a", "b" ,"c","d","e")
    var list1 = List("a", "b" ,"c","d","e")
//    print(list1)

//42、在list1列表开头添加元素t
//    "t"::list1

//43、在列表开头添加指定列表List("m","n")的元素
//    List("m","n"):::list1

//44、在列表list1后添加元素1
//    list1+="1"

//45、将列表的所有元素添加到 StringBuilder
    val sb = new StringBuilder()
//    println(list1.addString(sb))

//46、将列表的所有元素添加到 StringBuilder并指定分隔符为","
//    println(list1.addString(sb,","))

//47、获取列表索引为0的元素
//    println(list1(0))

//48、检测列表中是否包含指定的元素a
//    println(list1.contains("a"))

//49、向list1列表中追加数据"a"
//    list1++=List("a")

//50、去除list1列表的重复元素,并返回新列表
//    println(list1.distinct)

//51、list1丢弃前3个元素，并返回新列表
//    println(list1.drop(3))

//52、list1丢弃最后2个元素，并返回新列表
//    println(list1.dropRight(2))

//53、检测列表list1是否以指定a结尾
//    println(list1.endsWith("a"))

//54、判断是否是以指定a开始的列表list1
//    println(list1.startsWith("a"))

//55、获取list1列表的第一个元素
//    println(list1.head)

//56、在list1中从指定位置 0 开始查找元素d第一次出现的位置
//    println(list1.indexOf("d",0))

//57、list1返回所有元素，除了最后一个
//    println(list1.init)

//58、检测列表list1是否为空
//    println(list1.isEmpty)

//59、返回list1列表最后一个元素
//    println(list1.last)

//60、返回list1所有元素，除了第一个
//    println(list1.tail)

//61、提取列表list1的前2个元素
//    println(list1.take(2))

//62、提取列表list1的后2个元素
//    println(list1.takeRight(2))

    //63、列表list1转换为数组
//    println(list1.toArray)

//64、list1转换为 Seq
//    println(list1.toSeq)

//65、list1转换为 Set
//    println(list1.toSet)

//66、list1列表转换为字符串
//    println(list1.toString())

//67、list1列表反转
//    println(list1.reverse)

//68、list1列表排序
//    println(list1.sorted)

//69、检测list1列表在指定位置1处是否包含指定元素a
//    println(list1.startsWith(Seq("b"),1))

//70、列表list1转换为数组
//    println(list1.toArray)

//元组（71-76）
//71 创建一个元组Y1，内部含有zhangsan   biejing   20  true  四个数据
    var Y1 = ("zhangsan","beijing",20,true)

//72 获取元组Y1内的第二个元素（biejing）
//现有数据如下图
//姓名	zhangsan	lisi	wangwu	zhaoliu
//年龄	20	30	40	50
//性别	1	0	1	0
//    println(Y1._2)

//73 创建一个元组Y2，内部含有(zhangsan ,lisi,wangwu,zhaoliu),(20,30,40,50),(1,0,1,0)  3个数据(每个内部依然是元组)。
    var Y2 = (("zhangsan" ,"lisi","wangwu","zhaoliu"),(20,30,40,50),(1,0,1,0))

//74 获取zhangsan,并输出
//    println(Y2._1._1)

//75 获取lisi 的年龄,并输出
//    println(Y2._2._2)

//76 获取wangwu的性别,并输出
//    println(Y2._3._3)

  }
}