Prepare for and practice interview questions from Nomura.

Nomura Interview Questions

Nomura 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

Get Top N Frequent Words

String Shift

Minimum Change

Write a query to select the top 3 departments with at least ten employees and rank them according to the percentage of their employees making over 100K in salary.

Employee Salaries

Select the 2nd highest salary in the engineering department

2nd Highest Salary

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

Comments Histogram

Write a query that returns all neighborhoods that have 0 users.

Empty Neighborhoods

Closest SAT Scores

Machine Learning

Encoding Categorical Features

Coefficients of Logistic Regression

Bank Fraud Model

Lasso vs Ridge

Why would one algorithm generate different success rates with the same dataset?

Same Algorithm Different Success

Probability

500 Cards

Given three uniform(0,4) random variables, what is the probability that the median of them is greater than 3?

Median Probability

Jars and Coins

Flipping 576 Times

Profit-Maximizing Dice Game

Statistics

Write a function to return the cumulative percentage of students that received scores within certain buckets.

Bucket Test Scores

Estimating D

P-value to a Layman

What are the assumptions of linear regression?

Assumptions of Linear Regression

What is the difference between the Z and t tests?

Z and t-Tests

<p>Write a SQL query to select the 2nd highest salary in the engineering department.</p>

<p><strong>Note:</strong> If more than one person shares the highest salary, the query should select the next highest salary.</p>

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<p><code>employees</code> table</p>

<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>
<p><code>departments</code> table</p>

<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>
<p><strong>Output:</strong></p>

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

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


<p>We’re given two tables, a <code>users</code> table with demographic information and the neighborhood they live in and a <code>neighborhoods</code> table.</p>

<p>Write a query that returns all neighborhoods that have 0 users. </p>

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<p><code>users</code> table</p>

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

<tr>
<td><code>created_at</code></td>
<td>DATETIME</td>
</tr>
</tbody>
</table>
<p><code>neighborhoods</code> table</p>

<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>city_id</code></td>
<td>INTEGER</td>
</tr>
</tbody>
</table>
<p><strong>Output:</strong></p>

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

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


<p>Given a <code>employees</code> and <code>departments</code> table, select the top 3 departments with at least ten employees and rank them according to the percentage of their employees making over 100K in salary.</p>

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<p><code>employees</code> table</p>

<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>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>
<p><code>departments</code> table</p>

<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>
<p><strong>Output:</strong></p>

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

<tbody>
<tr>
<td><code>percentage_over_100k</code></td>
<td>FLOAT</td>
</tr>

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

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


<p>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). </p>

<p><em>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.</em> </p>

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<p><code>employees</code> table</p>

<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>
<p><code>departments</code> table</p>

<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>
<p><strong>Output</strong>:</p>

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


Get the top 3 highest employee salaries by department

Top Three Salaries

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

<p><em>Note: Assume bin buckets class intervals of one.</em></p>

<p><em>Note: Comments that were created outside of January 2020 should be counted in a “0” bucket</em></p>

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<p><code>users</code> table</p>

<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>
<p><code>comments</code> table</p>

<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>
<p><strong>Output:</strong></p>

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


<p>We’re given a table of bank transactions with three columns, <code>user_id</code>, a deposit or withdrawal value (determined if the value is positive or negative), and <code>created_at</code> time for each transaction.</p>

<p>Write a query to get the total three-day rolling average for deposits by day.</p>

<p><em>Note: Please use the format <code>&#39;%Y-%m-%d&#39;</code> for the date in the outout</em></p>

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<p><code>bank_transactions</code> table</p>

<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>created_at</code></td>
<td>DATETIME</td>
</tr>

<tr>
<td><code>transaction_value</code></td>
<td>FLOAT</td>
</tr>
</tbody>
</table>
<p><strong>Output:</strong></p>

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

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

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


Rolling Bank Transactions

<p>Suppose your company needs to cut costs due to an economic downturn. During a coffee break, you hear a rumor that a lot of money goes to employees who don’t do their work, and you decide to find out if the rumor is true.</p>

<p>Given two tables: <code>employees</code> and <code>projects</code>, find the sum of the salaries of all the employees who didn’t complete any of their projects.</p>

