Real-World Android Coding Interview Problems

sealed interface SearchState {
    data object Idle : SearchState
    data object Loading : SearchState
    data class Results(val items: List<String>) : SearchState
    data class Error(val message: String) : SearchState
}

@OptIn(FlowPreview::class, ExperimentalCoroutinesApi::class)
class SearchViewModel(private val api: suspend (String) -> List<String>) : ViewModel() {
    private val query = MutableStateFlow("")

    val state: StateFlow<SearchState> = query
        .map(String::trim)
        .debounce(300)
        .distinctUntilChanged()
        .flatMapLatest { q ->
            if (q.isEmpty()) flowOf(SearchState.Idle)
            else flow<SearchState> {
                emit(SearchState.Loading)
                emit(SearchState.Results(api(q)))
            }.catch { emit(SearchState.Error("Search failed")) }
        }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), SearchState.Idle)

    fun onQueryChange(q: String) { query.value = q }
}

class LruCache<K, V>(private val capacity: Int) {
    init { require(capacity > 0) }
    // accessOrder = true: iteration order is least → most recently accessed
    private val map = object : LinkedHashMap<K, V>(capacity, 0.75f, true) {
        override fun removeEldestEntry(eldest: MutableMap.MutableEntry<K, V>?) = size > capacity
    }

    @Synchronized fun get(key: K): V? = map[key]
    @Synchronized fun put(key: K, value: V) { map[key] = value }
    @Synchronized fun size(): Int = map.size
}

class TokenBucket(
    private val capacity: Int,
    private val refillPerSecond: Double,
    private val now: () -> Long = System::nanoTime,
) {
    private var tokens = capacity.toDouble()
    private var last = now()

    @Synchronized
    fun tryAcquire(): Boolean {
        val t = now()
        tokens = minOf(capacity.toDouble(), tokens + (t - last) / 1e9 * refillPerSecond)
        last = t
        return if (tokens >= 1) { tokens -= 1; true } else false
    }
}
// Use: limit AI or API calls per user action burst; inject `now` for deterministic tests.

data class ListState(
    val items: List<Item> = emptyList(),
    val nextPage: Int? = 1,
    val loadingMore: Boolean = false,
    val error: String? = null,
)

fun loadMore() {
    val s = _state.value
    if (s.loadingMore || s.nextPage == null) return            // guard duplicate and end-of-list loads
    _state.update { it.copy(loadingMore = true, error = null) }
    viewModelScope.launch {
        _state.update { cur ->
            try {
                val page = api.page(s.nextPage)
                cur.copy(items = cur.items + page.items, nextPage = page.next, loadingMore = false)
            } catch (e: IOException) {
                cur.copy(loadingMore = false, error = "Couldn't load more")
            }
        }
    }
}

viewModelScope.launch {
    val result = runCatching { api.page(s.nextPage) }
    _state.update { cur ->
        result.fold(
            onSuccess = { page -> cur.copy(items = cur.items + page.items, nextPage = page.next, loadingMore = false) },
            onFailure = { cur.copy(loadingMore = false, error = "Couldn't load more") },
        )
    }
}

data class Txn(val category: String, val amountPaise: Long, val date: LocalDate)

/** Top N categories by spend in a month, with totals. */
fun topCategories(txns: List<Txn>, month: YearMonth, n: Int): List<Pair<String, Long>> =
    txns.asSequence()
        .filter { YearMonth.from(it.date) == month }
        .groupingBy { it.category }
        .fold(0L) { acc, t -> acc + t.amountPaise }
        .entries
        .sortedByDescending { it.value }
        .take(n)
        .map { it.key to it.value }