Prepare for and practice interview questions from Data Axle.

Data Axle Interview Questions

Data Axle Interview Guides

Data Structures & Algorithms

Given two sorted lists, write a function to merge them into one sorted list.

Merge Sorted Lists

Find the missing integer from a array of consequtive integers

Find the Missing Number

Write a function to create a single dataframe with complete addresses in the format of street, city, state, zip code.

Complete Addresses

Given an integer N, write a function that returns all of the prime numbers up to N

Prime to N

One Element Removed

Machine Learning

Booking Regression

Missing Housing Data

Bank Fraud Model

Bagging vs Boosting

Spam Classifier 

Write a SQL query to create a histogram of the number of comments per user in the month of January 2020.

Comments Histogram

Subscription Overlap

Write a query to get the number of customers that were upsold

Upsell Transactions

Duplicate Rows

Monthly Customer Report

A/B Testing

Button AB Test

Network Experiment Design

Green Dot

AB Test Ties

Testing Price Increase

Statistics

Say you are given a dataset of perfectly linearly separable data. What would happen when you run logistic regression?

Perfectly Separable

P-value to a Layman

What are the assumptions of linear regression?

Assumptions of Linear Regression

A new airline came out as the fastest average boarding times compared to other airlines.  What factors could have biased this result and what would you look into?

Boarding Times Bias

Using R Squared

Write a SQL query to create a histogram of the number of comments per user in the month of January 2020.

Note: Assume bin buckets class intervals of one.

Note: Comments that were created outside of January 2020 should be counted in a “0” bucket

Example:

Input:

<code>users</code> table

<table>
<thead>
<tr>
<th>Columns</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>

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

<tr>
<td><code>neighborhood_id</code></td>
<td>INTEGER</td>
</tr>

<tr>
<td><code>mail</code></td>
<td>VARCHAR</td>
</tr>
</tbody>
</table>
<code>comments</code> table

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

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

<tr>
<td><code>body</code></td>
<td>VARCHAR</td>
</tr>

<tr>
<td><code>created_at</code></td>
<td>DATETIME</td>
</tr>
</tbody>
</table>
Output:

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

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

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

Given two sorted lists, write a function to merge them into one sorted list.

Bonus: What’s the time complexity?

Example:

Input:

<pre tabindex="0" class="chroma"><code>list1 = [1,2,5]
list2 = [2,4,6]
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>def merge_list(list1,list2) -&gt; [1,2,2,4,5,6]
</code></pre>

You have two sorted lists, one with m elements and one with n elements. What would be the time complexity of merging the two lists via merge sort?

You have two sorted lists, one with m elements and one with n elements. What would be the time complexity of merging the two lists via merge sort? 

Merging Lists Complexity

We’re given a table of product purchases. Each row in the table represents an individual user product purchase.

Write a query to get the number of customers that were upsold, or in other words, the number of users who bought additional products after their first purchase.

Note: If the customer purchased two things on the same day, that does not count as an upsell, as they were purchased within a similar timeframe.

Example:

Input:

<code>transactions</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>user_id</code></td>
<td>INTEGER</td>
</tr>

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

<tr>
<td><code>product_id</code></td>
<td>INTEGER</td>
</tr>

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

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

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

Given a table of product subscriptions with a subscription start date and end date for each user, write a query that returns true or false whether or not each user has a subscription date range that overlaps with any other completed subscription.

Completed subscriptions have <code>end_date</code> recorded.

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>
</tbody>
</table>

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

<tbody>
<tr>
<td>1</td>
<td>2019-01-01</td>
<td>2019-01-31</td>
</tr>

<tr>
<td>2</td>
<td>2019-01-15</td>
<td>2019-01-17</td>
</tr>

<tr>
<td>3</td>
<td>2019-01-29</td>
<td>2019-02-04</td>
</tr>

<tr>
<td>4</td>
<td>2019-02-05</td>
<td>2019-02-10</td>
</tr>
</tbody>
</table>
Output:

<table>
<thead>
<tr>
<th><code>user_id</code></th>
<th><code>overlap</code></th>
</tr>
</thead>

<tbody>
<tr>
<td>1</td>
<td>1</td>
</tr>

