number int64 1 2.6k | difficulty int64 0 2 | question stringlengths 294 4.95k |
|---|---|---|
1 | 0 | class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
"""
Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
You may assume that each input would have exactly one solution, and you may not use the s... |
2 | 1 | class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
"""
You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two num... |
3 | 1 | class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
"""
Given a string s, find the length of the longest substring without repeating characters.
Example 1:
Input: s = "abcabcbb"
Output: 3
Explanation: The answer is "abc", with the length of 3.
E... |
4 | 2 | class Solution:
def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
"""
Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays.
The overall run time complexity should be O(log (m+n)).
Example 1:
... |
5 | 1 | class Solution:
def longestPalindrome(self, s: str) -> str:
"""
Given a string s, return the longest palindromic substring in s.
Example 1:
Input: s = "babad"
Output: "bab"
Explanation: "aba" is also a valid answer.
Example 2:
Input: s = "cbbd"
... |
6 | 1 | class Solution:
def convert(self, s: str, numRows: int) -> str:
"""
The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)
P A H N
A P L S I I G
Y I ... |
7 | 1 | class Solution:
def reverse(self, x: int) -> int:
"""
Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range [-231, 231 - 1], then return 0.
Assume the environment does not allow you to store 64-bit in... |
8 | 1 | class Solution:
def myAtoi(self, s: str) -> int:
"""
Implement the myAtoi(string s) function, which converts a string to a 32-bit signed integer (similar to C/C++'s atoi function).
The algorithm for myAtoi(string s) is as follows:
Read in and ignore any leading whitespace.
... |
9 | 0 | class Solution:
def isPalindrome(self, x: int) -> bool:
"""
Given an integer x, return true if x is a palindrome, and false otherwise.
Example 1:
Input: x = 121
Output: true
Explanation: 121 reads as 121 from left to right and from right to left.
Example 2:
... |
10 | 2 | class Solution:
def isMatch(self, s: str, p: str) -> bool:
"""
Given an input string s and a pattern p, implement regular expression matching with support for '.' and '*' where:
'.' Matches any single character.
'*' Matches zero or more of the preceding element.
T... |
11 | 1 | class Solution:
def maxArea(self, height: List[int]) -> int:
"""
You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]).
Find two lines that together with the x-axis form a container, such ... |
12 | 1 | class Solution:
def intToRoman(self, num: int) -> str:
"""
Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.
Symbol Value
I 1
V 5
X 10
L 50
C 100
... |
13 | 0 | class Solution:
def romanToInt(self, s: str) -> int:
"""
Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.
Symbol Value
I 1
V 5
X 10
L 50
C 100
D... |
14 | 0 | class Solution:
def longestCommonPrefix(self, strs: List[str]) -> str:
"""
Write a function to find the longest common prefix string amongst an array of strings.
If there is no common prefix, return an empty string "".
Example 1:
Input: strs = ["flower","flow","flight"]
... |
15 | 1 | class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
"""
Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0.
Notice that the solution set must not contain duplicate tri... |
16 | 1 | class Solution:
def threeSumClosest(self, nums: List[int], target: int) -> int:
"""
Given an integer array nums of length n and an integer target, find three integers in nums such that the sum is closest to target.
Return the sum of the three integers.
You may assume that each input ... |
17 | 1 | class Solution:
def letterCombinations(self, digits: str) -> List[str]:
"""
Given a string containing digits from 2-9 inclusive, return all possible letter combinations that the number could represent. Return the answer in any order.
A mapping of digits to letters (just like on the telephone... |
18 | 1 | class Solution:
def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
"""
Given an array nums of n integers, return an array of all the unique quadruplets [nums[a], nums[b], nums[c], nums[d]] such that:
0 <= a, b, c, d < n
a, b, c, and d are distinct.
... |
19 | 1 | class Solution:
def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
"""
Given the head of a linked list, remove the nth node from the end of the list and return its head.
Example 1:
Input: head = [1,2,3,4,5], n = 2
Output: [1,2,3,5]
Exa... |
20 | 0 | class Solution:
def isValid(self, s: str) -> bool:
"""
Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.
An input string is valid if:
Open brackets must be closed by the same type of brackets.
Open... |
21 | 0 | class Solution:
def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
"""
You are given the heads of two sorted linked lists list1 and list2.
Merge the two lists in a one sorted list. The list should be made by splicing together the nodes of the... |
22 | 1 | class Solution:
def generateParenthesis(self, n: int) -> List[str]:
"""
Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.
Example 1:
Input: n = 3
Output: ["((()))","(()())","(())()","()(())","()()()"]
Example 2:
... |
23 | 2 | class Solution:
def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
"""
You are given an array of k linked-lists lists, each linked-list is sorted in ascending order.
Merge all the linked-lists into one sorted linked-list and return it.
Example 1:
In... |
24 | 1 | class Solution:
def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
"""
Given a linked list, swap every two adjacent nodes and return its head. You must solve the problem without modifying the values in the list's nodes (i.e., only nodes themselves may be changed.)
Example 1... |
25 | 2 | class Solution:
def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
"""
Given the head of a linked list, reverse the nodes of the list k at a time, and return the modified list.
k is a positive integer and is less than or equal to the length of the linked list. I... |
26 | 0 | class Solution:
def removeDuplicates(self, nums: List[int]) -> int:
"""
Given an integer array nums sorted in non-decreasing order, remove the duplicates in-place such that each unique element appears only once. The relative order of the elements should be kept the same.
Since it is impossib... |
27 | 0 | class Solution:
def removeElement(self, nums: List[int], val: int) -> int:
"""
Given an integer array nums and an integer val, remove all occurrences of val in nums in-place. The relative order of the elements may be changed.
Since it is impossible to change the length of the array in some l... |
28 | 0 | class Solution:
def strStr(self, haystack: str, needle: str) -> int:
"""
Given two strings needle and haystack, return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.
Example 1:
Input: haystack = "sadbutsad", needle = "sad"
Ou... |
29 | 1 | class Solution:
def divide(self, dividend: int, divisor: int) -> int:
"""
Given two integers dividend and divisor, divide two integers without using multiplication, division, and mod operator.
The integer division should truncate toward zero, which means losing its fractional part. For examp... |
30 | 2 | class Solution:
def findSubstring(self, s: str, words: List[str]) -> List[int]:
"""
You are given a string s and an array of strings words. All the strings of words are of the same length.
A concatenated substring in s is a substring that contains all the strings of any permutation of words ... |
31 | 1 | class Solution:
def nextPermutation(self, nums: List[int]) -> None:
"""
Do not return anything, modify nums in-place instead.
A permutation of an array of integers is an arrangement of its members into a sequence or linear order.
For example, for arr = [1,2,3], the following are ... |
32 | 2 | class Solution:
def longestValidParentheses(self, s: str) -> int:
"""
Given a string containing just the characters '(' and ')', return the length of the longest valid (well-formed) parentheses substring.
Example 1:
Input: s = "(()"
Output: 2
Explanation: The longest ... |
33 | 1 | class Solution:
def search(self, nums: List[int], target: int) -> int:
"""
There is an integer array nums sorted in ascending order (with distinct values).
Prior to being passed to your function, nums is possibly rotated at an unknown pivot index k (1 <= k < nums.length) such that the result... |
34 | 1 | class Solution:
def searchRange(self, nums: List[int], target: int) -> List[int]:
"""
Given an array of integers nums sorted in non-decreasing order, find the starting and ending position of a given target value.
If target is not found in the array, return [-1, -1].
You must write an... |
35 | 0 | class Solution:
def searchInsert(self, nums: List[int], target: int) -> int:
"""
Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.
You must write an algorithm with O(... |
36 | 1 | class Solution:
def isValidSudoku(self, board: List[List[str]]) -> bool:
"""
Determine if a 9 x 9 Sudoku board is valid. Only the filled cells need to be validated according to the following rules:
Each row must contain the digits 1-9 without repetition.
Each column must cont... |
37 | 2 | class Solution:
def solveSudoku(self, board: List[List[str]]) -> None:
"""
Do not return anything, modify board in-place instead.
Write a program to solve a Sudoku puzzle by filling the empty cells.
A sudoku solution must satisfy all of the following rules:
Each of the di... |
38 | 1 | class Solution:
def countAndSay(self, n: int) -> str:
"""
The count-and-say sequence is a sequence of digit strings defined by the recursive formula:
countAndSay(1) = "1"
countAndSay(n) is the way you would "say" the digit string from countAndSay(n-1), which is then converted... |
39 | 1 | class Solution:
def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
"""
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 combinati... |
40 | 1 | class Solution:
def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
"""
Given a collection of candidate numbers (candidates) and a target number (target), find all unique combinations in candidates where the candidate numbers sum to target.
Each number in candid... |
41 | 2 | class Solution:
def firstMissingPositive(self, nums: List[int]) -> int:
"""
Given an unsorted integer array nums, return the smallest missing positive integer.
You must implement an algorithm that runs in O(n) time and uses constant extra space.
Example 1:
Input: nums = [1,2,... |
42 | 2 | class Solution:
def trap(self, height: List[int]) -> int:
"""
Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it can trap after raining.
Example 1:
Input: height = [0,1,0,2,1,0,1,3,2,1,2,1]
Output: 6
... |
43 | 1 | class Solution:
def multiply(self, num1: str, num2: str) -> str:
"""
Given two non-negative integers num1 and num2 represented as strings, return the product of num1 and num2, also represented as a string.
Note: You must not use any built-in BigInteger library or convert the inputs to intege... |
44 | 2 | class Solution:
def isMatch(self, s: str, p: str) -> bool:
"""
Given an input string (s) and a pattern (p), implement wildcard pattern matching with support for '?' and '*' where:
'?' Matches any single character.
'*' Matches any sequence of characters (including the empty se... |
45 | 1 | class Solution:
def jump(self, nums: List[int]) -> int:
"""
You are given a 0-indexed array of integers nums of length n. You are initially positioned at nums[0].
Each element nums[i] represents the maximum length of a forward jump from index i. In other words, if you are at nums[i], you can... |
46 | 1 | class Solution:
def permute(self, nums: List[int]) -> List[List[int]]:
"""
Given an array nums of distinct integers, return all the possible permutations. You can return the answer in any order.
Example 1:
Input: nums = [1,2,3]
Output: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2]... |
47 | 1 | class Solution:
def permuteUnique(self, nums: List[int]) -> List[List[int]]:
"""
Given a collection of numbers, nums, that might contain duplicates, return all possible unique permutations in any order.
Example 1:
Input: nums = [1,1,2]
Output:
[[1,1,2],
[1,2,... |
48 | 1 | class Solution:
def rotate(self, matrix: List[List[int]]) -> None:
"""
Do not return anything, modify matrix in-place instead.
You are given an n x n 2D matrix representing an image, rotate the image by 90 degrees (clockwise).
You have to rotate the image in-place, which means you ha... |
49 | 1 | class Solution:
def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
"""
Given an array of strings strs, group the anagrams together. You can return the answer in any order.
An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically usin... |
50 | 1 | class Solution:
def myPow(self, x: float, n: int) -> float:
"""
Implement pow(x, n), which calculates x raised to the power n (i.e., xn).
Example 1:
Input: x = 2.00000, n = 10
Output: 1024.00000
Example 2:
Input: x = 2.10000, n = 3
Output: 9.26100
... |
51 | 2 | class Solution:
def solveNQueens(self, n: int) -> List[List[str]]:
"""
The n-queens puzzle is the problem of placing n queens on an n x n chessboard such that no two queens attack each other.
Given an integer n, return all distinct solutions to the n-queens puzzle. You may return the answer ... |
52 | 2 | class Solution:
def totalNQueens(self, n: int) -> int:
"""
The n-queens puzzle is the problem of placing n queens on an n x n chessboard such that no two queens attack each other.
Given an integer n, return the number of distinct solutions to the n-queens puzzle.
Example 1:
I... |
53 | 1 | class Solution:
def maxSubArray(self, nums: List[int]) -> int:
"""
Given an integer array nums, find the subarray with the largest sum, and return its sum.
Example 1:
Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
Output: 6
Explanation: The subarray [4,-1,2,1] has the largest ... |
54 | 1 | class Solution:
def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
"""
Given an m x n matrix, return all elements of the matrix in spiral order.
Example 1:
Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]
Output: [1,2,3,6,9,8,7,4,5]
Example 2:
Input: matrix... |
55 | 1 | class Solution:
def canJump(self, nums: List[int]) -> bool:
"""
You are given an integer array nums. You are initially positioned at the array's first index, and each element in the array represents your maximum jump length at that position.
Return true if you can reach the last index, or fa... |
56 | 1 | class Solution:
def merge(self, intervals: List[List[int]]) -> List[List[int]]:
"""
Given an array of intervals where intervals[i] = [starti, endi], merge all overlapping intervals, and return an array of the non-overlapping intervals that cover all the intervals in the input.
Example 1:
... |
57 | 1 | class Solution:
def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
"""
You are given an array of non-overlapping intervals intervals where intervals[i] = [starti, endi] represent the start and the end of the ith interval and intervals is sorted in ascending orde... |
58 | 0 | class Solution:
def lengthOfLastWord(self, s: str) -> int:
"""
Given a string s consisting of words and spaces, return the length of the last word in the string.
A word is a maximal substring consisting of non-space characters only.
Example 1:
Input: s = "Hello World"
... |
59 | 1 | class Solution:
def generateMatrix(self, n: int) -> List[List[int]]:
"""
Given a positive integer n, generate an n x n matrix filled with elements from 1 to n2 in spiral order.
Example 1:
Input: n = 3
Output: [[1,2,3],[8,9,4],[7,6,5]]
Example 2:
Input: n = 1
... |
60 | 2 | class Solution:
def getPermutation(self, n: int, k: int) -> str:
"""
The set [1, 2, 3, ..., n] contains a total of n! unique permutations.
By listing and labeling all of the permutations in order, we get the following sequence for n = 3:
"123"
"132"
"213"
... |
61 | 1 | class Solution:
def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
"""
Given the head of a linked list, rotate the list to the right by k places.
Example 1:
Input: head = [1,2,3,4,5], k = 2
Output: [4,5,1,2,3]
Example 2:
Input: head... |
62 | 1 | class Solution:
def uniquePaths(self, m: int, n: int) -> int:
"""
There is a robot on an m x n grid. The robot is initially located at the top-left corner (i.e., grid[0][0]). The robot tries to move to the bottom-right corner (i.e., grid[m - 1][n - 1]). The robot can only move either down or right a... |
63 | 1 | class Solution:
def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
"""
You are given an m x n integer array grid. There is a robot initially located at the top-left corner (i.e., grid[0][0]). The robot tries to move to the bottom-right corner (i.e., grid[m - 1][n - 1]). The ro... |
64 | 1 | class Solution:
def minPathSum(self, grid: List[List[int]]) -> int:
"""
Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right, which minimizes the sum of all numbers along its path.
Note: You can only move either down or right at any point in time.
... |
65 | 2 | class Solution:
def isNumber(self, s: str) -> bool:
"""
A valid number can be split up into these components (in order):
A decimal number or an integer.
(Optional) An 'e' or 'E', followed by an integer.
A decimal number can be split up into these components (in order)... |
66 | 0 | class Solution:
def plusOne(self, digits: List[int]) -> List[int]:
"""
You are given a large integer represented as an integer array digits, where each digits[i] is the ith digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integ... |
67 | 0 | class Solution:
def addBinary(self, a: str, b: str) -> str:
"""
Given two binary strings a and b, return their sum as a binary string.
Example 1:
Input: a = "11", b = "1"
Output: "100"
Example 2:
Input: a = "1010", b = "1011"
Output: "10101"
""... |
68 | 2 | class Solution:
def fullJustify(self, words: List[str], maxWidth: int) -> List[str]:
"""
Given an array of strings words and a width maxWidth, format the text such that each line has exactly maxWidth characters and is fully (left and right) justified.
You should pack your words in a greedy a... |
69 | 0 | class Solution:
def mySqrt(self, x: int) -> int:
"""
Given a non-negative integer x, return the square root of x rounded down to the nearest integer. The returned integer should be non-negative as well.
You must not use any built-in exponent function or operator.
For example, do ... |
70 | 0 | class Solution:
def climbStairs(self, n: int) -> int:
"""
You are climbing a staircase. It takes n steps to reach the top.
Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
Example 1:
Input: n = 2
Output: 2
Explan... |
71 | 1 | class Solution:
def simplifyPath(self, path: str) -> str:
"""
Given a string path, which is an absolute path (starting with a slash '/') to a file or directory in a Unix-style file system, convert it to the simplified canonical path.
In a Unix-style file system, a period '.' refers to the cu... |
72 | 2 | class Solution:
def minDistance(self, word1: str, word2: str) -> int:
"""
Given two strings word1 and word2, return the minimum number of operations required to convert word1 to word2.
You have the following three operations permitted on a word:
Insert a character
Del... |
73 | 1 | class Solution:
def setZeroes(self, matrix: List[List[int]]) -> None:
"""
Do not return anything, modify matrix in-place instead.
Given an m x n integer matrix matrix, if an element is 0, set its entire row and column to 0's.
You must do it in place.
Example 1:
Input:... |
74 | 1 | class Solution:
def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
"""
You are given an m x n integer matrix matrix with the following two properties:
Each row is sorted in non-decreasing order.
The first integer of each row is greater than the last integer... |
75 | 1 | class Solution:
def sortColors(self, nums: List[int]) -> None:
"""
Do not return anything, modify nums in-place instead.
Given an array nums with n objects colored red, white, or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white,... |
76 | 2 | class Solution:
def minWindow(self, s: str, t: str) -> str:
"""
Given two strings s and t of lengths m and n respectively, return the minimum window substring of s such that every character in t (including duplicates) is included in the window. If there is no such substring, return the empty string ... |
77 | 1 | class Solution:
def combine(self, n: int, k: int) -> List[List[int]]:
"""
Given two integers n and k, return all possible combinations of k numbers chosen from the range [1, n].
You may return the answer in any order.
Example 1:
Input: n = 4, k = 2
Output: [[1,2],[1,3... |
78 | 1 | class Solution:
def subsets(self, nums: List[int]) -> List[List[int]]:
"""
Given an integer array nums of unique elements, return all possible subsets (the power set).
The solution set must not contain duplicate subsets. Return the solution in any order.
Example 1:
Input: num... |
79 | 1 | class Solution:
def exist(self, board: List[List[str]], word: str) -> bool:
"""
Given an m x n grid of characters board and a string word, return true if word exists in the grid.
The word can be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or... |
80 | 1 | class Solution:
def removeDuplicates(self, nums: List[int]) -> int:
"""
Given an integer array nums sorted in non-decreasing order, remove some duplicates in-place such that each unique element appears at most twice. The relative order of the elements should be kept the same.
Since it is imp... |
81 | 1 | class Solution:
def search(self, nums: List[int], target: int) -> bool:
"""
There is an integer array nums sorted in non-decreasing order (not necessarily with distinct values).
Before being passed to your function, nums is rotated at an unknown pivot index k (0 <= k < nums.length) such that... |
82 | 1 | class Solution:
def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
"""
Given the head of a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list. Return the linked list sorted as well.
Example 1:
... |
83 | 0 | class Solution:
def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
"""
Given the head of a sorted linked list, delete all duplicates such that each element appears only once. Return the linked list sorted as well.
Example 1:
Input: head = [1,1,2]
Outp... |
84 | 2 | class Solution:
def largestRectangleArea(self, heights: List[int]) -> int:
"""
Given an array of integers heights representing the histogram's bar height where the width of each bar is 1, return the area of the largest rectangle in the histogram.
Example 1:
Input: heights = [2,1,5,6,... |
85 | 2 | class Solution:
def maximalRectangle(self, matrix: List[List[str]]) -> int:
"""
Given a rows x cols binary matrix filled with 0's and 1's, find the largest rectangle containing only 1's and return its area.
Example 1:
Input: matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1",... |
86 | 1 | class Solution:
def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:
"""
Given the head of a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.
You should preserve the original relative order of the no... |
87 | 2 | class Solution:
def isScramble(self, s1: str, s2: str) -> bool:
"""
We can scramble a string s to get a string t using the following algorithm:
If the length of the string is 1, stop.
If the length of the string is > 1, do the following:
Split the string into ... |
88 | 0 | class Solution:
def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
"""
Do not return anything, modify nums1 in-place instead.
You are given two integer arrays nums1 and nums2, sorted in non-decreasing order, and two integers m and n, representing the number of eleme... |
89 | 1 | class Solution:
def grayCode(self, n: int) -> List[int]:
"""
An n-bit gray code sequence is a sequence of 2n integers where:
Every integer is in the inclusive range [0, 2n - 1],
The first integer is 0,
An integer appears no more than once in the sequence,
... |
90 | 1 | class Solution:
def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
"""
Given an integer array nums that may contain duplicates, return all possible subsets (the power set).
The solution set must not contain duplicate subsets. Return the solution in any order.
Example 1:
... |
91 | 1 | class Solution:
def numDecodings(self, s: str) -> int:
"""
A message containing letters from A-Z can be encoded into numbers using the following mapping:
'A' -> "1"
'B' -> "2"
...
'Z' -> "26"
To decode an encoded message, all the digits must be grouped then ma... |
92 | 1 | class Solution:
def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
"""
Given the head of a singly linked list and two integers left and right where left <= right, reverse the nodes of the list from position left to position right, and return the reversed... |
93 | 1 | class Solution:
def restoreIpAddresses(self, s: str) -> List[str]:
"""
A valid IP address consists of exactly four integers separated by single dots. Each integer is between 0 and 255 (inclusive) and cannot have leading zeros.
For example, "0.1.2.201" and "192.168.1.1" are valid IP addre... |
94 | 0 | class Solution:
def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
"""
Given the root of a binary tree, return the inorder traversal of its nodes' values.
Example 1:
Input: root = [1,null,2,3]
Output: [1,3,2]
Example 2:
Input: root = []
... |
95 | 1 | class Solution:
def generateTrees(self, n: int) -> List[Optional[TreeNode]]:
"""
Given an integer n, return all the structurally unique BST's (binary search trees), which has exactly n nodes of unique values from 1 to n. Return the answer in any order.
Example 1:
Input: n = 3
... |
96 | 1 | class Solution:
def numTrees(self, n: int) -> int:
"""
Given an integer n, return the number of structurally unique BST's (binary search trees) which has exactly n nodes of unique values from 1 to n.
Example 1:
Input: n = 3
Output: 5
Example 2:
Input: n = 1
... |
97 | 1 | class Solution:
def isInterleave(self, s1: str, s2: str, s3: str) -> bool:
"""
Given strings s1, s2, and s3, find whether s3 is formed by an interleaving of s1 and s2.
An interleaving of two strings s and t is a configuration where s and t are divided into n and m substrings respectively, su... |
98 | 1 | class Solution:
def isValidBST(self, root: Optional[TreeNode]) -> bool:
"""
Given the root of a binary tree, determine if it is a valid binary search tree (BST).
A valid BST is defined as follows:
The left subtree of a node contains only nodes with keys less than the node's key.
... |
99 | 1 | class Solution:
def recoverTree(self, root: Optional[TreeNode]) -> None:
"""
Do not return anything, modify root in-place instead.
You are given the root of a binary search tree (BST), where the values of exactly two nodes of the tree were swapped by mistake. Recover the tree without changin... |
100 | 0 | class Solution:
def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
"""
Given the roots of two binary trees p and q, write a function to check if they are the same or not.
Two binary trees are considered the same if they are structurally identical, and the nodes have ... |
End of preview. Expand in Data Studio
No dataset card yet
- Downloads last month
- 13