Scala实操练习一
1.编写一个函数，输入分数，能够打印不合格（小于60分）、合格（60-80）、良好（80-90）、优秀（大于90）```
package com.dtinone.test1
import scala.io.StdIn
object Test1 {
def main(args: Array[String]): Unit = {
val s = StdIn.readInt()
println(score(s))
}
def score(in: Int): String = {
val result = in match {
case in if 0 to 59 contains in => "不及格"
case in if 60 to 79 contains in => "及格"
case in if 80 to 89 contains in => "良好"
case in if 90 to 100 contains in => "优秀"
case _ => "输入错误"
}
result
}
}
- 编写一个函数，输入名字，判断该名字是否为dtinone，如果是返回true，如果不是返回false（不使用return）
package com.dtinone.test1
import scala.io.StdIn
object Test2 {
def main(args: Array[String]): Unit = {
val s:String=StdIn.readLine()
println(StringRange(s))
}
def StringRange(s: String): Boolean = {
if(s.equals("dtinone")){
true
}
else
false
}
}
- 编写一个函数，要求能够输入一个大于0的数字参数，能够打印1到该数字范围内的所有数。（2种方式）
package com.dtinone.test1
import scala.io.StdIn
object Test3 {
def main(args: Array[String]): Unit = {
val i=StdIn.readInt()
num1(i)
println()
num2(i)
println()
num3(i)
println()
num4(i)
}
//方法1
def num1(i:Int):Unit={
val num=0 to i
for (i<-num){
print(i+",")
}
}
//方法2
def num2(i:Int):Unit={
print(0 to i)
}
//方法3
def num3(i:Int):Unit={
val num=0 to i by 1
for (i<-num){
print(i+",")
}
}
//方法4
/**
* 不包含最后一个数
* @param i
*/
def num4(i: Int):Unit={
val num=0 until i
for(i<-num){
print(i+",")
}
}
}
- 编写一个函数，要求能够输入一个大于0的数字参数，能够打印1到该数字范围内的所有偶数。（2种方式）
package com.dtinone.test1
import scala.io.StdIn
object Test4 {
def main(args: Array[String]): Unit = {
val i=StdIn.readInt()
num1(i)
println()
num2(i)
}
//方法1
def num1(i:Int):Unit={
val num=1 to i
for (i<-num){
if(i%2==0) {
print(i + ",")
}
}
}
//方法2
def num2(i:Int):Unit={
val num=2 to i by 2
for (i<-num){
print(i+",")
}
}
}
- 编写一个函数，要求能够输入一个大于0的数字参数，能够打印1到该数字范围内的所有奇数，并且该奇数不能被3整除。
package com.dtinone.test1
import scala.io.StdIn
object Test5 {
def main(args: Array[String]): Unit = {
val i = StdIn.readInt()
num1(i)
}
def num1(i: Int): Unit = {
val num = 1 to i
for (i <- num) {
if (i % 2 != 0 & i % 3 != 0) {
print(i + ",")
}
}
}
}
- 编写一个函数，要求可以输入任意多个参数(数字类型)，将每个参数乘以100后放入数组并返回该数组。
如：如1, 5, 10 返回 Array(100, 500, 1000)。提示：考虑用for … yield实现
package com.dtinone.test1
import scala.io.StdIn
object Test6 {
def main(args: Array[String]): Unit = {
mul(StdIn.readInt(),StdIn.readInt(),StdIn.readInt(),StdIn.readInt())
}
def mul(nums:Int*)={
var num:Int=0
var array= for(num<-nums)yield num*100
print(array)
}
}
- 编写一个函数，要求输入一个数字，如果数字大于100则抛出异常，并捕获该异常，捕获异常后打印The number is greater than 100。
提示：throw new Exception(“The number is greater than 100”)
package com.dtinone.test1
class NumException(msg:String)extends RuntimeException(msg){
// def this(){
// this("")
// }
}
package com.dtinone.test1
import scala.io.StdIn
object Test7 {
def main(args: Array[String]): Unit = {
val num= StdIn.readInt()
exp(num)
}
def exp(num:Int)={
if(num>100){
throw new NumException("The number is greater than 100")
}else{
println("num"+num)
}
}
}
- 调用一个有多个参数的函数，要求不以函数定义参数的顺序传参。
package com.dtinone.test1
object Test8 {
def main(args: Array[String]): Unit = {
println(sum(15,8,9))
//使用命名参数时参数顺序可以任意写
println(sum(c = 9, b = 8, a = 15))
}
def sum(a:Int,b:Int,c:Int)={
a+b+c
}
}
- 编写一个函数，要求有两个参数，如果不输入参数，这两个参数的默认值分别为10和100，返回两个参数的乘积。
package com.dtinone.test1
object Test9 {
def main(args: Array[String]): Unit = {
//传参时传递值取代默认值
println(sum(2 * 9))
//不传参使用默认值
println(sum())
}
def sum(a:Int=10,b:Int=100)={
a*b
}
}
10.定义一个具有两个参数的函数，第一个和第二个参数都为大于0的数字参数，要求能够打印1到第一个参数数字范围内的所有数，在打印过程中遇到与第二个参数相乘大于100就停止。
要求：用两种方式定义函数，提示：柯里化函数
如：输入20和7，会打印1,2,3,4,5,6,7,8,9,10,11,12,13,14
package com.dtinone.test1
object Test10 {
def main(args: Array[String]): Unit = {
mul(20, 7)
mul2(20)(7)
}
//方法1
def mul(a:Int,b:Int)={
var num=1 to a
var i=0
var numlist=for {i <- num if i * b < 100}yield i
println(numlist)
}
//方法2
def mul2(a:Int)=(b:Int)=>{
var num=1 to a
for(a<-num){
if(a*b<100)
print(a+" ")
}
}
}
11.自己思考写一个利用部分应用函数的例子。
package com.dtinone.test1
object Test11 {
def main(args: Array[String]): Unit = {
//部分应用函数
var s1=sum(_:Int)(_:Int)(_:Int)
var s2=s1(1,2,3)
//部分应用函数
var s3=sum(8)(_:Int)(_:Int)
var s4=s3(1,3)
//部分应用函数
var s5=sum(8)(9)(_:Int)
var s6=s5(1)
println(s2)
println(s4)
println(s6)
}
def sum(a:Int)(b:Int)(c:Int)={
a+b+c
}
}
12.定义一个名为make的函数，有三个参数，前两个为数字类型，
最后一个参数类型为函数（该函数类型参数接受两个数字类型参数，返回值也是数字类型），
该make函数返回值为数字类型。
要求：通过执行make函数能够对前两个参数进行由最后一个函数定义的逻辑执行，并返回结果。
提示：make要能够满足调用者传入的逻辑操作，假设调用make函数，第一个参数为5，第二个参数为10，第三个参数的逻辑是加法操作，
则执行make的返回值应该是15，如果第三个参数的逻辑是乘法操作，则返回50。
package com.dtinone.test1
object Tset12 {
def main(args: Array[String]): Unit = {
println(make(2, 3,f1(_,_)))
}
def make=(a:Int,b:Int,f1:(Int,Int)=>Int)=>{
f1(a,b)
}
def f1:(Int,Int)=>Int=_+_
}