<tr>
<td>2</td>
<td>1</td>
</tr>

<tr>
<td>3</td>
<td>1</td>
</tr>

<tr>
<td>4</td>
<td>0</td>
</tr>
</tbody>
</table>

You have an array of integers, <code>nums</code> of length <code>n</code> spanning <code>0</code> to <code>n</code> with one missing. Write a function <code>missing_number</code> that returns the missing number in the array.

Note: Complexity of \(O(n)\) required.

Example:

Input:

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

Let’s say we have a table with an <code>id</code> and <code>name</code> fields. The table holds over 100 million rows and we want to sample a random row in the table without throttling the database.

Write a query to randomly sample a row from this table.

Input:

<code>big_table</code> table

<table>
<thead>
<tr>
<th>Columns</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>

Write a query to randomly sample a row from a big table.

Random SQL Sample

Given an integer <code>N</code>, write a function that returns a list of all of the prime numbers up to <code>N</code>.

Note: Return an empty list there are no prime numbers less than or equal to <code>N</code>.

Example:

Input:

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

Output:

<pre tabindex="0" class="chroma"><code>def prime_numbers(N) -&gt; [2,3]
</code></pre>

A team wants to A/B test multiple different changes through a sign-up funnel.

For example, on a page, a button is currently red and at the top of the page. They want to see if changing a button from red to blue and/or from the top of the page to the bottom of the page will increase click-through.

How would you set up this test?

Your team wants to run an AB test on the color (red or blue) and position (top/bottom of the page) of a button that links to a promotion.

How many different variants of the test should you run to see the effect that a red button has on the bottom of the page, if currently the button is blue and on the top of the page.

Your team wants to run an AB test on the color (red or blue) and position (top/bottom of the page) of a button that links to a promotion.

How many different variants of the test should you run to see the effect that a red button has on the bottom of the page, if currently the button is blue and on the top of the page.

A/B Test Variants

You have a table containing information about the time that employees have worked on a project.

Write a query to find how many unique calendar days each employee worked. Order your query by the <code>employee_id</code>.

Example:

An employee worked on two projects, and recorded their time like this:

<table>
<thead>
<tr>
<th>employee_id</th>
<th>project_id</th>
<th>start_date</th>
<th>end_date</th>
</tr>
</thead>

<tbody>
<tr>
<td>1	</td>
<td>1</td>
<td>2024-01-01</td>
<td>2024-01-06</td>
</tr>

<tr>
<td>1	</td>
<td>2</td>
<td>2024-01-03</td>
<td>2024-01-07</td>
</tr>
</tbody>
</table>
The number of unique calendar days is therefore 7.

<h3>Schema</h3>

Input:

<code>projects</code> table

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

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

<tr>
<td><code>project_id</code>	</td>
<td>	INTEGER	</td>
</tr>

<tr>
<td><code>start_date</code>	</td>
<td>	DATE	</td>
</tr>

<tr>
<td><code>end_date</code>	</td>
<td>	DATE	</td>
</tr>
</tbody>
</table>
Output:

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

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

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

<h3>Example</h3>

Input:

<code>projects</code> table

<table>
<thead>
<tr>
<th>employee_id</th>
<th>project_id</th>
<th>start_date</th>
<th>end_date</th>
</tr>
</thead>

<tbody>
<tr>
<td>1</td>
<td>1</td>
<td>2024-01-01</td>
<td>2024-01-15</td>
</tr>

<tr>
<td>1</td>
<td>1</td>
<td>2024-01-21</td>
<td>2024-01-31</td>
</tr>

<tr>
<td>1</td>
<td>2</td>
<td>2024-01-25</td>
<td>2024-02-28</td>
</tr>

<tr>
<td>2</td>
<td>3</td>
<td>2024-01-01</td>
<td>2024-01-31</td>
</tr>
</tbody>
</table>
Output:

<table>
<thead>
<tr>
<th>employee_id</th>
<th>unique_days_worked</th>
</tr>
</thead>

<tbody>
<tr>
<td>1</td>
<td>54</td>
</tr>

<tr>
<td>2</td>
<td>31</td>
</tr>
</tbody>
</table>