<p>Clarification:</p>

<p>We will consider a project unfinished if it has no end date (its <code>End_dt</code> is <code>NULL</code>).</p>

<p>Given this, we’ll say an employee didn’t finish any of their projects when:</p>

<ul>
<li>They were assigned at least one project.</li>
<li>None of their projects have an <code>End_dt</code>.</li>
</ul>

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<p><code>employees</code> table</p>

<table>
<thead>
<tr>
<th>id</th>
<th>salary</th>
</tr>
</thead>

<tbody>
<tr>
<td>INTEGER</td>
<td>FLOAT</td>
</tr>
</tbody>
</table>
<p><code>projects</code> table</p>

<table>
<thead>
<tr>
<th>employee_id</th>
<th>project_id</th>
<th>Start_dt</th>
<th>End_dt</th>
</tr>
</thead>

<tbody>
<tr>
<td>INTEGER</td>
<td>INTEGER</td>
<td>DATETIME</td>
<td>DATETIME</td>
</tr>
</tbody>
</table>
<p><strong>Output:</strong></p>

<table>
<thead>
<tr>
<th>total_slack_salary</th>
</tr>
</thead>

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


Find the total salary of slacking employees.

Slacking Employees Salaries

<p>Let’s say we have two tables, <code>transactions</code> and <code>products</code>. Hypothetically the <code>transactions</code> table consists of over a billion rows of purchases bought by users.</p>

<p>We are trying to find paired products that are often purchased together by the same user, such as wine and bottle openers, chips and beer, etc..</p>

<p>Write a query to find the top five paired products and their names.</p>

<p><em>Notes:</em>
   <em>For the purposes of satisfying the test case, p2 should be the item that comes first in the alphabet.</em>
   <em>The <code>qty</code> column represents paired products count</em></p>

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<p><code>transactions</code> table</p>

<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>
<p><code>products</code> table</p>

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

<tr>
<td><code>price</code></td>
<td>FLOAT</td>
</tr>
</tbody>
</table>
<p><strong>Output:</strong></p>

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

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

<tr>
<td><code>p2</code></td>
<td>VARCHAR</td>
</tr>

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


Paired Products

<p>Given two sorted lists, write a function to merge them into one sorted list.</p>

<p><em>Bonus: What’s the time complexity?</em></p>

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">list1</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">5</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="n">list2</span> <span class="o">=</span> <span class="p">[</span><span class="mi">2</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">6</span><span class="p">]</span>
</span></span></code></pre>

<p><strong>Output:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">merge_list</span><span class="p">(</span><span class="n">list1</span><span class="p">,</span><span class="n">list2</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">]</span>
</span></span></code></pre>


<p>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?</p>


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

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

<p>Write a query to randomly sample a row from this table.</p>

<p><strong>Input:</strong></p>

<p><code>big_table</code> table</p>

<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

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

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

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<p><code>subscriptions</code> table</p>

<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>
<p><strong>Output:</strong></p>

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


Subscription Overlap

<p>Given a table of bank transactions with columns <code>id</code>, <code>transaction_value</code>, and <code>created_at</code> representing the date and time for each transaction, write a query to get the last transaction for each day.</p>

<p>The output should include the id of the transaction, datetime of the transaction, and the transaction amount. Order the transactions by datetime.</p>

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<p><code>bank_transactions</code> table</p>

<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>created_at</code></td>
<td>DATETIME</td>
</tr>

<tr>
<td><code>transaction_value</code></td>
<td>FLOAT</td>
</tr>
</tbody>
</table>
<p><strong>Output:</strong></p>

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

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

<tr>
<td><code>transaction_value</code></td>
<td>FLOAT</td>
</tr>

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


Last Transaction

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

<p><em>Note: Complexity of $O(n)$ required.</em></p>

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">]</span> 
</span></span><span class="line"><span class="cl"><span class="n">missing_number</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="mi">3</span>
</span></span></code></pre>


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

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

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">N</span> <span class="o">=</span> <span class="mi">3</span>
</span></span></code></pre>

<p><strong>Output:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">prime_numbers</span><span class="p">(</span><span class="n">N</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="p">[</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">]</span>
</span></span></code></pre>


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

