группа со складчатой ​​скалой

Question

У меня есть следующий список на входе:

val listInput1 = 
  List(
    "itemA,CATs,2,4",
    "itemA,CATS,3,1",
    "itemB,CATQ,4,5",
    "itemB,CATQ,4,6",
    "itemC,CARC,5,10")

, и я хочу написать функцию в scala, используя groupBy и foldleft (только одна функция), чтобы суммировать третий и четвертый столбец для строк, имеющихтот же заголовок (первый столбец здесь), требуемый результат:

val listOutput1 = 
      List(
         "itemA,CATS,5,5",
         "itemB,CATQ,8,11",
         "itemC,CARC,5,10"

       )


 def sumIndex (listIn:List[String]):List[String]={

 listIn.map(_.split(",")).groupBy(_(0)).map{ 
  case (title, label) => 
       "%s,%s,%d,%d".format(
         title,
         label.head.apply(1),
         label.map(_(2).toInt).sum,
         label.map(_(3).toInt).sum)}.toList

}

С уважением

Answer 1

Если у вас есть список как

val listInput1 =
  List(
    "itemA,CATs,2,4",
    "itemA,CATS,3,1",
    "itemB,CATQ,4,5",
    "itemB,CATQ,4,6",
    "itemC,CARC,5,10")

Тогда вы можете написать общую функцию , которую можно использовать с foldLeft и reduceLeft как

def accumulateLeft(x: Map[String, Tuple3[String, Int, Int]], y: Map[String, Tuple3[String, Int, Int]]): Map[String, Tuple3[String, Int, Int]] ={
  val key = y.keySet.toList(0)
  if(x.keySet.contains(key)){
    val oldTuple = x(key)
    x.updated(key, (y(key)._1, oldTuple._2+y(key)._2, oldTuple._3+y(key)._3))
  }
  else{
    x.updated(key, (y(key)._1, y(key)._2, y(key)._3))
  }
}

, и вы можете назвать их как

foldLeft

listInput1
  .map(_.split(","))
  .map(array => Map(array(0) -> (array(1), array(2).toInt, array(3).toInt)))
  .foldLeft(Map.empty[String, Tuple3[String, Int, Int]])(accumulateLeft)
  .map(x => x._1+","+x._2._1+","+x._2._2+","+x._2._3)
  .toList
//res0: List[String] = List(itemA,CATS,5,5, itemB,CATQ,8,11, itemC,CARC,5,10)

lowerLeft

listInput1
  .map(_.split(","))
  .map(array => Map(array(0) -> (array(1), array(2).toInt, array(3).toInt)))
  .reduceLeft(accumulateLeft)
  .map(x => x._1+","+x._2._1+","+x._2._2+","+x._2._3)
  .toList
//res1: List[String] = List(itemA,CATS,5,5, itemB,CATQ,8,11, itemC,CARC,5,10)

Аналогично вы можете просто поменять местамипеременные в общей функции , чтобы ее можно было использовать с foldRight и reduceRight как

def accumulateRight(y: Map[String, Tuple3[String, Int, Int]], x: Map[String, Tuple3[String, Int, Int]]): Map[String, Tuple3[String, Int, Int]] ={
  val key = y.keySet.toList(0)
  if(x.keySet.contains(key)){
    val oldTuple = x(key)
    x.updated(key, (y(key)._1, oldTuple._2+y(key)._2, oldTuple._3+y(key)._3))
  }
  else{
    x.updated(key, (y(key)._1, y(key)._2, y(key)._3))
  }
}

, а вызов функции дал бы вам

foldRight

listInput1
  .map(_.split(","))
  .map(array => Map(array(0) -> (array(1), array(2).toInt, array(3).toInt)))
  .foldRight(Map.empty[String, Tuple3[String, Int, Int]])(accumulateRight)
  .map(x => x._1+","+x._2._1+","+x._2._2+","+x._2._3)
  .toList
//res2: List[String] = List(itemC,CARC,5,10, itemB,CATQ,8,11, itemA,CATs,5,5)

lowerRight

listInput1
  .map(_.split(","))
  .map(array => Map(array(0) -> (array(1), array(2).toInt, array(3).toInt)))
  .reduceRight(accumulateRight)
  .map(x => x._1+","+x._2._1+","+x._2._2+","+x._2._3)
  .toList
//res3: List[String] = List(itemC,CARC,5,10, itemB,CATQ,8,11, itemA,CATs,5,5)

Таким образом, вам действительно не нужно groupBy, и вы можете использовать любой из foldLeft, foldRight, reduceLeft илиreduceRight функций для получения желаемого результата.

Answer 2

Логика в вашем коде выглядит разумно, здесь она реализована с помощью case class, который более аккуратно обрабатывает крайние случаи:

// represents a 'row' in the original list
case class Item(
                 name: String,
                 category: String,
                 amount: Int,
                 price: Int
               )

// safely converts the row of strings into case class, throws exception otherwise
def stringsToItem(strings: Array[String]): Item = {
  if (strings.length != 4) {
    throw new Exception(s"Invalid row: ${strings.foreach(print)}; must contain only 4 entries!")
  } else {
    val n = strings.headOption.getOrElse("N/A")
    val cat = strings.lift(1).getOrElse("N/A")
    val amt = strings.lift(2).filter(_.matches("^[0-9]*$")).map(_.toInt).getOrElse(0)
    val p = strings.lastOption.filter(_.matches("^[0-9]*$")).map(_.toInt).getOrElse(0)

    Item(n, cat, amt, p)
  }
}

// original code with case class and method above used
listInput1.map(_.split(","))
  .map(stringsToItem)
  .groupBy(_.name)
  .map { case (name, items) =>
    Item(
      name,
      category = items.head.category,
      amount = items.map(_.amount).sum,
      price = items.map(_.price).sum
    )
  }.toList

Answer 3

Вы можете решить это с помощью единого сгиба, перебирая список ввода только один раз.Используйте Карту для агрегирования результата.

listInput1.map(_.split(",")).foldLeft(Map.empty[String, Int]) {
  (acc: Map[String, Int], curr: Array[String]) =>
    val label: String = curr(0)
    val oldValue: Int = acc.getOrElse(label, 0)
    val newValue: Int = oldValue + curr(2).toInt + curr(3).toInt
    acc.updated(label, newValue)
}

result: Карта (элемент A -> 10, itemB -> 19, itemC -> 15)