Unique Work Days

Let’s say you want to test the close friends feature on Instagram Stories.

How would you make a control group and test group to account for network effects?

What could be a potential risk when Facebook segments the metrics of the user interface change by market or demographic groups?

What could be a potential risk when Facebook segments the metrics of the user interface change by market or demographic groups?

Network Experiment Design I

What is the primary metric that Facebook should monitor if it decides to make the user interface of its posting feature more like Instagram's?

What is the primary metric that Facebook should monitor if it decides to make the user interface of its posting feature more like Instagram's?

Network Experiment Design II

If Facebook changes its user interface to mimic Instagram's, which adverse effect should they anticipate and monitor?

If Facebook changes its user interface to mimic Instagram's, which adverse effect should they anticipate and monitor?

Tell me about a data project that didn’t go the way you expected. What did you set out to do, what surprised you, and how did you handle it?

Describing a data project and its challenges

Hurdles In Data Projects

Behavioral

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>.

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

Rectangle Overlap

Let’s say that you work at a bank that wants to build a model to detect fraud on the platform.

The bank wants to implement a text messaging service in addition that will text customers when the model detects a fraudulent transaction in order for the customer to approve or deny the transaction with a text response.

How would we build this model?

Let’s say that you work at a bank that wants to build a model to detect fraud on the platform.

The bank wants to implement a text messaging service that will text customers when the model detects a fraudulent transaction in order for the customer to approve or deny the transaction with a text response.

Which statement is true?

Let's say that you work at a bank that wants to build a model to detect fraud on the platform.

The bank wants to implement a text messaging service that will text customers when the model detects a fraudulent transaction in order for the customer to approve or deny the transaction with a text response.

Which statement is true?

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

Let’s say you work at Costco. Costco has a database with two tables. The first is <code>users</code> composed of user information, including their registration date, and the second is <code>purchases</code> that has the entire item purchase history (if any) for those users.

Write a query to get the total amount spent on each item in the ‘purchases’ table by users that registered in 2022.

Example:

Input:

<code>users</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>user_name</code></td>
<td>VARCHAR</td>
</tr>

<tr>
<td><code>registration_date</code></td>
<td>DATETIME</td>
</tr>
</tbody>
</table>
<code>purchases</code> table

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

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

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

<tr>
<td><code>item</code></td>
<td>VARCHAR</td>
</tr>

<tr>
<td><code>price</code></td>
<td>FLOAT</td>
</tr>

<tr>
<td><code>purchase_date</code></td>
<td>DATETIME</td>
</tr>
</tbody>
</table>
Output:

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

<tbody>
<tr>
<td><code>item</code></td>
<td>VARCHAR</td>
</tr>

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

Total Spent on Products

You’re a data scientist at Meta working on a feature that helps users discover trending books and understand borrowing behavior across the platform’s digital library.

Every time a user borrows a book, the system logs a <code>borrowed_at</code> timestamp and a <code>returned_at</code> timestamp. The team wants to measure how long books are typically kept, while also flagging which books have large inventories.

Write a SQL query to compute the following metrics for each book:

<ol>
<li><code>avg_borrow_duration_days</code>: average borrowing duration in days (rounded to 2 decimals)</li>
<li><code>has_over_10_copies</code>: <code>&#39;Yes&#39;</code> if the book has more than 10 copies available, otherwise <code>&#39;No&#39;</code></li>
</ol>

Only include completed borrows where <code>returned_at</code> is not NULL.

Sort results by <code>avg_borrow_duration_days</code> DESC, then by <code>book_id</code> ASC.

Note: Every book that has at least one completed borrow should appear in the output.

<h3>Schema</h3>

Input

<code>books</code> Table

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

<tbody>
<tr>
<td>book_id</td>
<td>INTEGER</td>
</tr>

<tr>
<td>title</td>
<td>VARCHAR</td>
</tr>

<tr>
<td>copies_available</td>
<td>INTEGER</td>
</tr>
</tbody>
</table>
<code>borrows</code> Table

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

<tbody>
<tr>
<td>borrow_id</td>
<td>INTEGER</td>
</tr>

<tr>
<td>user_id</td>
<td>INTEGER</td>
</tr>

