Arrays 如何删除数组中的每个元素？

因此，我在Scala中有一个字符串数组，称为发音数组，如下所示：

["EH1","N", "D", "P", "ER0", "EH1", "N", "TH", "AH0", "S", "IY2", "Z"]

我想写一个if-else语句，它反向读取数组，一旦它找到一个包含数字的字符串，它要么删除后面的所有字符串，要么将前面的所有内容放入一个单独的数组中

因此，对于上面的示例，我希望它停止在“IY2”，然后创建一个只有[“IY2”，“Z”]的新数组，或者删除后面的每个字符串，并保留原始数组，如我所说的[“IY2”，“Z”]。顺便说一句，数字本身不是整数，它是字符串的一部分，数字的范围是0-2

我用if-else反向尝试了for循环，它查找数字0、1、2，但它返回每个带数字的字符串，因此它返回[IY2、AH0、EH1、ER0、EH1]，它不会在找到带数字的第一个字符串时立即停止。如果我找到了阻止字符串的方法，我不知道如何将字符串之前的所有内容放入新数组

for (sounds <- pronunciationArray.reverse) {

  val number0 = sounds.contains("0")

  if (number0 == true) {

    println(sounds)

  } else if (number0 == true){

    println(sounds)

  } else if (number1 == true){

    println(sounds)

  } else {

    -1

  }

}

---

for（听起来我不太清楚您的目标，但是
Array
有一个
span
函数，它根据一个条件将它分成两部分——第一部分是数组的前缀，其中所有内容都满足该条件，第二部分是剩余部分

假设您的条件是字符串包含
2
，而不包含数字（因为我很懒——它可以是任何函数
f:string=>Boolean
）。如果我们反转数组，然后在函数的反方向上拆分，我们会得到：

scala> a.reverse.span(!_.contains("2"))
res5: (Array[String], Array[String]) = (Array(Z),Array(IY2, S, AH0, TH, N, EH1, ER0, P, D, N, EH1))

我们知道第二个数组的第一个元素满足我们的条件，所以我们只需组合结果：

scala> val (start, end) = a.reverse.span(!_.contains("2"))
start: Array[String] = Array(Z)
end: Array[String] = Array(IY2, S, AH0, TH, N, EH1, ER0, P, D, N, EH1)

scala> val result = end.take(1) ++ start.reverse
result: Array[String] = Array(IY2, Z)

所有的反转可能不是最有效的，但却能完成任务。
我不完全清楚您的目标，但是
Array
有一个
span
函数，它根据一个条件将其分成两部分——第一部分是数组的前缀，其中所有内容都满足该条件，第二部分是rEminder

假设您的条件是字符串包含
2
，而不包含数字（因为我很懒——它可以是任何函数
f:string=>Boolean
）。如果我们反转数组，然后在函数的反方向上拆分，我们会得到：

scala> a.reverse.span(!_.contains("2"))
res5: (Array[String], Array[String]) = (Array(Z),Array(IY2, S, AH0, TH, N, EH1, ER0, P, D, N, EH1))

我们知道第二个数组的第一个元素满足我们的条件，所以我们只需组合结果：

scala> val (start, end) = a.reverse.span(!_.contains("2"))
start: Array[String] = Array(Z)
end: Array[String] = Array(IY2, S, AH0, TH, N, EH1, ER0, P, D, N, EH1)

scala> val result = end.take(1) ++ start.reverse
result: Array[String] = Array(IY2, Z)

所有的反向操作可能不是最有效的，但可以完成任务。
您可以使用的算法之一是


从元素具有0、1或2的最后一个位置查找元素的索引
在上述索引处拆分数组
取第一个数组的最后一个元素和整个第二个数组

例如

val pronunciationArray = Array("EH1","N", "D", "P", "ER0", "EH1", "N", "TH", "AH0", "S", "IY2", "Z")

def takeUntil(inputArray: Array[String], condition: String => Boolean): Array[String] = {
  val findIndexFromLast = inputArray.reverse.zipWithIndex.collectFirst {
    case (elem, index) if condition.apply(elem) => index
  }

  findIndexFromLast match { // pattern match to check if there exists element with 0, 1, or 2
    case Some(indexFromLast) =>
      inputArray.splitAt(inputArray.length - indexFromLast) match {
        case (head, tail) => head.last +: tail
      }
    case None => // no element with 0, 1, 2 exists
      inputArray
  }
}

takeUntil(
  inputArray = pronunciationArray,
  condition = elem => elem.contains("0") || elem.contains("1") || elem.contains("2")) //gives [IY2, Z]

使用
.span（谓词）
解决相同问题的另一种方法是
.splitAt（索引）

