Is Rising Temperature easy or hard?

Rising Temperature is classified as an Easy SQL problem. The main challenge is recognizing that you must compare each row with the previous day using either a self join or a window function like LAG.

How to solve Rising Temperature in O(n)?

Pure O(n) is difficult in SQL because rows must be ordered by date before comparison. The closest practical solution uses the LAG window function after sorting by recordDate. Once ordered, each row is compared with the previous row in a single pass.

What is the best approach for Rising Temperature?

The LAG window function approach is the cleanest solution in modern SQL. It directly accesses the previous row's temperature and date without performing a self join. The query becomes shorter and easier to read while maintaining O(n log n) time due to sorting by date.

Rising Temperature Python or Java solution exists?

This problem is designed specifically for SQL because it operates on a relational database table. In application code like Python or Java, you would typically load the records, sort them by date, and compare adjacent entries to detect temperature increases.

What data structure is used in Rising Temperature?

The problem relies on relational table operations rather than traditional data structures. SQL joins and window functions act as the primary mechanisms for comparing rows, especially when working with ordered data by date.

What is the time complexity of Rising Temperature?

Most SQL solutions run in O(n log n) time because the database typically sorts rows by recordDate or uses indexed lookups during joins. The space complexity is O(1) for self-join solutions and O(n) when using window functions that create intermediate result sets.

Is Rising Temperature asked at Google, Amazon, or Meta?

Rising Temperature is a common SQL screening problem used by companies that evaluate database fundamentals. Variations of this problem appear in interviews at companies like Amazon and other data-heavy teams that require strong SQL querying skills.

Description Solution Video 6:58

197. Rising Temperature

Easy52.4% acceptance12 companies

Table: Weather

+---------------+---------+
| Column Name   | Type    |
+---------------+---------+
| id            | int     |
| recordDate    | date    |
| temperature   | int     |
+---------------+---------+
id is the column with unique values for this table.
There are no different rows with the same recordDate.
This table contains information about the temperature on a certain day.

Write a solution to find all dates' id with higher temperatures compared to its previous dates (yesterday).

Return the result table in any order.

The result format is in the following example.

Example 1:

Input: 
Weather table:
+----+------------+-------------+
| id | recordDate | temperature |
+----+------------+-------------+
| 1  | 2015-01-01 | 10          |
| 2  | 2015-01-02 | 25          |
| 3  | 2015-01-03 | 20          |
| 4  | 2015-01-04 | 30          |
+----+------------+-------------+
Output: 
+----+
| id |
+----+
| 2  |
| 4  |
+----+
Explanation: 
In 2015-01-02, the temperature was higher than the previous day (10 -> 25).
In 2015-01-04, the temperature was higher than the previous day (20 -> 30).

Asked at 12 companies

Meesho Fractal Analytics Microsoft Bloomberg Walmart Labs Cognizant

Deloitte

Google Amazon Meta Accenture

Cisco

Topics

Database

6:58

Still stuck?Read 5 approaches, or watch a walkthrough.

Open solution

LanguageLoading editor…

1# Write your MySQL query statement below

Starter codeMySQLSpaces: 4

Examples

Case 1

Input

{"headers": {"Weather": ["id", "recordDate", "temperature"]}, "rows": {"Weather": [[1, "2015-01-01", 10], [2, "2015-01-02", 25], [3, "2015-01-03", 20], [4, "2015-01-04", 30]]}}

Your code is saved on this device.Solution