Snowflake Online Assessment Questions

Snowflake SWE AI/ML Intern Online Assessment Problems

I recently gave the Snowflake SWE AI/ML Intern OA, and these were the three problems asked. The languages allowed were Go, Java, and Python only. --- # Problem 1: Simple Array Rotation Game ## **Descr

EPAM Lead Data Engineer Interview Experience

EPAM Lead Data Engineer Interview Experience : 1.Online Test 1 hr 30mins around 1.Multiple choice questions 10 2. one SQL question ( Find the total number of unique students...

SDE SNOWFLAKE OA

1. Table of Contents Create a table of contents for a simple markup language. It must follow two rules: 1. If a line starts with a single # followed by a space,...

Snowflake OA

!/bin/python3 import math import os import random import re import sys from collections import defaultdict from typing import List class Graph: def __init__(self, vertices: int): self.vertices = vertices self.adjacency_list = [[] for _ in range(vertices)] # Use of NoEdge(int,...

Snowflake OA | Oct 14th

A super bitstring is a a bitstring made by flipping zero or more of the 0s in the bit string to 1. Given k decimal integers, convert each to a bit...

Magnitude Software | ASE | Hyderabad

YOE : - 6 Months OA : 2 Coding + mcq 1. First question was based upon dp similar to Subset sum. 2. Second question was based upon simple sorting...

Snowflake Interview Experience

I applied for Snowflake Fall Co-op through a referral. I got the link for OA. Question in OA were mostly from DP(3 question time:90 minutes) varying form medium to hard...

Array Reduction 4: Reduce an Array by Repeatedly Removing the Minimum Pair Sum

## Problem Given an integer array, repeatedly perform the following operation until one element remains: - Find the two smallest elements, remove them, and insert their sum back into the array. Return the total cost (sum of all inserted sums across all operations). This is equivalent to building an optimal merge tree (Huffman-style). ```python from typing import List def array_reduction(nums: List[int]) -> int: # return the total cost of all merge operations pass ``` **Example:** ``` Input: [4, 3, 2, 6] Step 1: merge 2+3=5, cost=5, array=[4,5,6] Step 2: merge 4+5=9, cost=9, array=[6,9] Step 3: merge 6+9=15, cost=15, array=[15] Output: 5+9+15 = 29 ``` ## Approach Use a min-heap. At each step, pop two smallest elements, compute their sum, accumulate cost, and push the sum back. Time: O(n log n). ## Follow-ups 1. Why does a greedy min-heap strategy provably minimize total cost here? 2. What is the worst-case array that maximizes total cost for a fixed sum of elements? 3. How would the answer change if you could merge any k elements (not just 2) at each step? 4. How would you reconstruct the merge tree, not just the cost?

Snowflake SWE OA - Coloring Houses

## Problem Color a row of houses with given constraints (adjacent houses cannot share the same color) while minimizing total cost. Classic DP problem. ## Likely LeetCode equivalent No direct match. ## Tags dynamic_programming, arrays, oa

Efficient Cost: Minimize Total Cost to Connect All Nodes in a Network

## Problem You are given `n` nodes and a list of potential edges, each with a cost. Find the minimum total cost to connect all nodes (i.e., build a minimum spanning tree). If it is impossible to connect all nodes, return -1. ```python from typing import List def min_connection_cost(n: int, edges: List[List[int]]) -> int: # n: number of nodes (1-indexed) # edges: [[node_a, node_b, cost], ...] # return: minimum total cost, or -1 if not fully connectable pass ``` **Example:** ``` n = 4 edges = [[1,2,3],[1,3,1],[2,3,2],[2,4,4],[3,4,1]] MST edges: (1,3,1), (3,4,1), (1,2,3) or (2,3,2) Minimum cost = 1+1+2 = 4 Output: 4 ``` ## Approach Kruskal's with Union-Find: sort edges by cost, greedily add edges that don't form a cycle. Time: O(E log E). ## Follow-ups 1. When would you prefer Prim's algorithm over Kruskal's? 2. What if some nodes already have a free connection (cost = 0) — does the algorithm change? 3. How would you find the second-minimum spanning tree? 4. In a distributed setting with millions of edges, how would you compute MST across partitioned data?