Prime to N

<p>Write a Python function called <strong><code>max_profit</code></strong> that takes a list of integers, where the i-th integer represents the price of a given stock on day i, and returns the maximum profit you can achieve by buying and selling the stock.</p>

<p>You may complete, at most, two complete buy/sell transactions to maximize profits on a stock.</p>

<p><strong>Input:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">prices</span> <span class="o">=</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">4</span><span class="p">]</span>
</span></span></code></pre>

<p><strong>Output:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">max_profit</span><span class="p">(</span><span class="n">prices</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="mi">6</span>
</span></span></code></pre>

<p>Explanation:</p>

<pre><code>Buy on day 4 (price = 0) and sell on day 6 (price = 3): profit = 3 - 0 = 3.
Then buy again on day 7 (price = 1) and sell on day 8 (price = 4): profit = 4 - 1 = 3.
Total profit: 3 + 3 = 6.
</code></pre>


Maximum Profit

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

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

<p>Write a SQL query to compute the following metrics for each book:</p>

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

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

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

<p><strong><em>Note:</em></strong> <em>Every book that has at least one completed borrow should appear in the output.</em></p>

<h3><strong>Schema</strong></h3>

<p><strong>Input</strong></p>

<p><strong><code>books</code> Table</strong></p>

<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>
<p><strong><code>borrows</code> Table</strong></p>

<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>
<p><strong>Output</strong></p>

<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><strong>Example</strong></h3>

<p><strong>Input</strong></p>

<p><strong><code>books</code> Table</strong></p>

<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>
<p><strong><code>borrows</code> Table</strong></p>

<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>
<p><strong>Output</strong></p>

<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>
<p><strong>Explanation</strong></p>

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

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

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


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

Digital Library Borrowing Metrics

<p>As part of the financial management in a large corporation, the CFO wants to review the expenses in all departments for the previous financial year (2022).</p>

<p>Write a SQL query to calculate the total expenditure for each department in 2022. Additionally, for comparison purposes, return the average expense across all departments in 2022.</p>

<p><strong><em>Note:</em></strong> <em>The output should include the department name, the total expense, and the average expense (rounded to 2 decimal places). The data should be sorted in descending order by total expenditure.</em></p>

<h3><strong>Example:</strong></h3>

<p><strong>Input:</strong></p>

<p><code>departments</code> table</p>

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

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

<tr>
<td>name</td>
<td>VARCHAR</td>
</tr>
</tbody>
</table>
<p><code>expenses</code> table</p>

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

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

<tr>
<td>department_id</td>
<td>INTEGER</td>
</tr>

<tr>
<td>amount</td>
<td>FLOAT</td>
</tr>

<tr>
<td>date</td>
<td>DATE</td>
</tr>
</tbody>
</table>
<p><strong>Output:</strong></p>

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

<tbody>
<tr>
<td>department_name</td>
<td>VARCHAR</td>
</tr>

<tr>
<td>total_expense</td>
<td>FLOAT</td>
</tr>

<tr>
<td>average_expense</td>
<td>FLOAT</td>
</tr>
</tbody>
</table>


Calculate total and average expenses for each department.

Department Expenses

<p>As an accountant for a local grocery store, you have been tasked with calculating the daily sales of each product since their last restocking.</p>

<p>You have been provided with three tables: <code>products</code>, <code>sales</code>, and <code>restocking</code>. The <code>products</code> table contains information about each product, the <code>sales</code> table records the sales transactions, and the <code>restocking</code> table tracks the restocking events.</p>

<p>Write a query to retrieve the running total of sales for each product since its last restocking event.</p>

<p><strong><em>Notes:</em></strong> <em>The <code>sales_since_last_restock</code> column represents the cumulative sales of the product for each day since its last restocking event. Order the result set by <code>product_id</code>.</em></p>

<p>Example:</p>

<p><strong>Input:</strong></p>

<p>Table <code>products</code>:</p>

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

<tbody>
<tr>
<td>product_id</td>
<td>int</td>
</tr>

<tr>
<td>product_name</td>
<td>varchar</td>
</tr>
</tbody>
</table>
<p>Table <code>sales</code>:</p>

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

