Scala作业7-数据结构(集合)

1、编写一段代码，将a设置为一个n个随机整数的数组，要求随机数介于0和n之间。

以下是一个示例代码，用于生成一个包含 n 个随机整数的数组：

import scala.util.Random

def generateRandomArray(n: Int): Array[Int] = {
  val random = new Random()
  val array = new Array[Int](n)
  for (i <- 0 until n) {
    array(i) = random.nextInt(n)
  }
  array
}

val n = 10 // 替换为你想要的数组长度
val a = generateRandomArray(n)
println(a.mkString(", "))

在上述代码中，我们定义了一个 generateRandomArray 函数，它接受一个整数参数 n，并返回一个包含 n 个随机整数的数组。我们使用 scala.util.Random 类来生成随机数，并使用循环填充数组的每个元素。

你可以将代码中的 n 替换为你想要的数组长度，然后运行代码，将生成的随机数组打印出来。请注意，生成的随机数介于 0 和 n-1 之间，因为 nextInt 方法生成的是一个小于 n 的随机整数。

2. 编写一个循环，将整数数组中相邻的元素置换。比如Array(1, 2, 3, 4, 5)置换后为Array(2, 1, 4, 3, 5)

以下是一个示例代码，用于将整数数组中相邻的元素进行置换：

def swapAdjacentElements(arr: Array[Int]): Array[Int] = {
  for (i <- 0 until arr.length by 2) {
    if (i + 1 < arr.length) {
      val temp = arr(i)
      arr(i) = arr(i + 1)
      arr(i + 1) = temp
    }
  }
  arr
}

val array = Array(1, 2, 3, 4, 5)
val result = swapAdjacentElements(array)
println(result.mkString(", "))

在上述代码中，我们定义了一个 swapAdjacentElements 函数，它接受一个整数数组作为参数，并将相邻的元素进行置换。我们使用循环来遍历数组，通过交换相邻元素的值来实现置换。

在每次循环中，我们检查当前索引 i 和 i+1 是否在数组范围内，然后交换这两个位置上的元素的值。注意，我们使用一个临时变量 temp 来暂存要交换的元素值。

你可以将示例代码中的 array 替换为你想要操作的整数数组，然后运行代码，将置换后的数组打印出来。对于输入的示例数组 [1, 2, 3, 4, 5]，置换后的结果将是 [2, 1, 4, 3, 5]。

3. 给定一个整数数组，产出一个新的数组，包含原数组中的所有正值，以原有顺序排列，之后的元素是所有零或负值，以原有顺序排列。

以下是一个示例代码，用于根据给定的整数数组生成一个新的数组，其中包含原数组中的所有正值，后跟所有零或负值，保持原有顺序：

def separatePositiveAndNonPositive(arr: Array[Int]): Array[Int] = {
  val positive = arr.filter(_ > 0)
  val nonPositive = arr.filter(_ <= 0)
  positive ++ nonPositive
}

val array = Array(2, -1, 0, 4, -3, 6, -5)
val result = separatePositiveAndNonPositive(array)
println(result.mkString(", "))

在上述代码中，我们定义了一个 separatePositiveAndNonPositive 函数，它接受一个整数数组作为参数，并生成一个新的数组，其中包含原数组中的所有正值，后跟所有零或负值。

我们使用 filter 方法来筛选出正值和非正值（包括零和负值）两部分数组。然后，我们使用 ++ 操作符将两个数组连接起来，生成最终的结果数组。

你可以将示例代码中的 array 替换为你想要操作的整数数组，然后运行代码，将生成的新数组打印出来。例如，对于输入的示例数组 [2, -1, 0, 4, -3, 6, -5]，生成的新数组将是 [2, 4, 6, -1, 0, -3, -5]。

4、设置一个映射，其中包含你想要的一些装备，以及它们的价格。然后根据这个映射构建另一个新映射，采用同一组键，但是价格上打9折。

以下是一个示例代码，用于根据给定的装备映射构建一个新的映射，其中包含同一组键，但价格打9折：

val equipmentMap = Map(
  "sword" -> 100,
  "shield" -> 200,
  "armor" -> 500,
  "helmet" -> 150
)

val discountedMap = equipmentMap.mapValues(_ * 0.9)

println(discountedMap)

在上述代码中，我们定义了一个 equipmentMap 映射，其中包含一些装备和对应的价格。然后，我们使用 mapValues 方法对映射中的值进行转换，将每个价格乘以0.9，即打9折。这将生成一个新的映射 discountedMap。

