Question

I am trying to define a function, that would take a list and split it down n without using take, drop or grouped

  def mySplit[X](n: Int, xs: List[X]): (List[X], List[X]) = {
    if (n <= 0) (Nil, xs)
    else
    if (n >= xs.size) (xs, Nil)
    else
    if (n < xs.tail.size) (xs.head :: mySplit(n, xs.tail), Nil) 
                     else (Nil, xs.head :: mySplit(n, xs.tail))
  }

Here is what I am thinking. If n < xs.tail.size we can build up tuple 1 (representing part 1), else we can work on tuple 2 (second part of the list).

The above does not work. It seems that it does not like the :: when I am constructing part of a tuple.

Am I approaching this the right way?

Example: mySplit(3, (1 to 5).toList) should return (List(1,2,3), List(4,5))

Answer 1

Here is my take, rewritten from scratch:

def mySplit[X](n: Int, xs: List[X]): (List[X], List[X]) = {
  xs match {
    case Nil => (Nil, Nil)
    case head :: tail =>
      if(n == 0)
        (Nil, xs)
      else
        mySplit(n - 1, tail) match {
          case (before, after) =>
            (head :: before, after)
        }
  }
}

Or alternatively and shorter:

def mySplit[X](n: Int, xs: List[X]): (List[X], List[X]) = {
  n match {
    case 0 => (Nil, xs)
    case s =>
      mySplit(s - 1, xs.tail) match {
        case (before, after) =>
          (xs.head :: before, after)
      }  
  }
}