CODEWITHSUNDEEP
scala
Kieran
Kieran

Reputation: 406

Why is Scala returning a ';' expected but ',' found error?

I am currently trying to write an inversion count algorithm in Scala, utilizing a working merge-sort algorithm.

The merge-sort functions as expected but when I try to add a count as one of the parameters I get back the error:

Error:(14, 29) ';' expected but ',' found.
      case (_, Nil) => left, count
                           ^

Here is the program:

object MergeSort {

  def mergeSort(inputList: List[Int]): List[Int] = {

    if (inputList.length <= 1) inputList

    else {
      val (left, right) = inputList.splitAt(inputList.size / 2)
      merge(mergeSort(left), mergeSort(right), 0)
    }

  }

  def merge(left: List[Int], right: List[Int], count: Int): List[Int] =
    (left, right) match {
      case (_, Nil) => left, count
      case (Nil, _) => right, count
      case (leftHead :: leftTail, rightHead :: rightTail) =>
        if (leftHead < rightHead){
          val (leftList, leftCount) = leftHead :: merge(leftTail, right, count)
          return (leftList, leftCount)
        }
        else {
          val (rightList, rightCount) = rightHead :: merge(left, rightTail, count)
          val mergeInversions = leftCount + left.length
          return (rightList, mergeInversions)
        }
    }

  val inputList: List[Int] = List(10, 3, 5, 1, 7, 6)

  val sorted_arr = mergeSort(inputList)

}

Upvotes: 1

Views: 2998

Answers (1)

Tarang Bhalodia
Tarang Bhalodia

Reputation: 1195

@sepp2k pointed out correctly in the comment that if you want to create a tuple, then you need to wrap it around parentheses.

Here's the working solution:

object MergeSort {

  def mergeSort(inputList: List[Int]): List[Int] = {

    if (inputList.length <= 1) inputList
    else {
      val (left, right) = inputList.splitAt(inputList.size / 2)
      merge(mergeSort(left), mergeSort(right), 0)._1
    }

  }

  def merge(left: List[Int], right: List[Int], count: Int): (List[Int], Int) =
    (left, right) match {
      case (_, Nil) => (left, count)
      case (Nil, _) => (right, count)
      case (leftHead :: leftTail, rightHead :: rightTail) =>
        if (leftHead < rightHead) {
          val left = merge(leftTail, right, count)
          val (leftList, leftCount) = (leftHead :: left._1, left._2)
          (leftList, leftCount)
        } else {
          val right = merge(left, rightTail, count)
          val (rightList, rightCount) = (rightHead :: right._1, right._2)
          val mergeInversions = rightCount + left.length
          (rightList, mergeInversions)
        }
    }

  val inputList: List[Int] = List(10, 3, 5, 1, 7, 6, 0)

  val sorted_arr = mergeSort(inputList)
}

Upvotes: 1

Related Questions