Scaland

Algorithm: Find a pair in an array of numbers for a given sum Given an Array (or List) and a sum, we want to find a pair of numbers whose sum will be equal to the given sum.  For example for the [1,4,7] and 5 the outcome should be pair of 1 and 4. Or for [5, 7, 2, 8, 3] and 15 the outcome should be pair of 7 and 8.  Both pairs of 1 and 5, and 2 and 4 are correct for the input of [2, 4, 1, 5] and 6. The function signature looks like this: def findPairForSum(list: List[Int], sum: Int): Option[(Int, Int)] = ??? The return type is  Option[(Int, Int)] because there might be no pair at all. There are two approaches to solving this problem: The brute force approach which is the simplest and most naive one The first sort approach which is more efficient and a bit more complex Naive approach We can check the given sum against all possible pair combinations. In imperative programming, it would be the famous i and j for loops. But in functional programming, we can implement this us...

In this super short post, I am showing you how to write a very naive HTTP client ( GET ) to return the content of the response as a plain String . The whole point here is not to use a proper Scala library and wrap the side effect (an HTTP request is a side effect) in an IO object. object HttpService { def getRequest(uri: String): IO[String] = { try { IO { val url = new URL(uri) val con = url.openConnection.asInstanceOf[HttpURLConnection] con.setRequestMethod("GET") val streamReader = getTheStreamReader(con) val bufferedReader = new BufferedReader(streamReader) def loop(reader: BufferedReader, stringBuilder: StringBuilder): StringBuilder = { val line = reader.readLine() line match case null => stringBuilder case line => loop(reader, stringBuilder.append(line)) } loop(bufferedReader, new StringBuilder()).toString() } } catch { case t:...

Another String search problem that we like to solve in a functional way. This problem is very similar to the previous one,  Functional algorithm to find the position of a sub-string in a string , but it is a bit easier in the sense that we can always return an Int , so we do not have to return an Option of Int , because the number of the occurrences of a String in another String is always a non-negative number. So the signature of the function that we want to write looks like this: def countSubstring(str: String, subString: String): Int = ??? ⚠️ Be careful about overthinking the problems and always remain within the scope, in this case, it is very easy to overthink this problem by mixing up the terms sub-string and word . We only care about sub-strings and our algorithm does not know about words, meaning that our function should return the number 3 ( and not 2 )  if we pass it the following parameter: "This book is the best book among my books", "book" As we saw...

Let's practice some functional problem-solving!  Consider the classic problem of finding the index of a sub-string in a larger string. So we want to write a function that if we pass it the following strings it returns 0 . "hello world", "hello" If we pass it the following strings it returns 6 "hello world", "world" If we pass it the following strings it returns None , because "apple" can not be found inside "hello world. "hello world", "apple" So our function signature should look like this: def findFirstSubString(str: String, subStr: String): Option[Int] = ??? If we want to implement it in an imperative way, and yes Scala allows imperative programming, we can implement the function as follows, but we don't want imperative programming, do we? def findFirstSubString_bad(str: String, subStr: String): Option[Int] = { var j = 0; var temp = "" for (i So let's find the functional algorith...

In this post, I try to show you some more examples of fundamental tasks on an IO object. We have seen 3 of these examples in the part one of IO class exercises . Exercise 4:  Writing a function that takes an IO object and converts it to another data type: def convert[A, B](ioa: IO[A], value: B): IO[B] = ??? Of course, we want to wrap the value in an IO but also we want to make sure the receiving IO of A has been completed. We can use the famous map method that a monad has. def convert[A, B](ioa: IO[A], value: B): IO[B] = ioa.map(_ => value) This map operation on IO is so popular that there is method for that on IO class, so we can write the second version of this function like: def convert[A, B](ioa: IO[A], value: B): IO[B] = ioa.as(value)

 Finding the maximum element of an array is a relatively easy problem. An imperative solution would be to choose the first element as the max and then go through the rest of the array and assign the current element to the max if the current element is larger than the current max. In the end, the max variable will contain the max value of the array.  But we are here to learn about Scala and functional programming  so mutating a variable is not what we want to do. Also, we do not want to go through the array using a loop because a loop counter is also variable, in functional programming we usually implement loops or in general iterations using recursion . So let's see how we would implement a function with the following signature for finding the max value of a given array (or List): def maxValue(elements: List[Int]): Int = ??? For implementing recursion we can define a nested function inside our maxValue function which takes 2 parameters, one int which is the current max va...