Home / Blog / Scala Coding Interview Checklist

Scala Coding Interview Checklist

Published 2026-10-14 · Luna Interview

Scala can make interview solutions short and elegant—or turn a simple problem into a puzzle of implicit conversions and chained combinators that nobody can follow. If you're using Scala in a coding round, the goal is code that's correct, efficient, and easy to explain. This Scala coding interview checklist covers the collections, idioms, and traps worth reviewing before the day.

First, confirm with your recruiter that Scala is allowed, which version (2.13 and 3 differ in syntax), and whether you can compile and run code.

1. Choose the right collection, on purpose

Scala gives you immutable collections by default. That's great for correctness but can hurt performance in tight loops if you're not careful.

Say your reasoning aloud: "I'll use a mutable ArrayDeque for BFS because the algorithm is naturally imperative, and keep the public function pure."

Mixing styles is fine in interviews as long as you explain why.

2. The List indexing trap

List is a singly linked list. list(i) and list.length are O(n). Inside a loop, that quietly turns O(n) into O(n²).

// Risky
for (i <- 0 until xs.length) { ... xs(i) ... }

// Better for random access
val arr = xs.toArray
for (i <- arr.indices) { ... arr(i) ... }

Mention it: "I'm converting to an array so indexing is constant time."

3. PriorityQueue ordering

mutable.PriorityQueue dequeues the largest element first. For a min-heap, reverse the ordering:

import scala.collection.mutable
val minHeap = mutable.PriorityQueue.empty[(Int, Int)](
  Ordering.by[(Int, Int), Int](_._1).reverse
)
minHeap.enqueue((dist, node))
val (d, u) = minHeap.dequeue()

Practice this once before the interview. Getting the ordering wrong is a common source of silent bugs in Dijkstra and top-k problems.

4. Option instead of null

Use Option and say why:

val idx: Option[Int] = seen.get(target - x)
idx match {
  case Some(j) => return Array(j, i)
  case None    => seen(x) = i
}

Handy methods: getOrElse, map, fold, foreach, isDefined. Avoid .get on an Option unless you can justify that it's present.

5. Recursion and tail calls

Scala supports recursion well, but deep recursion can still overflow the JVM stack. Use @tailrec when the recursive call is in tail position:

import scala.annotation.tailrec
@tailrec
def gcd(a: Int, b: Int): Int =
  if (b == 0) a else gcd(b, a % b)

For tree DFS, recursion depth equals tree height—fine for balanced trees, risky for a degenerate chain of 100,000 nodes. Mention an iterative fallback with an explicit stack if input size could be large.

6. Keep combinator chains readable

groupBy, map, foldLeft, sliding, and zipWithIndex are powerful. But a five-step chain is hard to debug live.

// Readable
val counts = s.groupBy(identity).view.mapValues(_.length).toMap

// Often clearer in an interview
val counts = mutable.HashMap.empty[Char, Int].withDefaultValue(0)
for (c <- s) counts(c) += 1

A good rule: if you can't explain the chain in one breath, break it into named steps.

7. Performance notes worth stating

• foldLeft over a large collection is fine; foldRight on a List may not be stack-safe for large inputs
• String concatenation in a loop: use StringBuilder
• view avoids intermediate collections in long chains
• Boxing of Int in generic collections adds overhead; Array[Int] avoids it
• Range (0 until n) is lazy and cheap

8. Syntax you should have on autopilot

• for (i <- 0 until n) vs for (i <- 0 to n) (exclusive vs inclusive)
• arr.indices, arr.zipWithIndex
• Pattern matching on tuples: val (a, b) = pair
• Array.fill(n)(0) and Array.ofDim[Int](rows, cols)
• math.max, math.min, Int.MaxValue
• case class for small records like Edge(from, to, w)

Common Scala interview mistakes

1. Indexing a List inside a loop
2. Forgetting PriorityQueue is a max-heap
3. Calling .get on an Option without explanation
4. Writing clever one-liners that you then can't debug
5. Mixing Scala 2 and Scala 3 syntax without noticing
6. Deep non-tail recursion on large input

Soft practice note

Idiomatic but explainable Scala takes rehearsal—especially saying your collection choices out loud. If you want a calm, structured way to practice before the real round, Luna Interview is built for rehearsal and prep, not as a way around the rules during an interview.

Day-before checklist

• [ ] Scala version and environment confirmed with the recruiter
• [ ] Collection table reviewed (indexed vs linked)
• [ ] Min-heap PriorityQueue snippet practiced
• [ ] BFS with ArrayDeque written from memory
• [ ] Option handling patterns ready
• [ ] @tailrec and iterative DFS fallback understood
• [ ] One-sentence complexity explanation per solution

Scala's expressiveness is an advantage when it serves clarity. Write code the interviewer can read on the first pass, and explain each choice as you go.

Rehearse with an AI interview copilot, then browse commonly reported interview questions.