Atlassian Software Engineer Onsite Coding Questions

I had my Karrat interview a few weeks ago. The interview was a Snake game; these kinds of questions aren't difficult, but there are many corner cases to consider and handle well. VO: Coding 1: Likou57

**Candidate Profile** * **Experience:** 13 Years (B.Tech, CSE) * **Target Role:** Principal Engineer (Remote) * **Company:** Atlassian * **Date:** September 2025 * **Outcome:** Offer down-leveled to S

**Infection Sequences Count** **Problem Description** There are $n$ houses aligned in a straight line, numbered 1 to $n$. An integer array `infectedHouses` represents the houses initially infected wit

LeetCode #432: All O`one Data Structure. Difficulty: Hard. Topics: Hash Table, Linked List, Design, Doubly-Linked List. Asked at Atlassian in the last 6 months.

LeetCode #56: Merge Intervals. Difficulty: Medium. Topics: Array, Sorting. Asked at Atlassian in the last 6 months.

LeetCode #2034: Stock Price Fluctuation. Difficulty: Medium. Topics: Hash Table, Design, Heap (Priority Queue), Data Stream, Ordered Set. Asked at Atlassian in the last 6 months.

LeetCode #253: Meeting Rooms II. Difficulty: Medium. Topics: Array, Two Pointers, Greedy, Sorting, Heap (Priority Queue), Prefix Sum. Asked at Atlassian in the last 6 months.

LeetCode #1676: Lowest Common Ancestor of a Binary Tree IV. Difficulty: Medium. Topics: Hash Table, Tree, Depth-First Search, Binary Tree. Asked at Atlassian in the last 6 months.

LeetCode #353: Design Snake Game. Difficulty: Medium. Topics: Array, Hash Table, Design, Queue, Simulation. Asked at Atlassian in the last 6 months.

LeetCode #79: Word Search. Difficulty: Medium. Topics: Array, String, Backtracking, Depth-First Search, Matrix. Asked at Atlassian in the last 6 months.

LeetCode #3649: Number of Perfect Pairs. Difficulty: Medium. Topics: Array, Math, Two Pointers, Sorting. Asked at Atlassian in the last 6 months.

LeetCode #2939: Maximum Xor Product. Difficulty: Medium. Topics: Math, Greedy, Bit Manipulation. Asked at Atlassian in the last 6 months.

## Problem Design a `CompanyHierarchy` class representing an org chart. Each employee has an `emp_id`, `name`, `salary`, and at most one manager. ```python class CompanyHierarchy: def add_employee(self, emp_id: int, name: str, salary: int, manager_id: int | None) -> None: ... def remove_employee(self, emp_id: int) -> None: # re-parent direct reports to removed employee's manager ... def get_reports(self, emp_id: int, direct_only: bool = True) -> list[int]: ... def total_salary_under(self, emp_id: int) -> int: ... # sum salaries of entire subtree def path_to_ceo(self, emp_id: int) -> list[int]: ... # emp_id up to root, inclusive ``` **Example:** ``` ch = CompanyHierarchy() ch.add_employee(1, "CEO", 500000, None) ch.add_employee(2, "VP", 200000, 1) ch.add_employee(3, "Eng", 150000, 2) ch.total_salary_under(1) -> 850000 ch.path_to_ceo(3) -> [3, 2, 1] ch.remove_employee(2) ch.path_to_ceo(3) -> [3, 1] ``` ## Follow-ups - What is the time complexity of `total_salary_under` without caching? How would you cache it? - How do you detect if adding an employee would create a cycle? - Extend to support temporary "acting" manager assignments without modifying the permanent tree.

## Problem A customer support system stores satisfaction surveys as `(ticket_id, customer_id, agent_id, score, timestamp)` where score is 1-5. Implement a `SatisfactionAnalyzer`: ```python class SatisfactionAnalyzer: def add_response(self, ticket_id: str, customer_id: str, agent_id: str, score: int, ts: int) -> None: ... def agent_avg(self, agent_id: str) -> float: ... # overall average score def agent_trend(self, agent_id: str, window: int) -> float: ... # avg over last `window` responses def top_agents(self, n: int) -> list[tuple[str, float]]: ... # top n by overall avg, desc def customer_history(self, customer_id: str) -> list[tuple[str,int]]: ... # returns (ticket_id, score) sorted by timestamp asc ``` **Example:** ``` sa = SatisfactionAnalyzer() sa.add_response("T1","C1","A1",5,1000) sa.add_response("T2","C2","A1",3,2000) sa.add_response("T3","C1","A2",4,3000) sa.agent_avg("A1") -> 4.0 sa.agent_trend("A1", 1) -> 3.0 sa.top_agents(1) -> [("A2", 4.0)] ``` ## Follow-ups - How would you implement `agent_trend` in O(1) per query using a sliding window? - Extend to flag agents whose 7-day trend is declining by more than 1 point vs their overall average. - What database schema and indexes would you use to support these queries at scale?

## Problem A tennis club has `C` courts and receives booking requests as `(player_id, start_time, end_time)`. Process requests in order of arrival. Assign a request to any available court. If all courts are busy, add the request to a wait queue; it will be assigned when the earliest-ending match finishes. Return the final assignment list: `(player_id, court_id, actual_start_time)`. ```python def schedule_courts( num_courts: int, requests: list[tuple[str, int, int]] ) -> list[tuple[str, int, int]]: ... ``` **Example:** ``` num_courts = 2 requests = [("A",0,60),("B",0,90),("C",10,70),("D",20,50)] Output: [ ("A", 1, 0), ("B", 2, 0), ("C", 1, 60), # court 1 free at 60, C plays 60->120 ("D", 1, 120) # or court 2 free at 90 -> D at 90 ] ``` ## Follow-ups - What priority queue operations are needed, and what is the overall time complexity? - How do you handle a request where `end_time - start_time` varies (duration-based rather than fixed end)? - Extend to support VIP players who jump the wait queue.