<tbody>
<tr>
<td>sales_id</td>
<td>int</td>
</tr>

<tr>
<td>product_id</td>
<td>int</td>
</tr>

<tr>
<td>date</td>
<td>date</td>
</tr>

<tr>
<td>sold_count</td>
<td>int</td>
</tr>
</tbody>
</table>
<p>Table <code>restocking</code>:</p>

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

<tbody>
<tr>
<td>restock_id</td>
<td>int</td>
</tr>

<tr>
<td>product_id</td>
<td>int</td>
</tr>

<tr>
<td>restock_date</td>
<td>date</td>
</tr>
</tbody>
</table>
<p><strong>Output</strong></p>

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

<tbody>
<tr>
<td>product_name</td>
<td>varchar</td>
</tr>

<tr>
<td>date</td>
<td>date</td>
</tr>

<tr>
<td>sales_since_last_restock</td>
<td>int</td>
</tr>
</tbody>
</table>


Calculate daily sales of each product since last restocking.

Cumulative Sales Since Last Restocking

<p>There are two tables. One table is called <code>swipes</code> that holds a row for every Tinder swipe and contains a boolean column that determines if the swipe was a right or left swipe called <code>is_right_swipe</code>. The second is a table named <code>variants</code> that determines which user has which variant of an AB test.</p>

<p>Write a SQL query to output the average number of right swipes for two different variants of a feed ranking algorithm by comparing users that have swiped 10, 50, and 100 swipes in a <code>feed_change</code> experiment.</p>

<p><em>Note: Users have to have swiped at least 10 times to be included in the subset of users to analyze the mean number of right swipes.</em></p>

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<p><code>variants</code> table</p>

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

<tr>
<td><code>variant</code></td>
<td>VARCHAR</td>
</tr>

<tr>
<td><code>user_id</code></td>
<td>INTEGER</td>
</tr>
</tbody>
</table>
<p><code>swipes</code> table</p>

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

<tr>
<td><code>swiped_user_id</code></td>
<td>INTEGER</td>
</tr>

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

<tr>
<td><code>is_right_swipe</code></td>
<td>BOOLEAN</td>
</tr>
</tbody>
</table>
<p><strong>Output:</strong></p>

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

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

<tr>
<td><code>mean_right_swipes</code></td>
<td>FLOAT</td>
</tr>

<tr>
<td><code>swipe_threshold</code></td>
<td>INTEGER</td>
</tr>

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


Write a SQL query to find the average number of right swipes for different ranking algorithms.

Swipe Precision

A/B Testing

<p>Given a list of strings of letters from <code>a</code> to <code>z</code>, create a function, <code>sum_alphabet</code>, that returns a list of the <strong>alphabet sum</strong> of each word in the string.</p>

<p>The <strong>alphabet sum</strong> is the sum of the ordinal position of each of the string’s letters in the standard English alphabet ordering. So, the letter <code>a</code> will have a value of <code>1</code>, <code>z</code> will have a value of <code>26</code>, and so on.</p>

<p>As an example of the alphabet sum of a string, the string <code>sport</code> will have an <code>alphabet sum of 19 + 16 + 15 + 18 + 20 = 88</code>.</p>

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">words</span> <span class="o">=</span> <span class="p">[</span><span class="s2">&#34;sport&#34;</span> <span class="p">,</span> <span class="s2">&#34;good&#34;</span> <span class="p">,</span> <span class="s2">&#34;bad&#34;</span><span class="p">]</span>
</span></span></code></pre>

<p><strong>Output:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">sum_alphabet</span><span class="p">(</span><span class="n">words</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="p">[</span><span class="mi">88</span> <span class="p">,</span> <span class="mi">41</span> <span class="p">,</span> <span class="mi">7</span><span class="p">]</span>
</span></span></code></pre>


Alphabet Sum

<p>Write a query to show the number of users, number of transactions placed, and total order amount per month in the year 2020. Assume that we are only interested in the monthly reports for a single year (January-December).</p>

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<p><code>transactions</code> table</p>

<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>
<p><code>products</code> table</p>

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

