Adobe Coding Questions 2025 - DSA Problems & System Design with Solutions

Practice 25+ Adobe placement paper coding questions with detailed solutions. Access Adobe OA coding problems, DSA questions, and system design for Adobe placement 2025-2026.

Adobe Placement Paper Coding Questions - Complete Guide

Practice with 25+ Adobe placement paper coding questions covering DSA problems, algorithms, and system design concepts. These questions are representative of what you’ll encounter in Adobe’s online assessment and technical interviews.

What’s Included:

25+ Coding Problems: Easy, Medium, and Hard level questions with solutions
Multiple Language Solutions: Java, Python, and C++ solutions
Time Complexity Analysis: Every solution includes complexity analysis
Adobe-Specific Patterns: Focus on arrays, strings, trees, and dynamic programming

Adobe Placement Papers 2024

Access 2024 Adobe OA questions with solutions and exam pattern analysis.

View 2024 Papers →

Adobe Placement Papers 2025

Practice latest 2025 Adobe OA questions with updated patterns.

View 2025 Papers →

Complete Adobe Guide

Access complete Adobe placement papers guide with eligibility, process, and preparation strategy.

View Complete Guide →

Adobe OA Coding Section Overview

Adobe Online Assessment Breakdown:

Section	Questions	Time	Difficulty	Focus Areas
Coding Test	2-3	90 min	Medium-Hard	Arrays, trees, graphs, DP, strings

Languages Allowed: C, C++, Java, Python

Coding Problems by Difficulty

Two Sum

Problem: Find indices of two numbers that add up to target.

Example:

Input: nums = [2, 7, 11, 15], target = 9
Output: [0, 1]

Solution (Java):

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();

    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement)) {
            return new int[]{map.get(complement), i};
        }
        map.put(nums[i], i);
    }

    return new int[]{};
}

Solution (Python):

def two_sum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        if target - num in seen:
            return [seen[target - num], i]
        seen[num] = i
    return []

Time Complexity: O(n) | Space Complexity: O(n)

Valid Parentheses

Problem: Check if string with brackets is valid.

Example:

Input: "()[]{}"
Output: true

Solution (Java):

public boolean isValid(String s) {
    Stack<Character> stack = new Stack<>();
    Map<Character, Character> map = Map.of(')', '(', '}', '{', ']', '[');

    for (char c : s.toCharArray()) {
        if (map.containsKey(c)) {
            if (stack.isEmpty() || stack.pop() != map.get(c)) {
                return false;
            }
        } else {
            stack.push(c);
        }
    }

    return stack.isEmpty();
}

Solution (Python):

def is_valid(s):
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}

    for char in s:
        if char in mapping:
            if not stack or stack.pop() != mapping[char]:
                return False
        else:
            stack.append(char)

    return len(stack) == 0

Time Complexity: O(n) | Space Complexity: O(n)

Merge Two Sorted Lists

Problem: Merge two sorted linked lists.

Example:

Input: [1,2,4] + [1,3,4]
Output: [1,1,2,3,4,4]

Solution (Java):

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    ListNode dummy = new ListNode(0);
    ListNode curr = dummy;

    while (l1 != null && l2 != null) {
        if (l1.val < l2.val) {
            curr.next = l1;
            l1 = l1.next;
        } else {
            curr.next = l2;
            l2 = l2.next;
        }
        curr = curr.next;
    }

    curr.next = l1 != null ? l1 : l2;
    return dummy.next;
}

Solution (Python):

def merge_two_lists(l1, l2):
    dummy = ListNode(0)
    curr = dummy

    while l1 and l2:
        if l1.val < l2.val:
            curr.next = l1
            l1 = l1.next
        else:
            curr.next = l2
            l2 = l2.next
        curr = curr.next

    curr.next = l1 or l2
    return dummy.next

Time Complexity: O(n+m) | Space Complexity: O(1)

Best Time to Buy and Sell Stock

Problem: Find maximum profit from buying and selling stock once.

Example:

Input: [7,1,5,3,6,4]
Output: 5 (buy at 1, sell at 6)

Solution (Java):

public int maxProfit(int[] prices) {
    int minPrice = Integer.MAX_VALUE;
    int maxProfit = 0;

    for (int price : prices) {
        minPrice = Math.min(minPrice, price);
        maxProfit = Math.max(maxProfit, price - minPrice);
    }

    return maxProfit;
}

