Prepare for and practice interview questions from Smartworks.

Smartworks Interview Questions

smartworks embeds world-class systems that help leaders of teams and enterprises free up their people to work smarter. deliver more of your organisation's most valuable ideas and work - reach out to us to learn how we might help...

smartworks embeds world-class systems that help leaders of teams and enterprises free up their people to work smarter. deliver more of your organisation's most valuable ideas and work - reach out to us to learn how we might help...

Overview

Smartworks Interview Guides

Data Structures & Algorithms

Write a function to select only the rows where the student's favorite color is green or red and their grade is above 90.

Good Grades and Favorite Colors

Weighted Keys

Write a function to return the optimal friend that should host the party.

Optimal Host

Write a function to determine whether or not two rectangles overlap.

Rectangle Overlap

Write a function to rotate an array by 90 degrees in the clockwise direction.

Matrix Rotation

Machine Learning

Missing Housing Data

Bagging vs Boosting

Type-ahead Search

choosing k value during k-means clustering

Choosing k

Let's say that you're training a classification model.   How would you combat overfitting when building tree-based models?

Overfit Avoidance

Select the 2nd highest salary in the engineering department

2nd Highest Salary

Get the top 3 highest employee salaries by department

Top Three Salaries

Find the difference between users' first and last sessions in the year

Session Difference

Subscription Retention

Identify which purchases were users' first purchases within a product category.

Repeated Category Purchase

Statistics

P-value to a Layman

What are the assumptions of linear regression?

Assumptions of Linear Regression

You are testing hundreds of hypotheses with many t-tests. What considerations should be made?

Hundreds of Hypotheses

Possibly Biased Coin

A/B Testing

Sample Size Bias

New UI Effect

Precisely ascertain whether the outcomes of an A/B test, executed to assess the impact of a landing page redesign, exhibit statistical significance.

Statistically Significant Test

Challenge

When an interviewer asks a question along the lines of:

<ul>
<li>What would your current manager say about you? What constructive criticisms might he give?</li>
<li>What are your three biggest strengths and weaknesses you have identified in yourself?</li>
</ul>

How would you respond?

When asked about your strengths in an interview, what is an effective way to respond?

When asked about your strengths in an interview, what is an effective way to respond?

Your Strengths and Weaknesses I

Which of the following is an acceptable strategy when discussing weaknesses in an interview?

Which of the following is an acceptable strategy when discussing weaknesses in an interview?

Your Strengths and Weaknesses II

What do you tell an interviewer when they ask you what your strengths and weaknesses are?

Your Strengths and Weaknesses

Brainteasers

Describe a data project you worked on. What were some of the challenges you faced?

Describing a data project and its challenges

Hurdles In Data Projects

Analytics

How would you explain what a p-value is to someone who is not technical?

What does a p-value in a statistical test represent?

What does a p-value in a statistical test represent?

P-value to a Layman I

In a statistical test, how does a low p-value (less than 0.05) influence our decision about the null hypothesis?

In a statistical test, how does a low p-value (less than 0.05) influence our decision about the null hypothesis?

P-value to a Layman II

What are the assumptions of linear regression?

Which assumption of the residuals of the standard linear regression model can not be overcome by increasing the sample size?

Regression assumptions

Let’s say that you’re training a classification model.

How would you combat overfitting when building tree-based models?

Let’s say we’re comparing two machine learning algorithms. In which case would you use a bagging algorithm versus a boosting algorithm? 

Give an example of the tradeoffs between the two.

In machine learning, when would you use a bagging algorithm over a boosting algorithm?

In machine learning, when would you use a bagging algorithm over a boosting algorithm?

Bagging vs. Boosting

Write a SQL query to select the 2nd highest salary in the engineering department.

Note: If more than one person shares the highest salary, the query should select the next highest salary.

Example:

Input:

<code>employees</code> table

<table>
<thead>
<tr>
<th>Column</th>
<th>Type</th>
</tr>
</thead>

<tbody>
<tr>
<td><code>id</code></td>
<td>INTEGER</td>
</tr>