最后，我们将新的映射打印出来，可以看到新映射中的价格已经打了9折。

输出结果类似于：

Map(sword -> 90.0, shield -> 180.0, armor -> 450.0, helmet -> 135.0)

可以看到，新的映射中的价格是原来价格的90%。

5、编写一个函数 minmax(values:Array[Int]), 返回数组中最小值和最大值的对偶

以下是一个示例代码，用于编写一个名为 minmax 的函数，该函数接受一个整数数组作为参数，并返回数组中最小值和最大值的对偶（Tuple2）：

def minmax(values: Array[Int]): (Int, Int) = {
  val minValue = values.min
  val maxValue = values.max
  (minValue, maxValue)
}

val array = Array(5, 2, 8, 1, 9)
val result = minmax(array)
println(result)

在上述代码中，我们定义了一个 minmax 函数，它接受一个整数数组作为参数，并使用数组的 min 方法和 max 方法分别获取最小值和最大值。然后，我们使用 (minValue, maxValue) 创建一个对偶（Tuple2），其中最小值是对偶的第一个元素，最大值是对偶的第二个元素。

你可以将示例代码中的 array 替换为你想要操作的整数数组，然后运行代码，将最小值和最大值的对偶打印出来。例如，对于输入的示例数组 [5, 2, 8, 1, 9]，输出结果将是 (1, 9)。

6、编写一个函数，从一个整型链表中去除所有的零值。

以下是一个示例代码，用于编写一个函数 removeZeros，该函数从一个整型链表中去除所有的零值：

class ListNode(var value: Int, var next: ListNode = null)

def removeZeros(head: ListNode): ListNode = {
  var current = head
  var prev: ListNode = null

  while (current != null) {
    if (current.value == 0) {
      if (prev != null) {
        prev.next = current.next
      } else {
        head = current.next
      }
    } else {
      prev = current
    }
    current = current.next
  }

  head
}

// 测试代码
val node1 = new ListNode(0)
val node2 = new ListNode(1)
val node3 = new ListNode(0)
val node4 = new ListNode(2)

node1.next = node2
node2.next = node3
node3.next = node4

val result = removeZeros(node1)

var current = result
while (current != null) {
  println(current.value)
  current = current.next
}

在上述代码中，我们首先定义了一个 ListNode 类，表示链表的节点。然后，我们编写了 removeZeros 函数，它接受一个链表的头节点作为参数，并返回去除了所有零值的链表。

在函数中，我们使用了两个指针 current 和 prev，通过遍历链表来去除零值节点。如果当前节点的值为零，我们将其从链表中移除；否则，我们将 prev 指针指向当前节点，继续遍历下一个节点。

在测试代码中，我们创建了一个包含零值的链表，并调用 removeZeros 函数进行去零操作。最后，我们打印出去除零值后的链表中的节点值。

注意：这里的链表是使用自定义的 ListNode 类来表示的，你可以根据实际情况修改链表的数据结构和节点定义。

7、编写一个函数，接受一个字符串的集合，以及一个从字符串到整数值的映射。返回整形的集合，其值为能和集合中某个字符串相对应的映射的值。举例来说，给定Array(“Tom”,”Fred”,”Harry”)和Map(“Tom”->3,”Dick”->4,”Harry”->5)，返回Array(3,5)。提示：用flatMap将get返回的Option值组合在一起。

以下是一个示例代码，用于编写一个函数 getMappedValues，该函数接受一个字符串的集合和一个字符串到整数值的映射，并返回能和集合中某个字符串相对应的映射的值的整数集合：

def getMappedValues(strings: Seq[String], mapping: Map[String, Int]): Seq[Int] = {
  strings.flatMap(mapping.get)
}

val strings = Seq("Tom", "Fred", "Harry")
val mapping = Map("Tom" -> 3, "Dick" -> 4, "Harry" -> 5)

val result = getMappedValues(strings, mapping)
println(result)

在上述代码中，我们定义了一个 getMappedValues 函数，它接受一个字符串的集合 strings 和一个字符串到整数值的映射 mapping。我们使用 flatMap 方法对集合中的每个字符串进行映射查找操作，将查找结果组合成一个整数集合。

在测试代码中，我们创建了一个字符串集合和一个映射，然后调用 getMappedValues 函数进行映射值的获取。最后，我们打印出返回的整数集合。

