Snowflake SDE OA Experience: Two HackerRank Questions Breakdown (2026)

Just finished this Snowflake SDE OA, and honestly the two HackerRank problems were not the type that require crazy algorithms. The ideas came pretty quickly, but most of the time was spent carefully implementing the details.

However, I do not want to only share solutions. There is one thing about Snowflake OA that many candidates underestimate: you need to pass all test cases to move forward to the VO stage.

Because the problems look straightforward, they are actually more dangerous. Many candidates think "the logic is simple, I can just code it quickly", but one missing edge case or one incorrect condition can fail hidden test cases and end the process.

For Snowflake OA, the mindset is different from many other companies: it is not just about solving the problem. It is about getting a perfect score with zero failed cases.

Snowflake OA Format and Rules

The assessment platform is HackerRank. There are two coding questions, usually around medium difficulty. One is typically easier with an important observation, while the other requires more careful dynamic programming or counting logic.

The input sizes are not always huge, but each problem has a key insight. Once you identify the pattern, the implementation is relatively short.

The most important thing is the all-pass requirement: every hidden test case matters. Missing even one edge case can prevent you from reaching the interview stage.

Question 1: Generating Login Codes (Two Pointer + Segmentation)

Problem Description

You are given two arrays:

• initialLogin with length n
• standardLogin with length m

You can repeatedly perform an operation:

Choose any continuous subarray from either array and replace it with the sum of its elements.

For example:

[1,5,6,8,2]

can become:

[12,8,2]

by replacing [1,5,6] with [12].

The goal is to make the two arrays equal after operations, while maximizing the final length. If it is impossible, return -1.

Example:

initialLogin = [2,4,3,7,10]
standardLogin = [6,5,5,10]

Answer = 3

Solution Approach

The first observation is the impossibility condition:

Replacing segments with their sums changes only the segmentation, not the total sum. Therefore, if the total sums of the two arrays are different, the answer must be -1.

When the sums are equal, use a two-pointer segmentation strategy.

Maintain two pointers and accumulate segment sums from both arrays. Whenever one side has a smaller current sum, continue extending that side. Once both segment sums become equal, we have found one matching segment. Increase the answer count and continue from the next positions.

The final number of matched segments is the maximum possible length.

Time complexity:

O(n + m)

Common Edge Cases

• Do not forget the total sum comparison. Different sums must immediately return -1.
• Carefully handle the final unmatched segment.
• Make sure both pointers finish correctly.

Question 2: String Formation (Dynamic Programming Counting)

Problem Description

You are given an array of strings where every string has the same length, and a target string.

You need to build the target string by selecting characters from the given words. The selected character positions must be strictly increasing.

Different solutions are counted separately if:

• The selected index sequence is different.
• The same index is selected but the character comes from a different word.

Return the number of ways modulo 10^9 + 7.

Example:

words = ["adc","aec","efg"]
target = "ac"

Answer = 4

Solution Approach

This is a classic dynamic programming counting problem.

Define:

dp[j] = number of ways to match the first j characters of target

Initialize:

dp[0] = 1

Before running the DP, preprocess:

For each position i and character c, count how many words have character c at position i:

cnt[i][c]

Then iterate through positions from left to right. For each position, update the DP array from right to left:

dp[j] += dp[j-1] * cnt[i][target[j-1]]

The backward update is critical because it prevents using the same index multiple times.

The final answer is:

dp[target.length]

Common Edge Cases

• Always apply modulo operations to avoid overflow.
• Update DP from right to left, not left to right.
• Remember that selected indexes must be strictly increasing.

Why Many Candidates Fail Snowflake OA

The biggest trap with Snowflake OA is that the problems often look easier than they actually are.

The algorithms are not necessarily the hardest part. The challenge is writing completely correct code under a strict all-test-case requirement.

For these two questions, the most common mistakes are:

• Missing the total sum check in the segmentation problem.
• Forgetting modulo operations in DP counting.
• Updating DP in the wrong direction.

Your solution can be 90% correct and still fail the OA because of one hidden case.

My recommendation for Snowflake OA preparation is simple: even when the idea feels obvious, reserve time to manually test edge cases before submitting.

Preparation Resources

The good news is that Snowflake OA questions have a relatively high repetition rate. These patterns, including two-pointer segmentation and DP counting, appear frequently.

During preparation, I used InterviewShow to review frequently asked OA questions and solution patterns. For an assessment where every test case matters, reviewing common templates and edge cases beforehand can save a lot of time during the real test.

Good luck to everyone preparing for Snowflake SDE OA. Hope you all get a perfect score and move on to the VO stage.