List 用绝对值更新列表的值

scala的新手

我正在努力使这个代码工作几个小时了。其目的是用整数的绝对值更新列表[Int]（整数列表）。 花了很长时间才发现列表是不可变的，因此发现ListBuffer可以成为救世主，但最终在将其返回到列表表单中时，我想会遇到一些问题

def f (arr:List[Int]) : List[Int] =
{
  val list = new scala.collection.mutable.ListBuffer[Int]();
  val len = arr.length;
  for ( i <- 0 to len)
  {
    if(arr(i) < 0)
    {

      list.append((-1)*arr(i)) ;
    }
    else
    {
      list.append(arr(i));
    }
  }

  return list.toList;

}

---

这里没有什么不对劲。

最好的方法是使用Scala函数，如注释中建议的@senia。例如：

val res = list map math.abs

但是如果您想修复代码，只需将

替换为
，直到
。您只犯了一个错误：

def f (arr:List[Int]) : List[Int] =
{
val list = new scala.collection.mutable.ListBuffer[Int]();
val len = arr.length;
for ( i <- 0 until len)
{
    if(arr(i) < 0)
    {

        list.append((-1)*arr(i)) ;
    }
    else
    {
        list.append(arr(i));
    }
}

return list.toList;

}

您还可以删除
返回
，
甚至大括号
{
与
if/else
一起使用最好的方法是使用Scala函数，如注释中建议的@senia。例如：

val res = list map math.abs

但是，如果您想修复代码，只需将
替换为
，直到

def f (arr:List[Int]) : List[Int] =
{
val list = new scala.collection.mutable.ListBuffer[Int]();
val len = arr.length;
for ( i <- 0 until len)
{
    if(arr(i) < 0)
    {

        list.append((-1)*arr(i)) ;
    }
    else
    {
        list.append(arr(i));
    }
}

return list.toList;

}

您还可以删除
return
，
；
甚至与
if/else
一起使用的大括号
{
，另一个版本使用
进行理解，以避免索引

def f (arr:List[Int]) : List[Int] =
{
  val list = new scala.collection.mutable.ListBuffer[Int]();

  for {
    a <- arr
    sign = if (a < 0) -1 else 1
  } list.append(sign * a)

  return list.toList;
}

def（arr:List[Int]）：List[Int]=
{
val list=new scala.collection.mutable.ListBuffer[Int]（）；
为了{
另一个版本使用
进行理解，避免索引

def f (arr:List[Int]) : List[Int] =
{
  val list = new scala.collection.mutable.ListBuffer[Int]();

  for {
    a <- arr
    sign = if (a < 0) -1 else 1
  } list.append(sign * a)

  return list.toList;
}

def（arr:List[Int]）：List[Int]=
{
val list=new scala.collection.mutable.ListBuffer[Int]（）；
为了{
a您可以尝试使用case语句来获得更简洁的语法：

def f(arr:List[Int]):List[Int] = {
val list = scala.collection.mutable.ListBuffer[Int]()
arr.foreach{
    x =>
        x match {
        case _ if (x <0) => list+= (x*(-1))
        case _ => list +=x
    }
}
list.toList
}

def（arr:List[Int]）：List[Int]={
val list=scala.collection.mutable.ListBuffer[Int]（）
阿弗雷奇{
x=>
x匹配{
案例-if（x列表+=（x*（-1））
案例=>list+=x
}
}
list.toList
}
您可以尝试使用case语句来获得更简洁的语法：

def f(arr:List[Int]):List[Int] = {
val list = scala.collection.mutable.ListBuffer[Int]()
arr.foreach{
    x =>
        x match {
        case _ if (x <0) => list+= (x*(-1))
        case _ => list +=x
    }
}
list.toList
}

def（arr:List[Int]）：List[Int]={
val list=scala.collection.mutable.ListBuffer[Int]（）
阿弗雷奇{
x=>
x匹配{
案例-if（x列表+=（x*（-1））
案例=>list+=x
}
}
list.toList
}
看起来您正试图解决来自的挑战。您可能希望使用更具功能性的方法，使用递归和不可变列表

def f(arr: List[Int]): List[Int] = arr match {
  case Nil => Nil
  case x :: rest => java.lang.Math.abs(x) :: f(rest)
}

看起来您正试图解决来自的挑战。可能您希望使用递归和不可变列表的更具功能性的方法

def f(arr: List[Int]): List[Int] = arr match {
  case Nil => Nil
  case x :: rest => java.lang.Math.abs(x) :: f(rest)
}

初学者友好：我就是这样写的

def f(arr: List[Int]) : List[Int] = {
var list = new scala.collection.mutable.ArrayBuffer[Int]();
// var len = arr.length;

for(i <-0 until arr.length) {
    list.append( math.abs(arr(i)));
}

return list.toList; }

def（arr:List[Int]）：List[Int]={
var list=newscala.collection.mutable.ArrayBuffer[Int]（）；
//var len=阵列长度；
对于初学者友好型：我就是这样写的

def f(arr: List[Int]) : List[Int] = {
var list = new scala.collection.mutable.ArrayBuffer[Int]();
// var len = arr.length;

for(i <-0 until arr.length) {
    list.append( math.abs(arr(i)));
}

return list.toList; }

def（arr:List[Int]）：List[Int]={
var list=newscala.collection.mutable.ArrayBuffer[Int]（）；
//var len=阵列长度；
对于（i
val res=list-map-math.abs
或
val res=for{i
val res=list-map-math.abs
或
val res=for{i
list#apply
成本是
O（N）
，因此您的方法的复杂性是
O（N^2）
。至少替换
for（我@senia的观点很好。我并没有试图用更好的方式编写它，只是将它修好，让用户1043981看到问题所在。他非常接近：）。并不是说它是最好的实现。感谢@senia提供了关于复杂性的多个答案和见解。你能为scala中的复杂性问题提供一些指导吗。@harshit:请参阅。
List#apply
成本是
O（N）
，因此你的方法的复杂性是
O（N^2）
。至少替换
（我@senia的观点很好。我并没有试图用更好的方式编写它，只是将它修好，让用户1043981看到问题所在。他非常接近：）。并不是说它是最好的实现。感谢@senia提供了关于复杂性的多个答案和见解。你能为scala中的复杂性问题提供一些指导吗。@harshit:see。为什么不
def（arr:List[Int]）=对于{a为什么不
def（arr:List[Int]）=对于{非常糟糕的scala风格：1）使用可变
var
2）
var
不需要，因为所选集合已经是可变的3）使用不需要的
；
4）使用不需要的
返回
非常糟糕的Scala样式：1）使用可变的
var
2）
var
不需要，因为所选集合已经是可变的3）使用不需要的
；
4）使用不需要的
返回