LeetCode & Interview Prep — Full Handbook

def add(x: Int, xs: List[Int] = List.empty[Int]): List[Int] = xs :+ x
println(add(1))
println(add(2))

def add(x, xs=[]):
    xs.append(x)
    return xs
print(add(1))
print(add(2))

import scala.collection.mutable

def twoSum(nums: List[Int], target: Int): List[Int] = {
  val seen = mutable.Map[Int, Int]()
  val a = nums.toArray
  for (i <- a.indices) {
    val need = target - a(i)
    if (seen.contains(need)) return List(seen(need), i)
    seen(a(i)) = i
  }
  List.empty[Int]
}
println(twoSum(List(2, 7, 11, 15), 9))

def two_sum(nums, target):
    seen = {}
    for i, x in enumerate(nums):
        need = target - x
        if need in seen:
            return [seen[need], i]
        seen[x] = i
    return []

print(two_sum([2, 7, 11, 15], 9))

import scala.collection.mutable

def longestUnique(s: String): Int = {
  val seen = mutable.Set[Char]()
  var left = 0
  var best = 0
  for (right <- s.indices) {
    while (seen.contains(s(right))) {
      seen -= s(left)
      left += 1
    }
    seen += s(right)
    best = math.max(best, right - left + 1)
  }
  best
}
println(longestUnique("abcabcbb"))

def longest_unique(s):
    seen = set()
    left = 0
    best = 0
    for right, ch in enumerate(s):
        while ch in seen:
            seen.remove(s[left])
            left += 1
        seen.add(ch)
        best = max(best, right - left + 1)
    return best

print(longest_unique("abcabcbb"))

val xs = List(1, 2)
val ys = xs :+ 3
println(xs)
println(ys)

xs = [1, 2]
ys = xs + [3]
print(xs)
print(ys)

val a = (1 until 4).toList
val b = List(1, 1, 2, 3).toSet.size
println(a)
println(b)

a = list(range(1, 4))
b = len(set([1, 1, 2, 3]))
print(a)
print(b)

import scala.collection.mutable.ArrayBuffer

object DefaultDemo {
  private val sharedDefault = ArrayBuffer.empty[Int]

  def appendTo(element: Int,
      target: ArrayBuffer[Int] = sharedDefault): ArrayBuffer[Int] = {
    target += element
    target
  }
}

val myList1 = DefaultDemo.appendTo(1)
val myList2 = DefaultDemo.appendTo(2, ArrayBuffer.empty[Int])
val myList3 = DefaultDemo.appendTo(3)

println("my_list1: " + myList1)
println("my_list2: " + myList2)
println("my_list3: " + myList3)

def append_to(element, target=[]):
    target.append(element)
    return target

my_list1 = append_to(1)
my_list2 = append_to(2, [])
my_list3 = append_to(3)

print("my_list1:", my_list1)
print("my_list2:", my_list2)
print("my_list3:", my_list3)

// Scala for-comprehension captures each iteration value.
val multipliers = (0 until 3).map { i =>
  (x: Int) => i * x
}
val results = multipliers.map(m => m(2))
println("results: " + results)
// Scala normally prints Vector(0, 2, 4).

def create_multipliers():
    return [lambda x: i * x for i in range(3)]

multipliers = create_multipliers()
results = [m(2) for m in multipliers]

print("results:", results)

// Higher-order functions mimic decorator composition.
def dec1(func: () => Unit): () => Unit = {
  println("dec1 applied")
  () => {
    println("dec1 executed")
    func()
  }
}

def dec2(func: () => Unit): () => Unit = {
  println("dec2 applied")
  () => {
    println("dec2 executed")
    func()
  }
}

val myFunc = dec1(dec2(() => println("my_func executed")))
println("--- Start Calling ---")
myFunc()

def dec1(func):
    print("dec1 applied")
    def wrapper(*args, **kwargs):
        print("dec1 executed")
        return func(*args, **kwargs)
    return wrapper

def dec2(func):
    print("dec2 applied")
    def wrapper(*args, **kwargs):
        print("dec2 executed")
        return func(*args, **kwargs)
    return wrapper

@dec1
@dec2
def my_func():
    print("my_func executed")

print("--- Start Calling ---")
my_func()

// Idiomatic Scala: finally is for cleanup, not return.
def checkOrder(): String = {
  try {
    println("In try")
    "Return from try"
  } catch {
    case _: Exception => "Return from except"
  } finally {
    println("In finally")
  }
}

val result = checkOrder()
println("Final Result: " + result)
// Scala comparison returns "Return from try".

def check_order():
    try:
        print("In try")
        return "Return from try"
    except Exception:
        return "Return from except"
    finally:
        print("In finally")
        return "Return from finally"

result = check_order()
print("Final Result:", result)