import math
def decrypt(message):
    # JUST DO IT
    return message

module Kata (bot) where


bot :: String -> String
bot txt
  | length msgs < 2 = ""
  | head msgs == "Frank: Recalled a message" = "bot: " ++ (msgs !! 1)
  | otherwise = ""
  where msgs = reverse $ lines txt

def div(num1, num2):
    return(num1 / num2)

def fibonacci(x):
    if x == 0:
        return 0 
    elif x == 1:
        return 1
    else :
        return fibonacci(x-1) + fibonacci(x-2)

{-# LANGUAGE KindSignatures, GADTs #-}

module KnightsOnAChessboard where

-- Peano's axioms for the natural numbers
data Z
data S n

-- Definition of natural numbers (to prevent nonsensical types like `S Bool`)
data Natural :: * -> * where
  NumZ :: Natural Z
  NumS :: Natural n -> Natural (S n)

-- Legal moves of a knight in international chess
data KnightCanReach :: * -> * where
  NoMoves :: KnightCanReach (Z, Z)
  MoveRL :: KnightCanReach (n, m) -> KnightCanReach (S (S n), S m)
  MoveRR :: KnightCanReach (n, S m) -> KnightCanReach (S (S n), m)
  MoveUL :: KnightCanReach (S n, m) -> KnightCanReach (n, S (S m))
  MoveUR :: KnightCanReach (n, m) -> KnightCanReach (S n, S (S m))
  MoveLL :: KnightCanReach (S (S n), S m) -> KnightCanReach (n, m)
  MoveLR :: KnightCanReach (S (S n), m) -> KnightCanReach (n, S m)
  MoveDL :: KnightCanReach (n, S (S m)) -> KnightCanReach (S n, m)
  MoveDR :: KnightCanReach (S n, S (S m)) -> KnightCanReach (n, m)

-- Proof that knight can reach any square on a chessboard starting from (0, 0)
knightCanMoveAnywhere :: Natural n -> Natural m -> KnightCanReach (n, m)
knightCanMoveAnywhere NumZ NumZ = NoMoves
knightCanMoveAnywhere NumZ (NumS n) =
  MoveDR $ MoveUL $ MoveRL $ knightCanMoveAnywhere NumZ n
knightCanMoveAnywhere (NumS n) m =
  MoveLL $ MoveRR $ MoveUR $ knightCanMoveAnywhere n m

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Kata
{
public static int[] Remove(int[] integerList,int[] valuesList)
	{
		if (integerList==null||integerList.length<1) return new int[0];
		if (valuesList==null||valuesList.length<1) return integerList;
		List<Integer> list= Arrays.stream(valuesList).boxed().collect(Collectors.toList());
		return Arrays.stream(integerList).filter(i->!list.contains(i)).toArray();
	} 
}

{-# LANGUAGE
  KindSignatures,
  GADTs,
  TypeOperators,
  TypeFamilies,
  UndecidableInstances,
  RankNTypes,
  EmptyCase #-}

module TheMiddleSchoolersMistake where

-- Void - the type representing contradictions in Haskell
import Data.Void

-- Peano's axioms for the natural numbers
data Z
data S n

data Natural :: * -> * where
  NumZ :: Natural Z
  NumS :: Natural n -> Natural (S n)

-- Axiom of reflexivity of equality: The very notion
-- of equality itself mandates that everything be
-- considered equal to itself
data (:=:) :: * -> * -> * where
  Refl :: a -> a :=: a

-- Peano addition, multiplication and exponentation
type family (:+:) (n :: *) (m :: *) :: *
type instance Z :+: n = n
type instance S n :+: m = S (n :+: m)

type family (:*:) (n :: *) (m :: *) :: *
type instance Z :*: n = Z
type instance S n :*: m = m :+: (n :*: m)

type family (:^:) (n :: *) (m :: *) :: *
type instance n :^: Z = S Z
type instance n :^: S m = n :*: (n :^: m)

-- Useful type synonyms for readability
type N1 = S Z -- The natural number 1
type N2 = S N1 -- The natural number 2
type N4 = N2 :+: N2 -- The natural number 4

-- Our proof that (a + b)^2 /= a^2 + b^2 in general
proof ::
  (forall n m.
    Natural n ->
    Natural m ->
    ((n :+: m) :^: N2) :=: ((n :^: N2) :+: (m :^: N2))) -> Void
proof mistake = let
  -- 1 is a natural number
  one :: Natural N1
  one = NumS NumZ
  -- To disprove (a + b)^2 = a^2 + b^2, we provide witnesses
  -- a = 1, b = 1 to our counterexample.  A witness is a
  -- value demonstrating the correctness of a logical statement
  -- involving existential quantifiers
  -- N.B. The witnesses could be anything else as long as it
  -- proves our point.  For example, we could've chosen a = 2,
  -- b = 3 instead and show that (2 + 3)^2 = 5^2 = 25 /= 13 =
  -- 2^2 + 3^2
  erroneous :: N4 :=: N2
  erroneous = mistake one one in
    -- Now we consider all possible cases where 4 = 2 and
    -- describe how to construct a proof of Void in each case
    -- However, there are no constructors that would allow us
    -- to construct a value of such a type!  The only possible
    -- constructor we could consider is Refl, but Refl always
    -- constructs values of a :=: a, never a :=: b where a and
    -- b are distinct types.  Therefore, we have already
    -- considered all (0) possible cases of 4 = 2 and we are
    -- done here.
    case erroneous of {}

function getIDS($number) {
  return array_sum(str_split($number));
}

using System;
using System.Linq;
using System.Collections.Generic;


public class NumbersFinder
{
    public static int Generator(int size , int position){
        if ( Math.Pow( size , size ) < position )
            return -1;
        List<string>  arr = new List<string>();
        for (int i = 0; i < size; ++i)
            arr.Add((i+1).ToString());
        List<string>  newArr;
        while (arr.Count != Math.Pow(size,size)){
            newArr = new List<string>();
            for (int j = 0; j < arr.Count; j++)
                for (int i = 0; i < size; i++)
                    newArr.Add(arr[j]+(i+1));
            arr.Clear();
            arr.AddRange(newArr);
        }
        return Convert.ToInt32(arr[position - 1]);
    }
}

const linkedList = {
  list: {},
  addNode: {}
}