Archives functional programming

Hackerrank – String Compression

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution Look at the implementation. The steps and the result are described in problem statement. I created solution in: Scala All solutions are also available on my GitHub. Scala

object Solution extends App {
  val line = Source.stdin.getLines().toList.head

  val subs = uniformSubstrings(line)
  val substringCompressed = subs.map(s => {
    val length = s.length
    if(length > 1) {
      s.head.toString + length
    } else {
      s.head.toString
    }
  })

  println(substringCompressed.mkString(""))


  def uniformSubstrings(s: String): List[String] = {
    if(s.length <= 0) {
      return Nil
    }
    val c = s.charAt(0)
    val substring = s.takeWhile(_ == c)
    substring :: uniformSubstrings(s.drop(substring.length))
  }
}

object Solution extends App {

val line = Source.stdin.getLines().toList.head

val subs = uniformSubstrings(line)

val substringCompressed = subs.map(s => {

val length = s.length

if(length > 1) {

s.head.toString + length

} else {

s.head.toString

}

})

println(substringCompressed.mkString(""))

def uniformSubstrings(s: String): List[String] = {

if(s.length <= 0) {

return Nil

}

val c = s.charAt(0)

val substring = s.takeWhile(_ == c)

substring :: uniformSubstrings(s.drop(substring.length))

}

Hackerrank – Missing Numbers (FP)

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution Look at the Missing Numbers solution.

Hackerrank – Sequence full of colors

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution Create a recursive function with condition described – see implementation. I created solution in: Scala All solutions are also available on my GitHub. Scala

import scala.io.Source
import scala.collection.mutable.Map

object SequenceFullOfColors extends App {
  val lines = Source.stdin.getLines().toList.tail
  val results = lines.map(fullOfColors).map(_.toString.capitalize)

  println(results.mkString("\n"))

  def fullOfColors(sequence: String): Boolean = {
    val colors = Map.empty[Char, Int]
    def prefixSequences(seq: String, n: Int): Boolean = {
      val char = seq(n)
      val count = colors.getOrElse(char, 0)
      colors.put(char, count + 1)
      if(n < seq.length - 1) {
        val greenCount = colors.getOrElse('G', 0)
        val redCount = colors.getOrElse('R', 0)
        val yellowCount = colors.getOrElse('Y', 0)
        val blueCount = colors.getOrElse('B', 0)
        if((greenCount - redCount).abs <= 1 && (yellowCount - blueCount).abs <= 1) {
          return prefixSequences(seq, n + 1)
        }
        return false
      }
      true
    }

    val condition = prefixSequences(sequence, 0)
    val greenCount = colors.getOrElse('G', 0)
    val redCount = colors.getOrElse('R', 0)
    val yellowCount = colors.getOrElse('Y', 0)
    val blueCount = colors.getOrElse('B', 0)
    condition && (greenCount == redCount) && (yellowCount == blueCount)
  }
}

import scala.io.Source

import scala.collection.mutable.Map

object SequenceFullOfColors extends App {

val lines = Source.stdin.getLines().toList.tail

val results = lines.map(fullOfColors).map(_.toString.capitalize)

println(results.mkString("\n"))

def fullOfColors(sequence: String): Boolean = {

val colors = Map.empty[Char, Int]

def prefixSequences(seq: String, n: Int): Boolean = {

val char = seq(n)

val count = colors.getOrElse(char, 0)

colors.put(char, count + 1)

if(n < seq.length - 1) {

val greenCount = colors.getOrElse('G', 0)

val redCount = colors.getOrElse('R', 0)

val yellowCount = colors.getOrElse('Y', 0)

val blueCount = colors.getOrElse('B', 0)

if((greenCount - redCount).abs <= 1 && (yellowCount - blueCount).abs <= 1) {

return prefixSequences(seq, n + 1)

}

return false

}

true

}

val condition = prefixSequences(sequence, 0)

val greenCount = colors.getOrElse('G', 0)

val redCount = colors.getOrElse('R', 0)

val yellowCount = colors.getOrElse('Y', 0)

val blueCount = colors.getOrElse('B', 0)

condition && (greenCount == redCount) && (yellowCount == blueCount)

}

Hackerrank – Jumping Bunnies

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution Calculate the Least Common Multiple of bunnies jumps. I created solution in: Scala All solutions are also available on my GitHub. Scala

import scala.io.Source

object JumpingBunnies extends App {
  val lines = Source.stdin.getLines().toList
  val bunnies = lines(1).split(" ").map(_.toInt)

  val commonPoint = bunnies.foldLeft(BigInt(1))(lcm(_, _))

  println(commonPoint)

  def gcd(x: BigInt, y: BigInt): BigInt = {
    if(y == 0) x else gcd(y, x % y)
  }

  def lcm(x: BigInt, y: BigInt): BigInt = {
    (x * y) / gcd(x, y)
  }
}

import scala.io.Source

object JumpingBunnies extends App {

val lines = Source.stdin.getLines().toList

val bunnies = lines(1).split(" ").map(_.toInt)

val commonPoint = bunnies.foldLeft(BigInt(1))(lcm(_, _))

println(commonPoint)

def gcd(x: BigInt, y: BigInt): BigInt = {

if(y == 0) x else gcd(y, x % y)

}

def lcm(x: BigInt, y: BigInt): BigInt = {

(x * y) / gcd(x, y)

}

Hackerrank – Super Digit

import scala.io.Source

object SuperDigit extends App {
  val line = Source.stdin.bufferedReader().readLine()
  val nk = line.split(" ")
  val n = nk(0)
  val k = nk(1).toInt

