HackTheRounds Interview Experiences

Snowflake New Grad OA Interview Experience (2026) - Sort-Split Count, Flip-One Abs Sum & Parenthesis DP, Offer

Snowflake 2026 New Grad HackerRank OA: three problems in 120 minutes covering prefix max/suffix min split counting, single flip absolute sum minimization, and D

By Anonymous ยท 2026-04-17

Background

The Snowflake New Grad OA came through on a Thursday night about a week after my college career fair, and I almost missed the email because it landed in promotions. I am a final-year CS major at a mid-tier target school with one data-engineering internship at a consumer analytics company on my resume. My prep had been focused on Stripe and Databricks at the time, so Snowflake was a surprise add to my cycle. Three coding problems in 120 minutes on HackerRank, all algorithmic, no SQL or data-pipeline flavor despite the company being a warehouse. I cleared the round with all three problems passing full hidden-test credit and got the onsite invite seven business days later. Offer eventually landed.

Timeline

Online Assessment (120 min, HackerRank)

The 2026 Snowflake OA is deceptively tight on time for three problems. The platform is HackerRank in the standard multi-language editor with visible sample tests plus a hidden grading set. My session allowed Python, Java, Go, and C++. I used Python because two of the three problems were parsing-heavy. What separates Snowflake from most OA pools is the emphasis on modeling: the prompts describe business-ish scenarios and force you to translate them into DP or counting arguments. You will not see classic "rotate matrix" or "reverse linked list" here.

Problem 1: Sort-Then-Concatenate Split Count

Problem: Given an array of N integers, count the number of ways to split it into a non-empty left prefix and a non-empty right suffix such that sorting each half independently and concatenating them produces a fully non-decreasing array.

The valid split points are exactly the positions where the maximum of the left prefix is at most the minimum of the right suffix. Precompute a prefix-max array walking left to right, and a suffix-min array walking right to left. Then for each candidate split index i , check whether prefix max[i] <= suffix min[i + 1] . Count the indices that satisfy the condition.

The instinct is to try every split, sort both halves, and verify, but that is cubic and fails the N = 10^5 hidden tests. The prefix-max and suffix-min framing collapses the problem to two linear sweeps plus a linear scan. The corner case worth calling out is N < 2 , where there are no valid splits because both halves must be non-empty.

Practice it: no exact match in the current Snowflake set, so I did not link this one.

This question is coming soon to HackTheRounds.

Problem 2: Minimize Absolute Sum by Flipping One Element

Problem: Given an array of N integers, you may multiply at most one element by -1 . Return the minimum achievable value of the absolute sum after the operation.

Let the current total be S . Flipping arr[k] changes the sum to S - 2 arr[k] . We want the magnitude of the new sum as small as possible, which means choosing the arr[k] whose doubled value is closest to S . Equivalently, find the element v in the array minimizing abs(S - 2 v) .

That reduces to a single-pass scan if you allow linear time, or a binary search on a sorted copy if you want log N per query. The element pool includes its original sign, so positive and negative arr[k] both need to be considered. Also, "at most one flip" means the base case abs(S) is itself a candidate answer, in case the original sum is already the minimum.

I double-checked the three examples from the prompt during coding: the positive-array case, the negative-heavy case, and the case where no flip improves the result. All three fall out of the same formula.

Practice it: no exact match in the current Snowflake set, so I did not link this one.

This question is coming soon to HackTheRounds.

This question is coming soon to HackTheRounds.

Problem 3: Balanced Parentheses Max Efficiency

Problem: You are given an initial parenthesis string s , a "toolkit" string kitParentheses , and a score array efficiencyRatings assigning a signed value to each toolkit character. Starting from s and inserting any subset of toolkit characters (order preserved among kept characters), construct a balanced parenthesis sequence and maximize the sum of scores of the original string plus the kept toolkit characters.

This is dynamic programming on balance. Model the state as (position in the eventual string, current open-minus-close count) . Transitions: keep or skip each toolkit character, and always consume the original string's characters in order. The objective is the maximum accumulated score reaching (end, balance = 0) . The balance dimension is bounded by the total length of both strings, so the state space is O(|s| + |kit|) ^ 2 which fits in the constraints.

Two implementation details mattered. First, the initial string is mandatory: you cannot drop any of its characters, only augment around them. Second, the toolkit scores can be negative, so greedy insertion does not work. A negative-weight close-paren might still be forced to keep balance non-negative, in which case you accept the cost.

The corner cases include an empty initial string (answer is the max balanced subset of the toolkit), an initial string that is already unfixable without toolkit support (the prompt guarantees a solution exists), and a toolkit where every score is non-positive (you use as few characters as possible, often zero).

Practice it: no exact match in the current Snowflake set, so I did not link this one.

This question is coming soon to HackTheRounds.

Result

Three-for-three on visible tests, full credit on the hidden grader per the recruiter's follow-up. Got the onsite invite a week later, cleared a 5-round virtual onsite, and received the offer six business days after the final round.

Tips

  1. Model before you code. Snowflake's OA problems reward whiteboard thinking. The sort-split and minimize-abs-sum problems both have `O(N^2)` or worse brute-force solutions that collapse to linear once you identify the right reformulation. Spend five minutes outlining the invariant before touching the editor.
  2. DP on balance is the default for parenthesis-with-weights prompts. Any time you see "maximum score while keeping parentheses balanced," pair the string index with the running open count as your DP state. Do not try to greedy your way through negative scores.
  3. Prefix-max and suffix-min are the two highest-yield precomputations. Snowflake recycled this pattern in Problem 1 and I have seen variants in Databricks and MongoDB OAs as well. A clean implementation is ten lines. Have it memorized.
  4. For "flip at most one element" optimizations, write out the post-flip formula explicitly. The answer almost always reduces to "find the element that makes the post-flip value closest to some target." That is a single pass, not a simulation.
  5. Use HackerRank's custom input box. The default sample tests do not cover edge cases like empty strings or single-element arrays. Paste your own edge-case inputs and run before you submit. Partial credit on the hidden grader is the difference between passing the OA and getting auto-rejected.
  6. Pick Python unless you have strong reason otherwise. Snowflake's 120-minute budget feels comfortable in Python, tight in Java, and slightly painful in C++ for three problems with string parsing. Use the language with the fewest keystrokes per unit of logic.