+4

Author: Code-Wen

1103.distribute-candies-to-people.py

@@ -0,0 +1,100 @@
+#
+# @lc app=leetcode id=1103 lang=python3
+#
+# [1103] Distribute Candies to People
+#
+# https://leetcode.com/problems/distribute-candies-to-people/description/
+#
+# algorithms
+# Easy (60.40%)
+# Likes:    321
+# Dislikes: 79
+# Total Accepted:    33.1K
+# Total Submissions: 53.1K
+# Testcase Example:  '7\n4'
+#
+# We distribute some number of candies, to a row of n = num_people people in
+# the following way:
+# 
+# We then give 1 candy to the first person, 2 candies to the second person, and
+# so on until we give n candies to the last person.
+# 
+# Then, we go back to the start of the row, giving n + 1 candies to the first
+# person, n + 2 candies to the second person, and so on until we give 2 * n
+# candies to the last person.
+# 
+# This process repeats (with us giving one more candy each time, and moving to
+# the start of the row after we reach the end) until we run out of candies.
+# The last person will receive all of our remaining candies (not necessarily
+# one more than the previous gift).
+# 
+# Return an array (of length num_people and sum candies) that represents the
+# final distribution of candies.
+# 
+# 
+# Example 1:
+# 
+# 
+# Input: candies = 7, num_people = 4
+# Output: [1,2,3,1]
+# Explanation:
+# On the first turn, ans[0] += 1, and the array is [1,0,0,0].
+# On the second turn, ans[1] += 2, and the array is [1,2,0,0].
+# On the third turn, ans[2] += 3, and the array is [1,2,3,0].
+# On the fourth turn, ans[3] += 1 (because there is only one candy left), and
+# the final array is [1,2,3,1].
+# 
+# 
+# Example 2:
+# 
+# 
+# Input: candies = 10, num_people = 3
+# Output: [5,2,3]
+# Explanation: 
+# On the first turn, ans[0] += 1, and the array is [1,0,0].
+# On the second turn, ans[1] += 2, and the array is [1,2,0].
+# On the third turn, ans[2] += 3, and the array is [1,2,3].
+# On the fourth turn, ans[0] += 4, and the final array is [5,2,3].
+# 
+# 
+# 
+# Constraints:
+# 
+# 
+# 1 <= candies <= 10^9
+# 1 <= num_people <= 1000
+# 
+# 
+#
+
+# @lc code=start
+class Solution:
+    def distributeCandies(self, candies: int, num_people: int) -> List[int]:
+        # get how many full rounds 
+        rounds, n  =  0, num_people
+        nxtRound, addition = n*(n+1)//2, n*n
+        while candies >= nxtRound:
+            rounds += 1
+            candies -= nxtRound
+            nxtRound += addition
+        
+        # calculate the numbers after full rounds 
+        res = [0]*num_people
+        n_multiples = num_people*rounds*(rounds-1)//2
+        for i in range(num_people):
+            res[i] += n_multiples + (i+1)*rounds
+        
+        # distribute the rest
+        nxt, j = rounds*n+1, 0
+        while candies > 0:
+            if candies <= nxt:
+                res[j] += candies
+                break
+            else:
+                res[j] += nxt
+                candies -= nxt
+                nxt += 1
+                j += 1
+        return res
+# @lc code=end
+

1544.make-the-string-great.py

@@ -0,0 +1,85 @@
+#
+# @lc app=leetcode id=1544 lang=python3
+#
+# [1544] Make The String Great
+#
+# https://leetcode.com/problems/make-the-string-great/description/
+#
+# algorithms
+# Easy (54.23%)
+# Likes:    112
+# Dislikes: 16
+# Total Accepted:    13.1K
+# Total Submissions: 24.2K
+# Testcase Example:  '"leEeetcode"'
+#
+# Given a string s of lower and upper case English letters.
+# 
+# A good string is a string which doesn't have two adjacent characters s[i] and
+# s[i + 1] where:
+# 
+# 
+# 0 <= i <= s.length - 2
+# s[i] is a lower-case letter and s[i + 1] is the same letter but in upper-case
+# or vice-versa.
+# 
+# 
+# To make the string good, you can choose two adjacent characters that make the
+# string bad and remove them. You can keep doing this until the string becomes
+# good.
+# 
+# Return the string after making it good. The answer is guaranteed to be unique
+# under the given constraints.
+# 
+# Notice that an empty string is also good.
+# 
+# 
+# Example 1:
+# 
+# 
+# Input: s = "leEeetcode"
+# Output: "leetcode"
+# Explanation: In the first step, either you choose i = 1 or i = 2, both will
+# result "leEeetcode" to be reduced to "leetcode".
+# 
+# 
+# Example 2:
+# 
+# 
+# Input: s = "abBAcC"
+# Output: ""
+# Explanation: We have many possible scenarios, and all lead to the same
+# answer. For example:
+# "abBAcC" --> "aAcC" --> "cC" --> ""
+# "abBAcC" --> "abBA" --> "aA" --> ""
+# 
+# 
+# Example 3:
+# 
+# 
+# Input: s = "s"
+# Output: "s"
+# 
+# 
+# 
+# Constraints:
+# 
+# 
+# 1 <= s.length <= 100
+# s contains only lower and upper case English letters.
+# 
+#
+
+# @lc code=start
+class Solution:
+    def makeGood(self, s: str) -> str:
+        stack, diff = [], abs(ord('a')-ord('A'))
+        for l in s:
+            if stack and abs(ord(stack[-1])-ord(l)) == diff:
+                stack.pop()
+            else:
+                stack.append(l)
+        return ''.join(stack)
+
+# @lc code=end
+