  println(superDigit(n, k))

  def superDigit(num: String, k: Int): String = {
    if(num.length == 1) {
      return num
    } else {
      val sum: BigInt = num.foldLeft(BigInt(0))(_ + Character.digit(_, 10)) * k
      return superDigit(sum.toString, 1)
    }
  }
}

import scala.io.Source

object SuperDigit extends App {

val line = Source.stdin.bufferedReader().readLine()

val nk = line.split(" ")

val n = nk(0)

val k = nk(1).toInt

println(superDigit(n, k))

def superDigit(num: String, k: Int): String = {

if(num.length == 1) {

return num

} else {

val sum: BigInt = num.foldLeft(BigInt(0))(_ + Character.digit(_, 10)) * k

return superDigit(sum.toString, 1)

}

Hackerrank – Functions Or Not?

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution Check if for a given value x is always only one function output value y. See function definition. I created solution in: Scala All solutions are also available on my GitHub. Scala

import scala.io.Source

object FunctionOrNot extends App {
  val lines = Source.stdin.getLines().toList
  val tests = lines.head.toInt
  val parts = lines.tail.partition(!_.contains(" "))
  val counts = parts._1.map(_.toInt)
  val pairs = parts._2.map(_.split(" ")).map(arr => Tuple2(arr(0).toInt, arr(1).toInt))
  var start = 0
  counts.foreach {
    i => {
      val p = pairs.slice(start, start + i)
      start = start + i
      println(if(isFunction(p)) "YES" else "NO")
    }
  }

  def isFunction(rel: List[(Int, Int)]): Boolean = {
    val groupByX = rel.groupBy(_._1)
    val filteredMoreThanOne =
      groupByX.filter(p => p._2.size > 1)
    filteredMoreThanOne.forall(_._2.map(_._2).distinct == 1)
  }
}

import scala.io.Source

object FunctionOrNot extends App {

val lines = Source.stdin.getLines().toList

val tests = lines.head.toInt

val parts = lines.tail.partition(!_.contains(" "))

val counts = parts._1.map(_.toInt)

val pairs = parts._2.map(_.split(" ")).map(arr => Tuple2(arr(0).toInt, arr(1).toInt))

var start = 0

counts.foreach {

i => {

val p = pairs.slice(start, start + i)

start = start + i

println(if(isFunction(p)) "YES" else "NO")

}

def isFunction(rel: List[(Int, Int)]): Boolean = {

val groupByX = rel.groupBy(_._1)

val filteredMoreThanOne =

groupByX.filter(p => p._2.size > 1)

filteredMoreThanOne.forall(_._2.map(_._2).distinct == 1)

}

Hackerrank – String-o-Permute

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution For every input line: divide into character pairs reverse order of characters concat the pairs it into the one string I created solution in: Scala All solutions are also available on my GitHub. Scala

object StringOPermute extends App {
  val lines = Source.stdin.getLines().drop(1)
  val linePairs = lines.map(_.grouped(2).map(_.reverse).toList.flatten)
  println(linePairs.mkString("\n"))
}

object StringOPermute extends App {

val lines = Source.stdin.getLines().drop(1)

val linePairs = lines.map(_.grouped(2).map(_.reverse).toList.flatten)

println(linePairs.mkString("\n"))

}

Hackerrank – String Mingling

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution Iterate through one of the strings and concatenate each actual character. I created solution in: Scala All solutions are also available on my GitHub. Scala

import scala.io.Source

object StringMingling extends App {
  val lines = Source.stdin.getLines().toList
  val p = lines.head
  val q = lines.tail.head

  val mingled = p.indices.map(i => p(i) + "" + q(i)).mkString("")
  println(mingled)
}

import scala.io.Source

object StringMingling extends App {

val lines = Source.stdin.getLines().toList

val p = lines.head

val q = lines.tail.head

val mingled = p.indices.map(i => p(i) + "" + q(i)).mkString("")

println(mingled)

}

Hackerrank – Area Under Curves and Volume of Revolving a Curve

Hackerrank – Problem Statement A description of the problem can be found on Hackerrank. Solution function f is an applied algebraic expression to x as in problem description function area is area of the cycle ($$\Pi r^2$$) with center 0 and radius value of function(x) function summation is applied once for function f and one […]

Hackerrank – Lambda Calculi – March 2016

Hackerrank Contest I participated in an another programming contest organized by Hackerrank named Lambda Calculi – March 2016. The contest hosts seven challenges ranging from some basic functional programming concepts to some harder algorithmic problems I was able to solve 3 of 7 challenges and earned full points: Functions Or Not? Compute the Perimeter of […]

Pavol Pidanič

I can count to 1023 with 10 fingers

Tag: functional programming

Hackerrank – String Compression

Hackerrank – Missing Numbers (FP)

Hackerrank – Sequence full of colors

Hackerrank – Jumping Bunnies

Hackerrank – Super Digit

Hackerrank – Functions Or Not?

Hackerrank – String-o-Permute

Hackerrank – String Mingling

Hackerrank – Area Under Curves and Volume of Revolving a Curve

Hackerrank – Lambda Calculi – March 2016