<tr>
<td><code>first_name</code></td>
<td>VARCHAR</td>
</tr>

<tr>
<td><code>last_name</code></td>
<td>VARCHAR</td>
</tr>

<tr>
<td><code>salary</code></td>
<td>INTEGER</td>
</tr>

<tr>
<td><code>department_id</code></td>
<td>INTEGER</td>
</tr>
</tbody>
</table>
<code>departments</code> table

<table>
<thead>
<tr>
<th>Column</th>
<th>Type</th>
</tr>
</thead>

<tbody>
<tr>
<td><code>id</code></td>
<td>INTEGER</td>
</tr>

<tr>
<td><code>name</code></td>
<td>VARCHAR</td>
</tr>
</tbody>
</table>
Output:

<table>
<thead>
<tr>
<th>Column</th>
<th>Type</th>
</tr>
</thead>

<tbody>
<tr>
<td><code>salary</code></td>
<td>INTEGER</td>
</tr>
</tbody>
</table>

Create a class named <code>LRUCache</code> that implements the behavior expected of a Least Recently Used (LRU) Cache.

The <code>LRUCache</code> class implements the following methods:

<ul>
<li><code>__init__(self, capacity)</code> - initializes the object and takes in a capacity parameter specifying the maximum capacity of the cache.</li>
<li><code>get_if_exists(self, key) -&gt; Any|None</code> - gets a value based on a key. If the key exists, returns the associated value. If the key has expired or did not exist in the first place, returns <code>None</code>.</li>
<li><code>put(self, key, value)</code> - places a value inside the cache. In the case wherein the cache is full, invalidates the least recently used element. When two keys collide, the older value should be invalidated in place of the new one.</li>
</ul>

Example:

<pre tabindex="0" class="chroma"><code>cache = LRUCache(2)
cache.put(&#34;sample&#34;, 55)
cache.get_if_exists(&#34;sample&#34;) # returns 55
cache.get_if_exists(&#34;key&#34;) # returns None
cache.put(&#34;hello&#34;, 10) 
cache.put(&#34;sample&#34;, 9)
cache.put(&#34;world&#34;, 5)
cache.get_if_exists(&#34;hello&#34;) # returns None
</code></pre>

Notes:

<ul>
<li>It is assured that the value in the <code>put</code> method will never receive a <code>None</code> value. Moreover, it is assured that the capacity will always be &gt; 0.</li>

<li>All operations must be O(1).</li>

<li>Aside from Python’s standard dictionary implementation (<code>{}</code>), you may not use any other built-in data structures.</li>
</ul>

LRU Cache 1

Let’s say we want to launch a re-design of a landing page to improve the click-through rate. We can do this by implementing an AB test.
Given that we launch an AB test, how would you infer if the results of the click-through rate were statistically significant or not?

How can you accurately conclude if the results of an A/B test, conducted to evaluate the effectiveness of a landing page redesign, are statistically significant?

How can you accurately conclude if the results of an A/B test, conducted to evaluate the effectiveness of a landing page redesign, are statistically significant?

Given an array and a target integer, write a function <code>sum_pair_indices</code> that returns the indices of two integers in the array that add up to the target integer. If not found, just return an empty list.

Note: Can you do it on \(O(n)\) time?

Note: Even though there could be many solutions, only one needs to be returned.

Example 1:

Input:

<pre tabindex="0" class="chroma"><code>array = [1 2 3 4] 
target = 5 
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>def sum_pair_indices(array, target) -&gt; [0 3] or [1 2]
</code></pre>

Example 2:

Input:

<pre tabindex="0" class="chroma"><code>array = [3]
target = 6 
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>Do NOT return [0 0] as you can&#39;t use an index twice.
</code></pre>

Given an array and a target integer, write a function that returns the indices of two integers in the array that add up to the target integer.

Target Indices

<h1>Binary Tree Validation</h1>

You are given the root of a binary tree. You need to determine if it is a valid binary search tree (BST).

A valid BST is defined as follows:

<ul>
<li>The left subtree of a node contains only nodes with values less than or equal to the node’s value.</li>
<li>The right subtree of a node contains only nodes with values greater than or equal to the node’s value.</li>
<li>Both the left and right subtrees must also be binary search trees.</li>
</ul>

Given the function <code>def is_valid_bst(root: Node) -&gt; bool:</code>, return True if the binary tree is a valid BST. Otherwise, return False.

<h3>Example:</h3>

Input:

<img src="https://d2qpirhrfplx04.cloudfront.net/9664817c-3e12-4a40-9236-8382b13f55a0.png" alt="image"/>Converted Binary Tree.png

Output:

<pre tabindex="0" class="chroma"><code>def is_valid_bst(Node(3)) -&gt; True
</code></pre>

Given the root node, verify if a binary search tree is valid or not.

Binary Tree Validation

The Fibonacci sequence is a series of numbers in which each number is the sum of the two preceding ones, usually starting with 0 and 1. It is often used in algorithm examples, and is defined by the following formula: F(n) = F(n-1) + F(n-2), with F(0) = 0 and F(1) = 1.

Your task is to implement the Fibonacci algorithm in three different methods:
1. Recursively
2. Iteratively
3. Using Memoization

Example 1:

Input:

<pre tabindex="0" class="chroma"><code>n = 5
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>fibonacci(n) -&gt; 5
</code></pre>

Example 2:

Input:

<pre tabindex="0" class="chroma"><code>n = 10
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>fibonacci(n) -&gt; 55
</code></pre>

The Fibonacci sequence starts as follows: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55…

This question requires the implementation of the Fibonacci sequence using three different methods: recursively, iteratively, and using memoization.

Implementing the Fibonacci Sequence in Three Different Methods

Given the <code>employees</code> and <code>departments</code> table, write a query to get the top 3 highest employee salaries by department. If the department contains less that 3 employees, the top 2 or the top 1 highest salaries should be listed (assume that each department has at least 1 employee). 

Note: The output should include the full name of the employee in one column, the department name, and the salary. The output should be sorted by department name in ascending order and salary in descending order. 

Example:

Input:

<code>employees</code> table

<table>
<thead>
<tr>
<th>Column</th>
<th>Type</th>
</tr>
</thead>

<tbody>
<tr>
<td><code>id</code></td>
<td>INTEGER</td>
</tr>

<tr>
<td><code>first_name</code></td>
<td>VARCHAR</td>
</tr>

<tr>
<td><code>last_name</code></td>
<td>VARCHAR</td>
</tr>

<tr>
<td><code>salary</code></td>
<td>INTEGER</td>
</tr>

<tr>
<td><code>department_id</code></td>
<td>INTEGER</td>
</tr>
</tbody>
</table>
<code>departments</code> table

<table>
<thead>
<tr>
<th>Column</th>
<th>Type</th>
</tr>
</thead>

<tbody>
<tr>
<td><code>id</code></td>
<td>INTEGER</td>
</tr>

<tr>
<td><code>name</code></td>
<td>VARCHAR</td>
</tr>
</tbody>
</table>
Output:

<table>
<thead>
<tr>
<th>Column</th>
<th>Type</th>
</tr>
</thead>

<tbody>
<tr>
<td><code>employee_nam</code>e</td>
<td>VARCHAR</td>
</tr>

<tr>
<td><code>department_name</code></td>
<td>VARCHAR</td>
</tr>

<tr>
<td><code>salary</code></td>
<td>INTEGER</td>
</tr>
</tbody>
</table>

Given two strings, write a function to return <code>True</code> if the strings are anagrams of each other and <code>False</code> if they are not.

Note: A word is not an anagram of itself.

Example 1:

Input:

<pre tabindex="0" class="chroma"><code>string_1 = &#34;listen&#34;
string_2 = &#34;silent&#34;
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>True
</code></pre>

Example 2:

Input:

<pre tabindex="0" class="chroma"><code>string_1 = &#34;banana&#34;
string_2 = &#34;bandana&#34;
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>False
</code></pre>

Valid Anagram

We want to build a model to predict housing prices in the city of Seattle. We’ve scraped 100K sold listings over the past three years but found that around 20% of the listings are missing square footage data.

How do we deal with the missing data to construct our model?

We want to build a model to predict housing prices in the city of Seattle. We’ve scraped 100K sold listings over the past three years, but have discovered that around 20% of the listings are missing square footage data.

How would you approach dealing with this missing data, in order to construct the most useful predictive model possible?

We want to build a model to predict housing prices in the city of Seattle. We’ve scraped 100K sold listings over the past three years, but have discovered that around 20% of the listings are missing square footage data.

How would you approach dealing with this missing data, in order to construct the most useful predictive model possible?



Given a list of integers, identify all the duplicate values in the list. Assume that the list can contain both positive and negative numbers, and the order of the list does not matter. A number is considered a duplicate if it appears more than once in the list. Return a list of the duplicate numbers.

Example 1:

Input:

<pre tabindex="0" class="chroma"><code>nums = [1, 2, 3, 1, 2, 3]
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>find_duplicates(nums) -&gt; [1, 2, 3]
</code></pre>

The numbers 1, 2, and 3 all appear more than once in the list, so they are considered duplicates.

Example 2:

Input:

<pre tabindex="0" class="chroma"><code>nums = [1, -1, 2, 3, 3, -1]
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>find_duplicates(nums) -&gt; [-1, 3]
</code></pre>

The numbers -1 and 3 both appear more than once in the list, so they are considered duplicates. Note that the order of the output does not matter.

Example 3:

Input:

<pre tabindex="0" class="chroma"><code>nums = [1, 2, 3, 4, 5]
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>find_duplicates(nums) -&gt; []
</code></pre>

None of the numbers in the list appear more than once, so there are no duplicates.

This problem involves identifying duplicate numbers in a list of integers. The function should return a list of the duplicate numbers.

Find Duplicate Numbers in a List

How would you choose the k value when using k-means clustering?

Let’s say we’re testing a new UI with the goal to increase conversion rates. We test it by giving the new UI to a random subset of users.

The test variant wins by 5% on the target metric. What would you expect to happen after the new UI is applied to all users? Will the metric actually go up by ~5%, more, or less?

Note: Assume there is no novelty effect.

You are given a binary tree of unique positive numbers. Each node in the binary tree is represented as a dictionary with the following keys:

<ul>
<li><code>data</code>: integer value stored in the node</li>
<li><code>left</code>: reference to the left child (or <code>None</code>)</li>
<li><code>right</code>: reference to the right child (or <code>None</code>)</li>
</ul>

<pre tabindex="0" class="chroma"><code>node = {
 &#34;data&#34;: 6,
 &#34;left&#34;: {
 &#34;data&#34;: 3,
 &#34;left&#34;: {...},
 &#34;right&#34;: {...}
 },
 &#34;right&#34;: {
 &#34;data&#34;: 9,
 &#34;left&#34;: {...},
 &#34;right&#34;: {...}
 }
}
</code></pre>

Given two node values as input (<code>value1</code> and <code>value2</code>), write a function to return the value of the nearest common ancestor (lowest node in the tree that has both nodes as descendants).

Note: If one of the nodes doesn’t exist in the tree, return <code>-1</code>.

Example:

Input:

<pre tabindex="0" class="chroma"><code># Diagram of the binary tree
&#39;&#39;&#39;
 6 
 / \ 
 3 9 
 / \
 2 11
 / \
 5 8
&#39;&#39;&#39;
value1 = 8
value2 = 2
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>common_ancestor(root,value1,value2) -&gt; 3
</code></pre>

Explanation:

<ul>
<li>Ancestors of <code>8</code>: <code>11 → 3 → 6</code></li>
<li>Ancestors of <code>2</code>: <code>3 → 6</code></li>
<li>Common ancestors: <code>3</code> and <code>6</code></li>
<li>The nearest common ancestor is <code>3</code>.</li>
</ul>

Write a function to return the value of the nearest node that is a parent to both nodes.

Nearest Common Ancestor

Let’s say you have to analyze the results of an AB test.

One variant of the AB test has a sample size of 50K users and the other has a sample size of 200K users.

Given the unbalanced size between the two groups, can you determine if the test will result in bias towards the smaller group?

Given an AB test where one variant has a sample size of 50K users and the other has a sample size of 200K users, what is the likely effect of the unbalanced sizes on the test results?

Given an AB test where one variant has a sample size of 50K users and the other has a sample size of 200K users, what is the likely effect of the unbalanced sizes on the test results?

Let’s say that you’re the PM on Google Maps.

<ol>
<li>How would you improve Google Maps?</li>

<li>What metrics would you check to see if your feature improvements are successful?</li>
</ol>

Google Maps Improvement

Product Sense & Metrics

Write a Python function called <code>group_anagrams</code> that takes a list of strings as input and returns a list of lists, where each inner list contains a group of anagrams that were present in the input list.

An anagram is a word or phrase formed by rearranging the letters of a different word or phrase, using all the original letters exactly once.

Note: Each of the inner lists should be ordered alphabetically and contain no duplicate values

<h3>Example:</h3>

Input:

<pre tabindex="0" class="chroma"><code>words = [&#34;eat&#34;, &#34;tea&#34;, &#34;tan&#34;, &#34;ate&#34;, &#34;nat&#34;, &#34;bat&#34;]
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>[ 
 [&#34;nat&#34;,&#34;tan&#34;],
 [&#34;ate&#34;,&#34;eat&#34;, &#34;tea&#34;],
 [&#34;bat&#34;]
]
</code></pre>

Explanation:

In the example, the words “eat”, “tea”, and “ate” are anagrams of each other, as are the words “tan” and “nat”. The word “bat” does not have any anagrams in the input list, and therefore is listed on its own. The function then groups the anagrams together and returns a list of lists representing these groups.

Each of the lists representing a group of anagrams is sorted in alphabetical order.

Identify the groups of anagrams in a list of words

Groups of Anagrams

Given an array filled with random values, write a function <code>rotate_matrix</code> to rotate the array by 90 degrees in the clockwise direction.

Example:

Input:

<pre tabindex="0" class="chroma"><code>import numpy as np

array = np.array( [[1, 2, 3, 4, 5], [2, 3, 4, 5, 6], [3, 4, 5, 6, 7], [4, 5, 6, 7, 8], [5, 6, 7, 8, 9]] )

</code></pre>

array
<table><tbody><tr><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td></tr><tr><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td></tr><tr><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td></tr><tr><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td></tr><tr><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td></tr></tbody></table>

Output:

<table><tbody><tr><td>5</td><td>4</td><td>3</td><td>2</td><td>1</td></tr><tr><td>6</td><td>5</td><td>4</td><td>3</td><td>2</td></tr><tr><td>7</td><td>6</td><td>5</td><td>4</td><td>3</td></tr><tr><td>8</td><td>7</td><td>6</td><td>5</td><td>4</td></tr><tr><td>9</td><td>8</td><td>7</td><td>6</td><td>5</td></tr></tbody></table>

Let’s say that we’re building a model to predict real estate home prices in a particular city.

We analyze the distribution of the home prices and see that the homes values are skewed to the right.

Do we need to do anything or take it into consideration? If so, what should we do?

Bonus: Let’s say you see your target distribution is heavily left instead. What do you do now?

You're building a model to predict home prices and you see that the prices in your training data are right-skewed. How would you handle this situation?

Skewed Pricing

How would you build the recommendation algorithm for type-ahead search for Netflix?

Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

You are given a target value to search. If the value is in the array, then return its index; otherwise, return -1. 

Notes:

<ul>
<li>Rotating an array at pivot \(n\) gives you a new array that begins with the elements after position \(n\) and ends with the elements up to position \(n\).</li>
<li>You may assume no duplicate exists in the array.</li>
</ul>

Bonus: Your algorithm’s runtime complexity should be in the order of \(O(\log n)\).

Example:

Input: 

<pre tabindex="0" class="chroma"><code>sample_input = [0,1,2,4,5,6,7] 
rotated_input = [4,5,6,7,0,1,2]
target_value = 6
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>def target_value_search(rotated_input, target_value) -&gt; 2
</code></pre>

Search for a value in log(n) over a sorted array that has been shifted.

Target Value Search

Let’s say you work at Spotify.

We want to design a relational database for storing metadata about songs.

We want to include metadata like song title, song length, the date the song was added to the platform, artist, album, track number (on the album), the song’s release year, and its genre.

How would you go about designing this database?

Music Database

Data Modeling

Given a list of strings, write a Python program to check whether each string has all the same characters or not. What is the complexity of this program?

Example:

Input:

<pre tabindex="0" class="chroma"><code>string_list = [&#39;bbbbb&#39;, &#39;abc&#39;, &#39;aaaaaaaab&#39;]
</code></pre>

Output: False

<code>string bbbbb</code> has all the same characters 
<code>string abc</code> does not have all the same characters 
<code>string aaaaaaaab</code> does not have all the same characters

Given a list of strings, write a Python program to check whether each string has all the same characters or not.

Same Characters

Given an integer list <code>nums</code> with length <code>n</code> and an integer <code>target</code>, find three integers in <code>nums</code> that yield a sum closest to <code>target</code>.

Return the sum of these three integers.

You can assume that each input will have exactly one solution.

<h3>Example:</h3>

Input:

<pre tabindex="0" class="chroma"><code>nums = [-1, 2, 1, -4]
target = 1
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>2
</code></pre>

Explanation:

The sum that is closest to the target is (-1) + 2 + 1 = 2.

Find the closest sum to a target value of three integers within a list.

Targeted sum

Given a table of <code>subscriptions</code>, write a query to get the retention rate of each monthly cohort for each <code>plan_id</code> for the three months after sign-up.

Order your output by <code>start_month</code>, <code>plan_id</code>, then <code>num_month</code>.

If an <code>end_date</code> is in the same month as <code>start_date</code> we say the subscription was not retained in the first month.

If the <code>end_date</code> occurs in the month after the month of <code>start_date</code>, the subscription was not retained in the second month. And so on for the third.

The <code>end_date</code> field is <code>NULL</code> if the user has not canceled.

Example:

Input:

<code>subscriptions</code> table

<table>
<thead>
<tr>
<th>Column</th>
<th>Type</th>
</tr>
</thead>

<tbody>
<tr>
<td><code>user_id</code></td>
<td>INTEGER</td>
</tr>

<tr>
<td><code>start_date</code></td>
<td>DATETIME</td>
</tr>

<tr>
<td><code>end_date</code></td>
<td>DATETIME</td>
</tr>

<tr>
<td><code>plan_id</code></td>
<td>VARCHAR</td>
</tr>
</tbody>
</table>
Output:

<table>
<thead>
<tr>
<th>Column</th>
<th>Type</th>
</tr>
</thead>

<tbody>
<tr>
<td><code>start_month</code></td>
<td>DATETIME</td>
</tr>

<tr>
<td><code>num_month</code></td>
<td>INTEGER</td>
</tr>

<tr>
<td><code>plan_id</code></td>
<td>VARCHAR</td>
</tr>

<tr>
<td><code>retained</code></td>
<td>FLOAT</td>
</tr>
</tbody>
</table>

Calculate Moving Average	SQL	Easy
Predict Customer Churn	Machine Learning	Medium
A/B Test Significance	Statistics	Medium
Optimize Query Performance	SQL	Hard
Feature Importance Analysis	Machine Learning	Medium
Clean Missing Data	Python	Easy
Neural Network Architecture	Deep Learning	Hard
Calculate Cohort Retention	SQL	Medium
Bayesian Probability	Statistics	Easy
Recommend Similar Products	Machine Learning	Hard

Smartworks Interview Questions

Overview

Smartworks Interview Guides

Challenge

Smartworks Interview Questions

Smartworks Salaries by Position