1550.three-consecutive-odds.py

@@ -0,0 +1,56 @@
+#
+# @lc app=leetcode id=1550 lang=python3
+#
+# [1550] Three Consecutive Odds
+#
+# https://leetcode.com/problems/three-consecutive-odds/description/
+#
+# algorithms
+# Easy (68.73%)
+# Likes:    45
+# Dislikes: 4
+# Total Accepted:    10.7K
+# Total Submissions: 15.6K
+# Testcase Example:  '[2,6,4,1]'
+#
+# Given an integer array arr, return true if there are three consecutive odd
+# numbers in the array. Otherwise, return false.
+# 
+# Example 1:
+# 
+# 
+# Input: arr = [2,6,4,1]
+# Output: false
+# Explanation: There are no three consecutive odds.
+# 
+# 
+# Example 2:
+# 
+# 
+# Input: arr = [1,2,34,3,4,5,7,23,12]
+# Output: true
+# Explanation: [5,7,23] are three consecutive odds.
+# 
+# 
+# 
+# Constraints:
+# 
+# 
+# 1 <= arr.length <= 1000
+# 1 <= arr[i] <= 1000
+# 
+# 
+#
+
+# @lc code=start
+class Solution:
+    def threeConsecutiveOdds(self, arr: List[int]) -> bool:
+        if len(arr) < 3:
+            return False
+        
+        for i in range(2, len(arr)):
+            if arr[i-2]%2 and arr[i-1]%2 and arr[i]%2:
+                return True
+        return False
+# @lc code=end
+

575.distribute-candies.py

@@ -0,0 +1,93 @@
+#
+# @lc app=leetcode id=575 lang=python3
+#
+# [575] Distribute Candies
+#
+# https://leetcode.com/problems/distribute-candies/description/
+#
+# algorithms
+# Easy (61.28%)
+# Likes:    472
+# Dislikes: 880
+# Total Accepted:    102.5K
+# Total Submissions: 167K
+# Testcase Example:  '[1,1,2,2,3,3]'
+#
+# You have n candies, the i^th candy is of type candies[i].
+# 
+# You want to distribute the candies equally between a sister and a brother so
+# that each of them gets n / 2 candies (n is even). The sister loves to collect
+# different types of candies, so you want to give her the maximum number of
+# different types of candies.
+# 
+# Return the maximum number of different types of candies you can give to the
+# sister.
+# 
+# 
+# 
+# 
+# 
+# Example 1:
+# 
+# 
+# Input: candies = [1,1,2,2,3,3]
+# Output: 3
+# Explanation:
+# There are three different kinds of candies (1, 2 and 3), and two candies for
+# each kind.
+# Optimal distribution: The sister has candies [1,2,3] and the brother has
+# candies [1,2,3], too. 
+# The sister has three different kinds of candies. 
+# 
+# 
+# Example 2:
+# 
+# 
+# Input: candies = [1,1,2,3]
+# Output: 2
+# Explanation: For example, the sister has candies [2,3] and the brother has
+# candies [1,1]. 
+# The sister has two different kinds of candies, the brother has only one kind
+# of candies.
+# 
+# 
+# Example 3:
+# 
+# 
+# Input: candies = [1,1]
+# Output: 1
+# 
+# 
+# Example 4:
+# 
+# 
+# Input: candies = [1,11]
+# Output: 1
+# 
+# 
+# Example 5:
+# 
+# 
+# Input: candies = [2,2]
+# Output: 1
+# 
+# 
+# 
+# Constraints:
+# 
+# 
+# n == candies.length
+# 2 <= n <= 10^4
+# n is even.
+# -10^5 <= candies[i] <= 10^5
+# 
+# 
+#
+
+# @lc code=start
+class Solution:
+    def distributeCandies(self, candies: List[int]) -> int:
+        d, n = set(candies), len(candies)
+        return len(d) if len(d) < n//2 else n//2
+# @lc code=end
+