Solution (Python):

def max_profit(prices):
    min_price = float('inf')
    max_profit = 0

    for price in prices:
        min_price = min(min_price, price)
        max_profit = max(max_profit, price - min_price)

    return max_profit

Time Complexity: O(n) | Space Complexity: O(1)

Reverse Linked List

Problem: Reverse a singly linked list.

Solution (Java):

public ListNode reverseList(ListNode head) {
    ListNode prev = null;
    ListNode curr = head;

    while (curr != null) {
        ListNode next = curr.next;
        curr.next = prev;
        prev = curr;
        curr = next;
    }

    return prev;
}

Solution (Python):

def reverse_list(head):
    prev = None
    curr = head

    while curr:
        next_temp = curr.next
        curr.next = prev
        prev = curr
        curr = next_temp

    return prev

Time Complexity: O(n) | Space Complexity: O(1)

Product of Array Except Self

Problem: Return array where each element is product of all other elements (without division).

Example:

Input: [1,2,3,4]
Output: [24,12,8,6]

Solution (Java):

public int[] productExceptSelf(int[] nums) {
    int n = nums.length;
    int[] result = new int[n];

    result[0] = 1;
    for (int i = 1; i < n; i++) {
        result[i] = result[i-1] * nums[i-1];
    }

    int right = 1;
    for (int i = n-1; i >= 0; i--) {
        result[i] *= right;
        right *= nums[i];
    }

    return result;
}

Solution (Python):

def product_except_self(nums):
    n = len(nums)
    result = [1] * n

    prefix = 1
    for i in range(n):
        result[i] = prefix
        prefix *= nums[i]

    suffix = 1
    for i in range(n-1, -1, -1):
        result[i] *= suffix
        suffix *= nums[i]

    return result

Time Complexity: O(n) | Space Complexity: O(1) excluding output

Longest Substring Without Repeating

Problem: Find length of longest substring without repeating characters.

Example:

Input: "abcabcbb"
Output: 3 (substring "abc")

Solution (Java):

public int lengthOfLongestSubstring(String s) {
    Map<Character, Integer> seen = new HashMap<>();
    int maxLen = 0, left = 0;

    for (int right = 0; right < s.length(); right++) {
        char c = s.charAt(right);
        if (seen.containsKey(c) && seen.get(c) >= left) {
            left = seen.get(c) + 1;
        }
        seen.put(c, right);
        maxLen = Math.max(maxLen, right - left + 1);
    }

    return maxLen;
}

Solution (Python):

def length_of_longest_substring(s):
    seen = {}
    max_len = left = 0

    for right, char in enumerate(s):
        if char in seen and seen[char] >= left:
            left = seen[char] + 1
        seen[char] = right
        max_len = max(max_len, right - left + 1)

    return max_len

Time Complexity: O(n) | Space Complexity: O(min(m,n))

Longest Palindromic Substring

Problem: Find the longest palindromic substring.

Example:

Input: "babad"
Output: "bab" or "aba"

Solution (Java):

public String longestPalindrome(String s) {
    if (s == null || s.length() < 1) return "";

    int start = 0, end = 0;

    for (int i = 0; i < s.length(); i++) {
        int len1 = expandAroundCenter(s, i, i);
        int len2 = expandAroundCenter(s, i, i + 1);
        int len = Math.max(len1, len2);

        if (len > end - start) {
            start = i - (len - 1) / 2;
            end = i + len / 2;
        }
    }

    return s.substring(start, end + 1);
}

private int expandAroundCenter(String s, int left, int right) {
    while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
        left--;
        right++;
    }
    return right - left - 1;
}

Solution (Python):

def longest_palindrome(s):
    def expand(left, right):
        while left >= 0 and right < len(s) and s[left] == s[right]:
            left -= 1
            right += 1
        return s[left+1:right]

    result = ""
    for i in range(len(s)):
        odd = expand(i, i)
        even = expand(i, i+1)
        result = max(result, odd, even, key=len)

    return result

Time Complexity: O(n²) | Space Complexity: O(1)

Container With Most Water

Problem: Find two lines that form container with most water.

Example:

Input: [1,8,6,2,5,4,8,3,7]
Output: 49