<tr>
<td>book_id</td>
<td>INTEGER</td>
</tr>

<tr>
<td>borrowed_at</td>
<td>DATETIME</td>
</tr>

<tr>
<td>returned_at</td>
<td>DATETIME</td>
</tr>
</tbody>
</table>
Output

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

<tbody>
<tr>
<td>book_id</td>
<td>INTEGER</td>
</tr>

<tr>
<td>avg_borrow_duration_days</td>
<td>DECIMAL</td>
</tr>

<tr>
<td>has_over_10_copies</td>
<td>VARCHAR</td>
</tr>
</tbody>
</table>

<h3>Example</h3>

Input

<code>books</code> Table

<table>
<thead>
<tr>
<th>book_id</th>
<th>title</th>
<th>copies_available</th>
</tr>
</thead>

<tbody>
<tr>
<td>1</td>
<td>Dune</td>
<td>12</td>
</tr>

<tr>
<td>2</td>
<td>Sapiens</td>
<td>8</td>
</tr>

<tr>
<td>3</td>
<td>Clean Code</td>
<td>15</td>
</tr>
</tbody>
</table>
<code>borrows</code> Table

<table>
<thead>
<tr>
<th>borrow_id</th>
<th>user_id</th>
<th>book_id</th>
<th>borrowed_at</th>
<th>returned_at</th>
</tr>
</thead>

<tbody>
<tr>
<td>101</td>
<td>10</td>
<td>1</td>
<td>2026-01-01 09:00:00</td>
<td>2026-01-06 09:00:00</td>
</tr>

<tr>
<td>102</td>
<td>11</td>
<td>1</td>
<td>2026-01-10 10:00:00</td>
<td>2026-01-13 22:00:00</td>
</tr>

<tr>
<td>103</td>
<td>12</td>
<td>2</td>
<td>2026-01-02 12:00:00</td>
<td>2026-01-04 12:00:00</td>
</tr>

<tr>
<td>104</td>
<td>13</td>
<td>2</td>
<td>2026-01-05 09:00:00</td>
<td>NULL</td>
</tr>

<tr>
<td>105</td>
<td>14</td>
<td>3</td>
<td>2026-01-03 08:00:00</td>
<td>2026-01-10 08:00:00</td>
</tr>
</tbody>
</table>
Output

<table>
<thead>
<tr>
<th>book_id</th>
<th>avg_borrow_duration_days</th>
<th>has_over_10_copies</th>
</tr>
</thead>

<tbody>
<tr>
<td>3</td>
<td>7.00</td>
<td>Yes</td>
</tr>

<tr>
<td>1</td>
<td>4.25</td>
<td>Yes</td>
</tr>

<tr>
<td>2</td>
<td>2.00</td>
<td>No</td>
</tr>
</tbody>
</table>
Explanation

For book 1, there are two completed borrows. The durations are 5.00 days (Jan 1 → Jan 6) and 3.50 days (Jan 10 10:00 → Jan 13 22:00). The average borrowing duration is (5.00 + 3.50) / 2 = 4.25 days. Since <code>copies_available = 12</code>, the book is flagged as <code>&#39;Yes&#39;</code>.

For book 2, only one borrow is completed (the other has <code>returned_at = NULL</code> and is excluded). The completed duration is 2.00 days. Since <code>copies_available = 8</code>, it is flagged as <code>&#39;No&#39;</code>.

For book 3, there is one completed borrow lasting 7.00 days, and <code>copies_available = 15</code>, so it is flagged as <code>&#39;Yes&#39;</code>.

Write a SQL query to compute the average borrowing duration and identify books with over 10 copies.

Digital Library Borrowing Metrics

You’re given two dataframes. One contains information about addresses and the other contains relationships between various cities and states:

Example:

<code>df_addresses</code>

<table>
<thead>
<tr>
<th>address</th>
</tr>
</thead>

<tbody>
<tr>
<td>4860 Sunset Boulevard, San Francisco, 94105</td>
</tr>

<tr>
<td>3055 Paradise Lane, Salt Lake City, 84103</td>
</tr>

<tr>
<td>682 Main Street, Detroit, 48204</td>
</tr>

