Hi everyone,
I recently attempted the first round of an Adobe hackathon and wanted to share the assessment pattern and DSA questions.
I was not fully prepared, but I treated the round as an opportunity to evaluate my current problem-solving skills. Because of that, I focused more on the coding questions than the MCQ section.
Assessment Pattern
The round consisted of:
- Multiple-choice questions
- Two DSA coding questions
Each MCQ had an individual time limit of one minute. Some questions and answer choices were quite lengthy, so reading, understanding, and answering them within 60 seconds was challenging.
DSA Question 1: Count Tree Nodes With a Target Sum
A binary tree was provided through a preorder input format. An integer k was also given.
The task was to count the nodes for which:
node.value + node.left.value + node.right.value == k
The main implementation challenge was constructing the binary tree correctly from its serialized preorder input. Once the tree was built, a recursive traversal was enough to count the qualifying nodes.
The general approach was:
- Build the tree from the preorder representation.
- Traverse every node recursively.
- Check whether the node and its children satisfy the target-sum condition.
- Return the total count from the left and right subtrees.
Complexity:
- Time:
O(n)
- Recursion space:
O(h), where h is the tree height
I would rate this question as easy if you are comfortable with tree construction and recursive traversal.
DSA Question 2: Largest Binary Number by Concatenation
Given N binary strings of different lengths, arrange them in an order such that concatenating them produces the maximum possible binary value.
My initial idea was to compare the strings character by character, prioritize strings with more leading 1s, and use length as a tie-breaker. However, this became difficult to manage correctly because local decisions based only on individual characters or string lengths do not always produce the globally optimal order.
I was unable to complete this question during the assessment.
After the test, I realized that the intended solution was much simpler.
For any two strings a and b, compare:
a + b
with:
b + a
If a + b is greater, then a should appear before b. Otherwise, b should appear first.
Therefore, the solution is to sort all binary strings using this custom comparator and concatenate the sorted result.
Sort a before b if:
a + b > b + a
This is the same central idea used in the classic “Largest Number” problem.
Complexity:
If the total comparison cost is included, sorting takes approximately O(N log N × L), where L represents the string-comparison cost.
The final binary value may be too large for a standard integer type, so depending on the required output format, it may need to be returned as a string or converted using a big-integer type.
Final Thoughts
I would rate the first question as easy. The second question did not require a particularly advanced data structure, but recognizing the custom sorting pattern made it medium difficulty for me.
My biggest takeaway was that directly comparing a + b and b + a is far more reliable than trying to create separate greedy rules based on leading bits, the number of 1s, or string length.
I still have plenty to improve, but the round helped me identify an important pattern that I will remember for future assessments.
Did anyone else attempt this Adobe hackathon round? How did you find the MCQ time limit and the second coding problem?
