arr = np.array([1, 2, 3, 4, 5, 6]) val = 4 indices = np.where(arr < val)[0]报错：TypeError '<' not supported between instances of 'numpy.ndarray'and

这个错误提示告诉我们，在这个语句 `arr < val` 中，不能对 `numpy.ndarray` 类型的数组和 `int` 类型的值进行比较操作。

解决这个问题的方法是，使用 `np.where()` 函数的第一个参数，传入一个布尔型的数组，表示数组中每个元素是否小于 `val`。代码如下：

import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6])
val = 4
indices = np.where(arr < val)[0]

这样，`indices` 变量就会得到一个数组，其中存储的是符合条件的元素的下标。在本例中，`indices` 的值为 `[0 1 2]`，表示数组中第 0、1、2 个元素小于 4。

相关问题

使用import java.util.Arrays，给你一个数组，val arr = Array(49, 38, 65, 97, 76, 13, 27, 101, 34, 119, 1)，请使用归并排序完成排序。

好的，下面是使用归并排序对数组进行排序的代码：

import java.util.Arrays

fun main() {
    val arr = arrayOf(49, 38, 65, 97, 76, 13, 27, 101, 34, 119, 1)
    mergeSort(arr, 0, arr.size - 1)
    println(Arrays.toString(arr))
}

fun mergeSort(arr: Array<Int>, left: Int, right: Int) {
    if (left < right) {
        val mid = (left + right) / 2
        mergeSort(arr, left, mid)
        mergeSort(arr, mid + 1, right)
        merge(arr, left, mid, right)
    }
}

fun merge(arr: Array<Int>, left: Int, mid: Int, right: Int) {
    val temp = Array(right - left + 1) { 0 }
    var i = left // 左序列指针
    var j = mid + 1 // 右序列指针
    var k = 0 // 临时数组指针

    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) {
            temp[k++] = arr[i++]
        } else {
            temp[k++] = arr[j++]
        }
    }

    while (i <= mid) {
        temp[k++] = arr[i++]
    }

    while (j <= right) {
        temp[k++] = arr[j++]
    }

    for (p in temp.indices) {
        arr[left + p] = temp[p]
    }
}

输出结果为：`[1, 13, 27, 34, 38, 49, 65, 76, 97, 101, 119]`，表示排序完成。

已知程序如下，其中op可能是两个数的比较规则，或者计算规则。 def cal(num: Array[Int], op:(Int,Int) => Int) = { } 先要求数组的所有数之和以及求数组的最大值， val arr = cal(Array(1, 2, 3, 4，5,6,7,8), opAdd)。请实现cal函数及对应高阶函数。

可以使用高阶函数来实现cal函数，具体实现如下：

def cal(num: Array[Int], op:(Int,Int) => Int): (Int, Int) = {
  var sum = 0
  var max = num(0)
  for(i <- num.indices) {
    sum = op(sum, num(i))
    max = if(num(i) > max) num(i) else max
  }
  (sum, max)
}

def opAdd(a: Int, b: Int): Int = a + b

其中，cal函数接收一个整型数组和一个函数作为参数，函数类型为(Int, Int) => Int，即接收两个整型参数并返回一个整型结果。在cal函数内部，我们通过循环遍历整型数组，使用op函数对数组元素进行累加并求出最大值，最终返回一个元组，包含数组元素之和和最大值。opAdd函数为具体的操作函数，实现了两个整型数值相加的操作。