Given the the schema presented below find two actors who cast together the most and list titles of only those movies they were casting together. Order the result set alphabetically by the movie title.

`Column | Type | Modifiers`

------------+-----------------------------+----------

actor_id | smallint | not null

film_id | smallint | not null

...

`Column | Type | Modifiers`

------------+-----------------------------+----------

actor_id | integer | not null

first_name | character varying(45) | not null

last_name | character varying(45) | not null

...

`Column | Type | Modifiers`

------------+-----------------------------+----------

film_id | integer | not null

title | character varying(255) | not null

...

`…`

Contains Duplicate

Given an array of integers, find if the array contains any duplicates.

Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.

**Example 1:**

**Input:** [1,2,3,1]

**Output:** true

**Example 2:**

**Input: **[1,2,3,4]

**Output:** false

**Example 3:**

**Input: **[1,1,1,3,3,4,3,2,4,2]

**Output:** true

—

My idea was pretty simple: Firstly, sort the array. And then loop through the array, if there are two consecutive elements the same, store the duplicated one in the empty array. Return whether the duplicate array is 0 or not.

Remember the…

39. Combination Sum

Given an array of **distinct** integers `candidates`

and a target integer `target`

, return *a list of all **unique combinations** of *`candidates`

* where the chosen numbers sum to *`target`

*.* You may return the combinations in **any order**.

The **same** number may be chosen from `candidates`

an **unlimited number of times**. Two combinations are unique if the frequency of at least one of the chosen numbers is different.

It is **guaranteed** that the number of unique combinations that sum up to `target`

is less than `150`

combinations for the given input.

**Example 1:**

**Input:** candidates = [2,3,6,7], target =…

21. Merge Two Sorted Lists

Merge two sorted linked lists and return it as a **sorted** list. The list should be made by splicing together the nodes of the first two lists.

**Example 1:**

**Input:** l1 = [1,2,4], l2 = [1,3,4]

**Output:** [1,1,2,3,4,4]

**Example 2:**

**Input:** l1 = [], l2 = []

**Output:** []

**Example 3:**

**Input:** l1 = [], l2 = [0]

**Output:** [0]

**Constraints:**

- The number of nodes in both lists is in the range
`[0, 50]`

. `-100 <= Node.val <= 100`

- Both
`l1`

and`l2`

are sorted in**non-decreasing**order.

**Solution1: Iteratively**

`class Solution…`

360. Sort Transformed Array

Given a **sorted** integer array `nums`

and three integers `a`

, `b`

and `c`

, apply a quadratic function of the form `f(x) = ax2 + bx + c`

to each element `nums[i]`

in the array, and return *the array in a sorted order*.

**Example 1:**

**Input:** nums = [-4,-2,2,4], a = 1, b = 3, c = 5

**Output:** [3,9,15,33]

**Example 2:**

**Input:** nums = [-4,-2,2,4], a = -1, b = 3, c = 5

**Output:** [-23,-5,1,7]

**Constraints:**

`1 <= nums.length <= 200`

`-100 <= nums[i], a, b, c <= 100`

`nums`

is sorted in**ascending**order.

**…**

1196. How Many Apples Can You Put into the Basket

You have some apples, where `arr[i]`

is the weight of the `i`

-th apple. You also have a basket that can carry up to `5000`

units of weight.

Return the maximum number of apples you can put in the basket.

**Example 1:**

**Input:** arr = [100,200,150,1000]

**Output:** 4

**Explanation: **All 4 apples can be carried by the basket since their sum of weights is 1450.

**Example 2:**

**Input:** arr = [900,950,800,1000,700,800]

**Output:** 5

**Explanation: **The sum of weights of the 6 apples exceeds 5000 so we choose any 5 of them.

**…**

You are asked to ensure that the first and last names of people begin with a capital letter in their passports. For example, `alison heck`

should be capitalised correctly as `Alison Heck`

.

Given a full name, your task is to capitalize the name appropriately.

**Input Format**

A single line of input containing the full name, S.

**Constraints**

- 0 < len(S) < 1000
- The string consists of alphanumeric characters and spaces.

**Note:** in a word only the first character is capitalized. Example 12abc when capitalized remains 12abc.

**Output Format**

Print the capitalized string, S.

**Sample Input**

`chris alan`

**Sample Output**

`Chris Alan`

Solution(Python3):

# Complete the solve function below.def solve(s):return ' '.join(word.capitalize() for word in s.split(' '))

if __name__ == '__main__':fptr = open(os.environ['OUTPUT_PATH'], 'w')s = input()result = solve(s)fptr.write(result + '\n')fptr.close()

Given the names and grades for each student in a class of students N, store them in a nested list and print the name(s) of any student(s) having the second lowest grade.

**Note:** If there are multiple students with the second lowest grade, order their names alphabetically and print each name on a new line.

**Example**

The ordered list of scores is , so the second lowest score is . There are two students with that score: . Ordered alphabetically, the names are printed as:

`alpha`

beta

**Input Format**

The first line contains an integer, N , the number of…

262. Trips and Users

Table: `Trips`

`+-------------+----------+`

| Column Name | Type |

+-------------+----------+

| Id | int |

| Client_Id | int |

| Driver_Id | int |

| City_Id | int |

| Status | enum |

| Request_at | date |

+-------------+----------+

Id is the primary key for this table.

The table holds all taxi trips. Each trip has a unique Id, while Client_Id and Driver_Id are foreign keys to the Users_Id at the Users table.

Status is an ENUM type of (‘completed’, ‘cancelled_by_driver’, ‘cancelled_by_client’).

Table: `Users`

`+-------------+----------+`

| Column Name | Type |

+-------------+----------+

|…

An extra day is added to the calendar almost every four years as February 29, and the day is called a leap day. It corrects the calendar for the fact that our planet takes approximately 365.25 days to orbit the sun. A leap year contains a leap day.

In the Gregorian calendar, three conditions are used to identify leap years:

- The year can be evenly divided by 4, is a leap year, unless:
- The year can be evenly divided by 100, it is NOT a leap year, unless:
- The year is also evenly divisible by 400. …

In love with telling stories with data