<tr>
<td><code>price</code></td>
<td>FLOAT</td>
</tr>
</tbody>
</table>
<p><code>users</code> table</p>

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

<tr>
<td><code>sex</code></td>
<td>VARCHAR</td>
</tr>
</tbody>
</table>
<p><strong>Output:</strong></p>

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

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

<tr>
<td><code>num_customers</code></td>
<td>INTEGER</td>
</tr>

<tr>
<td><code>num_orders</code></td>
<td>INTEGER</td>
</tr>

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


Monthly Customer Report

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

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

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<p><code>users</code> table</p>

<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>
<p><code>purchases</code> table</p>

<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>
<p><strong>Output:</strong></p>

<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

<p>You have a table containing information about the time that employees have worked on a project.</p>

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

<p><strong>Example:</strong></p>

<p>An employee worked on two projects, and recorded their time like this:</p>

<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>
<p>The number of unique calendar days is therefore 7.</p>

<h3>Schema</h3>

<p><strong>Input:</strong></p>

<p><code>projects</code> table</p>

<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>
<p><strong>Output:</strong></p>

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

<p><strong>Input:</strong></p>

<p><strong><code>projects</code> table</strong></p>

<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>
<p><strong>Output:</strong></p>

<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

<p>Let’s say that you’re a data scientist working on a distribution team at Amazon.</p>

<p>Create a report displaying which shipments were delivered to customers during their membership period.</p>

<p>If the transaction is shipped during the membership period, column <code>is_member</code> should have the value <code>Y</code>. If not, the column should have the value <code>N</code>.</p>

<p><em>Hint: You may assume that <code>customer_id</code> is unique and that shipments are made only to registered customers.</em></p>

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<p><code>customers</code> table</p>

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

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

<tr>
<td><code>membership_start_date</code></td>
<td>DATETIME</td>
</tr>

<tr>
<td><code>membership_end_date</code></td>
<td>DATETIME</td>
</tr>
</tbody>
</table>
<p><code>shipments</code> table</p>

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

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

<tr>
<td><code>ship_date</code></td>
<td>DATETIME</td>
</tr>

<tr>
<td><code>customer_id</code></td>
<td>INTEGER</td>
</tr>

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

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

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

<tr>
<td><code>ship_date</code></td>
<td>DATETIME</td>
</tr>

<tr>
<td><code>customer_id</code></td>
<td>INTEGER</td>
</tr>

<tr>
<td><code>is_member</code></td>
<td>TEXT</td>
</tr>

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


Create a report displaying which shipments were delivered to customers during their membership period.

Completed Shipments

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

<p><strong>Example 1:</strong></p>

<p><strong>Input:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
</span></span></code></pre>

<p><strong>Output:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">find_duplicates</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
</span></span></code></pre>

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

<p><strong>Example 2:</strong></p>

<p><strong>Input:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">]</span>
</span></span></code></pre>

<p><strong>Output:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">find_duplicates</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
</span></span></code></pre>

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

<p><strong>Example 3:</strong></p>

<p><strong>Input:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">]</span>
</span></span></code></pre>

<p><strong>Output:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">find_duplicates</span><span class="p">(</span><span class="n">nums</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="p">[]</span>
</span></span></code></pre>

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


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

<p>Given a sorted list of positive integers with some entries being <code>None</code>, write a function to return a new list where all <code>None</code> values are replaced with the most recent non-<code>None</code> value in the list.</p>

<p><em>Note: If the first entry in the list is <code>None</code>, assume the previous entry was <code>0</code>.</em></p>

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">input_list</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="kc">None</span><span class="p">,</span><span class="kc">None</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="kc">None</span><span class="p">]</span>
</span></span></code></pre>

<p><strong>Output:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">fill_none</span><span class="p">(</span><span class="n">input_list</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">5</span><span class="p">]</span> 
</span></span></code></pre>


Write a function to return a new list where all empty values are replaced with the most recent non-empty value in the list.

Fill None Values

<p>You’re given a string that may contain the characters <strong><code>{</code></strong>, <strong><code>}</code></strong>, <strong><code>[</code></strong>, <strong><code>]</code></strong>, <strong><code>(</code></strong>, and <strong><code>)</code></strong>.</p>