Solution (Java):

public int maxArea(int[] height) {
    int left = 0, right = height.length - 1;
    int maxArea = 0;

    while (left < right) {
        int area = Math.min(height[left], height[right]) * (right - left);
        maxArea = Math.max(maxArea, area);

        if (height[left] < height[right]) {
            left++;
        } else {
            right--;
        }
    }

    return maxArea;
}

Solution (Python):

def max_area(height):
    left, right = 0, len(height) - 1
    max_area = 0

    while left < right:
        area = min(height[left], height[right]) * (right - left)
        max_area = max(max_area, area)

        if height[left] < height[right]:
            left += 1
        else:
            right -= 1

    return max_area

Time Complexity: O(n) | Space Complexity: O(1)

3Sum

Problem: Find all unique triplets that sum to zero.

Example:

Input: [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]

Solution (Java):

public List<List<Integer>> threeSum(int[] nums) {
    Arrays.sort(nums);
    List<List<Integer>> result = new ArrayList<>();

    for (int i = 0; i < nums.length - 2; i++) {
        if (i > 0 && nums[i] == nums[i-1]) continue;

        int left = i + 1, right = nums.length - 1;

        while (left < right) {
            int sum = nums[i] + nums[left] + nums[right];

            if (sum == 0) {
                result.add(Arrays.asList(nums[i], nums[left], nums[right]));
                while (left < right && nums[left] == nums[left+1]) left++;
                while (left < right && nums[right] == nums[right-1]) right--;
                left++;
                right--;
            } else if (sum < 0) {
                left++;
            } else {
                right--;
            }
        }
    }

    return result;
}

Solution (Python):

def three_sum(nums):
    nums.sort()
    result = []

    for i in range(len(nums) - 2):
        if i > 0 and nums[i] == nums[i-1]:
            continue

        left, right = i + 1, len(nums) - 1

        while left < right:
            total = nums[i] + nums[left] + nums[right]

            if total == 0:
                result.append([nums[i], nums[left], nums[right]])
                while left < right and nums[left] == nums[left+1]:
                    left += 1
                while left < right and nums[right] == nums[right-1]:
                    right -= 1
                left += 1
                right -= 1
            elif total < 0:
                left += 1
            else:
                right -= 1

    return result

Time Complexity: O(n²) | Space Complexity: O(1)

Binary Tree Level Order Traversal

Problem: Return level order traversal of binary tree.

Solution (Java):

public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> result = new ArrayList<>();
    if (root == null) return result;

    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);

    while (!queue.isEmpty()) {
        int size = queue.size();
        List<Integer> level = new ArrayList<>();

        for (int i = 0; i < size; i++) {
            TreeNode node = queue.poll();
            level.add(node.val);

            if (node.left != null) queue.offer(node.left);
            if (node.right != null) queue.offer(node.right);
        }

        result.add(level);
    }

    return result;
}

Solution (Python):

from collections import deque

def level_order(root):
    if not root:
        return []

    result = []
    queue = deque([root])

    while queue:
        level = []
        for _ in range(len(queue)):
            node = queue.popleft()
            level.append(node.val)

            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)

        result.append(level)

    return result

Time Complexity: O(n) | Space Complexity: O(n)

Lowest Common Ancestor of Binary Tree

Problem: Find LCA of two nodes in a binary tree.

Solution (Java):

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    if (root == null || root == p || root == q) {
        return root;
    }

    TreeNode left = lowestCommonAncestor(root.left, p, q);
    TreeNode right = lowestCommonAncestor(root.right, p, q);

    if (left != null && right != null) {
        return root;
    }

    return left != null ? left : right;
}

Solution (Python):

def lowest_common_ancestor(root, p, q):
    if not root or root == p or root == q:
        return root

    left = lowest_common_ancestor(root.left, p, q)
    right = lowest_common_ancestor(root.right, p, q)

    if left and right:
        return root

    return left if left else right

Time Complexity: O(n) | Space Complexity: O(h)

Median of Two Sorted Arrays

Problem: Find median with O(log(min(m,n))) complexity.

Example:

Input: [1,3], [2]
Output: 2.0

Solution (Java):

