Scala作业（2）：控制结构和函数

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

在 Scala 中，你可以编写一个函数来计算给定数字的 signum 值。以下是一个示例函数的实现：

def signum(num: Int): Int = {
  if (num > 0) 1
  else if (num < 0) -1
  else 0
}

// 调用 signum 函数进行测试
println(signum(10))  // 输出：1
println(signum(-5))  // 输出：-1
println(signum(0))   // 输出：0

在上面的代码中，我们定义了一个名为 signum 的函数，它接受一个整数参数 num。在函数体内，我们使用条件语句来判断 num 的正负性，并返回相应的 signum 值。

然后，我们调用 signum 函数进行测试，分别传入正数、负数和零，打印结果。

运行上述代码将输出以下结果：

1
-1
0

这样，你就成功地编写了一个函数来计算给定数字的 signum 值。

2、一个空的块表达式{}的值是什么？类型是什么？

一个空的块表达式 {} 在 Scala 中的值是 Unit，类型为 Unit。

在 Scala 中，Unit 是一个特殊的类型，表示不返回任何有用的值。它类似于其他编程语言中的 void 类型。

一个空的块表达式 {} 不包含任何代码，因此它不会返回任何有意义的值。在 Scala 中，空的块表达式被解释为一个 Unit 值，表示执行了一些操作，但没有返回结果。

你可以使用 Unit 类型来指示某个函数没有返回值，或者在需要执行一些副作用而不关心返回值的情况下使用空的块表达式。

3、针对下列Java循环编写一个Scala版本: for(inti=10;i>=0;i–)System.out.println(i);

下面是将给定的 Java 循环转换为 Scala 版本的代码：

for (i <- 10 to 0 by -1) {
  println(i)
}

在上述代码中，我们使用 for 循环结构来迭代从 10 到 0 的整数，步长为 -1。在每次迭代中，我们打印出当前的 i 值。

在 Scala 中，使用 for 循环可以更加简洁地实现迭代，无需显式地声明和更新循环变量。通过指定迭代的范围和步长，我们可以在 for 循环中直接访问迭代的值。

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

下面是一个编写过程 countdown(n: Int)，用于打印从 n 到 0 的数字的示例代码：

def countdown(n: Int): Unit = {
  for (i <- n to 0 by -1) {
    println(i)
  }
}

// 调用 countdown 过程进行测试
countdown(10)

在上面的代码中，我们定义了一个过程 countdown，它接受一个整数参数 n。在过程体内，我们使用 for 循环来从 n 开始，以步长 -1 迭代到 0。在每次迭代中，我们打印出当前的数字 i。

然后，我们调用 countdown 过程进行测试，传入参数 10。这将打印从 10 到 0 的数字。

运行上述代码将输出以下结果：

10
9
8
7
6
5
4
3
2
1
0

这样，你就成功地编写了一个过程，用于打印从给定数字 n 到 0 的数字。

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

以下是一个使用 for 循环计算字符串中所有字母的 Unicode 代码乘积的示例代码：

val str = "Hello"
var product: Long = 1L

for (c <- str) {
  product *= c.toLong
}

println("Product: " + product)

在上面的代码中，我们定义了一个字符串 str，并初始化一个变量 product 为 1L，表示乘积的初始值。

然后，我们使用 for 循环遍历字符串中的每个字符，通过 c.toLong 将字符转换为其对应的 Unicode 代码，并将结果与 product 相乘，更新 product 的值。

最后，我们打印出计算得到的乘积值。

运行上述代码将输出以下结果：

Product: 9415087488

这样，你就成功地使用 for 循环计算了字符串中所有字母的 Unicode 代码的乘积。

以下是使用 StringOps 的 foreach 方法来解决前一个练习问题的示例代码：

val str = "Hello"
var product: Long = 1L

str.foreach { c =>
  product *= c.toLong
}

println("Product: " + product)

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

在上面的代码中，我们使用 StringOps 类型的 foreach 方法来遍历字符串中的每个字符。在每次迭代中，我们将字符转换为其对应的 Unicode 代码，并将结果与 product 相乘，更新 product 的值。

最后，我们打印出计算得到的乘积值。

运行上述代码将输出以下结果：

Product: 9415087488

这样，你就成功地使用 StringOps 的 foreach 方法解决了前一个练习的问题，计算了字符串中所有字母的 Unicode 代码的乘积。

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

以下是一个编写函数 product(s: String)，用于计算字符串中所有字母的 Unicode 代码乘积的示例代码：

def product(s: String): Long = {
  s.foldLeft(1L) { (acc, c) =>
    acc * c.toLong
  }
}

// 调用 product 函数进行测试
val str = "Hello"
val result = product(str)
println("Product: " + result)

在上面的代码中，我们定义了一个函数 product，它接受一个字符串参数 s。在函数体内，我们使用 foldLeft 方法来遍历字符串中的每个字符，并将初始值设置为 1L。在每次迭代中，我们将当前字符的 Unicode 代码与累积值相乘，得到新的累积值。

最后，我们返回计算得到的最终累积值。

然后，我们调用 product 函数进行测试，传入字符串 “Hello”，并将结果打印出来。

运行上述代码将输出以下结果：

Product: 9415087488

这样，你就成功地编写了一个函数，用于计算字符串中所有字母的 Unicode 代码的乘积。

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

以下是将前面练习中的函数 product 改写为递归函数的示例代码：

def product(s: String): Long = {
  if (s.isEmpty) {
    1L
  } else {
    s.head.toLong * product(s.tail)
  }
}

// 调用 product 函数进行测试
val str = "Hello"
val result = product(str)
println("Product: " + result)

在上面的代码中，我们将函数 product 改写为递归函数。在递归函数中，我们首先检查字符串是否为空。如果为空，则返回初始值 1L。否则，我们使用 s.head 获取字符串的首字符，并将其转换为对应的 Unicode 代码。然后，我们将其与递归调用 product(s.tail) 的结果相乘，得到新的累积值。

通过递归调用，我们可以逐步处理字符串的每个字符，直到字符串为空。

最后，我们调用递归函数 product 进行测试，并将结果打印出来。

运行上述代码将输出以下结果：

Product: 9415087488

这样，你就成功地将函数 product 改写为递归函数，实现了计算字符串中所有字母的 Unicode 代码的乘积。

9、编写函数计算,其中n是整数，使用如下的递归定义:  = x*,如果n是正数的话  = 1  = 1/,如果n是负数的话 不得使用return语句

根据你提供的递归定义，我假设你的意思是计算 x 的 n 次幂。以下是根据这个定义编写的递归函数 power 的示例代码：

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

// 调用 power 函数进行测试
val x = 2.0
val n = 3
val result = power(x, n)
println(s"$x 的 $n 次幂: $result")

在上面的代码中，我们定义了一个递归函数 power，它接受两个参数 x 和 n。根据你的定义，我们使用条件语句进行判断：

• 如果 n 大于 0，则返回 x 乘以 power(x, n - 1)，即 x 的 n 次幂。
• 如果 n 小于 0，则返回 1 除以 power(x, -n)，即 x 的 -n 次幂的倒数。
• 如果 n 等于 0，则返回 1，任何数的 0 次幂均为 1。

然后，我们调用 power 函数进行测试，计算 2.0 的 3 次幂，并将结果打印出来。

运行上述代码将输出以下结果：

2.0 的 3 次幂: 8.0

这样，你就成功地编写了一个函数，根据给定的递归定义计算 x 的 n 次幂。注意，在这个递归函数中，我们没有使用 return 语句，而是使用递归调用来实现计算。