<p><strong>Task:</strong> Verify that the string is balanced. A balanced string is one where every opening character, <strong><code>{</code></strong>, <strong><code>[</code></strong>, or <strong><code>(</code></strong>, has a corresponding closing character, <strong><code>}</code></strong>, <strong><code>]</code></strong>, or <strong><code>)</code></strong>.</p>

<p>Write a function called <strong><code>is_balanced(string: str) -&gt; bool</code></strong> which verifies the balance of a string.</p>

<p><strong>Example:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">is_balanced</span><span class="p">(</span><span class="s1">&#39;(())[]</span><span class="si">{}</span><span class="s1">&#39;</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">True</span>
</span></span></code></pre>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">is_balanced</span><span class="p">(</span><span class="s1">&#39;{([()</span><span class="si">{}</span><span class="s1">])()}&#39;</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">True</span>
</span></span></code></pre>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">is_balanced</span><span class="p">(</span><span class="s1">&#39;</span><span class="si">{}</span><span class="s1">[]())&#39;</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">False</span>
</span></span></code></pre>

<hr/>


Write a function that tests whether a string of brackets is balanced.

The Brackets Problem

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

<p>Example questions:</p>

<p>Consider a string where all characters are lowercase alphabets.</p>

<p><strong>Example 1:</strong></p>

<p><strong>Input:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">s</span> <span class="o">=</span> <span class="s1">&#39;helloworld&#39;</span>
</span></span></code></pre>

<p><strong>Output:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">first_uniq_char</span><span class="p">(</span><span class="n">s</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="mi">0</span>
</span></span></code></pre>

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

<p><strong>Example 2:</strong></p>

<p><strong>Input:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">s</span> <span class="o">=</span> <span class="s1">&#39;concussion&#39;</span>
</span></span></code></pre>

<p><strong>Output:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="n">first_uniq_char</span><span class="p">(</span><span class="n">s</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="mi">4</span>
</span></span></code></pre>

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


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

<p>Let’s say that you’re the PM on Google Maps.</p>

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

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


Google Maps Improvement

Product Sense & Metrics

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

<p><em>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.</em></p>

<p><em>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.</em></p>

<p><strong>Example:</strong></p>

<p><strong>Input:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">a</span> <span class="o">=</span> <span class="p">[(</span><span class="o">-</span><span class="mi">3</span><span class="p">,</span><span class="mi">5</span><span class="p">),</span> <span class="p">(</span><span class="o">-</span><span class="mi">3</span><span class="p">,</span><span class="mi">2</span><span class="p">),(</span><span class="mi">0</span><span class="p">,</span><span class="mi">5</span><span class="p">),(</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">)]</span>
</span></span><span class="line"><span class="cl"><span class="n">b</span> <span class="o">=</span> <span class="p">[(</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span><span class="mi">4</span><span class="p">),</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">),</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="mi">1</span><span class="p">),</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">)]</span>
</span></span></code></pre>

<p><strong>Output:</strong></p>

<pre tabindex="0" class="chroma"><code><span class="line"><span class="cl"><span class="k">def</span> <span class="nf">rectangle_overlap</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">True</span>
</span></span></code></pre>

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


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

Rectangle Overlap

Challenge

Nomura Salaries by Position

