Question

I am executing the following code:

def takeN(s : String, n : Int): String = {
    var j = 1
    var o = s.split("")
    if(n != 0){
      var arr = new Array[Char](n)
    }
    while(j <= n){
      arr(j) = o(j)
      j += 1
    }
    val ml = List.fromArray(arr)
    var newS = ml.mkString("")
    newS
  }

When I test this code with this takeN(“abcd”,2), the answer that I am getting is this:

nullab

When I run this code at: http://www.simplyscala.com/ everything works but when I try it at my home pc I get errors so I changed it to :

     def takeN(s : String, n : Int): String = {
    var j = 1
    var o = s.split("")
    var arr = new Array[Char](n)
    while(j <= n){
      arr(j) = o(j)
      j += 1
    }
    val ml = List.fromArray(arr)
    var newS = ml.mkString("")
    newS
  }

then I get this error:

error: type mismatch;
 found   : java.lang.String
 required: Char
             arr(j) = o(j)

I am not sure how to fix this. why scala is so hard??

Answer 1

You can write a recursive answer without all that vals and vars. Most code is to guard agains invalid input:

def takeN (s : String, n : Int): String = {
  if (n > s.length) sys.error ("n > s.length: " + n  + " > " + (s.length))
  else if (n < 0) sys.error ("n < 0 : " + n)
  else if (n == 0) ""
  else if (n == s.length) s 
  else s(0) + takeN (s.substring (1), n-1) }

A shorter solution (but without guard) is:

def takeN (s : String, n: Int): String =
   (0 to n-1).map (s(_)).mkString 

usage:

takeN ("foolish", 5)
res16: String = fooli

But let’s try an solution closer to your approach:

  def takeN (s: String, n: Int): String = {
    var j = 0
    var arr = new Array[Char](n)
    while (j < n) {
      arr (j) = s(j)
      j += 1
    }
    val ml = List.fromArray (arr)
    var newS = ml.mkString("")
    newS
  }

String indexes start (as in Java) with 0, and so we go to j < n, not j <= n and from 0, not 1. We don’t need ‘o’ (with dubious split (“”), since we can use s(j) instead too.

Next step, get rid of the intermediate List:

  def takeN (s: String, n: Int): String = {
    var j = 0
    var arr = new Array[Char](n)
    while (j < n) {
      arr (j) = s(j)
      j += 1
    }
    arr.mkString 
  }

We simplified the return. Now let’s use a for-loop, instead of the while:

  def takeN (s: String, n: Int): String = {
    val arr = for (j <- (0 to n-1)) yield s(j)
    arr.mkString 
  }

or just

  def takeN (s: String, n: Int): String =
    (for (j <- (0 to n-1)) yield s(j)).mkString