akhileshs

• Continuous Subarray Sum
• Subarray Product Less Than K
• Basic Calculator II
• Longest Univalue Path
• LFU Cache
• Cheapest Flight Within K Stops
• Good Nodes in Binary Tree
• Partition Labels
• Binary Tree Diameter
• Find first and last position

akhileshs

@ def id[A](x: A): A = x
defined function id

@ def k[A, B](x: A, y: B): A = x 
defined function k

@ def a[A, B](f: A => B, x: A): B = f(x) 
defined function a

@ a((x: Int) => x + 1, 1) 

akhileshs

import Control.Monad

class Profunctor p where
  dimap :: (a -> b) -> (c -> d) -> p b c -> p a d

  -- lmap :: (a -> b) -> p b c -> p a c
  -- rmap :: (c -> d) -> p b c -> p b d

instance Profunctor (->) where
  -- dimap :: (a -> b) -> (c -> d) -> (->) b c -> (->) a d

akhileshs

class Contravariant f where
  fmap :: (b -> a) -> f a -> f b

newtype Predicate a = Predicate { runPredicate :: a -> Bool }

instance Contravariant Predicate where
  fmap f (Predicate a) = Predicate (a . f)

data MyOrdering = LT | EQ | GT

akhileshs

scala> "{ /* hello */ def foo(bar: Int) = bar }".parse[Term].get 
res0: scala.meta.Term = { /* hello */ def foo(bar: Int) = bar }

scala> res0 transform { case q"bar" => q"baz" } 
x.origin: Parsed(Input.String("{ /* hello */ def foo(bar: Int) = bar }"),Scala211,[18..21) in Input.String("{ /* hello */ def foo(bar: Int) = bar }"))
x : foo

x.origin: Transformed(bar)
x : baz

akhileshs

scala> type Foo[A, B] = Map[A, B]
defined type alias Foo

scala> type World[M[_]] = M[Int]
warning: there was one feature warning; re-run with -feature for details
defined type alias World

scala> type X[A] = World[({ type M[A] = Foo[String, A] })#M]
defined type alias X

akhileshs

{-# LANGUAGE RankNTypes #-}
module F where

data User = User { name :: String, age :: Int } deriving Show
data Project = Project { owner :: User } deriving Show

type Lens s a = Functor f => (a -> f a) -> s -> f s

newtype Identity a = Identity { runIdentity :: a }

akhileshs

data Toy b next =
  Output b next
  | Bell next
  | Done
  deriving (Show)

data FixE f e = Fix (f (FixE f e)) | Throw e

catch :: (Functor f) => FixE f e1 -> (e1 -> FixE f e2) -> FixE f e2
catch (Fix x) f = Fix (fmap (flip catch f) x)

akhileshs

trait Vect[Size, A]

def ++[n, m, a](v1: Vect[n, a], v2: Vect[m, a]): Vect[(n + m), a]

akhileshs

sequence :: Monad m => [m a] -> m [a]
sequence = foldr mcons (return [])    
              where mcons p q = p >>= \x -> q >>= \y -> return (x : y)