From 3de42a8ea7a66896af7b891e5538959d7dd5bdd2 Mon Sep 17 00:00:00 2001 From: Alexey Rykhalskiy Date: Mon, 28 Oct 2024 09:41:07 +0200 Subject: [PATCH 1/6] -- hr 3 swap nodes --- .../djnz/hackerrank/fp/a3structures/P10.scala | 5 ++ .../djnz/hackerrank/fp/a3structures/P11.scala | 5 ++ .../djnz/hackerrank/fp/a3structures/P12.scala | 5 ++ .../djnz/hackerrank/fp/a3structures/P13.scala | 5 ++ .../fp/a3structures/P1SwapNodes.scala | 68 +++++++++++++++++++ .../djnz/hackerrank/fp/a3structures/P2.scala | 5 ++ .../djnz/hackerrank/fp/a3structures/P3.scala | 5 ++ .../djnz/hackerrank/fp/a3structures/P4.scala | 5 ++ .../djnz/hackerrank/fp/a3structures/P5.scala | 5 ++ .../djnz/hackerrank/fp/a3structures/P6.scala | 5 ++ .../djnz/hackerrank/fp/a3structures/P7.scala | 5 ++ .../djnz/hackerrank/fp/a3structures/P8.scala | 5 ++ .../djnz/hackerrank/fp/a3structures/P9.scala | 5 ++ .../main/scala/djnz/hackerrank/fp/index.md | 30 ++++---- 14 files changed, 143 insertions(+), 15 deletions(-) create mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P10.scala create mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P11.scala create mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P12.scala create mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P13.scala create mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P1SwapNodes.scala create mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P2.scala create mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P3.scala create mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P4.scala create mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P5.scala create mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P6.scala create mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P7.scala create mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P8.scala create mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P9.scala diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P10.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P10.scala new file mode 100644 index 0000000..abb2a19 --- /dev/null +++ b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P10.scala @@ -0,0 +1,5 @@ +package djnz.hackerrank.fp.a3structures + +object P10 { + +} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P11.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P11.scala new file mode 100644 index 0000000..92ecc71 --- /dev/null +++ b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P11.scala @@ -0,0 +1,5 @@ +package djnz.hackerrank.fp.a3structures + +object P11 { + +} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P12.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P12.scala new file mode 100644 index 0000000..4ad4bfe --- /dev/null +++ b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P12.scala @@ -0,0 +1,5 @@ +package djnz.hackerrank.fp.a3structures + +object P12 { + +} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P13.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P13.scala new file mode 100644 index 0000000..a1c8aa3 --- /dev/null +++ b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P13.scala @@ -0,0 +1,5 @@ +package djnz.hackerrank.fp.a3structures + +object P13 { + +} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P1SwapNodes.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P1SwapNodes.scala new file mode 100644 index 0000000..fb22ea1 --- /dev/null +++ b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P1SwapNodes.scala @@ -0,0 +1,68 @@ +package djnz.hackerrank.fp.a3structures + +/** https://www.hackerrank.com/challenges/swap-nodes/problem */ +object P1SwapNodes { + + sealed trait Tree + case class Node(value: Int, left: Tree, right: Tree) extends Tree + case object Empty extends Tree + + object Tree { + + def parse(nodes: Seq[(Int, Int)]): Tree = { + + def go(index: Int): Tree = index match { + case -1 => Empty + case _ => + val (il, ir) = nodes(index - 1) + Node(index, go(il), go(ir)) + } + + go(1) + } + + def inOrder(t: Tree): Seq[Int] = t match { + case Empty => Seq.empty + case Node(v, l, r) => (inOrder(l) :+ v) ++ inOrder(r) + } + + def swap(t: Tree, k: Int, depth: Int): Tree = t match { + case Empty => t + case Node(v, l, r) => + val (l2, r2) = depth % k match { + case 0 => (r, l) + case _ => (l, r) + } + Node( + v, + Tree.swap(l2, k, depth + 1), + Tree.swap(r2, k, depth + 1) + ) + + } + } + + def next() = scala.io.StdIn.readLine() + + def main(args: Array[String]): Unit = { + val n = next().toInt + val nodes = (1 to n).map { _ => + next().split(" ").map(_.toInt) match { + case Array(x, y) => x -> y + } + } + + val t0 = Tree.parse(nodes) + + val tc = next().toInt + val queries = (1 to tc).map(_ => next().toInt) + + queries.foldLeft(t0) { (t, q) => + val t2 = Tree.swap(t, q, 1) + val ino = Tree.inOrder(t2) + println(ino.mkString(" ")) + t2 + } + } + +} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P2.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P2.scala new file mode 100644 index 0000000..b33d938 --- /dev/null +++ b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P2.scala @@ -0,0 +1,5 @@ +package djnz.hackerrank.fp.a3structures + +object P2 { + +} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P3.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P3.scala new file mode 100644 index 0000000..16a7a9b --- /dev/null +++ b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P3.scala @@ -0,0 +1,5 @@ +package djnz.hackerrank.fp.a3structures + +object P3 { + +} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P4.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P4.scala new file mode 100644 index 0000000..ce4dcd7 --- /dev/null +++ b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P4.scala @@ -0,0 +1,5 @@ +package djnz.hackerrank.fp.a3structures + +object P4 { + +} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P5.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P5.scala new file mode 100644 index 0000000..d2ffc08 --- /dev/null +++ b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P5.scala @@ -0,0 +1,5 @@ +package djnz.hackerrank.fp.a3structures + +object P5 { + +} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P6.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P6.scala new file mode 100644 index 0000000..f87ec4b --- /dev/null +++ b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P6.scala @@ -0,0 +1,5 @@ +package djnz.hackerrank.fp.a3structures + +object P6 { + +} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P7.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P7.scala new file mode 100644 index 0000000..83304e6 --- /dev/null +++ b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P7.scala @@ -0,0 +1,5 @@ +package djnz.hackerrank.fp.a3structures + +object P7 { + +} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P8.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P8.scala new file mode 100644 index 0000000..e44d348 --- /dev/null +++ b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P8.scala @@ -0,0 +1,5 @@ +package djnz.hackerrank.fp.a3structures + +object P8 { + +} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P9.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P9.scala new file mode 100644 index 0000000..5f50c9e --- /dev/null +++ b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P9.scala @@ -0,0 +1,5 @@ +package djnz.hackerrank.fp.a3structures + +object P9 { + +} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/index.md b/algo/src/main/scala/djnz/hackerrank/fp/index.md index 5ab30e5..c0ef40c 100644 --- a/algo/src/main/scala/djnz/hackerrank/fp/index.md +++ b/algo/src/main/scala/djnz/hackerrank/fp/index.md @@ -69,21 +69,21 @@ Some solutions to [HackerRank](https://www.hackerrank.com) problems in chapter [ ### Functional Structures -| | Problem | Solution | -|:--:|:-----------------------------------------------------------------------------------------------------------|:----------------------------:| -| 1 | [Swap Nodes](https://www.hackerrank.com/challenges/swap-nodes/problem) | [code](a3structures/P.scala) | -| 2 | [Matrix Rotation](https://www.hackerrank.com/challenges/matrix-rotation/problem) | [code](a3structures/P.scala) | -| 3 | [Valid BST](https://www.hackerrank.com/challenges/valid-bst/problem) | [code](a3structures/P.scala) | -| 4 | [Lists and GCD](https://www.hackerrank.com/challenges/lists-and-gcd/problem) | [code](a3structures/P.scala) | -| 5 | [Prison Transport](https://www.hackerrank.com/challenges/prison-transport/problem) | [code](a3structures/P.scala) | -| 6 | [Substring Searching](https://www.hackerrank.com/challenges/kmp-fp/problem) | [code](a3structures/P.scala) | -| 7 | [Order exercises](https://www.hackerrank.com/challenges/order-exercises/problem) | [code](a3structures/P.scala) | -| 8 | [John and Fences](https://www.hackerrank.com/challenges/john-and-fences/problem) | [code](a3structures/P.scala) | -| 9 | [Range Minimum Query](https://www.hackerrank.com/challenges/range-minimum-query/problem) | [code](a3structures/P.scala) | -| 10 | [Stock Prediction](https://www.hackerrank.com/challenges/stocks-prediction/problem) | [code](a3structures/P.scala) | -| 11 | [Mirko at the Construction Site](https://www.hackerrank.com/challenges/mirko-at-construction-site/problem) | [code](a3structures/P.scala) | -| 12 | [Tree manager](https://www.hackerrank.com/challenges/tree-manager/problem) | [code](a3structures/P.scala) | -| 13 | [Fighting Armies](https://www.hackerrank.com/challenges/fighting-armies/problem) | [code](a3structures/P.scala) | +| | Problem | Solution | +|:--:|:-----------------------------------------------------------------------------------------------------------|:--------------------------------------:| +| 1 | [Swap Nodes](https://www.hackerrank.com/challenges/swap-nodes/problem) | [code](a3structures/P1SwapNodes.scala) | +| 2 | [Matrix Rotation](https://www.hackerrank.com/challenges/matrix-rotation/problem) | [code](a3structures/P2.scala) | +| 3 | [Valid BST](https://www.hackerrank.com/challenges/valid-bst/problem) | [code](a3structures/P3.scala) | +| 4 | [Lists and GCD](https://www.hackerrank.com/challenges/lists-and-gcd/problem) | [code](a3structures/P4.scala) | +| 5 | [Prison Transport](https://www.hackerrank.com/challenges/prison-transport/problem) | [code](a3structures/P5.scala) | +| 6 | [Substring Searching](https://www.hackerrank.com/challenges/kmp-fp/problem) | [code](a3structures/P6.scala) | +| 7 | [Order exercises](https://www.hackerrank.com/challenges/order-exercises/problem) | [code](a3structures/P7.scala) | +| 8 | [John and Fences](https://www.hackerrank.com/challenges/john-and-fences/problem) | [code](a3structures/P8.scala) | +| 9 | [Range Minimum Query](https://www.hackerrank.com/challenges/range-minimum-query/problem) | [code](a3structures/P9.scala) | +| 10 | [Stock Prediction](https://www.hackerrank.com/challenges/stocks-prediction/problem) | [code](a3structures/P10.scala) | +| 11 | [Mirko at the Construction Site](https://www.hackerrank.com/challenges/mirko-at-construction-site/problem) | [code](a3structures/P11.scala) | +| 12 | [Tree manager](https://www.hackerrank.com/challenges/tree-manager/problem) | [code](a3structures/P12.scala) | +| 13 | [Fighting Armies](https://www.hackerrank.com/challenges/fighting-armies/problem) | [code](a3structures/P13.scala) | ### Memoization and DP From d22041910401d88586cd3aab19718cab7dceefc1 Mon Sep 17 00:00:00 2001 From: Alexey Rykhalskiy Date: Mon, 28 Oct 2024 11:02:24 +0200 Subject: [PATCH 2/6] -- hr the closest numbers --- .../a8interpreters/P1WhileInterpreter.scala | 283 ++++++++++++++++++ .../main/scala/djnz/hackerrank/fp/index.md | 14 +- .../hackerrank/sorting/ClosestNumbers.scala | 24 ++ 3 files changed, 314 insertions(+), 7 deletions(-) create mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a8interpreters/P1WhileInterpreter.scala create mode 100644 algo/src/main/scala/djnz/hackerrank/sorting/ClosestNumbers.scala diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a8interpreters/P1WhileInterpreter.scala b/algo/src/main/scala/djnz/hackerrank/fp/a8interpreters/P1WhileInterpreter.scala new file mode 100644 index 0000000..fbfd76f --- /dev/null +++ b/algo/src/main/scala/djnz/hackerrank/fp/a8interpreters/P1WhileInterpreter.scala @@ -0,0 +1,283 @@ +package djnz.hackerrank.fp.a8interpreters + +/** https://www.hackerrank.com/challenges/while-language-fp/problem */ +object P1WhileInterpreter { + + import scala.collection.mutable + case class Ram(data: mutable.Map[String, Long]) + object Ram { + val clean: Ram = Ram(mutable.Map.empty) + } + + object algebra { + sealed trait Expression + + sealed trait Keyword extends Expression + case object If extends Keyword + case object Then extends Keyword + case object Else extends Keyword + case object While extends Keyword + case object Do extends Keyword + + sealed trait Operand extends Expression + sealed trait BooleanValue extends Operand { + def value: Boolean + } + + sealed trait Evaluation extends Operand + + case class CurlyBrackets(expressions: List[Expression]) extends Expression + sealed trait Operation extends Expression + + case class Statement(expressions: List[Expression]) extends Expression + case class Lexeme(s: String) extends Expression + sealed trait Operator extends Expression { + def execute(ram: Ram): Unit + } + + case class Variable(name: String) extends ArithmeticEvaluation { + def eval(ram: Ram): Long = ram.data(name) + } + case class Number(value: Long) extends ArithmeticEvaluation { + def eval(ram: Ram): Long = value + } + + case class Parentheses(expressions: List[Expression]) extends ArithmeticEvaluation { + private lazy val evaluation = toEvaluation.asInstanceOf[ArithmeticEvaluation] + + def toEvaluation: Evaluation = { + val res = Parentheses.groups.foldLeft(expressions) { (acc, ops) => + def simplify(exs: List[Expression]): List[Expression] = exs match { + case Nil => Nil + case (a: BooleanValue) :: Nil => simplify(ValueBool(a) :: Nil) + case (a: BoolEvaluation) :: (op: BooleanOperation) :: (b: BoolEvaluation) :: exs if ops.contains(op) => + simplify(BinaryBool(op, a, b) :: exs) + case (a: Number) :: Nil => simplify(ValueArithmetic(a) :: Nil) + case (a: Variable) :: Nil => simplify(ValueArithmetic(a) :: Nil) + case (a: ArithmeticEvaluation) :: (op: ArithmeticOperation) :: (b: ArithmeticEvaluation) :: exs if ops.contains(op) => + simplify(BinaryArighmetic(op, a, b) :: exs) + case (a: ArithmeticEvaluation) :: (op: RelationalOperation) :: (b: ArithmeticEvaluation) :: exs if ops.contains(op) => + simplify(BinaryRelational(op, a, b) :: exs) + case ex :: exs => ex :: simplify(exs) + } + + simplify(acc) + } + + res.head.asInstanceOf[Evaluation] + } + + def eval(ram: Ram): Long = evaluation.eval(ram) + } + object Parentheses { + val groups = Seq( + Seq(Multiplication, Division), + Seq(Addition, Subtraction), + Seq(Greater, Less), + Seq(And), + Seq(Or), + Seq(Assignment) + ) + } + + trait ArithmeticOperation extends Operation { + def eval(a: Long, b: Long): Long + } + + trait Additive extends ArithmeticOperation + case object Addition extends Additive { + def eval(a: Long, b: Long): Long = a + b + } + case object Subtraction extends Additive { + def eval(a: Long, b: Long): Long = a - b + } + + trait Multiplicative extends ArithmeticOperation + case object Multiplication extends Multiplicative { + def eval(a: Long, b: Long): Long = a * b + } + case object Division extends Multiplicative { + def eval(a: Long, b: Long): Long = a / b + } + + trait RelationalOperation extends Operation { + def eval(a: Long, b: Long): Boolean + } + case object Less extends RelationalOperation { + def eval(a: Long, b: Long): Boolean = a < b + } + case object Greater extends RelationalOperation { + def eval(a: Long, b: Long): Boolean = a > b + } + + trait BooleanOperation extends Operation { + def eval(a: Boolean, b: Boolean): Boolean + } + case object And extends BooleanOperation { + def eval(a: Boolean, b: Boolean): Boolean = a && b + } + case object Or extends BooleanOperation { + def eval(a: Boolean, b: Boolean): Boolean = a || b + } + + case object Assignment extends Operation + + case object False extends BooleanValue { + def value: Boolean = false + } + case object True extends BooleanValue { + def value: Boolean = true + } + + trait BoolEvaluation extends Evaluation { + def eval(ram: Ram): Boolean + } + + case class ValueBool(a: BooleanValue) extends BoolEvaluation { + def eval(ram: Ram): Boolean = a.value + } + case class BinaryBool(op: BooleanOperation, a: BoolEvaluation, b: BoolEvaluation) extends BoolEvaluation { + def eval(ram: Ram): Boolean = op.eval(a.eval(ram), b.eval(ram)) + } + case class BinaryRelational(op: RelationalOperation, a: ArithmeticEvaluation, b: ArithmeticEvaluation) extends BoolEvaluation { + def eval(ram: Ram): Boolean = op.eval(a.eval(ram), b.eval(ram)) + } + + trait ArithmeticEvaluation extends Evaluation { + def eval(ram: Ram): Long + } + case class ValueArithmetic(a: ArithmeticEvaluation) extends ArithmeticEvaluation { + def eval(ram: Ram): Long = a.eval(ram) + } + case class BinaryArighmetic(op: ArithmeticOperation, a: ArithmeticEvaluation, b: ArithmeticEvaluation) extends ArithmeticEvaluation { + def eval(ram: Ram): Long = op.eval(a.eval(ram), b.eval(ram)) + } + + case class WhileOperator(condition: BoolEvaluation, body: List[Operator]) extends Operator { + def execute(ram: Ram): Unit = + while (condition.eval(ram)) + body.foreach(_.execute(ram)) + } + case class IfOperator(condition: BoolEvaluation, op1: List[Operator], op2: List[Operator]) extends Operator { + def execute(ram: Ram): Unit = + if (condition.eval(ram)) op1.foreach(_.execute(ram)) + else op2.foreach(_.execute(ram)) + } + case class AssignmentOperator(variable: Variable, evaluation: ArithmeticEvaluation) extends Operator { + def execute(ram: Ram): Unit = ram.data(variable.name) = evaluation.eval(ram) + } + + } + + import algebra._ + + def parse(it: Iterator[String]): List[Statement] = { + case class State(exs: List[Expression] = Nil, subExs: List[List[Expression]] = Nil) + + @scala.annotation.tailrec + def extract(expressions: List[Expression], acc: List[Expression] = Nil): List[Expression] = expressions match { + case Nil => Statement(acc) :: Nil + case (st: Statement) :: exs => Statement(acc) :: st :: exs + case ex :: exs => extract(exs, ex :: acc) + } + + val lexemes = Map( + "+" -> Addition, + "-" -> Subtraction, + "*" -> Multiplication, + "/" -> Division, + "and" -> And, + "or" -> Or, + ">" -> Greater, + "<" -> Less, + ":=" -> Assignment, + "true" -> True, + "false" -> False, + "if" -> If, + "then" -> Then, + "else" -> Else, + "while" -> While, + "do" -> Do, + "(" -> Lexeme("("), + ")" -> Lexeme(")"), + "{" -> Lexeme("{"), + "}" -> Lexeme("}"), + ";" -> Lexeme(";"), + ) + + @scala.annotation.tailrec + def go(state: State): State = { + + def withEx(ex: Expression): State = State(ex :: state.exs, state.subExs) + + it.hasNext match { + case true => + val next = it.next() match { + case lx if lexemes.contains(lx) => + lexemes(lx) match { + case Lexeme("(") | Lexeme("{") => State(Nil, state.exs :: state.subExs) + case Lexeme(")") => State(Parentheses(state.exs.reverse) :: state.subExs.head, state.subExs.tail) + case Lexeme("}") => State(CurlyBrackets(extract(state.exs)) :: state.subExs.head, state.subExs.tail) + case Lexeme(";") => State(extract(state.exs), state.subExs) + case lex => withEx(lex) + } + + case v if v.head.isLetter => State(Variable(v) :: state.exs, state.subExs) + case n if n.head.isDigit => State(Number(n.toLong) :: state.exs, state.subExs) + case _ => state + } + + go(next) + case _ => state + } + } + + val st = go(State()) + + extract(st.exs) + .map(_.asInstanceOf[Statement]) + } + + def mkFlow(statements: List[Statement], acc: List[Operator] = Nil): List[Operator] = statements match { + case Nil => acc + case st :: sts => + val next = st.expressions match { + case While :: (condition: Parentheses) :: Do :: CurlyBrackets(body) :: Nil => + WhileOperator(condition.toEvaluation.asInstanceOf[BoolEvaluation], mkFlow(body.map(_.asInstanceOf[Statement]))) + case If :: (condition: Parentheses) :: Then :: CurlyBrackets(op1) :: Else :: CurlyBrackets(op2) :: Nil => + IfOperator( + condition.toEvaluation.asInstanceOf[BoolEvaluation], + mkFlow(op1.map(_.asInstanceOf[Statement])), + mkFlow(op2.map(_.asInstanceOf[Statement])) + ) + case (variable: Variable) :: Assignment :: exs => AssignmentOperator(variable, Parentheses(exs).toEvaluation.asInstanceOf[ArithmeticEvaluation]) + case _ => throw new Exception("Unsupported statement") + } + mkFlow(sts, next :: acc) + } + + def represent(ram: Ram) = + ram.data + .toSeq + .sortBy { case (n, v) => n } + .map { case (n, v) => s"$n $v" } + .mkString("\n") + + def main(args: Array[String]): Unit = { + val code = { + val block = scala.io.Source.stdin + .getLines() + .mkString("\n") + .split("""\s+""").iterator + val statements = parse(block) + mkFlow(statements) + } + val outcome = { + val ram = Ram.clean + code.foreach(_.execute(ram)) + represent(ram) + } + println(outcome) + } + +} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/index.md b/algo/src/main/scala/djnz/hackerrank/fp/index.md index c0ef40c..e69359d 100644 --- a/algo/src/main/scala/djnz/hackerrank/fp/index.md +++ b/algo/src/main/scala/djnz/hackerrank/fp/index.md @@ -138,10 +138,10 @@ Some solutions to [HackerRank](https://www.hackerrank.com) problems in chapter [ ### Interpreter and Compilers -| | Problem | Solution | -|:-:|:-----------------------------------------------------------------------------------------------|:------------------------------:| -| 1 | [While Language](https://www.hackerrank.com/challenges/while-language-fp/problem) | [code](a8interpreters/P.scala) | -| 2 | [Intuitive language](https://www.hackerrank.com/challenges/intuitive-language/problem) | [code](a8interpreters/P.scala) | -| 3 | [Down With Abstractions](https://www.hackerrank.com/challenges/down-with-abstractions/problem) | [code](a8interpreters/P.scala) | -| 4 | [Infer](https://www.hackerrank.com/challenges/infer/problem) | [code](a8interpreters/P.scala) | -| 5 | [BrainF__k interpreter](https://www.hackerrank.com/challenges/brainf-k-interpreter-fp/problem) | [code](a8interpreters/P.scala) | +| | Problem | Solution | +|:-:|:-----------------------------------------------------------------------------------------------|:-------------------------------:| +| 1 | [While Language](https://www.hackerrank.com/challenges/while-language-fp/problem) | [code](a8interpreters/P1WhileInterpreter.scala) | +| 2 | [Intuitive language](https://www.hackerrank.com/challenges/intuitive-language/problem) | [code](a8interpreters/P.scala) | +| 3 | [Down With Abstractions](https://www.hackerrank.com/challenges/down-with-abstractions/problem) | [code](a8interpreters/P.scala) | +| 4 | [Infer](https://www.hackerrank.com/challenges/infer/problem) | [code](a8interpreters/P.scala) | +| 5 | [BrainF__k interpreter](https://www.hackerrank.com/challenges/brainf-k-interpreter-fp/problem) | [code](a8interpreters/P.scala) | diff --git a/algo/src/main/scala/djnz/hackerrank/sorting/ClosestNumbers.scala b/algo/src/main/scala/djnz/hackerrank/sorting/ClosestNumbers.scala new file mode 100644 index 0000000..7d5715a --- /dev/null +++ b/algo/src/main/scala/djnz/hackerrank/sorting/ClosestNumbers.scala @@ -0,0 +1,24 @@ +package djnz.hackerrank.sorting + +/** https://www.hackerrank.com/challenges/closest-numbers/problem */ +object ClosestNumbers extends App { + + def closestNumbers(arr: Array[Int]): Array[Int] = + arr.sorted + .iterator + .sliding(2) + .map { case Seq(a, b) => math.abs(a - b) -> (a, b) } + .toList + .groupMap { case (diff, _) => diff } { case (_, ab) => ab } + .iterator + .minBy { case (diff, _) => diff } + ._2 + .sorted + .flatMap { case (a, b) => Array(a, b) } + .toArray + + val as = Array(1, 5, 7, 100, 101) + val s = closestNumbers(as) + println(s.mkString("Array(", ", ", ")")) + +} From 55ceccfbe3d5eaefa69777e8c34ad1b9cab9ebd8 Mon Sep 17 00:00:00 2001 From: Alexey Rykhalskiy Date: Mon, 28 Oct 2024 11:07:13 +0200 Subject: [PATCH 3/6] -- hr the closest numbers --- .../scala/djnz/hackerrank/sorting/ClosestNumbers.scala | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/algo/src/main/scala/djnz/hackerrank/sorting/ClosestNumbers.scala b/algo/src/main/scala/djnz/hackerrank/sorting/ClosestNumbers.scala index 7d5715a..746b89f 100644 --- a/algo/src/main/scala/djnz/hackerrank/sorting/ClosestNumbers.scala +++ b/algo/src/main/scala/djnz/hackerrank/sorting/ClosestNumbers.scala @@ -7,15 +7,12 @@ object ClosestNumbers extends App { arr.sorted .iterator .sliding(2) - .map { case Seq(a, b) => math.abs(a - b) -> (a, b) } - .toList - .groupMap { case (diff, _) => diff } { case (_, ab) => ab } - .iterator + .toArray + .groupMap { case Seq(a, b) => math.abs(a - b) } { case Seq(a, b) => (a, b) } .minBy { case (diff, _) => diff } ._2 .sorted .flatMap { case (a, b) => Array(a, b) } - .toArray val as = Array(1, 5, 7, 100, 101) val s = closestNumbers(as) From 6d366710b683781e023b2d7da0ce308293200444 Mon Sep 17 00:00:00 2001 From: Alexey Rykhalskiy Date: Mon, 28 Oct 2024 14:27:50 +0200 Subject: [PATCH 4/6] -- 1 --- .../djnz/hackerrank/fp/a3structures/P10.scala | 5 -- .../djnz/hackerrank/fp/a3structures/P11.scala | 5 -- .../djnz/hackerrank/fp/a3structures/P12.scala | 5 -- .../djnz/hackerrank/fp/a3structures/P13.scala | 5 -- .../fp/a3structures/P1SwapNodes.scala | 68 ------------------- .../djnz/hackerrank/fp/a3structures/P2.scala | 5 -- .../djnz/hackerrank/fp/a3structures/P3.scala | 5 -- .../djnz/hackerrank/fp/a3structures/P4.scala | 5 -- .../djnz/hackerrank/fp/a3structures/P5.scala | 5 -- .../djnz/hackerrank/fp/a3structures/P6.scala | 5 -- .../djnz/hackerrank/fp/a3structures/P7.scala | 5 -- .../djnz/hackerrank/fp/a3structures/P8.scala | 5 -- .../djnz/hackerrank/fp/a3structures/P9.scala | 5 -- 13 files changed, 128 deletions(-) delete mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P10.scala delete mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P11.scala delete mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P12.scala delete mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P13.scala delete mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P1SwapNodes.scala delete mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P2.scala delete mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P3.scala delete mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P4.scala delete mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P5.scala delete mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P6.scala delete mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P7.scala delete mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P8.scala delete mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a3structures/P9.scala diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P10.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P10.scala deleted file mode 100644 index abb2a19..0000000 --- a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P10.scala +++ /dev/null @@ -1,5 +0,0 @@ -package djnz.hackerrank.fp.a3structures - -object P10 { - -} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P11.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P11.scala deleted file mode 100644 index 92ecc71..0000000 --- a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P11.scala +++ /dev/null @@ -1,5 +0,0 @@ -package djnz.hackerrank.fp.a3structures - -object P11 { - -} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P12.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P12.scala deleted file mode 100644 index 4ad4bfe..0000000 --- a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P12.scala +++ /dev/null @@ -1,5 +0,0 @@ -package djnz.hackerrank.fp.a3structures - -object P12 { - -} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P13.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P13.scala deleted file mode 100644 index a1c8aa3..0000000 --- a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P13.scala +++ /dev/null @@ -1,5 +0,0 @@ -package djnz.hackerrank.fp.a3structures - -object P13 { - -} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P1SwapNodes.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P1SwapNodes.scala deleted file mode 100644 index fb22ea1..0000000 --- a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P1SwapNodes.scala +++ /dev/null @@ -1,68 +0,0 @@ -package djnz.hackerrank.fp.a3structures - -/** https://www.hackerrank.com/challenges/swap-nodes/problem */ -object P1SwapNodes { - - sealed trait Tree - case class Node(value: Int, left: Tree, right: Tree) extends Tree - case object Empty extends Tree - - object Tree { - - def parse(nodes: Seq[(Int, Int)]): Tree = { - - def go(index: Int): Tree = index match { - case -1 => Empty - case _ => - val (il, ir) = nodes(index - 1) - Node(index, go(il), go(ir)) - } - - go(1) - } - - def inOrder(t: Tree): Seq[Int] = t match { - case Empty => Seq.empty - case Node(v, l, r) => (inOrder(l) :+ v) ++ inOrder(r) - } - - def swap(t: Tree, k: Int, depth: Int): Tree = t match { - case Empty => t - case Node(v, l, r) => - val (l2, r2) = depth % k match { - case 0 => (r, l) - case _ => (l, r) - } - Node( - v, - Tree.swap(l2, k, depth + 1), - Tree.swap(r2, k, depth + 1) - ) - - } - } - - def next() = scala.io.StdIn.readLine() - - def main(args: Array[String]): Unit = { - val n = next().toInt - val nodes = (1 to n).map { _ => - next().split(" ").map(_.toInt) match { - case Array(x, y) => x -> y - } - } - - val t0 = Tree.parse(nodes) - - val tc = next().toInt - val queries = (1 to tc).map(_ => next().toInt) - - queries.foldLeft(t0) { (t, q) => - val t2 = Tree.swap(t, q, 1) - val ino = Tree.inOrder(t2) - println(ino.mkString(" ")) - t2 - } - } - -} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P2.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P2.scala deleted file mode 100644 index b33d938..0000000 --- a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P2.scala +++ /dev/null @@ -1,5 +0,0 @@ -package djnz.hackerrank.fp.a3structures - -object P2 { - -} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P3.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P3.scala deleted file mode 100644 index 16a7a9b..0000000 --- a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P3.scala +++ /dev/null @@ -1,5 +0,0 @@ -package djnz.hackerrank.fp.a3structures - -object P3 { - -} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P4.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P4.scala deleted file mode 100644 index ce4dcd7..0000000 --- a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P4.scala +++ /dev/null @@ -1,5 +0,0 @@ -package djnz.hackerrank.fp.a3structures - -object P4 { - -} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P5.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P5.scala deleted file mode 100644 index d2ffc08..0000000 --- a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P5.scala +++ /dev/null @@ -1,5 +0,0 @@ -package djnz.hackerrank.fp.a3structures - -object P5 { - -} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P6.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P6.scala deleted file mode 100644 index f87ec4b..0000000 --- a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P6.scala +++ /dev/null @@ -1,5 +0,0 @@ -package djnz.hackerrank.fp.a3structures - -object P6 { - -} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P7.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P7.scala deleted file mode 100644 index 83304e6..0000000 --- a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P7.scala +++ /dev/null @@ -1,5 +0,0 @@ -package djnz.hackerrank.fp.a3structures - -object P7 { - -} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P8.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P8.scala deleted file mode 100644 index e44d348..0000000 --- a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P8.scala +++ /dev/null @@ -1,5 +0,0 @@ -package djnz.hackerrank.fp.a3structures - -object P8 { - -} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P9.scala b/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P9.scala deleted file mode 100644 index 5f50c9e..0000000 --- a/algo/src/main/scala/djnz/hackerrank/fp/a3structures/P9.scala +++ /dev/null @@ -1,5 +0,0 @@ -package djnz.hackerrank.fp.a3structures - -object P9 { - -} From cab8efd41975d4037be5be5f6d31718d81c1aefb Mon Sep 17 00:00:00 2001 From: Alexey Rykhalskiy Date: Mon, 28 Oct 2024 14:32:19 +0200 Subject: [PATCH 5/6] -- a8 --- .../a8interpreters/P1WhileInterpreter.scala | 283 ------------------ .../main/scala/djnz/hackerrank/fp/index.md | 14 +- 2 files changed, 7 insertions(+), 290 deletions(-) delete mode 100644 algo/src/main/scala/djnz/hackerrank/fp/a8interpreters/P1WhileInterpreter.scala diff --git a/algo/src/main/scala/djnz/hackerrank/fp/a8interpreters/P1WhileInterpreter.scala b/algo/src/main/scala/djnz/hackerrank/fp/a8interpreters/P1WhileInterpreter.scala deleted file mode 100644 index fbfd76f..0000000 --- a/algo/src/main/scala/djnz/hackerrank/fp/a8interpreters/P1WhileInterpreter.scala +++ /dev/null @@ -1,283 +0,0 @@ -package djnz.hackerrank.fp.a8interpreters - -/** https://www.hackerrank.com/challenges/while-language-fp/problem */ -object P1WhileInterpreter { - - import scala.collection.mutable - case class Ram(data: mutable.Map[String, Long]) - object Ram { - val clean: Ram = Ram(mutable.Map.empty) - } - - object algebra { - sealed trait Expression - - sealed trait Keyword extends Expression - case object If extends Keyword - case object Then extends Keyword - case object Else extends Keyword - case object While extends Keyword - case object Do extends Keyword - - sealed trait Operand extends Expression - sealed trait BooleanValue extends Operand { - def value: Boolean - } - - sealed trait Evaluation extends Operand - - case class CurlyBrackets(expressions: List[Expression]) extends Expression - sealed trait Operation extends Expression - - case class Statement(expressions: List[Expression]) extends Expression - case class Lexeme(s: String) extends Expression - sealed trait Operator extends Expression { - def execute(ram: Ram): Unit - } - - case class Variable(name: String) extends ArithmeticEvaluation { - def eval(ram: Ram): Long = ram.data(name) - } - case class Number(value: Long) extends ArithmeticEvaluation { - def eval(ram: Ram): Long = value - } - - case class Parentheses(expressions: List[Expression]) extends ArithmeticEvaluation { - private lazy val evaluation = toEvaluation.asInstanceOf[ArithmeticEvaluation] - - def toEvaluation: Evaluation = { - val res = Parentheses.groups.foldLeft(expressions) { (acc, ops) => - def simplify(exs: List[Expression]): List[Expression] = exs match { - case Nil => Nil - case (a: BooleanValue) :: Nil => simplify(ValueBool(a) :: Nil) - case (a: BoolEvaluation) :: (op: BooleanOperation) :: (b: BoolEvaluation) :: exs if ops.contains(op) => - simplify(BinaryBool(op, a, b) :: exs) - case (a: Number) :: Nil => simplify(ValueArithmetic(a) :: Nil) - case (a: Variable) :: Nil => simplify(ValueArithmetic(a) :: Nil) - case (a: ArithmeticEvaluation) :: (op: ArithmeticOperation) :: (b: ArithmeticEvaluation) :: exs if ops.contains(op) => - simplify(BinaryArighmetic(op, a, b) :: exs) - case (a: ArithmeticEvaluation) :: (op: RelationalOperation) :: (b: ArithmeticEvaluation) :: exs if ops.contains(op) => - simplify(BinaryRelational(op, a, b) :: exs) - case ex :: exs => ex :: simplify(exs) - } - - simplify(acc) - } - - res.head.asInstanceOf[Evaluation] - } - - def eval(ram: Ram): Long = evaluation.eval(ram) - } - object Parentheses { - val groups = Seq( - Seq(Multiplication, Division), - Seq(Addition, Subtraction), - Seq(Greater, Less), - Seq(And), - Seq(Or), - Seq(Assignment) - ) - } - - trait ArithmeticOperation extends Operation { - def eval(a: Long, b: Long): Long - } - - trait Additive extends ArithmeticOperation - case object Addition extends Additive { - def eval(a: Long, b: Long): Long = a + b - } - case object Subtraction extends Additive { - def eval(a: Long, b: Long): Long = a - b - } - - trait Multiplicative extends ArithmeticOperation - case object Multiplication extends Multiplicative { - def eval(a: Long, b: Long): Long = a * b - } - case object Division extends Multiplicative { - def eval(a: Long, b: Long): Long = a / b - } - - trait RelationalOperation extends Operation { - def eval(a: Long, b: Long): Boolean - } - case object Less extends RelationalOperation { - def eval(a: Long, b: Long): Boolean = a < b - } - case object Greater extends RelationalOperation { - def eval(a: Long, b: Long): Boolean = a > b - } - - trait BooleanOperation extends Operation { - def eval(a: Boolean, b: Boolean): Boolean - } - case object And extends BooleanOperation { - def eval(a: Boolean, b: Boolean): Boolean = a && b - } - case object Or extends BooleanOperation { - def eval(a: Boolean, b: Boolean): Boolean = a || b - } - - case object Assignment extends Operation - - case object False extends BooleanValue { - def value: Boolean = false - } - case object True extends BooleanValue { - def value: Boolean = true - } - - trait BoolEvaluation extends Evaluation { - def eval(ram: Ram): Boolean - } - - case class ValueBool(a: BooleanValue) extends BoolEvaluation { - def eval(ram: Ram): Boolean = a.value - } - case class BinaryBool(op: BooleanOperation, a: BoolEvaluation, b: BoolEvaluation) extends BoolEvaluation { - def eval(ram: Ram): Boolean = op.eval(a.eval(ram), b.eval(ram)) - } - case class BinaryRelational(op: RelationalOperation, a: ArithmeticEvaluation, b: ArithmeticEvaluation) extends BoolEvaluation { - def eval(ram: Ram): Boolean = op.eval(a.eval(ram), b.eval(ram)) - } - - trait ArithmeticEvaluation extends Evaluation { - def eval(ram: Ram): Long - } - case class ValueArithmetic(a: ArithmeticEvaluation) extends ArithmeticEvaluation { - def eval(ram: Ram): Long = a.eval(ram) - } - case class BinaryArighmetic(op: ArithmeticOperation, a: ArithmeticEvaluation, b: ArithmeticEvaluation) extends ArithmeticEvaluation { - def eval(ram: Ram): Long = op.eval(a.eval(ram), b.eval(ram)) - } - - case class WhileOperator(condition: BoolEvaluation, body: List[Operator]) extends Operator { - def execute(ram: Ram): Unit = - while (condition.eval(ram)) - body.foreach(_.execute(ram)) - } - case class IfOperator(condition: BoolEvaluation, op1: List[Operator], op2: List[Operator]) extends Operator { - def execute(ram: Ram): Unit = - if (condition.eval(ram)) op1.foreach(_.execute(ram)) - else op2.foreach(_.execute(ram)) - } - case class AssignmentOperator(variable: Variable, evaluation: ArithmeticEvaluation) extends Operator { - def execute(ram: Ram): Unit = ram.data(variable.name) = evaluation.eval(ram) - } - - } - - import algebra._ - - def parse(it: Iterator[String]): List[Statement] = { - case class State(exs: List[Expression] = Nil, subExs: List[List[Expression]] = Nil) - - @scala.annotation.tailrec - def extract(expressions: List[Expression], acc: List[Expression] = Nil): List[Expression] = expressions match { - case Nil => Statement(acc) :: Nil - case (st: Statement) :: exs => Statement(acc) :: st :: exs - case ex :: exs => extract(exs, ex :: acc) - } - - val lexemes = Map( - "+" -> Addition, - "-" -> Subtraction, - "*" -> Multiplication, - "/" -> Division, - "and" -> And, - "or" -> Or, - ">" -> Greater, - "<" -> Less, - ":=" -> Assignment, - "true" -> True, - "false" -> False, - "if" -> If, - "then" -> Then, - "else" -> Else, - "while" -> While, - "do" -> Do, - "(" -> Lexeme("("), - ")" -> Lexeme(")"), - "{" -> Lexeme("{"), - "}" -> Lexeme("}"), - ";" -> Lexeme(";"), - ) - - @scala.annotation.tailrec - def go(state: State): State = { - - def withEx(ex: Expression): State = State(ex :: state.exs, state.subExs) - - it.hasNext match { - case true => - val next = it.next() match { - case lx if lexemes.contains(lx) => - lexemes(lx) match { - case Lexeme("(") | Lexeme("{") => State(Nil, state.exs :: state.subExs) - case Lexeme(")") => State(Parentheses(state.exs.reverse) :: state.subExs.head, state.subExs.tail) - case Lexeme("}") => State(CurlyBrackets(extract(state.exs)) :: state.subExs.head, state.subExs.tail) - case Lexeme(";") => State(extract(state.exs), state.subExs) - case lex => withEx(lex) - } - - case v if v.head.isLetter => State(Variable(v) :: state.exs, state.subExs) - case n if n.head.isDigit => State(Number(n.toLong) :: state.exs, state.subExs) - case _ => state - } - - go(next) - case _ => state - } - } - - val st = go(State()) - - extract(st.exs) - .map(_.asInstanceOf[Statement]) - } - - def mkFlow(statements: List[Statement], acc: List[Operator] = Nil): List[Operator] = statements match { - case Nil => acc - case st :: sts => - val next = st.expressions match { - case While :: (condition: Parentheses) :: Do :: CurlyBrackets(body) :: Nil => - WhileOperator(condition.toEvaluation.asInstanceOf[BoolEvaluation], mkFlow(body.map(_.asInstanceOf[Statement]))) - case If :: (condition: Parentheses) :: Then :: CurlyBrackets(op1) :: Else :: CurlyBrackets(op2) :: Nil => - IfOperator( - condition.toEvaluation.asInstanceOf[BoolEvaluation], - mkFlow(op1.map(_.asInstanceOf[Statement])), - mkFlow(op2.map(_.asInstanceOf[Statement])) - ) - case (variable: Variable) :: Assignment :: exs => AssignmentOperator(variable, Parentheses(exs).toEvaluation.asInstanceOf[ArithmeticEvaluation]) - case _ => throw new Exception("Unsupported statement") - } - mkFlow(sts, next :: acc) - } - - def represent(ram: Ram) = - ram.data - .toSeq - .sortBy { case (n, v) => n } - .map { case (n, v) => s"$n $v" } - .mkString("\n") - - def main(args: Array[String]): Unit = { - val code = { - val block = scala.io.Source.stdin - .getLines() - .mkString("\n") - .split("""\s+""").iterator - val statements = parse(block) - mkFlow(statements) - } - val outcome = { - val ram = Ram.clean - code.foreach(_.execute(ram)) - represent(ram) - } - println(outcome) - } - -} diff --git a/algo/src/main/scala/djnz/hackerrank/fp/index.md b/algo/src/main/scala/djnz/hackerrank/fp/index.md index e69359d..c0ef40c 100644 --- a/algo/src/main/scala/djnz/hackerrank/fp/index.md +++ b/algo/src/main/scala/djnz/hackerrank/fp/index.md @@ -138,10 +138,10 @@ Some solutions to [HackerRank](https://www.hackerrank.com) problems in chapter [ ### Interpreter and Compilers -| | Problem | Solution | -|:-:|:-----------------------------------------------------------------------------------------------|:-------------------------------:| -| 1 | [While Language](https://www.hackerrank.com/challenges/while-language-fp/problem) | [code](a8interpreters/P1WhileInterpreter.scala) | -| 2 | [Intuitive language](https://www.hackerrank.com/challenges/intuitive-language/problem) | [code](a8interpreters/P.scala) | -| 3 | [Down With Abstractions](https://www.hackerrank.com/challenges/down-with-abstractions/problem) | [code](a8interpreters/P.scala) | -| 4 | [Infer](https://www.hackerrank.com/challenges/infer/problem) | [code](a8interpreters/P.scala) | -| 5 | [BrainF__k interpreter](https://www.hackerrank.com/challenges/brainf-k-interpreter-fp/problem) | [code](a8interpreters/P.scala) | +| | Problem | Solution | +|:-:|:-----------------------------------------------------------------------------------------------|:------------------------------:| +| 1 | [While Language](https://www.hackerrank.com/challenges/while-language-fp/problem) | [code](a8interpreters/P.scala) | +| 2 | [Intuitive language](https://www.hackerrank.com/challenges/intuitive-language/problem) | [code](a8interpreters/P.scala) | +| 3 | [Down With Abstractions](https://www.hackerrank.com/challenges/down-with-abstractions/problem) | [code](a8interpreters/P.scala) | +| 4 | [Infer](https://www.hackerrank.com/challenges/infer/problem) | [code](a8interpreters/P.scala) | +| 5 | [BrainF__k interpreter](https://www.hackerrank.com/challenges/brainf-k-interpreter-fp/problem) | [code](a8interpreters/P.scala) | From 078de926f98e9e6f68e0426ecbbec0e93d20fb1a Mon Sep 17 00:00:00 2001 From: Alexey Rykhalskiy Date: Mon, 28 Oct 2024 14:34:51 +0200 Subject: [PATCH 6/6] -- a8 --- .../main/scala/djnz/hackerrank/fp/index.md | 30 +++++++++---------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/algo/src/main/scala/djnz/hackerrank/fp/index.md b/algo/src/main/scala/djnz/hackerrank/fp/index.md index c0ef40c..5ab30e5 100644 --- a/algo/src/main/scala/djnz/hackerrank/fp/index.md +++ b/algo/src/main/scala/djnz/hackerrank/fp/index.md @@ -69,21 +69,21 @@ Some solutions to [HackerRank](https://www.hackerrank.com) problems in chapter [ ### Functional Structures -| | Problem | Solution | -|:--:|:-----------------------------------------------------------------------------------------------------------|:--------------------------------------:| -| 1 | [Swap Nodes](https://www.hackerrank.com/challenges/swap-nodes/problem) | [code](a3structures/P1SwapNodes.scala) | -| 2 | [Matrix Rotation](https://www.hackerrank.com/challenges/matrix-rotation/problem) | [code](a3structures/P2.scala) | -| 3 | [Valid BST](https://www.hackerrank.com/challenges/valid-bst/problem) | [code](a3structures/P3.scala) | -| 4 | [Lists and GCD](https://www.hackerrank.com/challenges/lists-and-gcd/problem) | [code](a3structures/P4.scala) | -| 5 | [Prison Transport](https://www.hackerrank.com/challenges/prison-transport/problem) | [code](a3structures/P5.scala) | -| 6 | [Substring Searching](https://www.hackerrank.com/challenges/kmp-fp/problem) | [code](a3structures/P6.scala) | -| 7 | [Order exercises](https://www.hackerrank.com/challenges/order-exercises/problem) | [code](a3structures/P7.scala) | -| 8 | [John and Fences](https://www.hackerrank.com/challenges/john-and-fences/problem) | [code](a3structures/P8.scala) | -| 9 | [Range Minimum Query](https://www.hackerrank.com/challenges/range-minimum-query/problem) | [code](a3structures/P9.scala) | -| 10 | [Stock Prediction](https://www.hackerrank.com/challenges/stocks-prediction/problem) | [code](a3structures/P10.scala) | -| 11 | [Mirko at the Construction Site](https://www.hackerrank.com/challenges/mirko-at-construction-site/problem) | [code](a3structures/P11.scala) | -| 12 | [Tree manager](https://www.hackerrank.com/challenges/tree-manager/problem) | [code](a3structures/P12.scala) | -| 13 | [Fighting Armies](https://www.hackerrank.com/challenges/fighting-armies/problem) | [code](a3structures/P13.scala) | +| | Problem | Solution | +|:--:|:-----------------------------------------------------------------------------------------------------------|:----------------------------:| +| 1 | [Swap Nodes](https://www.hackerrank.com/challenges/swap-nodes/problem) | [code](a3structures/P.scala) | +| 2 | [Matrix Rotation](https://www.hackerrank.com/challenges/matrix-rotation/problem) | [code](a3structures/P.scala) | +| 3 | [Valid BST](https://www.hackerrank.com/challenges/valid-bst/problem) | [code](a3structures/P.scala) | +| 4 | [Lists and GCD](https://www.hackerrank.com/challenges/lists-and-gcd/problem) | [code](a3structures/P.scala) | +| 5 | [Prison Transport](https://www.hackerrank.com/challenges/prison-transport/problem) | [code](a3structures/P.scala) | +| 6 | [Substring Searching](https://www.hackerrank.com/challenges/kmp-fp/problem) | [code](a3structures/P.scala) | +| 7 | [Order exercises](https://www.hackerrank.com/challenges/order-exercises/problem) | [code](a3structures/P.scala) | +| 8 | [John and Fences](https://www.hackerrank.com/challenges/john-and-fences/problem) | [code](a3structures/P.scala) | +| 9 | [Range Minimum Query](https://www.hackerrank.com/challenges/range-minimum-query/problem) | [code](a3structures/P.scala) | +| 10 | [Stock Prediction](https://www.hackerrank.com/challenges/stocks-prediction/problem) | [code](a3structures/P.scala) | +| 11 | [Mirko at the Construction Site](https://www.hackerrank.com/challenges/mirko-at-construction-site/problem) | [code](a3structures/P.scala) | +| 12 | [Tree manager](https://www.hackerrank.com/challenges/tree-manager/problem) | [code](a3structures/P.scala) | +| 13 | [Fighting Armies](https://www.hackerrank.com/challenges/fighting-armies/problem) | [code](a3structures/P.scala) | ### Memoization and DP