Prepare for and practice interview questions from American homes 4 rent.

American homes 4 rent Interview Questions

american homes 4 rent is focused on acquiring, renovating, leasing, and operating residential homes. as an industry leader in rental homes, we combine the benefits of a national organization, the ease of innovative leasing technologies, and the experience of talented local professionals to provide a superior residential rental experience.

american homes 4 rent is focused on acquiring, renovating, leasing, and operating residential homes. as an industry leader in rental homes, we combine the benefits of a national organization, the ease of innovative leasing technologies, and the experience of talented local professionals to provide a superior residential rental experience.

Overview

American homes 4 rent 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

Reconstruct the path of a trip so that the trip tickets are in order.

Scrambled Tickets

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

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

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

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

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

Type-ahead Search

choosing k value during k-means clustering

Choosing k

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

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

A/B Testing

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

Sample Size Bias

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

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

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

Consider a trip from one city to another that may contain many layovers. Given the list of flights out of order, each with a starting city and end city, write a function <code>plan_trip</code> to reconstruct the path of the trip so the trip tickets are in order.

Example:

For a trip from Bombay to Beijing:

Input:

<pre tabindex="0" class="chroma"><code>flights = [
 [&#39;Chennai&#39;, &#39;Bangalore&#39;], 
 [&#39;Bombay&#39;, &#39;Delhi&#39;], 
 [&#39;Goa&#39;, &#39;Chennai&#39;], 
 [&#39;Delhi&#39;, &#39;Goa&#39;], 
 [&#39;Bangalore&#39;, &#39;Beijing&#39;]
]
output = [
 [&#39;Bombay&#39;, &#39;Delhi&#39;], 
 [&#39;Delhi&#39;, &#39;Goa&#39;], 
 [&#39;Goa&#39;, &#39;Chennai&#39;], 
 [&#39;Chennai&#39;, &#39;Bangalore&#39;], 
 [&#39;Bangalore&#39;, &#39;Beijing&#39;],
]
</code></pre>

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

You’re analyzing a user’s purchases for a retail business.

Each product belongs to a category. Your task is to identify which purchases represent the first time the user has bought a product from its own category and which purchases represent repeat purchases within the product category.

The <code>id</code> in the <code>purchases</code> table represents the purchase order (rows with a lower <code>id</code> are earlier purchases).

Your code should output a table that includes every purchase the user has made. Additionally, the table should include a boolean column with a value of <code>1</code> if the user has previously purchased a product from its category and <code>0</code> if it’s their first time buying a product from that category.

Note: Sort the results by the time purchased, in ascending order.

<h3>Schema</h3>

Input:

<code>purchases</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>product_name</code></td>
<td>VARCHAR</td>
</tr>

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

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

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

<tr>
<td><code>category_previously_purchased</code></td>
<td>BOOLEAN</td>
</tr>
</tbody>
</table>
Display results in the following way:

<table>
<thead>
<tr>
<th>product_name</th>
<th>category_previously_purchased</th>
</tr>
</thead>

<tbody>
<tr>
<td>toy car</td>
<td>0</td>
</tr>

<tr>
<td>toy plane</td>
<td>1</td>
</tr>

<tr>
<td>basketball</td>
<td>0</td>
</tr>

<tr>
<td>football</td>
<td>1</td>
</tr>

<tr>
<td>baseball</td>
<td>1</td>
</tr>
</tbody>
</table>

<h3>Example</h3>

Input:

<code>purchases</code> table

<table>
<thead>
<tr>
<th>id</th>
<th>product_name</th>
<th>product_category</th>
</tr>
</thead>

<tbody>
<tr>
<td>1</td>
<td>toy car</td>
<td>1</td>
</tr>

<tr>
<td>2</td>
<td>basketball</td>
<td>2</td>
</tr>

<tr>
<td>3</td>
<td>toy car</td>
<td>1</td>
</tr>

<tr>
<td>4</td>
<td>basketball</td>
<td>2</td>
</tr>

<tr>
<td>5</td>
<td>baseball</td>
<td>2</td>
</tr>

<tr>
<td>6</td>
<td>robot X1</td>
<td>3</td>
</tr>

<tr>
<td>7</td>
<td>robot X2</td>
<td>3</td>
</tr>

<tr>
<td>8</td>
<td>toy plane</td>
<td>1</td>
</tr>

<tr>
<td>9</td>
<td>robot X3</td>
<td>3</td>
</tr>

<tr>
<td>10</td>
<td>teddy bear</td>
<td>5</td>
</tr>
</tbody>
</table>
Output:

<table>
<thead>
<tr>
<th>product_name</th>
<th>category_previously_purchased</th>
</tr>
</thead>

<tbody>
<tr>
<td>toy car</td>
<td>0</td>
</tr>

<tr>
<td>basketball</td>
<td>0</td>
</tr>

<tr>
<td>toy car</td>
<td>1</td>
</tr>

<tr>
<td>basketball</td>
<td>1</td>
</tr>

<tr>
<td>baseball</td>
<td>1</td>
</tr>

<tr>
<td>robot X1</td>
<td>0</td>
</tr>

<tr>
<td>robot X2</td>
<td>1</td>
</tr>

<tr>
<td>toy plane</td>
<td>1</td>
</tr>

<tr>
<td>robot X3</td>
<td>1</td>
</tr>

<tr>
<td>teddy bear</td>
<td>0</td>
</tr>
</tbody>
</table>

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

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

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.

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

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>

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

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

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>

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?

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?

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

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

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

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

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>

Write a function to return True if two strings are anagrams of each other and False if they are not

Valid Anagram

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?

Find and return all the prime numbers in an array of integers. If there are no prime numbers, return an empty array.

Example:

Input:

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

Output:

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

Find and return all the prime numbers in an array of integers.

Prime Numbers Identification

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>

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

Matrix Rotation

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.

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.

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

American homes 4 rent Interview Questions

Overview

American homes 4 rent Interview Guides

Challenge

American homes 4 rent Interview Questions

Discussion & Interview Experiences

Discussion & Interview Experiences