Prepare for and practice interview questions from Roofstock across topics like Python, SQL, Statistics and more.

Roofstock Interview Questions

Roofstock 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

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

This problem involves finding the first non-repeating character in a given string. The solution involves iterating over the string and keeping track of the frequency of each character. The first character that has a frequency of 1 is the first non-repeating character.

Find the First Non-Repeating Character in a String

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

Statistics

Explain what a p-value is to someone who is not technical

P-value to a Layman

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

Hundreds of Hypotheses

What are the assumptions of linear regression?

Assumptions of Linear Regression

Design a test to determine whether the coin is biased

Possibly Biased Coin

Find a bound for how many people drink coffee AND tea based on a survey

Bounds for Coffee and Tea Drinkers

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

Write a SQL query to compute the median household income for each city

Median Household Income

Data Modeling

Design a database for a stand-alone fast food restaurant

Fast Food Database

Design a relational database for storing song metadata

Music Database

Design the backend and data model for a notification system

Reddit-like Notifications

How would you approach designing a system capable of processing and displaying real-time data across multiple platforms?

Unified Live Comments

Machine Learning

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

Missing Housing Data

In which case would you use a bagging algorithm versus a boosting algorithm

Bagging vs Boosting

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

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

Overfit Avoidance

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>

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>

Given a table of user sessions, write a query to get the number of days between each user’s first session and last session for the year 2020. 

Example:

Input:

<code>user_sessions</code> table

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

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

<tr>
<td><code>created_at</code></td>
<td>DATETIME</td>
</tr>

<tr>
<td><code>user_id</code></td>
<td>INTEGER</td>
</tr>
</tbody>
</table>
Output:

<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>no_of_days</code></td>
<td>INTEGER</td>
</tr>
</tbody>
</table>

The probability that it will rain tomorrow is dependent on whether or not it is raining today and whether or not it rained yesterday.

If it rained yesterday and today, there is a 20% chance it will rain tomorrow. If it rained one of the days, there is a 60% chance it will rain tomorrow. If it rained neither today nor yesterday, there is a 20% chance it will rain tomorrow.

Given that it is raining today and that it rained yesterday, write a function <code>rain_days</code> to calculate the probability that it will rain on the nth day after today.

Example:

Input:

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

Output:

<pre tabindex="0" class="chroma"><code>def rain_days(n) -&gt; 0.39968
</code></pre>

Given that it is raining today and that it rained yesterday, write a function to calculate the probability that it will rain on the nth day after today.

Rain in N Days

Probability

Given a dictionary with weights, write a function <code>random_key</code> that returns a key at random with a probability proportional to the weights.

Example 1:

Input:

<pre tabindex="0" class="chroma"><code>weights = {&#39;A&#39;: 1, &#39;B&#39;: 2}
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>random_key(weights) -&gt; return A 1/3 of the time, B 2/3 of the time
</code></pre>

Example 2:

Input:

<pre tabindex="0" class="chroma"><code>weights = {&#39;A&#39;: 1, &#39;B&#39;: 1}
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>random_key(weights) -&gt; return A 1/2 of the time, B 1/2 of the time
</code></pre>

Weighted Keys

You are given two rectangles <code>a</code> and <code>b</code> each defined by four ordered pairs denoting their corners on the <code>x</code>, <code>y</code> plane. Write a function <code>rectangle_overlap</code> to determine whether or not they overlap. Return <code>True</code> if so, and <code>False</code> otherwise.

Note: If the two rectangles border one another, or share a corner like two diagonally adjacent positions on a chessboard, they are said to overlap.

Note: The lists of ordered pairs are in no particular order. The first entry in list <code>a</code> could be the top left corner while the first in list <code>b</code> is the bottom right.

Example:

Input:

<pre tabindex="0" class="chroma"><code>
a = [(-3,5), (-3,2),(0,5),(0,2)]
b = [(-1,4), (3,4), (3,1), (-1,1)]
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>def rectangle_overlap(a, b) -&gt; True
</code></pre>

As point <code>(0,2)</code> is fully contained in rectangle <code>b</code> and point <code>(-1,4)</code> is fully contained in a rectangle <code>a</code>.

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

Given a string, find the first non-repeating character in it and return its index. If it doesn’t exist, return -1.

Example questions:

Consider a string where all characters are lowercase alphabets.

Example 1:

Input:

<pre tabindex="0" class="chroma"><code>s = &#39;helloworld&#39;
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>first_uniq_char(s) -&gt; 0
</code></pre>

In the string ‘helloworld’, the first non-repeating character is ‘h’, which is at index 0.

Example 2:

Input:

<pre tabindex="0" class="chroma"><code>s = &#39;concussion&#39;
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>first_uniq_char(s) -&gt; 4
</code></pre>

In the string ‘concussion’, the first non-repeating character is ‘u’, which is at index 4.

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

You’re given a dataframe of students named <code>students_df</code>:

<code>students_df</code> table

<table>
<thead>
<tr>
<th>name</th>
<th>age</th>
<th>favorite_color</th>
<th>grade</th>
</tr>
</thead>

<tbody>
<tr>
<td>Tim Voss</td>
<td>19</td>
<td>red</td>
<td>91</td>
</tr>

<tr>
<td>Nicole Johnson</td>
<td>20</td>
<td>yellow</td>
<td>95</td>
</tr>

<tr>
<td>Elsa Williams</td>
<td>21</td>
<td>green</td>
<td>82</td>
</tr>

<tr>
<td>John James</td>
<td>20</td>
<td>blue</td>
<td>75</td>
</tr>

<tr>
<td>Catherine Jones</td>
<td>23</td>
<td>green</td>
<td>93</td>
</tr>
</tbody>
</table>
Write a function named <code>grades_colors</code> to select only the rows where the student’s favorite color is green or red and their grade is above 90.

Example:

Input:

<pre tabindex="0" class="chroma"><code>import pandas as pd

students = {&#34;name&#34; : [&#34;Tim Voss&#34;, &#34;Nicole Johnson&#34;, &#34;Elsa Williams&#34;, &#34;John James&#34;, &#34;Catherine Jones&#34;], &#34;age&#34; : [19, 20, 21, 20, 23], &#34;favorite_color&#34; : [&#34;red&#34;, &#34;yellow&#34;, &#34;green&#34;, &#34;blue&#34;, &#34;green&#34;], &#34;grade&#34; : [91, 95, 82, 75, 93]}

students_df = pd.DataFrame(students)
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>def grades_colors(students_df) -&gt;
</code></pre>

<table>
<thead>
<tr>
<th>name</th>
<th>age</th>
<th>favorite_color</th>
<th>grade</th>
</tr>
</thead>

<tbody>
<tr>
<td>Tim Voss</td>
<td>19</td>
<td>red</td>
<td>91</td>
</tr>

<tr>
<td>Catherine Jones</td>
<td>23</td>
<td>green</td>
<td>93</td>
</tr>
</tbody>
</table>

As a data scientist at a real estate analytics startup, you’re tasked with building a predictive model for home prices in a large metropolitan area. During your exploratory data analysis, you notice that the <code>home_prices</code> column in your dataset is heavily right-skewed (i.e., there are many lower-priced homes and a few extremely high-priced ones).

How might this skewness impact your modeling approach, and what steps would you consider to address it before training your model?

Bonus: If, instead, you discover that the target variable (<code>home_prices</code>) is heavily left-skewed (i.e., there are many high-priced homes and a few low-priced outliers), what would you do differently, if anything?

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

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

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

What is a key disadvantage of the F-test when compared to multiple t-tests?

What is a key disadvantage of the F-test when compared to multiple t-tests?

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.

<h3>Schema:</h3>

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>

<h3>Example</h3>

Input:

<code>subscriptions</code> table

<table>
<thead>
<tr>
<th>user_id</th>
<th>start_date</th>
<th>end_date</th>
<th>plan_id</th>
</tr>
</thead>

<tbody>
<tr>
<td>1</td>
<td>2020-01-10 00:00:00</td>
<td>2020-03-31 23:59:59</td>
<td>plan1</td>
</tr>

<tr>
<td>2</td>
<td>2020-01-10 00:00:00</td>
<td>2020-02-01 23:59:59</td>
<td>plan1</td>
</tr>

<tr>
<td>3</td>
<td>2020-01-10 00:00:00</td>
<td>2020-07-31 23:59:59</td>
<td>plan1</td>
</tr>
</tbody>
</table>
Output:

<table>
<thead>
<tr>
<th>start_month</th>
<th>num_month</th>
<th>plan_id</th>
<th>retained</th>
</tr>
</thead>

<tbody>
<tr>
<td>2020-01-01</td>
<td>1</td>
<td>plan1</td>
<td>1.0</td>
</tr>

<tr>
<td>2020-01-01</td>
<td>2</td>
<td>plan1</td>
<td>0.67</td>
</tr>

<tr>
<td>2020-01-01</td>
<td>3</td>
<td>plan1</td>
<td>0.33</td>
</tr>
</tbody>
</table>
Explanation:

<ul>
<li>Cohort: All subscriptions starting in January 2020.</li>
<li>Month 1 retention: All 3 users were active in the first month → 3⁄3 = 1.0</li>
<li>Month 2 retention: Only users 1 and 3 were active in Feb → 2⁄3 ≈ 0.67</li>
<li>Month 3 retention: Only user 3 was active in Mar → 1⁄3 ≈ 0.33</li>
</ul>

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

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?



Let’s say that you work for an E-commerce store. A new marketing manager joins the company and redesigns the existing new-user email journey to try and boost customer conversion rates. A few weeks after launching the new email journey, the new-user to customer conversion rate goes up from 40% to 43%.

Before you can celebrate, the company’s CMO points out a troubling fact. Just a few months prior to the new manager starting the conversion rate already stood at 45%, before slowly dropping down to the “starting” 40%.

How would you investigate if the redesigned email campaign actually led to the increase in the conversion rate, and that the increase wasn’t instead the result of other factors?

What would be an appropriate method to investigate whether the redesigned email campaign led to an increase in the conversion rate of an E-commerce store, in the absence of infrastructure for an AB test?

What would be an appropriate method to investigate whether the redesigned email campaign led to an increase in the conversion rate of an E-commerce store, in the absence of infrastructure for an AB test?

Causal Email Journey

How would you find out if an increase in user conversion rates after a new email journey is casual or just part of a wider trend?

Causal Email Journey 

Analytics

Three zebras are chilling in the desert. Suddenly a lion attacks.
Each zebra is sitting on a corner of a triangle with sides of equal length.
Each zebra randomly picks a direction and only runs along the outline of the triangle to either edge of the triangle.

What is the probability that none of the zebras collide?

Three zebras are chilling in the desert. Suddenly a lion attacks.

Each zebra is sitting on a corner of a triangle with side of equal length. Each zebra randomly picks a direction and only runs along the outline of the triangle to either edge of the triangle.

What is the probability that none of the zebras collide?

Three zebras are chilling in the desert. Suddenly a lion attacks.

Each zebra is sitting on a corner of a triangle with side of equal length.  Each zebra randomly picks a direction and only runs along the outline of the triangle to either edge of the triangle.

What is the probability that none of the zebras collide?



Three Zebras

Brainteasers

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.

You are given a list of integers called <code>numbers</code>. Write a function to return any subset of <code>numbers</code> where the elements <code>sum</code> to <code>zero</code> and that does not contain the number <code>0</code>.

If there are no combinations of elements that sum to zero, return an empty list.

Example 1:

Input:

<pre tabindex="0" class="chroma"><code>numbers = [1,-2,6,7,1]
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>def zero_sum(numbers) -&gt; [1,-2,1] # only possible combination
</code></pre>

Example 2:

Input:

<pre tabindex="0" class="chroma"><code>numbers = [0,0,1,3,6,-4,-1]
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>def zero_sum(numbers) -&gt; [1,3,-4]
</code></pre>

or

<pre tabindex="0" class="chroma"><code>def zero_sum(numbers) -&gt; [1,-1]
</code></pre>

or any other subset that sums to zero and doesn’t include <code>0</code>.

Write a function to return any subset of the input list where the elements sum to zero and that does not contain the number 0.

Sum to Zero

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

You’re given a two-sided coin that could be fair or biased. How would you figure out whether or not the coin is biased?

Design a test and describe which outcome would tell you that the coin is biased.

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.

What would you expect to happen after the new UI is applied to all users?

New UI Effect

A/B Testing

Tower of Hanoi is a fun puzzle game that consists of a set of <code>3</code> pegs (<code>A</code>, <code>B</code>, <code>C</code>) and <code>n</code> number of disks. You are required to move all disks from the source peg <code>A</code> to destination peg <code>C</code>, under the following conditions:

<ul>
<li>You can only move one disk for each action.</li>
<li>You can only move the disk onto the top of another peg; you cannot place it off to the side or under existing disks.</li>
<li>You cannot place a larger disk onto a smaller disk.</li>
</ul>

Initially, all disks are on the source <code>A</code> peg and sorted by decreasing width from bottom to the top (widest on the bottom, smallest on the top).

You must develop an algorithm to move all disks from <code>A</code> to the destination peg <code>C</code> with the optimal solution. Also, return every step made from the starting state to the final state.

<img src="https://i.ibb.co/my0Vm13/initail.png" alt="alt"/>

<img src="https://i.ibb.co/0Ftzs7D/final.png" alt="alt"/>

Example

Input:

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

Output:

<pre tabindex="0" class="chroma"><code>#return list of {&#34;A&#34;:[],&#34;B&#34;:[],&#34;C&#34;:[]} 
tower_of_hanoi_solver(n) -&gt; [
 {&#34;A&#34;: [1, 2, 3], &#34;B&#34;: [], &#34;C&#34;: []},
 {&#34;A&#34;: [2, 3], &#34;B&#34;: [], &#34;C&#34;: [1]},
 {&#34;A&#34;: [3], &#34;B&#34;: [2], &#34;C&#34;: [1]},
 {&#34;A&#34;: [3], &#34;B&#34;: [1, 2], &#34;C&#34;: []},
 {&#34;A&#34;: [], &#34;B&#34;: [1, 2], &#34;C&#34;: [3]},
 {&#34;A&#34;: [1], &#34;B&#34;: [2], &#34;C&#34;: [3]},
 {&#34;A&#34;: [1], &#34;B&#34;: [], &#34;C&#34;: [2, 3]},
 {&#34;A&#34;: [], &#34;B&#34;: [], &#34;C&#34;: [1, 2, 3]}
 ]
</code></pre>

What is the minimal number of steps needed to solve the Tower of Hanoi problem with n disks?

What is the minimal number of steps needed to solve the Tower of Hanoi problem with *n* disks?

Linear Data Structures

Write an algorithm to solve Tower of Hanoi optimally and return every step from A to C

Tower of Hanoi

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?

Sample Size Bias

Can you determine if the test will result in bias towards the smaller group?

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

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

<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="/s3/questions/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

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?

<h3>Example</h3>

Input:

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

Output:

<pre tabindex="0" class="chroma"><code>def same_characters(input_list) -&gt; False
</code></pre>

Explanation:

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

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

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

Roofstock Interview Questions

Roofstock Interview Guides

Roofstock Interview Questions

Challenge

Roofstock Salaries by Position

Discussion & Interview Experiences

Discussion & Interview Experiences