Kotlin Coding Round Prep

Problem

Employees have a managerId. Implement chainOfCommand, allReports, commonManager (LCA).

data class Employee(val id: String, val name: String, val managerId: String?)

class OrgChart(employees: List<Employee>) {
    private val byId: Map<String, Employee> = employees.associateBy { it.id }
    private val directReports: Map<String, List<Employee>> =
        employees.filter { it.managerId != null }
                 .groupBy { it.managerId!! }

    fun chainOfCommand(empId: String): List<Employee> {
        val chain = mutableListOf<Employee>()
        var cur = byId[empId] ?: return emptyList()
        while (cur.managerId != null) {
            cur = byId[cur.managerId] ?: break
            chain += cur
        }
        return chain
    }

    fun allReports(empId: String): List<Employee> {
        val result = mutableListOf<Employee>()
        val queue = ArrayDeque(directReports[empId].orEmpty())
        while (queue.isNotEmpty()) {
            val e = queue.removeFirst()
            result += e
            queue += directReports[e.id].orEmpty()
        }
        return result
    }

    fun commonManager(a: String, b: String): Employee? {
        val chainA = (listOf(byId[a]!!) + chainOfCommand(a))
                         .map { it.id }.toSet()
        var cur: Employee? = byId[b]
        while (cur != null) {
            if (cur.id in chainA) return cur
            cur = cur.managerId?.let { byId[it] }
        }
        return null
    }
}

Senior touches

• Precompute directReports once in the constructor — saves repeated O(n) scans.
• Use ArrayDeque for BFS, not LinkedList.
• Cycle protection: if they push, add a visited: MutableSet in chainOfCommand.
• For DB-backed: mention WITH RECURSIVE CTE in Postgres.

Problem

Users have roles. Roles have permissions. Roles inherit. Implement can(user, action, resource).

data class Permission(val action: String, val resource: String) {
    fun matches(action: String, resource: String) =
        (this.action == action || this.action == "*") &&
        (this.resource == resource || this.resource == "*")
}

class RBAC(
    private val userRoles: Map<String, Set<String>>,
    private val roleParents: Map<String, Set<String>>,
    private val rolePerms: Map<String, Set<Permission>>
) {
    private fun effectiveRoles(user: String): Set<String> {
        val visited = mutableSetOf<String>()
        val queue = ArrayDeque(userRoles[user].orEmpty())
        while (queue.isNotEmpty()) {
            val r = queue.removeFirst()
            if (r in visited) continue
            visited += r
            queue += roleParents[r].orEmpty()
        }
        return visited
    }

    fun effectivePermissions(user: String): Set<Permission> =
        effectiveRoles(user).flatMap { rolePerms[it].orEmpty() }.toSet()

    fun can(user: String, action: String, resource: String): Boolean =
        effectivePermissions(user).any { it.matches(action, resource) }
}

Follow-ups

• Negative permissions: add data class Deny(...) sealed alongside Permission. Walk both; deny wins.
• Caching: memoize effectivePermissions(user) — invalidate on role change.
• Query-time filter: for list endpoints, push the perm filter into SQL via WHERE … AND user_perms @> required.

Solution (sealed classes = compile-time safety)

sealed class State {
    data object Draft : State()
    data object Submitted : State()
    data class   ManagerApproved(val by: String) : State()
    data class   HrApproved(val by: String) : State()
    data object Done : State()
    data class   Rejected(val reason: String) : State()
    data object Cancelled : State()
}

sealed class Action {
    data class Submit(val by: String) : Action()
    data class ManagerApprove(val by: String) : Action()
    data class HrApprove(val by: String) : Action()
    data object Finalize : Action()
    data class Reject(val reason: String) : Action()
    data object Cancel : Action()
}

class InvalidTransition(state: State, action: Action) :
    IllegalStateException("$action not allowed in $state")

fun State.transition(action: Action): State = when (this) {
    is State.Draft -> when (action) {
        is Action.Submit -> State.Submitted
        is Action.Cancel -> State.Cancelled
        else -> throw InvalidTransition(this, action)
    }
    is State.Submitted -> when (action) {
        is Action.ManagerApprove -> State.ManagerApproved(action.by)
        is Action.Reject          -> State.Rejected(action.reason)
        is Action.Cancel          -> State.Cancelled
        else -> throw InvalidTransition(this, action)
    }
    is State.ManagerApproved -> when (action) {
        is Action.HrApprove -> State.HrApproved(action.by)
        is Action.Reject    -> State.Rejected(action.reason)
        is Action.Cancel    -> State.Cancelled
        else -> throw InvalidTransition(this, action)
    }
    is State.HrApproved -> when (action) {
        is Action.Finalize -> State.Done
        is Action.Cancel   -> State.Cancelled
        else -> throw InvalidTransition(this, action)
    }
    is State.Done, is State.Rejected, is State.Cancelled ->
        throw InvalidTransition(this, action)
}

Senior touches to mention

• Sealed for both State and Action — closed sets, exhaustive when.
• Carry data on transitions (the approver's id) — captures audit info in the type.
• Extension function on State — reads naturally: request.state.transition(action).
• Authorization separate from transition validity — manager_approve is "valid action from Submitted" regardless of who tries; you check actor permission in a wrapping layer.

Problem

Given a list of reminders + their per-day "done" status, return the set of reminders that should appear on a given employee's dashboard today: scheduled for today OR scheduled for any past day where they're not yet marked done.

import java.time.LocalDate

data class Reminder(
    val id: String,
    val employeeId: String,
    val text: String,
    val scheduledDate: LocalDate
)

data class Occurrence(
    val reminderId: String,
    val occursOn: LocalDate,
    val doneAt: java.time.Instant? = null
)

fun dashboardFor(
    employeeId: String,
    reminders: List<Reminder>,
    occurrences: List<Occurrence>,
    today: LocalDate
): List<Occurrence> {
    val remByEmp = reminders
        .filter { it.employeeId == employeeId }
        .associateBy { it.id }
    return occurrences
        .filter { it.reminderId in remByEmp }
        .filter { it.doneAt == null }
        .filter { !it.occursOn.isAfter(today) }
        .sortedBy { it.occursOn }
}

What to talk about

• Pure function — no I/O. Easy to test.
• Sorted output — UI gets stable order.
• Filter chain reads top-to-bottom like the spec.
• For scale: "I'd push this into SQL — WHERE employee_id = ? AND occurs_on <= today AND done_at IS NULL ORDER BY occurs_on."

Bonus: writing the markDone function (idempotency-aware)

fun markDone(
    occurrences: MutableList<Occurrence>,
    reminderId: String,
    occursOn: LocalDate,
    now: java.time.Instant
): Occurrence {
    val idx = occurrences.indexOfFirst {
        it.reminderId == reminderId && it.occursOn == occursOn
    }
    require(idx >= 0) { "no such occurrence" }
    val existing = occurrences[idx]
    return if (existing.doneAt != null) {
        existing  // idempotent: already done, no-op
    } else {
        val updated = existing.copy(doneAt = now)
        occurrences[idx] = updated
        updated
    }
}