Appearance
question:Given two integer arrays `nums1` and `nums2` sorted in non-decreasing order, and two integers `m` and `n`, representing the number of elements in `nums1` and `nums2` respectively, merge `nums2` into `nums1` as one sorted array. Note: - The number of elements initialized in `nums1` and `nums2` are `m` and `n` respectively. - You may assume that `nums1` has enough space (size that is equal to `m + n`) to hold additional elements from `nums2`. Function signature: ``` def merge(nums1: List[int], m: int, nums2: List[int], n: int) -> None: Do not return anything, modify nums1 in-place instead. ```
answer:from typing import List def merge(nums1: List[int], m: int, nums2: List[int], n: int) -> None: Merges nums2 into nums1 in-place. i, j, k = m - 1, n - 1, m + n - 1 while j >= 0: if i >= 0 and nums1[i] > nums2[j]: nums1[k] = nums1[i] i -= 1 else: nums1[k] = nums2[j] j -= 1 k -= 1
question:A **language** processing company is developing an algorithm to analyze the **reading habits** of users on their platform. You are provided with a 2D integer array `sessions`, where `sessions[i] = [userID, bookID, duration]` represents that the user with `userID` has read the book with `bookID` for `duration` minutes during a single reading session. The company wants to understand the **most engaged user** with each book by finding the total time each user has spent reading each book. Write a function that returns a 2D integer array representing each book and the most engaged user for that book. Each entry in this array should be of the form `[bookID, userID, totalDuration]`. If there are multiple users with the same total reading duration for a book, return the user with the smallest `userID`. The returned array should be sorted by `bookID` in ascending order.
answer:def most_engaged_users(sessions): from collections import defaultdict # Dictionary to store total duration per user per book book_user_duration = defaultdict(lambda: defaultdict(int)) for session in sessions: userID, bookID, duration = session book_user_duration[bookID][userID] += duration result = [] for bookID in sorted(book_user_duration.keys()): most_engaged_user = min(book_user_duration[bookID].items(), key=lambda x: (-x[1], x[0])) result.append([bookID, most_engaged_user[0], most_engaged_user[1]]) return result
question:You are given a **0-indexed** integer array `temperature`, where `temperature[i]` denotes the temperature measured on the `i`th day. A day `i` is considered a **cold day** if it satisfies the following conditions: - There are at least `k` days before and after the `i`th day, - The temperatures for the `k` days **before** `i` are strictly decreasing, - The temperatures for the `k` days **after** `i` are strictly increasing. More formally, day `i` is a cold day if and only if `temperature[i - k] > temperature[i - k + 1] > ... > temperature[i] < ... < temperature[i + k - 1] < temperature[i + k]`. Return _a list of **all** days **(0-indexed)** that are considered cold days_. The order of the days in the returned list does **not** matter.
answer:def find_cold_days(temperature, k): cold_days = [] n = len(temperature) for i in range(k, n - k): is_cold = True for j in range(1, k + 1): if not (temperature[i - j] > temperature[i - j + 1] and temperature[i + j - 1] < temperature[i + j]): is_cold = False break if is_cold: cold_days.append(i) return cold_days
question:You are participating in a programming contest with `n` problems numbered from `0` to `n - 1`. Each problem has a different scoring value represented by a **0-indexed** integer array `scores` where `scores[i]` is the score for solving the `i-th` problem. In addition, you are given an integer `minScore`. To pass the contest, you need to solve a subset of the problems such that the sum of their scores is at least `minScore`. However, there is a twist: you can choose to **skip** at most one problem while forming your subset. Your goal is to determine whether it is possible to pass the contest given this rule. Return _`true` if it is possible to pass the contest by choosing a subset of problems while possibly skipping one, or `false` otherwise_.
answer:def can_pass_contest(scores, minScore): total_score = sum(scores) if total_score >= minScore: return True if len(scores) == 1: return scores[0] >= minScore max_score_to_skip = max(scores) total_score -= max_score_to_skip return total_score >= minScore