title stringlengths 1 100 | titleSlug stringlengths 3 77 | Java int64 0 1 | Python3 int64 1 1 | content stringlengths 28 44.4k | voteCount int64 0 3.67k | question_content stringlengths 65 5k | question_hints stringclasses 970
values |
|---|---|---|---|---|---|---|---|
Heap using max difference | maximum-average-pass-ratio | 0 | 1 | use a heap sorted by: currentPassRate - nextPassRate\nthe first element will be the best one since it will have greatest impact\nthe second element is the index which we use to update where we put student\n# Code\n```\ndef maxAverageRatio(self, classes: List[List[int]], extraStudents: int) -> float:\n classPass = [(... | 0 | There is a school that has classes of students and each class will be having a final exam. You are given a 2D integer array `classes`, where `classes[i] = [passi, totali]`. You know beforehand that in the `ith` class, there are `totali` total students, but only `passi` number of students will pass the exam.
You are al... | In lexicographical order, the elements to the left have higher priority than those that come after. Can you think of a strategy that incrementally builds the answer from left to right? |
Heap || Python3 | maximum-average-pass-ratio | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n- Check what is the fraction that is adding up most at every stage and add each extra student in that class\n\n# Approach\n- With heap\n\n# Complexity\n- Time complexity:\n- O(NlogN)\n\n- Space complexity:\n- O(N)\n\n# Code\n```\nclass So... | 0 | There is a school that has classes of students and each class will be having a final exam. You are given a 2D integer array `classes`, where `classes[i] = [passi, totali]`. You know beforehand that in the `ith` class, there are `totali` total students, but only `passi` number of students will pass the exam.
You are al... | In lexicographical order, the elements to the left have higher priority than those that come after. Can you think of a strategy that incrementally builds the answer from left to right? |
python | maximum-average-pass-ratio | 0 | 1 | Things become a lot easier after looking at hints\n# Code\n```\nclass Solution:\n def maxAverageRatio(self, classes: List[List[int]], s: int) -> float:\n n = len(classes)\n h = []\n heapq.heapify(h)\n\n for i in range(n):\n change = ((classes[i][0]+1)/(classes[i][1]+1)) - (clas... | 0 | There is a school that has classes of students and each class will be having a final exam. You are given a 2D integer array `classes`, where `classes[i] = [passi, totali]`. You know beforehand that in the `ith` class, there are `totali` total students, but only `passi` number of students will pass the exam.
You are al... | In lexicographical order, the elements to the left have higher priority than those that come after. Can you think of a strategy that incrementally builds the answer from left to right? |
🚀 Monotonic Stack || Explained Intuition 🚀 | maximum-score-of-a-good-subarray | 1 | 1 | # Problem Description\n\nGiven an array of integers `nums` and an integer `k`, find the **maximum** score of a **good** subarray. \nA **good** subarray is one that contains the element at index `k` and is defined by the **product** of the **minimum** value within the subarray and its **length**. Where `min(nums[i], num... | 29 | You are given an array of integers `nums` **(0-indexed)** and an integer `k`.
The **score** of a subarray `(i, j)` is defined as `min(nums[i], nums[i+1], ..., nums[j]) * (j - i + 1)`. A **good** subarray is a subarray where `i <= k <= j`.
Return _the maximum possible **score** of a **good** subarray._
**Example 1:**... | Given a target sum x, each pair of nums[i] and nums[n-1-i] would either need 0, 1, or 2 modifications. Can you find the optimal target sum x value such that the sum of modifications is minimized? Create a difference array to efficiently sum all the modifications. |
🚀 Monotonic Stack || Explained Intuition 🚀 | maximum-score-of-a-good-subarray | 1 | 1 | # Problem Description\n\nGiven an array of integers `nums` and an integer `k`, find the **maximum** score of a **good** subarray. \nA **good** subarray is one that contains the element at index `k` and is defined by the **product** of the **minimum** value within the subarray and its **length**. Where `min(nums[i], num... | 29 | Given an integer array `nums` of length `n` and an integer `k`, return _the_ `kth` _**smallest subarray sum**._
A **subarray** is defined as a **non-empty** contiguous sequence of elements in an array. A **subarray sum** is the sum of all elements in the subarray.
**Example 1:**
**Input:** nums = \[2,1,3\], k = 4
**... | Try thinking about the prefix before index k and the suffix after index k as two separate arrays. Using two pointers or binary search, we can find the maximum prefix of each array where the numbers are less than or equal to a certain value |
【Video】Give me 10 minutes - How we think about a solution - Python, JavaScript, Java, C++ | maximum-score-of-a-good-subarray | 1 | 1 | # Intuition\nThe description accidentally say an answer. lol\n\n---\n\n# Solution Video\n\nhttps://youtu.be/ZiO47ctvu6w\n\n\u25A0 Timeline of the video\n`0:05` Easy way to solve a constraint\n`2:04` How we can move i and j pointers\n`3:59` candidates for minimum number and max score\n`4:29` Demonstrate how it works\n`8... | 23 | You are given an array of integers `nums` **(0-indexed)** and an integer `k`.
The **score** of a subarray `(i, j)` is defined as `min(nums[i], nums[i+1], ..., nums[j]) * (j - i + 1)`. A **good** subarray is a subarray where `i <= k <= j`.
Return _the maximum possible **score** of a **good** subarray._
**Example 1:**... | Given a target sum x, each pair of nums[i] and nums[n-1-i] would either need 0, 1, or 2 modifications. Can you find the optimal target sum x value such that the sum of modifications is minimized? Create a difference array to efficiently sum all the modifications. |
【Video】Give me 10 minutes - How we think about a solution - Python, JavaScript, Java, C++ | maximum-score-of-a-good-subarray | 1 | 1 | # Intuition\nThe description accidentally say an answer. lol\n\n---\n\n# Solution Video\n\nhttps://youtu.be/ZiO47ctvu6w\n\n\u25A0 Timeline of the video\n`0:05` Easy way to solve a constraint\n`2:04` How we can move i and j pointers\n`3:59` candidates for minimum number and max score\n`4:29` Demonstrate how it works\n`8... | 23 | Given an integer array `nums` of length `n` and an integer `k`, return _the_ `kth` _**smallest subarray sum**._
A **subarray** is defined as a **non-empty** contiguous sequence of elements in an array. A **subarray sum** is the sum of all elements in the subarray.
**Example 1:**
**Input:** nums = \[2,1,3\], k = 4
**... | Try thinking about the prefix before index k and the suffix after index k as two separate arrays. Using two pointers or binary search, we can find the maximum prefix of each array where the numbers are less than or equal to a certain value |
✅☑[C++/Java/Python/JavaScript] || 3 Approaches || EXPLAINED🔥 | maximum-score-of-a-good-subarray | 1 | 1 | # PLEASE UPVOTE IF IT HELPED\n\n---\n\n\n# Approaches\n**(Also explained in the code)**\n\n#### ***Approach 1 (Binary Search)***\n1. The `maximumScore` function is the main function that calculates the maximum score. It takes a vector of integers `nums` and an integer `k` as input.\n\n1. Inside the `maximumScore` funct... | 3 | You are given an array of integers `nums` **(0-indexed)** and an integer `k`.
The **score** of a subarray `(i, j)` is defined as `min(nums[i], nums[i+1], ..., nums[j]) * (j - i + 1)`. A **good** subarray is a subarray where `i <= k <= j`.
Return _the maximum possible **score** of a **good** subarray._
**Example 1:**... | Given a target sum x, each pair of nums[i] and nums[n-1-i] would either need 0, 1, or 2 modifications. Can you find the optimal target sum x value such that the sum of modifications is minimized? Create a difference array to efficiently sum all the modifications. |
✅☑[C++/Java/Python/JavaScript] || 3 Approaches || EXPLAINED🔥 | maximum-score-of-a-good-subarray | 1 | 1 | # PLEASE UPVOTE IF IT HELPED\n\n---\n\n\n# Approaches\n**(Also explained in the code)**\n\n#### ***Approach 1 (Binary Search)***\n1. The `maximumScore` function is the main function that calculates the maximum score. It takes a vector of integers `nums` and an integer `k` as input.\n\n1. Inside the `maximumScore` funct... | 3 | Given an integer array `nums` of length `n` and an integer `k`, return _the_ `kth` _**smallest subarray sum**._
A **subarray** is defined as a **non-empty** contiguous sequence of elements in an array. A **subarray sum** is the sum of all elements in the subarray.
**Example 1:**
**Input:** nums = \[2,1,3\], k = 4
**... | Try thinking about the prefix before index k and the suffix after index k as two separate arrays. Using two pointers or binary search, we can find the maximum prefix of each array where the numbers are less than or equal to a certain value |
Python3 Solution | maximum-score-of-a-good-subarray | 0 | 1 | \n```\nclass Solution:\n def maximumScore(self, nums: List[int], k: int) -> int:\n ans=nums[k]\n MIN=nums[k]\n low=k\n high=k\n n=len(nums)\n while 0<=low-1 or high+1<n:\n\n if low==0 or high+1<n and nums[low-1]<nums[high+1]:\n high+=1\n ... | 3 | You are given an array of integers `nums` **(0-indexed)** and an integer `k`.
The **score** of a subarray `(i, j)` is defined as `min(nums[i], nums[i+1], ..., nums[j]) * (j - i + 1)`. A **good** subarray is a subarray where `i <= k <= j`.
Return _the maximum possible **score** of a **good** subarray._
**Example 1:**... | Given a target sum x, each pair of nums[i] and nums[n-1-i] would either need 0, 1, or 2 modifications. Can you find the optimal target sum x value such that the sum of modifications is minimized? Create a difference array to efficiently sum all the modifications. |
Python3 Solution | maximum-score-of-a-good-subarray | 0 | 1 | \n```\nclass Solution:\n def maximumScore(self, nums: List[int], k: int) -> int:\n ans=nums[k]\n MIN=nums[k]\n low=k\n high=k\n n=len(nums)\n while 0<=low-1 or high+1<n:\n\n if low==0 or high+1<n and nums[low-1]<nums[high+1]:\n high+=1\n ... | 3 | Given an integer array `nums` of length `n` and an integer `k`, return _the_ `kth` _**smallest subarray sum**._
A **subarray** is defined as a **non-empty** contiguous sequence of elements in an array. A **subarray sum** is the sum of all elements in the subarray.
**Example 1:**
**Input:** nums = \[2,1,3\], k = 4
**... | Try thinking about the prefix before index k and the suffix after index k as two separate arrays. Using two pointers or binary search, we can find the maximum prefix of each array where the numbers are less than or equal to a certain value |
✅ 92.13% Two Pointers | maximum-score-of-a-good-subarray | 1 | 1 | # Intuition\nThe core of the problem revolves around identifying a subarray where the outcome of multiplying its length by its minimum element is the largest. A vital insight here is recognizing that the subarray yielding the utmost score will invariably encompass the element at index `k`. This observation drives the s... | 76 | You are given an array of integers `nums` **(0-indexed)** and an integer `k`.
The **score** of a subarray `(i, j)` is defined as `min(nums[i], nums[i+1], ..., nums[j]) * (j - i + 1)`. A **good** subarray is a subarray where `i <= k <= j`.
Return _the maximum possible **score** of a **good** subarray._
**Example 1:**... | Given a target sum x, each pair of nums[i] and nums[n-1-i] would either need 0, 1, or 2 modifications. Can you find the optimal target sum x value such that the sum of modifications is minimized? Create a difference array to efficiently sum all the modifications. |
✅ 92.13% Two Pointers | maximum-score-of-a-good-subarray | 1 | 1 | # Intuition\nThe core of the problem revolves around identifying a subarray where the outcome of multiplying its length by its minimum element is the largest. A vital insight here is recognizing that the subarray yielding the utmost score will invariably encompass the element at index `k`. This observation drives the s... | 76 | Given an integer array `nums` of length `n` and an integer `k`, return _the_ `kth` _**smallest subarray sum**._
A **subarray** is defined as a **non-empty** contiguous sequence of elements in an array. A **subarray sum** is the sum of all elements in the subarray.
**Example 1:**
**Input:** nums = \[2,1,3\], k = 4
**... | Try thinking about the prefix before index k and the suffix after index k as two separate arrays. Using two pointers or binary search, we can find the maximum prefix of each array where the numbers are less than or equal to a certain value |
[python3] Traverse from either sides to find min | maximum-score-of-a-good-subarray | 0 | 1 | There is more scope for optimization but here is a solution that keeps track of minimum from left and right side and then calculate maximum by using formula in the problem. ( right - left +1 ) * nums[i]\n\n```\nclass Solution:\n def maximumScore(self, nums: List[int], k: int) -> int:\n N = len(nums)\n ... | 1 | You are given an array of integers `nums` **(0-indexed)** and an integer `k`.
The **score** of a subarray `(i, j)` is defined as `min(nums[i], nums[i+1], ..., nums[j]) * (j - i + 1)`. A **good** subarray is a subarray where `i <= k <= j`.
Return _the maximum possible **score** of a **good** subarray._
**Example 1:**... | Given a target sum x, each pair of nums[i] and nums[n-1-i] would either need 0, 1, or 2 modifications. Can you find the optimal target sum x value such that the sum of modifications is minimized? Create a difference array to efficiently sum all the modifications. |
[python3] Traverse from either sides to find min | maximum-score-of-a-good-subarray | 0 | 1 | There is more scope for optimization but here is a solution that keeps track of minimum from left and right side and then calculate maximum by using formula in the problem. ( right - left +1 ) * nums[i]\n\n```\nclass Solution:\n def maximumScore(self, nums: List[int], k: int) -> int:\n N = len(nums)\n ... | 1 | Given an integer array `nums` of length `n` and an integer `k`, return _the_ `kth` _**smallest subarray sum**._
A **subarray** is defined as a **non-empty** contiguous sequence of elements in an array. A **subarray sum** is the sum of all elements in the subarray.
**Example 1:**
**Input:** nums = \[2,1,3\], k = 4
**... | Try thinking about the prefix before index k and the suffix after index k as two separate arrays. Using two pointers or binary search, we can find the maximum prefix of each array where the numbers are less than or equal to a certain value |
✅ Beats 100% 🔥 in 4 Languages || Beginner Friendly Eplanation || | maximum-score-of-a-good-subarray | 1 | 1 | ## TypeScript :\n\n\n## PHP :\n** and an integer `k`.
The **score** of a subarray `(i, j)` is defined as `min(nums[i], nums[i+1], ..., nums[j]) * (j - i + 1)`. A **good** subarray is a subarray where `i <= k <= j`.
Return _the maximum possible **score** of a **good** subarray._
**Example 1:**... | Given a target sum x, each pair of nums[i] and nums[n-1-i] would either need 0, 1, or 2 modifications. Can you find the optimal target sum x value such that the sum of modifications is minimized? Create a difference array to efficiently sum all the modifications. |
✅ Beats 100% 🔥 in 4 Languages || Beginner Friendly Eplanation || | maximum-score-of-a-good-subarray | 1 | 1 | ## TypeScript :\n\n\n## PHP :\n | maximum-score-of-a-good-subarray | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nThe problem becomes much easier with this "k condition": the subarray must contains nums[k]. We don\'t need to consider every subarray but only those that grows from index k.\n\n# Approach\n<!-- Describe your approach to solving the probl... | 0 | You are given an array of integers `nums` **(0-indexed)** and an integer `k`.
The **score** of a subarray `(i, j)` is defined as `min(nums[i], nums[i+1], ..., nums[j]) * (j - i + 1)`. A **good** subarray is a subarray where `i <= k <= j`.
Return _the maximum possible **score** of a **good** subarray._
**Example 1:**... | Given a target sum x, each pair of nums[i] and nums[n-1-i] would either need 0, 1, or 2 modifications. Can you find the optimal target sum x value such that the sum of modifications is minimized? Create a difference array to efficiently sum all the modifications. |
[python3] Intuitive two-pointer method (time beats 98.47%) | maximum-score-of-a-good-subarray | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nThe problem becomes much easier with this "k condition": the subarray must contains nums[k]. We don\'t need to consider every subarray but only those that grows from index k.\n\n# Approach\n<!-- Describe your approach to solving the probl... | 0 | Given an integer array `nums` of length `n` and an integer `k`, return _the_ `kth` _**smallest subarray sum**._
A **subarray** is defined as a **non-empty** contiguous sequence of elements in an array. A **subarray sum** is the sum of all elements in the subarray.
**Example 1:**
**Input:** nums = \[2,1,3\], k = 4
**... | Try thinking about the prefix before index k and the suffix after index k as two separate arrays. Using two pointers or binary search, we can find the maximum prefix of each array where the numbers are less than or equal to a certain value |
Pandas vs SQL | Elegant & Short | All 30 Days of Pandas solutions ✅ | rearrange-products-table | 0 | 1 | # Complexity\n- Time complexity: $$O(n)$$\n- Space complexity: $$O(n)$$\n\n# Code\n```Python []\ndef rearrange_products_table(products: pd.DataFrame) -> pd.DataFrame:\n return pd.melt(\n products, id_vars=\'product_id\', var_name=\'store\', value_name=\'price\'\n ).dropna()\n```\n```SQL []\nSELECT product_... | 61 | Due to a bug, there are many duplicate folders in a file system. You are given a 2D array `paths`, where `paths[i]` is an array representing an absolute path to the `ith` folder in the file system.
* For example, `[ "one ", "two ", "three "]` represents the path `"/one/two/three "`.
Two folders (not necessarily on ... | null |
the solution of the problem using a command that in pandas library | rearrange-products-table | 0 | 1 | \n# Code\n```\nimport pandas as pd\n\ndef rearrange_products_table(products: pd.DataFrame) -> pd.DataFrame:\n # 1. Saves output in new DataFrame\n df = (\n # 2. .melt() lets you unpivot the table\n products.melt(\n # 3. Columns you want to leave unchanged\n id_vars = [\'product... | 1 | Due to a bug, there are many duplicate folders in a file system. You are given a 2D array `paths`, where `paths[i]` is an array representing an absolute path to the `ith` folder in the file system.
* For example, `[ "one ", "two ", "three "]` represents the path `"/one/two/three "`.
Two folders (not necessarily on ... | null |
Simplest Python solution | second-largest-digit-in-a-string | 0 | 1 | \n\n# Code\n```\nfrom sortedcontainers import SortedSet\nclass Solution:\n def secondHighest(self, s: str) -> int:\n a = [int(x) for x in s if x.isnumeric()]\n return SortedSet(a)[-2] if len(set(a)) >= 2 else -1\n``` | 3 | Given an alphanumeric string `s`, return _the **second largest** numerical digit that appears in_ `s`_, or_ `-1` _if it does not exist_.
An **alphanumeric** string is a string consisting of lowercase English letters and digits.
**Example 1:**
**Input:** s = "dfa12321afd "
**Output:** 2
**Explanation:** The digits t... | If you traverse the tree from right to left, the invalid node will point to a node that has already been visited. |
Simplest Python solution | second-largest-digit-in-a-string | 0 | 1 | \n\n# Code\n```\nfrom sortedcontainers import SortedSet\nclass Solution:\n def secondHighest(self, s: str) -> int:\n a = [int(x) for x in s if x.isnumeric()]\n return SortedSet(a)[-2] if len(set(a)) >= 2 else -1\n``` | 3 | You are participating in an online chess tournament. There is a chess round that starts every `15` minutes. The first round of the day starts at `00:00`, and after every `15` minutes, a new round starts.
* For example, the second round starts at `00:15`, the fourth round starts at `00:45`, and the seventh round star... | First of all, get the distinct characters since we are only interested in those Let's note that there might not be any digits. |
Python | 99% Faster | Easy Solution✅ | second-largest-digit-in-a-string | 0 | 1 | ```\ndef secondHighest(self, s: str) -> int:\n digits = set()\n s = list(set(s))\n for letter in s:\n if letter.isdigit():\n digits.add(letter)\n digits = sorted(list(digits))\n return -1 if len(digits) < 2 else digits[-2]\n```\n![image](https://assets.leetco... | 5 | Given an alphanumeric string `s`, return _the **second largest** numerical digit that appears in_ `s`_, or_ `-1` _if it does not exist_.
An **alphanumeric** string is a string consisting of lowercase English letters and digits.
**Example 1:**
**Input:** s = "dfa12321afd "
**Output:** 2
**Explanation:** The digits t... | If you traverse the tree from right to left, the invalid node will point to a node that has already been visited. |
Python | 99% Faster | Easy Solution✅ | second-largest-digit-in-a-string | 0 | 1 | ```\ndef secondHighest(self, s: str) -> int:\n digits = set()\n s = list(set(s))\n for letter in s:\n if letter.isdigit():\n digits.add(letter)\n digits = sorted(list(digits))\n return -1 if len(digits) < 2 else digits[-2]\n```\n -> int:\n s=set(s)\n a=[]\n for i in s:\n if i.isnumeric() :\n a.append(int(i))\n a.sort()\n if len(a)<2:\n return -1\n return a[len(a)-2]\n```\n**optimized code**\n```\ndef secondHig... | 5 | Given an alphanumeric string `s`, return _the **second largest** numerical digit that appears in_ `s`_, or_ `-1` _if it does not exist_.
An **alphanumeric** string is a string consisting of lowercase English letters and digits.
**Example 1:**
**Input:** s = "dfa12321afd "
**Output:** 2
**Explanation:** The digits t... | If you traverse the tree from right to left, the invalid node will point to a node that has already been visited. |
✔ Python3 | Faster Solution | Easiest | brute force | second-largest-digit-in-a-string | 0 | 1 | ```\nclass Solution:\n def secondHighest(self, s: str) -> int:\n s=set(s)\n a=[]\n for i in s:\n if i.isnumeric() :\n a.append(int(i))\n a.sort()\n if len(a)<2:\n return -1\n return a[len(a)-2]\n```\n**optimized code**\n```\ndef secondHig... | 5 | You are participating in an online chess tournament. There is a chess round that starts every `15` minutes. The first round of the day starts at `00:00`, and after every `15` minutes, a new round starts.
* For example, the second round starts at `00:15`, the fourth round starts at `00:45`, and the seventh round star... | First of all, get the distinct characters since we are only interested in those Let's note that there might not be any digits. |
Clean python with comments | second-largest-digit-in-a-string | 0 | 1 | ```\ndef secondHighest(self, s):\n t = set() # create set to store unique digits\n for i in s:\n if \'0\'<=i<=\'9\':\n t.add(int(i)) # add digit to the set\n if len(t)>1:\n return sorted(list(t))[-2] # sort and return second largest one if number of elements ... | 16 | Given an alphanumeric string `s`, return _the **second largest** numerical digit that appears in_ `s`_, or_ `-1` _if it does not exist_.
An **alphanumeric** string is a string consisting of lowercase English letters and digits.
**Example 1:**
**Input:** s = "dfa12321afd "
**Output:** 2
**Explanation:** The digits t... | If you traverse the tree from right to left, the invalid node will point to a node that has already been visited. |
Clean python with comments | second-largest-digit-in-a-string | 0 | 1 | ```\ndef secondHighest(self, s):\n t = set() # create set to store unique digits\n for i in s:\n if \'0\'<=i<=\'9\':\n t.add(int(i)) # add digit to the set\n if len(t)>1:\n return sorted(list(t))[-2] # sort and return second largest one if number of elements ... | 16 | You are participating in an online chess tournament. There is a chess round that starts every `15` minutes. The first round of the day starts at `00:00`, and after every `15` minutes, a new round starts.
* For example, the second round starts at `00:15`, the fourth round starts at `00:45`, and the seventh round star... | First of all, get the distinct characters since we are only interested in those Let's note that there might not be any digits. |
PYTHON || EASY TO UNDERSTAND | second-largest-digit-in-a-string | 0 | 1 | \n# Approach\nIndexing and Brute Force\n\n# Complexity\n- Time complexity:\nO(NlogN)\n\n- Space complexity:\nO(N)\n\n# Code\n```\nclass Solution:\n def secondHighest(self, s: str) -> int:\n lst = []\n for i in range(len(s)):\n if s[i].isdigit():\n lst.append(s[i])\n lst... | 1 | Given an alphanumeric string `s`, return _the **second largest** numerical digit that appears in_ `s`_, or_ `-1` _if it does not exist_.
An **alphanumeric** string is a string consisting of lowercase English letters and digits.
**Example 1:**
**Input:** s = "dfa12321afd "
**Output:** 2
**Explanation:** The digits t... | If you traverse the tree from right to left, the invalid node will point to a node that has already been visited. |
PYTHON || EASY TO UNDERSTAND | second-largest-digit-in-a-string | 0 | 1 | \n# Approach\nIndexing and Brute Force\n\n# Complexity\n- Time complexity:\nO(NlogN)\n\n- Space complexity:\nO(N)\n\n# Code\n```\nclass Solution:\n def secondHighest(self, s: str) -> int:\n lst = []\n for i in range(len(s)):\n if s[i].isdigit():\n lst.append(s[i])\n lst... | 1 | You are participating in an online chess tournament. There is a chess round that starts every `15` minutes. The first round of the day starts at `00:00`, and after every `15` minutes, a new round starts.
* For example, the second round starts at `00:15`, the fourth round starts at `00:45`, and the seventh round star... | First of all, get the distinct characters since we are only interested in those Let's note that there might not be any digits. |
Python 3 (30ms) | Fastest Set Solution | Easy to Understand | second-largest-digit-in-a-string | 0 | 1 | ```\nclass Solution:\n def secondHighest(self, s: str) -> int:\n st = (set(s))\n f1,s2=-1,-1\n for i in st:\n if i.isnumeric():\n i=int(i)\n if i>f1:\n s2=f1\n f1=i\n elif i>s2 and i!=f1:\n ... | 3 | Given an alphanumeric string `s`, return _the **second largest** numerical digit that appears in_ `s`_, or_ `-1` _if it does not exist_.
An **alphanumeric** string is a string consisting of lowercase English letters and digits.
**Example 1:**
**Input:** s = "dfa12321afd "
**Output:** 2
**Explanation:** The digits t... | If you traverse the tree from right to left, the invalid node will point to a node that has already been visited. |
Python 3 (30ms) | Fastest Set Solution | Easy to Understand | second-largest-digit-in-a-string | 0 | 1 | ```\nclass Solution:\n def secondHighest(self, s: str) -> int:\n st = (set(s))\n f1,s2=-1,-1\n for i in st:\n if i.isnumeric():\n i=int(i)\n if i>f1:\n s2=f1\n f1=i\n elif i>s2 and i!=f1:\n ... | 3 | You are participating in an online chess tournament. There is a chess round that starts every `15` minutes. The first round of the day starts at `00:00`, and after every `15` minutes, a new round starts.
* For example, the second round starts at `00:15`, the fourth round starts at `00:45`, and the seventh round star... | First of all, get the distinct characters since we are only interested in those Let's note that there might not be any digits. |
✔ Python3 | Without array or sorting | Faster Solution | Easiest | second-largest-digit-in-a-string | 0 | 1 | ```\nclass Solution:\n def secondHighest(self, s: str) -> int:\n st = (set(s))\n f1,s2=-1,-1\n for i in st:\n if i.isnumeric():\n i=int(i)\n if i>f1:\n s2=f1\n f1=i\n elif i>s2 and i!=f1:\n ... | 2 | Given an alphanumeric string `s`, return _the **second largest** numerical digit that appears in_ `s`_, or_ `-1` _if it does not exist_.
An **alphanumeric** string is a string consisting of lowercase English letters and digits.
**Example 1:**
**Input:** s = "dfa12321afd "
**Output:** 2
**Explanation:** The digits t... | If you traverse the tree from right to left, the invalid node will point to a node that has already been visited. |
✔ Python3 | Without array or sorting | Faster Solution | Easiest | second-largest-digit-in-a-string | 0 | 1 | ```\nclass Solution:\n def secondHighest(self, s: str) -> int:\n st = (set(s))\n f1,s2=-1,-1\n for i in st:\n if i.isnumeric():\n i=int(i)\n if i>f1:\n s2=f1\n f1=i\n elif i>s2 and i!=f1:\n ... | 2 | You are participating in an online chess tournament. There is a chess round that starts every `15` minutes. The first round of the day starts at `00:00`, and after every `15` minutes, a new round starts.
* For example, the second round starts at `00:15`, the fourth round starts at `00:45`, and the seventh round star... | First of all, get the distinct characters since we are only interested in those Let's note that there might not be any digits. |
Python3 simple solution using list | second-largest-digit-in-a-string | 0 | 1 | ```\nclass Solution:\n def secondHighest(self, s: str) -> int:\n l = []\n for i in s:\n if i.isdigit() and i not in l:\n l.append(i)\n if len(l) >= 2:\n return int(sorted(l)[-2])\n else:\n return -1\n```\n**If you like this solution, please ... | 4 | Given an alphanumeric string `s`, return _the **second largest** numerical digit that appears in_ `s`_, or_ `-1` _if it does not exist_.
An **alphanumeric** string is a string consisting of lowercase English letters and digits.
**Example 1:**
**Input:** s = "dfa12321afd "
**Output:** 2
**Explanation:** The digits t... | If you traverse the tree from right to left, the invalid node will point to a node that has already been visited. |
Python3 simple solution using list | second-largest-digit-in-a-string | 0 | 1 | ```\nclass Solution:\n def secondHighest(self, s: str) -> int:\n l = []\n for i in s:\n if i.isdigit() and i not in l:\n l.append(i)\n if len(l) >= 2:\n return int(sorted(l)[-2])\n else:\n return -1\n```\n**If you like this solution, please ... | 4 | You are participating in an online chess tournament. There is a chess round that starts every `15` minutes. The first round of the day starts at `00:00`, and after every `15` minutes, a new round starts.
* For example, the second round starts at `00:15`, the fourth round starts at `00:45`, and the seventh round star... | First of all, get the distinct characters since we are only interested in those Let's note that there might not be any digits. |
Python easy solution without sort and hash | 38ms | second-largest-digit-in-a-string | 0 | 1 | # Intuition\nWhat we need is 2nd largest number, so we just keep track of first and second largest number\n\n# Approach\n1. Initiate first and second to -1, -1\n2. Loop over a string\n3. If item is a number and it\'s greater than `first` then assign that number as `first` and original `first` number to `second`\n4. If ... | 0 | Given an alphanumeric string `s`, return _the **second largest** numerical digit that appears in_ `s`_, or_ `-1` _if it does not exist_.
An **alphanumeric** string is a string consisting of lowercase English letters and digits.
**Example 1:**
**Input:** s = "dfa12321afd "
**Output:** 2
**Explanation:** The digits t... | If you traverse the tree from right to left, the invalid node will point to a node that has already been visited. |
Python easy solution without sort and hash | 38ms | second-largest-digit-in-a-string | 0 | 1 | # Intuition\nWhat we need is 2nd largest number, so we just keep track of first and second largest number\n\n# Approach\n1. Initiate first and second to -1, -1\n2. Loop over a string\n3. If item is a number and it\'s greater than `first` then assign that number as `first` and original `first` number to `second`\n4. If ... | 0 | You are participating in an online chess tournament. There is a chess round that starts every `15` minutes. The first round of the day starts at `00:00`, and after every `15` minutes, a new round starts.
* For example, the second round starts at `00:15`, the fourth round starts at `00:45`, and the seventh round star... | First of all, get the distinct characters since we are only interested in those Let's note that there might not be any digits. |
Python3: Dictionary + Deque = beat 98% runtime | design-authentication-manager | 0 | 1 | # Intuition\n* The problem has an inherent FIFO nature - tokens are added with strictly increasing timestamps, and the tokens which are added first will also expire first since TTL is the same for all tokens. This should inspire using a queue. \n* I used a hashmap with the queue just to keep track of the tokenids, but ... | 1 | There is an authentication system that works with authentication tokens. For each session, the user will receive a new authentication token that will expire `timeToLive` seconds after the `currentTime`. If the token is renewed, the expiry time will be **extended** to expire `timeToLive` seconds after the (potentially d... | You need to check at most 2 characters to determine which character comes next. |
Python3: Dictionary + Deque = beat 98% runtime | design-authentication-manager | 0 | 1 | # Intuition\n* The problem has an inherent FIFO nature - tokens are added with strictly increasing timestamps, and the tokens which are added first will also expire first since TTL is the same for all tokens. This should inspire using a queue. \n* I used a hashmap with the queue just to keep track of the tokenids, but ... | 1 | You are given two `m x n` binary matrices `grid1` and `grid2` containing only `0`'s (representing water) and `1`'s (representing land). An **island** is a group of `1`'s connected **4-directionally** (horizontal or vertical). Any cells outside of the grid are considered water cells.
An island in `grid2` is considered ... | Using a map, track the expiry times of the tokens. When generating a new token, add it to the map with its expiry time. When renewing a token, check if it's on the map and has not expired yet. If so, update its expiry time. To count unexpired tokens, iterate on the map and check for each token if it's not expired yet. |
Clean Python with explanation | design-authentication-manager | 0 | 1 | ```\nclass AuthenticationManager(object):\n\n def __init__(self, timeToLive):\n self.token = dict()\n self.time = timeToLive # store timeToLive and create dictionary\n\n def generate(self, tokenId, currentTime):\n self.token[tokenId] = currentTime # store tokenId with currentTime\n\n ... | 10 | There is an authentication system that works with authentication tokens. For each session, the user will receive a new authentication token that will expire `timeToLive` seconds after the `currentTime`. If the token is renewed, the expiry time will be **extended** to expire `timeToLive` seconds after the (potentially d... | You need to check at most 2 characters to determine which character comes next. |
Clean Python with explanation | design-authentication-manager | 0 | 1 | ```\nclass AuthenticationManager(object):\n\n def __init__(self, timeToLive):\n self.token = dict()\n self.time = timeToLive # store timeToLive and create dictionary\n\n def generate(self, tokenId, currentTime):\n self.token[tokenId] = currentTime # store tokenId with currentTime\n\n ... | 10 | You are given two `m x n` binary matrices `grid1` and `grid2` containing only `0`'s (representing water) and `1`'s (representing land). An **island** is a group of `1`'s connected **4-directionally** (horizontal or vertical). Any cells outside of the grid are considered water cells.
An island in `grid2` is considered ... | Using a map, track the expiry times of the tokens. When generating a new token, add it to the map with its expiry time. When renewing a token, check if it's on the map and has not expired yet. If so, update its expiry time. To count unexpired tokens, iterate on the map and check for each token if it's not expired yet. |
Python3 Easy | design-authentication-manager | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ --... | 0 | There is an authentication system that works with authentication tokens. For each session, the user will receive a new authentication token that will expire `timeToLive` seconds after the `currentTime`. If the token is renewed, the expiry time will be **extended** to expire `timeToLive` seconds after the (potentially d... | You need to check at most 2 characters to determine which character comes next. |
Python3 Easy | design-authentication-manager | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ --... | 0 | You are given two `m x n` binary matrices `grid1` and `grid2` containing only `0`'s (representing water) and `1`'s (representing land). An **island** is a group of `1`'s connected **4-directionally** (horizontal or vertical). Any cells outside of the grid are considered water cells.
An island in `grid2` is considered ... | Using a map, track the expiry times of the tokens. When generating a new token, add it to the map with its expiry time. When renewing a token, check if it's on the map and has not expired yet. If so, update its expiry time. To count unexpired tokens, iterate on the map and check for each token if it's not expired yet. |
Simple Python Dictionary Implementation | design-authentication-manager | 0 | 1 | ```\nclass AuthenticationManager:\n\n def __init__(self, timeToLive: int):\n self.mp = {}\n self.life = timeToLive\n \n def generate(self, tokenId: str, currentTime: int) -> None:\n self.mp[tokenId] = (currentTime, currentTime+self.life)\n \n def renew(self, tokenId: str, cur... | 0 | There is an authentication system that works with authentication tokens. For each session, the user will receive a new authentication token that will expire `timeToLive` seconds after the `currentTime`. If the token is renewed, the expiry time will be **extended** to expire `timeToLive` seconds after the (potentially d... | You need to check at most 2 characters to determine which character comes next. |
Simple Python Dictionary Implementation | design-authentication-manager | 0 | 1 | ```\nclass AuthenticationManager:\n\n def __init__(self, timeToLive: int):\n self.mp = {}\n self.life = timeToLive\n \n def generate(self, tokenId: str, currentTime: int) -> None:\n self.mp[tokenId] = (currentTime, currentTime+self.life)\n \n def renew(self, tokenId: str, cur... | 0 | You are given two `m x n` binary matrices `grid1` and `grid2` containing only `0`'s (representing water) and `1`'s (representing land). An **island** is a group of `1`'s connected **4-directionally** (horizontal or vertical). Any cells outside of the grid are considered water cells.
An island in `grid2` is considered ... | Using a map, track the expiry times of the tokens. When generating a new token, add it to the map with its expiry time. When renewing a token, check if it's on the map and has not expired yet. If so, update its expiry time. To count unexpired tokens, iterate on the map and check for each token if it's not expired yet. |
Amortized O(1) | design-authentication-manager | 0 | 1 | # Code\n```\nfrom collections import deque\n# Amortized O(1)\nclass AuthenticationManager:\n def __init__(self, timeToLive: int):\n self.ttl = timeToLive \n self.q = deque() # history [(expiry. id)]\n self.tokens = {} # {id : expiry}\n\n def cleanup(self, currentTime): \n for _ in rang... | 0 | There is an authentication system that works with authentication tokens. For each session, the user will receive a new authentication token that will expire `timeToLive` seconds after the `currentTime`. If the token is renewed, the expiry time will be **extended** to expire `timeToLive` seconds after the (potentially d... | You need to check at most 2 characters to determine which character comes next. |
Amortized O(1) | design-authentication-manager | 0 | 1 | # Code\n```\nfrom collections import deque\n# Amortized O(1)\nclass AuthenticationManager:\n def __init__(self, timeToLive: int):\n self.ttl = timeToLive \n self.q = deque() # history [(expiry. id)]\n self.tokens = {} # {id : expiry}\n\n def cleanup(self, currentTime): \n for _ in rang... | 0 | You are given two `m x n` binary matrices `grid1` and `grid2` containing only `0`'s (representing water) and `1`'s (representing land). An **island** is a group of `1`'s connected **4-directionally** (horizontal or vertical). Any cells outside of the grid are considered water cells.
An island in `grid2` is considered ... | Using a map, track the expiry times of the tokens. When generating a new token, add it to the map with its expiry time. When renewing a token, check if it's on the map and has not expired yet. If so, update its expiry time. To count unexpired tokens, iterate on the map and check for each token if it's not expired yet. |
[Python] Easy to understand: Hash Table | design-authentication-manager | 0 | 1 | # Intuition\nClean old tokens before renewing and counting unexpired tokens\n\n# Code\n```\nclass AuthenticationManager:\n\n def __init__(self, timeToLive: int):\n self.ttl = timeToLive\n self.time = defaultdict(set)\n self.token = {}\n\n def delete_old_tokens(self, currentTime):\n del... | 0 | There is an authentication system that works with authentication tokens. For each session, the user will receive a new authentication token that will expire `timeToLive` seconds after the `currentTime`. If the token is renewed, the expiry time will be **extended** to expire `timeToLive` seconds after the (potentially d... | You need to check at most 2 characters to determine which character comes next. |
[Python] Easy to understand: Hash Table | design-authentication-manager | 0 | 1 | # Intuition\nClean old tokens before renewing and counting unexpired tokens\n\n# Code\n```\nclass AuthenticationManager:\n\n def __init__(self, timeToLive: int):\n self.ttl = timeToLive\n self.time = defaultdict(set)\n self.token = {}\n\n def delete_old_tokens(self, currentTime):\n del... | 0 | You are given two `m x n` binary matrices `grid1` and `grid2` containing only `0`'s (representing water) and `1`'s (representing land). An **island** is a group of `1`'s connected **4-directionally** (horizontal or vertical). Any cells outside of the grid are considered water cells.
An island in `grid2` is considered ... | Using a map, track the expiry times of the tokens. When generating a new token, add it to the map with its expiry time. When renewing a token, check if it's on the map and has not expired yet. If so, update its expiry time. To count unexpired tokens, iterate on the map and check for each token if it's not expired yet. |
Simple Python Clean 🔥 | design-authentication-manager | 0 | 1 | \n# Complexity\n- Time complexity:\nO(N)\n\n- Space complexity:\nO(N)\n# Code\n```\n\'\'\'\nsess , auth token , TTL secons after curr time\n\nif renewed exp. time = curr time + ttl\n\n\nIn terms of System design we can trade of countUnexpiredTokens\n\'\'\'\n\n\nclass AuthenticationManager:\n\n def __init__(self, tim... | 0 | There is an authentication system that works with authentication tokens. For each session, the user will receive a new authentication token that will expire `timeToLive` seconds after the `currentTime`. If the token is renewed, the expiry time will be **extended** to expire `timeToLive` seconds after the (potentially d... | You need to check at most 2 characters to determine which character comes next. |
Simple Python Clean 🔥 | design-authentication-manager | 0 | 1 | \n# Complexity\n- Time complexity:\nO(N)\n\n- Space complexity:\nO(N)\n# Code\n```\n\'\'\'\nsess , auth token , TTL secons after curr time\n\nif renewed exp. time = curr time + ttl\n\n\nIn terms of System design we can trade of countUnexpiredTokens\n\'\'\'\n\n\nclass AuthenticationManager:\n\n def __init__(self, tim... | 0 | You are given two `m x n` binary matrices `grid1` and `grid2` containing only `0`'s (representing water) and `1`'s (representing land). An **island** is a group of `1`'s connected **4-directionally** (horizontal or vertical). Any cells outside of the grid are considered water cells.
An island in `grid2` is considered ... | Using a map, track the expiry times of the tokens. When generating a new token, add it to the map with its expiry time. When renewing a token, check if it's on the map and has not expired yet. If so, update its expiry time. To count unexpired tokens, iterate on the map and check for each token if it's not expired yet. |
Heap solution (beats 99%) - O(1) generate, O(1) renew , O(nlogn) count | design-authentication-manager | 1 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nFirst thoughts:\n- Can generate and renew using hashmaps\n- I have to calculate the number of expired tokens for count\n- Brute way is to check and remove each token, is there any faster approach?\n\n# Approach\n<!-- Describe your approac... | 0 | There is an authentication system that works with authentication tokens. For each session, the user will receive a new authentication token that will expire `timeToLive` seconds after the `currentTime`. If the token is renewed, the expiry time will be **extended** to expire `timeToLive` seconds after the (potentially d... | You need to check at most 2 characters to determine which character comes next. |
Heap solution (beats 99%) - O(1) generate, O(1) renew , O(nlogn) count | design-authentication-manager | 1 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nFirst thoughts:\n- Can generate and renew using hashmaps\n- I have to calculate the number of expired tokens for count\n- Brute way is to check and remove each token, is there any faster approach?\n\n# Approach\n<!-- Describe your approac... | 0 | You are given two `m x n` binary matrices `grid1` and `grid2` containing only `0`'s (representing water) and `1`'s (representing land). An **island** is a group of `1`'s connected **4-directionally** (horizontal or vertical). Any cells outside of the grid are considered water cells.
An island in `grid2` is considered ... | Using a map, track the expiry times of the tokens. When generating a new token, add it to the map with its expiry time. When renewing a token, check if it's on the map and has not expired yet. If so, update its expiry time. To count unexpired tokens, iterate on the map and check for each token if it's not expired yet. |
merge sort | maximum-number-of-consecutive-values-you-can-make | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nmerge sort\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\nO(nlogn)\n\n- Space complexity:\n<!-- Add your space complexity he... | 0 | You are given an integer array `coins` of length `n` which represents the `n` coins that you own. The value of the `ith` coin is `coins[i]`. You can **make** some value `x` if you can choose some of your `n` coins such that their values sum up to `x`.
Return the _maximum number of consecutive integer values that you *... | The abstract problem asks to count the number of disjoint pairs with a given sum k. For each possible value x, it can be paired up with k - x. The number of such pairs equals to min(count(x), count(k-x)), unless that x = k / 2, where the number of such pairs will be floor(count(x) / 2). |
merge sort | maximum-number-of-consecutive-values-you-can-make | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nmerge sort\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\nO(nlogn)\n\n- Space complexity:\n<!-- Add your space complexity he... | 0 | Given a string `s`, return _the number of **unique palindromes of length three** that are a **subsequence** of_ `s`.
Note that even if there are multiple ways to obtain the same subsequence, it is still only counted **once**.
A **palindrome** is a string that reads the same forwards and backwards.
A **subsequence** ... | If you can make the first x values and you have a value v, then you can make all the values ≤ v + x Sort the array of coins. You can always make the value 0 so you can start with x = 0. Process the values starting from the smallest and stop when there is a value that cannot be achieved with the current x. |
Python greedy with sorting with explanation (330 and 2952 variant) | maximum-number-of-consecutive-values-you-can-make | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n1. Initialize res = 1 since we count from 0;\n2. Sort coins;\n3. For each coin in coins:\n - if coin > res, then the consecutive values cannot expand to the right;\n - if coin == res, then the consecutive values can be just perfectly ex... | 0 | You are given an integer array `coins` of length `n` which represents the `n` coins that you own. The value of the `ith` coin is `coins[i]`. You can **make** some value `x` if you can choose some of your `n` coins such that their values sum up to `x`.
Return the _maximum number of consecutive integer values that you *... | The abstract problem asks to count the number of disjoint pairs with a given sum k. For each possible value x, it can be paired up with k - x. The number of such pairs equals to min(count(x), count(k-x)), unless that x = k / 2, where the number of such pairs will be floor(count(x) / 2). |
Python greedy with sorting with explanation (330 and 2952 variant) | maximum-number-of-consecutive-values-you-can-make | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n1. Initialize res = 1 since we count from 0;\n2. Sort coins;\n3. For each coin in coins:\n - if coin > res, then the consecutive values cannot expand to the right;\n - if coin == res, then the consecutive values can be just perfectly ex... | 0 | Given a string `s`, return _the number of **unique palindromes of length three** that are a **subsequence** of_ `s`.
Note that even if there are multiple ways to obtain the same subsequence, it is still only counted **once**.
A **palindrome** is a string that reads the same forwards and backwards.
A **subsequence** ... | If you can make the first x values and you have a value v, then you can make all the values ≤ v + x Sort the array of coins. You can always make the value 0 so you can start with x = 0. Process the values starting from the smallest and stop when there is a value that cannot be achieved with the current x. |
Maximum Number of Consecutive Values You Can Make solve with python | maximum-number-of-consecutive-values-you-can-make | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ --... | 0 | You are given an integer array `coins` of length `n` which represents the `n` coins that you own. The value of the `ith` coin is `coins[i]`. You can **make** some value `x` if you can choose some of your `n` coins such that their values sum up to `x`.
Return the _maximum number of consecutive integer values that you *... | The abstract problem asks to count the number of disjoint pairs with a given sum k. For each possible value x, it can be paired up with k - x. The number of such pairs equals to min(count(x), count(k-x)), unless that x = k / 2, where the number of such pairs will be floor(count(x) / 2). |
Maximum Number of Consecutive Values You Can Make solve with python | maximum-number-of-consecutive-values-you-can-make | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ --... | 0 | Given a string `s`, return _the number of **unique palindromes of length three** that are a **subsequence** of_ `s`.
Note that even if there are multiple ways to obtain the same subsequence, it is still only counted **once**.
A **palindrome** is a string that reads the same forwards and backwards.
A **subsequence** ... | If you can make the first x values and you have a value v, then you can make all the values ≤ v + x Sort the array of coins. You can always make the value 0 so you can start with x = 0. Process the values starting from the smallest and stop when there is a value that cannot be achieved with the current x. |
Hashmap | O(N + u log u) T | O(u) S | Commented and Explained | maximum-number-of-consecutive-values-you-can-make | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nWhat we care about are the coins we can greedily reach from the coin combinations we can so far generate. As such, we want to track the largest coin combinations we can make as we go over our unique coin types and frequencies in our coins... | 0 | You are given an integer array `coins` of length `n` which represents the `n` coins that you own. The value of the `ith` coin is `coins[i]`. You can **make** some value `x` if you can choose some of your `n` coins such that their values sum up to `x`.
Return the _maximum number of consecutive integer values that you *... | The abstract problem asks to count the number of disjoint pairs with a given sum k. For each possible value x, it can be paired up with k - x. The number of such pairs equals to min(count(x), count(k-x)), unless that x = k / 2, where the number of such pairs will be floor(count(x) / 2). |
Hashmap | O(N + u log u) T | O(u) S | Commented and Explained | maximum-number-of-consecutive-values-you-can-make | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\nWhat we care about are the coins we can greedily reach from the coin combinations we can so far generate. As such, we want to track the largest coin combinations we can make as we go over our unique coin types and frequencies in our coins... | 0 | Given a string `s`, return _the number of **unique palindromes of length three** that are a **subsequence** of_ `s`.
Note that even if there are multiple ways to obtain the same subsequence, it is still only counted **once**.
A **palindrome** is a string that reads the same forwards and backwards.
A **subsequence** ... | If you can make the first x values and you have a value v, then you can make all the values ≤ v + x Sort the array of coins. You can always make the value 0 so you can start with x = 0. Process the values starting from the smallest and stop when there is a value that cannot be achieved with the current x. |
Go/Python O(n*log(n)) time | O(1) space | maximum-number-of-consecutive-values-you-can-make | 0 | 1 | # Complexity\n- Time complexity: $$O(n*log(n))$$\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: $$O(1)$$\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```golang []\nfunc getMaximumConsecutive(coins []int) int {\n sort.Ints(coins)\n covered := 0\n for _,value ... | 0 | You are given an integer array `coins` of length `n` which represents the `n` coins that you own. The value of the `ith` coin is `coins[i]`. You can **make** some value `x` if you can choose some of your `n` coins such that their values sum up to `x`.
Return the _maximum number of consecutive integer values that you *... | The abstract problem asks to count the number of disjoint pairs with a given sum k. For each possible value x, it can be paired up with k - x. The number of such pairs equals to min(count(x), count(k-x)), unless that x = k / 2, where the number of such pairs will be floor(count(x) / 2). |
Go/Python O(n*log(n)) time | O(1) space | maximum-number-of-consecutive-values-you-can-make | 0 | 1 | # Complexity\n- Time complexity: $$O(n*log(n))$$\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity: $$O(1)$$\n<!-- Add your space complexity here, e.g. $$O(n)$$ -->\n\n# Code\n```golang []\nfunc getMaximumConsecutive(coins []int) int {\n sort.Ints(coins)\n covered := 0\n for _,value ... | 0 | Given a string `s`, return _the number of **unique palindromes of length three** that are a **subsequence** of_ `s`.
Note that even if there are multiple ways to obtain the same subsequence, it is still only counted **once**.
A **palindrome** is a string that reads the same forwards and backwards.
A **subsequence** ... | If you can make the first x values and you have a value v, then you can make all the values ≤ v + x Sort the array of coins. You can always make the value 0 so you can start with x = 0. Process the values starting from the smallest and stop when there is a value that cannot be achieved with the current x. |
[Java/Python] | Greedy | maximum-number-of-consecutive-values-you-can-make | 1 | 1 | Logic is if we have made consecutive sequence [0,K], then next coin coins[i] should be less than equal to K + 1 and next range we will be able to cover is coins[i] + K.\n***Java***\n```\nclass Solution {\n public int getMaximumConsecutive(int[] coins) {\n Arrays.sort(coins);\n int curr = 0 ; int n = co... | 0 | You are given an integer array `coins` of length `n` which represents the `n` coins that you own. The value of the `ith` coin is `coins[i]`. You can **make** some value `x` if you can choose some of your `n` coins such that their values sum up to `x`.
Return the _maximum number of consecutive integer values that you *... | The abstract problem asks to count the number of disjoint pairs with a given sum k. For each possible value x, it can be paired up with k - x. The number of such pairs equals to min(count(x), count(k-x)), unless that x = k / 2, where the number of such pairs will be floor(count(x) / 2). |
[Java/Python] | Greedy | maximum-number-of-consecutive-values-you-can-make | 1 | 1 | Logic is if we have made consecutive sequence [0,K], then next coin coins[i] should be less than equal to K + 1 and next range we will be able to cover is coins[i] + K.\n***Java***\n```\nclass Solution {\n public int getMaximumConsecutive(int[] coins) {\n Arrays.sort(coins);\n int curr = 0 ; int n = co... | 0 | Given a string `s`, return _the number of **unique palindromes of length three** that are a **subsequence** of_ `s`.
Note that even if there are multiple ways to obtain the same subsequence, it is still only counted **once**.
A **palindrome** is a string that reads the same forwards and backwards.
A **subsequence** ... | If you can make the first x values and you have a value v, then you can make all the values ≤ v + x Sort the array of coins. You can always make the value 0 so you can start with x = 0. Process the values starting from the smallest and stop when there is a value that cannot be achieved with the current x. |
Python | Greedy | O(n) | maximum-number-of-consecutive-values-you-can-make | 0 | 1 | # Code\n```\nclass Solution:\n def getMaximumConsecutive(self, coins: List[int]) -> int:\n coins.sort()\n i = 0\n for coin in coins:\n if coin > i+1:\n return i + 1\n else:\n i += coin\n return i + 1\n``` | 0 | You are given an integer array `coins` of length `n` which represents the `n` coins that you own. The value of the `ith` coin is `coins[i]`. You can **make** some value `x` if you can choose some of your `n` coins such that their values sum up to `x`.
Return the _maximum number of consecutive integer values that you *... | The abstract problem asks to count the number of disjoint pairs with a given sum k. For each possible value x, it can be paired up with k - x. The number of such pairs equals to min(count(x), count(k-x)), unless that x = k / 2, where the number of such pairs will be floor(count(x) / 2). |
Python | Greedy | O(n) | maximum-number-of-consecutive-values-you-can-make | 0 | 1 | # Code\n```\nclass Solution:\n def getMaximumConsecutive(self, coins: List[int]) -> int:\n coins.sort()\n i = 0\n for coin in coins:\n if coin > i+1:\n return i + 1\n else:\n i += coin\n return i + 1\n``` | 0 | Given a string `s`, return _the number of **unique palindromes of length three** that are a **subsequence** of_ `s`.
Note that even if there are multiple ways to obtain the same subsequence, it is still only counted **once**.
A **palindrome** is a string that reads the same forwards and backwards.
A **subsequence** ... | If you can make the first x values and you have a value v, then you can make all the values ≤ v + x Sort the array of coins. You can always make the value 0 so you can start with x = 0. Process the values starting from the smallest and stop when there is a value that cannot be achieved with the current x. |
Weak Test Cases: Subexponential Solution Passes All Current Test Cases | maximize-score-after-n-operations | 0 | 1 | This is a greedy solution that tries all first pairs, then greedily chooses the max gcd pair for the remaining pairs.\n\nThis will pass a test case with one layer of "gotchas" like [9088, 9344, 71, 73]. That is, one non-greedy choice is sufficient to greedily make the rest of the choices.\n\nBut, this solution should f... | 4 | You are given `nums`, an array of positive integers of size `2 * n`. You must perform `n` operations on this array.
In the `ith` operation **(1-indexed)**, you will:
* Choose two elements, `x` and `y`.
* Receive a score of `i * gcd(x, y)`.
* Remove `x` and `y` from `nums`.
Return _the maximum score you can rec... | The constraints are small enough for a backtrack solution but not any backtrack solution If we use a naive n^k don't you think it can be optimized |
Weak Test Cases: Subexponential Solution Passes All Current Test Cases | maximize-score-after-n-operations | 0 | 1 | This is a greedy solution that tries all first pairs, then greedily chooses the max gcd pair for the remaining pairs.\n\nThis will pass a test case with one layer of "gotchas" like [9088, 9344, 71, 73]. That is, one non-greedy choice is sufficient to greedily make the rest of the choices.\n\nBut, this solution should f... | 4 | The **minimum absolute difference** of an array `a` is defined as the **minimum value** of `|a[i] - a[j]|`, where `0 <= i < j < a.length` and `a[i] != a[j]`. If all elements of `a` are the **same**, the minimum absolute difference is `-1`.
* For example, the minimum absolute difference of the array `[5,2,3,7,2]` is ... | Find every way to split the array until n groups of 2. Brute force recursion is acceptable. Calculate the gcd of every pair and greedily multiply the largest gcds. |
The World Needs Another Python Solution | maximize-score-after-n-operations | 0 | 1 | ```\nfrom math import gcd\nfrom functools import cache\n\nclass Solution:\n def maxScore(self, nums: List[int]) -> int:\n n = len(nums)\n @cache\n def rec(nums):\n multiplier = (n-len(nums))//2 + 1\n best = 0\n for i in range(len(nums)-1):\n for j ... | 1 | You are given `nums`, an array of positive integers of size `2 * n`. You must perform `n` operations on this array.
In the `ith` operation **(1-indexed)**, you will:
* Choose two elements, `x` and `y`.
* Receive a score of `i * gcd(x, y)`.
* Remove `x` and `y` from `nums`.
Return _the maximum score you can rec... | The constraints are small enough for a backtrack solution but not any backtrack solution If we use a naive n^k don't you think it can be optimized |
The World Needs Another Python Solution | maximize-score-after-n-operations | 0 | 1 | ```\nfrom math import gcd\nfrom functools import cache\n\nclass Solution:\n def maxScore(self, nums: List[int]) -> int:\n n = len(nums)\n @cache\n def rec(nums):\n multiplier = (n-len(nums))//2 + 1\n best = 0\n for i in range(len(nums)-1):\n for j ... | 1 | The **minimum absolute difference** of an array `a` is defined as the **minimum value** of `|a[i] - a[j]|`, where `0 <= i < j < a.length` and `a[i] != a[j]`. If all elements of `a` are the **same**, the minimum absolute difference is `-1`.
* For example, the minimum absolute difference of the array `[5,2,3,7,2]` is ... | Find every way to split the array until n groups of 2. Brute force recursion is acceptable. Calculate the gcd of every pair and greedily multiply the largest gcds. |
SOLUTION IN PYTHON3 | maximize-score-after-n-operations | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ --... | 1 | You are given `nums`, an array of positive integers of size `2 * n`. You must perform `n` operations on this array.
In the `ith` operation **(1-indexed)**, you will:
* Choose two elements, `x` and `y`.
* Receive a score of `i * gcd(x, y)`.
* Remove `x` and `y` from `nums`.
Return _the maximum score you can rec... | The constraints are small enough for a backtrack solution but not any backtrack solution If we use a naive n^k don't you think it can be optimized |
SOLUTION IN PYTHON3 | maximize-score-after-n-operations | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ --... | 1 | The **minimum absolute difference** of an array `a` is defined as the **minimum value** of `|a[i] - a[j]|`, where `0 <= i < j < a.length` and `a[i] != a[j]`. If all elements of `a` are the **same**, the minimum absolute difference is `-1`.
* For example, the minimum absolute difference of the array `[5,2,3,7,2]` is ... | Find every way to split the array until n groups of 2. Brute force recursion is acceptable. Calculate the gcd of every pair and greedily multiply the largest gcds. |
[Python3] Greedy-ish, No Bitmask, No Memoization | maximize-score-after-n-operations | 0 | 1 | ```\nclass Solution:\n def maxScore(self, nums: List[int]) -> int:\n """LeetCode 1799\n\n The basic idea is greedy-ish. We want the largest operation to almost always\n conincide with the largest gcd. However, to iterate through all possible\n scenarios, we have to do backtracking where a... | 1 | You are given `nums`, an array of positive integers of size `2 * n`. You must perform `n` operations on this array.
In the `ith` operation **(1-indexed)**, you will:
* Choose two elements, `x` and `y`.
* Receive a score of `i * gcd(x, y)`.
* Remove `x` and `y` from `nums`.
Return _the maximum score you can rec... | The constraints are small enough for a backtrack solution but not any backtrack solution If we use a naive n^k don't you think it can be optimized |
[Python3] Greedy-ish, No Bitmask, No Memoization | maximize-score-after-n-operations | 0 | 1 | ```\nclass Solution:\n def maxScore(self, nums: List[int]) -> int:\n """LeetCode 1799\n\n The basic idea is greedy-ish. We want the largest operation to almost always\n conincide with the largest gcd. However, to iterate through all possible\n scenarios, we have to do backtracking where a... | 1 | The **minimum absolute difference** of an array `a` is defined as the **minimum value** of `|a[i] - a[j]|`, where `0 <= i < j < a.length` and `a[i] != a[j]`. If all elements of `a` are the **same**, the minimum absolute difference is `-1`.
* For example, the minimum absolute difference of the array `[5,2,3,7,2]` is ... | Find every way to split the array until n groups of 2. Brute force recursion is acceptable. Calculate the gcd of every pair and greedily multiply the largest gcds. |
python 3 - dp + bitmask (easy intuition) | maximize-score-after-n-operations | 0 | 1 | # Intuition\nPlease do it by reading the constraint.\n\nSimple backtracking is way tooooo slow which will definitely lead you to TLE. You need a faster solution.\n\nYou see there are similar sub-problems after choosing some numbers. So you need DP. The next question is how to cache.\n\nAs the input isn\'t large, bitmas... | 1 | You are given `nums`, an array of positive integers of size `2 * n`. You must perform `n` operations on this array.
In the `ith` operation **(1-indexed)**, you will:
* Choose two elements, `x` and `y`.
* Receive a score of `i * gcd(x, y)`.
* Remove `x` and `y` from `nums`.
Return _the maximum score you can rec... | The constraints are small enough for a backtrack solution but not any backtrack solution If we use a naive n^k don't you think it can be optimized |
python 3 - dp + bitmask (easy intuition) | maximize-score-after-n-operations | 0 | 1 | # Intuition\nPlease do it by reading the constraint.\n\nSimple backtracking is way tooooo slow which will definitely lead you to TLE. You need a faster solution.\n\nYou see there are similar sub-problems after choosing some numbers. So you need DP. The next question is how to cache.\n\nAs the input isn\'t large, bitmas... | 1 | The **minimum absolute difference** of an array `a` is defined as the **minimum value** of `|a[i] - a[j]|`, where `0 <= i < j < a.length` and `a[i] != a[j]`. If all elements of `a` are the **same**, the minimum absolute difference is `-1`.
* For example, the minimum absolute difference of the array `[5,2,3,7,2]` is ... | Find every way to split the array until n groups of 2. Brute force recursion is acceptable. Calculate the gcd of every pair and greedily multiply the largest gcds. |
Python short and clean. 2 solutions. Functional programming. | maximize-score-after-n-operations | 0 | 1 | # Approach 1:\nRecursion with list slicing **(TLE)**\n\n<!-- # Complexity\n- Time complexity: $$O(n ^ 3)$$\n\n- Space complexity: $$O(n)$$ -->\n\n# Code\n```python\nclass Solution:\n def maxScore(self, nums: list[int]) -> int:\n \n def score(xs: list[int]) -> int:\n n = len(xs)\n ... | 2 | You are given `nums`, an array of positive integers of size `2 * n`. You must perform `n` operations on this array.
In the `ith` operation **(1-indexed)**, you will:
* Choose two elements, `x` and `y`.
* Receive a score of `i * gcd(x, y)`.
* Remove `x` and `y` from `nums`.
Return _the maximum score you can rec... | The constraints are small enough for a backtrack solution but not any backtrack solution If we use a naive n^k don't you think it can be optimized |
Python short and clean. 2 solutions. Functional programming. | maximize-score-after-n-operations | 0 | 1 | # Approach 1:\nRecursion with list slicing **(TLE)**\n\n<!-- # Complexity\n- Time complexity: $$O(n ^ 3)$$\n\n- Space complexity: $$O(n)$$ -->\n\n# Code\n```python\nclass Solution:\n def maxScore(self, nums: list[int]) -> int:\n \n def score(xs: list[int]) -> int:\n n = len(xs)\n ... | 2 | The **minimum absolute difference** of an array `a` is defined as the **minimum value** of `|a[i] - a[j]|`, where `0 <= i < j < a.length` and `a[i] != a[j]`. If all elements of `a` are the **same**, the minimum absolute difference is `-1`.
* For example, the minimum absolute difference of the array `[5,2,3,7,2]` is ... | Find every way to split the array until n groups of 2. Brute force recursion is acceptable. Calculate the gcd of every pair and greedily multiply the largest gcds. |
🐍✅Python3 most 🔥optimised🔥 solution | maximize-score-after-n-operations | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n**Using Dynamic programming**\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n- Construct a matrix of greatest common divisors for all pairs of elements in the input array using nested loops and the built-in `gcd()... | 4 | You are given `nums`, an array of positive integers of size `2 * n`. You must perform `n` operations on this array.
In the `ith` operation **(1-indexed)**, you will:
* Choose two elements, `x` and `y`.
* Receive a score of `i * gcd(x, y)`.
* Remove `x` and `y` from `nums`.
Return _the maximum score you can rec... | The constraints are small enough for a backtrack solution but not any backtrack solution If we use a naive n^k don't you think it can be optimized |
🐍✅Python3 most 🔥optimised🔥 solution | maximize-score-after-n-operations | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n**Using Dynamic programming**\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n- Construct a matrix of greatest common divisors for all pairs of elements in the input array using nested loops and the built-in `gcd()... | 4 | The **minimum absolute difference** of an array `a` is defined as the **minimum value** of `|a[i] - a[j]|`, where `0 <= i < j < a.length` and `a[i] != a[j]`. If all elements of `a` are the **same**, the minimum absolute difference is `-1`.
* For example, the minimum absolute difference of the array `[5,2,3,7,2]` is ... | Find every way to split the array until n groups of 2. Brute force recursion is acceptable. Calculate the gcd of every pair and greedily multiply the largest gcds. |
Python🔥Java🔥C++🔥Simple Solution🔥Easy to Understand | maximize-score-after-n-operations | 1 | 1 | **!! BIG ANNOUNCEMENT !!**\nI am currently Giving away my premium content well-structured assignments and study materials to clear interviews at top companies related to computer science and data science to my current Subscribers. Next assignment will be shared tomorrow. **DON\'T FORGET** to Subscribe\n\n# Search \uD8... | 27 | You are given `nums`, an array of positive integers of size `2 * n`. You must perform `n` operations on this array.
In the `ith` operation **(1-indexed)**, you will:
* Choose two elements, `x` and `y`.
* Receive a score of `i * gcd(x, y)`.
* Remove `x` and `y` from `nums`.
Return _the maximum score you can rec... | The constraints are small enough for a backtrack solution but not any backtrack solution If we use a naive n^k don't you think it can be optimized |
Python🔥Java🔥C++🔥Simple Solution🔥Easy to Understand | maximize-score-after-n-operations | 1 | 1 | **!! BIG ANNOUNCEMENT !!**\nI am currently Giving away my premium content well-structured assignments and study materials to clear interviews at top companies related to computer science and data science to my current Subscribers. Next assignment will be shared tomorrow. **DON\'T FORGET** to Subscribe\n\n# Search \uD8... | 27 | The **minimum absolute difference** of an array `a` is defined as the **minimum value** of `|a[i] - a[j]|`, where `0 <= i < j < a.length` and `a[i] != a[j]`. If all elements of `a` are the **same**, the minimum absolute difference is `-1`.
* For example, the minimum absolute difference of the array `[5,2,3,7,2]` is ... | Find every way to split the array until n groups of 2. Brute force recursion is acceptable. Calculate the gcd of every pair and greedily multiply the largest gcds. |
Python 32 ms | maximum-ascending-subarray-sum | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ --... | 1 | Given an array of positive integers `nums`, return the _maximum possible sum of an **ascending** subarray in_ `nums`.
A subarray is defined as a contiguous sequence of numbers in an array.
A subarray `[numsl, numsl+1, ..., numsr-1, numsr]` is **ascending** if for all `i` where `l <= i < r`, `numsi < numsi+1`. Note th... | Express the nth number value in a recursion formula and think about how we can do a fast evaluation. |
Python 32 ms | maximum-ascending-subarray-sum | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:\n<!-- Add your space complexity here, e.g. $$O(n)$$ --... | 1 | Alice and Bob take turns playing a game, with **Alice** **starting first**.
You are given a string `num` of **even length** consisting of digits and `'?'` characters. On each turn, a player will do the following if there is still at least one `'?'` in `num`:
1. Choose an index `i` where `num[i] == '?'`.
2. Replace ... | It is fast enough to check all possible subarrays The end of each ascending subarray will be the start of the next |
Simple Python3 Solution | Faster than 95.89% | maximum-ascending-subarray-sum | 0 | 1 | ```\n def maxAscendingSum(self, nums: List[int]) -> int:\n res = 0\n \n curr = nums[0]\n for i, n in enumerate(nums[1:]):\n if n <= nums[i]:\n res = max(res, curr)\n curr = n\n else:\n curr += n\n \n ... | 1 | Given an array of positive integers `nums`, return the _maximum possible sum of an **ascending** subarray in_ `nums`.
A subarray is defined as a contiguous sequence of numbers in an array.
A subarray `[numsl, numsl+1, ..., numsr-1, numsr]` is **ascending** if for all `i` where `l <= i < r`, `numsi < numsi+1`. Note th... | Express the nth number value in a recursion formula and think about how we can do a fast evaluation. |
Simple Python3 Solution | Faster than 95.89% | maximum-ascending-subarray-sum | 0 | 1 | ```\n def maxAscendingSum(self, nums: List[int]) -> int:\n res = 0\n \n curr = nums[0]\n for i, n in enumerate(nums[1:]):\n if n <= nums[i]:\n res = max(res, curr)\n curr = n\n else:\n curr += n\n \n ... | 1 | Alice and Bob take turns playing a game, with **Alice** **starting first**.
You are given a string `num` of **even length** consisting of digits and `'?'` characters. On each turn, a player will do the following if there is still at least one `'?'` in `num`:
1. Choose an index `i` where `num[i] == '?'`.
2. Replace ... | It is fast enough to check all possible subarrays The end of each ascending subarray will be the start of the next |
Straightforward Python Solution | maximum-ascending-subarray-sum | 0 | 1 | \n\n# Code\n```\nclass Solution:\n def maxAscendingSum(self, nums: List[int]) -> int:\n res = 0\n temp = nums[0]\n for i in range(1, len(nums)):\n if nums[i] > nums[i-1]:\n temp += nums[i]\n else:\n res = max(res, temp)\n temp = ... | 1 | Given an array of positive integers `nums`, return the _maximum possible sum of an **ascending** subarray in_ `nums`.
A subarray is defined as a contiguous sequence of numbers in an array.
A subarray `[numsl, numsl+1, ..., numsr-1, numsr]` is **ascending** if for all `i` where `l <= i < r`, `numsi < numsi+1`. Note th... | Express the nth number value in a recursion formula and think about how we can do a fast evaluation. |
Straightforward Python Solution | maximum-ascending-subarray-sum | 0 | 1 | \n\n# Code\n```\nclass Solution:\n def maxAscendingSum(self, nums: List[int]) -> int:\n res = 0\n temp = nums[0]\n for i in range(1, len(nums)):\n if nums[i] > nums[i-1]:\n temp += nums[i]\n else:\n res = max(res, temp)\n temp = ... | 1 | Alice and Bob take turns playing a game, with **Alice** **starting first**.
You are given a string `num` of **even length** consisting of digits and `'?'` characters. On each turn, a player will do the following if there is still at least one `'?'` in `num`:
1. Choose an index `i` where `num[i] == '?'`.
2. Replace ... | It is fast enough to check all possible subarrays The end of each ascending subarray will be the start of the next |
[Python3] line sweep | maximum-ascending-subarray-sum | 0 | 1 | \n```\nclass Solution:\n def maxAscendingSum(self, nums: List[int]) -> int:\n ans = 0\n for i, x in enumerate(nums): \n if not i or nums[i-1] >= nums[i]: val = 0 # reset val \n val += nums[i]\n ans = max(ans, val)\n return ans \n```\n\nEdited on 3/22/2021\nAdding... | 7 | Given an array of positive integers `nums`, return the _maximum possible sum of an **ascending** subarray in_ `nums`.
A subarray is defined as a contiguous sequence of numbers in an array.
A subarray `[numsl, numsl+1, ..., numsr-1, numsr]` is **ascending** if for all `i` where `l <= i < r`, `numsi < numsi+1`. Note th... | Express the nth number value in a recursion formula and think about how we can do a fast evaluation. |
[Python3] line sweep | maximum-ascending-subarray-sum | 0 | 1 | \n```\nclass Solution:\n def maxAscendingSum(self, nums: List[int]) -> int:\n ans = 0\n for i, x in enumerate(nums): \n if not i or nums[i-1] >= nums[i]: val = 0 # reset val \n val += nums[i]\n ans = max(ans, val)\n return ans \n```\n\nEdited on 3/22/2021\nAdding... | 7 | Alice and Bob take turns playing a game, with **Alice** **starting first**.
You are given a string `num` of **even length** consisting of digits and `'?'` characters. On each turn, a player will do the following if there is still at least one `'?'` in `num`:
1. Choose an index `i` where `num[i] == '?'`.
2. Replace ... | It is fast enough to check all possible subarrays The end of each ascending subarray will be the start of the next |
PYTHON | Simple python solution | maximum-ascending-subarray-sum | 0 | 1 | ```\nclass Solution:\n def maxAscendingSum(self, nums: List[int]) -> int:\n maxSum = 0\n subSum = 0\n \n for i in range(len(nums)):\n \n if i == 0 or nums[i-1] < nums[i]:\n subSum += nums[i]\n maxSum = max(maxSum, subSum)\n el... | 1 | Given an array of positive integers `nums`, return the _maximum possible sum of an **ascending** subarray in_ `nums`.
A subarray is defined as a contiguous sequence of numbers in an array.
A subarray `[numsl, numsl+1, ..., numsr-1, numsr]` is **ascending** if for all `i` where `l <= i < r`, `numsi < numsi+1`. Note th... | Express the nth number value in a recursion formula and think about how we can do a fast evaluation. |
PYTHON | Simple python solution | maximum-ascending-subarray-sum | 0 | 1 | ```\nclass Solution:\n def maxAscendingSum(self, nums: List[int]) -> int:\n maxSum = 0\n subSum = 0\n \n for i in range(len(nums)):\n \n if i == 0 or nums[i-1] < nums[i]:\n subSum += nums[i]\n maxSum = max(maxSum, subSum)\n el... | 1 | Alice and Bob take turns playing a game, with **Alice** **starting first**.
You are given a string `num` of **even length** consisting of digits and `'?'` characters. On each turn, a player will do the following if there is still at least one `'?'` in `num`:
1. Choose an index `i` where `num[i] == '?'`.
2. Replace ... | It is fast enough to check all possible subarrays The end of each ascending subarray will be the start of the next |
Python3 Solution - Two Pointers | maximum-ascending-subarray-sum | 0 | 1 | # Code :)\n```\nclass Solution:\n def maxAscendingSum(self, nums: List[int]) -> int:\n # Initialize the result to -1 to store the maximum sum\n result = 0\n # Initialize the outer loop index\n i = 0\n \n # Iterate through the list until the end\n while i < len(nums): ... | 0 | Given an array of positive integers `nums`, return the _maximum possible sum of an **ascending** subarray in_ `nums`.
A subarray is defined as a contiguous sequence of numbers in an array.
A subarray `[numsl, numsl+1, ..., numsr-1, numsr]` is **ascending** if for all `i` where `l <= i < r`, `numsi < numsi+1`. Note th... | Express the nth number value in a recursion formula and think about how we can do a fast evaluation. |
Python3 Solution - Two Pointers | maximum-ascending-subarray-sum | 0 | 1 | # Code :)\n```\nclass Solution:\n def maxAscendingSum(self, nums: List[int]) -> int:\n # Initialize the result to -1 to store the maximum sum\n result = 0\n # Initialize the outer loop index\n i = 0\n \n # Iterate through the list until the end\n while i < len(nums): ... | 0 | Alice and Bob take turns playing a game, with **Alice** **starting first**.
You are given a string `num` of **even length** consisting of digits and `'?'` characters. On each turn, a player will do the following if there is still at least one `'?'` in `num`:
1. Choose an index `i` where `num[i] == '?'`.
2. Replace ... | It is fast enough to check all possible subarrays The end of each ascending subarray will be the start of the next |
Maximum Ascending Subarray Sum | maximum-ascending-subarray-sum | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:O(n^3)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:O(1)\n<!-- Add your space complexity here, e.g. $... | 0 | Given an array of positive integers `nums`, return the _maximum possible sum of an **ascending** subarray in_ `nums`.
A subarray is defined as a contiguous sequence of numbers in an array.
A subarray `[numsl, numsl+1, ..., numsr-1, numsr]` is **ascending** if for all `i` where `l <= i < r`, `numsi < numsi+1`. Note th... | Express the nth number value in a recursion formula and think about how we can do a fast evaluation. |
Maximum Ascending Subarray Sum | maximum-ascending-subarray-sum | 0 | 1 | # Intuition\n<!-- Describe your first thoughts on how to solve this problem. -->\n\n# Approach\n<!-- Describe your approach to solving the problem. -->\n\n# Complexity\n- Time complexity:O(n^3)\n<!-- Add your time complexity here, e.g. $$O(n)$$ -->\n\n- Space complexity:O(1)\n<!-- Add your space complexity here, e.g. $... | 0 | Alice and Bob take turns playing a game, with **Alice** **starting first**.
You are given a string `num` of **even length** consisting of digits and `'?'` characters. On each turn, a player will do the following if there is still at least one `'?'` in `num`:
1. Choose an index `i` where `num[i] == '?'`.
2. Replace ... | It is fast enough to check all possible subarrays The end of each ascending subarray will be the start of the next |
Python 3 || 9 lines, w/ explanation || T/M: 89% / 49% | number-of-orders-in-the-backlog | 0 | 1 | Here\'s the plan:\n1. Establish maxheap `buy` for buy orders and minheap `sell` for sell orders.\n2. Iterate through `orders`. Push each element onto the appropriate heap.\n3. During each iteration, peak at the heads of each list and determine whether they allow a transaction. If so, pop both heads, and if one has a po... | 3 | You are given a 2D integer array `orders`, where each `orders[i] = [pricei, amounti, orderTypei]` denotes that `amounti` orders have been placed of type `orderTypei` at the price `pricei`. The `orderTypei` is:
* `0` if it is a batch of `buy` orders, or
* `1` if it is a batch of `sell` orders.
Note that `orders[i]... | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.