Atlassian Interview Questions

Background: Atlassian products often require collaboration tools that manage user input and changes effectively. Analyzing version changes via common subsequences is crucial for tracking modifications in collaborative documents, such as those in Confluence.
Problem statement: Given two strings, text1 and text2, return the length of their longest common subsequence. If there is no common subsequence, return 0. A subsequence of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. For example, ace is a subsequence of abcde.
Function/class signature:

• def longest_common_subsequence(text1: str, text2: str) -> int:

Example 1:

• Input: text1 = "abcde", text2 = "ace"


• Output: 3


• Explanation: The longest common subsequence is "ace", which has a length of 3.

Example 2:

• Input: text1 = "abc", text2 = "abc"


• Output: 3


• Explanation: The longest common subsequence is "abc", which has a length of 3.

Constraints:

• 1 <= text1.length, text2.length <= 100


• text1 and text2 consist of English letters only.

Background: Atlassian develops collaborative software tools which often require efficient data manipulation. Managing unique items in lists can speed up operations in products like Jira and Confluence.
Problem statement: You are given a sorted array of integers nums. Your task is to remove the duplicates in-place such that each element appears only once and returns the new length of the array. Elements beyond the returned length will be ignored. The relative order of the elements should be kept the same.
Function/class signature:

• def remove_duplicates(nums: List[int]) -> int:

Example 1:
Input: nums = [1, 1, 2]
Output: 2
Explanation: The nums array will be modified to [1, 2] and the new length is 2.Example 2:
Input: nums = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4]
Output: 5
Explanation: The nums array will be modified to [0, 1, 2, 3, 4] and the new length is 5.Constraints:

• 0 <= nums.length <= 3 * 10^4


• -100 <= nums[i] <= 100


• nums is sorted in ascending order.

Background: Atlassian is known for its collaborative software tools, and creating interactive prototypes can be essential in their product design process. A snake game serves as a foundational exercise in understanding game logic and user interface dynamics.
Problem statement: Build a simple snake game where the player controls a snake that moves around a grid, eats food to grow, and dies if it runs into itself or the boundaries of the grid. The game should include methods to initialize the game, generate food, move the snake, and check game-over conditions.
Function/class signature:

• def __init__(self, width: int, height: int): Initializes the game with a specified grid size.


• def generate_food(self) -> Tuple[int, int]: Generates a food item at a random position on the grid.


• def move_snake(self, direction: str) -> bool: Moves the snake in the given direction and returns whether the game is still running.


• def game_over(self) -> bool: Checks if the snake has collided with the wall or itself.

Example 1:
Input: Game(width=10, height=10).generate_food()
Output: (3, 5)
Explanation: Food appears at position (3, 5) on the grid.
Example 2:
Input:
game = Game(10, 10)
game.move_snake('right')
Output: True
Explanation: The snake successfully moved right without hitting walls or itself.
Constraints:

• Width and height of the grid should be between 5 and 20.


• The snake can only move in four directions: 'up', 'down', 'left', 'right'.


• The snake's initial length is 1, and it can grow indefinitely on consuming food.

Background: Atlassian is known for its project management tools like Jira. A robust task management system is essential for organizing tasks effectively within teams and improving productivity.
Problem statement: You need to design a task management system that allows you to add, retrieve, and delete tasks. Each task has a unique id, a description, and a status (which can be Pending, In Progress, or Completed). Implement the following functions:

• add_task(id: int, description: str) -> None: Adds a new task with the given id and description.


• get_task(id: int) -> Tuple[str, str]: Retrieves the task's description and status by id. Returns None if the task does not exist.


• delete_task(id: int) -> bool: Deletes the task with the specified id. Returns True if the task was deleted successfully, False otherwise.

Function/class signature:

• add_task(id: int, description: str) -> None


• get_task(id: int) -> Tuple[str, str]


• delete_task(id: int) -> bool

Example 1:

• Input: add_task(1, "Write unit tests")


• Output: None


• Explanation: A task is created with id 1 and the description "Write unit tests".

Example 2:

• Input: get_task(1)


• Output: ("Write unit tests", "Pending")


• Explanation: Retrieves the task with id 1, which currently is "Write unit tests" and is in status "Pending".

Constraints:

• 1 <= id <= 10^6


• description is non-empty and has at most 100 characters


• At most 10^5 operations are performed.

Background: Atlassian relies heavily on cloud services to provide robust software tools for collaboration and project management. A clear understanding of cloud architecture is vital for maintaining scalability and efficiency in this ecosystem.Problem statement: You are tasked with developing a simplified version of a cloud service manager. This manager will keep track of various cloud services in terms of their name, status, and region. You need to implement methods for adding a service, retrieving the status of a service, and listing all services based on a specific status.Function/class signature:

• def add_service(name: str, status: str, region: str) -> None:


• def get_service_status(name: str) -> str:


• def list_services_by_status(status: str) -> List[str]:

Example 1:

• Input: add_service('Jira', 'active', 'US-East')


• Input: get_service_status('Jira')


• Output: 'active'


• Explanation: The service Jira was added as active.

Example 2:

• Input: add_service('Confluence', 'inactive', 'US-West')


• Input: list_services_by_status('active')


• Output: ['Jira']


• Explanation: Only the active service Jira is listed.

Constraints:

• Service names are unique strings (1-100 characters).


• Status can only be either "active" or "inactive."


• Region can be any string (1-50 characters).

Background: Atlassian's tools often facilitate project management and time tracking for development teams. A problem arises when teams want to maximize their productivity by selecting tasks they can complete within given time constraints.
Problem statement: You are given a list of tasks, where each task has a duration and a profit associated with it. Your goal is to find the maximum profit you can achieve by completing tasks without exceeding a total available time. The tasks cannot overlap and must be completed within the given total time.

def maximum_profit(tasks: List[Tuple[int, int]], total_time: int) -> int:
    pass

Example 1:
Input: tasks = [(2, 50), (3, 60), (1, 30)], total_time = 4
Output: 80
Explanation: You can complete the tasks with durations 2 and 1, thus earning a profit of 50 + 30 = 80.Example 2:
Input: tasks = [(3, 40), (4, 50), (2, 20)], total_time = 5
Output: 50
Explanation: The best option is to complete only the task with duration 4, earning 50 profit.Constraints:

• 1 <= len(tasks) <= 100


• Each task duration and profit is a positive integer, with 1 <= duration, profit <= 100


• 1 <= total_time <= 100

Background: In Jira, issues can be related to each other through links. These links can represent dependencies, blocks, or references. Understanding the shortest path between issues can help teams efficiently navigate dependencies and address blocking issues.
Problem statement: Given a directed graph representing issues as nodes and links as edges, implement a function to find the shortest path from a start issue to a target issue. Return the list of issue IDs representing the path or an empty list if no path exists.
Function/class signature:

• def shortest_path(links: List[Tuple[str, str]], start: str, target: str) -> List[str]:

Example 1:
Input: links = [("A", "B"), ("A", "C"), ("B", "D"), ("C", "D"), ("D", "E")], start = "A", target = "E"
Output: ["A", "B", "D", "E"]
Explanation: The shortest path from A to E is through B and D.
Example 2:
Input: links = [("A", "B"), ("B", "C"), ("C", "D")], start = "A", target = "D"
Output: ["A", "B", "C", "D"]
Constraints:

• 1 <= len(links) <= 1000


• All issue IDs are unique strings consisting of uppercase letters and digits.


• Graph can contain multiple edges (but no self-loops).