Dataset Viewer
problem_id
int64 122
5k
| question
stringlengths 50
14k
| solutions
stringlengths 12
1.21M
| input_output
stringlengths 0
871k
| difficulty
stringclasses 3
values | url
stringlengths 36
108
| starter_code
stringlengths 0
1.1k
| solutions_list
listlengths 1
990
| n_sols
int64 1
990
| non_interactive_idx
listlengths 1
929
| interaction_reason
listlengths 1
990
| requires_input()
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|
122 |
There are several cards arranged in a row, and each card has an associated number of points The points are given in the integer array cardPoints.
In one step, you can take one card from the beginning or from the end of the row. You have to take exactly k cards.
Your score is the sum of the points of the cards you have taken.
Given the integer array cardPoints and the integer k, return the maximum score you can obtain.
Example 1:
Input: cardPoints = [1,2,3,4,5,6,1], k = 3
Output: 12
Explanation: After the first step, your score will always be 1. However, choosing the rightmost card first will maximize your total score. The optimal strategy is to take the three cards on the right, giving a final score of 1 + 6 + 5 = 12.
Example 2:
Input: cardPoints = [2,2,2], k = 2
Output: 4
Explanation: Regardless of which two cards you take, your score will always be 4.
Example 3:
Input: cardPoints = [9,7,7,9,7,7,9], k = 7
Output: 55
Explanation: You have to take all the cards. Your score is the sum of points of all cards.
Example 4:
Input: cardPoints = [1,1000,1], k = 1
Output: 1
Explanation: You cannot take the card in the middle. Your best score is 1.
Example 5:
Input: cardPoints = [1,79,80,1,1,1,200,1], k = 3
Output: 202
Constraints:
1 <= cardPoints.length <= 10^5
1 <= cardPoints[i] <= 10^4
1 <= k <= cardPoints.length
|
["class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n max_score = 0\n curr_score= 0\n init_hand = cardPoints[len(cardPoints)-k:]\n max_score = sum(init_hand)\n curr_score = max_score\n for i in range(k):\n curr_score -= init_hand[i]\n curr_score += cardPoints[i]\n if curr_score > max_score:\n max_score = curr_score\n return max_score", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints) - k\n min = 0\n window = 0\n all = 0\n for i in range(n):\n window += cardPoints[i]\n all += cardPoints[i]\n min = window\n # print(all)\n\n for x in range(k):\n # print(x)\n all += cardPoints[x+n]\n window -= cardPoints[x]\n window += cardPoints[x+n]\n if window < min:\n min = window\n return all - min\n # print(all)\n # print(all-min)\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n result = curr = 0\n for i in range(-k, k):\n curr += cardPoints[i]\n if i >= 0:\n curr -= cardPoints[i - k]\n result = max(result, curr)\n return result", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n # dfs TLE\n # use sliding window instead\n # keep moving a window of size n - k along the way\n \n maxSum = sum(cardPoints)\n if len(cardPoints) <= k:\n return maxSum\n \n subSum = 0\n ans = 0\n for i in range(len(cardPoints)):\n subSum += cardPoints[i]\n \n if i + 1 >= (len(cardPoints) - k):\n ans = max(ans, maxSum - subSum)\n subSum -= cardPoints[i - (len(cardPoints) - k - 1)]\n \n return ans\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n answer = 0\n left = [0]*len(cardPoints)\n right = [0]*len(cardPoints)\n \n for i in range(len(cardPoints)) :\n if i == 0 : left[0] = cardPoints[0]\n else :\n left[i] = left[i-1] + cardPoints[i]\n \n for i in range(len(cardPoints)-1,-1,-1) :\n if i == len(cardPoints)-1 : right[-1] = cardPoints[-1]\n else :\n right[i] = right[i+1] + cardPoints[i]\n \n for i in range(k+1) :\n if i == 0 : Sum = right[-k]\n elif i == k : Sum = left[k-1]\n else : \n Sum = left[k-i-1] + right[-i]\n answer = max(answer,Sum)\n return answer ", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n size = len(cardPoints) - k\n minSum = float('inf')\n cur = 0\n left = 0\n \n for i, v in enumerate(cardPoints):\n cur += v\n if i - left + 1 > size:\n cur -= cardPoints[left]\n left += 1\n if i - left + 1 == size:\n minSum = min(minSum, cur)\n \n return sum(cardPoints) - minSum\n \n \n", "class Solution:\n def maxScore(self, points: List[int], num_cards: int) -> int:\n size = len(points) - num_cards\n min_subarray_sum = math.inf\n left = curr = 0\n for right, val in enumerate(points):\n curr += val\n if right - left + 1 > size:\n curr -= points[left]\n left += 1\n if right - left + 1 == size:\n min_subarray_sum = min(min_subarray_sum, curr)\n return sum(points) - min_subarray_sum", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints) - k\n min = 0\n window = 0\n all = 0\n for i in range(n):\n window += cardPoints[i]\n all += cardPoints[i]\n min = window\n # print(all)\n\n for x in range(k):\n # print(x)\n y = x+n\n all += cardPoints[y]\n window -= cardPoints[x]\n window += cardPoints[y]\n if window < min:\n min = window\n return all - min\n # print(all)\n # print(all-min)\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n # The Edge Case not needed here: if k > len(cardPoints) or k<=0: raise ValueErro('')\n left, right = [0], [0]\n for i in range(k):\n left.append(left[-1]+ cardPoints[i])\n right.append(right[-1] + cardPoints[len(cardPoints) -1 - i])\n \n res = 0 \n for i in range(k+1):\n \n x = left[i] + right[k-i]\n res = max(res,x)\n \n return res\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n # The Edge Case not needed here: if k > len(cardPoints) or k<=0: raise ValueErro('')\n # Your solution is O(N) and this solution is O(k)\n # Eventhough the real time is similar, O(k) is better\n left = [0] * (k+1)\n right = [0] * (k+1)\n for i in range(k):\n left[i+1] = left[i] + cardPoints[i]\n right[i+1] = right[i] + cardPoints[-i-1]\n return max(left[j]+right[k-j] for j in range(k+1))", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int: \n left_cumsum = [0]\n right_cumsum = [0]\n for p in cardPoints[:k+1]:\n left_cumsum.append(left_cumsum[-1] + p)\n for p in reversed(cardPoints[-(k+1):]):\n right_cumsum.append(right_cumsum[-1] + p)\n \n result = 0\n for i in range(k+1):\n result = max(result, left_cumsum[i] + right_cumsum[k-i])\n return result", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n left, right = [0], [0]\n for i in range(len(cardPoints)):\n left.append(left[-1]+cardPoints[i])\n right.append(right[-1]+cardPoints[-i-1])\n return max(left[i]+right[k-i] for i in range(k+1))", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n \n n = len(cardPoints)\n \n # prefix sum solution\n pre = [0]*(n+1)\n for i in range(n):\n pre[i+1] = pre[i] + cardPoints[i]\n \n max_val = -1\n \n for i in range(k+1):\n max_val = max(max_val, pre[i] + pre[n] - pre[n-k+i])\n \n return max_val\n \n# if k >= n:\n# return sum(cardPoints)\n \n# def dfs(i,j):\n# if i + (n-j-1) >= k:\n# return 0\n \n# else:\n# return max(dfs(i+1,j)+cardPoints[i], dfs(i,j-1)+cardPoints[j])\n \n# return dfs(0,n-1)\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints)\n total = sum(cardPoints)\n if n == k or n < k : return total \n remove = n - k\n ans = 0\n \n '''memo = [0]*(n+1)\n memo[0] = 0\n \n start = 0\n for i in range(0, n):\n memo[i+1] = memo[i] + cardPoints[i] \n if i-start + 1 == remove: \n ans = max(ans, total-(memo[i+1]-memo[start]))\n start = start+1'''\n curr = 0\n start = 0\n for right in range(n):\n curr += cardPoints[right]\n if right-start+1 == remove:\n ans = max(ans, total-curr)\n curr -= cardPoints[start]\n start +=1\n \n \n return ans", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n left, right = [0], [0]\n for i in range(k):\n left.append(left[-1]+ cardPoints[i])\n right.append(right[-1] + cardPoints[len(cardPoints) -1 - i])\n \n res = 0 \n for i in range(k+1):\n \n x = left[i] + right[k-i]\n res = max(res,x)\n \n return res\n \n\n# front_sum=back_sum=[0]\n# print 'cardPoints:', cardPoints\n# print 'k:', k\n# frontSum, backSum = [0], [0]\n# for n in cardPoints:\n# frontSum.append(frontSum[-1]+n)\n# print 'frontSum:', frontSum\n# for n in cardPoints[::-1]:\n# backSum.append(backSum[-1]+n)\n# print 'backSum:', backSum\n# allCombinations = [frontSum[i]+backSum[k-i] for i in range(k+1)]\n# print 'allCombinations:', allCombinations\n# return max(allCombinations)\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n min_len = len(cardPoints) - k\n curr_sum = 0\n min_val = 0\n for start in range(len(cardPoints) - min_len + 1):\n if start == 0:\n curr_sum = sum(cardPoints[start:start+min_len])\n min_val = curr_sum\n else:\n curr_sum = curr_sum - cardPoints[start - 1] + cardPoints[start+min_len-1] \n if min_val > curr_sum:\n min_val = curr_sum\n \n return sum(cardPoints) - min_val\n \n\n# front_sum=back_sum=[0]\n# print 'cardPoints:', cardPoints\n# print 'k:', k\n# frontSum, backSum = [0], [0]\n# for n in cardPoints:\n# frontSum.append(frontSum[-1]+n)\n# print 'frontSum:', frontSum\n# for n in cardPoints[::-1]:\n# backSum.append(backSum[-1]+n)\n# print 'backSum:', backSum\n# allCombinations = [frontSum[i]+backSum[k-i] for i in range(k+1)]\n# print 'allCombinations:', allCombinations\n# return max(allCombinations)\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints) - k\n min = 0\n window = 0\n all = 0\n for i in range(n):\n window += cardPoints[i]\n all += cardPoints[i]\n min = window\n print(all)\n\n for x in range(k):\n print(x)\n all += cardPoints[x+n]\n window -= cardPoints[x]\n window += cardPoints[x+n]\n if window < min:\n min = window\n return all - min\n # print(all)\n # print(all-min)\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints)\n sums = [0] * (n+1)\n for i in range(1, n+1):\n sums[i] = sums[i-1] + cardPoints[i-1]\n \n ans = float('inf')\n for i in range(k+1):\n ans = min(ans, sums[i+n-k] - sums[i])\n \n print((sums, ans))\n return sums[-1] - ans\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n s = sum(cardPoints)\n if k >= len(cardPoints):\n return s\n maxPoint = 0\n cur = 0\n j = 0\n # i-j+k == n\n n = len(cardPoints)\n for i, point in enumerate(cardPoints):\n if i-j+k > n-1:\n cur -= cardPoints[j]\n j += 1\n cur += point\n if i-j+k == n-1:\n maxPoint = max(maxPoint, s-cur)\n return maxPoint\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n # find a subarray in the middle that its sum is min, maintain n-k length\n n = len(cardPoints)\n runningsum = 0\n start = end = 0\n total = sum(cardPoints)\n minsum = float('inf')\n while end < len(cardPoints):\n runningsum += cardPoints[end]\n if end - start + 1 > n-k:\n runningsum -= cardPoints[start]\n start += 1\n if end - start + 1 == n-k:\n minsum = min(minsum, runningsum)\n end += 1\n return total-minsum\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n \n# cardLen = len(cardPoints)\n# if cardLen == k:\n# return sum(cardPoints)\n \n# dp = {}\n# def takeCard(l0, r0, k0):\n# if k0 == 1:\n# return max(cardPoints[l0], cardPoints[r0])\n# if (l0, r0, k0) in dp:\n# return dp[(l0, r0, k0)]\n \n# ans = max(cardPoints[l0] + takeCard(l0+1, r0, k0-1), cardPoints[r0] + takeCard(l0, r0-1, k0-1))\n# dp[(l0, r0, k0)] = ans\n \n# return ans\n \n# return takeCard(0, cardLen-1, k)\n cardLen = len(cardPoints)\n frontSum = [0]\n for num in cardPoints:\n frontSum.append(frontSum[-1]+ num)\n backSum = [0 for _ in range(cardLen + 1)]\n for i in range(cardLen - 1, -1, -1):\n backSum[i] = cardPoints[i] + backSum[i+1]\n ans = frontSum[k]\n for i in range(k):\n ans = max(ans, frontSum[i] + backSum[-(k-i)-1])\n return ans", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n left, right = [0], [0]\n for i in range(k):\n left.append(left[-1]+ cardPoints[i])\n right.append(right[-1] + cardPoints[len(cardPoints) -1 - i])\n print(left)\n print(right)\n res = 0 \n for i in range(k+1):\n \n x = left[i] + right[k-i]\n res = max(res,x)\n \n return res\n \n \n \n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n forwardSum = [m for m in cardPoints]\n backwardSum = cardPoints.copy()\n backwardSum.append(0)\n for c in range(1, len(cardPoints)):\n forwardSum[c] = forwardSum[c-1] + forwardSum[c]\n \n for l in range(len(cardPoints)-2, 0, -1):\n backwardSum[l] = backwardSum[l+1] + backwardSum[l]\n maximum = 0\n for i in range(k-1, -2, -1):\n if i != -1:\n maximum = max(maximum, forwardSum[i] + backwardSum[len(backwardSum)-1-(k-1-i)])\n else:\n maximum = max(maximum, backwardSum[len(backwardSum)-1-k])\n \n return maximum\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints) - k\n min = 0\n window = 0\n all = 0\n for i in range(n):\n window += cardPoints[i]\n min = window\n all = window\n # print(all)\n\n for x in range(k):\n # print(x)\n all += cardPoints[x+n]\n window -= cardPoints[x]\n window += cardPoints[x+n]\n if window < min:\n min = window\n return all - min\n # print(all)\n # print(all-min)\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n score = sum(cardPoints[:k])\n best = score\n \n for i in range(k):\n score += cardPoints[-(i+1)] - cardPoints[k-i-1]\n if score > best:\n best = score\n \n return best", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n leftsum = [0] * len(cardPoints)\n rightsum = [0] * len(cardPoints)\n n = len(cardPoints)\n leftsum[0] = cardPoints[0]\n rightsum[n-1] = cardPoints[n-1]\n for i in range(1,n):\n leftsum[i] = leftsum[i-1] + cardPoints[i]\n rightsum[n-1-i] = rightsum[n-1-i+1] + cardPoints[n-1-i]\n \n res = max(leftsum[k-1],rightsum[-(k-1+1)])\n\n \n for i in range(k-1):\n \n res = max((leftsum[i] + rightsum[-(k-i-1)]), res)\n \n return res", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n '''\n convert this into a sliding window problem\n rephrase the problem:\n find the max window of length k between cardPoints[n-k:n+k]\n [1,2,3,4,5,6]\n k = 2\n 4,5,0,1\n \n \n '''\n ans = 0\n curSum = 0\n n = len(cardPoints)\n for i in range(n-k, n+k):\n curSum += cardPoints[i%n]\n if i >= n:\n curSum -= cardPoints[(i-k)%n]\n ans = max(ans, curSum)\n return ans\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n if not cardPoints or len(cardPoints) == 0:\n return 0\n window = len(cardPoints) - k\n res = float('inf')\n s = 0\n for i in range(window):\n s += cardPoints[i]\n res = min(s, res)\n for i in range(window, len(cardPoints)):\n print(cardPoints[i],s,i)\n s -= cardPoints[i-window]\n s += cardPoints[i]\n res = min(s, res)\n return sum(cardPoints) - res", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n \n n = len(cardPoints)\n if n == k:\n return sum(cardPoints)\n \n pre, post = [0] * (n + 1), [0] * (n + 1)\n for i in range(1, n + 1):\n pre[i] = pre[i - 1] + cardPoints[i - 1]\n for i in range(1, n + 1):\n post[i] = post[i - 1] + cardPoints[n - i]\n \n best = 0\n \n # n = 7\n # k = 3\n # i = 0\n # x = 5\n # print (pre, post)\n for i in range(k + 1):\n best = max(best, pre[i] + post[k - i])\n \n return best", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n if k == len(cardPoints):\n return sum(cardPoints)\n front = [0] * k\n back = [0] * k\n front[0] = cardPoints[0]\n for i in range(1,k):\n front[i] = front[i-1] + cardPoints[i]\n \n back[0] = cardPoints[-1]\n for i in range(1,k):\n back[i] = back[i-1] + cardPoints[-1-i]\n \n max_score = 0\n print(front,back)\n for i in range(k+1):\n if i == 0:\n max_score = max(max_score,back[-1])\n # print(i,back[-1])\n elif i == k:\n max_score = max(max_score,front[k-1])\n # print(i,front[k-1])\n else:\n max_score = max(max_score,front[i-1]+back[k-i-1])\n # print(i,k-i,max_score,front[i-1]+back[k-i-1])\n # print(i,k-i,max_score)\n return max_score", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n length = len(cardPoints)\n total = sum(cardPoints)\n if k == length:\n return total\n curr = 0\n temp = 2 ** 31 - 1\n left = 0\n for right in range(length):\n curr += cardPoints[right]\n if right - left + 1 < length - k:\n continue\n print(right, curr)\n temp = min(temp, curr)\n curr -= cardPoints[left]\n left += 1\n \n return total - temp", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints)\n \n cum_sum = [0 for i in range(n)]\n cum_sum[0] = cardPoints[0]\n rev_sum = [0 for i in range(n)]\n rev_sum[0] = cardPoints[-1]\n \n \n for i in range(1,n):\n cum_sum[i] = cum_sum[i-1]+cardPoints[i]\n rev_sum[i] = rev_sum[i-1]+cardPoints[n-i-1]\n \n max_sum = max(cum_sum[k-1],rev_sum[k-1])\n \n for i in range(1,k):\n max_sum = max(max_sum,(cum_sum[i-1]+rev_sum[k-i-1]))\n \n return max_sum\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n remainCnt = len(cardPoints) - k\n if remainCnt == 0: return sum(cardPoints)\n minRemainSum = float('inf')\n curr = 0\n cnt = 0\n for i in range(len(cardPoints)):\n cnt += 1\n curr += cardPoints[i]\n if cnt == remainCnt:\n minRemainSum = min(minRemainSum, curr)\n curr -= cardPoints[i + 1 - cnt]\n cnt -= 1\n \n return sum(cardPoints) - minRemainSum\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n # Sliding window of length k\n ans = total = sum(cardPoints[:k])\n for i in range(1, k+1):\n total -= cardPoints[k-i]\n total += cardPoints[-1-i+1]\n ans = max(ans, total)\n return ans\n", "from collections import deque\nclass Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n first = deque(cardPoints[0:k])\n second = deque(cardPoints[len(cardPoints)-k:])\n final = 0\n \n firstSum = sum(first)\n secondSum = sum(second)\n \n for i in range(k):\n if firstSum > secondSum:\n final += first[0]\n firstSum -= first.popleft()\n secondSum -= second.popleft()\n \n else:\n final += second[len(second)-1]\n firstSum -= first.pop()\n secondSum -= second.pop()\n\n return final", "class Solution:\n def maxScore(self, cardPoints, k: int) -> int:\n N = len(cardPoints)\n preS, afterS = [0]*(N+1), [0]*(N+1)\n ans = 0\n for i in range(1,N+1):\n preS[i]=preS[i-1]+cardPoints[i-1]\n for j in range(1,N+1):\n afterS[j] = afterS[j-1]+cardPoints[N-j]\n for l in range(k+1):\n ans = max(ans,preS[l]+afterS[k-l])\n return ans", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n right_index = len(cardPoints)-k\n curr_max = sum(cardPoints[right_index:])\n curr_sum = curr_max\n for left_index in range(0, k):\n curr_sum -= cardPoints[right_index]\n right_index += 1\n curr_sum += cardPoints[left_index]\n if curr_sum > curr_max:\n curr_max = curr_sum\n return curr_max\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n \n n = len(cardPoints)\n \n cum_sum = [0 for i in range(n)]\n cum_sum[0] = cardPoints[0]\n rev_sum = [0 for i in range(n)]\n rev_sum[0] = cardPoints[-1]\n \n \n for i in range(1,n):\n cum_sum[i] = cum_sum[i-1]+cardPoints[i]\n rev_sum[i] = rev_sum[i-1]+cardPoints[n-i-1]\n \n max_sum = max(cum_sum[k-1],rev_sum[k-1])\n \n for i in range(1,k):\n max_sum = max(max_sum,(cum_sum[i-1]+rev_sum[k-i-1]))\n \n return max_sum", "class Solution:\n def maxScore(self, A: List[int], k: int) -> int: \n su = sum(A[:k])\n n = len(A) \n res = su \n for i in range(k):\n su -= A[k-i-1]\n su += A[n-i-1]\n res = max(res, su) \n return res", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n # sum of points from left most\n # sum of points from right most\n # sum of points from both left and right\n \n # defualt max_sum\n total = sum(cardPoints[:k])\n \n # if k == len(cardPoitns), result is the total sum of cardPoints\n if k == len(cardPoints):\n return total\n max_sum = total\n print(max_sum)\n \n # compute sum from left to right\n for i in range(k - 1, -1, -1):\n total = total + cardPoints[i - k] - cardPoints[i]\n print((i-k, total, cardPoints[i - k], cardPoints[i]))\n if total > max_sum:\n max_sum = total\n return max_sum\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n j = len(cardPoints) - 1\n ms = 0\n \n for i in range(k):\n ms += cardPoints[j]\n j -= 1\n \n cand = ms\n \n for i in range(k):\n cand += cardPoints[i] - cardPoints[j+1]\n j += 1\n ms = max(cand, ms)\n \n return ms", "class Solution:\n def maxScore(self, nums: List[int], k: int) -> int:\n \n n = len(nums)\n\n if k == n:\n return sum(nums)\n \n pre =[0]\n post = []\n \n for e in nums:\n pre.append(pre[-1]+e)\n post.append(e)\n post.append(0)\n \n \n for i in range(n-1,-1,-1):\n post[i] = post[i+1] + nums[i]\n \n res = 0\n j = n - k\n \n while j <= n:\n res = max(res, pre[i] + post[j])\n \n i+=1\n j+=1\n \n return res", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n if len(cardPoints) < k:\n return -1\n \n remain = len(cardPoints) - k\n suum = sum(cardPoints[:remain])\n min_suum = suum\n for i in range(remain, len(cardPoints)):\n suum = suum - cardPoints[i-remain] + cardPoints[i]\n min_suum = min(min_suum, suum)\n return sum(cardPoints) - min_suum", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints)\n sums = [0] * (n+1)\n for i in range(1, n+1):\n sums[i] = sums[i-1] + cardPoints[i-1]\n \n ans = float('inf')\n for i in range(k+1):\n ans = min(ans, sums[i+n-k] - sums[i])\n \n return sums[-1] - ans\n", "class Solution:\n def maxScore(self, A: List[int], k: int) -> int: \n su = sum(A[:k])\n res = su \n for i in range(k):\n su -= A[k-i-1]\n su += A[len(A)-i-1]\n res = max(res, su) \n return res", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints) - k\n l, r, res, count = 0, 0, sum(cardPoints[:n]), 0\n while r < len(cardPoints):\n count += cardPoints[r]\n if r >= n:\n count -= cardPoints[l]\n l += 1\n res = min(res, count)\n r += 1\n return sum(cardPoints) - res", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n pre = [cardPoints[0]]\n n = len(cardPoints)\n for i in range(1, n):\n pre.append(pre[-1] + cardPoints[i])\n \n if k == n:\n return pre[-1]\n \n s = pre[-1]\n cur_s = pre[n - k - 1]\n l = 0\n r = n - k + l - 1\n ans = s - pre[n - k - 1]\n \n while l != len(cardPoints) - (n - k) :\n cur_s -= cardPoints[l]\n l += 1\n r += 1\n cur_s += cardPoints[r]\n ans = max(ans, s - cur_s)\n \n return ans\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints) - k\n current = 0\n for i in range(n):\n current += cardPoints[i]\n result = current\n \n for i in range(1, k+1):\n current -= cardPoints[i-1]\n current += cardPoints[i+n-1]\n result = min(result, current)\n \n return sum(cardPoints) - result\n \n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n f, b = [0], [0]\n for n in cardPoints:\n f.append(f[-1] + n)\n for n in cardPoints[::-1]:\n b.append(b[-1] + n)\n allCombo = [f[i] + b[k-i] for i in range(k+1)]\n return max(allCombo)\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n \n points_L = []\n points_R = []\n \n for p in cardPoints:\n if len(points_L): points_L.append(points_L[-1] + p)\n else: points_L.append(p)\n for p in cardPoints[::-1]:\n if len(points_R): points_R.append(points_R[-1] + p)\n else: points_R.append(p)\n points_R = points_R[::-1]\n \n return self.solution(points_L, points_R, k)\n \n\n def solution(self, points_L, points_R, k):\n max = 0\n for i in range(k+1):\n cmp1 = points_L[i-1] if i > 0 else 0\n cmp2 = points_R[-(k-i)] if i < k else 0\n score = cmp1 + cmp2\n if score > max:\n max = score\n return max\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n left_sums = [0] * (k + 1)\n right_sums = [0] * (k + 1)\n \n \n for i in range(k):\n left_sums[i+1] = left_sums[i] + cardPoints[i]\n right_sums[i+1] = right_sums[i] + cardPoints[len(cardPoints)-i-1]\n \n\n res = 0\n for i in range(k+1): # we must include K as a choice\n j = k-i\n res = max(res, left_sums[i] + right_sums[j])\n \n return res\n", "from functools import lru_cache\nimport sys\nfrom itertools import accumulate\n\nsys.setrecursionlimit(10**5)\n\n\nclass Solution:\n def maxScore(self, arr: List[int], k: int) -> int:\n\n n = len(arr)\n pre = list(accumulate(arr))\n total = pre[-1]\n # print(f'{pre=}')\n \n if k == n:\n return total\n \n w = n-k\n result = 0 \n # print(f'{w=}')\n \n for i in range(w-1, n):\n # print(f'{i=}')\n sub_sum = total - (pre[i] - pre[i-w+1] + arr[i-w+1])\n result = max(result, sub_sum)\n \n \n return result", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n curr_max = sum(cardPoints[0:k])\n curr_sum = curr_max\n for i in range(1, k+1):\n curr_sum = curr_sum - cardPoints[k-i] + cardPoints[-i]\n curr_max = max(curr_max, curr_sum)\n return curr_max\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n size = len(cardPoints)\n maxRightSum = sum(cardPoints[size-k:])\n ans = maxRightSum\n currSum = maxRightSum\n # sum with left\n for i in range(k):\n currSum = currSum - cardPoints[size-k+i] + cardPoints[i]\n ans = max(ans, currSum)\n return ans\n # def maxScore(self, cardPoints: List[int], k: int) -> int:\n # windowEnd = 0\n # size = len(cardPoints) - k\n # ans = float(\\\"inf\\\")\n # currSum = 0\n # for windowStart, point in enumerate(cardPoints):\n # currSum += point\n # if windowStart - windowEnd + 1 > size:\n # currSum -= cardPoints[windowEnd]\n # windowEnd += 1\n # if windowStart - windowEnd + 1 == size:\n # ans = min(ans, currSum)\n # return sum(cardPoints) - ans\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints)\n curr_max = sum(cardPoints[0:k])\n curr_sum = curr_max\n for i in range(1, k+1):\n curr_sum = curr_sum - cardPoints[k-i] + cardPoints[-i]\n curr_max = max(curr_max, curr_sum)\n return curr_max\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n totalPoints, window = sum(cardPoints), len(cardPoints) - k\n i, j, Sum, Min = 0, 0, 0, totalPoints\n \n while j < len(cardPoints):\n Sum += cardPoints[j]\n \n if j - i + 1 > window:\n Sum -= cardPoints[i]\n i += 1\n \n if j - i + 1 == window: Min = min(Min, Sum)\n j += 1\n \n # print(Min)\n return totalPoints - Min\n \n \n \n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n if len(cardPoints) < k:\n return 0\n if len(cardPoints) == k:\n return sum(cardPoints)\n n = len(cardPoints)\n res, cur = sum(cardPoints[:k]), sum(cardPoints[:k])\n for i in range(k):\n cur += cardPoints[n-i-1]-cardPoints[k-1-i]\n res = max(res, cur)\n return res", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n if not cardPoints or k==0:\n return 0\n for i in range(1,len(cardPoints)):\n cardPoints[i]+=cardPoints[i-1]\n \n if k==len(cardPoints):\n return cardPoints[-1]\n ans=cardPoints[k-1]\n \n for i in range(1,k+1):\n print(i)\n ans=max(ans,cardPoints[k-i]+cardPoints[-1]-cardPoints[-i])\n print(cardPoints[k-i],cardPoints[-1]-cardPoints[-i])\n return max(ans,cardPoints[-1]-cardPoints[-(k+1)])", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints)\n left = n - k\n mini = sum(cardPoints[:left])\n cur = mini\n for i in range(left, n):\n cur = cur - cardPoints[i-left] + cardPoints[i]\n mini = min(mini, cur)\n \n return sum(cardPoints) - mini", "class Solution:\n def maxScore(self, card_points: List[int], k: int) -> int:\n window_size = len(card_points) - k\n current_min_sum, min_sum = 0, sys.maxsize\n total_points = 0\n left = 0\n for right, value in enumerate(card_points):\n total_points += value\n current_min_sum += value\n\n current_size = right - left + 1\n if current_size < window_size:\n continue\n\n if current_size > window_size:\n current_min_sum -= card_points[left]\n left += 1\n\n min_sum = min(min_sum, current_min_sum)\n\n return total_points - min_sum\n", "def max_score_using_subsequence(card_points, k):\n l = len(card_points) - k\n if l == 0:\n return sum(card_points)\n \n sum_subsequence = 0\n for i in range(l):\n sum_subsequence += card_points[i]\n \n lowest = sum_subsequence\n for i in range(len(card_points) - l):\n sum_subsequence = sum_subsequence - card_points[i] + card_points[i+l]\n if sum_subsequence < lowest:\n lowest = sum_subsequence\n \n return sum(card_points) - lowest\n \n\nclass Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n # return max_score_recursive(cardPoints, k, 0, len(cardPoints)-1, {})\n return max_score_using_subsequence(cardPoints, k)", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n psum = sum(cardPoints[:k])\n res = psum\n n = len(cardPoints)\n for i in range(k):\n psum += cardPoints[n - i - 1] - cardPoints[k - i - 1]\n res = max(res, psum)\n return res\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n pre_sum = [] # i: sum of all items before i\n temp_left = 0\n for i, v in enumerate(cardPoints):\n pre_sum.append(temp_left)\n temp_left += v\n pre_sum.append(temp_left)\n \n post_sum = [] # i: sum of all items after i-1\n temp_right = 0\n temp_right = 0\n for i in range(len(cardPoints)-1, -1, -1):\n v = cardPoints[i]\n post_sum.append(temp_right)\n temp_right += v\n post_sum.append(v)\n post_sum.reverse()\n # print(pre_sum)\n # print(post_sum)\n return max([pre_sum[i] + post_sum[-(k-i)-1] for i in range(k+1)])\n \n \n \n\n", "from collections import deque\nclass Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints)\n cards = n-k\n minimum = 0\n if (cards != 0):\n sum1 = 0\n q = deque()\n for i in range(cards):\n q.append(cardPoints[i])\n sum1 += cardPoints[i]\n minimum = sum1\n for i in range(cards, n):\n first = q.popleft()\n q.append(cardPoints[i])\n sum1 -=first\n sum1 += cardPoints[i]\n if (sum1 < minimum):\n minimum = sum1\n #else:\n # minimum = 0\n print(minimum)\n return sum(cardPoints) - minimum\n", "class Solution:\n def maxScore(self, l: List[int], k: int) -> int:\n length = len(l)\n \n if k == length:\n return sum(l)\n elif k == 0:\n return 0\n \n k = length - k\n v = curr_min = sum(l[:k])\n \n for i in range(k,length):\n v = v - l[i-k] + l[i]\n curr_min = min(curr_min, v)\n \n return sum(l) - curr_min\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n if k == len(cardPoints):\n return sum(cardPoints)\n size = len(cardPoints) - k\n min_sum = float('inf')\n left = 0\n right = 0\n window_sum = 0\n while right < len(cardPoints):\n window_sum += cardPoints[right]\n right += 1\n while right - left == size:\n min_sum = min(min_sum, window_sum)\n window_sum -= cardPoints[left]\n left += 1\n return sum(cardPoints) - min_sum\n", "class Solution:\n def maxScore(self, p: List[int], k: int) -> int:\n res = sum(p[:k])\n cur = res\n \n for i in range(1, k+1):\n cur += p[-i] - p[k-i]\n res = max(cur, res)\n \n return res\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n # Time: O(k)\n # Space: O(1)\n ans = win = 0\n for i in range(-k, k):\n win += cardPoints[i]\n if i >= 0:\n win -= cardPoints[i - k]\n #print(i, i-k, ans, win, cardPoints[i] ) \n ans = max(win, ans) \n return ans\n \n \n", "# O(n) time and O(1) space\n# alternative dp solution O(k) space: form two k sized arrays: 1 to k and n-k to n\n# https://www.youtube.com/watch?v=t3JHx5J01F0 9mins06s\nclass Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n curr_max = sum(cardPoints[:k])\n ans = curr_max\n for i in range(1, k+1):\n curr_max += cardPoints[-i] - cardPoints[k-i]\n ans = max(ans, curr_max)\n return ans\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints)\n w = n - k\n left, right = 0, w - 1\n ans = float('-inf')\n \n win_sum = sum(cardPoints[:w])\n total = sum(cardPoints)\n while right < n:\n sub = total - win_sum\n ans = max(sub, ans)\n if left < n:\n win_sum -= cardPoints[left]\n left += 1\n right += 1\n if right < n:\n win_sum += cardPoints[right]\n\n return ans\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n# \u6211\u5199\u7684\u8fd8\u662f\u592a\u590d\u6742\u4e86\n# if not cardPoints or not k:\n# return 0\n# if k==len(cardPoints):\n# return sum(cardPoints)\n \n# front={0:0}\n# back={0:0}\n# total=0\n# for i in range(k):\n# total+=cardPoints[i]\n# front[i+1]=total\n# total=0\n# for i in range(-1,-k-1,-1):\n# total+=cardPoints[i]\n# back[-i]=total\n \n# maxres=float('-inf')\n# for i in range(k+1):\n# maxres=max(maxres,front[i]+back[k-i])\n \n# return maxres\n s = sum(cardPoints[:k])\n res = s\n for i in range(1, k+1):\n s += cardPoints[-i] - cardPoints[k-i]\n res = max(res, s)\n return res\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n left, right = [0], [0]\n for i in range(k):\n left.append(left[-1] + cardPoints[i])\n right.append(right[-1] + cardPoints[len(cardPoints) - 1 - i])\n # print(left, right)\n maxSoFar = 0\n for i in range(k + 1):\n if left[i] + right[k - i] > maxSoFar:\n maxSoFar = left[i] + right[k - i]\n return maxSoFar\n \n", "class Solution:\n def maxScore(self, p: List[int], k: int) -> int:\n s = sum(p)\n if k == len(p): return s\n n = len(p)\n for i in range(1, len(p)): p[i] += p[i-1]\n\n return s - min(p[n+i-k-1] - (p[i-1] if i else 0) for i in range(k+1))\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n score = 0\n l = k\n prefix = [0]\n for i in range(len(cardPoints)):\n prefix.append(prefix[-1] + cardPoints[i])\n for i in range(k+1):\n score = max(score, prefix[l] + prefix[-1] - prefix[-1-i])\n l -= 1\n return score", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n right_index = len(cardPoints)-k\n curr_max = sum(cardPoints[right_index:])\n curr_sum = curr_max\n for left_index, right_index in zip(list(range(0, k)), list(range(len(cardPoints)-k, len(cardPoints)))):\n print((left_index, right_index))\n curr_sum -= cardPoints[right_index]\n curr_sum += cardPoints[left_index]\n curr_max = max(curr_max, curr_sum)\n return curr_max\n", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int: \n sub_len = len(cardPoints) - k\n localSum = 0\n localSum = sum(cardPoints[0: sub_len])\n localMin = localSum\n for i in range(sub_len, len(cardPoints)):\n localSum += cardPoints[i]\n localSum -= cardPoints[i - sub_len]\n localMin = min(localSum, localMin)\n return sum(cardPoints) - localMin", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n points = cardPoints[-k:] + cardPoints[:k]\n curr = 0\n max_ = 0\n for ind, score in enumerate(points):\n if ind >= k:\n curr -= points[ind-k]\n curr += score\n max_ = max(max_, curr)\n return max_", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n \n total = sum(cardPoints)\n \n nk = len(cardPoints) - k\n \n if nk == 0:\n return total\n \n current = sum(cardPoints[0:nk])\n max_score = current\n \n for i in range(1, k + 1):\n current = current - cardPoints[i - 1] + cardPoints[nk + i - 1]\n \n max_score = min(max_score, current)\n \n return total - max_score", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n \n total = [0 for _ in range(len(cardPoints))]\n total[0] = cardPoints[0]\n \n for i in range(1, len(cardPoints)):\n total[i] = total[i-1] + cardPoints[i]\n \n max_sum = 0\n for i in range(k+1):\n left = total[k-i-1] if k-i > 0 else 0\n right = total[-1] - total[len(cardPoints)-i-1]\n if left + right > max_sum:\n max_sum = left + right\n \n return max_sum", "class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n N = len(cardPoints)\n res = float('inf')\n run = 0\n for i, p in enumerate(cardPoints):\n if i >= N-k: run -= cardPoints[i-N+k]\n run += p\n if i >= N-k-1: res = min(res, run)\n return sum(cardPoints) - res"]
|
{"fn_name": "maxScore", "inputs": [[[1, 2, 3, 4, 5, 6, 1], 3]], "outputs": [12]}
|
interview
|
https://leetcode.com/problems/maximum-points-you-can-obtain-from-cards/
|
class Solution:
def maxScore(self, cardPoints: List[int], k: int) -> int:
|
[
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n max_score = 0\n curr_score= 0\n init_hand = cardPoints[len(cardPoints)-k:]\n max_score = sum(init_hand)\n curr_score = max_score\n for i in range(k):\n curr_score -= init_hand[i]\n curr_score += cardPoints[i]\n if curr_score > max_score:\n max_score = curr_score\n return max_score",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints) - k\n min = 0\n window = 0\n all = 0\n for i in range(n):\n window += cardPoints[i]\n all += cardPoints[i]\n min = window\n # print(all)\n\n for x in range(k):\n # print(x)\n all += cardPoints[x+n]\n window -= cardPoints[x]\n window += cardPoints[x+n]\n if window < min:\n min = window\n return all - min\n # print(all)\n # print(all-min)\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n result = curr = 0\n for i in range(-k, k):\n curr += cardPoints[i]\n if i >= 0:\n curr -= cardPoints[i - k]\n result = max(result, curr)\n return result",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n # dfs TLE\n # use sliding window instead\n # keep moving a window of size n - k along the way\n \n maxSum = sum(cardPoints)\n if len(cardPoints) <= k:\n return maxSum\n \n subSum = 0\n ans = 0\n for i in range(len(cardPoints)):\n subSum += cardPoints[i]\n \n if i + 1 >= (len(cardPoints) - k):\n ans = max(ans, maxSum - subSum)\n subSum -= cardPoints[i - (len(cardPoints) - k - 1)]\n \n return ans\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n answer = 0\n left = [0]*len(cardPoints)\n right = [0]*len(cardPoints)\n \n for i in range(len(cardPoints)) :\n if i == 0 : left[0] = cardPoints[0]\n else :\n left[i] = left[i-1] + cardPoints[i]\n \n for i in range(len(cardPoints)-1,-1,-1) :\n if i == len(cardPoints)-1 : right[-1] = cardPoints[-1]\n else :\n right[i] = right[i+1] + cardPoints[i]\n \n for i in range(k+1) :\n if i == 0 : Sum = right[-k]\n elif i == k : Sum = left[k-1]\n else : \n Sum = left[k-i-1] + right[-i]\n answer = max(answer,Sum)\n return answer ",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n size = len(cardPoints) - k\n minSum = float('inf')\n cur = 0\n left = 0\n \n for i, v in enumerate(cardPoints):\n cur += v\n if i - left + 1 > size:\n cur -= cardPoints[left]\n left += 1\n if i - left + 1 == size:\n minSum = min(minSum, cur)\n \n return sum(cardPoints) - minSum\n \n \n",
"class Solution:\n def maxScore(self, points: List[int], num_cards: int) -> int:\n size = len(points) - num_cards\n min_subarray_sum = math.inf\n left = curr = 0\n for right, val in enumerate(points):\n curr += val\n if right - left + 1 > size:\n curr -= points[left]\n left += 1\n if right - left + 1 == size:\n min_subarray_sum = min(min_subarray_sum, curr)\n return sum(points) - min_subarray_sum",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints) - k\n min = 0\n window = 0\n all = 0\n for i in range(n):\n window += cardPoints[i]\n all += cardPoints[i]\n min = window\n # print(all)\n\n for x in range(k):\n # print(x)\n y = x+n\n all += cardPoints[y]\n window -= cardPoints[x]\n window += cardPoints[y]\n if window < min:\n min = window\n return all - min\n # print(all)\n # print(all-min)\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n # The Edge Case not needed here: if k > len(cardPoints) or k<=0: raise ValueErro('')\n left, right = [0], [0]\n for i in range(k):\n left.append(left[-1]+ cardPoints[i])\n right.append(right[-1] + cardPoints[len(cardPoints) -1 - i])\n \n res = 0 \n for i in range(k+1):\n \n x = left[i] + right[k-i]\n res = max(res,x)\n \n return res\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n # The Edge Case not needed here: if k > len(cardPoints) or k<=0: raise ValueErro('')\n # Your solution is O(N) and this solution is O(k)\n # Eventhough the real time is similar, O(k) is better\n left = [0] * (k+1)\n right = [0] * (k+1)\n for i in range(k):\n left[i+1] = left[i] + cardPoints[i]\n right[i+1] = right[i] + cardPoints[-i-1]\n return max(left[j]+right[k-j] for j in range(k+1))",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int: \n left_cumsum = [0]\n right_cumsum = [0]\n for p in cardPoints[:k+1]:\n left_cumsum.append(left_cumsum[-1] + p)\n for p in reversed(cardPoints[-(k+1):]):\n right_cumsum.append(right_cumsum[-1] + p)\n \n result = 0\n for i in range(k+1):\n result = max(result, left_cumsum[i] + right_cumsum[k-i])\n return result",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n left, right = [0], [0]\n for i in range(len(cardPoints)):\n left.append(left[-1]+cardPoints[i])\n right.append(right[-1]+cardPoints[-i-1])\n return max(left[i]+right[k-i] for i in range(k+1))",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n \n n = len(cardPoints)\n \n # prefix sum solution\n pre = [0]*(n+1)\n for i in range(n):\n pre[i+1] = pre[i] + cardPoints[i]\n \n max_val = -1\n \n for i in range(k+1):\n max_val = max(max_val, pre[i] + pre[n] - pre[n-k+i])\n \n return max_val\n \n# if k >= n:\n# return sum(cardPoints)\n \n# def dfs(i,j):\n# if i + (n-j-1) >= k:\n# return 0\n \n# else:\n# return max(dfs(i+1,j)+cardPoints[i], dfs(i,j-1)+cardPoints[j])\n \n# return dfs(0,n-1)\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints)\n total = sum(cardPoints)\n if n == k or n < k : return total \n remove = n - k\n ans = 0\n \n '''memo = [0]*(n+1)\n memo[0] = 0\n \n start = 0\n for i in range(0, n):\n memo[i+1] = memo[i] + cardPoints[i] \n if i-start + 1 == remove: \n ans = max(ans, total-(memo[i+1]-memo[start]))\n start = start+1'''\n curr = 0\n start = 0\n for right in range(n):\n curr += cardPoints[right]\n if right-start+1 == remove:\n ans = max(ans, total-curr)\n curr -= cardPoints[start]\n start +=1\n \n \n return ans",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n left, right = [0], [0]\n for i in range(k):\n left.append(left[-1]+ cardPoints[i])\n right.append(right[-1] + cardPoints[len(cardPoints) -1 - i])\n \n res = 0 \n for i in range(k+1):\n \n x = left[i] + right[k-i]\n res = max(res,x)\n \n return res\n \n\n# front_sum=back_sum=[0]\n# print 'cardPoints:', cardPoints\n# print 'k:', k\n# frontSum, backSum = [0], [0]\n# for n in cardPoints:\n# frontSum.append(frontSum[-1]+n)\n# print 'frontSum:', frontSum\n# for n in cardPoints[::-1]:\n# backSum.append(backSum[-1]+n)\n# print 'backSum:', backSum\n# allCombinations = [frontSum[i]+backSum[k-i] for i in range(k+1)]\n# print 'allCombinations:', allCombinations\n# return max(allCombinations)\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n min_len = len(cardPoints) - k\n curr_sum = 0\n min_val = 0\n for start in range(len(cardPoints) - min_len + 1):\n if start == 0:\n curr_sum = sum(cardPoints[start:start+min_len])\n min_val = curr_sum\n else:\n curr_sum = curr_sum - cardPoints[start - 1] + cardPoints[start+min_len-1] \n if min_val > curr_sum:\n min_val = curr_sum\n \n return sum(cardPoints) - min_val\n \n\n# front_sum=back_sum=[0]\n# print 'cardPoints:', cardPoints\n# print 'k:', k\n# frontSum, backSum = [0], [0]\n# for n in cardPoints:\n# frontSum.append(frontSum[-1]+n)\n# print 'frontSum:', frontSum\n# for n in cardPoints[::-1]:\n# backSum.append(backSum[-1]+n)\n# print 'backSum:', backSum\n# allCombinations = [frontSum[i]+backSum[k-i] for i in range(k+1)]\n# print 'allCombinations:', allCombinations\n# return max(allCombinations)\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints) - k\n min = 0\n window = 0\n all = 0\n for i in range(n):\n window += cardPoints[i]\n all += cardPoints[i]\n min = window\n print(all)\n\n for x in range(k):\n print(x)\n all += cardPoints[x+n]\n window -= cardPoints[x]\n window += cardPoints[x+n]\n if window < min:\n min = window\n return all - min\n # print(all)\n # print(all-min)\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints)\n sums = [0] * (n+1)\n for i in range(1, n+1):\n sums[i] = sums[i-1] + cardPoints[i-1]\n \n ans = float('inf')\n for i in range(k+1):\n ans = min(ans, sums[i+n-k] - sums[i])\n \n print((sums, ans))\n return sums[-1] - ans\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n s = sum(cardPoints)\n if k >= len(cardPoints):\n return s\n maxPoint = 0\n cur = 0\n j = 0\n # i-j+k == n\n n = len(cardPoints)\n for i, point in enumerate(cardPoints):\n if i-j+k > n-1:\n cur -= cardPoints[j]\n j += 1\n cur += point\n if i-j+k == n-1:\n maxPoint = max(maxPoint, s-cur)\n return maxPoint\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n # find a subarray in the middle that its sum is min, maintain n-k length\n n = len(cardPoints)\n runningsum = 0\n start = end = 0\n total = sum(cardPoints)\n minsum = float('inf')\n while end < len(cardPoints):\n runningsum += cardPoints[end]\n if end - start + 1 > n-k:\n runningsum -= cardPoints[start]\n start += 1\n if end - start + 1 == n-k:\n minsum = min(minsum, runningsum)\n end += 1\n return total-minsum\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n \n# cardLen = len(cardPoints)\n# if cardLen == k:\n# return sum(cardPoints)\n \n# dp = {}\n# def takeCard(l0, r0, k0):\n# if k0 == 1:\n# return max(cardPoints[l0], cardPoints[r0])\n# if (l0, r0, k0) in dp:\n# return dp[(l0, r0, k0)]\n \n# ans = max(cardPoints[l0] + takeCard(l0+1, r0, k0-1), cardPoints[r0] + takeCard(l0, r0-1, k0-1))\n# dp[(l0, r0, k0)] = ans\n \n# return ans\n \n# return takeCard(0, cardLen-1, k)\n cardLen = len(cardPoints)\n frontSum = [0]\n for num in cardPoints:\n frontSum.append(frontSum[-1]+ num)\n backSum = [0 for _ in range(cardLen + 1)]\n for i in range(cardLen - 1, -1, -1):\n backSum[i] = cardPoints[i] + backSum[i+1]\n ans = frontSum[k]\n for i in range(k):\n ans = max(ans, frontSum[i] + backSum[-(k-i)-1])\n return ans",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n left, right = [0], [0]\n for i in range(k):\n left.append(left[-1]+ cardPoints[i])\n right.append(right[-1] + cardPoints[len(cardPoints) -1 - i])\n print(left)\n print(right)\n res = 0 \n for i in range(k+1):\n \n x = left[i] + right[k-i]\n res = max(res,x)\n \n return res\n \n \n \n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n forwardSum = [m for m in cardPoints]\n backwardSum = cardPoints.copy()\n backwardSum.append(0)\n for c in range(1, len(cardPoints)):\n forwardSum[c] = forwardSum[c-1] + forwardSum[c]\n \n for l in range(len(cardPoints)-2, 0, -1):\n backwardSum[l] = backwardSum[l+1] + backwardSum[l]\n maximum = 0\n for i in range(k-1, -2, -1):\n if i != -1:\n maximum = max(maximum, forwardSum[i] + backwardSum[len(backwardSum)-1-(k-1-i)])\n else:\n maximum = max(maximum, backwardSum[len(backwardSum)-1-k])\n \n return maximum\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints) - k\n min = 0\n window = 0\n all = 0\n for i in range(n):\n window += cardPoints[i]\n min = window\n all = window\n # print(all)\n\n for x in range(k):\n # print(x)\n all += cardPoints[x+n]\n window -= cardPoints[x]\n window += cardPoints[x+n]\n if window < min:\n min = window\n return all - min\n # print(all)\n # print(all-min)\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n score = sum(cardPoints[:k])\n best = score\n \n for i in range(k):\n score += cardPoints[-(i+1)] - cardPoints[k-i-1]\n if score > best:\n best = score\n \n return best",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n leftsum = [0] * len(cardPoints)\n rightsum = [0] * len(cardPoints)\n n = len(cardPoints)\n leftsum[0] = cardPoints[0]\n rightsum[n-1] = cardPoints[n-1]\n for i in range(1,n):\n leftsum[i] = leftsum[i-1] + cardPoints[i]\n rightsum[n-1-i] = rightsum[n-1-i+1] + cardPoints[n-1-i]\n \n res = max(leftsum[k-1],rightsum[-(k-1+1)])\n\n \n for i in range(k-1):\n \n res = max((leftsum[i] + rightsum[-(k-i-1)]), res)\n \n return res",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n '''\n convert this into a sliding window problem\n rephrase the problem:\n find the max window of length k between cardPoints[n-k:n+k]\n [1,2,3,4,5,6]\n k = 2\n 4,5,0,1\n \n \n '''\n ans = 0\n curSum = 0\n n = len(cardPoints)\n for i in range(n-k, n+k):\n curSum += cardPoints[i%n]\n if i >= n:\n curSum -= cardPoints[(i-k)%n]\n ans = max(ans, curSum)\n return ans\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n if not cardPoints or len(cardPoints) == 0:\n return 0\n window = len(cardPoints) - k\n res = float('inf')\n s = 0\n for i in range(window):\n s += cardPoints[i]\n res = min(s, res)\n for i in range(window, len(cardPoints)):\n print(cardPoints[i],s,i)\n s -= cardPoints[i-window]\n s += cardPoints[i]\n res = min(s, res)\n return sum(cardPoints) - res",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n \n n = len(cardPoints)\n if n == k:\n return sum(cardPoints)\n \n pre, post = [0] * (n + 1), [0] * (n + 1)\n for i in range(1, n + 1):\n pre[i] = pre[i - 1] + cardPoints[i - 1]\n for i in range(1, n + 1):\n post[i] = post[i - 1] + cardPoints[n - i]\n \n best = 0\n \n # n = 7\n # k = 3\n # i = 0\n # x = 5\n # print (pre, post)\n for i in range(k + 1):\n best = max(best, pre[i] + post[k - i])\n \n return best",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n if k == len(cardPoints):\n return sum(cardPoints)\n front = [0] * k\n back = [0] * k\n front[0] = cardPoints[0]\n for i in range(1,k):\n front[i] = front[i-1] + cardPoints[i]\n \n back[0] = cardPoints[-1]\n for i in range(1,k):\n back[i] = back[i-1] + cardPoints[-1-i]\n \n max_score = 0\n print(front,back)\n for i in range(k+1):\n if i == 0:\n max_score = max(max_score,back[-1])\n # print(i,back[-1])\n elif i == k:\n max_score = max(max_score,front[k-1])\n # print(i,front[k-1])\n else:\n max_score = max(max_score,front[i-1]+back[k-i-1])\n # print(i,k-i,max_score,front[i-1]+back[k-i-1])\n # print(i,k-i,max_score)\n return max_score",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n length = len(cardPoints)\n total = sum(cardPoints)\n if k == length:\n return total\n curr = 0\n temp = 2 ** 31 - 1\n left = 0\n for right in range(length):\n curr += cardPoints[right]\n if right - left + 1 < length - k:\n continue\n print(right, curr)\n temp = min(temp, curr)\n curr -= cardPoints[left]\n left += 1\n \n return total - temp",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints)\n \n cum_sum = [0 for i in range(n)]\n cum_sum[0] = cardPoints[0]\n rev_sum = [0 for i in range(n)]\n rev_sum[0] = cardPoints[-1]\n \n \n for i in range(1,n):\n cum_sum[i] = cum_sum[i-1]+cardPoints[i]\n rev_sum[i] = rev_sum[i-1]+cardPoints[n-i-1]\n \n max_sum = max(cum_sum[k-1],rev_sum[k-1])\n \n for i in range(1,k):\n max_sum = max(max_sum,(cum_sum[i-1]+rev_sum[k-i-1]))\n \n return max_sum\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n remainCnt = len(cardPoints) - k\n if remainCnt == 0: return sum(cardPoints)\n minRemainSum = float('inf')\n curr = 0\n cnt = 0\n for i in range(len(cardPoints)):\n cnt += 1\n curr += cardPoints[i]\n if cnt == remainCnt:\n minRemainSum = min(minRemainSum, curr)\n curr -= cardPoints[i + 1 - cnt]\n cnt -= 1\n \n return sum(cardPoints) - minRemainSum\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n # Sliding window of length k\n ans = total = sum(cardPoints[:k])\n for i in range(1, k+1):\n total -= cardPoints[k-i]\n total += cardPoints[-1-i+1]\n ans = max(ans, total)\n return ans\n",
"from collections import deque\nclass Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n first = deque(cardPoints[0:k])\n second = deque(cardPoints[len(cardPoints)-k:])\n final = 0\n \n firstSum = sum(first)\n secondSum = sum(second)\n \n for i in range(k):\n if firstSum > secondSum:\n final += first[0]\n firstSum -= first.popleft()\n secondSum -= second.popleft()\n \n else:\n final += second[len(second)-1]\n firstSum -= first.pop()\n secondSum -= second.pop()\n\n return final",
"class Solution:\n def maxScore(self, cardPoints, k: int) -> int:\n N = len(cardPoints)\n preS, afterS = [0]*(N+1), [0]*(N+1)\n ans = 0\n for i in range(1,N+1):\n preS[i]=preS[i-1]+cardPoints[i-1]\n for j in range(1,N+1):\n afterS[j] = afterS[j-1]+cardPoints[N-j]\n for l in range(k+1):\n ans = max(ans,preS[l]+afterS[k-l])\n return ans",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n right_index = len(cardPoints)-k\n curr_max = sum(cardPoints[right_index:])\n curr_sum = curr_max\n for left_index in range(0, k):\n curr_sum -= cardPoints[right_index]\n right_index += 1\n curr_sum += cardPoints[left_index]\n if curr_sum > curr_max:\n curr_max = curr_sum\n return curr_max\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n \n n = len(cardPoints)\n \n cum_sum = [0 for i in range(n)]\n cum_sum[0] = cardPoints[0]\n rev_sum = [0 for i in range(n)]\n rev_sum[0] = cardPoints[-1]\n \n \n for i in range(1,n):\n cum_sum[i] = cum_sum[i-1]+cardPoints[i]\n rev_sum[i] = rev_sum[i-1]+cardPoints[n-i-1]\n \n max_sum = max(cum_sum[k-1],rev_sum[k-1])\n \n for i in range(1,k):\n max_sum = max(max_sum,(cum_sum[i-1]+rev_sum[k-i-1]))\n \n return max_sum",
"class Solution:\n def maxScore(self, A: List[int], k: int) -> int: \n su = sum(A[:k])\n n = len(A) \n res = su \n for i in range(k):\n su -= A[k-i-1]\n su += A[n-i-1]\n res = max(res, su) \n return res",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n # sum of points from left most\n # sum of points from right most\n # sum of points from both left and right\n \n # defualt max_sum\n total = sum(cardPoints[:k])\n \n # if k == len(cardPoitns), result is the total sum of cardPoints\n if k == len(cardPoints):\n return total\n max_sum = total\n print(max_sum)\n \n # compute sum from left to right\n for i in range(k - 1, -1, -1):\n total = total + cardPoints[i - k] - cardPoints[i]\n print((i-k, total, cardPoints[i - k], cardPoints[i]))\n if total > max_sum:\n max_sum = total\n return max_sum\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n j = len(cardPoints) - 1\n ms = 0\n \n for i in range(k):\n ms += cardPoints[j]\n j -= 1\n \n cand = ms\n \n for i in range(k):\n cand += cardPoints[i] - cardPoints[j+1]\n j += 1\n ms = max(cand, ms)\n \n return ms",
"class Solution:\n def maxScore(self, nums: List[int], k: int) -> int:\n \n n = len(nums)\n\n if k == n:\n return sum(nums)\n \n pre =[0]\n post = []\n \n for e in nums:\n pre.append(pre[-1]+e)\n post.append(e)\n post.append(0)\n \n \n for i in range(n-1,-1,-1):\n post[i] = post[i+1] + nums[i]\n \n res = 0\n j = n - k\n \n while j <= n:\n res = max(res, pre[i] + post[j])\n \n i+=1\n j+=1\n \n return res",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n if len(cardPoints) < k:\n return -1\n \n remain = len(cardPoints) - k\n suum = sum(cardPoints[:remain])\n min_suum = suum\n for i in range(remain, len(cardPoints)):\n suum = suum - cardPoints[i-remain] + cardPoints[i]\n min_suum = min(min_suum, suum)\n return sum(cardPoints) - min_suum",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints)\n sums = [0] * (n+1)\n for i in range(1, n+1):\n sums[i] = sums[i-1] + cardPoints[i-1]\n \n ans = float('inf')\n for i in range(k+1):\n ans = min(ans, sums[i+n-k] - sums[i])\n \n return sums[-1] - ans\n",
"class Solution:\n def maxScore(self, A: List[int], k: int) -> int: \n su = sum(A[:k])\n res = su \n for i in range(k):\n su -= A[k-i-1]\n su += A[len(A)-i-1]\n res = max(res, su) \n return res",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints) - k\n l, r, res, count = 0, 0, sum(cardPoints[:n]), 0\n while r < len(cardPoints):\n count += cardPoints[r]\n if r >= n:\n count -= cardPoints[l]\n l += 1\n res = min(res, count)\n r += 1\n return sum(cardPoints) - res",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n pre = [cardPoints[0]]\n n = len(cardPoints)\n for i in range(1, n):\n pre.append(pre[-1] + cardPoints[i])\n \n if k == n:\n return pre[-1]\n \n s = pre[-1]\n cur_s = pre[n - k - 1]\n l = 0\n r = n - k + l - 1\n ans = s - pre[n - k - 1]\n \n while l != len(cardPoints) - (n - k) :\n cur_s -= cardPoints[l]\n l += 1\n r += 1\n cur_s += cardPoints[r]\n ans = max(ans, s - cur_s)\n \n return ans\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints) - k\n current = 0\n for i in range(n):\n current += cardPoints[i]\n result = current\n \n for i in range(1, k+1):\n current -= cardPoints[i-1]\n current += cardPoints[i+n-1]\n result = min(result, current)\n \n return sum(cardPoints) - result\n \n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n f, b = [0], [0]\n for n in cardPoints:\n f.append(f[-1] + n)\n for n in cardPoints[::-1]:\n b.append(b[-1] + n)\n allCombo = [f[i] + b[k-i] for i in range(k+1)]\n return max(allCombo)\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n \n points_L = []\n points_R = []\n \n for p in cardPoints:\n if len(points_L): points_L.append(points_L[-1] + p)\n else: points_L.append(p)\n for p in cardPoints[::-1]:\n if len(points_R): points_R.append(points_R[-1] + p)\n else: points_R.append(p)\n points_R = points_R[::-1]\n \n return self.solution(points_L, points_R, k)\n \n\n def solution(self, points_L, points_R, k):\n max = 0\n for i in range(k+1):\n cmp1 = points_L[i-1] if i > 0 else 0\n cmp2 = points_R[-(k-i)] if i < k else 0\n score = cmp1 + cmp2\n if score > max:\n max = score\n return max\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n left_sums = [0] * (k + 1)\n right_sums = [0] * (k + 1)\n \n \n for i in range(k):\n left_sums[i+1] = left_sums[i] + cardPoints[i]\n right_sums[i+1] = right_sums[i] + cardPoints[len(cardPoints)-i-1]\n \n\n res = 0\n for i in range(k+1): # we must include K as a choice\n j = k-i\n res = max(res, left_sums[i] + right_sums[j])\n \n return res\n",
"from functools import lru_cache\nimport sys\nfrom itertools import accumulate\n\nsys.setrecursionlimit(10**5)\n\n\nclass Solution:\n def maxScore(self, arr: List[int], k: int) -> int:\n\n n = len(arr)\n pre = list(accumulate(arr))\n total = pre[-1]\n # print(f'{pre=}')\n \n if k == n:\n return total\n \n w = n-k\n result = 0 \n # print(f'{w=}')\n \n for i in range(w-1, n):\n # print(f'{i=}')\n sub_sum = total - (pre[i] - pre[i-w+1] + arr[i-w+1])\n result = max(result, sub_sum)\n \n \n return result",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n curr_max = sum(cardPoints[0:k])\n curr_sum = curr_max\n for i in range(1, k+1):\n curr_sum = curr_sum - cardPoints[k-i] + cardPoints[-i]\n curr_max = max(curr_max, curr_sum)\n return curr_max\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n size = len(cardPoints)\n maxRightSum = sum(cardPoints[size-k:])\n ans = maxRightSum\n currSum = maxRightSum\n # sum with left\n for i in range(k):\n currSum = currSum - cardPoints[size-k+i] + cardPoints[i]\n ans = max(ans, currSum)\n return ans\n # def maxScore(self, cardPoints: List[int], k: int) -> int:\n # windowEnd = 0\n # size = len(cardPoints) - k\n # ans = float(\\\"inf\\\")\n # currSum = 0\n # for windowStart, point in enumerate(cardPoints):\n # currSum += point\n # if windowStart - windowEnd + 1 > size:\n # currSum -= cardPoints[windowEnd]\n # windowEnd += 1\n # if windowStart - windowEnd + 1 == size:\n # ans = min(ans, currSum)\n # return sum(cardPoints) - ans\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints)\n curr_max = sum(cardPoints[0:k])\n curr_sum = curr_max\n for i in range(1, k+1):\n curr_sum = curr_sum - cardPoints[k-i] + cardPoints[-i]\n curr_max = max(curr_max, curr_sum)\n return curr_max\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n totalPoints, window = sum(cardPoints), len(cardPoints) - k\n i, j, Sum, Min = 0, 0, 0, totalPoints\n \n while j < len(cardPoints):\n Sum += cardPoints[j]\n \n if j - i + 1 > window:\n Sum -= cardPoints[i]\n i += 1\n \n if j - i + 1 == window: Min = min(Min, Sum)\n j += 1\n \n # print(Min)\n return totalPoints - Min\n \n \n \n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n if len(cardPoints) < k:\n return 0\n if len(cardPoints) == k:\n return sum(cardPoints)\n n = len(cardPoints)\n res, cur = sum(cardPoints[:k]), sum(cardPoints[:k])\n for i in range(k):\n cur += cardPoints[n-i-1]-cardPoints[k-1-i]\n res = max(res, cur)\n return res",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n if not cardPoints or k==0:\n return 0\n for i in range(1,len(cardPoints)):\n cardPoints[i]+=cardPoints[i-1]\n \n if k==len(cardPoints):\n return cardPoints[-1]\n ans=cardPoints[k-1]\n \n for i in range(1,k+1):\n print(i)\n ans=max(ans,cardPoints[k-i]+cardPoints[-1]-cardPoints[-i])\n print(cardPoints[k-i],cardPoints[-1]-cardPoints[-i])\n return max(ans,cardPoints[-1]-cardPoints[-(k+1)])",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints)\n left = n - k\n mini = sum(cardPoints[:left])\n cur = mini\n for i in range(left, n):\n cur = cur - cardPoints[i-left] + cardPoints[i]\n mini = min(mini, cur)\n \n return sum(cardPoints) - mini",
"class Solution:\n def maxScore(self, card_points: List[int], k: int) -> int:\n window_size = len(card_points) - k\n current_min_sum, min_sum = 0, sys.maxsize\n total_points = 0\n left = 0\n for right, value in enumerate(card_points):\n total_points += value\n current_min_sum += value\n\n current_size = right - left + 1\n if current_size < window_size:\n continue\n\n if current_size > window_size:\n current_min_sum -= card_points[left]\n left += 1\n\n min_sum = min(min_sum, current_min_sum)\n\n return total_points - min_sum\n",
"def max_score_using_subsequence(card_points, k):\n l = len(card_points) - k\n if l == 0:\n return sum(card_points)\n \n sum_subsequence = 0\n for i in range(l):\n sum_subsequence += card_points[i]\n \n lowest = sum_subsequence\n for i in range(len(card_points) - l):\n sum_subsequence = sum_subsequence - card_points[i] + card_points[i+l]\n if sum_subsequence < lowest:\n lowest = sum_subsequence\n \n return sum(card_points) - lowest\n \n\nclass Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n # return max_score_recursive(cardPoints, k, 0, len(cardPoints)-1, {})\n return max_score_using_subsequence(cardPoints, k)",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n psum = sum(cardPoints[:k])\n res = psum\n n = len(cardPoints)\n for i in range(k):\n psum += cardPoints[n - i - 1] - cardPoints[k - i - 1]\n res = max(res, psum)\n return res\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n pre_sum = [] # i: sum of all items before i\n temp_left = 0\n for i, v in enumerate(cardPoints):\n pre_sum.append(temp_left)\n temp_left += v\n pre_sum.append(temp_left)\n \n post_sum = [] # i: sum of all items after i-1\n temp_right = 0\n temp_right = 0\n for i in range(len(cardPoints)-1, -1, -1):\n v = cardPoints[i]\n post_sum.append(temp_right)\n temp_right += v\n post_sum.append(v)\n post_sum.reverse()\n # print(pre_sum)\n # print(post_sum)\n return max([pre_sum[i] + post_sum[-(k-i)-1] for i in range(k+1)])\n \n \n \n\n",
"from collections import deque\nclass Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints)\n cards = n-k\n minimum = 0\n if (cards != 0):\n sum1 = 0\n q = deque()\n for i in range(cards):\n q.append(cardPoints[i])\n sum1 += cardPoints[i]\n minimum = sum1\n for i in range(cards, n):\n first = q.popleft()\n q.append(cardPoints[i])\n sum1 -=first\n sum1 += cardPoints[i]\n if (sum1 < minimum):\n minimum = sum1\n #else:\n # minimum = 0\n print(minimum)\n return sum(cardPoints) - minimum\n",
"class Solution:\n def maxScore(self, l: List[int], k: int) -> int:\n length = len(l)\n \n if k == length:\n return sum(l)\n elif k == 0:\n return 0\n \n k = length - k\n v = curr_min = sum(l[:k])\n \n for i in range(k,length):\n v = v - l[i-k] + l[i]\n curr_min = min(curr_min, v)\n \n return sum(l) - curr_min\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n if k == len(cardPoints):\n return sum(cardPoints)\n size = len(cardPoints) - k\n min_sum = float('inf')\n left = 0\n right = 0\n window_sum = 0\n while right < len(cardPoints):\n window_sum += cardPoints[right]\n right += 1\n while right - left == size:\n min_sum = min(min_sum, window_sum)\n window_sum -= cardPoints[left]\n left += 1\n return sum(cardPoints) - min_sum\n",
"class Solution:\n def maxScore(self, p: List[int], k: int) -> int:\n res = sum(p[:k])\n cur = res\n \n for i in range(1, k+1):\n cur += p[-i] - p[k-i]\n res = max(cur, res)\n \n return res\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n # Time: O(k)\n # Space: O(1)\n ans = win = 0\n for i in range(-k, k):\n win += cardPoints[i]\n if i >= 0:\n win -= cardPoints[i - k]\n #print(i, i-k, ans, win, cardPoints[i] ) \n ans = max(win, ans) \n return ans\n \n \n",
"# O(n) time and O(1) space\n# alternative dp solution O(k) space: form two k sized arrays: 1 to k and n-k to n\n# https://www.youtube.com/watch?v=t3JHx5J01F0 9mins06s\nclass Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n curr_max = sum(cardPoints[:k])\n ans = curr_max\n for i in range(1, k+1):\n curr_max += cardPoints[-i] - cardPoints[k-i]\n ans = max(ans, curr_max)\n return ans\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n n = len(cardPoints)\n w = n - k\n left, right = 0, w - 1\n ans = float('-inf')\n \n win_sum = sum(cardPoints[:w])\n total = sum(cardPoints)\n while right < n:\n sub = total - win_sum\n ans = max(sub, ans)\n if left < n:\n win_sum -= cardPoints[left]\n left += 1\n right += 1\n if right < n:\n win_sum += cardPoints[right]\n\n return ans\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n# 我写的还是太复杂了\n# if not cardPoints or not k:\n# return 0\n# if k==len(cardPoints):\n# return sum(cardPoints)\n \n# front={0:0}\n# back={0:0}\n# total=0\n# for i in range(k):\n# total+=cardPoints[i]\n# front[i+1]=total\n# total=0\n# for i in range(-1,-k-1,-1):\n# total+=cardPoints[i]\n# back[-i]=total\n \n# maxres=float('-inf')\n# for i in range(k+1):\n# maxres=max(maxres,front[i]+back[k-i])\n \n# return maxres\n s = sum(cardPoints[:k])\n res = s\n for i in range(1, k+1):\n s += cardPoints[-i] - cardPoints[k-i]\n res = max(res, s)\n return res\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n left, right = [0], [0]\n for i in range(k):\n left.append(left[-1] + cardPoints[i])\n right.append(right[-1] + cardPoints[len(cardPoints) - 1 - i])\n # print(left, right)\n maxSoFar = 0\n for i in range(k + 1):\n if left[i] + right[k - i] > maxSoFar:\n maxSoFar = left[i] + right[k - i]\n return maxSoFar\n \n",
"class Solution:\n def maxScore(self, p: List[int], k: int) -> int:\n s = sum(p)\n if k == len(p): return s\n n = len(p)\n for i in range(1, len(p)): p[i] += p[i-1]\n\n return s - min(p[n+i-k-1] - (p[i-1] if i else 0) for i in range(k+1))\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n score = 0\n l = k\n prefix = [0]\n for i in range(len(cardPoints)):\n prefix.append(prefix[-1] + cardPoints[i])\n for i in range(k+1):\n score = max(score, prefix[l] + prefix[-1] - prefix[-1-i])\n l -= 1\n return score",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n right_index = len(cardPoints)-k\n curr_max = sum(cardPoints[right_index:])\n curr_sum = curr_max\n for left_index, right_index in zip(list(range(0, k)), list(range(len(cardPoints)-k, len(cardPoints)))):\n print((left_index, right_index))\n curr_sum -= cardPoints[right_index]\n curr_sum += cardPoints[left_index]\n curr_max = max(curr_max, curr_sum)\n return curr_max\n",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int: \n sub_len = len(cardPoints) - k\n localSum = 0\n localSum = sum(cardPoints[0: sub_len])\n localMin = localSum\n for i in range(sub_len, len(cardPoints)):\n localSum += cardPoints[i]\n localSum -= cardPoints[i - sub_len]\n localMin = min(localSum, localMin)\n return sum(cardPoints) - localMin",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n points = cardPoints[-k:] + cardPoints[:k]\n curr = 0\n max_ = 0\n for ind, score in enumerate(points):\n if ind >= k:\n curr -= points[ind-k]\n curr += score\n max_ = max(max_, curr)\n return max_",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n \n total = sum(cardPoints)\n \n nk = len(cardPoints) - k\n \n if nk == 0:\n return total\n \n current = sum(cardPoints[0:nk])\n max_score = current\n \n for i in range(1, k + 1):\n current = current - cardPoints[i - 1] + cardPoints[nk + i - 1]\n \n max_score = min(max_score, current)\n \n return total - max_score",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n \n total = [0 for _ in range(len(cardPoints))]\n total[0] = cardPoints[0]\n \n for i in range(1, len(cardPoints)):\n total[i] = total[i-1] + cardPoints[i]\n \n max_sum = 0\n for i in range(k+1):\n left = total[k-i-1] if k-i > 0 else 0\n right = total[-1] - total[len(cardPoints)-i-1]\n if left + right > max_sum:\n max_sum = left + right\n \n return max_sum",
"class Solution:\n def maxScore(self, cardPoints: List[int], k: int) -> int:\n N = len(cardPoints)\n res = float('inf')\n run = 0\n for i, p in enumerate(cardPoints):\n if i >= N-k: run -= cardPoints[i-N+k]\n run += p\n if i >= N-k-1: res = min(res, run)\n return sum(cardPoints) - res"
] | 80 |
[
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
41,
42,
43,
44,
45,
46,
47,
48,
49,
50,
51,
52,
53,
54,
55,
56,
57,
58,
59,
60,
61,
62,
63,
64,
65,
66,
67,
68,
69,
70,
71,
72,
73,
74,
75,
76,
77,
78,
79
] |
[
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
123 |
Your music player contains N different songs and she wants to listen to L (not necessarily different) songs during your trip. You create a playlist so that:
Every song is played at least once
A song can only be played again only if K other songs have been played
Return the number of possible playlists. As the answer can be very large, return it modulo 10^9 + 7.
Example 1:
Input: N = 3, L = 3, K = 1
Output: 6
Explanation: There are 6 possible playlists. [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1].
Example 2:
Input: N = 2, L = 3, K = 0
Output: 6
Explanation: There are 6 possible playlists. [1, 1, 2], [1, 2, 1], [2, 1, 1], [2, 2, 1], [2, 1, 2], [1, 2, 2]
Example 3:
Input: N = 2, L = 3, K = 1
Output: 2
Explanation: There are 2 possible playlists. [1, 2, 1], [2, 1, 2]
Note:
0 <= K < N <= L <= 100
|
["import math\nclass Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n s=0\n c=0\n r=0\n x=math.factorial(N)\n while(True):\n c=x*((N-r-K)**(L-K))*(-1)**(r)//(math.factorial(N-r-K)*math.factorial(r))\n if(c!=0):\n s=(s+c)%(10**9+7)\n r+=1\n else:\n return s\n", "import math\nclass Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n s=0\n c=0\n r=0\n x=math.factorial(N)\n while(True):\n c=x*((N-r-K)**(L-K))*(-1)**(r)//(math.factorial(N-r-K)*math.factorial(r))\n if(c!=0):\n s=(s+c)%(10**9+7)\n r+=1\n else:\n return s\n \n", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n MOD = 10 ** 9 + 7\n @lru_cache(None)\n def dp(i, j):\n if i < j: return 0\n if i == 0:\n return 1 if j == 0 else 0\n # if i == j:\n # return math.factorial\n a = dp(i - 1, j - 1) * (N - j + 1)\n a += dp(i - 1, j) * (j - K if j > K else 0)\n return a % MOD\n return dp(L, N)\n \n", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n mod = 10**9+7\n def memo(f):\n dic = {}\n\n def f_alt(*args):\n if args not in dic:\n dic[args] = f(*args)\n return dic[args]\n return f_alt\n\n @memo\n def play(N, L):\n if L == 0:\n return 1 if N == 0 else 0\n if N > L:\n return 0\n return (N*play(N-1, L-1) + max(0, N-K)*play(N, L-1))%mod\n\n return play(N, L)", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [[0] * (N + 1) for _ in range(L + 1)]\n dp[0][0] = 1\n for i in range(1, L + 1):\n for j in range(1, N + 1):\n dp[i][j] = dp[i - 1][j - 1] * (N - j + 1) #play new song\n if j > K: #play old song\n dp[i][j] += dp[i - 1][j] * (j - K)\n return dp[-1][-1]%(10 ** 9 + 7)\n \n \n", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n mod = 10 ** 9 + 7\n dp = [[0] * (L + 1) for _ in range(N + 1)]\n \n for i in range(1, N + 1):\n for j in range(i, L + 1):\n if i == K + 1:# or i == j:\n dp[i][j] = math.factorial(i)\n else:\n dp[i][j] = dp[i - 1][j - 1] * i\n if j > i:\n dp[i][j] += dp[i][j - 1] * (i - K)\n dp[i][j] %= mod\n # print(dp)\n return dp[N][L]\n", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [[0]*(N+1) for _ in range(L+1)]\n dp[0][0] = 1\n \n for i in range(1,L+1):\n for j in range(1,N+1):\n dp[i][j] = dp[i-1][j-1]*(N-j+1)%(10**9+7)\n if j > K:\n dp[i][j] = (dp[i][j] + dp[i-1][j] * (j-K))%(10**9+7)\n \n return dp[L][N] \n \n #T=O(NL) S=O(NL) \n memo = {}\n def DFS(i,j):\n if i == 0:\n return j==0\n if (i,j) in memo:\n return memo[(i,j)]\n ans = DFS(i-1, j-1)*(N-j+1)\n ans += DFS(i-1, j)* max(j-K,0)\n memo[(i,j)] = ans%(10**9+7)\n return memo[(i,j)]\n \n return DFS(L,N)", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n mod = 10 ** 9 + 7\n dp = [[0] * (L + 1) for _ in range(N + 1)]\n \n for i in range(1, N + 1):\n for j in range(i, L + 1):\n if i == K + 1 or i == j:\n dp[i][j] = math.factorial(i)\n else:\n dp[i][j] = dp[i - 1][j - 1] * i\n if j > i:\n dp[i][j] += dp[i][j - 1] * (i - K)\n dp[i][j] %= mod\n # print(dp)\n return dp[N][L]\n", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [[0 for _ in range(N+1)] for _ in range(L+1)]\n dp[0][0] = 1\n mod = 10**9 + 7\n for i in range(1, L+1):\n for j in range(1, N+1):\n dp[i][j] = dp[i-1][j-1] * (N-j+1)\n if j > K:\n dp[i][j] += dp[i-1][j]*(j-K)\n dp[i][j] %= mod\n \n return dp[L][N]", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [1] * (L-N+1)\n for p in range(2, N-K+1):\n for i in range(1, L-N+1):\n dp[i] += dp[i-1] * p\n \n ans = dp[-1]\n for k in range(2, N+1):\n ans *= k\n \n return ans % (10 ** 9 + 7)", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n # 11:35\n # pick k+1 songs out of N Songs\n # k+1 factorial\n # you can pick a new song or old song from this k+1 => basically you got N options now\n \n mod=10**9+7\n @lru_cache(None)\n def helper(i,notplayed):\n nonlocal mod\n if i==L+1:\n return 0 if notplayed!=0 else 1 \n ans=(max((N-notplayed)-K,0)*helper(i+1,notplayed))%mod\n if notplayed!=0:\n ans+=(notplayed)*helper(i+1,notplayed-1)\n return ans%mod\n return helper(1,N)\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n BIG = 10**9+7\n \n @lru_cache(None)\n def dp(r,n):\n if r == 0: return 1 if n == 0 else 0\n return ( dp(r-1,n-1) * (N-(n-1)) + dp(r-1,n) * max(0, n-K) ) % BIG\n \n \n return dp(L, N)", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n @lru_cache(None)\n def unique(length, uni):\n if uni == 0:\n return 0\n if length == 1:\n if uni == 1:\n return N\n else:\n return 0\n \n ret = unique(length - 1, uni - 1) * (N - uni + 1)\n ret += unique(length -1, uni) * max(0, uni - K)\n \n return ret % (10**9+7)\n \n return unique(L, N)", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n m = 10 ** 9 + 7\n dp = [[0 for _ in range(N+1)] for _ in range(L+1)]\n dp[0][0] = 1\n for i in range(1,L+1):\n for j in range(1,N+1):\n dp[i][j] = (dp[i-1][j-1] * (N-j+1) + dp[i-1][j] * max(j-K,0))%m\n \n return int(dp[L][N])", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n mod = 10 ** 9 + 7\n \n @lru_cache(None)\n def dp(l, n):\n if not l:\n return not n\n return dp(l - 1, n - 1) * (N - n + 1) + dp(l - 1, n) * max(n - K, 0)\n \n return dp(L, N) % mod", "from functools import lru_cache\n\nclass Solution:\n def numMusicPlaylists(self, N, L, K):\n @lru_cache(None)\n def dp(i, j):\n if i == 0:\n return +(j == 0)\n ans = dp(i-1, j-1) * (N-j+1)\n ans += dp(i-1, j) * max(j-K, 0)\n return ans % (10**9+7)\n\n return dp(L, N)", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [[0 for i in range(L+1)] for j in range(N+1)]\n for i in range(1, len(dp)):\n for j in range(1, len(dp[0])):\n if i == j:\n dp[i][j] = math.factorial(i)\n else:\n dp[i][j] = dp[i-1][j-1]*i + dp[i][j-1]*max((i-K), 0)\n print(dp)\n return dp[N][L]%(10**9+7)", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [0 for _ in range(L + 1)]\n dp[0] = 1\n for i in range(1, N + 1):\n dp2 = [0 for _ in range (L + 1)]\n for j in range(1, L + 1):\n dp2[j] = dp[j - 1] * (N - i + 1) \n dp2[j] += dp2[j - 1] * max(i - K, 0)\n dp = dp2\n \n return dp[L] % (10**9 + 7)", "import math\nclass Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n mod = 10**9+7\n dp = [[0 for _ in range(L+1)] for _ in range(N+1)]\n dp[0][0]=1\n for i in range(1,N+1):\n for j in range(1,L+1):\n dp[i][j] = dp[i-1][j-1]*(N-i+1)%mod\n dp[i][j] += dp[i][j-1]*max(i-K,0)%mod\n return dp[-1][-1]%mod", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n memo = {}\n def dp(i, j):\n if i == 0:\n return j == 0\n if (i, j) in memo: return memo[i, j]\n memo[i, j] = dp(i - 1, j - 1) * (N - j + 1) + dp(i - 1, j) * max(j - K, 0)\n return memo[i, j]\n \n return dp(L, N)%(10**9 + 7)\n \n \n", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n # N = 10 L = 25 K = 4\n # 1~10 24 3\n # 2~9 23 2\n # Unique : L - N + 1 Extra : N-K+1\n \n dp = [1] * (L-N+1)\n \n for p in range(2,N-K+1):\n for i in range(1,L-N+1):\n dp[i] += p*dp[i-1]\n \n ans = dp[-1]\n for k in range(2,N+1):\n ans = ans * k\n return ans% (10**9 + 7)\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n dp = [1] * (L-N+1)\n print(dp)\n for p in range(2, N-K+1):\n for i in range(1, L-N+1):\n \n dp[i] += dp[i-1] * p\n print((p,i, dp))\n # Multiply by N!\n ans = dp[-1]\n for k in range(2, N+1):\n ans *= k\n return ans % (10**9 + 7)\n \n", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n cache = {}\n def dp(i, j):\n if i == 0:\n return +(j == 0)\n if (i,j) in cache:\n return cache[(i,j)]\n ans = dp(i-1, j-1) * (N-j+1)\n ans += dp(i-1, j) * max(j-K, 0)\n ans %= (10**9+7)\n cache[(i,j)] = ans\n return ans\n\n return dp(L, N)", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n \n @lru_cache(None)\n def dp(i, j):\n if i == 0:\n return j == 0\n \n return (dp(i-1, j) * max(0, j - K) + dp(i-1, j-1) * (N - j + 1)) % (10**9 + 7)\n \n return dp(L, N)", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n \n dp = [[0 for n in range(N+1) ] for l in range(L+1)]\n dp[0][0] = 1\n for l in range(1, L+1):\n for n in range(1, N+1):\n dp[l][n] += dp[l-1][n-1] * (N-n+1)\n dp[l][n] += dp[l-1][n] * max(n-K, 0)\n dp [l][n] = dp [l][n] % (10 **9+7)\n return dp[L][N]", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [[0] * (N + 1) for _ in range(L + 1)]\n dp[0][0] = 1;\n for l in range(1, L + 1):\n for n in range(1, N + 1):\n dp[l][n] += dp[l - 1][n - 1] * (N - n + 1)\n dp[l][n] += dp[l - 1][n] * max(n - K, 0)\n dp[l][n] = dp[l][n] % (1000000007)\n return dp[L][N]", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n mod = 10**9 + 7\n memo = {}\n # helper(i,j) returns the number of playlists of len i\n # that have exactly j unique songs\n def helper(i, j):\n nonlocal N, K\n if i==0:\n if j==0:\n # base case\n # helper(0,0) returns 1\n return 1\n else:\n return 0\n if (i,j) in memo:\n return memo[(i,j)]\n ans = 0\n # the jth song is unique,\n # then the jth song has (N-(j-1)) possibilities\n ans += helper(i-1, j-1)*(N-(j-1))\n # the jth song is not unique\n # it is the same as one of the previous songs\n # then the jth song has max(0, j-K) possibilities\n # since it can be the same as the previous K songs\n ans += helper(i-1, j)*max(0, j-K)\n memo[(i,j)]=ans%mod\n return ans%mod\n return helper(L, N)", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n memo = {}\n def dp(i, j):\n if i == 0: return 1 if j == 0 else 0\n if (i, j) in memo: return memo[(i, j)]\n # non repeat\n ans = dp(i - 1, j - 1) * (N - (j - 1))\n # repeat\n ans += dp(i - 1, j) * max(0, j - K)\n memo[(i, j)] = ans % (10 ** 9 + 7)\n return memo[(i, j)]\n return dp(L, N)", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n memo = {}\n def dp(i, j):\n if i == 0: return 1 if j == 0 else 0\n if (i, j) in memo: return memo[(i, j)]\n # non repeat\n ans = dp(i - 1, j - 1) * (N - (j - 1))\n # repeat\n ans += dp(i - 1, j) * max(0, j - K)\n memo[(i, j)] = ans % (10 ** 9 + 7)\n return memo[(i, j)]\n return dp(L, N)\n# from functools import lru_cache\n\n# class Solution:\n# def numMusicPlaylists(self, N, L, K):\n# @lru_cache(None)\n# def dp(i, j):\n# if i == 0:\n# return +(j == 0)\n# ans = dp(i-1, j-1) * (N-j+1)\n# ans += dp(i-1, j) * max(j-K, 0)\n# return ans % (10**9+7)\n\n# return dp(L, N)\n", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n @lru_cache(None)\n def dp(i, j):\n if i == 0:\n return +(j == 0)\n ans = dp(i-1, j-1) * (N-j+1)\n ans += dp(i-1, j) * max(j-K, 0)\n return ans % (10**9+7)\n\n return dp(L, N)", "from functools import lru_cache\nclass Solution:\n def numMusicPlaylists(self, N, L, K):\n @lru_cache(None)\n def dp(i, j):\n if i == 0:\n return +(j == 0)\n ans = dp(i-1, j-1) * (N-j+1)\n ans += dp(i-1, j) * (j-min(K, i-1))\n return ans % (10**9+7)\n\n return dp(L, N)\n \n \n", "from functools import lru_cache\n\nclass Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n # Dynamic Programming\n # Let dp[i][j] be the number of playlists of length i that have exactly j unique songs.\n # Time complexity: O(NL)\n # Space complexity: O(NL)\n @lru_cache(None)\n def dp(i, j):\n if i == 0:\n return +(j == 0)\n ans = dp(i - 1, j - 1) * (N - j + 1)\n ans += dp(i - 1, j) * max(j - K, 0)\n return ans % (10**9 + 7)\n\n return dp(L, N)\n\n", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [[0 for j in range(L+1)] for i in range(N+1)]\n for i in range(K+1, N+1):\n for j in range(i, L+1):\n if i == j or i == K+1:\n dp[i][j] = math.factorial(i)\n else:\n dp[i][j] = dp[i-1][j-1]*i + dp[i][j-1]*(i-K)\n return dp[N][L]%(10**9+7)\n", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n '''\n construct a 2d dp[i][j] where i is i different songs and\n j is the length of the playlist, also track the remaining songs r:\n for dp update, we have two options:\n if i <= k:\n 1. add a new song to the list, r -= 1\n else:\n if r > L-j\n 1. add a new song to the list, r -= 1\n 2. add an existing song\n else:\n 1. add a new song\n ''' \n @lru_cache(None)\n def dp(unique, total, r):\n if total == L:\n return 1\n if unique <= K:\n return r * dp(unique+1, total+1, r-1)\n else:\n ans = 0\n if r < L-total:\n # add an existing song\n ans += (unique-K) * dp(unique, total+1, r)\n # add a new song\n ans += r * dp(unique+1, total+1, r-1)\n return ans\n\n return dp(0, 0, N) % (10**9+7)", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [[0 for i in range(L + 1)] for j in range(N + 1)]\n for i in range(K + 1, N + 1):\n for j in range(i, L + 1):\n if i == j or i == K + 1:\n dp[i][j] = math.factorial(i)\n else:\n dp[i][j] = dp[i - 1][j - 1] * i + dp[i][j - 1] * (i - K)\n return dp[N][L] % (10**9 + 7)", "class Solution:\n import math\n from functools import lru_cache\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n MOD = 1000000007\n\n @lru_cache(maxsize=None)\n def rec(n, l):\n if l < n or n <= K:\n return 0\n elif l == n:\n return math.factorial(n) % MOD\n return (n * rec(n - 1, l - 1) + (n - K) * rec(n, l - 1)) % MOD\n\n return rec(N, L)", "class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n MOD = 10 ** 9 + 7\n @lru_cache(None)\n def dp(i, j):\n if i < j: return 0\n if i == 0:\n return 1 if j == 0 else 0\n if i == j:\n return (math.factorial(N) // math.factorial(N - j)) % MOD\n a = dp(i - 1, j - 1) * (N - j + 1)\n a += dp(i - 1, j) * (j - K if j > K else 0)\n return a % MOD\n return dp(L, N)\n \n"]
|
{"fn_name": "numMusicPlaylists", "inputs": [[3, 3, 1]], "outputs": [6]}
|
interview
|
https://leetcode.com/problems/number-of-music-playlists/
|
class Solution:
def numMusicPlaylists(self, N: int, L: int, K: int) -> int:
|
[
"import math\nclass Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n s=0\n c=0\n r=0\n x=math.factorial(N)\n while(True):\n c=x*((N-r-K)**(L-K))*(-1)**(r)//(math.factorial(N-r-K)*math.factorial(r))\n if(c!=0):\n s=(s+c)%(10**9+7)\n r+=1\n else:\n return s\n",
"import math\nclass Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n s=0\n c=0\n r=0\n x=math.factorial(N)\n while(True):\n c=x*((N-r-K)**(L-K))*(-1)**(r)//(math.factorial(N-r-K)*math.factorial(r))\n if(c!=0):\n s=(s+c)%(10**9+7)\n r+=1\n else:\n return s\n \n",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n MOD = 10 ** 9 + 7\n @lru_cache(None)\n def dp(i, j):\n if i < j: return 0\n if i == 0:\n return 1 if j == 0 else 0\n # if i == j:\n # return math.factorial\n a = dp(i - 1, j - 1) * (N - j + 1)\n a += dp(i - 1, j) * (j - K if j > K else 0)\n return a % MOD\n return dp(L, N)\n \n",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n mod = 10**9+7\n def memo(f):\n dic = {}\n\n def f_alt(*args):\n if args not in dic:\n dic[args] = f(*args)\n return dic[args]\n return f_alt\n\n @memo\n def play(N, L):\n if L == 0:\n return 1 if N == 0 else 0\n if N > L:\n return 0\n return (N*play(N-1, L-1) + max(0, N-K)*play(N, L-1))%mod\n\n return play(N, L)",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [[0] * (N + 1) for _ in range(L + 1)]\n dp[0][0] = 1\n for i in range(1, L + 1):\n for j in range(1, N + 1):\n dp[i][j] = dp[i - 1][j - 1] * (N - j + 1) #play new song\n if j > K: #play old song\n dp[i][j] += dp[i - 1][j] * (j - K)\n return dp[-1][-1]%(10 ** 9 + 7)\n \n \n",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n mod = 10 ** 9 + 7\n dp = [[0] * (L + 1) for _ in range(N + 1)]\n \n for i in range(1, N + 1):\n for j in range(i, L + 1):\n if i == K + 1:# or i == j:\n dp[i][j] = math.factorial(i)\n else:\n dp[i][j] = dp[i - 1][j - 1] * i\n if j > i:\n dp[i][j] += dp[i][j - 1] * (i - K)\n dp[i][j] %= mod\n # print(dp)\n return dp[N][L]\n",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [[0]*(N+1) for _ in range(L+1)]\n dp[0][0] = 1\n \n for i in range(1,L+1):\n for j in range(1,N+1):\n dp[i][j] = dp[i-1][j-1]*(N-j+1)%(10**9+7)\n if j > K:\n dp[i][j] = (dp[i][j] + dp[i-1][j] * (j-K))%(10**9+7)\n \n return dp[L][N] \n \n #T=O(NL) S=O(NL) \n memo = {}\n def DFS(i,j):\n if i == 0:\n return j==0\n if (i,j) in memo:\n return memo[(i,j)]\n ans = DFS(i-1, j-1)*(N-j+1)\n ans += DFS(i-1, j)* max(j-K,0)\n memo[(i,j)] = ans%(10**9+7)\n return memo[(i,j)]\n \n return DFS(L,N)",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n mod = 10 ** 9 + 7\n dp = [[0] * (L + 1) for _ in range(N + 1)]\n \n for i in range(1, N + 1):\n for j in range(i, L + 1):\n if i == K + 1 or i == j:\n dp[i][j] = math.factorial(i)\n else:\n dp[i][j] = dp[i - 1][j - 1] * i\n if j > i:\n dp[i][j] += dp[i][j - 1] * (i - K)\n dp[i][j] %= mod\n # print(dp)\n return dp[N][L]\n",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [[0 for _ in range(N+1)] for _ in range(L+1)]\n dp[0][0] = 1\n mod = 10**9 + 7\n for i in range(1, L+1):\n for j in range(1, N+1):\n dp[i][j] = dp[i-1][j-1] * (N-j+1)\n if j > K:\n dp[i][j] += dp[i-1][j]*(j-K)\n dp[i][j] %= mod\n \n return dp[L][N]",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [1] * (L-N+1)\n for p in range(2, N-K+1):\n for i in range(1, L-N+1):\n dp[i] += dp[i-1] * p\n \n ans = dp[-1]\n for k in range(2, N+1):\n ans *= k\n \n return ans % (10 ** 9 + 7)",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n # 11:35\n # pick k+1 songs out of N Songs\n # k+1 factorial\n # you can pick a new song or old song from this k+1 => basically you got N options now\n \n mod=10**9+7\n @lru_cache(None)\n def helper(i,notplayed):\n nonlocal mod\n if i==L+1:\n return 0 if notplayed!=0 else 1 \n ans=(max((N-notplayed)-K,0)*helper(i+1,notplayed))%mod\n if notplayed!=0:\n ans+=(notplayed)*helper(i+1,notplayed-1)\n return ans%mod\n return helper(1,N)\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n BIG = 10**9+7\n \n @lru_cache(None)\n def dp(r,n):\n if r == 0: return 1 if n == 0 else 0\n return ( dp(r-1,n-1) * (N-(n-1)) + dp(r-1,n) * max(0, n-K) ) % BIG\n \n \n return dp(L, N)",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n @lru_cache(None)\n def unique(length, uni):\n if uni == 0:\n return 0\n if length == 1:\n if uni == 1:\n return N\n else:\n return 0\n \n ret = unique(length - 1, uni - 1) * (N - uni + 1)\n ret += unique(length -1, uni) * max(0, uni - K)\n \n return ret % (10**9+7)\n \n return unique(L, N)",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n m = 10 ** 9 + 7\n dp = [[0 for _ in range(N+1)] for _ in range(L+1)]\n dp[0][0] = 1\n for i in range(1,L+1):\n for j in range(1,N+1):\n dp[i][j] = (dp[i-1][j-1] * (N-j+1) + dp[i-1][j] * max(j-K,0))%m\n \n return int(dp[L][N])",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n mod = 10 ** 9 + 7\n \n @lru_cache(None)\n def dp(l, n):\n if not l:\n return not n\n return dp(l - 1, n - 1) * (N - n + 1) + dp(l - 1, n) * max(n - K, 0)\n \n return dp(L, N) % mod",
"from functools import lru_cache\n\nclass Solution:\n def numMusicPlaylists(self, N, L, K):\n @lru_cache(None)\n def dp(i, j):\n if i == 0:\n return +(j == 0)\n ans = dp(i-1, j-1) * (N-j+1)\n ans += dp(i-1, j) * max(j-K, 0)\n return ans % (10**9+7)\n\n return dp(L, N)",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [[0 for i in range(L+1)] for j in range(N+1)]\n for i in range(1, len(dp)):\n for j in range(1, len(dp[0])):\n if i == j:\n dp[i][j] = math.factorial(i)\n else:\n dp[i][j] = dp[i-1][j-1]*i + dp[i][j-1]*max((i-K), 0)\n print(dp)\n return dp[N][L]%(10**9+7)",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [0 for _ in range(L + 1)]\n dp[0] = 1\n for i in range(1, N + 1):\n dp2 = [0 for _ in range (L + 1)]\n for j in range(1, L + 1):\n dp2[j] = dp[j - 1] * (N - i + 1) \n dp2[j] += dp2[j - 1] * max(i - K, 0)\n dp = dp2\n \n return dp[L] % (10**9 + 7)",
"import math\nclass Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n mod = 10**9+7\n dp = [[0 for _ in range(L+1)] for _ in range(N+1)]\n dp[0][0]=1\n for i in range(1,N+1):\n for j in range(1,L+1):\n dp[i][j] = dp[i-1][j-1]*(N-i+1)%mod\n dp[i][j] += dp[i][j-1]*max(i-K,0)%mod\n return dp[-1][-1]%mod",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n memo = {}\n def dp(i, j):\n if i == 0:\n return j == 0\n if (i, j) in memo: return memo[i, j]\n memo[i, j] = dp(i - 1, j - 1) * (N - j + 1) + dp(i - 1, j) * max(j - K, 0)\n return memo[i, j]\n \n return dp(L, N)%(10**9 + 7)\n \n \n",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n # N = 10 L = 25 K = 4\n # 1~10 24 3\n # 2~9 23 2\n # Unique : L - N + 1 Extra : N-K+1\n \n dp = [1] * (L-N+1)\n \n for p in range(2,N-K+1):\n for i in range(1,L-N+1):\n dp[i] += p*dp[i-1]\n \n ans = dp[-1]\n for k in range(2,N+1):\n ans = ans * k\n return ans% (10**9 + 7)\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n dp = [1] * (L-N+1)\n print(dp)\n for p in range(2, N-K+1):\n for i in range(1, L-N+1):\n \n dp[i] += dp[i-1] * p\n print((p,i, dp))\n # Multiply by N!\n ans = dp[-1]\n for k in range(2, N+1):\n ans *= k\n return ans % (10**9 + 7)\n \n",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n cache = {}\n def dp(i, j):\n if i == 0:\n return +(j == 0)\n if (i,j) in cache:\n return cache[(i,j)]\n ans = dp(i-1, j-1) * (N-j+1)\n ans += dp(i-1, j) * max(j-K, 0)\n ans %= (10**9+7)\n cache[(i,j)] = ans\n return ans\n\n return dp(L, N)",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n \n @lru_cache(None)\n def dp(i, j):\n if i == 0:\n return j == 0\n \n return (dp(i-1, j) * max(0, j - K) + dp(i-1, j-1) * (N - j + 1)) % (10**9 + 7)\n \n return dp(L, N)",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n \n dp = [[0 for n in range(N+1) ] for l in range(L+1)]\n dp[0][0] = 1\n for l in range(1, L+1):\n for n in range(1, N+1):\n dp[l][n] += dp[l-1][n-1] * (N-n+1)\n dp[l][n] += dp[l-1][n] * max(n-K, 0)\n dp [l][n] = dp [l][n] % (10 **9+7)\n return dp[L][N]",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [[0] * (N + 1) for _ in range(L + 1)]\n dp[0][0] = 1;\n for l in range(1, L + 1):\n for n in range(1, N + 1):\n dp[l][n] += dp[l - 1][n - 1] * (N - n + 1)\n dp[l][n] += dp[l - 1][n] * max(n - K, 0)\n dp[l][n] = dp[l][n] % (1000000007)\n return dp[L][N]",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n mod = 10**9 + 7\n memo = {}\n # helper(i,j) returns the number of playlists of len i\n # that have exactly j unique songs\n def helper(i, j):\n nonlocal N, K\n if i==0:\n if j==0:\n # base case\n # helper(0,0) returns 1\n return 1\n else:\n return 0\n if (i,j) in memo:\n return memo[(i,j)]\n ans = 0\n # the jth song is unique,\n # then the jth song has (N-(j-1)) possibilities\n ans += helper(i-1, j-1)*(N-(j-1))\n # the jth song is not unique\n # it is the same as one of the previous songs\n # then the jth song has max(0, j-K) possibilities\n # since it can be the same as the previous K songs\n ans += helper(i-1, j)*max(0, j-K)\n memo[(i,j)]=ans%mod\n return ans%mod\n return helper(L, N)",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n memo = {}\n def dp(i, j):\n if i == 0: return 1 if j == 0 else 0\n if (i, j) in memo: return memo[(i, j)]\n # non repeat\n ans = dp(i - 1, j - 1) * (N - (j - 1))\n # repeat\n ans += dp(i - 1, j) * max(0, j - K)\n memo[(i, j)] = ans % (10 ** 9 + 7)\n return memo[(i, j)]\n return dp(L, N)",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n memo = {}\n def dp(i, j):\n if i == 0: return 1 if j == 0 else 0\n if (i, j) in memo: return memo[(i, j)]\n # non repeat\n ans = dp(i - 1, j - 1) * (N - (j - 1))\n # repeat\n ans += dp(i - 1, j) * max(0, j - K)\n memo[(i, j)] = ans % (10 ** 9 + 7)\n return memo[(i, j)]\n return dp(L, N)\n# from functools import lru_cache\n\n# class Solution:\n# def numMusicPlaylists(self, N, L, K):\n# @lru_cache(None)\n# def dp(i, j):\n# if i == 0:\n# return +(j == 0)\n# ans = dp(i-1, j-1) * (N-j+1)\n# ans += dp(i-1, j) * max(j-K, 0)\n# return ans % (10**9+7)\n\n# return dp(L, N)\n",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n @lru_cache(None)\n def dp(i, j):\n if i == 0:\n return +(j == 0)\n ans = dp(i-1, j-1) * (N-j+1)\n ans += dp(i-1, j) * max(j-K, 0)\n return ans % (10**9+7)\n\n return dp(L, N)",
"from functools import lru_cache\nclass Solution:\n def numMusicPlaylists(self, N, L, K):\n @lru_cache(None)\n def dp(i, j):\n if i == 0:\n return +(j == 0)\n ans = dp(i-1, j-1) * (N-j+1)\n ans += dp(i-1, j) * (j-min(K, i-1))\n return ans % (10**9+7)\n\n return dp(L, N)\n \n \n",
"from functools import lru_cache\n\nclass Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n # Dynamic Programming\n # Let dp[i][j] be the number of playlists of length i that have exactly j unique songs.\n # Time complexity: O(NL)\n # Space complexity: O(NL)\n @lru_cache(None)\n def dp(i, j):\n if i == 0:\n return +(j == 0)\n ans = dp(i - 1, j - 1) * (N - j + 1)\n ans += dp(i - 1, j) * max(j - K, 0)\n return ans % (10**9 + 7)\n\n return dp(L, N)\n\n",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [[0 for j in range(L+1)] for i in range(N+1)]\n for i in range(K+1, N+1):\n for j in range(i, L+1):\n if i == j or i == K+1:\n dp[i][j] = math.factorial(i)\n else:\n dp[i][j] = dp[i-1][j-1]*i + dp[i][j-1]*(i-K)\n return dp[N][L]%(10**9+7)\n",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n '''\n construct a 2d dp[i][j] where i is i different songs and\n j is the length of the playlist, also track the remaining songs r:\n for dp update, we have two options:\n if i <= k:\n 1. add a new song to the list, r -= 1\n else:\n if r > L-j\n 1. add a new song to the list, r -= 1\n 2. add an existing song\n else:\n 1. add a new song\n ''' \n @lru_cache(None)\n def dp(unique, total, r):\n if total == L:\n return 1\n if unique <= K:\n return r * dp(unique+1, total+1, r-1)\n else:\n ans = 0\n if r < L-total:\n # add an existing song\n ans += (unique-K) * dp(unique, total+1, r)\n # add a new song\n ans += r * dp(unique+1, total+1, r-1)\n return ans\n\n return dp(0, 0, N) % (10**9+7)",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n dp = [[0 for i in range(L + 1)] for j in range(N + 1)]\n for i in range(K + 1, N + 1):\n for j in range(i, L + 1):\n if i == j or i == K + 1:\n dp[i][j] = math.factorial(i)\n else:\n dp[i][j] = dp[i - 1][j - 1] * i + dp[i][j - 1] * (i - K)\n return dp[N][L] % (10**9 + 7)",
"class Solution:\n import math\n from functools import lru_cache\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n MOD = 1000000007\n\n @lru_cache(maxsize=None)\n def rec(n, l):\n if l < n or n <= K:\n return 0\n elif l == n:\n return math.factorial(n) % MOD\n return (n * rec(n - 1, l - 1) + (n - K) * rec(n, l - 1)) % MOD\n\n return rec(N, L)",
"class Solution:\n def numMusicPlaylists(self, N: int, L: int, K: int) -> int:\n MOD = 10 ** 9 + 7\n @lru_cache(None)\n def dp(i, j):\n if i < j: return 0\n if i == 0:\n return 1 if j == 0 else 0\n if i == j:\n return (math.factorial(N) // math.factorial(N - j)) % MOD\n a = dp(i - 1, j - 1) * (N - j + 1)\n a += dp(i - 1, j) * (j - K if j > K else 0)\n return a % MOD\n return dp(L, N)\n \n"
] | 36 |
[
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35
] |
[
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
124 |
Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
(i.e., [0,0,1,2,2,5,6] might become [2,5,6,0,0,1,2]).
You are given a target value to search. If found in the array return true, otherwise return false.
Example 1:
Input: nums = [2,5,6,0,0,1,2], target = 0
Output: true
Example 2:
Input: nums = [2,5,6,0,0,1,2], target = 3
Output: false
Follow up:
This is a follow up problem to Search in Rotated Sorted Array, where nums may contain duplicates.
Would this affect the run-time complexity? How and why?
|
["class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n return target in nums\n", "class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n l,r = 0, len(nums) -1\n while l <= r:\n m = l+(r-l)//2\n if nums[m] == target: return True\n while nums[m] == nums[l] and l < m:\n l += 1\n \n if nums[l] <= nums[m]:#[l,m] is sorted\n if nums[l] <= target < nums[m]:\n r = m - 1\n else:\n l = m+1\n else:\n if nums[m] < target <= nums[r]:\n l = m + 1\n else:\n r = m - 1\n return False\n", "class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n low = 0\n high = len(nums)-1\n while low<=high:\n mid = (low+high)//2\n if nums[mid]==target:\n return True\n if nums[low]<nums[mid]:\n if nums[low]<=target and nums[mid]>target:\n high = mid-1\n else:\n low= mid+1\n elif nums[low]>nums[mid]:\n if nums[mid]<target and nums[high]>=target:\n low= mid+1\n else:\n high = mid -1\n else:\n low+=1\n return False\n", "class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n left, right = 0, len(nums)-1\n while left <= right:\n mid = (left+right) // 2\n if nums[mid] == target:\n return True\n elif nums[mid] > nums[left]:\n if target >= nums[left] and target < nums[mid]:\n right = mid\n else:\n left = mid + 1\n elif nums[mid] < nums[left]:\n if target > nums[mid] and target <= nums[right]:\n left = mid + 1\n else:\n right = mid\n else:\n left = left + 1\n \n return False", "class Solution:\n res = False\n \n def searchR(self, nums, target, start, end):\n if(start > end or self.res == True):\n return self.res\n else:\n mid = int((start + end) / 2)\n print(\"Mid index: %d, Mid val: %d, Target: %d\" % (mid, nums[mid], target))\n if(nums[mid] == target):\n self.res = True\n elif(nums[start] <= nums[mid]):\n if(nums[mid] == nums[end]):\n self.searchR(nums, target, start, mid - 1)\n self.searchR(nums, target, mid+1, end)\n elif (target >= nums[start] and target <= nums[mid]):\n self.searchR(nums, target, start, mid - 1)\n else:\n self.searchR(nums, target, mid+1, end)\n else:\n print(\"Here\")\n if (target >= nums[mid] and target <= nums[end]):\n self.searchR(nums, target, mid + 1, end)\n else:\n self.searchR(nums, target, start, mid - 1)\n return self.res\n \n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n res = self.searchR(nums, target, 0, (len(nums) - 1))\n return res", "class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n \n return self.bsearch(nums, target, 0, len(nums)-1)\n \n \n def bsearch(self, nums, target, left, right):\n \n if left > right:\n return False\n \n mid = (left+right)//2\n if nums[mid] == target:\n return True\n \n #print(nums[left], nums[mid], nums[right])\n if nums[left] < nums[mid]: # left sorted\n \n if nums[left] <= target <= nums[mid]:\n return self.bsearch(nums, target, left, mid-1)\n else:\n return self.bsearch(nums, target, mid+1, right)\n \n elif nums[mid] < nums[right]: # right sorted\n \n if nums[mid] <= target <= nums[right]:\n return self.bsearch(nums, target, mid+1, right)\n else:\n return self.bsearch(nums, target, left, mid-1)\n \n elif nums[mid] == nums[left]:\n return self.bsearch(nums, target, left+1, right)\n \n elif nums[mid] == nums[right]:\n return self.bsearch(nums, target, left, right-1)\n \n \n \n", "class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n if not nums:\n return False\n left, right = 0, len(nums) - 1\n while nums[left] == nums[right] and left != right:\n right -= 1\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] == target:\n return True\n elif nums[mid] >= nums[left]:\n if target >= nums[left] and target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n else:\n if target > nums[mid] and target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n return False", "class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n start, end = 0, len(nums)-1\n while start<=end:\n mid = start+(end-start)//2\n if nums[mid]==target:\n return True\n while start<=end and nums[start]==nums[end]:\n if nums[start]==target:\n return True\n start += 1\n end -= 1\n if start>end:\n return False\n if nums[start]<nums[end]:\n #normal\n if target<nums[mid]:\n end = mid-1\n else:\n start = mid+1\n else:\n if nums[mid]<nums[start]:\n #peak between start and mid\n if target<nums[mid] or target>=nums[start]:\n end = mid-1\n else:\n start = mid+1\n else:\n #peak between mid and end\n if target>nums[mid] or target<=nums[end]:\n start = mid+1\n else:\n end = mid-1\n return False\n", "class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n if not nums:\n return False\n l, r = 0, len(nums)-1\n while l < r:\n mid = (l + r) // 2\n if nums[mid] == target:\n return True\n if nums[mid] < nums[r]:\n if nums[mid] < target <= nums[r]:\n l = mid + 1\n else:\n r = mid - 1\n elif nums[mid] > nums[r]:\n if nums[l] <= target < nums[mid]:\n r = mid - 1\n else:\n l = mid + 1\n else:\n r -= 1\n return nums[l] == target", "class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n if not nums:\n return False\n l = 0\n r = len(nums) - 1\n print((\">\", l, r))\n while l < r and nums[l] == nums[r]:\n l = l + 1\n while l <= r:\n mid = int((l + r + 1) / 2)\n if target == nums[mid]:\n return True\n if target < nums[mid]:\n if target == nums[l]:\n return True\n elif target > nums[l]:\n r = mid - 1\n elif target < nums[l]:\n if nums[l] <= nums[mid]:\n l = mid + 1\n elif nums[l] > nums[mid]:\n r = mid - 1\n if target > nums[mid]:\n if target == nums[r]:\n return True\n elif target > nums[r]:\n if nums[mid] >= nums[l]:\n l = mid + 1\n elif nums[mid] < nums[l]:\n r = mid - 1\n elif target < nums[r]:\n l = mid + 1\n return False\n \n \n", "class Solution:\n def recursive(self, nums, left, right , target):\n print((left, right))\n if left > right:\n return False\n if left == right:\n return nums[left] == target\n if left + 1 == right:\n return nums[left] == target or nums[right] == target\n mid = (left + right) // 2\n if nums[mid] == target:\n return True\n if nums[mid] == nums[left] and nums[mid] == nums[right]:\n return self.recursive(nums, mid, right, target) or self.recursive(nums, left, mid, target)\n else:\n if nums[mid] < target:\n if nums[right] >= target or (nums[left] <= nums[mid] and nums[mid] >= nums[right]):\n return self.recursive(nums, mid, right, target)\n else:\n return self.recursive(nums, left, mid, target)\n else:\n if nums[left] <=target or (nums[right] >= nums[mid] and nums[mid] <= nums[left]):\n return self.recursive(nums, left, mid, target)\n else:\n return self.recursive(nums, mid, right, target)\n \n \n \n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n return self.recursive(nums, 0, len(nums) - 1, target)\n", "class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n if len(nums) == 0:\n return False\n def binary_search(leftIndex, rightIndex):\n midIndex = int((rightIndex+leftIndex)/2)\n if nums[midIndex] == target:\n return True\n if leftIndex > rightIndex:\n return False\n return binary_search(leftIndex, midIndex-1) or binary_search(midIndex+1, rightIndex)\n return binary_search(0, len(nums)-1)\n", "class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n l, r = 0, len(nums) - 1\n while l <= r:\n mid = l + (r - l)//2\n \n if nums[mid] == target:\n return True\n \n while nums[mid] == nums[r]:\n r -= 1\n mid = l + (r - l)//2\n if r < 0:\n return False\n \n if nums[mid] == target:\n return True\n \n if nums[mid] <= nums[r]:\n if target > nums[mid] and target <= nums[r]:\n l = mid + 1\n else:\n r = mid - 1\n else:\n if target < nums[mid] and target >= nums[l]:\n r = mid - 1\n else:\n l = mid + 1\n \n \n return False", "class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n if (not nums):\n return False\n i = 0\n while (i + 1 < len(nums) and nums[i] == nums[i + 1]):\n i += 1\n if (i + 1 == len(nums)):\n # nums\u4e2d\u6240\u6709\u5143\u7d20\u76f8\u7b49\n return nums[0] == target\n \n # \u627e\u5230\u6700\u5927\u5143\u7d20\u7684\u4f4d\u7f6e\n l, r = i, len(nums) - 1\n while (l + 1 < r):\n mid = l + (r - l) // 2\n if (nums[i] < nums[mid]):\n l = mid\n else:\n r = mid - 1\n highest_pos = l if (nums[l] > nums[r]) else r\n \n if (target >= nums[0]):\n return self._binarySearch(nums, 0, highest_pos, target)\n else:\n return self._binarySearch(nums, highest_pos + 1, len(nums) - 1, target)\n \n \n def _binarySearch(self, nums, l, r, target):\n while (l <= r):\n mid = l + (r - l) // 2\n if (nums[mid] < target):\n l = mid + 1\n elif (nums[mid] > target):\n r = mid - 1\n else:\n return True\n return False\n", "class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n for i in nums:\n if i == target:\n return True\n \n return False"]
|
{"fn_name": "search", "inputs": [[[2, 5, 6, 0, 0, 1, 2], 0]], "outputs": [true]}
|
interview
|
https://leetcode.com/problems/search-in-rotated-sorted-array-ii/
|
class Solution:
def search(self, nums: List[int], target: int) -> bool:
|
[
"class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n return target in nums\n",
"class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n l,r = 0, len(nums) -1\n while l <= r:\n m = l+(r-l)//2\n if nums[m] == target: return True\n while nums[m] == nums[l] and l < m:\n l += 1\n \n if nums[l] <= nums[m]:#[l,m] is sorted\n if nums[l] <= target < nums[m]:\n r = m - 1\n else:\n l = m+1\n else:\n if nums[m] < target <= nums[r]:\n l = m + 1\n else:\n r = m - 1\n return False\n",
"class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n low = 0\n high = len(nums)-1\n while low<=high:\n mid = (low+high)//2\n if nums[mid]==target:\n return True\n if nums[low]<nums[mid]:\n if nums[low]<=target and nums[mid]>target:\n high = mid-1\n else:\n low= mid+1\n elif nums[low]>nums[mid]:\n if nums[mid]<target and nums[high]>=target:\n low= mid+1\n else:\n high = mid -1\n else:\n low+=1\n return False\n",
"class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n left, right = 0, len(nums)-1\n while left <= right:\n mid = (left+right) // 2\n if nums[mid] == target:\n return True\n elif nums[mid] > nums[left]:\n if target >= nums[left] and target < nums[mid]:\n right = mid\n else:\n left = mid + 1\n elif nums[mid] < nums[left]:\n if target > nums[mid] and target <= nums[right]:\n left = mid + 1\n else:\n right = mid\n else:\n left = left + 1\n \n return False",
"class Solution:\n res = False\n \n def searchR(self, nums, target, start, end):\n if(start > end or self.res == True):\n return self.res\n else:\n mid = int((start + end) / 2)\n print(\"Mid index: %d, Mid val: %d, Target: %d\" % (mid, nums[mid], target))\n if(nums[mid] == target):\n self.res = True\n elif(nums[start] <= nums[mid]):\n if(nums[mid] == nums[end]):\n self.searchR(nums, target, start, mid - 1)\n self.searchR(nums, target, mid+1, end)\n elif (target >= nums[start] and target <= nums[mid]):\n self.searchR(nums, target, start, mid - 1)\n else:\n self.searchR(nums, target, mid+1, end)\n else:\n print(\"Here\")\n if (target >= nums[mid] and target <= nums[end]):\n self.searchR(nums, target, mid + 1, end)\n else:\n self.searchR(nums, target, start, mid - 1)\n return self.res\n \n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n res = self.searchR(nums, target, 0, (len(nums) - 1))\n return res",
"class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n \n return self.bsearch(nums, target, 0, len(nums)-1)\n \n \n def bsearch(self, nums, target, left, right):\n \n if left > right:\n return False\n \n mid = (left+right)//2\n if nums[mid] == target:\n return True\n \n #print(nums[left], nums[mid], nums[right])\n if nums[left] < nums[mid]: # left sorted\n \n if nums[left] <= target <= nums[mid]:\n return self.bsearch(nums, target, left, mid-1)\n else:\n return self.bsearch(nums, target, mid+1, right)\n \n elif nums[mid] < nums[right]: # right sorted\n \n if nums[mid] <= target <= nums[right]:\n return self.bsearch(nums, target, mid+1, right)\n else:\n return self.bsearch(nums, target, left, mid-1)\n \n elif nums[mid] == nums[left]:\n return self.bsearch(nums, target, left+1, right)\n \n elif nums[mid] == nums[right]:\n return self.bsearch(nums, target, left, right-1)\n \n \n \n",
"class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n if not nums:\n return False\n left, right = 0, len(nums) - 1\n while nums[left] == nums[right] and left != right:\n right -= 1\n while left <= right:\n mid = (left + right) // 2\n if nums[mid] == target:\n return True\n elif nums[mid] >= nums[left]:\n if target >= nums[left] and target < nums[mid]:\n right = mid - 1\n else:\n left = mid + 1\n else:\n if target > nums[mid] and target <= nums[right]:\n left = mid + 1\n else:\n right = mid - 1\n return False",
"class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n start, end = 0, len(nums)-1\n while start<=end:\n mid = start+(end-start)//2\n if nums[mid]==target:\n return True\n while start<=end and nums[start]==nums[end]:\n if nums[start]==target:\n return True\n start += 1\n end -= 1\n if start>end:\n return False\n if nums[start]<nums[end]:\n #normal\n if target<nums[mid]:\n end = mid-1\n else:\n start = mid+1\n else:\n if nums[mid]<nums[start]:\n #peak between start and mid\n if target<nums[mid] or target>=nums[start]:\n end = mid-1\n else:\n start = mid+1\n else:\n #peak between mid and end\n if target>nums[mid] or target<=nums[end]:\n start = mid+1\n else:\n end = mid-1\n return False\n",
"class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n if not nums:\n return False\n l, r = 0, len(nums)-1\n while l < r:\n mid = (l + r) // 2\n if nums[mid] == target:\n return True\n if nums[mid] < nums[r]:\n if nums[mid] < target <= nums[r]:\n l = mid + 1\n else:\n r = mid - 1\n elif nums[mid] > nums[r]:\n if nums[l] <= target < nums[mid]:\n r = mid - 1\n else:\n l = mid + 1\n else:\n r -= 1\n return nums[l] == target",
"class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n if not nums:\n return False\n l = 0\n r = len(nums) - 1\n print((\">\", l, r))\n while l < r and nums[l] == nums[r]:\n l = l + 1\n while l <= r:\n mid = int((l + r + 1) / 2)\n if target == nums[mid]:\n return True\n if target < nums[mid]:\n if target == nums[l]:\n return True\n elif target > nums[l]:\n r = mid - 1\n elif target < nums[l]:\n if nums[l] <= nums[mid]:\n l = mid + 1\n elif nums[l] > nums[mid]:\n r = mid - 1\n if target > nums[mid]:\n if target == nums[r]:\n return True\n elif target > nums[r]:\n if nums[mid] >= nums[l]:\n l = mid + 1\n elif nums[mid] < nums[l]:\n r = mid - 1\n elif target < nums[r]:\n l = mid + 1\n return False\n \n \n",
"class Solution:\n def recursive(self, nums, left, right , target):\n print((left, right))\n if left > right:\n return False\n if left == right:\n return nums[left] == target\n if left + 1 == right:\n return nums[left] == target or nums[right] == target\n mid = (left + right) // 2\n if nums[mid] == target:\n return True\n if nums[mid] == nums[left] and nums[mid] == nums[right]:\n return self.recursive(nums, mid, right, target) or self.recursive(nums, left, mid, target)\n else:\n if nums[mid] < target:\n if nums[right] >= target or (nums[left] <= nums[mid] and nums[mid] >= nums[right]):\n return self.recursive(nums, mid, right, target)\n else:\n return self.recursive(nums, left, mid, target)\n else:\n if nums[left] <=target or (nums[right] >= nums[mid] and nums[mid] <= nums[left]):\n return self.recursive(nums, left, mid, target)\n else:\n return self.recursive(nums, mid, right, target)\n \n \n \n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n return self.recursive(nums, 0, len(nums) - 1, target)\n",
"class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n if len(nums) == 0:\n return False\n def binary_search(leftIndex, rightIndex):\n midIndex = int((rightIndex+leftIndex)/2)\n if nums[midIndex] == target:\n return True\n if leftIndex > rightIndex:\n return False\n return binary_search(leftIndex, midIndex-1) or binary_search(midIndex+1, rightIndex)\n return binary_search(0, len(nums)-1)\n",
"class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n l, r = 0, len(nums) - 1\n while l <= r:\n mid = l + (r - l)//2\n \n if nums[mid] == target:\n return True\n \n while nums[mid] == nums[r]:\n r -= 1\n mid = l + (r - l)//2\n if r < 0:\n return False\n \n if nums[mid] == target:\n return True\n \n if nums[mid] <= nums[r]:\n if target > nums[mid] and target <= nums[r]:\n l = mid + 1\n else:\n r = mid - 1\n else:\n if target < nums[mid] and target >= nums[l]:\n r = mid - 1\n else:\n l = mid + 1\n \n \n return False",
"class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n if (not nums):\n return False\n i = 0\n while (i + 1 < len(nums) and nums[i] == nums[i + 1]):\n i += 1\n if (i + 1 == len(nums)):\n # nums中所有元素相等\n return nums[0] == target\n \n # 找到最大元素的位置\n l, r = i, len(nums) - 1\n while (l + 1 < r):\n mid = l + (r - l) // 2\n if (nums[i] < nums[mid]):\n l = mid\n else:\n r = mid - 1\n highest_pos = l if (nums[l] > nums[r]) else r\n \n if (target >= nums[0]):\n return self._binarySearch(nums, 0, highest_pos, target)\n else:\n return self._binarySearch(nums, highest_pos + 1, len(nums) - 1, target)\n \n \n def _binarySearch(self, nums, l, r, target):\n while (l <= r):\n mid = l + (r - l) // 2\n if (nums[mid] < target):\n l = mid + 1\n elif (nums[mid] > target):\n r = mid - 1\n else:\n return True\n return False\n",
"class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: bool\n \"\"\"\n for i in nums:\n if i == target:\n return True\n \n return False"
] | 15 |
[
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14
] |
[
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
125 |
Your task is to calculate ab mod 1337 where a is a positive integer and b is an extremely large positive integer given in the form of an array.
Example1:
a = 2
b = [3]
Result: 8
Example2:
a = 2
b = [1,0]
Result: 1024
Credits:Special thanks to @Stomach_ache for adding this problem and creating all test cases.
|
["class Solution:\n def superPow(self, a, b):\n result = 1\n fermatb = (int(''.join(map(str, b)))) % 570\n while fermatb:\n if fermatb & 1:\n result = (result * a) % 1337\n a = (a * a) % 1337\n fermatb >>= 1\n return result", "class Solution:\n def superPow(self, a, b):\n return pow(a, int(''.join(map(str, b))), 1337)", "class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n \"\"\"\n \n res = a**b[0]\n for i in range(1, len(b)):\n res = res**10 % 1337 * a**b[i] % 1337 % 1337\n return res", "class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n \"\"\"\n b.reverse()\n p = b.pop()\n res = pow(a,p) % 1337\n while b:\n p = b.pop()\n res = pow(res,10) % 1337\n res = res * pow(a,p) % 1337\n return res\n", "class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n \"\"\"\n temp1 = a\n temp = 1\n for i in range(len(b)-1,-1,-1):\n if i<len(b)-1:\n temp1 = pow(temp1,10) % 1337\n temp2 = pow(temp1,b[i]) % 1337\n temp = temp * temp2 % 1337\n return temp\n", "class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n \"\"\"\n from functools import reduce\n return 0 if a % 1337 == 0 else pow(a, reduce(lambda x, y: (x * 10 + y) % 1140, b) + 1140, 1337)", "class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n \"\"\"\n def eular(mod):\n res, a = mod, mod\n i = 2\n while i * i <= a:\n if a % i == 0:\n res = res // i * (i - 1)\n while a % i == 0:\n a //= i\n i += 1\n if a > 1:\n res = res // a * (a - 1)\n return res\n def qpow(x, n, mod):\n res = 1\n while n > 0:\n if n&1 != 0:\n res = res * x % mod\n x = x * x % mod\n n >>= 1\n return res\n \n phi = eular(1337)\n n = 0\n for num in b:\n n = (n*10 % phi + num) % phi\n return qpow(a, n, 1337)", "class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n \"\"\"\n a, b = a % 1337, int(\"\".join([str(i) for i in b]))\n base, temp, extra = {1: a}, 1, {a: 1}\n for temp in range(2, 1338):\n rem = base[temp - 1] * a % 1337\n if rem in extra:\n start = extra[rem]\n length = temp - start\n break\n else:\n base[temp] = rem\n extra[rem] = temp\n if b in base:\n return base[b]\n return base[start + (b - start) % length]", "class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n \"\"\"\n return pow(a, int(''.join(map(str, b))), 1337)\n # from functools import reduce\n # k=reduce(lambda x,y:x*10+y, b)\n # print(k)\n # return (a%1337)**k\n", "class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n \"\"\"\n # return pow(a, int(''.join(map(str, b))), 1337)\n from functools import reduce\n k=reduce(lambda x,y:x*10+y, b)\n # print(k)\n # return pow(a,k)%1337\n return pow(a, k, 1337)", "class Solution:\n def superPow(self, a, b):\n num = 0\n currentpow = 1\n for item in b[::-1]:\n num += currentpow * item\n currentpow *= 10\n return self.binpow(a, num % 570)\n \n def binpow(self, n, p):\n if(p == 0):\n return 1\n if(p % 2 == 0):\n return (self.binpow(n * n, p // 2)) % 1337\n return (n * self.binpow(n, p - 1)) % 1337", "class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n a %= 1337\n if len(b) == 1:\n return self.powMod(a, b[0])\n return self.powMod(self.superPow(a, b[:-1]), 10) * self.powMod(a, b[-1]) % 1337\n \"\"\"\n res = 1\n x = a % 1337\n for y in b[::-1]:\n res = (res * (x ** y)) % 1337\n x = (x ** 10) % 1337\n return res\n", "class Solution:\n def superPow(self, a, b):\n result = 1\n fermatb = (int(''.join(map(str, b)))) % 570\n while fermatb:\n if fermatb & 1:\n result = (result * a) % 1337\n a = (a * a) % 1337\n fermatb >>= 1\n return result", "class Solution:\n def superPow(self, a, b):\n result = 1\n x = a % 1337\n for y in b[::-1]:\n result = (result * (x**y)) % 1337\n x = (x**10) % 1337\n return result"]
|
{"fn_name": "superPow", "inputs": [[2, [3]]], "outputs": [8]}
|
interview
|
https://leetcode.com/problems/super-pow/
|
class Solution:
def superPow(self, a: int, b: List[int]) -> int:
|
[
"class Solution:\n def superPow(self, a, b):\n result = 1\n fermatb = (int(''.join(map(str, b)))) % 570\n while fermatb:\n if fermatb & 1:\n result = (result * a) % 1337\n a = (a * a) % 1337\n fermatb >>= 1\n return result",
"class Solution:\n def superPow(self, a, b):\n return pow(a, int(''.join(map(str, b))), 1337)",
"class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n \"\"\"\n \n res = a**b[0]\n for i in range(1, len(b)):\n res = res**10 % 1337 * a**b[i] % 1337 % 1337\n return res",
"class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n \"\"\"\n b.reverse()\n p = b.pop()\n res = pow(a,p) % 1337\n while b:\n p = b.pop()\n res = pow(res,10) % 1337\n res = res * pow(a,p) % 1337\n return res\n",
"class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n \"\"\"\n temp1 = a\n temp = 1\n for i in range(len(b)-1,-1,-1):\n if i<len(b)-1:\n temp1 = pow(temp1,10) % 1337\n temp2 = pow(temp1,b[i]) % 1337\n temp = temp * temp2 % 1337\n return temp\n",
"class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n \"\"\"\n from functools import reduce\n return 0 if a % 1337 == 0 else pow(a, reduce(lambda x, y: (x * 10 + y) % 1140, b) + 1140, 1337)",
"class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n \"\"\"\n def eular(mod):\n res, a = mod, mod\n i = 2\n while i * i <= a:\n if a % i == 0:\n res = res // i * (i - 1)\n while a % i == 0:\n a //= i\n i += 1\n if a > 1:\n res = res // a * (a - 1)\n return res\n def qpow(x, n, mod):\n res = 1\n while n > 0:\n if n&1 != 0:\n res = res * x % mod\n x = x * x % mod\n n >>= 1\n return res\n \n phi = eular(1337)\n n = 0\n for num in b:\n n = (n*10 % phi + num) % phi\n return qpow(a, n, 1337)",
"class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n \"\"\"\n a, b = a % 1337, int(\"\".join([str(i) for i in b]))\n base, temp, extra = {1: a}, 1, {a: 1}\n for temp in range(2, 1338):\n rem = base[temp - 1] * a % 1337\n if rem in extra:\n start = extra[rem]\n length = temp - start\n break\n else:\n base[temp] = rem\n extra[rem] = temp\n if b in base:\n return base[b]\n return base[start + (b - start) % length]",
"class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n \"\"\"\n return pow(a, int(''.join(map(str, b))), 1337)\n # from functools import reduce\n # k=reduce(lambda x,y:x*10+y, b)\n # print(k)\n # return (a%1337)**k\n",
"class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n \"\"\"\n # return pow(a, int(''.join(map(str, b))), 1337)\n from functools import reduce\n k=reduce(lambda x,y:x*10+y, b)\n # print(k)\n # return pow(a,k)%1337\n return pow(a, k, 1337)",
"class Solution:\n def superPow(self, a, b):\n num = 0\n currentpow = 1\n for item in b[::-1]:\n num += currentpow * item\n currentpow *= 10\n return self.binpow(a, num % 570)\n \n def binpow(self, n, p):\n if(p == 0):\n return 1\n if(p % 2 == 0):\n return (self.binpow(n * n, p // 2)) % 1337\n return (n * self.binpow(n, p - 1)) % 1337",
"class Solution:\n def superPow(self, a, b):\n \"\"\"\n :type a: int\n :type b: List[int]\n :rtype: int\n a %= 1337\n if len(b) == 1:\n return self.powMod(a, b[0])\n return self.powMod(self.superPow(a, b[:-1]), 10) * self.powMod(a, b[-1]) % 1337\n \"\"\"\n res = 1\n x = a % 1337\n for y in b[::-1]:\n res = (res * (x ** y)) % 1337\n x = (x ** 10) % 1337\n return res\n",
"class Solution:\n def superPow(self, a, b):\n result = 1\n fermatb = (int(''.join(map(str, b)))) % 570\n while fermatb:\n if fermatb & 1:\n result = (result * a) % 1337\n a = (a * a) % 1337\n fermatb >>= 1\n return result",
"class Solution:\n def superPow(self, a, b):\n result = 1\n x = a % 1337\n for y in b[::-1]:\n result = (result * (x**y)) % 1337\n x = (x**10) % 1337\n return result"
] | 14 |
[
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13
] |
[
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
126 | "Given a string s, return the maximum number of ocurrences of any substring under the following rul(...TRUNCATED) | "[\"class Solution:\\n def maxFreq(self, s: str, maxLetters: int, minSize: int, maxSize: int) -> (...TRUNCATED) |
{"fn_name": "maxFreq", "inputs": [["\"aababcaab\"", 2, 3, 4]], "outputs": [2]}
|
interview
|
https://leetcode.com/problems/maximum-number-of-occurrences-of-a-substring/
| "\nclass Solution:\n def maxFreq(self, s: str, maxLetters: int, minSize: int, maxSize: int) -> in(...TRUNCATED) | ["class Solution:\n def maxFreq(self, s: str, maxLetters: int, minSize: int, maxSize: int) -> int(...TRUNCATED) | 205 | [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,3(...TRUNCATED) | [null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null(...TRUNCATED) | false |
127 | "There is a group of G members, and a list of various crimes they could commit.\nThe ith crime gen(...TRUNCATED) | "[\"class Solution:\\n def profitableSchemes(self, G: int, P: int, group: List[int], profit: List(...TRUNCATED) |
{"fn_name": "profitableSchemes", "inputs": [[5, 3, [2, 2], [2, 3]]], "outputs": [2]}
|
interview
|
https://leetcode.com/problems/profitable-schemes/
| "\nclass Solution:\n def profitableSchemes(self, G: int, P: int, group: List[int], profit: List[i(...TRUNCATED) | ["class Solution:\n def profitableSchemes(self, G: int, P: int, group: List[int], profit: List[in(...TRUNCATED) | 74 | [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,3(...TRUNCATED) | [null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null(...TRUNCATED) | false |
128 | "Implement a basic calculator to evaluate a simple expression string.\n\nThe expression string may c(...TRUNCATED) | "[\"class Solution:\\n def calculate(self, s):\\n \\\"\\\"\\\"\\n :type s: str\\(...TRUNCATED) |
{"fn_name": "calculate", "inputs": [["\"1 + 1\""]], "outputs": [2]}
|
interview
|
https://leetcode.com/problems/basic-calculator/
|
class Solution:
def calculate(self, s: str) -> int:
| ["class Solution:\n def calculate(self, s):\n \"\"\"\n :type s: str\n :r(...TRUNCATED) | 7 |
[
0,
1,
2,
3,
4,
5,
6
] |
[
null,
null,
null,
null,
null,
null,
null
] | false |
129 | "Given an array A of positive integers, A[i] represents the value of the i-th sightseeing spot, and (...TRUNCATED) | "[\"class Solution:\\n def maxScoreSightseeingPair(self, A: List[int]) -> int:\\n curmaxsi(...TRUNCATED) |
{"fn_name": "maxScoreSightseeingPair", "inputs": [[[8, 1, 5, 2, 6]]], "outputs": [11]}
|
interview
|
https://leetcode.com/problems/best-sightseeing-pair/
|
class Solution:
def maxScoreSightseeingPair(self, A: List[int]) -> int:
| ["class Solution:\n def maxScoreSightseeingPair(self, A: List[int]) -> int:\n curmaxsight (...TRUNCATED) | 78 | [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,3(...TRUNCATED) | [null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null(...TRUNCATED) | false |
130 | "A program was supposed to print an array of integers. The program forgot to print whitespaces and t(...TRUNCATED) | "[\"class Solution:\\n def numberOfArrays(self, s: str, k: int) -> int:\\n dp = [-1] * len(...TRUNCATED) |
{"fn_name": "numberOfArrays", "inputs": [["\"1000\"", 10000]], "outputs": [4]}
|
interview
|
https://leetcode.com/problems/restore-the-array/
|
class Solution:
def numberOfArrays(self, s: str, k: int) -> int:
| ["class Solution:\n def numberOfArrays(self, s: str, k: int) -> int:\n dp = [-1] * len(s)\(...TRUNCATED) | 9 |
[
0,
1,
2,
3,
4,
5,
6,
7,
8
] |
[
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
131 | "You are given a string expression representing a Lisp-like expression to return the integer value o(...TRUNCATED) | "[\"class Solution(object):\\n \\tdef parse(self,expression,d,i):\\n \\t\\tcount = 0\\n \\t\\tstart (...TRUNCATED) |
{"fn_name": "evaluate", "inputs": [["\"(add 1 2)\""]], "outputs": [2]}
|
interview
|
https://leetcode.com/problems/parse-lisp-expression/
|
class Solution:
def evaluate(self, expression: str) -> int:
| ["class Solution(object):\n \tdef parse(self,expression,d,i):\n \t\tcount = 0\n \t\tstart = i\n \t\t(...TRUNCATED) | 1 |
[
0
] |
[
null
] | false |
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 916