def takeUntil2(inputArray: Array[String]): Array[String] = {
  inputArray.reverse.span {
    element =>
      !element.contains("0") && !element.contains("1") && !element.contains("2")
  } match {
    case (head, tail) => tail.take(1) ++ head.reverse
  }
}

val result = takeUntil2(inputArray = pronunciationArray)

现在，使用scala方式，您可以扩展
数组
以具有自定义功能，

  implicit class ArrayOps(array: Array[String]) {
    def takeUntil(predicate: String => Boolean): Array[String] = {
      val splitAt = array.reverse.span(predicate.apply)
      splitAt._2.take(1) ++ splitAt._1.reverse
    }
  }

  val res = pronunciationArray
    .takeUntil(predicate = elem => !elem.contains("0") && !elem.contains("1") && !elem.contains("2"))

类似问题：

您可以使用的算法之一是


从元素具有0、1或2的最后一个位置查找元素的索引
在上述索引处拆分数组
取第一个数组的最后一个元素和整个第二个数组

例如

val pronunciationArray = Array("EH1","N", "D", "P", "ER0", "EH1", "N", "TH", "AH0", "S", "IY2", "Z")

def takeUntil(inputArray: Array[String], condition: String => Boolean): Array[String] = {
  val findIndexFromLast = inputArray.reverse.zipWithIndex.collectFirst {
    case (elem, index) if condition.apply(elem) => index
  }

  findIndexFromLast match { // pattern match to check if there exists element with 0, 1, or 2
    case Some(indexFromLast) =>
      inputArray.splitAt(inputArray.length - indexFromLast) match {
        case (head, tail) => head.last +: tail
      }
    case None => // no element with 0, 1, 2 exists
      inputArray
  }
}

takeUntil(
  inputArray = pronunciationArray,
  condition = elem => elem.contains("0") || elem.contains("1") || elem.contains("2")) //gives [IY2, Z]

使用
.span（谓词）
解决相同问题的另一种方法是
.splitAt（索引）

def takeUntil2(inputArray: Array[String]): Array[String] = {
  inputArray.reverse.span {
    element =>
      !element.contains("0") && !element.contains("1") && !element.contains("2")
  } match {
    case (head, tail) => tail.take(1) ++ head.reverse
  }
}

val result = takeUntil2(inputArray = pronunciationArray)

现在，使用scala方式，您可以扩展
数组
以具有自定义功能，

  implicit class ArrayOps(array: Array[String]) {
    def takeUntil(predicate: String => Boolean): Array[String] = {
      val splitAt = array.reverse.span(predicate.apply)
      splitAt._2.take(1) ++ splitAt._1.reverse
    }
  }

  val res = pronunciationArray
    .takeUntil(predicate = elem => !elem.contains("0") && !elem.contains("1") && !elem.contains("2"))

类似问题：

Scala数组提供了一种方法，该方法接受谓词并返回满足谓词的最后一个元素的索引：

val arr = Array("EH1","N", "D", "P", "ER0", "EH1", "N", "TH", "AH0", "S", "IY2", "Z")

val idx = arr.lastIndexWhere(e => e.intersect(Array('0', '1', '2')).size > 0)

然后调用takeRight方法以获得所需的结果

val res = arr.takeRight(arr.size - idx)

Scala数组提供了一种方法，该方法接受谓词并返回满足谓词的最后一个元素的索引：

val arr = Array("EH1","N", "D", "P", "ER0", "EH1", "N", "TH", "AH0", "S", "IY2", "Z")

val idx = arr.lastIndexWhere(e => e.intersect(Array('0', '1', '2')).size > 0)

然后调用takeRight方法以获得所需的结果

val res = arr.takeRight(arr.size - idx)

关于代码的一些观察：if

和else子句没有返回相同的类型（

println（）

返回

Unit

，

-1

是

Int

）。

number1

在测试之前不存在。

number0

针对相同的条件测试两次。

if（number0==true）

与

if（number0）

是一样的，这与

if（sounds.contains（“0”）

是一样的。谢谢，这让我省去了很多头疼的事情。关于你的代码，我有一些观察：

if

和

else

子句没有返回相同的类型（

println（）

返回

单元

，

-1

是一个

整数

）。

number1

在测试之前不存在。

number0

在相同条件下测试两次。

如果（number0==true）

与

如果（number0）

是相同的，这与

如果（声音包含（“0”）是相同的

。谢谢，这让我省去了很多头疼。谢谢，它奏效了。如果你有时间解释比赛结束后会发生什么？谢谢，它奏效了。如果你有时间解释比赛结束后会发生什么？

arr.splitAt（arr.lastinexwhere（u.intersect（“012”）。非空））

一个很好的建议。谢谢。

arr.splitAt（arr.lastIndexWhere（u.intersect（“012”）。非空））

一个很好的建议。谢谢。