public double findMedianSortedArrays(int[] nums1, int[] nums2) {
    if (nums1.length > nums2.length) {
        return findMedianSortedArrays(nums2, nums1);
    }

    int m = nums1.length, n = nums2.length;
    int low = 0, high = m;

    while (low <= high) {
        int i = (low + high) / 2;
        int j = (m + n + 1) / 2 - i;

        int maxLeft1 = (i == 0) ? Integer.MIN_VALUE : nums1[i-1];
        int minRight1 = (i == m) ? Integer.MAX_VALUE : nums1[i];
        int maxLeft2 = (j == 0) ? Integer.MIN_VALUE : nums2[j-1];
        int minRight2 = (j == n) ? Integer.MAX_VALUE : nums2[j];

        if (maxLeft1 <= minRight2 && maxLeft2 <= minRight1) {
            if ((m + n) % 2 == 0) {
                return (Math.max(maxLeft1, maxLeft2) + Math.min(minRight1, minRight2)) / 2.0;
            } else {
                return Math.max(maxLeft1, maxLeft2);
            }
        } else if (maxLeft1 > minRight2) {
            high = i - 1;
        } else {
            low = i + 1;
        }
    }

    return 0.0;
}

Time Complexity: O(log(min(m,n))) | Space Complexity: O(1)

LRU Cache

Problem: Design LRU cache with O(1) get and put operations.

Solution (Java):

class LRUCache {
    private int capacity;
    private Map<Integer, Node> cache;
    private Node head, tail;

    class Node {
        int key, value;
        Node prev, next;
        Node(int k, int v) { key = k; value = v; }
    }

    public LRUCache(int capacity) {
        this.capacity = capacity;
        cache = new HashMap<>();
        head = new Node(0, 0);
        tail = new Node(0, 0);
        head.next = tail;
        tail.prev = head;
    }

    public int get(int key) {
        if (!cache.containsKey(key)) return -1;
        Node node = cache.get(key);
        remove(node);
        insert(node);
        return node.value;
    }

    public void put(int key, int value) {
        if (cache.containsKey(key)) {
            remove(cache.get(key));
        }
        if (cache.size() == capacity) {
            remove(tail.prev);
        }
        insert(new Node(key, value));
    }

    private void remove(Node node) {
        cache.remove(node.key);
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    private void insert(Node node) {
        cache.put(node.key, node);
        node.next = head.next;
        node.prev = head;
        head.next.prev = node;
        head.next = node;
    }
}

Solution (Python):

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity):
        self.cache = OrderedDict()
        self.capacity = capacity

    def get(self, key):
        if key not in self.cache:
            return -1
        self.cache.move_to_end(key)
        return self.cache[key]

    def put(self, key, value):
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)

Time Complexity: O(1) for both operations | Space Complexity: O(capacity)

Trapping Rain Water

Problem: Calculate water trapped after raining.

Example:

Input: [0,1,0,2,1,0,1,3,2,1,2,1]
Output: 6

Solution (Java):

public int trap(int[] height) {
    if (height == null || height.length == 0) return 0;

    int left = 0, right = height.length - 1;
    int leftMax = 0, rightMax = 0;
    int water = 0;

    while (left < right) {
        if (height[left] < height[right]) {
            if (height[left] >= leftMax) {
                leftMax = height[left];
            } else {
                water += leftMax - height[left];
            }
            left++;
        } else {
            if (height[right] >= rightMax) {
                rightMax = height[right];
            } else {
                water += rightMax - height[right];
            }
            right--;
        }
    }

    return water;
}

Solution (Python):

def trap(height):
    if not height:
        return 0

    left, right = 0, len(height) - 1
    left_max, right_max = height[left], height[right]
    water = 0

    while left < right:
        if left_max < right_max:
            left += 1
            left_max = max(left_max, height[left])
            water += left_max - height[left]
        else:
            right -= 1
            right_max = max(right_max, height[right])
            water += right_max - height[right]

    return water

Time Complexity: O(n) | Space Complexity: O(1)

Word Ladder

Problem: Find shortest transformation sequence from beginWord to endWord.

Solution (Java):