<div><h2>Junior Business Analyst</h2><p>Position: Junior Business Analyst</p><p>Department: Digital Solutions</p><p>This is a 9-month contract position based in the Philadelphia office (hybrid)</p><p>The pay range for this position at commencement of employment is expected to be between $250-300/day* (see below footnote for additional compensation and benefits information).</p><p>Company Overview: Nomura is a global financial services group with an integrated network spanning approximately 30 countries and regions. By connecting markets East & West, Nomura services the needs of individuals, institutions, corporates and governments through its three business divisions: Wealth Management, Investment Management, and Wholesale (Global Markets and Investment Banking). Founded in 1925, the firm is built on a tradition of disciplined entrepreneurship, serving clients with creative solutions and considered thought leadership.</p><p>Division Overview: NAM International</p><p>The international business brings together a legacy of investing in public and private markets on a global scale. Through active management, we deliver differentiated and innovative solutions across equities, fixed income, multi-asset, and private credit supported by a team of disciplined and tenured investment professionals. Building upon Nomura's century long heritage, our teams are responsible stewards of clients' capital. We approach everything we do with accountability, curiosity, and integrity to help clients across wealth and institutional channels navigate an ever-changing market, capture opportunities around the world, and reach long-term investment goals.</p><h3>Role Description / Responsibilities:</h3><ul><li>Function as a liaison between business stakeholders and technology teams, ensuring requirements are accurately captured, processes are streamlined, and deliverables are aligned with business objectives</li><li>Facilitate communication, drive efficiency, and help mitigate risks throughout the migration and transformation process</li><li>Analyze and document current-state and future-state business, identifying gaps and opportunities for improvement</li><li>Convert business objectives and requirements into clear, actionable specifications for technology teams, ensuring mutual understanding</li><li>Facilitate user acceptance testing (UAT) and sign-off of migrated applications and processes, ensuring solutions align with business goals</li><li>Assess and communicate the impact of technology changes on business operations, processes, and roles</li><li>Develop training materials, conduct training sessions, and provide ongoing support to business users during and after migration</li><li>Work with business and technical teams to map source and target data structures, ensuring data integrity during migration and define and execute business-level data validation processes post-migration, collaborating with technology teams to resolve discrepancies</li><li>Proactively identify business risks related to migration, integration, and process changes and implement necessary mitigation strategy</li><li>Gather and analyze feedback from business users to identify areas for process improvement and optimization and document lessons learned and best practices for future migrations and technology transitions</li></ul><h3>Skills, Experience, Qualifications and Knowledge Required:</h3><ul><li>Bachelor's degree in Business, IT, or related field</li><li>2-4+ years' experience with system migrations, data transitions, or similar transformation projects</li><li>Knowledge of and substantiated work within business analysis methodologies (Agile)</li><li>Proficiency in documentation tools (Confluence, DrawIO for process mapping), data analysis tools (Excel, SQL basics, Aladdin? or specific platforms we are targeting), and project management tools (Jira, ServiceNow, etc.)</li><li>Knowledge of the Investment Management/Asset Management industry is a plus</li><li>Strong analytical and problem-solving abilities</li><li>Excellent written and verbal communication</li><li>Stakeholder management experience</li><li>Ability to work in fast-paced, changing environments</li></ul><h3>Nomura Competencies:</h3><p><strong>Explore Insights & Vision</strong></p><ul><li>Identify the underlying causes of problems faced by you or your team and define a clear vision and direction for the future.</li></ul><p><strong>Making Strategic Decisions</strong></p><ul><li>Evaluate all the options for resolving the problems and effectively prioritize actions or recommendations.</li></ul><p><strong>Inspire Entrepreneurship in People</strong></p><ul><li>Inspire team members through effective communication of ideas and motivate them to actively enhance productivity.</li></ul><p><strong>Elevate Organizational Capability</strong></p><ul><li>Engage proactively in professional development and enhance team productivity through the promotion of knowledge sharing.</li></ul><p><strong>Inclusion</strong></p><ul><li>Foster a culture of inclusion and psychological safety in the workplace and cultivate a "Risk Culture" (Challenge, Escalate and Respect).</li></ul><p>*base pay offered may vary depending on multiple individualized factors, including market location, corporate and functional title and duties, job-related knowledge and advanced degrees, skills, and experience. The total compensation package for this position may also include other elements, including a sign-on bonus, restricted stock units, discretionary awards and eligibility for commissions for applicable sales roles in addition to a full range of medical, financial, and/or other benefits (including 401(k) eligibility and various paid time off benefits, such as vacation, sick time, and parental leave), dependent on the position offered. Details of participation in these benefit plans will be provided if an employee receives an offer of employment.</p><p>If hired in the U.S., employee will be in an "at-will position" and the Company reserves the right to modify base salary (as well as any other discretionary payment or compensation program) at any time, including for reasons related to individual performance, Company or individual department/team performance, and market factors".</p><p>Nomura is an Equal Opportunity Employer</p></div>

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

Nomura Interview Questions

Nomura Interview Guides