根据示例数据，输入的字符串集合为 [“Tom”, “Fred”, “Harry”]，映射为 {“Tom”->3, “Dick”->4, “Harry”->5}。函数返回的整数集合将是 [3, 5]，即能和集合中的字符串相对应的映射的值。

8、实现一个函数，作用与mkStirng相同，提示：使用reduceLeft实现试试

以下是一个使用 reduceLeft 实现的函数，具有与 mkString 相同的功能：

def customMkString(seq: Seq[String], separator: String): String = {
  seq.reduceLeft((acc, str) => acc + separator + str)
}

val strings = Seq("Hello", "World", "Scala")
val separator = "-"

val result = customMkString(strings, separator)
println(result)

在上述代码中，我们定义了一个 customMkString 函数，它接受一个字符串的序列 seq 和一个分隔符 separator，使用 reduceLeft 方法将序列中的字符串按顺序拼接起来。

在 reduceLeft 的操作函数中，我们将累积值 acc 和当前字符串 str 以分隔符分隔开，并将结果作为下一次迭代的累积值。这样，最终得到的累积值即为序列中所有字符串按顺序拼接而成的字符串。

在测试代码中，我们创建了一个字符串序列 strings 和一个分隔符 -，然后调用 customMkString 函数进行字符串拼接。最后，我们打印出结果字符串。

根据示例数据，输入的字符串序列为 [“Hello”, “World”, “Scala”]，分隔符为 “-”。函数返回的结果将是 “Hello-World-Scala”，即字符串序列中的字符串按顺序用分隔符连接起来的结果。

9、给定整型列表lst，(lst :\ ListInt)(_ :: )得到什么? (ListInt /: lst)( :+ _)又得到什么？如何修改他们中的一个，以对原列表进行反向排列?

给定整型列表 lst，(lst :\ List[Int]())(_ :: _) 表达式将返回原列表 lst 的逆序。

具体解释如下：

• (lst :\ List[Int]()) 表示对列表 lst 进行右折叠操作，初始累积值为一个空列表 List[Int]()。
• (_ :: _) 表示对每个元素进行操作，将元素添加到累积列表的头部。

因此，(lst :\ List[Int]())(_ :: _) 的结果将是原列表 lst 的逆序。

相反，(List[Int]() /: lst)(_ :+ _) 表达式将返回原列表 lst 的正序。

具体解释如下：

• (List[Int]() /: lst) 表示对列表 lst 进行左折叠操作，初始累积值为一个空列表 List[Int]()。
• (_ :+ _) 表示对每个元素进行操作，将元素追加到累积列表的尾部。

因此，(List[Int]() /: lst)(_ :+ _) 的结果将是原列表 lst 的正序。

如果要对原列表进行反向排列，可以修改其中一个表达式。例如，可以修改 (lst :\ List[Int]())(_ :: _) 为 (List[Int]() /: lst)(_ :+ _)，或者反之。这样就可以得到原列表的反向排列结果。

10、编写一个函数，将Double数组转换成二维数组。传入列数作为参数。距离来说，传入Array(1,2,3,4,5,6)和3列，返回Array(Array(1,2,3), Array(4,5,6))。

以下是一个示例代码，用于编写一个函数 convertTo2DArray，该函数将一个 Double 数组转换为二维数组，传入列数作为参数：

def convertTo2DArray(arr: Array[Double], columns: Int): Array[Array[Double]] = {
  val rows = math.ceil(arr.length.toDouble / columns).toInt
  val result = Array.ofDim[Double](rows, columns)

  for (i <- 0 until arr.length) {
    val row = i / columns
    val col = i % columns
    result(row)(col) = arr(i)
  }

  result
}

val arr = Array(1, 2, 3, 4, 5, 6).map(_.toDouble)
val columns = 3

val result = convertTo2DArray(arr, columns)
result.foreach(row => println(row.mkString(", ")))

在上述代码中，我们定义了一个 convertTo2DArray 函数，它接受一个 Double 数组 arr 和一个列数 columns，并返回一个二维数组。

我们首先计算出需要的行数 rows，通过将数组长度除以列数并向上取整得到。然后，我们使用 Array.ofDim[Double](rows, columns) 创建一个具有指定行数和列数的二维数组。

接下来，我们使用循环遍历原始数组中的每个元素，并计算它在二维数组中的行和列。然后，我们将该元素赋值给二维数组对应位置上的元素。

最后，我们打印出转换后的二维数组，每行元素以逗号分隔。

根据示例数据，输入的 Double 数组为 [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]，列数为 3。函数返回的二维数组将是 [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]。