public int ladderLength(String beginWord, String endWord, List<String> wordList) {
    Set<String> wordSet = new HashSet<>(wordList);
    if (!wordSet.contains(endWord)) return 0;

    Queue<String> queue = new LinkedList<>();
    queue.offer(beginWord);
    int level = 1;

    while (!queue.isEmpty()) {
        int size = queue.size();

        for (int i = 0; i < size; i++) {
            String word = queue.poll();

            char[] chars = word.toCharArray();
            for (int j = 0; j < chars.length; j++) {
                char original = chars[j];

                for (char c = 'a'; c <= 'z'; c++) {
                    if (c == original) continue;
                    chars[j] = c;
                    String newWord = new String(chars);

                    if (newWord.equals(endWord)) return level + 1;

                    if (wordSet.contains(newWord)) {
                        queue.offer(newWord);
                        wordSet.remove(newWord);
                    }
                }

                chars[j] = original;
            }
        }

        level++;
    }

    return 0;
}

Time Complexity: O(M² × N) | Space Complexity: O(M × N)

Merge k Sorted Lists

Problem: Merge k sorted linked lists into one sorted list.

Solution (Java):

public ListNode mergeKLists(ListNode[] lists) {
    PriorityQueue<ListNode> pq = new PriorityQueue<>((a, b) -> a.val - b.val);

    for (ListNode node : lists) {
        if (node != null) {
            pq.offer(node);
        }
    }

    ListNode dummy = new ListNode(0);
    ListNode curr = dummy;

    while (!pq.isEmpty()) {
        ListNode node = pq.poll();
        curr.next = node;
        curr = curr.next;

        if (node.next != null) {
            pq.offer(node.next);
        }
    }

    return dummy.next;
}

Solution (Python):

import heapq

def merge_k_lists(lists):
    heap = []

    for i, node in enumerate(lists):
        if node:
            heapq.heappush(heap, (node.val, i, node))

    dummy = ListNode(0)
    curr = dummy

    while heap:
        val, idx, node = heapq.heappop(heap)
        curr.next = node
        curr = curr.next

        if node.next:
            heapq.heappush(heap, (node.next.val, idx, node.next))

    return dummy.next

Time Complexity: O(N log k) | Space Complexity: O(k)

Practice Tips for Adobe OA

Master DSA Fundamentals

Arrays, strings, trees, graphs
Dynamic programming patterns
Linked lists, stacks, queues
Hash maps and sets

Focus on Medium-Hard

Adobe asks harder problems
Practice LeetCode medium/hard
Focus on optimization
Understand time complexity

Time Management

30 minutes per problem
Read problem carefully
Start with brute force
Optimize if time permits

Common Patterns

Two pointers
Sliding window
Binary search
BFS/DFS
Dynamic programming

Practice More Adobe Coding Questions →

Adobe 2024 Papers

Previous year papers with coding questions

View 2024 Papers →

Adobe 2025 Papers

Latest papers with current year questions

View 2025 Papers →

Adobe Interview Experience

Real interview experiences

Read Experiences →

Adobe Preparation Guide

Comprehensive preparation strategy

View Preparation Guide →

Adobe Main Page

Complete Adobe placement guide

View Main Page →

Practice Adobe coding questions regularly! Focus on medium-hard DSA problems. Adobe values optimal solutions and clean code.

Pro Tip: Adobe interviews emphasize problem-solving approach. Think out loud and communicate your thought process clearly.

Last updated: February 2026

Adobe Coding Questions 2025 - DSA Problems & System Design with Solutions

Adobe Placement Paper Coding Questions - Complete Guide

Adobe OA Coding Section Overview

Coding Problems by Difficulty

Practice Tips for Adobe OA

FAANG & Top Tech

Global Tech Companies

Indian Product Companies

Service-Based Companies

Big 4 Consulting

Investment Banks

Indian Banks & FinTech

Global Banks & Financial Services

Indian Conglomerates

Retail & E-commerce

Government & PSUs

Compare Companies

Adobe Coding Questions 2025 - DSA Problems & System Design with Solutions

Adobe Placement Paper Coding Questions - Complete Guide

Adobe OA Coding Section Overview

Coding Problems by Difficulty

Practice Tips for Adobe OA

Related Resources

FAANG & Top Tech

Global Tech Companies

Indian Product Companies

Service-Based Companies

Big 4 Consulting

Investment Banks

Indian Banks & FinTech

Global Banks & Financial Services

Indian Conglomerates

Retail & E-commerce

Government & PSUs

Compare Companies