<tr>
<td>9001 Cascade Road, Kansas City, 64102</td>
</tr>

<tr>
<td>5853 Leon Street, Tampa, 33605</td>
</tr>
</tbody>
</table>
<code>df_cities</code>

<table>
<thead>
<tr>
<th>city</th>
<th>state</th>
</tr>
</thead>

<tbody>
<tr>
<td>Salt Lake City</td>
<td>Utah</td>
</tr>

<tr>
<td>Kansas City</td>
<td>Missouri</td>
</tr>

<tr>
<td>Detroit</td>
<td>Michigan</td>
</tr>

<tr>
<td>Tampa</td>
<td>Florida</td>
</tr>

<tr>
<td>San Francisco</td>
<td>California</td>
</tr>
</tbody>
</table>
Write a function <code>complete_address</code> to create a single dataframe with complete addresses in the format of street, city, state, zip code.

Input:

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

addresses = {&#34;address&#34;: [&#34;4860 Sunset Boulevard, San Francisco, 94105&#34;, &#34;3055 Paradise Lane, Salt Lake City, 84103&#34;, &#34;682 Main Street, Detroit, 48204&#34;, &#34;9001 Cascade Road, Kansas City, 64102&#34;, &#34;5853 Leon Street, Tampa, 33605&#34;]}

cities = {&#34;city&#34;: [&#34;Salt Lake City&#34;, &#34;Kansas City&#34;, &#34;Detroit&#34;, &#34;Tampa&#34;, &#34;San Francisco&#34;], &#34;state&#34;: [&#34;Utah&#34;, &#34;Missouri&#34;, &#34;Michigan&#34;, &#34;Florida&#34;, &#34;California&#34;]}

df_addresses = pd.DataFrame(addresses)
df_cities = pd.DataFrame(cities)
</code></pre>

Output:

<pre tabindex="0" class="chroma"><code>def complete_address(df_addresses,df_cities) -&gt;
</code></pre>

<table>
<thead>
<tr>
<th>address</th>
</tr>
</thead>

<tbody>
<tr>
<td>4860 Sunset Boulevard, San Francisco, California, 94105</td>
</tr>

<tr>
<td>3055 Paradise Lane, Salt Lake City, Utah, 84103</td>
</tr>

<tr>
<td>682 Main Street, Detroit, Michigan, 48204</td>
</tr>

<tr>
<td>9001 Cascade Road, Kansas City, Missouri, 64102</td>
</tr>

<tr>
<td>5853 Leon Street, Tampa, Florida, 33605</td>
</tr>
</tbody>
</table>

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

There are two lists, <code>list X</code> and <code>list Y</code>. Both lists contain integers from <code>-1000</code> to <code>1000</code> and are identical to each other except that one integer is removed in <code>list Y</code> that exists in <code>list X</code>.

Write a function <code>one_element_removed</code> that takes in both lists and returns the integer that was removed in \(O(1)\) space and \(O(n)\) time without using the python set function.

Example:

Input:

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

one_element_removed(list_x, list_y) -&gt; 3
</code></pre>

Which of the following methods would be the most efficient way of identifying what element is not included in two lists of integers that differ by a single element being removed?

For example, if the lists are <code>[1,2,3,4,5]</code> and <code>[1,2,4,5]</code>, the function should return <code>3</code>

Which of the following methods would be the most efficient way of identifying what element is not included in two lists of integers that differ by a single element being removed? 

For example, if the lists are `[1,2,3,4,5]` and `[1,2,4,5]`, the function should return `3`

Efficiently Identifying Missing Integer

Let’s say we have a very naive advertising platform. There is an audience of size A and a limited amount of impressions B.

Each of the impressions goes to just one user, defined at random. Every user in the audience has the same random chance of receiving each impression. 

<ol>
<li>Compute the probability that a user has exactly 0 impressions. </li>

<li>What’s the probability that every person has at least 1 impression?</li>
</ol>

Impression Reach

Probability

Let’s say that you work at a B2B SAAS company that’s interested in testing the pricing of different levels of subscriptions.

Your project manager comes to you and asks you to run a two-week-long A/B test to test an increase in pricing.

How would you approach designing this test? How would you determine whether the increase in pricing is a good business decision?

Given two strings, <code>string1</code> and <code>string2</code>, write a function <code>is_subsequence</code> to find out if <code>string1</code> is a subsequence of <code>string2</code>.

Bonus: A subsequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements.

Example:

Input:

<pre tabindex="0" class="chroma"><code>string1 = &#39;abc&#39;
string2 = &#39;asbsc&#39;
string3 = &#39;acedb&#39;

is_subsequence(string1, string2) -&gt; True
is_subsequence(string1, string3) -&gt; False
</code></pre>

String Subsequence

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

Say you are given a dataset of perfectly linearly separable data.

What would happen when you run logistic regression?

What happens when logistic regression is run on a dataset of perfectly linearly separable data?

What happens when logistic regression is run on a dataset of perfectly linearly separable data?

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

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 you’re interning at a fintech startup that’s building a platform for online games of chance. During testing, one of your simulations flips a coin 10 times and gets 8 tails and 2 heads.

How would you determine if the coin is fair, and what statistical approach would you use to support your conclusion?

How would you assess if a coin is fair after observing 8 tails in 10 flips?

Fair Coin

Given two strings, <code>string1</code> and <code>string2</code>, write a function <code>str_map</code> to determine if there exists a one-to-one correspondence (bijection) between the characters of <code>string1</code> and <code>string2</code>.

For the two strings, our correspondence must be between characters in the same position/index.

Example 1:

Input:

<pre tabindex="0" class="chroma"><code>string1 = &#39;qwe&#39;
string2 = &#39;asd&#39;

string_map(string1, string2) == True

# q = a, w = s, and e = d
</code></pre>

Example 2:

Input:

<pre tabindex="0" class="chroma"><code>string1 = &#39;donut&#39;
string2 = &#39;fatty&#39;

string_map(string1, string2) == False
# cannot map two distinct characters to two equal characters
</code></pre>

Example 3:

Input:

<pre tabindex="0" class="chroma"><code>string1 = &#39;enemy&#39;
string2 = &#39;enemy&#39;

string_map(string1, string2) == True
# there exists a one-to-one correspondence between equivalent strings
</code></pre>

Example 4:

Input:

<pre tabindex="0" class="chroma"><code>string1 = &#39;enemy&#39;
string2 = &#39;ymene&#39;

string_map(string1, string2) == False
# since our correspondence must be between characters of the same index, this case returns &#39;False&#39; as we must map e = y AND e = e
</code></pre>

String Mapping

You’re given a dataframe <code>df_cheeses</code> containing a list of the price of various cheeses from California. The dataframe has missing values in the price column.

Write a function <code>cheese_median</code> to impute the median price of the selected California cheeses in place of the missing values. You may assume at least one cheese is not missing its price.

Example:

Input:

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

cheeses = {&#34;Name&#34;: [
&#34;Bohemian Goat&#34;, 
&#34;Central Coast Bleu&#34;, 
&#34;Cowgirl Mozzarella&#34;, 
&#34;Cypress Grove Cheddar&#34;, 
&#34;Oakdale Colby&#34;], 
&#34;Price&#34; : [15.00, None, 30.00, None, 45.00]}

df_cheeses = pd.DataFrame(cheeses)
</code></pre>

Output:

<table>
<thead>
<tr>
<th>Name</th>
<th>Price</th>
</tr>
</thead>

<tbody>
<tr>
<td>Bohemian Goat</td>
<td>15.00</td>
</tr>

<tr>
<td>Central Coast Bleu</td>
<td>30.00</td>
</tr>

<tr>
<td>Cowgirl Mozzarella</td>
<td>30.00</td>
</tr>

<tr>
<td>Cypress Grove Cheddar</td>
<td>30.00</td>
</tr>

<tr>
<td>Oakdale Colby</td>
<td>45.00</td>
</tr>
</tbody>
</table>

Write a function to impute the median price of the selected California cheeses in place of the missing values.

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

Data Axle Interview Questions

Data Axle Interview Guides

Data Axle Interview Questions

Challenge

Discussion & Interview Experiences

Discussion & Interview Experiences