Scala for/yield语法

我正在学习的书中有一个练习：

编写一个循环，交换整数数组的相邻元素。例如

Array（1,2,3,4,5）

变成

Array（2,1,4,3,5）

。我的解决办法是：

var v=数组（0,1,2,3,4,5,6,7,8,9）
对于生成器中的（i，使用
0直到v.length乘以2
，这是一种
索引eq
。这是您的输入类型，
yield
将为
res
生成相同的集合类型

由于
不可变。IndexedSeq
是不可变的，您不能修改它。因此不允许使用
res（i-1）=a（i）
，它将在i-1处更新项目

因此，一种选择是在继续之前将
res
转换为可变集合

一个通常更可取的选择是在不更新的情况下解决它。这里使用
foldLeft
，它迭代我们的
索引eq
，并建立一个新的、平坦的
数组[Int]

val array = Array(1,2,3,4,5)

val result = (
    for ( i <- 0 until array.length by 2) 
    yield 
        if (i < array.length-1) 
            Array(array(i+1), array(i)) 
        else 
            Array(array(i))
).foldLeft (Array[Int]()) ((a,b) => a ++ b )

val数组=数组（1,2,3,4,5）
val结果=(
对于（i a++b）
在生成器中，使用
0直到v.length乘以2
，这是一种
索引eq
。这是您的输入类型，
yield
将为
res
生成相同的集合类型

由于
不可变。IndexedSeq
是不可变的，您不能修改它。因此不允许使用
res（i-1）=a（i）
，它将在i-1处更新项目

因此，一种选择是在继续之前将
res
转换为可变集合

一个通常更可取的选择是在不更新的情况下解决它。这里使用
foldLeft
，它迭代我们的
索引eq
，并建立一个新的、平坦的
数组[Int]

val array = Array(1,2,3,4,5)

val result = (
    for ( i <- 0 until array.length by 2) 
    yield 
        if (i < array.length-1) 
            Array(array(i+1), array(i)) 
        else 
            Array(array(i))
).foldLeft (Array[Int]()) ((a,b) => a ++ b )

val数组=数组（1,2,3,4,5）
val结果=(
对于（i a++b）
错误是因为
res
是一个不可变序列（向量），无法就地更新。但是，向量确实有一个
更新（index:Int，elem:a）
方法，该方法返回一个带有更新元素的新向量

我不确定练习的作者在想什么-这里使用for/yield似乎有点尴尬，但您可以使用
grouped（）
：

错误是因为
res
是一个不可变的序列（向量），不能就地更新。但是，向量确实有一个
updated（index:Int，elem:a）
方法，该方法返回一个带有更新元素的新向量

我不确定练习的作者在想什么-这里使用for/yield似乎有点尴尬，但您可以使用
grouped（）
：

有一个
滑动
功能，完全满足您的需要：

(for {
  i <- Array(1,2,3,4,5).sliding(2,2)
  j <- i.reverse
} yield j).toArray

（用于{
i有一个
滑动
功能，完全满足您的需要：

(for {
  i <- Array(1,2,3,4,5).sliding(2,2)
  j <- i.reverse
} yield j).toArray

（用于{
我我正在通过Scala为不耐烦的我自己更新我的Scala编码技能。鉴于本书中这一点介绍的概念，我相信作者正在寻找以下内容：

val a = Array(1, 2, 3, 4, 5)
for (i <- 0 until a.length) 
  yield 
    if (i % 2 == 0) 
      if (i == a.length-1) a(i) 
      else a(i+1) 
    else a(i-1)

vala=Array（1,2,3,4,5）
对于（我我正在通过Scala为不耐烦的我自己更新我的Scala编码技能。鉴于本书中这一点介绍的概念，我相信作者正在寻找以下内容：

val a = Array(1, 2, 3, 4, 5)
for (i <- 0 until a.length) 
  yield 
    if (i % 2 == 0) 
      if (i == a.length-1) a(i) 
      else a(i+1) 
    else a(i-1)

vala=Array（1,2,3,4,5）
对于（i而言，这只是一种新的方法：

(for (i<-0 to arr.length-2 by 2) yield Array(arr(i+1), arr(i))).flatten.toArray

（对于（i而言）只是一种新方法：

(for (i<-0 to arr.length-2 by 2) yield Array(arr(i+1), arr(i))).flatten.toArray

（对于（i），以下是我的解决方案：

def swap(a: Array[Int]): Array[Int] = {
    for (elem <- 0 until a.length)
      yield {
        if (elem % 2 == 0) {
          if (elem == a.length - 1) a(elem)
          else a(elem + 1)
        }
        else a(elem - 1)
      }
  }.toArray

def交换（a:Array[Int]）：Array[Int]={
对于（elem以下是我的解决方案：

def swap(a: Array[Int]): Array[Int] = {
    for (elem <- 0 until a.length)
      yield {
        if (elem % 2 == 0) {
          if (elem == a.length - 1) a(elem)
          else a(elem + 1)
        }
        else a(elem - 1)
      }
  }.toArray

def交换（a:Array[Int]）：Array[Int]={
for（elem
var result=for（j
var result=for）（j）错误是因为
res
是一个不可变的序列（向量），不能就地更新。向量确实有一个
更新（索引：Int，elem:a）
方法，它返回一个带有更新元素的新向量。a是一个ArrayBuffer，因此res也会自动成为ArrayBuffer。对吗？不，它不会-试试看！如果你像for（i）那样执行
操作，它会变成
ArrayBuffer（i），错误是因为
res
是一个不可变序列（向量），无法就地更新。向量的
已更新（索引：Int，元素：A）
方法，但是，它返回一个带有更新元素的新向量。a是一个ArrayBuffer，因此也会自动将res变成ArrayBuffer。对吗？不，它不会-试试看！如果你对（i或一个单行程序）执行类似的操作，它会变成一个
ArrayBuffer
，而不是对循环：
数组（1,2,3,4,5）。滑动（2）。flatMap（u.reverse）.toArray
你能详细解释一下你写的代码吗？我理解滑动函数，但为什么两个索引（I和j）？
iOr是一个一行，但不是循环：
Array（1,2,3,4,5）.滑动（2,2）.平面图（u.reverse）.toArray
你能详细解释一下你写的代码吗？我理解滑动函数，但为什么有两个索引（I和j）？
这段代码工作得很好，就像其他用户发布的其他代码一样，但我还没有真正理解。你能解释一下吗？结构if（）…else（）在收益率确定结果值之后，我想。但是关于.foldLeft呢？你可能对阅读Haskell的内容感兴趣。Haskell是一种函数语言，在某些方面类似于Scala。我建议阅读Haskell对折叠的描述，因为关于Haskell的信息很容易以一种好的、可理解的格式找到。我有一个困难的时间e与Scala相关的信息。通过这种方式，您可能能够大致了解它的功能。此代码与其他用户发布的其他代码一样工作正常，但我还没有真正理解它。您能解释一下吗？结构if（）…else（）在收益率之后，我想确定结果值。但是关于.foldLeft呢？您可能有兴趣阅读Haskell的内容。Haskell是一种函数语言，在某些方面与Scala类似。我建议