int:\n # Maximum Sum Circular Subarray\n # 8/22/20 3:41\n total, maxSum = 0, A[0]\n curMax, minSum, curMin = 0, A[0], 0\n for a in A:\n curMax = max(curMax + a, a)\n maxSum = max(maxSum, curMax)\n curMin = min(curMin + a, a)\n minSum = min(minSum, curMin)\n total += a\n return max(maxSum, total - minSum) if total != minSum else maxSum\n \n \n\n# input: [5,-3,5]\n# Output:7\n# Expected:10\n\n \n \n \n \n \n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n maxsum = minsum = A[0]\n curmax = curmin = total = 0\n \n for num in A:\n curmax = max(num, curmax + num)\n maxsum = max(maxsum, curmax)\n curmin = min(num, curmin + num)\n minsum = min(minsum, curmin)\n total += num\n \n return max(maxsum, total - minsum) if maxsum > 0 else maxsum","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n curmax, curmin = 0 , 0\n total = 0\n maxsum = minsum = A[0]\n \n for num in A:\n curmax = max(num, curmax + num)\n maxsum = max(maxsum, curmax)\n curmin = min(num, curmin + num)\n minsum = min(minsum, curmin)\n total += num\n return max(maxsum, total - minsum) if maxsum > 0 else maxsum","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n maxSubarraySum = [i for i in A]\n minSubarraySum = [i for i in A]\n for i in range(1,len(A)):\n maxSubarraySum[i] = max(maxSubarraySum[i-1]+A[i],A[i])\n for i in range(1,len(A)):\n minSubarraySum[i] = min(minSubarraySum[i-1]+A[i],A[i])\n return max(max(maxSubarraySum),sum(A)-min(minSubarraySum)) if max(maxSubarraySum) >0 else max(maxSubarraySum)","class Solution:\n def maxSubarraySumCircular(self, A):\n n = len(A)\n S = sum(A)\n m1 = self.kadane(A)\n m2 = S + self.kadane([-A[i] for i in range(1, n)])\n m3 = S + self.kadane([-A[i] for i in range(n-1)])\n return max(m1, m2, m3)\n \n def kadane(self, arr):\n res = cur = -float('inf')\n for a in arr:\n cur = a + max(0, cur)\n res = max(cur, res)\n return res\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n n = len(A)\n B = [0]+A+A\n for i in range(1, len(B)):\n B[i] += B[i-1]\n maxv = B[1]\n \n stack = [0]\n for end in range(1, len(B)):\n num = B[end]\n while stack and num < B[stack[-1]]:\n stack.pop()\n stack.append(end)\n if end-stack[0] == n+1:\n stack.pop(0)\n maxv = max(num-B[stack[0]], maxv)\n #print(end, stack, maxv)\n if all(x<0 for x in A):\n return max(A)\n return maxv\n \n \n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n if A == None or len(A) == 0:\n return 0\n max_sum , min_sum , total = -100000000, 1000000000, 0\n curr_max_sum, curr_min_sum = 0, 0\n for i in A:\n curr_max_sum += i\n max_sum = max(curr_max_sum, max_sum)\n curr_max_sum = max(curr_max_sum, 0)\n curr_min_sum += i\n min_sum = min(curr_min_sum, min_sum)\n curr_min_sum = min(curr_min_sum, 0)\n total += i\n return max_sum if max_sum < 0 else max(max_sum, total-min_sum)\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n #naive will be n^2: try every possible start position\n \n #3 cases\n \n minSum = A[0]\n maxSum = A[0]\n maximum = A[0]\n minimum = A[0]\n for i in range(1, len(A)):\n if A[i] > maxSum + A[i]:\n maxSum = A[i]\n else:\n maxSum += A[i]\n maximum = max(maximum, maxSum)\n if A[i] < minSum + A[i]:\n minSum = A[i]\n else:\n minSum += A[i]\n minimum = min(minimum, minSum)\n \n minimum = sum(A) - minimum\n if minimum == 0: #means the entire araay is negative, so we take the max element\n return maximum\n return max(maximum, minimum)\n \n #take the max of 3 cases\n #1. maximum\n #2. total - minimum\n #3. if all negatives, then the max should be the maximum\n \n #[-2,-3,-1]. Take a look at this case, for example. \n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n maxSum=A[0]\n minSum=A[0]\n currMax=0\n currMin=0\n total=0\n for a in A:\n currMax=max(currMax+a,a)\n maxSum=max(currMax,maxSum)\n currMin=min(currMin+a,a)\n minSum=min(currMin,minSum)\n total+=a\n return max(maxSum,total-minSum) if maxSum>0 else maxSum","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n mx = float('-inf')\n curr = 0\n for x in A:\n if curr >= 0:\n curr += x\n else:\n curr = x\n mx = max(mx, curr)\n cumSum = []\n curr = 0\n for x in A:\n curr += x\n cumSum.append(curr)\n revCumSum = []\n curr = 0\n for x in reversed(A):\n curr += x\n revCumSum.append(curr)\n for i in range(1, len(A)):\n revCumSum[i] = max(revCumSum[i-1], revCumSum[i])\n for i in range(len(A)-1):\n mx = max(mx, cumSum[i]+revCumSum[len(A)-2-i])\n mx = max(mx, cumSum[-1])\n return mx\n \n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n max_seen = max(A)\n if max_seen < 0:\n return max_seen\n min_seen = float('inf')\n curr_max = 0\n curr_min = 0\n total = 0\n \n for num in A:\n total += num\n curr_max = max(0, curr_max + num)\n curr_min = min(0, curr_min + num)\n max_seen = max(max_seen, curr_max)\n min_seen = min(min_seen, curr_min)\n \n return max(max_seen, total - min_seen)","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n \n def maxSubarray (A):\n dp = [0] * len(A)\n max_c = A[0]\n for idx,num in enumerate(A):\n if idx != 0:\n dp[idx]=max(num, dp[idx-1] + num)\n else:\n dp[0]=num\n \n return max(dp)\n \n temp = maxSubarray(A)\n\n \n res = float('-inf')\n rightMax = [max(A[0],0)] + [0] * (len(A)-1)\n currMax = max(A[0],0)\n rightWindow = [A[0]] + [0] * (len(A)-1)\n for idx,i in enumerate(A[1:]):\n currMax = max(i+rightWindow[idx], currMax)\n rightMax[idx+1] = currMax\n rightWindow[idx+1] = i+rightWindow[idx]\n \n\n reversedA = A.reverse()\n leftWindow = [A[0]] + [0] * (len(A)-1)\n \n for idx,i in enumerate(A[1:]):\n leftWindow[idx +1] = i+leftWindow[idx]\n currMax = rightMax[len(A)-idx-2]\n res = max(res,currMax + leftWindow[idx])\n \n\n return max(res,temp)\n","from sys import maxsize\nclass Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n i=1\n n=len(A)\n # A=A+A\n # end = n\n ans = A[0]\n ans_max = A[0]\n ans_min = A[0]\n ans_f = A[0]\n sumi = A[0]\n while i < n:\n sumi += A[i]\n if ans+A[i%n]>A[i%n]:\n ans+=A[i%n]\n else:\n ans=A[i%n]\n \n if ans_f+A[i%n]<A[i%n]:\n ans_f+=A[i%n]\n else:\n ans_f=A[i%n]\n ans_max = max(ans_max, ans)\n ans_min = min(ans_min, ans_f)\n i+=1\n \n return max(ans_max,sumi-ans_min) if ans_min!=sumi else ans_max","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n for i in range(1, len(A)):\n A[i] += A[i-1]\n pre_min, pre_max = float('inf'), float('-inf')\n res1, res2 = A[0], A[0]\n for a in A:\n res1 = max(res1, a-pre_min)\n res2 = min(res2, a-pre_max)\n pre_min = min(pre_min, a)\n pre_max = max(pre_max, a)\n res1 = max(res1, A[-1])\n res2 = min(res2, A[-1])\n if res2 == A[-1]:\n return res1\n else:\n return max(res1, A[-1]-res2)","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n n = len(A)\n if n == 1:\n return A[0]\n \n max_ = A[0]\n current = 0\n for num in A:\n current += num\n max_ = max(max_, current)\n if current < 0:\n current = 0\n \n max_from_left = [0] * n\n max_from_left[0] = float('-inf')\n current = A[0]\n for idx in range(1, n):\n max_from_left[idx] = max(max_from_left[idx - 1], current)\n current += A[idx]\n max_from_left[0] = 0\n \n so_far = 0\n for idx in range(n - 1, -1, -1):\n so_far += A[idx]\n max_ = max(max_, so_far + max_from_left[idx])\n return max_\n \n# left_acc = [0] * n\n# left_acc[0] = A[0]\n# for idx in range(1, n):\n# left_acc[idx] = A[idx] + left_acc[idx - 1]\n \n \n# right_acc = [0] * n\n# right_acc[-1] = A[-1]\n# for idx in range(n - 2, -1, -1):\n# right_acc[idx] = A[idx] + right_acc[idx + 1]\n \n# print(left_acc)\n# print(right_acc)\n# left, right = 0, n - 1\n# while left < right:\n# max_ = max(max_, left_acc[left] + right_acc[right])\n# if left_acc[left] > right_acc[right]:\n# right -= 1\n# else:\n# left += 1\n \n# return max_\n","import math\n\nclass Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n total = 0\n maxss, maxss_cur = -math.inf, -math.inf\n minss, minss_cur = 0, 0\n for a in A:\n maxss_cur = a + max(maxss_cur, 0)\n maxss = max(maxss, maxss_cur)\n \n minss_cur = a + min(minss_cur, 0)\n minss = min(minss, minss_cur)\n \n total += a\n \n return maxss if total == minss else max(maxss, total - minss)\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n \n currMaxSum = 0\n currMinSum = 0\n maxSum = float('-inf')\n minSum = float('inf')\n flag = False\n \n totalSum = 0\n \n for i in range(len(A)):\n currMaxSum += A[i]\n maxSum = max(maxSum, currMaxSum)\n if currMaxSum < 0:\n currMaxSum = 0\n\n \n totalSum += A[i]\n if A[i] >= 0: \n flag = True\n \n currMinSum += A[i]\n minSum = min(minSum, currMinSum)\n if currMinSum > 0:\n currMinSum = 0\n \n if flag:\n return max(totalSum-minSum, maxSum)\n else:\n return maxSum\n \n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n# currMaxSum = 0\n# currMinSum = 0\n# flag = False\n# maxSum = float('-inf')\n# minSum = float('inf')\n# totalSum = 0\n \n# for i in range(len(A)):\n \n# currMaxSum += A[i]\n# maxSum = max(maxSum, currMaxSum)\n# if currMaxSum < 0:\n# currMaxSum = 0\n \n# totalSum += A[i]\n# if A[i] >= 0:\n# flag = True\n \n \n# currMinSum += A[i]\n# minSum = min(minSum, currMinSum)\n# if currMinSum > 0:\n# currMinSum = 0\n \n# if not flag:\n# return maxSum \n\n# else:\n# return max(maxSum, totalSum-minSum)\n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n# ans1 = cur = None \n# for x in A:\n# cur = x + max(cur, 0)\n# ans1 = max(ans1, cur)\n \n# ans2 = cur = float(\\\"inf\\\")\n# for i in range(1, len(A)):\n# cur = A[i] + min(cur, 0)\n# ans2 = min(ans2, cur)\n# ans2 = sum(A) - ans2\n \n# ans3 = cur = float(\\\"inf\\\")\n# for i in range(len(A)-1):\n# cur = A[i] + min(cur, 0)\n# ans3 = min(ans3, cur)\n# ans3 = sum(A) - ans3\n \n# return max(ans1, ans2, ans3)\n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n# track = [[0 for j in range(len(A))] for j in range(len(A))]\n# max_val = min(A)\n# for i in range(len(A)):\n# track[i][i] = A[i]\n# for j in range(i+1, len(A)):\n# track[i][j] = track[i][j-1] + A[j]\n# max_val = max(max_val, track[i][j])\n# max_val = max(max_val, track[i][i])\n \n# #print(track)\n# for i in range(len(A)-1, 0, -1):\n# for j in range(0, i):\n# track[i][j] = track[i][len(track) - 1] + track[0][j]\n# max_val = max(max_val, track[i][j])\n \n# #print(track)\n# return max_val]\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n \n currMaxSum = 0\n currMinSum = 0\n flag = False\n maxSum = float('-inf')\n minSum = float('inf')\n totalSum = 0\n \n for i in range(len(A)):\n \n currMaxSum += A[i]\n maxSum = max(maxSum, currMaxSum)\n if currMaxSum < 0:\n currMaxSum = 0\n \n totalSum += A[i]\n if A[i] >= 0:\n flag = True\n \n \n currMinSum += A[i]\n minSum = min(minSum, currMinSum)\n if currMinSum > 0:\n currMinSum = 0\n \n if not flag:\n return maxSum \n\n else:\n return max(maxSum, totalSum-minSum)\n \n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n# ans1 = cur = None \n# for x in A:\n# cur = x + max(cur, 0)\n# ans1 = max(ans1, cur)\n \n# ans2 = cur = float(\\\"inf\\\")\n# for i in range(1, len(A)):\n# cur = A[i] + min(cur, 0)\n# ans2 = min(ans2, cur)\n# ans2 = sum(A) - ans2\n \n# ans3 = cur = float(\\\"inf\\\")\n# for i in range(len(A)-1):\n# cur = A[i] + min(cur, 0)\n# ans3 = min(ans3, cur)\n# ans3 = sum(A) - ans3\n \n# return max(ans1, ans2, ans3)\n \n \n \n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n# track = [[0 for j in range(len(A))] for j in range(len(A))]\n# max_val = min(A)\n# for i in range(len(A)):\n# track[i][i] = A[i]\n# for j in range(i+1, len(A)):\n# track[i][j] = track[i][j-1] + A[j]\n# max_val = max(max_val, track[i][j])\n# max_val = max(max_val, track[i][i])\n \n# #print(track)\n# for i in range(len(A)-1, 0, -1):\n# for j in range(0, i):\n# track[i][j] = track[i][len(track) - 1] + track[0][j]\n# max_val = max(max_val, track[i][j])\n \n# #print(track)\n# return max_val\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n# total, maxSum, curMax, minSum, curMin = 0, float('-inf'), 0, float('inf'), 0\n \n# for a in A:\n# curMax = max(curMax + a, a)\n# maxSum = max(maxSum, curMax)\n# curMin = min(curMin + a, a)\n# minSum = min(minSum, curMin)\n# total += a\n \n# return max(maxSum, total - minSum) if maxSum > 0 else maxSum\n \n \n if not A:\n return 0\n \n dp_max = [-99999] * len(A)\n dp_min = [-99999] * len(A)\n dp_max[0], dp_min[0] = A[0], A[0]\n \n for i in range(1, len(A)):\n dp_max[i] = max(A[i], dp_max[i - 1] + A[i])\n dp_min[i] = min(A[i], dp_min[i - 1] + A[i])\n \n if min(dp_min) == sum(A):\n return max(dp_max)\n else:\n return max(max(dp_max), sum(A) - min(dp_min))","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n # max(the max subarray sum, the total sum - the min subarray sum)\n max_sum = -float('inf')\n cur_max = -float('inf')\n total_sum = 0\n cur_min = float('inf')\n min_sum = float('inf')\n for i in A:\n total_sum += i\n \n cur_max = max(cur_max + i, i)\n cur_min = min(cur_min + i, i)\n \n max_sum = max(max_sum, cur_max)\n min_sum = min(min_sum, cur_min)\n \n if total_sum - min_sum == 0:\n return max_sum\n return max(max_sum, total_sum - min_sum) ","# method 1 append array's copy at back of it. then apply kadane's algorithm\n# *not work* because we can only attain maximum n size window but here it can be 2n\n\n# method 2 sliding window max window size = n\n# *not work* because there is no way to move back of window\n\n# method 3 modified kadane's algorithm(see in lee215's solution)\nclass Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n if not A:\n return 0\n \n max_sum, cur_max, min_sum, cur_min, total = A[0], 0, A[0], 0, 0\n for a in A:\n cur_max = max(a + cur_max, a)\n max_sum = max(max_sum, cur_max)\n \n cur_min = min(a + cur_min, a)\n min_sum = min(min_sum, cur_min)\n \n total += a\n \n return max(max_sum, total - min_sum) if total > min_sum else max_sum","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n total = sum(A)\n minSum = self.maxSum([-x for x in A]) + total\n maxSum = self.maxSum(A)\n #print(maxSum)\n #print(minSum)\n return max(maxSum, minSum) if minSum > 0 else maxSum\n \n def maxSum(self, A: List[int]) -> int:\n current = 0\n max_sum = float('-inf')\n for num in A:\n current += num\n \n if current > max_sum:\n max_sum = current\n \n if current < 0:\n current = 0\n \n return max_sum\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n # 1. get max subarray sum\n maxSum = curSum = A[0]\n for i in range(1, len(A)):\n curSum = max(A[i], A[i] + curSum)\n maxSum = max(maxSum, curSum)\n \n if maxSum < 0:\n return maxSum\n \n # 2. get min subarray sum\n minSum = curSum = A[0]\n for i in range(1, len(A)):\n curSum = min(A[i], A[i] + curSum)\n minSum = min(minSum, curSum)\n \n # 3. compare (max subarray sum) with (total sum - min subarray sum)\n return max(sum(A)-minSum, maxSum)","#Two cases:\n#MaxSubarray = normal -> proceed normally\n#MaxSubarray = circular -> total sum - minSubarray\n#return max(maxSubarray, maxSubarraycircular\nclass Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n total_sum = 0\n global_max = A[0]\n global_min = A[0]\n local_max = 0\n local_min = 0\n for num in A:\n local_max = max(num, local_max + num)\n local_min = min(num, local_min + num)\n global_max = max(global_max, local_max)\n global_min = min(global_min, local_min)\n total_sum += num\n \n circular_max = total_sum - global_min\n if global_max <= 0:\n return global_max\n return max(circular_max, global_max)","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n SUM = 0\n MIN = 0\n minsum = sys.maxsize\n MAX = 0\n maxsum = -sys.maxsize\n \n for num in A:\n SUM += num\n maxsum = max(maxsum, SUM-MIN)\n MIN = min(MIN,SUM)\n minsum = min(minsum, SUM-MAX)\n MAX = max(MAX,SUM)\n if minsum == SUM:\n return maxsum\n return max(maxsum, SUM-minsum)","#Two cases:\n#MaxSubarray = normal -> proceed normally\n#MaxSubarray = circular -> total sum - minSubarray\n#return max(maxSubarray, maxSubarraycircular\nclass Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n total_sum = 0\n global_max = A[0]\n global_min = A[0]\n local_max = 0\n local_min = 0\n for num in A:\n local_max = max(num, local_max + num)\n local_min = min(num, local_min + num)\n global_max = max(global_max, local_max)\n global_min = min(global_min, local_min)\n total_sum += num\n \n circular_max = total_sum - global_min\n return max(circular_max, global_max) if global_max > 0 else global_max","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n n = len(A)\n \n if n == 1:\n return A[0]\n \n global_max = float('-inf')\n global_min = float('inf')\n \n local_max = 0\n local_min = 0\n \n for i, a in enumerate(A):\n local_max = max(local_max + a, a)\n global_max = max(global_max, local_max)\n \n if 0 < i < n - 1:\n local_min = min(local_min + a, a)\n global_min = min(global_min, local_min)\n \n return max(global_max, sum(A) - global_min)\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n max1 = -float('inf')\n maxc = -float('inf')\n for i in range(len(A)):\n maxc = max(maxc+A[i],A[i])\n max1 = max(max1,maxc)\n \n \n min1 = float('inf')\n minc = float('inf')\n for i in range(len(A)):\n minc = min(minc+A[i],A[i])\n min1 = min(min1,minc)\n \n if min1==sum(A):\n return max1\n\n return max(max1,sum(A)-min1)\n \n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n # n = len(A)\n # max_sub_ending = [A[0]]\n # max_sub_start_index = [0]\n \n# A.extend(A)\n# print(A)\n# for i in range(1, len(A)):\n# prev = max_sub_ending[i-1]\n# if prev <= 0:\n# max_sub_start_index.append(i)\n# max_sub_ending.append(A[i])\n# if i - max_sub_start_index[-1] < n:\n# max_sub_start_index.append(max_sub_start_index[-1])\n# max_sub_ending.append(A[i]+max_sub_ending[-1])\n# elif (i - max_sub_start_index[-1]) == n:\n# index_len = len(max_sub_start_index)\n# val = max_sub_start_index[index_len-n]\n# current_sum = max_sub_ending[-1] - val\n# if current_sum <= 0:\n# max_sub_start_index.append(i)\n# max_sub_ending.append(A[i])\n# else:\n# max_sub_start_index.append(max_sub_start_index[-1]+1)\n# max_sub_ending.append(A[i]+current_sum)\n# print(max_sub_ending)\n# return max(max_sub_ending)\n n = len(A)\n max_sub_ending = [A[0]]\n max_sub_ending_index = [0]\n \n for i in range(1, len(A)):\n prev = max_sub_ending[i-1]\n if prev <= 0:\n max_sub_ending_index.append(i)\n max_sub_ending.append(A[i])\n else:\n max_sub_ending_index.append(max_sub_ending_index[-1])\n max_sub_ending.append(A[i]+max_sub_ending[-1])\n print(max_sub_ending)\n posmax = max(max_sub_ending)\n total = sum(A)\n \n for i in range(len(A)):\n A[i] = -A[i]\n max_sub_ending = [A[0]]\n max_sub_ending_index = [0]\n \n for i in range(1, len(A)):\n prev = max_sub_ending[i-1]\n if prev <= 0:\n max_sub_ending_index.append(i)\n max_sub_ending.append(A[i])\n else:\n max_sub_ending_index.append(max_sub_ending_index[-1])\n max_sub_ending.append(A[i]+max_sub_ending[-1])\n print(max_sub_ending)\n negmax = max(max_sub_ending)+total \n if negmax > posmax and negmax != 0:\n return negmax\n else:\n return posmax\n \n# cycle = max_sub_ending[-1]\n# if cycle <= 0:\n# return max(max_sub_ending)\n \n# for i in range(max_sub_ending_index[-1]):\n# if cycle <= 0:\n# return max(max_sub_ending)\n \n# max_sub_ending_index[i] = cycle+A[i]\n# cycle = max_sub_ending_index[i]\n# return max(max_sub_ending)\n \n# total = sum(A)\n \n# #left sum\n# left_sum = [A[0]]\n# left = A[0]\n \n# for i in range(1, len(A)):\n \n# left = left+A[i]\n# left_sum.append(left)\n \n# #right sum\n# right = A[-1]\n# right_sum = [right]\n \n# for i in range(len(A)-2, -1, -1):\n \n# right += A[i]\n# right_sum.append(right)\n\n# right_sum.reverse()\n \n# max_sub = total\n\n# for i in range(0, len(A)):\n# for j in range(i, len(A)):\n# left, right = 0, 0\n# if i != 0:\n# left = left_sum[i-1]\n# if j != (len(A) -1):\n# right = right_sum[j+1]\n# max_sub = max(max_sub, total - left - right , left+right)\n \n# #corner case\n# if max(A) < 0:\n# return max(A)\n# return max_sub\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n #On\n n=len(A)\n total=A[0]\n curmax=A[0]\n curmin=A[0]\n maxsum=curmax\n minsum=curmin\n for i in range(1,n):\n curmax=max(curmax+A[i],A[i])\n maxsum=max(maxsum,curmax)\n curmin=min(curmin+A[i],A[i])\n minsum=min(minsum,curmin)\n total+=A[i]\n #get maxsum and minsum\n # total-minsum and maxsum\n if total==minsum:\n return maxsum\n else:\n return max(maxsum,total-minsum)\n \n \n \n \n \n \n \n \n# dp=[0]*n\n# optsum=[A[0]]*n\n# pre=A[0]\n# dp[0]=A[0]\n# first=dp[0]\n# for i in range(1,n):\n# dp[i]=max(dp[i-1]+A[i],A[i])\n# first=max(first,dp[i])\n \n# pre+=A[i]\n# if pre>optsum[i-1]:\n# optsum[i]=pre\n# else:\n# optsum[i]=optsum[i-1]\n# # get second case now\n# #print(optsum)\n# pre=0\n# for j in range(n-1,0,-1):\n# first=max(first,pre+A[j]+optsum[j-1])\n# pre+=A[j]\n \n# return first\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n #N2 solution\n# n = len(A)\n# maxSum = -float('inf')\n\n# for i in range(n):\n# currSum = 0\n# for j in range(n):\n# ind = (i+j)%n\n# ele = A[ind]\n \n# newSum = currSum +ele\n# maxSum = max(maxSum,newSum)\n \n# if currSum>0 and newSum<0:\n# currSum = 0\n# elif currSum<0 and newSum<currSum:\n# currSum=0\n \n# else:\n# currSum = newSum\n\n# return maxSum\n \n n = len(A)\n maxSum = -float('inf')\n\n currSum = 0\n for j in range(n):\n ele = A[j]\n\n newSum = currSum +ele\n maxSum = max(maxSum,newSum)\n\n if currSum>0 and newSum<0:\n currSum = 0\n elif currSum<=0 and newSum<currSum:\n currSum=0\n\n else:\n currSum = newSum\n\n lSum = 0\n bestLSum=0\n totalSum = sum(A)\n for i in range(n):\n currSum= totalSum-lSum\n currSum+=bestLSum\n maxSum = max(maxSum,currSum)\n \n lSum+=A[i]\n bestLSum=max(lSum,bestLSum)\n \n return maxSum","\nclass Solution:\n def maxSubarraySumCircular(self, arr: List[int]) -> int:\n def maxsub(a,n):\n maxsum = a[0]\n currsum= 0\n for i in range(n):\n if currsum+a[i]>0:\n currsum+=a[i]\n maxsum = max(maxsum,currsum)\n else:\n currsum=0\n maxsum= max(maxsum,a[i])\n return maxsum\n b =[i*-1 for i in arr]\n n = len(arr)\n s=sum(arr)\n ans2=0\n ans2 = maxsub(b,n)\n if s==-ans2:\n ans2 = -ans2\n return max(maxsub(arr,n),s+ans2)\n \n \n \n \n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n if len(A) == 0:\n return 0\n minS = minT = maxS = maxT = s = A[0]\n for i in range(1,len(A)):\n minS = min(A[i],minS + A[i])\n minT = min(minS,minT)\n \n maxS = max(A[i],maxS + A[i])\n maxT = max(maxT,maxS)\n \n s += A[i]\n if s == minT:\n return maxT\n return max(s - minT,maxT)","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n if len(A) == 1:\n return A[0]\n s = sum(A)\n nums = A\n m = nums[0]\n last = m\n num = 1\n last_max = m\n res = last\n res_max = last_max\n for i in A[1:]:\n if i + last < i:\n last = i + last\n num += 1\n else:\n last = i\n num = 1\n if num != len(A):\n res = min(res, last)\n last_max = max(i, i+last_max)\n res_max = max(res_max, last_max)\n return max(s-res, res_max)","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n currentMax = totalMax = currentMin = totalMin = A[0]\n s = A[0]\n for i in range(1, len(A)):\n currentMax = max(currentMax + A[i], A[i])\n totalMax = max(totalMax, currentMax)\n currentMin = min(currentMin + A[i], A[i])\n totalMin = min(totalMin, currentMin)\n s += A[i] \n if s - totalMin != 0:\n return max(totalMax, s - totalMin)\n else: return totalMax","import math\nimport random\nimport string\nfrom functools import lru_cache\nfrom operator import truediv\nfrom typing import List, Set\nimport collections\nimport functools\nimport heapq\nimport itertools\nimport sys\nfrom functools import lru_cache\nfrom typing import List\nimport numpy as np\nimport collections\nimport functools\nimport heapq\nimport itertools\nimport sys\nfrom functools import lru_cache\nfrom typing import List\n\n'''\n53. Maximum Subarray 无循环\n dp[i] = max(A[i], dp[i-1] + A[i])\n 显然当dp[i-1] < 0 时， dp[i] = A[i]，则有：\n dp[i] = A[i] + max(dp[i-1], 0)\n\n类比53，此题加了循环。也就是找到尾部和开头的最大正数组。\n\nhttps://leetcode.com/problems/maximum-sum-circular-subarray/discuss/178422/One-Pass\n\n但其实就是找到中间的最负子数组。\n'''\n\n\nclass Solution:\n def maxSubarraySumCircular(self, A):\n total, maxSum, curMax, minSum, curMin = 0, A[0], 0, A[0], 0\n for a in A:\n curMax = max(curMax + a, a)\n maxSum = max(maxSum, curMax)\n curMin = min(curMin + a, a)\n minSum = min(minSum, curMin)\n total += a\n return max(maxSum, total - minSum) if maxSum > 0 else maxSum\n\n\n# r = Solution()\n# a = r.maxSubarraySumCircular([3,-1,2,-1])\n# print(a)\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n #On\n n=len(A)\n dp=[0]*n\n optsum=[A[0]]*n\n pre=A[0]\n dp[0]=A[0]\n first=dp[0]\n for i in range(1,n):\n dp[i]=max(dp[i-1]+A[i],A[i])\n first=max(first,dp[i])\n \n pre+=A[i]\n if pre>optsum[i-1]:\n optsum[i]=pre\n else:\n optsum[i]=optsum[i-1]\n # get second case now\n #print(optsum)\n pre=0\n for j in range(n-1,0,-1):\n first=max(first,pre+A[j]+optsum[j-1])\n pre+=A[j]\n \n return first","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n ans1 = cur = 0\n for x in A:\n cur = x + max(cur, 0)\n ans1 = max(ans1, cur)\n \n ans2 = cur = 0\n for x in A[1:]:\n cur = x + min(cur, 0)\n ans2 = min(ans2, cur)\n ans2 = sum(A) - ans2\n \n ans3 = cur = 0\n for x in A[:-1]:\n cur = x + min(cur, 0)\n ans3 = min(ans3, cur)\n ans3 = sum(A) - ans3\n \n ans = max(ans1, ans2, ans3)\n return ans if ans != 0 else max(A)\n","class Solution:\n def maxSubarraySumCircular(self, nums: List[int]) -> int:\n greatest: int = -sys.maxsize + 1\n smallest: int = sys.maxsize\n x = y = total = 0\n\n for i in range(len(nums)):\n x += nums[i]\n greatest = max(greatest, x)\n x = max(x, 0)\n\n y += nums[i]\n smallest = min(smallest, y)\n y = min(y, 0)\n\n total += nums[i]\n\n return greatest if greatest < 0 else max(greatest, total - smallest)\n\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n N = len(A)\n\n ans = cur = 0\n for x in A:\n cur = x + max(cur, 0)\n ans = max(ans, cur)\n\n rightsums = [None] * N\n rightsums[-1] = A[-1]\n for i in range(N-2, -1, -1):\n rightsums[i] = rightsums[i+1] + A[i]\n\n # maxright[i] = max_{j >= i} rightsums[j]\n maxright = [None] * N\n maxright[-1] = rightsums[-1]\n for i in range(N-2, -1, -1):\n maxright[i] = max(maxright[i+1], rightsums[i])\n\n leftsum = 0\n for i in range(N-2):\n leftsum += A[i]\n ans = max(ans, leftsum + maxright[i+1])\n if max(A) < 0:\n return max(A)\n return ans\n \n \n# total = sum(A)\n# max_sum_ending_i = [A[0]]\n# prev = max_sum_ending_i[-1]\n \n \n# for i in range(1, len(A)):\n# if prev <= 0:\n# max_sum_ending_i.append(A[i])\n# else:\n# max_sum_ending_i.append(max_sum_ending_i[-1]+A[i])\n# prev = max_sum_ending_i[-1]\n \n# min_sum_ending_i = [A[0]]\n# prev = min_sum_ending_i[-1]\n\n# for i in range(1, len(A)):\n# if prev >= 0:\n# min_sum_ending_i.append(A[i])\n# else:\n# min_sum_ending_i.append(min_sum_ending_i[-1]+A[i])\n# prev = min_sum_ending_i[-1]\n \n# if max(A) > 0:\n# return max(total - min(min_sum_ending_i), max(max_sum_ending_i))\n# else:\n# return max(A)\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n sums = sum(A)\n min_res = min_s = sys.maxsize\n max_res = max_s = -sys.maxsize\n n = len(A)\n for i in range(n):\n min_s = min(A[i], min_s + A[i])\n max_s = max(A[i], max_s + A[i])\n min_res = min(min_res, min_s)\n max_res = max(max_res, max_s)\n if min_res == sums:\n min_res = min(A)\n else:\n min_res = sums - min_res\n return max(min_res, max_res)","import numpy as np\nclass Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n total, maxSum, curMax, minSum, curMin = 0, A[0], -np.Infinity, A[0], np.Infinity\n for a in A:\n curMax = max(curMax + a, a)\n maxSum = max(maxSum, curMax)\n curMin = min(curMin + a, a)\n minSum = min(minSum, curMin)\n total += a\n return max(maxSum, total - minSum) if maxSum>0 else maxSum","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n if max(A) <= 0: return max(A)\n endmax = [i for i in A]\n endmin = [i for i in A]\n for i in range(len(A)-1):\n if endmax[i] > 0: endmax[i+1] += endmax[i]\n if endmin[i] < 0: endmin[i+1] += endmin[i]\n return max(max(endmax), sum(A) - min(endmin))","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n def kadane(gen):\n ans = None\n cur = None\n for x in gen:\n if cur:\n cur = x + max(cur, 0)\n else:\n cur = x\n if ans:\n ans = max(ans, cur)\n else:\n ans = cur\n return ans\n S = sum(A)\n ans1 = kadane((A))\n if len(A) > 1:\n ans2 = S + kadane([-A[i] for i in range(1, len(A))])\n ans3 = S + kadane([-A[i] for i in range(len(A) - 1)])\n return max(ans1, ans2, ans3)\n else:\n return ans1\n","# class Solution(object):\n# def maxSubarraySumCircular(self, A):\n# N = len(A)\n\n# ans = float('-inf')\n# cur = 0\n# for x in A:\n# cur = x + max(cur, 0)\n# ans = max(ans, cur)\n\n# # ans is the answer for 1-interval subarrays.\n# # Now, let's consider all 2-interval subarrays.\n# # For each i, we want to know\n# # the maximum of sum(A[j:]) with j >= i+2\n\n# # rightsums[i] = sum(A[i:])\n# rightsums = [None] * N\n# rightsums[-1] = A[-1]\n# for i in xrange(N-2, -1, -1):\n# rightsums[i] = rightsums[i+1] + A[i]\n\n# # maxright[i] = max_{j >= i} rightsums[j]\n# maxright = [None] * N\n# maxright[-1] = rightsums[-1]\n# for i in xrange(N-2, -1, -1):\n# maxright[i] = max(maxright[i+1], rightsums[i])\n\n# leftsum = 0\n# for i in xrange(N-2):\n# leftsum += A[i]\n# ans = max(ans, leftsum + maxright[i+2])\n# return ans\n \nclass Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n \n N = len(A)\n ans = float('-inf')\n cur = 0\n for x in A:\n cur = x + max(cur, 0)\n ans = max(ans, cur)\n \n rightsums = [None] * N\n rightsums[-1] = A[-1]\n for i in range(N-2, -1, -1):\n rightsums[i] = rightsums[i+1] + A[i]\n \n maxright = [None] * N\n maxright[-1] = rightsums[-1]\n for i in range(N-2, -1, -1):\n maxright[i] = max(maxright[i+1], rightsums[i])\n \n leftsum = 0\n for i in range(N-2):\n leftsum += A[i]\n ans = max(ans, leftsum + maxright[i+2])\n \n return ans\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n n = len(A)\n ans = cur = float('-inf')\n for x in A:\n cur = x + max(cur, 0)\n ans = max(ans, cur)\n \n rightsums = [0]*n\n rightsums[-1] = A[-1]\n for i in range(n-2, -1, -1):\n rightsums[i] = rightsums[i+1] + A[i]\n \n maxright = [0]*n\n maxright[-1] = rightsums[-1]\n for i in range(n-2, -1, -1):\n maxright[i] = max(maxright[i+1], rightsums[i])\n \n leftsum = 0\n for i in range(n-2):\n leftsum += A[i]\n ans = max(ans, leftsum + maxright[i+2])\n \n return ans","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n ans1 = cur = 0\n for x in A:\n cur = x + max(cur, 0)\n ans1 = max(ans1, cur)\n \n ans2 = cur = 0\n for i in range(1, len(A)):\n cur = A[i] + min(cur, 0)\n ans2 = min(ans2, cur)\n ans2 = sum(A) - ans2\n \n ans3 = cur = 0\n for i in range(len(A)-1):\n cur = A[i] + min(cur, 0)\n ans3 = min(ans3, cur)\n ans3 = sum(A) - ans3\n \n ans = max(ans1, ans2, ans3)\n return ans if ans != 0 else max(A)\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n \n def kadane(A):\n ts=A[0]\n ms=A[0]\n for i in range(1,len(A)):\n ts=max(A[i],ts+A[i])\n ms=max(ms,ts)\n return ms\n x=kadane(A)\n for i in range(len(A)):\n A[i]*=-1\n s=sum(A)\n y=kadane(A)\n if y==s:\n y=-1e10\n else:\n y=-s+y\n return max(x,y)\n \n \n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n def find_max_sum(A):\n curr_sum = 0\n max_sum = -math.inf\n for num in A:\n if curr_sum > 0:\n curr_sum += num\n else:\n curr_sum = num\n max_sum = max(max_sum, curr_sum)\n return max_sum\n max_sum = find_max_sum(A)\n min_sum_1 = -find_max_sum(-num for num in A[1:])\n min_sum_2 = -find_max_sum(-num for num in A[:-1])\n return max(sum(A) - min(min_sum_1, min_sum_2), max_sum)","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n n = len(A)\n A *= 2\n ans = [0] * len(A)\n q = collections.deque()\n cur = 0\n for i, a in enumerate(A):\n while q and i - q[0][0] > n:\n q.popleft()\n cur += a\n ans[i] = cur - q[0][1] if q else cur\n while q and q[-1][1] >= cur:\n q.pop()\n q.append((i, cur))\n return max(ans)\n \n \n # n = len(A)\n # A *= 2\n # ans = [A[0]] + [0] * (len(A) - 1)\n # q = collections.deque([(0, A[0])])\n # cur = A[0]\n # for i, a in enumerate(A[1:], 1):\n # while q and i - q[0][0] > n:\n # q.popleft()\n # cur += a\n # ans[i] = cur - q[0][1]\n # while q and q[-1][1] >= cur:\n # q.pop()\n # q.append((i, cur))\n # return max(ans)\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n def kadane(gen):\n # maximum non-empty subarray sum\n ans = - sys.maxsize\n cur = - sys.maxsize\n for x in gen:\n cur = x + max(cur, 0)\n ans = max(ans, cur)\n \n return ans\n \n S = sum(A)\n ans1 = kadane(iter(A))\n ans2 = S + kadane(-A[i] for i in range(1, len(A)))\n ans3 = S + kadane(-A[i] for i in range(len(A) - 1))\n \n return max(ans1, ans2, ans3)\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n '''\n 12341234\n limit of len[] < a.length\n \n \n p[i], i\n \n '''\n def kaden(gen):\n ans = cur = gen[0]\n for n in gen[1:]:\n cur = n + max(0, cur)\n ans = max(ans, cur)\n return ans\n \n ans1 = kaden(A)\n if len(A)>1: \n s = sum(A)\n ans2 = s + kaden([-a for a in A[1:]])\n ans3 = s + kaden([-a for a in A[:-1]])\n else:\n ans2 = ans3 = -float('inf')\n \n return max(ans1, ans2, ans3)","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n def kadane(gen):\n ans = cur = -float('inf')\n for x in gen:\n cur = x + max(cur, 0)\n ans = max(ans, cur)\n return ans\n S = sum(A)\n ans1 = kadane(iter(A))\n ans2 = S + kadane(-A[i] for i in range(1, len(A)))\n ans3 = S + kadane(-A[i] for i in range(len(A)-1))\n return max(ans1, ans2, ans3)","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n B = A.copy()\n for i in range(1,len(B)):\n if B[i-1] > 0:\n B[i] += B[i-1]\n maxsum = max(B)\n C = A.copy()\n for i in range(1, len(C)):\n if C[i-1] < 0:\n C[i] += C[i-1]\n minsum = min(C)\n if minsum == sum(A):\n return max([maxsum, max(A)])\n return max([maxsum, sum(A)-minsum])","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n '''\n 12341234\n limit of len[] < a.length\n \n \n p[i], i\n \n '''\n def kaden(gen):\n ans = cur = -float('inf')\n for n in gen:\n cur = n + max(0, cur)\n ans = max(ans, cur)\n return ans\n ans1 = kaden(iter(A))\n if len(A)>1: \n s = sum(A)\n ans2 = s + kaden(-a for a in A[1:])\n ans3 = s + kaden(-a for a in A[1:])\n else:\n ans2 = ans3 = -float('inf')\n \n return max(ans1, ans2, ans3)","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n def kadane(gen):\n #ans = None\n #cur = None\n #for x in gen:\n # if cur:\n # cur = x + max(cur, 0)\n # else:\n # cur = x\n # if ans:\n # ans = max(ans, cur)\n # else:\n # ans = cur\n #return ans\n \n size = len(gen)\n ans = cur = gen[0]\n for i in range(1,size):\n cur = max(gen[i], cur + gen[i])\n ans = max(ans, cur)\n return ans\n S = sum(A)\n ans1 = kadane((A))\n if len(A) > 1:\n ans2 = S + kadane([-A[i] for i in range(1, len(A))])\n ans3 = S + kadane([-A[i] for i in range(len(A) - 1)])\n return max(ans1, ans2, ans3)\n else:\n return ans1\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n n = len(A)\n A *= 2\n ans = [A[0]] + [0] * (len(A) - 1)\n q = collections.deque([(0, A[0])])\n cur = A[0]\n for i, a in enumerate(A[1:], 1):\n while q and i - q[0][0] > n:\n q.popleft()\n cur += a\n ans[i] = cur - q[0][1]\n while q and q[-1][1] >= cur:\n q.pop()\n q.append((i, cur))\n return max(ans)\n \n \n # n = len(A)\n # A *= 2\n # ans = [0] * len(A)\n # q = collections.deque()\n # cur = 0\n # for i, a in enumerate(A):\n # while q and i - q[0][0] > n:\n # q.popleft()\n # cur += a\n # ans[i] = cur - q[0][1] if q else cur\n # while q and q[-1][1] >= cur:\n # q.pop()\n # q.append((i, cur))\n # return max(ans)\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n n = len(A) \n ans = cur = float('-inf') \n for v in A:\n cur = v + max(cur, 0) \n ans = max(ans, cur)\n \n rightsum = [0] * n\n rightsum[-1] = A[-1]\n for i in range(n-2, -1, -1):\n rightsum[i] = rightsum[i+1] + A[i]\n \n rightmax = [0]*n\n rightmax[-1] = rightsum[-1]\n for i in range(n-2, -1, -1):\n rightmax[i] = max(rightmax[i+1], rightsum[i])\n \n \n cur = 0\n for i in range(n-2):\n cur += A[i]\n ans = max(ans, cur+rightmax[i+2])\n \n return ans\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n n = len(A)\n \n ans = -float('inf')\n currmax = -float('inf')\n for i in range(n):\n currmax = max(currmax+A[i], A[i])\n ans = max(ans, currmax)\n \n right_sums = [0]*n\n right_sums[-1] = A[-1]\n for i in range(1, n):\n right_sums[n-1-i] = right_sums[n-i] + A[n-i-1]\n \n maxright = [0]*n\n maxright[-1] = right_sums[-1]\n for i in range(1, n):\n maxright[n-i-1] = max(maxright[n-i], right_sums[n-i-1])\n \n \n lefts = 0\n for i in range(n-2):\n lefts += A[i]\n ans = max(ans, lefts+maxright[i+2])\n \n return ans","class Solution:\n def maxSubarraySumCircular(self, A):\n total = sum(A)\n max_sum = [0 for i in range(len(A))]\n min_sum = [0 for i in range(len(A))]\n\n max_sum[0] = A[0]\n min_sum[0] = A[0]\n\n best_non_loop = max_sum[0]\n best_inverse_loop = min_sum[0]\n\n for i in range(1, len(A)):\n max_sum[i] = A[i] + max(max_sum[i - 1], 0)\n min_sum[i] = A[i] + min(min_sum[i - 1], 0)\n \n best_non_loop = max(best_non_loop, max_sum[i])\n best_inverse_loop = min(best_inverse_loop, min_sum[i])\n\n ret = max(best_non_loop, total - best_inverse_loop)\n if ret == 0:\n return max(A)\n return ret","class Solution(object):\n def maxSubarraySumCircular(self, A):\n N = len(A)\n\n # Compute P[j] = sum(B[:j]) for the fixed array B = A+A\n P = [0]\n for _ in range(2):\n for x in A:\n P.append(P[-1] + x)\n\n # Want largest P[j] - P[i] with 1 <= j-i <= N\n # For each j, want smallest P[i] with i >= j-N\n ans = A[0]\n deque = collections.deque([0]) # i's, increasing by P[i]\n for j in range(1, len(P)):\n # If the smallest i is too small, remove it.\n if deque[0] < j-N:\n deque.popleft()\n\n # The optimal i is deque[0], for cand. answer P[j] - P[i].\n ans = max(ans, P[j] - P[deque[0]])\n\n # Remove any i1's with P[i2] <= P[i1].\n while deque and P[j] <= P[deque[-1]]:\n deque.pop()\n\n deque.append(j)\n\n return ans","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n \n tot = sum(A)\n B = A[:]\n \n for i in range(1, len(A)):\n if A[i - 1] > 0:\n A[i] += A[i - 1]\n if B[i - 1] < 0:\n B[i] += B[i - 1]\n \n submax = max(A)\n submin = min(B)\n \n return max(submax, tot - submin) if tot != submin else submax\n \n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n N = len(A)\n prefix = [0]\n for _ in range(2):\n for x in A:\n prefix.append(prefix[-1] + x)\n \n res = A[0]\n deque = collections.deque([0])\n for j in range(1, len(prefix)):\n if deque[0] < j-N:\n deque.popleft()\n \n res = max(res, prefix[j] - prefix[deque[0]])\n \n while deque and prefix[j] <= prefix[deque[-1]]:\n deque.pop()\n \n deque.append(j)\n \n return res","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n total, maxSum, curMax, minSum, curMin = 0, A[0], 0, A[0], 0\n for a in A:\n curMax = max(curMax + a, a)\n maxSum = max(maxSum, curMax)\n curMin = min(curMin + a, a)\n minSum = min(minSum, curMin)\n total += a\n return max(maxSum, total - minSum) if maxSum > 0 else maxSum\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n maxHere = currentMax = float('-inf')\n minHere = currentMin = float('inf')\n for i in A:\n currentMax = i + max(0, currentMax)\n currentMin = i + min(0, currentMin)\n maxHere = max(currentMax, maxHere)\n minHere = min(currentMin, minHere)\n print(maxHere, minHere)\n if minHere == sum(A) and 0 not in A:\n return maxHere\n return max(maxHere, sum(A)-minHere)","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n # find linear max subarray sum\n maxSum = A[0]\n curMaxSum = A[0]\n for i in range(1, len(A)):\n curMaxSum = max(curMaxSum + A[i], A[i])\n maxSum = max(maxSum, curMaxSum)\n \n # find linear min subarray sum\n minSum = A[0]\n curMinSum = A[0]\n for i in range(1, len(A)):\n curMinSum = min(curMinSum + A[i], A[i])\n minSum = min(minSum, curMinSum)\n \n # edge case: all values of A are negative\n if maxSum < 0:\n return maxSum\n \n # compare (linear max) with (total sum - linear min)\n return max(maxSum, sum(A)-minSum)\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n l = len(A)\n A = A+A\n q = collections.deque([(0, -1)])\n cur = 0\n ret = float('-inf')\n for i, num in enumerate(A):\n cur += num\n ret = max(ret, cur-q[0][0])\n if q[0][1]+l == i:\n q.popleft()\n while len(q) > 0 and q[-1][0] > cur:\n q.pop()\n q.append((cur, i))\n return ret\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n def kadane(aa):\n ans= cur =float('-inf') \n for v in aa:\n cur = max(cur, 0) + v\n ans = max(ans, cur)\n return ans \n S = sum(A)\n ans1 = kadane(A)\n ans2 = S + kadane(-A[i] for i in range(1, len(A)))\n ans3 = S + kadane(-A[i] for i in range(len(A) - 1))\n return max(ans1, ans2, ans3) \n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n L = len(A)\n cum_sum = [0]*L\n cum_max = [0]*L\n cum_max_final = [0]*L\n sum_ = 0\n for i in range(L):\n sum_ += A[i]\n cum_sum[i] = sum_\n if i==0:\n cum_max[i] = A[i]\n else:\n if cum_max[i-1]>0:\n cum_max[i] = cum_max[i-1] + A[i]\n else:\n cum_max[i] = A[i]\n m = A[L-1]\n for i in range(L-1,-1,-1):\n if i!=0:\n cur = cum_sum[L-1] - cum_sum[i-1]\n cum_max_final[i] = max(cur,m)\n m = max(m,cur)\n \n else:\n cum_max_final[i] = max(m,cum_sum[L-1])\n \n res = -float('inf')\n for i in range(L):\n if i!=L-1:\n cur = cum_max[i]\n cur = max(cur,cum_sum[i]+cum_max_final[i+1])\n res = max(res,cur)\n else:\n res = max(res,cum_max[L-1])\n return res\n \n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n pre = 0\n rtn = float('-inf')\n if max(A) <= 0:\n return max(A)\n \n for i in range(len(A)):\n pre += A[i]\n if pre <= 0:\n pre = 0\n else:\n rtn = max(rtn, pre)\n left_sum = [0]*(len(A)+1)\n left = 0\n for i in range(len(A)):\n left += A[i]\n left_sum[i+1] = max(left, left_sum[i])\n right = 0\n for j in reversed(range(len(A))):\n right += A[j]\n rtn = max(rtn, right+left_sum[j])\n return rtn","class Solution:\n def maxSubarraySumCircular(self, A):\n # compute pre(k)\n # maximum continuous subarray that ends at end of A and starts after k\n pre = [0 for i in range(len(A))]\n\n pre_continuous = [0 for i in range(len(A))]\n pre_earlystop = [0 for i in range(len(A))]\n\n for i in range(len(A) - 2, -1, -1):\n pre_continuous[i] = pre_continuous[i + 1] + A[i + 1]\n pre_earlystop[i] = max(pre_earlystop[i + 1], pre_continuous[i])\n pre[i] = max(pre_continuous[i], pre_earlystop[i])\n\n # compute regular dp\n dp = [0 for i in range(len(A))]\n dp[0] = A[0]\n\n running_sum = A[0]\n best = dp[0] + pre[0]\n \n for i in range(1, len(A)):\n dp[i] = max(dp[i - 1] + A[i], A[i])\n\n best = max(best, dp[i], running_sum + pre[i])\n running_sum += A[i]\n\n return best","from collections import deque\nclass Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n B = A + A\n N = len(A)\n queue = deque([0])\n pre_sum = [0]\n for i in range(len(B)):\n pre_sum.append(pre_sum[-1] + B[i])\n ans = A[0]\n for j in range(1, len(pre_sum)):\n if j - queue[0] > N:\n queue.popleft()\n ans = max(ans, pre_sum[j] - pre_sum[queue[0]])\n while queue and pre_sum[queue[-1]] >= pre_sum[j]:\n queue.pop()\n queue.append(j)\n return ans \n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n negateA=[-x for x in A]\n print(negateA)\n cursum=0\n res=float('-inf')\n for v in negateA:\n cursum=max(v,cursum+v)\n res=max(res,cursum)\n \n print(res)\n res1=float('-inf')\n cursum=0\n for v in A:\n cursum=max(v,cursum+v)\n res1=max(res1,cursum)\n print(res1)\n return max(res1,sum(A)+(res)) if res1>0 else res1\n# min maxsum\n# 0,6\n \n # total, maxSum, curMax, minSum, curMin = 0, A[0], 0, A[0], 0\n # for a in A:\n # curMax = max(curMax + a, a)\n # maxSum = max(maxSum, curMax)\n # curMin = min(curMin + a, a)\n # minSum = min(minSum, curMin)\n # total += a\n # print(maxSum, total , minSum)\n # return max(maxSum, total - minSum) if maxSum > 0 else maxSum\n#1 -2 3 -2\n# [-1,2,-3,2]\n# cu -1 2 -1 1\n# re. -1 2 2 2\n\n# sum-min(subARR)\n# SUM+MAX()\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n # there are two cases, one, includes end points, two, not include end points\n ans = float('-inf')\n csum = 0\n for x in A:\n csum = max(x,csum+x)\n ans = max(ans,csum)\n \n mi = float('inf')\n csum = 0 # notice that it can be zero\n for i in range(1,len(A)-1):\n csum = min(csum+A[i],A[i])\n mi = min(mi,csum)\n\n ans = max(ans, sum(A)-mi)\n return ans","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n N = len(A)\n P = [0]\n for _ in range(2):\n for v in A:\n P.append(P[-1] + v)\n \n ans = A[0]\n q = collections.deque([0])\n for j in range(1, len(P)):\n while q and j - q[0] > N:\n q.popleft()\n \n ans = max(ans, P[j] - P[q[0]])\n \n while q and P[q[-1]] >= P[j]:\n q.pop()\n q.append(j) \n \n return ans\n","from collections import deque\nclass Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n arr = A + A\n arr = arr[:-1]\n \n prefix = [0] * len(arr)\n prefix[0] = arr[0]\n for i in range(1, len(prefix)):\n prefix[i] = prefix[i-1] + arr[i]\n \n prefix.insert(0, 0)\n #monotonic increasing array\n dq = deque([0])\n res = -float('inf')\n for i in range(1, len(prefix)):\n\n while dq and i - dq[0] > len(A):\n dq.popleft()\n if dq:\n res = max(res, prefix[i] - prefix[dq[0]])\n \n while dq and prefix[i] <= prefix[dq[-1]]:\n dq.pop()\n dq.append(i)\n \n return res\n \n","class Solution:\n def maxSubarraySumCircular(self, A):\n total, maxSum, curMax, minSum, curMin = 0, A[0], 0, A[0], 0\n for a in A:\n curMax = max(curMax + a, a)\n maxSum = max(maxSum, curMax)\n curMin = min(curMin + a, a)\n minSum = min(minSum, curMin)\n total += a\n return max(maxSum, total - minSum) if maxSum > 0 else maxSum","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n # case 1, kadane's algo\n totalSum = sum(A)\n curr = A[0]\n maxSum = A[0]\n \n for i in range(1, len(A)):\n \n curr = max(A[i] + curr, A[i])\n maxSum = max(maxSum, curr)\n \n # case 2, wrapping\n \n curr = A[0]\n minSum = totalSum\n \n for i in range(1, len(A)):\n curr = min(A[i]+curr, A[i])\n \n minSum = min(minSum, curr)\n \n if totalSum == minSum:\n return maxSum\n return max(totalSum - minSum, maxSum)","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n n = len(A)\n \n if n == 1:\n return A[0]\n \n pre_sum = 0\n pre_min_sum = 0\n pre_max_sum = 0\n \n \n pre_max_sum_i = -1\n min_sum_left = -1\n min_sum_right = -1\n max_sum = float('-inf')\n min_sum = float('inf')\n \n for i, a in enumerate(A):\n pre_sum += a\n \n max_sum = max(max_sum, pre_sum - pre_min_sum)\n min_sum_tmp = pre_sum - pre_max_sum\n if min_sum_tmp < min_sum:\n min_sum = min_sum_tmp\n min_sum_right = i\n min_sum_left = pre_max_sum_i + 1\n \n pre_min_sum = min(pre_min_sum, pre_sum)\n if pre_sum > pre_max_sum:\n pre_max_sum = pre_sum\n pre_max_sum_i = i\n \n total = sum(A)\n \n if total == min_sum and min_sum_left == 0 and min_sum_right == n - 1:\n return max_sum\n return max(max_sum, total - min_sum)\n \n \n \n \n \n \n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n # Main idea: if we iterate over A twice to generate\n # a prefix array, then we can get subarrays in const\n # time by checking windows of size j - i <= len(A)\n \n # Once we have the prefix array, this problem reduces\n # to sliding window maximum (except we're looking for\n # the minimum). With the sliding window minimum, we \n # can then update the result with \n # result = max(result, curr_elem - minimum)\n \n from collections import deque\n dq = deque()\n prefix = [0]\n N = len(A)\n \n for _ in range(2):\n for elem in A:\n prefix.append(elem + prefix[-1])\n \n result = A[0]\n for i in range(len(prefix)):\n if dq and dq[0] < i - N:\n dq.popleft()\n if dq:\n result = max(result, prefix[i] - prefix[dq[0]])\n while dq and prefix[dq[-1]] > prefix[i]:\n dq.pop()\n dq.append(i)\n return result","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n N = len(A)\n\n # Compute P[j] = sum(B[:j]) for the fixed array B = A+A\n P = [0]\n for _ in range(2):\n for x in A:\n P.append(P[-1] + x)\n\n # Want largest P[j] - P[i] with 1 <= j-i <= N\n # For each j, want smallest P[i] with i >= j-N\n ans = A[0]\n deque = collections.deque([0]) # i's, increasing by P[i]\n for j in range(1, len(P)):\n # If the smallest i is too small, remove it.\n while deque[0] < j-N:\n deque.popleft()\n\n # The optimal i is deque[0], for cand. answer P[j] - P[i].\n ans = max(ans, P[j] - P[deque[0]])\n\n # Remove any i1's with P[i2] <= P[i1].\n while deque and P[j] <= P[deque[-1]]:\n deque.pop()\n\n deque.append(j)\n\n return ans\n","from copy import deepcopy\n\ndef cumsum(A: list) -> list:\n cum = 0\n res = []\n for x in A:\n cum += x\n res.append(cum)\n return res\n\nclass Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n # normal kadane's algo\n opt = deepcopy(A)\n n = len(A)\n \n for i in range(1, n, 1):\n if opt[i-1] + A[i] > opt[i]:\n opt[i] = opt[i-1] + A[i]\n \n # forward cumsum and backward cumsum\n forward_cumsum = cumsum(A)\n \n back_cumsum = cumsum(A[::-1])\n tmp = [back_cumsum[0]]\n for i in range(1, n):\n tmp.append(max(tmp[i-1], back_cumsum[i]))\n back_cumsum = tmp\n \n # update opt estimates (if needed)\n for i in range(0, n-1):\n potential_replacement = forward_cumsum[i] + back_cumsum[(n-2)-i]\n opt[i] = max(opt[i], potential_replacement)\n \n # return max\n return max(opt)\n \n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n N = len(A)\n\n # Compute P[j] = sum(B[:j]) for the fixed array B = A+A\n P = [0]\n for _ in range(2):\n for x in A:\n P.append(P[-1] + x)\n\n ans = A[0]\n deque = collections.deque([0])\n for j in range(1, len(P)):\n if deque[0] < j-N:\n deque.popleft()\n\n # The optimal i is deque[0], for cand. answer P[j] - P[i].\n ans = max(ans, P[j] - P[deque[0]])\n\n # Remove any i1's with P[i2] <= P[i1].\n while deque and P[j] <= P[deque[-1]]:\n deque.pop()\n\n deque.append(j)\n\n return ans","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n max_sums_left = []\n max_sums_right = collections.deque()\n sum_up_to_index = []\n max_sums_index_right = collections.deque()\n min_sum_right = 0\n min_sum_left = 0\n max_sum_right = 0\n max_sum_left = 0\n sum_left = 0\n sum_right = 0\n ret = -999999999\n \n \n for i in range(len(A)):\n sum_left += A[i]\n sum_right += A[-i - 1]\n sum_up_to_index.append(sum_left)\n max_sums_left.append(sum_left - min_sum_left)\n max_sums_right.appendleft(sum_right - min_sum_right)\n \n\n if (sum_left < min_sum_left):\n min_sum_left = sum_left\n\n \n if (sum_right > max_sum_right):\n max_sums_index_right.appendleft((len(A) - i - 1, sum_right, ))\n max_sum_right = sum_right\n elif (sum_right < min_sum_right):\n min_sum_right = sum_right\n else: \n pass\n \n sum_left = 0\n \n \n for i in range(len(A)):\n if (len(max_sums_index_right) and i == max_sums_index_right[0][0]):\n max_sums_index_right.popleft()\n\n sum_left += A[i]\n candidates = [max_sums_left[i] + max_sums_right[i] - A[i], sum_right + max_sum_left]\n sum_right -= A[i]\n \n \n if (sum_left > max_sum_left):\n max_sum_left = sum_left\n \n \n if (len(max_sums_index_right)):\n candidates.append(sum_left + max_sums_index_right[0][1])\n \n candidate = max(candidates)\n \n \n if (candidate > ret):\n ret = candidate\n \n return ret ","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n n = len(A)\n B = A + A\n pfx = [0]\n for x in B:\n pfx.append(pfx[-1] + x)\n dq = collections.deque()\n ans = A[0]\n dq.append(0)\n #monoqueue dq that contains indices i such that P[i]s are non-decreasing\n for j in range(1,len(pfx)):\n if j - dq[0] > n:\n dq.popleft()\n \n ans = max(ans, pfx[j] - pfx[dq[0]])\n \n while dq and pfx[dq[-1]] > pfx[j]:\n dq.pop()\n \n dq.append(j)\n return ans","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n def max_subarray(nums):\n for i in range(1, len(nums)):\n if nums[i-1] > 0:\n nums[i] += nums[i-1]\n \n return max(nums)\n \n max_sum ,cur_sum = max_subarray(A[:]), sum(A)\n \n if max_sum < 0:\n return max_sum\n final_sum = cur_sum + max_subarray(list(map(lambda x: -x, A)))\n \n return max(max_sum, final_sum)","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n n = len(A)\n B = [0]+A+A\n for i in range(1, len(B)):\n B[i] += B[i-1]\n maxv = B[1]\n \n stack = deque([0])\n for end in range(1, len(B)):\n num = B[end]\n while stack and num < B[stack[-1]]:\n stack.pop()\n stack.append(end)\n if end-stack[0] == n+1:\n stack.popleft()\n maxv = max(num-B[stack[0]], maxv)\n #print(end, stack, maxv)\n if all(x<0 for x in A):\n return max(A)\n return maxv\n \n \n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n # edge case: all values of A are negative\n allNeg = True\n for i in A:\n if i > 0:\n allNeg = False\n if allNeg:\n return max(A)\n \n # find linear max subarray sum\n maxSum = A[0]\n curMaxSum = A[0]\n for i in range(1, len(A)):\n curMaxSum = max(curMaxSum + A[i], A[i])\n maxSum = max(maxSum, curMaxSum)\n \n # find linear min subarray sum\n minSum = A[0]\n curMinSum = A[0]\n for i in range(1, len(A)):\n curMinSum = min(curMinSum + A[i], A[i])\n minSum = min(minSum, curMinSum)\n \n # compare (linear max) with (total sum - linear min)\n return max(maxSum, sum(A)-minSum)\n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n res = A[0]\n cur = A[0]\n \n for num in A[1:]:\n cur = num + max(0, cur)\n res = max(cur, res)\n \n presum = []\n accu = 0\n for num in A:\n accu += num\n presum.append(accu)\n \n \n postsum = [0 for i in range(len(A))]\n postsum[-1] = A[-1]\n accu = A[-1]\n curmax = A[-1]\n for i in range(len(A) - 2, -1, -1):\n accu += A[i]\n curmax = max(curmax, accu)\n postsum[i] = curmax\n \n \n for i in range(0, len(A) - 2):\n res = max(presum[i] + postsum[i + 2], res)\n \n \n \n return res\n \n","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n '''\n Case 1. The first is that the subarray take only a middle part, and we know how to find the max subarray sum.\n Case2. The second is that the subarray take a part of head array and a part of tail array.\n \n in case two, you have two sub arrays, one at the front and one at the end. The middle segment actually now is the MIN\n subarray.\n The maximum result equals to the total sum minus the minimum subarray sum.\n '''\n total=0\n maxSum=A[0] #case1\n minSum=A[0] #case2\n curr_sum=0\n curr_sum_min=0\n for val in A:\n total+=val #calculate total sum\\\\\n #calculate max sum with kadanes normally for case1, assuming NO WRAP\n curr_sum=max(val,curr_sum+val)\n maxSum=max(maxSum,curr_sum)\n #now calculate the minsum\n curr_sum_min=min(val,curr_sum_min+val)\n minSum=min(minSum,curr_sum_min)\n print(maxSum)\n wrap_maxSum=total-minSum\n \n if maxSum>0:\n return max(wrap_maxSum,maxSum)\n else:\n return maxSum","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n tot = 0\n mn, mx = float('inf'), float('-inf')\n curmx, curmn = 0, 0\n for num in A:\n curmn = min(curmn + num, num)\n mn = min(mn, curmn)\n curmx = max(curmx + num, num)\n mx = max(mx, curmx)\n tot += num\n \n if tot == mn:\n return mx\n return max(mx, tot-mn)","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n def maxSum(gen):\n res = cur = -float('inf')\n for n in gen:\n cur = n + max(0, cur)\n res = max(res, cur)\n return res\n \n total = sum(A)\n res1 = maxSum(iter(A))\n res2 = total + maxSum(-A[i] for i in range(1, len(A))) # min sum of the unwated sub array\n res3 = total + maxSum(-A[i] for i in range(len(A)-1))\n return max(res1, res2, res3)","import heapq\n\nclass Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n N = len(A)\n best = A[0]\n \n heap = [(0, -1)] \n current_sum = 0\n for i in range(2 * N):\n current_sum += A[i % N]\n while len(heap) > 0 and i - heap[0][1] > N:\n heapq.heappop(heap)\n \n best = max(best, current_sum - heap[0][0])\n heapq.heappush(heap, (current_sum, i))\n \n return best","class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n N = len(A)\n P = []\n P.append(0)\n for _ in range(2):\n for x in A:\n P.append(P[-1] + x)\n \n ans = A[0]\n queue = []\n queue.append(0)\n \n for j in range(1, len(P)):\n if queue[0] < j - N:\n queue.pop(0)\n ans = max(ans, P[j] - P[queue[0]])\n \n while queue and P[j] <= P[queue[-1]]:\n queue.pop()\n queue.append(j)\n \n return ans"],"string":"[\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n N = len(A)\\n if(N==0):\\n return 0\\n curr_max = A[0]\\n global_max = A[0]\\n curr_min = A[0]\\n global_min = A[0]\\n flag = 0 \\n if(A[0]>=0):\\n flag=1\\n \\n for i in range(1, N):\\n if(A[i]>=0):\\n flag=1\\n if(curr_max >= 0):\\n curr_max = curr_max + A[i] \\n else:\\n curr_max = A[i]\\n \\n if(curr_min >= 0):\\n curr_min = A[i]\\n else:\\n curr_min = curr_min + A[i] \\n \\n if(curr_max > global_max):\\n global_max = curr_max\\n if(curr_min < global_min):\\n global_min = curr_min\\n if(flag==0):\\n return max(A)\\n return max(global_max, sum(A) - global_min)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n \\n \\n curr_max = A[0]\\n max_sum = A[0]\\n \\n curr_min = A[0]\\n min_sum = A[0]\\n \\n for i in range(1, len(A)):\\n \\n curr_max = max(A[i], A[i] + curr_max)\\n max_sum = max(curr_max, max_sum)\\n \\n curr_min = min(A[i], A[i] + curr_min)\\n min_sum = min(curr_min, min_sum)\\n \\n if max_sum > 0:\\n return max(sum(A) - min_sum, max_sum)\\n else:\\n return max(A)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n if not A:\\n return 0\\n max_A = max(A)\\n if max_A <= 0:\\n return max_A\\n max_sum = 0\\n cur_sum = 0\\n for i in range(len(A)):\\n cur_sum = max(cur_sum, 0) + A[i]\\n max_sum = max(max_sum, cur_sum)\\n if len(A) <= 2:\\n return max_sum\\n \\n right_sum = A[-1]\\n right_max = [A[-1]]\\n for i in A[len(A)-2::-1]:\\n right_sum += i\\n right_max.append(max(right_max[-1], right_sum))\\n right_max = right_max[::-1]\\n # print(right_max)\\n \\n left_max = A[0]\\n left_sum = A[0]\\n for i in range(1, len(A)-1):\\n # print(A[i], left_max, left_sum)\\n left_sum += A[i]\\n left_max = max(left_max, left_sum)\\n max_sum = max(max_sum, left_max + right_max[i+1])\\n \\n return max_sum\\n \\n \\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n mini = maxi = A[0]\\n curMin = curMax = total = 0\\n for num in A:\\n curMin = min(curMin + num, num) # 2\\n curMax = max(curMax + num, num) # 7\\n maxi = max(maxi, curMax) # 7\\n mini = min(mini, curMin) # -3\\n total += num\\n return max(maxi, total - mini) if maxi > 0 else maxi\\n \\n \\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n \\n \\n def _get_max(lo, hi, flag):\\n m = float('-inf')\\n s = 0\\n for i in range(lo, hi):\\n s = max(s, 0) + flag * A[i]\\n m = max(m, s)\\n return m\\n \\n s = sum(A)\\n \\n return max(_get_max(0, len(A), 1), s + _get_max(0, len(A) - 1, -1), s + _get_max(1, len(A), -1))\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n mx = curr = A[0]\\n cumSum = [A[0]]\\n for i in range(1, len(A)):\\n if curr >= 0:\\n curr += A[i]\\n else:\\n curr = A[i]\\n mx = max(mx, curr)\\n cumSum.append(cumSum[-1]+A[i])\\n revCumSum = []\\n curr = 0\\n for x in reversed(A):\\n curr += x\\n if revCumSum:\\n revCumSum.append(max(revCumSum[-1], curr))\\n else:\\n revCumSum.append(curr)\\n for i in range(len(A)-1):\\n mx = max(mx, cumSum[i]+revCumSum[len(A)-2-i])\\n mx = max(mx, cumSum[-1])\\n return mx\\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n \\n def maxSubarray (A):\\n dp = [0] * len(A)\\n max_c = A[0]\\n flag = True\\n for idx,num in enumerate(A):\\n if num < 0:\\n flag = False\\n if idx == 0:\\n dp[0]=num\\n else:\\n dp[idx]=max(num, dp[idx-1] + num)\\n return max(dp), flag\\n \\n temp,nonNeg = maxSubarray(A)\\n if nonNeg:\\n return temp\\n \\n res = float('-inf')\\n \\n rightWindow = [A[0]] + [0] * (len(A)-1)\\n for idx,i in enumerate(A[1:]):\\n rightWindow[idx+1] = i+rightWindow[idx]\\n\\n \\n currMax = float('-inf')\\n MaxIdx = float('inf')\\n reversedA = A.reverse()\\n leftWindow = [A[0]] + [0] * (len(A)-1)\\n \\n for idx,i in enumerate(A[1:]):\\n leftWindow[idx +1] = i+leftWindow[idx]\\n \\n if MaxIdx >= len(A)-idx-1:\\n currMax = max(rightWindow[:len(A)-idx-1])\\n MaxIdx = rightWindow.index(currMax)\\n\\n res = max(res,currMax + leftWindow[idx])\\n \\n\\n return max(res,temp)\\n\",\n \"import heapq\\n\\nclass Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n N = len(A)\\n best = A[0]\\n \\n heap = [(0, 0)] \\n cumsums = [0]\\n for n in A:\\n cumsums.append(cumsums[-1] + n)\\n for n in A:\\n cumsums.append(cumsums[-1] + n)\\n \\n for i in range(1, len(cumsums)):\\n while len(heap) > 0 and i - heap[0][1] > N:\\n heapq.heappop(heap)\\n \\n best = max(best, cumsums[i] - heap[0][0])\\n heapq.heappush(heap, (cumsums[i], i))\\n \\n return best\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n total, maxSum, curMax, minSum, curMin = 0, A[0], 0, A[0], 0\\n for a in A:\\n curMax = max(curMax + a, a)\\n maxSum = max(maxSum, curMax)\\n curMin = min(curMin + a, a)\\n minSum = min(minSum, curMin)\\n total += a\\n return max(maxSum, total - minSum) if maxSum > 0 else maxSum\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n # case 1, kadane's algo\\n totalSum = sum(A)\\n curr = A[0]\\n maxSum = A[0]\\n \\n for i in range(1, len(A)):\\n if A[i] + curr > A[i]:\\n curr = A[i] + curr\\n else:\\n curr = A[i]\\n \\n maxSum = max(maxSum, curr)\\n \\n # case 2, wrapping\\n \\n curr = A[0]\\n minSum = totalSum\\n \\n for i in range(1, len(A)):\\n curr = min(A[i]+curr, A[i])\\n \\n minSum = min(minSum, curr)\\n \\n if totalSum == minSum:\\n return maxSum\\n return max(totalSum - minSum, maxSum)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n\\n def kadane(array):\\n global_max = array[0]\\n local_max = array[0]\\n\\n for i in range(1,len(array)):\\n if local_max < 0:\\n local_max = 0\\n local_max = array[i] + local_max \\n if local_max > global_max:\\n global_max = local_max\\n\\n return global_max\\n \\n def kadane_inverse(array):\\n global_min = array[0]\\n local_min = array[0]\\n \\n for i in range(1,len(array)):\\n if local_min > 0:\\n local_min = 0\\n local_min = array[i] + local_min \\n if local_min < global_min:\\n global_min = local_min\\n\\n return global_min\\n \\n total = sum(A)\\n inv = kadane_inverse(A)\\n reg = kadane(A)\\n if total == inv:\\n return reg\\n return max(total-inv, reg)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n \\n def maxSubarray (A):\\n dp = [0] * len(A)\\n max_c = A[0]\\n for idx,num in enumerate(A):\\n if idx != 0:\\n dp[idx]=max(num, dp[idx-1] + num)\\n else:\\n dp[0]=num\\n \\n return max(dp)\\n \\n temp = maxSubarray(A)\\n\\n res = float('-inf')\\n rightMax = [max(A[0],0)] + [0] * (len(A)-1)\\n currMax = max(A[0],0)\\n rightWindow = [A[0]] + [0] * (len(A)-1)\\n for idx,i in enumerate(A[1:]):\\n currMax = max(i+rightWindow[idx], currMax)\\n rightMax[idx+1] = currMax\\n rightWindow[idx+1] = i+rightWindow[idx]\\n \\n\\n reversedA = A.reverse()\\n leftWindow = [A[0]] + [0] * (len(A)-1)\\n \\n for idx,i in enumerate(A[1:]):\\n leftWindow[idx +1] = i+leftWindow[idx]\\n currMax = rightMax[len(A)-idx-2]\\n res = max(res,currMax + leftWindow[idx])\\n \\n\\n return max(res,temp)\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n \\n n = len(A)\\n cur_sum = A[0]\\n result1 = A[0]\\n for i in range(1,n):\\n cur_sum = max(A[i],cur_sum+A[i])\\n result1 = max(cur_sum,result1)\\n \\n if n == 1: return result1\\n \\n cur_sum = A[1]\\n result2 = A[1]\\n for i in range(2,n-1):\\n cur_sum = min(A[i],cur_sum+A[i])\\n result2 = min(cur_sum, result2)\\n \\n return max(result1,sum(A)-result2)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n total, maxSum, curMax, minSum, curMin = 0, A[0], 0, A[0], 0\\n for a in A:\\n curMax = max(curMax + a, a)\\n maxSum = max(maxSum, curMax)\\n curMin = min(curMin + a, a)\\n minSum = min(minSum, curMin)\\n total += a\\n return max(maxSum, total - minSum) if maxSum > 0 else maxSum\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n n = len(A)\\n if n == 1:\\n return A[0]\\n \\n def kadane(it):\\n max_ = current = float('-inf')\\n for num in it:\\n current = num + max(current, 0)\\n max_ = max(max_, current)\\n return max_\\n \\n total = sum(A)\\n max1 = kadane(num for num in A)\\n max2 = total + kadane(-A[idx] for idx in range(n - 1))\\n max3 = total + kadane(-A[idx] for idx in range(1, n))\\n\\n return max(max1, max2, max3)\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n if A is None or not A:\\n return 0\\n\\n N = len(A)\\n A = A + A\\n\\n acc = [0]\\n for d in A:\\n acc.append(acc[-1] + d)\\n\\n ret = -sys.maxsize\\n queue = deque([0])\\n\\n for j in range(1, 2 * N):\\n while queue and queue[0] < j - N:\\n queue.popleft()\\n\\n ret = max(ret, acc[j] - acc[queue[0]])\\n\\n while queue and acc[queue[-1]] >= acc[j]:\\n queue.pop()\\n\\n queue.append(j)\\n\\n return ret\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n \\n def maxSubarray (A):\\n dp = [0] * len(A)\\n max_c = A[0]\\n flag = True\\n for idx,num in enumerate(A):\\n if num < 0:\\n flag = False\\n if idx == 0:\\n dp[0]=num\\n else:\\n dp[idx]=max(num, dp[idx-1] + num)\\n return max(dp), flag\\n \\n temp,nonNeg = maxSubarray(A)\\n\\n \\n res = float('-inf')\\n rightMax = [max(A[0],0)] + [0] * (len(A)-1)\\n currMax = max(A[0],0)\\n rightWindow = [A[0]] + [0] * (len(A)-1)\\n for idx,i in enumerate(A[1:]):\\n currMax = max(i+rightWindow[idx], currMax)\\n rightMax[idx+1] = currMax\\n rightWindow[idx+1] = i+rightWindow[idx]\\n \\n\\n reversedA = A.reverse()\\n leftWindow = [A[0]] + [0] * (len(A)-1)\\n \\n for idx,i in enumerate(A[1:]):\\n leftWindow[idx +1] = i+leftWindow[idx]\\n currMax = rightMax[len(A)-idx-2]\\n res = max(res,currMax + leftWindow[idx])\\n \\n\\n return max(res,temp)\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n sm = sum(A)\\n mx = mn = cur_mx = cur_mn = A[0]\\n for i in range(1, len(A)):\\n cur_mn = min(cur_mn + A[i], A[i])\\n mn = min(mn, cur_mn)\\n cur_mx = max(cur_mx + A[i], A[i])\\n mx = max(mx, cur_mx)\\n return max(mx, (mn if mn==sm else (sm - mn)))\",\n \"class Solution:\\n def maxSubarraySumCircular(self, a: List[int]) -> int:\\n n = len(a)\\n ans = float('-inf')\\n current = 0\\n for num in a:\\n current = num + max(0, current)\\n ans = max(ans, current)\\n \\n right_sum = [0] * n\\n right_sum[-1] = a[-1]\\n right_most = [float('-inf')] * n\\n right_most[-1] = right_sum[-1]\\n for i in range(n - 2, -1, -1):\\n right_sum[i] = right_sum[i + 1] + a[i]\\n right_most[i] = max(right_sum[i], right_most[i + 1])\\n left_sum = 0\\n for i in range(n - 2):\\n left_sum += a[i]\\n ans = max(ans, left_sum + right_most[i + 2])\\n return ans\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n max_subarray = float('-inf')\\n cur_max_subarray = 0\\n min_subarray = float('inf')\\n cur_min_subarray = 0\\n total = 0\\n max_value = float('-inf')\\n for num in A:\\n cur_max_subarray += num\\n if cur_max_subarray < 0:\\n cur_max_subarray = 0\\n else:\\n max_subarray = max(max_subarray, cur_max_subarray)\\n cur_min_subarray += num\\n if cur_min_subarray > 0:\\n cur_min_subarray = 0\\n else:\\n min_subarray = min(min_subarray, cur_min_subarray)\\n total += num\\n max_value = max(max_value, num)\\n if max_value <= 0:\\n return max_value\\n return max(max_subarray, total-min_subarray)\\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n dp = [0]\\n for _ in range(2):\\n for num in A:\\n dp.append(dp[-1]+num) \\n \\n res = A[0]\\n deque = collections.deque([0]) # i's, increasing by P[i]\\n for j in range(1, len(dp)):\\n # If the smallest i is too small, remove it.\\n if deque[0] < j-len(A):\\n deque.popleft()\\n\\n # The optimal i is deque[0], for cand. answer P[j] - P[i].\\n res = max(res, dp[j] - dp[deque[0]])\\n\\n # Remove any i1's with P[i2] <= P[i1].\\n while deque and dp[j] <= dp[deque[-1]]:\\n deque.pop()\\n\\n deque.append(j)\\n return res\\n '''\\n As before, sum(nums[i:i+k]) = dp[i+k]-dp[i]\\n now, sum[i+k:i] = dp[len(A)-(i+k)]+dp[i]\\n '''\\n cur_max = -float('inf')\\n dp = [0]\\n for num in A:\\n dp.append(dp[-1]+num)\\n \\n for i in range(len(A)):\\n for j in range(i+1,i+len(A)+1):\\n if j <= len(A):\\n cur_max = max(cur_max,dp[j]-dp[i])\\n else:\\n cur_max = max(cur_max,dp[len(A)]-dp[i]+dp[j%len(A)])\\n return cur_max\\n \\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n ansIfOne = kadane(A)\\n \\n ansIfTwo = sum(A) - kadaneMin(A[1:len(A)-1])\\n \\n return max(ansIfOne, ansIfTwo)\\n \\n \\n \\ndef kadane(A):\\n prevMax = -math.inf\\n result = -math.inf\\n for x in A:\\n curMax = max(prevMax + x, x)\\n prevMax = curMax\\n result = max(result, curMax)\\n return result\\n\\ndef kadaneMin(A):\\n prevMin = math.inf\\n result = math.inf\\n for x in A:\\n curMin = min(prevMin + x, x)\\n prevMin = curMin\\n result = min(result, curMin)\\n return result\\n\",\n \"class Solution:\\n def maxSubarraySumCircular1(self, A: List[int]) -> int:\\n maxSubarraySum = [i for i in A]\\n minSubarraySum = [i for i in A]\\n for i in range(1,len(A)):\\n maxSubarraySum[i] = max(maxSubarraySum[i-1]+A[i],A[i])\\n for i in range(1,len(A)):\\n minSubarraySum[i] = min(minSubarraySum[i-1]+A[i],A[i])\\n return max(max(maxSubarraySum),sum(A)-min(minSubarraySum)) if max(maxSubarraySum) >0 else max(maxSubarraySum)\\n \\n def maxSubarraySumCircular(self, A):\\n total = 0\\n curMax = 0\\n maxSubArraySum = A[0]\\n curMin = 0\\n minSubArraySum = A[0]\\n \\n for a in A:\\n curMax = max(curMax+a,a)\\n maxSubArraySum = max(maxSubArraySum,curMax)\\n curMin = min(curMin+a,a)\\n minSubArraySum = min(minSubArraySum,curMin)\\n total += a \\n return max(maxSubArraySum,total-minSubArraySum) if maxSubArraySum > 0 else maxSubArraySum\",\n \"import sys\\nclass Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n def kadane(A,n):\\n maxG = 0\\n curr_max = 0\\n for i in range(n):\\n curr_max += A[i]\\n curr_max = max(0,curr_max)\\n maxG = max(maxG, curr_max)\\n \\n return maxG\\n \\n flag = None\\n for i in A:\\n if i > 0:\\n flag=1\\n break\\n if not flag:\\n return max(A)\\n \\n n = len(A)\\n noWrap = kadane(A,n)\\n total = 0\\n for i in range(n):\\n total += A[i]\\n A[i] *= -1\\n minTotal = kadane(A,n)\\n maxG = total+minTotal\\n return max(noWrap,maxG)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A):\\n def kadane(gen):\\n ans = cur = float('-inf') # maximum non-empty subarray sum\\n for x in gen:\\n cur = max(cur, 0) + x\\n ans = max(ans, cur)\\n return ans\\n\\n S = sum(A)\\n ans1 = kadane(iter(A))\\n ans2 = S + kadane(-A[i] for i in range(1, len(A)))\\n ans3 = S + kadane(-A[i] for i in range(len(A) - 1))\\n\\n return max(ans1, ans2, ans3)\",\n \"class Solution:\\n def maxSubarraySumCircular1(self, A: List[int]) -> int:\\n maxSubarraySum = [i for i in A]\\n minSubarraySum = [i for i in A]\\n for i in range(1,len(A)):\\n maxSubarraySum[i] = max(maxSubarraySum[i-1]+A[i],A[i])\\n for i in range(1,len(A)):\\n minSubarraySum[i] = min(minSubarraySum[i-1]+A[i],A[i])\\n return max(max(maxSubarraySum),sum(A)-min(minSubarraySum)) if max(maxSubarraySum) >0 else max(maxSubarraySum)\\n \\n def maxSubarraySumCircular(self, A):\\n total, maxSum, curMax, minSum, curMin = 0, A[0], 0, A[0], 0\\n for a in A:\\n curMax = max(curMax + a, a)\\n maxSum = max(maxSum, curMax)\\n curMin = min(curMin + a, a)\\n minSum = min(minSum, curMin)\\n total += a\\n return max(maxSum, total - minSum) if maxSum > 0 else maxSum\",\n \"class Solution:\\n def maxSubarraySumCircular(self, arr: List[int]) -> int:\\n max_eh = arr[0]\\n min_eh = arr[0]\\n max_sf = arr[0]\\n min_sf = arr[0]\\n total = sum(arr)\\n for i in range(1,len(arr)):\\n max_eh = max(max_eh+arr[i],arr[i])\\n max_sf = max(max_eh,max_sf)\\n min_eh = min(min_eh+arr[i],arr[i])\\n min_sf = min(min_eh,min_sf)\\n\\n if min_sf == total:\\n return max_sf\\n else:\\n return max(max_sf,total-min_sf)\\n\\n\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n res = A[0]\\n cur = A[0]\\n sumn = sum(A)\\n \\n \\n for num in A[1:]:\\n cur = num + max(0, cur)\\n res = max(cur, res)\\n \\n if len(A) >= 2:\\n mincur = -A[1]\\n minres = -A[1]\\n for num in A[2:]:\\n mincur = -num + max(0, mincur)\\n minres = max(minres, mincur)\\n \\n res = max(res, sumn + minres)\\n \\n mincur = -A[0]\\n minres = -A[0]\\n for num in A[1:(len(A)-1)]:\\n mincur = -num + max(0, mincur)\\n minres = max(minres, mincur)\\n \\n \\n res = max(res, sumn + minres)\\n \\n return res\\n \\n\",\n \"# case1: ---------|\\n \\n# case2: ---------|----------\\n# |--------|\\n# suf pre\\n# maxsubarray = total - min(subarray)\\n\\n\\nclass Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n local_min = 0\\n local_max = 0\\n global_min = A[0]\\n global_max = A[0]\\n total = 0\\n for num in A:\\n total += num\\n local_min = min(local_min+num, num)\\n global_min = min(global_min, local_min)\\n local_max = max(local_max+num, num)\\n global_max = max(global_max, local_max)\\n \\n \\n if global_max < 0: return global_max \\n else: return max(global_max, total-global_min)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n max_sum = min_sum = A[0]\\n curr_max = curr_min = tot = 0\\n for a in A:\\n curr_max = max(curr_max + a, a)\\n curr_min = min(curr_min + a, a)\\n max_sum = max(curr_max, max_sum)\\n min_sum = min(curr_min, min_sum)\\n tot += a\\n return max(max_sum, tot - min_sum) if max_sum > 0 else max_sum\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n # Maximum Sum Circular Subarray\\n # 8/22/20 3:41\\n total, maxSum = 0, A[0]\\n curMax, minSum, curMin = 0, A[0], 0\\n for a in A:\\n curMax = max(curMax + a, a)\\n maxSum = max(maxSum, curMax)\\n curMin = min(curMin + a, a)\\n minSum = min(minSum, curMin)\\n total += a\\n return max(maxSum, total - minSum) if total != minSum else maxSum\\n \\n \\n\\n# input: [5,-3,5]\\n# Output:7\\n# Expected:10\\n\\n \\n \\n \\n \\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n maxsum = minsum = A[0]\\n curmax = curmin = total = 0\\n \\n for num in A:\\n curmax = max(num, curmax + num)\\n maxsum = max(maxsum, curmax)\\n curmin = min(num, curmin + num)\\n minsum = min(minsum, curmin)\\n total += num\\n \\n return max(maxsum, total - minsum) if maxsum > 0 else maxsum\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n curmax, curmin = 0 , 0\\n total = 0\\n maxsum = minsum = A[0]\\n \\n for num in A:\\n curmax = max(num, curmax + num)\\n maxsum = max(maxsum, curmax)\\n curmin = min(num, curmin + num)\\n minsum = min(minsum, curmin)\\n total += num\\n return max(maxsum, total - minsum) if maxsum > 0 else maxsum\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n maxSubarraySum = [i for i in A]\\n minSubarraySum = [i for i in A]\\n for i in range(1,len(A)):\\n maxSubarraySum[i] = max(maxSubarraySum[i-1]+A[i],A[i])\\n for i in range(1,len(A)):\\n minSubarraySum[i] = min(minSubarraySum[i-1]+A[i],A[i])\\n return max(max(maxSubarraySum),sum(A)-min(minSubarraySum)) if max(maxSubarraySum) >0 else max(maxSubarraySum)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A):\\n n = len(A)\\n S = sum(A)\\n m1 = self.kadane(A)\\n m2 = S + self.kadane([-A[i] for i in range(1, n)])\\n m3 = S + self.kadane([-A[i] for i in range(n-1)])\\n return max(m1, m2, m3)\\n \\n def kadane(self, arr):\\n res = cur = -float('inf')\\n for a in arr:\\n cur = a + max(0, cur)\\n res = max(cur, res)\\n return res\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n n = len(A)\\n B = [0]+A+A\\n for i in range(1, len(B)):\\n B[i] += B[i-1]\\n maxv = B[1]\\n \\n stack = [0]\\n for end in range(1, len(B)):\\n num = B[end]\\n while stack and num < B[stack[-1]]:\\n stack.pop()\\n stack.append(end)\\n if end-stack[0] == n+1:\\n stack.pop(0)\\n maxv = max(num-B[stack[0]], maxv)\\n #print(end, stack, maxv)\\n if all(x<0 for x in A):\\n return max(A)\\n return maxv\\n \\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n if A == None or len(A) == 0:\\n return 0\\n max_sum , min_sum , total = -100000000, 1000000000, 0\\n curr_max_sum, curr_min_sum = 0, 0\\n for i in A:\\n curr_max_sum += i\\n max_sum = max(curr_max_sum, max_sum)\\n curr_max_sum = max(curr_max_sum, 0)\\n curr_min_sum += i\\n min_sum = min(curr_min_sum, min_sum)\\n curr_min_sum = min(curr_min_sum, 0)\\n total += i\\n return max_sum if max_sum < 0 else max(max_sum, total-min_sum)\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n #naive will be n^2: try every possible start position\\n \\n #3 cases\\n \\n minSum = A[0]\\n maxSum = A[0]\\n maximum = A[0]\\n minimum = A[0]\\n for i in range(1, len(A)):\\n if A[i] > maxSum + A[i]:\\n maxSum = A[i]\\n else:\\n maxSum += A[i]\\n maximum = max(maximum, maxSum)\\n if A[i] < minSum + A[i]:\\n minSum = A[i]\\n else:\\n minSum += A[i]\\n minimum = min(minimum, minSum)\\n \\n minimum = sum(A) - minimum\\n if minimum == 0: #means the entire araay is negative, so we take the max element\\n return maximum\\n return max(maximum, minimum)\\n \\n #take the max of 3 cases\\n #1. maximum\\n #2. total - minimum\\n #3. if all negatives, then the max should be the maximum\\n \\n #[-2,-3,-1]. Take a look at this case, for example. \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n maxSum=A[0]\\n minSum=A[0]\\n currMax=0\\n currMin=0\\n total=0\\n for a in A:\\n currMax=max(currMax+a,a)\\n maxSum=max(currMax,maxSum)\\n currMin=min(currMin+a,a)\\n minSum=min(currMin,minSum)\\n total+=a\\n return max(maxSum,total-minSum) if maxSum>0 else maxSum\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n mx = float('-inf')\\n curr = 0\\n for x in A:\\n if curr >= 0:\\n curr += x\\n else:\\n curr = x\\n mx = max(mx, curr)\\n cumSum = []\\n curr = 0\\n for x in A:\\n curr += x\\n cumSum.append(curr)\\n revCumSum = []\\n curr = 0\\n for x in reversed(A):\\n curr += x\\n revCumSum.append(curr)\\n for i in range(1, len(A)):\\n revCumSum[i] = max(revCumSum[i-1], revCumSum[i])\\n for i in range(len(A)-1):\\n mx = max(mx, cumSum[i]+revCumSum[len(A)-2-i])\\n mx = max(mx, cumSum[-1])\\n return mx\\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n max_seen = max(A)\\n if max_seen < 0:\\n return max_seen\\n min_seen = float('inf')\\n curr_max = 0\\n curr_min = 0\\n total = 0\\n \\n for num in A:\\n total += num\\n curr_max = max(0, curr_max + num)\\n curr_min = min(0, curr_min + num)\\n max_seen = max(max_seen, curr_max)\\n min_seen = min(min_seen, curr_min)\\n \\n return max(max_seen, total - min_seen)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n \\n def maxSubarray (A):\\n dp = [0] * len(A)\\n max_c = A[0]\\n for idx,num in enumerate(A):\\n if idx != 0:\\n dp[idx]=max(num, dp[idx-1] + num)\\n else:\\n dp[0]=num\\n \\n return max(dp)\\n \\n temp = maxSubarray(A)\\n\\n \\n res = float('-inf')\\n rightMax = [max(A[0],0)] + [0] * (len(A)-1)\\n currMax = max(A[0],0)\\n rightWindow = [A[0]] + [0] * (len(A)-1)\\n for idx,i in enumerate(A[1:]):\\n currMax = max(i+rightWindow[idx], currMax)\\n rightMax[idx+1] = currMax\\n rightWindow[idx+1] = i+rightWindow[idx]\\n \\n\\n reversedA = A.reverse()\\n leftWindow = [A[0]] + [0] * (len(A)-1)\\n \\n for idx,i in enumerate(A[1:]):\\n leftWindow[idx +1] = i+leftWindow[idx]\\n currMax = rightMax[len(A)-idx-2]\\n res = max(res,currMax + leftWindow[idx])\\n \\n\\n return max(res,temp)\\n\",\n \"from sys import maxsize\\nclass Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n i=1\\n n=len(A)\\n # A=A+A\\n # end = n\\n ans = A[0]\\n ans_max = A[0]\\n ans_min = A[0]\\n ans_f = A[0]\\n sumi = A[0]\\n while i < n:\\n sumi += A[i]\\n if ans+A[i%n]>A[i%n]:\\n ans+=A[i%n]\\n else:\\n ans=A[i%n]\\n \\n if ans_f+A[i%n]<A[i%n]:\\n ans_f+=A[i%n]\\n else:\\n ans_f=A[i%n]\\n ans_max = max(ans_max, ans)\\n ans_min = min(ans_min, ans_f)\\n i+=1\\n \\n return max(ans_max,sumi-ans_min) if ans_min!=sumi else ans_max\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n for i in range(1, len(A)):\\n A[i] += A[i-1]\\n pre_min, pre_max = float('inf'), float('-inf')\\n res1, res2 = A[0], A[0]\\n for a in A:\\n res1 = max(res1, a-pre_min)\\n res2 = min(res2, a-pre_max)\\n pre_min = min(pre_min, a)\\n pre_max = max(pre_max, a)\\n res1 = max(res1, A[-1])\\n res2 = min(res2, A[-1])\\n if res2 == A[-1]:\\n return res1\\n else:\\n return max(res1, A[-1]-res2)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n n = len(A)\\n if n == 1:\\n return A[0]\\n \\n max_ = A[0]\\n current = 0\\n for num in A:\\n current += num\\n max_ = max(max_, current)\\n if current < 0:\\n current = 0\\n \\n max_from_left = [0] * n\\n max_from_left[0] = float('-inf')\\n current = A[0]\\n for idx in range(1, n):\\n max_from_left[idx] = max(max_from_left[idx - 1], current)\\n current += A[idx]\\n max_from_left[0] = 0\\n \\n so_far = 0\\n for idx in range(n - 1, -1, -1):\\n so_far += A[idx]\\n max_ = max(max_, so_far + max_from_left[idx])\\n return max_\\n \\n# left_acc = [0] * n\\n# left_acc[0] = A[0]\\n# for idx in range(1, n):\\n# left_acc[idx] = A[idx] + left_acc[idx - 1]\\n \\n \\n# right_acc = [0] * n\\n# right_acc[-1] = A[-1]\\n# for idx in range(n - 2, -1, -1):\\n# right_acc[idx] = A[idx] + right_acc[idx + 1]\\n \\n# print(left_acc)\\n# print(right_acc)\\n# left, right = 0, n - 1\\n# while left < right:\\n# max_ = max(max_, left_acc[left] + right_acc[right])\\n# if left_acc[left] > right_acc[right]:\\n# right -= 1\\n# else:\\n# left += 1\\n \\n# return max_\\n\",\n \"import math\\n\\nclass Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n total = 0\\n maxss, maxss_cur = -math.inf, -math.inf\\n minss, minss_cur = 0, 0\\n for a in A:\\n maxss_cur = a + max(maxss_cur, 0)\\n maxss = max(maxss, maxss_cur)\\n \\n minss_cur = a + min(minss_cur, 0)\\n minss = min(minss, minss_cur)\\n \\n total += a\\n \\n return maxss if total == minss else max(maxss, total - minss)\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n \\n currMaxSum = 0\\n currMinSum = 0\\n maxSum = float('-inf')\\n minSum = float('inf')\\n flag = False\\n \\n totalSum = 0\\n \\n for i in range(len(A)):\\n currMaxSum += A[i]\\n maxSum = max(maxSum, currMaxSum)\\n if currMaxSum < 0:\\n currMaxSum = 0\\n\\n \\n totalSum += A[i]\\n if A[i] >= 0: \\n flag = True\\n \\n currMinSum += A[i]\\n minSum = min(minSum, currMinSum)\\n if currMinSum > 0:\\n currMinSum = 0\\n \\n if flag:\\n return max(totalSum-minSum, maxSum)\\n else:\\n return maxSum\\n \\n \\n \\n \\n \\n\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n# currMaxSum = 0\\n# currMinSum = 0\\n# flag = False\\n# maxSum = float('-inf')\\n# minSum = float('inf')\\n# totalSum = 0\\n \\n# for i in range(len(A)):\\n \\n# currMaxSum += A[i]\\n# maxSum = max(maxSum, currMaxSum)\\n# if currMaxSum < 0:\\n# currMaxSum = 0\\n \\n# totalSum += A[i]\\n# if A[i] >= 0:\\n# flag = True\\n \\n \\n# currMinSum += A[i]\\n# minSum = min(minSum, currMinSum)\\n# if currMinSum > 0:\\n# currMinSum = 0\\n \\n# if not flag:\\n# return maxSum \\n\\n# else:\\n# return max(maxSum, totalSum-minSum)\\n \\n \\n \\n \\n\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n# ans1 = cur = None \\n# for x in A:\\n# cur = x + max(cur, 0)\\n# ans1 = max(ans1, cur)\\n \\n# ans2 = cur = float(\\\\\\\"inf\\\\\\\")\\n# for i in range(1, len(A)):\\n# cur = A[i] + min(cur, 0)\\n# ans2 = min(ans2, cur)\\n# ans2 = sum(A) - ans2\\n \\n# ans3 = cur = float(\\\\\\\"inf\\\\\\\")\\n# for i in range(len(A)-1):\\n# cur = A[i] + min(cur, 0)\\n# ans3 = min(ans3, cur)\\n# ans3 = sum(A) - ans3\\n \\n# return max(ans1, ans2, ans3)\\n \\n \\n \\n\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n# track = [[0 for j in range(len(A))] for j in range(len(A))]\\n# max_val = min(A)\\n# for i in range(len(A)):\\n# track[i][i] = A[i]\\n# for j in range(i+1, len(A)):\\n# track[i][j] = track[i][j-1] + A[j]\\n# max_val = max(max_val, track[i][j])\\n# max_val = max(max_val, track[i][i])\\n \\n# #print(track)\\n# for i in range(len(A)-1, 0, -1):\\n# for j in range(0, i):\\n# track[i][j] = track[i][len(track) - 1] + track[0][j]\\n# max_val = max(max_val, track[i][j])\\n \\n# #print(track)\\n# return max_val]\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n \\n currMaxSum = 0\\n currMinSum = 0\\n flag = False\\n maxSum = float('-inf')\\n minSum = float('inf')\\n totalSum = 0\\n \\n for i in range(len(A)):\\n \\n currMaxSum += A[i]\\n maxSum = max(maxSum, currMaxSum)\\n if currMaxSum < 0:\\n currMaxSum = 0\\n \\n totalSum += A[i]\\n if A[i] >= 0:\\n flag = True\\n \\n \\n currMinSum += A[i]\\n minSum = min(minSum, currMinSum)\\n if currMinSum > 0:\\n currMinSum = 0\\n \\n if not flag:\\n return maxSum \\n\\n else:\\n return max(maxSum, totalSum-minSum)\\n \\n \\n \\n \\n\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n# ans1 = cur = None \\n# for x in A:\\n# cur = x + max(cur, 0)\\n# ans1 = max(ans1, cur)\\n \\n# ans2 = cur = float(\\\\\\\"inf\\\\\\\")\\n# for i in range(1, len(A)):\\n# cur = A[i] + min(cur, 0)\\n# ans2 = min(ans2, cur)\\n# ans2 = sum(A) - ans2\\n \\n# ans3 = cur = float(\\\\\\\"inf\\\\\\\")\\n# for i in range(len(A)-1):\\n# cur = A[i] + min(cur, 0)\\n# ans3 = min(ans3, cur)\\n# ans3 = sum(A) - ans3\\n \\n# return max(ans1, ans2, ans3)\\n \\n \\n \\n\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n# track = [[0 for j in range(len(A))] for j in range(len(A))]\\n# max_val = min(A)\\n# for i in range(len(A)):\\n# track[i][i] = A[i]\\n# for j in range(i+1, len(A)):\\n# track[i][j] = track[i][j-1] + A[j]\\n# max_val = max(max_val, track[i][j])\\n# max_val = max(max_val, track[i][i])\\n \\n# #print(track)\\n# for i in range(len(A)-1, 0, -1):\\n# for j in range(0, i):\\n# track[i][j] = track[i][len(track) - 1] + track[0][j]\\n# max_val = max(max_val, track[i][j])\\n \\n# #print(track)\\n# return max_val\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n# total, maxSum, curMax, minSum, curMin = 0, float('-inf'), 0, float('inf'), 0\\n \\n# for a in A:\\n# curMax = max(curMax + a, a)\\n# maxSum = max(maxSum, curMax)\\n# curMin = min(curMin + a, a)\\n# minSum = min(minSum, curMin)\\n# total += a\\n \\n# return max(maxSum, total - minSum) if maxSum > 0 else maxSum\\n \\n \\n if not A:\\n return 0\\n \\n dp_max = [-99999] * len(A)\\n dp_min = [-99999] * len(A)\\n dp_max[0], dp_min[0] = A[0], A[0]\\n \\n for i in range(1, len(A)):\\n dp_max[i] = max(A[i], dp_max[i - 1] + A[i])\\n dp_min[i] = min(A[i], dp_min[i - 1] + A[i])\\n \\n if min(dp_min) == sum(A):\\n return max(dp_max)\\n else:\\n return max(max(dp_max), sum(A) - min(dp_min))\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n # max(the max subarray sum, the total sum - the min subarray sum)\\n max_sum = -float('inf')\\n cur_max = -float('inf')\\n total_sum = 0\\n cur_min = float('inf')\\n min_sum = float('inf')\\n for i in A:\\n total_sum += i\\n \\n cur_max = max(cur_max + i, i)\\n cur_min = min(cur_min + i, i)\\n \\n max_sum = max(max_sum, cur_max)\\n min_sum = min(min_sum, cur_min)\\n \\n if total_sum - min_sum == 0:\\n return max_sum\\n return max(max_sum, total_sum - min_sum) \",\n \"# method 1 append array's copy at back of it. then apply kadane's algorithm\\n# *not work* because we can only attain maximum n size window but here it can be 2n\\n\\n# method 2 sliding window max window size = n\\n# *not work* because there is no way to move back of window\\n\\n# method 3 modified kadane's algorithm(see in lee215's solution)\\nclass Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n if not A:\\n return 0\\n \\n max_sum, cur_max, min_sum, cur_min, total = A[0], 0, A[0], 0, 0\\n for a in A:\\n cur_max = max(a + cur_max, a)\\n max_sum = max(max_sum, cur_max)\\n \\n cur_min = min(a + cur_min, a)\\n min_sum = min(min_sum, cur_min)\\n \\n total += a\\n \\n return max(max_sum, total - min_sum) if total > min_sum else max_sum\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n total = sum(A)\\n minSum = self.maxSum([-x for x in A]) + total\\n maxSum = self.maxSum(A)\\n #print(maxSum)\\n #print(minSum)\\n return max(maxSum, minSum) if minSum > 0 else maxSum\\n \\n def maxSum(self, A: List[int]) -> int:\\n current = 0\\n max_sum = float('-inf')\\n for num in A:\\n current += num\\n \\n if current > max_sum:\\n max_sum = current\\n \\n if current < 0:\\n current = 0\\n \\n return max_sum\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n # 1. get max subarray sum\\n maxSum = curSum = A[0]\\n for i in range(1, len(A)):\\n curSum = max(A[i], A[i] + curSum)\\n maxSum = max(maxSum, curSum)\\n \\n if maxSum < 0:\\n return maxSum\\n \\n # 2. get min subarray sum\\n minSum = curSum = A[0]\\n for i in range(1, len(A)):\\n curSum = min(A[i], A[i] + curSum)\\n minSum = min(minSum, curSum)\\n \\n # 3. compare (max subarray sum) with (total sum - min subarray sum)\\n return max(sum(A)-minSum, maxSum)\",\n \"#Two cases:\\n#MaxSubarray = normal -> proceed normally\\n#MaxSubarray = circular -> total sum - minSubarray\\n#return max(maxSubarray, maxSubarraycircular\\nclass Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n total_sum = 0\\n global_max = A[0]\\n global_min = A[0]\\n local_max = 0\\n local_min = 0\\n for num in A:\\n local_max = max(num, local_max + num)\\n local_min = min(num, local_min + num)\\n global_max = max(global_max, local_max)\\n global_min = min(global_min, local_min)\\n total_sum += num\\n \\n circular_max = total_sum - global_min\\n if global_max <= 0:\\n return global_max\\n return max(circular_max, global_max)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n SUM = 0\\n MIN = 0\\n minsum = sys.maxsize\\n MAX = 0\\n maxsum = -sys.maxsize\\n \\n for num in A:\\n SUM += num\\n maxsum = max(maxsum, SUM-MIN)\\n MIN = min(MIN,SUM)\\n minsum = min(minsum, SUM-MAX)\\n MAX = max(MAX,SUM)\\n if minsum == SUM:\\n return maxsum\\n return max(maxsum, SUM-minsum)\",\n \"#Two cases:\\n#MaxSubarray = normal -> proceed normally\\n#MaxSubarray = circular -> total sum - minSubarray\\n#return max(maxSubarray, maxSubarraycircular\\nclass Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n total_sum = 0\\n global_max = A[0]\\n global_min = A[0]\\n local_max = 0\\n local_min = 0\\n for num in A:\\n local_max = max(num, local_max + num)\\n local_min = min(num, local_min + num)\\n global_max = max(global_max, local_max)\\n global_min = min(global_min, local_min)\\n total_sum += num\\n \\n circular_max = total_sum - global_min\\n return max(circular_max, global_max) if global_max > 0 else global_max\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n n = len(A)\\n \\n if n == 1:\\n return A[0]\\n \\n global_max = float('-inf')\\n global_min = float('inf')\\n \\n local_max = 0\\n local_min = 0\\n \\n for i, a in enumerate(A):\\n local_max = max(local_max + a, a)\\n global_max = max(global_max, local_max)\\n \\n if 0 < i < n - 1:\\n local_min = min(local_min + a, a)\\n global_min = min(global_min, local_min)\\n \\n return max(global_max, sum(A) - global_min)\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n max1 = -float('inf')\\n maxc = -float('inf')\\n for i in range(len(A)):\\n maxc = max(maxc+A[i],A[i])\\n max1 = max(max1,maxc)\\n \\n \\n min1 = float('inf')\\n minc = float('inf')\\n for i in range(len(A)):\\n minc = min(minc+A[i],A[i])\\n min1 = min(min1,minc)\\n \\n if min1==sum(A):\\n return max1\\n\\n return max(max1,sum(A)-min1)\\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n # n = len(A)\\n # max_sub_ending = [A[0]]\\n # max_sub_start_index = [0]\\n \\n# A.extend(A)\\n# print(A)\\n# for i in range(1, len(A)):\\n# prev = max_sub_ending[i-1]\\n# if prev <= 0:\\n# max_sub_start_index.append(i)\\n# max_sub_ending.append(A[i])\\n# if i - max_sub_start_index[-1] < n:\\n# max_sub_start_index.append(max_sub_start_index[-1])\\n# max_sub_ending.append(A[i]+max_sub_ending[-1])\\n# elif (i - max_sub_start_index[-1]) == n:\\n# index_len = len(max_sub_start_index)\\n# val = max_sub_start_index[index_len-n]\\n# current_sum = max_sub_ending[-1] - val\\n# if current_sum <= 0:\\n# max_sub_start_index.append(i)\\n# max_sub_ending.append(A[i])\\n# else:\\n# max_sub_start_index.append(max_sub_start_index[-1]+1)\\n# max_sub_ending.append(A[i]+current_sum)\\n# print(max_sub_ending)\\n# return max(max_sub_ending)\\n n = len(A)\\n max_sub_ending = [A[0]]\\n max_sub_ending_index = [0]\\n \\n for i in range(1, len(A)):\\n prev = max_sub_ending[i-1]\\n if prev <= 0:\\n max_sub_ending_index.append(i)\\n max_sub_ending.append(A[i])\\n else:\\n max_sub_ending_index.append(max_sub_ending_index[-1])\\n max_sub_ending.append(A[i]+max_sub_ending[-1])\\n print(max_sub_ending)\\n posmax = max(max_sub_ending)\\n total = sum(A)\\n \\n for i in range(len(A)):\\n A[i] = -A[i]\\n max_sub_ending = [A[0]]\\n max_sub_ending_index = [0]\\n \\n for i in range(1, len(A)):\\n prev = max_sub_ending[i-1]\\n if prev <= 0:\\n max_sub_ending_index.append(i)\\n max_sub_ending.append(A[i])\\n else:\\n max_sub_ending_index.append(max_sub_ending_index[-1])\\n max_sub_ending.append(A[i]+max_sub_ending[-1])\\n print(max_sub_ending)\\n negmax = max(max_sub_ending)+total \\n if negmax > posmax and negmax != 0:\\n return negmax\\n else:\\n return posmax\\n \\n# cycle = max_sub_ending[-1]\\n# if cycle <= 0:\\n# return max(max_sub_ending)\\n \\n# for i in range(max_sub_ending_index[-1]):\\n# if cycle <= 0:\\n# return max(max_sub_ending)\\n \\n# max_sub_ending_index[i] = cycle+A[i]\\n# cycle = max_sub_ending_index[i]\\n# return max(max_sub_ending)\\n \\n# total = sum(A)\\n \\n# #left sum\\n# left_sum = [A[0]]\\n# left = A[0]\\n \\n# for i in range(1, len(A)):\\n \\n# left = left+A[i]\\n# left_sum.append(left)\\n \\n# #right sum\\n# right = A[-1]\\n# right_sum = [right]\\n \\n# for i in range(len(A)-2, -1, -1):\\n \\n# right += A[i]\\n# right_sum.append(right)\\n\\n# right_sum.reverse()\\n \\n# max_sub = total\\n\\n# for i in range(0, len(A)):\\n# for j in range(i, len(A)):\\n# left, right = 0, 0\\n# if i != 0:\\n# left = left_sum[i-1]\\n# if j != (len(A) -1):\\n# right = right_sum[j+1]\\n# max_sub = max(max_sub, total - left - right , left+right)\\n \\n# #corner case\\n# if max(A) < 0:\\n# return max(A)\\n# return max_sub\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n #On\\n n=len(A)\\n total=A[0]\\n curmax=A[0]\\n curmin=A[0]\\n maxsum=curmax\\n minsum=curmin\\n for i in range(1,n):\\n curmax=max(curmax+A[i],A[i])\\n maxsum=max(maxsum,curmax)\\n curmin=min(curmin+A[i],A[i])\\n minsum=min(minsum,curmin)\\n total+=A[i]\\n #get maxsum and minsum\\n # total-minsum and maxsum\\n if total==minsum:\\n return maxsum\\n else:\\n return max(maxsum,total-minsum)\\n \\n \\n \\n \\n \\n \\n \\n \\n# dp=[0]*n\\n# optsum=[A[0]]*n\\n# pre=A[0]\\n# dp[0]=A[0]\\n# first=dp[0]\\n# for i in range(1,n):\\n# dp[i]=max(dp[i-1]+A[i],A[i])\\n# first=max(first,dp[i])\\n \\n# pre+=A[i]\\n# if pre>optsum[i-1]:\\n# optsum[i]=pre\\n# else:\\n# optsum[i]=optsum[i-1]\\n# # get second case now\\n# #print(optsum)\\n# pre=0\\n# for j in range(n-1,0,-1):\\n# first=max(first,pre+A[j]+optsum[j-1])\\n# pre+=A[j]\\n \\n# return first\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n #N2 solution\\n# n = len(A)\\n# maxSum = -float('inf')\\n\\n# for i in range(n):\\n# currSum = 0\\n# for j in range(n):\\n# ind = (i+j)%n\\n# ele = A[ind]\\n \\n# newSum = currSum +ele\\n# maxSum = max(maxSum,newSum)\\n \\n# if currSum>0 and newSum<0:\\n# currSum = 0\\n# elif currSum<0 and newSum<currSum:\\n# currSum=0\\n \\n# else:\\n# currSum = newSum\\n\\n# return maxSum\\n \\n n = len(A)\\n maxSum = -float('inf')\\n\\n currSum = 0\\n for j in range(n):\\n ele = A[j]\\n\\n newSum = currSum +ele\\n maxSum = max(maxSum,newSum)\\n\\n if currSum>0 and newSum<0:\\n currSum = 0\\n elif currSum<=0 and newSum<currSum:\\n currSum=0\\n\\n else:\\n currSum = newSum\\n\\n lSum = 0\\n bestLSum=0\\n totalSum = sum(A)\\n for i in range(n):\\n currSum= totalSum-lSum\\n currSum+=bestLSum\\n maxSum = max(maxSum,currSum)\\n \\n lSum+=A[i]\\n bestLSum=max(lSum,bestLSum)\\n \\n return maxSum\",\n \"\\nclass Solution:\\n def maxSubarraySumCircular(self, arr: List[int]) -> int:\\n def maxsub(a,n):\\n maxsum = a[0]\\n currsum= 0\\n for i in range(n):\\n if currsum+a[i]>0:\\n currsum+=a[i]\\n maxsum = max(maxsum,currsum)\\n else:\\n currsum=0\\n maxsum= max(maxsum,a[i])\\n return maxsum\\n b =[i*-1 for i in arr]\\n n = len(arr)\\n s=sum(arr)\\n ans2=0\\n ans2 = maxsub(b,n)\\n if s==-ans2:\\n ans2 = -ans2\\n return max(maxsub(arr,n),s+ans2)\\n \\n \\n \\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n if len(A) == 0:\\n return 0\\n minS = minT = maxS = maxT = s = A[0]\\n for i in range(1,len(A)):\\n minS = min(A[i],minS + A[i])\\n minT = min(minS,minT)\\n \\n maxS = max(A[i],maxS + A[i])\\n maxT = max(maxT,maxS)\\n \\n s += A[i]\\n if s == minT:\\n return maxT\\n return max(s - minT,maxT)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n if len(A) == 1:\\n return A[0]\\n s = sum(A)\\n nums = A\\n m = nums[0]\\n last = m\\n num = 1\\n last_max = m\\n res = last\\n res_max = last_max\\n for i in A[1:]:\\n if i + last < i:\\n last = i + last\\n num += 1\\n else:\\n last = i\\n num = 1\\n if num != len(A):\\n res = min(res, last)\\n last_max = max(i, i+last_max)\\n res_max = max(res_max, last_max)\\n return max(s-res, res_max)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n currentMax = totalMax = currentMin = totalMin = A[0]\\n s = A[0]\\n for i in range(1, len(A)):\\n currentMax = max(currentMax + A[i], A[i])\\n totalMax = max(totalMax, currentMax)\\n currentMin = min(currentMin + A[i], A[i])\\n totalMin = min(totalMin, currentMin)\\n s += A[i] \\n if s - totalMin != 0:\\n return max(totalMax, s - totalMin)\\n else: return totalMax\",\n \"import math\\nimport random\\nimport string\\nfrom functools import lru_cache\\nfrom operator import truediv\\nfrom typing import List, Set\\nimport collections\\nimport functools\\nimport heapq\\nimport itertools\\nimport sys\\nfrom functools import lru_cache\\nfrom typing import List\\nimport numpy as np\\nimport collections\\nimport functools\\nimport heapq\\nimport itertools\\nimport sys\\nfrom functools import lru_cache\\nfrom typing import List\\n\\n'''\\n53. Maximum Subarray 无循环\\n dp[i] = max(A[i], dp[i-1] + A[i])\\n 显然当dp[i-1] < 0 时， dp[i] = A[i]，则有：\\n dp[i] = A[i] + max(dp[i-1], 0)\\n\\n类比53，此题加了循环。也就是找到尾部和开头的最大正数组。\\n\\nhttps://leetcode.com/problems/maximum-sum-circular-subarray/discuss/178422/One-Pass\\n\\n但其实就是找到中间的最负子数组。\\n'''\\n\\n\\nclass Solution:\\n def maxSubarraySumCircular(self, A):\\n total, maxSum, curMax, minSum, curMin = 0, A[0], 0, A[0], 0\\n for a in A:\\n curMax = max(curMax + a, a)\\n maxSum = max(maxSum, curMax)\\n curMin = min(curMin + a, a)\\n minSum = min(minSum, curMin)\\n total += a\\n return max(maxSum, total - minSum) if maxSum > 0 else maxSum\\n\\n\\n# r = Solution()\\n# a = r.maxSubarraySumCircular([3,-1,2,-1])\\n# print(a)\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n #On\\n n=len(A)\\n dp=[0]*n\\n optsum=[A[0]]*n\\n pre=A[0]\\n dp[0]=A[0]\\n first=dp[0]\\n for i in range(1,n):\\n dp[i]=max(dp[i-1]+A[i],A[i])\\n first=max(first,dp[i])\\n \\n pre+=A[i]\\n if pre>optsum[i-1]:\\n optsum[i]=pre\\n else:\\n optsum[i]=optsum[i-1]\\n # get second case now\\n #print(optsum)\\n pre=0\\n for j in range(n-1,0,-1):\\n first=max(first,pre+A[j]+optsum[j-1])\\n pre+=A[j]\\n \\n return first\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n ans1 = cur = 0\\n for x in A:\\n cur = x + max(cur, 0)\\n ans1 = max(ans1, cur)\\n \\n ans2 = cur = 0\\n for x in A[1:]:\\n cur = x + min(cur, 0)\\n ans2 = min(ans2, cur)\\n ans2 = sum(A) - ans2\\n \\n ans3 = cur = 0\\n for x in A[:-1]:\\n cur = x + min(cur, 0)\\n ans3 = min(ans3, cur)\\n ans3 = sum(A) - ans3\\n \\n ans = max(ans1, ans2, ans3)\\n return ans if ans != 0 else max(A)\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, nums: List[int]) -> int:\\n greatest: int = -sys.maxsize + 1\\n smallest: int = sys.maxsize\\n x = y = total = 0\\n\\n for i in range(len(nums)):\\n x += nums[i]\\n greatest = max(greatest, x)\\n x = max(x, 0)\\n\\n y += nums[i]\\n smallest = min(smallest, y)\\n y = min(y, 0)\\n\\n total += nums[i]\\n\\n return greatest if greatest < 0 else max(greatest, total - smallest)\\n\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n N = len(A)\\n\\n ans = cur = 0\\n for x in A:\\n cur = x + max(cur, 0)\\n ans = max(ans, cur)\\n\\n rightsums = [None] * N\\n rightsums[-1] = A[-1]\\n for i in range(N-2, -1, -1):\\n rightsums[i] = rightsums[i+1] + A[i]\\n\\n # maxright[i] = max_{j >= i} rightsums[j]\\n maxright = [None] * N\\n maxright[-1] = rightsums[-1]\\n for i in range(N-2, -1, -1):\\n maxright[i] = max(maxright[i+1], rightsums[i])\\n\\n leftsum = 0\\n for i in range(N-2):\\n leftsum += A[i]\\n ans = max(ans, leftsum + maxright[i+1])\\n if max(A) < 0:\\n return max(A)\\n return ans\\n \\n \\n# total = sum(A)\\n# max_sum_ending_i = [A[0]]\\n# prev = max_sum_ending_i[-1]\\n \\n \\n# for i in range(1, len(A)):\\n# if prev <= 0:\\n# max_sum_ending_i.append(A[i])\\n# else:\\n# max_sum_ending_i.append(max_sum_ending_i[-1]+A[i])\\n# prev = max_sum_ending_i[-1]\\n \\n# min_sum_ending_i = [A[0]]\\n# prev = min_sum_ending_i[-1]\\n\\n# for i in range(1, len(A)):\\n# if prev >= 0:\\n# min_sum_ending_i.append(A[i])\\n# else:\\n# min_sum_ending_i.append(min_sum_ending_i[-1]+A[i])\\n# prev = min_sum_ending_i[-1]\\n \\n# if max(A) > 0:\\n# return max(total - min(min_sum_ending_i), max(max_sum_ending_i))\\n# else:\\n# return max(A)\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n sums = sum(A)\\n min_res = min_s = sys.maxsize\\n max_res = max_s = -sys.maxsize\\n n = len(A)\\n for i in range(n):\\n min_s = min(A[i], min_s + A[i])\\n max_s = max(A[i], max_s + A[i])\\n min_res = min(min_res, min_s)\\n max_res = max(max_res, max_s)\\n if min_res == sums:\\n min_res = min(A)\\n else:\\n min_res = sums - min_res\\n return max(min_res, max_res)\",\n \"import numpy as np\\nclass Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n total, maxSum, curMax, minSum, curMin = 0, A[0], -np.Infinity, A[0], np.Infinity\\n for a in A:\\n curMax = max(curMax + a, a)\\n maxSum = max(maxSum, curMax)\\n curMin = min(curMin + a, a)\\n minSum = min(minSum, curMin)\\n total += a\\n return max(maxSum, total - minSum) if maxSum>0 else maxSum\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n if max(A) <= 0: return max(A)\\n endmax = [i for i in A]\\n endmin = [i for i in A]\\n for i in range(len(A)-1):\\n if endmax[i] > 0: endmax[i+1] += endmax[i]\\n if endmin[i] < 0: endmin[i+1] += endmin[i]\\n return max(max(endmax), sum(A) - min(endmin))\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n def kadane(gen):\\n ans = None\\n cur = None\\n for x in gen:\\n if cur:\\n cur = x + max(cur, 0)\\n else:\\n cur = x\\n if ans:\\n ans = max(ans, cur)\\n else:\\n ans = cur\\n return ans\\n S = sum(A)\\n ans1 = kadane((A))\\n if len(A) > 1:\\n ans2 = S + kadane([-A[i] for i in range(1, len(A))])\\n ans3 = S + kadane([-A[i] for i in range(len(A) - 1)])\\n return max(ans1, ans2, ans3)\\n else:\\n return ans1\\n\",\n \"# class Solution(object):\\n# def maxSubarraySumCircular(self, A):\\n# N = len(A)\\n\\n# ans = float('-inf')\\n# cur = 0\\n# for x in A:\\n# cur = x + max(cur, 0)\\n# ans = max(ans, cur)\\n\\n# # ans is the answer for 1-interval subarrays.\\n# # Now, let's consider all 2-interval subarrays.\\n# # For each i, we want to know\\n# # the maximum of sum(A[j:]) with j >= i+2\\n\\n# # rightsums[i] = sum(A[i:])\\n# rightsums = [None] * N\\n# rightsums[-1] = A[-1]\\n# for i in xrange(N-2, -1, -1):\\n# rightsums[i] = rightsums[i+1] + A[i]\\n\\n# # maxright[i] = max_{j >= i} rightsums[j]\\n# maxright = [None] * N\\n# maxright[-1] = rightsums[-1]\\n# for i in xrange(N-2, -1, -1):\\n# maxright[i] = max(maxright[i+1], rightsums[i])\\n\\n# leftsum = 0\\n# for i in xrange(N-2):\\n# leftsum += A[i]\\n# ans = max(ans, leftsum + maxright[i+2])\\n# return ans\\n \\nclass Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n \\n N = len(A)\\n ans = float('-inf')\\n cur = 0\\n for x in A:\\n cur = x + max(cur, 0)\\n ans = max(ans, cur)\\n \\n rightsums = [None] * N\\n rightsums[-1] = A[-1]\\n for i in range(N-2, -1, -1):\\n rightsums[i] = rightsums[i+1] + A[i]\\n \\n maxright = [None] * N\\n maxright[-1] = rightsums[-1]\\n for i in range(N-2, -1, -1):\\n maxright[i] = max(maxright[i+1], rightsums[i])\\n \\n leftsum = 0\\n for i in range(N-2):\\n leftsum += A[i]\\n ans = max(ans, leftsum + maxright[i+2])\\n \\n return ans\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n n = len(A)\\n ans = cur = float('-inf')\\n for x in A:\\n cur = x + max(cur, 0)\\n ans = max(ans, cur)\\n \\n rightsums = [0]*n\\n rightsums[-1] = A[-1]\\n for i in range(n-2, -1, -1):\\n rightsums[i] = rightsums[i+1] + A[i]\\n \\n maxright = [0]*n\\n maxright[-1] = rightsums[-1]\\n for i in range(n-2, -1, -1):\\n maxright[i] = max(maxright[i+1], rightsums[i])\\n \\n leftsum = 0\\n for i in range(n-2):\\n leftsum += A[i]\\n ans = max(ans, leftsum + maxright[i+2])\\n \\n return ans\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n ans1 = cur = 0\\n for x in A:\\n cur = x + max(cur, 0)\\n ans1 = max(ans1, cur)\\n \\n ans2 = cur = 0\\n for i in range(1, len(A)):\\n cur = A[i] + min(cur, 0)\\n ans2 = min(ans2, cur)\\n ans2 = sum(A) - ans2\\n \\n ans3 = cur = 0\\n for i in range(len(A)-1):\\n cur = A[i] + min(cur, 0)\\n ans3 = min(ans3, cur)\\n ans3 = sum(A) - ans3\\n \\n ans = max(ans1, ans2, ans3)\\n return ans if ans != 0 else max(A)\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n \\n def kadane(A):\\n ts=A[0]\\n ms=A[0]\\n for i in range(1,len(A)):\\n ts=max(A[i],ts+A[i])\\n ms=max(ms,ts)\\n return ms\\n x=kadane(A)\\n for i in range(len(A)):\\n A[i]*=-1\\n s=sum(A)\\n y=kadane(A)\\n if y==s:\\n y=-1e10\\n else:\\n y=-s+y\\n return max(x,y)\\n \\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n def find_max_sum(A):\\n curr_sum = 0\\n max_sum = -math.inf\\n for num in A:\\n if curr_sum > 0:\\n curr_sum += num\\n else:\\n curr_sum = num\\n max_sum = max(max_sum, curr_sum)\\n return max_sum\\n max_sum = find_max_sum(A)\\n min_sum_1 = -find_max_sum(-num for num in A[1:])\\n min_sum_2 = -find_max_sum(-num for num in A[:-1])\\n return max(sum(A) - min(min_sum_1, min_sum_2), max_sum)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n n = len(A)\\n A *= 2\\n ans = [0] * len(A)\\n q = collections.deque()\\n cur = 0\\n for i, a in enumerate(A):\\n while q and i - q[0][0] > n:\\n q.popleft()\\n cur += a\\n ans[i] = cur - q[0][1] if q else cur\\n while q and q[-1][1] >= cur:\\n q.pop()\\n q.append((i, cur))\\n return max(ans)\\n \\n \\n # n = len(A)\\n # A *= 2\\n # ans = [A[0]] + [0] * (len(A) - 1)\\n # q = collections.deque([(0, A[0])])\\n # cur = A[0]\\n # for i, a in enumerate(A[1:], 1):\\n # while q and i - q[0][0] > n:\\n # q.popleft()\\n # cur += a\\n # ans[i] = cur - q[0][1]\\n # while q and q[-1][1] >= cur:\\n # q.pop()\\n # q.append((i, cur))\\n # return max(ans)\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n def kadane(gen):\\n # maximum non-empty subarray sum\\n ans = - sys.maxsize\\n cur = - sys.maxsize\\n for x in gen:\\n cur = x + max(cur, 0)\\n ans = max(ans, cur)\\n \\n return ans\\n \\n S = sum(A)\\n ans1 = kadane(iter(A))\\n ans2 = S + kadane(-A[i] for i in range(1, len(A)))\\n ans3 = S + kadane(-A[i] for i in range(len(A) - 1))\\n \\n return max(ans1, ans2, ans3)\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n '''\\n 12341234\\n limit of len[] < a.length\\n \\n \\n p[i], i\\n \\n '''\\n def kaden(gen):\\n ans = cur = gen[0]\\n for n in gen[1:]:\\n cur = n + max(0, cur)\\n ans = max(ans, cur)\\n return ans\\n \\n ans1 = kaden(A)\\n if len(A)>1: \\n s = sum(A)\\n ans2 = s + kaden([-a for a in A[1:]])\\n ans3 = s + kaden([-a for a in A[:-1]])\\n else:\\n ans2 = ans3 = -float('inf')\\n \\n return max(ans1, ans2, ans3)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n def kadane(gen):\\n ans = cur = -float('inf')\\n for x in gen:\\n cur = x + max(cur, 0)\\n ans = max(ans, cur)\\n return ans\\n S = sum(A)\\n ans1 = kadane(iter(A))\\n ans2 = S + kadane(-A[i] for i in range(1, len(A)))\\n ans3 = S + kadane(-A[i] for i in range(len(A)-1))\\n return max(ans1, ans2, ans3)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n B = A.copy()\\n for i in range(1,len(B)):\\n if B[i-1] > 0:\\n B[i] += B[i-1]\\n maxsum = max(B)\\n C = A.copy()\\n for i in range(1, len(C)):\\n if C[i-1] < 0:\\n C[i] += C[i-1]\\n minsum = min(C)\\n if minsum == sum(A):\\n return max([maxsum, max(A)])\\n return max([maxsum, sum(A)-minsum])\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n '''\\n 12341234\\n limit of len[] < a.length\\n \\n \\n p[i], i\\n \\n '''\\n def kaden(gen):\\n ans = cur = -float('inf')\\n for n in gen:\\n cur = n + max(0, cur)\\n ans = max(ans, cur)\\n return ans\\n ans1 = kaden(iter(A))\\n if len(A)>1: \\n s = sum(A)\\n ans2 = s + kaden(-a for a in A[1:])\\n ans3 = s + kaden(-a for a in A[1:])\\n else:\\n ans2 = ans3 = -float('inf')\\n \\n return max(ans1, ans2, ans3)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n def kadane(gen):\\n #ans = None\\n #cur = None\\n #for x in gen:\\n # if cur:\\n # cur = x + max(cur, 0)\\n # else:\\n # cur = x\\n # if ans:\\n # ans = max(ans, cur)\\n # else:\\n # ans = cur\\n #return ans\\n \\n size = len(gen)\\n ans = cur = gen[0]\\n for i in range(1,size):\\n cur = max(gen[i], cur + gen[i])\\n ans = max(ans, cur)\\n return ans\\n S = sum(A)\\n ans1 = kadane((A))\\n if len(A) > 1:\\n ans2 = S + kadane([-A[i] for i in range(1, len(A))])\\n ans3 = S + kadane([-A[i] for i in range(len(A) - 1)])\\n return max(ans1, ans2, ans3)\\n else:\\n return ans1\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n n = len(A)\\n A *= 2\\n ans = [A[0]] + [0] * (len(A) - 1)\\n q = collections.deque([(0, A[0])])\\n cur = A[0]\\n for i, a in enumerate(A[1:], 1):\\n while q and i - q[0][0] > n:\\n q.popleft()\\n cur += a\\n ans[i] = cur - q[0][1]\\n while q and q[-1][1] >= cur:\\n q.pop()\\n q.append((i, cur))\\n return max(ans)\\n \\n \\n # n = len(A)\\n # A *= 2\\n # ans = [0] * len(A)\\n # q = collections.deque()\\n # cur = 0\\n # for i, a in enumerate(A):\\n # while q and i - q[0][0] > n:\\n # q.popleft()\\n # cur += a\\n # ans[i] = cur - q[0][1] if q else cur\\n # while q and q[-1][1] >= cur:\\n # q.pop()\\n # q.append((i, cur))\\n # return max(ans)\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n n = len(A) \\n ans = cur = float('-inf') \\n for v in A:\\n cur = v + max(cur, 0) \\n ans = max(ans, cur)\\n \\n rightsum = [0] * n\\n rightsum[-1] = A[-1]\\n for i in range(n-2, -1, -1):\\n rightsum[i] = rightsum[i+1] + A[i]\\n \\n rightmax = [0]*n\\n rightmax[-1] = rightsum[-1]\\n for i in range(n-2, -1, -1):\\n rightmax[i] = max(rightmax[i+1], rightsum[i])\\n \\n \\n cur = 0\\n for i in range(n-2):\\n cur += A[i]\\n ans = max(ans, cur+rightmax[i+2])\\n \\n return ans\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n n = len(A)\\n \\n ans = -float('inf')\\n currmax = -float('inf')\\n for i in range(n):\\n currmax = max(currmax+A[i], A[i])\\n ans = max(ans, currmax)\\n \\n right_sums = [0]*n\\n right_sums[-1] = A[-1]\\n for i in range(1, n):\\n right_sums[n-1-i] = right_sums[n-i] + A[n-i-1]\\n \\n maxright = [0]*n\\n maxright[-1] = right_sums[-1]\\n for i in range(1, n):\\n maxright[n-i-1] = max(maxright[n-i], right_sums[n-i-1])\\n \\n \\n lefts = 0\\n for i in range(n-2):\\n lefts += A[i]\\n ans = max(ans, lefts+maxright[i+2])\\n \\n return ans\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A):\\n total = sum(A)\\n max_sum = [0 for i in range(len(A))]\\n min_sum = [0 for i in range(len(A))]\\n\\n max_sum[0] = A[0]\\n min_sum[0] = A[0]\\n\\n best_non_loop = max_sum[0]\\n best_inverse_loop = min_sum[0]\\n\\n for i in range(1, len(A)):\\n max_sum[i] = A[i] + max(max_sum[i - 1], 0)\\n min_sum[i] = A[i] + min(min_sum[i - 1], 0)\\n \\n best_non_loop = max(best_non_loop, max_sum[i])\\n best_inverse_loop = min(best_inverse_loop, min_sum[i])\\n\\n ret = max(best_non_loop, total - best_inverse_loop)\\n if ret == 0:\\n return max(A)\\n return ret\",\n \"class Solution(object):\\n def maxSubarraySumCircular(self, A):\\n N = len(A)\\n\\n # Compute P[j] = sum(B[:j]) for the fixed array B = A+A\\n P = [0]\\n for _ in range(2):\\n for x in A:\\n P.append(P[-1] + x)\\n\\n # Want largest P[j] - P[i] with 1 <= j-i <= N\\n # For each j, want smallest P[i] with i >= j-N\\n ans = A[0]\\n deque = collections.deque([0]) # i's, increasing by P[i]\\n for j in range(1, len(P)):\\n # If the smallest i is too small, remove it.\\n if deque[0] < j-N:\\n deque.popleft()\\n\\n # The optimal i is deque[0], for cand. answer P[j] - P[i].\\n ans = max(ans, P[j] - P[deque[0]])\\n\\n # Remove any i1's with P[i2] <= P[i1].\\n while deque and P[j] <= P[deque[-1]]:\\n deque.pop()\\n\\n deque.append(j)\\n\\n return ans\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n \\n tot = sum(A)\\n B = A[:]\\n \\n for i in range(1, len(A)):\\n if A[i - 1] > 0:\\n A[i] += A[i - 1]\\n if B[i - 1] < 0:\\n B[i] += B[i - 1]\\n \\n submax = max(A)\\n submin = min(B)\\n \\n return max(submax, tot - submin) if tot != submin else submax\\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n N = len(A)\\n prefix = [0]\\n for _ in range(2):\\n for x in A:\\n prefix.append(prefix[-1] + x)\\n \\n res = A[0]\\n deque = collections.deque([0])\\n for j in range(1, len(prefix)):\\n if deque[0] < j-N:\\n deque.popleft()\\n \\n res = max(res, prefix[j] - prefix[deque[0]])\\n \\n while deque and prefix[j] <= prefix[deque[-1]]:\\n deque.pop()\\n \\n deque.append(j)\\n \\n return res\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n total, maxSum, curMax, minSum, curMin = 0, A[0], 0, A[0], 0\\n for a in A:\\n curMax = max(curMax + a, a)\\n maxSum = max(maxSum, curMax)\\n curMin = min(curMin + a, a)\\n minSum = min(minSum, curMin)\\n total += a\\n return max(maxSum, total - minSum) if maxSum > 0 else maxSum\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n maxHere = currentMax = float('-inf')\\n minHere = currentMin = float('inf')\\n for i in A:\\n currentMax = i + max(0, currentMax)\\n currentMin = i + min(0, currentMin)\\n maxHere = max(currentMax, maxHere)\\n minHere = min(currentMin, minHere)\\n print(maxHere, minHere)\\n if minHere == sum(A) and 0 not in A:\\n return maxHere\\n return max(maxHere, sum(A)-minHere)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n # find linear max subarray sum\\n maxSum = A[0]\\n curMaxSum = A[0]\\n for i in range(1, len(A)):\\n curMaxSum = max(curMaxSum + A[i], A[i])\\n maxSum = max(maxSum, curMaxSum)\\n \\n # find linear min subarray sum\\n minSum = A[0]\\n curMinSum = A[0]\\n for i in range(1, len(A)):\\n curMinSum = min(curMinSum + A[i], A[i])\\n minSum = min(minSum, curMinSum)\\n \\n # edge case: all values of A are negative\\n if maxSum < 0:\\n return maxSum\\n \\n # compare (linear max) with (total sum - linear min)\\n return max(maxSum, sum(A)-minSum)\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n l = len(A)\\n A = A+A\\n q = collections.deque([(0, -1)])\\n cur = 0\\n ret = float('-inf')\\n for i, num in enumerate(A):\\n cur += num\\n ret = max(ret, cur-q[0][0])\\n if q[0][1]+l == i:\\n q.popleft()\\n while len(q) > 0 and q[-1][0] > cur:\\n q.pop()\\n q.append((cur, i))\\n return ret\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n def kadane(aa):\\n ans= cur =float('-inf') \\n for v in aa:\\n cur = max(cur, 0) + v\\n ans = max(ans, cur)\\n return ans \\n S = sum(A)\\n ans1 = kadane(A)\\n ans2 = S + kadane(-A[i] for i in range(1, len(A)))\\n ans3 = S + kadane(-A[i] for i in range(len(A) - 1))\\n return max(ans1, ans2, ans3) \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n L = len(A)\\n cum_sum = [0]*L\\n cum_max = [0]*L\\n cum_max_final = [0]*L\\n sum_ = 0\\n for i in range(L):\\n sum_ += A[i]\\n cum_sum[i] = sum_\\n if i==0:\\n cum_max[i] = A[i]\\n else:\\n if cum_max[i-1]>0:\\n cum_max[i] = cum_max[i-1] + A[i]\\n else:\\n cum_max[i] = A[i]\\n m = A[L-1]\\n for i in range(L-1,-1,-1):\\n if i!=0:\\n cur = cum_sum[L-1] - cum_sum[i-1]\\n cum_max_final[i] = max(cur,m)\\n m = max(m,cur)\\n \\n else:\\n cum_max_final[i] = max(m,cum_sum[L-1])\\n \\n res = -float('inf')\\n for i in range(L):\\n if i!=L-1:\\n cur = cum_max[i]\\n cur = max(cur,cum_sum[i]+cum_max_final[i+1])\\n res = max(res,cur)\\n else:\\n res = max(res,cum_max[L-1])\\n return res\\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n pre = 0\\n rtn = float('-inf')\\n if max(A) <= 0:\\n return max(A)\\n \\n for i in range(len(A)):\\n pre += A[i]\\n if pre <= 0:\\n pre = 0\\n else:\\n rtn = max(rtn, pre)\\n left_sum = [0]*(len(A)+1)\\n left = 0\\n for i in range(len(A)):\\n left += A[i]\\n left_sum[i+1] = max(left, left_sum[i])\\n right = 0\\n for j in reversed(range(len(A))):\\n right += A[j]\\n rtn = max(rtn, right+left_sum[j])\\n return rtn\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A):\\n # compute pre(k)\\n # maximum continuous subarray that ends at end of A and starts after k\\n pre = [0 for i in range(len(A))]\\n\\n pre_continuous = [0 for i in range(len(A))]\\n pre_earlystop = [0 for i in range(len(A))]\\n\\n for i in range(len(A) - 2, -1, -1):\\n pre_continuous[i] = pre_continuous[i + 1] + A[i + 1]\\n pre_earlystop[i] = max(pre_earlystop[i + 1], pre_continuous[i])\\n pre[i] = max(pre_continuous[i], pre_earlystop[i])\\n\\n # compute regular dp\\n dp = [0 for i in range(len(A))]\\n dp[0] = A[0]\\n\\n running_sum = A[0]\\n best = dp[0] + pre[0]\\n \\n for i in range(1, len(A)):\\n dp[i] = max(dp[i - 1] + A[i], A[i])\\n\\n best = max(best, dp[i], running_sum + pre[i])\\n running_sum += A[i]\\n\\n return best\",\n \"from collections import deque\\nclass Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n B = A + A\\n N = len(A)\\n queue = deque([0])\\n pre_sum = [0]\\n for i in range(len(B)):\\n pre_sum.append(pre_sum[-1] + B[i])\\n ans = A[0]\\n for j in range(1, len(pre_sum)):\\n if j - queue[0] > N:\\n queue.popleft()\\n ans = max(ans, pre_sum[j] - pre_sum[queue[0]])\\n while queue and pre_sum[queue[-1]] >= pre_sum[j]:\\n queue.pop()\\n queue.append(j)\\n return ans \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n negateA=[-x for x in A]\\n print(negateA)\\n cursum=0\\n res=float('-inf')\\n for v in negateA:\\n cursum=max(v,cursum+v)\\n res=max(res,cursum)\\n \\n print(res)\\n res1=float('-inf')\\n cursum=0\\n for v in A:\\n cursum=max(v,cursum+v)\\n res1=max(res1,cursum)\\n print(res1)\\n return max(res1,sum(A)+(res)) if res1>0 else res1\\n# min maxsum\\n# 0,6\\n \\n # total, maxSum, curMax, minSum, curMin = 0, A[0], 0, A[0], 0\\n # for a in A:\\n # curMax = max(curMax + a, a)\\n # maxSum = max(maxSum, curMax)\\n # curMin = min(curMin + a, a)\\n # minSum = min(minSum, curMin)\\n # total += a\\n # print(maxSum, total , minSum)\\n # return max(maxSum, total - minSum) if maxSum > 0 else maxSum\\n#1 -2 3 -2\\n# [-1,2,-3,2]\\n# cu -1 2 -1 1\\n# re. -1 2 2 2\\n\\n# sum-min(subARR)\\n# SUM+MAX()\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n # there are two cases, one, includes end points, two, not include end points\\n ans = float('-inf')\\n csum = 0\\n for x in A:\\n csum = max(x,csum+x)\\n ans = max(ans,csum)\\n \\n mi = float('inf')\\n csum = 0 # notice that it can be zero\\n for i in range(1,len(A)-1):\\n csum = min(csum+A[i],A[i])\\n mi = min(mi,csum)\\n\\n ans = max(ans, sum(A)-mi)\\n return ans\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n N = len(A)\\n P = [0]\\n for _ in range(2):\\n for v in A:\\n P.append(P[-1] + v)\\n \\n ans = A[0]\\n q = collections.deque([0])\\n for j in range(1, len(P)):\\n while q and j - q[0] > N:\\n q.popleft()\\n \\n ans = max(ans, P[j] - P[q[0]])\\n \\n while q and P[q[-1]] >= P[j]:\\n q.pop()\\n q.append(j) \\n \\n return ans\\n\",\n \"from collections import deque\\nclass Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n arr = A + A\\n arr = arr[:-1]\\n \\n prefix = [0] * len(arr)\\n prefix[0] = arr[0]\\n for i in range(1, len(prefix)):\\n prefix[i] = prefix[i-1] + arr[i]\\n \\n prefix.insert(0, 0)\\n #monotonic increasing array\\n dq = deque([0])\\n res = -float('inf')\\n for i in range(1, len(prefix)):\\n\\n while dq and i - dq[0] > len(A):\\n dq.popleft()\\n if dq:\\n res = max(res, prefix[i] - prefix[dq[0]])\\n \\n while dq and prefix[i] <= prefix[dq[-1]]:\\n dq.pop()\\n dq.append(i)\\n \\n return res\\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A):\\n total, maxSum, curMax, minSum, curMin = 0, A[0], 0, A[0], 0\\n for a in A:\\n curMax = max(curMax + a, a)\\n maxSum = max(maxSum, curMax)\\n curMin = min(curMin + a, a)\\n minSum = min(minSum, curMin)\\n total += a\\n return max(maxSum, total - minSum) if maxSum > 0 else maxSum\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n # case 1, kadane's algo\\n totalSum = sum(A)\\n curr = A[0]\\n maxSum = A[0]\\n \\n for i in range(1, len(A)):\\n \\n curr = max(A[i] + curr, A[i])\\n maxSum = max(maxSum, curr)\\n \\n # case 2, wrapping\\n \\n curr = A[0]\\n minSum = totalSum\\n \\n for i in range(1, len(A)):\\n curr = min(A[i]+curr, A[i])\\n \\n minSum = min(minSum, curr)\\n \\n if totalSum == minSum:\\n return maxSum\\n return max(totalSum - minSum, maxSum)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n n = len(A)\\n \\n if n == 1:\\n return A[0]\\n \\n pre_sum = 0\\n pre_min_sum = 0\\n pre_max_sum = 0\\n \\n \\n pre_max_sum_i = -1\\n min_sum_left = -1\\n min_sum_right = -1\\n max_sum = float('-inf')\\n min_sum = float('inf')\\n \\n for i, a in enumerate(A):\\n pre_sum += a\\n \\n max_sum = max(max_sum, pre_sum - pre_min_sum)\\n min_sum_tmp = pre_sum - pre_max_sum\\n if min_sum_tmp < min_sum:\\n min_sum = min_sum_tmp\\n min_sum_right = i\\n min_sum_left = pre_max_sum_i + 1\\n \\n pre_min_sum = min(pre_min_sum, pre_sum)\\n if pre_sum > pre_max_sum:\\n pre_max_sum = pre_sum\\n pre_max_sum_i = i\\n \\n total = sum(A)\\n \\n if total == min_sum and min_sum_left == 0 and min_sum_right == n - 1:\\n return max_sum\\n return max(max_sum, total - min_sum)\\n \\n \\n \\n \\n \\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n # Main idea: if we iterate over A twice to generate\\n # a prefix array, then we can get subarrays in const\\n # time by checking windows of size j - i <= len(A)\\n \\n # Once we have the prefix array, this problem reduces\\n # to sliding window maximum (except we're looking for\\n # the minimum). With the sliding window minimum, we \\n # can then update the result with \\n # result = max(result, curr_elem - minimum)\\n \\n from collections import deque\\n dq = deque()\\n prefix = [0]\\n N = len(A)\\n \\n for _ in range(2):\\n for elem in A:\\n prefix.append(elem + prefix[-1])\\n \\n result = A[0]\\n for i in range(len(prefix)):\\n if dq and dq[0] < i - N:\\n dq.popleft()\\n if dq:\\n result = max(result, prefix[i] - prefix[dq[0]])\\n while dq and prefix[dq[-1]] > prefix[i]:\\n dq.pop()\\n dq.append(i)\\n return result\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n N = len(A)\\n\\n # Compute P[j] = sum(B[:j]) for the fixed array B = A+A\\n P = [0]\\n for _ in range(2):\\n for x in A:\\n P.append(P[-1] + x)\\n\\n # Want largest P[j] - P[i] with 1 <= j-i <= N\\n # For each j, want smallest P[i] with i >= j-N\\n ans = A[0]\\n deque = collections.deque([0]) # i's, increasing by P[i]\\n for j in range(1, len(P)):\\n # If the smallest i is too small, remove it.\\n while deque[0] < j-N:\\n deque.popleft()\\n\\n # The optimal i is deque[0], for cand. answer P[j] - P[i].\\n ans = max(ans, P[j] - P[deque[0]])\\n\\n # Remove any i1's with P[i2] <= P[i1].\\n while deque and P[j] <= P[deque[-1]]:\\n deque.pop()\\n\\n deque.append(j)\\n\\n return ans\\n\",\n \"from copy import deepcopy\\n\\ndef cumsum(A: list) -> list:\\n cum = 0\\n res = []\\n for x in A:\\n cum += x\\n res.append(cum)\\n return res\\n\\nclass Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n # normal kadane's algo\\n opt = deepcopy(A)\\n n = len(A)\\n \\n for i in range(1, n, 1):\\n if opt[i-1] + A[i] > opt[i]:\\n opt[i] = opt[i-1] + A[i]\\n \\n # forward cumsum and backward cumsum\\n forward_cumsum = cumsum(A)\\n \\n back_cumsum = cumsum(A[::-1])\\n tmp = [back_cumsum[0]]\\n for i in range(1, n):\\n tmp.append(max(tmp[i-1], back_cumsum[i]))\\n back_cumsum = tmp\\n \\n # update opt estimates (if needed)\\n for i in range(0, n-1):\\n potential_replacement = forward_cumsum[i] + back_cumsum[(n-2)-i]\\n opt[i] = max(opt[i], potential_replacement)\\n \\n # return max\\n return max(opt)\\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n N = len(A)\\n\\n # Compute P[j] = sum(B[:j]) for the fixed array B = A+A\\n P = [0]\\n for _ in range(2):\\n for x in A:\\n P.append(P[-1] + x)\\n\\n ans = A[0]\\n deque = collections.deque([0])\\n for j in range(1, len(P)):\\n if deque[0] < j-N:\\n deque.popleft()\\n\\n # The optimal i is deque[0], for cand. answer P[j] - P[i].\\n ans = max(ans, P[j] - P[deque[0]])\\n\\n # Remove any i1's with P[i2] <= P[i1].\\n while deque and P[j] <= P[deque[-1]]:\\n deque.pop()\\n\\n deque.append(j)\\n\\n return ans\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n max_sums_left = []\\n max_sums_right = collections.deque()\\n sum_up_to_index = []\\n max_sums_index_right = collections.deque()\\n min_sum_right = 0\\n min_sum_left = 0\\n max_sum_right = 0\\n max_sum_left = 0\\n sum_left = 0\\n sum_right = 0\\n ret = -999999999\\n \\n \\n for i in range(len(A)):\\n sum_left += A[i]\\n sum_right += A[-i - 1]\\n sum_up_to_index.append(sum_left)\\n max_sums_left.append(sum_left - min_sum_left)\\n max_sums_right.appendleft(sum_right - min_sum_right)\\n \\n\\n if (sum_left < min_sum_left):\\n min_sum_left = sum_left\\n\\n \\n if (sum_right > max_sum_right):\\n max_sums_index_right.appendleft((len(A) - i - 1, sum_right, ))\\n max_sum_right = sum_right\\n elif (sum_right < min_sum_right):\\n min_sum_right = sum_right\\n else: \\n pass\\n \\n sum_left = 0\\n \\n \\n for i in range(len(A)):\\n if (len(max_sums_index_right) and i == max_sums_index_right[0][0]):\\n max_sums_index_right.popleft()\\n\\n sum_left += A[i]\\n candidates = [max_sums_left[i] + max_sums_right[i] - A[i], sum_right + max_sum_left]\\n sum_right -= A[i]\\n \\n \\n if (sum_left > max_sum_left):\\n max_sum_left = sum_left\\n \\n \\n if (len(max_sums_index_right)):\\n candidates.append(sum_left + max_sums_index_right[0][1])\\n \\n candidate = max(candidates)\\n \\n \\n if (candidate > ret):\\n ret = candidate\\n \\n return ret \",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n n = len(A)\\n B = A + A\\n pfx = [0]\\n for x in B:\\n pfx.append(pfx[-1] + x)\\n dq = collections.deque()\\n ans = A[0]\\n dq.append(0)\\n #monoqueue dq that contains indices i such that P[i]s are non-decreasing\\n for j in range(1,len(pfx)):\\n if j - dq[0] > n:\\n dq.popleft()\\n \\n ans = max(ans, pfx[j] - pfx[dq[0]])\\n \\n while dq and pfx[dq[-1]] > pfx[j]:\\n dq.pop()\\n \\n dq.append(j)\\n return ans\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n def max_subarray(nums):\\n for i in range(1, len(nums)):\\n if nums[i-1] > 0:\\n nums[i] += nums[i-1]\\n \\n return max(nums)\\n \\n max_sum ,cur_sum = max_subarray(A[:]), sum(A)\\n \\n if max_sum < 0:\\n return max_sum\\n final_sum = cur_sum + max_subarray(list(map(lambda x: -x, A)))\\n \\n return max(max_sum, final_sum)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n n = len(A)\\n B = [0]+A+A\\n for i in range(1, len(B)):\\n B[i] += B[i-1]\\n maxv = B[1]\\n \\n stack = deque([0])\\n for end in range(1, len(B)):\\n num = B[end]\\n while stack and num < B[stack[-1]]:\\n stack.pop()\\n stack.append(end)\\n if end-stack[0] == n+1:\\n stack.popleft()\\n maxv = max(num-B[stack[0]], maxv)\\n #print(end, stack, maxv)\\n if all(x<0 for x in A):\\n return max(A)\\n return maxv\\n \\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n # edge case: all values of A are negative\\n allNeg = True\\n for i in A:\\n if i > 0:\\n allNeg = False\\n if allNeg:\\n return max(A)\\n \\n # find linear max subarray sum\\n maxSum = A[0]\\n curMaxSum = A[0]\\n for i in range(1, len(A)):\\n curMaxSum = max(curMaxSum + A[i], A[i])\\n maxSum = max(maxSum, curMaxSum)\\n \\n # find linear min subarray sum\\n minSum = A[0]\\n curMinSum = A[0]\\n for i in range(1, len(A)):\\n curMinSum = min(curMinSum + A[i], A[i])\\n minSum = min(minSum, curMinSum)\\n \\n # compare (linear max) with (total sum - linear min)\\n return max(maxSum, sum(A)-minSum)\\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n res = A[0]\\n cur = A[0]\\n \\n for num in A[1:]:\\n cur = num + max(0, cur)\\n res = max(cur, res)\\n \\n presum = []\\n accu = 0\\n for num in A:\\n accu += num\\n presum.append(accu)\\n \\n \\n postsum = [0 for i in range(len(A))]\\n postsum[-1] = A[-1]\\n accu = A[-1]\\n curmax = A[-1]\\n for i in range(len(A) - 2, -1, -1):\\n accu += A[i]\\n curmax = max(curmax, accu)\\n postsum[i] = curmax\\n \\n \\n for i in range(0, len(A) - 2):\\n res = max(presum[i] + postsum[i + 2], res)\\n \\n \\n \\n return res\\n \\n\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n '''\\n Case 1. The first is that the subarray take only a middle part, and we know how to find the max subarray sum.\\n Case2. The second is that the subarray take a part of head array and a part of tail array.\\n \\n in case two, you have two sub arrays, one at the front and one at the end. The middle segment actually now is the MIN\\n subarray.\\n The maximum result equals to the total sum minus the minimum subarray sum.\\n '''\\n total=0\\n maxSum=A[0] #case1\\n minSum=A[0] #case2\\n curr_sum=0\\n curr_sum_min=0\\n for val in A:\\n total+=val #calculate total sum\\\\\\\\\\n #calculate max sum with kadanes normally for case1, assuming NO WRAP\\n curr_sum=max(val,curr_sum+val)\\n maxSum=max(maxSum,curr_sum)\\n #now calculate the minsum\\n curr_sum_min=min(val,curr_sum_min+val)\\n minSum=min(minSum,curr_sum_min)\\n print(maxSum)\\n wrap_maxSum=total-minSum\\n \\n if maxSum>0:\\n return max(wrap_maxSum,maxSum)\\n else:\\n return maxSum\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n tot = 0\\n mn, mx = float('inf'), float('-inf')\\n curmx, curmn = 0, 0\\n for num in A:\\n curmn = min(curmn + num, num)\\n mn = min(mn, curmn)\\n curmx = max(curmx + num, num)\\n mx = max(mx, curmx)\\n tot += num\\n \\n if tot == mn:\\n return mx\\n return max(mx, tot-mn)\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n def maxSum(gen):\\n res = cur = -float('inf')\\n for n in gen:\\n cur = n + max(0, cur)\\n res = max(res, cur)\\n return res\\n \\n total = sum(A)\\n res1 = maxSum(iter(A))\\n res2 = total + maxSum(-A[i] for i in range(1, len(A))) # min sum of the unwated sub array\\n res3 = total + maxSum(-A[i] for i in range(len(A)-1))\\n return max(res1, res2, res3)\",\n \"import heapq\\n\\nclass Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n N = len(A)\\n best = A[0]\\n \\n heap = [(0, -1)] \\n current_sum = 0\\n for i in range(2 * N):\\n current_sum += A[i % N]\\n while len(heap) > 0 and i - heap[0][1] > N:\\n heapq.heappop(heap)\\n \\n best = max(best, current_sum - heap[0][0])\\n heapq.heappush(heap, (current_sum, i))\\n \\n return best\",\n \"class Solution:\\n def maxSubarraySumCircular(self, A: List[int]) -> int:\\n N = len(A)\\n P = []\\n P.append(0)\\n for _ in range(2):\\n for x in A:\\n P.append(P[-1] + x)\\n \\n ans = A[0]\\n queue = []\\n queue.append(0)\\n \\n for j in range(1, len(P)):\\n if queue[0] < j - N:\\n queue.pop(0)\\n ans = max(ans, P[j] - P[queue[0]])\\n \\n while queue and P[j] <= P[queue[-1]]:\\n queue.pop()\\n queue.append(j)\\n \\n return ans\"\n]","isConversational":false},"n_sols":{"kind":"number","value":124,"string":"124"},"non_interactive_idx":{"kind":"list like","value":[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,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32,\n 33,\n 34,\n 35,\n 36,\n 37,\n 38,\n 39,\n 40,\n 41,\n 42,\n 43,\n 44,\n 45,\n 46,\n 47,\n 48,\n 49,\n 50,\n 51,\n 52,\n 53,\n 54,\n 55,\n 56,\n 57,\n 58,\n 59,\n 60,\n 61,\n 62,\n 63,\n 64,\n 65,\n 66,\n 67,\n 68,\n 69,\n 70,\n 71,\n 72,\n 73,\n 74,\n 75,\n 76,\n 77,\n 78,\n 79,\n 80,\n 81,\n 82,\n 83,\n 84,\n 85,\n 86,\n 87,\n 88,\n 89,\n 90,\n 91,\n 92,\n 93,\n 94,\n 95,\n 96,\n 97,\n 98,\n 99,\n 100,\n 101,\n 102,\n 103,\n 104,\n 105,\n 106,\n 107,\n 108,\n 109,\n 110,\n 111,\n 112,\n 113,\n 114,\n 115,\n 116,\n 117,\n 118,\n 119,\n 120,\n 121,\n 122,\n 123\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[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,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],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":64,"cells":{"problem_id":{"kind":"number","value":197,"string":"197"},"question":{"kind":"string","value":"Given a string s, determine if it is valid.\nA string s is valid if, starting with an empty string t = \"\", you can transform t into s after performing the following operation any number of times:\n\nInsert string \"abc\" into any position in t. More formally, t becomes tleft + \"abc\" + tright, where t == tleft + tright. Note that tleft and tright may be empty.\n\nReturn true if s is a valid string, otherwise, return false.\n \nExample 1:\nInput: s = \"aabcbc\"\nOutput: true\nExplanation:\n\"\" -> \"abc\" -> \"aabcbc\"\nThus, \"aabcbc\" is valid.\nExample 2:\nInput: s = \"abcabcababcc\"\nOutput: true\nExplanation:\n\"\" -> \"abc\" -> \"abcabc\" -> \"abcabcabc\" -> \"abcabcababcc\"\nThus, \"abcabcababcc\" is valid.\n\nExample 3:\nInput: s = \"abccba\"\nOutput: false\nExplanation: It is impossible to get \"abccba\" using the operation.\n\nExample 4:\nInput: s = \"cababc\"\nOutput: false\nExplanation: It is impossible to get \"cababc\" using the operation.\n\n \nConstraints:\n\n1 <= s.length <= 2 * 104\ns consists of letters 'a', 'b', and 'c'"},"solutions":{"kind":"string","value":"[\"class Solution:\\n def isValid(self, s: str) -> bool:\\n if not s:\\n return True\\n return self.isValid(s.replace('abc', '')) if s.replace('abc', '') != s else False\\n\", \"class Solution:\\n def isValid(self, S: str) -> bool:\\n stack = []\\n for i in S:\\n if i == 'c':\\n if stack[-2:] !=['a','b']:\\n return False\\n stack.pop()\\n stack.pop()\\n else:\\n stack.append(i)\\n return not stack\\n \\n \\n \\n \\n\", \"class Solution:\\n def isValid(self, S: str) -> bool:\\n l = ''\\n for c in S:\\n l += c\\n if l[-3:]== 'abc':\\n l = l[:-3]\\n return not l\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n stack = collections.deque()\\n for char in s:\\n if char == 'c' and len(stack) >= 2:\\n if stack[-1] == 'b' and stack[-2] == 'a':\\n stack.pop()\\n stack.pop()\\n else:\\n stack.append(char)\\n if len(stack) == 0:\\n return True\\n return False\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n \\n \\n stack = []\\n \\n for c in s:\\n if c == 'c':\\n if ''.join(stack[-2:]) == 'ab':\\n stack.pop()\\n stack.pop()\\n continue\\n stack.append(c)\\n \\n return not stack\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n if len(s) % 3 != 0:\\n return False\\n if len(s) == 0:\\n return True\\n stack = []\\n for i in s:\\n if i != 'c':\\n stack.append(i)\\n elif len(stack) >= 2 and stack[-1] == 'b' and stack[-2] == 'a':\\n stack.pop()\\n stack.pop()\\n else:\\n stack.append(i)\\n if len(stack) == 0:\\n return True\\n return False\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n stack = []\\n for ch in s:\\n if ch == 'c':\\n if len(stack) > 1 and stack[-1] == 'b' and stack[-2] == 'a':\\n stack.pop()\\n stack.pop()\\n else:\\n stack.append(ch)\\n return not stack\", \"class Solution:\\n base = 'abc'\\n base_len = 3\\n \\n def isValid(self, S: str) -> bool:\\n stack = []\\n for c in S:\\n stack.append(c)\\n if len(stack) >= 3:\\n if stack[-1] == 'c' and stack[-2] == 'b' and stack[-3] == 'a':\\n stack.pop()\\n stack.pop()\\n stack.pop()\\n return len(stack) == 0\\n \\n# if not stack:\\n# stack.append(c)\\n# else:\\n\", \"from collections import deque\\nclass Solution:\\n def isValid(self, s: str) -> bool:\\n stk = deque()\\n for st in s:\\n stk.append(st)\\n if len(stk) >= 3:\\n if stk[-1]=='c' and stk[-2]=='b' and stk[-3]=='a':\\n for i in range(3):\\n stk.pop()\\n return len(stk)==0\\n\", \"# class Solution:\\n# def isValid(self, s: str) -> bool:\\n# element = 0\\n# lg = len(s)\\n# for j in range(lg):\\n# element += 1\\n# if element >= 3:\\n# if s[2]=='c' and s[1]=='b' and s[0]=='a':\\n# for i in range(2,-1,-1):\\n# del s[i]\\n\\n# return len(s)==0\\n \\nfrom collections import deque\\nclass Solution:\\n def isValid(self, s: str) -> bool:\\n stk = deque()\\n for st in s:\\n stk.append(st)\\n if len(stk) >= 3:\\n if stk[-1]=='c' and stk[-2]=='b' and stk[-3]=='a':\\n for i in range(3):\\n stk.pop()\\n return len(stk)==0\\n\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n LAST_THREE = ['a','b','c']\\n stack = [] \\n \\n for index, _chr in enumerate(s):\\n stack.append(_chr)\\n if stack[-3:] == LAST_THREE:\\n stack.pop()\\n stack.pop()\\n stack.pop()\\n \\n return len(stack) == 0\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n rtn =''\\n for i,char in enumerate(s):\\n if char == 'a':\\n rtn = rtn[:i] + 'abc' + rtn[i:]\\n return rtn == s\\n \\n# aabcbc,...abcabcababcc\\n\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n cnt = collections.Counter()\\n stack = []\\n for c in s:\\n cnt[c] += 1\\n if not cnt['a'] >= cnt['b'] >= cnt['c']:\\n return False\\n stack.append(c)\\n while len(stack)>=3 and stack[-1]=='c' and stack[-2]=='b' and stack[-3]=='a':\\n stack = stack[:-3]\\n #print(stack)\\n if stack:\\n return False\\n else:\\n return True\\n\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n cnt = collections.Counter()\\n stack = []\\n for c in s:\\n cnt[c] += 1\\n if not cnt['a'] >= cnt['b'] >= cnt['c']:\\n return False\\n if c == 'c':\\n if len(stack)>=2:\\n if stack[-1]=='b' and stack[-2]=='a':\\n stack.pop()\\n stack.pop()\\n else:\\n return False\\n else:\\n stack.append(c)\\n return not stack\\n\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n while s:\\n if 'abc' not in s:\\n return False\\n j = 0\\n while j < len(s) - 2:\\n if s[j:j+3] == 'abc':\\n s = s[:j] + s[j+3:]\\n else:\\n j += 1\\n return True\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n \\n \\n dic = collections.defaultdict(list)\\n \\n for i, c in enumerate(s):\\n dic[c].append(i)\\n \\n t = ''\\n for i in dic['a']:\\n t = t[:i] + 'abc' + t[i:]\\n \\n return t == s\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n l = len(s)\\n f = 0\\n while s:\\n i = 0\\n f = 0\\n while i<l:\\n if s[i]=='a' and i+1<l and s[i+1]=='b' and i+2<l and s[i+2]=='c':\\n s = s[:i]+s[i+3:]\\n l-=3\\n f = 1\\n else:\\n i+=1\\n if f==0 and l!=0 and s!='':\\n return False\\n return True\\n\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n while s:\\n tmp=s.replace('abc','')\\n if tmp==s:break\\n s=tmp\\n return not s\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n cnt = collections.Counter()\\n stack = []\\n for c in s:\\n cnt[c] += 1\\n if not cnt['a'] >= cnt['b'] >= cnt['c']:\\n return False\\n stack.append(c)\\n while len(stack)>=3 and stack[-1]=='c' and stack[-2]=='b' and stack[-3]=='a':\\n for _ in range(3):\\n stack.pop()\\n #print(stack)\\n if stack:\\n return False\\n else:\\n return True\\n\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n findVal = s.find('abc')\\n while findVal != -1:\\n s = s[:findVal] + s[findVal+3:]\\n findVal = s.find('abc')\\n return s==''\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n cnt = collections.Counter()\\n stack = []\\n for c in s:\\n cnt[c] += 1\\n if not cnt['a'] >= cnt['b'] >= cnt['c']:\\n return False\\n stack.append(c)\\n while ''.join(stack[-3:]) == 'abc':\\n stack = stack[:-3]\\n #print(stack)\\n if stack:\\n return False\\n else:\\n return True\\n\", \"class Solution:\\n def isValid0(self, S: str) -> bool:\\n \\n if len(S)<3:\\n return False\\n \\n if len(S) == 3:\\n if S == 'abc':\\n return True\\n else:\\n return False\\n \\n # find 'abc'\\n i=0\\n while i<len(S) and S[i:i+3] != 'abc':\\n i += 1\\n \\n if S[i:i+3] == 'abc':\\n new_S = S[:i] + S[i+3:]\\n return self.isValid(new_S)\\n else:\\n return False\\n \\n def isValid(self, S: str) -> bool:\\n \\n stack = []\\n for c in S:\\n if len(stack) < 2:\\n stack.append(c)\\n else:\\n if stack[-2]+ stack[-1] + c =='abc':\\n stack.pop()\\n stack.pop()\\n else:\\n stack.append(c)\\n \\n if len(stack) == 0:\\n return True\\n else:\\n return False\\n \\n \\n \\n \\n\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n stack=[]\\n i=0\\n while(i<len(s) or (stack and len(stack)>2 and stack[-3:]==['a','b','c'])):\\n while(stack and len(stack)>2 and stack[-3:]==['a','b','c']):\\n \\n stack.pop()\\n stack.pop()\\n stack.pop()\\n if i<len(s):\\n stack.append(s[i])\\n i+=1\\n #print('stack',stack)\\n if not stack:\\n return True\\n return False\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n while True:\\n ns = s.replace('abc', '')\\n if ns == '':\\n return True\\n if ns == s:\\n return False\\n s = ns\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n indicesToDelete = set()\\n for i in range(len(s)-2):\\n substr = s[i:i+3]\\n if substr =='abc':\\n indicesToDelete.add(i)\\n indicesToDelete.add(i+1)\\n indicesToDelete.add(i+2)\\n newS = ''\\n for i in range(len(s)-1,-1,-1):\\n if i not in indicesToDelete:\\n newS += s[i]\\n s = newS[::-1]\\n left = 0\\n right = len(s) -1\\n\\n while left < right:\\n if s[left] =='a' and s[right] =='c':\\n if s[left+1] =='b' and s[left+2] =='c':\\n left +=3\\n elif s[right-1] =='b' and s[right-2] =='a':\\n right -=3\\n elif s[left+1] == 'b':\\n left +=2\\n right -=1\\n elif s[right-1] =='b':\\n left +=1\\n right -=2\\n else:\\n return False\\n else:\\n return False\\n return True\\n\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n stack = []\\n for i in range(len(s)):\\n if stack == []:\\n stack.append([])\\n stack[-1].append(ord(s[i]))\\n elif stack[-1][-1] + 1 == ord(s[i]):\\n stack[-1].append(ord(s[i]))\\n else:\\n stack.append([ord(s[i])])\\n \\n if stack[-1] == [ord('a'), ord('b'), ord('c')]:\\n stack.pop()\\n return stack == []\\n \\n\", \"class Solution:\\n def isValid(self, S: str) -> bool:\\n i = S.find('abc')\\n while i != -1:\\n S = S[:i] + S[i+3:]\\n i = S.find('abc')\\n return not S\\n\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n while len(s) > 3:\\n i = s.find('abc')\\n if i == -1:\\n return False\\n s = s[:i] + s[i + 3:]\\n return not s or s == 'abc'\", \"class Solution:\\n def isValid(self, S: str) -> bool:\\n stack = []\\n for c in S:\\n stack.append(c)\\n if ''.join(stack[-3:]) == 'abc':\\n stack = stack[:-3]\\n return len(stack) == 0\", \"class Solution:\\n def isValid(self, S: str) -> bool:\\n stack = []\\n for c in S:\\n stack.append(c)\\n while stack and stack[-1] == 'c' and len(stack) >= 3 and stack[-2] == 'b' and stack[-3] == 'a':\\n stack = stack[:-3]\\n \\n return not stack\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n while s.find('abc') > -1:\\n i = s.find('abc')\\n s = s[:i] + s[i+3:]\\n return s == ''\\n \\n\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n while s.find('abc') >= 0:\\n s = s.replace('abc', '')\\n return s == ''\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n stack = []\\n for c in s:\\n stack.append(c)\\n while ''.join(stack[-3:]) == 'abc':\\n stack = stack[:-3]\\n #print(stack)\\n if stack:\\n return False\\n else:\\n return True\\n\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n s = list(s)\\n left = 0\\n while len(s) > 2 and left < len(s)-2:\\n if s[left:left+3] == ['a', 'b', 'c']:\\n s.pop(left+2)\\n s.pop(left+1)\\n s.pop(left)\\n left -= 2\\n else:\\n left += 1\\n if s:\\n return False\\n else:\\n return True\\n\", \"class Solution:\\n def isValid(self, S: str) -> bool:\\n st = []\\n for i, s in enumerate(S):\\n st.append(s)\\n while st[-3:] == ['a','b','c']:\\n st = st[:-3]\\n return len(st) == 0\", \"class Solution:\\n def isValid(self, S: str) -> bool:\\n stack = []\\n for i in S:\\n if i == 'c':\\n if stack[-2:] != ['a', 'b']:\\n return False\\n stack.pop()\\n stack.pop()\\n else:\\n stack.append(i)\\n return not stack\\n\", \"'''\\nabc abc\\na abc bc\\nab abc c\\n\\nKeep a stack that remembers the current letter for each depth level\\n\\nfor example:\\naabcbc\\n 123\\n1 [a, b]\\n2 [a]\\n3 [b]\\n\\n'''\\n\\n\\nclass Solution:\\n def isValid(self, s: str) -> bool:\\n stack = list()\\n \\n for ch in s:\\n if ch == 'a':\\n stack.append('a')\\n elif ch == 'b':\\n if stack and stack[-1] == 'a':\\n stack[-1] = 'b'\\n else:\\n return False\\n elif ch == 'c':\\n if stack and stack[-1] == 'b':\\n stack.pop()\\n else:\\n return False\\n else:\\n return False\\n \\n return (len(stack) == 0)\", \"class Solution:\\n def isValid(self, s: str) -> bool:\\n d=[]\\n for i in s:\\n if i=='c':\\n if d[-2:]!=['a','b']:return False\\n d.pop();d.pop()\\n else:d.append(i)\\n return not d\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"isValid\", \"inputs\": [[\"\\\"aabcbc\\\"\"]], \"outputs\": [false]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/check-if-word-is-valid-after-substitutions/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def isValid(self, s: str) -> bool:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def isValid(self, s: str) -> bool:\n if not s:\n return True\n return self.isValid(s.replace('abc', '')) if s.replace('abc', '') != s else False\n","class Solution:\n def isValid(self, S: str) -> bool:\n stack = []\n for i in S:\n if i == 'c':\n if stack[-2:] !=['a','b']:\n return False\n stack.pop()\n stack.pop()\n else:\n stack.append(i)\n return not stack\n \n \n \n \n","class Solution:\n def isValid(self, S: str) -> bool:\n l = ''\n for c in S:\n l += c\n if l[-3:]== 'abc':\n l = l[:-3]\n return not l","class Solution:\n def isValid(self, s: str) -> bool:\n stack = collections.deque()\n for char in s:\n if char == 'c' and len(stack) >= 2:\n if stack[-1] == 'b' and stack[-2] == 'a':\n stack.pop()\n stack.pop()\n else:\n stack.append(char)\n if len(stack) == 0:\n return True\n return False","class Solution:\n def isValid(self, s: str) -> bool:\n \n \n stack = []\n \n for c in s:\n if c == 'c':\n if ''.join(stack[-2:]) == 'ab':\n stack.pop()\n stack.pop()\n continue\n stack.append(c)\n \n return not stack","class Solution:\n def isValid(self, s: str) -> bool:\n if len(s) % 3 != 0:\n return False\n if len(s) == 0:\n return True\n stack = []\n for i in s:\n if i != 'c':\n stack.append(i)\n elif len(stack) >= 2 and stack[-1] == 'b' and stack[-2] == 'a':\n stack.pop()\n stack.pop()\n else:\n stack.append(i)\n if len(stack) == 0:\n return True\n return False","class Solution:\n def isValid(self, s: str) -> bool:\n stack = []\n for ch in s:\n if ch == 'c':\n if len(stack) > 1 and stack[-1] == 'b' and stack[-2] == 'a':\n stack.pop()\n stack.pop()\n else:\n stack.append(ch)\n return not stack","class Solution:\n base = 'abc'\n base_len = 3\n \n def isValid(self, S: str) -> bool:\n stack = []\n for c in S:\n stack.append(c)\n if len(stack) >= 3:\n if stack[-1] == 'c' and stack[-2] == 'b' and stack[-3] == 'a':\n stack.pop()\n stack.pop()\n stack.pop()\n return len(stack) == 0\n \n# if not stack:\n# stack.append(c)\n# else:\n","from collections import deque\nclass Solution:\n def isValid(self, s: str) -> bool:\n stk = deque()\n for st in s:\n stk.append(st)\n if len(stk) >= 3:\n if stk[-1]=='c' and stk[-2]=='b' and stk[-3]=='a':\n for i in range(3):\n stk.pop()\n return len(stk)==0\n","# class Solution:\n# def isValid(self, s: str) -> bool:\n# element = 0\n# lg = len(s)\n# for j in range(lg):\n# element += 1\n# if element >= 3:\n# if s[2]=='c' and s[1]=='b' and s[0]=='a':\n# for i in range(2,-1,-1):\n# del s[i]\n\n# return len(s)==0\n \nfrom collections import deque\nclass Solution:\n def isValid(self, s: str) -> bool:\n stk = deque()\n for st in s:\n stk.append(st)\n if len(stk) >= 3:\n if stk[-1]=='c' and stk[-2]=='b' and stk[-3]=='a':\n for i in range(3):\n stk.pop()\n return len(stk)==0\n","class Solution:\n def isValid(self, s: str) -> bool:\n LAST_THREE = ['a','b','c']\n stack = [] \n \n for index, _chr in enumerate(s):\n stack.append(_chr)\n if stack[-3:] == LAST_THREE:\n stack.pop()\n stack.pop()\n stack.pop()\n \n return len(stack) == 0","class Solution:\n def isValid(self, s: str) -> bool:\n rtn =''\n for i,char in enumerate(s):\n if char == 'a':\n rtn = rtn[:i] + 'abc' + rtn[i:]\n return rtn == s\n \n# aabcbc,...abcabcababcc\n","class Solution:\n def isValid(self, s: str) -> bool:\n cnt = collections.Counter()\n stack = []\n for c in s:\n cnt[c] += 1\n if not cnt['a'] >= cnt['b'] >= cnt['c']:\n return False\n stack.append(c)\n while len(stack)>=3 and stack[-1]=='c' and stack[-2]=='b' and stack[-3]=='a':\n stack = stack[:-3]\n #print(stack)\n if stack:\n return False\n else:\n return True\n","class Solution:\n def isValid(self, s: str) -> bool:\n cnt = collections.Counter()\n stack = []\n for c in s:\n cnt[c] += 1\n if not cnt['a'] >= cnt['b'] >= cnt['c']:\n return False\n if c == 'c':\n if len(stack)>=2:\n if stack[-1]=='b' and stack[-2]=='a':\n stack.pop()\n stack.pop()\n else:\n return False\n else:\n stack.append(c)\n return not stack\n","class Solution:\n def isValid(self, s: str) -> bool:\n while s:\n if 'abc' not in s:\n return False\n j = 0\n while j < len(s) - 2:\n if s[j:j+3] == 'abc':\n s = s[:j] + s[j+3:]\n else:\n j += 1\n return True","class Solution:\n def isValid(self, s: str) -> bool:\n \n \n dic = collections.defaultdict(list)\n \n for i, c in enumerate(s):\n dic[c].append(i)\n \n t = ''\n for i in dic['a']:\n t = t[:i] + 'abc' + t[i:]\n \n return t == s","class Solution:\n def isValid(self, s: str) -> bool:\n l = len(s)\n f = 0\n while s:\n i = 0\n f = 0\n while i<l:\n if s[i]=='a' and i+1<l and s[i+1]=='b' and i+2<l and s[i+2]=='c':\n s = s[:i]+s[i+3:]\n l-=3\n f = 1\n else:\n i+=1\n if f==0 and l!=0 and s!='':\n return False\n return True\n","class Solution:\n def isValid(self, s: str) -> bool:\n while s:\n tmp=s.replace('abc','')\n if tmp==s:break\n s=tmp\n return not s","class Solution:\n def isValid(self, s: str) -> bool:\n cnt = collections.Counter()\n stack = []\n for c in s:\n cnt[c] += 1\n if not cnt['a'] >= cnt['b'] >= cnt['c']:\n return False\n stack.append(c)\n while len(stack)>=3 and stack[-1]=='c' and stack[-2]=='b' and stack[-3]=='a':\n for _ in range(3):\n stack.pop()\n #print(stack)\n if stack:\n return False\n else:\n return True\n","class Solution:\n def isValid(self, s: str) -> bool:\n findVal = s.find('abc')\n while findVal != -1:\n s = s[:findVal] + s[findVal+3:]\n findVal = s.find('abc')\n return s==''","class Solution:\n def isValid(self, s: str) -> bool:\n cnt = collections.Counter()\n stack = []\n for c in s:\n cnt[c] += 1\n if not cnt['a'] >= cnt['b'] >= cnt['c']:\n return False\n stack.append(c)\n while ''.join(stack[-3:]) == 'abc':\n stack = stack[:-3]\n #print(stack)\n if stack:\n return False\n else:\n return True\n","class Solution:\n def isValid0(self, S: str) -> bool:\n \n if len(S)<3:\n return False\n \n if len(S) == 3:\n if S == 'abc':\n return True\n else:\n return False\n \n # find 'abc'\n i=0\n while i<len(S) and S[i:i+3] != 'abc':\n i += 1\n \n if S[i:i+3] == 'abc':\n new_S = S[:i] + S[i+3:]\n return self.isValid(new_S)\n else:\n return False\n \n def isValid(self, S: str) -> bool:\n \n stack = []\n for c in S:\n if len(stack) < 2:\n stack.append(c)\n else:\n if stack[-2]+ stack[-1] + c =='abc':\n stack.pop()\n stack.pop()\n else:\n stack.append(c)\n \n if len(stack) == 0:\n return True\n else:\n return False\n \n \n \n \n","class Solution:\n def isValid(self, s: str) -> bool:\n stack=[]\n i=0\n while(i<len(s) or (stack and len(stack)>2 and stack[-3:]==['a','b','c'])):\n while(stack and len(stack)>2 and stack[-3:]==['a','b','c']):\n \n stack.pop()\n stack.pop()\n stack.pop()\n if i<len(s):\n stack.append(s[i])\n i+=1\n #print('stack',stack)\n if not stack:\n return True\n return False","class Solution:\n def isValid(self, s: str) -> bool:\n while True:\n ns = s.replace('abc', '')\n if ns == '':\n return True\n if ns == s:\n return False\n s = ns","class Solution:\n def isValid(self, s: str) -> bool:\n indicesToDelete = set()\n for i in range(len(s)-2):\n substr = s[i:i+3]\n if substr =='abc':\n indicesToDelete.add(i)\n indicesToDelete.add(i+1)\n indicesToDelete.add(i+2)\n newS = ''\n for i in range(len(s)-1,-1,-1):\n if i not in indicesToDelete:\n newS += s[i]\n s = newS[::-1]\n left = 0\n right = len(s) -1\n\n while left < right:\n if s[left] =='a' and s[right] =='c':\n if s[left+1] =='b' and s[left+2] =='c':\n left +=3\n elif s[right-1] =='b' and s[right-2] =='a':\n right -=3\n elif s[left+1] == 'b':\n left +=2\n right -=1\n elif s[right-1] =='b':\n left +=1\n right -=2\n else:\n return False\n else:\n return False\n return True\n","class Solution:\n def isValid(self, s: str) -> bool:\n stack = []\n for i in range(len(s)):\n if stack == []:\n stack.append([])\n stack[-1].append(ord(s[i]))\n elif stack[-1][-1] + 1 == ord(s[i]):\n stack[-1].append(ord(s[i]))\n else:\n stack.append([ord(s[i])])\n \n if stack[-1] == [ord('a'), ord('b'), ord('c')]:\n stack.pop()\n return stack == []\n \n","class Solution:\n def isValid(self, S: str) -> bool:\n i = S.find('abc')\n while i != -1:\n S = S[:i] + S[i+3:]\n i = S.find('abc')\n return not S\n","class Solution:\n def isValid(self, s: str) -> bool:\n while len(s) > 3:\n i = s.find('abc')\n if i == -1:\n return False\n s = s[:i] + s[i + 3:]\n return not s or s == 'abc'","class Solution:\n def isValid(self, S: str) -> bool:\n stack = []\n for c in S:\n stack.append(c)\n if ''.join(stack[-3:]) == 'abc':\n stack = stack[:-3]\n return len(stack) == 0","class Solution:\n def isValid(self, S: str) -> bool:\n stack = []\n for c in S:\n stack.append(c)\n while stack and stack[-1] == 'c' and len(stack) >= 3 and stack[-2] == 'b' and stack[-3] == 'a':\n stack = stack[:-3]\n \n return not stack","class Solution:\n def isValid(self, s: str) -> bool:\n while s.find('abc') > -1:\n i = s.find('abc')\n s = s[:i] + s[i+3:]\n return s == ''\n \n","class Solution:\n def isValid(self, s: str) -> bool:\n while s.find('abc') >= 0:\n s = s.replace('abc', '')\n return s == ''","class Solution:\n def isValid(self, s: str) -> bool:\n stack = []\n for c in s:\n stack.append(c)\n while ''.join(stack[-3:]) == 'abc':\n stack = stack[:-3]\n #print(stack)\n if stack:\n return False\n else:\n return True\n","class Solution:\n def isValid(self, s: str) -> bool:\n s = list(s)\n left = 0\n while len(s) > 2 and left < len(s)-2:\n if s[left:left+3] == ['a', 'b', 'c']:\n s.pop(left+2)\n s.pop(left+1)\n s.pop(left)\n left -= 2\n else:\n left += 1\n if s:\n return False\n else:\n return True\n","class Solution:\n def isValid(self, S: str) -> bool:\n st = []\n for i, s in enumerate(S):\n st.append(s)\n while st[-3:] == ['a','b','c']:\n st = st[:-3]\n return len(st) == 0","class Solution:\n def isValid(self, S: str) -> bool:\n stack = []\n for i in S:\n if i == 'c':\n if stack[-2:] != ['a', 'b']:\n return False\n stack.pop()\n stack.pop()\n else:\n stack.append(i)\n return not stack\n","'''\nabc abc\na abc bc\nab abc c\n\nKeep a stack that remembers the current letter for each depth level\n\nfor example:\naabcbc\n 123\n1 [a, b]\n2 [a]\n3 [b]\n\n'''\n\n\nclass Solution:\n def isValid(self, s: str) -> bool:\n stack = list()\n \n for ch in s:\n if ch == 'a':\n stack.append('a')\n elif ch == 'b':\n if stack and stack[-1] == 'a':\n stack[-1] = 'b'\n else:\n return False\n elif ch == 'c':\n if stack and stack[-1] == 'b':\n stack.pop()\n else:\n return False\n else:\n return False\n \n return (len(stack) == 0)","class Solution:\n def isValid(self, s: str) -> bool:\n d=[]\n for i in s:\n if i=='c':\n if d[-2:]!=['a','b']:return False\n d.pop();d.pop()\n else:d.append(i)\n return not d"],"string":"[\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n if not s:\\n return True\\n return self.isValid(s.replace('abc', '')) if s.replace('abc', '') != s else False\\n\",\n \"class Solution:\\n def isValid(self, S: str) -> bool:\\n stack = []\\n for i in S:\\n if i == 'c':\\n if stack[-2:] !=['a','b']:\\n return False\\n stack.pop()\\n stack.pop()\\n else:\\n stack.append(i)\\n return not stack\\n \\n \\n \\n \\n\",\n \"class Solution:\\n def isValid(self, S: str) -> bool:\\n l = ''\\n for c in S:\\n l += c\\n if l[-3:]== 'abc':\\n l = l[:-3]\\n return not l\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n stack = collections.deque()\\n for char in s:\\n if char == 'c' and len(stack) >= 2:\\n if stack[-1] == 'b' and stack[-2] == 'a':\\n stack.pop()\\n stack.pop()\\n else:\\n stack.append(char)\\n if len(stack) == 0:\\n return True\\n return False\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n \\n \\n stack = []\\n \\n for c in s:\\n if c == 'c':\\n if ''.join(stack[-2:]) == 'ab':\\n stack.pop()\\n stack.pop()\\n continue\\n stack.append(c)\\n \\n return not stack\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n if len(s) % 3 != 0:\\n return False\\n if len(s) == 0:\\n return True\\n stack = []\\n for i in s:\\n if i != 'c':\\n stack.append(i)\\n elif len(stack) >= 2 and stack[-1] == 'b' and stack[-2] == 'a':\\n stack.pop()\\n stack.pop()\\n else:\\n stack.append(i)\\n if len(stack) == 0:\\n return True\\n return False\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n stack = []\\n for ch in s:\\n if ch == 'c':\\n if len(stack) > 1 and stack[-1] == 'b' and stack[-2] == 'a':\\n stack.pop()\\n stack.pop()\\n else:\\n stack.append(ch)\\n return not stack\",\n \"class Solution:\\n base = 'abc'\\n base_len = 3\\n \\n def isValid(self, S: str) -> bool:\\n stack = []\\n for c in S:\\n stack.append(c)\\n if len(stack) >= 3:\\n if stack[-1] == 'c' and stack[-2] == 'b' and stack[-3] == 'a':\\n stack.pop()\\n stack.pop()\\n stack.pop()\\n return len(stack) == 0\\n \\n# if not stack:\\n# stack.append(c)\\n# else:\\n\",\n \"from collections import deque\\nclass Solution:\\n def isValid(self, s: str) -> bool:\\n stk = deque()\\n for st in s:\\n stk.append(st)\\n if len(stk) >= 3:\\n if stk[-1]=='c' and stk[-2]=='b' and stk[-3]=='a':\\n for i in range(3):\\n stk.pop()\\n return len(stk)==0\\n\",\n \"# class Solution:\\n# def isValid(self, s: str) -> bool:\\n# element = 0\\n# lg = len(s)\\n# for j in range(lg):\\n# element += 1\\n# if element >= 3:\\n# if s[2]=='c' and s[1]=='b' and s[0]=='a':\\n# for i in range(2,-1,-1):\\n# del s[i]\\n\\n# return len(s)==0\\n \\nfrom collections import deque\\nclass Solution:\\n def isValid(self, s: str) -> bool:\\n stk = deque()\\n for st in s:\\n stk.append(st)\\n if len(stk) >= 3:\\n if stk[-1]=='c' and stk[-2]=='b' and stk[-3]=='a':\\n for i in range(3):\\n stk.pop()\\n return len(stk)==0\\n\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n LAST_THREE = ['a','b','c']\\n stack = [] \\n \\n for index, _chr in enumerate(s):\\n stack.append(_chr)\\n if stack[-3:] == LAST_THREE:\\n stack.pop()\\n stack.pop()\\n stack.pop()\\n \\n return len(stack) == 0\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n rtn =''\\n for i,char in enumerate(s):\\n if char == 'a':\\n rtn = rtn[:i] + 'abc' + rtn[i:]\\n return rtn == s\\n \\n# aabcbc,...abcabcababcc\\n\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n cnt = collections.Counter()\\n stack = []\\n for c in s:\\n cnt[c] += 1\\n if not cnt['a'] >= cnt['b'] >= cnt['c']:\\n return False\\n stack.append(c)\\n while len(stack)>=3 and stack[-1]=='c' and stack[-2]=='b' and stack[-3]=='a':\\n stack = stack[:-3]\\n #print(stack)\\n if stack:\\n return False\\n else:\\n return True\\n\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n cnt = collections.Counter()\\n stack = []\\n for c in s:\\n cnt[c] += 1\\n if not cnt['a'] >= cnt['b'] >= cnt['c']:\\n return False\\n if c == 'c':\\n if len(stack)>=2:\\n if stack[-1]=='b' and stack[-2]=='a':\\n stack.pop()\\n stack.pop()\\n else:\\n return False\\n else:\\n stack.append(c)\\n return not stack\\n\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n while s:\\n if 'abc' not in s:\\n return False\\n j = 0\\n while j < len(s) - 2:\\n if s[j:j+3] == 'abc':\\n s = s[:j] + s[j+3:]\\n else:\\n j += 1\\n return True\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n \\n \\n dic = collections.defaultdict(list)\\n \\n for i, c in enumerate(s):\\n dic[c].append(i)\\n \\n t = ''\\n for i in dic['a']:\\n t = t[:i] + 'abc' + t[i:]\\n \\n return t == s\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n l = len(s)\\n f = 0\\n while s:\\n i = 0\\n f = 0\\n while i<l:\\n if s[i]=='a' and i+1<l and s[i+1]=='b' and i+2<l and s[i+2]=='c':\\n s = s[:i]+s[i+3:]\\n l-=3\\n f = 1\\n else:\\n i+=1\\n if f==0 and l!=0 and s!='':\\n return False\\n return True\\n\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n while s:\\n tmp=s.replace('abc','')\\n if tmp==s:break\\n s=tmp\\n return not s\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n cnt = collections.Counter()\\n stack = []\\n for c in s:\\n cnt[c] += 1\\n if not cnt['a'] >= cnt['b'] >= cnt['c']:\\n return False\\n stack.append(c)\\n while len(stack)>=3 and stack[-1]=='c' and stack[-2]=='b' and stack[-3]=='a':\\n for _ in range(3):\\n stack.pop()\\n #print(stack)\\n if stack:\\n return False\\n else:\\n return True\\n\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n findVal = s.find('abc')\\n while findVal != -1:\\n s = s[:findVal] + s[findVal+3:]\\n findVal = s.find('abc')\\n return s==''\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n cnt = collections.Counter()\\n stack = []\\n for c in s:\\n cnt[c] += 1\\n if not cnt['a'] >= cnt['b'] >= cnt['c']:\\n return False\\n stack.append(c)\\n while ''.join(stack[-3:]) == 'abc':\\n stack = stack[:-3]\\n #print(stack)\\n if stack:\\n return False\\n else:\\n return True\\n\",\n \"class Solution:\\n def isValid0(self, S: str) -> bool:\\n \\n if len(S)<3:\\n return False\\n \\n if len(S) == 3:\\n if S == 'abc':\\n return True\\n else:\\n return False\\n \\n # find 'abc'\\n i=0\\n while i<len(S) and S[i:i+3] != 'abc':\\n i += 1\\n \\n if S[i:i+3] == 'abc':\\n new_S = S[:i] + S[i+3:]\\n return self.isValid(new_S)\\n else:\\n return False\\n \\n def isValid(self, S: str) -> bool:\\n \\n stack = []\\n for c in S:\\n if len(stack) < 2:\\n stack.append(c)\\n else:\\n if stack[-2]+ stack[-1] + c =='abc':\\n stack.pop()\\n stack.pop()\\n else:\\n stack.append(c)\\n \\n if len(stack) == 0:\\n return True\\n else:\\n return False\\n \\n \\n \\n \\n\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n stack=[]\\n i=0\\n while(i<len(s) or (stack and len(stack)>2 and stack[-3:]==['a','b','c'])):\\n while(stack and len(stack)>2 and stack[-3:]==['a','b','c']):\\n \\n stack.pop()\\n stack.pop()\\n stack.pop()\\n if i<len(s):\\n stack.append(s[i])\\n i+=1\\n #print('stack',stack)\\n if not stack:\\n return True\\n return False\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n while True:\\n ns = s.replace('abc', '')\\n if ns == '':\\n return True\\n if ns == s:\\n return False\\n s = ns\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n indicesToDelete = set()\\n for i in range(len(s)-2):\\n substr = s[i:i+3]\\n if substr =='abc':\\n indicesToDelete.add(i)\\n indicesToDelete.add(i+1)\\n indicesToDelete.add(i+2)\\n newS = ''\\n for i in range(len(s)-1,-1,-1):\\n if i not in indicesToDelete:\\n newS += s[i]\\n s = newS[::-1]\\n left = 0\\n right = len(s) -1\\n\\n while left < right:\\n if s[left] =='a' and s[right] =='c':\\n if s[left+1] =='b' and s[left+2] =='c':\\n left +=3\\n elif s[right-1] =='b' and s[right-2] =='a':\\n right -=3\\n elif s[left+1] == 'b':\\n left +=2\\n right -=1\\n elif s[right-1] =='b':\\n left +=1\\n right -=2\\n else:\\n return False\\n else:\\n return False\\n return True\\n\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n stack = []\\n for i in range(len(s)):\\n if stack == []:\\n stack.append([])\\n stack[-1].append(ord(s[i]))\\n elif stack[-1][-1] + 1 == ord(s[i]):\\n stack[-1].append(ord(s[i]))\\n else:\\n stack.append([ord(s[i])])\\n \\n if stack[-1] == [ord('a'), ord('b'), ord('c')]:\\n stack.pop()\\n return stack == []\\n \\n\",\n \"class Solution:\\n def isValid(self, S: str) -> bool:\\n i = S.find('abc')\\n while i != -1:\\n S = S[:i] + S[i+3:]\\n i = S.find('abc')\\n return not S\\n\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n while len(s) > 3:\\n i = s.find('abc')\\n if i == -1:\\n return False\\n s = s[:i] + s[i + 3:]\\n return not s or s == 'abc'\",\n \"class Solution:\\n def isValid(self, S: str) -> bool:\\n stack = []\\n for c in S:\\n stack.append(c)\\n if ''.join(stack[-3:]) == 'abc':\\n stack = stack[:-3]\\n return len(stack) == 0\",\n \"class Solution:\\n def isValid(self, S: str) -> bool:\\n stack = []\\n for c in S:\\n stack.append(c)\\n while stack and stack[-1] == 'c' and len(stack) >= 3 and stack[-2] == 'b' and stack[-3] == 'a':\\n stack = stack[:-3]\\n \\n return not stack\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n while s.find('abc') > -1:\\n i = s.find('abc')\\n s = s[:i] + s[i+3:]\\n return s == ''\\n \\n\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n while s.find('abc') >= 0:\\n s = s.replace('abc', '')\\n return s == ''\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n stack = []\\n for c in s:\\n stack.append(c)\\n while ''.join(stack[-3:]) == 'abc':\\n stack = stack[:-3]\\n #print(stack)\\n if stack:\\n return False\\n else:\\n return True\\n\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n s = list(s)\\n left = 0\\n while len(s) > 2 and left < len(s)-2:\\n if s[left:left+3] == ['a', 'b', 'c']:\\n s.pop(left+2)\\n s.pop(left+1)\\n s.pop(left)\\n left -= 2\\n else:\\n left += 1\\n if s:\\n return False\\n else:\\n return True\\n\",\n \"class Solution:\\n def isValid(self, S: str) -> bool:\\n st = []\\n for i, s in enumerate(S):\\n st.append(s)\\n while st[-3:] == ['a','b','c']:\\n st = st[:-3]\\n return len(st) == 0\",\n \"class Solution:\\n def isValid(self, S: str) -> bool:\\n stack = []\\n for i in S:\\n if i == 'c':\\n if stack[-2:] != ['a', 'b']:\\n return False\\n stack.pop()\\n stack.pop()\\n else:\\n stack.append(i)\\n return not stack\\n\",\n \"'''\\nabc abc\\na abc bc\\nab abc c\\n\\nKeep a stack that remembers the current letter for each depth level\\n\\nfor example:\\naabcbc\\n 123\\n1 [a, b]\\n2 [a]\\n3 [b]\\n\\n'''\\n\\n\\nclass Solution:\\n def isValid(self, s: str) -> bool:\\n stack = list()\\n \\n for ch in s:\\n if ch == 'a':\\n stack.append('a')\\n elif ch == 'b':\\n if stack and stack[-1] == 'a':\\n stack[-1] = 'b'\\n else:\\n return False\\n elif ch == 'c':\\n if stack and stack[-1] == 'b':\\n stack.pop()\\n else:\\n return False\\n else:\\n return False\\n \\n return (len(stack) == 0)\",\n \"class Solution:\\n def isValid(self, s: str) -> bool:\\n d=[]\\n for i in s:\\n if i=='c':\\n if d[-2:]!=['a','b']:return False\\n d.pop();d.pop()\\n else:d.append(i)\\n return not d\"\n]","isConversational":false},"n_sols":{"kind":"number","value":38,"string":"38"},"non_interactive_idx":{"kind":"list like","value":[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],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32,\n 33,\n 34,\n 35,\n 36,\n 37\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[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],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":65,"cells":{"problem_id":{"kind":"number","value":198,"string":"198"},"question":{"kind":"string","value":"You are given two strings s and t of the same length. You want to change s to t. Changing the i-th character of s to i-th character of t costs |s[i] - t[i]| that is, the absolute difference between the ASCII values of the characters.\nYou are also given an integer maxCost.\nReturn the maximum length of a substring of s that can be changed to be the same as the corresponding substring of twith a cost less than or equal to maxCost.\nIf there is no substring from s that can be changed to its corresponding substring from t, return 0.\n \nExample 1:\nInput: s = \"abcd\", t = \"bcdf\", maxCost = 3\nOutput: 3\nExplanation: \"abc\" of s can change to \"bcd\". That costs 3, so the maximum length is 3.\nExample 2:\nInput: s = \"abcd\", t = \"cdef\", maxCost = 3\nOutput: 1\nExplanation: Each character in s costs 2 to change to charactor in t, so the maximum length is 1.\n\nExample 3:\nInput: s = \"abcd\", t = \"acde\", maxCost = 0\nOutput: 1\nExplanation: You can't make any change, so the maximum length is 1.\n\n \nConstraints:\n\n1 <= s.length, t.length <= 10^5\n0 <= maxCost <= 10^6\ns and t only contain lower case English letters."},"solutions":{"kind":"string","value":"[\"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n dist = [ abs( ord(s[i]) - ord(t[i]) ) for i in range(len(s))]\\n \\n# i = 0\\n# cur = 0\\n# res = 0\\n# for j in range(len(s)):\\n# cur += dist[j]\\n# while cur>maxCost:\\n# cur -= dist[i]\\n# i += 1\\n# res = max(res, j-i+1)\\n \\n# return res\\n\\n i = 0\\n cost = maxCost\\n for j in range(len(s)):\\n cost -= dist[j]\\n if cost < 0:\\n cost += dist[i]\\n i += 1\\n \\n return j-i+1\\n \\n \\n\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n \\n\\n i=0\\n ans=0\\n \\n curr = 0\\n for j in range(0,len(s)):\\n curr = curr + abs(ord(s[j])-ord(t[j]))\\n if curr<=maxCost:\\n ans = max(ans , j-i+1)\\n else:\\n curr = curr - abs(ord(s[i])-ord(t[i])) \\n i=i+1\\n \\n \\n \\n print()\\n return ans\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n #I could first create an array with the cost of each character change\\n\\n currCost = 0\\n maxLength = 0\\n start = 0\\n curr = 0\\n costs = [abs(ord(s[i])- ord(t[i])) for i in range(len(s))]\\n print(costs)\\n while curr < len(costs):\\n currCost += costs[curr]\\n while currCost > maxCost:\\n currCost = currCost - costs[start]\\n start+=1\\n if curr - start + 1 > maxLength:\\n maxLength = curr - start + 1\\n # print(f\\\\\\\"currCost: {currCost}, start: {start}, curr: {curr}\\\\\\\")\\n curr +=1\\n return maxLength\\n\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n if not s: return 0\\n costs = [abs(ord(si)-ord(ti)) for si, ti in zip(s, t)]\\n ans = 0\\n l, r = 0, 0\\n cur_cost = 0\\n print(costs)\\n while l < len(s) and r < len(s):\\n while r < len(s) and cur_cost <= maxCost:\\n cur_cost += costs[r]\\n r += 1\\n ans = max(ans, r-l-1)\\n \\n while l < r and cur_cost > maxCost:\\n cur_cost -= costs[l]\\n l += 1\\n ans = max(ans, r-l)\\n return ans\\n \\n\", \"class Solution:\\n def equalSubstring(self, string: str, target: str, maxCost: int) -> int:\\n cost = [0]*len(string)\\n for i in range(len(string)) :\\n if string[i] != target[i] : cost[i] += abs(ord(string[i]) - ord(target[i]))\\n if i > 0 : cost[i]+= cost[i-1]\\n answer = 0\\n s=0\\n for i in range(len(string)) :\\n if cost[i] <= maxCost : answer = max(answer,i+1)\\n else :\\n while s<=i and cost[i]-cost[s]> maxCost: s+=1\\n answer = max(answer,i-s)\\n \\n return answer\\n\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n cost = [abs(ord(s[i])-ord(t[i])) for i in range(len(s))]\\n prefix = [0] # prefix[i] gives us cost[0] + ... + cost[i-1]\\n for i in range(len(cost)):\\n prefix.append(prefix[-1]+cost[i])\\n maxLen = 0\\n i,j = 0,0\\n # print(prefix)\\n while j < len(cost):\\n while j < len(cost) and prefix[j+1]-prefix[i] <= maxCost:\\n j += 1\\n maxLen = max(maxLen,j-i)\\n i += 1\\n # j = i\\n if i > j:\\n j = i\\n return maxLen\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n \\n start = 0\\n ans = 0\\n cur = 0\\n for end in range(len(s)): \\n val = abs(ord(s[end]) - ord(t[end]))\\n cur += val\\n if cur <= maxCost:\\n ans = max(ans, end-start+1)\\n else:\\n while cur > maxCost:\\n cur -= abs(ord(s[start]) - ord(t[start]))\\n start += 1\\n \\n return ans\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n \\n res = 0\\n c = [0]*(len(s)+1)\\n j = 0\\n for i in range(1, len(s)+1):\\n c[i] += c[i-1]+abs(ord(s[i-1])-ord(t[i-1]))\\n \\n while c[i]>maxCost:\\n c[i] -= abs(ord(s[j])-ord(t[j]))\\n j += 1\\n res = max(res, i-j)\\n return res\\n\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n max_length = 0\\n start = 0\\n end = 0\\n cost = 0\\n while end < len(s):\\n c = abs(ord(s[end]) - ord(t[end]))\\n if cost + c <= maxCost:\\n cost += c\\n end += 1\\n else:\\n cost -= abs(ord(s[start]) - ord(t[start]))\\n start += 1\\n max_length = max(max_length, end - start) \\n return max_length \\n\", \"class Solution:\\n def equalSubstring(self, s, t, maxCost):\\n n = len(s)\\n right = 0\\n nowSum = 0\\n res = 0\\n for left in range(n):\\n while right <= n - 1 and nowSum + abs(ord(s[right]) - ord(t[right])) <= maxCost: \\n nowSum += abs(ord(s[right]) - ord(t[right]))\\n right += 1\\n res = max(res, right - left)\\n nowSum -= abs(ord(s[left]) - ord(t[left]))\\n return res \", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n cost_array = [abs(a - b) for a, b in zip(map(ord, s), map(ord, t))]\\n left = right = t = 0\\n mx = 0\\n while right < len(cost_array):\\n t += cost_array[right]\\n if t > maxCost:\\n while left < len(cost_array) and t > maxCost:\\n t -= cost_array[left]\\n left += 1\\n\\n right += 1\\n mx = max(mx, right - left)\\n\\n return mx\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n i = 0\\n for j in range(len(s)):\\n maxCost -= abs(ord(s[j]) - ord(t[j]))\\n if maxCost < 0:\\n maxCost += abs(ord(s[i]) - ord(t[i]))\\n i += 1\\n return j - i + 1\\n\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n cost_array = [abs(a - b) for a, b in zip(list(map(ord, s)), list(map(ord, t)))]\\n \\n left = right = t = mx = 0\\n \\n while right < len(cost_array):\\n \\n t += cost_array[right]\\n if t > maxCost:\\n t -= cost_array[left]\\n left += 1\\n\\n right += 1\\n mx = max(mx, right - left)\\n\\n return mx\\n\\n\", \"import numpy as np\\n\\nclass Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n #Ss = [ord(c) for c in s]\\n #Tt = [ord(d) for d in t]\\n #diff = np.abs(np.array(Ss)-np.array(Tt))\\n #n = len(s)\\n i = result = 0\\n for j in range(len(s)):\\n maxCost -= abs(ord(s[j])-ord(t[j]))\\n while(maxCost<0):\\n maxCost += abs(ord(s[i])-ord(t[i]))\\n i+=1\\n result = max(result,j-i+1)\\n\\n return result\", \"import numpy as np\\n\\nclass Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n #table = np.zeros(len(s))\\n i = result = 0\\n for j in range(len(s)):\\n maxCost -= abs(ord(s[j])-ord(t[j]))\\n while(maxCost<0):\\n maxCost += abs(ord(s[i])-ord(t[i]))\\n i+=1\\n result = max(result,j-i+1)\\n #table[j] = j-i+1\\n return result\\n #return int(max(table))\\n\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n res = curr = i = j = 0\\n while i < len(s) and j < len(s):\\n curr += abs(ord(s[j]) - ord(t[j]))\\n j += 1\\n while curr > maxCost:\\n curr -= abs(ord(s[i]) - ord(t[i]))\\n i += 1\\n res = max(res, j - i)\\n return res\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n currcost=0;i=0;j=0\\n if(len(s)==0):\\n return 0\\n if(len(s)==1):\\n if(abs(ord[s[0]])-ord(t[0])>=maxcost):\\n return 1\\n else:\\n return 0\\n currcost=0\\n ans=0\\n state=False\\n while(i<len(s) and j<len(s)):\\n if(currcost+abs(ord(s[j])-ord(t[j]))<=maxCost):\\n currcost+=abs(ord(s[j])-ord(t[j]))\\n j+=1\\n state=True\\n else:\\n ans=max(ans,j-i)\\n currcost-=abs(ord(s[i])-ord(t[i]))\\n i+=1\\n state=False\\n if(i>=j):\\n j=i\\n currcost=0\\n if state:\\n ans=max(ans,j-i)\\n return ans\\n\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n max_substring = 0\\n curr_substring = 0\\n \\n left = right = diff = 0\\n \\n while right < len(s):\\n local_diff = abs(ord(s[right]) - ord(t[right]))\\n if diff + local_diff <= maxCost:\\n diff += local_diff\\n right += 1\\n curr_substring += 1\\n max_substring = max(curr_substring, max_substring)\\n else:\\n if left == right:\\n right += 1\\n else:\\n diff -= abs(ord(s[left]) - ord(t[left]))\\n curr_substring -= 1\\n left += 1\\n \\n return max_substring\\n\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n \\n arr = [abs(ord(sc) - ord(tc)) for sc, tc in zip(s, t)]\\n max_len = 0\\n left, right = 0, 0\\n curr_sum = 0\\n max_len = 0\\n while(right < len(arr)):\\n curr_sum += arr[right]\\n while(left < len(arr) and curr_sum > maxCost):\\n curr_sum -= arr[left]\\n left += 1\\n max_len = max(max_len, right - left + 1)\\n right += 1\\n return max_len\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n start = 0\\n cost = 0\\n max_len = 0\\n for end in range(len(s)):\\n cost += abs(ord(s[end]) - ord(t[end]))\\n while cost > maxCost:\\n cost -= abs(ord(s[start]) - ord(t[start]))\\n start += 1\\n max_len = max(max_len,end - start + 1)\\n return max_len\\n \\n \\n\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n max_len = head = subtotal = 0\\n for tail in range(len(s)):\\n subtotal += abs(ord(s[tail]) - ord(t[tail]))\\n while subtotal > maxCost:\\n subtotal -= abs(ord(s[head]) - ord(t[head]))\\n head += 1\\n max_len = max(max_len, tail - head + 1)\\n return max_len\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n totalCost = 0\\n maxLength = 0\\n \\n costs = []\\n left = 0\\n length = 0\\n for i in range(len(s)):\\n costs.append(abs(ord(s[i]) - ord(t[i])))\\n totalCost += costs[-1]\\n length += 1\\n \\n if totalCost <= maxCost:\\n maxLength = length if length > maxLength else maxLength\\n else:\\n while totalCost > maxCost:\\n totalCost -= costs[left]\\n left += 1\\n length -= 1\\n \\n return maxLength\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n n = len(s)\\n cost = 0\\n left = 0\\n max_len = 0\\n for right in range(n):\\n cost += abs(ord(s[right]) - ord(t[right]))\\n while cost > maxCost:\\n cost -= abs(ord(s[left]) - ord(t[left]))\\n left += 1\\n max_len = max(max_len, right - left + 1)\\n return max_len\", \"import numpy as np\\n\\nclass Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n Ss = [ord(c) for c in s]\\n Tt = [ord(d) for d in t]\\n diff = np.abs(np.array(Ss)-np.array(Tt))\\n n = len(diff)\\n i = result = 0\\n for j in range(n):\\n maxCost -= diff[j]\\n if maxCost<0:\\n maxCost += diff[i]\\n i+=1\\n result = max(result,j-i+1)\\n\\n return result\", \"class Solution:\\n def equalSubstring(self, s, t, maxCost):\\n cost = 0\\n ans = 0\\n left, right = 0, -1\\n for s_c, t_c in zip(s, t):\\n right += 1\\n cost += abs(ord(s_c) - ord(t_c))\\n while cost > maxCost:\\n cost -= abs(ord(s[left]) - ord(t[left]))\\n left += 1\\n ans = max(ans, right - left + 1)\\n return ans\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n end = 0\\n result = 0\\n\\n allCost = 0\\n for start in range(len(s)):\\n if start >= 1:\\n allCost -= abs(ord(s[start-1]) - ord(t[start-1]))\\n\\n while (end +1<len(s)+1) and (allCost+ abs(ord(s[end]) - ord(t[end]))<= maxCost):\\n end += 1\\n allCost += abs(ord(s[end-1]) - ord(t[end-1]))\\n\\n\\n result = max(result, end-start)\\n return result\\n\", \"import numpy as np\\n\\nclass Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n Ss = [ord(c) for c in s]\\n Tt = [ord(d) for d in t]\\n diff = np.abs(np.array(Ss)-np.array(Tt))\\n n = len(diff)\\n i = result = 0\\n for j in range(n):\\n maxCost -= diff[j]\\n while(maxCost<0):\\n maxCost += diff[i]\\n i+=1\\n result = max(result,j-i+1)\\n\\n return result\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n \\n arr = []\\n lim = len(s)\\n for i in range(0,lim):\\n arr.append(abs(ord(s[i])-ord(t[i])))\\n \\n sm = [arr[0]]\\n \\n for j in range(1,lim):\\n sm.append(sm[-1]+arr[j])\\n \\n \\n l = 0\\n h = lim\\n \\n mx = 0\\n while l<=h:\\n m = (l+h)//2\\n ###print(m)\\n t = 0\\n for i in range(0,lim-m):\\n if sm[i+m]-sm[i]+arr[i]<=maxCost:\\n t = 1\\n break\\n if t==1:\\n if m+1>mx:mx = m+1\\n l = m+1\\n else:\\n h = m-1\\n return mx\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n start = 0\\n end = 0\\n cost = 0\\n best = 0\\n while end < len(s):\\n while end < len(s) and cost + abs(ord(s[end]) - ord(t[end])) <= maxCost:\\n cost += abs(ord(s[end]) - ord(t[end]))\\n end += 1\\n if start == end:\\n start += 1\\n end += 1\\n continue\\n best = max(best, end - start)\\n cost -= abs(ord(s[start]) - ord(t[start]))\\n start += 1\\n return best\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n \\n diff = []\\n for i in range(len(s)):\\n diff.append(abs(ord(s[i])-ord(t[i])))\\n \\n i=0\\n ans=0\\n \\n curr = 0\\n for j in range(0,len(s)):\\n curr = curr + diff[j]\\n if curr<=maxCost:\\n ans = max(ans , j-i+1)\\n else:\\n curr = curr - diff[i] \\n i=i+1\\n return ans\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n ans = 0\\n cost = 0\\n left,right=0,0\\n while right < len(s):\\n cost += abs(ord(s[right])-ord(t[right]))\\n if cost > maxCost:\\n cost -= abs(ord(s[left])-ord(t[left]))\\n left += 1\\n else:\\n ans = max(ans,right-left+1)\\n right += 1\\n return ans\\n \\n\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n #I could first create an array with the cost of each character change\\n\\n currCost = 0\\n maxLength = 0\\n start = 0\\n curr = 0\\n while curr < len(s):\\n currCost += abs(ord(s[curr])- ord(t[curr]))\\n while currCost > maxCost:\\n currCost = currCost - (abs(ord(s[start])- ord(t[start])))\\n start+=1\\n if curr - start + 1 > maxLength:\\n maxLength = curr - start + 1\\n curr +=1\\n return maxLength\\n\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n maxLength = 0\\n currLength = 0\\n currCost = 0\\n \\n for i in range(len(s)):\\n currLength += 1\\n currCost += abs(ord(s[i]) - ord(t[i]))\\n while currCost > maxCost:\\n currCost -= abs(ord(s[i-(currLength-1)]) - ord(t[i-(currLength-1)]))\\n currLength -= 1\\n maxLength = max(maxLength, currLength)\\n \\n return maxLength\\n \\n# Time: O(n)\\n# Space: O(1)\\n\", \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n res = 0\\n i,j = 0,0\\n while j < len(s):\\n maxCost -= abs(ord(t[j]) - ord(s[j]))\\n while maxCost < 0:\\n maxCost += abs(ord(t[i]) - ord(s[i]))\\n i += 1\\n j += 1\\n res = max(res, j -i)\\n return res\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"equalSubstring\", \"inputs\": [[\"\\\"abcd\\\"\", \"\\\"bcdf\\\"\", 3]], \"outputs\": [4]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/get-equal-substrings-within-budget/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n dist = [ abs( ord(s[i]) - ord(t[i]) ) for i in range(len(s))]\n \n# i = 0\n# cur = 0\n# res = 0\n# for j in range(len(s)):\n# cur += dist[j]\n# while cur>maxCost:\n# cur -= dist[i]\n# i += 1\n# res = max(res, j-i+1)\n \n# return res\n\n i = 0\n cost = maxCost\n for j in range(len(s)):\n cost -= dist[j]\n if cost < 0:\n cost += dist[i]\n i += 1\n \n return j-i+1\n \n \n","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n \n\n i=0\n ans=0\n \n curr = 0\n for j in range(0,len(s)):\n curr = curr + abs(ord(s[j])-ord(t[j]))\n if curr<=maxCost:\n ans = max(ans , j-i+1)\n else:\n curr = curr - abs(ord(s[i])-ord(t[i])) \n i=i+1\n \n \n \n print()\n return ans","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n #I could first create an array with the cost of each character change\n\n currCost = 0\n maxLength = 0\n start = 0\n curr = 0\n costs = [abs(ord(s[i])- ord(t[i])) for i in range(len(s))]\n print(costs)\n while curr < len(costs):\n currCost += costs[curr]\n while currCost > maxCost:\n currCost = currCost - costs[start]\n start+=1\n if curr - start + 1 > maxLength:\n maxLength = curr - start + 1\n # print(f\\\"currCost: {currCost}, start: {start}, curr: {curr}\\\")\n curr +=1\n return maxLength\n","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n if not s: return 0\n costs = [abs(ord(si)-ord(ti)) for si, ti in zip(s, t)]\n ans = 0\n l, r = 0, 0\n cur_cost = 0\n print(costs)\n while l < len(s) and r < len(s):\n while r < len(s) and cur_cost <= maxCost:\n cur_cost += costs[r]\n r += 1\n ans = max(ans, r-l-1)\n \n while l < r and cur_cost > maxCost:\n cur_cost -= costs[l]\n l += 1\n ans = max(ans, r-l)\n return ans\n \n","class Solution:\n def equalSubstring(self, string: str, target: str, maxCost: int) -> int:\n cost = [0]*len(string)\n for i in range(len(string)) :\n if string[i] != target[i] : cost[i] += abs(ord(string[i]) - ord(target[i]))\n if i > 0 : cost[i]+= cost[i-1]\n answer = 0\n s=0\n for i in range(len(string)) :\n if cost[i] <= maxCost : answer = max(answer,i+1)\n else :\n while s<=i and cost[i]-cost[s]> maxCost: s+=1\n answer = max(answer,i-s)\n \n return answer\n","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n cost = [abs(ord(s[i])-ord(t[i])) for i in range(len(s))]\n prefix = [0] # prefix[i] gives us cost[0] + ... + cost[i-1]\n for i in range(len(cost)):\n prefix.append(prefix[-1]+cost[i])\n maxLen = 0\n i,j = 0,0\n # print(prefix)\n while j < len(cost):\n while j < len(cost) and prefix[j+1]-prefix[i] <= maxCost:\n j += 1\n maxLen = max(maxLen,j-i)\n i += 1\n # j = i\n if i > j:\n j = i\n return maxLen","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n \n start = 0\n ans = 0\n cur = 0\n for end in range(len(s)): \n val = abs(ord(s[end]) - ord(t[end]))\n cur += val\n if cur <= maxCost:\n ans = max(ans, end-start+1)\n else:\n while cur > maxCost:\n cur -= abs(ord(s[start]) - ord(t[start]))\n start += 1\n \n return ans","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n \n res = 0\n c = [0]*(len(s)+1)\n j = 0\n for i in range(1, len(s)+1):\n c[i] += c[i-1]+abs(ord(s[i-1])-ord(t[i-1]))\n \n while c[i]>maxCost:\n c[i] -= abs(ord(s[j])-ord(t[j]))\n j += 1\n res = max(res, i-j)\n return res\n","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n max_length = 0\n start = 0\n end = 0\n cost = 0\n while end < len(s):\n c = abs(ord(s[end]) - ord(t[end]))\n if cost + c <= maxCost:\n cost += c\n end += 1\n else:\n cost -= abs(ord(s[start]) - ord(t[start]))\n start += 1\n max_length = max(max_length, end - start) \n return max_length \n","class Solution:\n def equalSubstring(self, s, t, maxCost):\n n = len(s)\n right = 0\n nowSum = 0\n res = 0\n for left in range(n):\n while right <= n - 1 and nowSum + abs(ord(s[right]) - ord(t[right])) <= maxCost: \n nowSum += abs(ord(s[right]) - ord(t[right]))\n right += 1\n res = max(res, right - left)\n nowSum -= abs(ord(s[left]) - ord(t[left]))\n return res ","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n cost_array = [abs(a - b) for a, b in zip(map(ord, s), map(ord, t))]\n left = right = t = 0\n mx = 0\n while right < len(cost_array):\n t += cost_array[right]\n if t > maxCost:\n while left < len(cost_array) and t > maxCost:\n t -= cost_array[left]\n left += 1\n\n right += 1\n mx = max(mx, right - left)\n\n return mx","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n i = 0\n for j in range(len(s)):\n maxCost -= abs(ord(s[j]) - ord(t[j]))\n if maxCost < 0:\n maxCost += abs(ord(s[i]) - ord(t[i]))\n i += 1\n return j - i + 1\n","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n cost_array = [abs(a - b) for a, b in zip(list(map(ord, s)), list(map(ord, t)))]\n \n left = right = t = mx = 0\n \n while right < len(cost_array):\n \n t += cost_array[right]\n if t > maxCost:\n t -= cost_array[left]\n left += 1\n\n right += 1\n mx = max(mx, right - left)\n\n return mx\n\n","import numpy as np\n\nclass Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n #Ss = [ord(c) for c in s]\n #Tt = [ord(d) for d in t]\n #diff = np.abs(np.array(Ss)-np.array(Tt))\n #n = len(s)\n i = result = 0\n for j in range(len(s)):\n maxCost -= abs(ord(s[j])-ord(t[j]))\n while(maxCost<0):\n maxCost += abs(ord(s[i])-ord(t[i]))\n i+=1\n result = max(result,j-i+1)\n\n return result","import numpy as np\n\nclass Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n #table = np.zeros(len(s))\n i = result = 0\n for j in range(len(s)):\n maxCost -= abs(ord(s[j])-ord(t[j]))\n while(maxCost<0):\n maxCost += abs(ord(s[i])-ord(t[i]))\n i+=1\n result = max(result,j-i+1)\n #table[j] = j-i+1\n return result\n #return int(max(table))\n","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n res = curr = i = j = 0\n while i < len(s) and j < len(s):\n curr += abs(ord(s[j]) - ord(t[j]))\n j += 1\n while curr > maxCost:\n curr -= abs(ord(s[i]) - ord(t[i]))\n i += 1\n res = max(res, j - i)\n return res","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n currcost=0;i=0;j=0\n if(len(s)==0):\n return 0\n if(len(s)==1):\n if(abs(ord[s[0]])-ord(t[0])>=maxcost):\n return 1\n else:\n return 0\n currcost=0\n ans=0\n state=False\n while(i<len(s) and j<len(s)):\n if(currcost+abs(ord(s[j])-ord(t[j]))<=maxCost):\n currcost+=abs(ord(s[j])-ord(t[j]))\n j+=1\n state=True\n else:\n ans=max(ans,j-i)\n currcost-=abs(ord(s[i])-ord(t[i]))\n i+=1\n state=False\n if(i>=j):\n j=i\n currcost=0\n if state:\n ans=max(ans,j-i)\n return ans\n","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n max_substring = 0\n curr_substring = 0\n \n left = right = diff = 0\n \n while right < len(s):\n local_diff = abs(ord(s[right]) - ord(t[right]))\n if diff + local_diff <= maxCost:\n diff += local_diff\n right += 1\n curr_substring += 1\n max_substring = max(curr_substring, max_substring)\n else:\n if left == right:\n right += 1\n else:\n diff -= abs(ord(s[left]) - ord(t[left]))\n curr_substring -= 1\n left += 1\n \n return max_substring\n","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n \n arr = [abs(ord(sc) - ord(tc)) for sc, tc in zip(s, t)]\n max_len = 0\n left, right = 0, 0\n curr_sum = 0\n max_len = 0\n while(right < len(arr)):\n curr_sum += arr[right]\n while(left < len(arr) and curr_sum > maxCost):\n curr_sum -= arr[left]\n left += 1\n max_len = max(max_len, right - left + 1)\n right += 1\n return max_len","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n start = 0\n cost = 0\n max_len = 0\n for end in range(len(s)):\n cost += abs(ord(s[end]) - ord(t[end]))\n while cost > maxCost:\n cost -= abs(ord(s[start]) - ord(t[start]))\n start += 1\n max_len = max(max_len,end - start + 1)\n return max_len\n \n \n","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n max_len = head = subtotal = 0\n for tail in range(len(s)):\n subtotal += abs(ord(s[tail]) - ord(t[tail]))\n while subtotal > maxCost:\n subtotal -= abs(ord(s[head]) - ord(t[head]))\n head += 1\n max_len = max(max_len, tail - head + 1)\n return max_len","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n totalCost = 0\n maxLength = 0\n \n costs = []\n left = 0\n length = 0\n for i in range(len(s)):\n costs.append(abs(ord(s[i]) - ord(t[i])))\n totalCost += costs[-1]\n length += 1\n \n if totalCost <= maxCost:\n maxLength = length if length > maxLength else maxLength\n else:\n while totalCost > maxCost:\n totalCost -= costs[left]\n left += 1\n length -= 1\n \n return maxLength","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n n = len(s)\n cost = 0\n left = 0\n max_len = 0\n for right in range(n):\n cost += abs(ord(s[right]) - ord(t[right]))\n while cost > maxCost:\n cost -= abs(ord(s[left]) - ord(t[left]))\n left += 1\n max_len = max(max_len, right - left + 1)\n return max_len","import numpy as np\n\nclass Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n Ss = [ord(c) for c in s]\n Tt = [ord(d) for d in t]\n diff = np.abs(np.array(Ss)-np.array(Tt))\n n = len(diff)\n i = result = 0\n for j in range(n):\n maxCost -= diff[j]\n if maxCost<0:\n maxCost += diff[i]\n i+=1\n result = max(result,j-i+1)\n\n return result","class Solution:\n def equalSubstring(self, s, t, maxCost):\n cost = 0\n ans = 0\n left, right = 0, -1\n for s_c, t_c in zip(s, t):\n right += 1\n cost += abs(ord(s_c) - ord(t_c))\n while cost > maxCost:\n cost -= abs(ord(s[left]) - ord(t[left]))\n left += 1\n ans = max(ans, right - left + 1)\n return ans","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n end = 0\n result = 0\n\n allCost = 0\n for start in range(len(s)):\n if start >= 1:\n allCost -= abs(ord(s[start-1]) - ord(t[start-1]))\n\n while (end +1<len(s)+1) and (allCost+ abs(ord(s[end]) - ord(t[end]))<= maxCost):\n end += 1\n allCost += abs(ord(s[end-1]) - ord(t[end-1]))\n\n\n result = max(result, end-start)\n return result\n","import numpy as np\n\nclass Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n Ss = [ord(c) for c in s]\n Tt = [ord(d) for d in t]\n diff = np.abs(np.array(Ss)-np.array(Tt))\n n = len(diff)\n i = result = 0\n for j in range(n):\n maxCost -= diff[j]\n while(maxCost<0):\n maxCost += diff[i]\n i+=1\n result = max(result,j-i+1)\n\n return result","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n \n arr = []\n lim = len(s)\n for i in range(0,lim):\n arr.append(abs(ord(s[i])-ord(t[i])))\n \n sm = [arr[0]]\n \n for j in range(1,lim):\n sm.append(sm[-1]+arr[j])\n \n \n l = 0\n h = lim\n \n mx = 0\n while l<=h:\n m = (l+h)//2\n ###print(m)\n t = 0\n for i in range(0,lim-m):\n if sm[i+m]-sm[i]+arr[i]<=maxCost:\n t = 1\n break\n if t==1:\n if m+1>mx:mx = m+1\n l = m+1\n else:\n h = m-1\n return mx","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n start = 0\n end = 0\n cost = 0\n best = 0\n while end < len(s):\n while end < len(s) and cost + abs(ord(s[end]) - ord(t[end])) <= maxCost:\n cost += abs(ord(s[end]) - ord(t[end]))\n end += 1\n if start == end:\n start += 1\n end += 1\n continue\n best = max(best, end - start)\n cost -= abs(ord(s[start]) - ord(t[start]))\n start += 1\n return best","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n \n diff = []\n for i in range(len(s)):\n diff.append(abs(ord(s[i])-ord(t[i])))\n \n i=0\n ans=0\n \n curr = 0\n for j in range(0,len(s)):\n curr = curr + diff[j]\n if curr<=maxCost:\n ans = max(ans , j-i+1)\n else:\n curr = curr - diff[i] \n i=i+1\n return ans","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n ans = 0\n cost = 0\n left,right=0,0\n while right < len(s):\n cost += abs(ord(s[right])-ord(t[right]))\n if cost > maxCost:\n cost -= abs(ord(s[left])-ord(t[left]))\n left += 1\n else:\n ans = max(ans,right-left+1)\n right += 1\n return ans\n \n","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n #I could first create an array with the cost of each character change\n\n currCost = 0\n maxLength = 0\n start = 0\n curr = 0\n while curr < len(s):\n currCost += abs(ord(s[curr])- ord(t[curr]))\n while currCost > maxCost:\n currCost = currCost - (abs(ord(s[start])- ord(t[start])))\n start+=1\n if curr - start + 1 > maxLength:\n maxLength = curr - start + 1\n curr +=1\n return maxLength\n","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n maxLength = 0\n currLength = 0\n currCost = 0\n \n for i in range(len(s)):\n currLength += 1\n currCost += abs(ord(s[i]) - ord(t[i]))\n while currCost > maxCost:\n currCost -= abs(ord(s[i-(currLength-1)]) - ord(t[i-(currLength-1)]))\n currLength -= 1\n maxLength = max(maxLength, currLength)\n \n return maxLength\n \n# Time: O(n)\n# Space: O(1)\n","class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n res = 0\n i,j = 0,0\n while j < len(s):\n maxCost -= abs(ord(t[j]) - ord(s[j]))\n while maxCost < 0:\n maxCost += abs(ord(t[i]) - ord(s[i]))\n i += 1\n j += 1\n res = max(res, j -i)\n return res"],"string":"[\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n dist = [ abs( ord(s[i]) - ord(t[i]) ) for i in range(len(s))]\\n \\n# i = 0\\n# cur = 0\\n# res = 0\\n# for j in range(len(s)):\\n# cur += dist[j]\\n# while cur>maxCost:\\n# cur -= dist[i]\\n# i += 1\\n# res = max(res, j-i+1)\\n \\n# return res\\n\\n i = 0\\n cost = maxCost\\n for j in range(len(s)):\\n cost -= dist[j]\\n if cost < 0:\\n cost += dist[i]\\n i += 1\\n \\n return j-i+1\\n \\n \\n\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n \\n\\n i=0\\n ans=0\\n \\n curr = 0\\n for j in range(0,len(s)):\\n curr = curr + abs(ord(s[j])-ord(t[j]))\\n if curr<=maxCost:\\n ans = max(ans , j-i+1)\\n else:\\n curr = curr - abs(ord(s[i])-ord(t[i])) \\n i=i+1\\n \\n \\n \\n print()\\n return ans\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n #I could first create an array with the cost of each character change\\n\\n currCost = 0\\n maxLength = 0\\n start = 0\\n curr = 0\\n costs = [abs(ord(s[i])- ord(t[i])) for i in range(len(s))]\\n print(costs)\\n while curr < len(costs):\\n currCost += costs[curr]\\n while currCost > maxCost:\\n currCost = currCost - costs[start]\\n start+=1\\n if curr - start + 1 > maxLength:\\n maxLength = curr - start + 1\\n # print(f\\\\\\\"currCost: {currCost}, start: {start}, curr: {curr}\\\\\\\")\\n curr +=1\\n return maxLength\\n\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n if not s: return 0\\n costs = [abs(ord(si)-ord(ti)) for si, ti in zip(s, t)]\\n ans = 0\\n l, r = 0, 0\\n cur_cost = 0\\n print(costs)\\n while l < len(s) and r < len(s):\\n while r < len(s) and cur_cost <= maxCost:\\n cur_cost += costs[r]\\n r += 1\\n ans = max(ans, r-l-1)\\n \\n while l < r and cur_cost > maxCost:\\n cur_cost -= costs[l]\\n l += 1\\n ans = max(ans, r-l)\\n return ans\\n \\n\",\n \"class Solution:\\n def equalSubstring(self, string: str, target: str, maxCost: int) -> int:\\n cost = [0]*len(string)\\n for i in range(len(string)) :\\n if string[i] != target[i] : cost[i] += abs(ord(string[i]) - ord(target[i]))\\n if i > 0 : cost[i]+= cost[i-1]\\n answer = 0\\n s=0\\n for i in range(len(string)) :\\n if cost[i] <= maxCost : answer = max(answer,i+1)\\n else :\\n while s<=i and cost[i]-cost[s]> maxCost: s+=1\\n answer = max(answer,i-s)\\n \\n return answer\\n\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n cost = [abs(ord(s[i])-ord(t[i])) for i in range(len(s))]\\n prefix = [0] # prefix[i] gives us cost[0] + ... + cost[i-1]\\n for i in range(len(cost)):\\n prefix.append(prefix[-1]+cost[i])\\n maxLen = 0\\n i,j = 0,0\\n # print(prefix)\\n while j < len(cost):\\n while j < len(cost) and prefix[j+1]-prefix[i] <= maxCost:\\n j += 1\\n maxLen = max(maxLen,j-i)\\n i += 1\\n # j = i\\n if i > j:\\n j = i\\n return maxLen\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n \\n start = 0\\n ans = 0\\n cur = 0\\n for end in range(len(s)): \\n val = abs(ord(s[end]) - ord(t[end]))\\n cur += val\\n if cur <= maxCost:\\n ans = max(ans, end-start+1)\\n else:\\n while cur > maxCost:\\n cur -= abs(ord(s[start]) - ord(t[start]))\\n start += 1\\n \\n return ans\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n \\n res = 0\\n c = [0]*(len(s)+1)\\n j = 0\\n for i in range(1, len(s)+1):\\n c[i] += c[i-1]+abs(ord(s[i-1])-ord(t[i-1]))\\n \\n while c[i]>maxCost:\\n c[i] -= abs(ord(s[j])-ord(t[j]))\\n j += 1\\n res = max(res, i-j)\\n return res\\n\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n max_length = 0\\n start = 0\\n end = 0\\n cost = 0\\n while end < len(s):\\n c = abs(ord(s[end]) - ord(t[end]))\\n if cost + c <= maxCost:\\n cost += c\\n end += 1\\n else:\\n cost -= abs(ord(s[start]) - ord(t[start]))\\n start += 1\\n max_length = max(max_length, end - start) \\n return max_length \\n\",\n \"class Solution:\\n def equalSubstring(self, s, t, maxCost):\\n n = len(s)\\n right = 0\\n nowSum = 0\\n res = 0\\n for left in range(n):\\n while right <= n - 1 and nowSum + abs(ord(s[right]) - ord(t[right])) <= maxCost: \\n nowSum += abs(ord(s[right]) - ord(t[right]))\\n right += 1\\n res = max(res, right - left)\\n nowSum -= abs(ord(s[left]) - ord(t[left]))\\n return res \",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n cost_array = [abs(a - b) for a, b in zip(map(ord, s), map(ord, t))]\\n left = right = t = 0\\n mx = 0\\n while right < len(cost_array):\\n t += cost_array[right]\\n if t > maxCost:\\n while left < len(cost_array) and t > maxCost:\\n t -= cost_array[left]\\n left += 1\\n\\n right += 1\\n mx = max(mx, right - left)\\n\\n return mx\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n i = 0\\n for j in range(len(s)):\\n maxCost -= abs(ord(s[j]) - ord(t[j]))\\n if maxCost < 0:\\n maxCost += abs(ord(s[i]) - ord(t[i]))\\n i += 1\\n return j - i + 1\\n\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n cost_array = [abs(a - b) for a, b in zip(list(map(ord, s)), list(map(ord, t)))]\\n \\n left = right = t = mx = 0\\n \\n while right < len(cost_array):\\n \\n t += cost_array[right]\\n if t > maxCost:\\n t -= cost_array[left]\\n left += 1\\n\\n right += 1\\n mx = max(mx, right - left)\\n\\n return mx\\n\\n\",\n \"import numpy as np\\n\\nclass Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n #Ss = [ord(c) for c in s]\\n #Tt = [ord(d) for d in t]\\n #diff = np.abs(np.array(Ss)-np.array(Tt))\\n #n = len(s)\\n i = result = 0\\n for j in range(len(s)):\\n maxCost -= abs(ord(s[j])-ord(t[j]))\\n while(maxCost<0):\\n maxCost += abs(ord(s[i])-ord(t[i]))\\n i+=1\\n result = max(result,j-i+1)\\n\\n return result\",\n \"import numpy as np\\n\\nclass Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n #table = np.zeros(len(s))\\n i = result = 0\\n for j in range(len(s)):\\n maxCost -= abs(ord(s[j])-ord(t[j]))\\n while(maxCost<0):\\n maxCost += abs(ord(s[i])-ord(t[i]))\\n i+=1\\n result = max(result,j-i+1)\\n #table[j] = j-i+1\\n return result\\n #return int(max(table))\\n\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n res = curr = i = j = 0\\n while i < len(s) and j < len(s):\\n curr += abs(ord(s[j]) - ord(t[j]))\\n j += 1\\n while curr > maxCost:\\n curr -= abs(ord(s[i]) - ord(t[i]))\\n i += 1\\n res = max(res, j - i)\\n return res\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n currcost=0;i=0;j=0\\n if(len(s)==0):\\n return 0\\n if(len(s)==1):\\n if(abs(ord[s[0]])-ord(t[0])>=maxcost):\\n return 1\\n else:\\n return 0\\n currcost=0\\n ans=0\\n state=False\\n while(i<len(s) and j<len(s)):\\n if(currcost+abs(ord(s[j])-ord(t[j]))<=maxCost):\\n currcost+=abs(ord(s[j])-ord(t[j]))\\n j+=1\\n state=True\\n else:\\n ans=max(ans,j-i)\\n currcost-=abs(ord(s[i])-ord(t[i]))\\n i+=1\\n state=False\\n if(i>=j):\\n j=i\\n currcost=0\\n if state:\\n ans=max(ans,j-i)\\n return ans\\n\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n max_substring = 0\\n curr_substring = 0\\n \\n left = right = diff = 0\\n \\n while right < len(s):\\n local_diff = abs(ord(s[right]) - ord(t[right]))\\n if diff + local_diff <= maxCost:\\n diff += local_diff\\n right += 1\\n curr_substring += 1\\n max_substring = max(curr_substring, max_substring)\\n else:\\n if left == right:\\n right += 1\\n else:\\n diff -= abs(ord(s[left]) - ord(t[left]))\\n curr_substring -= 1\\n left += 1\\n \\n return max_substring\\n\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n \\n arr = [abs(ord(sc) - ord(tc)) for sc, tc in zip(s, t)]\\n max_len = 0\\n left, right = 0, 0\\n curr_sum = 0\\n max_len = 0\\n while(right < len(arr)):\\n curr_sum += arr[right]\\n while(left < len(arr) and curr_sum > maxCost):\\n curr_sum -= arr[left]\\n left += 1\\n max_len = max(max_len, right - left + 1)\\n right += 1\\n return max_len\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n start = 0\\n cost = 0\\n max_len = 0\\n for end in range(len(s)):\\n cost += abs(ord(s[end]) - ord(t[end]))\\n while cost > maxCost:\\n cost -= abs(ord(s[start]) - ord(t[start]))\\n start += 1\\n max_len = max(max_len,end - start + 1)\\n return max_len\\n \\n \\n\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n max_len = head = subtotal = 0\\n for tail in range(len(s)):\\n subtotal += abs(ord(s[tail]) - ord(t[tail]))\\n while subtotal > maxCost:\\n subtotal -= abs(ord(s[head]) - ord(t[head]))\\n head += 1\\n max_len = max(max_len, tail - head + 1)\\n return max_len\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n totalCost = 0\\n maxLength = 0\\n \\n costs = []\\n left = 0\\n length = 0\\n for i in range(len(s)):\\n costs.append(abs(ord(s[i]) - ord(t[i])))\\n totalCost += costs[-1]\\n length += 1\\n \\n if totalCost <= maxCost:\\n maxLength = length if length > maxLength else maxLength\\n else:\\n while totalCost > maxCost:\\n totalCost -= costs[left]\\n left += 1\\n length -= 1\\n \\n return maxLength\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n n = len(s)\\n cost = 0\\n left = 0\\n max_len = 0\\n for right in range(n):\\n cost += abs(ord(s[right]) - ord(t[right]))\\n while cost > maxCost:\\n cost -= abs(ord(s[left]) - ord(t[left]))\\n left += 1\\n max_len = max(max_len, right - left + 1)\\n return max_len\",\n \"import numpy as np\\n\\nclass Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n Ss = [ord(c) for c in s]\\n Tt = [ord(d) for d in t]\\n diff = np.abs(np.array(Ss)-np.array(Tt))\\n n = len(diff)\\n i = result = 0\\n for j in range(n):\\n maxCost -= diff[j]\\n if maxCost<0:\\n maxCost += diff[i]\\n i+=1\\n result = max(result,j-i+1)\\n\\n return result\",\n \"class Solution:\\n def equalSubstring(self, s, t, maxCost):\\n cost = 0\\n ans = 0\\n left, right = 0, -1\\n for s_c, t_c in zip(s, t):\\n right += 1\\n cost += abs(ord(s_c) - ord(t_c))\\n while cost > maxCost:\\n cost -= abs(ord(s[left]) - ord(t[left]))\\n left += 1\\n ans = max(ans, right - left + 1)\\n return ans\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n end = 0\\n result = 0\\n\\n allCost = 0\\n for start in range(len(s)):\\n if start >= 1:\\n allCost -= abs(ord(s[start-1]) - ord(t[start-1]))\\n\\n while (end +1<len(s)+1) and (allCost+ abs(ord(s[end]) - ord(t[end]))<= maxCost):\\n end += 1\\n allCost += abs(ord(s[end-1]) - ord(t[end-1]))\\n\\n\\n result = max(result, end-start)\\n return result\\n\",\n \"import numpy as np\\n\\nclass Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n Ss = [ord(c) for c in s]\\n Tt = [ord(d) for d in t]\\n diff = np.abs(np.array(Ss)-np.array(Tt))\\n n = len(diff)\\n i = result = 0\\n for j in range(n):\\n maxCost -= diff[j]\\n while(maxCost<0):\\n maxCost += diff[i]\\n i+=1\\n result = max(result,j-i+1)\\n\\n return result\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n \\n arr = []\\n lim = len(s)\\n for i in range(0,lim):\\n arr.append(abs(ord(s[i])-ord(t[i])))\\n \\n sm = [arr[0]]\\n \\n for j in range(1,lim):\\n sm.append(sm[-1]+arr[j])\\n \\n \\n l = 0\\n h = lim\\n \\n mx = 0\\n while l<=h:\\n m = (l+h)//2\\n ###print(m)\\n t = 0\\n for i in range(0,lim-m):\\n if sm[i+m]-sm[i]+arr[i]<=maxCost:\\n t = 1\\n break\\n if t==1:\\n if m+1>mx:mx = m+1\\n l = m+1\\n else:\\n h = m-1\\n return mx\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n start = 0\\n end = 0\\n cost = 0\\n best = 0\\n while end < len(s):\\n while end < len(s) and cost + abs(ord(s[end]) - ord(t[end])) <= maxCost:\\n cost += abs(ord(s[end]) - ord(t[end]))\\n end += 1\\n if start == end:\\n start += 1\\n end += 1\\n continue\\n best = max(best, end - start)\\n cost -= abs(ord(s[start]) - ord(t[start]))\\n start += 1\\n return best\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n \\n diff = []\\n for i in range(len(s)):\\n diff.append(abs(ord(s[i])-ord(t[i])))\\n \\n i=0\\n ans=0\\n \\n curr = 0\\n for j in range(0,len(s)):\\n curr = curr + diff[j]\\n if curr<=maxCost:\\n ans = max(ans , j-i+1)\\n else:\\n curr = curr - diff[i] \\n i=i+1\\n return ans\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n ans = 0\\n cost = 0\\n left,right=0,0\\n while right < len(s):\\n cost += abs(ord(s[right])-ord(t[right]))\\n if cost > maxCost:\\n cost -= abs(ord(s[left])-ord(t[left]))\\n left += 1\\n else:\\n ans = max(ans,right-left+1)\\n right += 1\\n return ans\\n \\n\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n #I could first create an array with the cost of each character change\\n\\n currCost = 0\\n maxLength = 0\\n start = 0\\n curr = 0\\n while curr < len(s):\\n currCost += abs(ord(s[curr])- ord(t[curr]))\\n while currCost > maxCost:\\n currCost = currCost - (abs(ord(s[start])- ord(t[start])))\\n start+=1\\n if curr - start + 1 > maxLength:\\n maxLength = curr - start + 1\\n curr +=1\\n return maxLength\\n\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n maxLength = 0\\n currLength = 0\\n currCost = 0\\n \\n for i in range(len(s)):\\n currLength += 1\\n currCost += abs(ord(s[i]) - ord(t[i]))\\n while currCost > maxCost:\\n currCost -= abs(ord(s[i-(currLength-1)]) - ord(t[i-(currLength-1)]))\\n currLength -= 1\\n maxLength = max(maxLength, currLength)\\n \\n return maxLength\\n \\n# Time: O(n)\\n# Space: O(1)\\n\",\n \"class Solution:\\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\\n res = 0\\n i,j = 0,0\\n while j < len(s):\\n maxCost -= abs(ord(t[j]) - ord(s[j]))\\n while maxCost < 0:\\n maxCost += abs(ord(t[i]) - ord(s[i]))\\n i += 1\\n j += 1\\n res = max(res, j -i)\\n return res\"\n]","isConversational":false},"n_sols":{"kind":"number","value":34,"string":"34"},"non_interactive_idx":{"kind":"list like","value":[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],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32,\n 33\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[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],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":66,"cells":{"problem_id":{"kind":"number","value":199,"string":"199"},"question":{"kind":"string","value":"Given an unsorted array of integers, find the length of the longest consecutive elements sequence.\n\nYour algorithm should run in O(n) complexity.\n\nExample:\n\n\nInput: [100, 4, 200, 1, 3, 2]\nOutput: 4\nExplanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4."},"solutions":{"kind":"string","value":"[\"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n longest_streak = 0\\n num_set = set(nums)\\n for num in num_set:\\n if num - 1 not in num_set:\\n current_num = num\\n current_streak = 1\\n \\n while current_num + 1 in num_set:\\n current_num += 1\\n current_streak += 1\\n \\n longest_streak = max(longest_streak, current_streak)\\n return longest_streak\", \"class Solution(object):\\n def radix_sort(self, nums):\\n if not nums:\\n return []\\n n_rounds = 0\\n num_strs = [str(num) for num in nums]\\n n_rounds = max([len(num_str) for num_str in num_strs])\\n buckets = [[] for i in range(10)]\\n for i in range(n_rounds):\\n for num_str in num_strs:\\n if i < len(num_str): # get the last ith digit\\n radix = ord(num_str[-i - 1]) - ord('0')\\n else:\\n radix = 0\\n buckets[radix].append(num_str)\\n num_strs.clear()\\n for bucket in buckets:\\n num_strs.extend(bucket)\\n bucket.clear()\\n return [int(num_str) for num_str in num_strs]\\n \\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n if not nums:\\n return 0\\n pos_nums = [num for num in nums if num >= 0]\\n neg_nums = [-num for num in nums if num < 0]\\n pos_nums = self.radix_sort(pos_nums)\\n neg_nums = self.radix_sort(neg_nums)\\n nums = [-num for num in reversed(neg_nums)] + pos_nums\\n n = 1\\n max_n = 1\\n for i in range(1, len(nums)):\\n if nums[i] - nums[i - 1] == 1:\\n n += 1\\n if n > max_n:\\n max_n = n\\n elif nums[i] == nums[i - 1]:\\n continue\\n else:\\n n = 1\\n return max_n\\n\", \"class Solution:\\n def longestConsecutive(self, a):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n nums = set(a)\\n maxlen = 0\\n \\n while nums:\\n first = last = nums.pop()\\n while first - 1 in nums:\\n first -= 1\\n nums.remove(first)\\n \\n while last + 1 in nums:\\n last += 1\\n nums.remove(last)\\n \\n maxlen = max(maxlen, last - first + 1)\\n \\n return maxlen\\n\", \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n # init dict, set default to 0\\n length_dict = {key: 0 for key in nums}\\n longest = 0\\n \\n for i in nums:\\n #print(\\\"i = \\\"+str(i))\\n if length_dict[i]:\\n #print(\\\"skip \\\"+str(i)) # already done\\n continue\\n \\n length = 1\\n length_dict[i] = 1\\n #print(length_dict)\\n \\n j = i + 1\\n while j in length_dict:\\n #print(\\\"+:\\\"+str(j))\\n length_dict[j] = 1\\n length += 1\\n j += 1\\n \\n j = i - 1\\n while j in length_dict:\\n #print(\\\"-:\\\"+str(j))\\n length_dict[j] = 1\\n length += 1\\n j -= 1\\n \\n longest = max(longest, length)\\n \\n return longest\\n\", \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n if len(nums) == 0:\\n return 0\\n \\n seen = set()\\n heads = set()\\n tails = set()\\n forward = dict()\\n reverse = dict()\\n \\n for n in nums:\\n \\n if n in seen:\\n continue\\n else:\\n seen.add(n)\\n \\n if n-1 not in tails and n+1 not in heads:\\n heads.add(n)\\n tails.add(n)\\n forward[n] = n\\n reverse[n] = n\\n \\n if n-1 not in tails and n+1 in heads:\\n heads.remove(n+1)\\n heads.add(n)\\n tail = forward[n+1]\\n del forward[n+1]\\n forward[n] = tail\\n reverse[tail] = n\\n \\n if n-1 in tails and n+1 not in heads:\\n tails.remove(n-1)\\n tails.add(n)\\n head = reverse[n-1]\\n del reverse[n-1]\\n reverse[n] = head\\n forward[head] = n\\n \\n if n-1 in tails and n+1 in heads:\\n head = reverse[n-1]\\n tail = forward[n+1]\\n heads.remove(n+1)\\n tails.remove(n-1)\\n del forward[n+1]\\n del reverse[n-1]\\n forward[head] = tail\\n reverse[tail] = head\\n \\n \\n diffs = [v - k + 1 for (k,v) in list(forward.items())]\\n maxRun = max(diffs)\\n \\n return maxRun\\n \\n \\n \\n \\n\", \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n flag_map = {}\\n for x in nums:\\n flag_map[x] = False\\n \\n result = 0\\n for x in nums:\\n count = 1\\n tmp = x + 1\\n flag_map[x] = True\\n while True:\\n if tmp in flag_map and not flag_map[tmp]:\\n count = count + 1\\n flag_map[tmp] = True\\n tmp = tmp + 1\\n else:\\n break\\n \\n tmp = x - 1\\n while True:\\n if tmp in flag_map and not flag_map[tmp]:\\n count = count + 1\\n flag_map[tmp] = True\\n tmp = tmp - 1\\n else:\\n break\\n \\n result = max(result, count)\\n \\n return result\", \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n from collections import Counter\\n def find(x,maps):\\n if x in maps:\\n maps[x]=find(maps[x],maps)\\n else:\\n return x\\n return maps[x]\\n def join(x,y,maps):\\n i,j=find(x,maps),find(y,maps)\\n if i!=j:\\n if i<j:\\n maps[j]=i\\n else:\\n maps[i]=j\\n if not nums:\\n return 0\\n visited={}\\n maps={}\\n for i in nums:\\n if i in visited:\\n continue\\n if i not in visited and i-1 in visited:\\n join(i-1,i,maps)\\n if i not in visited and i+1 in visited:\\n join(i+1,i,maps)\\n if i not in visited:\\n visited[i]=1\\n if not maps:\\n return 1\\n for key in list(maps.keys()):\\n join(maps[key],key,maps)\\n d=Counter(list(maps.values()))\\n return max(d.values())+1\\n\", \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n nums = set(nums)\\n best = 0\\n for x in nums:\\n if x - 1 not in nums:\\n y = x + 1\\n while y in nums:\\n y += 1\\n best = max(best, y - x)\\n return best\\n \\n\", \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n s = set(nums)\\n \\n longest = 0\\n for i in s: \\n if(i-1 in s):\\n continue\\n sequence = 1\\n num = i\\n while(num+1 in s):\\n sequence += 1\\n num += 1\\n longest = max(longest, sequence)\\n \\n return longest\", \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n max_count = 0\\n s = set(nums)\\n for i in nums:\\n cnt = 1\\n tmp = i-1\\n while tmp in s:\\n cnt += 1\\n s.discard(tmp)\\n tmp -= 1\\n \\n tmp = i+1\\n while tmp in s:\\n cnt += 1\\n s.discard(tmp)\\n tmp += 1\\n \\n max_count = max(max_count, cnt)\\n \\n return max_count\\n\", \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n if not nums:\\n return 0\\n \\n longest = 1\\n current = 1\\n \\n nums.sort()\\n \\n n = len(nums)\\n for i in range(1, n):\\n if nums[i] != nums[i-1]:\\n if nums[i] == nums[i-1] + 1:\\n current += 1\\n else:\\n longest = max(longest, current)\\n current = 1\\n \\n return max(longest, current)\\n\", \"class Solution(object):\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n if not nums:\\n return 0\\n nums_set = set(nums) # dedup and build a map for fast lookup\\n # remove numbers which are not connected with any other numbers\\n for num in list(nums_set):\\n if (num - 1) not in nums_set and (num + 1) not in nums_set:\\n nums_set.remove(num)\\n \\n # now nums_set only contains groups of consecutive numbers\\n # calculate the size of each group and find the largest group\\n max_group_size = 1\\n while nums_set:\\n num = nums_set.pop()\\n group_size = 1\\n prev_num = num - 1\\n while prev_num in nums_set:\\n group_size += 1\\n nums_set.remove(prev_num)\\n prev_num -= 1\\n next_num = num + 1\\n while next_num in nums_set:\\n group_size += 1\\n nums_set.remove(next_num)\\n next_num += 1\\n if group_size > max_group_size:\\n max_group_size = group_size\\n return max_group_size\\n\", \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n nums.sort()\\n max_length = 0\\n count =0\\n \\n for idx, v in enumerate(nums):\\n \\n if count==0:\\n count+=1\\n max_length=max(max_length,count)\\n if idx+1<len(nums):\\n n_v = nums[idx+1]\\n \\n if n_v==v+1:\\n count=count+1 \\n elif n_v==v:\\n continue\\n \\n \\n else:\\n max_length=max(max_length,count)\\n count = 0\\n #deal with the end \\n max_length=max(max_length,count)\\n return max_length\\n \\n \\n\", \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n def union(uf, p, q):\\n i, j = root(uf, p), root(uf, q)\\n uf[i], uf[j] = min(i, j), min(i, j)\\n def root (uf, p):\\n while p != uf[p]:\\n uf[p] = uf[uf[p]]\\n p = uf[p]\\n return p\\n if len(nums) == 0:\\n return 0\\n ht = {}\\n uf = [i for i in range(len(nums))]\\n for i, n in enumerate(nums):\\n if n not in ht:\\n ht[n] = i\\n else:\\n continue\\n m, o = n - 1, n + 1\\n if m in ht:\\n union(uf, ht[m], i)\\n if o in ht:\\n union(uf, ht[o], i)\\n roots = {}\\n for x in uf:\\n r = root(uf, x)\\n if r in roots:\\n roots[r] += 1\\n else:\\n roots[r] = 1\\n return max(roots.values())\\n\", \"class Solution:\\n \\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n # unique elms in list\\n elms = set()\\n \\n # prevent dup. effort during consecutive search\\n visited = set()\\n max_consecutive = 0\\n \\n for num in nums:\\n \\n elms.add(num)\\n \\n # look for all unique consecutive subsequences\\n for num in nums:\\n \\n if num in visited:\\n \\n continue\\n \\n visited.add(num)\\n \\n # elm by itself\\n curr_consecutive = 1\\n tmp = num - 1\\n \\n # number of consecutive elms before\\n # this elm\\n while tmp in elms:\\n \\n visited.add(tmp)\\n curr_consecutive += 1\\n tmp -= 1\\n \\n tmp = num + 1\\n \\n # number of consecutive elms after\\n # this elm\\n while tmp in elms:\\n \\n visited.add(tmp)\\n curr_consecutive += 1\\n tmp += 1\\n \\n if curr_consecutive > max_consecutive:\\n \\n max_consecutive = curr_consecutive\\n \\n return max_consecutive\\n \\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"longestConsecutive\", \"inputs\": [[[100, 4, 200, 1, 3, 2]]], \"outputs\": [4]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/longest-consecutive-sequence/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def longestConsecutive(self, nums: List[int]) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def longestConsecutive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n longest_streak = 0\n num_set = set(nums)\n for num in num_set:\n if num - 1 not in num_set:\n current_num = num\n current_streak = 1\n \n while current_num + 1 in num_set:\n current_num += 1\n current_streak += 1\n \n longest_streak = max(longest_streak, current_streak)\n return longest_streak","class Solution(object):\n def radix_sort(self, nums):\n if not nums:\n return []\n n_rounds = 0\n num_strs = [str(num) for num in nums]\n n_rounds = max([len(num_str) for num_str in num_strs])\n buckets = [[] for i in range(10)]\n for i in range(n_rounds):\n for num_str in num_strs:\n if i < len(num_str): # get the last ith digit\n radix = ord(num_str[-i - 1]) - ord('0')\n else:\n radix = 0\n buckets[radix].append(num_str)\n num_strs.clear()\n for bucket in buckets:\n num_strs.extend(bucket)\n bucket.clear()\n return [int(num_str) for num_str in num_strs]\n \n def longestConsecutive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n if not nums:\n return 0\n pos_nums = [num for num in nums if num >= 0]\n neg_nums = [-num for num in nums if num < 0]\n pos_nums = self.radix_sort(pos_nums)\n neg_nums = self.radix_sort(neg_nums)\n nums = [-num for num in reversed(neg_nums)] + pos_nums\n n = 1\n max_n = 1\n for i in range(1, len(nums)):\n if nums[i] - nums[i - 1] == 1:\n n += 1\n if n > max_n:\n max_n = n\n elif nums[i] == nums[i - 1]:\n continue\n else:\n n = 1\n return max_n\n","class Solution:\n def longestConsecutive(self, a):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n nums = set(a)\n maxlen = 0\n \n while nums:\n first = last = nums.pop()\n while first - 1 in nums:\n first -= 1\n nums.remove(first)\n \n while last + 1 in nums:\n last += 1\n nums.remove(last)\n \n maxlen = max(maxlen, last - first + 1)\n \n return maxlen\n","class Solution:\n def longestConsecutive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n \n # init dict, set default to 0\n length_dict = {key: 0 for key in nums}\n longest = 0\n \n for i in nums:\n #print(\"i = \"+str(i))\n if length_dict[i]:\n #print(\"skip \"+str(i)) # already done\n continue\n \n length = 1\n length_dict[i] = 1\n #print(length_dict)\n \n j = i + 1\n while j in length_dict:\n #print(\"+:\"+str(j))\n length_dict[j] = 1\n length += 1\n j += 1\n \n j = i - 1\n while j in length_dict:\n #print(\"-:\"+str(j))\n length_dict[j] = 1\n length += 1\n j -= 1\n \n longest = max(longest, length)\n \n return longest\n","class Solution:\n def longestConsecutive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n \n if len(nums) == 0:\n return 0\n \n seen = set()\n heads = set()\n tails = set()\n forward = dict()\n reverse = dict()\n \n for n in nums:\n \n if n in seen:\n continue\n else:\n seen.add(n)\n \n if n-1 not in tails and n+1 not in heads:\n heads.add(n)\n tails.add(n)\n forward[n] = n\n reverse[n] = n\n \n if n-1 not in tails and n+1 in heads:\n heads.remove(n+1)\n heads.add(n)\n tail = forward[n+1]\n del forward[n+1]\n forward[n] = tail\n reverse[tail] = n\n \n if n-1 in tails and n+1 not in heads:\n tails.remove(n-1)\n tails.add(n)\n head = reverse[n-1]\n del reverse[n-1]\n reverse[n] = head\n forward[head] = n\n \n if n-1 in tails and n+1 in heads:\n head = reverse[n-1]\n tail = forward[n+1]\n heads.remove(n+1)\n tails.remove(n-1)\n del forward[n+1]\n del reverse[n-1]\n forward[head] = tail\n reverse[tail] = head\n \n \n diffs = [v - k + 1 for (k,v) in list(forward.items())]\n maxRun = max(diffs)\n \n return maxRun\n \n \n \n \n","class Solution:\n def longestConsecutive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n flag_map = {}\n for x in nums:\n flag_map[x] = False\n \n result = 0\n for x in nums:\n count = 1\n tmp = x + 1\n flag_map[x] = True\n while True:\n if tmp in flag_map and not flag_map[tmp]:\n count = count + 1\n flag_map[tmp] = True\n tmp = tmp + 1\n else:\n break\n \n tmp = x - 1\n while True:\n if tmp in flag_map and not flag_map[tmp]:\n count = count + 1\n flag_map[tmp] = True\n tmp = tmp - 1\n else:\n break\n \n result = max(result, count)\n \n return result","class Solution:\n def longestConsecutive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n from collections import Counter\n def find(x,maps):\n if x in maps:\n maps[x]=find(maps[x],maps)\n else:\n return x\n return maps[x]\n def join(x,y,maps):\n i,j=find(x,maps),find(y,maps)\n if i!=j:\n if i<j:\n maps[j]=i\n else:\n maps[i]=j\n if not nums:\n return 0\n visited={}\n maps={}\n for i in nums:\n if i in visited:\n continue\n if i not in visited and i-1 in visited:\n join(i-1,i,maps)\n if i not in visited and i+1 in visited:\n join(i+1,i,maps)\n if i not in visited:\n visited[i]=1\n if not maps:\n return 1\n for key in list(maps.keys()):\n join(maps[key],key,maps)\n d=Counter(list(maps.values()))\n return max(d.values())+1\n","class Solution:\n def longestConsecutive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n nums = set(nums)\n best = 0\n for x in nums:\n if x - 1 not in nums:\n y = x + 1\n while y in nums:\n y += 1\n best = max(best, y - x)\n return best\n \n","class Solution:\n def longestConsecutive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n s = set(nums)\n \n longest = 0\n for i in s: \n if(i-1 in s):\n continue\n sequence = 1\n num = i\n while(num+1 in s):\n sequence += 1\n num += 1\n longest = max(longest, sequence)\n \n return longest","class Solution:\n def longestConsecutive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n max_count = 0\n s = set(nums)\n for i in nums:\n cnt = 1\n tmp = i-1\n while tmp in s:\n cnt += 1\n s.discard(tmp)\n tmp -= 1\n \n tmp = i+1\n while tmp in s:\n cnt += 1\n s.discard(tmp)\n tmp += 1\n \n max_count = max(max_count, cnt)\n \n return max_count\n","class Solution:\n def longestConsecutive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n if not nums:\n return 0\n \n longest = 1\n current = 1\n \n nums.sort()\n \n n = len(nums)\n for i in range(1, n):\n if nums[i] != nums[i-1]:\n if nums[i] == nums[i-1] + 1:\n current += 1\n else:\n longest = max(longest, current)\n current = 1\n \n return max(longest, current)\n","class Solution(object):\n def longestConsecutive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n if not nums:\n return 0\n nums_set = set(nums) # dedup and build a map for fast lookup\n # remove numbers which are not connected with any other numbers\n for num in list(nums_set):\n if (num - 1) not in nums_set and (num + 1) not in nums_set:\n nums_set.remove(num)\n \n # now nums_set only contains groups of consecutive numbers\n # calculate the size of each group and find the largest group\n max_group_size = 1\n while nums_set:\n num = nums_set.pop()\n group_size = 1\n prev_num = num - 1\n while prev_num in nums_set:\n group_size += 1\n nums_set.remove(prev_num)\n prev_num -= 1\n next_num = num + 1\n while next_num in nums_set:\n group_size += 1\n nums_set.remove(next_num)\n next_num += 1\n if group_size > max_group_size:\n max_group_size = group_size\n return max_group_size\n","class Solution:\n def longestConsecutive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n nums.sort()\n max_length = 0\n count =0\n \n for idx, v in enumerate(nums):\n \n if count==0:\n count+=1\n max_length=max(max_length,count)\n if idx+1<len(nums):\n n_v = nums[idx+1]\n \n if n_v==v+1:\n count=count+1 \n elif n_v==v:\n continue\n \n \n else:\n max_length=max(max_length,count)\n count = 0\n #deal with the end \n max_length=max(max_length,count)\n return max_length\n \n \n","class Solution:\n def longestConsecutive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n def union(uf, p, q):\n i, j = root(uf, p), root(uf, q)\n uf[i], uf[j] = min(i, j), min(i, j)\n def root (uf, p):\n while p != uf[p]:\n uf[p] = uf[uf[p]]\n p = uf[p]\n return p\n if len(nums) == 0:\n return 0\n ht = {}\n uf = [i for i in range(len(nums))]\n for i, n in enumerate(nums):\n if n not in ht:\n ht[n] = i\n else:\n continue\n m, o = n - 1, n + 1\n if m in ht:\n union(uf, ht[m], i)\n if o in ht:\n union(uf, ht[o], i)\n roots = {}\n for x in uf:\n r = root(uf, x)\n if r in roots:\n roots[r] += 1\n else:\n roots[r] = 1\n return max(roots.values())\n","class Solution:\n \n def longestConsecutive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n \n # unique elms in list\n elms = set()\n \n # prevent dup. effort during consecutive search\n visited = set()\n max_consecutive = 0\n \n for num in nums:\n \n elms.add(num)\n \n # look for all unique consecutive subsequences\n for num in nums:\n \n if num in visited:\n \n continue\n \n visited.add(num)\n \n # elm by itself\n curr_consecutive = 1\n tmp = num - 1\n \n # number of consecutive elms before\n # this elm\n while tmp in elms:\n \n visited.add(tmp)\n curr_consecutive += 1\n tmp -= 1\n \n tmp = num + 1\n \n # number of consecutive elms after\n # this elm\n while tmp in elms:\n \n visited.add(tmp)\n curr_consecutive += 1\n tmp += 1\n \n if curr_consecutive > max_consecutive:\n \n max_consecutive = curr_consecutive\n \n return max_consecutive\n \n"],"string":"[\n \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n longest_streak = 0\\n num_set = set(nums)\\n for num in num_set:\\n if num - 1 not in num_set:\\n current_num = num\\n current_streak = 1\\n \\n while current_num + 1 in num_set:\\n current_num += 1\\n current_streak += 1\\n \\n longest_streak = max(longest_streak, current_streak)\\n return longest_streak\",\n \"class Solution(object):\\n def radix_sort(self, nums):\\n if not nums:\\n return []\\n n_rounds = 0\\n num_strs = [str(num) for num in nums]\\n n_rounds = max([len(num_str) for num_str in num_strs])\\n buckets = [[] for i in range(10)]\\n for i in range(n_rounds):\\n for num_str in num_strs:\\n if i < len(num_str): # get the last ith digit\\n radix = ord(num_str[-i - 1]) - ord('0')\\n else:\\n radix = 0\\n buckets[radix].append(num_str)\\n num_strs.clear()\\n for bucket in buckets:\\n num_strs.extend(bucket)\\n bucket.clear()\\n return [int(num_str) for num_str in num_strs]\\n \\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n if not nums:\\n return 0\\n pos_nums = [num for num in nums if num >= 0]\\n neg_nums = [-num for num in nums if num < 0]\\n pos_nums = self.radix_sort(pos_nums)\\n neg_nums = self.radix_sort(neg_nums)\\n nums = [-num for num in reversed(neg_nums)] + pos_nums\\n n = 1\\n max_n = 1\\n for i in range(1, len(nums)):\\n if nums[i] - nums[i - 1] == 1:\\n n += 1\\n if n > max_n:\\n max_n = n\\n elif nums[i] == nums[i - 1]:\\n continue\\n else:\\n n = 1\\n return max_n\\n\",\n \"class Solution:\\n def longestConsecutive(self, a):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n nums = set(a)\\n maxlen = 0\\n \\n while nums:\\n first = last = nums.pop()\\n while first - 1 in nums:\\n first -= 1\\n nums.remove(first)\\n \\n while last + 1 in nums:\\n last += 1\\n nums.remove(last)\\n \\n maxlen = max(maxlen, last - first + 1)\\n \\n return maxlen\\n\",\n \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n # init dict, set default to 0\\n length_dict = {key: 0 for key in nums}\\n longest = 0\\n \\n for i in nums:\\n #print(\\\"i = \\\"+str(i))\\n if length_dict[i]:\\n #print(\\\"skip \\\"+str(i)) # already done\\n continue\\n \\n length = 1\\n length_dict[i] = 1\\n #print(length_dict)\\n \\n j = i + 1\\n while j in length_dict:\\n #print(\\\"+:\\\"+str(j))\\n length_dict[j] = 1\\n length += 1\\n j += 1\\n \\n j = i - 1\\n while j in length_dict:\\n #print(\\\"-:\\\"+str(j))\\n length_dict[j] = 1\\n length += 1\\n j -= 1\\n \\n longest = max(longest, length)\\n \\n return longest\\n\",\n \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n if len(nums) == 0:\\n return 0\\n \\n seen = set()\\n heads = set()\\n tails = set()\\n forward = dict()\\n reverse = dict()\\n \\n for n in nums:\\n \\n if n in seen:\\n continue\\n else:\\n seen.add(n)\\n \\n if n-1 not in tails and n+1 not in heads:\\n heads.add(n)\\n tails.add(n)\\n forward[n] = n\\n reverse[n] = n\\n \\n if n-1 not in tails and n+1 in heads:\\n heads.remove(n+1)\\n heads.add(n)\\n tail = forward[n+1]\\n del forward[n+1]\\n forward[n] = tail\\n reverse[tail] = n\\n \\n if n-1 in tails and n+1 not in heads:\\n tails.remove(n-1)\\n tails.add(n)\\n head = reverse[n-1]\\n del reverse[n-1]\\n reverse[n] = head\\n forward[head] = n\\n \\n if n-1 in tails and n+1 in heads:\\n head = reverse[n-1]\\n tail = forward[n+1]\\n heads.remove(n+1)\\n tails.remove(n-1)\\n del forward[n+1]\\n del reverse[n-1]\\n forward[head] = tail\\n reverse[tail] = head\\n \\n \\n diffs = [v - k + 1 for (k,v) in list(forward.items())]\\n maxRun = max(diffs)\\n \\n return maxRun\\n \\n \\n \\n \\n\",\n \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n flag_map = {}\\n for x in nums:\\n flag_map[x] = False\\n \\n result = 0\\n for x in nums:\\n count = 1\\n tmp = x + 1\\n flag_map[x] = True\\n while True:\\n if tmp in flag_map and not flag_map[tmp]:\\n count = count + 1\\n flag_map[tmp] = True\\n tmp = tmp + 1\\n else:\\n break\\n \\n tmp = x - 1\\n while True:\\n if tmp in flag_map and not flag_map[tmp]:\\n count = count + 1\\n flag_map[tmp] = True\\n tmp = tmp - 1\\n else:\\n break\\n \\n result = max(result, count)\\n \\n return result\",\n \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n from collections import Counter\\n def find(x,maps):\\n if x in maps:\\n maps[x]=find(maps[x],maps)\\n else:\\n return x\\n return maps[x]\\n def join(x,y,maps):\\n i,j=find(x,maps),find(y,maps)\\n if i!=j:\\n if i<j:\\n maps[j]=i\\n else:\\n maps[i]=j\\n if not nums:\\n return 0\\n visited={}\\n maps={}\\n for i in nums:\\n if i in visited:\\n continue\\n if i not in visited and i-1 in visited:\\n join(i-1,i,maps)\\n if i not in visited and i+1 in visited:\\n join(i+1,i,maps)\\n if i not in visited:\\n visited[i]=1\\n if not maps:\\n return 1\\n for key in list(maps.keys()):\\n join(maps[key],key,maps)\\n d=Counter(list(maps.values()))\\n return max(d.values())+1\\n\",\n \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n nums = set(nums)\\n best = 0\\n for x in nums:\\n if x - 1 not in nums:\\n y = x + 1\\n while y in nums:\\n y += 1\\n best = max(best, y - x)\\n return best\\n \\n\",\n \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n s = set(nums)\\n \\n longest = 0\\n for i in s: \\n if(i-1 in s):\\n continue\\n sequence = 1\\n num = i\\n while(num+1 in s):\\n sequence += 1\\n num += 1\\n longest = max(longest, sequence)\\n \\n return longest\",\n \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n max_count = 0\\n s = set(nums)\\n for i in nums:\\n cnt = 1\\n tmp = i-1\\n while tmp in s:\\n cnt += 1\\n s.discard(tmp)\\n tmp -= 1\\n \\n tmp = i+1\\n while tmp in s:\\n cnt += 1\\n s.discard(tmp)\\n tmp += 1\\n \\n max_count = max(max_count, cnt)\\n \\n return max_count\\n\",\n \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n if not nums:\\n return 0\\n \\n longest = 1\\n current = 1\\n \\n nums.sort()\\n \\n n = len(nums)\\n for i in range(1, n):\\n if nums[i] != nums[i-1]:\\n if nums[i] == nums[i-1] + 1:\\n current += 1\\n else:\\n longest = max(longest, current)\\n current = 1\\n \\n return max(longest, current)\\n\",\n \"class Solution(object):\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n if not nums:\\n return 0\\n nums_set = set(nums) # dedup and build a map for fast lookup\\n # remove numbers which are not connected with any other numbers\\n for num in list(nums_set):\\n if (num - 1) not in nums_set and (num + 1) not in nums_set:\\n nums_set.remove(num)\\n \\n # now nums_set only contains groups of consecutive numbers\\n # calculate the size of each group and find the largest group\\n max_group_size = 1\\n while nums_set:\\n num = nums_set.pop()\\n group_size = 1\\n prev_num = num - 1\\n while prev_num in nums_set:\\n group_size += 1\\n nums_set.remove(prev_num)\\n prev_num -= 1\\n next_num = num + 1\\n while next_num in nums_set:\\n group_size += 1\\n nums_set.remove(next_num)\\n next_num += 1\\n if group_size > max_group_size:\\n max_group_size = group_size\\n return max_group_size\\n\",\n \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n nums.sort()\\n max_length = 0\\n count =0\\n \\n for idx, v in enumerate(nums):\\n \\n if count==0:\\n count+=1\\n max_length=max(max_length,count)\\n if idx+1<len(nums):\\n n_v = nums[idx+1]\\n \\n if n_v==v+1:\\n count=count+1 \\n elif n_v==v:\\n continue\\n \\n \\n else:\\n max_length=max(max_length,count)\\n count = 0\\n #deal with the end \\n max_length=max(max_length,count)\\n return max_length\\n \\n \\n\",\n \"class Solution:\\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n def union(uf, p, q):\\n i, j = root(uf, p), root(uf, q)\\n uf[i], uf[j] = min(i, j), min(i, j)\\n def root (uf, p):\\n while p != uf[p]:\\n uf[p] = uf[uf[p]]\\n p = uf[p]\\n return p\\n if len(nums) == 0:\\n return 0\\n ht = {}\\n uf = [i for i in range(len(nums))]\\n for i, n in enumerate(nums):\\n if n not in ht:\\n ht[n] = i\\n else:\\n continue\\n m, o = n - 1, n + 1\\n if m in ht:\\n union(uf, ht[m], i)\\n if o in ht:\\n union(uf, ht[o], i)\\n roots = {}\\n for x in uf:\\n r = root(uf, x)\\n if r in roots:\\n roots[r] += 1\\n else:\\n roots[r] = 1\\n return max(roots.values())\\n\",\n \"class Solution:\\n \\n def longestConsecutive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n # unique elms in list\\n elms = set()\\n \\n # prevent dup. effort during consecutive search\\n visited = set()\\n max_consecutive = 0\\n \\n for num in nums:\\n \\n elms.add(num)\\n \\n # look for all unique consecutive subsequences\\n for num in nums:\\n \\n if num in visited:\\n \\n continue\\n \\n visited.add(num)\\n \\n # elm by itself\\n curr_consecutive = 1\\n tmp = num - 1\\n \\n # number of consecutive elms before\\n # this elm\\n while tmp in elms:\\n \\n visited.add(tmp)\\n curr_consecutive += 1\\n tmp -= 1\\n \\n tmp = num + 1\\n \\n # number of consecutive elms after\\n # this elm\\n while tmp in elms:\\n \\n visited.add(tmp)\\n curr_consecutive += 1\\n tmp += 1\\n \\n if curr_consecutive > max_consecutive:\\n \\n max_consecutive = curr_consecutive\\n \\n return max_consecutive\\n \\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":15,"string":"15"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":67,"cells":{"problem_id":{"kind":"number","value":200,"string":"200"},"question":{"kind":"string","value":"Given an integer k, return the minimum number of Fibonacci numbers whose sum is equal to k. The same Fibonacci number can be used multiple times.\nThe Fibonacci numbers are defined as:\n\nF1 = 1\nF2 = 1\nFn = Fn-1 + Fn-2 for n > 2.\n\nIt is guaranteed that for the given constraints we can always find such Fibonacci numbers that sum up to k.\n \nExample 1:\nInput: k = 7\nOutput: 2 \nExplanation: The Fibonacci numbers are: 1, 1, 2, 3, 5, 8, 13, ... \nFor k = 7 we can use 2 + 5 = 7.\nExample 2:\nInput: k = 10\nOutput: 2 \nExplanation: For k = 10 we can use 2 + 8 = 10.\n\nExample 3:\nInput: k = 19\nOutput: 3 \nExplanation: For k = 19 we can use 1 + 5 + 13 = 19.\n\n \nConstraints:\n\n1 <= k <= 10^9"},"solutions":{"kind":"string","value":"[\"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n fib = [1, 1] # initializing a Fibonacci table with F[0] and F[1]\\n i = 1 # index that will represent the last filled index of table\\n temp = fib[0] + fib[1] # initial value of values to be appended\\n while temp < k: # we keep filling table until temp >= k\\n fib.append(temp) # add the current value to the table\\n i += 1 # increase i by 1 to keep track of the last filled index\\n temp = fib[i] + fib[i-1] # calculate new temp\\n fib.append(temp) # to cover case temp == k, we append the last value >= k\\n \\n ans = 0 # initializing answer value with 0\\n j = -1 # placeholder to represent last checked Fibonacci table index\\n while k > 0: # keep repeating until k <= 0\\n temp = fib[j] # get the biggest number available \\n j -= 1 # decrease j by 1 since we tried the last number\\n \\n if temp <= k:\\n ans+=1\\n k-=temp\\n \\n return ans\", \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n a = b = 1\\n fibo = [a,b]\\n \\n res = 0\\n while a + b <= k:\\n fibo.append(a + b)\\n a, b = b, a+b\\n for i in fibo[::-1]:\\n if k >= i:\\n k -= i\\n res +=1\\n return res\\n \\n \\n \\n\", \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n f = []\\n f.append(1)\\n f.append(1)\\n while 1:\\n if max(f) <= k:\\n f.append(f[len(f)-1] + f[len(f)-2])\\n else:\\n break\\n f.remove(f[len(f)-1])\\n\\n number = 0\\n while k != 0:\\n if f[len(f)-1] <= k:\\n k -= f[len(f)-1]\\n f.remove(max(f))\\n number += 1\\n else:\\n f.remove(max(f))\\n\\n return number\", \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n first = 1\\n second = 1\\n \\n fib = []\\n \\n i = 0\\n while True:\\n if i == 0:\\n fib.append(1)\\n elif i == 1:\\n fib.append(1)\\n else:\\n val = fib[i - 1] + fib[i - 2]\\n if val > k: break\\n fib.append(val)\\n i += 1\\n print(fib)\\n accum = 0\\n ct = 0\\n for i in range(len(fib) - 1, -1 , -1):\\n accum += fib[i]\\n if accum == k:\\n ct += 1\\n break\\n elif accum > k:\\n accum -= fib[i]\\n else:\\n ct += 1\\n return ct\", \"\\nclass Solution:\\n \\n def findMinFibonacciNumbers(self, k: int) -> int:\\n grid = [1,1]\\n last = 1\\n while last < k:\\n target = grid[-1] + grid[-2]\\n if target > k: break\\n else:\\n grid.append(grid[-1] + grid[-2])\\n last = grid[-1]\\n res = 0\\n ends = len(grid)-1\\n while k > 0:\\n while grid[ends] > k: ends -= 1\\n k -= grid[ends]\\n ends -= 1\\n res += 1\\n return res\\n\", \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n if k < 2:\\n return k\\n f1, f2 = 1, 1\\n while f2 <= k:\\n f1, f2 = f2, f1 + f2\\n t = 0\\n while k:\\n # print(f1, f2, k, t)\\n if f2 <= k:\\n k -= f2\\n t += 1\\n else:\\n f1, f2 = f2 - f1, f1\\n return t\\n\", \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n \\n a,b = 1,1\\n while b<=k:\\n a,b = b, a+b\\n \\n res = 0\\n while a > 0:\\n if k >= a:\\n k -= a\\n res += 1\\n a,b = b-a, a \\n \\n \\n return res\\n \\n \\n \\n \\n# if k == 0:\\n# return 0\\n \\n# a,b = 1, 1\\n# while b <= k: # O( (logk)^2 ) \\n# a,b = b, a+b\\n# return self.findMinFibonacciNumbers(k-a)+1\\n \\n # First recursion, logk. Second resursion logK - 1, third entry logK - 2.\\n \\n \\n# arr = [1, 1]\\n# while arr[-1] <= k:\\n# arr.append( arr[-1]+arr[-2] ) # O(n) space\\n \\n# d = k-arr[-2]\\n \\n# cnt = 1\\n \\n# while d > 0:\\n# ind = bisect.bisect_right(arr, d) # O(n log n) \\n# d -= arr[ind-1]\\n# cnt += 1\\n \\n# return cnt\\n \\n\", \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n fibo=[]\\n fibo.append(1)\\n fibo.append(1)\\n lenn=2\\n while fibo[-1]<=k:\\n fibo.append(fibo[lenn-1]+fibo[lenn-2])\\n lenn+=1\\n \\n nums=k\\n cnt=0\\n for i in range(len(fibo)-1, -1, -1):\\n while nums>=fibo[i]:\\n nums-=fibo[i]\\n cnt+=1\\n if nums==0:\\n break\\n return cnt\", \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n \\n if k == 0:\\n return 0\\n \\n a,b = 1, 1\\n while b <= k:\\n a,b = b, a+b\\n return self.findMinFibonacciNumbers(k-a)+1\\n \\n \\n# arr = [1, 1]\\n# while arr[-1] <= k:\\n# arr.append( arr[-1]+arr[-2] ) # O(n) space\\n \\n# d = k-arr[-2]\\n \\n# cnt = 1\\n \\n# while d > 0:\\n# ind = bisect.bisect_right(arr, d) # O(n log n) \\n# d -= arr[ind-1]\\n# cnt += 1\\n \\n# return cnt\\n \\n\", \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n count=0\\n while(k>=0):\\n arr=[]\\n arr.append(1)\\n arr.append(1)\\n while(arr[-1]+arr[-2]<=k):\\n arr.append(arr[-1]+arr[-2])\\n \\n k-=arr[-1]\\n count+=1\\n \\n return count-1\", \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n fib = [1,1]\\n while(fib[-1]<k):\\n fib.append(fib[-1]+fib[-2])\\n print(fib)\\n if k in fib:\\n return 1\\n cnt =0\\n for i in range(len(fib)-1,-1,-1):\\n print(('cnt ',cnt,'i ',i, fib[i],'k ',k))\\n if fib[i]<=k:\\n k = k-fib[i]\\n cnt+=1\\n if k==0:\\n break\\n return cnt\\n \\n \\n\", \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n fib = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610,\\n 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, \\n 75025, 121393, 196418, 317811, 514229, 832040, 1346269, \\n 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, \\n 39088169, 63245986, 102334155, 165580141, 267914296, \\n 433494437, 701408733]\\n ans = 0\\n j= -1\\n while k>0:\\n tmp = fib[j]\\n j-=1\\n if tmp<=k:\\n ans+=1\\n k-=tmp\\n return ans\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"findMinFibonacciNumbers\", \"inputs\": [[7]], \"outputs\": [2]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def findMinFibonacciNumbers(self, k: int) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def findMinFibonacciNumbers(self, k: int) -> int:\n fib = [1, 1] # initializing a Fibonacci table with F[0] and F[1]\n i = 1 # index that will represent the last filled index of table\n temp = fib[0] + fib[1] # initial value of values to be appended\n while temp < k: # we keep filling table until temp >= k\n fib.append(temp) # add the current value to the table\n i += 1 # increase i by 1 to keep track of the last filled index\n temp = fib[i] + fib[i-1] # calculate new temp\n fib.append(temp) # to cover case temp == k, we append the last value >= k\n \n ans = 0 # initializing answer value with 0\n j = -1 # placeholder to represent last checked Fibonacci table index\n while k > 0: # keep repeating until k <= 0\n temp = fib[j] # get the biggest number available \n j -= 1 # decrease j by 1 since we tried the last number\n \n if temp <= k:\n ans+=1\n k-=temp\n \n return ans","class Solution:\n def findMinFibonacciNumbers(self, k: int) -> int:\n a = b = 1\n fibo = [a,b]\n \n res = 0\n while a + b <= k:\n fibo.append(a + b)\n a, b = b, a+b\n for i in fibo[::-1]:\n if k >= i:\n k -= i\n res +=1\n return res\n \n \n \n","class Solution:\n def findMinFibonacciNumbers(self, k: int) -> int:\n f = []\n f.append(1)\n f.append(1)\n while 1:\n if max(f) <= k:\n f.append(f[len(f)-1] + f[len(f)-2])\n else:\n break\n f.remove(f[len(f)-1])\n\n number = 0\n while k != 0:\n if f[len(f)-1] <= k:\n k -= f[len(f)-1]\n f.remove(max(f))\n number += 1\n else:\n f.remove(max(f))\n\n return number","class Solution:\n def findMinFibonacciNumbers(self, k: int) -> int:\n first = 1\n second = 1\n \n fib = []\n \n i = 0\n while True:\n if i == 0:\n fib.append(1)\n elif i == 1:\n fib.append(1)\n else:\n val = fib[i - 1] + fib[i - 2]\n if val > k: break\n fib.append(val)\n i += 1\n print(fib)\n accum = 0\n ct = 0\n for i in range(len(fib) - 1, -1 , -1):\n accum += fib[i]\n if accum == k:\n ct += 1\n break\n elif accum > k:\n accum -= fib[i]\n else:\n ct += 1\n return ct","\nclass Solution:\n \n def findMinFibonacciNumbers(self, k: int) -> int:\n grid = [1,1]\n last = 1\n while last < k:\n target = grid[-1] + grid[-2]\n if target > k: break\n else:\n grid.append(grid[-1] + grid[-2])\n last = grid[-1]\n res = 0\n ends = len(grid)-1\n while k > 0:\n while grid[ends] > k: ends -= 1\n k -= grid[ends]\n ends -= 1\n res += 1\n return res\n","class Solution:\n def findMinFibonacciNumbers(self, k: int) -> int:\n if k < 2:\n return k\n f1, f2 = 1, 1\n while f2 <= k:\n f1, f2 = f2, f1 + f2\n t = 0\n while k:\n # print(f1, f2, k, t)\n if f2 <= k:\n k -= f2\n t += 1\n else:\n f1, f2 = f2 - f1, f1\n return t\n","class Solution:\n def findMinFibonacciNumbers(self, k: int) -> int:\n \n a,b = 1,1\n while b<=k:\n a,b = b, a+b\n \n res = 0\n while a > 0:\n if k >= a:\n k -= a\n res += 1\n a,b = b-a, a \n \n \n return res\n \n \n \n \n# if k == 0:\n# return 0\n \n# a,b = 1, 1\n# while b <= k: # O( (logk)^2 ) \n# a,b = b, a+b\n# return self.findMinFibonacciNumbers(k-a)+1\n \n # First recursion, logk. Second resursion logK - 1, third entry logK - 2.\n \n \n# arr = [1, 1]\n# while arr[-1] <= k:\n# arr.append( arr[-1]+arr[-2] ) # O(n) space\n \n# d = k-arr[-2]\n \n# cnt = 1\n \n# while d > 0:\n# ind = bisect.bisect_right(arr, d) # O(n log n) \n# d -= arr[ind-1]\n# cnt += 1\n \n# return cnt\n \n","class Solution:\n def findMinFibonacciNumbers(self, k: int) -> int:\n fibo=[]\n fibo.append(1)\n fibo.append(1)\n lenn=2\n while fibo[-1]<=k:\n fibo.append(fibo[lenn-1]+fibo[lenn-2])\n lenn+=1\n \n nums=k\n cnt=0\n for i in range(len(fibo)-1, -1, -1):\n while nums>=fibo[i]:\n nums-=fibo[i]\n cnt+=1\n if nums==0:\n break\n return cnt","class Solution:\n def findMinFibonacciNumbers(self, k: int) -> int:\n \n if k == 0:\n return 0\n \n a,b = 1, 1\n while b <= k:\n a,b = b, a+b\n return self.findMinFibonacciNumbers(k-a)+1\n \n \n# arr = [1, 1]\n# while arr[-1] <= k:\n# arr.append( arr[-1]+arr[-2] ) # O(n) space\n \n# d = k-arr[-2]\n \n# cnt = 1\n \n# while d > 0:\n# ind = bisect.bisect_right(arr, d) # O(n log n) \n# d -= arr[ind-1]\n# cnt += 1\n \n# return cnt\n \n","class Solution:\n def findMinFibonacciNumbers(self, k: int) -> int:\n count=0\n while(k>=0):\n arr=[]\n arr.append(1)\n arr.append(1)\n while(arr[-1]+arr[-2]<=k):\n arr.append(arr[-1]+arr[-2])\n \n k-=arr[-1]\n count+=1\n \n return count-1","class Solution:\n def findMinFibonacciNumbers(self, k: int) -> int:\n fib = [1,1]\n while(fib[-1]<k):\n fib.append(fib[-1]+fib[-2])\n print(fib)\n if k in fib:\n return 1\n cnt =0\n for i in range(len(fib)-1,-1,-1):\n print(('cnt ',cnt,'i ',i, fib[i],'k ',k))\n if fib[i]<=k:\n k = k-fib[i]\n cnt+=1\n if k==0:\n break\n return cnt\n \n \n","class Solution:\n def findMinFibonacciNumbers(self, k: int) -> int:\n fib = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610,\n 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, \n 75025, 121393, 196418, 317811, 514229, 832040, 1346269, \n 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, \n 39088169, 63245986, 102334155, 165580141, 267914296, \n 433494437, 701408733]\n ans = 0\n j= -1\n while k>0:\n tmp = fib[j]\n j-=1\n if tmp<=k:\n ans+=1\n k-=tmp\n return ans"],"string":"[\n \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n fib = [1, 1] # initializing a Fibonacci table with F[0] and F[1]\\n i = 1 # index that will represent the last filled index of table\\n temp = fib[0] + fib[1] # initial value of values to be appended\\n while temp < k: # we keep filling table until temp >= k\\n fib.append(temp) # add the current value to the table\\n i += 1 # increase i by 1 to keep track of the last filled index\\n temp = fib[i] + fib[i-1] # calculate new temp\\n fib.append(temp) # to cover case temp == k, we append the last value >= k\\n \\n ans = 0 # initializing answer value with 0\\n j = -1 # placeholder to represent last checked Fibonacci table index\\n while k > 0: # keep repeating until k <= 0\\n temp = fib[j] # get the biggest number available \\n j -= 1 # decrease j by 1 since we tried the last number\\n \\n if temp <= k:\\n ans+=1\\n k-=temp\\n \\n return ans\",\n \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n a = b = 1\\n fibo = [a,b]\\n \\n res = 0\\n while a + b <= k:\\n fibo.append(a + b)\\n a, b = b, a+b\\n for i in fibo[::-1]:\\n if k >= i:\\n k -= i\\n res +=1\\n return res\\n \\n \\n \\n\",\n \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n f = []\\n f.append(1)\\n f.append(1)\\n while 1:\\n if max(f) <= k:\\n f.append(f[len(f)-1] + f[len(f)-2])\\n else:\\n break\\n f.remove(f[len(f)-1])\\n\\n number = 0\\n while k != 0:\\n if f[len(f)-1] <= k:\\n k -= f[len(f)-1]\\n f.remove(max(f))\\n number += 1\\n else:\\n f.remove(max(f))\\n\\n return number\",\n \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n first = 1\\n second = 1\\n \\n fib = []\\n \\n i = 0\\n while True:\\n if i == 0:\\n fib.append(1)\\n elif i == 1:\\n fib.append(1)\\n else:\\n val = fib[i - 1] + fib[i - 2]\\n if val > k: break\\n fib.append(val)\\n i += 1\\n print(fib)\\n accum = 0\\n ct = 0\\n for i in range(len(fib) - 1, -1 , -1):\\n accum += fib[i]\\n if accum == k:\\n ct += 1\\n break\\n elif accum > k:\\n accum -= fib[i]\\n else:\\n ct += 1\\n return ct\",\n \"\\nclass Solution:\\n \\n def findMinFibonacciNumbers(self, k: int) -> int:\\n grid = [1,1]\\n last = 1\\n while last < k:\\n target = grid[-1] + grid[-2]\\n if target > k: break\\n else:\\n grid.append(grid[-1] + grid[-2])\\n last = grid[-1]\\n res = 0\\n ends = len(grid)-1\\n while k > 0:\\n while grid[ends] > k: ends -= 1\\n k -= grid[ends]\\n ends -= 1\\n res += 1\\n return res\\n\",\n \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n if k < 2:\\n return k\\n f1, f2 = 1, 1\\n while f2 <= k:\\n f1, f2 = f2, f1 + f2\\n t = 0\\n while k:\\n # print(f1, f2, k, t)\\n if f2 <= k:\\n k -= f2\\n t += 1\\n else:\\n f1, f2 = f2 - f1, f1\\n return t\\n\",\n \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n \\n a,b = 1,1\\n while b<=k:\\n a,b = b, a+b\\n \\n res = 0\\n while a > 0:\\n if k >= a:\\n k -= a\\n res += 1\\n a,b = b-a, a \\n \\n \\n return res\\n \\n \\n \\n \\n# if k == 0:\\n# return 0\\n \\n# a,b = 1, 1\\n# while b <= k: # O( (logk)^2 ) \\n# a,b = b, a+b\\n# return self.findMinFibonacciNumbers(k-a)+1\\n \\n # First recursion, logk. Second resursion logK - 1, third entry logK - 2.\\n \\n \\n# arr = [1, 1]\\n# while arr[-1] <= k:\\n# arr.append( arr[-1]+arr[-2] ) # O(n) space\\n \\n# d = k-arr[-2]\\n \\n# cnt = 1\\n \\n# while d > 0:\\n# ind = bisect.bisect_right(arr, d) # O(n log n) \\n# d -= arr[ind-1]\\n# cnt += 1\\n \\n# return cnt\\n \\n\",\n \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n fibo=[]\\n fibo.append(1)\\n fibo.append(1)\\n lenn=2\\n while fibo[-1]<=k:\\n fibo.append(fibo[lenn-1]+fibo[lenn-2])\\n lenn+=1\\n \\n nums=k\\n cnt=0\\n for i in range(len(fibo)-1, -1, -1):\\n while nums>=fibo[i]:\\n nums-=fibo[i]\\n cnt+=1\\n if nums==0:\\n break\\n return cnt\",\n \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n \\n if k == 0:\\n return 0\\n \\n a,b = 1, 1\\n while b <= k:\\n a,b = b, a+b\\n return self.findMinFibonacciNumbers(k-a)+1\\n \\n \\n# arr = [1, 1]\\n# while arr[-1] <= k:\\n# arr.append( arr[-1]+arr[-2] ) # O(n) space\\n \\n# d = k-arr[-2]\\n \\n# cnt = 1\\n \\n# while d > 0:\\n# ind = bisect.bisect_right(arr, d) # O(n log n) \\n# d -= arr[ind-1]\\n# cnt += 1\\n \\n# return cnt\\n \\n\",\n \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n count=0\\n while(k>=0):\\n arr=[]\\n arr.append(1)\\n arr.append(1)\\n while(arr[-1]+arr[-2]<=k):\\n arr.append(arr[-1]+arr[-2])\\n \\n k-=arr[-1]\\n count+=1\\n \\n return count-1\",\n \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n fib = [1,1]\\n while(fib[-1]<k):\\n fib.append(fib[-1]+fib[-2])\\n print(fib)\\n if k in fib:\\n return 1\\n cnt =0\\n for i in range(len(fib)-1,-1,-1):\\n print(('cnt ',cnt,'i ',i, fib[i],'k ',k))\\n if fib[i]<=k:\\n k = k-fib[i]\\n cnt+=1\\n if k==0:\\n break\\n return cnt\\n \\n \\n\",\n \"class Solution:\\n def findMinFibonacciNumbers(self, k: int) -> int:\\n fib = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610,\\n 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, \\n 75025, 121393, 196418, 317811, 514229, 832040, 1346269, \\n 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, \\n 39088169, 63245986, 102334155, 165580141, 267914296, \\n 433494437, 701408733]\\n ans = 0\\n j= -1\\n while k>0:\\n tmp = fib[j]\\n j-=1\\n if tmp<=k:\\n ans+=1\\n k-=tmp\\n return ans\"\n]","isConversational":false},"n_sols":{"kind":"number","value":12,"string":"12"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4,5,6,7,8,9,10,11],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null,null,null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":68,"cells":{"problem_id":{"kind":"number","value":201,"string":"201"},"question":{"kind":"string","value":"Given n, how many structurally unique BST's (binary search trees) that store values 1 ... n?\n\nExample:\n\n\nInput: 3\nOutput: 5\nExplanation:\nGiven n = 3, there are a total of 5 unique BST's:\n\n 1 3 3 2 1\n \\ / / / \\ \\\n 3 2 1 1 3 2\n / / \\ \\\n 2 1 2 3"},"solutions":{"kind":"string","value":"[\"class Solution:\\n hash = {}\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n # return base case\\n if n == 0:\\n return 1\\n if n == 1 or n == 2:\\n return n\\n \\n # try fetching from hash\\n try:\\n return self.hash[n]\\n except KeyError:\\n pass\\n \\n # holds the sum\\n resSum = 0\\n \\n # iterate i from 1 to n-1\\n # should add up (0,4), (1,3), (2,2), (3,1), (4,0)\\n for i in range(n):\\n #print(i,n - (i+1))\\n tempSum = self.numTrees(i) * self.numTrees(n - (i+1))\\n #print(tempSum)\\n resSum += tempSum\\n \\n # append to hash\\n self.hash[n]=resSum\\n return resSum\", \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n res = [0] * (n+1)\\n res[0] = res[1] = 1\\n for i in range(2,n+1):\\n for j in range(1,i+1):\\n res[i] += res[j-1] * res[i-j]\\n return res[-1]\", \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if n<1:\\n return 1\\n \\n tree_nums = [0]*(n+1)\\n tree_nums[0] = 1\\n tree_nums[1] = 1 # index start with 1\\n \\n for t in range(2, n+1):\\n for root in range(1,t+1):\\n lt_num = root-1 # nodes num which smaller than root\\n rt_num = t-root # nodes num which larger than root\\n \\n tree_nums[t] += tree_nums[lt_num]*tree_nums[rt_num]\\n \\n return tree_nums[n]\\n\", \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n dp = [0]*(n+1)\\n dp[0] = dp[1] = 1\\n for i in range(2, n+1):\\n total = 0\\n for j in range(i):\\n total += (dp[j] * dp[i-j-1])\\n dp[i] = total\\n \\n return dp[n] \", \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n \\\"\\\"\\\"\\n The most straightforward solution would be to try all possible permutations that specify the order of input in constructing a BST and counting the different ways in which the BST results. But that would take O(n!) time and O(n) space.\\n Maybe it would help to use the fact that a BST is defined recursively.\\n Does the topology of a subtree affects whether the parent subtree is valid or not?\\n No.\\n And is it possible that we get any duplicate trees when we first designate our root and then permute its subtrees? \\n No.\\n So for each node i, set i as a root and then construct/permute the left and the right subtrees. \\n The parameter we need to take care of is the list of available nodes in that subtree.\\n Memoize the results, too.\\n \\\"\\\"\\\"\\n \\n def memoize(func):\\n func.cache = cache = dict()\\n def memoizer(*args):\\n key = str(args)\\n if key not in cache:\\n cache[key] = func(*args)\\n return cache[key]\\n return memoizer\\n \\n \\n @memoize\\n def count(root, lower_bound, upper_bound):\\n \\n if upper_bound < lower_bound:\\n return 0\\n \\n if lower_bound == upper_bound:\\n return 1\\n \\n left_combinations = max(1, sum(count(left, lower_bound, root - 1) for left in range(lower_bound, root)))\\n right_combinations = max(1, sum(count(right, root + 1, upper_bound) for right in range(root + 1, upper_bound + 1)))\\n #print(root, lower_bound, upper_bound, left_combinations, right_combinations)\\n return left_combinations * right_combinations\\n \\n return sum(count(root, 1, n) for root in range(1, n + 1))\\n \\n\", \"class Solution:\\n from functools import lru_cache\\n @lru_cache(maxsize=None)\\n def numTrees(self, high, low=1, depth=0):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n return sum(self.numTrees(key - 1, low, depth + 1) * self.numTrees(high, key + 1, depth + 1) for key in range(low, high + 1)) or 1\", \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n nums = [0] * (n+1)\\n nums[0] = 1\\n nums[1] = 1\\n \\n for i in range(2, n+1):\\n for j in range(i):\\n nums[i] += nums[j] * nums[i - j - 1]\\n return nums[n]\", \"class Solution:\\n def numTrees(self, n):\\n \\n dp = [0] * (n + 1)\\n \\n dp[0] = 1\\n \\n for i in range(1, n + 1):\\n for j in range(i):\\n print(j)\\n print((i - j - 1))\\n dp[i] += dp[j] * dp[i - j - 1]\\n \\n return dp[-1]\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n\", \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n a = [1]\\n i = 1\\n while i < n:\\n tmp = [sum(a), sum(a)]\\n for j in range(len(a) - 1):\\n tmp.append(tmp[j + 1] - a[j]) \\n i += 1\\n a = tmp\\n return sum(a)\", \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n dp = [1, 1, 2]\\n if n < 3:\\n return dp[n]\\n for i in range(3, n + 1):\\n \\n dp.append(sum(dp[j - 1] * dp[i - j] for j in range(1, i + 1)))\\n return dp[n]\\n\", \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n dp = [0 for _ in range(n+1)]\\n dp[1] = 1\\n dp[0] = 1\\n \\n for x in range(2, n+1):\\n for y in range(1, x+1): \\n dp[x] += (dp[y - 1] * dp[x-y])\\n \\n return dp[-1]\\n\", \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if n <= 1:\\n return 1\\n dp = [1 for i in range(n+1)]\\n for i in range(2, n+1):\\n sums = 0\\n for j in range(1, i+1):\\n sums += dp[j-1] * dp[i-j]\\n dp[i] = sums\\n print(dp)\\n return dp[-1]\", \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int \\n \\\"\\\"\\\"\\n M = [0 for x in range(n)]\\n M[0] = 1\\n for i in range(1,n):\\n for j in range(1,i):\\n M[i] += M[j-1] * M[i-j-1]\\n M[i] += M[i-1] * 2\\n return M[n-1]\", \"class Solution:\\n from functools import lru_cache\\n @lru_cache(maxsize=None)\\n def numTrees(self, high, low=1):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n return sum(self.numTrees(key - 1, low) * self.numTrees(high, key + 1) for key in range(low, high + 1)) or 1\", \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n G = [0 for _ in range(n+1)]\\n G[0] = 1\\n G[1] = 1\\n \\n for i in range(2, n+1):\\n for j in range(i+1):\\n G[i] += G[j-1]*G[i-j]\\n \\n return G[-1]\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"numTrees\", \"inputs\": [[3]], \"outputs\": [5]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/unique-binary-search-trees/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def numTrees(self, n: int) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n hash = {}\n def numTrees(self, n):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n # return base case\n if n == 0:\n return 1\n if n == 1 or n == 2:\n return n\n \n # try fetching from hash\n try:\n return self.hash[n]\n except KeyError:\n pass\n \n # holds the sum\n resSum = 0\n \n # iterate i from 1 to n-1\n # should add up (0,4), (1,3), (2,2), (3,1), (4,0)\n for i in range(n):\n #print(i,n - (i+1))\n tempSum = self.numTrees(i) * self.numTrees(n - (i+1))\n #print(tempSum)\n resSum += tempSum\n \n # append to hash\n self.hash[n]=resSum\n return resSum","class Solution:\n def numTrees(self, n):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n res = [0] * (n+1)\n res[0] = res[1] = 1\n for i in range(2,n+1):\n for j in range(1,i+1):\n res[i] += res[j-1] * res[i-j]\n return res[-1]","class Solution:\n def numTrees(self, n):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n if n<1:\n return 1\n \n tree_nums = [0]*(n+1)\n tree_nums[0] = 1\n tree_nums[1] = 1 # index start with 1\n \n for t in range(2, n+1):\n for root in range(1,t+1):\n lt_num = root-1 # nodes num which smaller than root\n rt_num = t-root # nodes num which larger than root\n \n tree_nums[t] += tree_nums[lt_num]*tree_nums[rt_num]\n \n return tree_nums[n]\n","class Solution:\n def numTrees(self, n):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n dp = [0]*(n+1)\n dp[0] = dp[1] = 1\n for i in range(2, n+1):\n total = 0\n for j in range(i):\n total += (dp[j] * dp[i-j-1])\n dp[i] = total\n \n return dp[n] ","class Solution:\n def numTrees(self, n):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n \n \"\"\"\n The most straightforward solution would be to try all possible permutations that specify the order of input in constructing a BST and counting the different ways in which the BST results. But that would take O(n!) time and O(n) space.\n Maybe it would help to use the fact that a BST is defined recursively.\n Does the topology of a subtree affects whether the parent subtree is valid or not?\n No.\n And is it possible that we get any duplicate trees when we first designate our root and then permute its subtrees? \n No.\n So for each node i, set i as a root and then construct/permute the left and the right subtrees. \n The parameter we need to take care of is the list of available nodes in that subtree.\n Memoize the results, too.\n \"\"\"\n \n def memoize(func):\n func.cache = cache = dict()\n def memoizer(*args):\n key = str(args)\n if key not in cache:\n cache[key] = func(*args)\n return cache[key]\n return memoizer\n \n \n @memoize\n def count(root, lower_bound, upper_bound):\n \n if upper_bound < lower_bound:\n return 0\n \n if lower_bound == upper_bound:\n return 1\n \n left_combinations = max(1, sum(count(left, lower_bound, root - 1) for left in range(lower_bound, root)))\n right_combinations = max(1, sum(count(right, root + 1, upper_bound) for right in range(root + 1, upper_bound + 1)))\n #print(root, lower_bound, upper_bound, left_combinations, right_combinations)\n return left_combinations * right_combinations\n \n return sum(count(root, 1, n) for root in range(1, n + 1))\n \n","class Solution:\n from functools import lru_cache\n @lru_cache(maxsize=None)\n def numTrees(self, high, low=1, depth=0):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n return sum(self.numTrees(key - 1, low, depth + 1) * self.numTrees(high, key + 1, depth + 1) for key in range(low, high + 1)) or 1","class Solution:\n def numTrees(self, n):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n nums = [0] * (n+1)\n nums[0] = 1\n nums[1] = 1\n \n for i in range(2, n+1):\n for j in range(i):\n nums[i] += nums[j] * nums[i - j - 1]\n return nums[n]","class Solution:\n def numTrees(self, n):\n \n dp = [0] * (n + 1)\n \n dp[0] = 1\n \n for i in range(1, n + 1):\n for j in range(i):\n print(j)\n print((i - j - 1))\n dp[i] += dp[j] * dp[i - j - 1]\n \n return dp[-1]\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n","class Solution:\n def numTrees(self, n):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n a = [1]\n i = 1\n while i < n:\n tmp = [sum(a), sum(a)]\n for j in range(len(a) - 1):\n tmp.append(tmp[j + 1] - a[j]) \n i += 1\n a = tmp\n return sum(a)","class Solution:\n def numTrees(self, n):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n dp = [1, 1, 2]\n if n < 3:\n return dp[n]\n for i in range(3, n + 1):\n \n dp.append(sum(dp[j - 1] * dp[i - j] for j in range(1, i + 1)))\n return dp[n]\n","class Solution:\n def numTrees(self, n):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n \n dp = [0 for _ in range(n+1)]\n dp[1] = 1\n dp[0] = 1\n \n for x in range(2, n+1):\n for y in range(1, x+1): \n dp[x] += (dp[y - 1] * dp[x-y])\n \n return dp[-1]\n","class Solution:\n def numTrees(self, n):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n if n <= 1:\n return 1\n dp = [1 for i in range(n+1)]\n for i in range(2, n+1):\n sums = 0\n for j in range(1, i+1):\n sums += dp[j-1] * dp[i-j]\n dp[i] = sums\n print(dp)\n return dp[-1]","class Solution:\n def numTrees(self, n):\n \"\"\"\n :type n: int\n :rtype: int \n \"\"\"\n M = [0 for x in range(n)]\n M[0] = 1\n for i in range(1,n):\n for j in range(1,i):\n M[i] += M[j-1] * M[i-j-1]\n M[i] += M[i-1] * 2\n return M[n-1]","class Solution:\n from functools import lru_cache\n @lru_cache(maxsize=None)\n def numTrees(self, high, low=1):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n return sum(self.numTrees(key - 1, low) * self.numTrees(high, key + 1) for key in range(low, high + 1)) or 1","class Solution:\n def numTrees(self, n):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n G = [0 for _ in range(n+1)]\n G[0] = 1\n G[1] = 1\n \n for i in range(2, n+1):\n for j in range(i+1):\n G[i] += G[j-1]*G[i-j]\n \n return G[-1]"],"string":"[\n \"class Solution:\\n hash = {}\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n # return base case\\n if n == 0:\\n return 1\\n if n == 1 or n == 2:\\n return n\\n \\n # try fetching from hash\\n try:\\n return self.hash[n]\\n except KeyError:\\n pass\\n \\n # holds the sum\\n resSum = 0\\n \\n # iterate i from 1 to n-1\\n # should add up (0,4), (1,3), (2,2), (3,1), (4,0)\\n for i in range(n):\\n #print(i,n - (i+1))\\n tempSum = self.numTrees(i) * self.numTrees(n - (i+1))\\n #print(tempSum)\\n resSum += tempSum\\n \\n # append to hash\\n self.hash[n]=resSum\\n return resSum\",\n \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n res = [0] * (n+1)\\n res[0] = res[1] = 1\\n for i in range(2,n+1):\\n for j in range(1,i+1):\\n res[i] += res[j-1] * res[i-j]\\n return res[-1]\",\n \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if n<1:\\n return 1\\n \\n tree_nums = [0]*(n+1)\\n tree_nums[0] = 1\\n tree_nums[1] = 1 # index start with 1\\n \\n for t in range(2, n+1):\\n for root in range(1,t+1):\\n lt_num = root-1 # nodes num which smaller than root\\n rt_num = t-root # nodes num which larger than root\\n \\n tree_nums[t] += tree_nums[lt_num]*tree_nums[rt_num]\\n \\n return tree_nums[n]\\n\",\n \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n dp = [0]*(n+1)\\n dp[0] = dp[1] = 1\\n for i in range(2, n+1):\\n total = 0\\n for j in range(i):\\n total += (dp[j] * dp[i-j-1])\\n dp[i] = total\\n \\n return dp[n] \",\n \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n \\\"\\\"\\\"\\n The most straightforward solution would be to try all possible permutations that specify the order of input in constructing a BST and counting the different ways in which the BST results. But that would take O(n!) time and O(n) space.\\n Maybe it would help to use the fact that a BST is defined recursively.\\n Does the topology of a subtree affects whether the parent subtree is valid or not?\\n No.\\n And is it possible that we get any duplicate trees when we first designate our root and then permute its subtrees? \\n No.\\n So for each node i, set i as a root and then construct/permute the left and the right subtrees. \\n The parameter we need to take care of is the list of available nodes in that subtree.\\n Memoize the results, too.\\n \\\"\\\"\\\"\\n \\n def memoize(func):\\n func.cache = cache = dict()\\n def memoizer(*args):\\n key = str(args)\\n if key not in cache:\\n cache[key] = func(*args)\\n return cache[key]\\n return memoizer\\n \\n \\n @memoize\\n def count(root, lower_bound, upper_bound):\\n \\n if upper_bound < lower_bound:\\n return 0\\n \\n if lower_bound == upper_bound:\\n return 1\\n \\n left_combinations = max(1, sum(count(left, lower_bound, root - 1) for left in range(lower_bound, root)))\\n right_combinations = max(1, sum(count(right, root + 1, upper_bound) for right in range(root + 1, upper_bound + 1)))\\n #print(root, lower_bound, upper_bound, left_combinations, right_combinations)\\n return left_combinations * right_combinations\\n \\n return sum(count(root, 1, n) for root in range(1, n + 1))\\n \\n\",\n \"class Solution:\\n from functools import lru_cache\\n @lru_cache(maxsize=None)\\n def numTrees(self, high, low=1, depth=0):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n return sum(self.numTrees(key - 1, low, depth + 1) * self.numTrees(high, key + 1, depth + 1) for key in range(low, high + 1)) or 1\",\n \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n nums = [0] * (n+1)\\n nums[0] = 1\\n nums[1] = 1\\n \\n for i in range(2, n+1):\\n for j in range(i):\\n nums[i] += nums[j] * nums[i - j - 1]\\n return nums[n]\",\n \"class Solution:\\n def numTrees(self, n):\\n \\n dp = [0] * (n + 1)\\n \\n dp[0] = 1\\n \\n for i in range(1, n + 1):\\n for j in range(i):\\n print(j)\\n print((i - j - 1))\\n dp[i] += dp[j] * dp[i - j - 1]\\n \\n return dp[-1]\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n\",\n \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n a = [1]\\n i = 1\\n while i < n:\\n tmp = [sum(a), sum(a)]\\n for j in range(len(a) - 1):\\n tmp.append(tmp[j + 1] - a[j]) \\n i += 1\\n a = tmp\\n return sum(a)\",\n \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n dp = [1, 1, 2]\\n if n < 3:\\n return dp[n]\\n for i in range(3, n + 1):\\n \\n dp.append(sum(dp[j - 1] * dp[i - j] for j in range(1, i + 1)))\\n return dp[n]\\n\",\n \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n dp = [0 for _ in range(n+1)]\\n dp[1] = 1\\n dp[0] = 1\\n \\n for x in range(2, n+1):\\n for y in range(1, x+1): \\n dp[x] += (dp[y - 1] * dp[x-y])\\n \\n return dp[-1]\\n\",\n \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if n <= 1:\\n return 1\\n dp = [1 for i in range(n+1)]\\n for i in range(2, n+1):\\n sums = 0\\n for j in range(1, i+1):\\n sums += dp[j-1] * dp[i-j]\\n dp[i] = sums\\n print(dp)\\n return dp[-1]\",\n \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int \\n \\\"\\\"\\\"\\n M = [0 for x in range(n)]\\n M[0] = 1\\n for i in range(1,n):\\n for j in range(1,i):\\n M[i] += M[j-1] * M[i-j-1]\\n M[i] += M[i-1] * 2\\n return M[n-1]\",\n \"class Solution:\\n from functools import lru_cache\\n @lru_cache(maxsize=None)\\n def numTrees(self, high, low=1):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n return sum(self.numTrees(key - 1, low) * self.numTrees(high, key + 1) for key in range(low, high + 1)) or 1\",\n \"class Solution:\\n def numTrees(self, n):\\n \\\"\\\"\\\"\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n G = [0 for _ in range(n+1)]\\n G[0] = 1\\n G[1] = 1\\n \\n for i in range(2, n+1):\\n for j in range(i+1):\\n G[i] += G[j-1]*G[i-j]\\n \\n return G[-1]\"\n]","isConversational":false},"n_sols":{"kind":"number","value":15,"string":"15"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":69,"cells":{"problem_id":{"kind":"number","value":202,"string":"202"},"question":{"kind":"string","value":"Let's call any (contiguous) subarray B (of A) a mountain if the following properties hold:\n\nB.length >= 3\nThere exists some 0 < i < B.length - 1 such that B[0] < B[1] < ... B[i-1] < B[i] > B[i+1] > ... > B[B.length - 1]\n\n(Note that B could be any subarray of A, including the entire array A.)\nGiven an array A of integers, return the length of the longest mountain. \nReturn 0 if there is no mountain.\nExample 1:\nInput: [2,1,4,7,3,2,5]\nOutput: 5\nExplanation: The largest mountain is [1,4,7,3,2] which has length 5.\n\nExample 2:\nInput: [2,2,2]\nOutput: 0\nExplanation: There is no mountain.\n\nNote:\n\n0 <= A.length <= 10000\n0 <= A[i] <= 10000\n\nFollow up:\n\nCan you solve it using only one pass?\nCan you solve it in O(1) space?"},"solutions":{"kind":"string","value":"[\"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n up=0\\n down=0\\n ans=0\\n for i in range(0,len(A)-1):\\n if A[i]<A[i+1]:\\n if down==0:\\n up+=1\\n else:\\n up=1\\n down=0\\n \\n elif A[i]>A[i+1]:\\n if up>0:\\n down+=1\\n mountain=up+down+1\\n if ans<mountain:\\n ans=mountain\\n \\n else:\\n up=0\\n down=0\\n\\n \\n \\n return ans\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n \\n leftpivot = 0\\n rightpivot = 0\\n ascendign = False\\n descending = False\\n changes = 0\\n highest = 0\\n while(leftpivot<len(A)):\\n rightpivot=leftpivot\\n \\n if(rightpivot+1 < len(A) and A[rightpivot]<A[rightpivot+1]):\\n while(rightpivot + 1<len(A) and A[rightpivot]<A[rightpivot+1] ):\\n rightpivot+=1\\n\\n\\n if(rightpivot + 1<len(A) and A[rightpivot]>A[rightpivot+1]):\\n while(rightpivot<(len(A)-1) and A[rightpivot]>A[rightpivot+1]):\\n rightpivot+=1 \\n highest = max(highest,rightpivot+1-leftpivot)\\n\\n leftpivot = max(rightpivot,leftpivot+1)\\n return highest\\n\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if len(A) < 3:\\n return 0\\n \\n prev_height = None\\n peaks = [0 for _ in range(len(A))]\\n has_increment = False\\n \\n # combs left to right for peaks\\n for idx in range(len(A)):\\n if prev_height is not None:\\n if prev_height < A[idx]:\\n peaks[idx] = peaks[idx-1] + 1\\n has_increment = True\\n else:\\n if has_increment:\\n peaks[idx-1] += 1\\n peaks[idx] = 0\\n has_increment = False\\n prev_height = A[idx]\\n \\n print(peaks)\\n \\n # combs right to left for peaks\\n prev_height = None\\n max_so_far = 0\\n has_increment = False\\n \\n for idx in range(len(A)-1, -1, -1):\\n if prev_height is not None:\\n if prev_height < A[idx]:\\n peaks[idx] += peaks[idx+1] + 1\\n has_increment = True\\n else:\\n if has_increment and prev_height > A[idx]:\\n max_so_far = max(max_so_far, peaks[idx+1])\\n peaks[idx] = peaks[idx]\\n has_increment = False\\n prev_height = A[idx]\\n \\n print(peaks)\\n \\n return max_so_far\\n\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if len(A) < 3:\\n return 0\\n \\n n = len(A)\\n ups, downs = [0] * n, [0] * n\\n i, j = 0, n - 1\\n \\n while i < n - 1:\\n if A[i] < A[i+1]:\\n ups[i+1] = ups[i] + 1\\n \\n i += 1\\n \\n while j > 0:\\n if A[j] < A[j-1]:\\n downs[j-1] = downs[j] + 1\\n \\n j -= 1\\n \\n print((ups, downs))\\n longest = [u + d + 1 for u, d in zip(ups, downs) if u and d]\\n \\n return max(longest) if longest else 0\\n\", \"class Solution:\\n \\n def longestMountain(self, A: List[int]) -> int:\\n N = len(A)\\n prefix = [1] * N\\n suffix = [1] * N\\n \\n for i, num in enumerate(A[1:], 1):\\n i_rev = N - i - 1\\n prefix[i] = prefix[i-1] + 1 if A[i-1] < num else 1\\n suffix[i_rev] = suffix[i_rev+1] + 1 if A[i_rev] > A[i_rev+1] else 1\\n \\n ans = 0\\n for i, num in enumerate(A):\\n left = prefix[i]\\n right = suffix[i]\\n length = left + right - 1\\n \\n if length >= 3 and min(left, right) > 1:\\n ans = max(ans, length)\\n \\n return ans\\n\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n \\n leftIncreasing = [0 for x in range(len(A))]\\n rightIncreasing = [0 for x in range(len(A))]\\n \\n for x in range(1, len(A)):\\n \\n if A[x] > A[x - 1]:\\n leftIncreasing[x] += (leftIncreasing[x - 1] + 1)\\n \\n if A[len(A) - 1 - x] > A[len(A) - x]:\\n rightIncreasing[len(A) - 1 - x] += (rightIncreasing[len(A) - x] + 1)\\n \\n result = 0\\n \\n for x in range(len(A)):\\n \\n if leftIncreasing[x] and rightIncreasing[x]:\\n result = max(result, leftIncreasing[x] + rightIncreasing[x] + 1)\\n \\n return result if result >= 3 else 0\\n\", \"class Solution:\\n\\n def longestMountain(self, A):\\n up, down = [0] * len(A), [0] * len(A)\\n for i in range(1, len(A)):\\n if A[i] > A[i - 1]: up[i] = up[i - 1] + 1\\n for i in range(len(A) - 1)[::-1]:\\n if A[i] > A[i + 1]: down[i] = down[i + 1] + 1\\n \\n print(down)\\n print(up)\\n return max([u + d + 1 for u, d in zip(up, down) if u and d] or [0])\\n\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if len(A) < 3:\\n return 0\\n \\n longestMountain = 0\\n\\n for i in range(1, len(A) - 1):\\n # Index i denotes a 'peak' in the mountain.\\n if A[i - 1] < A[i] > A[i + 1]:\\n left = right = i\\n \\n # Traverse left and down the mountain from i until there is no longer a downwards slope.\\n while left > 0 and A[left - 1] < A[left]:\\n left -= 1\\n \\n # Traverse right and down the mountain from i until there is no longer a downwards slope.\\n while right + 1 < len(A) and A[right + 1] < A[right]:\\n right += 1\\n \\n # The length of the mountain will be the distance from left and right (+ 1 to factor in the peak).\\n mountainLength = right - left + 1\\n longestMountain = max(longestMountain, mountainLength)\\n \\n return longestMountain\", \"class Solution:\\n def longestMountain(self, a: List[int]) -> int:\\n ml = 0\\n i = 0\\n while(i<len(a)):\\n c = 0\\n if i+1<len(a) and a[i+1]>a[i]:\\n c = 1\\n while(i+1<len(a) and a[i+1]>a[i]):\\n c = c + 1\\n i = i + 1\\n while(i+1<len(a) and a[i+1]<a[i]):\\n c = c + 1\\n ml = max(c,ml)\\n i = i + 1\\n else:\\n i = i + 1\\n return ml\\n \\n\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n idx = 0\\n big = 0\\n while idx+1 < len(A):\\n long = 1\\n if A[idx+1] > A[idx]:\\n while idx+1 < len(A) and A[idx+1] > A[idx]:\\n idx += 1\\n long += 1\\n else:\\n idx += 1\\n continue\\n if idx+1 < len(A) and A[idx+1] < A[idx]:\\n while idx+1 < len(A) and A[idx+1] < A[idx]:\\n idx += 1\\n long += 1\\n else:\\n idx += 1\\n continue\\n big = max(long, big)\\n return big if big >= 3 else 0\", \"class Solution:\\n def longestMountain(self, A):\\n res = up = down = 0\\n for i in range(1, len(A)):\\n if down and A[i - 1] < A[i] or A[i - 1] == A[i]: up = down = 0\\n up += A[i - 1] < A[i]\\n down += A[i - 1] > A[i]\\n if up and down: res = max(res, up + down + 1)\\n return res\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n res = up = down = 0\\n for i in range(1, len(A)):\\n if down and A[i - 1] < A[i] or A[i - 1] == A[i]:\\n up = down = 0\\n if A[i - 1] < A[i]:\\n up += 1\\n else:\\n down += 1\\n if up and down:\\n res = max(res, up + down + 1)\\n return res\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n n=len(A)\\n left_inc=[0]*n\\n for i in range(1,n):\\n if A[i]>A[i-1]:\\n left_inc[i]=1+left_inc[i-1]\\n print(left_inc)\\n \\n right_inc=[0]*n\\n for i in range(n-2,-1,-1):\\n if A[i]>A[i+1]:\\n right_inc[i]=1+right_inc[i+1]\\n print(right_inc)\\n \\n res=0\\n for i in range(n):\\n if left_inc[i]!=0 and right_inc[i]!=0:\\n res=max(res,left_inc[i]+right_inc[i]+1)\\n \\n return res if res>=3 else 0\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n # edge case\\n if len(A)==0: return 0\\n \\n n = len(A)\\n peak = None\\n maxMountainLen = 0\\n \\n i = 1\\n while (i+1) <n:\\n if A[i-1]<A[i] and A[i]>A[i+1]:\\n # already obtained the peak\\n left = right = i\\n \\n while (left-1)>=0 and A[left-1] < A[left]:\\n left -= 1\\n \\n while (right+1) <n and A[right+1] < A[right]:\\n right += 1\\n \\n # max length of mountain\\n maxMountainLen = max(maxMountainLen, right-left+1)\\n i=right+1\\n else:\\n i+=1\\n \\n return maxMountainLen\\n\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n \\n i = 0\\n answer = 0\\n while i < len(A) - 1:\\n \\n j = i + 1\\n visited_top = False\\n \\n while j < len(A):\\n print(i, j)\\n if A[j] > A[j-1]:\\n if visited_top:\\n break\\n \\n if A[j] < A[j-1]:\\n if not visited_top:\\n if j - i == 1:\\n break\\n visited_top = True\\n \\n if A[j] == A[j-1]:\\n break\\n j += 1\\n\\n \\n \\n if visited_top and j - i > 2:\\n answer = max(answer, j - i)\\n i = j\\n if visited_top:\\n i -= 1\\n \\n return answer\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n import copy \\n \\n if not A:\\n return 0\\n \\n dp = []\\n B = copy.deepcopy(A)\\n B.insert(0, A[0])\\n B.append(A[-1])\\n \\n for i in range(1,len(B) - 1):\\n \\n if (B[i-1] < B[i] and B[i+1] < B[i]):\\n dp.append(i-1)\\n \\n \\n ret = []\\n A.append(A[-1])\\n for top in dp:\\n \\n \\n left = top\\n while A[left - 1] < A[left] and left > 0:\\n left -= 1\\n \\n right = top\\n while A[right + 1] < A[right]:\\n right +=1\\n \\n print(right, left)\\n ret.append(right -left + 1)\\n \\n print(dp, ret)\\n \\n \\n return max(ret) if ret else 0\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if not A or len(A)==1: return 0\\n m=len(A)\\n up,down=[0 for i in range(m)],[0 for i in range(m)]\\n up[0], down[-1]=0,0\\n for i in range(1,m):\\n j=m-1-i\\n if A[i]>A[i-1]:\\n up[i]=up[i-1]+1\\n else:up[i]=0\\n if A[j]>A[j+1]:\\n down[j]=down[j+1]+1\\n else: down[j]=0\\n ans=0\\n for i in range(m):\\n if up[i] and down[i]: ## need peak\\n ans=max(ans,up[i]+down[i]+1)\\n return ans\\n \\n \\n \\n \\n\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n \\n ans = 0\\n temp = 0\\n trend = False\\n \\n if len(A)<3: return 0\\n good = False\\n \\n for i in range(1,len(A)):\\n \\n diff = A[i]-A[i-1]\\n if diff>0:\\n if not trend:\\n good = True\\n trend = True\\n temp = 2\\n else:\\n temp=max(temp+1,2)\\n elif diff<0:\\n if trend:\\n trend = False\\n temp = max(temp+1,2)\\n ans = max(ans,temp)\\n else:\\n temp=max(temp+1,2)\\n if good: ans = max(ans,temp)\\n else:\\n temp = 0\\n trend = False\\n good = False\\n print(A[i], temp,trend, ans)\\n \\n # ans = max(ans,temp)\\n \\n return ans\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if len(A) < 3: return 0\\n up, down, Max = [1] * len(A), [1] * len(A), 0\\n for i in range(1, len(A)):\\n if A[i] > A[i - 1]: up[i] = up[i - 1] + 1\\n \\n for i in range(len(A) - 2, -1, -1):\\n if A[i] > A[i + 1]: down[i] = down[i + 1] + 1\\n \\n # print(up)\\n # print(down)\\n \\n for i in range(1, len(A) - 1):\\n if A[i - 1] < A[i] > A[i + 1]:\\n Max = max(Max, up[i] + down[i] - 1)\\n return Max \\n \\n \\n \\n \\n\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n # https://leetcode.com/problems/longest-mountain-in-array/discuss/135593/C%2B%2BJavaPython-1-pass-and-O(1)-space\\n res = up = down = 0\\n for i in range(1, len(A)):\\n if down and A[i - 1] < A[i] or A[i - 1] == A[i]: up = down = 0\\n up += A[i - 1] < A[i]\\n down += A[i - 1] > A[i]\\n if up and down: res = max(res, up + down + 1)\\n return res\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n N = len(A)\\n up = [1]*N\\n for i in range(1, N):\\n if A[i]>A[i-1]: up[i]+=up[i-1]\\n down = [1]*N\\n for i in range(N-2,-1, -1):\\n if A[i]>A[i+1]: down[i]+=down[i+1]\\n # print(up, down)\\n return max([u+d-1 for u, d in zip(up, down) if u>1 and d>1 and u+d-1>=3] or [0])\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n res = up = down = 0\\n for i in range(1, len(A)):\\n if down and A[i-1] < A[i] or A[i-1] == A[i]: # to check if we found down and the next is up\\n up = down = 0 # reset for next down and make sure we are counting right up's\\n up += A[i-1] < A[i]\\n down += A[i-1] > A[i]\\n if up and down:\\n res = max(res, up+down+1)\\n return res\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if not A: return 0\\n # None -> Haven't started a mountain, True -> rising up, False -> Falling down\\n rising = None\\n curr = 0\\n best = 0\\n prev = None\\n for i,x in enumerate(A):\\n print((i,':', x, 'curr', curr))\\n if prev is None:\\n prev = x\\n curr = best = 1\\n continue\\n \\n if rising is None and x < prev:\\n prev = x\\n continue\\n if rising is None and x > prev:\\n rising = True\\n prev = x\\n curr = 2\\n continue\\n \\n # Continue rising\\n if rising and x > prev:\\n curr += 1\\n # Continue falling\\n elif not rising and x < prev:\\n curr += 1\\n # Failure regardless of rising/not rising\\n elif x == prev:\\n rising = None\\n best = max(best, curr)\\n # Was rising, gonna fall now\\n elif rising and x < prev:\\n rising = False\\n curr += 1\\n # Was falling, gonna start a new mountain\\n elif not rising and x > prev:\\n best = max(best, curr)\\n rising = True\\n curr = 2 # x and the previous\\n \\n prev = x\\n # Check if \\n if rising is not None and not rising:\\n best = max(best, curr)\\n return 0 if best < 3 else best\\n \\n\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n N = len(A)\\n start = 0 \\n ans = 0 \\n while start < N:\\n end = start\\n if end + 1 < N and A[end] < A[end+1]:\\n while end + 1 < N and A[end] < A[end+1]:\\n end +=1\\n if end + 1 < N and A[end] > A[end+1]:\\n while end + 1 < N and A[end] > A[end+1]:\\n end +=1\\n ans = max(ans, end-start+1)\\n start = max(end, start+1)\\n return ans\\n\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if len(A) == 0:\\n return 0\\n increasing = False\\n count = -float('inf')\\n last = A[0]\\n max_len = 0\\n for i in range(1,len(A)):\\n if A[i] > last and increasing:\\n count += 1\\n elif A[i] > last and not increasing:\\n count = 2\\n increasing = True\\n elif A[i] < last and increasing:\\n count += 1\\n increasing = False\\n max_len = max(max_len, count)\\n elif A[i] < last and not increasing:\\n count += 1\\n max_len = max(max_len, count)\\n else:\\n if not increasing:\\n max_len = max(max_len, count)\\n count = -float('inf')\\n increasing = False\\n last = A[i]\\n \\n if max_len < 3:\\n return 0\\n return max_len\\n \\n\\n\\n\", \"class Solution:\\n def longestMountain(self, A):\\n res = up = down = 0\\n for i in range(1, len(A)):\\n if down and A[i - 1] < A[i] or A[i - 1] == A[i]: up = down = 0\\n up += A[i - 1] < A[i]\\n down += A[i - 1] > A[i]\\n if up and down: res = max(res, up + down + 1)\\n return res\\n\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if not A or len(A) < 3:\\n return 0\\n \\n left = right = mid = max_moun = 0\\n while right < len(A):\\n \\n prev = mid\\n while right + 1 < len(A) and A[right + 1] > A[right]:\\n right += 1\\n mid += 1\\n \\n if prev != mid:\\n while right + 1 < len(A) and A[right + 1] < A[right]:\\n right += 1\\n\\n if mid != 0 and mid != len(A) - 1:\\n max_moun = max(max_moun, right - left + 1)\\n \\n right = mid + 1\\n left = right\\n mid = right\\n \\n if max_moun < 3:\\n return 0\\n \\n return max_moun\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n left = right = 0\\n max_length = 0\\n while left < len(A):\\n \\n prev = A[left]\\n climbing = False\\n descending = False\\n right = left + 1\\n while right < len(A):\\n current = A[right]\\n if prev < current and not descending:\\n climbing = True\\n elif prev > current and (climbing or descending):\\n climbing = False\\n descending = True\\n else:\\n right -= 1\\n break\\n right += 1\\n prev = current\\n \\n if right == len(A):\\n right -= 1\\n \\n curr_length = right - left + 1\\n if curr_length > 2 and descending:\\n max_length = max(max_length, curr_length)\\n \\n left = max(left + 1, right)\\n \\n return max_length\", \"class Solution:\\n def mountain_search(self,start,A):\\n valid_mountain = True\\n i = start\\n while (i < len(A)-1 and A[i] < A[i+1]):\\n i+=1\\n if (i < len(A)-1 and A[i] != A[i+1]):\\n while (i < len(A)-1 and A[i] > A[i+1]):\\n i+=1\\n else:\\n valid_mountain = False\\n \\n return valid_mountain, i\\n \\n def longestMountain(self, A: List[int]) -> int:\\n # Idea: go through every element in array and try to build largest mountain\\n max_mountain = 0\\n i = 0\\n if not A: return 0\\n A.append(A[-1]+1)\\n \\n while i < len(A)-3:\\n if A[i] < A[i+1]:\\n valid, new_i = self.mountain_search(i, A)\\n if valid:\\n max_mountain = max(max_mountain, new_i-i+1)\\n i = new_i\\n else:\\n i+=1\\n return max_mountain\\n \\n\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n res = 0\\n for i in range(1,len(A) - 1):\\n if A[i + 1] < A[i] > A[i - 1]:\\n l = r = i\\n \\n while l and A[l] > A[l - 1]:\\n l -= 1\\n \\n while r + 1 < len(A) and A[r] > A[r + 1]:\\n r += 1\\n \\n if r - l + 1 > res:\\n res = r - l + 1\\n return res\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n is_peak = False\\n index = 1\\n longest = 0\\n while index < len(A) - 1:\\n if A[index] > A[index-1] and A[index] > A[index+1]:\\n is_peak = True\\n if not is_peak:\\n index += 1\\n continue\\n left = index-1\\n while left-1 >= 0 and A[left] > A[left-1]:\\n left -= 1\\n right = index+1\\n while right+1 < len(A) and A[right] > A[right+1]:\\n right += 1\\n longest = max(longest, right-left+1)\\n index = right\\n is_peak = False\\n return longest\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n up = down = ans = 0\\n for i in range(1, len(A)):\\n if A[i-1]==A[i]:\\n up = down = 0\\n elif A[i-1]<A[i]:\\n if down or up==0:\\n up = 2\\n down = 0\\n else:\\n up += 1\\n else:\\n down += 1\\n if up and down:\\n ans = max(ans, up+down)\\n return ans\\n \\n \\n '''\\n up = down = ans = 0\\n for i in range(1, len(A)):\\n if A[i-1]>A[i] and up:\\n down += 1\\n if A[i-1]==A[i] or A[i-1]<A[i] and down or i==len(A)-1:\\n if up and down:\\n ans = max(ans, up+down)\\n up = down = 0\\n if A[i-1]<A[i]:\\n up = 2 if not up else up+1\\n\\n return ans\\n '''\\n \\n '''\\n l = ans = 0\\n phase = 0 #0:ascend, 1: descend\\n for r in range(1, len(A)):\\n if phase==0:\\n if A[r-1]==A[r]:\\n l = r\\n elif A[r-1]>A[r]:\\n if l+1<r:\\n phase = 1\\n else:\\n l = r\\n if phase==1:\\n if A[r-1]<=A[r] or r==len(A)-1:\\n ans = max(ans, r-l)\\n if r==len(A)-1 and A[r-1]>A[r] and r-l==ans:\\n ans += 1\\n l = r if A[r-1]==A[r] else r-1\\n phase = 0\\n \\n return ans\\n ''' \", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n res = cur = 1\\n desc = False\\n for i in range(1, len(A)):\\n if A[i-1] == A[i]:\\n if desc: res = max(res, cur)\\n desc = False\\n cur = 1\\n elif A[i-1] < A[i]:\\n if not desc: cur += 1\\n else:\\n res = max(res, cur)\\n cur = 2\\n desc = False\\n else:\\n if desc: cur += 1\\n elif cur > 1: \\n desc = True\\n cur += 1\\n else:\\n cur = 1\\n desc = False\\n if desc: res = max(res, cur)\\n return 0 if res < 3 and not desc else res\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n res = 0\\n i = 0\\n \\n while i < len(A):\\n j = i\\n while j + 1 < len(A) and A[j] < A[j+1]:\\n j += 1\\n mid = j\\n while j + 1 < len(A) and A[j] > A[j+1]:\\n j += 1\\n if i < mid < j:\\n res = max(res, j-i+1)\\n if i == j:\\n i +=1\\n else:\\n i = j\\n \\n return res\", \"'''\\n\\nmountain = relative maximum\\n- find decr and incr after mountain\\n\\n[2,1,4,7,3,2,5]\\n\\n[2,3,2]\\n\\n\\nwhile j < len\\n use flag to incr and decr\\n \\n while next and next incr\\n j+=1\\n \\n if not incr:\\n incr and cont\\n \\n while next and next decr\\n j+=1\\n \\n if not decr:\\n incr and cont\\n \\n if len 3\\n check/override max\\n'''\\n\\nclass Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n \\n long_mont = 0\\n i, j = 0, 0\\n \\n while j < len(A):\\n \\n incr = False\\n while j!=len(A)-1 and A[j] < A[j+1]:\\n incr = True\\n j+=1\\n \\n if not incr:\\n j+=1\\n i=j\\n continue\\n \\n decr = False\\n while j!=len(A)-1 and A[j] > A[j+1]:\\n decr = True\\n j+=1\\n \\n if not decr:\\n j+=1\\n i=j\\n continue\\n \\n curr_len = j-i+1\\n if curr_len >= 3:\\n long_mont = max(long_mont, curr_len)\\n\\n i = j\\n \\n return long_mont\\n\", \"class Solution(object):\\n def longestMountain(self, A):\\n N = len(A)\\n ans = base = 0\\n\\n while base < N:\\n end = base\\n if end + 1 < N and A[end] < A[end + 1]: #if base is a left-boundary\\n #set end to the peak of this potential mountain\\n while end+1 < N and A[end] < A[end+1]:\\n end += 1\\n\\n if end + 1 < N and A[end] > A[end + 1]: #if end is really a peak..\\n #set 'end' to right-boundary of mountain\\n while end+1 < N and A[end] > A[end+1]:\\n end += 1\\n #record candidate answer\\n ans = max(ans, end - base + 1)\\n\\n base = max(end, base + 1)\\n\\n return ans\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n # Write your code here.\\n longest, i = 0, 1\\n while i < len(A) - 1:\\n is_peak = A[i-1] < A[i] and A[i] > A[i+1]\\n #Check if i is peak\\n if is_peak:\\n left = i-2\\n #Move left pointer left while in bounds and greater\\n while left >= 0 and A[left] < A[left + 1]:\\n left -= 1\\n right = i + 2\\n #Move right pointer right while in bounds and greater\\n while right < len(A) and A[right] < A[right - 1]:\\n right += 1\\n #Current peak \\n longest = max(longest, right - left - 1)\\n #Increment i\\n i = right\\n #If i is not peak, increment and continue.\\n else:\\n i += 1\\n continue\\n return longest\", \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if len(A)<3:\\n return 0\\n a=A\\n start =0\\n end = 0\\n maxlen=0\\n n=len(a)\\n while(start<n-1 and end<n):\\n end = start\\n if a[start]<a[start+1]:\\n while end<n-1 and a[end]<a[end+1]:\\n end+=1\\n if end<n-1 and a[end]>a[end+1]:\\n while(end<n-1 and a[end]>a[end+1]):\\n end +=1\\n maxlen = max(maxlen,end-start+1)\\n start = max(start+1,end)\\n \\n return maxlen\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"longestMountain\", \"inputs\": [[[2, 1, 4, 7, 3, 2, 5]]], \"outputs\": [5]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/longest-mountain-in-array/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def longestMountain(self, A: List[int]) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def longestMountain(self, A: List[int]) -> int:\n up=0\n down=0\n ans=0\n for i in range(0,len(A)-1):\n if A[i]<A[i+1]:\n if down==0:\n up+=1\n else:\n up=1\n down=0\n \n elif A[i]>A[i+1]:\n if up>0:\n down+=1\n mountain=up+down+1\n if ans<mountain:\n ans=mountain\n \n else:\n up=0\n down=0\n\n \n \n return ans","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n \n leftpivot = 0\n rightpivot = 0\n ascendign = False\n descending = False\n changes = 0\n highest = 0\n while(leftpivot<len(A)):\n rightpivot=leftpivot\n \n if(rightpivot+1 < len(A) and A[rightpivot]<A[rightpivot+1]):\n while(rightpivot + 1<len(A) and A[rightpivot]<A[rightpivot+1] ):\n rightpivot+=1\n\n\n if(rightpivot + 1<len(A) and A[rightpivot]>A[rightpivot+1]):\n while(rightpivot<(len(A)-1) and A[rightpivot]>A[rightpivot+1]):\n rightpivot+=1 \n highest = max(highest,rightpivot+1-leftpivot)\n\n leftpivot = max(rightpivot,leftpivot+1)\n return highest\n","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n if len(A) < 3:\n return 0\n \n prev_height = None\n peaks = [0 for _ in range(len(A))]\n has_increment = False\n \n # combs left to right for peaks\n for idx in range(len(A)):\n if prev_height is not None:\n if prev_height < A[idx]:\n peaks[idx] = peaks[idx-1] + 1\n has_increment = True\n else:\n if has_increment:\n peaks[idx-1] += 1\n peaks[idx] = 0\n has_increment = False\n prev_height = A[idx]\n \n print(peaks)\n \n # combs right to left for peaks\n prev_height = None\n max_so_far = 0\n has_increment = False\n \n for idx in range(len(A)-1, -1, -1):\n if prev_height is not None:\n if prev_height < A[idx]:\n peaks[idx] += peaks[idx+1] + 1\n has_increment = True\n else:\n if has_increment and prev_height > A[idx]:\n max_so_far = max(max_so_far, peaks[idx+1])\n peaks[idx] = peaks[idx]\n has_increment = False\n prev_height = A[idx]\n \n print(peaks)\n \n return max_so_far\n","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n if len(A) < 3:\n return 0\n \n n = len(A)\n ups, downs = [0] * n, [0] * n\n i, j = 0, n - 1\n \n while i < n - 1:\n if A[i] < A[i+1]:\n ups[i+1] = ups[i] + 1\n \n i += 1\n \n while j > 0:\n if A[j] < A[j-1]:\n downs[j-1] = downs[j] + 1\n \n j -= 1\n \n print((ups, downs))\n longest = [u + d + 1 for u, d in zip(ups, downs) if u and d]\n \n return max(longest) if longest else 0\n","class Solution:\n \n def longestMountain(self, A: List[int]) -> int:\n N = len(A)\n prefix = [1] * N\n suffix = [1] * N\n \n for i, num in enumerate(A[1:], 1):\n i_rev = N - i - 1\n prefix[i] = prefix[i-1] + 1 if A[i-1] < num else 1\n suffix[i_rev] = suffix[i_rev+1] + 1 if A[i_rev] > A[i_rev+1] else 1\n \n ans = 0\n for i, num in enumerate(A):\n left = prefix[i]\n right = suffix[i]\n length = left + right - 1\n \n if length >= 3 and min(left, right) > 1:\n ans = max(ans, length)\n \n return ans\n","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n \n leftIncreasing = [0 for x in range(len(A))]\n rightIncreasing = [0 for x in range(len(A))]\n \n for x in range(1, len(A)):\n \n if A[x] > A[x - 1]:\n leftIncreasing[x] += (leftIncreasing[x - 1] + 1)\n \n if A[len(A) - 1 - x] > A[len(A) - x]:\n rightIncreasing[len(A) - 1 - x] += (rightIncreasing[len(A) - x] + 1)\n \n result = 0\n \n for x in range(len(A)):\n \n if leftIncreasing[x] and rightIncreasing[x]:\n result = max(result, leftIncreasing[x] + rightIncreasing[x] + 1)\n \n return result if result >= 3 else 0\n","class Solution:\n\n def longestMountain(self, A):\n up, down = [0] * len(A), [0] * len(A)\n for i in range(1, len(A)):\n if A[i] > A[i - 1]: up[i] = up[i - 1] + 1\n for i in range(len(A) - 1)[::-1]:\n if A[i] > A[i + 1]: down[i] = down[i + 1] + 1\n \n print(down)\n print(up)\n return max([u + d + 1 for u, d in zip(up, down) if u and d] or [0])\n","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n if len(A) < 3:\n return 0\n \n longestMountain = 0\n\n for i in range(1, len(A) - 1):\n # Index i denotes a 'peak' in the mountain.\n if A[i - 1] < A[i] > A[i + 1]:\n left = right = i\n \n # Traverse left and down the mountain from i until there is no longer a downwards slope.\n while left > 0 and A[left - 1] < A[left]:\n left -= 1\n \n # Traverse right and down the mountain from i until there is no longer a downwards slope.\n while right + 1 < len(A) and A[right + 1] < A[right]:\n right += 1\n \n # The length of the mountain will be the distance from left and right (+ 1 to factor in the peak).\n mountainLength = right - left + 1\n longestMountain = max(longestMountain, mountainLength)\n \n return longestMountain","class Solution:\n def longestMountain(self, a: List[int]) -> int:\n ml = 0\n i = 0\n while(i<len(a)):\n c = 0\n if i+1<len(a) and a[i+1]>a[i]:\n c = 1\n while(i+1<len(a) and a[i+1]>a[i]):\n c = c + 1\n i = i + 1\n while(i+1<len(a) and a[i+1]<a[i]):\n c = c + 1\n ml = max(c,ml)\n i = i + 1\n else:\n i = i + 1\n return ml\n \n","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n idx = 0\n big = 0\n while idx+1 < len(A):\n long = 1\n if A[idx+1] > A[idx]:\n while idx+1 < len(A) and A[idx+1] > A[idx]:\n idx += 1\n long += 1\n else:\n idx += 1\n continue\n if idx+1 < len(A) and A[idx+1] < A[idx]:\n while idx+1 < len(A) and A[idx+1] < A[idx]:\n idx += 1\n long += 1\n else:\n idx += 1\n continue\n big = max(long, big)\n return big if big >= 3 else 0","class Solution:\n def longestMountain(self, A):\n res = up = down = 0\n for i in range(1, len(A)):\n if down and A[i - 1] < A[i] or A[i - 1] == A[i]: up = down = 0\n up += A[i - 1] < A[i]\n down += A[i - 1] > A[i]\n if up and down: res = max(res, up + down + 1)\n return res","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n res = up = down = 0\n for i in range(1, len(A)):\n if down and A[i - 1] < A[i] or A[i - 1] == A[i]:\n up = down = 0\n if A[i - 1] < A[i]:\n up += 1\n else:\n down += 1\n if up and down:\n res = max(res, up + down + 1)\n return res","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n n=len(A)\n left_inc=[0]*n\n for i in range(1,n):\n if A[i]>A[i-1]:\n left_inc[i]=1+left_inc[i-1]\n print(left_inc)\n \n right_inc=[0]*n\n for i in range(n-2,-1,-1):\n if A[i]>A[i+1]:\n right_inc[i]=1+right_inc[i+1]\n print(right_inc)\n \n res=0\n for i in range(n):\n if left_inc[i]!=0 and right_inc[i]!=0:\n res=max(res,left_inc[i]+right_inc[i]+1)\n \n return res if res>=3 else 0","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n # edge case\n if len(A)==0: return 0\n \n n = len(A)\n peak = None\n maxMountainLen = 0\n \n i = 1\n while (i+1) <n:\n if A[i-1]<A[i] and A[i]>A[i+1]:\n # already obtained the peak\n left = right = i\n \n while (left-1)>=0 and A[left-1] < A[left]:\n left -= 1\n \n while (right+1) <n and A[right+1] < A[right]:\n right += 1\n \n # max length of mountain\n maxMountainLen = max(maxMountainLen, right-left+1)\n i=right+1\n else:\n i+=1\n \n return maxMountainLen\n","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n \n i = 0\n answer = 0\n while i < len(A) - 1:\n \n j = i + 1\n visited_top = False\n \n while j < len(A):\n print(i, j)\n if A[j] > A[j-1]:\n if visited_top:\n break\n \n if A[j] < A[j-1]:\n if not visited_top:\n if j - i == 1:\n break\n visited_top = True\n \n if A[j] == A[j-1]:\n break\n j += 1\n\n \n \n if visited_top and j - i > 2:\n answer = max(answer, j - i)\n i = j\n if visited_top:\n i -= 1\n \n return answer","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n import copy \n \n if not A:\n return 0\n \n dp = []\n B = copy.deepcopy(A)\n B.insert(0, A[0])\n B.append(A[-1])\n \n for i in range(1,len(B) - 1):\n \n if (B[i-1] < B[i] and B[i+1] < B[i]):\n dp.append(i-1)\n \n \n ret = []\n A.append(A[-1])\n for top in dp:\n \n \n left = top\n while A[left - 1] < A[left] and left > 0:\n left -= 1\n \n right = top\n while A[right + 1] < A[right]:\n right +=1\n \n print(right, left)\n ret.append(right -left + 1)\n \n print(dp, ret)\n \n \n return max(ret) if ret else 0","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n if not A or len(A)==1: return 0\n m=len(A)\n up,down=[0 for i in range(m)],[0 for i in range(m)]\n up[0], down[-1]=0,0\n for i in range(1,m):\n j=m-1-i\n if A[i]>A[i-1]:\n up[i]=up[i-1]+1\n else:up[i]=0\n if A[j]>A[j+1]:\n down[j]=down[j+1]+1\n else: down[j]=0\n ans=0\n for i in range(m):\n if up[i] and down[i]: ## need peak\n ans=max(ans,up[i]+down[i]+1)\n return ans\n \n \n \n \n","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n \n ans = 0\n temp = 0\n trend = False\n \n if len(A)<3: return 0\n good = False\n \n for i in range(1,len(A)):\n \n diff = A[i]-A[i-1]\n if diff>0:\n if not trend:\n good = True\n trend = True\n temp = 2\n else:\n temp=max(temp+1,2)\n elif diff<0:\n if trend:\n trend = False\n temp = max(temp+1,2)\n ans = max(ans,temp)\n else:\n temp=max(temp+1,2)\n if good: ans = max(ans,temp)\n else:\n temp = 0\n trend = False\n good = False\n print(A[i], temp,trend, ans)\n \n # ans = max(ans,temp)\n \n return ans","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n if len(A) < 3: return 0\n up, down, Max = [1] * len(A), [1] * len(A), 0\n for i in range(1, len(A)):\n if A[i] > A[i - 1]: up[i] = up[i - 1] + 1\n \n for i in range(len(A) - 2, -1, -1):\n if A[i] > A[i + 1]: down[i] = down[i + 1] + 1\n \n # print(up)\n # print(down)\n \n for i in range(1, len(A) - 1):\n if A[i - 1] < A[i] > A[i + 1]:\n Max = max(Max, up[i] + down[i] - 1)\n return Max \n \n \n \n \n","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n # https://leetcode.com/problems/longest-mountain-in-array/discuss/135593/C%2B%2BJavaPython-1-pass-and-O(1)-space\n res = up = down = 0\n for i in range(1, len(A)):\n if down and A[i - 1] < A[i] or A[i - 1] == A[i]: up = down = 0\n up += A[i - 1] < A[i]\n down += A[i - 1] > A[i]\n if up and down: res = max(res, up + down + 1)\n return res","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n N = len(A)\n up = [1]*N\n for i in range(1, N):\n if A[i]>A[i-1]: up[i]+=up[i-1]\n down = [1]*N\n for i in range(N-2,-1, -1):\n if A[i]>A[i+1]: down[i]+=down[i+1]\n # print(up, down)\n return max([u+d-1 for u, d in zip(up, down) if u>1 and d>1 and u+d-1>=3] or [0])","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n res = up = down = 0\n for i in range(1, len(A)):\n if down and A[i-1] < A[i] or A[i-1] == A[i]: # to check if we found down and the next is up\n up = down = 0 # reset for next down and make sure we are counting right up's\n up += A[i-1] < A[i]\n down += A[i-1] > A[i]\n if up and down:\n res = max(res, up+down+1)\n return res","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n if not A: return 0\n # None -> Haven't started a mountain, True -> rising up, False -> Falling down\n rising = None\n curr = 0\n best = 0\n prev = None\n for i,x in enumerate(A):\n print((i,':', x, 'curr', curr))\n if prev is None:\n prev = x\n curr = best = 1\n continue\n \n if rising is None and x < prev:\n prev = x\n continue\n if rising is None and x > prev:\n rising = True\n prev = x\n curr = 2\n continue\n \n # Continue rising\n if rising and x > prev:\n curr += 1\n # Continue falling\n elif not rising and x < prev:\n curr += 1\n # Failure regardless of rising/not rising\n elif x == prev:\n rising = None\n best = max(best, curr)\n # Was rising, gonna fall now\n elif rising and x < prev:\n rising = False\n curr += 1\n # Was falling, gonna start a new mountain\n elif not rising and x > prev:\n best = max(best, curr)\n rising = True\n curr = 2 # x and the previous\n \n prev = x\n # Check if \n if rising is not None and not rising:\n best = max(best, curr)\n return 0 if best < 3 else best\n \n","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n N = len(A)\n start = 0 \n ans = 0 \n while start < N:\n end = start\n if end + 1 < N and A[end] < A[end+1]:\n while end + 1 < N and A[end] < A[end+1]:\n end +=1\n if end + 1 < N and A[end] > A[end+1]:\n while end + 1 < N and A[end] > A[end+1]:\n end +=1\n ans = max(ans, end-start+1)\n start = max(end, start+1)\n return ans\n","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n if len(A) == 0:\n return 0\n increasing = False\n count = -float('inf')\n last = A[0]\n max_len = 0\n for i in range(1,len(A)):\n if A[i] > last and increasing:\n count += 1\n elif A[i] > last and not increasing:\n count = 2\n increasing = True\n elif A[i] < last and increasing:\n count += 1\n increasing = False\n max_len = max(max_len, count)\n elif A[i] < last and not increasing:\n count += 1\n max_len = max(max_len, count)\n else:\n if not increasing:\n max_len = max(max_len, count)\n count = -float('inf')\n increasing = False\n last = A[i]\n \n if max_len < 3:\n return 0\n return max_len\n \n\n\n","class Solution:\n def longestMountain(self, A):\n res = up = down = 0\n for i in range(1, len(A)):\n if down and A[i - 1] < A[i] or A[i - 1] == A[i]: up = down = 0\n up += A[i - 1] < A[i]\n down += A[i - 1] > A[i]\n if up and down: res = max(res, up + down + 1)\n return res\n","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n if not A or len(A) < 3:\n return 0\n \n left = right = mid = max_moun = 0\n while right < len(A):\n \n prev = mid\n while right + 1 < len(A) and A[right + 1] > A[right]:\n right += 1\n mid += 1\n \n if prev != mid:\n while right + 1 < len(A) and A[right + 1] < A[right]:\n right += 1\n\n if mid != 0 and mid != len(A) - 1:\n max_moun = max(max_moun, right - left + 1)\n \n right = mid + 1\n left = right\n mid = right\n \n if max_moun < 3:\n return 0\n \n return max_moun","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n left = right = 0\n max_length = 0\n while left < len(A):\n \n prev = A[left]\n climbing = False\n descending = False\n right = left + 1\n while right < len(A):\n current = A[right]\n if prev < current and not descending:\n climbing = True\n elif prev > current and (climbing or descending):\n climbing = False\n descending = True\n else:\n right -= 1\n break\n right += 1\n prev = current\n \n if right == len(A):\n right -= 1\n \n curr_length = right - left + 1\n if curr_length > 2 and descending:\n max_length = max(max_length, curr_length)\n \n left = max(left + 1, right)\n \n return max_length","class Solution:\n def mountain_search(self,start,A):\n valid_mountain = True\n i = start\n while (i < len(A)-1 and A[i] < A[i+1]):\n i+=1\n if (i < len(A)-1 and A[i] != A[i+1]):\n while (i < len(A)-1 and A[i] > A[i+1]):\n i+=1\n else:\n valid_mountain = False\n \n return valid_mountain, i\n \n def longestMountain(self, A: List[int]) -> int:\n # Idea: go through every element in array and try to build largest mountain\n max_mountain = 0\n i = 0\n if not A: return 0\n A.append(A[-1]+1)\n \n while i < len(A)-3:\n if A[i] < A[i+1]:\n valid, new_i = self.mountain_search(i, A)\n if valid:\n max_mountain = max(max_mountain, new_i-i+1)\n i = new_i\n else:\n i+=1\n return max_mountain\n \n","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n res = 0\n for i in range(1,len(A) - 1):\n if A[i + 1] < A[i] > A[i - 1]:\n l = r = i\n \n while l and A[l] > A[l - 1]:\n l -= 1\n \n while r + 1 < len(A) and A[r] > A[r + 1]:\n r += 1\n \n if r - l + 1 > res:\n res = r - l + 1\n return res","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n is_peak = False\n index = 1\n longest = 0\n while index < len(A) - 1:\n if A[index] > A[index-1] and A[index] > A[index+1]:\n is_peak = True\n if not is_peak:\n index += 1\n continue\n left = index-1\n while left-1 >= 0 and A[left] > A[left-1]:\n left -= 1\n right = index+1\n while right+1 < len(A) and A[right] > A[right+1]:\n right += 1\n longest = max(longest, right-left+1)\n index = right\n is_peak = False\n return longest","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n up = down = ans = 0\n for i in range(1, len(A)):\n if A[i-1]==A[i]:\n up = down = 0\n elif A[i-1]<A[i]:\n if down or up==0:\n up = 2\n down = 0\n else:\n up += 1\n else:\n down += 1\n if up and down:\n ans = max(ans, up+down)\n return ans\n \n \n '''\n up = down = ans = 0\n for i in range(1, len(A)):\n if A[i-1]>A[i] and up:\n down += 1\n if A[i-1]==A[i] or A[i-1]<A[i] and down or i==len(A)-1:\n if up and down:\n ans = max(ans, up+down)\n up = down = 0\n if A[i-1]<A[i]:\n up = 2 if not up else up+1\n\n return ans\n '''\n \n '''\n l = ans = 0\n phase = 0 #0:ascend, 1: descend\n for r in range(1, len(A)):\n if phase==0:\n if A[r-1]==A[r]:\n l = r\n elif A[r-1]>A[r]:\n if l+1<r:\n phase = 1\n else:\n l = r\n if phase==1:\n if A[r-1]<=A[r] or r==len(A)-1:\n ans = max(ans, r-l)\n if r==len(A)-1 and A[r-1]>A[r] and r-l==ans:\n ans += 1\n l = r if A[r-1]==A[r] else r-1\n phase = 0\n \n return ans\n ''' ","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n res = cur = 1\n desc = False\n for i in range(1, len(A)):\n if A[i-1] == A[i]:\n if desc: res = max(res, cur)\n desc = False\n cur = 1\n elif A[i-1] < A[i]:\n if not desc: cur += 1\n else:\n res = max(res, cur)\n cur = 2\n desc = False\n else:\n if desc: cur += 1\n elif cur > 1: \n desc = True\n cur += 1\n else:\n cur = 1\n desc = False\n if desc: res = max(res, cur)\n return 0 if res < 3 and not desc else res","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n res = 0\n i = 0\n \n while i < len(A):\n j = i\n while j + 1 < len(A) and A[j] < A[j+1]:\n j += 1\n mid = j\n while j + 1 < len(A) and A[j] > A[j+1]:\n j += 1\n if i < mid < j:\n res = max(res, j-i+1)\n if i == j:\n i +=1\n else:\n i = j\n \n return res","'''\n\nmountain = relative maximum\n- find decr and incr after mountain\n\n[2,1,4,7,3,2,5]\n\n[2,3,2]\n\n\nwhile j < len\n use flag to incr and decr\n \n while next and next incr\n j+=1\n \n if not incr:\n incr and cont\n \n while next and next decr\n j+=1\n \n if not decr:\n incr and cont\n \n if len 3\n check/override max\n'''\n\nclass Solution:\n def longestMountain(self, A: List[int]) -> int:\n \n long_mont = 0\n i, j = 0, 0\n \n while j < len(A):\n \n incr = False\n while j!=len(A)-1 and A[j] < A[j+1]:\n incr = True\n j+=1\n \n if not incr:\n j+=1\n i=j\n continue\n \n decr = False\n while j!=len(A)-1 and A[j] > A[j+1]:\n decr = True\n j+=1\n \n if not decr:\n j+=1\n i=j\n continue\n \n curr_len = j-i+1\n if curr_len >= 3:\n long_mont = max(long_mont, curr_len)\n\n i = j\n \n return long_mont\n","class Solution(object):\n def longestMountain(self, A):\n N = len(A)\n ans = base = 0\n\n while base < N:\n end = base\n if end + 1 < N and A[end] < A[end + 1]: #if base is a left-boundary\n #set end to the peak of this potential mountain\n while end+1 < N and A[end] < A[end+1]:\n end += 1\n\n if end + 1 < N and A[end] > A[end + 1]: #if end is really a peak..\n #set 'end' to right-boundary of mountain\n while end+1 < N and A[end] > A[end+1]:\n end += 1\n #record candidate answer\n ans = max(ans, end - base + 1)\n\n base = max(end, base + 1)\n\n return ans","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n # Write your code here.\n longest, i = 0, 1\n while i < len(A) - 1:\n is_peak = A[i-1] < A[i] and A[i] > A[i+1]\n #Check if i is peak\n if is_peak:\n left = i-2\n #Move left pointer left while in bounds and greater\n while left >= 0 and A[left] < A[left + 1]:\n left -= 1\n right = i + 2\n #Move right pointer right while in bounds and greater\n while right < len(A) and A[right] < A[right - 1]:\n right += 1\n #Current peak \n longest = max(longest, right - left - 1)\n #Increment i\n i = right\n #If i is not peak, increment and continue.\n else:\n i += 1\n continue\n return longest","class Solution:\n def longestMountain(self, A: List[int]) -> int:\n if len(A)<3:\n return 0\n a=A\n start =0\n end = 0\n maxlen=0\n n=len(a)\n while(start<n-1 and end<n):\n end = start\n if a[start]<a[start+1]:\n while end<n-1 and a[end]<a[end+1]:\n end+=1\n if end<n-1 and a[end]>a[end+1]:\n while(end<n-1 and a[end]>a[end+1]):\n end +=1\n maxlen = max(maxlen,end-start+1)\n start = max(start+1,end)\n \n return maxlen"],"string":"[\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n up=0\\n down=0\\n ans=0\\n for i in range(0,len(A)-1):\\n if A[i]<A[i+1]:\\n if down==0:\\n up+=1\\n else:\\n up=1\\n down=0\\n \\n elif A[i]>A[i+1]:\\n if up>0:\\n down+=1\\n mountain=up+down+1\\n if ans<mountain:\\n ans=mountain\\n \\n else:\\n up=0\\n down=0\\n\\n \\n \\n return ans\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n \\n leftpivot = 0\\n rightpivot = 0\\n ascendign = False\\n descending = False\\n changes = 0\\n highest = 0\\n while(leftpivot<len(A)):\\n rightpivot=leftpivot\\n \\n if(rightpivot+1 < len(A) and A[rightpivot]<A[rightpivot+1]):\\n while(rightpivot + 1<len(A) and A[rightpivot]<A[rightpivot+1] ):\\n rightpivot+=1\\n\\n\\n if(rightpivot + 1<len(A) and A[rightpivot]>A[rightpivot+1]):\\n while(rightpivot<(len(A)-1) and A[rightpivot]>A[rightpivot+1]):\\n rightpivot+=1 \\n highest = max(highest,rightpivot+1-leftpivot)\\n\\n leftpivot = max(rightpivot,leftpivot+1)\\n return highest\\n\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if len(A) < 3:\\n return 0\\n \\n prev_height = None\\n peaks = [0 for _ in range(len(A))]\\n has_increment = False\\n \\n # combs left to right for peaks\\n for idx in range(len(A)):\\n if prev_height is not None:\\n if prev_height < A[idx]:\\n peaks[idx] = peaks[idx-1] + 1\\n has_increment = True\\n else:\\n if has_increment:\\n peaks[idx-1] += 1\\n peaks[idx] = 0\\n has_increment = False\\n prev_height = A[idx]\\n \\n print(peaks)\\n \\n # combs right to left for peaks\\n prev_height = None\\n max_so_far = 0\\n has_increment = False\\n \\n for idx in range(len(A)-1, -1, -1):\\n if prev_height is not None:\\n if prev_height < A[idx]:\\n peaks[idx] += peaks[idx+1] + 1\\n has_increment = True\\n else:\\n if has_increment and prev_height > A[idx]:\\n max_so_far = max(max_so_far, peaks[idx+1])\\n peaks[idx] = peaks[idx]\\n has_increment = False\\n prev_height = A[idx]\\n \\n print(peaks)\\n \\n return max_so_far\\n\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if len(A) < 3:\\n return 0\\n \\n n = len(A)\\n ups, downs = [0] * n, [0] * n\\n i, j = 0, n - 1\\n \\n while i < n - 1:\\n if A[i] < A[i+1]:\\n ups[i+1] = ups[i] + 1\\n \\n i += 1\\n \\n while j > 0:\\n if A[j] < A[j-1]:\\n downs[j-1] = downs[j] + 1\\n \\n j -= 1\\n \\n print((ups, downs))\\n longest = [u + d + 1 for u, d in zip(ups, downs) if u and d]\\n \\n return max(longest) if longest else 0\\n\",\n \"class Solution:\\n \\n def longestMountain(self, A: List[int]) -> int:\\n N = len(A)\\n prefix = [1] * N\\n suffix = [1] * N\\n \\n for i, num in enumerate(A[1:], 1):\\n i_rev = N - i - 1\\n prefix[i] = prefix[i-1] + 1 if A[i-1] < num else 1\\n suffix[i_rev] = suffix[i_rev+1] + 1 if A[i_rev] > A[i_rev+1] else 1\\n \\n ans = 0\\n for i, num in enumerate(A):\\n left = prefix[i]\\n right = suffix[i]\\n length = left + right - 1\\n \\n if length >= 3 and min(left, right) > 1:\\n ans = max(ans, length)\\n \\n return ans\\n\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n \\n leftIncreasing = [0 for x in range(len(A))]\\n rightIncreasing = [0 for x in range(len(A))]\\n \\n for x in range(1, len(A)):\\n \\n if A[x] > A[x - 1]:\\n leftIncreasing[x] += (leftIncreasing[x - 1] + 1)\\n \\n if A[len(A) - 1 - x] > A[len(A) - x]:\\n rightIncreasing[len(A) - 1 - x] += (rightIncreasing[len(A) - x] + 1)\\n \\n result = 0\\n \\n for x in range(len(A)):\\n \\n if leftIncreasing[x] and rightIncreasing[x]:\\n result = max(result, leftIncreasing[x] + rightIncreasing[x] + 1)\\n \\n return result if result >= 3 else 0\\n\",\n \"class Solution:\\n\\n def longestMountain(self, A):\\n up, down = [0] * len(A), [0] * len(A)\\n for i in range(1, len(A)):\\n if A[i] > A[i - 1]: up[i] = up[i - 1] + 1\\n for i in range(len(A) - 1)[::-1]:\\n if A[i] > A[i + 1]: down[i] = down[i + 1] + 1\\n \\n print(down)\\n print(up)\\n return max([u + d + 1 for u, d in zip(up, down) if u and d] or [0])\\n\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if len(A) < 3:\\n return 0\\n \\n longestMountain = 0\\n\\n for i in range(1, len(A) - 1):\\n # Index i denotes a 'peak' in the mountain.\\n if A[i - 1] < A[i] > A[i + 1]:\\n left = right = i\\n \\n # Traverse left and down the mountain from i until there is no longer a downwards slope.\\n while left > 0 and A[left - 1] < A[left]:\\n left -= 1\\n \\n # Traverse right and down the mountain from i until there is no longer a downwards slope.\\n while right + 1 < len(A) and A[right + 1] < A[right]:\\n right += 1\\n \\n # The length of the mountain will be the distance from left and right (+ 1 to factor in the peak).\\n mountainLength = right - left + 1\\n longestMountain = max(longestMountain, mountainLength)\\n \\n return longestMountain\",\n \"class Solution:\\n def longestMountain(self, a: List[int]) -> int:\\n ml = 0\\n i = 0\\n while(i<len(a)):\\n c = 0\\n if i+1<len(a) and a[i+1]>a[i]:\\n c = 1\\n while(i+1<len(a) and a[i+1]>a[i]):\\n c = c + 1\\n i = i + 1\\n while(i+1<len(a) and a[i+1]<a[i]):\\n c = c + 1\\n ml = max(c,ml)\\n i = i + 1\\n else:\\n i = i + 1\\n return ml\\n \\n\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n idx = 0\\n big = 0\\n while idx+1 < len(A):\\n long = 1\\n if A[idx+1] > A[idx]:\\n while idx+1 < len(A) and A[idx+1] > A[idx]:\\n idx += 1\\n long += 1\\n else:\\n idx += 1\\n continue\\n if idx+1 < len(A) and A[idx+1] < A[idx]:\\n while idx+1 < len(A) and A[idx+1] < A[idx]:\\n idx += 1\\n long += 1\\n else:\\n idx += 1\\n continue\\n big = max(long, big)\\n return big if big >= 3 else 0\",\n \"class Solution:\\n def longestMountain(self, A):\\n res = up = down = 0\\n for i in range(1, len(A)):\\n if down and A[i - 1] < A[i] or A[i - 1] == A[i]: up = down = 0\\n up += A[i - 1] < A[i]\\n down += A[i - 1] > A[i]\\n if up and down: res = max(res, up + down + 1)\\n return res\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n res = up = down = 0\\n for i in range(1, len(A)):\\n if down and A[i - 1] < A[i] or A[i - 1] == A[i]:\\n up = down = 0\\n if A[i - 1] < A[i]:\\n up += 1\\n else:\\n down += 1\\n if up and down:\\n res = max(res, up + down + 1)\\n return res\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n n=len(A)\\n left_inc=[0]*n\\n for i in range(1,n):\\n if A[i]>A[i-1]:\\n left_inc[i]=1+left_inc[i-1]\\n print(left_inc)\\n \\n right_inc=[0]*n\\n for i in range(n-2,-1,-1):\\n if A[i]>A[i+1]:\\n right_inc[i]=1+right_inc[i+1]\\n print(right_inc)\\n \\n res=0\\n for i in range(n):\\n if left_inc[i]!=0 and right_inc[i]!=0:\\n res=max(res,left_inc[i]+right_inc[i]+1)\\n \\n return res if res>=3 else 0\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n # edge case\\n if len(A)==0: return 0\\n \\n n = len(A)\\n peak = None\\n maxMountainLen = 0\\n \\n i = 1\\n while (i+1) <n:\\n if A[i-1]<A[i] and A[i]>A[i+1]:\\n # already obtained the peak\\n left = right = i\\n \\n while (left-1)>=0 and A[left-1] < A[left]:\\n left -= 1\\n \\n while (right+1) <n and A[right+1] < A[right]:\\n right += 1\\n \\n # max length of mountain\\n maxMountainLen = max(maxMountainLen, right-left+1)\\n i=right+1\\n else:\\n i+=1\\n \\n return maxMountainLen\\n\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n \\n i = 0\\n answer = 0\\n while i < len(A) - 1:\\n \\n j = i + 1\\n visited_top = False\\n \\n while j < len(A):\\n print(i, j)\\n if A[j] > A[j-1]:\\n if visited_top:\\n break\\n \\n if A[j] < A[j-1]:\\n if not visited_top:\\n if j - i == 1:\\n break\\n visited_top = True\\n \\n if A[j] == A[j-1]:\\n break\\n j += 1\\n\\n \\n \\n if visited_top and j - i > 2:\\n answer = max(answer, j - i)\\n i = j\\n if visited_top:\\n i -= 1\\n \\n return answer\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n import copy \\n \\n if not A:\\n return 0\\n \\n dp = []\\n B = copy.deepcopy(A)\\n B.insert(0, A[0])\\n B.append(A[-1])\\n \\n for i in range(1,len(B) - 1):\\n \\n if (B[i-1] < B[i] and B[i+1] < B[i]):\\n dp.append(i-1)\\n \\n \\n ret = []\\n A.append(A[-1])\\n for top in dp:\\n \\n \\n left = top\\n while A[left - 1] < A[left] and left > 0:\\n left -= 1\\n \\n right = top\\n while A[right + 1] < A[right]:\\n right +=1\\n \\n print(right, left)\\n ret.append(right -left + 1)\\n \\n print(dp, ret)\\n \\n \\n return max(ret) if ret else 0\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if not A or len(A)==1: return 0\\n m=len(A)\\n up,down=[0 for i in range(m)],[0 for i in range(m)]\\n up[0], down[-1]=0,0\\n for i in range(1,m):\\n j=m-1-i\\n if A[i]>A[i-1]:\\n up[i]=up[i-1]+1\\n else:up[i]=0\\n if A[j]>A[j+1]:\\n down[j]=down[j+1]+1\\n else: down[j]=0\\n ans=0\\n for i in range(m):\\n if up[i] and down[i]: ## need peak\\n ans=max(ans,up[i]+down[i]+1)\\n return ans\\n \\n \\n \\n \\n\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n \\n ans = 0\\n temp = 0\\n trend = False\\n \\n if len(A)<3: return 0\\n good = False\\n \\n for i in range(1,len(A)):\\n \\n diff = A[i]-A[i-1]\\n if diff>0:\\n if not trend:\\n good = True\\n trend = True\\n temp = 2\\n else:\\n temp=max(temp+1,2)\\n elif diff<0:\\n if trend:\\n trend = False\\n temp = max(temp+1,2)\\n ans = max(ans,temp)\\n else:\\n temp=max(temp+1,2)\\n if good: ans = max(ans,temp)\\n else:\\n temp = 0\\n trend = False\\n good = False\\n print(A[i], temp,trend, ans)\\n \\n # ans = max(ans,temp)\\n \\n return ans\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if len(A) < 3: return 0\\n up, down, Max = [1] * len(A), [1] * len(A), 0\\n for i in range(1, len(A)):\\n if A[i] > A[i - 1]: up[i] = up[i - 1] + 1\\n \\n for i in range(len(A) - 2, -1, -1):\\n if A[i] > A[i + 1]: down[i] = down[i + 1] + 1\\n \\n # print(up)\\n # print(down)\\n \\n for i in range(1, len(A) - 1):\\n if A[i - 1] < A[i] > A[i + 1]:\\n Max = max(Max, up[i] + down[i] - 1)\\n return Max \\n \\n \\n \\n \\n\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n # https://leetcode.com/problems/longest-mountain-in-array/discuss/135593/C%2B%2BJavaPython-1-pass-and-O(1)-space\\n res = up = down = 0\\n for i in range(1, len(A)):\\n if down and A[i - 1] < A[i] or A[i - 1] == A[i]: up = down = 0\\n up += A[i - 1] < A[i]\\n down += A[i - 1] > A[i]\\n if up and down: res = max(res, up + down + 1)\\n return res\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n N = len(A)\\n up = [1]*N\\n for i in range(1, N):\\n if A[i]>A[i-1]: up[i]+=up[i-1]\\n down = [1]*N\\n for i in range(N-2,-1, -1):\\n if A[i]>A[i+1]: down[i]+=down[i+1]\\n # print(up, down)\\n return max([u+d-1 for u, d in zip(up, down) if u>1 and d>1 and u+d-1>=3] or [0])\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n res = up = down = 0\\n for i in range(1, len(A)):\\n if down and A[i-1] < A[i] or A[i-1] == A[i]: # to check if we found down and the next is up\\n up = down = 0 # reset for next down and make sure we are counting right up's\\n up += A[i-1] < A[i]\\n down += A[i-1] > A[i]\\n if up and down:\\n res = max(res, up+down+1)\\n return res\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if not A: return 0\\n # None -> Haven't started a mountain, True -> rising up, False -> Falling down\\n rising = None\\n curr = 0\\n best = 0\\n prev = None\\n for i,x in enumerate(A):\\n print((i,':', x, 'curr', curr))\\n if prev is None:\\n prev = x\\n curr = best = 1\\n continue\\n \\n if rising is None and x < prev:\\n prev = x\\n continue\\n if rising is None and x > prev:\\n rising = True\\n prev = x\\n curr = 2\\n continue\\n \\n # Continue rising\\n if rising and x > prev:\\n curr += 1\\n # Continue falling\\n elif not rising and x < prev:\\n curr += 1\\n # Failure regardless of rising/not rising\\n elif x == prev:\\n rising = None\\n best = max(best, curr)\\n # Was rising, gonna fall now\\n elif rising and x < prev:\\n rising = False\\n curr += 1\\n # Was falling, gonna start a new mountain\\n elif not rising and x > prev:\\n best = max(best, curr)\\n rising = True\\n curr = 2 # x and the previous\\n \\n prev = x\\n # Check if \\n if rising is not None and not rising:\\n best = max(best, curr)\\n return 0 if best < 3 else best\\n \\n\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n N = len(A)\\n start = 0 \\n ans = 0 \\n while start < N:\\n end = start\\n if end + 1 < N and A[end] < A[end+1]:\\n while end + 1 < N and A[end] < A[end+1]:\\n end +=1\\n if end + 1 < N and A[end] > A[end+1]:\\n while end + 1 < N and A[end] > A[end+1]:\\n end +=1\\n ans = max(ans, end-start+1)\\n start = max(end, start+1)\\n return ans\\n\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if len(A) == 0:\\n return 0\\n increasing = False\\n count = -float('inf')\\n last = A[0]\\n max_len = 0\\n for i in range(1,len(A)):\\n if A[i] > last and increasing:\\n count += 1\\n elif A[i] > last and not increasing:\\n count = 2\\n increasing = True\\n elif A[i] < last and increasing:\\n count += 1\\n increasing = False\\n max_len = max(max_len, count)\\n elif A[i] < last and not increasing:\\n count += 1\\n max_len = max(max_len, count)\\n else:\\n if not increasing:\\n max_len = max(max_len, count)\\n count = -float('inf')\\n increasing = False\\n last = A[i]\\n \\n if max_len < 3:\\n return 0\\n return max_len\\n \\n\\n\\n\",\n \"class Solution:\\n def longestMountain(self, A):\\n res = up = down = 0\\n for i in range(1, len(A)):\\n if down and A[i - 1] < A[i] or A[i - 1] == A[i]: up = down = 0\\n up += A[i - 1] < A[i]\\n down += A[i - 1] > A[i]\\n if up and down: res = max(res, up + down + 1)\\n return res\\n\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if not A or len(A) < 3:\\n return 0\\n \\n left = right = mid = max_moun = 0\\n while right < len(A):\\n \\n prev = mid\\n while right + 1 < len(A) and A[right + 1] > A[right]:\\n right += 1\\n mid += 1\\n \\n if prev != mid:\\n while right + 1 < len(A) and A[right + 1] < A[right]:\\n right += 1\\n\\n if mid != 0 and mid != len(A) - 1:\\n max_moun = max(max_moun, right - left + 1)\\n \\n right = mid + 1\\n left = right\\n mid = right\\n \\n if max_moun < 3:\\n return 0\\n \\n return max_moun\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n left = right = 0\\n max_length = 0\\n while left < len(A):\\n \\n prev = A[left]\\n climbing = False\\n descending = False\\n right = left + 1\\n while right < len(A):\\n current = A[right]\\n if prev < current and not descending:\\n climbing = True\\n elif prev > current and (climbing or descending):\\n climbing = False\\n descending = True\\n else:\\n right -= 1\\n break\\n right += 1\\n prev = current\\n \\n if right == len(A):\\n right -= 1\\n \\n curr_length = right - left + 1\\n if curr_length > 2 and descending:\\n max_length = max(max_length, curr_length)\\n \\n left = max(left + 1, right)\\n \\n return max_length\",\n \"class Solution:\\n def mountain_search(self,start,A):\\n valid_mountain = True\\n i = start\\n while (i < len(A)-1 and A[i] < A[i+1]):\\n i+=1\\n if (i < len(A)-1 and A[i] != A[i+1]):\\n while (i < len(A)-1 and A[i] > A[i+1]):\\n i+=1\\n else:\\n valid_mountain = False\\n \\n return valid_mountain, i\\n \\n def longestMountain(self, A: List[int]) -> int:\\n # Idea: go through every element in array and try to build largest mountain\\n max_mountain = 0\\n i = 0\\n if not A: return 0\\n A.append(A[-1]+1)\\n \\n while i < len(A)-3:\\n if A[i] < A[i+1]:\\n valid, new_i = self.mountain_search(i, A)\\n if valid:\\n max_mountain = max(max_mountain, new_i-i+1)\\n i = new_i\\n else:\\n i+=1\\n return max_mountain\\n \\n\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n res = 0\\n for i in range(1,len(A) - 1):\\n if A[i + 1] < A[i] > A[i - 1]:\\n l = r = i\\n \\n while l and A[l] > A[l - 1]:\\n l -= 1\\n \\n while r + 1 < len(A) and A[r] > A[r + 1]:\\n r += 1\\n \\n if r - l + 1 > res:\\n res = r - l + 1\\n return res\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n is_peak = False\\n index = 1\\n longest = 0\\n while index < len(A) - 1:\\n if A[index] > A[index-1] and A[index] > A[index+1]:\\n is_peak = True\\n if not is_peak:\\n index += 1\\n continue\\n left = index-1\\n while left-1 >= 0 and A[left] > A[left-1]:\\n left -= 1\\n right = index+1\\n while right+1 < len(A) and A[right] > A[right+1]:\\n right += 1\\n longest = max(longest, right-left+1)\\n index = right\\n is_peak = False\\n return longest\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n up = down = ans = 0\\n for i in range(1, len(A)):\\n if A[i-1]==A[i]:\\n up = down = 0\\n elif A[i-1]<A[i]:\\n if down or up==0:\\n up = 2\\n down = 0\\n else:\\n up += 1\\n else:\\n down += 1\\n if up and down:\\n ans = max(ans, up+down)\\n return ans\\n \\n \\n '''\\n up = down = ans = 0\\n for i in range(1, len(A)):\\n if A[i-1]>A[i] and up:\\n down += 1\\n if A[i-1]==A[i] or A[i-1]<A[i] and down or i==len(A)-1:\\n if up and down:\\n ans = max(ans, up+down)\\n up = down = 0\\n if A[i-1]<A[i]:\\n up = 2 if not up else up+1\\n\\n return ans\\n '''\\n \\n '''\\n l = ans = 0\\n phase = 0 #0:ascend, 1: descend\\n for r in range(1, len(A)):\\n if phase==0:\\n if A[r-1]==A[r]:\\n l = r\\n elif A[r-1]>A[r]:\\n if l+1<r:\\n phase = 1\\n else:\\n l = r\\n if phase==1:\\n if A[r-1]<=A[r] or r==len(A)-1:\\n ans = max(ans, r-l)\\n if r==len(A)-1 and A[r-1]>A[r] and r-l==ans:\\n ans += 1\\n l = r if A[r-1]==A[r] else r-1\\n phase = 0\\n \\n return ans\\n ''' \",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n res = cur = 1\\n desc = False\\n for i in range(1, len(A)):\\n if A[i-1] == A[i]:\\n if desc: res = max(res, cur)\\n desc = False\\n cur = 1\\n elif A[i-1] < A[i]:\\n if not desc: cur += 1\\n else:\\n res = max(res, cur)\\n cur = 2\\n desc = False\\n else:\\n if desc: cur += 1\\n elif cur > 1: \\n desc = True\\n cur += 1\\n else:\\n cur = 1\\n desc = False\\n if desc: res = max(res, cur)\\n return 0 if res < 3 and not desc else res\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n res = 0\\n i = 0\\n \\n while i < len(A):\\n j = i\\n while j + 1 < len(A) and A[j] < A[j+1]:\\n j += 1\\n mid = j\\n while j + 1 < len(A) and A[j] > A[j+1]:\\n j += 1\\n if i < mid < j:\\n res = max(res, j-i+1)\\n if i == j:\\n i +=1\\n else:\\n i = j\\n \\n return res\",\n \"'''\\n\\nmountain = relative maximum\\n- find decr and incr after mountain\\n\\n[2,1,4,7,3,2,5]\\n\\n[2,3,2]\\n\\n\\nwhile j < len\\n use flag to incr and decr\\n \\n while next and next incr\\n j+=1\\n \\n if not incr:\\n incr and cont\\n \\n while next and next decr\\n j+=1\\n \\n if not decr:\\n incr and cont\\n \\n if len 3\\n check/override max\\n'''\\n\\nclass Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n \\n long_mont = 0\\n i, j = 0, 0\\n \\n while j < len(A):\\n \\n incr = False\\n while j!=len(A)-1 and A[j] < A[j+1]:\\n incr = True\\n j+=1\\n \\n if not incr:\\n j+=1\\n i=j\\n continue\\n \\n decr = False\\n while j!=len(A)-1 and A[j] > A[j+1]:\\n decr = True\\n j+=1\\n \\n if not decr:\\n j+=1\\n i=j\\n continue\\n \\n curr_len = j-i+1\\n if curr_len >= 3:\\n long_mont = max(long_mont, curr_len)\\n\\n i = j\\n \\n return long_mont\\n\",\n \"class Solution(object):\\n def longestMountain(self, A):\\n N = len(A)\\n ans = base = 0\\n\\n while base < N:\\n end = base\\n if end + 1 < N and A[end] < A[end + 1]: #if base is a left-boundary\\n #set end to the peak of this potential mountain\\n while end+1 < N and A[end] < A[end+1]:\\n end += 1\\n\\n if end + 1 < N and A[end] > A[end + 1]: #if end is really a peak..\\n #set 'end' to right-boundary of mountain\\n while end+1 < N and A[end] > A[end+1]:\\n end += 1\\n #record candidate answer\\n ans = max(ans, end - base + 1)\\n\\n base = max(end, base + 1)\\n\\n return ans\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n # Write your code here.\\n longest, i = 0, 1\\n while i < len(A) - 1:\\n is_peak = A[i-1] < A[i] and A[i] > A[i+1]\\n #Check if i is peak\\n if is_peak:\\n left = i-2\\n #Move left pointer left while in bounds and greater\\n while left >= 0 and A[left] < A[left + 1]:\\n left -= 1\\n right = i + 2\\n #Move right pointer right while in bounds and greater\\n while right < len(A) and A[right] < A[right - 1]:\\n right += 1\\n #Current peak \\n longest = max(longest, right - left - 1)\\n #Increment i\\n i = right\\n #If i is not peak, increment and continue.\\n else:\\n i += 1\\n continue\\n return longest\",\n \"class Solution:\\n def longestMountain(self, A: List[int]) -> int:\\n if len(A)<3:\\n return 0\\n a=A\\n start =0\\n end = 0\\n maxlen=0\\n n=len(a)\\n while(start<n-1 and end<n):\\n end = start\\n if a[start]<a[start+1]:\\n while end<n-1 and a[end]<a[end+1]:\\n end+=1\\n if end<n-1 and a[end]>a[end+1]:\\n while(end<n-1 and a[end]>a[end+1]):\\n end +=1\\n maxlen = max(maxlen,end-start+1)\\n start = max(start+1,end)\\n \\n return maxlen\"\n]","isConversational":false},"n_sols":{"kind":"number","value":38,"string":"38"},"non_interactive_idx":{"kind":"list like","value":[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],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32,\n 33,\n 34,\n 35,\n 36,\n 37\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[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],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":70,"cells":{"problem_id":{"kind":"number","value":203,"string":"203"},"question":{"kind":"string","value":"A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).\n\nThe robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).\n\nHow many possible unique paths are there?\n\n\nAbove is a 7 x 3 grid. How many possible unique paths are there?\n\nNote: m and n will be at most 100.\n\nExample 1:\n\n\nInput: m = 3, n = 2\nOutput: 3\nExplanation:\nFrom the top-left corner, there are a total of 3 ways to reach the bottom-right corner:\n1. Right -> Right -> Down\n2. Right -> Down -> Right\n3. Down -> Right -> Right\n\n\nExample 2:\n\n\nInput: m = 7, n = 3\nOutput: 28"},"solutions":{"kind":"string","value":"[\"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n def f(n):\\n ret = 1\\n for i in range(1, n+1):\\n ret *= i\\n return ret\\n return f(m+n-2)//(f(m-1)*f(n-1))\", \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n sol = [[0 for j in range(n)] for i in range(m)]\\n sol[0][0] = 1\\n for i in range(0, m ):\\n for j in range(0, n ):\\n if i == 0 or j == 0: sol[i][j] = 1\\n else: sol[i][j] = sol[i-1][j] + sol[i][j-1]\\n \\n return sol[-1][-1]\", \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n counts = {}\\n counts[(1, 1)] = 1\\n for r in range(2, m+ 1):\\n counts[(r, 1)] = 1\\n for c in range(2, n + 1):\\n counts[(1, c)] = 1\\n for i in range(2, m +1):\\n for j in range(2, n + 1):\\n counts[(i, j)] = counts[(i - 1, j)] + counts[(i, j -1)]\\n return counts[(m, n)]\\n \\n \\n def temp(self, m, n):\\n cache = {}\\n def go(m, n):\\n if m == 1 and n == 1:\\n return 1\\n count = 0\\n if m > 1:\\n if (m -1, n) not in cache:\\n cache[(m-1, n)] = go(m-1, n)\\n count += cache[(m-1, n)]\\n if n > 1:\\n if (m, n - 1) not in cache:\\n cache[(m, n-1)] = go(m, n-1)\\n count += cache[(m, n -1)]\\n return count\\n return go(m, n)\", \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n a = m - 1\\n b = n - 1\\n ret = 1\\n for i in range(b):\\n ret = ret * (a+b-i) / (b-i)\\n return round(ret)\", \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n num_paths = [[0 for _ in range(n)] for _ in range(m)]\\n for i in range(m):\\n for j in range(n):\\n above = num_paths[i-1][j] if i > 0 else 0\\n left = num_paths[i][j-1] if j > 0 else 0\\n num_paths[i][j] = above + left\\n if i==0 and j==0:\\n num_paths[0][0] = 1\\n return num_paths[m-1][n-1]\\n\", \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n aux = [[1 for x in range(n)] for x in range(m)]\\n for i in range(1, m):\\n for j in range(1, n):\\n aux[i][j] = aux[i][j-1]+aux[i-1][j]\\n return aux[-1][-1]\\n\", \"class Solution:\\n def __init__(self):\\n self.dp = [[0 for _ in range(101)] for _ in range(101)]\\n def go(self, x, y, m, n):\\n if self.dp[x][y] == 0:\\n if x == m or y == n:\\n self.dp[x][y] = 0\\n elif x == m - 1 and y == n - 1:\\n self.dp[x][y] = 1\\n elif x == m - 1 and y == n-1:\\n self.dp[x][y] = 1\\n else:\\n self.dp[x][y] = self.go(x+1, y, m, n) + self.go(x, y+1, m, n)\\n return self.dp[x][y]\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n return self.go(0, 0, m, n)\\n\", \"class Solution:\\n import math\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if m==1 or n==1:\\n return 1\\n r,c = m-1, n-1\\n return int(math.factorial(r+c)/(math.factorial(r)*math.factorial(c)))\\n\", \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if 0 in (m,n):return 0\\n results = [[1] * n]*m\\n for i in range(1, m):\\n for j in range(1, n):\\n results[i][j] = results[i-1][j] + results[i][j-1]\\n return results[m-1][n-1]\", \"class Solution:\\n def uniquePaths(self, m, n, memo = None):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if m == 1 and n == 1:\\n return 1\\n if m < 1 or n < 1:\\n return 0\\n \\n if not memo:\\n memo = [[0 for i in range(n+1)] for j in range(m+1)]\\n \\n if memo[m][n]:\\n return memo[m][n]\\n else:\\n memo[m][n] = self.uniquePaths(m-1, n, memo) + self.uniquePaths(m, n-1, memo)\\n return memo[m][n]\\n \\n \\n\", \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n M = [[1 for _ in range(n)] for _ in range(2)]\\n for i in range(m-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if i == m-1 or j == n-1: continue\\n else: M[i%2][j] = M[(i+1)%2][j] + M[i%2][j+1]\\n return M[0][0]\", \"class Solution:\\n def paths(self,m,n,a,b,memo):\\n if m>a or n>b:\\n return 0\\n if m==a and n==b:\\n return 1\\n if str(m)+\\\" \\\"+str(n) not in memo:\\n memo[str(m)+\\\" \\\"+str(n)] = self.paths(m+1,n,a,b,memo) + self.paths(m,n+1,a,b,memo)\\n \\n return memo[str(m)+\\\" \\\"+str(n)]\\n \\n \\n def uniquePaths(self, m, n):\\n memo = dict()\\n return(self.paths(0,0,m-1,n-1,memo))\", \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n matrix = [[0 for j in range(n)] for i in range(m)]\\n \\n matrix[0][0] = 1\\n \\n for i in range(m):\\n for j in range(n):\\n if i == 0 and j == 0:\\n continue\\n elif i == 0:\\n matrix[i][j] = matrix[i][j-1]\\n elif j == 0:\\n matrix[i][j] = matrix[i-1][j]\\n else:\\n matrix[i][j] = matrix[i][j-1]+matrix[i-1][j]\\n return matrix[m-1][n-1]\\n \\n\", \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n all=m-1+n-1\\n x=1\\n y=1\\n for i in range(m-1):\\n x=x*(all-i)\\n y=y*(i+1)\\n return x//y\\n \\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"uniquePaths\", \"inputs\": [[3, 7]], \"outputs\": [28]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/unique-paths/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def uniquePaths(self, m: int, n: int) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def uniquePaths(self, m, n):\n \"\"\"\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n def f(n):\n ret = 1\n for i in range(1, n+1):\n ret *= i\n return ret\n return f(m+n-2)//(f(m-1)*f(n-1))","class Solution:\n def uniquePaths(self, m, n):\n \"\"\"\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n \n sol = [[0 for j in range(n)] for i in range(m)]\n sol[0][0] = 1\n for i in range(0, m ):\n for j in range(0, n ):\n if i == 0 or j == 0: sol[i][j] = 1\n else: sol[i][j] = sol[i-1][j] + sol[i][j-1]\n \n return sol[-1][-1]","class Solution:\n def uniquePaths(self, m, n):\n \"\"\"\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n counts = {}\n counts[(1, 1)] = 1\n for r in range(2, m+ 1):\n counts[(r, 1)] = 1\n for c in range(2, n + 1):\n counts[(1, c)] = 1\n for i in range(2, m +1):\n for j in range(2, n + 1):\n counts[(i, j)] = counts[(i - 1, j)] + counts[(i, j -1)]\n return counts[(m, n)]\n \n \n def temp(self, m, n):\n cache = {}\n def go(m, n):\n if m == 1 and n == 1:\n return 1\n count = 0\n if m > 1:\n if (m -1, n) not in cache:\n cache[(m-1, n)] = go(m-1, n)\n count += cache[(m-1, n)]\n if n > 1:\n if (m, n - 1) not in cache:\n cache[(m, n-1)] = go(m, n-1)\n count += cache[(m, n -1)]\n return count\n return go(m, n)","class Solution:\n def uniquePaths(self, m, n):\n \"\"\"\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n a = m - 1\n b = n - 1\n ret = 1\n for i in range(b):\n ret = ret * (a+b-i) / (b-i)\n return round(ret)","class Solution:\n def uniquePaths(self, m, n):\n \"\"\"\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n num_paths = [[0 for _ in range(n)] for _ in range(m)]\n for i in range(m):\n for j in range(n):\n above = num_paths[i-1][j] if i > 0 else 0\n left = num_paths[i][j-1] if j > 0 else 0\n num_paths[i][j] = above + left\n if i==0 and j==0:\n num_paths[0][0] = 1\n return num_paths[m-1][n-1]\n","class Solution:\n def uniquePaths(self, m, n):\n \"\"\"\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n aux = [[1 for x in range(n)] for x in range(m)]\n for i in range(1, m):\n for j in range(1, n):\n aux[i][j] = aux[i][j-1]+aux[i-1][j]\n return aux[-1][-1]\n","class Solution:\n def __init__(self):\n self.dp = [[0 for _ in range(101)] for _ in range(101)]\n def go(self, x, y, m, n):\n if self.dp[x][y] == 0:\n if x == m or y == n:\n self.dp[x][y] = 0\n elif x == m - 1 and y == n - 1:\n self.dp[x][y] = 1\n elif x == m - 1 and y == n-1:\n self.dp[x][y] = 1\n else:\n self.dp[x][y] = self.go(x+1, y, m, n) + self.go(x, y+1, m, n)\n return self.dp[x][y]\n def uniquePaths(self, m, n):\n \"\"\"\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n return self.go(0, 0, m, n)\n","class Solution:\n import math\n def uniquePaths(self, m, n):\n \"\"\"\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n if m==1 or n==1:\n return 1\n r,c = m-1, n-1\n return int(math.factorial(r+c)/(math.factorial(r)*math.factorial(c)))\n","class Solution:\n def uniquePaths(self, m, n):\n \"\"\"\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n if 0 in (m,n):return 0\n results = [[1] * n]*m\n for i in range(1, m):\n for j in range(1, n):\n results[i][j] = results[i-1][j] + results[i][j-1]\n return results[m-1][n-1]","class Solution:\n def uniquePaths(self, m, n, memo = None):\n \"\"\"\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n if m == 1 and n == 1:\n return 1\n if m < 1 or n < 1:\n return 0\n \n if not memo:\n memo = [[0 for i in range(n+1)] for j in range(m+1)]\n \n if memo[m][n]:\n return memo[m][n]\n else:\n memo[m][n] = self.uniquePaths(m-1, n, memo) + self.uniquePaths(m, n-1, memo)\n return memo[m][n]\n \n \n","class Solution:\n def uniquePaths(self, m, n):\n \"\"\"\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n M = [[1 for _ in range(n)] for _ in range(2)]\n for i in range(m-1, -1, -1):\n for j in range(n-1, -1, -1):\n if i == m-1 or j == n-1: continue\n else: M[i%2][j] = M[(i+1)%2][j] + M[i%2][j+1]\n return M[0][0]","class Solution:\n def paths(self,m,n,a,b,memo):\n if m>a or n>b:\n return 0\n if m==a and n==b:\n return 1\n if str(m)+\" \"+str(n) not in memo:\n memo[str(m)+\" \"+str(n)] = self.paths(m+1,n,a,b,memo) + self.paths(m,n+1,a,b,memo)\n \n return memo[str(m)+\" \"+str(n)]\n \n \n def uniquePaths(self, m, n):\n memo = dict()\n return(self.paths(0,0,m-1,n-1,memo))","class Solution:\n def uniquePaths(self, m, n):\n \"\"\"\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n \n matrix = [[0 for j in range(n)] for i in range(m)]\n \n matrix[0][0] = 1\n \n for i in range(m):\n for j in range(n):\n if i == 0 and j == 0:\n continue\n elif i == 0:\n matrix[i][j] = matrix[i][j-1]\n elif j == 0:\n matrix[i][j] = matrix[i-1][j]\n else:\n matrix[i][j] = matrix[i][j-1]+matrix[i-1][j]\n return matrix[m-1][n-1]\n \n","class Solution:\n def uniquePaths(self, m, n):\n \"\"\"\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n all=m-1+n-1\n x=1\n y=1\n for i in range(m-1):\n x=x*(all-i)\n y=y*(i+1)\n return x//y\n \n"],"string":"[\n \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n def f(n):\\n ret = 1\\n for i in range(1, n+1):\\n ret *= i\\n return ret\\n return f(m+n-2)//(f(m-1)*f(n-1))\",\n \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n sol = [[0 for j in range(n)] for i in range(m)]\\n sol[0][0] = 1\\n for i in range(0, m ):\\n for j in range(0, n ):\\n if i == 0 or j == 0: sol[i][j] = 1\\n else: sol[i][j] = sol[i-1][j] + sol[i][j-1]\\n \\n return sol[-1][-1]\",\n \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n counts = {}\\n counts[(1, 1)] = 1\\n for r in range(2, m+ 1):\\n counts[(r, 1)] = 1\\n for c in range(2, n + 1):\\n counts[(1, c)] = 1\\n for i in range(2, m +1):\\n for j in range(2, n + 1):\\n counts[(i, j)] = counts[(i - 1, j)] + counts[(i, j -1)]\\n return counts[(m, n)]\\n \\n \\n def temp(self, m, n):\\n cache = {}\\n def go(m, n):\\n if m == 1 and n == 1:\\n return 1\\n count = 0\\n if m > 1:\\n if (m -1, n) not in cache:\\n cache[(m-1, n)] = go(m-1, n)\\n count += cache[(m-1, n)]\\n if n > 1:\\n if (m, n - 1) not in cache:\\n cache[(m, n-1)] = go(m, n-1)\\n count += cache[(m, n -1)]\\n return count\\n return go(m, n)\",\n \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n a = m - 1\\n b = n - 1\\n ret = 1\\n for i in range(b):\\n ret = ret * (a+b-i) / (b-i)\\n return round(ret)\",\n \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n num_paths = [[0 for _ in range(n)] for _ in range(m)]\\n for i in range(m):\\n for j in range(n):\\n above = num_paths[i-1][j] if i > 0 else 0\\n left = num_paths[i][j-1] if j > 0 else 0\\n num_paths[i][j] = above + left\\n if i==0 and j==0:\\n num_paths[0][0] = 1\\n return num_paths[m-1][n-1]\\n\",\n \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n aux = [[1 for x in range(n)] for x in range(m)]\\n for i in range(1, m):\\n for j in range(1, n):\\n aux[i][j] = aux[i][j-1]+aux[i-1][j]\\n return aux[-1][-1]\\n\",\n \"class Solution:\\n def __init__(self):\\n self.dp = [[0 for _ in range(101)] for _ in range(101)]\\n def go(self, x, y, m, n):\\n if self.dp[x][y] == 0:\\n if x == m or y == n:\\n self.dp[x][y] = 0\\n elif x == m - 1 and y == n - 1:\\n self.dp[x][y] = 1\\n elif x == m - 1 and y == n-1:\\n self.dp[x][y] = 1\\n else:\\n self.dp[x][y] = self.go(x+1, y, m, n) + self.go(x, y+1, m, n)\\n return self.dp[x][y]\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n return self.go(0, 0, m, n)\\n\",\n \"class Solution:\\n import math\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if m==1 or n==1:\\n return 1\\n r,c = m-1, n-1\\n return int(math.factorial(r+c)/(math.factorial(r)*math.factorial(c)))\\n\",\n \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if 0 in (m,n):return 0\\n results = [[1] * n]*m\\n for i in range(1, m):\\n for j in range(1, n):\\n results[i][j] = results[i-1][j] + results[i][j-1]\\n return results[m-1][n-1]\",\n \"class Solution:\\n def uniquePaths(self, m, n, memo = None):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if m == 1 and n == 1:\\n return 1\\n if m < 1 or n < 1:\\n return 0\\n \\n if not memo:\\n memo = [[0 for i in range(n+1)] for j in range(m+1)]\\n \\n if memo[m][n]:\\n return memo[m][n]\\n else:\\n memo[m][n] = self.uniquePaths(m-1, n, memo) + self.uniquePaths(m, n-1, memo)\\n return memo[m][n]\\n \\n \\n\",\n \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n M = [[1 for _ in range(n)] for _ in range(2)]\\n for i in range(m-1, -1, -1):\\n for j in range(n-1, -1, -1):\\n if i == m-1 or j == n-1: continue\\n else: M[i%2][j] = M[(i+1)%2][j] + M[i%2][j+1]\\n return M[0][0]\",\n \"class Solution:\\n def paths(self,m,n,a,b,memo):\\n if m>a or n>b:\\n return 0\\n if m==a and n==b:\\n return 1\\n if str(m)+\\\" \\\"+str(n) not in memo:\\n memo[str(m)+\\\" \\\"+str(n)] = self.paths(m+1,n,a,b,memo) + self.paths(m,n+1,a,b,memo)\\n \\n return memo[str(m)+\\\" \\\"+str(n)]\\n \\n \\n def uniquePaths(self, m, n):\\n memo = dict()\\n return(self.paths(0,0,m-1,n-1,memo))\",\n \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n matrix = [[0 for j in range(n)] for i in range(m)]\\n \\n matrix[0][0] = 1\\n \\n for i in range(m):\\n for j in range(n):\\n if i == 0 and j == 0:\\n continue\\n elif i == 0:\\n matrix[i][j] = matrix[i][j-1]\\n elif j == 0:\\n matrix[i][j] = matrix[i-1][j]\\n else:\\n matrix[i][j] = matrix[i][j-1]+matrix[i-1][j]\\n return matrix[m-1][n-1]\\n \\n\",\n \"class Solution:\\n def uniquePaths(self, m, n):\\n \\\"\\\"\\\"\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n all=m-1+n-1\\n x=1\\n y=1\\n for i in range(m-1):\\n x=x*(all-i)\\n y=y*(i+1)\\n return x//y\\n \\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":14,"string":"14"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4,5,6,7,8,9,10,11,12,13],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null,null,null,null,null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":71,"cells":{"problem_id":{"kind":"number","value":204,"string":"204"},"question":{"kind":"string","value":"Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.\n\n(i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]).\n\nYou are given a target value to search. If found in the array return its index, otherwise return -1.\n\nYou may assume no duplicate exists in the array.\n\nYour algorithm's runtime complexity must be in the order of O(log n).\n\nExample 1:\n\n\nInput: nums = [4,5,6,7,0,1,2], target = 0\nOutput: 4\n\n\nExample 2:\n\n\nInput: nums = [4,5,6,7,0,1,2], target = 3\nOutput: -1"},"solutions":{"kind":"string","value":"[\"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n # left = 0\\n # right = len(nums) - 1\\n # while left <= right: \\n # mid = int((left + right)/2)\\n # if nums[mid] == target: \\n # return mid\\n # elif (nums[right] < target) or (nums[mid] > target and nums[right] > target): \\n # right = mid - 1\\n # else: \\n # left = mid + 1\\n # return -1\\n \\n left = 0\\n right = len(nums) - 1\\n while left <= right: \\n mid = int((left + right)/2)\\n if nums[mid] == target: \\n return mid\\n if (nums[left] < nums[mid]): \\n if (target < nums[left]) or (target > nums[mid]): \\n left = mid + 1\\n else: \\n right = mid - 1\\n elif (nums[left] > nums[mid]): \\n if (target < nums[mid]) or (target >= nums[left]): \\n right = mid - 1\\n else: \\n left = mid + 1\\n else: \\n if nums[right] == target: \\n return right\\n else: \\n return -1\\n return -1\", \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n l, r = 0, len(nums)-1\\n while l <= r:\\n mid = (l+r)//2\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] >= nums[l]:\\n if nums[l] <= target < nums[mid]:\\n r = mid-1\\n else:\\n l = mid+1\\n else:\\n if nums[mid] < target <= nums[r]:\\n l = mid+1\\n else:\\n r = mid-1\\n return -1\", \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n length = len(nums)\\n if length <= 0:\\n return -1\\n pivot = self.find_pivot(0, length-1, nums)\\n print(pivot)\\n search_index_A = self.binary_search(0, max(pivot-1, 0), nums, target)\\n search_index_B = self.binary_search(pivot, length-1, nums, target)\\n if search_index_A >= 0:\\n return search_index_A\\n elif search_index_B >= 0:\\n return search_index_B\\n else:\\n return -1\\n \\n def find_pivot(self, left_ind, right_ind, nums):\\n mid = left_ind + (right_ind - left_ind)//2\\n if left_ind == right_ind:\\n return left_ind\\n elif nums[mid] < nums[mid-1]:\\n return mid\\n elif nums[right_ind] < nums[mid]:\\n return self.find_pivot(mid+1, right_ind, nums)\\n else:\\n return self.find_pivot(left_ind, max(0,mid-1), nums)\\n \\n def binary_search(self, left_ind, right_ind, nums, target):\\n mid = left_ind + (right_ind - left_ind)//2\\n if nums[mid] == target:\\n return mid\\n elif left_ind == right_ind:\\n return -1\\n elif nums[mid] < target:\\n return self.binary_search(mid+1, right_ind, nums, target)\\n else:\\n return self.binary_search(left_ind, max(left_ind,mid-1), nums, target)\\n\", \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n left, right = 0, len(nums)-1\\n while left <= right:\\n mid = (left+right) // 2\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] >= nums[left]:\\n if nums[left] <= target < nums[mid]:\\n right = mid-1\\n else:\\n left = mid+1\\n else:\\n if nums[mid] < target <= nums[right]:\\n left = mid+1\\n else:\\n right = mid-1\\n return -1\\n\", \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n # if target in nums:\\n # return nums.index(target)\\n # else:\\n # return -1\\n \\n low, high = 0, len(nums)-1\\n while low < high:\\n mid = (low+high)//2\\n if nums[mid] > nums[high]:\\n low = mid+1\\n else:\\n high = mid\\n start = low\\n low, high = 0, len(nums)-1\\n while low <= high:\\n mid = (low+high)//2\\n realMid = (mid+start) % (len(nums))\\n if nums[realMid] == target:\\n return realMid\\n if target > nums[realMid]:\\n low = mid+1\\n else:\\n high = mid-1\\n return -1\\n \\n \\n\", \"class Solution:\\n def search_interval(self, start, end, nums, target):\\n if start == end:\\n if nums[start] == target:\\n return start\\n else:\\n return -1\\n \\n size = end - start\\n half = size // 2\\n new_start_1 = start\\n new_end_1 = start + half\\n new_start_2 = start + half + 1\\n new_end_2 = end\\n \\n # check first interval\\n first_half_sorted = False\\n first_half_contains = False\\n second_half_sorted = False\\n second_half_contains = False\\n if nums[new_end_1] >= nums[new_start_1]:\\n first_half_sorted = True\\n if (target >= nums[new_start_1]) and (target <= nums[new_end_1]):\\n first_half_contains = True\\n if nums[new_end_2] >= nums[new_start_2]:\\n second_half_sorted = True\\n if (target >= nums[new_start_2]) and (target <= nums[new_end_2]):\\n second_half_contains = True\\n \\n if first_half_contains:\\n return self.search_interval(new_start_1, new_end_1, nums, target)\\n elif second_half_contains:\\n return self.search_interval(new_start_2, new_end_2, nums, target)\\n elif first_half_sorted:\\n return self.search_interval(new_start_2, new_end_2, nums, target)\\n elif second_half_sorted:\\n return self.search_interval(new_start_1, new_end_1, nums, target)\\n \\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n if len(nums) == 0:\\n return -1\\n \\n return self.search_interval(0, len(nums) - 1, nums, target)\", \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n length = len(nums)\\n if length <= 0:\\n return -1\\n pivot = self.find_pivot(0, length-1, nums)\\n print(pivot)\\n search_index_A = self.binary_search(0, max(pivot-1, 0), nums, target)\\n search_index_B = self.binary_search(pivot, length-1, nums, target)\\n if search_index_A >= 0:\\n return search_index_A\\n elif search_index_B >= 0:\\n return search_index_B\\n else:\\n return -1\\n \\n def find_pivot(self, left_ind, right_ind, nums):\\n mid = left_ind + (right_ind - left_ind)//2\\n if left_ind == right_ind:\\n return left_ind\\n elif nums[mid] < nums[mid-1]:\\n return mid\\n elif nums[right_ind] < nums[mid]:\\n return self.find_pivot(mid+1, right_ind, nums)\\n else:\\n return self.find_pivot(left_ind, max(0,mid-1), nums)\\n \\n def binary_search(self, left_ind, right_ind, nums, target):\\n mid = left_ind + (right_ind - left_ind)//2\\n print(nums)\\n print(mid)\\n if nums[mid] == target:\\n return mid\\n elif left_ind == right_ind:\\n return -1\\n elif nums[mid] < target:\\n return self.binary_search(mid+1, right_ind, nums, target)\\n else:\\n return self.binary_search(left_ind, max(left_ind,mid-1), nums, target)\\n \\n # [5,1,3]\\n # [0]\\n \\n # find_pivot(0,2,[5,1,3])\\n # left = 0\\n # right = 2\\n # mid = 0 + 2//2 = 1\\n # nums[mid] < nums[mid-1]\\n # pivot = 1\\n # binary_search(0, max(pivot-1,0), ...)\\n # left = 0, right = 0\\n # search_index_A = -1\\n # binary_search(pivot, length-1, ...)\\n # left = 1, right = 2\\n # mid = 1 + (2-1)//2 = 1\\n # binary_search(1, max(0,0), ...)\\n # search_index_B = -1\\n\", \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n idx = -1\\n for i in range(1,len(nums)):\\n if nums[i] < nums[i-1]:\\n idx = i\\n break\\n if idx == -1:\\n return self.bin_search(nums, 0, len(nums), target)\\n else:\\n if target < nums[0] or target < nums[-1]:\\n return self.bin_search(nums, idx, len(nums), target)\\n elif target > nums[-1] or target > nums[0]:\\n return self.bin_search(nums, 0, idx, target)\\n else: \\n assert(False)\\n \\n def bin_search(self, nums, i1, i2, target):\\n while i1 < i2:\\n mi = (i1 + i2) // 2\\n if nums[mi] == target: return mi\\n if nums[mi] > target: i2 = mi\\n else: i1 = mi + 1\\n \\n return -1\\n\", \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n for i in range(0,len(nums)):\\n if nums[i] == target:\\n return i\\n return -1\", \"class Solution:\\n def search(self, nums, target):\\n if len(nums) <= 3: return nums.index(target) if target in nums else -1\\n l, r = 0, len(nums) - 1\\n while l < r:\\n m = (l + r) // 2\\n left = nums[l]\\n mid = nums[m]\\n right = nums[r]\\n if left == target:\\n return l\\n if mid == target:\\n return m\\n if right == target:\\n return r\\n elif left < right:\\n print(('mono:', l, r))\\n if mid < target:\\n l = m\\n r -= 1\\n else:\\n r = m\\n l += 1\\n else:\\n print(('not mono:', l, r))\\n if left < target < mid or mid < left < target or target < mid < left:\\n r = m\\n l += 1\\n else:\\n l = m\\n r -= 1\\n return -1\\n\", \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n low = 0\\n high = len(nums)-1\\n while high >= low:\\n mid = high+low//2\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] > nums[high]:\\n low = mid+1\\n else:\\n print (\\\"comes here\\\")\\n print (high)\\n print (mid)\\n print (low)\\n high = mid-1\\n print (high)\\n return -1\\n\", \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if not nums:\\n return -1\\n \\n # [4,5,6,7,0,1,2]\\n # 0\\n start, end = 0, len(nums) - 1\\n while start + 1 < end:\\n mid = start + (end - start) // 2\\n if target < nums[end]:\\n if nums[mid] < target or nums[mid] > nums[end]:\\n start = mid\\n elif nums[mid] > target and nums[mid] < nums[end]:\\n end = mid\\n else:\\n return mid\\n elif target > nums[end]:\\n if nums[mid] > target or nums[mid] < nums[end]:\\n end = mid\\n elif nums[mid] < target and nums[mid] > nums[end]:\\n start = mid\\n else:\\n return mid\\n else:\\n return len(nums) - 1\\n \\n if nums[start] == target:\\n return start\\n if nums[end] == target:\\n return end\\n \\n return -1\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"search\", \"inputs\": [[[4, 5, 6, 7, 0, 1, 2], 0]], \"outputs\": [4]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/search-in-rotated-sorted-array/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def search(self, nums: List[int], target: int) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: int\n \"\"\"\n # left = 0\n # right = len(nums) - 1\n # while left <= right: \n # mid = int((left + right)/2)\n # if nums[mid] == target: \n # return mid\n # elif (nums[right] < target) or (nums[mid] > target and nums[right] > target): \n # right = mid - 1\n # else: \n # left = mid + 1\n # return -1\n \n left = 0\n right = len(nums) - 1\n while left <= right: \n mid = int((left + right)/2)\n if nums[mid] == target: \n return mid\n if (nums[left] < nums[mid]): \n if (target < nums[left]) or (target > nums[mid]): \n left = mid + 1\n else: \n right = mid - 1\n elif (nums[left] > nums[mid]): \n if (target < nums[mid]) or (target >= nums[left]): \n right = mid - 1\n else: \n left = mid + 1\n else: \n if nums[right] == target: \n return right\n else: \n return -1\n return -1","class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: int\n \"\"\"\n l, r = 0, len(nums)-1\n while l <= r:\n mid = (l+r)//2\n if nums[mid] == target:\n return mid\n elif nums[mid] >= nums[l]:\n if nums[l] <= target < nums[mid]:\n r = mid-1\n else:\n l = mid+1\n else:\n if nums[mid] < target <= nums[r]:\n l = mid+1\n else:\n r = mid-1\n return -1","class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: int\n \"\"\"\n length = len(nums)\n if length <= 0:\n return -1\n pivot = self.find_pivot(0, length-1, nums)\n print(pivot)\n search_index_A = self.binary_search(0, max(pivot-1, 0), nums, target)\n search_index_B = self.binary_search(pivot, length-1, nums, target)\n if search_index_A >= 0:\n return search_index_A\n elif search_index_B >= 0:\n return search_index_B\n else:\n return -1\n \n def find_pivot(self, left_ind, right_ind, nums):\n mid = left_ind + (right_ind - left_ind)//2\n if left_ind == right_ind:\n return left_ind\n elif nums[mid] < nums[mid-1]:\n return mid\n elif nums[right_ind] < nums[mid]:\n return self.find_pivot(mid+1, right_ind, nums)\n else:\n return self.find_pivot(left_ind, max(0,mid-1), nums)\n \n def binary_search(self, left_ind, right_ind, nums, target):\n mid = left_ind + (right_ind - left_ind)//2\n if nums[mid] == target:\n return mid\n elif left_ind == right_ind:\n return -1\n elif nums[mid] < target:\n return self.binary_search(mid+1, right_ind, nums, target)\n else:\n return self.binary_search(left_ind, max(left_ind,mid-1), nums, target)\n","class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: int\n \"\"\"\n left, right = 0, len(nums)-1\n while left <= right:\n mid = (left+right) // 2\n if nums[mid] == target:\n return mid\n elif nums[mid] >= nums[left]:\n if nums[left] <= target < nums[mid]:\n right = mid-1\n else:\n left = mid+1\n else:\n if nums[mid] < target <= nums[right]:\n left = mid+1\n else:\n right = mid-1\n return -1\n","class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: int\n \"\"\"\n # if target in nums:\n # return nums.index(target)\n # else:\n # return -1\n \n low, high = 0, len(nums)-1\n while low < high:\n mid = (low+high)//2\n if nums[mid] > nums[high]:\n low = mid+1\n else:\n high = mid\n start = low\n low, high = 0, len(nums)-1\n while low <= high:\n mid = (low+high)//2\n realMid = (mid+start) % (len(nums))\n if nums[realMid] == target:\n return realMid\n if target > nums[realMid]:\n low = mid+1\n else:\n high = mid-1\n return -1\n \n \n","class Solution:\n def search_interval(self, start, end, nums, target):\n if start == end:\n if nums[start] == target:\n return start\n else:\n return -1\n \n size = end - start\n half = size // 2\n new_start_1 = start\n new_end_1 = start + half\n new_start_2 = start + half + 1\n new_end_2 = end\n \n # check first interval\n first_half_sorted = False\n first_half_contains = False\n second_half_sorted = False\n second_half_contains = False\n if nums[new_end_1] >= nums[new_start_1]:\n first_half_sorted = True\n if (target >= nums[new_start_1]) and (target <= nums[new_end_1]):\n first_half_contains = True\n if nums[new_end_2] >= nums[new_start_2]:\n second_half_sorted = True\n if (target >= nums[new_start_2]) and (target <= nums[new_end_2]):\n second_half_contains = True\n \n if first_half_contains:\n return self.search_interval(new_start_1, new_end_1, nums, target)\n elif second_half_contains:\n return self.search_interval(new_start_2, new_end_2, nums, target)\n elif first_half_sorted:\n return self.search_interval(new_start_2, new_end_2, nums, target)\n elif second_half_sorted:\n return self.search_interval(new_start_1, new_end_1, nums, target)\n \n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: int\n \"\"\"\n \n if len(nums) == 0:\n return -1\n \n return self.search_interval(0, len(nums) - 1, nums, target)","class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: int\n \"\"\"\n length = len(nums)\n if length <= 0:\n return -1\n pivot = self.find_pivot(0, length-1, nums)\n print(pivot)\n search_index_A = self.binary_search(0, max(pivot-1, 0), nums, target)\n search_index_B = self.binary_search(pivot, length-1, nums, target)\n if search_index_A >= 0:\n return search_index_A\n elif search_index_B >= 0:\n return search_index_B\n else:\n return -1\n \n def find_pivot(self, left_ind, right_ind, nums):\n mid = left_ind + (right_ind - left_ind)//2\n if left_ind == right_ind:\n return left_ind\n elif nums[mid] < nums[mid-1]:\n return mid\n elif nums[right_ind] < nums[mid]:\n return self.find_pivot(mid+1, right_ind, nums)\n else:\n return self.find_pivot(left_ind, max(0,mid-1), nums)\n \n def binary_search(self, left_ind, right_ind, nums, target):\n mid = left_ind + (right_ind - left_ind)//2\n print(nums)\n print(mid)\n if nums[mid] == target:\n return mid\n elif left_ind == right_ind:\n return -1\n elif nums[mid] < target:\n return self.binary_search(mid+1, right_ind, nums, target)\n else:\n return self.binary_search(left_ind, max(left_ind,mid-1), nums, target)\n \n # [5,1,3]\n # [0]\n \n # find_pivot(0,2,[5,1,3])\n # left = 0\n # right = 2\n # mid = 0 + 2//2 = 1\n # nums[mid] < nums[mid-1]\n # pivot = 1\n # binary_search(0, max(pivot-1,0), ...)\n # left = 0, right = 0\n # search_index_A = -1\n # binary_search(pivot, length-1, ...)\n # left = 1, right = 2\n # mid = 1 + (2-1)//2 = 1\n # binary_search(1, max(0,0), ...)\n # search_index_B = -1\n","class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: int\n \"\"\"\n idx = -1\n for i in range(1,len(nums)):\n if nums[i] < nums[i-1]:\n idx = i\n break\n if idx == -1:\n return self.bin_search(nums, 0, len(nums), target)\n else:\n if target < nums[0] or target < nums[-1]:\n return self.bin_search(nums, idx, len(nums), target)\n elif target > nums[-1] or target > nums[0]:\n return self.bin_search(nums, 0, idx, target)\n else: \n assert(False)\n \n def bin_search(self, nums, i1, i2, target):\n while i1 < i2:\n mi = (i1 + i2) // 2\n if nums[mi] == target: return mi\n if nums[mi] > target: i2 = mi\n else: i1 = mi + 1\n \n return -1\n","class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: int\n \"\"\"\n for i in range(0,len(nums)):\n if nums[i] == target:\n return i\n return -1","class Solution:\n def search(self, nums, target):\n if len(nums) <= 3: return nums.index(target) if target in nums else -1\n l, r = 0, len(nums) - 1\n while l < r:\n m = (l + r) // 2\n left = nums[l]\n mid = nums[m]\n right = nums[r]\n if left == target:\n return l\n if mid == target:\n return m\n if right == target:\n return r\n elif left < right:\n print(('mono:', l, r))\n if mid < target:\n l = m\n r -= 1\n else:\n r = m\n l += 1\n else:\n print(('not mono:', l, r))\n if left < target < mid or mid < left < target or target < mid < left:\n r = m\n l += 1\n else:\n l = m\n r -= 1\n return -1\n","class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: int\n \"\"\"\n low = 0\n high = len(nums)-1\n while high >= low:\n mid = high+low//2\n if nums[mid] == target:\n return mid\n elif nums[mid] > nums[high]:\n low = mid+1\n else:\n print (\"comes here\")\n print (high)\n print (mid)\n print (low)\n high = mid-1\n print (high)\n return -1\n","class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: int\n \"\"\"\n if not nums:\n return -1\n \n # [4,5,6,7,0,1,2]\n # 0\n start, end = 0, len(nums) - 1\n while start + 1 < end:\n mid = start + (end - start) // 2\n if target < nums[end]:\n if nums[mid] < target or nums[mid] > nums[end]:\n start = mid\n elif nums[mid] > target and nums[mid] < nums[end]:\n end = mid\n else:\n return mid\n elif target > nums[end]:\n if nums[mid] > target or nums[mid] < nums[end]:\n end = mid\n elif nums[mid] < target and nums[mid] > nums[end]:\n start = mid\n else:\n return mid\n else:\n return len(nums) - 1\n \n if nums[start] == target:\n return start\n if nums[end] == target:\n return end\n \n return -1"],"string":"[\n \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n # left = 0\\n # right = len(nums) - 1\\n # while left <= right: \\n # mid = int((left + right)/2)\\n # if nums[mid] == target: \\n # return mid\\n # elif (nums[right] < target) or (nums[mid] > target and nums[right] > target): \\n # right = mid - 1\\n # else: \\n # left = mid + 1\\n # return -1\\n \\n left = 0\\n right = len(nums) - 1\\n while left <= right: \\n mid = int((left + right)/2)\\n if nums[mid] == target: \\n return mid\\n if (nums[left] < nums[mid]): \\n if (target < nums[left]) or (target > nums[mid]): \\n left = mid + 1\\n else: \\n right = mid - 1\\n elif (nums[left] > nums[mid]): \\n if (target < nums[mid]) or (target >= nums[left]): \\n right = mid - 1\\n else: \\n left = mid + 1\\n else: \\n if nums[right] == target: \\n return right\\n else: \\n return -1\\n return -1\",\n \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n l, r = 0, len(nums)-1\\n while l <= r:\\n mid = (l+r)//2\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] >= nums[l]:\\n if nums[l] <= target < nums[mid]:\\n r = mid-1\\n else:\\n l = mid+1\\n else:\\n if nums[mid] < target <= nums[r]:\\n l = mid+1\\n else:\\n r = mid-1\\n return -1\",\n \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n length = len(nums)\\n if length <= 0:\\n return -1\\n pivot = self.find_pivot(0, length-1, nums)\\n print(pivot)\\n search_index_A = self.binary_search(0, max(pivot-1, 0), nums, target)\\n search_index_B = self.binary_search(pivot, length-1, nums, target)\\n if search_index_A >= 0:\\n return search_index_A\\n elif search_index_B >= 0:\\n return search_index_B\\n else:\\n return -1\\n \\n def find_pivot(self, left_ind, right_ind, nums):\\n mid = left_ind + (right_ind - left_ind)//2\\n if left_ind == right_ind:\\n return left_ind\\n elif nums[mid] < nums[mid-1]:\\n return mid\\n elif nums[right_ind] < nums[mid]:\\n return self.find_pivot(mid+1, right_ind, nums)\\n else:\\n return self.find_pivot(left_ind, max(0,mid-1), nums)\\n \\n def binary_search(self, left_ind, right_ind, nums, target):\\n mid = left_ind + (right_ind - left_ind)//2\\n if nums[mid] == target:\\n return mid\\n elif left_ind == right_ind:\\n return -1\\n elif nums[mid] < target:\\n return self.binary_search(mid+1, right_ind, nums, target)\\n else:\\n return self.binary_search(left_ind, max(left_ind,mid-1), nums, target)\\n\",\n \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n left, right = 0, len(nums)-1\\n while left <= right:\\n mid = (left+right) // 2\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] >= nums[left]:\\n if nums[left] <= target < nums[mid]:\\n right = mid-1\\n else:\\n left = mid+1\\n else:\\n if nums[mid] < target <= nums[right]:\\n left = mid+1\\n else:\\n right = mid-1\\n return -1\\n\",\n \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n # if target in nums:\\n # return nums.index(target)\\n # else:\\n # return -1\\n \\n low, high = 0, len(nums)-1\\n while low < high:\\n mid = (low+high)//2\\n if nums[mid] > nums[high]:\\n low = mid+1\\n else:\\n high = mid\\n start = low\\n low, high = 0, len(nums)-1\\n while low <= high:\\n mid = (low+high)//2\\n realMid = (mid+start) % (len(nums))\\n if nums[realMid] == target:\\n return realMid\\n if target > nums[realMid]:\\n low = mid+1\\n else:\\n high = mid-1\\n return -1\\n \\n \\n\",\n \"class Solution:\\n def search_interval(self, start, end, nums, target):\\n if start == end:\\n if nums[start] == target:\\n return start\\n else:\\n return -1\\n \\n size = end - start\\n half = size // 2\\n new_start_1 = start\\n new_end_1 = start + half\\n new_start_2 = start + half + 1\\n new_end_2 = end\\n \\n # check first interval\\n first_half_sorted = False\\n first_half_contains = False\\n second_half_sorted = False\\n second_half_contains = False\\n if nums[new_end_1] >= nums[new_start_1]:\\n first_half_sorted = True\\n if (target >= nums[new_start_1]) and (target <= nums[new_end_1]):\\n first_half_contains = True\\n if nums[new_end_2] >= nums[new_start_2]:\\n second_half_sorted = True\\n if (target >= nums[new_start_2]) and (target <= nums[new_end_2]):\\n second_half_contains = True\\n \\n if first_half_contains:\\n return self.search_interval(new_start_1, new_end_1, nums, target)\\n elif second_half_contains:\\n return self.search_interval(new_start_2, new_end_2, nums, target)\\n elif first_half_sorted:\\n return self.search_interval(new_start_2, new_end_2, nums, target)\\n elif second_half_sorted:\\n return self.search_interval(new_start_1, new_end_1, nums, target)\\n \\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n if len(nums) == 0:\\n return -1\\n \\n return self.search_interval(0, len(nums) - 1, nums, target)\",\n \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n length = len(nums)\\n if length <= 0:\\n return -1\\n pivot = self.find_pivot(0, length-1, nums)\\n print(pivot)\\n search_index_A = self.binary_search(0, max(pivot-1, 0), nums, target)\\n search_index_B = self.binary_search(pivot, length-1, nums, target)\\n if search_index_A >= 0:\\n return search_index_A\\n elif search_index_B >= 0:\\n return search_index_B\\n else:\\n return -1\\n \\n def find_pivot(self, left_ind, right_ind, nums):\\n mid = left_ind + (right_ind - left_ind)//2\\n if left_ind == right_ind:\\n return left_ind\\n elif nums[mid] < nums[mid-1]:\\n return mid\\n elif nums[right_ind] < nums[mid]:\\n return self.find_pivot(mid+1, right_ind, nums)\\n else:\\n return self.find_pivot(left_ind, max(0,mid-1), nums)\\n \\n def binary_search(self, left_ind, right_ind, nums, target):\\n mid = left_ind + (right_ind - left_ind)//2\\n print(nums)\\n print(mid)\\n if nums[mid] == target:\\n return mid\\n elif left_ind == right_ind:\\n return -1\\n elif nums[mid] < target:\\n return self.binary_search(mid+1, right_ind, nums, target)\\n else:\\n return self.binary_search(left_ind, max(left_ind,mid-1), nums, target)\\n \\n # [5,1,3]\\n # [0]\\n \\n # find_pivot(0,2,[5,1,3])\\n # left = 0\\n # right = 2\\n # mid = 0 + 2//2 = 1\\n # nums[mid] < nums[mid-1]\\n # pivot = 1\\n # binary_search(0, max(pivot-1,0), ...)\\n # left = 0, right = 0\\n # search_index_A = -1\\n # binary_search(pivot, length-1, ...)\\n # left = 1, right = 2\\n # mid = 1 + (2-1)//2 = 1\\n # binary_search(1, max(0,0), ...)\\n # search_index_B = -1\\n\",\n \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n idx = -1\\n for i in range(1,len(nums)):\\n if nums[i] < nums[i-1]:\\n idx = i\\n break\\n if idx == -1:\\n return self.bin_search(nums, 0, len(nums), target)\\n else:\\n if target < nums[0] or target < nums[-1]:\\n return self.bin_search(nums, idx, len(nums), target)\\n elif target > nums[-1] or target > nums[0]:\\n return self.bin_search(nums, 0, idx, target)\\n else: \\n assert(False)\\n \\n def bin_search(self, nums, i1, i2, target):\\n while i1 < i2:\\n mi = (i1 + i2) // 2\\n if nums[mi] == target: return mi\\n if nums[mi] > target: i2 = mi\\n else: i1 = mi + 1\\n \\n return -1\\n\",\n \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n for i in range(0,len(nums)):\\n if nums[i] == target:\\n return i\\n return -1\",\n \"class Solution:\\n def search(self, nums, target):\\n if len(nums) <= 3: return nums.index(target) if target in nums else -1\\n l, r = 0, len(nums) - 1\\n while l < r:\\n m = (l + r) // 2\\n left = nums[l]\\n mid = nums[m]\\n right = nums[r]\\n if left == target:\\n return l\\n if mid == target:\\n return m\\n if right == target:\\n return r\\n elif left < right:\\n print(('mono:', l, r))\\n if mid < target:\\n l = m\\n r -= 1\\n else:\\n r = m\\n l += 1\\n else:\\n print(('not mono:', l, r))\\n if left < target < mid or mid < left < target or target < mid < left:\\n r = m\\n l += 1\\n else:\\n l = m\\n r -= 1\\n return -1\\n\",\n \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n low = 0\\n high = len(nums)-1\\n while high >= low:\\n mid = high+low//2\\n if nums[mid] == target:\\n return mid\\n elif nums[mid] > nums[high]:\\n low = mid+1\\n else:\\n print (\\\"comes here\\\")\\n print (high)\\n print (mid)\\n print (low)\\n high = mid-1\\n print (high)\\n return -1\\n\",\n \"class Solution:\\n def search(self, nums, target):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type target: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if not nums:\\n return -1\\n \\n # [4,5,6,7,0,1,2]\\n # 0\\n start, end = 0, len(nums) - 1\\n while start + 1 < end:\\n mid = start + (end - start) // 2\\n if target < nums[end]:\\n if nums[mid] < target or nums[mid] > nums[end]:\\n start = mid\\n elif nums[mid] > target and nums[mid] < nums[end]:\\n end = mid\\n else:\\n return mid\\n elif target > nums[end]:\\n if nums[mid] > target or nums[mid] < nums[end]:\\n end = mid\\n elif nums[mid] < target and nums[mid] > nums[end]:\\n start = mid\\n else:\\n return mid\\n else:\\n return len(nums) - 1\\n \\n if nums[start] == target:\\n return start\\n if nums[end] == target:\\n return end\\n \\n return -1\"\n]","isConversational":false},"n_sols":{"kind":"number","value":12,"string":"12"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4,5,6,7,8,9,10,11],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null,null,null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":72,"cells":{"problem_id":{"kind":"number","value":205,"string":"205"},"question":{"kind":"string","value":"In the computer world, use restricted resource you have to generate maximum benefit is what we always want to pursue.\nFor now, suppose you are a dominator of m 0s and n 1s respectively. On the other hand, there is an array with strings consisting of only 0s and 1s.\n\n\nNow your task is to find the maximum number of strings that you can form with given m 0s and n 1s. Each 0 and 1 can be used at most once.\n\n\n\nNote:\n\nThe given numbers of 0s and 1s will both not exceed 100\nThe size of given string array won't exceed 600.\n\n\n\nExample 1:\n\nInput: Array = {\"10\", \"0001\", \"111001\", \"1\", \"0\"}, m = 5, n = 3\nOutput: 4\n\nExplanation: This are totally 4 strings can be formed by the using of 5 0s and 3 1s, which are “10,”0001”,”1”,”0”\n\n\n\nExample 2:\n\nInput: Array = {\"10\", \"0\", \"1\"}, m = 1, n = 1\nOutput: 2\n\nExplanation: You could form \"10\", but then you'd have nothing left. Better form \"0\" and \"1\"."},"solutions":{"kind":"string","value":"[\"class Solution:\\n def getMax(self, arr, m, n):\\n res = 0\\n \\n for e in arr:\\n if m >= e[0] and n >= e[1]:\\n res += 1\\n m -= e[0]\\n n -= e[1]\\n \\n return res\\n \\n def findMaxForm(self, strs, m, n):\\n \\\"\\\"\\\"\\n :type strs: List[str]\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n arr = [(s.count('0'), s.count('1')) for s in strs]\\n arr1 = sorted(arr, key=lambda s: -min(m - s[0], n - s[1]))\\n arr2 = sorted(arr, key=lambda s: min(s[0], s[1]))\\n res = max(self.getMax(arr1, m, n), self.getMax(arr2, m, n))\\n \\n return res\", \"class Solution:\\n def Greedy(self, counts, zeros, ones) :\\n num = 0;\\n for a, b in counts :\\n if a <= zeros and b <= ones :\\n zeros -= a\\n ones -= b\\n num += 1\\n return num\\n \\n def findMaxForm(self, strs, m, n):\\n \\\"\\\"\\\"\\n :type strs: List[str]\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n counts = list(map(lambda x : [x.count('0'), x.count('1')], strs))\\n return max(self.Greedy(sorted(counts, key = lambda c : min(c[0], c[1])), m, n),\\n self.Greedy(sorted(counts, key = lambda c : min(m - c[0], n - c[1]), reverse = True), m, n))\", \"class Solution:\\n def findMaxForm(self, strs, m, n):\\n \\\"\\\"\\\"\\n :type strs: List[str]\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n def getMax(arr, m, n):\\n res = 0\\n \\n for e in arr:\\n if m >= e[0] and n >= e[1]:\\n res += 1\\n m -= e[0]\\n n -= e[1]\\n \\n return res\\n \\n arr = [(s.count('0'), s.count('1')) for s in strs]\\n arr1 = sorted(arr, key=lambda s: -min(m - s[0], n - s[1]))\\n arr2 = sorted(arr, key=lambda s: min(s[0], s[1]))\\n res = max(getMax(arr1, m, n), getMax(arr2, m, n))\\n \\n return res\", \"class Solution:\\n def Greedy(self, counts, zeros, ones) :\\n num = 0;\\n for a, b in counts :\\n if a <= zeros and b <= ones :\\n zeros -= a\\n ones -= b\\n num += 1\\n return num\\n \\n def findMaxForm(self, strs, m, n):\\n \\\"\\\"\\\"\\n :type strs: List[str]\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n counts = [[s.count('0'), s.count('1')] for s in strs]\\n \\n res1 = self.Greedy(sorted(counts, key=lambda c: min(c[0], c[1])), m, n)\\n res2 = self.Greedy(sorted(counts, key=lambda c: min(m - c[0], n - c[1]), reverse=True), m, n)\\n \\n return max(res1, res2)\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"findMaxForm\", \"inputs\": [[[\"\\\"10\\\"\", \"\\\"0001\\\"\", \"\\\"111001\\\"\", \"\\\"1\\\"\", \"\\\"0\\\"\"], 5, 3]], \"outputs\": [4]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/ones-and-zeroes/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def findMaxForm(self, strs: List[str], m: int, n: int) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def getMax(self, arr, m, n):\n res = 0\n \n for e in arr:\n if m >= e[0] and n >= e[1]:\n res += 1\n m -= e[0]\n n -= e[1]\n \n return res\n \n def findMaxForm(self, strs, m, n):\n \"\"\"\n :type strs: List[str]\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n arr = [(s.count('0'), s.count('1')) for s in strs]\n arr1 = sorted(arr, key=lambda s: -min(m - s[0], n - s[1]))\n arr2 = sorted(arr, key=lambda s: min(s[0], s[1]))\n res = max(self.getMax(arr1, m, n), self.getMax(arr2, m, n))\n \n return res","class Solution:\n def Greedy(self, counts, zeros, ones) :\n num = 0;\n for a, b in counts :\n if a <= zeros and b <= ones :\n zeros -= a\n ones -= b\n num += 1\n return num\n \n def findMaxForm(self, strs, m, n):\n \"\"\"\n :type strs: List[str]\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n counts = list(map(lambda x : [x.count('0'), x.count('1')], strs))\n return max(self.Greedy(sorted(counts, key = lambda c : min(c[0], c[1])), m, n),\n self.Greedy(sorted(counts, key = lambda c : min(m - c[0], n - c[1]), reverse = True), m, n))","class Solution:\n def findMaxForm(self, strs, m, n):\n \"\"\"\n :type strs: List[str]\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n def getMax(arr, m, n):\n res = 0\n \n for e in arr:\n if m >= e[0] and n >= e[1]:\n res += 1\n m -= e[0]\n n -= e[1]\n \n return res\n \n arr = [(s.count('0'), s.count('1')) for s in strs]\n arr1 = sorted(arr, key=lambda s: -min(m - s[0], n - s[1]))\n arr2 = sorted(arr, key=lambda s: min(s[0], s[1]))\n res = max(getMax(arr1, m, n), getMax(arr2, m, n))\n \n return res","class Solution:\n def Greedy(self, counts, zeros, ones) :\n num = 0;\n for a, b in counts :\n if a <= zeros and b <= ones :\n zeros -= a\n ones -= b\n num += 1\n return num\n \n def findMaxForm(self, strs, m, n):\n \"\"\"\n :type strs: List[str]\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n counts = [[s.count('0'), s.count('1')] for s in strs]\n \n res1 = self.Greedy(sorted(counts, key=lambda c: min(c[0], c[1])), m, n)\n res2 = self.Greedy(sorted(counts, key=lambda c: min(m - c[0], n - c[1]), reverse=True), m, n)\n \n return max(res1, res2)"],"string":"[\n \"class Solution:\\n def getMax(self, arr, m, n):\\n res = 0\\n \\n for e in arr:\\n if m >= e[0] and n >= e[1]:\\n res += 1\\n m -= e[0]\\n n -= e[1]\\n \\n return res\\n \\n def findMaxForm(self, strs, m, n):\\n \\\"\\\"\\\"\\n :type strs: List[str]\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n arr = [(s.count('0'), s.count('1')) for s in strs]\\n arr1 = sorted(arr, key=lambda s: -min(m - s[0], n - s[1]))\\n arr2 = sorted(arr, key=lambda s: min(s[0], s[1]))\\n res = max(self.getMax(arr1, m, n), self.getMax(arr2, m, n))\\n \\n return res\",\n \"class Solution:\\n def Greedy(self, counts, zeros, ones) :\\n num = 0;\\n for a, b in counts :\\n if a <= zeros and b <= ones :\\n zeros -= a\\n ones -= b\\n num += 1\\n return num\\n \\n def findMaxForm(self, strs, m, n):\\n \\\"\\\"\\\"\\n :type strs: List[str]\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n counts = list(map(lambda x : [x.count('0'), x.count('1')], strs))\\n return max(self.Greedy(sorted(counts, key = lambda c : min(c[0], c[1])), m, n),\\n self.Greedy(sorted(counts, key = lambda c : min(m - c[0], n - c[1]), reverse = True), m, n))\",\n \"class Solution:\\n def findMaxForm(self, strs, m, n):\\n \\\"\\\"\\\"\\n :type strs: List[str]\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n def getMax(arr, m, n):\\n res = 0\\n \\n for e in arr:\\n if m >= e[0] and n >= e[1]:\\n res += 1\\n m -= e[0]\\n n -= e[1]\\n \\n return res\\n \\n arr = [(s.count('0'), s.count('1')) for s in strs]\\n arr1 = sorted(arr, key=lambda s: -min(m - s[0], n - s[1]))\\n arr2 = sorted(arr, key=lambda s: min(s[0], s[1]))\\n res = max(getMax(arr1, m, n), getMax(arr2, m, n))\\n \\n return res\",\n \"class Solution:\\n def Greedy(self, counts, zeros, ones) :\\n num = 0;\\n for a, b in counts :\\n if a <= zeros and b <= ones :\\n zeros -= a\\n ones -= b\\n num += 1\\n return num\\n \\n def findMaxForm(self, strs, m, n):\\n \\\"\\\"\\\"\\n :type strs: List[str]\\n :type m: int\\n :type n: int\\n :rtype: int\\n \\\"\\\"\\\"\\n counts = [[s.count('0'), s.count('1')] for s in strs]\\n \\n res1 = self.Greedy(sorted(counts, key=lambda c: min(c[0], c[1])), m, n)\\n res2 = self.Greedy(sorted(counts, key=lambda c: min(m - c[0], n - c[1]), reverse=True), m, n)\\n \\n return max(res1, res2)\"\n]","isConversational":false},"n_sols":{"kind":"number","value":4,"string":"4"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3],"string":"[\n 0,\n 1,\n 2,\n 3\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null],"string":"[\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":73,"cells":{"problem_id":{"kind":"number","value":206,"string":"206"},"question":{"kind":"string","value":"Given an array of scores that are non-negative integers. Player 1 picks one of the numbers from either end of the array followed by the player 2 and then player 1 and so on. Each time a player picks a number, that number will not be available for the next player. This continues until all the scores have been chosen. The player with the maximum score wins. \n\nGiven an array of scores, predict whether player 1 is the winner. You can assume each player plays to maximize his score. \n\nExample 1:\n\nInput: [1, 5, 2]\nOutput: False\nExplanation: Initially, player 1 can choose between 1 and 2. If he chooses 2 (or 1), then player 2 can choose from 1 (or 2) and 5. If player 2 chooses 5, then player 1 will be left with 1 (or 2). So, final score of player 1 is 1 + 2 = 3, and player 2 is 5. Hence, player 1 will never be the winner and you need to return False.\n\n\n\nExample 2:\n\nInput: [1, 5, 233, 7]\nOutput: True\nExplanation: Player 1 first chooses 1. Then player 2 have to choose between 5 and 7. No matter which number player 2 choose, player 1 can choose 233.Finally, player 1 has more score (234) than player 2 (12), so you need to return True representing player1 can win.\n\n\n\nNote:\n\n1 \nAny scores in the given array are non-negative integers and will not exceed 10,000,000.\nIf the scores of both players are equal, then player 1 is still the winner."},"solutions":{"kind":"string","value":"[\"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n if not nums: return True\\n n = len(nums)\\n if n & 1 == 0: return True\\n \\n dp = [0] * n\\n for i in range(n-1, -1, -1):\\n for j in range(i, n):\\n if i == j:\\n dp[i] = nums[i]\\n else:\\n dp[j] = max(nums[i] - dp[j], nums[j] - dp[j-1])\\n return dp[n-1] >= 0\\n\", \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n # total = sum(nums)\\n # memo = {}\\n # def score(l, r, t):\\n # if l>r: return 0\\n # if (l, r) not in memo:\\n # memo[(l, r)] = t-min(score(l+1, r, t-nums[l]), score(l, r-1, t-nums[r]))\\n # return memo[(l, r)]\\n # sc = score(0, len(nums)-1, total)\\n # return sc>=total-sc\\n N = len(nums)\\n dp = [[0]*N for _ in range(N)]\\n pre_sum = [nums[0]]*(N+1)\\n pre_sum[-1] = 0\\n for i in range(1, N):\\n pre_sum[i] = pre_sum[i-1]+nums[i]\\n for i in range(N):\\n dp[i][i] = nums[i]\\n for l in range(1, N):\\n for i in range(N-l):\\n dp[i][i+l] = max(pre_sum[i+l]-pre_sum[i-1]-dp[i+1][i+l], pre_sum[i+l]-pre_sum[i-1]-dp[i][i+l-1])\\n return dp[0][N-1]*2>=pre_sum[N-1]\", \"class Solution:\\n def PredictTheWinner(self, nums):\\n cache = {}\\n \\n def whose_turn(i, j):\\n return (len(nums) - (j - i + 1)) % 2 == 0\\n \\n def traverse(i, j):\\n if (i, j) in cache:\\n return cache[(i, j)]\\n \\n p1_turn = whose_turn(i, j)\\n \\n if i == j:\\n return (nums[i], 0) if p1_turn else (0, nums[i])\\n \\n if i + 1 == j:\\n winning_move = max(nums[i], nums[j])\\n losing_move = min(nums[i], nums[j])\\n cache[(i, j)] = (winning_move, losing_move) if p1_turn else (losing_move, winning_move)\\n return cache[(i, j)]\\n \\n p1_left, p2_left = traverse(i + 1, j)\\n p1_right, p2_right = traverse(i, j - 1)\\n \\n if p1_turn:\\n p1_move = max(p1_left + nums[i], p1_right + nums[j])\\n p2_move = p2_left if p1_left + nums[i] >= p1_right + nums[j] else p2_right\\n else:\\n p1_move = p1_left if p2_left + nums[i] >= p2_right + nums[j] else p1_right\\n p2_move = max(p2_left + nums[i], p2_right + nums[j])\\n \\n cache[(i, j)] = (p1_move, p2_move)\\n return cache[(i, j)]\\n \\n p1_final, p2_final = traverse(0, len(nums) - 1)\\n return p1_final >= p2_final\", \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\n \\\"\\\"\\\"\\n memo = [ [0 for _ in range(len(nums))] for _ in range(len(nums))]\\n self.count=0\\n \\n def winner( left , right , player):\\n self.count +=1\\n #print(self.count)\\n if left == right:\\n \\n return player * nums[left]\\n \\n # p1 selct max from each end\\n # remove the selected\\n # p2 selects max from each end\\n # do above seps until no mor num\\n # 1 5 2\\n #print( left, right)\\n \\n if memo[left][right] != 0 :\\n print((nums[left:right+1]))\\n return memo[left][right]\\n \\n #self.count +=1\\n a = player * nums[left] + winner( left+1 , right, -player )\\n \\n #self.count +=1\\n b = player * nums[right] + winner( left , right -1 , -player)\\n \\n \\n \\n if player == 1:\\n res = max(a,b)\\n else:\\n res = min(a,b)\\n \\n memo[left][right] = res\\n \\n return res\\n \\n self.count=0 \\n return winner( 0, len(nums) -1 , 1) >=0 \\n \\n \\n \\n \\n\", \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n n = len(nums)\\n if n == 0:\\n return False\\n dp = [[0]*n for i in range(n)]\\n for i in range(n):\\n dp[i][i] = nums[i]\\n for period in range(1,n): \\n for i in range(n-period):\\n j = i+period\\n dp[i][j] = max(nums[i]-dp[i+1][j], nums[j]-dp[i][j-1])\\n return dp[0][n-1] >= 0\\n\", \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n def helper(nums, start, end, mem):\\n if start == end:\\n return nums[start]\\n if (start, end) not in mem:\\n mem[(start, end)] = max(nums[start] - helper(nums, start + 1, end, mem), nums[end] - helper(nums, start, end - 1, mem))\\n return mem[(start, end)]\\n \\n return helper(nums, 0, len(nums) - 1, {}) >= 0\", \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n dic = {}\\n # tnums = tuple(nums)\\n # move to the solve function\\n def solve(nums):\\n ###BUG\\uff01 IndexError: list index out of range\\n if len(nums) <=1: return sum(nums)\\n tnums = tuple(nums)\\n if tnums in dic:\\n return dic[tnums]\\n dic[tnums] = max(nums[0]-solve(nums[1:]),nums[-1]-solve(nums[:-1]))\\n # TypeError: unsupported operand type(s) for -: 'int' and 'NoneType'\\n return dic[tnums]\\n return solve(nums) >= 0\", \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n total = sum(nums)\\n dic = {}\\n def score(i, j, t):\\n if i>j:\\n return 0\\n if (i, j) in dic:\\n return dic[(i, j)]\\n ret = max(t-score(i+1, j, t-nums[i]), t-score(i, j-1, t-nums[j]))\\n dic[(i, j)] = ret\\n return ret\\n l = len(nums)\\n sc = score(0, l-1, total)\\n return sc>=total-sc\", \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n if not nums:\\n return 0\\n n=len(nums)\\n dp=[[0]*n for _ in range(n)]\\n \\n for i in range(n):\\n dp[i][i]=nums[i]\\n \\n for length in range(1,n):\\n for i in range(n-length):\\n j=i+length\\n dp[i][j]=max(nums[i]-dp[i+1][j],nums[j]-dp[i][j-1])\\n \\n return dp[0][-1]>=0\\n\", \"class Solution:\\n p1dict = {}\\n p2dict = {}\\n \\n def play1(self, nums):\\n if str(nums) in self.p1dict:\\n return self.p1dict[str(nums)]\\n if len(nums) == 1:\\n return nums[0]\\n ret = max(self.play2(nums[1:]) + nums[0], self.play2(nums[:-1]) + nums[-1])\\n self.p1dict[str(nums)] = ret\\n return ret\\n \\n def play2(self, nums):\\n if str(nums) in self.p2dict:\\n return self.p2dict[str(nums)]\\n if len(nums) == 1:\\n return -nums[0]\\n ret = min(self.play1(nums[1:]) - nums[0], self.play1(nums[:-1]) - nums[-1])\\n self.p2dict[str(nums)] = ret\\n return ret\\n \\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n return self.play1(nums) >= 0\\n\", \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n _cache = {}\\n return Solution.Moves(self,nums, 0,len(nums)-1, 1, _cache ) >= 0\\n \\n \\n def Moves(self, nums, ini ,fin, pl, _cache = {}):\\n \\n memo = str((ini,fin,pl))\\n \\n if memo in list(_cache.keys()):\\n return _cache[memo]\\n \\n if ini == fin :\\n if pl == 1:\\n _cache[memo] = nums[ini]\\n return _cache[memo]\\n else:\\n _cache[memo] = - nums[ini]\\n return _cache[memo]\\n else:\\n if pl == 1: \\n _cache[memo]= max(Solution.Moves(self, nums, ini+1, fin, 2,_cache) + nums[ini] , Solution.Moves(self, nums, ini, fin-1, 2,_cache) + nums[fin])\\n return _cache[memo]\\n \\n if pl == 2:\\n _cache[memo] = min(Solution.Moves(self, nums, ini+1, fin, 1,_cache) - nums[ini] , Solution.Moves(self, nums, ini, fin-1, 1,_cache) - nums[fin])\\n return _cache[memo]\\n\", \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n l = len(nums)\\n memo = [[None] * l for _ in range(l)]\\n def predict(start, end, memo):\\n if start == end:\\n return nums[start]\\n if memo[start][end]:\\n return memo[start][end]\\n one = nums[start] - predict(start + 1, end, memo)\\n two = nums[end] - predict(start, end - 1, memo)\\n memo[start][end] = max(one, two)\\n return memo[start][end]\\n \\n return predict(0, len(nums) - 1, memo) >= 0\", \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n if not nums: return True\\n n = len(nums)\\n if n & 1 == 0: return True\\n \\n dp = [0] * n\\n for i in range(n-1, -1, -1):\\n for j in range(i, n):\\n if i == j:\\n dp[i] = nums[i]\\n else:\\n dp[j] = max(nums[i] - dp[j], nums[j] - dp[j-1])\\n return dp[n-1] >= 0\\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"PredictTheWinner\", \"inputs\": [[[1, 5, 2]]], \"outputs\": [false]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/predict-the-winner/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def PredictTheWinner(self, nums: List[int]) -> bool:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def PredictTheWinner(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: bool\n \"\"\"\n if not nums: return True\n n = len(nums)\n if n & 1 == 0: return True\n \n dp = [0] * n\n for i in range(n-1, -1, -1):\n for j in range(i, n):\n if i == j:\n dp[i] = nums[i]\n else:\n dp[j] = max(nums[i] - dp[j], nums[j] - dp[j-1])\n return dp[n-1] >= 0\n","class Solution:\n def PredictTheWinner(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: bool\n \"\"\"\n # total = sum(nums)\n # memo = {}\n # def score(l, r, t):\n # if l>r: return 0\n # if (l, r) not in memo:\n # memo[(l, r)] = t-min(score(l+1, r, t-nums[l]), score(l, r-1, t-nums[r]))\n # return memo[(l, r)]\n # sc = score(0, len(nums)-1, total)\n # return sc>=total-sc\n N = len(nums)\n dp = [[0]*N for _ in range(N)]\n pre_sum = [nums[0]]*(N+1)\n pre_sum[-1] = 0\n for i in range(1, N):\n pre_sum[i] = pre_sum[i-1]+nums[i]\n for i in range(N):\n dp[i][i] = nums[i]\n for l in range(1, N):\n for i in range(N-l):\n dp[i][i+l] = max(pre_sum[i+l]-pre_sum[i-1]-dp[i+1][i+l], pre_sum[i+l]-pre_sum[i-1]-dp[i][i+l-1])\n return dp[0][N-1]*2>=pre_sum[N-1]","class Solution:\n def PredictTheWinner(self, nums):\n cache = {}\n \n def whose_turn(i, j):\n return (len(nums) - (j - i + 1)) % 2 == 0\n \n def traverse(i, j):\n if (i, j) in cache:\n return cache[(i, j)]\n \n p1_turn = whose_turn(i, j)\n \n if i == j:\n return (nums[i], 0) if p1_turn else (0, nums[i])\n \n if i + 1 == j:\n winning_move = max(nums[i], nums[j])\n losing_move = min(nums[i], nums[j])\n cache[(i, j)] = (winning_move, losing_move) if p1_turn else (losing_move, winning_move)\n return cache[(i, j)]\n \n p1_left, p2_left = traverse(i + 1, j)\n p1_right, p2_right = traverse(i, j - 1)\n \n if p1_turn:\n p1_move = max(p1_left + nums[i], p1_right + nums[j])\n p2_move = p2_left if p1_left + nums[i] >= p1_right + nums[j] else p2_right\n else:\n p1_move = p1_left if p2_left + nums[i] >= p2_right + nums[j] else p1_right\n p2_move = max(p2_left + nums[i], p2_right + nums[j])\n \n cache[(i, j)] = (p1_move, p2_move)\n return cache[(i, j)]\n \n p1_final, p2_final = traverse(0, len(nums) - 1)\n return p1_final >= p2_final","class Solution:\n def PredictTheWinner(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: bool\n \n \"\"\"\n memo = [ [0 for _ in range(len(nums))] for _ in range(len(nums))]\n self.count=0\n \n def winner( left , right , player):\n self.count +=1\n #print(self.count)\n if left == right:\n \n return player * nums[left]\n \n # p1 selct max from each end\n # remove the selected\n # p2 selects max from each end\n # do above seps until no mor num\n # 1 5 2\n #print( left, right)\n \n if memo[left][right] != 0 :\n print((nums[left:right+1]))\n return memo[left][right]\n \n #self.count +=1\n a = player * nums[left] + winner( left+1 , right, -player )\n \n #self.count +=1\n b = player * nums[right] + winner( left , right -1 , -player)\n \n \n \n if player == 1:\n res = max(a,b)\n else:\n res = min(a,b)\n \n memo[left][right] = res\n \n return res\n \n self.count=0 \n return winner( 0, len(nums) -1 , 1) >=0 \n \n \n \n \n","class Solution:\n def PredictTheWinner(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: bool\n \"\"\"\n n = len(nums)\n if n == 0:\n return False\n dp = [[0]*n for i in range(n)]\n for i in range(n):\n dp[i][i] = nums[i]\n for period in range(1,n): \n for i in range(n-period):\n j = i+period\n dp[i][j] = max(nums[i]-dp[i+1][j], nums[j]-dp[i][j-1])\n return dp[0][n-1] >= 0\n","class Solution:\n def PredictTheWinner(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: bool\n \"\"\"\n def helper(nums, start, end, mem):\n if start == end:\n return nums[start]\n if (start, end) not in mem:\n mem[(start, end)] = max(nums[start] - helper(nums, start + 1, end, mem), nums[end] - helper(nums, start, end - 1, mem))\n return mem[(start, end)]\n \n return helper(nums, 0, len(nums) - 1, {}) >= 0","class Solution:\n def PredictTheWinner(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: bool\n \"\"\"\n dic = {}\n # tnums = tuple(nums)\n # move to the solve function\n def solve(nums):\n ###BUG！ IndexError: list index out of range\n if len(nums) <=1: return sum(nums)\n tnums = tuple(nums)\n if tnums in dic:\n return dic[tnums]\n dic[tnums] = max(nums[0]-solve(nums[1:]),nums[-1]-solve(nums[:-1]))\n # TypeError: unsupported operand type(s) for -: 'int' and 'NoneType'\n return dic[tnums]\n return solve(nums) >= 0","class Solution:\n def PredictTheWinner(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: bool\n \"\"\"\n total = sum(nums)\n dic = {}\n def score(i, j, t):\n if i>j:\n return 0\n if (i, j) in dic:\n return dic[(i, j)]\n ret = max(t-score(i+1, j, t-nums[i]), t-score(i, j-1, t-nums[j]))\n dic[(i, j)] = ret\n return ret\n l = len(nums)\n sc = score(0, l-1, total)\n return sc>=total-sc","class Solution:\n def PredictTheWinner(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: bool\n \"\"\"\n if not nums:\n return 0\n n=len(nums)\n dp=[[0]*n for _ in range(n)]\n \n for i in range(n):\n dp[i][i]=nums[i]\n \n for length in range(1,n):\n for i in range(n-length):\n j=i+length\n dp[i][j]=max(nums[i]-dp[i+1][j],nums[j]-dp[i][j-1])\n \n return dp[0][-1]>=0\n","class Solution:\n p1dict = {}\n p2dict = {}\n \n def play1(self, nums):\n if str(nums) in self.p1dict:\n return self.p1dict[str(nums)]\n if len(nums) == 1:\n return nums[0]\n ret = max(self.play2(nums[1:]) + nums[0], self.play2(nums[:-1]) + nums[-1])\n self.p1dict[str(nums)] = ret\n return ret\n \n def play2(self, nums):\n if str(nums) in self.p2dict:\n return self.p2dict[str(nums)]\n if len(nums) == 1:\n return -nums[0]\n ret = min(self.play1(nums[1:]) - nums[0], self.play1(nums[:-1]) - nums[-1])\n self.p2dict[str(nums)] = ret\n return ret\n \n def PredictTheWinner(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: bool\n \"\"\"\n return self.play1(nums) >= 0\n","class Solution:\n def PredictTheWinner(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: bool\n \"\"\"\n _cache = {}\n return Solution.Moves(self,nums, 0,len(nums)-1, 1, _cache ) >= 0\n \n \n def Moves(self, nums, ini ,fin, pl, _cache = {}):\n \n memo = str((ini,fin,pl))\n \n if memo in list(_cache.keys()):\n return _cache[memo]\n \n if ini == fin :\n if pl == 1:\n _cache[memo] = nums[ini]\n return _cache[memo]\n else:\n _cache[memo] = - nums[ini]\n return _cache[memo]\n else:\n if pl == 1: \n _cache[memo]= max(Solution.Moves(self, nums, ini+1, fin, 2,_cache) + nums[ini] , Solution.Moves(self, nums, ini, fin-1, 2,_cache) + nums[fin])\n return _cache[memo]\n \n if pl == 2:\n _cache[memo] = min(Solution.Moves(self, nums, ini+1, fin, 1,_cache) - nums[ini] , Solution.Moves(self, nums, ini, fin-1, 1,_cache) - nums[fin])\n return _cache[memo]\n","class Solution:\n def PredictTheWinner(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: bool\n \"\"\"\n l = len(nums)\n memo = [[None] * l for _ in range(l)]\n def predict(start, end, memo):\n if start == end:\n return nums[start]\n if memo[start][end]:\n return memo[start][end]\n one = nums[start] - predict(start + 1, end, memo)\n two = nums[end] - predict(start, end - 1, memo)\n memo[start][end] = max(one, two)\n return memo[start][end]\n \n return predict(0, len(nums) - 1, memo) >= 0","class Solution:\n def PredictTheWinner(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: bool\n \"\"\"\n if not nums: return True\n n = len(nums)\n if n & 1 == 0: return True\n \n dp = [0] * n\n for i in range(n-1, -1, -1):\n for j in range(i, n):\n if i == j:\n dp[i] = nums[i]\n else:\n dp[j] = max(nums[i] - dp[j], nums[j] - dp[j-1])\n return dp[n-1] >= 0\n"],"string":"[\n \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n if not nums: return True\\n n = len(nums)\\n if n & 1 == 0: return True\\n \\n dp = [0] * n\\n for i in range(n-1, -1, -1):\\n for j in range(i, n):\\n if i == j:\\n dp[i] = nums[i]\\n else:\\n dp[j] = max(nums[i] - dp[j], nums[j] - dp[j-1])\\n return dp[n-1] >= 0\\n\",\n \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n # total = sum(nums)\\n # memo = {}\\n # def score(l, r, t):\\n # if l>r: return 0\\n # if (l, r) not in memo:\\n # memo[(l, r)] = t-min(score(l+1, r, t-nums[l]), score(l, r-1, t-nums[r]))\\n # return memo[(l, r)]\\n # sc = score(0, len(nums)-1, total)\\n # return sc>=total-sc\\n N = len(nums)\\n dp = [[0]*N for _ in range(N)]\\n pre_sum = [nums[0]]*(N+1)\\n pre_sum[-1] = 0\\n for i in range(1, N):\\n pre_sum[i] = pre_sum[i-1]+nums[i]\\n for i in range(N):\\n dp[i][i] = nums[i]\\n for l in range(1, N):\\n for i in range(N-l):\\n dp[i][i+l] = max(pre_sum[i+l]-pre_sum[i-1]-dp[i+1][i+l], pre_sum[i+l]-pre_sum[i-1]-dp[i][i+l-1])\\n return dp[0][N-1]*2>=pre_sum[N-1]\",\n \"class Solution:\\n def PredictTheWinner(self, nums):\\n cache = {}\\n \\n def whose_turn(i, j):\\n return (len(nums) - (j - i + 1)) % 2 == 0\\n \\n def traverse(i, j):\\n if (i, j) in cache:\\n return cache[(i, j)]\\n \\n p1_turn = whose_turn(i, j)\\n \\n if i == j:\\n return (nums[i], 0) if p1_turn else (0, nums[i])\\n \\n if i + 1 == j:\\n winning_move = max(nums[i], nums[j])\\n losing_move = min(nums[i], nums[j])\\n cache[(i, j)] = (winning_move, losing_move) if p1_turn else (losing_move, winning_move)\\n return cache[(i, j)]\\n \\n p1_left, p2_left = traverse(i + 1, j)\\n p1_right, p2_right = traverse(i, j - 1)\\n \\n if p1_turn:\\n p1_move = max(p1_left + nums[i], p1_right + nums[j])\\n p2_move = p2_left if p1_left + nums[i] >= p1_right + nums[j] else p2_right\\n else:\\n p1_move = p1_left if p2_left + nums[i] >= p2_right + nums[j] else p1_right\\n p2_move = max(p2_left + nums[i], p2_right + nums[j])\\n \\n cache[(i, j)] = (p1_move, p2_move)\\n return cache[(i, j)]\\n \\n p1_final, p2_final = traverse(0, len(nums) - 1)\\n return p1_final >= p2_final\",\n \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\n \\\"\\\"\\\"\\n memo = [ [0 for _ in range(len(nums))] for _ in range(len(nums))]\\n self.count=0\\n \\n def winner( left , right , player):\\n self.count +=1\\n #print(self.count)\\n if left == right:\\n \\n return player * nums[left]\\n \\n # p1 selct max from each end\\n # remove the selected\\n # p2 selects max from each end\\n # do above seps until no mor num\\n # 1 5 2\\n #print( left, right)\\n \\n if memo[left][right] != 0 :\\n print((nums[left:right+1]))\\n return memo[left][right]\\n \\n #self.count +=1\\n a = player * nums[left] + winner( left+1 , right, -player )\\n \\n #self.count +=1\\n b = player * nums[right] + winner( left , right -1 , -player)\\n \\n \\n \\n if player == 1:\\n res = max(a,b)\\n else:\\n res = min(a,b)\\n \\n memo[left][right] = res\\n \\n return res\\n \\n self.count=0 \\n return winner( 0, len(nums) -1 , 1) >=0 \\n \\n \\n \\n \\n\",\n \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n n = len(nums)\\n if n == 0:\\n return False\\n dp = [[0]*n for i in range(n)]\\n for i in range(n):\\n dp[i][i] = nums[i]\\n for period in range(1,n): \\n for i in range(n-period):\\n j = i+period\\n dp[i][j] = max(nums[i]-dp[i+1][j], nums[j]-dp[i][j-1])\\n return dp[0][n-1] >= 0\\n\",\n \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n def helper(nums, start, end, mem):\\n if start == end:\\n return nums[start]\\n if (start, end) not in mem:\\n mem[(start, end)] = max(nums[start] - helper(nums, start + 1, end, mem), nums[end] - helper(nums, start, end - 1, mem))\\n return mem[(start, end)]\\n \\n return helper(nums, 0, len(nums) - 1, {}) >= 0\",\n \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n dic = {}\\n # tnums = tuple(nums)\\n # move to the solve function\\n def solve(nums):\\n ###BUG！ IndexError: list index out of range\\n if len(nums) <=1: return sum(nums)\\n tnums = tuple(nums)\\n if tnums in dic:\\n return dic[tnums]\\n dic[tnums] = max(nums[0]-solve(nums[1:]),nums[-1]-solve(nums[:-1]))\\n # TypeError: unsupported operand type(s) for -: 'int' and 'NoneType'\\n return dic[tnums]\\n return solve(nums) >= 0\",\n \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n total = sum(nums)\\n dic = {}\\n def score(i, j, t):\\n if i>j:\\n return 0\\n if (i, j) in dic:\\n return dic[(i, j)]\\n ret = max(t-score(i+1, j, t-nums[i]), t-score(i, j-1, t-nums[j]))\\n dic[(i, j)] = ret\\n return ret\\n l = len(nums)\\n sc = score(0, l-1, total)\\n return sc>=total-sc\",\n \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n if not nums:\\n return 0\\n n=len(nums)\\n dp=[[0]*n for _ in range(n)]\\n \\n for i in range(n):\\n dp[i][i]=nums[i]\\n \\n for length in range(1,n):\\n for i in range(n-length):\\n j=i+length\\n dp[i][j]=max(nums[i]-dp[i+1][j],nums[j]-dp[i][j-1])\\n \\n return dp[0][-1]>=0\\n\",\n \"class Solution:\\n p1dict = {}\\n p2dict = {}\\n \\n def play1(self, nums):\\n if str(nums) in self.p1dict:\\n return self.p1dict[str(nums)]\\n if len(nums) == 1:\\n return nums[0]\\n ret = max(self.play2(nums[1:]) + nums[0], self.play2(nums[:-1]) + nums[-1])\\n self.p1dict[str(nums)] = ret\\n return ret\\n \\n def play2(self, nums):\\n if str(nums) in self.p2dict:\\n return self.p2dict[str(nums)]\\n if len(nums) == 1:\\n return -nums[0]\\n ret = min(self.play1(nums[1:]) - nums[0], self.play1(nums[:-1]) - nums[-1])\\n self.p2dict[str(nums)] = ret\\n return ret\\n \\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n return self.play1(nums) >= 0\\n\",\n \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n _cache = {}\\n return Solution.Moves(self,nums, 0,len(nums)-1, 1, _cache ) >= 0\\n \\n \\n def Moves(self, nums, ini ,fin, pl, _cache = {}):\\n \\n memo = str((ini,fin,pl))\\n \\n if memo in list(_cache.keys()):\\n return _cache[memo]\\n \\n if ini == fin :\\n if pl == 1:\\n _cache[memo] = nums[ini]\\n return _cache[memo]\\n else:\\n _cache[memo] = - nums[ini]\\n return _cache[memo]\\n else:\\n if pl == 1: \\n _cache[memo]= max(Solution.Moves(self, nums, ini+1, fin, 2,_cache) + nums[ini] , Solution.Moves(self, nums, ini, fin-1, 2,_cache) + nums[fin])\\n return _cache[memo]\\n \\n if pl == 2:\\n _cache[memo] = min(Solution.Moves(self, nums, ini+1, fin, 1,_cache) - nums[ini] , Solution.Moves(self, nums, ini, fin-1, 1,_cache) - nums[fin])\\n return _cache[memo]\\n\",\n \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n l = len(nums)\\n memo = [[None] * l for _ in range(l)]\\n def predict(start, end, memo):\\n if start == end:\\n return nums[start]\\n if memo[start][end]:\\n return memo[start][end]\\n one = nums[start] - predict(start + 1, end, memo)\\n two = nums[end] - predict(start, end - 1, memo)\\n memo[start][end] = max(one, two)\\n return memo[start][end]\\n \\n return predict(0, len(nums) - 1, memo) >= 0\",\n \"class Solution:\\n def PredictTheWinner(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: bool\\n \\\"\\\"\\\"\\n if not nums: return True\\n n = len(nums)\\n if n & 1 == 0: return True\\n \\n dp = [0] * n\\n for i in range(n-1, -1, -1):\\n for j in range(i, n):\\n if i == j:\\n dp[i] = nums[i]\\n else:\\n dp[j] = max(nums[i] - dp[j], nums[j] - dp[j-1])\\n return dp[n-1] >= 0\\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":13,"string":"13"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4,5,6,7,8,9,10,11,12],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null,null,null,null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":74,"cells":{"problem_id":{"kind":"number","value":207,"string":"207"},"question":{"kind":"string","value":"Given a list of non negative integers, arrange them such that they form the largest number.\n\nExample 1:\n\n\nInput: [10,2]\nOutput: \"210\"\n\nExample 2:\n\n\nInput: [3,30,34,5,9]\nOutput: \"9534330\"\n\n\nNote: The result may be very large, so you need to return a string instead of an integer."},"solutions":{"kind":"string","value":"[\"class Solution:\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n nums = [str(n) for n in nums]\\n \\n nums.sort(reverse=True)\\n \\n for i in range(1, len(nums)):\\n if len(nums[i-1]) > len(nums[i]):\\n ran = len(nums[i])\\n j = i\\n while j-1 >= 0 and nums[j-1][:ran] == nums[j] and nums[j-1]+nums[j]<=nums[j]+nums[j-1]:\\n nums[j-1], nums[j] = nums[j], nums[j-1]\\n j -= 1\\n \\n return str(int(''.join(nums)))\", \"class Solution:\\n class MyNumber:\\n def __init__(self, v):\\n self.str_val = str(v)\\n self.val = [int(x) for x in self.str_val]\\n self.n = len(self.val)\\n def __cmp__(self, other):\\n n1 = self.str_val + other.str_val\\n n2 = other.str_val + self.str_val \\n return 0 if n1 == n2 else 1 if n1 > n2 else -1\\n \\n \\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n if all(x == 0 for x in nums):\\n return '0'\\n myns = [self.MyNumber(x) for x in nums]\\n \\n for i in range(len(nums)):\\n for j in range(i + 1, len(nums)):\\n if myns[j].__cmp__(myns[i]) > 0:\\n t = myns[i]\\n myns[i] = myns[j]\\n myns[j] = t\\n \\n return \\\"\\\".join([x.str_val for x in myns])\\n \\n\", \"class Solution:\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n # maxPos = 0\\n # maxNum = ''\\n # maxLen = 0\\n # maxCut = ''\\n # res = ''\\n # while nums:\\n # for i in range(len(nums)):\\n # cur = nums[i]\\n # ori = cur\\n # while cur % 10 == 0:\\n # cur = cur // 10\\n # if str(cur) > maxCut or (str(cur) == maxCut and len(str(ori)) < maxLen):\\n # maxCut = str(cur)\\n # maxNum = str(ori)\\n # maxPos = i\\n # maxLen = len(maxNum)\\n # nums.pop(maxPos)\\n # res += maxNum\\n # maxPos = 0\\n # maxNum = ''\\n # maxLen = 0\\n # maxCut = ''\\n # return res\\n \\n maxPos = 0\\n maxNum = ''\\n res = ''\\n while nums:\\n for i in range(len(nums)):\\n cur = nums[i]\\n if str(cur) + maxNum >= maxNum + str(cur):\\n maxNum = str(cur)\\n maxPos = i\\n nums.pop(maxPos)\\n res += maxNum\\n maxPos = 0\\n maxNum = ''\\n if res[0] == '0':\\n return '0'\\n return res\\n\", \"class Solution:\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n \\n ## edge case: 981 3,31 331 313\\n \\n \\n strs = [str(num) for num in nums]\\n \\n def bigger(str1, str2):\\n if int(str1+str2) >= int(str2+str1):\\n return str1\\n else:\\n return str2\\n \\n answer = \\\"\\\"\\n current = strs\\n while current:\\n maximum = current[0]\\n for i in range(len(current)):\\n maximum = bigger(maximum, current[i])\\n \\n answer += maximum\\n current.remove(maximum)\\n \\n if answer[0] == \\\"0\\\":\\n return \\\"0\\\"\\n return answer\", \"class Solution:\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n # case 1 34 vs 34\\n #case2: 3 vs 34 ; 34 vs 3; 30 vs 3; 3 vs 30\\n \\n # this works:\\n # compare the element by ourselves according to the rule of largest number first \\n if nums is None or len(nums) == 0:\\n return ''\\n \\n for i in range(len(nums)-1, -1, -1):\\n for j in range(len(nums)-1, len(nums)-i-1, -1):\\n #compare element 1, 2\\n e1 = str(nums[j-1])\\n e2 = str(nums[j])\\n #print (\\\"e1, e2: \\\", e1, e2, nums)\\n if e1+e2 < e2+e1:\\n #swap \\n t = nums[j]\\n nums[j] = nums[j-1]\\n nums[j-1] = t\\n \\n ans = ''\\n for n in nums:\\n if n == 0 and ans == '':\\n continue\\n ans += str(n)\\n #print (\\\"nums: \\\", nums)\\n return '0' if len(ans) == 0 else ans \\n\", \"class Solution:\\n \\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n import functools\\n # s_nums = []\\n # maximum_length = 0\\n # result = \\\"\\\"\\n # dic = {}\\n # for i in range(0, len(nums)):\\n # value = str(num[i])\\n # maximum_length = max(maximum_length, len(value))\\n # s_nums.append(value)\\n # dic[i] = True\\n \\n # for i in range(0, maximum_length-1): \\n # temp_max = \\\"\\\"\\n # temp_max_array = []\\n # for j in range(0, s_nums-1):\\n # try:\\n # a = s_nums[j][i]\\n # try:\\n # b = s_nums[j][i+1]\\n # except:\\n # if dic[j] != False:\\n # temp_max_array.append(nums[j])\\n # dic[j] = False\\n # dic[j] += 1\\n # except:\\n # continue\\n # print(temp_max_array)\\n # result += ''.join(sorted(temp_max_array))\\n \\n # return result\\n nums_str = []\\n for each in nums:\\n nums_str.append(str(each))\\n \\n result = ''.join(sorted(nums_str, key = functools.cmp_to_key(self.comparator)))\\n \\n if int(result) == 0:\\n return '0'\\n else:\\n return result\\n \\n \\n \\n def comparator(self, a, b):\\n \\n num1 = a + b\\n num2 = b + a\\n \\n if num1 > num2:\\n return -1\\n elif num2 > num1:\\n return 1\\n else:\\n return 0\\n \\n\", \"class Solution:\\n def sorting(self, numstr):\\n newnumstr = []\\n #print(numstr)\\n for i in range(0, len(numstr)):\\n for j in range(1, len(numstr)-i):\\n if numstr[j-1] + numstr[j] < numstr[j] + numstr[j-1]:\\n temp = numstr[j-1]\\n numstr[j-1] = numstr[j]\\n numstr[j] = temp\\n #print(numstr)\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n matrix = dict()\\n for num in nums:\\n numstr = str(num)\\n if numstr[0] not in matrix:\\n matrix[numstr[0]] = []\\n matrix[numstr[0]].append(numstr)\\n print(matrix)\\n \\n ret = \\\"\\\"\\n for i in range(9, -1, -1):\\n if str(i) in matrix:\\n prenums = matrix[str(i)]\\n self.sorting(prenums)\\n #print(prenums)\\n ret += \\\"\\\".join(prenums)\\n #print(ret)\\n return str(int(ret))\\n\", \"class Solution:\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n def lexic_comp(a, b):\\n ab = str(a) + str(b)\\n ba = str(b) + str(a)\\n if ab > ba:\\n return -1\\n elif ba > ab:\\n return 1\\n return 0\\n \\n import functools\\n \\n nums.sort(key=functools.cmp_to_key(lexic_comp))\\n \\n return str(int(''.join(map(str, nums))))\\n\", \"class Solution:\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n s=self.sort(nums)\\n if s.startswith(\\\"0\\\"):\\n return \\\"0\\\"\\n else:return s\\n def sort(self,nums):\\n if not nums:return \\\"\\\"\\n else:\\n pivot=nums[0]\\n left=[]\\n right=[]\\n for i in range(1,len(nums)):\\n if self.compare(nums[i],pivot):\\n left.append(nums[i])\\n else:\\n right.append(nums[i])\\n return self.sort(left)+str(pivot)+self.sort(right)\\n \\n def compare(self,num1,num2):\\n num1,num2=str(num1),str(num2)\\n return int(num1+num2)>int(num2+num1)\", \"class Solution:\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n def cmp_to_key(mycmp):\\n 'Convert a cmp= function into a key= function'\\n class K:\\n def __init__(self, obj, *args):\\n self.obj = obj\\n def __lt__(self, other):\\n return mycmp(self.obj, other.obj) < 0\\n def __gt__(self, other):\\n return mycmp(self.obj, other.obj) > 0\\n def __eq__(self, other):\\n return mycmp(self.obj, other.obj) == 0\\n def __le__(self, other):\\n return mycmp(self.obj, other.obj) <= 0\\n def __ge__(self, other):\\n return mycmp(self.obj, other.obj) >= 0\\n def __ne__(self, other):\\n return mycmp(self.obj, other.obj) != 0\\n return K\\n \\n def compare(n1, n2):\\n #print(n1, n2, \\\":\\\")\\n l1 = len(n1)\\n l2 = len(n2)\\n i = 0\\n if l1 != l2:\\n tmp = n1 \\n n1 = n1 + n2\\n n2 = n2 + tmp\\n l1 = l1 + l2\\n #print(n1, n2)\\n while i < max(l1, l2):\\n #print(i, n1[i], n2[i])\\n if n1[i] < n2[i]:\\n #print(n1, \\\"<\\\", n2)\\n return -1\\n elif n1[i] > n2[i]:\\n #print(n1, \\\">\\\", n2)\\n return 1\\n i += 1\\n #print(n1, \\\"=\\\", n2)\\n return 0\\n \\n \\n def convert(num):\\n if num == 0:\\n return [0]\\n res = []\\n while num:\\n res.append(num % 10)\\n num //= 10\\n res.reverse()\\n return res\\n \\n nums = list(map(convert, nums))\\n nums.sort(key=cmp_to_key(compare), reverse=True)\\n print(nums)\\n res = [str(c) for num in nums for c in num]\\n \\n res = \\\"\\\".join(res).lstrip('0')\\n if not res:\\n res = '0'\\n return res\", \"class Solution:\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n s=self.sort(nums)\\n if s.startswith(\\\"0\\\"):\\n return \\\"0\\\"\\n else:return s\\n def sort(self,nums):\\n if not nums:return \\\"\\\"\\n else:\\n pivot=nums[0]\\n left=[]\\n right=[]\\n for i in range(1,len(nums)):\\n if self.compare(nums[i],pivot):\\n left.append(nums[i])\\n else:\\n right.append(nums[i])\\n return self.sort(left)+str(pivot)+self.sort(right)\\n \\n def compare(self,num1,num2):\\n return int(str(num1)+str(num2))>int(str(num2)+str(num1))\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"largestNumber\", \"inputs\": [[[10, 2]]], \"outputs\": [\"210\"]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/largest-number/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def largestNumber(self, nums: List[int]) -> str:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def largestNumber(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: str\n \"\"\"\n nums = [str(n) for n in nums]\n \n nums.sort(reverse=True)\n \n for i in range(1, len(nums)):\n if len(nums[i-1]) > len(nums[i]):\n ran = len(nums[i])\n j = i\n while j-1 >= 0 and nums[j-1][:ran] == nums[j] and nums[j-1]+nums[j]<=nums[j]+nums[j-1]:\n nums[j-1], nums[j] = nums[j], nums[j-1]\n j -= 1\n \n return str(int(''.join(nums)))","class Solution:\n class MyNumber:\n def __init__(self, v):\n self.str_val = str(v)\n self.val = [int(x) for x in self.str_val]\n self.n = len(self.val)\n def __cmp__(self, other):\n n1 = self.str_val + other.str_val\n n2 = other.str_val + self.str_val \n return 0 if n1 == n2 else 1 if n1 > n2 else -1\n \n \n def largestNumber(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: str\n \"\"\"\n if all(x == 0 for x in nums):\n return '0'\n myns = [self.MyNumber(x) for x in nums]\n \n for i in range(len(nums)):\n for j in range(i + 1, len(nums)):\n if myns[j].__cmp__(myns[i]) > 0:\n t = myns[i]\n myns[i] = myns[j]\n myns[j] = t\n \n return \"\".join([x.str_val for x in myns])\n \n","class Solution:\n def largestNumber(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: str\n \"\"\"\n # maxPos = 0\n # maxNum = ''\n # maxLen = 0\n # maxCut = ''\n # res = ''\n # while nums:\n # for i in range(len(nums)):\n # cur = nums[i]\n # ori = cur\n # while cur % 10 == 0:\n # cur = cur // 10\n # if str(cur) > maxCut or (str(cur) == maxCut and len(str(ori)) < maxLen):\n # maxCut = str(cur)\n # maxNum = str(ori)\n # maxPos = i\n # maxLen = len(maxNum)\n # nums.pop(maxPos)\n # res += maxNum\n # maxPos = 0\n # maxNum = ''\n # maxLen = 0\n # maxCut = ''\n # return res\n \n maxPos = 0\n maxNum = ''\n res = ''\n while nums:\n for i in range(len(nums)):\n cur = nums[i]\n if str(cur) + maxNum >= maxNum + str(cur):\n maxNum = str(cur)\n maxPos = i\n nums.pop(maxPos)\n res += maxNum\n maxPos = 0\n maxNum = ''\n if res[0] == '0':\n return '0'\n return res\n","class Solution:\n def largestNumber(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: str\n \"\"\"\n \n ## edge case: 981 3,31 331 313\n \n \n strs = [str(num) for num in nums]\n \n def bigger(str1, str2):\n if int(str1+str2) >= int(str2+str1):\n return str1\n else:\n return str2\n \n answer = \"\"\n current = strs\n while current:\n maximum = current[0]\n for i in range(len(current)):\n maximum = bigger(maximum, current[i])\n \n answer += maximum\n current.remove(maximum)\n \n if answer[0] == \"0\":\n return \"0\"\n return answer","class Solution:\n def largestNumber(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: str\n \"\"\"\n # case 1 34 vs 34\n #case2: 3 vs 34 ; 34 vs 3; 30 vs 3; 3 vs 30\n \n # this works:\n # compare the element by ourselves according to the rule of largest number first \n if nums is None or len(nums) == 0:\n return ''\n \n for i in range(len(nums)-1, -1, -1):\n for j in range(len(nums)-1, len(nums)-i-1, -1):\n #compare element 1, 2\n e1 = str(nums[j-1])\n e2 = str(nums[j])\n #print (\"e1, e2: \", e1, e2, nums)\n if e1+e2 < e2+e1:\n #swap \n t = nums[j]\n nums[j] = nums[j-1]\n nums[j-1] = t\n \n ans = ''\n for n in nums:\n if n == 0 and ans == '':\n continue\n ans += str(n)\n #print (\"nums: \", nums)\n return '0' if len(ans) == 0 else ans \n","class Solution:\n \n def largestNumber(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: str\n \"\"\"\n import functools\n # s_nums = []\n # maximum_length = 0\n # result = \"\"\n # dic = {}\n # for i in range(0, len(nums)):\n # value = str(num[i])\n # maximum_length = max(maximum_length, len(value))\n # s_nums.append(value)\n # dic[i] = True\n \n # for i in range(0, maximum_length-1): \n # temp_max = \"\"\n # temp_max_array = []\n # for j in range(0, s_nums-1):\n # try:\n # a = s_nums[j][i]\n # try:\n # b = s_nums[j][i+1]\n # except:\n # if dic[j] != False:\n # temp_max_array.append(nums[j])\n # dic[j] = False\n # dic[j] += 1\n # except:\n # continue\n # print(temp_max_array)\n # result += ''.join(sorted(temp_max_array))\n \n # return result\n nums_str = []\n for each in nums:\n nums_str.append(str(each))\n \n result = ''.join(sorted(nums_str, key = functools.cmp_to_key(self.comparator)))\n \n if int(result) == 0:\n return '0'\n else:\n return result\n \n \n \n def comparator(self, a, b):\n \n num1 = a + b\n num2 = b + a\n \n if num1 > num2:\n return -1\n elif num2 > num1:\n return 1\n else:\n return 0\n \n","class Solution:\n def sorting(self, numstr):\n newnumstr = []\n #print(numstr)\n for i in range(0, len(numstr)):\n for j in range(1, len(numstr)-i):\n if numstr[j-1] + numstr[j] < numstr[j] + numstr[j-1]:\n temp = numstr[j-1]\n numstr[j-1] = numstr[j]\n numstr[j] = temp\n #print(numstr)\n def largestNumber(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: str\n \"\"\"\n matrix = dict()\n for num in nums:\n numstr = str(num)\n if numstr[0] not in matrix:\n matrix[numstr[0]] = []\n matrix[numstr[0]].append(numstr)\n print(matrix)\n \n ret = \"\"\n for i in range(9, -1, -1):\n if str(i) in matrix:\n prenums = matrix[str(i)]\n self.sorting(prenums)\n #print(prenums)\n ret += \"\".join(prenums)\n #print(ret)\n return str(int(ret))\n","class Solution:\n def largestNumber(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: str\n \"\"\"\n def lexic_comp(a, b):\n ab = str(a) + str(b)\n ba = str(b) + str(a)\n if ab > ba:\n return -1\n elif ba > ab:\n return 1\n return 0\n \n import functools\n \n nums.sort(key=functools.cmp_to_key(lexic_comp))\n \n return str(int(''.join(map(str, nums))))\n","class Solution:\n def largestNumber(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: str\n \"\"\"\n s=self.sort(nums)\n if s.startswith(\"0\"):\n return \"0\"\n else:return s\n def sort(self,nums):\n if not nums:return \"\"\n else:\n pivot=nums[0]\n left=[]\n right=[]\n for i in range(1,len(nums)):\n if self.compare(nums[i],pivot):\n left.append(nums[i])\n else:\n right.append(nums[i])\n return self.sort(left)+str(pivot)+self.sort(right)\n \n def compare(self,num1,num2):\n num1,num2=str(num1),str(num2)\n return int(num1+num2)>int(num2+num1)","class Solution:\n def largestNumber(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: str\n \"\"\"\n def cmp_to_key(mycmp):\n 'Convert a cmp= function into a key= function'\n class K:\n def __init__(self, obj, *args):\n self.obj = obj\n def __lt__(self, other):\n return mycmp(self.obj, other.obj) < 0\n def __gt__(self, other):\n return mycmp(self.obj, other.obj) > 0\n def __eq__(self, other):\n return mycmp(self.obj, other.obj) == 0\n def __le__(self, other):\n return mycmp(self.obj, other.obj) <= 0\n def __ge__(self, other):\n return mycmp(self.obj, other.obj) >= 0\n def __ne__(self, other):\n return mycmp(self.obj, other.obj) != 0\n return K\n \n def compare(n1, n2):\n #print(n1, n2, \":\")\n l1 = len(n1)\n l2 = len(n2)\n i = 0\n if l1 != l2:\n tmp = n1 \n n1 = n1 + n2\n n2 = n2 + tmp\n l1 = l1 + l2\n #print(n1, n2)\n while i < max(l1, l2):\n #print(i, n1[i], n2[i])\n if n1[i] < n2[i]:\n #print(n1, \"<\", n2)\n return -1\n elif n1[i] > n2[i]:\n #print(n1, \">\", n2)\n return 1\n i += 1\n #print(n1, \"=\", n2)\n return 0\n \n \n def convert(num):\n if num == 0:\n return [0]\n res = []\n while num:\n res.append(num % 10)\n num //= 10\n res.reverse()\n return res\n \n nums = list(map(convert, nums))\n nums.sort(key=cmp_to_key(compare), reverse=True)\n print(nums)\n res = [str(c) for num in nums for c in num]\n \n res = \"\".join(res).lstrip('0')\n if not res:\n res = '0'\n return res","class Solution:\n def largestNumber(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: str\n \"\"\"\n s=self.sort(nums)\n if s.startswith(\"0\"):\n return \"0\"\n else:return s\n def sort(self,nums):\n if not nums:return \"\"\n else:\n pivot=nums[0]\n left=[]\n right=[]\n for i in range(1,len(nums)):\n if self.compare(nums[i],pivot):\n left.append(nums[i])\n else:\n right.append(nums[i])\n return self.sort(left)+str(pivot)+self.sort(right)\n \n def compare(self,num1,num2):\n return int(str(num1)+str(num2))>int(str(num2)+str(num1))"],"string":"[\n \"class Solution:\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n nums = [str(n) for n in nums]\\n \\n nums.sort(reverse=True)\\n \\n for i in range(1, len(nums)):\\n if len(nums[i-1]) > len(nums[i]):\\n ran = len(nums[i])\\n j = i\\n while j-1 >= 0 and nums[j-1][:ran] == nums[j] and nums[j-1]+nums[j]<=nums[j]+nums[j-1]:\\n nums[j-1], nums[j] = nums[j], nums[j-1]\\n j -= 1\\n \\n return str(int(''.join(nums)))\",\n \"class Solution:\\n class MyNumber:\\n def __init__(self, v):\\n self.str_val = str(v)\\n self.val = [int(x) for x in self.str_val]\\n self.n = len(self.val)\\n def __cmp__(self, other):\\n n1 = self.str_val + other.str_val\\n n2 = other.str_val + self.str_val \\n return 0 if n1 == n2 else 1 if n1 > n2 else -1\\n \\n \\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n if all(x == 0 for x in nums):\\n return '0'\\n myns = [self.MyNumber(x) for x in nums]\\n \\n for i in range(len(nums)):\\n for j in range(i + 1, len(nums)):\\n if myns[j].__cmp__(myns[i]) > 0:\\n t = myns[i]\\n myns[i] = myns[j]\\n myns[j] = t\\n \\n return \\\"\\\".join([x.str_val for x in myns])\\n \\n\",\n \"class Solution:\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n # maxPos = 0\\n # maxNum = ''\\n # maxLen = 0\\n # maxCut = ''\\n # res = ''\\n # while nums:\\n # for i in range(len(nums)):\\n # cur = nums[i]\\n # ori = cur\\n # while cur % 10 == 0:\\n # cur = cur // 10\\n # if str(cur) > maxCut or (str(cur) == maxCut and len(str(ori)) < maxLen):\\n # maxCut = str(cur)\\n # maxNum = str(ori)\\n # maxPos = i\\n # maxLen = len(maxNum)\\n # nums.pop(maxPos)\\n # res += maxNum\\n # maxPos = 0\\n # maxNum = ''\\n # maxLen = 0\\n # maxCut = ''\\n # return res\\n \\n maxPos = 0\\n maxNum = ''\\n res = ''\\n while nums:\\n for i in range(len(nums)):\\n cur = nums[i]\\n if str(cur) + maxNum >= maxNum + str(cur):\\n maxNum = str(cur)\\n maxPos = i\\n nums.pop(maxPos)\\n res += maxNum\\n maxPos = 0\\n maxNum = ''\\n if res[0] == '0':\\n return '0'\\n return res\\n\",\n \"class Solution:\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n \\n ## edge case: 981 3,31 331 313\\n \\n \\n strs = [str(num) for num in nums]\\n \\n def bigger(str1, str2):\\n if int(str1+str2) >= int(str2+str1):\\n return str1\\n else:\\n return str2\\n \\n answer = \\\"\\\"\\n current = strs\\n while current:\\n maximum = current[0]\\n for i in range(len(current)):\\n maximum = bigger(maximum, current[i])\\n \\n answer += maximum\\n current.remove(maximum)\\n \\n if answer[0] == \\\"0\\\":\\n return \\\"0\\\"\\n return answer\",\n \"class Solution:\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n # case 1 34 vs 34\\n #case2: 3 vs 34 ; 34 vs 3; 30 vs 3; 3 vs 30\\n \\n # this works:\\n # compare the element by ourselves according to the rule of largest number first \\n if nums is None or len(nums) == 0:\\n return ''\\n \\n for i in range(len(nums)-1, -1, -1):\\n for j in range(len(nums)-1, len(nums)-i-1, -1):\\n #compare element 1, 2\\n e1 = str(nums[j-1])\\n e2 = str(nums[j])\\n #print (\\\"e1, e2: \\\", e1, e2, nums)\\n if e1+e2 < e2+e1:\\n #swap \\n t = nums[j]\\n nums[j] = nums[j-1]\\n nums[j-1] = t\\n \\n ans = ''\\n for n in nums:\\n if n == 0 and ans == '':\\n continue\\n ans += str(n)\\n #print (\\\"nums: \\\", nums)\\n return '0' if len(ans) == 0 else ans \\n\",\n \"class Solution:\\n \\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n import functools\\n # s_nums = []\\n # maximum_length = 0\\n # result = \\\"\\\"\\n # dic = {}\\n # for i in range(0, len(nums)):\\n # value = str(num[i])\\n # maximum_length = max(maximum_length, len(value))\\n # s_nums.append(value)\\n # dic[i] = True\\n \\n # for i in range(0, maximum_length-1): \\n # temp_max = \\\"\\\"\\n # temp_max_array = []\\n # for j in range(0, s_nums-1):\\n # try:\\n # a = s_nums[j][i]\\n # try:\\n # b = s_nums[j][i+1]\\n # except:\\n # if dic[j] != False:\\n # temp_max_array.append(nums[j])\\n # dic[j] = False\\n # dic[j] += 1\\n # except:\\n # continue\\n # print(temp_max_array)\\n # result += ''.join(sorted(temp_max_array))\\n \\n # return result\\n nums_str = []\\n for each in nums:\\n nums_str.append(str(each))\\n \\n result = ''.join(sorted(nums_str, key = functools.cmp_to_key(self.comparator)))\\n \\n if int(result) == 0:\\n return '0'\\n else:\\n return result\\n \\n \\n \\n def comparator(self, a, b):\\n \\n num1 = a + b\\n num2 = b + a\\n \\n if num1 > num2:\\n return -1\\n elif num2 > num1:\\n return 1\\n else:\\n return 0\\n \\n\",\n \"class Solution:\\n def sorting(self, numstr):\\n newnumstr = []\\n #print(numstr)\\n for i in range(0, len(numstr)):\\n for j in range(1, len(numstr)-i):\\n if numstr[j-1] + numstr[j] < numstr[j] + numstr[j-1]:\\n temp = numstr[j-1]\\n numstr[j-1] = numstr[j]\\n numstr[j] = temp\\n #print(numstr)\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n matrix = dict()\\n for num in nums:\\n numstr = str(num)\\n if numstr[0] not in matrix:\\n matrix[numstr[0]] = []\\n matrix[numstr[0]].append(numstr)\\n print(matrix)\\n \\n ret = \\\"\\\"\\n for i in range(9, -1, -1):\\n if str(i) in matrix:\\n prenums = matrix[str(i)]\\n self.sorting(prenums)\\n #print(prenums)\\n ret += \\\"\\\".join(prenums)\\n #print(ret)\\n return str(int(ret))\\n\",\n \"class Solution:\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n def lexic_comp(a, b):\\n ab = str(a) + str(b)\\n ba = str(b) + str(a)\\n if ab > ba:\\n return -1\\n elif ba > ab:\\n return 1\\n return 0\\n \\n import functools\\n \\n nums.sort(key=functools.cmp_to_key(lexic_comp))\\n \\n return str(int(''.join(map(str, nums))))\\n\",\n \"class Solution:\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n s=self.sort(nums)\\n if s.startswith(\\\"0\\\"):\\n return \\\"0\\\"\\n else:return s\\n def sort(self,nums):\\n if not nums:return \\\"\\\"\\n else:\\n pivot=nums[0]\\n left=[]\\n right=[]\\n for i in range(1,len(nums)):\\n if self.compare(nums[i],pivot):\\n left.append(nums[i])\\n else:\\n right.append(nums[i])\\n return self.sort(left)+str(pivot)+self.sort(right)\\n \\n def compare(self,num1,num2):\\n num1,num2=str(num1),str(num2)\\n return int(num1+num2)>int(num2+num1)\",\n \"class Solution:\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n def cmp_to_key(mycmp):\\n 'Convert a cmp= function into a key= function'\\n class K:\\n def __init__(self, obj, *args):\\n self.obj = obj\\n def __lt__(self, other):\\n return mycmp(self.obj, other.obj) < 0\\n def __gt__(self, other):\\n return mycmp(self.obj, other.obj) > 0\\n def __eq__(self, other):\\n return mycmp(self.obj, other.obj) == 0\\n def __le__(self, other):\\n return mycmp(self.obj, other.obj) <= 0\\n def __ge__(self, other):\\n return mycmp(self.obj, other.obj) >= 0\\n def __ne__(self, other):\\n return mycmp(self.obj, other.obj) != 0\\n return K\\n \\n def compare(n1, n2):\\n #print(n1, n2, \\\":\\\")\\n l1 = len(n1)\\n l2 = len(n2)\\n i = 0\\n if l1 != l2:\\n tmp = n1 \\n n1 = n1 + n2\\n n2 = n2 + tmp\\n l1 = l1 + l2\\n #print(n1, n2)\\n while i < max(l1, l2):\\n #print(i, n1[i], n2[i])\\n if n1[i] < n2[i]:\\n #print(n1, \\\"<\\\", n2)\\n return -1\\n elif n1[i] > n2[i]:\\n #print(n1, \\\">\\\", n2)\\n return 1\\n i += 1\\n #print(n1, \\\"=\\\", n2)\\n return 0\\n \\n \\n def convert(num):\\n if num == 0:\\n return [0]\\n res = []\\n while num:\\n res.append(num % 10)\\n num //= 10\\n res.reverse()\\n return res\\n \\n nums = list(map(convert, nums))\\n nums.sort(key=cmp_to_key(compare), reverse=True)\\n print(nums)\\n res = [str(c) for num in nums for c in num]\\n \\n res = \\\"\\\".join(res).lstrip('0')\\n if not res:\\n res = '0'\\n return res\",\n \"class Solution:\\n def largestNumber(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: str\\n \\\"\\\"\\\"\\n s=self.sort(nums)\\n if s.startswith(\\\"0\\\"):\\n return \\\"0\\\"\\n else:return s\\n def sort(self,nums):\\n if not nums:return \\\"\\\"\\n else:\\n pivot=nums[0]\\n left=[]\\n right=[]\\n for i in range(1,len(nums)):\\n if self.compare(nums[i],pivot):\\n left.append(nums[i])\\n else:\\n right.append(nums[i])\\n return self.sort(left)+str(pivot)+self.sort(right)\\n \\n def compare(self,num1,num2):\\n return int(str(num1)+str(num2))>int(str(num2)+str(num1))\"\n]","isConversational":false},"n_sols":{"kind":"number","value":11,"string":"11"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4,5,6,7,8,9,10],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null,null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":75,"cells":{"problem_id":{"kind":"number","value":208,"string":"208"},"question":{"kind":"string","value":"In the world of Dota2, there are two parties: the Radiant and the Dire.\n\n\n\nThe Dota2 senate consists of senators coming from two parties. Now the senate wants to make a decision about a change in the Dota2 game. The voting for this change is a round-based procedure. In each round, each senator can exercise one of the two rights:\n\nBan one senator's right: A senator can make another senator lose all his rights in this and all the following rounds.\nAnnounce the victory: If this senator found the senators who still have rights to vote are all from the same party, he can announce the victory and make the decision about the change in the game.\n\n\n\n\nGiven a string representing each senator's party belonging. The character 'R' and 'D' represent the Radiant party and the Dire party respectively. Then if there are n senators, the size of the given string will be n.\n\n\n\nThe round-based procedure starts from the first senator to the last senator in the given order. This procedure will last until the end of voting. All the senators who have lost their rights will be skipped during the procedure.\n\n\n\nSuppose every senator is smart enough and will play the best strategy for his own party, you need to predict which party will finally announce the victory and make the change in the Dota2 game. The output should be Radiant or Dire.\n\n\nExample 1:\n\nInput: \"RD\"\nOutput: \"Radiant\"\nExplanation: The first senator comes from Radiant and he can just ban the next senator's right in the round 1. And the second senator can't exercise any rights any more since his right has been banned. And in the round 2, the first senator can just announce the victory since he is the only guy in the senate who can vote.\n\n\n\n\nExample 2:\n\nInput: \"RDD\"\nOutput: \"Dire\"\nExplanation: \nThe first senator comes from Radiant and he can just ban the next senator's right in the round 1. And the second senator can't exercise any rights anymore since his right has been banned. And the third senator comes from Dire and he can ban the first senator's right in the round 1. And in the round 2, the third senator can just announce the victory since he is the only guy in the senate who can vote.\n\n\n\nNote:\n\nThe length of the given string will in the range [1, 10,000]."},"solutions":{"kind":"string","value":"[\"class Solution:\\n def predictPartyVictory(self, senate):\\n \\\"\\\"\\\"\\n :type senate: str\\n :rtype: str\\n \\\"\\\"\\\"\\n num = 0 # num of Reeding R\\n while ('R' in senate and 'D' in senate):\\n res = []\\n for i in senate:\\n if i=='R':\\n if num>=0:\\n res.append(i)\\n num+=1\\n else:\\n if num<=0:\\n res.append(i)\\n num-=1\\n senate = res\\n return 'Radiant' if 'R' in senate else 'Dire'\\n\", \"class Solution:\\n def predictPartyVictory(self, senate):\\n \\\"\\\"\\\"\\n :type senate: str\\n :rtype: str\\n \\\"\\\"\\\"\\n from collections import deque\\n n = len(senate)\\n queueR = deque()\\n queueD = deque()\\n for i in range(len(senate)):\\n if senate[i] == \\\"R\\\":\\n queueR.append(i)\\n else:\\n queueD.append(i)\\n while queueR and queueD:\\n p1 = queueR.popleft()\\n p2 = queueD.popleft()\\n if p1 < p2:\\n queueR.append(p1+n)\\n else:\\n queueD.append(p2+n)\\n if queueR:\\n return \\\"Radiant\\\"\\n return \\\"Dire\\\"\", \"class Solution:\\n def predictPartyVictory(self, senate):\\n \\\"\\\"\\\"\\n :type senate: str\\n :rtype: str\\n \\\"\\\"\\\"\\n r = collections.deque()\\n d = collections.deque()\\n for i,c in enumerate(senate):\\n if c == \\\"R\\\":\\n r.append(i)\\n else:\\n d.append(i)\\n \\n return self.eliminateSenators(r,d)\\n \\n def eliminateSenators(self,r,d):\\n if len(r)==0: return \\\"Dire\\\"\\n if len(d)==0:return \\\"Radiant\\\"\\n \\n r2 = collections.deque()\\n d2 = collections.deque()\\n \\n while len(r)> 0 or len(d)>0:\\n if len(r)==0:\\n if len(r2)==0:\\n return \\\"Dire\\\"\\n else:\\n r2.popleft()\\n d2.append(d.popleft())\\n elif len(d)==0:\\n if len(d2)==0:\\n return \\\"Radiant\\\"\\n else:\\n d2.popleft()\\n r2.append(r.popleft()) \\n else:\\n r_curr = r.popleft()\\n d_curr = d.popleft()\\n if r_curr < d_curr:\\n r2.append(r_curr)\\n else:\\n d2.append(d_curr)\\n \\n return self.eliminateSenators(r2,d2) \", \"class Solution:\\n def predictPartyVictory(self, senate):\\n \\\"\\\"\\\"\\n :type senate: str\\n :rtype: str\\n \\\"\\\"\\\"\\n queue = collections.deque()\\n people, bans = [0, 0], [0, 0]\\n \\n for person in senate:\\n x = person == 'R'\\n people[x] += 1\\n queue.append(x)\\n \\n while all(people):\\n x = queue.popleft()\\n if bans[x]:\\n bans[x] -= 1\\n people[x] -= 1\\n else:\\n bans[x^1] += 1\\n queue.append(x)\\n \\n return 'Radiant' if people[1] else 'Dire'\\n\", \"class Solution:\\n def predictPartyVictory(self, senate):\\n \\\"\\\"\\\"\\n :type senate: str\\n :rtype: str\\n \\\"\\\"\\\"\\n queue = collections.deque()\\n people, bans = [0, 0], [0, 0]\\n \\n for person in senate:\\n x = person == 'R'\\n people[x] += 1\\n queue.append(x)\\n \\n while all(people):\\n x = queue.popleft()\\n if bans[x]:\\n bans[x] -= 1\\n people[x] -= 1\\n else:\\n bans[x^1] += 1\\n queue.append(x)\\n \\n return \\\"Radiant\\\" if people[1] else \\\"Dire\\\" \", \"class Solution:\\n def predictPartyVictory(self, senate):\\n \\\"\\\"\\\"\\n :type senate: str\\n :rtype: str\\n \\\"\\\"\\\"\\n s = [1 if x == 'R' else 0 for x in senate]\\n \\n Rban = 0\\n Dban = 0\\n i = 0\\n ban = False\\n while True:\\n if s[i] == -1: pass\\n else:\\n if s[i] == 1:\\n if Dban > 0:\\n Dban -= 1\\n s[i] = -1\\n ban = True\\n else: Rban += 1\\n else:\\n if Rban > 0:\\n Rban -= 1\\n s[i] = -1\\n ban = True\\n else: Dban += 1\\n \\n i += 1\\n if i == len(s):\\n i = 0\\n if not ban: break\\n else: ban = False\\n \\n if Rban > 0: return \\\"Radiant\\\"\\n else: return \\\"Dire\\\"\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"predictPartyVictory\", \"inputs\": [[\"\\\"RD\\\"\"]], \"outputs\": [\"Dire\"]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/dota2-senate/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def predictPartyVictory(self, senate: str) -> str:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def predictPartyVictory(self, senate):\n \"\"\"\n :type senate: str\n :rtype: str\n \"\"\"\n num = 0 # num of Reeding R\n while ('R' in senate and 'D' in senate):\n res = []\n for i in senate:\n if i=='R':\n if num>=0:\n res.append(i)\n num+=1\n else:\n if num<=0:\n res.append(i)\n num-=1\n senate = res\n return 'Radiant' if 'R' in senate else 'Dire'\n","class Solution:\n def predictPartyVictory(self, senate):\n \"\"\"\n :type senate: str\n :rtype: str\n \"\"\"\n from collections import deque\n n = len(senate)\n queueR = deque()\n queueD = deque()\n for i in range(len(senate)):\n if senate[i] == \"R\":\n queueR.append(i)\n else:\n queueD.append(i)\n while queueR and queueD:\n p1 = queueR.popleft()\n p2 = queueD.popleft()\n if p1 < p2:\n queueR.append(p1+n)\n else:\n queueD.append(p2+n)\n if queueR:\n return \"Radiant\"\n return \"Dire\"","class Solution:\n def predictPartyVictory(self, senate):\n \"\"\"\n :type senate: str\n :rtype: str\n \"\"\"\n r = collections.deque()\n d = collections.deque()\n for i,c in enumerate(senate):\n if c == \"R\":\n r.append(i)\n else:\n d.append(i)\n \n return self.eliminateSenators(r,d)\n \n def eliminateSenators(self,r,d):\n if len(r)==0: return \"Dire\"\n if len(d)==0:return \"Radiant\"\n \n r2 = collections.deque()\n d2 = collections.deque()\n \n while len(r)> 0 or len(d)>0:\n if len(r)==0:\n if len(r2)==0:\n return \"Dire\"\n else:\n r2.popleft()\n d2.append(d.popleft())\n elif len(d)==0:\n if len(d2)==0:\n return \"Radiant\"\n else:\n d2.popleft()\n r2.append(r.popleft()) \n else:\n r_curr = r.popleft()\n d_curr = d.popleft()\n if r_curr < d_curr:\n r2.append(r_curr)\n else:\n d2.append(d_curr)\n \n return self.eliminateSenators(r2,d2) ","class Solution:\n def predictPartyVictory(self, senate):\n \"\"\"\n :type senate: str\n :rtype: str\n \"\"\"\n queue = collections.deque()\n people, bans = [0, 0], [0, 0]\n \n for person in senate:\n x = person == 'R'\n people[x] += 1\n queue.append(x)\n \n while all(people):\n x = queue.popleft()\n if bans[x]:\n bans[x] -= 1\n people[x] -= 1\n else:\n bans[x^1] += 1\n queue.append(x)\n \n return 'Radiant' if people[1] else 'Dire'\n","class Solution:\n def predictPartyVictory(self, senate):\n \"\"\"\n :type senate: str\n :rtype: str\n \"\"\"\n queue = collections.deque()\n people, bans = [0, 0], [0, 0]\n \n for person in senate:\n x = person == 'R'\n people[x] += 1\n queue.append(x)\n \n while all(people):\n x = queue.popleft()\n if bans[x]:\n bans[x] -= 1\n people[x] -= 1\n else:\n bans[x^1] += 1\n queue.append(x)\n \n return \"Radiant\" if people[1] else \"Dire\" ","class Solution:\n def predictPartyVictory(self, senate):\n \"\"\"\n :type senate: str\n :rtype: str\n \"\"\"\n s = [1 if x == 'R' else 0 for x in senate]\n \n Rban = 0\n Dban = 0\n i = 0\n ban = False\n while True:\n if s[i] == -1: pass\n else:\n if s[i] == 1:\n if Dban > 0:\n Dban -= 1\n s[i] = -1\n ban = True\n else: Rban += 1\n else:\n if Rban > 0:\n Rban -= 1\n s[i] = -1\n ban = True\n else: Dban += 1\n \n i += 1\n if i == len(s):\n i = 0\n if not ban: break\n else: ban = False\n \n if Rban > 0: return \"Radiant\"\n else: return \"Dire\""],"string":"[\n \"class Solution:\\n def predictPartyVictory(self, senate):\\n \\\"\\\"\\\"\\n :type senate: str\\n :rtype: str\\n \\\"\\\"\\\"\\n num = 0 # num of Reeding R\\n while ('R' in senate and 'D' in senate):\\n res = []\\n for i in senate:\\n if i=='R':\\n if num>=0:\\n res.append(i)\\n num+=1\\n else:\\n if num<=0:\\n res.append(i)\\n num-=1\\n senate = res\\n return 'Radiant' if 'R' in senate else 'Dire'\\n\",\n \"class Solution:\\n def predictPartyVictory(self, senate):\\n \\\"\\\"\\\"\\n :type senate: str\\n :rtype: str\\n \\\"\\\"\\\"\\n from collections import deque\\n n = len(senate)\\n queueR = deque()\\n queueD = deque()\\n for i in range(len(senate)):\\n if senate[i] == \\\"R\\\":\\n queueR.append(i)\\n else:\\n queueD.append(i)\\n while queueR and queueD:\\n p1 = queueR.popleft()\\n p2 = queueD.popleft()\\n if p1 < p2:\\n queueR.append(p1+n)\\n else:\\n queueD.append(p2+n)\\n if queueR:\\n return \\\"Radiant\\\"\\n return \\\"Dire\\\"\",\n \"class Solution:\\n def predictPartyVictory(self, senate):\\n \\\"\\\"\\\"\\n :type senate: str\\n :rtype: str\\n \\\"\\\"\\\"\\n r = collections.deque()\\n d = collections.deque()\\n for i,c in enumerate(senate):\\n if c == \\\"R\\\":\\n r.append(i)\\n else:\\n d.append(i)\\n \\n return self.eliminateSenators(r,d)\\n \\n def eliminateSenators(self,r,d):\\n if len(r)==0: return \\\"Dire\\\"\\n if len(d)==0:return \\\"Radiant\\\"\\n \\n r2 = collections.deque()\\n d2 = collections.deque()\\n \\n while len(r)> 0 or len(d)>0:\\n if len(r)==0:\\n if len(r2)==0:\\n return \\\"Dire\\\"\\n else:\\n r2.popleft()\\n d2.append(d.popleft())\\n elif len(d)==0:\\n if len(d2)==0:\\n return \\\"Radiant\\\"\\n else:\\n d2.popleft()\\n r2.append(r.popleft()) \\n else:\\n r_curr = r.popleft()\\n d_curr = d.popleft()\\n if r_curr < d_curr:\\n r2.append(r_curr)\\n else:\\n d2.append(d_curr)\\n \\n return self.eliminateSenators(r2,d2) \",\n \"class Solution:\\n def predictPartyVictory(self, senate):\\n \\\"\\\"\\\"\\n :type senate: str\\n :rtype: str\\n \\\"\\\"\\\"\\n queue = collections.deque()\\n people, bans = [0, 0], [0, 0]\\n \\n for person in senate:\\n x = person == 'R'\\n people[x] += 1\\n queue.append(x)\\n \\n while all(people):\\n x = queue.popleft()\\n if bans[x]:\\n bans[x] -= 1\\n people[x] -= 1\\n else:\\n bans[x^1] += 1\\n queue.append(x)\\n \\n return 'Radiant' if people[1] else 'Dire'\\n\",\n \"class Solution:\\n def predictPartyVictory(self, senate):\\n \\\"\\\"\\\"\\n :type senate: str\\n :rtype: str\\n \\\"\\\"\\\"\\n queue = collections.deque()\\n people, bans = [0, 0], [0, 0]\\n \\n for person in senate:\\n x = person == 'R'\\n people[x] += 1\\n queue.append(x)\\n \\n while all(people):\\n x = queue.popleft()\\n if bans[x]:\\n bans[x] -= 1\\n people[x] -= 1\\n else:\\n bans[x^1] += 1\\n queue.append(x)\\n \\n return \\\"Radiant\\\" if people[1] else \\\"Dire\\\" \",\n \"class Solution:\\n def predictPartyVictory(self, senate):\\n \\\"\\\"\\\"\\n :type senate: str\\n :rtype: str\\n \\\"\\\"\\\"\\n s = [1 if x == 'R' else 0 for x in senate]\\n \\n Rban = 0\\n Dban = 0\\n i = 0\\n ban = False\\n while True:\\n if s[i] == -1: pass\\n else:\\n if s[i] == 1:\\n if Dban > 0:\\n Dban -= 1\\n s[i] = -1\\n ban = True\\n else: Rban += 1\\n else:\\n if Rban > 0:\\n Rban -= 1\\n s[i] = -1\\n ban = True\\n else: Dban += 1\\n \\n i += 1\\n if i == len(s):\\n i = 0\\n if not ban: break\\n else: ban = False\\n \\n if Rban > 0: return \\\"Radiant\\\"\\n else: return \\\"Dire\\\"\"\n]","isConversational":false},"n_sols":{"kind":"number","value":6,"string":"6"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4,5],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":76,"cells":{"problem_id":{"kind":"number","value":209,"string":"209"},"question":{"kind":"string","value":"There are N piles of stones arranged in a row. The i-th pile has stones[i] stones.\nA move consists of merging exactly K consecutive piles into one pile, and the cost of this move is equal to the total number of stones in these K piles.\nFind the minimum cost to merge all piles of stones into one pile. If it is impossible, return -1.\n \n\nExample 1:\nInput: stones = [3,2,4,1], K = 2\nOutput: 20\nExplanation: \nWe start with [3, 2, 4, 1].\nWe merge [3, 2] for a cost of 5, and we are left with [5, 4, 1].\nWe merge [4, 1] for a cost of 5, and we are left with [5, 5].\nWe merge [5, 5] for a cost of 10, and we are left with [10].\nThe total cost was 20, and this is the minimum possible.\n\n\nExample 2:\nInput: stones = [3,2,4,1], K = 3\nOutput: -1\nExplanation: After any merge operation, there are 2 piles left, and we can't merge anymore. So the task is impossible.\n\n\nExample 3:\nInput: stones = [3,5,1,2,6], K = 3\nOutput: 25\nExplanation: \nWe start with [3, 5, 1, 2, 6].\nWe merge [5, 1, 2] for a cost of 8, and we are left with [3, 8, 6].\nWe merge [3, 8, 6] for a cost of 17, and we are left with [17].\nThe total cost was 25, and this is the minimum possible.\n\n \nNote:\n\n1 <= stones.length <= 30\n2 <= K <= 30\n1 <= stones[i] <= 100"},"solutions":{"kind":"string","value":"[\"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n if (n - 1) % (K - 1) != 0:\\n return -1\\n prefix = [0]\\n for s in stones:\\n prefix.append(prefix[-1] + s)\\n @lru_cache(None)\\n def dp(i, j):\\n if j - i + 1 < K:\\n return 0\\n res = 0\\n if (j - i) % (K - 1) == 0:\\n res = prefix[j+1] - prefix[i]\\n return res + min(dp(i, mid) + dp(mid+1, j) for mid in range(i, j, K - 1))\\n return dp(0, n - 1)\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n if (n-1)%(K-1) != 0:\\n return -1\\n dp = [[0]*n for _ in range(n)]\\n sums = [0]*(n+1)\\n for i in range(1,n+1):\\n sums[i] = sums[i-1]+stones[i-1]\\n for length in range(K,n+1):\\n for i in range(n-length+1):\\n j = i+length-1\\n dp[i][j] = float('inf')\\n for t in range(i,j,K-1):\\n dp[i][j] = min(dp[i][j], dp[i][t]+dp[t+1][j])\\n if (j-i)%(K-1)==0:\\n dp[i][j] += sums[j+1]-sums[i]\\n return dp[0][n-1]\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n \\n @lru_cache(None)\\n def recursive(i, j, piles):\\n if j - i + 1 < K: return 0\\n if piles == 1:\\n return recursive(i, j, K) + pre_sum[j+1] - pre_sum[i]\\n else:\\n min_cost = float('inf')\\n for k in range(i, j, K - 1):\\n min_cost = min(min_cost, recursive(i, k, 1) + recursive(k + 1, j, piles - 1))\\n return min_cost\\n \\n n = len(stones)\\n if (n - 1) % (K - 1) != 0:\\n return -1\\n pre_sum = [0] * (n + 1)\\n for i in range(n):\\n pre_sum[i + 1] = pre_sum[i] + stones[i]\\n\\n return recursive(0, n - 1, 1)\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n k = K\\n if (n < k and n != 1) or (n - 1) % (k - 1) != 0:\\n return -1\\n if n == 1:\\n return 0\\n \\n dp = [[-1 for _ in range(n)] for _ in range(n)] # dp[i][j] stores min cost to reduce [i, j] as much as possible\\n self.solve(stones, 0, n - 1, k, dp)\\n # print(dp)\\n return dp[0][n - 1]\\n \\n def solve(self, stones, l, r, k, dp):\\n length = r - l + 1\\n if length < k:\\n dp[l][r] = 0\\n return\\n if length == k:\\n dp[l][r] = sum(stones[l:r+1])\\n return\\n res = float('inf')\\n for m in range(l, r):\\n length = length\\n length_l = m - l + 1\\n length_r = r - m\\n \\n rem = k - 1 if length % (k - 1) == 0 else length % (k - 1)\\n rem_l = k - 1 if length_l % (k - 1) == 0 else length_l % (k - 1)\\n rem_r = k - 1 if length_r % (k - 1) == 0 else length_r % (k - 1)\\n rem_total = k - 1 if (rem_l + rem_r) % (k - 1) == 0 else (rem_l + rem_r) % (k - 1)\\n if rem_total == rem and (rem_l + rem_r) <= k:\\n if dp[l][m] == -1:\\n self.solve(stones, l, m, k, dp)\\n if dp[m + 1][r] == -1:\\n self.solve(stones, m + 1, r, k, dp)\\n # print('lets check {} to {} and {}'.format(l, m, r))\\n # print(dp[l][m], dp[m+1][r])\\n res = min(res, dp[l][m] + dp[m+1][r])\\n \\n dp[l][r] = res\\n if rem == 1:\\n dp[l][r] += sum(stones[l:r+1])\\n \\n \\n# class Solution:\\n# def mergeStones(self, stones: List[int], K: int) -> int:\\n# n = len(stones)\\n# k = K\\n# if (n < k and n != 1) or (n - k) % (k - 1) != 0:\\n# return -1\\n# if n == 1:\\n# return 0\\n \\n# return self.comp_min(stones, k, -1)\\n \\n# def comp_min(self, stones, k, locked): # can't do a merge which only involves the first 'locked' stones\\n# n = len(stones)\\n# if n == k:\\n# return sum(stones)\\n \\n# total_cur_cost = float('inf')\\n \\n# for i in range(max(0, locked - k + 2), n - k + 1):\\n# cur_cost = sum(stones[i:i+k])\\n# new_stones = stones[:i] + [cur_cost] + stones[i+k:]\\n \\n# new_locked = i - 1\\n \\n# tmp = self.comp_min(new_stones, k, new_locked)\\n \\n# total_cur_cost = min(total_cur_cost, cur_cost + tmp)\\n \\n# return total_cur_cost\\n\", \"from functools import lru_cache\\nimport itertools\\n\\nclass Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n # dp[i][j] means the minimum cost needed to merge stones[i] ~ stones[j].\\n # Time complexity: O(N^3 / K)\\n # Space complexity: O(KN^2)\\n n = len(stones)\\n if (n - 1) % (K - 1): return -1\\n prefix = [0] * (n + 1)\\n for i in range(n):\\n prefix[i + 1] = prefix[i] + stones[i]\\n\\n @lru_cache(None)\\n def dp(i, j):\\n if j - i + 1 < K: return 0\\n\\n res = min(dp(i, mid) + dp(mid + 1, j) for mid in range(i, j, K - 1))\\n\\n if (j - i) % (K - 1) == 0:\\n res += prefix[j + 1] - prefix[i]\\n\\n return res\\n\\n return dp(0, n - 1)\\n\", \"from functools import lru_cache\\nimport itertools\\n\\nclass Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n # Time complexity: O(N^3 / K)\\n # Space complexity: O(KN^2)\\n n = len(stones)\\n if (n - 1) % (K - 1): return -1\\n prefix = [0] * (n + 1)\\n for i in range(n):\\n prefix[i + 1] = prefix[i] + stones[i]\\n\\n @lru_cache(None)\\n def dp(i, j):\\n if j - i + 1 < K: return 0\\n\\n res = min(dp(i, mid) + dp(mid + 1, j) for mid in range(i, j, K - 1))\\n\\n if (j - i) % (K - 1) == 0:\\n res += prefix[j + 1] - prefix[i]\\n\\n return res\\n\\n return dp(0, n - 1)\\n\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n dp, N, Sum, H = {}, len(stones), {-1: 0}, {}\\n for i in range(N):\\n j, dp[i], H[i], Sum[i] = i, {}, {}, Sum[i - 1] + stones[i] \\n while j > -1:\\n H[i][j] = (i-j+1)%(K-1)+(K-1)*(1//(1+(i-j+1)%(K-1)))\\n if i - j < K - 1: dp[i][j] = 0 \\n else:\\n dp[i][j] = dp[i][i] + dp[i - 1][j]\\n for k in range(j + 1, i + 1):\\n if H[i][k] + H[k - 1][j] == H[i][j] or H[i][k] + H[k - 1][j] == K:\\n dp[i][j] = min(dp[i][j], dp[i][k] + dp[k - 1][j]) \\n if H[i][j] == 1: dp[i][j] += Sum[i] - Sum[j - 1]\\n j = j - 1 \\n return dp[N-1][0]*(1//H[N-1][0]) - min(H[N-1][0]-1, 1) \", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n k = K\\n if (n < k and n != 1) or (n - 1) % (k - 1) != 0:\\n return -1\\n if n == 1:\\n return 0\\n \\n dp = [[-1 for _ in range(n)] for _ in range(n)] # dp[i][j] stores min cost to reduce [i, j] as much as possible\\n self.solve(stones, 0, n - 1, k, dp)\\n return dp[0][n - 1]\\n \\n def solve(self, stones, l, r, k, dp):\\n length = r - l + 1\\n if length < k:\\n dp[l][r] = 0\\n return\\n if length == k:\\n dp[l][r] = sum(stones[l:r+1])\\n return\\n res = float('inf')\\n for m in range(l, r):\\n length = length\\n length_l = m - l + 1\\n length_r = r - m\\n \\n rem = k - 1 if length % (k - 1) == 0 else length % (k - 1)\\n rem_l = k - 1 if length_l % (k - 1) == 0 else length_l % (k - 1)\\n rem_r = k - 1 if length_r % (k - 1) == 0 else length_r % (k - 1)\\n rem_total = k - 1 if (rem_l + rem_r) % (k - 1) == 0 else (rem_l + rem_r) % (k - 1)\\n if rem_total == rem and (rem_l + rem_r) <= k:\\n if dp[l][m] == -1:\\n self.solve(stones, l, m, k, dp)\\n if dp[m + 1][r] == -1:\\n self.solve(stones, m + 1, r, k, dp)\\n res = min(res, dp[l][m] + dp[m+1][r])\\n \\n dp[l][r] = res\\n if rem == 1:\\n dp[l][r] += sum(stones[l:r+1])\\n\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n total = len(stones)\\n if (total-1) % (K-1):\\n return -1\\n \\n \\n prefix = [0] * (total+1)\\n for i in range(total):\\n prefix[i+1] = prefix[i]+stones[i]\\n \\n import functools\\n @functools.lru_cache(None)\\n def dfs(i, j):\\n if j-i+1 < K:\\n return 0\\n res = min(dfs(i,k)+dfs(k+1,j) for k in range(i, j, K-1))\\n if (j-i) % (K-1) == 0:\\n res += prefix[j+1]-prefix[i]\\n \\n return res\\n \\n return dfs(0, total-1)\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n '''\\n dp[i][j][k]: the min cost to merge stone[i: j + 1] into k piles\\n the range for consecutive piles of stone[i:j + 1] to be k piles after merging can be divided into two parts (for stones[:n] be finally merged into 1 pile):\\n 1. a sub-range from the start to the devide that is sured to be merged in to 1 pile: dp[i][divide][1]\\n divide goes from start by K - 1 step to make this happen: dp[i][divide][1] < math.inf\\n 2. a sub-range from the divide + 1 to the end (not guaranteed to be realistic): dp[divide + 1][k - 1]\\n The longer ranges are always merged from the smaller ones, no matter how the smaller ones were merged from. That is why this is a DP problem.\\n '''\\n n = len(stones)\\n if K > 2 and n % (K - 1) != 1:\\n return -1\\n \\n dp = [[[math.inf] * (K + 1) for i in range(n)] for j in range(n)]\\n for i in range(n):\\n dp[i][i][1] = 0\\n \\n presum = [stones[0]]\\n for i in range(1, n):\\n presum.append(presum[i - 1] + stones[i])\\n \\n def stones_in_range(i, j):\\n return presum[j] - presum[i - 1] if i > 0 else presum[j]\\n \\n for rangelen in range(2, n + 1):\\n for start in range(n + 1 - rangelen):\\n end = start + rangelen - 1\\n for k in range(2, K + 1):\\n for divide in range(start, end, K - 1):\\n dp[start][end][k] = min(dp[start][end][k], dp[start][divide][1] + dp[divide + 1][end][k - 1])\\n if dp[start][end][K] < math.inf:\\n dp[start][end][1] = dp[start][end][K] + stones_in_range(start, end)\\n \\n return dp[0][n - 1][1]\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n if (len(stones) - 1) % (K - 1) != 0:\\n return -1\\n \\n prefix = [0]\\n for stone in stones:\\n prefix.append(prefix[-1] + stone)\\n \\n memo = {}\\n\\n def recur(i: int, j: int, m: int):\\n key = str(i) + ',' + str(j) + ',' + str(m)\\n if key in memo:\\n return memo[key]\\n \\n if (j - i + 1 - m) % (K - 1):\\n return 91111111\\n \\n if (j - i + 1) < K:\\n memo[key] = 0\\n return 0\\n\\n if m == 1:\\n if j - i + 1 == K:\\n memo[key] = prefix[j + 1] - prefix[i]\\n return memo[key]\\n else:\\n return recur(i, j, K) + prefix[j + 1] - prefix[i]\\n\\n min_sum = 91111111\\n for mid in range(i, j, K - 1):\\n cur_sum = recur(i, mid, 1) + recur(mid + 1, j, m - 1)\\n min_sum = min(min_sum, cur_sum)\\n\\n memo[key] = min_sum\\n return min_sum\\n \\n return recur(0, len(stones) - 1, 1)\", \"from typing import List\\nimport numpy\\nimport sys\\nimport bisect\\n\\n\\nclass Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n\\n tmp = 0\\n n = len(stones)\\n dims = (n, n)\\n dp = numpy.zeros(dims)\\n presum = numpy.zeros(n+1)\\n\\n if (n - 1) % (K - 1) != 0:\\n return -1\\n\\n for index, stone in enumerate(stones):\\n tmp += stone\\n presum[index+1] = tmp\\n\\n for rlen in range(K, n + 1):\\n for i in range(0, n - rlen + 1):\\n end = i + rlen - 1\\n dp[i][end] = sys.maxsize\\n for j in range(i, end, K - 1):\\n dp[i][end] = min(dp[i][end], dp[i][j] + dp[j + 1][end])\\n\\n if (rlen - 1) % (K - 1) == 0:\\n dp[i][end] += presum[end+1] - presum[i]\\n\\n return int(dp[0][n - 1])\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n dp = [[[math.inf for k in range(K + 1)] for j in range(n)] for i in range(n)]\\n # dp[i][j][k]: min cost of merging from i to j (inclusive) and finally having k piles\\n for i in range(n):\\n dp[i][i][1] = 0\\n \\n pre_sum = [0] * n\\n pre_sum[0] = stones[0]\\n for i in range(1, n):\\n pre_sum[i] = pre_sum[i - 1] + stones[i]\\n \\n def range_sum(i, j):\\n if i == 0:\\n return pre_sum[j]\\n else:\\n return pre_sum[j] - pre_sum[i - 1]\\n \\n for merge_len in range(2, n + 1): # \\u679a\\u4e3e\\u533a\\u95f4\\u957f\\u5ea6\\n for start in range(n - merge_len + 1): # \\u679a\\u4e3e\\u533a\\u95f4\\u5de6\\u7aef\\u70b9\\n end = start + merge_len - 1 # \\u533a\\u95f4\\u53f3\\u7aef\\u70b9\\n for k in range(2, K + 1): \\n for middle in range(start, end, K - 1): # \\u679a\\u4e3e\\u5206\\u5272\\u70b9\\uff0c\\u5de6\\u533a\\u95f4start~middle\\uff0c\\u53f3\\u533a\\u95f4middle+1~end\\n dp[start][end][k] = min(dp[start][end][k], dp[start][middle][1] + dp[middle + 1][end][k - 1])\\n if dp[start][end][K] < math.inf: # \\u53ef\\u4ee5make a move\\uff0cmerge start ~ end \\u6210 1 \\u4e2apile\\n dp[start][end][1] = dp[start][end][K] + range_sum(start, end)\\n return dp[0][n-1][1] if dp[0][n-1][1] < math.inf else -1\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n # dp[i][j][k]: min cost of merging from i to j and finally having k piles\\n n = len(stones)\\n dp = [[[math.inf for k in range(K + 1)] for _ in range(n)] for _ in range(n)]\\n for i in range(n):\\n dp[i][i][1] = 0\\n \\n pre_sum = [0] * n\\n pre_sum[0] = stones[0]\\n for i in range(1, n):\\n pre_sum[i] = pre_sum[i - 1] + stones[i]\\n \\n def range_sum(i, j):\\n if i == 0:\\n return pre_sum[j]\\n else:\\n return pre_sum[j] - pre_sum[i - 1]\\n \\n for length in range(2, n+1):\\n for i in range(n - length + 1):\\n j = i + length - 1\\n # \\u6700\\u5c11\\u4e24\\u4e2a\\uff0c\\u6700\\u591aK\\u4e2apile\\n for k in range(2, K + 1):\\n for middle in range(i, j, K-1):\\n # \\u5206\\u6210 1 \\u548c k-1\\u5806\\uff0c\\u5408\\u5e76\\u8d77\\u6765\\u662f k\\n dp[i][j][k] = min(dp[i][j][k], dp[i][middle][1] + dp[middle + 1][j][k - 1])\\n if dp[i][j][K] < math.inf:\\n # \\u5408\\u5e76\\u6210 1\\u4e2apile\\n dp[i][j][1] = dp[i][j][K] + range_sum(i, j)\\n return dp[0][n-1][1] if dp[0][n - 1][1] < math.inf else -1\\n\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n\\n dp = [[[math.inf for k in range(K + 1)] for j in range(n)] for i in range(n)]\\n # dp[i][j][k]: min cost of merging from i to j and finally having k piles\\n for i in range(n):\\n dp[i][i][1] = 0 \\n \\n pre_sum = [0] * (n + 1)\\n for i in range(1, n + 1):\\n pre_sum[i] = pre_sum[i - 1] + stones[i - 1]\\n \\n for merge_len in range(2, n + 1):\\n for start in range(n - merge_len + 1):\\n end = start + merge_len - 1 \\n for k in range(2, K + 1):\\n for middle in range(start, end, K-1):\\n dp[start][end][k] = min(dp[start][end][k], dp[start][middle][1] + dp[middle + 1][end][k - 1])\\n if dp[start][end][K] < math.inf:\\n dp[start][end][1] = dp[start][end][K] + pre_sum[end + 1] - pre_sum[start]\\n return dp[0][n-1][1] if dp[0][n-1][1] < math.inf else -1\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n inf = float('inf')\\n if (n - 1) % (K - 1) is not 0:\\n return -1\\n \\n prefix = [0] * (n + 1)\\n for i in range(1, n + 1):\\n prefix[i] = prefix[i - 1] + stones[i - 1]\\n \\n @lru_cache(None)\\n def dp(i, j, k):\\n if i == j:\\n # cost to make one pile from one pile is 0, otherwise impossible\\n return 0 if k == 1 else inf\\n if k == 1:\\n return dp(i, j, K) + prefix[j + 1] - prefix[i]\\n return min(dp(i, m, 1) + dp(m + 1, j, k - 1) for m in range(i, j))\\n \\n return dp(0, n - 1, 1)\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n N = len(stones)\\n presum = [0 for _ in range(N + 1)]\\n dp = [[[math.inf for _ in range(K + 1)] for _ in range(N)] for _ in range(N)]\\n \\n if (N - 1) % (K - 1) != 0:\\n return -1\\n \\n for i in range(N):\\n presum[i + 1] = presum[i] + stones[i]\\n \\n for i in range(N):\\n dp[i][i][1] = 0\\n \\n for length in range(2, N + 1):\\n for start in range(N - length + 1):\\n end = start + length - 1\\n for mid in range(start, end):\\n for k in range(2, K + 1):\\n if k > length: \\n continue\\n if dp[start][mid][1] == math.inf or dp[mid + 1][end][k - 1] == math.inf:\\n continue\\n \\n dp[start][end][k] = min(dp[start][end][k], dp[start][mid][1] + dp[mid + 1][end][k - 1])\\n \\n if dp[start][end][K] != math.inf:\\n dp[start][end][1] = dp[start][end][K] + presum[end + 1] - presum[start]\\n \\n if dp[0][N - 1][1] == math.inf:\\n return -1\\n return dp[0][N - 1][1]\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n if (len(stones) - 1) % (K - 1) != 0:\\n return -1\\n \\n presum = 0\\n presum_list = [presum]\\n for cost in stones:\\n presum += cost\\n presum_list.append(presum)\\n \\n # dp[i][j][k]: cost that merges into k piles: from ith pile to jth pile\\n n = len(stones)\\n dp = [[[math.inf] * (K + 1) for _ in range(n)] for _ in range(n)]\\n \\n for i in range(n):\\n dp[i][i][1] = 0\\n \\n for pile_length in range(1, n + 1):\\n # pile_length = j - i + 1\\n for i in range(n - pile_length + 1):\\n j = pile_length + i - 1\\n for possible_k in range(2, min(pile_length, K) + 1):\\n for t in range(i, j):\\n dp[i][j][possible_k] = min(dp[i][j][possible_k], dp[i][t][possible_k - 1] + dp[t + 1][j][1])\\n dp[i][j][1] = min(dp[i][j][1], dp[i][j][K] + presum_list[j + 1] - presum_list[i])\\n \\n return dp[0][n - 1][1]\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n # Time Complexity: O(N^3 K)\\n \\n self.dp = {}\\n self.prefix = [0] + list(itertools.accumulate(stones))\\n \\n ret = self.merge(stones, 0, len(stones) - 1, 1, K)\\n \\n return ret\\n \\n def merge(self, stones, start: int, end: int, num_parts: int, K: int):\\n if (start, end, num_parts) in self.dp:\\n return self.dp[(start, end, num_parts)]\\n \\n if end - start + 1 < num_parts:\\n return -1\\n \\n if end - start + 1 == num_parts:\\n return 0\\n \\n window_sum = self.prefix[end + 1] - self.prefix[start] \\n \\n if num_parts == 1:\\n split = self.merge(stones, start, end, K, K)\\n \\n if split == -1:\\n ret = -1\\n else:\\n ret = window_sum + split\\n else:\\n candidates = []\\n \\n for i in range(start, end):\\n left = self.merge(stones, start, i, 1, K)\\n right = self.merge(stones, i + 1, end, num_parts - 1, K)\\n \\n \\n if left >= 0 and right >= 0:\\n candidates.append(left + right)\\n \\n if candidates:\\n ret = min(candidates)\\n else:\\n ret = -1\\n \\n self.dp[(start, end, num_parts)] = ret\\n return ret\\n\\n\", \"# 1000. Minimum Cost to Merge Stones\\nclass Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n N = len(stones)\\n if (N - 1) % (K - 1): \\n return -1\\n dp = [[0] * N for _ in range(N)]\\n \\n for l in range(K, N+1):\\n for i in range(N-l+1):\\n dp[i][i+l-1] = float('inf')\\n for x in range(i, i+l-1, K-1):\\n dp[i][i+l-1] = min(dp[i][i+l-1], dp[i][x] + dp[x+1][i+l-1])\\n dp[i][i+l-1] += (sum(stones[i:i+l]) if (l-1)%(K-1) == 0 else 0)\\n \\n return dp[0][N-1]\", \"class Solution:\\n def mergeStones(self, stones, k):\\n \\n # quick check to see if this number of piles can be merged. \\n if (len(stones)-1)%(k-1): \\n return -1\\n\\n cost = [[None]*len(stones) for _ in stones]\\n\\n def subCost(left, right):\\n\\n # Base case: there is no cost to \\\\\\\"merging\\\\\\\" one pile\\n if left == right: \\n return 0\\n\\n if cost[left][right] != None: \\n return cost[left][right]\\n\\n # Base case: a single merge is just the sum of the elements. \\n if (right - left + 1) == k: \\n cost[left][right] = sum(stones[left:right+1])\\n return cost[left][right]\\n\\n # find k-1 division points. Each division except the last is the start index of a sub-array\\n # ie. if stones = [ 0, 1, 2, 3, 4, 5, 6, 7, 8 ], left = 0 right = 8 divs = [0, 3, 8, 9]\\n # then sub-arrays are as follows: [0, 1, 2] [3, 4, 5, 6, 7] [8] \\n # the above divs would incidentally be valid for k = 3. \\n\\n divs = [ left + i for i in range(k+1)]\\n divs[-1] = right + 1 # set the last divider to one past the subarray. \\n # for example above, divs is initialized to -> [0, 1, 2, 9]. The first and last divider never change\\n\\n def moveDividers():\\n # loop through dividers to move, starting at last one. \\n # if the last one is at the end, move the next one up. \\n\\n def moveDivider(i): \\n if i == 0: \\n return False\\n\\n # if the div we're looking at is smashing all dividers to its right against the right end of the array. \\n # If k = 3, i = 1, we have 1 divider to our right. Leave 1 space for each divider to our right.\\n # division 0 stays at 0 \\n # div 1 can go to 2. = right - (k - 1 - i)\\n if divs[i] == ( right - (k - 1 - i)):\\n # switch to the next divider to the left\\n return moveDivider(i-1)\\n\\n # move this divider to the next usable spot given where the left neighbor div is. \\n divs[i] += 1\\n while (divs[i] - divs[i-1] - 1)%(k-1):\\n divs[i] += 1\\n\\n # stack all following divs next to each other and this one. []\\n for j in range(i+1, len(divs)-1):\\n divs[j] = divs[j-1] + 1\\n\\n return True\\n\\n # start by moving the rightmost divider\\n return moveDivider(len(divs) - 2)\\n\\n best = float('inf')\\n while 1:\\n subSum = 0\\n for div_i in range(len(divs)-1):\\n subSum += subCost(divs[div_i], divs[div_i+1] - 1) \\n best = min(best, subSum) \\n if not moveDividers():\\n break\\n\\n result = best + sum(stones[left:right+1])\\n cost[left][right] = result\\n return result\\n\\n result = subCost(0, len(stones)-1)\\n #print(cost)\\n return result \", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n # Time Complexity: O(N^3 K)\\n # Space Complexity: O(N^2 K)\\n \\n self.dp = {}\\n self.prefix = [0] + list(itertools.accumulate(stones))\\n \\n ret = self.merge(stones, 0, len(stones) - 1, 1, K)\\n \\n return ret\\n \\n def merge(self, stones, start: int, end: int, num_parts: int, K: int):\\n if (start, end, num_parts) in self.dp:\\n return self.dp[(start, end, num_parts)]\\n \\n if end - start + 1 < num_parts:\\n return -1\\n \\n if end - start + 1 == num_parts:\\n return 0\\n \\n window_sum = self.prefix[end + 1] - self.prefix[start] \\n \\n if num_parts == 1:\\n split = self.merge(stones, start, end, K, K)\\n \\n if split == -1:\\n ret = -1\\n else:\\n ret = window_sum + split\\n else:\\n candidates = []\\n \\n for i in range(start, end):\\n left = self.merge(stones, start, i, 1, K)\\n right = self.merge(stones, i + 1, end, num_parts - 1, K)\\n \\n \\n if left >= 0 and right >= 0:\\n candidates.append(left + right)\\n \\n if candidates:\\n ret = min(candidates)\\n else:\\n ret = -1\\n \\n self.dp[(start, end, num_parts)] = ret\\n return ret\\n\\n\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n self.dp = {}\\n \\n \\n ret = self.merge(stones, 0, len(stones) - 1, 1, K)\\n \\n return ret\\n \\n def merge(self, stones, start: int, end: int, num_parts: int, K: int):\\n if (start, end, num_parts) in self.dp:\\n return self.dp[(start, end, num_parts)]\\n \\n if end - start + 1 < num_parts:\\n return -1\\n \\n if end - start + 1 == num_parts:\\n return 0\\n \\n window_sum = sum(stones[start:end + 1])\\n \\n if num_parts == 1:\\n split = self.merge(stones, start, end, K, K)\\n \\n if split == -1:\\n ret = -1\\n else:\\n ret = window_sum + split\\n else:\\n candidates = []\\n \\n for i in range(start, end):\\n left = self.merge(stones, start, i, 1, K)\\n right = self.merge(stones, i + 1, end, num_parts - 1, K)\\n \\n \\n if left >= 0 and right >= 0:\\n candidates.append(left + right)\\n \\n if candidates:\\n ret = min(candidates)\\n else:\\n ret = -1\\n \\n self.dp[(start, end, num_parts)] = ret\\n return ret\\n\\n\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones) \\n \\n inf = float('inf')\\n prefix = [0] * (n + 1)\\n \\n for i in range(n): \\n prefix[i + 1] = prefix[i] + stones[i]\\n \\n import functools\\n \\n @functools.lru_cache(None) \\n def dp(i, j, m): \\n if i == j: \\n return 0 if m == 1 else inf\\n if m == 1: \\n return dp(i, j, K) + prefix[j + 1] - prefix[i]\\n \\n return min(dp(i, mid, 1) + dp(mid + 1, j, m - 1) for mid in range(i, j))\\n \\n res = dp(0, n - 1, 1)\\n \\n return res if res < inf else -1 \", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n if K > 2 and n % (K - 1) != 1:\\n return -1\\n \\n dp = [[[math.inf] * (K + 1) for i in range(n)] for j in range(n)]\\n for i in range(n):\\n dp[i][i][1] = 0\\n \\n presum = [stones[0]]\\n for i in range(1, n):\\n presum.append(presum[i - 1] + stones[i])\\n \\n def stones_in_range(i, j):\\n return presum[j] - presum[i - 1] if i > 0 else presum[j]\\n \\n for rangelen in range(2, n + 1):\\n for start in range(n + 1 - rangelen):\\n end = start + rangelen - 1\\n for k in range(2, K + 1):\\n for divide in range(start, end, K - 1):\\n dp[start][end][k] = min(dp[start][end][k], dp[start][divide][1] + dp[divide + 1][end][k - 1])\\n print(start, end, k, divide, dp[start][end][k])\\n if dp[start][end][K] < math.inf:\\n dp[start][end][1] = dp[start][end][K] + stones_in_range(start, end)\\n \\n return dp[0][n - 1][1]\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n if (n - 1) % (K - 1):\\n return -1\\n \\n s = [0]\\n for num in stones:\\n s.append(s[-1] + num)\\n \\n dp = [[0] * n for _ in range(n)]\\n for i in range(n - 1, -1, -1):\\n for j in range(i + 1, n):\\n dp[i][j] = float('inf')\\n for m in range(i, j, K - 1):\\n dp[i][j] = min(dp[i][j], dp[i][m] + dp[m + 1][j] + (0 if (j - i) % (K - 1) else s[j + 1] - s[i]))\\n \\n return -1 if dp[0][-1] == float('inf') else dp[0][-1]\\n \\n \\n @functools.lru_cache(None)\\n def f(i, j):\\n if i == j:\\n return 0\\n ans = float('inf')\\n m = i\\n while m < j:\\n ans = min(ans, f(i, m) + f(m + 1, j) + (0 if (j - i) % (K - 1) else s[j + 1] - s[i]))\\n m += K - 1\\n \\n return ans\\n \\n ans = f(0, n - 1)\\n return -1 if ans == float('inf') else ans\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n if (n-1)%(K-1) != 0:\\n return -1\\n dp = [[0]*n for i in range(n)]\\n sums = [0]*(n+1)\\n for i in range(1, n+1):\\n sums[i] = sums[i-1] + stones[i-1]\\n for l in range(K, n+1):\\n for i in range(n-l+1):\\n j = i+l-1\\n dp[i][j] = float('inf')\\n for t in range(i, j, K-1):\\n dp[i][j] = min(dp[i][j], dp[i][t]+dp[t+1][j])\\n if (j-i)%(K-1) == 0:\\n dp[i][j] += sums[j+1] - sums[i]\\n return dp[0][n-1]\\n\", \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n if (n - 1) % (K - 1):\\n return -1\\n prefix = [0]*(n+1)\\n for i in range(1, n+1):\\n prefix[i] = prefix[i-1] + stones[i-1]\\n import functools\\n @functools.lru_cache(None)\\n def dp(i, j):\\n if j - i + 1 < K:\\n return 0\\n res = min(dp(i, mid) + dp(mid+1, j) for mid in range(i, j, K-1))\\n if (j - i) % (K - 1) == 0:\\n res += prefix[j + 1] - prefix[i]\\n return res\\n return dp(0, n-1)\\n \\n# n = len(stones)\\n# if (n - 1) % (K - 1): return -1\\n# prefix = [0] * (n + 1)\\n# for i in range(n):\\n# prefix[i + 1] = prefix[i] + stones[i]\\n\\n# import functools\\n# @functools.lru_cache(None)\\n# def dp(i, j):\\n# if j - i + 1 < K: return 0\\n# res = min(dp(i, mid) + dp(mid + 1, j) for mid in range(i, j, K - 1))\\n# if (j - i) % (K - 1) == 0:\\n# res += prefix[j + 1] - prefix[i]\\n# return res\\n# return dp(0, n - 1)\\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"mergeStones\", \"inputs\": [[[3, 2, 4, 1], 2]], \"outputs\": [20]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/minimum-cost-to-merge-stones/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n n = len(stones)\n if (n - 1) % (K - 1) != 0:\n return -1\n prefix = [0]\n for s in stones:\n prefix.append(prefix[-1] + s)\n @lru_cache(None)\n def dp(i, j):\n if j - i + 1 < K:\n return 0\n res = 0\n if (j - i) % (K - 1) == 0:\n res = prefix[j+1] - prefix[i]\n return res + min(dp(i, mid) + dp(mid+1, j) for mid in range(i, j, K - 1))\n return dp(0, n - 1)","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n n = len(stones)\n if (n-1)%(K-1) != 0:\n return -1\n dp = [[0]*n for _ in range(n)]\n sums = [0]*(n+1)\n for i in range(1,n+1):\n sums[i] = sums[i-1]+stones[i-1]\n for length in range(K,n+1):\n for i in range(n-length+1):\n j = i+length-1\n dp[i][j] = float('inf')\n for t in range(i,j,K-1):\n dp[i][j] = min(dp[i][j], dp[i][t]+dp[t+1][j])\n if (j-i)%(K-1)==0:\n dp[i][j] += sums[j+1]-sums[i]\n return dp[0][n-1]","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n \n @lru_cache(None)\n def recursive(i, j, piles):\n if j - i + 1 < K: return 0\n if piles == 1:\n return recursive(i, j, K) + pre_sum[j+1] - pre_sum[i]\n else:\n min_cost = float('inf')\n for k in range(i, j, K - 1):\n min_cost = min(min_cost, recursive(i, k, 1) + recursive(k + 1, j, piles - 1))\n return min_cost\n \n n = len(stones)\n if (n - 1) % (K - 1) != 0:\n return -1\n pre_sum = [0] * (n + 1)\n for i in range(n):\n pre_sum[i + 1] = pre_sum[i] + stones[i]\n\n return recursive(0, n - 1, 1)","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n n = len(stones)\n k = K\n if (n < k and n != 1) or (n - 1) % (k - 1) != 0:\n return -1\n if n == 1:\n return 0\n \n dp = [[-1 for _ in range(n)] for _ in range(n)] # dp[i][j] stores min cost to reduce [i, j] as much as possible\n self.solve(stones, 0, n - 1, k, dp)\n # print(dp)\n return dp[0][n - 1]\n \n def solve(self, stones, l, r, k, dp):\n length = r - l + 1\n if length < k:\n dp[l][r] = 0\n return\n if length == k:\n dp[l][r] = sum(stones[l:r+1])\n return\n res = float('inf')\n for m in range(l, r):\n length = length\n length_l = m - l + 1\n length_r = r - m\n \n rem = k - 1 if length % (k - 1) == 0 else length % (k - 1)\n rem_l = k - 1 if length_l % (k - 1) == 0 else length_l % (k - 1)\n rem_r = k - 1 if length_r % (k - 1) == 0 else length_r % (k - 1)\n rem_total = k - 1 if (rem_l + rem_r) % (k - 1) == 0 else (rem_l + rem_r) % (k - 1)\n if rem_total == rem and (rem_l + rem_r) <= k:\n if dp[l][m] == -1:\n self.solve(stones, l, m, k, dp)\n if dp[m + 1][r] == -1:\n self.solve(stones, m + 1, r, k, dp)\n # print('lets check {} to {} and {}'.format(l, m, r))\n # print(dp[l][m], dp[m+1][r])\n res = min(res, dp[l][m] + dp[m+1][r])\n \n dp[l][r] = res\n if rem == 1:\n dp[l][r] += sum(stones[l:r+1])\n \n \n# class Solution:\n# def mergeStones(self, stones: List[int], K: int) -> int:\n# n = len(stones)\n# k = K\n# if (n < k and n != 1) or (n - k) % (k - 1) != 0:\n# return -1\n# if n == 1:\n# return 0\n \n# return self.comp_min(stones, k, -1)\n \n# def comp_min(self, stones, k, locked): # can't do a merge which only involves the first 'locked' stones\n# n = len(stones)\n# if n == k:\n# return sum(stones)\n \n# total_cur_cost = float('inf')\n \n# for i in range(max(0, locked - k + 2), n - k + 1):\n# cur_cost = sum(stones[i:i+k])\n# new_stones = stones[:i] + [cur_cost] + stones[i+k:]\n \n# new_locked = i - 1\n \n# tmp = self.comp_min(new_stones, k, new_locked)\n \n# total_cur_cost = min(total_cur_cost, cur_cost + tmp)\n \n# return total_cur_cost\n","from functools import lru_cache\nimport itertools\n\nclass Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n # dp[i][j] means the minimum cost needed to merge stones[i] ~ stones[j].\n # Time complexity: O(N^3 / K)\n # Space complexity: O(KN^2)\n n = len(stones)\n if (n - 1) % (K - 1): return -1\n prefix = [0] * (n + 1)\n for i in range(n):\n prefix[i + 1] = prefix[i] + stones[i]\n\n @lru_cache(None)\n def dp(i, j):\n if j - i + 1 < K: return 0\n\n res = min(dp(i, mid) + dp(mid + 1, j) for mid in range(i, j, K - 1))\n\n if (j - i) % (K - 1) == 0:\n res += prefix[j + 1] - prefix[i]\n\n return res\n\n return dp(0, n - 1)\n","from functools import lru_cache\nimport itertools\n\nclass Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n # Time complexity: O(N^3 / K)\n # Space complexity: O(KN^2)\n n = len(stones)\n if (n - 1) % (K - 1): return -1\n prefix = [0] * (n + 1)\n for i in range(n):\n prefix[i + 1] = prefix[i] + stones[i]\n\n @lru_cache(None)\n def dp(i, j):\n if j - i + 1 < K: return 0\n\n res = min(dp(i, mid) + dp(mid + 1, j) for mid in range(i, j, K - 1))\n\n if (j - i) % (K - 1) == 0:\n res += prefix[j + 1] - prefix[i]\n\n return res\n\n return dp(0, n - 1)\n","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n dp, N, Sum, H = {}, len(stones), {-1: 0}, {}\n for i in range(N):\n j, dp[i], H[i], Sum[i] = i, {}, {}, Sum[i - 1] + stones[i] \n while j > -1:\n H[i][j] = (i-j+1)%(K-1)+(K-1)*(1//(1+(i-j+1)%(K-1)))\n if i - j < K - 1: dp[i][j] = 0 \n else:\n dp[i][j] = dp[i][i] + dp[i - 1][j]\n for k in range(j + 1, i + 1):\n if H[i][k] + H[k - 1][j] == H[i][j] or H[i][k] + H[k - 1][j] == K:\n dp[i][j] = min(dp[i][j], dp[i][k] + dp[k - 1][j]) \n if H[i][j] == 1: dp[i][j] += Sum[i] - Sum[j - 1]\n j = j - 1 \n return dp[N-1][0]*(1//H[N-1][0]) - min(H[N-1][0]-1, 1) ","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n n = len(stones)\n k = K\n if (n < k and n != 1) or (n - 1) % (k - 1) != 0:\n return -1\n if n == 1:\n return 0\n \n dp = [[-1 for _ in range(n)] for _ in range(n)] # dp[i][j] stores min cost to reduce [i, j] as much as possible\n self.solve(stones, 0, n - 1, k, dp)\n return dp[0][n - 1]\n \n def solve(self, stones, l, r, k, dp):\n length = r - l + 1\n if length < k:\n dp[l][r] = 0\n return\n if length == k:\n dp[l][r] = sum(stones[l:r+1])\n return\n res = float('inf')\n for m in range(l, r):\n length = length\n length_l = m - l + 1\n length_r = r - m\n \n rem = k - 1 if length % (k - 1) == 0 else length % (k - 1)\n rem_l = k - 1 if length_l % (k - 1) == 0 else length_l % (k - 1)\n rem_r = k - 1 if length_r % (k - 1) == 0 else length_r % (k - 1)\n rem_total = k - 1 if (rem_l + rem_r) % (k - 1) == 0 else (rem_l + rem_r) % (k - 1)\n if rem_total == rem and (rem_l + rem_r) <= k:\n if dp[l][m] == -1:\n self.solve(stones, l, m, k, dp)\n if dp[m + 1][r] == -1:\n self.solve(stones, m + 1, r, k, dp)\n res = min(res, dp[l][m] + dp[m+1][r])\n \n dp[l][r] = res\n if rem == 1:\n dp[l][r] += sum(stones[l:r+1])\n","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n total = len(stones)\n if (total-1) % (K-1):\n return -1\n \n \n prefix = [0] * (total+1)\n for i in range(total):\n prefix[i+1] = prefix[i]+stones[i]\n \n import functools\n @functools.lru_cache(None)\n def dfs(i, j):\n if j-i+1 < K:\n return 0\n res = min(dfs(i,k)+dfs(k+1,j) for k in range(i, j, K-1))\n if (j-i) % (K-1) == 0:\n res += prefix[j+1]-prefix[i]\n \n return res\n \n return dfs(0, total-1)","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n '''\n dp[i][j][k]: the min cost to merge stone[i: j + 1] into k piles\n the range for consecutive piles of stone[i:j + 1] to be k piles after merging can be divided into two parts (for stones[:n] be finally merged into 1 pile):\n 1. a sub-range from the start to the devide that is sured to be merged in to 1 pile: dp[i][divide][1]\n divide goes from start by K - 1 step to make this happen: dp[i][divide][1] < math.inf\n 2. a sub-range from the divide + 1 to the end (not guaranteed to be realistic): dp[divide + 1][k - 1]\n The longer ranges are always merged from the smaller ones, no matter how the smaller ones were merged from. That is why this is a DP problem.\n '''\n n = len(stones)\n if K > 2 and n % (K - 1) != 1:\n return -1\n \n dp = [[[math.inf] * (K + 1) for i in range(n)] for j in range(n)]\n for i in range(n):\n dp[i][i][1] = 0\n \n presum = [stones[0]]\n for i in range(1, n):\n presum.append(presum[i - 1] + stones[i])\n \n def stones_in_range(i, j):\n return presum[j] - presum[i - 1] if i > 0 else presum[j]\n \n for rangelen in range(2, n + 1):\n for start in range(n + 1 - rangelen):\n end = start + rangelen - 1\n for k in range(2, K + 1):\n for divide in range(start, end, K - 1):\n dp[start][end][k] = min(dp[start][end][k], dp[start][divide][1] + dp[divide + 1][end][k - 1])\n if dp[start][end][K] < math.inf:\n dp[start][end][1] = dp[start][end][K] + stones_in_range(start, end)\n \n return dp[0][n - 1][1]","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n if (len(stones) - 1) % (K - 1) != 0:\n return -1\n \n prefix = [0]\n for stone in stones:\n prefix.append(prefix[-1] + stone)\n \n memo = {}\n\n def recur(i: int, j: int, m: int):\n key = str(i) + ',' + str(j) + ',' + str(m)\n if key in memo:\n return memo[key]\n \n if (j - i + 1 - m) % (K - 1):\n return 91111111\n \n if (j - i + 1) < K:\n memo[key] = 0\n return 0\n\n if m == 1:\n if j - i + 1 == K:\n memo[key] = prefix[j + 1] - prefix[i]\n return memo[key]\n else:\n return recur(i, j, K) + prefix[j + 1] - prefix[i]\n\n min_sum = 91111111\n for mid in range(i, j, K - 1):\n cur_sum = recur(i, mid, 1) + recur(mid + 1, j, m - 1)\n min_sum = min(min_sum, cur_sum)\n\n memo[key] = min_sum\n return min_sum\n \n return recur(0, len(stones) - 1, 1)","from typing import List\nimport numpy\nimport sys\nimport bisect\n\n\nclass Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n\n tmp = 0\n n = len(stones)\n dims = (n, n)\n dp = numpy.zeros(dims)\n presum = numpy.zeros(n+1)\n\n if (n - 1) % (K - 1) != 0:\n return -1\n\n for index, stone in enumerate(stones):\n tmp += stone\n presum[index+1] = tmp\n\n for rlen in range(K, n + 1):\n for i in range(0, n - rlen + 1):\n end = i + rlen - 1\n dp[i][end] = sys.maxsize\n for j in range(i, end, K - 1):\n dp[i][end] = min(dp[i][end], dp[i][j] + dp[j + 1][end])\n\n if (rlen - 1) % (K - 1) == 0:\n dp[i][end] += presum[end+1] - presum[i]\n\n return int(dp[0][n - 1])","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n n = len(stones)\n dp = [[[math.inf for k in range(K + 1)] for j in range(n)] for i in range(n)]\n # dp[i][j][k]: min cost of merging from i to j (inclusive) and finally having k piles\n for i in range(n):\n dp[i][i][1] = 0\n \n pre_sum = [0] * n\n pre_sum[0] = stones[0]\n for i in range(1, n):\n pre_sum[i] = pre_sum[i - 1] + stones[i]\n \n def range_sum(i, j):\n if i == 0:\n return pre_sum[j]\n else:\n return pre_sum[j] - pre_sum[i - 1]\n \n for merge_len in range(2, n + 1): # 枚举区间长度\n for start in range(n - merge_len + 1): # 枚举区间左端点\n end = start + merge_len - 1 # 区间右端点\n for k in range(2, K + 1): \n for middle in range(start, end, K - 1): # 枚举分割点，左区间start~middle，右区间middle+1~end\n dp[start][end][k] = min(dp[start][end][k], dp[start][middle][1] + dp[middle + 1][end][k - 1])\n if dp[start][end][K] < math.inf: # 可以make a move，merge start ~ end 成 1 个pile\n dp[start][end][1] = dp[start][end][K] + range_sum(start, end)\n return dp[0][n-1][1] if dp[0][n-1][1] < math.inf else -1","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n # dp[i][j][k]: min cost of merging from i to j and finally having k piles\n n = len(stones)\n dp = [[[math.inf for k in range(K + 1)] for _ in range(n)] for _ in range(n)]\n for i in range(n):\n dp[i][i][1] = 0\n \n pre_sum = [0] * n\n pre_sum[0] = stones[0]\n for i in range(1, n):\n pre_sum[i] = pre_sum[i - 1] + stones[i]\n \n def range_sum(i, j):\n if i == 0:\n return pre_sum[j]\n else:\n return pre_sum[j] - pre_sum[i - 1]\n \n for length in range(2, n+1):\n for i in range(n - length + 1):\n j = i + length - 1\n # 最少两个，最多K个pile\n for k in range(2, K + 1):\n for middle in range(i, j, K-1):\n # 分成 1 和 k-1堆，合并起来是 k\n dp[i][j][k] = min(dp[i][j][k], dp[i][middle][1] + dp[middle + 1][j][k - 1])\n if dp[i][j][K] < math.inf:\n # 合并成 1个pile\n dp[i][j][1] = dp[i][j][K] + range_sum(i, j)\n return dp[0][n-1][1] if dp[0][n - 1][1] < math.inf else -1\n","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n n = len(stones)\n\n dp = [[[math.inf for k in range(K + 1)] for j in range(n)] for i in range(n)]\n # dp[i][j][k]: min cost of merging from i to j and finally having k piles\n for i in range(n):\n dp[i][i][1] = 0 \n \n pre_sum = [0] * (n + 1)\n for i in range(1, n + 1):\n pre_sum[i] = pre_sum[i - 1] + stones[i - 1]\n \n for merge_len in range(2, n + 1):\n for start in range(n - merge_len + 1):\n end = start + merge_len - 1 \n for k in range(2, K + 1):\n for middle in range(start, end, K-1):\n dp[start][end][k] = min(dp[start][end][k], dp[start][middle][1] + dp[middle + 1][end][k - 1])\n if dp[start][end][K] < math.inf:\n dp[start][end][1] = dp[start][end][K] + pre_sum[end + 1] - pre_sum[start]\n return dp[0][n-1][1] if dp[0][n-1][1] < math.inf else -1","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n n = len(stones)\n inf = float('inf')\n if (n - 1) % (K - 1) is not 0:\n return -1\n \n prefix = [0] * (n + 1)\n for i in range(1, n + 1):\n prefix[i] = prefix[i - 1] + stones[i - 1]\n \n @lru_cache(None)\n def dp(i, j, k):\n if i == j:\n # cost to make one pile from one pile is 0, otherwise impossible\n return 0 if k == 1 else inf\n if k == 1:\n return dp(i, j, K) + prefix[j + 1] - prefix[i]\n return min(dp(i, m, 1) + dp(m + 1, j, k - 1) for m in range(i, j))\n \n return dp(0, n - 1, 1)","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n N = len(stones)\n presum = [0 for _ in range(N + 1)]\n dp = [[[math.inf for _ in range(K + 1)] for _ in range(N)] for _ in range(N)]\n \n if (N - 1) % (K - 1) != 0:\n return -1\n \n for i in range(N):\n presum[i + 1] = presum[i] + stones[i]\n \n for i in range(N):\n dp[i][i][1] = 0\n \n for length in range(2, N + 1):\n for start in range(N - length + 1):\n end = start + length - 1\n for mid in range(start, end):\n for k in range(2, K + 1):\n if k > length: \n continue\n if dp[start][mid][1] == math.inf or dp[mid + 1][end][k - 1] == math.inf:\n continue\n \n dp[start][end][k] = min(dp[start][end][k], dp[start][mid][1] + dp[mid + 1][end][k - 1])\n \n if dp[start][end][K] != math.inf:\n dp[start][end][1] = dp[start][end][K] + presum[end + 1] - presum[start]\n \n if dp[0][N - 1][1] == math.inf:\n return -1\n return dp[0][N - 1][1]","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n if (len(stones) - 1) % (K - 1) != 0:\n return -1\n \n presum = 0\n presum_list = [presum]\n for cost in stones:\n presum += cost\n presum_list.append(presum)\n \n # dp[i][j][k]: cost that merges into k piles: from ith pile to jth pile\n n = len(stones)\n dp = [[[math.inf] * (K + 1) for _ in range(n)] for _ in range(n)]\n \n for i in range(n):\n dp[i][i][1] = 0\n \n for pile_length in range(1, n + 1):\n # pile_length = j - i + 1\n for i in range(n - pile_length + 1):\n j = pile_length + i - 1\n for possible_k in range(2, min(pile_length, K) + 1):\n for t in range(i, j):\n dp[i][j][possible_k] = min(dp[i][j][possible_k], dp[i][t][possible_k - 1] + dp[t + 1][j][1])\n dp[i][j][1] = min(dp[i][j][1], dp[i][j][K] + presum_list[j + 1] - presum_list[i])\n \n return dp[0][n - 1][1]","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n # Time Complexity: O(N^3 K)\n \n self.dp = {}\n self.prefix = [0] + list(itertools.accumulate(stones))\n \n ret = self.merge(stones, 0, len(stones) - 1, 1, K)\n \n return ret\n \n def merge(self, stones, start: int, end: int, num_parts: int, K: int):\n if (start, end, num_parts) in self.dp:\n return self.dp[(start, end, num_parts)]\n \n if end - start + 1 < num_parts:\n return -1\n \n if end - start + 1 == num_parts:\n return 0\n \n window_sum = self.prefix[end + 1] - self.prefix[start] \n \n if num_parts == 1:\n split = self.merge(stones, start, end, K, K)\n \n if split == -1:\n ret = -1\n else:\n ret = window_sum + split\n else:\n candidates = []\n \n for i in range(start, end):\n left = self.merge(stones, start, i, 1, K)\n right = self.merge(stones, i + 1, end, num_parts - 1, K)\n \n \n if left >= 0 and right >= 0:\n candidates.append(left + right)\n \n if candidates:\n ret = min(candidates)\n else:\n ret = -1\n \n self.dp[(start, end, num_parts)] = ret\n return ret\n\n","# 1000. Minimum Cost to Merge Stones\nclass Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n N = len(stones)\n if (N - 1) % (K - 1): \n return -1\n dp = [[0] * N for _ in range(N)]\n \n for l in range(K, N+1):\n for i in range(N-l+1):\n dp[i][i+l-1] = float('inf')\n for x in range(i, i+l-1, K-1):\n dp[i][i+l-1] = min(dp[i][i+l-1], dp[i][x] + dp[x+1][i+l-1])\n dp[i][i+l-1] += (sum(stones[i:i+l]) if (l-1)%(K-1) == 0 else 0)\n \n return dp[0][N-1]","class Solution:\n def mergeStones(self, stones, k):\n \n # quick check to see if this number of piles can be merged. \n if (len(stones)-1)%(k-1): \n return -1\n\n cost = [[None]*len(stones) for _ in stones]\n\n def subCost(left, right):\n\n # Base case: there is no cost to \\\"merging\\\" one pile\n if left == right: \n return 0\n\n if cost[left][right] != None: \n return cost[left][right]\n\n # Base case: a single merge is just the sum of the elements. \n if (right - left + 1) == k: \n cost[left][right] = sum(stones[left:right+1])\n return cost[left][right]\n\n # find k-1 division points. Each division except the last is the start index of a sub-array\n # ie. if stones = [ 0, 1, 2, 3, 4, 5, 6, 7, 8 ], left = 0 right = 8 divs = [0, 3, 8, 9]\n # then sub-arrays are as follows: [0, 1, 2] [3, 4, 5, 6, 7] [8] \n # the above divs would incidentally be valid for k = 3. \n\n divs = [ left + i for i in range(k+1)]\n divs[-1] = right + 1 # set the last divider to one past the subarray. \n # for example above, divs is initialized to -> [0, 1, 2, 9]. The first and last divider never change\n\n def moveDividers():\n # loop through dividers to move, starting at last one. \n # if the last one is at the end, move the next one up. \n\n def moveDivider(i): \n if i == 0: \n return False\n\n # if the div we're looking at is smashing all dividers to its right against the right end of the array. \n # If k = 3, i = 1, we have 1 divider to our right. Leave 1 space for each divider to our right.\n # division 0 stays at 0 \n # div 1 can go to 2. = right - (k - 1 - i)\n if divs[i] == ( right - (k - 1 - i)):\n # switch to the next divider to the left\n return moveDivider(i-1)\n\n # move this divider to the next usable spot given where the left neighbor div is. \n divs[i] += 1\n while (divs[i] - divs[i-1] - 1)%(k-1):\n divs[i] += 1\n\n # stack all following divs next to each other and this one. []\n for j in range(i+1, len(divs)-1):\n divs[j] = divs[j-1] + 1\n\n return True\n\n # start by moving the rightmost divider\n return moveDivider(len(divs) - 2)\n\n best = float('inf')\n while 1:\n subSum = 0\n for div_i in range(len(divs)-1):\n subSum += subCost(divs[div_i], divs[div_i+1] - 1) \n best = min(best, subSum) \n if not moveDividers():\n break\n\n result = best + sum(stones[left:right+1])\n cost[left][right] = result\n return result\n\n result = subCost(0, len(stones)-1)\n #print(cost)\n return result ","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n # Time Complexity: O(N^3 K)\n # Space Complexity: O(N^2 K)\n \n self.dp = {}\n self.prefix = [0] + list(itertools.accumulate(stones))\n \n ret = self.merge(stones, 0, len(stones) - 1, 1, K)\n \n return ret\n \n def merge(self, stones, start: int, end: int, num_parts: int, K: int):\n if (start, end, num_parts) in self.dp:\n return self.dp[(start, end, num_parts)]\n \n if end - start + 1 < num_parts:\n return -1\n \n if end - start + 1 == num_parts:\n return 0\n \n window_sum = self.prefix[end + 1] - self.prefix[start] \n \n if num_parts == 1:\n split = self.merge(stones, start, end, K, K)\n \n if split == -1:\n ret = -1\n else:\n ret = window_sum + split\n else:\n candidates = []\n \n for i in range(start, end):\n left = self.merge(stones, start, i, 1, K)\n right = self.merge(stones, i + 1, end, num_parts - 1, K)\n \n \n if left >= 0 and right >= 0:\n candidates.append(left + right)\n \n if candidates:\n ret = min(candidates)\n else:\n ret = -1\n \n self.dp[(start, end, num_parts)] = ret\n return ret\n\n","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n self.dp = {}\n \n \n ret = self.merge(stones, 0, len(stones) - 1, 1, K)\n \n return ret\n \n def merge(self, stones, start: int, end: int, num_parts: int, K: int):\n if (start, end, num_parts) in self.dp:\n return self.dp[(start, end, num_parts)]\n \n if end - start + 1 < num_parts:\n return -1\n \n if end - start + 1 == num_parts:\n return 0\n \n window_sum = sum(stones[start:end + 1])\n \n if num_parts == 1:\n split = self.merge(stones, start, end, K, K)\n \n if split == -1:\n ret = -1\n else:\n ret = window_sum + split\n else:\n candidates = []\n \n for i in range(start, end):\n left = self.merge(stones, start, i, 1, K)\n right = self.merge(stones, i + 1, end, num_parts - 1, K)\n \n \n if left >= 0 and right >= 0:\n candidates.append(left + right)\n \n if candidates:\n ret = min(candidates)\n else:\n ret = -1\n \n self.dp[(start, end, num_parts)] = ret\n return ret\n\n","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n n = len(stones) \n \n inf = float('inf')\n prefix = [0] * (n + 1)\n \n for i in range(n): \n prefix[i + 1] = prefix[i] + stones[i]\n \n import functools\n \n @functools.lru_cache(None) \n def dp(i, j, m): \n if i == j: \n return 0 if m == 1 else inf\n if m == 1: \n return dp(i, j, K) + prefix[j + 1] - prefix[i]\n \n return min(dp(i, mid, 1) + dp(mid + 1, j, m - 1) for mid in range(i, j))\n \n res = dp(0, n - 1, 1)\n \n return res if res < inf else -1 ","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n n = len(stones)\n if K > 2 and n % (K - 1) != 1:\n return -1\n \n dp = [[[math.inf] * (K + 1) for i in range(n)] for j in range(n)]\n for i in range(n):\n dp[i][i][1] = 0\n \n presum = [stones[0]]\n for i in range(1, n):\n presum.append(presum[i - 1] + stones[i])\n \n def stones_in_range(i, j):\n return presum[j] - presum[i - 1] if i > 0 else presum[j]\n \n for rangelen in range(2, n + 1):\n for start in range(n + 1 - rangelen):\n end = start + rangelen - 1\n for k in range(2, K + 1):\n for divide in range(start, end, K - 1):\n dp[start][end][k] = min(dp[start][end][k], dp[start][divide][1] + dp[divide + 1][end][k - 1])\n print(start, end, k, divide, dp[start][end][k])\n if dp[start][end][K] < math.inf:\n dp[start][end][1] = dp[start][end][K] + stones_in_range(start, end)\n \n return dp[0][n - 1][1]","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n n = len(stones)\n if (n - 1) % (K - 1):\n return -1\n \n s = [0]\n for num in stones:\n s.append(s[-1] + num)\n \n dp = [[0] * n for _ in range(n)]\n for i in range(n - 1, -1, -1):\n for j in range(i + 1, n):\n dp[i][j] = float('inf')\n for m in range(i, j, K - 1):\n dp[i][j] = min(dp[i][j], dp[i][m] + dp[m + 1][j] + (0 if (j - i) % (K - 1) else s[j + 1] - s[i]))\n \n return -1 if dp[0][-1] == float('inf') else dp[0][-1]\n \n \n @functools.lru_cache(None)\n def f(i, j):\n if i == j:\n return 0\n ans = float('inf')\n m = i\n while m < j:\n ans = min(ans, f(i, m) + f(m + 1, j) + (0 if (j - i) % (K - 1) else s[j + 1] - s[i]))\n m += K - 1\n \n return ans\n \n ans = f(0, n - 1)\n return -1 if ans == float('inf') else ans","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n n = len(stones)\n if (n-1)%(K-1) != 0:\n return -1\n dp = [[0]*n for i in range(n)]\n sums = [0]*(n+1)\n for i in range(1, n+1):\n sums[i] = sums[i-1] + stones[i-1]\n for l in range(K, n+1):\n for i in range(n-l+1):\n j = i+l-1\n dp[i][j] = float('inf')\n for t in range(i, j, K-1):\n dp[i][j] = min(dp[i][j], dp[i][t]+dp[t+1][j])\n if (j-i)%(K-1) == 0:\n dp[i][j] += sums[j+1] - sums[i]\n return dp[0][n-1]\n","class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n n = len(stones)\n if (n - 1) % (K - 1):\n return -1\n prefix = [0]*(n+1)\n for i in range(1, n+1):\n prefix[i] = prefix[i-1] + stones[i-1]\n import functools\n @functools.lru_cache(None)\n def dp(i, j):\n if j - i + 1 < K:\n return 0\n res = min(dp(i, mid) + dp(mid+1, j) for mid in range(i, j, K-1))\n if (j - i) % (K - 1) == 0:\n res += prefix[j + 1] - prefix[i]\n return res\n return dp(0, n-1)\n \n# n = len(stones)\n# if (n - 1) % (K - 1): return -1\n# prefix = [0] * (n + 1)\n# for i in range(n):\n# prefix[i + 1] = prefix[i] + stones[i]\n\n# import functools\n# @functools.lru_cache(None)\n# def dp(i, j):\n# if j - i + 1 < K: return 0\n# res = min(dp(i, mid) + dp(mid + 1, j) for mid in range(i, j, K - 1))\n# if (j - i) % (K - 1) == 0:\n# res += prefix[j + 1] - prefix[i]\n# return res\n# return dp(0, n - 1)\n"],"string":"[\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n if (n - 1) % (K - 1) != 0:\\n return -1\\n prefix = [0]\\n for s in stones:\\n prefix.append(prefix[-1] + s)\\n @lru_cache(None)\\n def dp(i, j):\\n if j - i + 1 < K:\\n return 0\\n res = 0\\n if (j - i) % (K - 1) == 0:\\n res = prefix[j+1] - prefix[i]\\n return res + min(dp(i, mid) + dp(mid+1, j) for mid in range(i, j, K - 1))\\n return dp(0, n - 1)\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n if (n-1)%(K-1) != 0:\\n return -1\\n dp = [[0]*n for _ in range(n)]\\n sums = [0]*(n+1)\\n for i in range(1,n+1):\\n sums[i] = sums[i-1]+stones[i-1]\\n for length in range(K,n+1):\\n for i in range(n-length+1):\\n j = i+length-1\\n dp[i][j] = float('inf')\\n for t in range(i,j,K-1):\\n dp[i][j] = min(dp[i][j], dp[i][t]+dp[t+1][j])\\n if (j-i)%(K-1)==0:\\n dp[i][j] += sums[j+1]-sums[i]\\n return dp[0][n-1]\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n \\n @lru_cache(None)\\n def recursive(i, j, piles):\\n if j - i + 1 < K: return 0\\n if piles == 1:\\n return recursive(i, j, K) + pre_sum[j+1] - pre_sum[i]\\n else:\\n min_cost = float('inf')\\n for k in range(i, j, K - 1):\\n min_cost = min(min_cost, recursive(i, k, 1) + recursive(k + 1, j, piles - 1))\\n return min_cost\\n \\n n = len(stones)\\n if (n - 1) % (K - 1) != 0:\\n return -1\\n pre_sum = [0] * (n + 1)\\n for i in range(n):\\n pre_sum[i + 1] = pre_sum[i] + stones[i]\\n\\n return recursive(0, n - 1, 1)\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n k = K\\n if (n < k and n != 1) or (n - 1) % (k - 1) != 0:\\n return -1\\n if n == 1:\\n return 0\\n \\n dp = [[-1 for _ in range(n)] for _ in range(n)] # dp[i][j] stores min cost to reduce [i, j] as much as possible\\n self.solve(stones, 0, n - 1, k, dp)\\n # print(dp)\\n return dp[0][n - 1]\\n \\n def solve(self, stones, l, r, k, dp):\\n length = r - l + 1\\n if length < k:\\n dp[l][r] = 0\\n return\\n if length == k:\\n dp[l][r] = sum(stones[l:r+1])\\n return\\n res = float('inf')\\n for m in range(l, r):\\n length = length\\n length_l = m - l + 1\\n length_r = r - m\\n \\n rem = k - 1 if length % (k - 1) == 0 else length % (k - 1)\\n rem_l = k - 1 if length_l % (k - 1) == 0 else length_l % (k - 1)\\n rem_r = k - 1 if length_r % (k - 1) == 0 else length_r % (k - 1)\\n rem_total = k - 1 if (rem_l + rem_r) % (k - 1) == 0 else (rem_l + rem_r) % (k - 1)\\n if rem_total == rem and (rem_l + rem_r) <= k:\\n if dp[l][m] == -1:\\n self.solve(stones, l, m, k, dp)\\n if dp[m + 1][r] == -1:\\n self.solve(stones, m + 1, r, k, dp)\\n # print('lets check {} to {} and {}'.format(l, m, r))\\n # print(dp[l][m], dp[m+1][r])\\n res = min(res, dp[l][m] + dp[m+1][r])\\n \\n dp[l][r] = res\\n if rem == 1:\\n dp[l][r] += sum(stones[l:r+1])\\n \\n \\n# class Solution:\\n# def mergeStones(self, stones: List[int], K: int) -> int:\\n# n = len(stones)\\n# k = K\\n# if (n < k and n != 1) or (n - k) % (k - 1) != 0:\\n# return -1\\n# if n == 1:\\n# return 0\\n \\n# return self.comp_min(stones, k, -1)\\n \\n# def comp_min(self, stones, k, locked): # can't do a merge which only involves the first 'locked' stones\\n# n = len(stones)\\n# if n == k:\\n# return sum(stones)\\n \\n# total_cur_cost = float('inf')\\n \\n# for i in range(max(0, locked - k + 2), n - k + 1):\\n# cur_cost = sum(stones[i:i+k])\\n# new_stones = stones[:i] + [cur_cost] + stones[i+k:]\\n \\n# new_locked = i - 1\\n \\n# tmp = self.comp_min(new_stones, k, new_locked)\\n \\n# total_cur_cost = min(total_cur_cost, cur_cost + tmp)\\n \\n# return total_cur_cost\\n\",\n \"from functools import lru_cache\\nimport itertools\\n\\nclass Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n # dp[i][j] means the minimum cost needed to merge stones[i] ~ stones[j].\\n # Time complexity: O(N^3 / K)\\n # Space complexity: O(KN^2)\\n n = len(stones)\\n if (n - 1) % (K - 1): return -1\\n prefix = [0] * (n + 1)\\n for i in range(n):\\n prefix[i + 1] = prefix[i] + stones[i]\\n\\n @lru_cache(None)\\n def dp(i, j):\\n if j - i + 1 < K: return 0\\n\\n res = min(dp(i, mid) + dp(mid + 1, j) for mid in range(i, j, K - 1))\\n\\n if (j - i) % (K - 1) == 0:\\n res += prefix[j + 1] - prefix[i]\\n\\n return res\\n\\n return dp(0, n - 1)\\n\",\n \"from functools import lru_cache\\nimport itertools\\n\\nclass Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n # Time complexity: O(N^3 / K)\\n # Space complexity: O(KN^2)\\n n = len(stones)\\n if (n - 1) % (K - 1): return -1\\n prefix = [0] * (n + 1)\\n for i in range(n):\\n prefix[i + 1] = prefix[i] + stones[i]\\n\\n @lru_cache(None)\\n def dp(i, j):\\n if j - i + 1 < K: return 0\\n\\n res = min(dp(i, mid) + dp(mid + 1, j) for mid in range(i, j, K - 1))\\n\\n if (j - i) % (K - 1) == 0:\\n res += prefix[j + 1] - prefix[i]\\n\\n return res\\n\\n return dp(0, n - 1)\\n\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n dp, N, Sum, H = {}, len(stones), {-1: 0}, {}\\n for i in range(N):\\n j, dp[i], H[i], Sum[i] = i, {}, {}, Sum[i - 1] + stones[i] \\n while j > -1:\\n H[i][j] = (i-j+1)%(K-1)+(K-1)*(1//(1+(i-j+1)%(K-1)))\\n if i - j < K - 1: dp[i][j] = 0 \\n else:\\n dp[i][j] = dp[i][i] + dp[i - 1][j]\\n for k in range(j + 1, i + 1):\\n if H[i][k] + H[k - 1][j] == H[i][j] or H[i][k] + H[k - 1][j] == K:\\n dp[i][j] = min(dp[i][j], dp[i][k] + dp[k - 1][j]) \\n if H[i][j] == 1: dp[i][j] += Sum[i] - Sum[j - 1]\\n j = j - 1 \\n return dp[N-1][0]*(1//H[N-1][0]) - min(H[N-1][0]-1, 1) \",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n k = K\\n if (n < k and n != 1) or (n - 1) % (k - 1) != 0:\\n return -1\\n if n == 1:\\n return 0\\n \\n dp = [[-1 for _ in range(n)] for _ in range(n)] # dp[i][j] stores min cost to reduce [i, j] as much as possible\\n self.solve(stones, 0, n - 1, k, dp)\\n return dp[0][n - 1]\\n \\n def solve(self, stones, l, r, k, dp):\\n length = r - l + 1\\n if length < k:\\n dp[l][r] = 0\\n return\\n if length == k:\\n dp[l][r] = sum(stones[l:r+1])\\n return\\n res = float('inf')\\n for m in range(l, r):\\n length = length\\n length_l = m - l + 1\\n length_r = r - m\\n \\n rem = k - 1 if length % (k - 1) == 0 else length % (k - 1)\\n rem_l = k - 1 if length_l % (k - 1) == 0 else length_l % (k - 1)\\n rem_r = k - 1 if length_r % (k - 1) == 0 else length_r % (k - 1)\\n rem_total = k - 1 if (rem_l + rem_r) % (k - 1) == 0 else (rem_l + rem_r) % (k - 1)\\n if rem_total == rem and (rem_l + rem_r) <= k:\\n if dp[l][m] == -1:\\n self.solve(stones, l, m, k, dp)\\n if dp[m + 1][r] == -1:\\n self.solve(stones, m + 1, r, k, dp)\\n res = min(res, dp[l][m] + dp[m+1][r])\\n \\n dp[l][r] = res\\n if rem == 1:\\n dp[l][r] += sum(stones[l:r+1])\\n\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n total = len(stones)\\n if (total-1) % (K-1):\\n return -1\\n \\n \\n prefix = [0] * (total+1)\\n for i in range(total):\\n prefix[i+1] = prefix[i]+stones[i]\\n \\n import functools\\n @functools.lru_cache(None)\\n def dfs(i, j):\\n if j-i+1 < K:\\n return 0\\n res = min(dfs(i,k)+dfs(k+1,j) for k in range(i, j, K-1))\\n if (j-i) % (K-1) == 0:\\n res += prefix[j+1]-prefix[i]\\n \\n return res\\n \\n return dfs(0, total-1)\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n '''\\n dp[i][j][k]: the min cost to merge stone[i: j + 1] into k piles\\n the range for consecutive piles of stone[i:j + 1] to be k piles after merging can be divided into two parts (for stones[:n] be finally merged into 1 pile):\\n 1. a sub-range from the start to the devide that is sured to be merged in to 1 pile: dp[i][divide][1]\\n divide goes from start by K - 1 step to make this happen: dp[i][divide][1] < math.inf\\n 2. a sub-range from the divide + 1 to the end (not guaranteed to be realistic): dp[divide + 1][k - 1]\\n The longer ranges are always merged from the smaller ones, no matter how the smaller ones were merged from. That is why this is a DP problem.\\n '''\\n n = len(stones)\\n if K > 2 and n % (K - 1) != 1:\\n return -1\\n \\n dp = [[[math.inf] * (K + 1) for i in range(n)] for j in range(n)]\\n for i in range(n):\\n dp[i][i][1] = 0\\n \\n presum = [stones[0]]\\n for i in range(1, n):\\n presum.append(presum[i - 1] + stones[i])\\n \\n def stones_in_range(i, j):\\n return presum[j] - presum[i - 1] if i > 0 else presum[j]\\n \\n for rangelen in range(2, n + 1):\\n for start in range(n + 1 - rangelen):\\n end = start + rangelen - 1\\n for k in range(2, K + 1):\\n for divide in range(start, end, K - 1):\\n dp[start][end][k] = min(dp[start][end][k], dp[start][divide][1] + dp[divide + 1][end][k - 1])\\n if dp[start][end][K] < math.inf:\\n dp[start][end][1] = dp[start][end][K] + stones_in_range(start, end)\\n \\n return dp[0][n - 1][1]\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n if (len(stones) - 1) % (K - 1) != 0:\\n return -1\\n \\n prefix = [0]\\n for stone in stones:\\n prefix.append(prefix[-1] + stone)\\n \\n memo = {}\\n\\n def recur(i: int, j: int, m: int):\\n key = str(i) + ',' + str(j) + ',' + str(m)\\n if key in memo:\\n return memo[key]\\n \\n if (j - i + 1 - m) % (K - 1):\\n return 91111111\\n \\n if (j - i + 1) < K:\\n memo[key] = 0\\n return 0\\n\\n if m == 1:\\n if j - i + 1 == K:\\n memo[key] = prefix[j + 1] - prefix[i]\\n return memo[key]\\n else:\\n return recur(i, j, K) + prefix[j + 1] - prefix[i]\\n\\n min_sum = 91111111\\n for mid in range(i, j, K - 1):\\n cur_sum = recur(i, mid, 1) + recur(mid + 1, j, m - 1)\\n min_sum = min(min_sum, cur_sum)\\n\\n memo[key] = min_sum\\n return min_sum\\n \\n return recur(0, len(stones) - 1, 1)\",\n \"from typing import List\\nimport numpy\\nimport sys\\nimport bisect\\n\\n\\nclass Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n\\n tmp = 0\\n n = len(stones)\\n dims = (n, n)\\n dp = numpy.zeros(dims)\\n presum = numpy.zeros(n+1)\\n\\n if (n - 1) % (K - 1) != 0:\\n return -1\\n\\n for index, stone in enumerate(stones):\\n tmp += stone\\n presum[index+1] = tmp\\n\\n for rlen in range(K, n + 1):\\n for i in range(0, n - rlen + 1):\\n end = i + rlen - 1\\n dp[i][end] = sys.maxsize\\n for j in range(i, end, K - 1):\\n dp[i][end] = min(dp[i][end], dp[i][j] + dp[j + 1][end])\\n\\n if (rlen - 1) % (K - 1) == 0:\\n dp[i][end] += presum[end+1] - presum[i]\\n\\n return int(dp[0][n - 1])\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n dp = [[[math.inf for k in range(K + 1)] for j in range(n)] for i in range(n)]\\n # dp[i][j][k]: min cost of merging from i to j (inclusive) and finally having k piles\\n for i in range(n):\\n dp[i][i][1] = 0\\n \\n pre_sum = [0] * n\\n pre_sum[0] = stones[0]\\n for i in range(1, n):\\n pre_sum[i] = pre_sum[i - 1] + stones[i]\\n \\n def range_sum(i, j):\\n if i == 0:\\n return pre_sum[j]\\n else:\\n return pre_sum[j] - pre_sum[i - 1]\\n \\n for merge_len in range(2, n + 1): # 枚举区间长度\\n for start in range(n - merge_len + 1): # 枚举区间左端点\\n end = start + merge_len - 1 # 区间右端点\\n for k in range(2, K + 1): \\n for middle in range(start, end, K - 1): # 枚举分割点，左区间start~middle，右区间middle+1~end\\n dp[start][end][k] = min(dp[start][end][k], dp[start][middle][1] + dp[middle + 1][end][k - 1])\\n if dp[start][end][K] < math.inf: # 可以make a move，merge start ~ end 成 1 个pile\\n dp[start][end][1] = dp[start][end][K] + range_sum(start, end)\\n return dp[0][n-1][1] if dp[0][n-1][1] < math.inf else -1\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n # dp[i][j][k]: min cost of merging from i to j and finally having k piles\\n n = len(stones)\\n dp = [[[math.inf for k in range(K + 1)] for _ in range(n)] for _ in range(n)]\\n for i in range(n):\\n dp[i][i][1] = 0\\n \\n pre_sum = [0] * n\\n pre_sum[0] = stones[0]\\n for i in range(1, n):\\n pre_sum[i] = pre_sum[i - 1] + stones[i]\\n \\n def range_sum(i, j):\\n if i == 0:\\n return pre_sum[j]\\n else:\\n return pre_sum[j] - pre_sum[i - 1]\\n \\n for length in range(2, n+1):\\n for i in range(n - length + 1):\\n j = i + length - 1\\n # 最少两个，最多K个pile\\n for k in range(2, K + 1):\\n for middle in range(i, j, K-1):\\n # 分成 1 和 k-1堆，合并起来是 k\\n dp[i][j][k] = min(dp[i][j][k], dp[i][middle][1] + dp[middle + 1][j][k - 1])\\n if dp[i][j][K] < math.inf:\\n # 合并成 1个pile\\n dp[i][j][1] = dp[i][j][K] + range_sum(i, j)\\n return dp[0][n-1][1] if dp[0][n - 1][1] < math.inf else -1\\n\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n\\n dp = [[[math.inf for k in range(K + 1)] for j in range(n)] for i in range(n)]\\n # dp[i][j][k]: min cost of merging from i to j and finally having k piles\\n for i in range(n):\\n dp[i][i][1] = 0 \\n \\n pre_sum = [0] * (n + 1)\\n for i in range(1, n + 1):\\n pre_sum[i] = pre_sum[i - 1] + stones[i - 1]\\n \\n for merge_len in range(2, n + 1):\\n for start in range(n - merge_len + 1):\\n end = start + merge_len - 1 \\n for k in range(2, K + 1):\\n for middle in range(start, end, K-1):\\n dp[start][end][k] = min(dp[start][end][k], dp[start][middle][1] + dp[middle + 1][end][k - 1])\\n if dp[start][end][K] < math.inf:\\n dp[start][end][1] = dp[start][end][K] + pre_sum[end + 1] - pre_sum[start]\\n return dp[0][n-1][1] if dp[0][n-1][1] < math.inf else -1\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n inf = float('inf')\\n if (n - 1) % (K - 1) is not 0:\\n return -1\\n \\n prefix = [0] * (n + 1)\\n for i in range(1, n + 1):\\n prefix[i] = prefix[i - 1] + stones[i - 1]\\n \\n @lru_cache(None)\\n def dp(i, j, k):\\n if i == j:\\n # cost to make one pile from one pile is 0, otherwise impossible\\n return 0 if k == 1 else inf\\n if k == 1:\\n return dp(i, j, K) + prefix[j + 1] - prefix[i]\\n return min(dp(i, m, 1) + dp(m + 1, j, k - 1) for m in range(i, j))\\n \\n return dp(0, n - 1, 1)\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n N = len(stones)\\n presum = [0 for _ in range(N + 1)]\\n dp = [[[math.inf for _ in range(K + 1)] for _ in range(N)] for _ in range(N)]\\n \\n if (N - 1) % (K - 1) != 0:\\n return -1\\n \\n for i in range(N):\\n presum[i + 1] = presum[i] + stones[i]\\n \\n for i in range(N):\\n dp[i][i][1] = 0\\n \\n for length in range(2, N + 1):\\n for start in range(N - length + 1):\\n end = start + length - 1\\n for mid in range(start, end):\\n for k in range(2, K + 1):\\n if k > length: \\n continue\\n if dp[start][mid][1] == math.inf or dp[mid + 1][end][k - 1] == math.inf:\\n continue\\n \\n dp[start][end][k] = min(dp[start][end][k], dp[start][mid][1] + dp[mid + 1][end][k - 1])\\n \\n if dp[start][end][K] != math.inf:\\n dp[start][end][1] = dp[start][end][K] + presum[end + 1] - presum[start]\\n \\n if dp[0][N - 1][1] == math.inf:\\n return -1\\n return dp[0][N - 1][1]\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n if (len(stones) - 1) % (K - 1) != 0:\\n return -1\\n \\n presum = 0\\n presum_list = [presum]\\n for cost in stones:\\n presum += cost\\n presum_list.append(presum)\\n \\n # dp[i][j][k]: cost that merges into k piles: from ith pile to jth pile\\n n = len(stones)\\n dp = [[[math.inf] * (K + 1) for _ in range(n)] for _ in range(n)]\\n \\n for i in range(n):\\n dp[i][i][1] = 0\\n \\n for pile_length in range(1, n + 1):\\n # pile_length = j - i + 1\\n for i in range(n - pile_length + 1):\\n j = pile_length + i - 1\\n for possible_k in range(2, min(pile_length, K) + 1):\\n for t in range(i, j):\\n dp[i][j][possible_k] = min(dp[i][j][possible_k], dp[i][t][possible_k - 1] + dp[t + 1][j][1])\\n dp[i][j][1] = min(dp[i][j][1], dp[i][j][K] + presum_list[j + 1] - presum_list[i])\\n \\n return dp[0][n - 1][1]\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n # Time Complexity: O(N^3 K)\\n \\n self.dp = {}\\n self.prefix = [0] + list(itertools.accumulate(stones))\\n \\n ret = self.merge(stones, 0, len(stones) - 1, 1, K)\\n \\n return ret\\n \\n def merge(self, stones, start: int, end: int, num_parts: int, K: int):\\n if (start, end, num_parts) in self.dp:\\n return self.dp[(start, end, num_parts)]\\n \\n if end - start + 1 < num_parts:\\n return -1\\n \\n if end - start + 1 == num_parts:\\n return 0\\n \\n window_sum = self.prefix[end + 1] - self.prefix[start] \\n \\n if num_parts == 1:\\n split = self.merge(stones, start, end, K, K)\\n \\n if split == -1:\\n ret = -1\\n else:\\n ret = window_sum + split\\n else:\\n candidates = []\\n \\n for i in range(start, end):\\n left = self.merge(stones, start, i, 1, K)\\n right = self.merge(stones, i + 1, end, num_parts - 1, K)\\n \\n \\n if left >= 0 and right >= 0:\\n candidates.append(left + right)\\n \\n if candidates:\\n ret = min(candidates)\\n else:\\n ret = -1\\n \\n self.dp[(start, end, num_parts)] = ret\\n return ret\\n\\n\",\n \"# 1000. Minimum Cost to Merge Stones\\nclass Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n N = len(stones)\\n if (N - 1) % (K - 1): \\n return -1\\n dp = [[0] * N for _ in range(N)]\\n \\n for l in range(K, N+1):\\n for i in range(N-l+1):\\n dp[i][i+l-1] = float('inf')\\n for x in range(i, i+l-1, K-1):\\n dp[i][i+l-1] = min(dp[i][i+l-1], dp[i][x] + dp[x+1][i+l-1])\\n dp[i][i+l-1] += (sum(stones[i:i+l]) if (l-1)%(K-1) == 0 else 0)\\n \\n return dp[0][N-1]\",\n \"class Solution:\\n def mergeStones(self, stones, k):\\n \\n # quick check to see if this number of piles can be merged. \\n if (len(stones)-1)%(k-1): \\n return -1\\n\\n cost = [[None]*len(stones) for _ in stones]\\n\\n def subCost(left, right):\\n\\n # Base case: there is no cost to \\\\\\\"merging\\\\\\\" one pile\\n if left == right: \\n return 0\\n\\n if cost[left][right] != None: \\n return cost[left][right]\\n\\n # Base case: a single merge is just the sum of the elements. \\n if (right - left + 1) == k: \\n cost[left][right] = sum(stones[left:right+1])\\n return cost[left][right]\\n\\n # find k-1 division points. Each division except the last is the start index of a sub-array\\n # ie. if stones = [ 0, 1, 2, 3, 4, 5, 6, 7, 8 ], left = 0 right = 8 divs = [0, 3, 8, 9]\\n # then sub-arrays are as follows: [0, 1, 2] [3, 4, 5, 6, 7] [8] \\n # the above divs would incidentally be valid for k = 3. \\n\\n divs = [ left + i for i in range(k+1)]\\n divs[-1] = right + 1 # set the last divider to one past the subarray. \\n # for example above, divs is initialized to -> [0, 1, 2, 9]. The first and last divider never change\\n\\n def moveDividers():\\n # loop through dividers to move, starting at last one. \\n # if the last one is at the end, move the next one up. \\n\\n def moveDivider(i): \\n if i == 0: \\n return False\\n\\n # if the div we're looking at is smashing all dividers to its right against the right end of the array. \\n # If k = 3, i = 1, we have 1 divider to our right. Leave 1 space for each divider to our right.\\n # division 0 stays at 0 \\n # div 1 can go to 2. = right - (k - 1 - i)\\n if divs[i] == ( right - (k - 1 - i)):\\n # switch to the next divider to the left\\n return moveDivider(i-1)\\n\\n # move this divider to the next usable spot given where the left neighbor div is. \\n divs[i] += 1\\n while (divs[i] - divs[i-1] - 1)%(k-1):\\n divs[i] += 1\\n\\n # stack all following divs next to each other and this one. []\\n for j in range(i+1, len(divs)-1):\\n divs[j] = divs[j-1] + 1\\n\\n return True\\n\\n # start by moving the rightmost divider\\n return moveDivider(len(divs) - 2)\\n\\n best = float('inf')\\n while 1:\\n subSum = 0\\n for div_i in range(len(divs)-1):\\n subSum += subCost(divs[div_i], divs[div_i+1] - 1) \\n best = min(best, subSum) \\n if not moveDividers():\\n break\\n\\n result = best + sum(stones[left:right+1])\\n cost[left][right] = result\\n return result\\n\\n result = subCost(0, len(stones)-1)\\n #print(cost)\\n return result \",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n # Time Complexity: O(N^3 K)\\n # Space Complexity: O(N^2 K)\\n \\n self.dp = {}\\n self.prefix = [0] + list(itertools.accumulate(stones))\\n \\n ret = self.merge(stones, 0, len(stones) - 1, 1, K)\\n \\n return ret\\n \\n def merge(self, stones, start: int, end: int, num_parts: int, K: int):\\n if (start, end, num_parts) in self.dp:\\n return self.dp[(start, end, num_parts)]\\n \\n if end - start + 1 < num_parts:\\n return -1\\n \\n if end - start + 1 == num_parts:\\n return 0\\n \\n window_sum = self.prefix[end + 1] - self.prefix[start] \\n \\n if num_parts == 1:\\n split = self.merge(stones, start, end, K, K)\\n \\n if split == -1:\\n ret = -1\\n else:\\n ret = window_sum + split\\n else:\\n candidates = []\\n \\n for i in range(start, end):\\n left = self.merge(stones, start, i, 1, K)\\n right = self.merge(stones, i + 1, end, num_parts - 1, K)\\n \\n \\n if left >= 0 and right >= 0:\\n candidates.append(left + right)\\n \\n if candidates:\\n ret = min(candidates)\\n else:\\n ret = -1\\n \\n self.dp[(start, end, num_parts)] = ret\\n return ret\\n\\n\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n self.dp = {}\\n \\n \\n ret = self.merge(stones, 0, len(stones) - 1, 1, K)\\n \\n return ret\\n \\n def merge(self, stones, start: int, end: int, num_parts: int, K: int):\\n if (start, end, num_parts) in self.dp:\\n return self.dp[(start, end, num_parts)]\\n \\n if end - start + 1 < num_parts:\\n return -1\\n \\n if end - start + 1 == num_parts:\\n return 0\\n \\n window_sum = sum(stones[start:end + 1])\\n \\n if num_parts == 1:\\n split = self.merge(stones, start, end, K, K)\\n \\n if split == -1:\\n ret = -1\\n else:\\n ret = window_sum + split\\n else:\\n candidates = []\\n \\n for i in range(start, end):\\n left = self.merge(stones, start, i, 1, K)\\n right = self.merge(stones, i + 1, end, num_parts - 1, K)\\n \\n \\n if left >= 0 and right >= 0:\\n candidates.append(left + right)\\n \\n if candidates:\\n ret = min(candidates)\\n else:\\n ret = -1\\n \\n self.dp[(start, end, num_parts)] = ret\\n return ret\\n\\n\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones) \\n \\n inf = float('inf')\\n prefix = [0] * (n + 1)\\n \\n for i in range(n): \\n prefix[i + 1] = prefix[i] + stones[i]\\n \\n import functools\\n \\n @functools.lru_cache(None) \\n def dp(i, j, m): \\n if i == j: \\n return 0 if m == 1 else inf\\n if m == 1: \\n return dp(i, j, K) + prefix[j + 1] - prefix[i]\\n \\n return min(dp(i, mid, 1) + dp(mid + 1, j, m - 1) for mid in range(i, j))\\n \\n res = dp(0, n - 1, 1)\\n \\n return res if res < inf else -1 \",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n if K > 2 and n % (K - 1) != 1:\\n return -1\\n \\n dp = [[[math.inf] * (K + 1) for i in range(n)] for j in range(n)]\\n for i in range(n):\\n dp[i][i][1] = 0\\n \\n presum = [stones[0]]\\n for i in range(1, n):\\n presum.append(presum[i - 1] + stones[i])\\n \\n def stones_in_range(i, j):\\n return presum[j] - presum[i - 1] if i > 0 else presum[j]\\n \\n for rangelen in range(2, n + 1):\\n for start in range(n + 1 - rangelen):\\n end = start + rangelen - 1\\n for k in range(2, K + 1):\\n for divide in range(start, end, K - 1):\\n dp[start][end][k] = min(dp[start][end][k], dp[start][divide][1] + dp[divide + 1][end][k - 1])\\n print(start, end, k, divide, dp[start][end][k])\\n if dp[start][end][K] < math.inf:\\n dp[start][end][1] = dp[start][end][K] + stones_in_range(start, end)\\n \\n return dp[0][n - 1][1]\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n if (n - 1) % (K - 1):\\n return -1\\n \\n s = [0]\\n for num in stones:\\n s.append(s[-1] + num)\\n \\n dp = [[0] * n for _ in range(n)]\\n for i in range(n - 1, -1, -1):\\n for j in range(i + 1, n):\\n dp[i][j] = float('inf')\\n for m in range(i, j, K - 1):\\n dp[i][j] = min(dp[i][j], dp[i][m] + dp[m + 1][j] + (0 if (j - i) % (K - 1) else s[j + 1] - s[i]))\\n \\n return -1 if dp[0][-1] == float('inf') else dp[0][-1]\\n \\n \\n @functools.lru_cache(None)\\n def f(i, j):\\n if i == j:\\n return 0\\n ans = float('inf')\\n m = i\\n while m < j:\\n ans = min(ans, f(i, m) + f(m + 1, j) + (0 if (j - i) % (K - 1) else s[j + 1] - s[i]))\\n m += K - 1\\n \\n return ans\\n \\n ans = f(0, n - 1)\\n return -1 if ans == float('inf') else ans\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n if (n-1)%(K-1) != 0:\\n return -1\\n dp = [[0]*n for i in range(n)]\\n sums = [0]*(n+1)\\n for i in range(1, n+1):\\n sums[i] = sums[i-1] + stones[i-1]\\n for l in range(K, n+1):\\n for i in range(n-l+1):\\n j = i+l-1\\n dp[i][j] = float('inf')\\n for t in range(i, j, K-1):\\n dp[i][j] = min(dp[i][j], dp[i][t]+dp[t+1][j])\\n if (j-i)%(K-1) == 0:\\n dp[i][j] += sums[j+1] - sums[i]\\n return dp[0][n-1]\\n\",\n \"class Solution:\\n def mergeStones(self, stones: List[int], K: int) -> int:\\n n = len(stones)\\n if (n - 1) % (K - 1):\\n return -1\\n prefix = [0]*(n+1)\\n for i in range(1, n+1):\\n prefix[i] = prefix[i-1] + stones[i-1]\\n import functools\\n @functools.lru_cache(None)\\n def dp(i, j):\\n if j - i + 1 < K:\\n return 0\\n res = min(dp(i, mid) + dp(mid+1, j) for mid in range(i, j, K-1))\\n if (j - i) % (K - 1) == 0:\\n res += prefix[j + 1] - prefix[i]\\n return res\\n return dp(0, n-1)\\n \\n# n = len(stones)\\n# if (n - 1) % (K - 1): return -1\\n# prefix = [0] * (n + 1)\\n# for i in range(n):\\n# prefix[i + 1] = prefix[i] + stones[i]\\n\\n# import functools\\n# @functools.lru_cache(None)\\n# def dp(i, j):\\n# if j - i + 1 < K: return 0\\n# res = min(dp(i, mid) + dp(mid + 1, j) for mid in range(i, j, K - 1))\\n# if (j - i) % (K - 1) == 0:\\n# res += prefix[j + 1] - prefix[i]\\n# return res\\n# return dp(0, n - 1)\\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":28,"string":"28"},"non_interactive_idx":{"kind":"list like","value":[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],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[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],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":77,"cells":{"problem_id":{"kind":"number","value":210,"string":"210"},"question":{"kind":"string","value":"Given an array of integers, find out whether there are two distinct indices i and j in the array such that the absolute difference between nums[i] and nums[j] is at most t and the absolute difference between i and j is at most k.\n\n\nExample 1:\n\n\nInput: nums = [1,2,3,1], k = 3, t = 0\nOutput: true\n\n\n\nExample 2:\n\n\nInput: nums = [1,0,1,1], k = 1, t = 2\nOutput: true\n\n\n\nExample 3:\n\n\nInput: nums = [1,5,9,1,5,9], k = 2, t = 3\nOutput: false"},"solutions":{"kind":"string","value":"[\"class Solution:\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n if len(nums) < 2 or k <= 0 or t < 0: return False\\n if t == 0:\\n visited = set()\\n for i, n in enumerate(nums):\\n if n in visited: return True\\n visited.add(n)\\n if i >= k: visited.remove(nums[i-k])\\n return False\\n bucket = {}\\n for i, n in enumerate(nums):\\n b = n // t\\n if b in bucket: return True\\n if b+1 in bucket and abs(bucket[b+1]-n) <= t: return True\\n if b-1 in bucket and abs(bucket[b-1]-n) <= t: return True\\n bucket[b] = n\\n if i >= k: del bucket[nums[i-k]//t]\\n return False\", \"class Solution:\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n nums2 = [(n, i) for i, n in enumerate(nums)]\\n nums2 = sorted(nums2)\\n print(nums2)\\n for i in range(1, len(nums2)):\\n j = i-1\\n a, n = nums2[j]\\n b, m = nums2[i]\\n while abs(a-b) <= t:\\n if abs(n-m) <= k:\\n return True\\n j -= 1\\n if j < 0:\\n break\\n a, n = nums2[j]\\n \\n return False\\n \\n\", \"class Solution(object):\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n if k < 1 or t < 0:\\n return False\\n import sys\\n \\n bh = {}\\n # To prevent 0 as a divisor\\n w = t+1\\n for i in range(len(nums)):\\n n_i = nums[i]\\n n_i_w = n_i // w\\n if n_i_w in bh:\\n return True\\n if n_i_w-1 in bh and abs(n_i - bh[n_i_w-1]) < w:\\n return True\\n if n_i_w+1 in bh and abs(n_i - bh[n_i_w+1]) < w:\\n return True\\n bh[n_i_w] = nums[i]\\n if len(bh) > k:\\n del bh[(nums[i - k]) // w]\\n return False\\n\", \"class Solution:\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n \\n if t<0:\\n return False\\n \\n w = t+1\\n d = {}\\n \\n for i in range(0, len(nums)):\\n m = nums[i]//w\\n #print(m,d)\\n if m in d:\\n return True\\n if m-1 in d and abs(nums[i]-d[m-1])<=t:\\n return True\\n if m+1 in d and abs(nums[i]-d[m+1])<=t:\\n return True\\n d[m] = nums[i]\\n if i>=k:\\n del d[nums[i-k]//w]\\n \\n return False\\n\", \"class Solution:\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n if t < 0: return False\\n n = len(nums)\\n buckets = {}\\n w = t + 1\\n for i in range(n):\\n bucket_num = nums[i] // w\\n if bucket_num in buckets:\\n return True\\n if bucket_num - 1 in buckets and abs(nums[i] - buckets[bucket_num - 1]) < w:\\n return True\\n if bucket_num + 1 in buckets and abs(nums[i] - buckets[bucket_num + 1]) < w:\\n return True\\n buckets[bucket_num] = nums[i]\\n if i >= k: del buckets[nums[i-k]//w]\\n return False\\n\", \"class Solution:\\n def equalSol(self, nums, k):\\n if k == 0:\\n return False\\n d = {}\\n for i in range(len(nums)):\\n if nums[i] in d.keys() and abs(i - d[nums[i]]) <= k:\\n return True\\n else:\\n d[nums[i]] = i\\n return False\\n \\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n if k == 0:\\n return False\\n if t == 0:\\n return self.equalSol(nums, k)\\n for i in range(len(nums)):\\n for j in range(1,(k+1)):\\n if (i + j) < len(nums) and abs(nums[i] - nums[i+j]) <= t:\\n return True\\n if (i - j) >= 0 and abs(nums[i] - nums[i-j]) <=t:\\n return True\\n return False\", \"class Solution:\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n buckets = {}\\n for i, v in enumerate(nums):\\n bucket_num, offset = (v//t, 1) if t else (v, 0)\\n for idx in range(bucket_num - offset, bucket_num + offset + 1):\\n if idx in buckets and abs(buckets[idx] - nums[i]) <= t:\\n return True\\n \\n buckets[bucket_num] = nums[i]\\n if len(buckets) > k:\\n del buckets[nums[i-k] // t if t else nums[i-k]]\\n \\n return False\\n\", \"class Solution:\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n if t < 0: return False\\n n = len(nums)\\n buckets = {}\\n w = t + 1\\n for i in range(n):\\n bucket_num = nums[i] // w\\n if bucket_num in buckets:\\n return True\\n if bucket_num - 1 in buckets and abs(nums[i] - buckets[bucket_num - 1]) < w:\\n return True\\n if bucket_num + 1 in buckets and abs(nums[i] - buckets[bucket_num + 1]) < w:\\n return True\\n buckets[bucket_num] = nums[i]\\n if i >= k: del buckets[nums[i-k]//w]\\n return False\\n\", \"class Solution:\\n # @param {integer[]} nums\\n # @param {integer} k\\n # @param {integer} t\\n # @return {boolean}\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n if len(nums) == 0 or len(nums) == 1 or k < 1 or t < 0:\\n return False\\n d = collections.OrderedDict()\\n for i in nums:\\n key = i if not t else i // t\\n for j in (d.get(key - 1), d.get(key), d.get(key + 1)):\\n if j != None and abs(j - i) <= t:\\n return True\\n if len(d) == k:\\n d.popitem(False)\\n d[key] = i\\n \\n return False\", \"class Solution:\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n if k < 1 or t < 0:\\n return False\\n m = len(nums)\\n if m == 0:\\n return False\\n \\n \\n buckets = {}\\n _min = 0\\n for i in range(m):\\n num = nums[i] - _min\\n bucket = num // (t + 1)\\n flag = bucket in buckets \\\\\\n or (bucket - 1 in buckets and abs(buckets[bucket - 1] - num) <= t) \\\\\\n or (bucket + 1 in buckets and abs(buckets[bucket + 1] - num) <= t)\\n \\n if flag:\\n return True\\n if len(buckets) >= k:\\n del buckets[(nums[i - k] - _min) // (t + 1)]\\n \\n buckets[bucket] = num\\n return False\", \"class Solution:\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n if t < 0:\\n return False\\n d = {}\\n w = t + 1\\n \\n for i in range(len(nums)):\\n b = nums[i] // w\\n if b in d:\\n return True\\n if b - 1 in d and abs(nums[i] - d[b - 1]) < w:\\n return True\\n if b + 1 in d and abs(nums[i] - d[b + 1]) < w:\\n return True\\n d[b] = nums[i]\\n if i >= k:\\n del d[nums[i - k] // w]\\n \\n return False\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"containsNearbyAlmostDuplicate\", \"inputs\": [[[1, 2, 3, 1], 3, 0]], \"outputs\": [true]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/contains-duplicate-iii/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def containsNearbyAlmostDuplicate(self, nums: List[int], k: int, t: int) -> bool:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def containsNearbyAlmostDuplicate(self, nums, k, t):\n \"\"\"\n :type nums: List[int]\n :type k: int\n :type t: int\n :rtype: bool\n \"\"\"\n if len(nums) < 2 or k <= 0 or t < 0: return False\n if t == 0:\n visited = set()\n for i, n in enumerate(nums):\n if n in visited: return True\n visited.add(n)\n if i >= k: visited.remove(nums[i-k])\n return False\n bucket = {}\n for i, n in enumerate(nums):\n b = n // t\n if b in bucket: return True\n if b+1 in bucket and abs(bucket[b+1]-n) <= t: return True\n if b-1 in bucket and abs(bucket[b-1]-n) <= t: return True\n bucket[b] = n\n if i >= k: del bucket[nums[i-k]//t]\n return False","class Solution:\n def containsNearbyAlmostDuplicate(self, nums, k, t):\n \"\"\"\n :type nums: List[int]\n :type k: int\n :type t: int\n :rtype: bool\n \"\"\"\n nums2 = [(n, i) for i, n in enumerate(nums)]\n nums2 = sorted(nums2)\n print(nums2)\n for i in range(1, len(nums2)):\n j = i-1\n a, n = nums2[j]\n b, m = nums2[i]\n while abs(a-b) <= t:\n if abs(n-m) <= k:\n return True\n j -= 1\n if j < 0:\n break\n a, n = nums2[j]\n \n return False\n \n","class Solution(object):\n def containsNearbyAlmostDuplicate(self, nums, k, t):\n \"\"\"\n :type nums: List[int]\n :type k: int\n :type t: int\n :rtype: bool\n \"\"\"\n if k < 1 or t < 0:\n return False\n import sys\n \n bh = {}\n # To prevent 0 as a divisor\n w = t+1\n for i in range(len(nums)):\n n_i = nums[i]\n n_i_w = n_i // w\n if n_i_w in bh:\n return True\n if n_i_w-1 in bh and abs(n_i - bh[n_i_w-1]) < w:\n return True\n if n_i_w+1 in bh and abs(n_i - bh[n_i_w+1]) < w:\n return True\n bh[n_i_w] = nums[i]\n if len(bh) > k:\n del bh[(nums[i - k]) // w]\n return False\n","class Solution:\n def containsNearbyAlmostDuplicate(self, nums, k, t):\n \"\"\"\n :type nums: List[int]\n :type k: int\n :type t: int\n :rtype: bool\n \"\"\"\n \n if t<0:\n return False\n \n w = t+1\n d = {}\n \n for i in range(0, len(nums)):\n m = nums[i]//w\n #print(m,d)\n if m in d:\n return True\n if m-1 in d and abs(nums[i]-d[m-1])<=t:\n return True\n if m+1 in d and abs(nums[i]-d[m+1])<=t:\n return True\n d[m] = nums[i]\n if i>=k:\n del d[nums[i-k]//w]\n \n return False\n","class Solution:\n def containsNearbyAlmostDuplicate(self, nums, k, t):\n \"\"\"\n :type nums: List[int]\n :type k: int\n :type t: int\n :rtype: bool\n \"\"\"\n if t < 0: return False\n n = len(nums)\n buckets = {}\n w = t + 1\n for i in range(n):\n bucket_num = nums[i] // w\n if bucket_num in buckets:\n return True\n if bucket_num - 1 in buckets and abs(nums[i] - buckets[bucket_num - 1]) < w:\n return True\n if bucket_num + 1 in buckets and abs(nums[i] - buckets[bucket_num + 1]) < w:\n return True\n buckets[bucket_num] = nums[i]\n if i >= k: del buckets[nums[i-k]//w]\n return False\n","class Solution:\n def equalSol(self, nums, k):\n if k == 0:\n return False\n d = {}\n for i in range(len(nums)):\n if nums[i] in d.keys() and abs(i - d[nums[i]]) <= k:\n return True\n else:\n d[nums[i]] = i\n return False\n \n def containsNearbyAlmostDuplicate(self, nums, k, t):\n \"\"\"\n :type nums: List[int]\n :type k: int\n :type t: int\n :rtype: bool\n \"\"\"\n if k == 0:\n return False\n if t == 0:\n return self.equalSol(nums, k)\n for i in range(len(nums)):\n for j in range(1,(k+1)):\n if (i + j) < len(nums) and abs(nums[i] - nums[i+j]) <= t:\n return True\n if (i - j) >= 0 and abs(nums[i] - nums[i-j]) <=t:\n return True\n return False","class Solution:\n def containsNearbyAlmostDuplicate(self, nums, k, t):\n \"\"\"\n :type nums: List[int]\n :type k: int\n :type t: int\n :rtype: bool\n \"\"\"\n buckets = {}\n for i, v in enumerate(nums):\n bucket_num, offset = (v//t, 1) if t else (v, 0)\n for idx in range(bucket_num - offset, bucket_num + offset + 1):\n if idx in buckets and abs(buckets[idx] - nums[i]) <= t:\n return True\n \n buckets[bucket_num] = nums[i]\n if len(buckets) > k:\n del buckets[nums[i-k] // t if t else nums[i-k]]\n \n return False\n","class Solution:\n def containsNearbyAlmostDuplicate(self, nums, k, t):\n \"\"\"\n :type nums: List[int]\n :type k: int\n :type t: int\n :rtype: bool\n \"\"\"\n if t < 0: return False\n n = len(nums)\n buckets = {}\n w = t + 1\n for i in range(n):\n bucket_num = nums[i] // w\n if bucket_num in buckets:\n return True\n if bucket_num - 1 in buckets and abs(nums[i] - buckets[bucket_num - 1]) < w:\n return True\n if bucket_num + 1 in buckets and abs(nums[i] - buckets[bucket_num + 1]) < w:\n return True\n buckets[bucket_num] = nums[i]\n if i >= k: del buckets[nums[i-k]//w]\n return False\n","class Solution:\n # @param {integer[]} nums\n # @param {integer} k\n # @param {integer} t\n # @return {boolean}\n def containsNearbyAlmostDuplicate(self, nums, k, t):\n if len(nums) == 0 or len(nums) == 1 or k < 1 or t < 0:\n return False\n d = collections.OrderedDict()\n for i in nums:\n key = i if not t else i // t\n for j in (d.get(key - 1), d.get(key), d.get(key + 1)):\n if j != None and abs(j - i) <= t:\n return True\n if len(d) == k:\n d.popitem(False)\n d[key] = i\n \n return False","class Solution:\n def containsNearbyAlmostDuplicate(self, nums, k, t):\n \"\"\"\n :type nums: List[int]\n :type k: int\n :type t: int\n :rtype: bool\n \"\"\"\n if k < 1 or t < 0:\n return False\n m = len(nums)\n if m == 0:\n return False\n \n \n buckets = {}\n _min = 0\n for i in range(m):\n num = nums[i] - _min\n bucket = num // (t + 1)\n flag = bucket in buckets \\\n or (bucket - 1 in buckets and abs(buckets[bucket - 1] - num) <= t) \\\n or (bucket + 1 in buckets and abs(buckets[bucket + 1] - num) <= t)\n \n if flag:\n return True\n if len(buckets) >= k:\n del buckets[(nums[i - k] - _min) // (t + 1)]\n \n buckets[bucket] = num\n return False","class Solution:\n def containsNearbyAlmostDuplicate(self, nums, k, t):\n \"\"\"\n :type nums: List[int]\n :type k: int\n :type t: int\n :rtype: bool\n \"\"\"\n if t < 0:\n return False\n d = {}\n w = t + 1\n \n for i in range(len(nums)):\n b = nums[i] // w\n if b in d:\n return True\n if b - 1 in d and abs(nums[i] - d[b - 1]) < w:\n return True\n if b + 1 in d and abs(nums[i] - d[b + 1]) < w:\n return True\n d[b] = nums[i]\n if i >= k:\n del d[nums[i - k] // w]\n \n return False"],"string":"[\n \"class Solution:\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n if len(nums) < 2 or k <= 0 or t < 0: return False\\n if t == 0:\\n visited = set()\\n for i, n in enumerate(nums):\\n if n in visited: return True\\n visited.add(n)\\n if i >= k: visited.remove(nums[i-k])\\n return False\\n bucket = {}\\n for i, n in enumerate(nums):\\n b = n // t\\n if b in bucket: return True\\n if b+1 in bucket and abs(bucket[b+1]-n) <= t: return True\\n if b-1 in bucket and abs(bucket[b-1]-n) <= t: return True\\n bucket[b] = n\\n if i >= k: del bucket[nums[i-k]//t]\\n return False\",\n \"class Solution:\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n nums2 = [(n, i) for i, n in enumerate(nums)]\\n nums2 = sorted(nums2)\\n print(nums2)\\n for i in range(1, len(nums2)):\\n j = i-1\\n a, n = nums2[j]\\n b, m = nums2[i]\\n while abs(a-b) <= t:\\n if abs(n-m) <= k:\\n return True\\n j -= 1\\n if j < 0:\\n break\\n a, n = nums2[j]\\n \\n return False\\n \\n\",\n \"class Solution(object):\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n if k < 1 or t < 0:\\n return False\\n import sys\\n \\n bh = {}\\n # To prevent 0 as a divisor\\n w = t+1\\n for i in range(len(nums)):\\n n_i = nums[i]\\n n_i_w = n_i // w\\n if n_i_w in bh:\\n return True\\n if n_i_w-1 in bh and abs(n_i - bh[n_i_w-1]) < w:\\n return True\\n if n_i_w+1 in bh and abs(n_i - bh[n_i_w+1]) < w:\\n return True\\n bh[n_i_w] = nums[i]\\n if len(bh) > k:\\n del bh[(nums[i - k]) // w]\\n return False\\n\",\n \"class Solution:\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n \\n if t<0:\\n return False\\n \\n w = t+1\\n d = {}\\n \\n for i in range(0, len(nums)):\\n m = nums[i]//w\\n #print(m,d)\\n if m in d:\\n return True\\n if m-1 in d and abs(nums[i]-d[m-1])<=t:\\n return True\\n if m+1 in d and abs(nums[i]-d[m+1])<=t:\\n return True\\n d[m] = nums[i]\\n if i>=k:\\n del d[nums[i-k]//w]\\n \\n return False\\n\",\n \"class Solution:\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n if t < 0: return False\\n n = len(nums)\\n buckets = {}\\n w = t + 1\\n for i in range(n):\\n bucket_num = nums[i] // w\\n if bucket_num in buckets:\\n return True\\n if bucket_num - 1 in buckets and abs(nums[i] - buckets[bucket_num - 1]) < w:\\n return True\\n if bucket_num + 1 in buckets and abs(nums[i] - buckets[bucket_num + 1]) < w:\\n return True\\n buckets[bucket_num] = nums[i]\\n if i >= k: del buckets[nums[i-k]//w]\\n return False\\n\",\n \"class Solution:\\n def equalSol(self, nums, k):\\n if k == 0:\\n return False\\n d = {}\\n for i in range(len(nums)):\\n if nums[i] in d.keys() and abs(i - d[nums[i]]) <= k:\\n return True\\n else:\\n d[nums[i]] = i\\n return False\\n \\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n if k == 0:\\n return False\\n if t == 0:\\n return self.equalSol(nums, k)\\n for i in range(len(nums)):\\n for j in range(1,(k+1)):\\n if (i + j) < len(nums) and abs(nums[i] - nums[i+j]) <= t:\\n return True\\n if (i - j) >= 0 and abs(nums[i] - nums[i-j]) <=t:\\n return True\\n return False\",\n \"class Solution:\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n buckets = {}\\n for i, v in enumerate(nums):\\n bucket_num, offset = (v//t, 1) if t else (v, 0)\\n for idx in range(bucket_num - offset, bucket_num + offset + 1):\\n if idx in buckets and abs(buckets[idx] - nums[i]) <= t:\\n return True\\n \\n buckets[bucket_num] = nums[i]\\n if len(buckets) > k:\\n del buckets[nums[i-k] // t if t else nums[i-k]]\\n \\n return False\\n\",\n \"class Solution:\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n if t < 0: return False\\n n = len(nums)\\n buckets = {}\\n w = t + 1\\n for i in range(n):\\n bucket_num = nums[i] // w\\n if bucket_num in buckets:\\n return True\\n if bucket_num - 1 in buckets and abs(nums[i] - buckets[bucket_num - 1]) < w:\\n return True\\n if bucket_num + 1 in buckets and abs(nums[i] - buckets[bucket_num + 1]) < w:\\n return True\\n buckets[bucket_num] = nums[i]\\n if i >= k: del buckets[nums[i-k]//w]\\n return False\\n\",\n \"class Solution:\\n # @param {integer[]} nums\\n # @param {integer} k\\n # @param {integer} t\\n # @return {boolean}\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n if len(nums) == 0 or len(nums) == 1 or k < 1 or t < 0:\\n return False\\n d = collections.OrderedDict()\\n for i in nums:\\n key = i if not t else i // t\\n for j in (d.get(key - 1), d.get(key), d.get(key + 1)):\\n if j != None and abs(j - i) <= t:\\n return True\\n if len(d) == k:\\n d.popitem(False)\\n d[key] = i\\n \\n return False\",\n \"class Solution:\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n if k < 1 or t < 0:\\n return False\\n m = len(nums)\\n if m == 0:\\n return False\\n \\n \\n buckets = {}\\n _min = 0\\n for i in range(m):\\n num = nums[i] - _min\\n bucket = num // (t + 1)\\n flag = bucket in buckets \\\\\\n or (bucket - 1 in buckets and abs(buckets[bucket - 1] - num) <= t) \\\\\\n or (bucket + 1 in buckets and abs(buckets[bucket + 1] - num) <= t)\\n \\n if flag:\\n return True\\n if len(buckets) >= k:\\n del buckets[(nums[i - k] - _min) // (t + 1)]\\n \\n buckets[bucket] = num\\n return False\",\n \"class Solution:\\n def containsNearbyAlmostDuplicate(self, nums, k, t):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :type k: int\\n :type t: int\\n :rtype: bool\\n \\\"\\\"\\\"\\n if t < 0:\\n return False\\n d = {}\\n w = t + 1\\n \\n for i in range(len(nums)):\\n b = nums[i] // w\\n if b in d:\\n return True\\n if b - 1 in d and abs(nums[i] - d[b - 1]) < w:\\n return True\\n if b + 1 in d and abs(nums[i] - d[b + 1]) < w:\\n return True\\n d[b] = nums[i]\\n if i >= k:\\n del d[nums[i - k] // w]\\n \\n return False\"\n]","isConversational":false},"n_sols":{"kind":"number","value":11,"string":"11"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4,5,6,7,8,9,10],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null,null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":78,"cells":{"problem_id":{"kind":"number","value":212,"string":"212"},"question":{"kind":"string","value":"Given an array of unique integers, each integer is strictly greater than 1.\nWe make a binary tree using these integers and each number may be used for any number of times.\nEach non-leaf node's value should be equal to the product of the values of it's children.\nHow many binary trees can we make? Return the answer modulo 10 ** 9 + 7.\nExample 1:\nInput: A = [2, 4]\nOutput: 3\nExplanation: We can make these trees: [2], [4], [4, 2, 2]\nExample 2:\nInput: A = [2, 4, 5, 10]\nOutput: 7\nExplanation: We can make these trees: [2], [4], [5], [10], [4, 2, 2], [10, 2, 5], [10, 5, 2].\n \nNote:\n\n1 <= A.length <= 1000.\n2 <= A[i] <= 10 ^ 9."},"solutions":{"kind":"string","value":"[\"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n \\n mod = 10**9 + 7\\n\\n nums_set = set(A)\\n nums = A.copy()\\n nums.sort()\\n counts = {}\\n total = 0\\n\\n for n in nums:\\n n_count = 1\\n for d in nums:\\n if d * d > n:\\n break\\n if n % d != 0:\\n continue\\n e = n // d\\n if e not in nums_set:\\n continue\\n\\n subtrees = (counts[d] * counts[e]) % mod\\n if d != e:\\n subtrees = (subtrees * 2) % mod\\n n_count = (n_count + subtrees) % mod\\n counts[n] = n_count % mod\\n total = (total + n_count) % mod\\n\\n return total\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n factorSet = set(A)\\n A.sort()\\n treeCount = collections.defaultdict(lambda : 1)\\n \\n n = len(A)\\n end = 0\\n for num in A:\\n sqrt = int(math.sqrt(num)+1)\\n while end < n and A[end] <= sqrt:\\n end += 1\\n count = 0\\n for _, p in zip(list(range(end)), A):\\n if num % p == 0 and (q := num // p) in factorSet and p <= q:\\n count += 2*treeCount[p]*treeCount[q] if p != q else treeCount[p]*treeCount[q]\\n treeCount[num] += count\\n return sum(treeCount.values()) % (1000_000_000 + 7)\\n \\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n factorSet = set(A)\\n A.sort()\\n treeCount = {}\\n\\n for num in A:\\n count = 1\\n for p, pCount in list(treeCount.items()):\\n q, rem = divmod(num, p)\\n if p > q:\\n break\\n if rem == 0:\\n tmp = pCount * treeCount.get(q, 0)\\n count += tmp if p == q else 2*tmp\\n treeCount[num] = count\\n return sum(treeCount.values()) % (1000_000_000 + 7)\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n dp = {}\\n res = 0\\n for i in range(len(A)):\\n dp[A[i]] = 1\\n for j in range(i):\\n if A[j] * A[j] == A[i]:\\n dp[A[i]] += dp[A[j]] * dp[A[j]]\\n dp[A[i]] %= 1000_000_007\\n elif A[j] * A[j] > A[i] and A[i] % A[j] == 0:\\n dp[A[i]] += dp[A[j]] * dp.get(A[i] // A[j], 0) * 2\\n dp[A[i]] %= 1000_000_007\\n res = sum([v for _, v in dp.items()])\\n res %= 1000_000_007\\n return res\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n dp = {}\\n res = 0\\n for i in range(len(A)):\\n dp[A[i]] = 1\\n for j in range(i):\\n if A[j] * A[j] == A[i]:\\n dp[A[i]] += dp[A[j]] * dp[A[j]]\\n dp[A[i]] %= 1000_000_007\\n elif A[j] * A[j] > A[i]:\\n div = A[i] // A[j]\\n if div * A[j] == A[i] and div in dp:\\n dp[A[i]] += dp[A[j]] * dp[div] * 2\\n dp[A[i]] %= 1000_000_007\\n res += dp[A[i]]\\n res %= 1000_000_007\\n return res\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n dp = {}\\n res = 0\\n for i in range(len(A)):\\n dp[A[i]] = 1\\n for j in range(i):\\n if A[j] * A[j] == A[i]:\\n dp[A[i]] += dp[A[j]] * dp[A[j]]\\n dp[A[i]] %= 1000_000_007\\n elif A[j] * A[j] > A[i] and A[i] % A[j] == 0:\\n dp[A[i]] += dp[A[j]] * dp.get(A[i] // A[j], 0) * 2\\n dp[A[i]] %= 1000_000_007\\n res += dp[A[i]]\\n res %= 1000_000_007\\n return res\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n cache = dict()\\n iSet = set(A)\\n def helper(i):\\n if i not in cache:\\n count = 1\\n for j in range(len(A)):\\n if i != A[j] and i % A[j] == 0:\\n if i//A[j] in iSet:\\n count += helper(A[j]) * helper(i//A[j])\\n cache[i] = count\\n return cache[i]\\n ans = 0\\n for i in range(len(A)):\\n ans += helper(A[i])\\n return ans % 1000000007\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A=sorted(A)\\n res=dict()\\n for idx, a in enumerate(A):\\n if idx==0:\\n res[a]=1\\n else:\\n res[a]=1\\n for j in range(idx):\\n if (a%A[j]==0) and (a//A[j] in A):\\n res[a]+=res[A[j]]*res[a//A[j]]\\n return sum(res.values())%(10**9+7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n \\n A.sort()\\n \\n dp = [1 for _ in range(len(A))]\\n \\n for i in range(len(A)):\\n \\n for j in range(i):\\n \\n time, remain = divmod(A[i], A[j])\\n\\n if remain == 0 and time in A:\\n\\n dp[i] += (dp[j] * dp[A.index(time)])\\n \\n return sum(dp) % (10**9 + 7)\\n \\n \\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n d = {}\\n Aset = set(A)\\n A.sort()\\n ans = 0\\n for i in range(len(A)):\\n d[A[i]] = 1\\n for j in range(i):\\n if A[i]%A[j] == 0:\\n k = A[i]//A[j]\\n if k in set(A):\\n d[A[i]] += d[A[j]]*d[k]\\n d[A[i]] %= 10**9+7\\n ans += d[A[i]]\\n ans %= 10**9+7\\n # print(d)\\n return ans\\n # return sum(d[key] for key in d)\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n d = {}\\n Aset = set(A)\\n A.sort()\\n ans = 0\\n for i in range(len(A)):\\n d[A[i]] = 1\\n for j in range(i):\\n if A[i]%A[j] == 0:\\n k = A[i]//A[j]\\n if k == A[j]:\\n d[A[i]] += d[A[j]]*d[A[j]]\\n elif k in set(A):\\n d[A[i]] += d[A[j]]*d[k]\\n ans += d[A[i]]\\n ans %= 10**9+7\\n # print(d)\\n return ans\\n # return sum(d[key] for key in d)\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n d = {}\\n Aset = set(A)\\n A.sort()\\n ans = 0\\n for i in range(len(A)):\\n d[A[i]] = 1\\n for j in range(i):\\n if A[i]%A[j] == 0:\\n k = A[i]//A[j]\\n if k in set(A):\\n d[A[i]] += d[A[j]]*d[k]\\n d[A[i]] %= 10**9+7\\n ans += d[A[i]]\\n ans %= 10**9+7\\n return ans\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n SA = set(A)\\n A = sorted(SA)\\n C = {}\\n for x in A:\\n C[x] = 1\\n for i, x in enumerate(A):\\n for j in range(i):\\n if A[j] * A[j] > A[i]:\\n break\\n elif A[j] * A[j] == A[i]:\\n C[A[i]] += C[A[j]] * C[A[j]]\\n elif A[i] % A[j] == 0 and A[i] // A[j] in SA:\\n C[A[i]] += 2 * C[A[j]] * C[A[i] // A[j]]\\n # print(C)\\n res = sum(C.values())\\n return res % (10**9 + 7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n treeCount = {}\\n\\n for num in A:\\n count = 1\\n for p, pCount in list(treeCount.items()):\\n q, rem = divmod(num, p)\\n if p > q:\\n break\\n if rem == 0 and q in treeCount:\\n count += pCount*treeCount[q] if p == q else 2*pCount*treeCount[q]\\n treeCount[num] = count\\n return sum(treeCount.values()) % (1000_000_000 + 7)\\n\", \"class Solution:\\n def collect(self, lst, st, num, cache):\\n if num in cache:\\n return cache[num]\\n res = 1\\n for n1 in lst:\\n if n1**2 > num:\\n break\\n if num % n1 == 0 and (num // n1) in st:\\n n2 = num // n1\\n res_local = self.collect(lst, st, n1, cache) * self.collect(lst, st, n2, cache)\\n res += res_local\\n if n1 != n2:\\n res += res_local\\n mod = (10**9)+7\\n res = res % mod\\n cache[num] = res\\n return res\\n \\n def solve(self, A): \\n st = set(A)\\n lst = sorted(list(st))\\n res = 0\\n cache = {}\\n mod = (10**9)+7\\n for n in lst:\\n res += self.collect(lst, st, n, cache)\\n return res % mod\\n \\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n return self.solve(A)\", \"import functools as ft\\nimport typing as t\\n\\n\\nclass Solution:\\n \\n BASE = 10 ** 9 + 7\\n \\n def divisor_pairs(self, idx: int) -> List[t.Tuple[int, int]]:\\n num = self.A[idx]\\n left_idx = 0\\n ans = []\\n while self.A[left_idx] ** 2 <= num:\\n left = self.A[left_idx]\\n if num % left == 0:\\n right = num // left\\n if right in self.A_idx:\\n ans.append((left_idx, self.A_idx[right]))\\n left_idx += 1\\n return ans\\n \\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n self.A = sorted(A)\\n self.A_idx = {a: idx for idx, a in enumerate(self.A)}\\n return sum(self.count_binary_trees(idx) for idx in range(len(A))) % self.BASE\\n \\n @ft.lru_cache(None)\\n def count_binary_trees(self, idx: int) -> int:\\n num = self.A[idx]\\n ans = 1 # root only\\n for left_idx, right_idx in self.divisor_pairs(idx):\\n left_cnt = self.count_binary_trees(left_idx)\\n right_cnt = self.count_binary_trees(right_idx)\\n if left_idx == right_idx:\\n total_cnt = left_cnt * right_cnt\\n else:\\n total_cnt = 2 * left_cnt * right_cnt\\n ans += total_cnt\\n return ans\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n d = {}\\n MOD = 1000000007\\n for a in A:\\n d[a] = 1 + sum(d[a//b] * d[b] for b in d if not a%b and a//b in d)\\n #print(d)\\n return sum(d.values()) % MOD\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n mod = 10 ** 9 + 7\\n A.sort()\\n parents = dict()\\n seen = set()\\n for a in A:\\n tot = 1\\n for s in seen:\\n if a % s == 0:\\n b = a // s\\n if b in seen:\\n tot += parents[s] * parents[b]\\n parents[a] = tot\\n seen.add(a)\\n return sum(parents.values()) % mod\\n \\n \\n \\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n # Time complexity: O(N^2)\\n # Space complexity: O(N)\\n # A.sort()\\n # dic = {num: 1 for num in A}\\n # for i in range(1, len(A)):\\n # for j in range(i):\\n # q, res = divmod(A[i], A[j])\\n # if res == 0 and q in dic:\\n # dic[A[i]] += dic[q] * dic[A[j]]\\n\\n # return sum(dic.values()) % (10**9 + 7)\\n\\n\\n dp = {}\\n for a in sorted(A):\\n dp[a] = sum(dp[b] * dp.get(a // b, 0) for b in dp if a % b == 0) + 1\\n return sum(dp.values()) % (10**9 + 7)\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n d = {A[0]:0}\\n dp = [1]*len(A)\\n MOD = 1000000007\\n \\n for i in range(1, len(A)):\\n for j in range(0, i):\\n t = A[i]//A[j]\\n if t< A[j]:\\n break\\n \\n if not A[i] % A[j] and t in d:\\n if A[j] == t:\\n dp[i] += dp[j] * dp[d[t]] \\n else:\\n dp[i] += dp[j] * dp[d[t]] * 2\\n \\n dp[i] %= MOD\\n d[A[i]] = i\\n \\n return sum(dp) % MOD\", \"class Solution:\\n def numFactoredBinaryTrees(self, A):\\n dp = {}\\n for a in sorted(A):\\n dp[a] = sum(dp[b] * dp.get(a / b, 0) for b in dp if a % b == 0) + 1\\n return sum(dp.values()) % (10**9 + 7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n dp = {}\\n for a in sorted(A):\\n dp[a] = sum(dp[b] * dp.get(a / b, 0) for b in dp if a % b == 0) + 1\\n return sum(dp.values()) % (10**9 + 7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n dp = {}\\n for a in sorted(A):\\n dp[a] = sum(dp[b]*dp.get(a/b, 0) for b in dp if(a%b == 0))+1\\n return sum(dp.values())%(10**9+7)\\n \\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n \\n A.sort()\\n A_set = set(A)\\n cache = {}\\n num_trees = 0\\n \\n # Update num trees. \\n for i, n in enumerate(A):\\n \\n # Get factors pairs.\\n factor_pairs = []\\n for j in range(i):\\n if n % A[j] == 0 and n // A[j] in A_set:\\n factor_pairs.append((n // A[j], A[j]))\\n \\n # Compute num_trees.\\n new_trees = 1\\n for factor1, factor2 in factor_pairs:\\n if factor1 != factor2:\\n new_trees += cache[factor1] * cache[factor2] # Each pair is run over twice. \\n elif factor1 == factor2:\\n new_trees += cache[factor1] * cache[factor2]\\n num_trees += new_trees\\n cache[n] = new_trees\\n \\n print(cache) \\n return num_trees % (10 ** 9 + 7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n MOD = 10 ** 9 + 7\\n N = len(A)\\n A.sort()\\n dp = [1] * N\\n index = {x: i for i, x in enumerate(A)}\\n for i, x in enumerate(A):\\n for j in range(i):\\n if x % A[j] == 0: #A[j] will be left child\\n right = x / A[j]\\n if right in index:\\n dp[i] += dp[j] * dp[index[right]]\\n dp[i] %= MOD\\n\\n return sum(dp) % MOD\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n mod = 10**9 + 7\\n A.sort()\\n dp = [1 for _ in range(len(A))]\\n reverse_map = {x: i for i, x in enumerate(A)}\\n\\n\\n for i, x in enumerate(A):\\n for j in range(i):\\n if x % A[j] == 0: #A[j] will be left child\\n right_child = x / A[j]\\n if right_child in reverse_map:\\n dp[i] += dp[j] * dp[reverse_map[right_child]]\\n dp[i] % mod\\n\\n return sum(dp) % mod\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n \\n MOD = int(1e9 + 7)\\n N = len(A)\\n \\n A.sort()\\n dp = [1] * N\\n idx = {ele: i for i, ele in enumerate(A)}\\n \\n for c, rootVal in enumerate(A):\\n for j in range(c):\\n left = A[j]\\n if rootVal % left == 0:\\n right = rootVal / left \\n if right in idx:\\n dp[c] += dp[j] * dp[idx[right]] % MOD\\n \\n return sum(dp) % MOD\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n \\n MOD = int(1e9 + 7)\\n N = len(A)\\n \\n A.sort()\\n dp = [1] * N\\n idx = {ele: i for i, ele in enumerate(A)}\\n \\n for i, rootVal in enumerate(A):\\n for j in range(i):\\n left = A[j]\\n if rootVal % left == 0:\\n right = rootVal / left \\n if right in idx:\\n dp[i] += dp[j] * dp[idx[right]]\\n dp[i] %= MOD\\n \\n return sum(dp) % MOD\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n MOD = 10 ** 9 + 7\\n N = len(A)\\n A.sort()\\n dp = [1] * N\\n index = {x: i for i, x in enumerate(A)}\\n for i, x in enumerate(A):\\n for j in range(i):\\n if x % A[j] == 0: #A[j] will be left child\\n right = x / A[j]\\n if right in index:\\n dp[i] += dp[j] * dp[index[right]]\\n dp[i] %= MOD\\n\\n return sum(dp) % MOD\\n \\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n O = {}\\n for a in A:\\n if a not in O:\\n O[a] = 1\\n for k, v in list(O.items()):\\n if a % k == 0 and a // k in O:\\n O[a] += v * O[a // k]\\n return sum(O.values()) % 1000000007\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n \\n MOD = int(1e9 + 7)\\n N = len(A)\\n \\n A.sort()\\n dp = [1] * N\\n idx = {ele: i for i, ele in enumerate(A)}\\n \\n for i, root_val in enumerate(A):\\n for j in range(i):\\n left = A[j]\\n if root_val % left == 0:\\n right = root_val / left \\n if right in idx:\\n dp[i] += dp[j] * dp[idx[right]]\\n dp[i] %= MOD\\n \\n return sum(dp) % MOD\", \"\\n# 823. Binary Trees With Factors\\n\\nclass Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n \\n MOD = int(1e9 + 7)\\n N = len(A)\\n \\n A.sort()\\n dp = [1] * N\\n idx = {ele: i for i, ele in enumerate(A)}\\n \\n for c, rootVal in enumerate(A):\\n for l in range(c):\\n leftVal = A[l]\\n if rootVal % leftVal == 0:\\n rightVal = rootVal / leftVal \\n if rightVal in idx:\\n dp[c] += dp[l] * dp[idx[rightVal]] % MOD\\n \\n return sum(dp) % MOD\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int: \\n A.sort()\\n numToIdx = {x : i for i, x in enumerate(A)}\\n \\n dp = [1 for _ in range(len(A))]\\n \\n MOD = 10**9 + 7\\n totalSum = 0\\n \\n for i, x in enumerate(A):\\n for j in range(i):\\n y = A[j]\\n if x % y == 0 and x // y in numToIdx:\\n dp[i] += dp[j] * dp[numToIdx[x // y]]\\n \\n totalSum = (totalSum + dp[i]) % MOD\\n \\n return totalSum\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A = sorted(A)\\n N = len(A)\\n dp = [1 for _ in range(N)]\\n index_map = {}\\n for index in range(N):\\n index_map[A[index]] = index\\n \\n for k in range(N):\\n for i in range(k):\\n if A[k] % A[i] == 0:\\n num_to_look = A[k]//A[i]\\n if num_to_look in index_map:\\n j = index_map[num_to_look]\\n dp[k] += dp[i]*dp[j] # okay why is this not giving me the right number?\\n \\n return sum(dp) % (10**9 +7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n factorSet = set(A)\\n A.sort()\\n treeCount = {}\\n\\n for num in A:\\n count = 1\\n for p, pCount in list(treeCount.items()):\\n q, rem = divmod(num, p)\\n if p > q:\\n break\\n if rem == 0 and q in treeCount:\\n tmp = pCount * treeCount[q]\\n count += tmp if p == q else 2*tmp\\n treeCount[num] = count\\n return sum(treeCount.values()) % (1000_000_000 + 7)\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n ret = 0\\n root_value_to_tree_number = collections.defaultdict(int)\\n \\n \\n for i in range(len(A)):\\n occurrences = 1\\n \\n \\n for j in range(i - 1, -1, -1):\\n if (A[i] % A[j] == 0):\\n required_root_value = A[i] // A[j]\\n occurrences += root_value_to_tree_number[required_root_value] * root_value_to_tree_number[A[j]]\\n \\n root_value_to_tree_number[A[i]] = occurrences\\n ret += occurrences\\n \\n return ret % 1000000007 \", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n factors = set(A)\\n A.sort()\\n dp = defaultdict(int)\\n count = 0\\n modulus = 10**9 + 7\\n for i in range(len(A)):\\n dp[A[i]] += 1\\n for j in range(i):\\n if A[i] % A[j] == 0 and (A[i] // A[j]) in factors:\\n dp[A[i]] += dp[A[j]] * dp[A[i] // A[j]]\\n count = (count + dp[A[i]]) % modulus\\n return count\", \"class Solution:\\n def numFactoredBinaryTrees(self, A):\\n MOD = 10 ** 9 + 7\\n n = len(A)\\n A.sort()\\n dp = [1] * n\\n index = {x: i for i, x in enumerate(A)}\\n for i, x in enumerate(A):\\n for j in range(i):\\n if x % A[j] == 0:\\n right = x / A[j]\\n if right in index:\\n dp[i] += dp[j] * dp[index[right]]\\n dp[i] %= MOD\\n\\n return sum(dp) % MOD\", \"import math\\nclass Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n mod = 1000000007\\n dp = [1 for i in range(len(A))]\\n A.sort()\\n val_to_idx = {val: idx for idx, val in enumerate(A)}\\n M = len(A)\\n for i in range(M):\\n for j in range(0, i):\\n \\n if A[i] % A[j] == 0 and A[i]//A[j] in val_to_idx:\\n dp[i] += (dp[j] * dp[val_to_idx[A[i]//A[j]]]) % mod\\n dp[i] = dp[i] % mod\\n print(dp)\\n return sum(dp) % mod\\n \\n \\n \\n \\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n \\n A.sort()\\n dp = {val: 1 for val in A}\\n \\n for i in range(len(A)):\\n for j in range(i):\\n if A[i] % A[j] == 0 and A[i]//A[j] in dp:\\n dp[A[i]] += dp[A[i]//A[j]] * dp[A[j]]\\n \\n return sum(dp[v] for v in dp) % (10 ** 9 + 7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n n = len(A)\\n A.sort()\\n s = {a:i for i,a in enumerate(A)}\\n d = collections.defaultdict(set)\\n for i in range(n):\\n for j in range(i):\\n if A[i] % A[j] == 0:\\n res = A[i] // A[j]\\n if res in s:\\n d[i].add((j, s[res]))\\n \\n @lru_cache(maxsize=None)\\n def dfs(i):\\n nonlocal ans\\n cur = 1\\n for l, r in d[i]:\\n cur += dfs(l) * dfs(r)\\n return cur \\n ans = 0 \\n for i in range(n): \\n val = dfs(i) \\n ans += val\\n return ans % 1000000007\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, x: List[int]) -> int:\\n def f(n):\\n if n in dp:return dp[n]\\n ans=1\\n for i in x:\\n if i>(n**.5):break\\n if n%i==0 and n//i in se:\\n ans+=(1 if n//i==i else 2)*f(i)*f(n//i)\\n dp[n]=ans\\n return ans \\n dp={}\\n x.sort()\\n se=set(x)\\n ans=0\\n for i in x:ans+=f(i)\\n return ans%(10**9+7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n num_trees = {}\\n A.sort()\\n A_set = set(A)\\n for i in range (len(A)):\\n curr_num = A[i]\\n num_trees[curr_num] = 1 \\n for j in range (i):\\n if (A[i] % A[j] == 0):\\n if (A[i] // A[j]) in A_set:\\n num_trees[curr_num] += (num_trees[A[j]] * num_trees[A[i] // A[j]])\\n total = 0\\n for key in num_trees:\\n total += num_trees[key]\\n total %= (10**9 + 7)\\n return total\\n \\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n if not A:\\n return 0\\n\\n A.sort()\\n dp = {}\\n for i in range(len(A)):\\n dp[A[i]] = 1\\n for j in range(i):\\n if A[i] % A[j] == 0 and int(A[i]/A[j]) in dp:\\n dp[A[i]] += dp[A[j]] * dp[A[i]/A[j]]\\n\\n result = 0\\n for key in dp:\\n result += dp[key]\\n\\n return result % (10 ** 9 + 7)\", \"def prodcount(a):\\n dp =defaultdict(int)\\n a.sort()\\n for i in range(0,len(a)):\\n dp[a[i]] = 1\\n for j in range(i):\\n if a[i]%a[j]==0:\\n if a[i]//a[j] == a[j]:\\n dp[a[i]] += (dp[a[j]] *dp[a[i]//a[j]])\\n elif dp[a[i]//a[j]]:\\n dp[a[i]] += (dp[a[j]] *dp[a[i]//a[j]])\\n return sum(dp.values())% (10**9 + 7)\\nclass Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n return prodcount(A)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n memo = {}\\n ans = 0\\n A.sort()\\n \\n for i in range(len(A)):\\n localAns = 1\\n for j in range(i, -1, -1):\\n if A[i] / A[j] in memo:\\n localAns += memo[A[i]/A[j]] * memo[A[j]]\\n ans += localAns\\n memo[A[i]] = localAns\\n return ans % (10 ** 9 + 7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n # https://blog.csdn.net/fuxuemingzhu/article/details/83536814\\n A.sort()\\n dp = {}\\n for i, a in enumerate(A):\\n dp[a] = 1\\n for j in range(i):\\n if a % A[j] == 0 and a / A[j] in dp:\\n dp[a] += dp[A[j]] * dp[a / A[j]]\\n \\n return sum(dp.values()) % (10**9 + 7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, x: List[int]) -> int:\\n def f(n):\\n if n in dp:return dp[n]\\n ans=0\\n for i in x:\\n if i==n:\\n ans+=1\\n break\\n if i>n:break\\n if n%i==0 and n//i in se:\\n ans+=f(i)*f(n//i)\\n dp[n]=ans\\n return ans \\n dp={}\\n x.sort()\\n se=set(x)\\n ans=0\\n for i in x:\\n ans+=f(i)\\n return ans%(10**9+7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n mapping = {x: i for i, x in enumerate(A)}\\n maximal = A[-1]\\n N = len(A)\\n ans, MOD = [1] * N, 10 ** 9 + 7\\n for i in range(N):\\n for j in range(i + 1):\\n if A[i] * A[j] in mapping and A[i] * A[j] <= maximal:\\n if A[i] != A[j]:\\n ans[mapping[A[i] * A[j]]] += 2 * ans[i] * ans[j]\\n else:\\n ans[mapping[A[i] * A[j]]] += ans[i] * ans[j]\\n ans[mapping[A[i] * A[j]]] %= MOD\\n return sum(ans) % MOD\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n ret = 0\\n root_value_to_tree_number = collections.defaultdict(int)\\n \\n \\n for i in range(len(A)):\\n occurrences = 1\\n \\n \\n for j in range(i - 1, -1, -1):\\n if (A[i] % A[j] == 0):\\n required_root_value = A[i] // A[j]\\n occurrences += root_value_to_tree_number[required_root_value] * root_value_to_tree_number[A[j]]\\n \\n root_value_to_tree_number[A[i]] = occurrences\\n ret += occurrences\\n \\n return ret % 1000000007 \", \"class Solution:\\n def numFactoredBinaryTrees(self, x: List[int]) -> int:\\n def f(n):\\n if n in dp:return dp[n]\\n ans=1\\n for i in x:\\n if i>(n**.5):break\\n if n%i==0 and n//i in se:\\n ans+=(1 if n//i==i else 2)*f(i)*f(n//i)\\n dp[n]=ans\\n return ans \\n dp={}\\n x.sort()\\n se=set(x)\\n ans=0\\n for i in x:ans+=f(i)\\n return ans%(10**9+7)\\n\", \"class Solution(object):\\n def numFactoredBinaryTrees(self, A):\\n MOD = 10 ** 9 + 7\\n N = len(A)\\n A.sort()\\n dp = [1] * N\\n index = {x: i for i, x in enumerate(A)}\\n for i, x in enumerate(A):\\n for j in range(i):\\n if x % A[j] == 0: #A[j] will be left child\\n right = x //A[j]\\n if right in index:\\n dp[i] += dp[j] * dp[index[right]]\\n dp[i] %= MOD\\n\\n return sum(dp) % MOD\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n if len(A) <= 1:\\n return len(A)\\n \\n N, MOD = len(A), 10 ** 9 + 7\\n trees = {}\\n ans = 0\\n A.sort()\\n for i in range(N):\\n trees[A[i]] = 1\\n for j in range(i):\\n factor = A[i]/A[j]\\n if not factor.is_integer():\\n continue\\n factor = int(factor)\\n if factor in trees:\\n trees[A[i]] += trees[A[j]]*trees[factor] \\n ans += trees[A[i]] \\n return ans % MOD\\n \\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n dp = {n: 1 for n in A}\\n setA = set(A)\\n for i in range(len(A)): # goal\\n target = A[i]\\n for j in range(0, i): # using this as factor\\n factor = A[j]\\n if target%factor == 0:\\n other_half = target//factor\\n if other_half in setA:\\n dp[target] += dp[other_half] * dp[factor]\\n return sum(dp.values())%(10**9 + 7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n n = len(A)\\n nums = set(A)\\n A = sorted(A)\\n counts = collections.defaultdict(int)\\n mod = 10**9+7\\n res = 0\\n for i, num in enumerate(A):\\n for j in range(i):\\n b, c = A[j], num/A[j]\\n if c in nums:\\n counts[num] += (counts[b]*counts[c])%mod\\n counts[num] += 1\\n res = (res+counts[num])%mod\\n return res\", \"import math\\n\\n\\nclass Solution:\\n @staticmethod\\n def numFactors(num, A_set):\\n factors = set()\\n for a in A_set:\\n if num < a:\\n continue\\n if num % a == 0 and num // a in A_set:\\n factors.add(a)\\n factors.add(num // a)\\n return factors\\n\\n @staticmethod\\n def numFactoredTrees(root, results, A_set):\\n if root in results:\\n return results[root]\\n factors = Solution.numFactors(root, A_set)\\n # tree can only have depth 1 with the root node alone\\n if len(factors) == 0:\\n results[root] = 1\\n return 1\\n # tree can have depth greater than 1\\n n = 1 # depth 1\\n while len(factors) > 0:\\n factor = factors.pop()\\n remainder = root // factor\\n if factor not in results:\\n results[factor] = Solution.numFactoredTrees(factor, results, A_set)\\n if factor == remainder:\\n n += results[factor] * results[factor]\\n else:\\n factors.remove(remainder)\\n if remainder not in results:\\n results[remainder] = Solution.numFactoredTrees(remainder, results, A_set)\\n n += results[factor] * results[remainder] * 2\\n results[root] = n\\n return n\\n\\n def numFactoredBinaryTrees(self, A) -> int:\\n A.sort()\\n A_set = set(A)\\n results = {}\\n return sum([Solution.numFactoredTrees(a, results, A_set) for a in A]) % (10 ** 9 + 7)\\n\\n\", \"import math\\n\\n\\nclass Solution:\\n @staticmethod\\n def numFactors(num, A_set):\\n factors = set()\\n for a in A_set:\\n if num % a == 0 and num // a in A_set:\\n factors.add(a)\\n factors.add(num // a)\\n return factors\\n\\n @staticmethod\\n def numFactoredTrees(root, results, A_set):\\n if root in results:\\n return results[root]\\n factors = Solution.numFactors(root, A_set)\\n # tree can only have depth 1 with the root node alone\\n if len(factors) == 0:\\n results[root] = 1\\n return 1\\n # tree can have depth greater than 1\\n n = 1 # depth 1\\n while len(factors) > 0:\\n factor = factors.pop()\\n remainder = root // factor\\n if factor not in results:\\n results[factor] = Solution.numFactoredTrees(factor, results, A_set)\\n if factor == remainder:\\n n += results[factor] * results[factor]\\n else:\\n factors.remove(remainder)\\n if remainder not in results:\\n results[remainder] = Solution.numFactoredTrees(remainder, results, A_set)\\n n += results[factor] * results[remainder] * 2\\n results[root] = n\\n return n\\n\\n def numFactoredBinaryTrees(self, A) -> int:\\n #A.sort()\\n A_set = set(A)\\n results = {}\\n return sum([Solution.numFactoredTrees(a, results, A_set) for a in A]) % (10 ** 9 + 7)\\n\\n\", \"import math\\n\\n\\nclass Solution:\\n @staticmethod\\n def numFactors(num, A_set):\\n factors = set()\\n for a in A_set:\\n if num % a == 0 and num // a in A_set:\\n factors.add(a)\\n factors.add(num // a)\\n return factors\\n\\n @staticmethod\\n def numFactoredTrees(root, results, A_set):\\n if root in results:\\n return results[root]\\n factors = Solution.numFactors(root, A_set)\\n # tree can only have depth 1 with the root node alone\\n if len(factors) == 0:\\n results[root] = 1\\n return 1\\n # tree can have depth greater than 1\\n n = 1 # depth 1\\n while len(factors) > 0:\\n factor = factors.pop()\\n remainder = root // factor\\n if factor not in results:\\n results[factor] = Solution.numFactoredTrees(factor, results, A_set)\\n if factor == remainder:\\n n += results[factor] * results[factor]\\n else:\\n factors.remove(remainder)\\n if remainder not in results:\\n results[remainder] = Solution.numFactoredTrees(remainder, results, A_set)\\n n += results[factor] * results[remainder] * 2\\n results[root] = n\\n return n\\n\\n def numFactoredBinaryTrees(self, A) -> int:\\n A.sort()\\n A_set = set(A)\\n results = {}\\n return sum([Solution.numFactoredTrees(a, results, A_set) for a in A]) % (10 ** 9 + 7)\\n\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A = sorted(A)\\n n = len(A)\\n dict_num = {}\\n for num in A:\\n dict_num[num] = True\\n dp_dict = {}\\n factor_pair = []\\n for i in range(n):\\n factor_pair.append([])\\n \\n for i in range(n):\\n for j in range(i):\\n if(A[i] % A[j] == 0 and A[i]//A[j] in dict_num):\\n factor_pair[i].append((A[j], A[i]//A[j]))\\n # print(factor_pair)\\n for i in range(n):\\n root = A[i]\\n num_trees = 1\\n for a, b in factor_pair[i]:\\n num_trees += dp_dict[a]*dp_dict[b]\\n \\n dp_dict[root] = num_trees\\n \\n answer = 0\\n for key in dp_dict:\\n answer += dp_dict[key]\\n \\n return answer % (10**9+7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n O = {}\\n ans = 0\\n for a in A:\\n if a not in O:\\n O[a] = 1\\n for k, v in list(O.items()):\\n if a % k == 0 and a // k in O:\\n O[a] += v * O[a // k]\\n ans += O[a]\\n return ans % 1000000007\\n\", \"\\n \\nclass Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n MOD = 10 ** 9 + 7\\n \\n n = len(A)\\n tips = sorted(A)\\n \\n \\n index = { x: i for i, x in enumerate(tips) }\\n d = [1] * n\\n \\n for i, x in enumerate(tips):\\n head = x\\n\\n for j in range(i):\\n x = tips[j]\\n \\n y = head // x\\n \\n if y*x != head:\\n continue\\n if y in index:\\n leaf_1 = j\\n leaf_2 = index[y]\\n d[i] = d[i] + (d[leaf_1] * d[leaf_2])\\n \\n return sum(d) % MOD\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n n = len(A)\\n dp = defaultdict(int)\\n res = 0\\n for i, num in enumerate(A):\\n dp[num] = 1\\n for j in range(i):\\n if num % A[j] == 0:\\n dp[num] += dp[A[j]] * dp[A[i]//A[j]]\\n res += dp[num]\\n return res % 1000000007\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n seen,A={},set(A)\\n def find_all(root):\\n if root in seen:\\n return seen[root]\\n combs=1\\n for left in A:\\n if root==left or root%left: continue\\n right=root//left\\n if right not in A: continue\\n combs+=find_all(left)*find_all(right)\\n seen[root]=combs\\n return combs\\n return sum(find_all(num) for num in sorted(A))%1000000007\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n mod = 10**9 + 7\\n processed = dict()\\n res = 0\\n for a in sorted(A):\\n counter = 1\\n for key, val in list(processed.items()):\\n key2 = a / key\\n val2 = processed.get(key2, 0)\\n if val2 != 0:\\n counter = (counter + val * val2) % mod\\n processed[a] = counter\\n res = (res + counter) % mod\\n return res\\n \\n \\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n n=len(A)\\n A.sort()\\n dp=[1]*n\\n mod=10**9+7\\n index={c:i for i,c in enumerate(A) }\\n \\n for i,x in enumerate(A):\\n for j in range(n):\\n if x%A[j]==0:\\n right=x/A[j]\\n if right in index:\\n dp[i]+=dp[j]*dp[index[right]]\\n dp[i]=dp[i]%mod\\n return sum(dp)%mod\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n factorSet = set(A)\\n A.sort()\\n treeCount = {}\\n\\n for num in A:\\n count = 1\\n for p, pCount in list(treeCount.items()):\\n q, rem = divmod(num, p)\\n if p > q:\\n break\\n if rem == 0 and q in treeCount:\\n count += pCount*treeCount[q] if p == q else 2*pCount*treeCount[q]\\n treeCount[num] = count\\n return sum(treeCount.values()) % (1000_000_000 + 7)\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n seen,A={},set(A)\\n def find_all(root):\\n if root in seen:\\n return seen[root]\\n combs=1\\n for left in A:\\n if root==left or root%left: continue\\n right=root//left\\n if right not in A: continue\\n combs+=find_all(left)*find_all(right)\\n seen[root]=combs\\n return combs\\n return sum(find_all(num) for num in A)%1000000007\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n dp = {i:1 for i in A}\\n res = 0\\n for idd, number in enumerate(A):\\n \\n for inner, inumber in enumerate(A[:idd]):\\n if number % inumber == 0 and ((number // inumber) in dp):\\n dp[number] += dp[inumber] * dp[number // inumber]\\n \\n res += dp[number]\\n res = res % (10 ** 9 + 7)\\n \\n return res\\n\", \"# 823. Binary Trees With Factors\\n\\nMOD = 10**9 + 7\\n\\ndef count_binary_trees (arr):\\n arr = sorted (arr)\\n coll = set (arr)\\n\\n count = {}\\n\\n for index, elem in enumerate (arr):\\n ans = 1\\n for i in range (index):\\n factor = arr[i]\\n if elem % factor == 0 and elem // factor in coll:\\n other_factor = elem // factor\\n ans = (ans + count[factor] * count[other_factor]) % MOD\\n\\n count[elem] = ans\\n\\n return sum (y for (x, y) in count.items ()) % MOD\\n\\nclass Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n return count_binary_trees(A)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A = sorted(A)\\n mems = {}\\n for ix in range(len(A)):\\n mems[A[ix]] = ix\\n \\n dp = [1] * len(A)\\n \\n big_mod = 10**9 + 7\\n \\n for i in range(len(A)):\\n extras = 0\\n for j in range(i):\\n d, mo = divmod(A[i], A[j])\\n if mo == 0:\\n if d in mems:\\n extras += dp[j] * dp[mems[d]]\\n extras = extras % big_mod\\n\\n dp[i] += extras\\n \\n result = sum(dp) % big_mod\\n \\n return result\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n # Time complexity: O(N^2)\\n # Space complexity: O(N)\\n A.sort()\\n dic = {num: 1 for num in A}\\n for i in range(1, len(A)):\\n for j in range(i):\\n q, res = divmod(A[i], A[j])\\n if res == 0 and q in dic:\\n dic[A[i]] += dic[q] * dic[A[j]]\\n\\n return sum(dic.values()) % (10**9 + 7)\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A = sorted(A)\\n mems = {}\\n for ix in range(len(A)):\\n mems[A[ix]] = ix\\n \\n dp = [1] * len(A)\\n \\n big_mod = 10**9 + 7\\n \\n for i in range(len(A)):\\n extras = 0\\n for j in range(i):\\n d, mo = divmod(A[i], A[j])\\n if mo == 0:\\n if d in mems:\\n extras += dp[j] * dp[mems[d]]\\n\\n extras = extras % big_mod\\n dp[i] += extras\\n \\n result = sum(dp) % big_mod\\n \\n return result\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n dp = {}\\n mod = 10**9+7\\n for a in A:\\n dp[a] = 1\\n for b in A:\\n if a%b==0 and b in dp and a//b in dp:\\n dp[a] += dp[b]*dp[a//b]\\n dp[a] %= mod\\n \\n return sum(dp.values())%mod\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n sorted_A = sorted(A)\\n dp = dict()\\n result = 0\\n \\n for i in range(len(sorted_A)):\\n cur_total = 0\\n for j in range(i + 1):\\n cur_val = sorted_A[i]\\n prev_val = sorted_A[j]\\n if i == j:\\n dp[cur_val] = cur_total + 1\\n result += cur_total + 1\\n elif (cur_val / prev_val) in dp:\\n cur_total += dp[cur_val/prev_val] * dp[prev_val]\\n \\n return result % (10 ** 9 + 7)\\n \\n '''\\n \\n \\n [18, 3, 6, 2]\\n [2, 3, 6, 18]\\n dp = {\\n 2 : 1\\n 3 : 1\\n 6 : 3\\n 18: 5\\n }\\n cur_val = 18\\n prev_val = 6\\n cur_total = 3 + 1 \\n result = 1 + 1 + 3 + 5\\n \\n \\n ''' \\n \\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n dp = {}\\n for a in sorted(A):\\n dp[a] = sum(dp[b] * dp.get(a/b, 0) for b in dp) + 1\\n return sum(dp.values()) % (10**9 + 7)\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n ans = 0\\n N = len(A)\\n cnt = [1 for _ in range(N)]\\n for i, n in enumerate(A):\\n l, r = 0, i - 1\\n while r >= l:\\n if A[r] * A[l] == n:\\n cnt[i] += cnt[r] * cnt[l] if r == l else cnt[r] * cnt[l] * 2\\n l += 1\\n r -= 1\\n elif A[r] * A[l] > n:\\n r -= 1\\n else:\\n l += 1\\n ans += cnt[i]\\n return ans % (10 ** 9 + 7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n factorSet = set(A)\\n A.sort()\\n treeCount = {}\\n\\n for num in A:\\n count = 1\\n for p, pCount in list(treeCount.items()):\\n q, rem = divmod(num, p)\\n if rem == 0:\\n count += pCount * treeCount.get(q, 0) \\n treeCount[num] = count\\n return sum(treeCount.values()) % (1000_000_000 + 7)\\n\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n t = {}\\n for a in A:\\n t[a] = 1 + sum(t[b] * t.get(a / b, 0) for b in A if b < a)\\n return sum(t.values()) % (pow(10, 9) + 7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n t = {}\\n for a in sorted(A):\\n t[a] = 1 + sum(t[b] * t.get(a/b, 0) for b in A if b < a)\\n return sum(t.values()) % (10**9 + 7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A): \\n \\n\\n t = {}\\n for a in sorted(A):\\n t[a] = 1 + sum(t[b] * t.get(a/b, 0) for b in A if b < a)\\n return sum(t.values()) % (10**9 + 7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n mymap = {}\\n for x in sorted(A):\\n # 1 for leaf, plus sum any that could be factors (y and currval/y)\\n mymap[x] = 1+ sum(mymap[y]*mymap.get(x/y,0) for y in A if y<x)\\n return sum(mymap.values())%(10**9+7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n n=len(A)\\n dp=[1 for i in range(n)]\\n for i in range(n):\\n start,end=0,i-1\\n while(start<=end):\\n if A[start]*A[end]<A[i]:\\n start+=1\\n continue\\n if A[start]*A[end]>A[i]:\\n end-=1\\n continue\\n if start==end: \\n dp[i]+=dp[start]*dp[end]\\n else:\\n dp[i]+=dp[start]*dp[end]*2\\n start+=1\\n end-=1\\n # print(dp)\\n return sum(dp)%(10**9+7)\", \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n n = len(A)\\n A.sort()\\n dp = [1] * n\\n res = 0\\n for i in range(n):\\n s = 0\\n e = i - 1\\n for s in range(i):\\n while s <= e and A[s] * A[e] > A[i]:\\n e -= 1\\n \\n if s > e:\\n break\\n \\n if A[s] * A[e] == A[i]:\\n dp[i] += ((dp[s] * dp[e] * 2) if s != e else (dp[s] * dp[e]))\\n dp[i] = dp[i] % (10 ** 9 + 7)\\n e -= 1\\n \\n res += dp[i]\\n res = res % (10 ** 9 + 7)\\n \\n return res\\n \\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"numFactoredBinaryTrees\", \"inputs\": [[[2, 4]]], \"outputs\": [3]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/binary-trees-with-factors/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n \n mod = 10**9 + 7\n\n nums_set = set(A)\n nums = A.copy()\n nums.sort()\n counts = {}\n total = 0\n\n for n in nums:\n n_count = 1\n for d in nums:\n if d * d > n:\n break\n if n % d != 0:\n continue\n e = n // d\n if e not in nums_set:\n continue\n\n subtrees = (counts[d] * counts[e]) % mod\n if d != e:\n subtrees = (subtrees * 2) % mod\n n_count = (n_count + subtrees) % mod\n counts[n] = n_count % mod\n total = (total + n_count) % mod\n\n return total\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n factorSet = set(A)\n A.sort()\n treeCount = collections.defaultdict(lambda : 1)\n \n n = len(A)\n end = 0\n for num in A:\n sqrt = int(math.sqrt(num)+1)\n while end < n and A[end] <= sqrt:\n end += 1\n count = 0\n for _, p in zip(list(range(end)), A):\n if num % p == 0 and (q := num // p) in factorSet and p <= q:\n count += 2*treeCount[p]*treeCount[q] if p != q else treeCount[p]*treeCount[q]\n treeCount[num] += count\n return sum(treeCount.values()) % (1000_000_000 + 7)\n \n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n factorSet = set(A)\n A.sort()\n treeCount = {}\n\n for num in A:\n count = 1\n for p, pCount in list(treeCount.items()):\n q, rem = divmod(num, p)\n if p > q:\n break\n if rem == 0:\n tmp = pCount * treeCount.get(q, 0)\n count += tmp if p == q else 2*tmp\n treeCount[num] = count\n return sum(treeCount.values()) % (1000_000_000 + 7)\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n dp = {}\n res = 0\n for i in range(len(A)):\n dp[A[i]] = 1\n for j in range(i):\n if A[j] * A[j] == A[i]:\n dp[A[i]] += dp[A[j]] * dp[A[j]]\n dp[A[i]] %= 1000_000_007\n elif A[j] * A[j] > A[i] and A[i] % A[j] == 0:\n dp[A[i]] += dp[A[j]] * dp.get(A[i] // A[j], 0) * 2\n dp[A[i]] %= 1000_000_007\n res = sum([v for _, v in dp.items()])\n res %= 1000_000_007\n return res","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n dp = {}\n res = 0\n for i in range(len(A)):\n dp[A[i]] = 1\n for j in range(i):\n if A[j] * A[j] == A[i]:\n dp[A[i]] += dp[A[j]] * dp[A[j]]\n dp[A[i]] %= 1000_000_007\n elif A[j] * A[j] > A[i]:\n div = A[i] // A[j]\n if div * A[j] == A[i] and div in dp:\n dp[A[i]] += dp[A[j]] * dp[div] * 2\n dp[A[i]] %= 1000_000_007\n res += dp[A[i]]\n res %= 1000_000_007\n return res","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n dp = {}\n res = 0\n for i in range(len(A)):\n dp[A[i]] = 1\n for j in range(i):\n if A[j] * A[j] == A[i]:\n dp[A[i]] += dp[A[j]] * dp[A[j]]\n dp[A[i]] %= 1000_000_007\n elif A[j] * A[j] > A[i] and A[i] % A[j] == 0:\n dp[A[i]] += dp[A[j]] * dp.get(A[i] // A[j], 0) * 2\n dp[A[i]] %= 1000_000_007\n res += dp[A[i]]\n res %= 1000_000_007\n return res","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n cache = dict()\n iSet = set(A)\n def helper(i):\n if i not in cache:\n count = 1\n for j in range(len(A)):\n if i != A[j] and i % A[j] == 0:\n if i//A[j] in iSet:\n count += helper(A[j]) * helper(i//A[j])\n cache[i] = count\n return cache[i]\n ans = 0\n for i in range(len(A)):\n ans += helper(A[i])\n return ans % 1000000007\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A=sorted(A)\n res=dict()\n for idx, a in enumerate(A):\n if idx==0:\n res[a]=1\n else:\n res[a]=1\n for j in range(idx):\n if (a%A[j]==0) and (a//A[j] in A):\n res[a]+=res[A[j]]*res[a//A[j]]\n return sum(res.values())%(10**9+7)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n \n A.sort()\n \n dp = [1 for _ in range(len(A))]\n \n for i in range(len(A)):\n \n for j in range(i):\n \n time, remain = divmod(A[i], A[j])\n\n if remain == 0 and time in A:\n\n dp[i] += (dp[j] * dp[A.index(time)])\n \n return sum(dp) % (10**9 + 7)\n \n \n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n d = {}\n Aset = set(A)\n A.sort()\n ans = 0\n for i in range(len(A)):\n d[A[i]] = 1\n for j in range(i):\n if A[i]%A[j] == 0:\n k = A[i]//A[j]\n if k in set(A):\n d[A[i]] += d[A[j]]*d[k]\n d[A[i]] %= 10**9+7\n ans += d[A[i]]\n ans %= 10**9+7\n # print(d)\n return ans\n # return sum(d[key] for key in d)\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n d = {}\n Aset = set(A)\n A.sort()\n ans = 0\n for i in range(len(A)):\n d[A[i]] = 1\n for j in range(i):\n if A[i]%A[j] == 0:\n k = A[i]//A[j]\n if k == A[j]:\n d[A[i]] += d[A[j]]*d[A[j]]\n elif k in set(A):\n d[A[i]] += d[A[j]]*d[k]\n ans += d[A[i]]\n ans %= 10**9+7\n # print(d)\n return ans\n # return sum(d[key] for key in d)\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n d = {}\n Aset = set(A)\n A.sort()\n ans = 0\n for i in range(len(A)):\n d[A[i]] = 1\n for j in range(i):\n if A[i]%A[j] == 0:\n k = A[i]//A[j]\n if k in set(A):\n d[A[i]] += d[A[j]]*d[k]\n d[A[i]] %= 10**9+7\n ans += d[A[i]]\n ans %= 10**9+7\n return ans\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n SA = set(A)\n A = sorted(SA)\n C = {}\n for x in A:\n C[x] = 1\n for i, x in enumerate(A):\n for j in range(i):\n if A[j] * A[j] > A[i]:\n break\n elif A[j] * A[j] == A[i]:\n C[A[i]] += C[A[j]] * C[A[j]]\n elif A[i] % A[j] == 0 and A[i] // A[j] in SA:\n C[A[i]] += 2 * C[A[j]] * C[A[i] // A[j]]\n # print(C)\n res = sum(C.values())\n return res % (10**9 + 7)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n treeCount = {}\n\n for num in A:\n count = 1\n for p, pCount in list(treeCount.items()):\n q, rem = divmod(num, p)\n if p > q:\n break\n if rem == 0 and q in treeCount:\n count += pCount*treeCount[q] if p == q else 2*pCount*treeCount[q]\n treeCount[num] = count\n return sum(treeCount.values()) % (1000_000_000 + 7)\n","class Solution:\n def collect(self, lst, st, num, cache):\n if num in cache:\n return cache[num]\n res = 1\n for n1 in lst:\n if n1**2 > num:\n break\n if num % n1 == 0 and (num // n1) in st:\n n2 = num // n1\n res_local = self.collect(lst, st, n1, cache) * self.collect(lst, st, n2, cache)\n res += res_local\n if n1 != n2:\n res += res_local\n mod = (10**9)+7\n res = res % mod\n cache[num] = res\n return res\n \n def solve(self, A): \n st = set(A)\n lst = sorted(list(st))\n res = 0\n cache = {}\n mod = (10**9)+7\n for n in lst:\n res += self.collect(lst, st, n, cache)\n return res % mod\n \n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n return self.solve(A)","import functools as ft\nimport typing as t\n\n\nclass Solution:\n \n BASE = 10 ** 9 + 7\n \n def divisor_pairs(self, idx: int) -> List[t.Tuple[int, int]]:\n num = self.A[idx]\n left_idx = 0\n ans = []\n while self.A[left_idx] ** 2 <= num:\n left = self.A[left_idx]\n if num % left == 0:\n right = num // left\n if right in self.A_idx:\n ans.append((left_idx, self.A_idx[right]))\n left_idx += 1\n return ans\n \n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n self.A = sorted(A)\n self.A_idx = {a: idx for idx, a in enumerate(self.A)}\n return sum(self.count_binary_trees(idx) for idx in range(len(A))) % self.BASE\n \n @ft.lru_cache(None)\n def count_binary_trees(self, idx: int) -> int:\n num = self.A[idx]\n ans = 1 # root only\n for left_idx, right_idx in self.divisor_pairs(idx):\n left_cnt = self.count_binary_trees(left_idx)\n right_cnt = self.count_binary_trees(right_idx)\n if left_idx == right_idx:\n total_cnt = left_cnt * right_cnt\n else:\n total_cnt = 2 * left_cnt * right_cnt\n ans += total_cnt\n return ans","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n d = {}\n MOD = 1000000007\n for a in A:\n d[a] = 1 + sum(d[a//b] * d[b] for b in d if not a%b and a//b in d)\n #print(d)\n return sum(d.values()) % MOD","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n mod = 10 ** 9 + 7\n A.sort()\n parents = dict()\n seen = set()\n for a in A:\n tot = 1\n for s in seen:\n if a % s == 0:\n b = a // s\n if b in seen:\n tot += parents[s] * parents[b]\n parents[a] = tot\n seen.add(a)\n return sum(parents.values()) % mod\n \n \n \n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n # Time complexity: O(N^2)\n # Space complexity: O(N)\n # A.sort()\n # dic = {num: 1 for num in A}\n # for i in range(1, len(A)):\n # for j in range(i):\n # q, res = divmod(A[i], A[j])\n # if res == 0 and q in dic:\n # dic[A[i]] += dic[q] * dic[A[j]]\n\n # return sum(dic.values()) % (10**9 + 7)\n\n\n dp = {}\n for a in sorted(A):\n dp[a] = sum(dp[b] * dp.get(a // b, 0) for b in dp if a % b == 0) + 1\n return sum(dp.values()) % (10**9 + 7)\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n d = {A[0]:0}\n dp = [1]*len(A)\n MOD = 1000000007\n \n for i in range(1, len(A)):\n for j in range(0, i):\n t = A[i]//A[j]\n if t< A[j]:\n break\n \n if not A[i] % A[j] and t in d:\n if A[j] == t:\n dp[i] += dp[j] * dp[d[t]] \n else:\n dp[i] += dp[j] * dp[d[t]] * 2\n \n dp[i] %= MOD\n d[A[i]] = i\n \n return sum(dp) % MOD","class Solution:\n def numFactoredBinaryTrees(self, A):\n dp = {}\n for a in sorted(A):\n dp[a] = sum(dp[b] * dp.get(a / b, 0) for b in dp if a % b == 0) + 1\n return sum(dp.values()) % (10**9 + 7)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n dp = {}\n for a in sorted(A):\n dp[a] = sum(dp[b] * dp.get(a / b, 0) for b in dp if a % b == 0) + 1\n return sum(dp.values()) % (10**9 + 7)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n dp = {}\n for a in sorted(A):\n dp[a] = sum(dp[b]*dp.get(a/b, 0) for b in dp if(a%b == 0))+1\n return sum(dp.values())%(10**9+7)\n \n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n \n A.sort()\n A_set = set(A)\n cache = {}\n num_trees = 0\n \n # Update num trees. \n for i, n in enumerate(A):\n \n # Get factors pairs.\n factor_pairs = []\n for j in range(i):\n if n % A[j] == 0 and n // A[j] in A_set:\n factor_pairs.append((n // A[j], A[j]))\n \n # Compute num_trees.\n new_trees = 1\n for factor1, factor2 in factor_pairs:\n if factor1 != factor2:\n new_trees += cache[factor1] * cache[factor2] # Each pair is run over twice. \n elif factor1 == factor2:\n new_trees += cache[factor1] * cache[factor2]\n num_trees += new_trees\n cache[n] = new_trees\n \n print(cache) \n return num_trees % (10 ** 9 + 7)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n MOD = 10 ** 9 + 7\n N = len(A)\n A.sort()\n dp = [1] * N\n index = {x: i for i, x in enumerate(A)}\n for i, x in enumerate(A):\n for j in range(i):\n if x % A[j] == 0: #A[j] will be left child\n right = x / A[j]\n if right in index:\n dp[i] += dp[j] * dp[index[right]]\n dp[i] %= MOD\n\n return sum(dp) % MOD","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n mod = 10**9 + 7\n A.sort()\n dp = [1 for _ in range(len(A))]\n reverse_map = {x: i for i, x in enumerate(A)}\n\n\n for i, x in enumerate(A):\n for j in range(i):\n if x % A[j] == 0: #A[j] will be left child\n right_child = x / A[j]\n if right_child in reverse_map:\n dp[i] += dp[j] * dp[reverse_map[right_child]]\n dp[i] % mod\n\n return sum(dp) % mod","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n \n MOD = int(1e9 + 7)\n N = len(A)\n \n A.sort()\n dp = [1] * N\n idx = {ele: i for i, ele in enumerate(A)}\n \n for c, rootVal in enumerate(A):\n for j in range(c):\n left = A[j]\n if rootVal % left == 0:\n right = rootVal / left \n if right in idx:\n dp[c] += dp[j] * dp[idx[right]] % MOD\n \n return sum(dp) % MOD\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n \n MOD = int(1e9 + 7)\n N = len(A)\n \n A.sort()\n dp = [1] * N\n idx = {ele: i for i, ele in enumerate(A)}\n \n for i, rootVal in enumerate(A):\n for j in range(i):\n left = A[j]\n if rootVal % left == 0:\n right = rootVal / left \n if right in idx:\n dp[i] += dp[j] * dp[idx[right]]\n dp[i] %= MOD\n \n return sum(dp) % MOD","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n MOD = 10 ** 9 + 7\n N = len(A)\n A.sort()\n dp = [1] * N\n index = {x: i for i, x in enumerate(A)}\n for i, x in enumerate(A):\n for j in range(i):\n if x % A[j] == 0: #A[j] will be left child\n right = x / A[j]\n if right in index:\n dp[i] += dp[j] * dp[index[right]]\n dp[i] %= MOD\n\n return sum(dp) % MOD\n \n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n O = {}\n for a in A:\n if a not in O:\n O[a] = 1\n for k, v in list(O.items()):\n if a % k == 0 and a // k in O:\n O[a] += v * O[a // k]\n return sum(O.values()) % 1000000007\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n \n MOD = int(1e9 + 7)\n N = len(A)\n \n A.sort()\n dp = [1] * N\n idx = {ele: i for i, ele in enumerate(A)}\n \n for i, root_val in enumerate(A):\n for j in range(i):\n left = A[j]\n if root_val % left == 0:\n right = root_val / left \n if right in idx:\n dp[i] += dp[j] * dp[idx[right]]\n dp[i] %= MOD\n \n return sum(dp) % MOD","\n# 823. Binary Trees With Factors\n\nclass Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n \n MOD = int(1e9 + 7)\n N = len(A)\n \n A.sort()\n dp = [1] * N\n idx = {ele: i for i, ele in enumerate(A)}\n \n for c, rootVal in enumerate(A):\n for l in range(c):\n leftVal = A[l]\n if rootVal % leftVal == 0:\n rightVal = rootVal / leftVal \n if rightVal in idx:\n dp[c] += dp[l] * dp[idx[rightVal]] % MOD\n \n return sum(dp) % MOD\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int: \n A.sort()\n numToIdx = {x : i for i, x in enumerate(A)}\n \n dp = [1 for _ in range(len(A))]\n \n MOD = 10**9 + 7\n totalSum = 0\n \n for i, x in enumerate(A):\n for j in range(i):\n y = A[j]\n if x % y == 0 and x // y in numToIdx:\n dp[i] += dp[j] * dp[numToIdx[x // y]]\n \n totalSum = (totalSum + dp[i]) % MOD\n \n return totalSum","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A = sorted(A)\n N = len(A)\n dp = [1 for _ in range(N)]\n index_map = {}\n for index in range(N):\n index_map[A[index]] = index\n \n for k in range(N):\n for i in range(k):\n if A[k] % A[i] == 0:\n num_to_look = A[k]//A[i]\n if num_to_look in index_map:\n j = index_map[num_to_look]\n dp[k] += dp[i]*dp[j] # okay why is this not giving me the right number?\n \n return sum(dp) % (10**9 +7)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n factorSet = set(A)\n A.sort()\n treeCount = {}\n\n for num in A:\n count = 1\n for p, pCount in list(treeCount.items()):\n q, rem = divmod(num, p)\n if p > q:\n break\n if rem == 0 and q in treeCount:\n tmp = pCount * treeCount[q]\n count += tmp if p == q else 2*tmp\n treeCount[num] = count\n return sum(treeCount.values()) % (1000_000_000 + 7)\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n ret = 0\n root_value_to_tree_number = collections.defaultdict(int)\n \n \n for i in range(len(A)):\n occurrences = 1\n \n \n for j in range(i - 1, -1, -1):\n if (A[i] % A[j] == 0):\n required_root_value = A[i] // A[j]\n occurrences += root_value_to_tree_number[required_root_value] * root_value_to_tree_number[A[j]]\n \n root_value_to_tree_number[A[i]] = occurrences\n ret += occurrences\n \n return ret % 1000000007 ","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n factors = set(A)\n A.sort()\n dp = defaultdict(int)\n count = 0\n modulus = 10**9 + 7\n for i in range(len(A)):\n dp[A[i]] += 1\n for j in range(i):\n if A[i] % A[j] == 0 and (A[i] // A[j]) in factors:\n dp[A[i]] += dp[A[j]] * dp[A[i] // A[j]]\n count = (count + dp[A[i]]) % modulus\n return count","class Solution:\n def numFactoredBinaryTrees(self, A):\n MOD = 10 ** 9 + 7\n n = len(A)\n A.sort()\n dp = [1] * n\n index = {x: i for i, x in enumerate(A)}\n for i, x in enumerate(A):\n for j in range(i):\n if x % A[j] == 0:\n right = x / A[j]\n if right in index:\n dp[i] += dp[j] * dp[index[right]]\n dp[i] %= MOD\n\n return sum(dp) % MOD","import math\nclass Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n mod = 1000000007\n dp = [1 for i in range(len(A))]\n A.sort()\n val_to_idx = {val: idx for idx, val in enumerate(A)}\n M = len(A)\n for i in range(M):\n for j in range(0, i):\n \n if A[i] % A[j] == 0 and A[i]//A[j] in val_to_idx:\n dp[i] += (dp[j] * dp[val_to_idx[A[i]//A[j]]]) % mod\n dp[i] = dp[i] % mod\n print(dp)\n return sum(dp) % mod\n \n \n \n \n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n \n A.sort()\n dp = {val: 1 for val in A}\n \n for i in range(len(A)):\n for j in range(i):\n if A[i] % A[j] == 0 and A[i]//A[j] in dp:\n dp[A[i]] += dp[A[i]//A[j]] * dp[A[j]]\n \n return sum(dp[v] for v in dp) % (10 ** 9 + 7)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n n = len(A)\n A.sort()\n s = {a:i for i,a in enumerate(A)}\n d = collections.defaultdict(set)\n for i in range(n):\n for j in range(i):\n if A[i] % A[j] == 0:\n res = A[i] // A[j]\n if res in s:\n d[i].add((j, s[res]))\n \n @lru_cache(maxsize=None)\n def dfs(i):\n nonlocal ans\n cur = 1\n for l, r in d[i]:\n cur += dfs(l) * dfs(r)\n return cur \n ans = 0 \n for i in range(n): \n val = dfs(i) \n ans += val\n return ans % 1000000007\n","class Solution:\n def numFactoredBinaryTrees(self, x: List[int]) -> int:\n def f(n):\n if n in dp:return dp[n]\n ans=1\n for i in x:\n if i>(n**.5):break\n if n%i==0 and n//i in se:\n ans+=(1 if n//i==i else 2)*f(i)*f(n//i)\n dp[n]=ans\n return ans \n dp={}\n x.sort()\n se=set(x)\n ans=0\n for i in x:ans+=f(i)\n return ans%(10**9+7)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n num_trees = {}\n A.sort()\n A_set = set(A)\n for i in range (len(A)):\n curr_num = A[i]\n num_trees[curr_num] = 1 \n for j in range (i):\n if (A[i] % A[j] == 0):\n if (A[i] // A[j]) in A_set:\n num_trees[curr_num] += (num_trees[A[j]] * num_trees[A[i] // A[j]])\n total = 0\n for key in num_trees:\n total += num_trees[key]\n total %= (10**9 + 7)\n return total\n \n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n if not A:\n return 0\n\n A.sort()\n dp = {}\n for i in range(len(A)):\n dp[A[i]] = 1\n for j in range(i):\n if A[i] % A[j] == 0 and int(A[i]/A[j]) in dp:\n dp[A[i]] += dp[A[j]] * dp[A[i]/A[j]]\n\n result = 0\n for key in dp:\n result += dp[key]\n\n return result % (10 ** 9 + 7)","def prodcount(a):\n dp =defaultdict(int)\n a.sort()\n for i in range(0,len(a)):\n dp[a[i]] = 1\n for j in range(i):\n if a[i]%a[j]==0:\n if a[i]//a[j] == a[j]:\n dp[a[i]] += (dp[a[j]] *dp[a[i]//a[j]])\n elif dp[a[i]//a[j]]:\n dp[a[i]] += (dp[a[j]] *dp[a[i]//a[j]])\n return sum(dp.values())% (10**9 + 7)\nclass Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n return prodcount(A)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n memo = {}\n ans = 0\n A.sort()\n \n for i in range(len(A)):\n localAns = 1\n for j in range(i, -1, -1):\n if A[i] / A[j] in memo:\n localAns += memo[A[i]/A[j]] * memo[A[j]]\n ans += localAns\n memo[A[i]] = localAns\n return ans % (10 ** 9 + 7)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n # https://blog.csdn.net/fuxuemingzhu/article/details/83536814\n A.sort()\n dp = {}\n for i, a in enumerate(A):\n dp[a] = 1\n for j in range(i):\n if a % A[j] == 0 and a / A[j] in dp:\n dp[a] += dp[A[j]] * dp[a / A[j]]\n \n return sum(dp.values()) % (10**9 + 7)","class Solution:\n def numFactoredBinaryTrees(self, x: List[int]) -> int:\n def f(n):\n if n in dp:return dp[n]\n ans=0\n for i in x:\n if i==n:\n ans+=1\n break\n if i>n:break\n if n%i==0 and n//i in se:\n ans+=f(i)*f(n//i)\n dp[n]=ans\n return ans \n dp={}\n x.sort()\n se=set(x)\n ans=0\n for i in x:\n ans+=f(i)\n return ans%(10**9+7)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n mapping = {x: i for i, x in enumerate(A)}\n maximal = A[-1]\n N = len(A)\n ans, MOD = [1] * N, 10 ** 9 + 7\n for i in range(N):\n for j in range(i + 1):\n if A[i] * A[j] in mapping and A[i] * A[j] <= maximal:\n if A[i] != A[j]:\n ans[mapping[A[i] * A[j]]] += 2 * ans[i] * ans[j]\n else:\n ans[mapping[A[i] * A[j]]] += ans[i] * ans[j]\n ans[mapping[A[i] * A[j]]] %= MOD\n return sum(ans) % MOD","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n ret = 0\n root_value_to_tree_number = collections.defaultdict(int)\n \n \n for i in range(len(A)):\n occurrences = 1\n \n \n for j in range(i - 1, -1, -1):\n if (A[i] % A[j] == 0):\n required_root_value = A[i] // A[j]\n occurrences += root_value_to_tree_number[required_root_value] * root_value_to_tree_number[A[j]]\n \n root_value_to_tree_number[A[i]] = occurrences\n ret += occurrences\n \n return ret % 1000000007 ","class Solution:\n def numFactoredBinaryTrees(self, x: List[int]) -> int:\n def f(n):\n if n in dp:return dp[n]\n ans=1\n for i in x:\n if i>(n**.5):break\n if n%i==0 and n//i in se:\n ans+=(1 if n//i==i else 2)*f(i)*f(n//i)\n dp[n]=ans\n return ans \n dp={}\n x.sort()\n se=set(x)\n ans=0\n for i in x:ans+=f(i)\n return ans%(10**9+7)\n","class Solution(object):\n def numFactoredBinaryTrees(self, A):\n MOD = 10 ** 9 + 7\n N = len(A)\n A.sort()\n dp = [1] * N\n index = {x: i for i, x in enumerate(A)}\n for i, x in enumerate(A):\n for j in range(i):\n if x % A[j] == 0: #A[j] will be left child\n right = x //A[j]\n if right in index:\n dp[i] += dp[j] * dp[index[right]]\n dp[i] %= MOD\n\n return sum(dp) % MOD","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n if len(A) <= 1:\n return len(A)\n \n N, MOD = len(A), 10 ** 9 + 7\n trees = {}\n ans = 0\n A.sort()\n for i in range(N):\n trees[A[i]] = 1\n for j in range(i):\n factor = A[i]/A[j]\n if not factor.is_integer():\n continue\n factor = int(factor)\n if factor in trees:\n trees[A[i]] += trees[A[j]]*trees[factor] \n ans += trees[A[i]] \n return ans % MOD\n \n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n dp = {n: 1 for n in A}\n setA = set(A)\n for i in range(len(A)): # goal\n target = A[i]\n for j in range(0, i): # using this as factor\n factor = A[j]\n if target%factor == 0:\n other_half = target//factor\n if other_half in setA:\n dp[target] += dp[other_half] * dp[factor]\n return sum(dp.values())%(10**9 + 7)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n n = len(A)\n nums = set(A)\n A = sorted(A)\n counts = collections.defaultdict(int)\n mod = 10**9+7\n res = 0\n for i, num in enumerate(A):\n for j in range(i):\n b, c = A[j], num/A[j]\n if c in nums:\n counts[num] += (counts[b]*counts[c])%mod\n counts[num] += 1\n res = (res+counts[num])%mod\n return res","import math\n\n\nclass Solution:\n @staticmethod\n def numFactors(num, A_set):\n factors = set()\n for a in A_set:\n if num < a:\n continue\n if num % a == 0 and num // a in A_set:\n factors.add(a)\n factors.add(num // a)\n return factors\n\n @staticmethod\n def numFactoredTrees(root, results, A_set):\n if root in results:\n return results[root]\n factors = Solution.numFactors(root, A_set)\n # tree can only have depth 1 with the root node alone\n if len(factors) == 0:\n results[root] = 1\n return 1\n # tree can have depth greater than 1\n n = 1 # depth 1\n while len(factors) > 0:\n factor = factors.pop()\n remainder = root // factor\n if factor not in results:\n results[factor] = Solution.numFactoredTrees(factor, results, A_set)\n if factor == remainder:\n n += results[factor] * results[factor]\n else:\n factors.remove(remainder)\n if remainder not in results:\n results[remainder] = Solution.numFactoredTrees(remainder, results, A_set)\n n += results[factor] * results[remainder] * 2\n results[root] = n\n return n\n\n def numFactoredBinaryTrees(self, A) -> int:\n A.sort()\n A_set = set(A)\n results = {}\n return sum([Solution.numFactoredTrees(a, results, A_set) for a in A]) % (10 ** 9 + 7)\n\n","import math\n\n\nclass Solution:\n @staticmethod\n def numFactors(num, A_set):\n factors = set()\n for a in A_set:\n if num % a == 0 and num // a in A_set:\n factors.add(a)\n factors.add(num // a)\n return factors\n\n @staticmethod\n def numFactoredTrees(root, results, A_set):\n if root in results:\n return results[root]\n factors = Solution.numFactors(root, A_set)\n # tree can only have depth 1 with the root node alone\n if len(factors) == 0:\n results[root] = 1\n return 1\n # tree can have depth greater than 1\n n = 1 # depth 1\n while len(factors) > 0:\n factor = factors.pop()\n remainder = root // factor\n if factor not in results:\n results[factor] = Solution.numFactoredTrees(factor, results, A_set)\n if factor == remainder:\n n += results[factor] * results[factor]\n else:\n factors.remove(remainder)\n if remainder not in results:\n results[remainder] = Solution.numFactoredTrees(remainder, results, A_set)\n n += results[factor] * results[remainder] * 2\n results[root] = n\n return n\n\n def numFactoredBinaryTrees(self, A) -> int:\n #A.sort()\n A_set = set(A)\n results = {}\n return sum([Solution.numFactoredTrees(a, results, A_set) for a in A]) % (10 ** 9 + 7)\n\n","import math\n\n\nclass Solution:\n @staticmethod\n def numFactors(num, A_set):\n factors = set()\n for a in A_set:\n if num % a == 0 and num // a in A_set:\n factors.add(a)\n factors.add(num // a)\n return factors\n\n @staticmethod\n def numFactoredTrees(root, results, A_set):\n if root in results:\n return results[root]\n factors = Solution.numFactors(root, A_set)\n # tree can only have depth 1 with the root node alone\n if len(factors) == 0:\n results[root] = 1\n return 1\n # tree can have depth greater than 1\n n = 1 # depth 1\n while len(factors) > 0:\n factor = factors.pop()\n remainder = root // factor\n if factor not in results:\n results[factor] = Solution.numFactoredTrees(factor, results, A_set)\n if factor == remainder:\n n += results[factor] * results[factor]\n else:\n factors.remove(remainder)\n if remainder not in results:\n results[remainder] = Solution.numFactoredTrees(remainder, results, A_set)\n n += results[factor] * results[remainder] * 2\n results[root] = n\n return n\n\n def numFactoredBinaryTrees(self, A) -> int:\n A.sort()\n A_set = set(A)\n results = {}\n return sum([Solution.numFactoredTrees(a, results, A_set) for a in A]) % (10 ** 9 + 7)\n\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A = sorted(A)\n n = len(A)\n dict_num = {}\n for num in A:\n dict_num[num] = True\n dp_dict = {}\n factor_pair = []\n for i in range(n):\n factor_pair.append([])\n \n for i in range(n):\n for j in range(i):\n if(A[i] % A[j] == 0 and A[i]//A[j] in dict_num):\n factor_pair[i].append((A[j], A[i]//A[j]))\n # print(factor_pair)\n for i in range(n):\n root = A[i]\n num_trees = 1\n for a, b in factor_pair[i]:\n num_trees += dp_dict[a]*dp_dict[b]\n \n dp_dict[root] = num_trees\n \n answer = 0\n for key in dp_dict:\n answer += dp_dict[key]\n \n return answer % (10**9+7)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n O = {}\n ans = 0\n for a in A:\n if a not in O:\n O[a] = 1\n for k, v in list(O.items()):\n if a % k == 0 and a // k in O:\n O[a] += v * O[a // k]\n ans += O[a]\n return ans % 1000000007\n","\n \nclass Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n MOD = 10 ** 9 + 7\n \n n = len(A)\n tips = sorted(A)\n \n \n index = { x: i for i, x in enumerate(tips) }\n d = [1] * n\n \n for i, x in enumerate(tips):\n head = x\n\n for j in range(i):\n x = tips[j]\n \n y = head // x\n \n if y*x != head:\n continue\n if y in index:\n leaf_1 = j\n leaf_2 = index[y]\n d[i] = d[i] + (d[leaf_1] * d[leaf_2])\n \n return sum(d) % MOD","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n n = len(A)\n dp = defaultdict(int)\n res = 0\n for i, num in enumerate(A):\n dp[num] = 1\n for j in range(i):\n if num % A[j] == 0:\n dp[num] += dp[A[j]] * dp[A[i]//A[j]]\n res += dp[num]\n return res % 1000000007\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n seen,A={},set(A)\n def find_all(root):\n if root in seen:\n return seen[root]\n combs=1\n for left in A:\n if root==left or root%left: continue\n right=root//left\n if right not in A: continue\n combs+=find_all(left)*find_all(right)\n seen[root]=combs\n return combs\n return sum(find_all(num) for num in sorted(A))%1000000007","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n mod = 10**9 + 7\n processed = dict()\n res = 0\n for a in sorted(A):\n counter = 1\n for key, val in list(processed.items()):\n key2 = a / key\n val2 = processed.get(key2, 0)\n if val2 != 0:\n counter = (counter + val * val2) % mod\n processed[a] = counter\n res = (res + counter) % mod\n return res\n \n \n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n n=len(A)\n A.sort()\n dp=[1]*n\n mod=10**9+7\n index={c:i for i,c in enumerate(A) }\n \n for i,x in enumerate(A):\n for j in range(n):\n if x%A[j]==0:\n right=x/A[j]\n if right in index:\n dp[i]+=dp[j]*dp[index[right]]\n dp[i]=dp[i]%mod\n return sum(dp)%mod","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n factorSet = set(A)\n A.sort()\n treeCount = {}\n\n for num in A:\n count = 1\n for p, pCount in list(treeCount.items()):\n q, rem = divmod(num, p)\n if p > q:\n break\n if rem == 0 and q in treeCount:\n count += pCount*treeCount[q] if p == q else 2*pCount*treeCount[q]\n treeCount[num] = count\n return sum(treeCount.values()) % (1000_000_000 + 7)\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n seen,A={},set(A)\n def find_all(root):\n if root in seen:\n return seen[root]\n combs=1\n for left in A:\n if root==left or root%left: continue\n right=root//left\n if right not in A: continue\n combs+=find_all(left)*find_all(right)\n seen[root]=combs\n return combs\n return sum(find_all(num) for num in A)%1000000007","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n dp = {i:1 for i in A}\n res = 0\n for idd, number in enumerate(A):\n \n for inner, inumber in enumerate(A[:idd]):\n if number % inumber == 0 and ((number // inumber) in dp):\n dp[number] += dp[inumber] * dp[number // inumber]\n \n res += dp[number]\n res = res % (10 ** 9 + 7)\n \n return res\n","# 823. Binary Trees With Factors\n\nMOD = 10**9 + 7\n\ndef count_binary_trees (arr):\n arr = sorted (arr)\n coll = set (arr)\n\n count = {}\n\n for index, elem in enumerate (arr):\n ans = 1\n for i in range (index):\n factor = arr[i]\n if elem % factor == 0 and elem // factor in coll:\n other_factor = elem // factor\n ans = (ans + count[factor] * count[other_factor]) % MOD\n\n count[elem] = ans\n\n return sum (y for (x, y) in count.items ()) % MOD\n\nclass Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n return count_binary_trees(A)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A = sorted(A)\n mems = {}\n for ix in range(len(A)):\n mems[A[ix]] = ix\n \n dp = [1] * len(A)\n \n big_mod = 10**9 + 7\n \n for i in range(len(A)):\n extras = 0\n for j in range(i):\n d, mo = divmod(A[i], A[j])\n if mo == 0:\n if d in mems:\n extras += dp[j] * dp[mems[d]]\n extras = extras % big_mod\n\n dp[i] += extras\n \n result = sum(dp) % big_mod\n \n return result\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n # Time complexity: O(N^2)\n # Space complexity: O(N)\n A.sort()\n dic = {num: 1 for num in A}\n for i in range(1, len(A)):\n for j in range(i):\n q, res = divmod(A[i], A[j])\n if res == 0 and q in dic:\n dic[A[i]] += dic[q] * dic[A[j]]\n\n return sum(dic.values()) % (10**9 + 7)\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A = sorted(A)\n mems = {}\n for ix in range(len(A)):\n mems[A[ix]] = ix\n \n dp = [1] * len(A)\n \n big_mod = 10**9 + 7\n \n for i in range(len(A)):\n extras = 0\n for j in range(i):\n d, mo = divmod(A[i], A[j])\n if mo == 0:\n if d in mems:\n extras += dp[j] * dp[mems[d]]\n\n extras = extras % big_mod\n dp[i] += extras\n \n result = sum(dp) % big_mod\n \n return result\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n dp = {}\n mod = 10**9+7\n for a in A:\n dp[a] = 1\n for b in A:\n if a%b==0 and b in dp and a//b in dp:\n dp[a] += dp[b]*dp[a//b]\n dp[a] %= mod\n \n return sum(dp.values())%mod","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n sorted_A = sorted(A)\n dp = dict()\n result = 0\n \n for i in range(len(sorted_A)):\n cur_total = 0\n for j in range(i + 1):\n cur_val = sorted_A[i]\n prev_val = sorted_A[j]\n if i == j:\n dp[cur_val] = cur_total + 1\n result += cur_total + 1\n elif (cur_val / prev_val) in dp:\n cur_total += dp[cur_val/prev_val] * dp[prev_val]\n \n return result % (10 ** 9 + 7)\n \n '''\n \n \n [18, 3, 6, 2]\n [2, 3, 6, 18]\n dp = {\n 2 : 1\n 3 : 1\n 6 : 3\n 18: 5\n }\n cur_val = 18\n prev_val = 6\n cur_total = 3 + 1 \n result = 1 + 1 + 3 + 5\n \n \n ''' \n \n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n dp = {}\n for a in sorted(A):\n dp[a] = sum(dp[b] * dp.get(a/b, 0) for b in dp) + 1\n return sum(dp.values()) % (10**9 + 7)\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n ans = 0\n N = len(A)\n cnt = [1 for _ in range(N)]\n for i, n in enumerate(A):\n l, r = 0, i - 1\n while r >= l:\n if A[r] * A[l] == n:\n cnt[i] += cnt[r] * cnt[l] if r == l else cnt[r] * cnt[l] * 2\n l += 1\n r -= 1\n elif A[r] * A[l] > n:\n r -= 1\n else:\n l += 1\n ans += cnt[i]\n return ans % (10 ** 9 + 7)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n factorSet = set(A)\n A.sort()\n treeCount = {}\n\n for num in A:\n count = 1\n for p, pCount in list(treeCount.items()):\n q, rem = divmod(num, p)\n if rem == 0:\n count += pCount * treeCount.get(q, 0) \n treeCount[num] = count\n return sum(treeCount.values()) % (1000_000_000 + 7)\n","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n t = {}\n for a in A:\n t[a] = 1 + sum(t[b] * t.get(a / b, 0) for b in A if b < a)\n return sum(t.values()) % (pow(10, 9) + 7)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n t = {}\n for a in sorted(A):\n t[a] = 1 + sum(t[b] * t.get(a/b, 0) for b in A if b < a)\n return sum(t.values()) % (10**9 + 7)","class Solution:\n def numFactoredBinaryTrees(self, A): \n \n\n t = {}\n for a in sorted(A):\n t[a] = 1 + sum(t[b] * t.get(a/b, 0) for b in A if b < a)\n return sum(t.values()) % (10**9 + 7)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n mymap = {}\n for x in sorted(A):\n # 1 for leaf, plus sum any that could be factors (y and currval/y)\n mymap[x] = 1+ sum(mymap[y]*mymap.get(x/y,0) for y in A if y<x)\n return sum(mymap.values())%(10**9+7)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n A.sort()\n n=len(A)\n dp=[1 for i in range(n)]\n for i in range(n):\n start,end=0,i-1\n while(start<=end):\n if A[start]*A[end]<A[i]:\n start+=1\n continue\n if A[start]*A[end]>A[i]:\n end-=1\n continue\n if start==end: \n dp[i]+=dp[start]*dp[end]\n else:\n dp[i]+=dp[start]*dp[end]*2\n start+=1\n end-=1\n # print(dp)\n return sum(dp)%(10**9+7)","class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n n = len(A)\n A.sort()\n dp = [1] * n\n res = 0\n for i in range(n):\n s = 0\n e = i - 1\n for s in range(i):\n while s <= e and A[s] * A[e] > A[i]:\n e -= 1\n \n if s > e:\n break\n \n if A[s] * A[e] == A[i]:\n dp[i] += ((dp[s] * dp[e] * 2) if s != e else (dp[s] * dp[e]))\n dp[i] = dp[i] % (10 ** 9 + 7)\n e -= 1\n \n res += dp[i]\n res = res % (10 ** 9 + 7)\n \n return res\n \n"],"string":"[\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n \\n mod = 10**9 + 7\\n\\n nums_set = set(A)\\n nums = A.copy()\\n nums.sort()\\n counts = {}\\n total = 0\\n\\n for n in nums:\\n n_count = 1\\n for d in nums:\\n if d * d > n:\\n break\\n if n % d != 0:\\n continue\\n e = n // d\\n if e not in nums_set:\\n continue\\n\\n subtrees = (counts[d] * counts[e]) % mod\\n if d != e:\\n subtrees = (subtrees * 2) % mod\\n n_count = (n_count + subtrees) % mod\\n counts[n] = n_count % mod\\n total = (total + n_count) % mod\\n\\n return total\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n factorSet = set(A)\\n A.sort()\\n treeCount = collections.defaultdict(lambda : 1)\\n \\n n = len(A)\\n end = 0\\n for num in A:\\n sqrt = int(math.sqrt(num)+1)\\n while end < n and A[end] <= sqrt:\\n end += 1\\n count = 0\\n for _, p in zip(list(range(end)), A):\\n if num % p == 0 and (q := num // p) in factorSet and p <= q:\\n count += 2*treeCount[p]*treeCount[q] if p != q else treeCount[p]*treeCount[q]\\n treeCount[num] += count\\n return sum(treeCount.values()) % (1000_000_000 + 7)\\n \\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n factorSet = set(A)\\n A.sort()\\n treeCount = {}\\n\\n for num in A:\\n count = 1\\n for p, pCount in list(treeCount.items()):\\n q, rem = divmod(num, p)\\n if p > q:\\n break\\n if rem == 0:\\n tmp = pCount * treeCount.get(q, 0)\\n count += tmp if p == q else 2*tmp\\n treeCount[num] = count\\n return sum(treeCount.values()) % (1000_000_000 + 7)\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n dp = {}\\n res = 0\\n for i in range(len(A)):\\n dp[A[i]] = 1\\n for j in range(i):\\n if A[j] * A[j] == A[i]:\\n dp[A[i]] += dp[A[j]] * dp[A[j]]\\n dp[A[i]] %= 1000_000_007\\n elif A[j] * A[j] > A[i] and A[i] % A[j] == 0:\\n dp[A[i]] += dp[A[j]] * dp.get(A[i] // A[j], 0) * 2\\n dp[A[i]] %= 1000_000_007\\n res = sum([v for _, v in dp.items()])\\n res %= 1000_000_007\\n return res\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n dp = {}\\n res = 0\\n for i in range(len(A)):\\n dp[A[i]] = 1\\n for j in range(i):\\n if A[j] * A[j] == A[i]:\\n dp[A[i]] += dp[A[j]] * dp[A[j]]\\n dp[A[i]] %= 1000_000_007\\n elif A[j] * A[j] > A[i]:\\n div = A[i] // A[j]\\n if div * A[j] == A[i] and div in dp:\\n dp[A[i]] += dp[A[j]] * dp[div] * 2\\n dp[A[i]] %= 1000_000_007\\n res += dp[A[i]]\\n res %= 1000_000_007\\n return res\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n dp = {}\\n res = 0\\n for i in range(len(A)):\\n dp[A[i]] = 1\\n for j in range(i):\\n if A[j] * A[j] == A[i]:\\n dp[A[i]] += dp[A[j]] * dp[A[j]]\\n dp[A[i]] %= 1000_000_007\\n elif A[j] * A[j] > A[i] and A[i] % A[j] == 0:\\n dp[A[i]] += dp[A[j]] * dp.get(A[i] // A[j], 0) * 2\\n dp[A[i]] %= 1000_000_007\\n res += dp[A[i]]\\n res %= 1000_000_007\\n return res\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n cache = dict()\\n iSet = set(A)\\n def helper(i):\\n if i not in cache:\\n count = 1\\n for j in range(len(A)):\\n if i != A[j] and i % A[j] == 0:\\n if i//A[j] in iSet:\\n count += helper(A[j]) * helper(i//A[j])\\n cache[i] = count\\n return cache[i]\\n ans = 0\\n for i in range(len(A)):\\n ans += helper(A[i])\\n return ans % 1000000007\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A=sorted(A)\\n res=dict()\\n for idx, a in enumerate(A):\\n if idx==0:\\n res[a]=1\\n else:\\n res[a]=1\\n for j in range(idx):\\n if (a%A[j]==0) and (a//A[j] in A):\\n res[a]+=res[A[j]]*res[a//A[j]]\\n return sum(res.values())%(10**9+7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n \\n A.sort()\\n \\n dp = [1 for _ in range(len(A))]\\n \\n for i in range(len(A)):\\n \\n for j in range(i):\\n \\n time, remain = divmod(A[i], A[j])\\n\\n if remain == 0 and time in A:\\n\\n dp[i] += (dp[j] * dp[A.index(time)])\\n \\n return sum(dp) % (10**9 + 7)\\n \\n \\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n d = {}\\n Aset = set(A)\\n A.sort()\\n ans = 0\\n for i in range(len(A)):\\n d[A[i]] = 1\\n for j in range(i):\\n if A[i]%A[j] == 0:\\n k = A[i]//A[j]\\n if k in set(A):\\n d[A[i]] += d[A[j]]*d[k]\\n d[A[i]] %= 10**9+7\\n ans += d[A[i]]\\n ans %= 10**9+7\\n # print(d)\\n return ans\\n # return sum(d[key] for key in d)\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n d = {}\\n Aset = set(A)\\n A.sort()\\n ans = 0\\n for i in range(len(A)):\\n d[A[i]] = 1\\n for j in range(i):\\n if A[i]%A[j] == 0:\\n k = A[i]//A[j]\\n if k == A[j]:\\n d[A[i]] += d[A[j]]*d[A[j]]\\n elif k in set(A):\\n d[A[i]] += d[A[j]]*d[k]\\n ans += d[A[i]]\\n ans %= 10**9+7\\n # print(d)\\n return ans\\n # return sum(d[key] for key in d)\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n d = {}\\n Aset = set(A)\\n A.sort()\\n ans = 0\\n for i in range(len(A)):\\n d[A[i]] = 1\\n for j in range(i):\\n if A[i]%A[j] == 0:\\n k = A[i]//A[j]\\n if k in set(A):\\n d[A[i]] += d[A[j]]*d[k]\\n d[A[i]] %= 10**9+7\\n ans += d[A[i]]\\n ans %= 10**9+7\\n return ans\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n SA = set(A)\\n A = sorted(SA)\\n C = {}\\n for x in A:\\n C[x] = 1\\n for i, x in enumerate(A):\\n for j in range(i):\\n if A[j] * A[j] > A[i]:\\n break\\n elif A[j] * A[j] == A[i]:\\n C[A[i]] += C[A[j]] * C[A[j]]\\n elif A[i] % A[j] == 0 and A[i] // A[j] in SA:\\n C[A[i]] += 2 * C[A[j]] * C[A[i] // A[j]]\\n # print(C)\\n res = sum(C.values())\\n return res % (10**9 + 7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n treeCount = {}\\n\\n for num in A:\\n count = 1\\n for p, pCount in list(treeCount.items()):\\n q, rem = divmod(num, p)\\n if p > q:\\n break\\n if rem == 0 and q in treeCount:\\n count += pCount*treeCount[q] if p == q else 2*pCount*treeCount[q]\\n treeCount[num] = count\\n return sum(treeCount.values()) % (1000_000_000 + 7)\\n\",\n \"class Solution:\\n def collect(self, lst, st, num, cache):\\n if num in cache:\\n return cache[num]\\n res = 1\\n for n1 in lst:\\n if n1**2 > num:\\n break\\n if num % n1 == 0 and (num // n1) in st:\\n n2 = num // n1\\n res_local = self.collect(lst, st, n1, cache) * self.collect(lst, st, n2, cache)\\n res += res_local\\n if n1 != n2:\\n res += res_local\\n mod = (10**9)+7\\n res = res % mod\\n cache[num] = res\\n return res\\n \\n def solve(self, A): \\n st = set(A)\\n lst = sorted(list(st))\\n res = 0\\n cache = {}\\n mod = (10**9)+7\\n for n in lst:\\n res += self.collect(lst, st, n, cache)\\n return res % mod\\n \\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n return self.solve(A)\",\n \"import functools as ft\\nimport typing as t\\n\\n\\nclass Solution:\\n \\n BASE = 10 ** 9 + 7\\n \\n def divisor_pairs(self, idx: int) -> List[t.Tuple[int, int]]:\\n num = self.A[idx]\\n left_idx = 0\\n ans = []\\n while self.A[left_idx] ** 2 <= num:\\n left = self.A[left_idx]\\n if num % left == 0:\\n right = num // left\\n if right in self.A_idx:\\n ans.append((left_idx, self.A_idx[right]))\\n left_idx += 1\\n return ans\\n \\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n self.A = sorted(A)\\n self.A_idx = {a: idx for idx, a in enumerate(self.A)}\\n return sum(self.count_binary_trees(idx) for idx in range(len(A))) % self.BASE\\n \\n @ft.lru_cache(None)\\n def count_binary_trees(self, idx: int) -> int:\\n num = self.A[idx]\\n ans = 1 # root only\\n for left_idx, right_idx in self.divisor_pairs(idx):\\n left_cnt = self.count_binary_trees(left_idx)\\n right_cnt = self.count_binary_trees(right_idx)\\n if left_idx == right_idx:\\n total_cnt = left_cnt * right_cnt\\n else:\\n total_cnt = 2 * left_cnt * right_cnt\\n ans += total_cnt\\n return ans\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n d = {}\\n MOD = 1000000007\\n for a in A:\\n d[a] = 1 + sum(d[a//b] * d[b] for b in d if not a%b and a//b in d)\\n #print(d)\\n return sum(d.values()) % MOD\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n mod = 10 ** 9 + 7\\n A.sort()\\n parents = dict()\\n seen = set()\\n for a in A:\\n tot = 1\\n for s in seen:\\n if a % s == 0:\\n b = a // s\\n if b in seen:\\n tot += parents[s] * parents[b]\\n parents[a] = tot\\n seen.add(a)\\n return sum(parents.values()) % mod\\n \\n \\n \\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n # Time complexity: O(N^2)\\n # Space complexity: O(N)\\n # A.sort()\\n # dic = {num: 1 for num in A}\\n # for i in range(1, len(A)):\\n # for j in range(i):\\n # q, res = divmod(A[i], A[j])\\n # if res == 0 and q in dic:\\n # dic[A[i]] += dic[q] * dic[A[j]]\\n\\n # return sum(dic.values()) % (10**9 + 7)\\n\\n\\n dp = {}\\n for a in sorted(A):\\n dp[a] = sum(dp[b] * dp.get(a // b, 0) for b in dp if a % b == 0) + 1\\n return sum(dp.values()) % (10**9 + 7)\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n d = {A[0]:0}\\n dp = [1]*len(A)\\n MOD = 1000000007\\n \\n for i in range(1, len(A)):\\n for j in range(0, i):\\n t = A[i]//A[j]\\n if t< A[j]:\\n break\\n \\n if not A[i] % A[j] and t in d:\\n if A[j] == t:\\n dp[i] += dp[j] * dp[d[t]] \\n else:\\n dp[i] += dp[j] * dp[d[t]] * 2\\n \\n dp[i] %= MOD\\n d[A[i]] = i\\n \\n return sum(dp) % MOD\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A):\\n dp = {}\\n for a in sorted(A):\\n dp[a] = sum(dp[b] * dp.get(a / b, 0) for b in dp if a % b == 0) + 1\\n return sum(dp.values()) % (10**9 + 7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n dp = {}\\n for a in sorted(A):\\n dp[a] = sum(dp[b] * dp.get(a / b, 0) for b in dp if a % b == 0) + 1\\n return sum(dp.values()) % (10**9 + 7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n dp = {}\\n for a in sorted(A):\\n dp[a] = sum(dp[b]*dp.get(a/b, 0) for b in dp if(a%b == 0))+1\\n return sum(dp.values())%(10**9+7)\\n \\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n \\n A.sort()\\n A_set = set(A)\\n cache = {}\\n num_trees = 0\\n \\n # Update num trees. \\n for i, n in enumerate(A):\\n \\n # Get factors pairs.\\n factor_pairs = []\\n for j in range(i):\\n if n % A[j] == 0 and n // A[j] in A_set:\\n factor_pairs.append((n // A[j], A[j]))\\n \\n # Compute num_trees.\\n new_trees = 1\\n for factor1, factor2 in factor_pairs:\\n if factor1 != factor2:\\n new_trees += cache[factor1] * cache[factor2] # Each pair is run over twice. \\n elif factor1 == factor2:\\n new_trees += cache[factor1] * cache[factor2]\\n num_trees += new_trees\\n cache[n] = new_trees\\n \\n print(cache) \\n return num_trees % (10 ** 9 + 7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n MOD = 10 ** 9 + 7\\n N = len(A)\\n A.sort()\\n dp = [1] * N\\n index = {x: i for i, x in enumerate(A)}\\n for i, x in enumerate(A):\\n for j in range(i):\\n if x % A[j] == 0: #A[j] will be left child\\n right = x / A[j]\\n if right in index:\\n dp[i] += dp[j] * dp[index[right]]\\n dp[i] %= MOD\\n\\n return sum(dp) % MOD\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n mod = 10**9 + 7\\n A.sort()\\n dp = [1 for _ in range(len(A))]\\n reverse_map = {x: i for i, x in enumerate(A)}\\n\\n\\n for i, x in enumerate(A):\\n for j in range(i):\\n if x % A[j] == 0: #A[j] will be left child\\n right_child = x / A[j]\\n if right_child in reverse_map:\\n dp[i] += dp[j] * dp[reverse_map[right_child]]\\n dp[i] % mod\\n\\n return sum(dp) % mod\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n \\n MOD = int(1e9 + 7)\\n N = len(A)\\n \\n A.sort()\\n dp = [1] * N\\n idx = {ele: i for i, ele in enumerate(A)}\\n \\n for c, rootVal in enumerate(A):\\n for j in range(c):\\n left = A[j]\\n if rootVal % left == 0:\\n right = rootVal / left \\n if right in idx:\\n dp[c] += dp[j] * dp[idx[right]] % MOD\\n \\n return sum(dp) % MOD\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n \\n MOD = int(1e9 + 7)\\n N = len(A)\\n \\n A.sort()\\n dp = [1] * N\\n idx = {ele: i for i, ele in enumerate(A)}\\n \\n for i, rootVal in enumerate(A):\\n for j in range(i):\\n left = A[j]\\n if rootVal % left == 0:\\n right = rootVal / left \\n if right in idx:\\n dp[i] += dp[j] * dp[idx[right]]\\n dp[i] %= MOD\\n \\n return sum(dp) % MOD\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n MOD = 10 ** 9 + 7\\n N = len(A)\\n A.sort()\\n dp = [1] * N\\n index = {x: i for i, x in enumerate(A)}\\n for i, x in enumerate(A):\\n for j in range(i):\\n if x % A[j] == 0: #A[j] will be left child\\n right = x / A[j]\\n if right in index:\\n dp[i] += dp[j] * dp[index[right]]\\n dp[i] %= MOD\\n\\n return sum(dp) % MOD\\n \\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n O = {}\\n for a in A:\\n if a not in O:\\n O[a] = 1\\n for k, v in list(O.items()):\\n if a % k == 0 and a // k in O:\\n O[a] += v * O[a // k]\\n return sum(O.values()) % 1000000007\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n \\n MOD = int(1e9 + 7)\\n N = len(A)\\n \\n A.sort()\\n dp = [1] * N\\n idx = {ele: i for i, ele in enumerate(A)}\\n \\n for i, root_val in enumerate(A):\\n for j in range(i):\\n left = A[j]\\n if root_val % left == 0:\\n right = root_val / left \\n if right in idx:\\n dp[i] += dp[j] * dp[idx[right]]\\n dp[i] %= MOD\\n \\n return sum(dp) % MOD\",\n \"\\n# 823. Binary Trees With Factors\\n\\nclass Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n \\n MOD = int(1e9 + 7)\\n N = len(A)\\n \\n A.sort()\\n dp = [1] * N\\n idx = {ele: i for i, ele in enumerate(A)}\\n \\n for c, rootVal in enumerate(A):\\n for l in range(c):\\n leftVal = A[l]\\n if rootVal % leftVal == 0:\\n rightVal = rootVal / leftVal \\n if rightVal in idx:\\n dp[c] += dp[l] * dp[idx[rightVal]] % MOD\\n \\n return sum(dp) % MOD\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int: \\n A.sort()\\n numToIdx = {x : i for i, x in enumerate(A)}\\n \\n dp = [1 for _ in range(len(A))]\\n \\n MOD = 10**9 + 7\\n totalSum = 0\\n \\n for i, x in enumerate(A):\\n for j in range(i):\\n y = A[j]\\n if x % y == 0 and x // y in numToIdx:\\n dp[i] += dp[j] * dp[numToIdx[x // y]]\\n \\n totalSum = (totalSum + dp[i]) % MOD\\n \\n return totalSum\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A = sorted(A)\\n N = len(A)\\n dp = [1 for _ in range(N)]\\n index_map = {}\\n for index in range(N):\\n index_map[A[index]] = index\\n \\n for k in range(N):\\n for i in range(k):\\n if A[k] % A[i] == 0:\\n num_to_look = A[k]//A[i]\\n if num_to_look in index_map:\\n j = index_map[num_to_look]\\n dp[k] += dp[i]*dp[j] # okay why is this not giving me the right number?\\n \\n return sum(dp) % (10**9 +7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n factorSet = set(A)\\n A.sort()\\n treeCount = {}\\n\\n for num in A:\\n count = 1\\n for p, pCount in list(treeCount.items()):\\n q, rem = divmod(num, p)\\n if p > q:\\n break\\n if rem == 0 and q in treeCount:\\n tmp = pCount * treeCount[q]\\n count += tmp if p == q else 2*tmp\\n treeCount[num] = count\\n return sum(treeCount.values()) % (1000_000_000 + 7)\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n ret = 0\\n root_value_to_tree_number = collections.defaultdict(int)\\n \\n \\n for i in range(len(A)):\\n occurrences = 1\\n \\n \\n for j in range(i - 1, -1, -1):\\n if (A[i] % A[j] == 0):\\n required_root_value = A[i] // A[j]\\n occurrences += root_value_to_tree_number[required_root_value] * root_value_to_tree_number[A[j]]\\n \\n root_value_to_tree_number[A[i]] = occurrences\\n ret += occurrences\\n \\n return ret % 1000000007 \",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n factors = set(A)\\n A.sort()\\n dp = defaultdict(int)\\n count = 0\\n modulus = 10**9 + 7\\n for i in range(len(A)):\\n dp[A[i]] += 1\\n for j in range(i):\\n if A[i] % A[j] == 0 and (A[i] // A[j]) in factors:\\n dp[A[i]] += dp[A[j]] * dp[A[i] // A[j]]\\n count = (count + dp[A[i]]) % modulus\\n return count\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A):\\n MOD = 10 ** 9 + 7\\n n = len(A)\\n A.sort()\\n dp = [1] * n\\n index = {x: i for i, x in enumerate(A)}\\n for i, x in enumerate(A):\\n for j in range(i):\\n if x % A[j] == 0:\\n right = x / A[j]\\n if right in index:\\n dp[i] += dp[j] * dp[index[right]]\\n dp[i] %= MOD\\n\\n return sum(dp) % MOD\",\n \"import math\\nclass Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n mod = 1000000007\\n dp = [1 for i in range(len(A))]\\n A.sort()\\n val_to_idx = {val: idx for idx, val in enumerate(A)}\\n M = len(A)\\n for i in range(M):\\n for j in range(0, i):\\n \\n if A[i] % A[j] == 0 and A[i]//A[j] in val_to_idx:\\n dp[i] += (dp[j] * dp[val_to_idx[A[i]//A[j]]]) % mod\\n dp[i] = dp[i] % mod\\n print(dp)\\n return sum(dp) % mod\\n \\n \\n \\n \\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n \\n A.sort()\\n dp = {val: 1 for val in A}\\n \\n for i in range(len(A)):\\n for j in range(i):\\n if A[i] % A[j] == 0 and A[i]//A[j] in dp:\\n dp[A[i]] += dp[A[i]//A[j]] * dp[A[j]]\\n \\n return sum(dp[v] for v in dp) % (10 ** 9 + 7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n n = len(A)\\n A.sort()\\n s = {a:i for i,a in enumerate(A)}\\n d = collections.defaultdict(set)\\n for i in range(n):\\n for j in range(i):\\n if A[i] % A[j] == 0:\\n res = A[i] // A[j]\\n if res in s:\\n d[i].add((j, s[res]))\\n \\n @lru_cache(maxsize=None)\\n def dfs(i):\\n nonlocal ans\\n cur = 1\\n for l, r in d[i]:\\n cur += dfs(l) * dfs(r)\\n return cur \\n ans = 0 \\n for i in range(n): \\n val = dfs(i) \\n ans += val\\n return ans % 1000000007\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, x: List[int]) -> int:\\n def f(n):\\n if n in dp:return dp[n]\\n ans=1\\n for i in x:\\n if i>(n**.5):break\\n if n%i==0 and n//i in se:\\n ans+=(1 if n//i==i else 2)*f(i)*f(n//i)\\n dp[n]=ans\\n return ans \\n dp={}\\n x.sort()\\n se=set(x)\\n ans=0\\n for i in x:ans+=f(i)\\n return ans%(10**9+7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n num_trees = {}\\n A.sort()\\n A_set = set(A)\\n for i in range (len(A)):\\n curr_num = A[i]\\n num_trees[curr_num] = 1 \\n for j in range (i):\\n if (A[i] % A[j] == 0):\\n if (A[i] // A[j]) in A_set:\\n num_trees[curr_num] += (num_trees[A[j]] * num_trees[A[i] // A[j]])\\n total = 0\\n for key in num_trees:\\n total += num_trees[key]\\n total %= (10**9 + 7)\\n return total\\n \\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n if not A:\\n return 0\\n\\n A.sort()\\n dp = {}\\n for i in range(len(A)):\\n dp[A[i]] = 1\\n for j in range(i):\\n if A[i] % A[j] == 0 and int(A[i]/A[j]) in dp:\\n dp[A[i]] += dp[A[j]] * dp[A[i]/A[j]]\\n\\n result = 0\\n for key in dp:\\n result += dp[key]\\n\\n return result % (10 ** 9 + 7)\",\n \"def prodcount(a):\\n dp =defaultdict(int)\\n a.sort()\\n for i in range(0,len(a)):\\n dp[a[i]] = 1\\n for j in range(i):\\n if a[i]%a[j]==0:\\n if a[i]//a[j] == a[j]:\\n dp[a[i]] += (dp[a[j]] *dp[a[i]//a[j]])\\n elif dp[a[i]//a[j]]:\\n dp[a[i]] += (dp[a[j]] *dp[a[i]//a[j]])\\n return sum(dp.values())% (10**9 + 7)\\nclass Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n return prodcount(A)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n memo = {}\\n ans = 0\\n A.sort()\\n \\n for i in range(len(A)):\\n localAns = 1\\n for j in range(i, -1, -1):\\n if A[i] / A[j] in memo:\\n localAns += memo[A[i]/A[j]] * memo[A[j]]\\n ans += localAns\\n memo[A[i]] = localAns\\n return ans % (10 ** 9 + 7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n # https://blog.csdn.net/fuxuemingzhu/article/details/83536814\\n A.sort()\\n dp = {}\\n for i, a in enumerate(A):\\n dp[a] = 1\\n for j in range(i):\\n if a % A[j] == 0 and a / A[j] in dp:\\n dp[a] += dp[A[j]] * dp[a / A[j]]\\n \\n return sum(dp.values()) % (10**9 + 7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, x: List[int]) -> int:\\n def f(n):\\n if n in dp:return dp[n]\\n ans=0\\n for i in x:\\n if i==n:\\n ans+=1\\n break\\n if i>n:break\\n if n%i==0 and n//i in se:\\n ans+=f(i)*f(n//i)\\n dp[n]=ans\\n return ans \\n dp={}\\n x.sort()\\n se=set(x)\\n ans=0\\n for i in x:\\n ans+=f(i)\\n return ans%(10**9+7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n mapping = {x: i for i, x in enumerate(A)}\\n maximal = A[-1]\\n N = len(A)\\n ans, MOD = [1] * N, 10 ** 9 + 7\\n for i in range(N):\\n for j in range(i + 1):\\n if A[i] * A[j] in mapping and A[i] * A[j] <= maximal:\\n if A[i] != A[j]:\\n ans[mapping[A[i] * A[j]]] += 2 * ans[i] * ans[j]\\n else:\\n ans[mapping[A[i] * A[j]]] += ans[i] * ans[j]\\n ans[mapping[A[i] * A[j]]] %= MOD\\n return sum(ans) % MOD\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n ret = 0\\n root_value_to_tree_number = collections.defaultdict(int)\\n \\n \\n for i in range(len(A)):\\n occurrences = 1\\n \\n \\n for j in range(i - 1, -1, -1):\\n if (A[i] % A[j] == 0):\\n required_root_value = A[i] // A[j]\\n occurrences += root_value_to_tree_number[required_root_value] * root_value_to_tree_number[A[j]]\\n \\n root_value_to_tree_number[A[i]] = occurrences\\n ret += occurrences\\n \\n return ret % 1000000007 \",\n \"class Solution:\\n def numFactoredBinaryTrees(self, x: List[int]) -> int:\\n def f(n):\\n if n in dp:return dp[n]\\n ans=1\\n for i in x:\\n if i>(n**.5):break\\n if n%i==0 and n//i in se:\\n ans+=(1 if n//i==i else 2)*f(i)*f(n//i)\\n dp[n]=ans\\n return ans \\n dp={}\\n x.sort()\\n se=set(x)\\n ans=0\\n for i in x:ans+=f(i)\\n return ans%(10**9+7)\\n\",\n \"class Solution(object):\\n def numFactoredBinaryTrees(self, A):\\n MOD = 10 ** 9 + 7\\n N = len(A)\\n A.sort()\\n dp = [1] * N\\n index = {x: i for i, x in enumerate(A)}\\n for i, x in enumerate(A):\\n for j in range(i):\\n if x % A[j] == 0: #A[j] will be left child\\n right = x //A[j]\\n if right in index:\\n dp[i] += dp[j] * dp[index[right]]\\n dp[i] %= MOD\\n\\n return sum(dp) % MOD\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n if len(A) <= 1:\\n return len(A)\\n \\n N, MOD = len(A), 10 ** 9 + 7\\n trees = {}\\n ans = 0\\n A.sort()\\n for i in range(N):\\n trees[A[i]] = 1\\n for j in range(i):\\n factor = A[i]/A[j]\\n if not factor.is_integer():\\n continue\\n factor = int(factor)\\n if factor in trees:\\n trees[A[i]] += trees[A[j]]*trees[factor] \\n ans += trees[A[i]] \\n return ans % MOD\\n \\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n dp = {n: 1 for n in A}\\n setA = set(A)\\n for i in range(len(A)): # goal\\n target = A[i]\\n for j in range(0, i): # using this as factor\\n factor = A[j]\\n if target%factor == 0:\\n other_half = target//factor\\n if other_half in setA:\\n dp[target] += dp[other_half] * dp[factor]\\n return sum(dp.values())%(10**9 + 7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n n = len(A)\\n nums = set(A)\\n A = sorted(A)\\n counts = collections.defaultdict(int)\\n mod = 10**9+7\\n res = 0\\n for i, num in enumerate(A):\\n for j in range(i):\\n b, c = A[j], num/A[j]\\n if c in nums:\\n counts[num] += (counts[b]*counts[c])%mod\\n counts[num] += 1\\n res = (res+counts[num])%mod\\n return res\",\n \"import math\\n\\n\\nclass Solution:\\n @staticmethod\\n def numFactors(num, A_set):\\n factors = set()\\n for a in A_set:\\n if num < a:\\n continue\\n if num % a == 0 and num // a in A_set:\\n factors.add(a)\\n factors.add(num // a)\\n return factors\\n\\n @staticmethod\\n def numFactoredTrees(root, results, A_set):\\n if root in results:\\n return results[root]\\n factors = Solution.numFactors(root, A_set)\\n # tree can only have depth 1 with the root node alone\\n if len(factors) == 0:\\n results[root] = 1\\n return 1\\n # tree can have depth greater than 1\\n n = 1 # depth 1\\n while len(factors) > 0:\\n factor = factors.pop()\\n remainder = root // factor\\n if factor not in results:\\n results[factor] = Solution.numFactoredTrees(factor, results, A_set)\\n if factor == remainder:\\n n += results[factor] * results[factor]\\n else:\\n factors.remove(remainder)\\n if remainder not in results:\\n results[remainder] = Solution.numFactoredTrees(remainder, results, A_set)\\n n += results[factor] * results[remainder] * 2\\n results[root] = n\\n return n\\n\\n def numFactoredBinaryTrees(self, A) -> int:\\n A.sort()\\n A_set = set(A)\\n results = {}\\n return sum([Solution.numFactoredTrees(a, results, A_set) for a in A]) % (10 ** 9 + 7)\\n\\n\",\n \"import math\\n\\n\\nclass Solution:\\n @staticmethod\\n def numFactors(num, A_set):\\n factors = set()\\n for a in A_set:\\n if num % a == 0 and num // a in A_set:\\n factors.add(a)\\n factors.add(num // a)\\n return factors\\n\\n @staticmethod\\n def numFactoredTrees(root, results, A_set):\\n if root in results:\\n return results[root]\\n factors = Solution.numFactors(root, A_set)\\n # tree can only have depth 1 with the root node alone\\n if len(factors) == 0:\\n results[root] = 1\\n return 1\\n # tree can have depth greater than 1\\n n = 1 # depth 1\\n while len(factors) > 0:\\n factor = factors.pop()\\n remainder = root // factor\\n if factor not in results:\\n results[factor] = Solution.numFactoredTrees(factor, results, A_set)\\n if factor == remainder:\\n n += results[factor] * results[factor]\\n else:\\n factors.remove(remainder)\\n if remainder not in results:\\n results[remainder] = Solution.numFactoredTrees(remainder, results, A_set)\\n n += results[factor] * results[remainder] * 2\\n results[root] = n\\n return n\\n\\n def numFactoredBinaryTrees(self, A) -> int:\\n #A.sort()\\n A_set = set(A)\\n results = {}\\n return sum([Solution.numFactoredTrees(a, results, A_set) for a in A]) % (10 ** 9 + 7)\\n\\n\",\n \"import math\\n\\n\\nclass Solution:\\n @staticmethod\\n def numFactors(num, A_set):\\n factors = set()\\n for a in A_set:\\n if num % a == 0 and num // a in A_set:\\n factors.add(a)\\n factors.add(num // a)\\n return factors\\n\\n @staticmethod\\n def numFactoredTrees(root, results, A_set):\\n if root in results:\\n return results[root]\\n factors = Solution.numFactors(root, A_set)\\n # tree can only have depth 1 with the root node alone\\n if len(factors) == 0:\\n results[root] = 1\\n return 1\\n # tree can have depth greater than 1\\n n = 1 # depth 1\\n while len(factors) > 0:\\n factor = factors.pop()\\n remainder = root // factor\\n if factor not in results:\\n results[factor] = Solution.numFactoredTrees(factor, results, A_set)\\n if factor == remainder:\\n n += results[factor] * results[factor]\\n else:\\n factors.remove(remainder)\\n if remainder not in results:\\n results[remainder] = Solution.numFactoredTrees(remainder, results, A_set)\\n n += results[factor] * results[remainder] * 2\\n results[root] = n\\n return n\\n\\n def numFactoredBinaryTrees(self, A) -> int:\\n A.sort()\\n A_set = set(A)\\n results = {}\\n return sum([Solution.numFactoredTrees(a, results, A_set) for a in A]) % (10 ** 9 + 7)\\n\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A = sorted(A)\\n n = len(A)\\n dict_num = {}\\n for num in A:\\n dict_num[num] = True\\n dp_dict = {}\\n factor_pair = []\\n for i in range(n):\\n factor_pair.append([])\\n \\n for i in range(n):\\n for j in range(i):\\n if(A[i] % A[j] == 0 and A[i]//A[j] in dict_num):\\n factor_pair[i].append((A[j], A[i]//A[j]))\\n # print(factor_pair)\\n for i in range(n):\\n root = A[i]\\n num_trees = 1\\n for a, b in factor_pair[i]:\\n num_trees += dp_dict[a]*dp_dict[b]\\n \\n dp_dict[root] = num_trees\\n \\n answer = 0\\n for key in dp_dict:\\n answer += dp_dict[key]\\n \\n return answer % (10**9+7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n O = {}\\n ans = 0\\n for a in A:\\n if a not in O:\\n O[a] = 1\\n for k, v in list(O.items()):\\n if a % k == 0 and a // k in O:\\n O[a] += v * O[a // k]\\n ans += O[a]\\n return ans % 1000000007\\n\",\n \"\\n \\nclass Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n MOD = 10 ** 9 + 7\\n \\n n = len(A)\\n tips = sorted(A)\\n \\n \\n index = { x: i for i, x in enumerate(tips) }\\n d = [1] * n\\n \\n for i, x in enumerate(tips):\\n head = x\\n\\n for j in range(i):\\n x = tips[j]\\n \\n y = head // x\\n \\n if y*x != head:\\n continue\\n if y in index:\\n leaf_1 = j\\n leaf_2 = index[y]\\n d[i] = d[i] + (d[leaf_1] * d[leaf_2])\\n \\n return sum(d) % MOD\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n n = len(A)\\n dp = defaultdict(int)\\n res = 0\\n for i, num in enumerate(A):\\n dp[num] = 1\\n for j in range(i):\\n if num % A[j] == 0:\\n dp[num] += dp[A[j]] * dp[A[i]//A[j]]\\n res += dp[num]\\n return res % 1000000007\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n seen,A={},set(A)\\n def find_all(root):\\n if root in seen:\\n return seen[root]\\n combs=1\\n for left in A:\\n if root==left or root%left: continue\\n right=root//left\\n if right not in A: continue\\n combs+=find_all(left)*find_all(right)\\n seen[root]=combs\\n return combs\\n return sum(find_all(num) for num in sorted(A))%1000000007\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n mod = 10**9 + 7\\n processed = dict()\\n res = 0\\n for a in sorted(A):\\n counter = 1\\n for key, val in list(processed.items()):\\n key2 = a / key\\n val2 = processed.get(key2, 0)\\n if val2 != 0:\\n counter = (counter + val * val2) % mod\\n processed[a] = counter\\n res = (res + counter) % mod\\n return res\\n \\n \\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n n=len(A)\\n A.sort()\\n dp=[1]*n\\n mod=10**9+7\\n index={c:i for i,c in enumerate(A) }\\n \\n for i,x in enumerate(A):\\n for j in range(n):\\n if x%A[j]==0:\\n right=x/A[j]\\n if right in index:\\n dp[i]+=dp[j]*dp[index[right]]\\n dp[i]=dp[i]%mod\\n return sum(dp)%mod\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n factorSet = set(A)\\n A.sort()\\n treeCount = {}\\n\\n for num in A:\\n count = 1\\n for p, pCount in list(treeCount.items()):\\n q, rem = divmod(num, p)\\n if p > q:\\n break\\n if rem == 0 and q in treeCount:\\n count += pCount*treeCount[q] if p == q else 2*pCount*treeCount[q]\\n treeCount[num] = count\\n return sum(treeCount.values()) % (1000_000_000 + 7)\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n seen,A={},set(A)\\n def find_all(root):\\n if root in seen:\\n return seen[root]\\n combs=1\\n for left in A:\\n if root==left or root%left: continue\\n right=root//left\\n if right not in A: continue\\n combs+=find_all(left)*find_all(right)\\n seen[root]=combs\\n return combs\\n return sum(find_all(num) for num in A)%1000000007\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n dp = {i:1 for i in A}\\n res = 0\\n for idd, number in enumerate(A):\\n \\n for inner, inumber in enumerate(A[:idd]):\\n if number % inumber == 0 and ((number // inumber) in dp):\\n dp[number] += dp[inumber] * dp[number // inumber]\\n \\n res += dp[number]\\n res = res % (10 ** 9 + 7)\\n \\n return res\\n\",\n \"# 823. Binary Trees With Factors\\n\\nMOD = 10**9 + 7\\n\\ndef count_binary_trees (arr):\\n arr = sorted (arr)\\n coll = set (arr)\\n\\n count = {}\\n\\n for index, elem in enumerate (arr):\\n ans = 1\\n for i in range (index):\\n factor = arr[i]\\n if elem % factor == 0 and elem // factor in coll:\\n other_factor = elem // factor\\n ans = (ans + count[factor] * count[other_factor]) % MOD\\n\\n count[elem] = ans\\n\\n return sum (y for (x, y) in count.items ()) % MOD\\n\\nclass Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n return count_binary_trees(A)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A = sorted(A)\\n mems = {}\\n for ix in range(len(A)):\\n mems[A[ix]] = ix\\n \\n dp = [1] * len(A)\\n \\n big_mod = 10**9 + 7\\n \\n for i in range(len(A)):\\n extras = 0\\n for j in range(i):\\n d, mo = divmod(A[i], A[j])\\n if mo == 0:\\n if d in mems:\\n extras += dp[j] * dp[mems[d]]\\n extras = extras % big_mod\\n\\n dp[i] += extras\\n \\n result = sum(dp) % big_mod\\n \\n return result\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n # Time complexity: O(N^2)\\n # Space complexity: O(N)\\n A.sort()\\n dic = {num: 1 for num in A}\\n for i in range(1, len(A)):\\n for j in range(i):\\n q, res = divmod(A[i], A[j])\\n if res == 0 and q in dic:\\n dic[A[i]] += dic[q] * dic[A[j]]\\n\\n return sum(dic.values()) % (10**9 + 7)\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A = sorted(A)\\n mems = {}\\n for ix in range(len(A)):\\n mems[A[ix]] = ix\\n \\n dp = [1] * len(A)\\n \\n big_mod = 10**9 + 7\\n \\n for i in range(len(A)):\\n extras = 0\\n for j in range(i):\\n d, mo = divmod(A[i], A[j])\\n if mo == 0:\\n if d in mems:\\n extras += dp[j] * dp[mems[d]]\\n\\n extras = extras % big_mod\\n dp[i] += extras\\n \\n result = sum(dp) % big_mod\\n \\n return result\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n dp = {}\\n mod = 10**9+7\\n for a in A:\\n dp[a] = 1\\n for b in A:\\n if a%b==0 and b in dp and a//b in dp:\\n dp[a] += dp[b]*dp[a//b]\\n dp[a] %= mod\\n \\n return sum(dp.values())%mod\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n sorted_A = sorted(A)\\n dp = dict()\\n result = 0\\n \\n for i in range(len(sorted_A)):\\n cur_total = 0\\n for j in range(i + 1):\\n cur_val = sorted_A[i]\\n prev_val = sorted_A[j]\\n if i == j:\\n dp[cur_val] = cur_total + 1\\n result += cur_total + 1\\n elif (cur_val / prev_val) in dp:\\n cur_total += dp[cur_val/prev_val] * dp[prev_val]\\n \\n return result % (10 ** 9 + 7)\\n \\n '''\\n \\n \\n [18, 3, 6, 2]\\n [2, 3, 6, 18]\\n dp = {\\n 2 : 1\\n 3 : 1\\n 6 : 3\\n 18: 5\\n }\\n cur_val = 18\\n prev_val = 6\\n cur_total = 3 + 1 \\n result = 1 + 1 + 3 + 5\\n \\n \\n ''' \\n \\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n dp = {}\\n for a in sorted(A):\\n dp[a] = sum(dp[b] * dp.get(a/b, 0) for b in dp) + 1\\n return sum(dp.values()) % (10**9 + 7)\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n ans = 0\\n N = len(A)\\n cnt = [1 for _ in range(N)]\\n for i, n in enumerate(A):\\n l, r = 0, i - 1\\n while r >= l:\\n if A[r] * A[l] == n:\\n cnt[i] += cnt[r] * cnt[l] if r == l else cnt[r] * cnt[l] * 2\\n l += 1\\n r -= 1\\n elif A[r] * A[l] > n:\\n r -= 1\\n else:\\n l += 1\\n ans += cnt[i]\\n return ans % (10 ** 9 + 7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n factorSet = set(A)\\n A.sort()\\n treeCount = {}\\n\\n for num in A:\\n count = 1\\n for p, pCount in list(treeCount.items()):\\n q, rem = divmod(num, p)\\n if rem == 0:\\n count += pCount * treeCount.get(q, 0) \\n treeCount[num] = count\\n return sum(treeCount.values()) % (1000_000_000 + 7)\\n\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n t = {}\\n for a in A:\\n t[a] = 1 + sum(t[b] * t.get(a / b, 0) for b in A if b < a)\\n return sum(t.values()) % (pow(10, 9) + 7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n t = {}\\n for a in sorted(A):\\n t[a] = 1 + sum(t[b] * t.get(a/b, 0) for b in A if b < a)\\n return sum(t.values()) % (10**9 + 7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A): \\n \\n\\n t = {}\\n for a in sorted(A):\\n t[a] = 1 + sum(t[b] * t.get(a/b, 0) for b in A if b < a)\\n return sum(t.values()) % (10**9 + 7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n mymap = {}\\n for x in sorted(A):\\n # 1 for leaf, plus sum any that could be factors (y and currval/y)\\n mymap[x] = 1+ sum(mymap[y]*mymap.get(x/y,0) for y in A if y<x)\\n return sum(mymap.values())%(10**9+7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n A.sort()\\n n=len(A)\\n dp=[1 for i in range(n)]\\n for i in range(n):\\n start,end=0,i-1\\n while(start<=end):\\n if A[start]*A[end]<A[i]:\\n start+=1\\n continue\\n if A[start]*A[end]>A[i]:\\n end-=1\\n continue\\n if start==end: \\n dp[i]+=dp[start]*dp[end]\\n else:\\n dp[i]+=dp[start]*dp[end]*2\\n start+=1\\n end-=1\\n # print(dp)\\n return sum(dp)%(10**9+7)\",\n \"class Solution:\\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\\n n = len(A)\\n A.sort()\\n dp = [1] * n\\n res = 0\\n for i in range(n):\\n s = 0\\n e = i - 1\\n for s in range(i):\\n while s <= e and A[s] * A[e] > A[i]:\\n e -= 1\\n \\n if s > e:\\n break\\n \\n if A[s] * A[e] == A[i]:\\n dp[i] += ((dp[s] * dp[e] * 2) if s != e else (dp[s] * dp[e]))\\n dp[i] = dp[i] % (10 ** 9 + 7)\\n e -= 1\\n \\n res += dp[i]\\n res = res % (10 ** 9 + 7)\\n \\n return res\\n \\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":83,"string":"83"},"non_interactive_idx":{"kind":"list like","value":[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,80,81,82],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32,\n 33,\n 34,\n 35,\n 36,\n 37,\n 38,\n 39,\n 40,\n 41,\n 42,\n 43,\n 44,\n 45,\n 46,\n 47,\n 48,\n 49,\n 50,\n 51,\n 52,\n 53,\n 54,\n 55,\n 56,\n 57,\n 58,\n 59,\n 60,\n 61,\n 62,\n 63,\n 64,\n 65,\n 66,\n 67,\n 68,\n 69,\n 70,\n 71,\n 72,\n 73,\n 74,\n 75,\n 76,\n 77,\n 78,\n 79,\n 80,\n 81,\n 82\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[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,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":79,"cells":{"problem_id":{"kind":"number","value":213,"string":"213"},"question":{"kind":"string","value":"Implement pow(x, n), which calculates x raised to the power n (xn).\n\nExample 1:\n\n\nInput: 2.00000, 10\nOutput: 1024.00000\n\n\nExample 2:\n\n\nInput: 2.10000, 3\nOutput: 9.26100\n\n\nExample 3:\n\n\nInput: 2.00000, -2\nOutput: 0.25000\nExplanation: 2-2 = 1/22 = 1/4 = 0.25\n\n\nNote:\n\n\n -100.0 < x < 100.0\n n is a 32-bit signed integer, within the range [−231, 231 − 1]"},"solutions":{"kind":"string","value":"[\"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n == 0:\\n return 1\\n if abs(n) == 1:\\n if n == 1:\\n return x\\n else:\\n return 1/x\\n if n > 0:\\n a, b = int(n//2), n%2\\n else:\\n a, b = -int(-n//2), -(n%2)\\n y = self.myPow(x, a)\\n z = self.myPow(x, b)\\n return y*y*z\", \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n < 0:\\n return 1 / self.myPow(x, -n)\\n elif n == 1:\\n return x\\n elif n == 0:\\n return 1\\n elif n % 2:\\n return x * self.myPow(x, n - 1)\\n else:\\n t = self.myPow(x, n // 2)\\n return t * t\\n\", \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n < 0:\\n return 1 / self.myPow(x, -n)\\n elif n == 1:\\n return x\\n elif n == 0:\\n return 1\\n elif n % 2:\\n return x * self.myPow(x, n - 1)\\n else:\\n t = self.myPow(x, n // 2)\\n return t * t\\n\", \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if 0 <= n < 2:\\n return [1, x][n]\\n if n < 0:\\n n, x = -n, 1 / x\\n temp = divmod(n, 2)\\n return self.myPow(x, temp[0]) ** 2 * self.myPow(x, temp[1])\", \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n == 0:\\n return 1\\n if n == 1:\\n return x\\n if n < 0:\\n return self.myPow(1/x, -n)\\n if (n % 2) == 0:\\n return self.myPow(x*x, n/2) \\n else:\\n return self.myPow(x*x, (n-1)/2) * x\", \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n return pow(x,n)\", \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n == 0:\\n return 1\\n if n < 0:\\n n = -n\\n x = 1/x\\n if n % 2 == 0:\\n return self.myPow(x*x,n/2)\\n else:\\n return self.myPow(x*x,(n-1)/2)*x\", \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n<0:return 1/self.myPow(x,-n)\\n elif n==0:return 1\\n elif n>1000:return self.myPow(self.myPow(x,1000),n//1000)*self.myPow(x,n%1000)\\n else: return x*self.myPow(x,n-1)\", \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n return x**n\", \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n < 0:\\n return 1 / self.myPow(x, -n)\\n elif n == 1:\\n return x\\n elif n == 0:\\n return 1\\n elif n % 2:\\n return x * self.myPow(x, n - 1)\\n else:\\n t = self.myPow(x, n // 2)\\n return t * t\\n\", \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n output=1\\n power=0\\n power_applied=1\\n product=x\\n m=abs(n)\\n while m!=0 and power!=m:\\n if (power+power_applied*2)<m:\\n product=product*product\\n power_applied=power_applied*2\\n power=power+power_applied\\n else:\\n product=x\\n power_applied=1\\n power=power+power_applied\\n output=output*product\\n if n<0: output=1/output\\n return output\", \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if not n:\\n return 1\\n if n < 0:\\n return 1 / self.myPow(x, -n)\\n if n % 2:\\n return x * self.myPow(x, n-1)\\n return self.myPow(x*x, n/2)\\n\", \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n return x ** n\\n\", \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n == 0 :\\n return 1.00000\\n if n < 0 :\\n return 1 / self.myPow(x , -n)\\n \\n if n % 2 != 0 :\\n return x * self.myPow(x , n - 1)\\n return self.myPow(x * x , n / 2)\\n \\n\", \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n < 0:\\n return 1 / self.powRecu(x, -n)\\n \\n return self.powRecu(x, n)\\n \\n def powRecu(self, x, n):\\n if n == 0:\\n return 1.0\\n \\n if n % 2 == 0:\\n return self.powRecu(x * x, n // 2)\\n else:\\n return x * self.powRecu(x * x, n // 2)\", \"class Solution:\\n \\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n == 0: return 1\\n if n<0:\\n n= -n\\n x = 1/x\\n res = 1\\n \\n while n>0:\\n cnt = 1\\n mul = x\\n while (cnt+cnt) <= n:\\n mul = mul * mul\\n cnt += cnt\\n n = n - cnt\\n res = mul * res\\n if n%2 == 1: res = res*x\\n \\n return res\", \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n return x**n\\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"myPow\", \"inputs\": [[2.0, 10]], \"outputs\": [1024.0]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/powx-n/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def myPow(self, x: float, n: int) -> float:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n if n == 0:\n return 1\n if abs(n) == 1:\n if n == 1:\n return x\n else:\n return 1/x\n if n > 0:\n a, b = int(n//2), n%2\n else:\n a, b = -int(-n//2), -(n%2)\n y = self.myPow(x, a)\n z = self.myPow(x, b)\n return y*y*z","class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n if n < 0:\n return 1 / self.myPow(x, -n)\n elif n == 1:\n return x\n elif n == 0:\n return 1\n elif n % 2:\n return x * self.myPow(x, n - 1)\n else:\n t = self.myPow(x, n // 2)\n return t * t\n","class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n if n < 0:\n return 1 / self.myPow(x, -n)\n elif n == 1:\n return x\n elif n == 0:\n return 1\n elif n % 2:\n return x * self.myPow(x, n - 1)\n else:\n t = self.myPow(x, n // 2)\n return t * t\n","class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n if 0 <= n < 2:\n return [1, x][n]\n if n < 0:\n n, x = -n, 1 / x\n temp = divmod(n, 2)\n return self.myPow(x, temp[0]) ** 2 * self.myPow(x, temp[1])","class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n if n == 0:\n return 1\n if n == 1:\n return x\n if n < 0:\n return self.myPow(1/x, -n)\n if (n % 2) == 0:\n return self.myPow(x*x, n/2) \n else:\n return self.myPow(x*x, (n-1)/2) * x","class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n return pow(x,n)","class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n if n == 0:\n return 1\n if n < 0:\n n = -n\n x = 1/x\n if n % 2 == 0:\n return self.myPow(x*x,n/2)\n else:\n return self.myPow(x*x,(n-1)/2)*x","class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n if n<0:return 1/self.myPow(x,-n)\n elif n==0:return 1\n elif n>1000:return self.myPow(self.myPow(x,1000),n//1000)*self.myPow(x,n%1000)\n else: return x*self.myPow(x,n-1)","class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n return x**n","class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n if n < 0:\n return 1 / self.myPow(x, -n)\n elif n == 1:\n return x\n elif n == 0:\n return 1\n elif n % 2:\n return x * self.myPow(x, n - 1)\n else:\n t = self.myPow(x, n // 2)\n return t * t\n","class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n output=1\n power=0\n power_applied=1\n product=x\n m=abs(n)\n while m!=0 and power!=m:\n if (power+power_applied*2)<m:\n product=product*product\n power_applied=power_applied*2\n power=power+power_applied\n else:\n product=x\n power_applied=1\n power=power+power_applied\n output=output*product\n if n<0: output=1/output\n return output","class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n if not n:\n return 1\n if n < 0:\n return 1 / self.myPow(x, -n)\n if n % 2:\n return x * self.myPow(x, n-1)\n return self.myPow(x*x, n/2)\n","class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n return x ** n\n","class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n if n == 0 :\n return 1.00000\n if n < 0 :\n return 1 / self.myPow(x , -n)\n \n if n % 2 != 0 :\n return x * self.myPow(x , n - 1)\n return self.myPow(x * x , n / 2)\n \n","class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n if n < 0:\n return 1 / self.powRecu(x, -n)\n \n return self.powRecu(x, n)\n \n def powRecu(self, x, n):\n if n == 0:\n return 1.0\n \n if n % 2 == 0:\n return self.powRecu(x * x, n // 2)\n else:\n return x * self.powRecu(x * x, n // 2)","class Solution:\n \n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n if n == 0: return 1\n if n<0:\n n= -n\n x = 1/x\n res = 1\n \n while n>0:\n cnt = 1\n mul = x\n while (cnt+cnt) <= n:\n mul = mul * mul\n cnt += cnt\n n = n - cnt\n res = mul * res\n if n%2 == 1: res = res*x\n \n return res","class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n return x**n\n"],"string":"[\n \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n == 0:\\n return 1\\n if abs(n) == 1:\\n if n == 1:\\n return x\\n else:\\n return 1/x\\n if n > 0:\\n a, b = int(n//2), n%2\\n else:\\n a, b = -int(-n//2), -(n%2)\\n y = self.myPow(x, a)\\n z = self.myPow(x, b)\\n return y*y*z\",\n \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n < 0:\\n return 1 / self.myPow(x, -n)\\n elif n == 1:\\n return x\\n elif n == 0:\\n return 1\\n elif n % 2:\\n return x * self.myPow(x, n - 1)\\n else:\\n t = self.myPow(x, n // 2)\\n return t * t\\n\",\n \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n < 0:\\n return 1 / self.myPow(x, -n)\\n elif n == 1:\\n return x\\n elif n == 0:\\n return 1\\n elif n % 2:\\n return x * self.myPow(x, n - 1)\\n else:\\n t = self.myPow(x, n // 2)\\n return t * t\\n\",\n \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if 0 <= n < 2:\\n return [1, x][n]\\n if n < 0:\\n n, x = -n, 1 / x\\n temp = divmod(n, 2)\\n return self.myPow(x, temp[0]) ** 2 * self.myPow(x, temp[1])\",\n \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n == 0:\\n return 1\\n if n == 1:\\n return x\\n if n < 0:\\n return self.myPow(1/x, -n)\\n if (n % 2) == 0:\\n return self.myPow(x*x, n/2) \\n else:\\n return self.myPow(x*x, (n-1)/2) * x\",\n \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n return pow(x,n)\",\n \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n == 0:\\n return 1\\n if n < 0:\\n n = -n\\n x = 1/x\\n if n % 2 == 0:\\n return self.myPow(x*x,n/2)\\n else:\\n return self.myPow(x*x,(n-1)/2)*x\",\n \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n<0:return 1/self.myPow(x,-n)\\n elif n==0:return 1\\n elif n>1000:return self.myPow(self.myPow(x,1000),n//1000)*self.myPow(x,n%1000)\\n else: return x*self.myPow(x,n-1)\",\n \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n return x**n\",\n \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n < 0:\\n return 1 / self.myPow(x, -n)\\n elif n == 1:\\n return x\\n elif n == 0:\\n return 1\\n elif n % 2:\\n return x * self.myPow(x, n - 1)\\n else:\\n t = self.myPow(x, n // 2)\\n return t * t\\n\",\n \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n output=1\\n power=0\\n power_applied=1\\n product=x\\n m=abs(n)\\n while m!=0 and power!=m:\\n if (power+power_applied*2)<m:\\n product=product*product\\n power_applied=power_applied*2\\n power=power+power_applied\\n else:\\n product=x\\n power_applied=1\\n power=power+power_applied\\n output=output*product\\n if n<0: output=1/output\\n return output\",\n \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if not n:\\n return 1\\n if n < 0:\\n return 1 / self.myPow(x, -n)\\n if n % 2:\\n return x * self.myPow(x, n-1)\\n return self.myPow(x*x, n/2)\\n\",\n \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n return x ** n\\n\",\n \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n == 0 :\\n return 1.00000\\n if n < 0 :\\n return 1 / self.myPow(x , -n)\\n \\n if n % 2 != 0 :\\n return x * self.myPow(x , n - 1)\\n return self.myPow(x * x , n / 2)\\n \\n\",\n \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n < 0:\\n return 1 / self.powRecu(x, -n)\\n \\n return self.powRecu(x, n)\\n \\n def powRecu(self, x, n):\\n if n == 0:\\n return 1.0\\n \\n if n % 2 == 0:\\n return self.powRecu(x * x, n // 2)\\n else:\\n return x * self.powRecu(x * x, n // 2)\",\n \"class Solution:\\n \\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n if n == 0: return 1\\n if n<0:\\n n= -n\\n x = 1/x\\n res = 1\\n \\n while n>0:\\n cnt = 1\\n mul = x\\n while (cnt+cnt) <= n:\\n mul = mul * mul\\n cnt += cnt\\n n = n - cnt\\n res = mul * res\\n if n%2 == 1: res = res*x\\n \\n return res\",\n \"class Solution:\\n def myPow(self, x, n):\\n \\\"\\\"\\\"\\n :type x: float\\n :type n: int\\n :rtype: float\\n \\\"\\\"\\\"\\n return x**n\\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":17,"string":"17"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":80,"cells":{"problem_id":{"kind":"number","value":214,"string":"214"},"question":{"kind":"string","value":"Given an array nums of integers, a move consists of choosing any element and decreasing it by 1.\nAn array A is a zigzag array if either:\n\nEvery even-indexed element is greater than adjacent elements, ie. A[0] > A[1] < A[2] > A[3] < A[4] > ...\nOR, every odd-indexed element is greater than adjacent elements, ie. A[0] < A[1] > A[2] < A[3] > A[4] < ...\n\nReturn the minimum number of moves to transform the given array nums into a zigzag array.\n \nExample 1:\nInput: nums = [1,2,3]\nOutput: 2\nExplanation: We can decrease 2 to 0 or 3 to 1.\n\nExample 2:\nInput: nums = [9,6,1,6,2]\nOutput: 4\n\n \nConstraints:\n\n1 <= nums.length <= 1000\n1 <= nums[i] <= 1000"},"solutions":{"kind":"string","value":"[\"class Solution:\\n def movesToMakeZigzag(self, nums):\\n n = len(nums)\\n res0 = 0\\n for i in range(0, n, 2):\\n nei = min(nums[j] for j in [i - 1, i + 1] if 0 <= j <= n-1)\\n if nums[i] >= nei:\\n res0 += nums[i] - nei + 1\\n res1 = 0\\n for i in range(1, n, 2):\\n nei = min(nums[j] for j in [i - 1, i + 1] if 0 <= j <= n-1)\\n if nums[i] >= nei:\\n res1 += nums[i] - nei + 1\\n return min(res0, res1)\", \"class Solution:\\n def movesToMakeZigzag(self, nums: List[int]) -> int:\\n # do either first case or second case\\n even = odd = 0\\n n = len(nums)\\n for i in range(n):\\n prev = nums[i - 1] if (i - 1) >= 0 else float('inf')\\n next = nums[i + 1] if (i + 1) < n else float('inf')\\n \\n change = max(0, nums[i] - min(prev, next) + 1)\\n \\n if i % 2 == 0:\\n even += change\\n else:\\n odd += change\\n \\n return min(even, odd)\", \"class Solution:\\n def movesToMakeZigzag(self, nums: List[int]) -> int:\\n return self.sb(nums)\\n \\n '''\\n \\uac4d even \\uc744 \\uc791\\uac8c\\ub9cc\\ub4e4\\uac70\\ub098\\uc8fc\\ubcc0\\ubcf4\\ub2e4 \\ud639\\uc740 odd\\ub97c \\uc8fc\\ubcc0\\ubcf4\\ub2e4 \\uc791\\uac8c\\ub9cc\\ub4e4\\uac70\\ub098 \\u3147\\u3147\\n '''\\n def sb(self, nums):\\n nums = [float('inf')] + nums + [float('inf')]\\n \\n res = [0,0]\\n \\n for i in range(1, len(nums)-1):\\n res[i%2] += max(0, (nums[i] - min(nums[i-1],nums[i+1])+1)) # \\uc8fc\\ubcc0\\uc774 \\ub2e4 \\ub098\\ubcf4\\ub2e4 \\ud06c\\uba74 \\uc6c0\\uc9c1\\uc774\\uc9c0\\uc54a\\uc544\\ub3c4\\ub40c :) \\ud639\\uc740 \\ub098\\ubcf4\\ub2e4 \\uc791\\uc740\\uc560\\uc788\\uc73c\\uba74 \\ud070\\ub9cc\\ud07c + 1 \\uc904\\uc5ec\\uc57c\\ud568\\n return min(res)\", \"class Solution:\\n def movesToMakeZigzag(self, nums: List[int]) -> int:\\n if len(nums) <= 2:\\n return 0\\n n = len(nums)\\n if n%2 == 0:\\n step1 = max(0,nums[-1]-nums[-2]+1)\\n for i in range(1,n-1,2):\\n step1 += max(0, nums[i] - min(nums[i-1], nums[i+1])+1)\\n step2 = max(0, nums[0]-nums[1] +1)\\n for i in range(2,n,2):\\n step2 += max(0, nums[i] - min(nums[i-1], nums[i+1])+1)\\n else:\\n step1 = max(0,nums[-1]-nums[-2]+1) + max(0, nums[0]-nums[1] +1)\\n for i in range(2,n-1,2):\\n step1 += max(0, nums[i] - min(nums[i-1], nums[i+1])+1)\\n step2 = 0\\n for i in range(1,n,2):\\n step2 += max(0, nums[i] - min(nums[i-1], nums[i+1])+1)\\n return min(step1, step2)\", \"class Solution:\\n def movesToMakeZigzag(self, A: List[int]) -> int:\\n res1=0\\n n=len(A)\\n B=A.copy()\\n for i in range(1,n,2):\\n if A[i-1]<=A[i]:\\n t=A[i]-A[i-1]+1\\n res1+=t\\n A[i]=A[i-1]-1\\n if i+1<n and A[i+1]<=A[i]:\\n t=A[i]-A[i+1]+1\\n res1+=t\\n A[i]=A[i+1]-1\\n res2=0\\n for i in range(0,n,2):\\n if i-1>=0 and B[i]>=B[i-1]:\\n t=B[i]-B[i-1]+1\\n res2+=t\\n B[i]=B[i-1]-1\\n if i+1<n and B[i+1]<=B[i]:\\n t=B[i]-B[i+1]+1\\n res2+=t\\n B[i]=B[i+1]-1\\n # print(A)\\n # print(B)\\n # print(res1,res2)\\n return min(res1,res2)\", \"class Solution:\\n def movesToMakeZigzag(self, nums: List[int]) -> int:\\n res = [0, 0]\\n \\n for i in range(len(nums)):\\n res[i%2] += max(nums[i] + 1 - min(nums[i-1] if i else float('inf'), nums[i+1] if i < len(nums) - 1 else float('inf')), 0)\\n \\n return min(res)\\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"movesToMakeZigzag\", \"inputs\": [[[1, 2, 3]]], \"outputs\": [2]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/decrease-elements-to-make-array-zigzag/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def movesToMakeZigzag(self, nums: List[int]) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def movesToMakeZigzag(self, nums):\n n = len(nums)\n res0 = 0\n for i in range(0, n, 2):\n nei = min(nums[j] for j in [i - 1, i + 1] if 0 <= j <= n-1)\n if nums[i] >= nei:\n res0 += nums[i] - nei + 1\n res1 = 0\n for i in range(1, n, 2):\n nei = min(nums[j] for j in [i - 1, i + 1] if 0 <= j <= n-1)\n if nums[i] >= nei:\n res1 += nums[i] - nei + 1\n return min(res0, res1)","class Solution:\n def movesToMakeZigzag(self, nums: List[int]) -> int:\n # do either first case or second case\n even = odd = 0\n n = len(nums)\n for i in range(n):\n prev = nums[i - 1] if (i - 1) >= 0 else float('inf')\n next = nums[i + 1] if (i + 1) < n else float('inf')\n \n change = max(0, nums[i] - min(prev, next) + 1)\n \n if i % 2 == 0:\n even += change\n else:\n odd += change\n \n return min(even, odd)","class Solution:\n def movesToMakeZigzag(self, nums: List[int]) -> int:\n return self.sb(nums)\n \n '''\n 걍 even 을 작게만들거나주변보다 혹은 odd를 주변보다 작게만들거나 ㅇㅇ\n '''\n def sb(self, nums):\n nums = [float('inf')] + nums + [float('inf')]\n \n res = [0,0]\n \n for i in range(1, len(nums)-1):\n res[i%2] += max(0, (nums[i] - min(nums[i-1],nums[i+1])+1)) # 주변이 다 나보다 크면 움직이지않아도됌 :) 혹은 나보다 작은애있으면 큰만큼 + 1 줄여야함\n return min(res)","class Solution:\n def movesToMakeZigzag(self, nums: List[int]) -> int:\n if len(nums) <= 2:\n return 0\n n = len(nums)\n if n%2 == 0:\n step1 = max(0,nums[-1]-nums[-2]+1)\n for i in range(1,n-1,2):\n step1 += max(0, nums[i] - min(nums[i-1], nums[i+1])+1)\n step2 = max(0, nums[0]-nums[1] +1)\n for i in range(2,n,2):\n step2 += max(0, nums[i] - min(nums[i-1], nums[i+1])+1)\n else:\n step1 = max(0,nums[-1]-nums[-2]+1) + max(0, nums[0]-nums[1] +1)\n for i in range(2,n-1,2):\n step1 += max(0, nums[i] - min(nums[i-1], nums[i+1])+1)\n step2 = 0\n for i in range(1,n,2):\n step2 += max(0, nums[i] - min(nums[i-1], nums[i+1])+1)\n return min(step1, step2)","class Solution:\n def movesToMakeZigzag(self, A: List[int]) -> int:\n res1=0\n n=len(A)\n B=A.copy()\n for i in range(1,n,2):\n if A[i-1]<=A[i]:\n t=A[i]-A[i-1]+1\n res1+=t\n A[i]=A[i-1]-1\n if i+1<n and A[i+1]<=A[i]:\n t=A[i]-A[i+1]+1\n res1+=t\n A[i]=A[i+1]-1\n res2=0\n for i in range(0,n,2):\n if i-1>=0 and B[i]>=B[i-1]:\n t=B[i]-B[i-1]+1\n res2+=t\n B[i]=B[i-1]-1\n if i+1<n and B[i+1]<=B[i]:\n t=B[i]-B[i+1]+1\n res2+=t\n B[i]=B[i+1]-1\n # print(A)\n # print(B)\n # print(res1,res2)\n return min(res1,res2)","class Solution:\n def movesToMakeZigzag(self, nums: List[int]) -> int:\n res = [0, 0]\n \n for i in range(len(nums)):\n res[i%2] += max(nums[i] + 1 - min(nums[i-1] if i else float('inf'), nums[i+1] if i < len(nums) - 1 else float('inf')), 0)\n \n return min(res)\n"],"string":"[\n \"class Solution:\\n def movesToMakeZigzag(self, nums):\\n n = len(nums)\\n res0 = 0\\n for i in range(0, n, 2):\\n nei = min(nums[j] for j in [i - 1, i + 1] if 0 <= j <= n-1)\\n if nums[i] >= nei:\\n res0 += nums[i] - nei + 1\\n res1 = 0\\n for i in range(1, n, 2):\\n nei = min(nums[j] for j in [i - 1, i + 1] if 0 <= j <= n-1)\\n if nums[i] >= nei:\\n res1 += nums[i] - nei + 1\\n return min(res0, res1)\",\n \"class Solution:\\n def movesToMakeZigzag(self, nums: List[int]) -> int:\\n # do either first case or second case\\n even = odd = 0\\n n = len(nums)\\n for i in range(n):\\n prev = nums[i - 1] if (i - 1) >= 0 else float('inf')\\n next = nums[i + 1] if (i + 1) < n else float('inf')\\n \\n change = max(0, nums[i] - min(prev, next) + 1)\\n \\n if i % 2 == 0:\\n even += change\\n else:\\n odd += change\\n \\n return min(even, odd)\",\n \"class Solution:\\n def movesToMakeZigzag(self, nums: List[int]) -> int:\\n return self.sb(nums)\\n \\n '''\\n 걍 even 을 작게만들거나주변보다 혹은 odd를 주변보다 작게만들거나 ㅇㅇ\\n '''\\n def sb(self, nums):\\n nums = [float('inf')] + nums + [float('inf')]\\n \\n res = [0,0]\\n \\n for i in range(1, len(nums)-1):\\n res[i%2] += max(0, (nums[i] - min(nums[i-1],nums[i+1])+1)) # 주변이 다 나보다 크면 움직이지않아도됌 :) 혹은 나보다 작은애있으면 큰만큼 + 1 줄여야함\\n return min(res)\",\n \"class Solution:\\n def movesToMakeZigzag(self, nums: List[int]) -> int:\\n if len(nums) <= 2:\\n return 0\\n n = len(nums)\\n if n%2 == 0:\\n step1 = max(0,nums[-1]-nums[-2]+1)\\n for i in range(1,n-1,2):\\n step1 += max(0, nums[i] - min(nums[i-1], nums[i+1])+1)\\n step2 = max(0, nums[0]-nums[1] +1)\\n for i in range(2,n,2):\\n step2 += max(0, nums[i] - min(nums[i-1], nums[i+1])+1)\\n else:\\n step1 = max(0,nums[-1]-nums[-2]+1) + max(0, nums[0]-nums[1] +1)\\n for i in range(2,n-1,2):\\n step1 += max(0, nums[i] - min(nums[i-1], nums[i+1])+1)\\n step2 = 0\\n for i in range(1,n,2):\\n step2 += max(0, nums[i] - min(nums[i-1], nums[i+1])+1)\\n return min(step1, step2)\",\n \"class Solution:\\n def movesToMakeZigzag(self, A: List[int]) -> int:\\n res1=0\\n n=len(A)\\n B=A.copy()\\n for i in range(1,n,2):\\n if A[i-1]<=A[i]:\\n t=A[i]-A[i-1]+1\\n res1+=t\\n A[i]=A[i-1]-1\\n if i+1<n and A[i+1]<=A[i]:\\n t=A[i]-A[i+1]+1\\n res1+=t\\n A[i]=A[i+1]-1\\n res2=0\\n for i in range(0,n,2):\\n if i-1>=0 and B[i]>=B[i-1]:\\n t=B[i]-B[i-1]+1\\n res2+=t\\n B[i]=B[i-1]-1\\n if i+1<n and B[i+1]<=B[i]:\\n t=B[i]-B[i+1]+1\\n res2+=t\\n B[i]=B[i+1]-1\\n # print(A)\\n # print(B)\\n # print(res1,res2)\\n return min(res1,res2)\",\n \"class Solution:\\n def movesToMakeZigzag(self, nums: List[int]) -> int:\\n res = [0, 0]\\n \\n for i in range(len(nums)):\\n res[i%2] += max(nums[i] + 1 - min(nums[i-1] if i else float('inf'), nums[i+1] if i < len(nums) - 1 else float('inf')), 0)\\n \\n return min(res)\\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":6,"string":"6"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4,5],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":81,"cells":{"problem_id":{"kind":"number","value":215,"string":"215"},"question":{"kind":"string","value":"Given an array nums of positive integers. Your task is to select some subset of nums, multiply each element by an integer and add all these numbers. The array is said to be good if you can obtain a sum of 1 from the array by any possible subset and multiplicand.\nReturn True if the array is good otherwise return False.\n \nExample 1:\nInput: nums = [12,5,7,23]\nOutput: true\nExplanation: Pick numbers 5 and 7.\n5*3 + 7*(-2) = 1\n\nExample 2:\nInput: nums = [29,6,10]\nOutput: true\nExplanation: Pick numbers 29, 6 and 10.\n29*1 + 6*(-3) + 10*(-1) = 1\n\nExample 3:\nInput: nums = [3,6]\nOutput: false\n\n \nConstraints:\n\n1 <= nums.length <= 10^5\n1 <= nums[i] <= 10^9"},"solutions":{"kind":"string","value":"[\"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n n = nums[0]\\n \\n for i in nums:\\n n = gcd(i,n)\\n \\n if n==1:\\n return True\\n return False\\n\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n if not nums: return False\\n a=nums[0]\\n for i in range(1, len(nums)):\\n a=gcd(a,nums[i])\\n return a==1\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n def gcd(x,y):\\n while y:\\n x,y=y,x%y\\n return x\\n g=nums[0]\\n for x in nums:\\n g=gcd(g,x)\\n return g==1\\n\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n def gcd(x: int, y: int) -> int:\\n if y == 0:\\n return x\\n else:\\n return gcd(y, x % y)\\n \\n result = nums[0]\\n for num in nums:\\n result = gcd(result, num)\\n \\n return result == 1\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n gcd = nums[0]\\n for a in nums:\\n while a:\\n gcd, a = a, gcd % a\\n return gcd == 1\\n\", \"class Solution:\\n def gcd(self,a,b):\\n return a if b==0 else self.gcd(b,a%b)\\n def isGoodArray(self, nums: List[int]) -> bool:\\n nums=list(set(nums))\\n n=len(nums)\\n if n==1 and nums[0]==1:return True\\n cur=nums[0] \\n for i in range(1,n):\\n cur=self.gcd(cur,nums[i])\\n if cur==1:return True\\n return False\", \"class Solution:\\n def gcd(self, a, b):\\n if a == 0:\\n return b\\n if b == 0:\\n return a\\n if a == 1 or b == 1:\\n return 1\\n while b != 0:\\n a, b = b, a % b\\n return a\\n \\n def isGoodArray(self, nums: List[int]) -> bool:\\n g = 0\\n for n in nums:\\n if g == 0:\\n g = n\\n elif n == 1:\\n return True\\n else:\\n while n:\\n g, n = n, g % n\\n if g == 1:\\n return True\\n return False\", \"class Solution:\\n \\n def gcd(self, a:int, b:int) -> int:\\n a,b = max(a,b),min(a,b)\\n while b>0:\\n a,b = b,a%b\\n return a\\n \\n def isGoodArray(self, nums: List[int]) -> bool:\\n lowest = nums[0]\\n for i in nums[1:]:\\n lowest = self.gcd(lowest,i)\\n return lowest==1\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n if len(nums) == 1:\\n return nums[0] == 1\\n def gcd(a, b):\\n while b:\\n a, b = b, a % b\\n return a\\n \\n gcd_val = nums[0]\\n for i in range(1, len(nums)):\\n gcd_val = gcd(gcd_val, nums[i])\\n if gcd_val == 1:\\n return True\\n return False\", \"def gcd(a,b):\\n if(b==0):\\n return a\\n return gcd(b,a%b)\\n\\nclass Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n if(nums==[1]):\\n return True\\n i=0\\n a=nums[i]\\n for j in range(i+1,len(nums)):\\n if(a<nums[j]):\\n b=gcd(nums[j],a)\\n if(b==1):\\n return True\\n else:\\n a=b\\n else:\\n b=(gcd(a,nums[j]))\\n if(b==1):\\n return True\\n else:\\n a=b\\n return False\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n gcd = nums[0]\\n for n in nums:\\n while n:\\n gcd, n = n, gcd % n\\n return gcd == 1\\n \\n\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n def gcd(a, b):\\n a, b = max(a,b), min(a,b)\\n while b:\\n a, b = b, a%b\\n return a\\n if len(nums) == 1:\\n if nums != [1]:\\n return False\\n else:\\n return True\\n i = 0\\n d = nums[0]\\n while i < len(nums):\\n d = gcd(nums[i],d)\\n if d == 1:\\n return True\\n i += 1\\n return False\\n\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n \\n def gcd(x, y):\\n if x < y:\\n x, y = y, x\\n if not x % y:\\n return y\\n return gcd(x % y, y)\\n \\n if len(nums) == 1:\\n if nums[0] == 1:\\n return True\\n return False\\n \\n while True:\\n x = nums.pop(-1)\\n y = nums.pop(-1)\\n z = gcd(x, y)\\n if not nums:\\n return z == 1\\n \\n nums.append(z)\\n\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n \\n def euclid(a,b):\\n q, r = max(a,b), min(a,b)\\n while r > 1 and q > 0:\\n r, q = q % r, r\\n return r if r > 0 else q\\n \\n if len(nums) == 1:\\n return True if nums[0] == 1 else False\\n \\n nums.sort()\\n for i in range(1,len(nums)):\\n nums[i] = euclid(nums[i],nums[i-1])\\n if nums[i] == 1:\\n return True\\n \\n return False\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n def euclid(a,b):\\n q, r = max(a,b), min(a,b)\\n while r > 1 and q > 0:\\n r, q = q % r, r\\n return r if r > 0 else q\\n \\n if len(nums) == 1:\\n return True if nums[0] == 1 else False\\n \\n for i in range(1,len(nums)):\\n nums[i] = euclid(nums[i],nums[i-1])\\n if nums[i] == 1:\\n return True\\n \\n return False\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n def gcd(a, b):\\n if b>0:\\n return gcd(b, a%b)\\n return a\\n if not nums:\\n return False\\n if len(nums)==1:\\n return nums[0]==1\\n num = nums[0]\\n for i in range(1, len(nums)):\\n ans = gcd(num, nums[i])\\n if ans==1:\\n return True\\n num = ans\\n return False\\n\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n if len(nums) == 1:\\n if nums[0] == 1:\\n return True\\n else:\\n return False\\n \\n ans = self.gcd(nums[0],nums[1])\\n for num in nums[2:]:\\n ans = self.gcd(ans,num)\\n if ans == 1:\\n return True\\n return ans == 1\\n def gcd(self, a,b) :\\n if b == 0:\\n return a\\n return self.gcd(b,a%b)\\n\", \"from math import gcd\\nfrom functools import reduce\\n\\nclass Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n return (reduce((lambda x, y: gcd(x,y)), nums) == 1)\\n \\n# class Solution:\\n# def gcd(x, y):\\n# gcd_ = i\\n# for i in range(2, min(x, y)):\\n# if x%i == 0 and y%i == 0:\\n# gcd_ = i\\n# return gcd_\\n# def isGoodArray(self, nums: List[int]) -> bool:\\n# itergcd = nums[0]\\n# for i in nums:\\n# itergcd = gcd(itergcd, i)\\n# return itergcd == 1\\n \\n\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n import math\\n curr_gcd = nums[0]\\n for i in range(1, len(nums)):\\n curr_gcd = math.gcd(curr_gcd, nums[i])\\n if curr_gcd == 1:\\n return True\\n return curr_gcd == 1\\n \\n # if 1 in nums: return True\\n \\n# def find_factors(num):\\n# sol = set()\\n# for i in range(1,math.ceil(math.sqrt(num))):\\n# if num % i == 0:\\n# sol.add(i)\\n# sol.add(num/i)\\n# # sol.remove(num)\\n# sol.remove(1)\\n# return sol\\n \\n# all_items = set()\\n# factors_list = []\\n# for num in nums:\\n# temp_set = find_factors(num)\\n# for it in temp_set:\\n# all_items.add(it)\\n \\n# factors_list.append(temp_set)\\n# # print(all_items)\\n# # print(factors_list) \\n# for it in all_items:\\n# if it == 1: continue\\n# if all([it in lis for lis in factors_list]):\\n# return False\\n\\n# return True\\n \\n \\n \\n \\n '''\\n 29, 6, 10\\n 29, 3*2, 5*2\\n '''\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n for i in range(len(nums)):\\n nums[i] = gcd(nums[i],nums[i-1]) if i > 0 else nums[0]\\n \\n return nums[-1]==1\\n \\n\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n def gcd(x,y):\\n if y > x:\\n return gcd(y,x)\\n if y == 0:\\n return x\\n return gcd(y,x%y) \\n cur = nums[0]\\n for i in range(1, len(nums)):\\n cur = gcd(cur,nums[i])\\n \\n return cur == 1\\n\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n g=nums[0]\\n for i in nums:g=gcd(i,g)\\n return g==1\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n gcd = nums[0]\\n for num in nums:\\n while num:\\n gcd, num = num, gcd % num\\n if gcd == 1:\\n return True\\n return False\\n\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n \\n def gcd(a,b):\\n if b > a:\\n a,b = b,a\\n while (b > 0):\\n r = divmod(a,b)[1]\\n a = b\\n b = r\\n return a\\n \\n if len(nums) == 0: return 0\\n if len(nums) == 1: return nums[0] == 1\\n \\n ans = nums[0]\\n \\n for i in range(1,len(nums)):\\n ans = gcd(ans,nums[i])\\n if ans == 1: return True\\n \\n return ans == 1\", \"class Solution:\\n def gcd(self, nums):\\n g = nums[0]\\n for x in nums:\\n while x:\\n g, x = x, g%x\\n return g\\n\\n # a: list of integers\\n # d: desired GCD of the integers in a\\n def bezout(self, a: [int], d):\\n if self.gcd(a) == d:\\n return True\\n return False\\n\\n def isGoodArray(self, nums: [int]) -> bool:\\n return self.bezout(nums, 1)\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n gcd = nums[0]\\n for n in nums:\\n while n:\\n gcd, n = n, gcd % n\\n \\n return gcd == 1\", \"class Solution:\\n def getGCD(self, x: int, y: int) -> int:\\n while y:\\n x, y = y, x % y\\n return x \\n def getLCM(self, x: int, y: int) -> int:\\n return x * y // self.getGCD(x, y)\\n def isGoodArray(self, nums: List[int]) -> bool:\\n # question is equivalent to have any substr with gcd equals 1, iff array has gcd equals to 1\\n n = len(nums)\\n x, i = nums[0], 1\\n while i < n:\\n x = self.getGCD(x, nums[i])\\n if x == 1:\\n return True\\n i += 1\\n return x == 1\", \"class Solution:\\n def isGoodArray(self, A: List[int]) -> bool:\\n gcd = A[0]\\n for a in A:\\n while a:\\n gcd, a = a, gcd % a\\n if gcd == 1:\\n return gcd\\n return False\", \"from fractions import gcd\\nfrom functools import reduce\\nclass Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n def find_gcd(list):\\n x = reduce(gcd, list)\\n return x\\n if find_gcd(nums)==1:\\n return True\\n return False\\n\\n\", \"# from math import gcd\\n# from functools import reduce\\n\\n# class Solution:\\n# def isGoodArray(self, nums: List[int]) -> bool:\\n# return (reduce((lambda x, y: gcd(x,y)), nums) == 1)\\n \\nclass Solution:\\n def gcd(x, y):\\n gcd_ = i\\n for i in range(2, min(x, y)):\\n if x%i == 0 and y%i == 0:\\n gcd_ = i\\n return gcd_\\n def isGoodArray(self, nums: List[int]) -> bool:\\n start = nums[0]\\n for i in nums:\\n start = gcd(start, i)\\n return start == 1\\n \\n\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n g=nums[0]\\n for i in nums:\\n g=self.hcfnaive(i,g)\\n return g==1\\n \\n \\n def hcfnaive(self,a,b): \\n if(b==0): \\n return a \\n else: \\n return self.hcfnaive(b,a%b) \\n\", \"class Solution:\\n def isGoodArray(self, x: List[int]) -> bool:\\n g=x[0]\\n for i in x:g=gcd(i,g)\\n return g==1\\n\", \"from functools import reduce\\nclass Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n return reduce(gcd, nums) < 2\\n \\n\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n \\n if len(nums) == 1:\\n if nums[0] == 1:\\n return True\\n else:\\n return False\\n \\n now = -1\\n for i in range(1, len(nums)):\\n if i == 1:\\n now = math.gcd(nums[i-1], nums[i])\\n else:\\n now = math.gcd(nums[i],now)\\n \\n \\n if now == 1:\\n return True\\n return False\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n res = nums[0]\\n \\n for i in range(1, len(nums)):\\n res = math.gcd(res, nums[i])\\n if res == 1:\\n return True\\n \\n return res == 1\\n\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n \\n if len(nums) == 1:\\n return True if nums[0] == 1 else False\\n \\n for i in range(1,len(nums)):\\n nums[i] = gcd(nums[i],nums[i-1])\\n if nums[i] == 1:\\n return True\\n \\n return False\\n \\n\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n# primeSet = set()\\n# def isPrime(x):\\n# if x < 2 or x in primeSet:\\n# return False\\n# i = 2\\n# limit = int(x**0.5)\\n# while i < limit +1:\\n# if x%i == 0:\\n# return False\\n# limit = x//i\\n# i += 1\\n# primeSet.add(x)\\n# return True\\n \\n# numsLen = len(nums)\\n# primeCounter = 0\\n# for i in range(numsLen):\\n# if nums[i] == 1:\\n# return True\\n# if isPrime(nums[i]):\\n# primeCounter += 1\\n# if primeCounter == 2:\\n# return True\\n# else:\\n# for j in range(i):\\n# if isPrime(abs(nums[j] - nums[i])):\\n# primeCounter += 1\\n# if primeCounter == 2:\\n# return True\\n# return False\\n g=nums[0]\\n for i in nums:\\n g=gcd(i,g)\\n return g==1\", \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n for i in range(len(nums)):\\n nums[i] = gcd(nums[i],nums[i-1]) if i > 0 else nums[0]\\n if nums[i] == 1:\\n return True\\n return False\\n \\n\", \"class Solution:\\n def isGoodArray(self, A: List[int]) -> bool:\\n if len(A) == 0:\\n return False\\n gcd = A[0]\\n for a in A:\\n while a:\\n gcd, a = a, gcd % a\\n return gcd == 1\\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"isGoodArray\", \"inputs\": [[[12, 5, 7, 23]]], \"outputs\": [true]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/check-if-it-is-a-good-array/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n n = nums[0]\n \n for i in nums:\n n = gcd(i,n)\n \n if n==1:\n return True\n return False\n","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n if not nums: return False\n a=nums[0]\n for i in range(1, len(nums)):\n a=gcd(a,nums[i])\n return a==1","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n def gcd(x,y):\n while y:\n x,y=y,x%y\n return x\n g=nums[0]\n for x in nums:\n g=gcd(g,x)\n return g==1\n","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n def gcd(x: int, y: int) -> int:\n if y == 0:\n return x\n else:\n return gcd(y, x % y)\n \n result = nums[0]\n for num in nums:\n result = gcd(result, num)\n \n return result == 1","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n gcd = nums[0]\n for a in nums:\n while a:\n gcd, a = a, gcd % a\n return gcd == 1\n","class Solution:\n def gcd(self,a,b):\n return a if b==0 else self.gcd(b,a%b)\n def isGoodArray(self, nums: List[int]) -> bool:\n nums=list(set(nums))\n n=len(nums)\n if n==1 and nums[0]==1:return True\n cur=nums[0] \n for i in range(1,n):\n cur=self.gcd(cur,nums[i])\n if cur==1:return True\n return False","class Solution:\n def gcd(self, a, b):\n if a == 0:\n return b\n if b == 0:\n return a\n if a == 1 or b == 1:\n return 1\n while b != 0:\n a, b = b, a % b\n return a\n \n def isGoodArray(self, nums: List[int]) -> bool:\n g = 0\n for n in nums:\n if g == 0:\n g = n\n elif n == 1:\n return True\n else:\n while n:\n g, n = n, g % n\n if g == 1:\n return True\n return False","class Solution:\n \n def gcd(self, a:int, b:int) -> int:\n a,b = max(a,b),min(a,b)\n while b>0:\n a,b = b,a%b\n return a\n \n def isGoodArray(self, nums: List[int]) -> bool:\n lowest = nums[0]\n for i in nums[1:]:\n lowest = self.gcd(lowest,i)\n return lowest==1","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n if len(nums) == 1:\n return nums[0] == 1\n def gcd(a, b):\n while b:\n a, b = b, a % b\n return a\n \n gcd_val = nums[0]\n for i in range(1, len(nums)):\n gcd_val = gcd(gcd_val, nums[i])\n if gcd_val == 1:\n return True\n return False","def gcd(a,b):\n if(b==0):\n return a\n return gcd(b,a%b)\n\nclass Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n if(nums==[1]):\n return True\n i=0\n a=nums[i]\n for j in range(i+1,len(nums)):\n if(a<nums[j]):\n b=gcd(nums[j],a)\n if(b==1):\n return True\n else:\n a=b\n else:\n b=(gcd(a,nums[j]))\n if(b==1):\n return True\n else:\n a=b\n return False","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n gcd = nums[0]\n for n in nums:\n while n:\n gcd, n = n, gcd % n\n return gcd == 1\n \n","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n def gcd(a, b):\n a, b = max(a,b), min(a,b)\n while b:\n a, b = b, a%b\n return a\n if len(nums) == 1:\n if nums != [1]:\n return False\n else:\n return True\n i = 0\n d = nums[0]\n while i < len(nums):\n d = gcd(nums[i],d)\n if d == 1:\n return True\n i += 1\n return False\n","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n \n def gcd(x, y):\n if x < y:\n x, y = y, x\n if not x % y:\n return y\n return gcd(x % y, y)\n \n if len(nums) == 1:\n if nums[0] == 1:\n return True\n return False\n \n while True:\n x = nums.pop(-1)\n y = nums.pop(-1)\n z = gcd(x, y)\n if not nums:\n return z == 1\n \n nums.append(z)\n","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n \n def euclid(a,b):\n q, r = max(a,b), min(a,b)\n while r > 1 and q > 0:\n r, q = q % r, r\n return r if r > 0 else q\n \n if len(nums) == 1:\n return True if nums[0] == 1 else False\n \n nums.sort()\n for i in range(1,len(nums)):\n nums[i] = euclid(nums[i],nums[i-1])\n if nums[i] == 1:\n return True\n \n return False","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n def euclid(a,b):\n q, r = max(a,b), min(a,b)\n while r > 1 and q > 0:\n r, q = q % r, r\n return r if r > 0 else q\n \n if len(nums) == 1:\n return True if nums[0] == 1 else False\n \n for i in range(1,len(nums)):\n nums[i] = euclid(nums[i],nums[i-1])\n if nums[i] == 1:\n return True\n \n return False","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n def gcd(a, b):\n if b>0:\n return gcd(b, a%b)\n return a\n if not nums:\n return False\n if len(nums)==1:\n return nums[0]==1\n num = nums[0]\n for i in range(1, len(nums)):\n ans = gcd(num, nums[i])\n if ans==1:\n return True\n num = ans\n return False\n","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n if len(nums) == 1:\n if nums[0] == 1:\n return True\n else:\n return False\n \n ans = self.gcd(nums[0],nums[1])\n for num in nums[2:]:\n ans = self.gcd(ans,num)\n if ans == 1:\n return True\n return ans == 1\n def gcd(self, a,b) :\n if b == 0:\n return a\n return self.gcd(b,a%b)\n","from math import gcd\nfrom functools import reduce\n\nclass Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n return (reduce((lambda x, y: gcd(x,y)), nums) == 1)\n \n# class Solution:\n# def gcd(x, y):\n# gcd_ = i\n# for i in range(2, min(x, y)):\n# if x%i == 0 and y%i == 0:\n# gcd_ = i\n# return gcd_\n# def isGoodArray(self, nums: List[int]) -> bool:\n# itergcd = nums[0]\n# for i in nums:\n# itergcd = gcd(itergcd, i)\n# return itergcd == 1\n \n","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n import math\n curr_gcd = nums[0]\n for i in range(1, len(nums)):\n curr_gcd = math.gcd(curr_gcd, nums[i])\n if curr_gcd == 1:\n return True\n return curr_gcd == 1\n \n # if 1 in nums: return True\n \n# def find_factors(num):\n# sol = set()\n# for i in range(1,math.ceil(math.sqrt(num))):\n# if num % i == 0:\n# sol.add(i)\n# sol.add(num/i)\n# # sol.remove(num)\n# sol.remove(1)\n# return sol\n \n# all_items = set()\n# factors_list = []\n# for num in nums:\n# temp_set = find_factors(num)\n# for it in temp_set:\n# all_items.add(it)\n \n# factors_list.append(temp_set)\n# # print(all_items)\n# # print(factors_list) \n# for it in all_items:\n# if it == 1: continue\n# if all([it in lis for lis in factors_list]):\n# return False\n\n# return True\n \n \n \n \n '''\n 29, 6, 10\n 29, 3*2, 5*2\n '''","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n for i in range(len(nums)):\n nums[i] = gcd(nums[i],nums[i-1]) if i > 0 else nums[0]\n \n return nums[-1]==1\n \n","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n def gcd(x,y):\n if y > x:\n return gcd(y,x)\n if y == 0:\n return x\n return gcd(y,x%y) \n cur = nums[0]\n for i in range(1, len(nums)):\n cur = gcd(cur,nums[i])\n \n return cur == 1\n","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n g=nums[0]\n for i in nums:g=gcd(i,g)\n return g==1","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n gcd = nums[0]\n for num in nums:\n while num:\n gcd, num = num, gcd % num\n if gcd == 1:\n return True\n return False\n","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n \n def gcd(a,b):\n if b > a:\n a,b = b,a\n while (b > 0):\n r = divmod(a,b)[1]\n a = b\n b = r\n return a\n \n if len(nums) == 0: return 0\n if len(nums) == 1: return nums[0] == 1\n \n ans = nums[0]\n \n for i in range(1,len(nums)):\n ans = gcd(ans,nums[i])\n if ans == 1: return True\n \n return ans == 1","class Solution:\n def gcd(self, nums):\n g = nums[0]\n for x in nums:\n while x:\n g, x = x, g%x\n return g\n\n # a: list of integers\n # d: desired GCD of the integers in a\n def bezout(self, a: [int], d):\n if self.gcd(a) == d:\n return True\n return False\n\n def isGoodArray(self, nums: [int]) -> bool:\n return self.bezout(nums, 1)","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n gcd = nums[0]\n for n in nums:\n while n:\n gcd, n = n, gcd % n\n \n return gcd == 1","class Solution:\n def getGCD(self, x: int, y: int) -> int:\n while y:\n x, y = y, x % y\n return x \n def getLCM(self, x: int, y: int) -> int:\n return x * y // self.getGCD(x, y)\n def isGoodArray(self, nums: List[int]) -> bool:\n # question is equivalent to have any substr with gcd equals 1, iff array has gcd equals to 1\n n = len(nums)\n x, i = nums[0], 1\n while i < n:\n x = self.getGCD(x, nums[i])\n if x == 1:\n return True\n i += 1\n return x == 1","class Solution:\n def isGoodArray(self, A: List[int]) -> bool:\n gcd = A[0]\n for a in A:\n while a:\n gcd, a = a, gcd % a\n if gcd == 1:\n return gcd\n return False","from fractions import gcd\nfrom functools import reduce\nclass Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n def find_gcd(list):\n x = reduce(gcd, list)\n return x\n if find_gcd(nums)==1:\n return True\n return False\n\n","# from math import gcd\n# from functools import reduce\n\n# class Solution:\n# def isGoodArray(self, nums: List[int]) -> bool:\n# return (reduce((lambda x, y: gcd(x,y)), nums) == 1)\n \nclass Solution:\n def gcd(x, y):\n gcd_ = i\n for i in range(2, min(x, y)):\n if x%i == 0 and y%i == 0:\n gcd_ = i\n return gcd_\n def isGoodArray(self, nums: List[int]) -> bool:\n start = nums[0]\n for i in nums:\n start = gcd(start, i)\n return start == 1\n \n","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n g=nums[0]\n for i in nums:\n g=self.hcfnaive(i,g)\n return g==1\n \n \n def hcfnaive(self,a,b): \n if(b==0): \n return a \n else: \n return self.hcfnaive(b,a%b) \n","class Solution:\n def isGoodArray(self, x: List[int]) -> bool:\n g=x[0]\n for i in x:g=gcd(i,g)\n return g==1\n","from functools import reduce\nclass Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n return reduce(gcd, nums) < 2\n \n","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n \n if len(nums) == 1:\n if nums[0] == 1:\n return True\n else:\n return False\n \n now = -1\n for i in range(1, len(nums)):\n if i == 1:\n now = math.gcd(nums[i-1], nums[i])\n else:\n now = math.gcd(nums[i],now)\n \n \n if now == 1:\n return True\n return False","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n res = nums[0]\n \n for i in range(1, len(nums)):\n res = math.gcd(res, nums[i])\n if res == 1:\n return True\n \n return res == 1\n","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n \n if len(nums) == 1:\n return True if nums[0] == 1 else False\n \n for i in range(1,len(nums)):\n nums[i] = gcd(nums[i],nums[i-1])\n if nums[i] == 1:\n return True\n \n return False\n \n","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n# primeSet = set()\n# def isPrime(x):\n# if x < 2 or x in primeSet:\n# return False\n# i = 2\n# limit = int(x**0.5)\n# while i < limit +1:\n# if x%i == 0:\n# return False\n# limit = x//i\n# i += 1\n# primeSet.add(x)\n# return True\n \n# numsLen = len(nums)\n# primeCounter = 0\n# for i in range(numsLen):\n# if nums[i] == 1:\n# return True\n# if isPrime(nums[i]):\n# primeCounter += 1\n# if primeCounter == 2:\n# return True\n# else:\n# for j in range(i):\n# if isPrime(abs(nums[j] - nums[i])):\n# primeCounter += 1\n# if primeCounter == 2:\n# return True\n# return False\n g=nums[0]\n for i in nums:\n g=gcd(i,g)\n return g==1","class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n for i in range(len(nums)):\n nums[i] = gcd(nums[i],nums[i-1]) if i > 0 else nums[0]\n if nums[i] == 1:\n return True\n return False\n \n","class Solution:\n def isGoodArray(self, A: List[int]) -> bool:\n if len(A) == 0:\n return False\n gcd = A[0]\n for a in A:\n while a:\n gcd, a = a, gcd % a\n return gcd == 1\n"],"string":"[\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n n = nums[0]\\n \\n for i in nums:\\n n = gcd(i,n)\\n \\n if n==1:\\n return True\\n return False\\n\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n if not nums: return False\\n a=nums[0]\\n for i in range(1, len(nums)):\\n a=gcd(a,nums[i])\\n return a==1\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n def gcd(x,y):\\n while y:\\n x,y=y,x%y\\n return x\\n g=nums[0]\\n for x in nums:\\n g=gcd(g,x)\\n return g==1\\n\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n def gcd(x: int, y: int) -> int:\\n if y == 0:\\n return x\\n else:\\n return gcd(y, x % y)\\n \\n result = nums[0]\\n for num in nums:\\n result = gcd(result, num)\\n \\n return result == 1\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n gcd = nums[0]\\n for a in nums:\\n while a:\\n gcd, a = a, gcd % a\\n return gcd == 1\\n\",\n \"class Solution:\\n def gcd(self,a,b):\\n return a if b==0 else self.gcd(b,a%b)\\n def isGoodArray(self, nums: List[int]) -> bool:\\n nums=list(set(nums))\\n n=len(nums)\\n if n==1 and nums[0]==1:return True\\n cur=nums[0] \\n for i in range(1,n):\\n cur=self.gcd(cur,nums[i])\\n if cur==1:return True\\n return False\",\n \"class Solution:\\n def gcd(self, a, b):\\n if a == 0:\\n return b\\n if b == 0:\\n return a\\n if a == 1 or b == 1:\\n return 1\\n while b != 0:\\n a, b = b, a % b\\n return a\\n \\n def isGoodArray(self, nums: List[int]) -> bool:\\n g = 0\\n for n in nums:\\n if g == 0:\\n g = n\\n elif n == 1:\\n return True\\n else:\\n while n:\\n g, n = n, g % n\\n if g == 1:\\n return True\\n return False\",\n \"class Solution:\\n \\n def gcd(self, a:int, b:int) -> int:\\n a,b = max(a,b),min(a,b)\\n while b>0:\\n a,b = b,a%b\\n return a\\n \\n def isGoodArray(self, nums: List[int]) -> bool:\\n lowest = nums[0]\\n for i in nums[1:]:\\n lowest = self.gcd(lowest,i)\\n return lowest==1\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n if len(nums) == 1:\\n return nums[0] == 1\\n def gcd(a, b):\\n while b:\\n a, b = b, a % b\\n return a\\n \\n gcd_val = nums[0]\\n for i in range(1, len(nums)):\\n gcd_val = gcd(gcd_val, nums[i])\\n if gcd_val == 1:\\n return True\\n return False\",\n \"def gcd(a,b):\\n if(b==0):\\n return a\\n return gcd(b,a%b)\\n\\nclass Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n if(nums==[1]):\\n return True\\n i=0\\n a=nums[i]\\n for j in range(i+1,len(nums)):\\n if(a<nums[j]):\\n b=gcd(nums[j],a)\\n if(b==1):\\n return True\\n else:\\n a=b\\n else:\\n b=(gcd(a,nums[j]))\\n if(b==1):\\n return True\\n else:\\n a=b\\n return False\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n gcd = nums[0]\\n for n in nums:\\n while n:\\n gcd, n = n, gcd % n\\n return gcd == 1\\n \\n\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n def gcd(a, b):\\n a, b = max(a,b), min(a,b)\\n while b:\\n a, b = b, a%b\\n return a\\n if len(nums) == 1:\\n if nums != [1]:\\n return False\\n else:\\n return True\\n i = 0\\n d = nums[0]\\n while i < len(nums):\\n d = gcd(nums[i],d)\\n if d == 1:\\n return True\\n i += 1\\n return False\\n\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n \\n def gcd(x, y):\\n if x < y:\\n x, y = y, x\\n if not x % y:\\n return y\\n return gcd(x % y, y)\\n \\n if len(nums) == 1:\\n if nums[0] == 1:\\n return True\\n return False\\n \\n while True:\\n x = nums.pop(-1)\\n y = nums.pop(-1)\\n z = gcd(x, y)\\n if not nums:\\n return z == 1\\n \\n nums.append(z)\\n\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n \\n def euclid(a,b):\\n q, r = max(a,b), min(a,b)\\n while r > 1 and q > 0:\\n r, q = q % r, r\\n return r if r > 0 else q\\n \\n if len(nums) == 1:\\n return True if nums[0] == 1 else False\\n \\n nums.sort()\\n for i in range(1,len(nums)):\\n nums[i] = euclid(nums[i],nums[i-1])\\n if nums[i] == 1:\\n return True\\n \\n return False\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n def euclid(a,b):\\n q, r = max(a,b), min(a,b)\\n while r > 1 and q > 0:\\n r, q = q % r, r\\n return r if r > 0 else q\\n \\n if len(nums) == 1:\\n return True if nums[0] == 1 else False\\n \\n for i in range(1,len(nums)):\\n nums[i] = euclid(nums[i],nums[i-1])\\n if nums[i] == 1:\\n return True\\n \\n return False\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n def gcd(a, b):\\n if b>0:\\n return gcd(b, a%b)\\n return a\\n if not nums:\\n return False\\n if len(nums)==1:\\n return nums[0]==1\\n num = nums[0]\\n for i in range(1, len(nums)):\\n ans = gcd(num, nums[i])\\n if ans==1:\\n return True\\n num = ans\\n return False\\n\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n if len(nums) == 1:\\n if nums[0] == 1:\\n return True\\n else:\\n return False\\n \\n ans = self.gcd(nums[0],nums[1])\\n for num in nums[2:]:\\n ans = self.gcd(ans,num)\\n if ans == 1:\\n return True\\n return ans == 1\\n def gcd(self, a,b) :\\n if b == 0:\\n return a\\n return self.gcd(b,a%b)\\n\",\n \"from math import gcd\\nfrom functools import reduce\\n\\nclass Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n return (reduce((lambda x, y: gcd(x,y)), nums) == 1)\\n \\n# class Solution:\\n# def gcd(x, y):\\n# gcd_ = i\\n# for i in range(2, min(x, y)):\\n# if x%i == 0 and y%i == 0:\\n# gcd_ = i\\n# return gcd_\\n# def isGoodArray(self, nums: List[int]) -> bool:\\n# itergcd = nums[0]\\n# for i in nums:\\n# itergcd = gcd(itergcd, i)\\n# return itergcd == 1\\n \\n\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n import math\\n curr_gcd = nums[0]\\n for i in range(1, len(nums)):\\n curr_gcd = math.gcd(curr_gcd, nums[i])\\n if curr_gcd == 1:\\n return True\\n return curr_gcd == 1\\n \\n # if 1 in nums: return True\\n \\n# def find_factors(num):\\n# sol = set()\\n# for i in range(1,math.ceil(math.sqrt(num))):\\n# if num % i == 0:\\n# sol.add(i)\\n# sol.add(num/i)\\n# # sol.remove(num)\\n# sol.remove(1)\\n# return sol\\n \\n# all_items = set()\\n# factors_list = []\\n# for num in nums:\\n# temp_set = find_factors(num)\\n# for it in temp_set:\\n# all_items.add(it)\\n \\n# factors_list.append(temp_set)\\n# # print(all_items)\\n# # print(factors_list) \\n# for it in all_items:\\n# if it == 1: continue\\n# if all([it in lis for lis in factors_list]):\\n# return False\\n\\n# return True\\n \\n \\n \\n \\n '''\\n 29, 6, 10\\n 29, 3*2, 5*2\\n '''\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n for i in range(len(nums)):\\n nums[i] = gcd(nums[i],nums[i-1]) if i > 0 else nums[0]\\n \\n return nums[-1]==1\\n \\n\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n def gcd(x,y):\\n if y > x:\\n return gcd(y,x)\\n if y == 0:\\n return x\\n return gcd(y,x%y) \\n cur = nums[0]\\n for i in range(1, len(nums)):\\n cur = gcd(cur,nums[i])\\n \\n return cur == 1\\n\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n g=nums[0]\\n for i in nums:g=gcd(i,g)\\n return g==1\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n gcd = nums[0]\\n for num in nums:\\n while num:\\n gcd, num = num, gcd % num\\n if gcd == 1:\\n return True\\n return False\\n\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n \\n def gcd(a,b):\\n if b > a:\\n a,b = b,a\\n while (b > 0):\\n r = divmod(a,b)[1]\\n a = b\\n b = r\\n return a\\n \\n if len(nums) == 0: return 0\\n if len(nums) == 1: return nums[0] == 1\\n \\n ans = nums[0]\\n \\n for i in range(1,len(nums)):\\n ans = gcd(ans,nums[i])\\n if ans == 1: return True\\n \\n return ans == 1\",\n \"class Solution:\\n def gcd(self, nums):\\n g = nums[0]\\n for x in nums:\\n while x:\\n g, x = x, g%x\\n return g\\n\\n # a: list of integers\\n # d: desired GCD of the integers in a\\n def bezout(self, a: [int], d):\\n if self.gcd(a) == d:\\n return True\\n return False\\n\\n def isGoodArray(self, nums: [int]) -> bool:\\n return self.bezout(nums, 1)\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n gcd = nums[0]\\n for n in nums:\\n while n:\\n gcd, n = n, gcd % n\\n \\n return gcd == 1\",\n \"class Solution:\\n def getGCD(self, x: int, y: int) -> int:\\n while y:\\n x, y = y, x % y\\n return x \\n def getLCM(self, x: int, y: int) -> int:\\n return x * y // self.getGCD(x, y)\\n def isGoodArray(self, nums: List[int]) -> bool:\\n # question is equivalent to have any substr with gcd equals 1, iff array has gcd equals to 1\\n n = len(nums)\\n x, i = nums[0], 1\\n while i < n:\\n x = self.getGCD(x, nums[i])\\n if x == 1:\\n return True\\n i += 1\\n return x == 1\",\n \"class Solution:\\n def isGoodArray(self, A: List[int]) -> bool:\\n gcd = A[0]\\n for a in A:\\n while a:\\n gcd, a = a, gcd % a\\n if gcd == 1:\\n return gcd\\n return False\",\n \"from fractions import gcd\\nfrom functools import reduce\\nclass Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n def find_gcd(list):\\n x = reduce(gcd, list)\\n return x\\n if find_gcd(nums)==1:\\n return True\\n return False\\n\\n\",\n \"# from math import gcd\\n# from functools import reduce\\n\\n# class Solution:\\n# def isGoodArray(self, nums: List[int]) -> bool:\\n# return (reduce((lambda x, y: gcd(x,y)), nums) == 1)\\n \\nclass Solution:\\n def gcd(x, y):\\n gcd_ = i\\n for i in range(2, min(x, y)):\\n if x%i == 0 and y%i == 0:\\n gcd_ = i\\n return gcd_\\n def isGoodArray(self, nums: List[int]) -> bool:\\n start = nums[0]\\n for i in nums:\\n start = gcd(start, i)\\n return start == 1\\n \\n\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n g=nums[0]\\n for i in nums:\\n g=self.hcfnaive(i,g)\\n return g==1\\n \\n \\n def hcfnaive(self,a,b): \\n if(b==0): \\n return a \\n else: \\n return self.hcfnaive(b,a%b) \\n\",\n \"class Solution:\\n def isGoodArray(self, x: List[int]) -> bool:\\n g=x[0]\\n for i in x:g=gcd(i,g)\\n return g==1\\n\",\n \"from functools import reduce\\nclass Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n return reduce(gcd, nums) < 2\\n \\n\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n \\n if len(nums) == 1:\\n if nums[0] == 1:\\n return True\\n else:\\n return False\\n \\n now = -1\\n for i in range(1, len(nums)):\\n if i == 1:\\n now = math.gcd(nums[i-1], nums[i])\\n else:\\n now = math.gcd(nums[i],now)\\n \\n \\n if now == 1:\\n return True\\n return False\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n res = nums[0]\\n \\n for i in range(1, len(nums)):\\n res = math.gcd(res, nums[i])\\n if res == 1:\\n return True\\n \\n return res == 1\\n\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n \\n if len(nums) == 1:\\n return True if nums[0] == 1 else False\\n \\n for i in range(1,len(nums)):\\n nums[i] = gcd(nums[i],nums[i-1])\\n if nums[i] == 1:\\n return True\\n \\n return False\\n \\n\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n# primeSet = set()\\n# def isPrime(x):\\n# if x < 2 or x in primeSet:\\n# return False\\n# i = 2\\n# limit = int(x**0.5)\\n# while i < limit +1:\\n# if x%i == 0:\\n# return False\\n# limit = x//i\\n# i += 1\\n# primeSet.add(x)\\n# return True\\n \\n# numsLen = len(nums)\\n# primeCounter = 0\\n# for i in range(numsLen):\\n# if nums[i] == 1:\\n# return True\\n# if isPrime(nums[i]):\\n# primeCounter += 1\\n# if primeCounter == 2:\\n# return True\\n# else:\\n# for j in range(i):\\n# if isPrime(abs(nums[j] - nums[i])):\\n# primeCounter += 1\\n# if primeCounter == 2:\\n# return True\\n# return False\\n g=nums[0]\\n for i in nums:\\n g=gcd(i,g)\\n return g==1\",\n \"class Solution:\\n def isGoodArray(self, nums: List[int]) -> bool:\\n for i in range(len(nums)):\\n nums[i] = gcd(nums[i],nums[i-1]) if i > 0 else nums[0]\\n if nums[i] == 1:\\n return True\\n return False\\n \\n\",\n \"class Solution:\\n def isGoodArray(self, A: List[int]) -> bool:\\n if len(A) == 0:\\n return False\\n gcd = A[0]\\n for a in A:\\n while a:\\n gcd, a = a, gcd % a\\n return gcd == 1\\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":39,"string":"39"},"non_interactive_idx":{"kind":"list like","value":[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],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32,\n 33,\n 34,\n 35,\n 36,\n 37,\n 38\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[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],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":82,"cells":{"problem_id":{"kind":"number","value":216,"string":"216"},"question":{"kind":"string","value":"Given the string croakOfFrogs, which represents a combination of the string \"croak\" from different frogs, that is, multiple frogs can croak at the same time, so multiple “croak” are mixed. Return the minimum number of different frogs to finish all the croak in the given string.\nA valid \"croak\" means a frog is printing 5 letters ‘c’, ’r’, ’o’, ’a’, ’k’ sequentially. The frogs have to print all five letters to finish a croak. If the given string is not a combination of valid \"croak\" return -1.\n \nExample 1:\nInput: croakOfFrogs = \"croakcroak\"\nOutput: 1 \nExplanation: One frog yelling \"croak\" twice.\n\nExample 2:\nInput: croakOfFrogs = \"crcoakroak\"\nOutput: 2 \nExplanation: The minimum number of frogs is two. \nThe first frog could yell \"crcoakroak\".\nThe second frog could yell later \"crcoakroak\".\n\nExample 3:\nInput: croakOfFrogs = \"croakcrook\"\nOutput: -1\nExplanation: The given string is an invalid combination of \"croak\" from different frogs.\n\nExample 4:\nInput: croakOfFrogs = \"croakcroa\"\nOutput: -1\n\n \nConstraints:\n\n1 <= croakOfFrogs.length <= 10^5\nAll characters in the string are: 'c', 'r', 'o', 'a' or 'k'."},"solutions":{"kind":"string","value":"[\"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n # valid string? can be seperated into full croaks:\\n ### dict of letters. c, r, o, a, k should all be equal, nothing else in\\n if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':\\n return -1\\n \\n letters = {\\n 'c': 0,\\n 'r': 0,\\n 'o': 0,\\n 'a': 0,\\n 'k': 0\\n }\\n \\n frogs = 0\\n temp = 0\\n \\n for l in croakOfFrogs:\\n letters[l] += 1\\n temp = letters['c'] - letters['k']\\n if temp > frogs:\\n frogs = temp\\n \\n \\n c_count = letters['c']\\n for letter in letters:\\n if letters[letter] != c_count:\\n return -1\\n \\n return frogs\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n croaks = {'c':[], 'r':[], 'o':[], 'a':[]}\\n nfrogs = 0\\n icroak = 0\\n curfrogs = 0\\n for sound in croakOfFrogs:\\n if sound == 'c':\\n icroak += 1\\n croaks['c'].append(icroak)\\n curfrogs += 1\\n nfrogs = max(curfrogs, nfrogs)\\n elif sound == 'r':\\n if croaks['c']:\\n croaks['r'].append(croaks['c'].pop())\\n else:\\n return -1\\n elif sound == 'o':\\n if croaks['r']:\\n croaks['o'].append(croaks['r'].pop())\\n else:\\n return -1\\n elif sound == 'a':\\n if croaks['o']:\\n croaks['a'].append(croaks['o'].pop())\\n else:\\n return -1\\n elif sound == 'k':\\n if croaks['a']:\\n croaks['a'].pop()\\n curfrogs -= 1\\n else:\\n return -1\\n else:\\n return -1\\n \\n for sound in croaks:\\n if croaks[sound] != []:\\n return -1\\n \\n return nfrogs\\n \\n\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n croaks = {'c':[], 'r':[], 'o':[], 'a':[]}\\n maxfrogs = 0\\n i_croak = 0\\n nfrogs = 0\\n for sound in croakOfFrogs:\\n if sound == 'c':\\n i_croak += 1\\n croaks['c'].append(i_croak)\\n nfrogs += 1\\n maxfrogs = max(nfrogs, maxfrogs)\\n elif sound == 'r':\\n if croaks['c']:\\n croaks['r'].append(croaks['c'].pop())\\n else:\\n return -1\\n elif sound == 'o':\\n if croaks['r']:\\n croaks['o'].append(croaks['r'].pop())\\n else:\\n return -1\\n elif sound == 'a':\\n if croaks['o']:\\n croaks['a'].append(croaks['o'].pop())\\n else:\\n return -1\\n elif sound == 'k':\\n if croaks['a']:\\n croaks['a'].pop()\\n nfrogs -= 1\\n else:\\n return -1\\n else:\\n return -1\\n \\n for sound in croaks:\\n if croaks[sound] != []:\\n return -1\\n \\n return maxfrogs\\n \\n\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n ans = 1\\n waitingFor = defaultdict(int)\\n croak = 'croak'\\n croakDict= {'c': 0, 'r': 1, 'o': 2, 'a': 3, 'k': 4}\\n \\n # waitingFor['c'] = 0\\n for char in croakOfFrogs:\\n if char == 'c':\\n if waitingFor[char] != 0 and ans <= waitingFor[char]:\\n ans += 1\\n waitingFor[char] += 1\\n waitingFor[croak[croakDict[char]+1]] += 1\\n else:\\n if waitingFor[char] == 0:\\n return -1\\n waitingFor[char] -= 1\\n if char != 'k':\\n waitingFor[croak[croakDict[char]+1]] += 1\\n else:\\n waitingFor['c'] -= 1\\n # print(waitingFor)\\n for char in waitingFor:\\n if waitingFor[char] != 0:\\n return -1\\n return ans\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':\\n return -1\\n\\n max_frog_croak = 0\\n present_frog_croak = 0\\n\\n d={}\\n d['c']=0\\n d['r']=0\\n d['o']=0\\n d['a']=0\\n d['k']=0\\n\\n for ch in croakOfFrogs:\\n d[ch]+=1\\n if ch=='c':\\n present_frog_croak+=1\\n if ch=='k':\\n present_frog_croak-=1\\n\\n max_frog_croak = max(max_frog_croak,present_frog_croak)\\n\\n\\n if d['c']!=d['r'] or d['r']!=d['o'] or d['o']!=d['a'] or d['a']!=d['k']:\\n return -1\\n\\n return max_frog_croak\\n\", \"class Solution:\\n def minNumberOfFrogs(self, croak: str) -> int:\\n if len(croak) == 0:\\n return 0\\n if croak[0] != 'c':\\n return -1\\n if len(croak) % 5 != 0:\\n return -1\\n arr = [0 for _ in range(6)]\\n arr[0] = 9999999\\n index = {'c':1, 'r':2, 'o':3, 'a':4, 'k':5}\\n \\n for letter in croak:\\n i = index[letter] \\n if arr[i-1] > 0:\\n if i == 1 and arr[5]:\\n arr[5] -= 1\\n arr[i-1] -= 1\\n arr[i] += 1\\n else:\\n return -1\\n for i in arr[1:-1]:\\n if i != 0:\\n return -1\\n return arr[-1]\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n chr_c, chr_r, chr_o, chr_a = 0, 0, 0, 0\\n count = 0\\n for s in croakOfFrogs:\\n if s == 'c':\\n chr_c += 1\\n elif s == 'r':\\n if chr_c <= 0:\\n return -1\\n chr_c -= 1\\n chr_r += 1\\n elif s == 'o':\\n if chr_r <= 0:\\n return -1\\n chr_r -= 1\\n chr_o += 1\\n elif s == 'a':\\n if chr_o <= 0:\\n return -1\\n chr_o -= 1\\n chr_a += 1\\n else:\\n if chr_a <= 0:\\n return -1\\n chr_a -= 1\\n count = max(count, chr_c + chr_r + chr_o + chr_a)\\n # \\u6ca1\\u6709\\u5531\\u5b8c\\u6574\\u4e94\\u4e2a\\u5b57\\u7b26\\uff0c\\u90a3\\u4e48\\u5fc5\\u7136\\u4f1a\\u5927\\u4e8e0\\n if chr_c + chr_r + chr_o + chr_a > 0:\\n return -1\\n return count\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n # valid string? can be seperated into full croaks:\\n ### dict of letters. c, r, o, a, k should all be equal, nothing else in\\n if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':\\n return -1\\n \\n letters = {\\n 'c': 0,\\n 'r': 0,\\n 'o': 0,\\n 'a': 0,\\n 'k': 0\\n }\\n \\n frogs = 0\\n temp = 0\\n \\n for l in croakOfFrogs:\\n letters[l] += 1\\n temp = letters['c'] - letters['k']\\n if temp > frogs:\\n frogs = temp\\n \\n \\n c_count = letters['c']\\n for letter in letters:\\n if letters[letter] != c_count:\\n return -1\\n \\n return frogs\\n\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n curr=0\\n maxcurr=0\\n c=r=o=a=k=0\\n for i in croakOfFrogs:\\n if i=='c':\\n c+=1\\n curr+=1\\n elif i=='r':\\n r+=1\\n elif i=='o':\\n o+=1\\n elif i=='a':\\n a+=1\\n else:\\n k+=1\\n curr-=1\\n maxcurr=max(curr,maxcurr)\\n if c<r or r<o or o<a or a<k:\\n return -1\\n if curr==0 and c==r and r==o and o==a and a==k:\\n return maxcurr\\n return -1\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':\\n return -1\\n\\n max_frog_croak = 0\\n present_frog_croak = 0\\n\\n d={}\\n d['c']=0\\n d['r']=0\\n d['o']=0\\n d['a']=0\\n d['k']=0\\n\\n for ch in croakOfFrogs:\\n d[ch]+=1\\n if ch=='c':\\n present_frog_croak+=1\\n if ch=='k':\\n present_frog_croak-=1\\n\\n max_frog_croak = max(max_frog_croak,present_frog_croak)\\n\\n\\n if d['c']!=d['r'] or d['r']!=d['o'] or d['o']!=d['a'] or d['a']!=d['k']:\\n return -1\\n\\n return max_frog_croak\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n neighcount = [0,0,0,0,0]\\n minhorses = 0\\n nstarted = 0\\n nended = 0\\n \\n for s in croakOfFrogs:\\n if s == 'c':\\n neighcount[0] += 1\\n nstarted += 1\\n elif s == 'r':\\n neighcount[1] += 1\\n neighcount[0] -= 1\\n elif s == 'o':\\n neighcount[2] += 1\\n neighcount[1] -= 1\\n elif s == 'a':\\n neighcount[3] += 1\\n neighcount[2] -= 1\\n elif s == 'k':\\n neighcount[4] += 1\\n neighcount[3] -= 1\\n nstarted -= 1\\n else:\\n return -1\\n if nstarted > minhorses:\\n minhorses = nstarted\\n if neighcount[0] < 0 or neighcount[1] < 0 or neighcount[2] < 0 or neighcount[3] < 0:\\n return -1\\n if neighcount[0] == 0 and neighcount[1] == 0 and neighcount[2] == 0 and neighcount[3] == 0:\\n return minhorses\\n else:\\n return -1\\n \\n \\n \\n\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n if not len(croakOfFrogs): return 0\\n \\n c = 0\\n r = 0\\n o = 0\\n a = 0\\n k = 0\\n count = 0\\n \\n for ch in croakOfFrogs:\\n \\n if ch == 'c':\\n count += 1\\n c += 1\\n \\n elif ch == 'r':\\n if not c:\\n return -1\\n c -= 1\\n r += 1\\n \\n \\n elif ch == 'o':\\n if not r:\\n return -1\\n r -= 1\\n o += 1\\n \\n \\n elif ch == 'a':\\n if not o:\\n return -1\\n o -= 1\\n a += 1\\n \\n \\n elif ch == 'k':\\n if not a:\\n return -1\\n a -= 1\\n \\n k = max(k, count)\\n count -= 1\\n \\n \\n else:\\n return -1\\n \\n if not c and not r and not o and not a:\\n return k\\n else:\\n return -1\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n # print(len(croakOfFrogs))\\n if len(croakOfFrogs) % 5 > 0:\\n return -1\\n pos = {'c': 0, 'r': 1, 'o': 2, 'a': 3, 'k': 4}\\n count = [0]*5\\n res = 1\\n for c in croakOfFrogs:\\n count[pos[c]] += 1\\n # print(count)\\n if pos[c] > 0:\\n if count[pos[c]] > count[pos[c]-1]:\\n return -1\\n if pos[c] == 4:\\n for i in range(5):\\n count[i] -= 1\\n elif pos[c] == 0:\\n res = max(res, count[0])\\n for i in range(4):\\n if count[i+1] != count[i]:\\n return -1\\n return res\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n frogs, d = [], {c: [] for c in 'croak'}\\n for c in croakOfFrogs:\\n bucket = 'croak'['croak'.find(c)-1]\\n if not d[bucket]:\\n if bucket != 'k': return -1\\n frogs.append([])\\n d[c].append(len(frogs) - 1)\\n else:\\n d[c].append(d[bucket].pop())\\n if c == 'c':\\n frogs[d[c][-1]].clear()\\n frogs[d[c][-1]].append(c)\\n return len(frogs) if all(len(frog) == 5 for frog in frogs) else -1\\n\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n \\n r = 0\\n o = 0\\n a = 0\\n k = 0\\n \\n frogs = 0\\n max_frogs = 0\\n for L in croakOfFrogs:\\n \\n if L == 'c':\\n frogs += 1\\n max_frogs = max(max_frogs, frogs)\\n r += 1\\n \\n elif L == 'r':\\n if r == 0:\\n return -1\\n else:\\n r -= 1\\n o += 1\\n \\n elif L == 'o':\\n if o == 0:\\n return -1\\n else:\\n o -= 1\\n a += 1\\n \\n elif L == 'a':\\n if a == 0:\\n return -1\\n else:\\n a -= 1\\n k += 1\\n \\n else:\\n if k == 0:\\n return -1\\n else:\\n k -= 1\\n frogs -= 1\\n \\n if r + o + a + k != 0:\\n return -1\\n \\n return max_frogs\\n \\n\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n if len(croakOfFrogs) % 5 != 0:\\n return -1\\n \\n min_val = 0\\n cnt = {char: 0 for char in 'croak'}\\n for char in croakOfFrogs:\\n if char not in 'croak' or not cnt['c'] >= cnt['r'] >= cnt['o'] >= cnt['a'] >= cnt['k']:\\n return -1\\n cnt[char] += 1\\n \\n min_val = max(min_val, cnt['c'] - cnt['k'])\\n \\n return min_val if cnt['c'] == cnt['r'] == cnt['o'] == cnt['a'] == cnt['k'] else -1\", \"class Solution:\\n# def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n# neighcount = [0,0,0,0,0]\\n# minhorses = 0\\n# nstarted = 0\\n# nended = 0\\n \\n# for s in croakOfFrogs:\\n# if s == 'c':\\n# neighcount[0] += 1\\n# nstarted += 1\\n# elif s == 'r':\\n# neighcount[1] += 1\\n# neighcount[0] -= 1\\n# if neighcount[0] < 0:\\n# return -1\\n# elif s == 'o':\\n# neighcount[2] += 1\\n# neighcount[1] -= 1\\n# if neighcount[1] < 0:\\n# return -1\\n# elif s == 'a':\\n# neighcount[3] += 1\\n# neighcount[2] -= 1\\n# if neighcount[2] < 0:\\n# return -1\\n# elif s == 'k':\\n# neighcount[4] += 1\\n# neighcount[3] -= 1\\n# nstarted -= 1\\n# if neighcount[3] < 0:\\n# return -1 \\n# else:\\n# return -1\\n# if nstarted > minhorses:\\n# minhorses = nstarted\\n# neighcount[4] = 0\\n# if max(neighcount) == 0:\\n# return minhorses\\n# else:\\n# return -1\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n\\n if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':\\n return -1\\n \\n max_frog_croak = 0\\n present_frog_croak = 0\\n\\n d={}\\n d['c']=0\\n d['r']=0\\n d['o']=0\\n d['a']=0\\n d['k']=0\\n\\n for ch in croakOfFrogs:\\n d[ch]+=1\\n if ch=='c':\\n present_frog_croak+=1\\n if ch=='k':\\n present_frog_croak-=1\\n\\n max_frog_croak = max(max_frog_croak,present_frog_croak)\\n\\n\\n if d['c']!=d['r'] or d['r']!=d['o'] or d['o']!=d['a'] or d['a']!=d['k']:\\n return -1\\n\\n return max_frog_croak \\n \\n \\n\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n\\n if len(croakOfFrogs) % 5 != 0:\\n return -1\\n nums = [0] * 5\\n \\n dic = {'c': 0, 'r': 1, 'o':2, 'a': 3, 'k' : 4}\\n res = 1\\n for ch in croakOfFrogs:\\n if dic[ch] != 0 and nums[dic[ch]] >= nums[dic[ch] - 1]:\\n return -1\\n \\n nums[dic[ch]] += 1\\n res = max(res, nums[0])\\n if ch == 'k':\\n for i in range(5):\\n nums[i] -= 1 \\n \\n \\n return res\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n c, r, o, a, k, in_use, answer = 0, 0, 0, 0, 0, 0, 0\\n for d in croakOfFrogs:\\n if d == 'c':\\n c, in_use = c+1, in_use+1\\n elif d == 'r':\\n r += 1\\n elif d == 'o':\\n o += 1\\n elif d == 'a':\\n a += 1\\n else:\\n k, in_use = k+1, in_use-1\\n \\n answer = max(answer, in_use)\\n \\n if c < r or r < o or o < a or a < k:\\n return -1\\n \\n if in_use == 0 and c == r and r == o and o == a and a == k:\\n return answer\\n \\n return -1\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n \\n arr = [0] * 5 \\n\\n for item in croakOfFrogs:\\n \\n if item == 'c':\\n arr[0] += 1\\n \\n elif item == 'r':\\n arr[1] += 1\\n for i in range(0, 1):\\n if arr[i] < arr[1]:\\n return -1\\n \\n elif item == 'o':\\n arr[2] += 1\\n for i in range(0, 1):\\n if arr[i] < arr[2]:\\n return -1\\n \\n elif item == 'a':\\n arr[3] += 1\\n for i in range(0, 1):\\n if arr[i] < arr[3]:\\n return -1\\n\\n else:\\n arr[4] += 1\\n for i in range(0, 1):\\n if arr[i] < arr[4]:\\n return -1\\n \\n cur = arr[0]\\n \\n for i in range(1, 5):\\n if arr[i] != cur:\\n return -1\\n \\n ''' At this point there is a valid string '''\\n cur_frogs = 0\\n \\n result = float('-inf')\\n p = 0\\n \\n while p < len(croakOfFrogs):\\n \\n if croakOfFrogs[p] == 'c':\\n cur_frogs += 1\\n \\n elif croakOfFrogs[p] == 'k':\\n cur_frogs -= 1\\n \\n result = max(cur_frogs, result)\\n p += 1\\n \\n return result\\n \\n \\n \\n \\n \\n\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n \\n dic = {'c': 0, 'r': 1, 'o': 2, 'a': 3, 'k': 4}\\n num = 0\\n num_c = 0\\n num_k = 0\\n \\n freq = [0] * 5\\n \\n if not croakOfFrogs[0] == 'c': return -1\\n \\n # count the number of c before the first k shows up\\n \\n for ch in croakOfFrogs:\\n if 'c' == ch: \\n if num_k == 0: num_c += 1\\n else: num_k -= 1\\n num = max(num_c, num)\\n if 'k' == ch: num_k += 1 \\n \\n # check validation\\n for ch in croakOfFrogs:\\n freq[dic[ch]] += 1\\n \\n for idx in range(1, 5):\\n if freq[idx] > freq[idx - 1]: return -1\\n \\n for idx in range(1, 5):\\n if not freq[idx] == freq[idx-1]: return -1\\n \\n return num\\n \\n \\n \\n \\n\", \"class Solution:\\n def minNumberOfFrogs(self, s: str) -> int:\\n rec = defaultdict(int)\\n count = 0\\n \\n if not s.startswith('c') or not s.endswith('k'): return -1\\n \\n for i in range(len(s)):\\n if rec['c']>=rec['r']>=rec['o']>=rec['a']>=rec['k']:\\n rec[s[i]] += 1\\n if count < rec['c']: count += 1\\n if s[i] == 'k':\\n for k in rec:\\n rec[k] -= 1\\n else:\\n return -1\\n return count\\n \\n \\n# frog_counter = 0 # To count the minimum no. of frogs croaking\\n# crk_dict = {'c':0,'r':0,'o':0,'a':0,'k':0} # create dictionary initializing the values to 0\\n \\n# # The string must always start with 'c'\\n# if croakOfFrogs[0] != 'c':\\n# return (-1)\\n \\n# # The string must always end with 'k'\\n# elif croakOfFrogs[-1] != 'k':\\n# return (-1)\\n \\n# else:\\n# for i in range(len(croakOfFrogs)):\\n# # As the craok always start with c and the characters are sequential always the count of each of the char should greater than or equal to the next char of string 'craok'\\n# if crk_dict['c'] >= crk_dict['r'] >= crk_dict['o'] >= crk_dict['a'] >= crk_dict['k']:\\n \\n# crk_dict[croakOfFrogs[i]] += 1\\n \\n# # if 'c' is encountered in string before the completion of croak, that mean it is the other frog, hence add 1 to the frog counter\\n# if frog_counter < crk_dict['c']:\\n# frog_counter += 1\\n \\n# # if the iterable gets 'k' that means the frog is free to croak again\\n# if croakOfFrogs[i] == 'k':\\n# for m in crk_dict:\\n# crk_dict[m] -= 1\\n# else:\\n# return (-1)\\n# return frog_counter\\n\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n croak = 'croak'\\n frogs = 0\\n openCroaks = list()\\n char2count = {'c':0, 'r':0, 'o':0, 'a':0, 'k':0}\\n \\n for char in croakOfFrogs:\\n if char not in croak:\\n return -1\\n if char == 'c':\\n char2count[char]+=1\\n elif char2count[croak[croak.find(char)-1]]>0:\\n char2count[croak[croak.find(char)-1]]-=1\\n if char!= 'k':\\n char2count[char]+=1\\n \\n else:\\n return -1\\n frogs = max(frogs, sum(char2count.values()))\\n return frogs if sum(char2count.values())==0 else -1\", \"chars = ['c','r','o','a','k']\\nC = len(chars)\\ncs = set(chars)\\nclass Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n N=len(croakOfFrogs)\\n if N==0: return 0\\n if N%5!=0: return -1\\n counter = Counter(croakOfFrogs)\\n if len(counter)!=5: return -1\\n totFreq=None\\n for c in counter:\\n if not totFreq:\\n totFreq==counter[c]\\n elif totFreq!=counter[c]:\\n return -1\\n dic = [0]* C\\n ans=0\\n for i in range(N):\\n c = croakOfFrogs[i]\\n if c not in cs:\\n return -1\\n if c == chars[0]:\\n for j in range(1,len(chars)):\\n dic[j]+=1\\n ans=max(ans,dic[C-1])\\n else:\\n j = chars.index(c)\\n dic[j]-=1\\n prev = dic[j]\\n for k in range(j-1,-1,-1):\\n if dic[k]>prev:\\n return -1\\n prev=dic[k]\\n return ans\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n \\n if len(croakOfFrogs) % 5 != 0:\\n return -1\\n \\n dic = {'c': 0, 'r': 1, 'o': 2, 'a':3, 'k':4}\\n numsCount = [0]*5\\n \\n max_val = numOfFrogs = 0\\n \\n for i in range(len(croakOfFrogs)):\\n \\n if croakOfFrogs[i] == 'c':\\n numOfFrogs +=1\\n # print(numOfFrogs)\\n if croakOfFrogs[i] == 'k':\\n numOfFrogs -=1\\n \\n max_val = max(numOfFrogs, max_val)\\n numsCount[dic[croakOfFrogs[i]]] += 1\\n \\n for j in range(0, 4):\\n if numsCount[j] < numsCount[j+1]:\\n return -1\\n \\n \\n return max_val\\n \\n \\n\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n frog_counter = 0 # To count the minimum no. of frogs croaking\\n crk_dict = {'c':0,'r':0,'o':0,'a':0,'k':0} # create dictionary initializing the values to 0\\n \\n # The string must always start with 'c'\\n if croakOfFrogs[0] != 'c':\\n return (-1)\\n \\n # The string must always end with 'k'\\n elif croakOfFrogs[-1] != 'k':\\n return (-1)\\n \\n else:\\n for i in range(len(croakOfFrogs)):\\n # As the craok always start with c and the characters are sequential always the count of each of the char should greater than or equal to the next char of string 'craok'\\n if crk_dict['c'] >= crk_dict['r'] >= crk_dict['o'] >= crk_dict['a'] >= crk_dict['k']:\\n \\n crk_dict[croakOfFrogs[i]] += 1\\n \\n # if 'c' is encountered in string before the completion of croak, that mean it is the other frog, hence add 1 to the frog counter\\n if frog_counter < crk_dict['c']:\\n frog_counter += 1\\n \\n # if the iterable gets 'k' that means the frog is free to croak again\\n if croakOfFrogs[i] == 'k':\\n for m in crk_dict:\\n crk_dict[m] -= 1\\n else:\\n return (-1)\\n return frog_counter\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n croak = 'croak'\\n croak_positions = {char: 0 for char in croak}\\n max_size = 0\\n completed = 0\\n for char in croakOfFrogs:\\n if char in croak_positions:\\n croak_positions[char] += 1\\n else:\\n return -1\\n for char, count in croak_positions.items():\\n if char != croak[0]:\\n diff = croak_positions[croak[0]] - count\\n if diff < 0:\\n return -1\\n if diff > max_size:\\n max_size = diff\\n for char, count in croak_positions.items():\\n if count != croak_positions[croak[0]]:\\n return -1\\n return max_size\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n res = croaking = c = r = o = a = k = 0\\n for x in croakOfFrogs:\\n if x == 'c':\\n c, croaking = c+1, croaking+1\\n res = max(res, croaking)\\n elif x == 'r': r += 1\\n elif x == 'o': o += 1\\n elif x == 'a': a += 1\\n else: k, croaking = k+1, croaking-1\\n if c < r or r < o or o < a or a < k: return -1 \\n \\n return res if c == r == o == a == k and croaking == 0 else -1\\n\", \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n frogs, c, r, o, a, k = 0, 0, 0, 0, 0, 0\\n for char in croakOfFrogs:\\n if char == 'c':\\n c += 1\\n frogs = max(frogs, c - k)\\n elif char == 'r':\\n r += 1\\n elif char == 'o':\\n o += 1\\n elif char == 'a':\\n a += 1\\n elif char == 'k':\\n k += 1\\n else:\\n return -1\\n if not c >= r >= o >= a >= k:\\n return -1\\n if c == k:\\n return frogs\\n return -1\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"minNumberOfFrogs\", \"inputs\": [[\"\\\"croakcroak\\\"\"]], \"outputs\": [-1]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/minimum-number-of-frogs-croaking/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n # valid string? can be seperated into full croaks:\n ### dict of letters. c, r, o, a, k should all be equal, nothing else in\n if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':\n return -1\n \n letters = {\n 'c': 0,\n 'r': 0,\n 'o': 0,\n 'a': 0,\n 'k': 0\n }\n \n frogs = 0\n temp = 0\n \n for l in croakOfFrogs:\n letters[l] += 1\n temp = letters['c'] - letters['k']\n if temp > frogs:\n frogs = temp\n \n \n c_count = letters['c']\n for letter in letters:\n if letters[letter] != c_count:\n return -1\n \n return frogs","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n croaks = {'c':[], 'r':[], 'o':[], 'a':[]}\n nfrogs = 0\n icroak = 0\n curfrogs = 0\n for sound in croakOfFrogs:\n if sound == 'c':\n icroak += 1\n croaks['c'].append(icroak)\n curfrogs += 1\n nfrogs = max(curfrogs, nfrogs)\n elif sound == 'r':\n if croaks['c']:\n croaks['r'].append(croaks['c'].pop())\n else:\n return -1\n elif sound == 'o':\n if croaks['r']:\n croaks['o'].append(croaks['r'].pop())\n else:\n return -1\n elif sound == 'a':\n if croaks['o']:\n croaks['a'].append(croaks['o'].pop())\n else:\n return -1\n elif sound == 'k':\n if croaks['a']:\n croaks['a'].pop()\n curfrogs -= 1\n else:\n return -1\n else:\n return -1\n \n for sound in croaks:\n if croaks[sound] != []:\n return -1\n \n return nfrogs\n \n","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n croaks = {'c':[], 'r':[], 'o':[], 'a':[]}\n maxfrogs = 0\n i_croak = 0\n nfrogs = 0\n for sound in croakOfFrogs:\n if sound == 'c':\n i_croak += 1\n croaks['c'].append(i_croak)\n nfrogs += 1\n maxfrogs = max(nfrogs, maxfrogs)\n elif sound == 'r':\n if croaks['c']:\n croaks['r'].append(croaks['c'].pop())\n else:\n return -1\n elif sound == 'o':\n if croaks['r']:\n croaks['o'].append(croaks['r'].pop())\n else:\n return -1\n elif sound == 'a':\n if croaks['o']:\n croaks['a'].append(croaks['o'].pop())\n else:\n return -1\n elif sound == 'k':\n if croaks['a']:\n croaks['a'].pop()\n nfrogs -= 1\n else:\n return -1\n else:\n return -1\n \n for sound in croaks:\n if croaks[sound] != []:\n return -1\n \n return maxfrogs\n \n","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n ans = 1\n waitingFor = defaultdict(int)\n croak = 'croak'\n croakDict= {'c': 0, 'r': 1, 'o': 2, 'a': 3, 'k': 4}\n \n # waitingFor['c'] = 0\n for char in croakOfFrogs:\n if char == 'c':\n if waitingFor[char] != 0 and ans <= waitingFor[char]:\n ans += 1\n waitingFor[char] += 1\n waitingFor[croak[croakDict[char]+1]] += 1\n else:\n if waitingFor[char] == 0:\n return -1\n waitingFor[char] -= 1\n if char != 'k':\n waitingFor[croak[croakDict[char]+1]] += 1\n else:\n waitingFor['c'] -= 1\n # print(waitingFor)\n for char in waitingFor:\n if waitingFor[char] != 0:\n return -1\n return ans","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':\n return -1\n\n max_frog_croak = 0\n present_frog_croak = 0\n\n d={}\n d['c']=0\n d['r']=0\n d['o']=0\n d['a']=0\n d['k']=0\n\n for ch in croakOfFrogs:\n d[ch]+=1\n if ch=='c':\n present_frog_croak+=1\n if ch=='k':\n present_frog_croak-=1\n\n max_frog_croak = max(max_frog_croak,present_frog_croak)\n\n\n if d['c']!=d['r'] or d['r']!=d['o'] or d['o']!=d['a'] or d['a']!=d['k']:\n return -1\n\n return max_frog_croak\n","class Solution:\n def minNumberOfFrogs(self, croak: str) -> int:\n if len(croak) == 0:\n return 0\n if croak[0] != 'c':\n return -1\n if len(croak) % 5 != 0:\n return -1\n arr = [0 for _ in range(6)]\n arr[0] = 9999999\n index = {'c':1, 'r':2, 'o':3, 'a':4, 'k':5}\n \n for letter in croak:\n i = index[letter] \n if arr[i-1] > 0:\n if i == 1 and arr[5]:\n arr[5] -= 1\n arr[i-1] -= 1\n arr[i] += 1\n else:\n return -1\n for i in arr[1:-1]:\n if i != 0:\n return -1\n return arr[-1]","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n chr_c, chr_r, chr_o, chr_a = 0, 0, 0, 0\n count = 0\n for s in croakOfFrogs:\n if s == 'c':\n chr_c += 1\n elif s == 'r':\n if chr_c <= 0:\n return -1\n chr_c -= 1\n chr_r += 1\n elif s == 'o':\n if chr_r <= 0:\n return -1\n chr_r -= 1\n chr_o += 1\n elif s == 'a':\n if chr_o <= 0:\n return -1\n chr_o -= 1\n chr_a += 1\n else:\n if chr_a <= 0:\n return -1\n chr_a -= 1\n count = max(count, chr_c + chr_r + chr_o + chr_a)\n # 没有唱完整五个字符，那么必然会大于0\n if chr_c + chr_r + chr_o + chr_a > 0:\n return -1\n return count","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n # valid string? can be seperated into full croaks:\n ### dict of letters. c, r, o, a, k should all be equal, nothing else in\n if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':\n return -1\n \n letters = {\n 'c': 0,\n 'r': 0,\n 'o': 0,\n 'a': 0,\n 'k': 0\n }\n \n frogs = 0\n temp = 0\n \n for l in croakOfFrogs:\n letters[l] += 1\n temp = letters['c'] - letters['k']\n if temp > frogs:\n frogs = temp\n \n \n c_count = letters['c']\n for letter in letters:\n if letters[letter] != c_count:\n return -1\n \n return frogs\n","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n curr=0\n maxcurr=0\n c=r=o=a=k=0\n for i in croakOfFrogs:\n if i=='c':\n c+=1\n curr+=1\n elif i=='r':\n r+=1\n elif i=='o':\n o+=1\n elif i=='a':\n a+=1\n else:\n k+=1\n curr-=1\n maxcurr=max(curr,maxcurr)\n if c<r or r<o or o<a or a<k:\n return -1\n if curr==0 and c==r and r==o and o==a and a==k:\n return maxcurr\n return -1","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':\n return -1\n\n max_frog_croak = 0\n present_frog_croak = 0\n\n d={}\n d['c']=0\n d['r']=0\n d['o']=0\n d['a']=0\n d['k']=0\n\n for ch in croakOfFrogs:\n d[ch]+=1\n if ch=='c':\n present_frog_croak+=1\n if ch=='k':\n present_frog_croak-=1\n\n max_frog_croak = max(max_frog_croak,present_frog_croak)\n\n\n if d['c']!=d['r'] or d['r']!=d['o'] or d['o']!=d['a'] or d['a']!=d['k']:\n return -1\n\n return max_frog_croak","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n neighcount = [0,0,0,0,0]\n minhorses = 0\n nstarted = 0\n nended = 0\n \n for s in croakOfFrogs:\n if s == 'c':\n neighcount[0] += 1\n nstarted += 1\n elif s == 'r':\n neighcount[1] += 1\n neighcount[0] -= 1\n elif s == 'o':\n neighcount[2] += 1\n neighcount[1] -= 1\n elif s == 'a':\n neighcount[3] += 1\n neighcount[2] -= 1\n elif s == 'k':\n neighcount[4] += 1\n neighcount[3] -= 1\n nstarted -= 1\n else:\n return -1\n if nstarted > minhorses:\n minhorses = nstarted\n if neighcount[0] < 0 or neighcount[1] < 0 or neighcount[2] < 0 or neighcount[3] < 0:\n return -1\n if neighcount[0] == 0 and neighcount[1] == 0 and neighcount[2] == 0 and neighcount[3] == 0:\n return minhorses\n else:\n return -1\n \n \n \n","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n if not len(croakOfFrogs): return 0\n \n c = 0\n r = 0\n o = 0\n a = 0\n k = 0\n count = 0\n \n for ch in croakOfFrogs:\n \n if ch == 'c':\n count += 1\n c += 1\n \n elif ch == 'r':\n if not c:\n return -1\n c -= 1\n r += 1\n \n \n elif ch == 'o':\n if not r:\n return -1\n r -= 1\n o += 1\n \n \n elif ch == 'a':\n if not o:\n return -1\n o -= 1\n a += 1\n \n \n elif ch == 'k':\n if not a:\n return -1\n a -= 1\n \n k = max(k, count)\n count -= 1\n \n \n else:\n return -1\n \n if not c and not r and not o and not a:\n return k\n else:\n return -1","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n # print(len(croakOfFrogs))\n if len(croakOfFrogs) % 5 > 0:\n return -1\n pos = {'c': 0, 'r': 1, 'o': 2, 'a': 3, 'k': 4}\n count = [0]*5\n res = 1\n for c in croakOfFrogs:\n count[pos[c]] += 1\n # print(count)\n if pos[c] > 0:\n if count[pos[c]] > count[pos[c]-1]:\n return -1\n if pos[c] == 4:\n for i in range(5):\n count[i] -= 1\n elif pos[c] == 0:\n res = max(res, count[0])\n for i in range(4):\n if count[i+1] != count[i]:\n return -1\n return res","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n frogs, d = [], {c: [] for c in 'croak'}\n for c in croakOfFrogs:\n bucket = 'croak'['croak'.find(c)-1]\n if not d[bucket]:\n if bucket != 'k': return -1\n frogs.append([])\n d[c].append(len(frogs) - 1)\n else:\n d[c].append(d[bucket].pop())\n if c == 'c':\n frogs[d[c][-1]].clear()\n frogs[d[c][-1]].append(c)\n return len(frogs) if all(len(frog) == 5 for frog in frogs) else -1\n","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n \n r = 0\n o = 0\n a = 0\n k = 0\n \n frogs = 0\n max_frogs = 0\n for L in croakOfFrogs:\n \n if L == 'c':\n frogs += 1\n max_frogs = max(max_frogs, frogs)\n r += 1\n \n elif L == 'r':\n if r == 0:\n return -1\n else:\n r -= 1\n o += 1\n \n elif L == 'o':\n if o == 0:\n return -1\n else:\n o -= 1\n a += 1\n \n elif L == 'a':\n if a == 0:\n return -1\n else:\n a -= 1\n k += 1\n \n else:\n if k == 0:\n return -1\n else:\n k -= 1\n frogs -= 1\n \n if r + o + a + k != 0:\n return -1\n \n return max_frogs\n \n","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n if len(croakOfFrogs) % 5 != 0:\n return -1\n \n min_val = 0\n cnt = {char: 0 for char in 'croak'}\n for char in croakOfFrogs:\n if char not in 'croak' or not cnt['c'] >= cnt['r'] >= cnt['o'] >= cnt['a'] >= cnt['k']:\n return -1\n cnt[char] += 1\n \n min_val = max(min_val, cnt['c'] - cnt['k'])\n \n return min_val if cnt['c'] == cnt['r'] == cnt['o'] == cnt['a'] == cnt['k'] else -1","class Solution:\n# def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n# neighcount = [0,0,0,0,0]\n# minhorses = 0\n# nstarted = 0\n# nended = 0\n \n# for s in croakOfFrogs:\n# if s == 'c':\n# neighcount[0] += 1\n# nstarted += 1\n# elif s == 'r':\n# neighcount[1] += 1\n# neighcount[0] -= 1\n# if neighcount[0] < 0:\n# return -1\n# elif s == 'o':\n# neighcount[2] += 1\n# neighcount[1] -= 1\n# if neighcount[1] < 0:\n# return -1\n# elif s == 'a':\n# neighcount[3] += 1\n# neighcount[2] -= 1\n# if neighcount[2] < 0:\n# return -1\n# elif s == 'k':\n# neighcount[4] += 1\n# neighcount[3] -= 1\n# nstarted -= 1\n# if neighcount[3] < 0:\n# return -1 \n# else:\n# return -1\n# if nstarted > minhorses:\n# minhorses = nstarted\n# neighcount[4] = 0\n# if max(neighcount) == 0:\n# return minhorses\n# else:\n# return -1\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n\n if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':\n return -1\n \n max_frog_croak = 0\n present_frog_croak = 0\n\n d={}\n d['c']=0\n d['r']=0\n d['o']=0\n d['a']=0\n d['k']=0\n\n for ch in croakOfFrogs:\n d[ch]+=1\n if ch=='c':\n present_frog_croak+=1\n if ch=='k':\n present_frog_croak-=1\n\n max_frog_croak = max(max_frog_croak,present_frog_croak)\n\n\n if d['c']!=d['r'] or d['r']!=d['o'] or d['o']!=d['a'] or d['a']!=d['k']:\n return -1\n\n return max_frog_croak \n \n \n","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n\n if len(croakOfFrogs) % 5 != 0:\n return -1\n nums = [0] * 5\n \n dic = {'c': 0, 'r': 1, 'o':2, 'a': 3, 'k' : 4}\n res = 1\n for ch in croakOfFrogs:\n if dic[ch] != 0 and nums[dic[ch]] >= nums[dic[ch] - 1]:\n return -1\n \n nums[dic[ch]] += 1\n res = max(res, nums[0])\n if ch == 'k':\n for i in range(5):\n nums[i] -= 1 \n \n \n return res","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n c, r, o, a, k, in_use, answer = 0, 0, 0, 0, 0, 0, 0\n for d in croakOfFrogs:\n if d == 'c':\n c, in_use = c+1, in_use+1\n elif d == 'r':\n r += 1\n elif d == 'o':\n o += 1\n elif d == 'a':\n a += 1\n else:\n k, in_use = k+1, in_use-1\n \n answer = max(answer, in_use)\n \n if c < r or r < o or o < a or a < k:\n return -1\n \n if in_use == 0 and c == r and r == o and o == a and a == k:\n return answer\n \n return -1","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n \n arr = [0] * 5 \n\n for item in croakOfFrogs:\n \n if item == 'c':\n arr[0] += 1\n \n elif item == 'r':\n arr[1] += 1\n for i in range(0, 1):\n if arr[i] < arr[1]:\n return -1\n \n elif item == 'o':\n arr[2] += 1\n for i in range(0, 1):\n if arr[i] < arr[2]:\n return -1\n \n elif item == 'a':\n arr[3] += 1\n for i in range(0, 1):\n if arr[i] < arr[3]:\n return -1\n\n else:\n arr[4] += 1\n for i in range(0, 1):\n if arr[i] < arr[4]:\n return -1\n \n cur = arr[0]\n \n for i in range(1, 5):\n if arr[i] != cur:\n return -1\n \n ''' At this point there is a valid string '''\n cur_frogs = 0\n \n result = float('-inf')\n p = 0\n \n while p < len(croakOfFrogs):\n \n if croakOfFrogs[p] == 'c':\n cur_frogs += 1\n \n elif croakOfFrogs[p] == 'k':\n cur_frogs -= 1\n \n result = max(cur_frogs, result)\n p += 1\n \n return result\n \n \n \n \n \n","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n \n dic = {'c': 0, 'r': 1, 'o': 2, 'a': 3, 'k': 4}\n num = 0\n num_c = 0\n num_k = 0\n \n freq = [0] * 5\n \n if not croakOfFrogs[0] == 'c': return -1\n \n # count the number of c before the first k shows up\n \n for ch in croakOfFrogs:\n if 'c' == ch: \n if num_k == 0: num_c += 1\n else: num_k -= 1\n num = max(num_c, num)\n if 'k' == ch: num_k += 1 \n \n # check validation\n for ch in croakOfFrogs:\n freq[dic[ch]] += 1\n \n for idx in range(1, 5):\n if freq[idx] > freq[idx - 1]: return -1\n \n for idx in range(1, 5):\n if not freq[idx] == freq[idx-1]: return -1\n \n return num\n \n \n \n \n","class Solution:\n def minNumberOfFrogs(self, s: str) -> int:\n rec = defaultdict(int)\n count = 0\n \n if not s.startswith('c') or not s.endswith('k'): return -1\n \n for i in range(len(s)):\n if rec['c']>=rec['r']>=rec['o']>=rec['a']>=rec['k']:\n rec[s[i]] += 1\n if count < rec['c']: count += 1\n if s[i] == 'k':\n for k in rec:\n rec[k] -= 1\n else:\n return -1\n return count\n \n \n# frog_counter = 0 # To count the minimum no. of frogs croaking\n# crk_dict = {'c':0,'r':0,'o':0,'a':0,'k':0} # create dictionary initializing the values to 0\n \n# # The string must always start with 'c'\n# if croakOfFrogs[0] != 'c':\n# return (-1)\n \n# # The string must always end with 'k'\n# elif croakOfFrogs[-1] != 'k':\n# return (-1)\n \n# else:\n# for i in range(len(croakOfFrogs)):\n# # As the craok always start with c and the characters are sequential always the count of each of the char should greater than or equal to the next char of string 'craok'\n# if crk_dict['c'] >= crk_dict['r'] >= crk_dict['o'] >= crk_dict['a'] >= crk_dict['k']:\n \n# crk_dict[croakOfFrogs[i]] += 1\n \n# # if 'c' is encountered in string before the completion of croak, that mean it is the other frog, hence add 1 to the frog counter\n# if frog_counter < crk_dict['c']:\n# frog_counter += 1\n \n# # if the iterable gets 'k' that means the frog is free to croak again\n# if croakOfFrogs[i] == 'k':\n# for m in crk_dict:\n# crk_dict[m] -= 1\n# else:\n# return (-1)\n# return frog_counter\n","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n croak = 'croak'\n frogs = 0\n openCroaks = list()\n char2count = {'c':0, 'r':0, 'o':0, 'a':0, 'k':0}\n \n for char in croakOfFrogs:\n if char not in croak:\n return -1\n if char == 'c':\n char2count[char]+=1\n elif char2count[croak[croak.find(char)-1]]>0:\n char2count[croak[croak.find(char)-1]]-=1\n if char!= 'k':\n char2count[char]+=1\n \n else:\n return -1\n frogs = max(frogs, sum(char2count.values()))\n return frogs if sum(char2count.values())==0 else -1","chars = ['c','r','o','a','k']\nC = len(chars)\ncs = set(chars)\nclass Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n N=len(croakOfFrogs)\n if N==0: return 0\n if N%5!=0: return -1\n counter = Counter(croakOfFrogs)\n if len(counter)!=5: return -1\n totFreq=None\n for c in counter:\n if not totFreq:\n totFreq==counter[c]\n elif totFreq!=counter[c]:\n return -1\n dic = [0]* C\n ans=0\n for i in range(N):\n c = croakOfFrogs[i]\n if c not in cs:\n return -1\n if c == chars[0]:\n for j in range(1,len(chars)):\n dic[j]+=1\n ans=max(ans,dic[C-1])\n else:\n j = chars.index(c)\n dic[j]-=1\n prev = dic[j]\n for k in range(j-1,-1,-1):\n if dic[k]>prev:\n return -1\n prev=dic[k]\n return ans","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n \n if len(croakOfFrogs) % 5 != 0:\n return -1\n \n dic = {'c': 0, 'r': 1, 'o': 2, 'a':3, 'k':4}\n numsCount = [0]*5\n \n max_val = numOfFrogs = 0\n \n for i in range(len(croakOfFrogs)):\n \n if croakOfFrogs[i] == 'c':\n numOfFrogs +=1\n # print(numOfFrogs)\n if croakOfFrogs[i] == 'k':\n numOfFrogs -=1\n \n max_val = max(numOfFrogs, max_val)\n numsCount[dic[croakOfFrogs[i]]] += 1\n \n for j in range(0, 4):\n if numsCount[j] < numsCount[j+1]:\n return -1\n \n \n return max_val\n \n \n","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n frog_counter = 0 # To count the minimum no. of frogs croaking\n crk_dict = {'c':0,'r':0,'o':0,'a':0,'k':0} # create dictionary initializing the values to 0\n \n # The string must always start with 'c'\n if croakOfFrogs[0] != 'c':\n return (-1)\n \n # The string must always end with 'k'\n elif croakOfFrogs[-1] != 'k':\n return (-1)\n \n else:\n for i in range(len(croakOfFrogs)):\n # As the craok always start with c and the characters are sequential always the count of each of the char should greater than or equal to the next char of string 'craok'\n if crk_dict['c'] >= crk_dict['r'] >= crk_dict['o'] >= crk_dict['a'] >= crk_dict['k']:\n \n crk_dict[croakOfFrogs[i]] += 1\n \n # if 'c' is encountered in string before the completion of croak, that mean it is the other frog, hence add 1 to the frog counter\n if frog_counter < crk_dict['c']:\n frog_counter += 1\n \n # if the iterable gets 'k' that means the frog is free to croak again\n if croakOfFrogs[i] == 'k':\n for m in crk_dict:\n crk_dict[m] -= 1\n else:\n return (-1)\n return frog_counter","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n croak = 'croak'\n croak_positions = {char: 0 for char in croak}\n max_size = 0\n completed = 0\n for char in croakOfFrogs:\n if char in croak_positions:\n croak_positions[char] += 1\n else:\n return -1\n for char, count in croak_positions.items():\n if char != croak[0]:\n diff = croak_positions[croak[0]] - count\n if diff < 0:\n return -1\n if diff > max_size:\n max_size = diff\n for char, count in croak_positions.items():\n if count != croak_positions[croak[0]]:\n return -1\n return max_size","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n res = croaking = c = r = o = a = k = 0\n for x in croakOfFrogs:\n if x == 'c':\n c, croaking = c+1, croaking+1\n res = max(res, croaking)\n elif x == 'r': r += 1\n elif x == 'o': o += 1\n elif x == 'a': a += 1\n else: k, croaking = k+1, croaking-1\n if c < r or r < o or o < a or a < k: return -1 \n \n return res if c == r == o == a == k and croaking == 0 else -1\n","class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n frogs, c, r, o, a, k = 0, 0, 0, 0, 0, 0\n for char in croakOfFrogs:\n if char == 'c':\n c += 1\n frogs = max(frogs, c - k)\n elif char == 'r':\n r += 1\n elif char == 'o':\n o += 1\n elif char == 'a':\n a += 1\n elif char == 'k':\n k += 1\n else:\n return -1\n if not c >= r >= o >= a >= k:\n return -1\n if c == k:\n return frogs\n return -1"],"string":"[\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n # valid string? can be seperated into full croaks:\\n ### dict of letters. c, r, o, a, k should all be equal, nothing else in\\n if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':\\n return -1\\n \\n letters = {\\n 'c': 0,\\n 'r': 0,\\n 'o': 0,\\n 'a': 0,\\n 'k': 0\\n }\\n \\n frogs = 0\\n temp = 0\\n \\n for l in croakOfFrogs:\\n letters[l] += 1\\n temp = letters['c'] - letters['k']\\n if temp > frogs:\\n frogs = temp\\n \\n \\n c_count = letters['c']\\n for letter in letters:\\n if letters[letter] != c_count:\\n return -1\\n \\n return frogs\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n croaks = {'c':[], 'r':[], 'o':[], 'a':[]}\\n nfrogs = 0\\n icroak = 0\\n curfrogs = 0\\n for sound in croakOfFrogs:\\n if sound == 'c':\\n icroak += 1\\n croaks['c'].append(icroak)\\n curfrogs += 1\\n nfrogs = max(curfrogs, nfrogs)\\n elif sound == 'r':\\n if croaks['c']:\\n croaks['r'].append(croaks['c'].pop())\\n else:\\n return -1\\n elif sound == 'o':\\n if croaks['r']:\\n croaks['o'].append(croaks['r'].pop())\\n else:\\n return -1\\n elif sound == 'a':\\n if croaks['o']:\\n croaks['a'].append(croaks['o'].pop())\\n else:\\n return -1\\n elif sound == 'k':\\n if croaks['a']:\\n croaks['a'].pop()\\n curfrogs -= 1\\n else:\\n return -1\\n else:\\n return -1\\n \\n for sound in croaks:\\n if croaks[sound] != []:\\n return -1\\n \\n return nfrogs\\n \\n\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n croaks = {'c':[], 'r':[], 'o':[], 'a':[]}\\n maxfrogs = 0\\n i_croak = 0\\n nfrogs = 0\\n for sound in croakOfFrogs:\\n if sound == 'c':\\n i_croak += 1\\n croaks['c'].append(i_croak)\\n nfrogs += 1\\n maxfrogs = max(nfrogs, maxfrogs)\\n elif sound == 'r':\\n if croaks['c']:\\n croaks['r'].append(croaks['c'].pop())\\n else:\\n return -1\\n elif sound == 'o':\\n if croaks['r']:\\n croaks['o'].append(croaks['r'].pop())\\n else:\\n return -1\\n elif sound == 'a':\\n if croaks['o']:\\n croaks['a'].append(croaks['o'].pop())\\n else:\\n return -1\\n elif sound == 'k':\\n if croaks['a']:\\n croaks['a'].pop()\\n nfrogs -= 1\\n else:\\n return -1\\n else:\\n return -1\\n \\n for sound in croaks:\\n if croaks[sound] != []:\\n return -1\\n \\n return maxfrogs\\n \\n\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n ans = 1\\n waitingFor = defaultdict(int)\\n croak = 'croak'\\n croakDict= {'c': 0, 'r': 1, 'o': 2, 'a': 3, 'k': 4}\\n \\n # waitingFor['c'] = 0\\n for char in croakOfFrogs:\\n if char == 'c':\\n if waitingFor[char] != 0 and ans <= waitingFor[char]:\\n ans += 1\\n waitingFor[char] += 1\\n waitingFor[croak[croakDict[char]+1]] += 1\\n else:\\n if waitingFor[char] == 0:\\n return -1\\n waitingFor[char] -= 1\\n if char != 'k':\\n waitingFor[croak[croakDict[char]+1]] += 1\\n else:\\n waitingFor['c'] -= 1\\n # print(waitingFor)\\n for char in waitingFor:\\n if waitingFor[char] != 0:\\n return -1\\n return ans\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':\\n return -1\\n\\n max_frog_croak = 0\\n present_frog_croak = 0\\n\\n d={}\\n d['c']=0\\n d['r']=0\\n d['o']=0\\n d['a']=0\\n d['k']=0\\n\\n for ch in croakOfFrogs:\\n d[ch]+=1\\n if ch=='c':\\n present_frog_croak+=1\\n if ch=='k':\\n present_frog_croak-=1\\n\\n max_frog_croak = max(max_frog_croak,present_frog_croak)\\n\\n\\n if d['c']!=d['r'] or d['r']!=d['o'] or d['o']!=d['a'] or d['a']!=d['k']:\\n return -1\\n\\n return max_frog_croak\\n\",\n \"class Solution:\\n def minNumberOfFrogs(self, croak: str) -> int:\\n if len(croak) == 0:\\n return 0\\n if croak[0] != 'c':\\n return -1\\n if len(croak) % 5 != 0:\\n return -1\\n arr = [0 for _ in range(6)]\\n arr[0] = 9999999\\n index = {'c':1, 'r':2, 'o':3, 'a':4, 'k':5}\\n \\n for letter in croak:\\n i = index[letter] \\n if arr[i-1] > 0:\\n if i == 1 and arr[5]:\\n arr[5] -= 1\\n arr[i-1] -= 1\\n arr[i] += 1\\n else:\\n return -1\\n for i in arr[1:-1]:\\n if i != 0:\\n return -1\\n return arr[-1]\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n chr_c, chr_r, chr_o, chr_a = 0, 0, 0, 0\\n count = 0\\n for s in croakOfFrogs:\\n if s == 'c':\\n chr_c += 1\\n elif s == 'r':\\n if chr_c <= 0:\\n return -1\\n chr_c -= 1\\n chr_r += 1\\n elif s == 'o':\\n if chr_r <= 0:\\n return -1\\n chr_r -= 1\\n chr_o += 1\\n elif s == 'a':\\n if chr_o <= 0:\\n return -1\\n chr_o -= 1\\n chr_a += 1\\n else:\\n if chr_a <= 0:\\n return -1\\n chr_a -= 1\\n count = max(count, chr_c + chr_r + chr_o + chr_a)\\n # 没有唱完整五个字符，那么必然会大于0\\n if chr_c + chr_r + chr_o + chr_a > 0:\\n return -1\\n return count\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n # valid string? can be seperated into full croaks:\\n ### dict of letters. c, r, o, a, k should all be equal, nothing else in\\n if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':\\n return -1\\n \\n letters = {\\n 'c': 0,\\n 'r': 0,\\n 'o': 0,\\n 'a': 0,\\n 'k': 0\\n }\\n \\n frogs = 0\\n temp = 0\\n \\n for l in croakOfFrogs:\\n letters[l] += 1\\n temp = letters['c'] - letters['k']\\n if temp > frogs:\\n frogs = temp\\n \\n \\n c_count = letters['c']\\n for letter in letters:\\n if letters[letter] != c_count:\\n return -1\\n \\n return frogs\\n\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n curr=0\\n maxcurr=0\\n c=r=o=a=k=0\\n for i in croakOfFrogs:\\n if i=='c':\\n c+=1\\n curr+=1\\n elif i=='r':\\n r+=1\\n elif i=='o':\\n o+=1\\n elif i=='a':\\n a+=1\\n else:\\n k+=1\\n curr-=1\\n maxcurr=max(curr,maxcurr)\\n if c<r or r<o or o<a or a<k:\\n return -1\\n if curr==0 and c==r and r==o and o==a and a==k:\\n return maxcurr\\n return -1\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':\\n return -1\\n\\n max_frog_croak = 0\\n present_frog_croak = 0\\n\\n d={}\\n d['c']=0\\n d['r']=0\\n d['o']=0\\n d['a']=0\\n d['k']=0\\n\\n for ch in croakOfFrogs:\\n d[ch]+=1\\n if ch=='c':\\n present_frog_croak+=1\\n if ch=='k':\\n present_frog_croak-=1\\n\\n max_frog_croak = max(max_frog_croak,present_frog_croak)\\n\\n\\n if d['c']!=d['r'] or d['r']!=d['o'] or d['o']!=d['a'] or d['a']!=d['k']:\\n return -1\\n\\n return max_frog_croak\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n neighcount = [0,0,0,0,0]\\n minhorses = 0\\n nstarted = 0\\n nended = 0\\n \\n for s in croakOfFrogs:\\n if s == 'c':\\n neighcount[0] += 1\\n nstarted += 1\\n elif s == 'r':\\n neighcount[1] += 1\\n neighcount[0] -= 1\\n elif s == 'o':\\n neighcount[2] += 1\\n neighcount[1] -= 1\\n elif s == 'a':\\n neighcount[3] += 1\\n neighcount[2] -= 1\\n elif s == 'k':\\n neighcount[4] += 1\\n neighcount[3] -= 1\\n nstarted -= 1\\n else:\\n return -1\\n if nstarted > minhorses:\\n minhorses = nstarted\\n if neighcount[0] < 0 or neighcount[1] < 0 or neighcount[2] < 0 or neighcount[3] < 0:\\n return -1\\n if neighcount[0] == 0 and neighcount[1] == 0 and neighcount[2] == 0 and neighcount[3] == 0:\\n return minhorses\\n else:\\n return -1\\n \\n \\n \\n\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n if not len(croakOfFrogs): return 0\\n \\n c = 0\\n r = 0\\n o = 0\\n a = 0\\n k = 0\\n count = 0\\n \\n for ch in croakOfFrogs:\\n \\n if ch == 'c':\\n count += 1\\n c += 1\\n \\n elif ch == 'r':\\n if not c:\\n return -1\\n c -= 1\\n r += 1\\n \\n \\n elif ch == 'o':\\n if not r:\\n return -1\\n r -= 1\\n o += 1\\n \\n \\n elif ch == 'a':\\n if not o:\\n return -1\\n o -= 1\\n a += 1\\n \\n \\n elif ch == 'k':\\n if not a:\\n return -1\\n a -= 1\\n \\n k = max(k, count)\\n count -= 1\\n \\n \\n else:\\n return -1\\n \\n if not c and not r and not o and not a:\\n return k\\n else:\\n return -1\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n # print(len(croakOfFrogs))\\n if len(croakOfFrogs) % 5 > 0:\\n return -1\\n pos = {'c': 0, 'r': 1, 'o': 2, 'a': 3, 'k': 4}\\n count = [0]*5\\n res = 1\\n for c in croakOfFrogs:\\n count[pos[c]] += 1\\n # print(count)\\n if pos[c] > 0:\\n if count[pos[c]] > count[pos[c]-1]:\\n return -1\\n if pos[c] == 4:\\n for i in range(5):\\n count[i] -= 1\\n elif pos[c] == 0:\\n res = max(res, count[0])\\n for i in range(4):\\n if count[i+1] != count[i]:\\n return -1\\n return res\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n frogs, d = [], {c: [] for c in 'croak'}\\n for c in croakOfFrogs:\\n bucket = 'croak'['croak'.find(c)-1]\\n if not d[bucket]:\\n if bucket != 'k': return -1\\n frogs.append([])\\n d[c].append(len(frogs) - 1)\\n else:\\n d[c].append(d[bucket].pop())\\n if c == 'c':\\n frogs[d[c][-1]].clear()\\n frogs[d[c][-1]].append(c)\\n return len(frogs) if all(len(frog) == 5 for frog in frogs) else -1\\n\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n \\n r = 0\\n o = 0\\n a = 0\\n k = 0\\n \\n frogs = 0\\n max_frogs = 0\\n for L in croakOfFrogs:\\n \\n if L == 'c':\\n frogs += 1\\n max_frogs = max(max_frogs, frogs)\\n r += 1\\n \\n elif L == 'r':\\n if r == 0:\\n return -1\\n else:\\n r -= 1\\n o += 1\\n \\n elif L == 'o':\\n if o == 0:\\n return -1\\n else:\\n o -= 1\\n a += 1\\n \\n elif L == 'a':\\n if a == 0:\\n return -1\\n else:\\n a -= 1\\n k += 1\\n \\n else:\\n if k == 0:\\n return -1\\n else:\\n k -= 1\\n frogs -= 1\\n \\n if r + o + a + k != 0:\\n return -1\\n \\n return max_frogs\\n \\n\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n if len(croakOfFrogs) % 5 != 0:\\n return -1\\n \\n min_val = 0\\n cnt = {char: 0 for char in 'croak'}\\n for char in croakOfFrogs:\\n if char not in 'croak' or not cnt['c'] >= cnt['r'] >= cnt['o'] >= cnt['a'] >= cnt['k']:\\n return -1\\n cnt[char] += 1\\n \\n min_val = max(min_val, cnt['c'] - cnt['k'])\\n \\n return min_val if cnt['c'] == cnt['r'] == cnt['o'] == cnt['a'] == cnt['k'] else -1\",\n \"class Solution:\\n# def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n# neighcount = [0,0,0,0,0]\\n# minhorses = 0\\n# nstarted = 0\\n# nended = 0\\n \\n# for s in croakOfFrogs:\\n# if s == 'c':\\n# neighcount[0] += 1\\n# nstarted += 1\\n# elif s == 'r':\\n# neighcount[1] += 1\\n# neighcount[0] -= 1\\n# if neighcount[0] < 0:\\n# return -1\\n# elif s == 'o':\\n# neighcount[2] += 1\\n# neighcount[1] -= 1\\n# if neighcount[1] < 0:\\n# return -1\\n# elif s == 'a':\\n# neighcount[3] += 1\\n# neighcount[2] -= 1\\n# if neighcount[2] < 0:\\n# return -1\\n# elif s == 'k':\\n# neighcount[4] += 1\\n# neighcount[3] -= 1\\n# nstarted -= 1\\n# if neighcount[3] < 0:\\n# return -1 \\n# else:\\n# return -1\\n# if nstarted > minhorses:\\n# minhorses = nstarted\\n# neighcount[4] = 0\\n# if max(neighcount) == 0:\\n# return minhorses\\n# else:\\n# return -1\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n\\n if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':\\n return -1\\n \\n max_frog_croak = 0\\n present_frog_croak = 0\\n\\n d={}\\n d['c']=0\\n d['r']=0\\n d['o']=0\\n d['a']=0\\n d['k']=0\\n\\n for ch in croakOfFrogs:\\n d[ch]+=1\\n if ch=='c':\\n present_frog_croak+=1\\n if ch=='k':\\n present_frog_croak-=1\\n\\n max_frog_croak = max(max_frog_croak,present_frog_croak)\\n\\n\\n if d['c']!=d['r'] or d['r']!=d['o'] or d['o']!=d['a'] or d['a']!=d['k']:\\n return -1\\n\\n return max_frog_croak \\n \\n \\n\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n\\n if len(croakOfFrogs) % 5 != 0:\\n return -1\\n nums = [0] * 5\\n \\n dic = {'c': 0, 'r': 1, 'o':2, 'a': 3, 'k' : 4}\\n res = 1\\n for ch in croakOfFrogs:\\n if dic[ch] != 0 and nums[dic[ch]] >= nums[dic[ch] - 1]:\\n return -1\\n \\n nums[dic[ch]] += 1\\n res = max(res, nums[0])\\n if ch == 'k':\\n for i in range(5):\\n nums[i] -= 1 \\n \\n \\n return res\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n c, r, o, a, k, in_use, answer = 0, 0, 0, 0, 0, 0, 0\\n for d in croakOfFrogs:\\n if d == 'c':\\n c, in_use = c+1, in_use+1\\n elif d == 'r':\\n r += 1\\n elif d == 'o':\\n o += 1\\n elif d == 'a':\\n a += 1\\n else:\\n k, in_use = k+1, in_use-1\\n \\n answer = max(answer, in_use)\\n \\n if c < r or r < o or o < a or a < k:\\n return -1\\n \\n if in_use == 0 and c == r and r == o and o == a and a == k:\\n return answer\\n \\n return -1\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n \\n arr = [0] * 5 \\n\\n for item in croakOfFrogs:\\n \\n if item == 'c':\\n arr[0] += 1\\n \\n elif item == 'r':\\n arr[1] += 1\\n for i in range(0, 1):\\n if arr[i] < arr[1]:\\n return -1\\n \\n elif item == 'o':\\n arr[2] += 1\\n for i in range(0, 1):\\n if arr[i] < arr[2]:\\n return -1\\n \\n elif item == 'a':\\n arr[3] += 1\\n for i in range(0, 1):\\n if arr[i] < arr[3]:\\n return -1\\n\\n else:\\n arr[4] += 1\\n for i in range(0, 1):\\n if arr[i] < arr[4]:\\n return -1\\n \\n cur = arr[0]\\n \\n for i in range(1, 5):\\n if arr[i] != cur:\\n return -1\\n \\n ''' At this point there is a valid string '''\\n cur_frogs = 0\\n \\n result = float('-inf')\\n p = 0\\n \\n while p < len(croakOfFrogs):\\n \\n if croakOfFrogs[p] == 'c':\\n cur_frogs += 1\\n \\n elif croakOfFrogs[p] == 'k':\\n cur_frogs -= 1\\n \\n result = max(cur_frogs, result)\\n p += 1\\n \\n return result\\n \\n \\n \\n \\n \\n\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n \\n dic = {'c': 0, 'r': 1, 'o': 2, 'a': 3, 'k': 4}\\n num = 0\\n num_c = 0\\n num_k = 0\\n \\n freq = [0] * 5\\n \\n if not croakOfFrogs[0] == 'c': return -1\\n \\n # count the number of c before the first k shows up\\n \\n for ch in croakOfFrogs:\\n if 'c' == ch: \\n if num_k == 0: num_c += 1\\n else: num_k -= 1\\n num = max(num_c, num)\\n if 'k' == ch: num_k += 1 \\n \\n # check validation\\n for ch in croakOfFrogs:\\n freq[dic[ch]] += 1\\n \\n for idx in range(1, 5):\\n if freq[idx] > freq[idx - 1]: return -1\\n \\n for idx in range(1, 5):\\n if not freq[idx] == freq[idx-1]: return -1\\n \\n return num\\n \\n \\n \\n \\n\",\n \"class Solution:\\n def minNumberOfFrogs(self, s: str) -> int:\\n rec = defaultdict(int)\\n count = 0\\n \\n if not s.startswith('c') or not s.endswith('k'): return -1\\n \\n for i in range(len(s)):\\n if rec['c']>=rec['r']>=rec['o']>=rec['a']>=rec['k']:\\n rec[s[i]] += 1\\n if count < rec['c']: count += 1\\n if s[i] == 'k':\\n for k in rec:\\n rec[k] -= 1\\n else:\\n return -1\\n return count\\n \\n \\n# frog_counter = 0 # To count the minimum no. of frogs croaking\\n# crk_dict = {'c':0,'r':0,'o':0,'a':0,'k':0} # create dictionary initializing the values to 0\\n \\n# # The string must always start with 'c'\\n# if croakOfFrogs[0] != 'c':\\n# return (-1)\\n \\n# # The string must always end with 'k'\\n# elif croakOfFrogs[-1] != 'k':\\n# return (-1)\\n \\n# else:\\n# for i in range(len(croakOfFrogs)):\\n# # As the craok always start with c and the characters are sequential always the count of each of the char should greater than or equal to the next char of string 'craok'\\n# if crk_dict['c'] >= crk_dict['r'] >= crk_dict['o'] >= crk_dict['a'] >= crk_dict['k']:\\n \\n# crk_dict[croakOfFrogs[i]] += 1\\n \\n# # if 'c' is encountered in string before the completion of croak, that mean it is the other frog, hence add 1 to the frog counter\\n# if frog_counter < crk_dict['c']:\\n# frog_counter += 1\\n \\n# # if the iterable gets 'k' that means the frog is free to croak again\\n# if croakOfFrogs[i] == 'k':\\n# for m in crk_dict:\\n# crk_dict[m] -= 1\\n# else:\\n# return (-1)\\n# return frog_counter\\n\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n croak = 'croak'\\n frogs = 0\\n openCroaks = list()\\n char2count = {'c':0, 'r':0, 'o':0, 'a':0, 'k':0}\\n \\n for char in croakOfFrogs:\\n if char not in croak:\\n return -1\\n if char == 'c':\\n char2count[char]+=1\\n elif char2count[croak[croak.find(char)-1]]>0:\\n char2count[croak[croak.find(char)-1]]-=1\\n if char!= 'k':\\n char2count[char]+=1\\n \\n else:\\n return -1\\n frogs = max(frogs, sum(char2count.values()))\\n return frogs if sum(char2count.values())==0 else -1\",\n \"chars = ['c','r','o','a','k']\\nC = len(chars)\\ncs = set(chars)\\nclass Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n N=len(croakOfFrogs)\\n if N==0: return 0\\n if N%5!=0: return -1\\n counter = Counter(croakOfFrogs)\\n if len(counter)!=5: return -1\\n totFreq=None\\n for c in counter:\\n if not totFreq:\\n totFreq==counter[c]\\n elif totFreq!=counter[c]:\\n return -1\\n dic = [0]* C\\n ans=0\\n for i in range(N):\\n c = croakOfFrogs[i]\\n if c not in cs:\\n return -1\\n if c == chars[0]:\\n for j in range(1,len(chars)):\\n dic[j]+=1\\n ans=max(ans,dic[C-1])\\n else:\\n j = chars.index(c)\\n dic[j]-=1\\n prev = dic[j]\\n for k in range(j-1,-1,-1):\\n if dic[k]>prev:\\n return -1\\n prev=dic[k]\\n return ans\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n \\n if len(croakOfFrogs) % 5 != 0:\\n return -1\\n \\n dic = {'c': 0, 'r': 1, 'o': 2, 'a':3, 'k':4}\\n numsCount = [0]*5\\n \\n max_val = numOfFrogs = 0\\n \\n for i in range(len(croakOfFrogs)):\\n \\n if croakOfFrogs[i] == 'c':\\n numOfFrogs +=1\\n # print(numOfFrogs)\\n if croakOfFrogs[i] == 'k':\\n numOfFrogs -=1\\n \\n max_val = max(numOfFrogs, max_val)\\n numsCount[dic[croakOfFrogs[i]]] += 1\\n \\n for j in range(0, 4):\\n if numsCount[j] < numsCount[j+1]:\\n return -1\\n \\n \\n return max_val\\n \\n \\n\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n frog_counter = 0 # To count the minimum no. of frogs croaking\\n crk_dict = {'c':0,'r':0,'o':0,'a':0,'k':0} # create dictionary initializing the values to 0\\n \\n # The string must always start with 'c'\\n if croakOfFrogs[0] != 'c':\\n return (-1)\\n \\n # The string must always end with 'k'\\n elif croakOfFrogs[-1] != 'k':\\n return (-1)\\n \\n else:\\n for i in range(len(croakOfFrogs)):\\n # As the craok always start with c and the characters are sequential always the count of each of the char should greater than or equal to the next char of string 'craok'\\n if crk_dict['c'] >= crk_dict['r'] >= crk_dict['o'] >= crk_dict['a'] >= crk_dict['k']:\\n \\n crk_dict[croakOfFrogs[i]] += 1\\n \\n # if 'c' is encountered in string before the completion of croak, that mean it is the other frog, hence add 1 to the frog counter\\n if frog_counter < crk_dict['c']:\\n frog_counter += 1\\n \\n # if the iterable gets 'k' that means the frog is free to croak again\\n if croakOfFrogs[i] == 'k':\\n for m in crk_dict:\\n crk_dict[m] -= 1\\n else:\\n return (-1)\\n return frog_counter\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n croak = 'croak'\\n croak_positions = {char: 0 for char in croak}\\n max_size = 0\\n completed = 0\\n for char in croakOfFrogs:\\n if char in croak_positions:\\n croak_positions[char] += 1\\n else:\\n return -1\\n for char, count in croak_positions.items():\\n if char != croak[0]:\\n diff = croak_positions[croak[0]] - count\\n if diff < 0:\\n return -1\\n if diff > max_size:\\n max_size = diff\\n for char, count in croak_positions.items():\\n if count != croak_positions[croak[0]]:\\n return -1\\n return max_size\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n res = croaking = c = r = o = a = k = 0\\n for x in croakOfFrogs:\\n if x == 'c':\\n c, croaking = c+1, croaking+1\\n res = max(res, croaking)\\n elif x == 'r': r += 1\\n elif x == 'o': o += 1\\n elif x == 'a': a += 1\\n else: k, croaking = k+1, croaking-1\\n if c < r or r < o or o < a or a < k: return -1 \\n \\n return res if c == r == o == a == k and croaking == 0 else -1\\n\",\n \"class Solution:\\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\\n frogs, c, r, o, a, k = 0, 0, 0, 0, 0, 0\\n for char in croakOfFrogs:\\n if char == 'c':\\n c += 1\\n frogs = max(frogs, c - k)\\n elif char == 'r':\\n r += 1\\n elif char == 'o':\\n o += 1\\n elif char == 'a':\\n a += 1\\n elif char == 'k':\\n k += 1\\n else:\\n return -1\\n if not c >= r >= o >= a >= k:\\n return -1\\n if c == k:\\n return frogs\\n return -1\"\n]","isConversational":false},"n_sols":{"kind":"number","value":29,"string":"29"},"non_interactive_idx":{"kind":"list like","value":[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],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[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],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":83,"cells":{"problem_id":{"kind":"number","value":217,"string":"217"},"question":{"kind":"string","value":"We have an array A of non-negative integers.\nFor every (contiguous) subarray B = [A[i], A[i+1], ..., A[j]] (with i <= j), we take the bitwise OR of all the elements in B, obtaining a result A[i] | A[i+1] | ... | A[j].\nReturn the number of possible results. (Results that occur more than once are only counted once in the final answer.)\n \n\nExample 1:\nInput: [0]\nOutput: 1\nExplanation: \nThere is only one possible result: 0.\n\n\nExample 2:\nInput: [1,1,2]\nOutput: 3\nExplanation: \nThe possible subarrays are [1], [1], [2], [1, 1], [1, 2], [1, 1, 2].\nThese yield the results 1, 1, 2, 1, 3, 3.\nThere are 3 unique values, so the answer is 3.\n\n\nExample 3:\nInput: [1,2,4]\nOutput: 6\nExplanation: \nThe possible results are 1, 2, 3, 4, 6, and 7.\n\n\n\n\n \nNote:\n\n1 <= A.length <= 50000\n0 <= A[i] <= 10^9"},"solutions":{"kind":"string","value":"[\"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n res = set()\\n cur = set()\\n for a in A:\\n cur = {a | i for i in cur}\\n cur |= {a}\\n res |= cur\\n return len(res)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n s = set()\\n c = set()\\n for x in A:\\n c = {x|y for y in c}\\n c.add(x)\\n s|=c\\n return len(s)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n cur = set([0])\\n \\n for x in A:\\n cur = {x | y for y in cur} | {x}\\n ans |= cur\\n return len(ans)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n prev = set()\\n curr = set()\\n vals = set(A)\\n \\n for x in A:\\n curr.add(x)\\n for y in prev:\\n curr.add(x|y)\\n vals.add(x|y)\\n prev = curr\\n curr = set()\\n \\n return len(vals)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n curr = set()\\n ans = set()\\n for x in A:\\n curr = {x | y for y in curr} | {x}\\n ans |= curr\\n \\n return len(ans)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n results = set()\\n curr = {0}\\n for a in A:\\n curr = {a | b for b in curr} | {a}\\n results |= curr\\n return len(results)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n res, cur = set(), set()\\n for i in A:\\n cur = {i | j for j in cur} | {i}\\n res |= cur\\n return len(res)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # O(N^3) to try oring every possible subarray\\n \\n # key fact: for any number k , k | k = k\\n # also 0 | k = k for all k\\n \\n # one small optimization: scan through and delete any 0s or consecutive repeats\\n \\n # keep a list of or results s.t. or[i] = set of all possible results from oring subarrays that end at i\\n # then or[i] = [A[i]] + [A[i] | res for res in or[i - 1]] -> use a set to prune dups at each step\\n # you can just keep or[i] for most recent two i's\\n # \\n if not A:\\n return []\\n # [1, 2, 4]\\n # all_outcomes: {1, 2, 3, 4, 6, 7}\\n # outcomes: {2, 3}\\n # 4: temp {4, 6, 7}\\n \\n # todo(mywang): preprocess array and remove unnecessary stuff\\n for i in range(len(A))[::-1]:\\n if (i > 0 and A[i] == A[i - 1]):\\n A.pop(i)\\n all_outcomes = set([A[0]])\\n outcomes = set([A[0]])\\n for elt in A[1:]:\\n outcomes = {elt} | {elt | val for val in outcomes}\\n all_outcomes |= outcomes\\n \\n return len(all_outcomes)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans=set()\\n cur=set()\\n for i in A:\\n cur = set([i|j for j in cur])\\n cur.add(i)\\n ans|=cur\\n return len(ans)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n cur = set()\\n all = set()\\n for v in A:\\n cur = set(e | v for e in cur)\\n cur.add(v)\\n all |= cur\\n return len(all)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n cur = {0}\\n for i in A:\\n cur = {i | y for y in cur} | {i}\\n ans |= cur\\n return len(ans)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n cur, res = set(), set()\\n for i in A:\\n cur = {i | j for j in cur} | {i}\\n res |= cur\\n return len(res)\", \"import math\\nclass Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n res = set([])\\n tmp = []\\n maximpact = 0\\n for i in A:\\n newtmp = []\\n newtmp_set = set([])\\n maximpact = max(maximpact, int(math.log(i, 2)) + 1 if i > 0 else 0)\\n if i not in newtmp_set:\\n newtmp_set.add(i)\\n newtmp.append(i)\\n res.add(i)\\n if maximpact > 0:\\n for j in tmp:\\n k = i|j\\n if k not in newtmp_set:\\n newtmp_set.add(k)\\n newtmp.append(k)\\n res.add(k)\\n if len(newtmp) >= maximpact:\\n break\\n tmp = newtmp\\n return len(res)\\n \\n \\n \\n\", \"class Solution(object):\\n def subarrayBitwiseORs(self, A):\\n ans = set()\\n cur = {0}\\n for x in A:\\n cur = {x | y for y in cur} | {x}\\n ans |= cur\\n return len(ans)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n result, curr = set(), set()\\n for a in A:\\n curr = {a | j for j in curr} | {a}\\n result |= curr\\n return len(result)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n results = set()\\n temp = {0}\\n for cur in A:\\n # print(temp)\\n temp = {cur} | {cur | t for t in temp}\\n results.update(temp)\\n return len(results)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n s = set()\\n global_set = set()\\n ans = 0\\n for v in A:\\n s.add(v)\\n s = {x|v for x in s}\\n global_set |= s\\n \\n return len(global_set)\", \"import math\\nclass Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = {A[0]}\\n pre = {A[0]}\\n for a in A[1:]:\\n pre = {a|x for x in pre}\\n pre.add(a)\\n ans.update(pre) \\n return len(ans)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n S, last = set(), set()\\n for i in range(len(A)):\\n last = {a|A[i] for a in last}\\n last.add(A[i])\\n S |= last\\n \\n return len(S)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n cur = {0}\\n for x in A:\\n cur = {x | y for y in cur} | {x}\\n ans |= cur\\n return len(ans)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n \\n \\n \\n # my solution ... 760 ms ... 98 % ... 40.6 MB ... 15 %\\n # time: O(nlogn)\\n # space: O(logn)\\n \\n res = set()\\n tot = set()\\n for a in A:\\n res = {prev | a for prev in res} | {a} # \\u5f97\\u51fa\\u4ee5\\u5f53\\u524d a \\u7ed3\\u5c3e\\u7684 subarray\\n tot |= res # \\u628a\\u7ed3\\u679c\\u5e76\\u5165 tot\\n return len(tot)\\n \\n \\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n cur = set([0])\\n \\n for x in A:\\n cur = set([x | y for y in cur]) | {x}\\n ans |= cur\\n return len(ans)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n previous = set()\\n for v in A:\\n current = set([i|v for i in previous])\\n current.add(v)\\n ans.update(current)\\n previous = current\\n return len(ans)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n st = set()\\n cur = set()\\n for a in A:\\n cur = {b | a for b in cur} | {a}\\n st |= cur\\n return len(st)\", \"from typing import List\\n\\n\\nclass Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n seen = set()\\n cur = set()\\n\\n for num in A:\\n cur_new = set()\\n for num_seen in cur:\\n cur_new.add(num_seen | num)\\n\\n cur_new.add(num)\\n cur = cur_new\\n seen |= cur\\n\\n return len(seen)\\n\\n def subarrayBitwiseORsN2(self, A: List[int]) -> int:\\n dp = [[0] * len(A) for _ in range(len(A))]\\n\\n seen = set()\\n\\n count = 0\\n\\n for start in reversed(list(range(len(A)))):\\n for end in range(start, len(A)):\\n if start == end:\\n dp[start][end] = A[start]\\n else:\\n dp[start][end] = dp[start + 1][end] | A[start]\\n\\n if dp[start][end] not in seen:\\n count += 1\\n seen.add(dp[start][end])\\n\\n return count\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n cur = {0}\\n for x in A:\\n cur = {x|y for y in cur} | {x}\\n ans |= cur\\n return len(ans)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # Brute force with set, with list we can use if in list conditional statement\\n # Slow & bad....\\n\\n# rset = set()\\n# for i in range(len(A)):\\n# for j in range(i+1, len(A)+1):\\n# res = 0\\n# for k in range(i, j):\\n# res |= A[k]\\n# rset.add(res)\\n# return len(rset) \\n \\n# A cleaner code\\n# Assume B[i][j] = A[i] | A[i+1] | ... | A[j]\\n# Hash set cur stores all wise B[0][i], B[1][i], B[2][i], B[i][i].\\n\\n# When we handle the A[i+1], we want to update cur\\n# So we need operate bitwise OR on all elements in cur.\\n# Also we need to add A[i+1] to cur.\\n\\n# In each turn, we add all elements in cur to res.\\n# This method is better since it preserves the results of previous operation and make them useful\\n res, cur = set(), set()\\n \\n for i in A:\\n cur = {i|j for j in cur} | {i}\\n res |= cur\\n \\n return len(res)\\n \\n\", \"class Solution(object):\\n def subarrayBitwiseORs(self, A):\\n ans = set()\\n cur = {0}\\n for x in A:\\n cur = {x | y for y in cur} | {x}\\n ans|=cur\\n #print(cur)\\n #print(\\\\\\\"ans\\\\\\\",ans)\\n return len(ans)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n \\n result = set()\\n cur = {0}\\n \\n for x in A:\\n cur = {x | y for y in cur} | {x}\\n result |= cur\\n \\n return len(result)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n s = set()\\n res = set()\\n for x in A:\\n new_s = {x}\\n for xx in s:\\n new_s.add(xx | x)\\n s = new_s\\n res |= s\\n return len(res)\", \"import itertools as it\\n\\n\\nclass Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n res, cur = set(), set()\\n for i in A:\\n cur = {i | j for j in cur} | {i}\\n res |= cur\\n return len(res)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n cur, res = set(), set()\\n for a in A:\\n cur = {a|b for b in cur} | {a}\\n res |= cur\\n return len(res)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n \\n cur = {0}\\n \\n for x in A:\\n cur = {x|y for y in cur} | {x}\\n ans |= cur\\n \\n return len(ans)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # 12:57 8/24/20\\n \\n cur, res = set(),set()\\n for num in A:\\n cur = {num | j for j in cur} | {num}\\n # res |= cur\\n # cur = set(num | k for k in A)\\n # cur.add(num)\\n res.update(cur)\\n \\n return len(res)\\n \\n \\n \\n # res, cur = set(), set()\\n # for i in A:\\n # cur = {i | j for j in cur} | {i}\\n # res |= cur\\n # return len(res)\\n\\n \\n \\n\", \"class Solution:\\n# def findUnique(self, l):\\n# u = []\\n \\n# for num in l:\\n# if num not in u:\\n# u.append(num)\\n \\n# return self.findOR(u)\\n \\n# def findOR(self, l):\\n \\n# ret = 0\\n \\n# for num in l:\\n# ret = self.doBin(ret, num)\\n# return ret\\n \\n \\n# def doBin(self, a, b):\\n \\n# p = 0\\n \\n# ret = 0\\n# while a or b:\\n# if a%2 or b%2:\\n# ret += pow(2,p)\\n# p +=1\\n# a, b = a//2, b//2\\n \\n# return ret\\n \\n# def subarrayBitwiseORs(self, A: List[int]) -> int:\\n# #just unique combinations\\n \\n# res = 0 \\n \\n# seen = []\\n# #brute force\\n# for i in range(len(A)):\\n# for j in range(i,len(A)):\\n# uniq = self.findUnique(A[i:j+1])\\n# if uniq not in seen:\\n# seen.append(uniq)\\n# res +=1\\n \\n# return res\\n\\n\\n def subarrayBitwiseORs(self, A):\\n ans = set()\\n cur = {0}\\n for x in A:\\n cur = {x | y for y in cur} | {x}\\n ans |= cur\\n return len(ans)\\n\\n\\n\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n n = len(A)\\n dp = set()\\n ans = set()\\n \\n for j in range(n):\\n dp_new = set()\\n dp_new.add(A[j])\\n for x in dp:\\n dp_new.add(x | A[j])\\n dp = dp_new \\n ans.update(dp)\\n \\n return len(ans) \\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans, dp = set(), set()\\n for x in A:\\n ndp = set()\\n ndp.add(x)\\n for y in dp:\\n ndp.add(x|y)\\n ans.add(y)\\n dp = ndp\\n for x in dp: ans.add(x)\\n return len(ans)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # O(N^3) to try oring every possible subarray\\n \\n # key fact: for any number k , k | k = k\\n # also 0 | k = k for all k\\n \\n # one small optimization: scan through and delete any 0s or consecutive repeats\\n \\n # keep a list of or results s.t. or[i] = set of all possible results from oring subarrays that end at i\\n # then or[i] = [A[i]] + [A[i] | res for res in or[i - 1]] -> use a set to prune dups at each step\\n # you can just keep or[i] for most recent two i's\\n # \\n if not A:\\n return []\\n # [1, 2, 4]\\n # all_outcomes: {1, 2, 3, 4, 6, 7}\\n # outcomes: {2, 3}\\n # 4: temp {4, 6, 7}\\n \\n # todo(mywang): preprocess array and remove unnecessary stuff\\n for i in range(len(A))[::-1]:\\n if (i > 0 and A[i] == A[i - 1]):\\n A.pop(i)\\n all_outcomes = set([A[0]])\\n outcomes = set([A[0]])\\n for elt in A[1:]:\\n temp = set([elt])\\n for out in outcomes:\\n temp.add(out | elt)\\n outcomes = temp\\n all_outcomes |= outcomes\\n \\n return len(all_outcomes)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n tp = set()\\n tp.add(0)\\n for i in A:\\n tpp = set()\\n tpp.add(i)\\n for ii in tp:\\n tpp.add(ii|i)\\n tp=tpp\\n for ii in tp:\\n ans.add(ii)\\n return len(ans)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n s = set()\\n res = set()\\n for n in A:\\n s = {n} | {n | el for el in s}\\n res |= s\\n\\n return len(res)\", \"class Solution:\\n def subarrayBitwiseORs(self, arr: List[int]) -> int:\\n ans = set()\\n current = set()\\n current.add(0)\\n for i in range(len(arr)):\\n a = arr[i]\\n s = set()\\n s.add(a)\\n for y in current:\\n s.add(a | y)\\n current = s\\n ans |= s\\n return len(ans)\\n \\n # for x in arr:\\n # current = {x | y for y in current} | {x}\\n # # print(current)\\n # ans |= current\\n # # print(ans)\\n # return len(ans)\\n \\n # brute force time complexity :O(n^2)\\n # space complexity:O(n)\\n if not arr:return 0\\n l ,ans = len(arr) ,set()\\n for i in range(l):\\n res = arr[i]\\n ans.add(res)\\n for j in range(i+1,l):\\n res |= arr[j]\\n ans.add(res)\\n return len(ans)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n fullSet = set()\\n setAtI = {0}\\n \\n for i in range(len(A)):\\n setAtI = {A[i]| y for y in setAtI} | {A[i]}\\n fullSet |=setAtI\\n return len(fullSet)\\n \\n \\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n setA = set(A)\\n \\n prev = set()\\n \\n prev.add(A[0])\\n \\n for val in A[1:]:\\n temp = set()\\n \\n for p in prev:\\n temp.add(p|val)\\n setA.add(p|val)\\n prev = temp\\n prev.add(val)\\n return len(setA)\", \"import math\\nclass Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = {A[0]}\\n pre = {A[0]}\\n for a in A[1:]:\\n pre = {a|x for x in pre}\\n pre.add(a)\\n for i in pre:\\n ans.add(i) \\n return len(ans)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans=set()\\n vset=set()\\n for a in A:\\n newvset=set()\\n for v in vset:\\n newvset.add(a|v)\\n ans.add(a|v)\\n newvset.add(a)\\n vset=newvset\\n ans.add(a)\\n return len(ans)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n \\n cur = set()\\n res = set()\\n for i in A:\\n temp = set([i])\\n for j in cur:\\n temp.add(i|j)\\n cur = temp\\n for j in cur:\\n res.add(j)\\n return len(res)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n \\n result, prev = set(), set()\\n \\n for num in A:\\n temp = set()\\n temp.add(num)\\n \\n result.add(num)\\n \\n for p in prev:\\n temp.add(p|num)\\n result.add(p|num)\\n \\n prev = temp\\n return len(result)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n S, prev = set(), set()\\n for a in A:\\n temp = set()\\n temp.add(a)\\n S.add(a)\\n for p in prev:\\n temp.add(a|p)\\n S.add(a|p)\\n prev = temp\\n return len(S)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n alive = set()\\n dead = set()\\n for num1 in A:\\n tmp = {num1}\\n for num2 in alive:\\n dead.add(num2)\\n tmp.add(num1|num2)\\n alive = tmp\\n \\n return len(alive|dead)\", \"class Solution:\\n \\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n arr_len = len(A)\\n final_result_set = set()\\n pre_result_set = set()\\n pre_result_set.add(A[0])\\n final_result_set.add(A[0])\\n for i in range (1, arr_len):\\n cur_result_set = set()\\n for pre_result in pre_result_set:\\n one_cur_result = pre_result | A[i]\\n cur_result_set.add(one_cur_result)\\n final_result_set.add(one_cur_result)\\n cur_result_set.add(A[i])\\n final_result_set.add(A[i])\\n pre_result_set = cur_result_set\\n return len(final_result_set)\\n \\n \\n \\n \\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A):\\n nums, n, pre = set(), len(A), set()\\n for a in A:\\n pre = {a} | {num | a for num in pre}\\n nums |= pre\\n return len(nums)\\n\\n# @param {Integer[]} a\\n# @return {Integer}\\n#def subarray_bitwise_o_rs(a)\\n # Get subarrays\\n# solutions = {}\\n# iterating_array = a.clone\\n# a.each do |m|\\n# num = m\\n# iterating_array.each do |m|\\n# solutions[num] = 1\\n# num |= m\\n# end\\n# solutions[num] = 1\\n# iterating_array.shift\\n# end\\n# solutions.keys.length\\n#end\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n cur = set()\\n for a in A:\\n cur = {p | a for p in cur} | {a}\\n ans |= cur\\n return len(ans)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n my_set = [set([A[i]]) for i in range(len(A))]\\n \\n for i in range(1, len(A)):\\n for prev_result in my_set[i-1]:\\n my_set[i].add(A[i] | prev_result)\\n \\n return len(set.union(*my_set))\\n \\n \\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n \\n curr=set()\\n ans=set()\\n for a in A:\\n s=set()\\n s.add(a)\\n for i in curr:\\n s.add(a|i)\\n curr=s\\n for t in curr:\\n ans.add(t|a)\\n return len(ans)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n my_set = [set([A[i]]) for i in range(len(A))]\\n \\n for i in range(1, len(A)):\\n for prev_result in my_set[i-1]:\\n res = A[i] | prev_result\\n my_set[i].add(res)\\n \\n return len(set.union(*my_set))\\n \\n \\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n sets=[{i} for i in A]\\n for i in range(1,len(A)):\\n for prev in sets[i-1]:\\n sets[i].add(A[i]|prev)\\n \\n for num in sets[1:]:\\n sets[0]|=num \\n return len(sets[0])\", \"from typing import List, Set\\n\\n\\nclass Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n all_results: Set[int] = set()\\n prev_results: Set[int] = set()\\n\\n for start_index in range(len(A)):\\n curr_results: Set[int] = set()\\n curr_results.add(A[start_index])\\n\\n for prev_result in prev_results:\\n curr_results.add(prev_result | A[start_index])\\n\\n all_results |= curr_results\\n prev_results = curr_results\\n return len(all_results)\\n\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n res, curr = set(), set()\\n for a in A:\\n temp = {a}\\n for b in curr:\\n temp.add(a | b)\\n curr = temp\\n for num in curr:\\n res.add(num)\\n return len(res)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n sets=[{i} for i in A]\\n for i in range(1,len(A)):\\n for prev in sets[i-1]:\\n sets[i].add(A[i]|prev)\\n return len(set.union(*sets))\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n prev = set()\\n prev.add(0)\\n \\n for i in range(len(A)):\\n cur = set()\\n cur.add(A[i])\\n \\n for p in prev:\\n res = p | A[i]\\n if res != p:\\n ans.add(p)\\n cur.add(res)\\n \\n prev = cur\\n \\n for p in prev:\\n ans.add(p)\\n \\n if 0 not in A:\\n ans.remove(0)\\n \\n return len(ans)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n cur = set()\\n for x in A:\\n cur = {y|x for y in cur} | set([x])\\n ans |= cur\\n return len(ans)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n my_set = set(A)\\n curr = 0\\n prev = set()\\n prev.add(A[0])\\n for num in A[1:]:\\n temp = set()\\n for p in prev:\\n temp.add(num | p)\\n my_set.add(num | p)\\n prev = temp\\n prev.add(num)\\n\\n return len(my_set)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n if A == []:\\n return 0\\n # count = [0]\\n # dic = {}\\n # def OR(s):\\n # if len(s) == 1:\\n # return s[0]\\n # res = s[0]\\n # for item in s[1:]:\\n # res = res | item\\n # return res\\n # for i in range(len(A)):\\n # for j in range(i, len(A)):\\n # res = OR(A[i:j+1])\\n # if res in dic:\\n # continue\\n # dic[res] = 0\\n # count[0] += 1\\n # return count[0]\\n my_set = set(A)\\n curr = 0\\n prev = set()\\n prev.add(A[0])\\n for num in A[1:]:\\n temp = set()\\n for p in prev:\\n temp.add(num | p)\\n my_set.add(num | p)\\n prev = temp\\n prev.add(num)\\n\\n return len(my_set)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set(A)\\n prev = set([A[0]])\\n for i in A[1:]:\\n temp = set()\\n for p in prev:\\n temp.add(i|p)\\n ans.add(i|p)\\n prev = temp\\n prev.add(i)\\n return len(ans)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # res, cur = set(), set()\\n # for num in A:\\n # cur = {val | num for val in cur} | {num}\\n # res |= cur\\n # return len(res)\\n \\n # list\\n res = []\\n left, right = 0, 0\\n for val in A:\\n right = len(res)\\n res.append(val)\\n for i in range(left, right):\\n if res[-1] != (res[i] | val):\\n res.append(res[i] | val)\\n left = right\\n return len(set(res))\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n res = set()\\n \\n last = set()\\n \\n for x in A:\\n new = {x}\\n \\n for y in last:\\n new.add(x | y)\\n \\n res |= new\\n last = new\\n \\n return len(res)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n vals = set()\\n \\n if len(A) < 2:\\n return len(A)\\n \\n cur = {0}\\n for a in A:\\n cur = {a| y for y in cur} | {a}\\n vals |= cur\\n return len(vals)\", \"class Solution:\\n def subarrayBitwiseORs(self, A):\\n # Tabulation is a list of sets, one for each number in A. \\n # Each set, at position i, is initialised to containing the element at A[i]\\n tabulation = [set([A[i]]) for i in range(len(A))]\\n \\n # And now we need to go through, updating the sets based on the previous set.\\n for i in range(1, len(A)):\\n for previous_result in tabulation[i - 1]: \\n tabulation[i].add(A[i] | previous_result) \\n \\n # Return the number of unique numbers in the tabulation list.\\n return len(set.union(*tabulation)) if len(A) > 0 else 0\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: list) -> int:\\n results = set()\\n pre = {0}\\n\\n for a in A:\\n '''\\n cur = {a}\\n for prev in pre:\\n cur.add(prev | a)\\n results |= cur\\n pre = cur\\n '''\\n pre = {a | p for p in pre} | {a}\\n results |= pre\\n\\n return len(results)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n s, ans = set(), set()\\n for a in A:\\n s = {a} | {a | b for b in s}\\n ans |= s\\n return len(ans)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # https://blog.csdn.net/fuxuemingzhu/article/details/83511833\\n res = set()\\n cur = set()\\n for a in A:\\n cur = {n | a for n in cur} | {a}\\n res |= cur\\n return len(res)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n s = set()\\n s1 = set()\\n for n in A:\\n s2 = set()\\n for e in s1:\\n s2.add(e|n)\\n s1=s2\\n s1.add(n)\\n s|=s1\\n # print(s)\\n return len(s)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n res = set([])\\n tmp = set([])\\n for i in A:\\n newtmp = set([])\\n for j in tmp:\\n newtmp.add(i|j)\\n res.add(i|j)\\n newtmp.add(i)\\n res.add(i)\\n tmp = newtmp\\n return len(res)\\n \\n \\n \\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # 12:57 8/24/20\\n \\n res, cur = set(), set()\\n for i in A:\\n cur = {i | j for j in cur} | {i}\\n res |= cur\\n return len(res)\\n \\n \\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans, frontier = set(), set()\\n \\n for n in A:\\n frontier = {x | n for x in frontier if x|n != -1}\\n frontier.add(n)\\n ans |= frontier\\n \\n \\n return len(ans)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n curr = {0}\\n ans = set()\\n for a in A:\\n curr = {x|a for x in curr } | {a}\\n ans |= curr\\n return len(ans)\\n \\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n my_set = [set([A[i]]) for i in range(len(A))]\\n ans = set(A)\\n \\n for i in range(1, len(A)):\\n for prev_result in my_set[i-1]:\\n res = A[i] | prev_result\\n my_set[i].add(res)\\n ans.add(res)\\n \\n return len(ans)\\n \\n \\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n my_set = set(A)\\n curr = 0\\n prev = set()\\n prev.add(A[0])\\n for num in A[1:]:\\n temp = set()\\n curr |= num\\n my_set.add(curr)\\n prev.add(num)\\n for p in prev:\\n temp.add(num | p)\\n my_set.add(num | p)\\n prev = temp\\n\\n return len(my_set)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n dp = []\\n for i in range(len(A)):\\n if i == 0:\\n dp.append(set([A[i]]))\\n else:\\n inner = set([A[i]])\\n for d in dp[-1]:\\n inner.add(d | A[i])\\n dp.append(inner)\\n total = set()\\n for d in dp:\\n total.update(d)\\n return len(total)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n result = set()\\n curr = set()\\n for num in A:\\n curr = {num | prev_num for prev_num in curr} | {num}\\n result |= curr\\n return len(result)\\n \\n \\n \\n# result = set()\\n# prev = set([0])\\n# for num in A:\\n# curr = set([num])\\n# for prev_num in prev:\\n# curr.add(prev_num | num)\\n# result |= curr\\n# prev = curr\\n# return len(result)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, arr: List[int]) -> int:\\n ans = set()\\n current = {0}\\n for x in arr:\\n # print(x,current)\\n current = {x | y for y in current} | {x}\\n # print(current)\\n ans |= current\\n # print(ans)\\n return len(ans)\\n \\n # brute force time complexity :O(n^2)\\n # space complexity:O(n)\\n if not arr:return 0\\n l ,ans = len(arr) ,set()\\n for i in range(l):\\n res = arr[i]\\n ans.add(res)\\n for j in range(i+1,l):\\n res |= arr[j]\\n ans.add(res)\\n return len(ans)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, a: List[int]) -> int:\\n res, prev = set(), set()\\n res.add(a[0])\\n prev.add(a[0])\\n for i in range(1, len(a)):\\n cur = set()\\n cur.add(a[i])\\n res.add(a[i])\\n for j in prev:\\n cur.add(j|a[i])\\n res.add(j|a[i])\\n prev = cur\\n return len(res)\", \"class Solution(object):\\n def subarrayBitwiseORs(self, A):\\n final = set()\\n actual = set()\\n for el in A:\\n actual = {el} | {el2 | el for el2 in actual}\\n final |= actual\\n return len(final)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n mp={0:1} \\n ans={} \\n for a in A:\\n temp={} \\n for m in mp:\\n temp[m|a]=1 \\n temp[a]=1 \\n for t in temp:\\n ans[t]=1 \\n mp={} \\n for t in temp:\\n mp[t]=1 \\n cnt=0 \\n for c in ans:\\n cnt+=1 \\n return cnt\\n \\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n result_set = set()\\n results = set()\\n for num in A:\\n results = {j | num for j in results}\\n results.add(num)\\n result_set.update(results)\\n return len(result_set)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n \\n ans = set()\\n prev = set()\\n \\n for a in A:\\n \\n cur = set(a | b for b in prev)\\n cur.add(a)\\n \\n prev = cur\\n ans |= cur\\n \\n return len(ans)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # O(N^3) to try oring every possible subarray\\n \\n # key fact: for any number k , k | k = k\\n # also 0 | k = k for all k\\n \\n # one small optimization: scan through and delete any 0s or consecutive repeats\\n \\n # keep a list of or results s.t. or[i] = set of all possible results from oring subarrays that end at i\\n # then or[i] = [A[i]] + [A[i] | res for res in or[i - 1]] -> use a set to prune dups at each step\\n # you can just keep or[i] for most recent two i's\\n # \\n if not A:\\n return []\\n # [1, 2, 4]\\n # all_outcomes: {1, 2, 3, 4, 6, 7}\\n # outcomes: {2, 3}\\n # 4: temp {4, 6, 7}\\n \\n # todo(mywang): preprocess array and remove unnecessary stuff\\n # for i in range(len(A))[::-1]:\\n # if (i > 0 and A[i] == A[i - 1]):\\n # A.pop(i)\\n all_outcomes = set()\\n outcomes = set()\\n for elt in A:\\n outcomes = {elt} | {elt | val for val in outcomes}\\n all_outcomes |= outcomes\\n \\n return len(all_outcomes)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # O(N^3) to try oring every possible subarray\\n \\n # key fact: for any number k , k | k = k\\n # also 0 | k = k for all k\\n \\n # one small optimization: scan through and delete any 0s or consecutive repeats\\n \\n # keep a list of or results s.t. or[i] = set of all possible results from oring subarrays that end at i\\n # then or[i] = [A[i]] + [A[i] | res for res in or[i - 1]] -> use a set to prune dups at each step\\n # you can just keep or[i] for most recent two i's\\n # \\n if not A:\\n return []\\n # [1, 2, 4]\\n # all_outcomes: {1, 2, 3, 4, 6, 7}\\n # outcomes: {2, 3}\\n # 4: temp {4, 6, 7}\\n \\n # todo(mywang): preprocess array and remove unnecessary stuff\\n for i in range(len(A))[::-1]:\\n if (i > 0 and A[i] == A[i - 1]):\\n A.pop(i)\\n all_outcomes = set()\\n outcomes = set()\\n for elt in A:\\n outcomes = {elt} | {elt | val for val in outcomes}\\n all_outcomes |= outcomes\\n \\n return len(all_outcomes)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # O(N^3) to try oring every possible subarray\\n \\n # key fact: for any number k , k | k = k\\n # also 0 | k = k for all k\\n \\n # one small optimization: scan through and delete any 0s or consecutive repeats\\n \\n # keep a list of or results s.t. or[i] = set of all possible results from oring subarrays that end at i\\n # then or[i] = [A[i]] + [A[i] | res for res in or[i - 1]] -> use a set to prune dups at each step\\n # you can just keep or[i] for most recent two i's\\n # \\n if not A:\\n return []\\n # [1, 2, 4]\\n # all_outcomes: {1, 2, 3, 4, 6, 7}\\n # outcomes: {2, 3}\\n # 4: temp {4, 6, 7}\\n \\n # todo(mywang): preprocess array and remove unnecessary stuff\\n for i in range(len(A))[::-1]:\\n if (i > 0 and A[i] == A[i - 1]):\\n A.pop(i)\\n all_outcomes = set([A[0]])\\n outcomes = set([A[0]])\\n for elt in A[1:]:\\n temp = {elt} | {elt | val for val in outcomes}\\n outcomes = temp\\n all_outcomes |= outcomes\\n \\n return len(all_outcomes)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n cur,res = set(),set()\\n for i in A:\\n cur = { i|j for j in cur} | {i}\\n res |= cur\\n return len(res)\\n# nums, n = set(), len(A)\\n# for i in range(n):\\n# num = A[i]\\n# for j in range(i, n):\\n# num |= A[j]\\n# nums.add(num)\\n# return len(nums)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n \\n \\n \\n # my solution ... 736 ms ... 100 % ... 40.6 MB ... 15 %\\n # time: O(nlogn)\\n # space: O(logn)\\n \\n res = set()\\n tot = set()\\n for a in A:\\n res = {prev | a for prev in res} | {a} # \\u5f97\\u51fa\\u4ee5\\u5f53\\u524d a \\u7ed3\\u5c3e\\u7684 subarray\\n tot |= res # \\u628a\\u7ed3\\u679c\\u5e76\\u5165 tot\\n return len(tot)\\n \\n \\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n res = set()\\n \\n cur = set()\\n \\n for x in A:\\n cur = {x} | {x | y for y in cur}\\n res |= cur\\n \\n return len(res)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # Frontier Set \\n # Time complexity: O(NlogW), where N is the length of A, and W is the maximum size of elements in A.\\n # Space complexity: O(NlogW)\\n ans = set()\\n cur = {0}\\n for x in A:\\n cur = {x | y for y in cur} | {x}\\n ans |= cur\\n return len(ans)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # 12:57 8/24/20\\n \\n cur, res = set(),set()\\n for num in A:\\n cur = {num | j for j in cur} # | {num}\\n # cur = set(num | k for k in A)\\n cur.add(num)\\n res.update(cur)\\n \\n return len(res)\\n \\n \\n \\n # res, cur = set(), set()\\n # for i in A:\\n # cur = {i | j for j in cur} | {i}\\n # res |= cur\\n # return len(res)\\n\\n \\n \\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n self.res = set()\\n def helper(idx):\\n if idx < 0:\\n return set()\\n if idx==0:\\n self.res |= {A[idx]}\\n return {A[idx]}\\n val = {A[idx]}|{x|A[idx] for x in helper(idx-1)}\\n self.res |= val\\n return val\\n helper(len(A)-1)\\n return len(self.res)\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n result = set()\\n curr = set()\\n for num in A:\\n curr = {num | prev_num for prev_num in curr}\\n curr.add(num)\\n result.update(curr)\\n return len(result)\\n \\n \\n \\n# result = set()\\n# prev = set([0])\\n# for num in A:\\n# curr = set([num])\\n# for prev_num in prev:\\n# curr.add(prev_num | num)\\n# result |= curr\\n# prev = curr\\n# return len(result)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n my_set = set(A)\\n curr = 0\\n prev = set()\\n prev.add(A[0])\\n for num in A[1:]:\\n temp = set()\\n #curr |= num\\n #my_set.add(curr)\\n \\n for p in prev:\\n temp.add(num | p)\\n my_set.add(num | p)\\n \\n #print(temp)\\n prev = temp\\n prev.add(num)\\n\\n return len(my_set)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # Frontier Set \\n # Time complexity: O(NlogW) = O(30N), where N is the length of A, and W is the maximum size of elements in A.\\n # Space complexity: O(NlogW)\\n ans = set()\\n cur = {0}\\n for x in A:\\n cur = {x | y for y in cur} | {x}\\n ans |= cur\\n return len(ans)\\n\", \"class Solution:\\n def subarrayBitwiseORs(self, arr: List[int]) -> int:\\n s = set()\\n prev = set()\\n prev.add(arr[0])\\n s.add(arr[0])\\n \\n for i in range(len(arr)):\\n temp = set()\\n for val in prev:\\n temp.add(val|arr[i])\\n s.add(val|arr[i])\\n \\n prev = temp\\n prev.add(arr[i])\\n s.add(arr[i])\\n \\n return len(s)\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"subarrayBitwiseORs\", \"inputs\": [[[0]]], \"outputs\": [1]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/bitwise-ors-of-subarrays/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n res = set()\n cur = set()\n for a in A:\n cur = {a | i for i in cur}\n cur |= {a}\n res |= cur\n return len(res)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n s = set()\n c = set()\n for x in A:\n c = {x|y for y in c}\n c.add(x)\n s|=c\n return len(s)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans = set()\n cur = set([0])\n \n for x in A:\n cur = {x | y for y in cur} | {x}\n ans |= cur\n return len(ans)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n prev = set()\n curr = set()\n vals = set(A)\n \n for x in A:\n curr.add(x)\n for y in prev:\n curr.add(x|y)\n vals.add(x|y)\n prev = curr\n curr = set()\n \n return len(vals)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n curr = set()\n ans = set()\n for x in A:\n curr = {x | y for y in curr} | {x}\n ans |= curr\n \n return len(ans)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n results = set()\n curr = {0}\n for a in A:\n curr = {a | b for b in curr} | {a}\n results |= curr\n return len(results)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n res, cur = set(), set()\n for i in A:\n cur = {i | j for j in cur} | {i}\n res |= cur\n return len(res)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n # O(N^3) to try oring every possible subarray\n \n # key fact: for any number k , k | k = k\n # also 0 | k = k for all k\n \n # one small optimization: scan through and delete any 0s or consecutive repeats\n \n # keep a list of or results s.t. or[i] = set of all possible results from oring subarrays that end at i\n # then or[i] = [A[i]] + [A[i] | res for res in or[i - 1]] -> use a set to prune dups at each step\n # you can just keep or[i] for most recent two i's\n # \n if not A:\n return []\n # [1, 2, 4]\n # all_outcomes: {1, 2, 3, 4, 6, 7}\n # outcomes: {2, 3}\n # 4: temp {4, 6, 7}\n \n # todo(mywang): preprocess array and remove unnecessary stuff\n for i in range(len(A))[::-1]:\n if (i > 0 and A[i] == A[i - 1]):\n A.pop(i)\n all_outcomes = set([A[0]])\n outcomes = set([A[0]])\n for elt in A[1:]:\n outcomes = {elt} | {elt | val for val in outcomes}\n all_outcomes |= outcomes\n \n return len(all_outcomes)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans=set()\n cur=set()\n for i in A:\n cur = set([i|j for j in cur])\n cur.add(i)\n ans|=cur\n return len(ans)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n cur = set()\n all = set()\n for v in A:\n cur = set(e | v for e in cur)\n cur.add(v)\n all |= cur\n return len(all)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans = set()\n cur = {0}\n for i in A:\n cur = {i | y for y in cur} | {i}\n ans |= cur\n return len(ans)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n cur, res = set(), set()\n for i in A:\n cur = {i | j for j in cur} | {i}\n res |= cur\n return len(res)","import math\nclass Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n res = set([])\n tmp = []\n maximpact = 0\n for i in A:\n newtmp = []\n newtmp_set = set([])\n maximpact = max(maximpact, int(math.log(i, 2)) + 1 if i > 0 else 0)\n if i not in newtmp_set:\n newtmp_set.add(i)\n newtmp.append(i)\n res.add(i)\n if maximpact > 0:\n for j in tmp:\n k = i|j\n if k not in newtmp_set:\n newtmp_set.add(k)\n newtmp.append(k)\n res.add(k)\n if len(newtmp) >= maximpact:\n break\n tmp = newtmp\n return len(res)\n \n \n \n","class Solution(object):\n def subarrayBitwiseORs(self, A):\n ans = set()\n cur = {0}\n for x in A:\n cur = {x | y for y in cur} | {x}\n ans |= cur\n return len(ans)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n result, curr = set(), set()\n for a in A:\n curr = {a | j for j in curr} | {a}\n result |= curr\n return len(result)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n results = set()\n temp = {0}\n for cur in A:\n # print(temp)\n temp = {cur} | {cur | t for t in temp}\n results.update(temp)\n return len(results)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n s = set()\n global_set = set()\n ans = 0\n for v in A:\n s.add(v)\n s = {x|v for x in s}\n global_set |= s\n \n return len(global_set)","import math\nclass Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans = {A[0]}\n pre = {A[0]}\n for a in A[1:]:\n pre = {a|x for x in pre}\n pre.add(a)\n ans.update(pre) \n return len(ans)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n S, last = set(), set()\n for i in range(len(A)):\n last = {a|A[i] for a in last}\n last.add(A[i])\n S |= last\n \n return len(S)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans = set()\n cur = {0}\n for x in A:\n cur = {x | y for y in cur} | {x}\n ans |= cur\n return len(ans)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n \n \n \n # my solution ... 760 ms ... 98 % ... 40.6 MB ... 15 %\n # time: O(nlogn)\n # space: O(logn)\n \n res = set()\n tot = set()\n for a in A:\n res = {prev | a for prev in res} | {a} # 得出以当前 a 结尾的 subarray\n tot |= res # 把结果并入 tot\n return len(tot)\n \n \n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans = set()\n cur = set([0])\n \n for x in A:\n cur = set([x | y for y in cur]) | {x}\n ans |= cur\n return len(ans)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans = set()\n previous = set()\n for v in A:\n current = set([i|v for i in previous])\n current.add(v)\n ans.update(current)\n previous = current\n return len(ans)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n st = set()\n cur = set()\n for a in A:\n cur = {b | a for b in cur} | {a}\n st |= cur\n return len(st)","from typing import List\n\n\nclass Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n seen = set()\n cur = set()\n\n for num in A:\n cur_new = set()\n for num_seen in cur:\n cur_new.add(num_seen | num)\n\n cur_new.add(num)\n cur = cur_new\n seen |= cur\n\n return len(seen)\n\n def subarrayBitwiseORsN2(self, A: List[int]) -> int:\n dp = [[0] * len(A) for _ in range(len(A))]\n\n seen = set()\n\n count = 0\n\n for start in reversed(list(range(len(A)))):\n for end in range(start, len(A)):\n if start == end:\n dp[start][end] = A[start]\n else:\n dp[start][end] = dp[start + 1][end] | A[start]\n\n if dp[start][end] not in seen:\n count += 1\n seen.add(dp[start][end])\n\n return count\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans = set()\n cur = {0}\n for x in A:\n cur = {x|y for y in cur} | {x}\n ans |= cur\n return len(ans)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n # Brute force with set, with list we can use if in list conditional statement\n # Slow & bad....\n\n# rset = set()\n# for i in range(len(A)):\n# for j in range(i+1, len(A)+1):\n# res = 0\n# for k in range(i, j):\n# res |= A[k]\n# rset.add(res)\n# return len(rset) \n \n# A cleaner code\n# Assume B[i][j] = A[i] | A[i+1] | ... | A[j]\n# Hash set cur stores all wise B[0][i], B[1][i], B[2][i], B[i][i].\n\n# When we handle the A[i+1], we want to update cur\n# So we need operate bitwise OR on all elements in cur.\n# Also we need to add A[i+1] to cur.\n\n# In each turn, we add all elements in cur to res.\n# This method is better since it preserves the results of previous operation and make them useful\n res, cur = set(), set()\n \n for i in A:\n cur = {i|j for j in cur} | {i}\n res |= cur\n \n return len(res)\n \n","class Solution(object):\n def subarrayBitwiseORs(self, A):\n ans = set()\n cur = {0}\n for x in A:\n cur = {x | y for y in cur} | {x}\n ans|=cur\n #print(cur)\n #print(\\\"ans\\\",ans)\n return len(ans)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n \n result = set()\n cur = {0}\n \n for x in A:\n cur = {x | y for y in cur} | {x}\n result |= cur\n \n return len(result)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n s = set()\n res = set()\n for x in A:\n new_s = {x}\n for xx in s:\n new_s.add(xx | x)\n s = new_s\n res |= s\n return len(res)","import itertools as it\n\n\nclass Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n res, cur = set(), set()\n for i in A:\n cur = {i | j for j in cur} | {i}\n res |= cur\n return len(res)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n cur, res = set(), set()\n for a in A:\n cur = {a|b for b in cur} | {a}\n res |= cur\n return len(res)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans = set()\n \n cur = {0}\n \n for x in A:\n cur = {x|y for y in cur} | {x}\n ans |= cur\n \n return len(ans)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n # 12:57 8/24/20\n \n cur, res = set(),set()\n for num in A:\n cur = {num | j for j in cur} | {num}\n # res |= cur\n # cur = set(num | k for k in A)\n # cur.add(num)\n res.update(cur)\n \n return len(res)\n \n \n \n # res, cur = set(), set()\n # for i in A:\n # cur = {i | j for j in cur} | {i}\n # res |= cur\n # return len(res)\n\n \n \n","class Solution:\n# def findUnique(self, l):\n# u = []\n \n# for num in l:\n# if num not in u:\n# u.append(num)\n \n# return self.findOR(u)\n \n# def findOR(self, l):\n \n# ret = 0\n \n# for num in l:\n# ret = self.doBin(ret, num)\n# return ret\n \n \n# def doBin(self, a, b):\n \n# p = 0\n \n# ret = 0\n# while a or b:\n# if a%2 or b%2:\n# ret += pow(2,p)\n# p +=1\n# a, b = a//2, b//2\n \n# return ret\n \n# def subarrayBitwiseORs(self, A: List[int]) -> int:\n# #just unique combinations\n \n# res = 0 \n \n# seen = []\n# #brute force\n# for i in range(len(A)):\n# for j in range(i,len(A)):\n# uniq = self.findUnique(A[i:j+1])\n# if uniq not in seen:\n# seen.append(uniq)\n# res +=1\n \n# return res\n\n\n def subarrayBitwiseORs(self, A):\n ans = set()\n cur = {0}\n for x in A:\n cur = {x | y for y in cur} | {x}\n ans |= cur\n return len(ans)\n\n\n\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n n = len(A)\n dp = set()\n ans = set()\n \n for j in range(n):\n dp_new = set()\n dp_new.add(A[j])\n for x in dp:\n dp_new.add(x | A[j])\n dp = dp_new \n ans.update(dp)\n \n return len(ans) \n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans, dp = set(), set()\n for x in A:\n ndp = set()\n ndp.add(x)\n for y in dp:\n ndp.add(x|y)\n ans.add(y)\n dp = ndp\n for x in dp: ans.add(x)\n return len(ans)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n # O(N^3) to try oring every possible subarray\n \n # key fact: for any number k , k | k = k\n # also 0 | k = k for all k\n \n # one small optimization: scan through and delete any 0s or consecutive repeats\n \n # keep a list of or results s.t. or[i] = set of all possible results from oring subarrays that end at i\n # then or[i] = [A[i]] + [A[i] | res for res in or[i - 1]] -> use a set to prune dups at each step\n # you can just keep or[i] for most recent two i's\n # \n if not A:\n return []\n # [1, 2, 4]\n # all_outcomes: {1, 2, 3, 4, 6, 7}\n # outcomes: {2, 3}\n # 4: temp {4, 6, 7}\n \n # todo(mywang): preprocess array and remove unnecessary stuff\n for i in range(len(A))[::-1]:\n if (i > 0 and A[i] == A[i - 1]):\n A.pop(i)\n all_outcomes = set([A[0]])\n outcomes = set([A[0]])\n for elt in A[1:]:\n temp = set([elt])\n for out in outcomes:\n temp.add(out | elt)\n outcomes = temp\n all_outcomes |= outcomes\n \n return len(all_outcomes)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans = set()\n tp = set()\n tp.add(0)\n for i in A:\n tpp = set()\n tpp.add(i)\n for ii in tp:\n tpp.add(ii|i)\n tp=tpp\n for ii in tp:\n ans.add(ii)\n return len(ans)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n s = set()\n res = set()\n for n in A:\n s = {n} | {n | el for el in s}\n res |= s\n\n return len(res)","class Solution:\n def subarrayBitwiseORs(self, arr: List[int]) -> int:\n ans = set()\n current = set()\n current.add(0)\n for i in range(len(arr)):\n a = arr[i]\n s = set()\n s.add(a)\n for y in current:\n s.add(a | y)\n current = s\n ans |= s\n return len(ans)\n \n # for x in arr:\n # current = {x | y for y in current} | {x}\n # # print(current)\n # ans |= current\n # # print(ans)\n # return len(ans)\n \n # brute force time complexity :O(n^2)\n # space complexity:O(n)\n if not arr:return 0\n l ,ans = len(arr) ,set()\n for i in range(l):\n res = arr[i]\n ans.add(res)\n for j in range(i+1,l):\n res |= arr[j]\n ans.add(res)\n return len(ans)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n fullSet = set()\n setAtI = {0}\n \n for i in range(len(A)):\n setAtI = {A[i]| y for y in setAtI} | {A[i]}\n fullSet |=setAtI\n return len(fullSet)\n \n \n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n setA = set(A)\n \n prev = set()\n \n prev.add(A[0])\n \n for val in A[1:]:\n temp = set()\n \n for p in prev:\n temp.add(p|val)\n setA.add(p|val)\n prev = temp\n prev.add(val)\n return len(setA)","import math\nclass Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans = {A[0]}\n pre = {A[0]}\n for a in A[1:]:\n pre = {a|x for x in pre}\n pre.add(a)\n for i in pre:\n ans.add(i) \n return len(ans)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans=set()\n vset=set()\n for a in A:\n newvset=set()\n for v in vset:\n newvset.add(a|v)\n ans.add(a|v)\n newvset.add(a)\n vset=newvset\n ans.add(a)\n return len(ans)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n \n cur = set()\n res = set()\n for i in A:\n temp = set([i])\n for j in cur:\n temp.add(i|j)\n cur = temp\n for j in cur:\n res.add(j)\n return len(res)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n \n result, prev = set(), set()\n \n for num in A:\n temp = set()\n temp.add(num)\n \n result.add(num)\n \n for p in prev:\n temp.add(p|num)\n result.add(p|num)\n \n prev = temp\n return len(result)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n S, prev = set(), set()\n for a in A:\n temp = set()\n temp.add(a)\n S.add(a)\n for p in prev:\n temp.add(a|p)\n S.add(a|p)\n prev = temp\n return len(S)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n alive = set()\n dead = set()\n for num1 in A:\n tmp = {num1}\n for num2 in alive:\n dead.add(num2)\n tmp.add(num1|num2)\n alive = tmp\n \n return len(alive|dead)","class Solution:\n \n def subarrayBitwiseORs(self, A: List[int]) -> int:\n arr_len = len(A)\n final_result_set = set()\n pre_result_set = set()\n pre_result_set.add(A[0])\n final_result_set.add(A[0])\n for i in range (1, arr_len):\n cur_result_set = set()\n for pre_result in pre_result_set:\n one_cur_result = pre_result | A[i]\n cur_result_set.add(one_cur_result)\n final_result_set.add(one_cur_result)\n cur_result_set.add(A[i])\n final_result_set.add(A[i])\n pre_result_set = cur_result_set\n return len(final_result_set)\n \n \n \n \n","class Solution:\n def subarrayBitwiseORs(self, A):\n nums, n, pre = set(), len(A), set()\n for a in A:\n pre = {a} | {num | a for num in pre}\n nums |= pre\n return len(nums)\n\n# @param {Integer[]} a\n# @return {Integer}\n#def subarray_bitwise_o_rs(a)\n # Get subarrays\n# solutions = {}\n# iterating_array = a.clone\n# a.each do |m|\n# num = m\n# iterating_array.each do |m|\n# solutions[num] = 1\n# num |= m\n# end\n# solutions[num] = 1\n# iterating_array.shift\n# end\n# solutions.keys.length\n#end\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans = set()\n cur = set()\n for a in A:\n cur = {p | a for p in cur} | {a}\n ans |= cur\n return len(ans)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n my_set = [set([A[i]]) for i in range(len(A))]\n \n for i in range(1, len(A)):\n for prev_result in my_set[i-1]:\n my_set[i].add(A[i] | prev_result)\n \n return len(set.union(*my_set))\n \n \n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n \n curr=set()\n ans=set()\n for a in A:\n s=set()\n s.add(a)\n for i in curr:\n s.add(a|i)\n curr=s\n for t in curr:\n ans.add(t|a)\n return len(ans)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n my_set = [set([A[i]]) for i in range(len(A))]\n \n for i in range(1, len(A)):\n for prev_result in my_set[i-1]:\n res = A[i] | prev_result\n my_set[i].add(res)\n \n return len(set.union(*my_set))\n \n \n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n sets=[{i} for i in A]\n for i in range(1,len(A)):\n for prev in sets[i-1]:\n sets[i].add(A[i]|prev)\n \n for num in sets[1:]:\n sets[0]|=num \n return len(sets[0])","from typing import List, Set\n\n\nclass Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n all_results: Set[int] = set()\n prev_results: Set[int] = set()\n\n for start_index in range(len(A)):\n curr_results: Set[int] = set()\n curr_results.add(A[start_index])\n\n for prev_result in prev_results:\n curr_results.add(prev_result | A[start_index])\n\n all_results |= curr_results\n prev_results = curr_results\n return len(all_results)\n\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n res, curr = set(), set()\n for a in A:\n temp = {a}\n for b in curr:\n temp.add(a | b)\n curr = temp\n for num in curr:\n res.add(num)\n return len(res)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n sets=[{i} for i in A]\n for i in range(1,len(A)):\n for prev in sets[i-1]:\n sets[i].add(A[i]|prev)\n return len(set.union(*sets))","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans = set()\n prev = set()\n prev.add(0)\n \n for i in range(len(A)):\n cur = set()\n cur.add(A[i])\n \n for p in prev:\n res = p | A[i]\n if res != p:\n ans.add(p)\n cur.add(res)\n \n prev = cur\n \n for p in prev:\n ans.add(p)\n \n if 0 not in A:\n ans.remove(0)\n \n return len(ans)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans = set()\n cur = set()\n for x in A:\n cur = {y|x for y in cur} | set([x])\n ans |= cur\n return len(ans)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n my_set = set(A)\n curr = 0\n prev = set()\n prev.add(A[0])\n for num in A[1:]:\n temp = set()\n for p in prev:\n temp.add(num | p)\n my_set.add(num | p)\n prev = temp\n prev.add(num)\n\n return len(my_set)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n if A == []:\n return 0\n # count = [0]\n # dic = {}\n # def OR(s):\n # if len(s) == 1:\n # return s[0]\n # res = s[0]\n # for item in s[1:]:\n # res = res | item\n # return res\n # for i in range(len(A)):\n # for j in range(i, len(A)):\n # res = OR(A[i:j+1])\n # if res in dic:\n # continue\n # dic[res] = 0\n # count[0] += 1\n # return count[0]\n my_set = set(A)\n curr = 0\n prev = set()\n prev.add(A[0])\n for num in A[1:]:\n temp = set()\n for p in prev:\n temp.add(num | p)\n my_set.add(num | p)\n prev = temp\n prev.add(num)\n\n return len(my_set)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans = set(A)\n prev = set([A[0]])\n for i in A[1:]:\n temp = set()\n for p in prev:\n temp.add(i|p)\n ans.add(i|p)\n prev = temp\n prev.add(i)\n return len(ans)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n # res, cur = set(), set()\n # for num in A:\n # cur = {val | num for val in cur} | {num}\n # res |= cur\n # return len(res)\n \n # list\n res = []\n left, right = 0, 0\n for val in A:\n right = len(res)\n res.append(val)\n for i in range(left, right):\n if res[-1] != (res[i] | val):\n res.append(res[i] | val)\n left = right\n return len(set(res))\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n res = set()\n \n last = set()\n \n for x in A:\n new = {x}\n \n for y in last:\n new.add(x | y)\n \n res |= new\n last = new\n \n return len(res)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n vals = set()\n \n if len(A) < 2:\n return len(A)\n \n cur = {0}\n for a in A:\n cur = {a| y for y in cur} | {a}\n vals |= cur\n return len(vals)","class Solution:\n def subarrayBitwiseORs(self, A):\n # Tabulation is a list of sets, one for each number in A. \n # Each set, at position i, is initialised to containing the element at A[i]\n tabulation = [set([A[i]]) for i in range(len(A))]\n \n # And now we need to go through, updating the sets based on the previous set.\n for i in range(1, len(A)):\n for previous_result in tabulation[i - 1]: \n tabulation[i].add(A[i] | previous_result) \n \n # Return the number of unique numbers in the tabulation list.\n return len(set.union(*tabulation)) if len(A) > 0 else 0\n","class Solution:\n def subarrayBitwiseORs(self, A: list) -> int:\n results = set()\n pre = {0}\n\n for a in A:\n '''\n cur = {a}\n for prev in pre:\n cur.add(prev | a)\n results |= cur\n pre = cur\n '''\n pre = {a | p for p in pre} | {a}\n results |= pre\n\n return len(results)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n s, ans = set(), set()\n for a in A:\n s = {a} | {a | b for b in s}\n ans |= s\n return len(ans)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n # https://blog.csdn.net/fuxuemingzhu/article/details/83511833\n res = set()\n cur = set()\n for a in A:\n cur = {n | a for n in cur} | {a}\n res |= cur\n return len(res)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n s = set()\n s1 = set()\n for n in A:\n s2 = set()\n for e in s1:\n s2.add(e|n)\n s1=s2\n s1.add(n)\n s|=s1\n # print(s)\n return len(s)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n res = set([])\n tmp = set([])\n for i in A:\n newtmp = set([])\n for j in tmp:\n newtmp.add(i|j)\n res.add(i|j)\n newtmp.add(i)\n res.add(i)\n tmp = newtmp\n return len(res)\n \n \n \n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n # 12:57 8/24/20\n \n res, cur = set(), set()\n for i in A:\n cur = {i | j for j in cur} | {i}\n res |= cur\n return len(res)\n \n \n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n ans, frontier = set(), set()\n \n for n in A:\n frontier = {x | n for x in frontier if x|n != -1}\n frontier.add(n)\n ans |= frontier\n \n \n return len(ans)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n curr = {0}\n ans = set()\n for a in A:\n curr = {x|a for x in curr } | {a}\n ans |= curr\n return len(ans)\n \n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n my_set = [set([A[i]]) for i in range(len(A))]\n ans = set(A)\n \n for i in range(1, len(A)):\n for prev_result in my_set[i-1]:\n res = A[i] | prev_result\n my_set[i].add(res)\n ans.add(res)\n \n return len(ans)\n \n \n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n my_set = set(A)\n curr = 0\n prev = set()\n prev.add(A[0])\n for num in A[1:]:\n temp = set()\n curr |= num\n my_set.add(curr)\n prev.add(num)\n for p in prev:\n temp.add(num | p)\n my_set.add(num | p)\n prev = temp\n\n return len(my_set)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n dp = []\n for i in range(len(A)):\n if i == 0:\n dp.append(set([A[i]]))\n else:\n inner = set([A[i]])\n for d in dp[-1]:\n inner.add(d | A[i])\n dp.append(inner)\n total = set()\n for d in dp:\n total.update(d)\n return len(total)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n result = set()\n curr = set()\n for num in A:\n curr = {num | prev_num for prev_num in curr} | {num}\n result |= curr\n return len(result)\n \n \n \n# result = set()\n# prev = set([0])\n# for num in A:\n# curr = set([num])\n# for prev_num in prev:\n# curr.add(prev_num | num)\n# result |= curr\n# prev = curr\n# return len(result)\n","class Solution:\n def subarrayBitwiseORs(self, arr: List[int]) -> int:\n ans = set()\n current = {0}\n for x in arr:\n # print(x,current)\n current = {x | y for y in current} | {x}\n # print(current)\n ans |= current\n # print(ans)\n return len(ans)\n \n # brute force time complexity :O(n^2)\n # space complexity:O(n)\n if not arr:return 0\n l ,ans = len(arr) ,set()\n for i in range(l):\n res = arr[i]\n ans.add(res)\n for j in range(i+1,l):\n res |= arr[j]\n ans.add(res)\n return len(ans)\n","class Solution:\n def subarrayBitwiseORs(self, a: List[int]) -> int:\n res, prev = set(), set()\n res.add(a[0])\n prev.add(a[0])\n for i in range(1, len(a)):\n cur = set()\n cur.add(a[i])\n res.add(a[i])\n for j in prev:\n cur.add(j|a[i])\n res.add(j|a[i])\n prev = cur\n return len(res)","class Solution(object):\n def subarrayBitwiseORs(self, A):\n final = set()\n actual = set()\n for el in A:\n actual = {el} | {el2 | el for el2 in actual}\n final |= actual\n return len(final)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n mp={0:1} \n ans={} \n for a in A:\n temp={} \n for m in mp:\n temp[m|a]=1 \n temp[a]=1 \n for t in temp:\n ans[t]=1 \n mp={} \n for t in temp:\n mp[t]=1 \n cnt=0 \n for c in ans:\n cnt+=1 \n return cnt\n \n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n result_set = set()\n results = set()\n for num in A:\n results = {j | num for j in results}\n results.add(num)\n result_set.update(results)\n return len(result_set)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n \n ans = set()\n prev = set()\n \n for a in A:\n \n cur = set(a | b for b in prev)\n cur.add(a)\n \n prev = cur\n ans |= cur\n \n return len(ans)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n # O(N^3) to try oring every possible subarray\n \n # key fact: for any number k , k | k = k\n # also 0 | k = k for all k\n \n # one small optimization: scan through and delete any 0s or consecutive repeats\n \n # keep a list of or results s.t. or[i] = set of all possible results from oring subarrays that end at i\n # then or[i] = [A[i]] + [A[i] | res for res in or[i - 1]] -> use a set to prune dups at each step\n # you can just keep or[i] for most recent two i's\n # \n if not A:\n return []\n # [1, 2, 4]\n # all_outcomes: {1, 2, 3, 4, 6, 7}\n # outcomes: {2, 3}\n # 4: temp {4, 6, 7}\n \n # todo(mywang): preprocess array and remove unnecessary stuff\n # for i in range(len(A))[::-1]:\n # if (i > 0 and A[i] == A[i - 1]):\n # A.pop(i)\n all_outcomes = set()\n outcomes = set()\n for elt in A:\n outcomes = {elt} | {elt | val for val in outcomes}\n all_outcomes |= outcomes\n \n return len(all_outcomes)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n # O(N^3) to try oring every possible subarray\n \n # key fact: for any number k , k | k = k\n # also 0 | k = k for all k\n \n # one small optimization: scan through and delete any 0s or consecutive repeats\n \n # keep a list of or results s.t. or[i] = set of all possible results from oring subarrays that end at i\n # then or[i] = [A[i]] + [A[i] | res for res in or[i - 1]] -> use a set to prune dups at each step\n # you can just keep or[i] for most recent two i's\n # \n if not A:\n return []\n # [1, 2, 4]\n # all_outcomes: {1, 2, 3, 4, 6, 7}\n # outcomes: {2, 3}\n # 4: temp {4, 6, 7}\n \n # todo(mywang): preprocess array and remove unnecessary stuff\n for i in range(len(A))[::-1]:\n if (i > 0 and A[i] == A[i - 1]):\n A.pop(i)\n all_outcomes = set()\n outcomes = set()\n for elt in A:\n outcomes = {elt} | {elt | val for val in outcomes}\n all_outcomes |= outcomes\n \n return len(all_outcomes)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n # O(N^3) to try oring every possible subarray\n \n # key fact: for any number k , k | k = k\n # also 0 | k = k for all k\n \n # one small optimization: scan through and delete any 0s or consecutive repeats\n \n # keep a list of or results s.t. or[i] = set of all possible results from oring subarrays that end at i\n # then or[i] = [A[i]] + [A[i] | res for res in or[i - 1]] -> use a set to prune dups at each step\n # you can just keep or[i] for most recent two i's\n # \n if not A:\n return []\n # [1, 2, 4]\n # all_outcomes: {1, 2, 3, 4, 6, 7}\n # outcomes: {2, 3}\n # 4: temp {4, 6, 7}\n \n # todo(mywang): preprocess array and remove unnecessary stuff\n for i in range(len(A))[::-1]:\n if (i > 0 and A[i] == A[i - 1]):\n A.pop(i)\n all_outcomes = set([A[0]])\n outcomes = set([A[0]])\n for elt in A[1:]:\n temp = {elt} | {elt | val for val in outcomes}\n outcomes = temp\n all_outcomes |= outcomes\n \n return len(all_outcomes)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n cur,res = set(),set()\n for i in A:\n cur = { i|j for j in cur} | {i}\n res |= cur\n return len(res)\n# nums, n = set(), len(A)\n# for i in range(n):\n# num = A[i]\n# for j in range(i, n):\n# num |= A[j]\n# nums.add(num)\n# return len(nums)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n \n \n \n # my solution ... 736 ms ... 100 % ... 40.6 MB ... 15 %\n # time: O(nlogn)\n # space: O(logn)\n \n res = set()\n tot = set()\n for a in A:\n res = {prev | a for prev in res} | {a} # 得出以当前 a 结尾的 subarray\n tot |= res # 把结果并入 tot\n return len(tot)\n \n \n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n res = set()\n \n cur = set()\n \n for x in A:\n cur = {x} | {x | y for y in cur}\n res |= cur\n \n return len(res)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n # Frontier Set \n # Time complexity: O(NlogW), where N is the length of A, and W is the maximum size of elements in A.\n # Space complexity: O(NlogW)\n ans = set()\n cur = {0}\n for x in A:\n cur = {x | y for y in cur} | {x}\n ans |= cur\n return len(ans)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n # 12:57 8/24/20\n \n cur, res = set(),set()\n for num in A:\n cur = {num | j for j in cur} # | {num}\n # cur = set(num | k for k in A)\n cur.add(num)\n res.update(cur)\n \n return len(res)\n \n \n \n # res, cur = set(), set()\n # for i in A:\n # cur = {i | j for j in cur} | {i}\n # res |= cur\n # return len(res)\n\n \n \n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n self.res = set()\n def helper(idx):\n if idx < 0:\n return set()\n if idx==0:\n self.res |= {A[idx]}\n return {A[idx]}\n val = {A[idx]}|{x|A[idx] for x in helper(idx-1)}\n self.res |= val\n return val\n helper(len(A)-1)\n return len(self.res)","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n result = set()\n curr = set()\n for num in A:\n curr = {num | prev_num for prev_num in curr}\n curr.add(num)\n result.update(curr)\n return len(result)\n \n \n \n# result = set()\n# prev = set([0])\n# for num in A:\n# curr = set([num])\n# for prev_num in prev:\n# curr.add(prev_num | num)\n# result |= curr\n# prev = curr\n# return len(result)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n my_set = set(A)\n curr = 0\n prev = set()\n prev.add(A[0])\n for num in A[1:]:\n temp = set()\n #curr |= num\n #my_set.add(curr)\n \n for p in prev:\n temp.add(num | p)\n my_set.add(num | p)\n \n #print(temp)\n prev = temp\n prev.add(num)\n\n return len(my_set)\n","class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n # Frontier Set \n # Time complexity: O(NlogW) = O(30N), where N is the length of A, and W is the maximum size of elements in A.\n # Space complexity: O(NlogW)\n ans = set()\n cur = {0}\n for x in A:\n cur = {x | y for y in cur} | {x}\n ans |= cur\n return len(ans)\n","class Solution:\n def subarrayBitwiseORs(self, arr: List[int]) -> int:\n s = set()\n prev = set()\n prev.add(arr[0])\n s.add(arr[0])\n \n for i in range(len(arr)):\n temp = set()\n for val in prev:\n temp.add(val|arr[i])\n s.add(val|arr[i])\n \n prev = temp\n prev.add(arr[i])\n s.add(arr[i])\n \n return len(s)"],"string":"[\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n res = set()\\n cur = set()\\n for a in A:\\n cur = {a | i for i in cur}\\n cur |= {a}\\n res |= cur\\n return len(res)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n s = set()\\n c = set()\\n for x in A:\\n c = {x|y for y in c}\\n c.add(x)\\n s|=c\\n return len(s)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n cur = set([0])\\n \\n for x in A:\\n cur = {x | y for y in cur} | {x}\\n ans |= cur\\n return len(ans)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n prev = set()\\n curr = set()\\n vals = set(A)\\n \\n for x in A:\\n curr.add(x)\\n for y in prev:\\n curr.add(x|y)\\n vals.add(x|y)\\n prev = curr\\n curr = set()\\n \\n return len(vals)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n curr = set()\\n ans = set()\\n for x in A:\\n curr = {x | y for y in curr} | {x}\\n ans |= curr\\n \\n return len(ans)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n results = set()\\n curr = {0}\\n for a in A:\\n curr = {a | b for b in curr} | {a}\\n results |= curr\\n return len(results)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n res, cur = set(), set()\\n for i in A:\\n cur = {i | j for j in cur} | {i}\\n res |= cur\\n return len(res)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # O(N^3) to try oring every possible subarray\\n \\n # key fact: for any number k , k | k = k\\n # also 0 | k = k for all k\\n \\n # one small optimization: scan through and delete any 0s or consecutive repeats\\n \\n # keep a list of or results s.t. or[i] = set of all possible results from oring subarrays that end at i\\n # then or[i] = [A[i]] + [A[i] | res for res in or[i - 1]] -> use a set to prune dups at each step\\n # you can just keep or[i] for most recent two i's\\n # \\n if not A:\\n return []\\n # [1, 2, 4]\\n # all_outcomes: {1, 2, 3, 4, 6, 7}\\n # outcomes: {2, 3}\\n # 4: temp {4, 6, 7}\\n \\n # todo(mywang): preprocess array and remove unnecessary stuff\\n for i in range(len(A))[::-1]:\\n if (i > 0 and A[i] == A[i - 1]):\\n A.pop(i)\\n all_outcomes = set([A[0]])\\n outcomes = set([A[0]])\\n for elt in A[1:]:\\n outcomes = {elt} | {elt | val for val in outcomes}\\n all_outcomes |= outcomes\\n \\n return len(all_outcomes)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans=set()\\n cur=set()\\n for i in A:\\n cur = set([i|j for j in cur])\\n cur.add(i)\\n ans|=cur\\n return len(ans)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n cur = set()\\n all = set()\\n for v in A:\\n cur = set(e | v for e in cur)\\n cur.add(v)\\n all |= cur\\n return len(all)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n cur = {0}\\n for i in A:\\n cur = {i | y for y in cur} | {i}\\n ans |= cur\\n return len(ans)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n cur, res = set(), set()\\n for i in A:\\n cur = {i | j for j in cur} | {i}\\n res |= cur\\n return len(res)\",\n \"import math\\nclass Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n res = set([])\\n tmp = []\\n maximpact = 0\\n for i in A:\\n newtmp = []\\n newtmp_set = set([])\\n maximpact = max(maximpact, int(math.log(i, 2)) + 1 if i > 0 else 0)\\n if i not in newtmp_set:\\n newtmp_set.add(i)\\n newtmp.append(i)\\n res.add(i)\\n if maximpact > 0:\\n for j in tmp:\\n k = i|j\\n if k not in newtmp_set:\\n newtmp_set.add(k)\\n newtmp.append(k)\\n res.add(k)\\n if len(newtmp) >= maximpact:\\n break\\n tmp = newtmp\\n return len(res)\\n \\n \\n \\n\",\n \"class Solution(object):\\n def subarrayBitwiseORs(self, A):\\n ans = set()\\n cur = {0}\\n for x in A:\\n cur = {x | y for y in cur} | {x}\\n ans |= cur\\n return len(ans)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n result, curr = set(), set()\\n for a in A:\\n curr = {a | j for j in curr} | {a}\\n result |= curr\\n return len(result)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n results = set()\\n temp = {0}\\n for cur in A:\\n # print(temp)\\n temp = {cur} | {cur | t for t in temp}\\n results.update(temp)\\n return len(results)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n s = set()\\n global_set = set()\\n ans = 0\\n for v in A:\\n s.add(v)\\n s = {x|v for x in s}\\n global_set |= s\\n \\n return len(global_set)\",\n \"import math\\nclass Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = {A[0]}\\n pre = {A[0]}\\n for a in A[1:]:\\n pre = {a|x for x in pre}\\n pre.add(a)\\n ans.update(pre) \\n return len(ans)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n S, last = set(), set()\\n for i in range(len(A)):\\n last = {a|A[i] for a in last}\\n last.add(A[i])\\n S |= last\\n \\n return len(S)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n cur = {0}\\n for x in A:\\n cur = {x | y for y in cur} | {x}\\n ans |= cur\\n return len(ans)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n \\n \\n \\n # my solution ... 760 ms ... 98 % ... 40.6 MB ... 15 %\\n # time: O(nlogn)\\n # space: O(logn)\\n \\n res = set()\\n tot = set()\\n for a in A:\\n res = {prev | a for prev in res} | {a} # 得出以当前 a 结尾的 subarray\\n tot |= res # 把结果并入 tot\\n return len(tot)\\n \\n \\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n cur = set([0])\\n \\n for x in A:\\n cur = set([x | y for y in cur]) | {x}\\n ans |= cur\\n return len(ans)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n previous = set()\\n for v in A:\\n current = set([i|v for i in previous])\\n current.add(v)\\n ans.update(current)\\n previous = current\\n return len(ans)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n st = set()\\n cur = set()\\n for a in A:\\n cur = {b | a for b in cur} | {a}\\n st |= cur\\n return len(st)\",\n \"from typing import List\\n\\n\\nclass Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n seen = set()\\n cur = set()\\n\\n for num in A:\\n cur_new = set()\\n for num_seen in cur:\\n cur_new.add(num_seen | num)\\n\\n cur_new.add(num)\\n cur = cur_new\\n seen |= cur\\n\\n return len(seen)\\n\\n def subarrayBitwiseORsN2(self, A: List[int]) -> int:\\n dp = [[0] * len(A) for _ in range(len(A))]\\n\\n seen = set()\\n\\n count = 0\\n\\n for start in reversed(list(range(len(A)))):\\n for end in range(start, len(A)):\\n if start == end:\\n dp[start][end] = A[start]\\n else:\\n dp[start][end] = dp[start + 1][end] | A[start]\\n\\n if dp[start][end] not in seen:\\n count += 1\\n seen.add(dp[start][end])\\n\\n return count\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n cur = {0}\\n for x in A:\\n cur = {x|y for y in cur} | {x}\\n ans |= cur\\n return len(ans)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # Brute force with set, with list we can use if in list conditional statement\\n # Slow & bad....\\n\\n# rset = set()\\n# for i in range(len(A)):\\n# for j in range(i+1, len(A)+1):\\n# res = 0\\n# for k in range(i, j):\\n# res |= A[k]\\n# rset.add(res)\\n# return len(rset) \\n \\n# A cleaner code\\n# Assume B[i][j] = A[i] | A[i+1] | ... | A[j]\\n# Hash set cur stores all wise B[0][i], B[1][i], B[2][i], B[i][i].\\n\\n# When we handle the A[i+1], we want to update cur\\n# So we need operate bitwise OR on all elements in cur.\\n# Also we need to add A[i+1] to cur.\\n\\n# In each turn, we add all elements in cur to res.\\n# This method is better since it preserves the results of previous operation and make them useful\\n res, cur = set(), set()\\n \\n for i in A:\\n cur = {i|j for j in cur} | {i}\\n res |= cur\\n \\n return len(res)\\n \\n\",\n \"class Solution(object):\\n def subarrayBitwiseORs(self, A):\\n ans = set()\\n cur = {0}\\n for x in A:\\n cur = {x | y for y in cur} | {x}\\n ans|=cur\\n #print(cur)\\n #print(\\\\\\\"ans\\\\\\\",ans)\\n return len(ans)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n \\n result = set()\\n cur = {0}\\n \\n for x in A:\\n cur = {x | y for y in cur} | {x}\\n result |= cur\\n \\n return len(result)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n s = set()\\n res = set()\\n for x in A:\\n new_s = {x}\\n for xx in s:\\n new_s.add(xx | x)\\n s = new_s\\n res |= s\\n return len(res)\",\n \"import itertools as it\\n\\n\\nclass Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n res, cur = set(), set()\\n for i in A:\\n cur = {i | j for j in cur} | {i}\\n res |= cur\\n return len(res)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n cur, res = set(), set()\\n for a in A:\\n cur = {a|b for b in cur} | {a}\\n res |= cur\\n return len(res)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n \\n cur = {0}\\n \\n for x in A:\\n cur = {x|y for y in cur} | {x}\\n ans |= cur\\n \\n return len(ans)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # 12:57 8/24/20\\n \\n cur, res = set(),set()\\n for num in A:\\n cur = {num | j for j in cur} | {num}\\n # res |= cur\\n # cur = set(num | k for k in A)\\n # cur.add(num)\\n res.update(cur)\\n \\n return len(res)\\n \\n \\n \\n # res, cur = set(), set()\\n # for i in A:\\n # cur = {i | j for j in cur} | {i}\\n # res |= cur\\n # return len(res)\\n\\n \\n \\n\",\n \"class Solution:\\n# def findUnique(self, l):\\n# u = []\\n \\n# for num in l:\\n# if num not in u:\\n# u.append(num)\\n \\n# return self.findOR(u)\\n \\n# def findOR(self, l):\\n \\n# ret = 0\\n \\n# for num in l:\\n# ret = self.doBin(ret, num)\\n# return ret\\n \\n \\n# def doBin(self, a, b):\\n \\n# p = 0\\n \\n# ret = 0\\n# while a or b:\\n# if a%2 or b%2:\\n# ret += pow(2,p)\\n# p +=1\\n# a, b = a//2, b//2\\n \\n# return ret\\n \\n# def subarrayBitwiseORs(self, A: List[int]) -> int:\\n# #just unique combinations\\n \\n# res = 0 \\n \\n# seen = []\\n# #brute force\\n# for i in range(len(A)):\\n# for j in range(i,len(A)):\\n# uniq = self.findUnique(A[i:j+1])\\n# if uniq not in seen:\\n# seen.append(uniq)\\n# res +=1\\n \\n# return res\\n\\n\\n def subarrayBitwiseORs(self, A):\\n ans = set()\\n cur = {0}\\n for x in A:\\n cur = {x | y for y in cur} | {x}\\n ans |= cur\\n return len(ans)\\n\\n\\n\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n n = len(A)\\n dp = set()\\n ans = set()\\n \\n for j in range(n):\\n dp_new = set()\\n dp_new.add(A[j])\\n for x in dp:\\n dp_new.add(x | A[j])\\n dp = dp_new \\n ans.update(dp)\\n \\n return len(ans) \\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans, dp = set(), set()\\n for x in A:\\n ndp = set()\\n ndp.add(x)\\n for y in dp:\\n ndp.add(x|y)\\n ans.add(y)\\n dp = ndp\\n for x in dp: ans.add(x)\\n return len(ans)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # O(N^3) to try oring every possible subarray\\n \\n # key fact: for any number k , k | k = k\\n # also 0 | k = k for all k\\n \\n # one small optimization: scan through and delete any 0s or consecutive repeats\\n \\n # keep a list of or results s.t. or[i] = set of all possible results from oring subarrays that end at i\\n # then or[i] = [A[i]] + [A[i] | res for res in or[i - 1]] -> use a set to prune dups at each step\\n # you can just keep or[i] for most recent two i's\\n # \\n if not A:\\n return []\\n # [1, 2, 4]\\n # all_outcomes: {1, 2, 3, 4, 6, 7}\\n # outcomes: {2, 3}\\n # 4: temp {4, 6, 7}\\n \\n # todo(mywang): preprocess array and remove unnecessary stuff\\n for i in range(len(A))[::-1]:\\n if (i > 0 and A[i] == A[i - 1]):\\n A.pop(i)\\n all_outcomes = set([A[0]])\\n outcomes = set([A[0]])\\n for elt in A[1:]:\\n temp = set([elt])\\n for out in outcomes:\\n temp.add(out | elt)\\n outcomes = temp\\n all_outcomes |= outcomes\\n \\n return len(all_outcomes)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n tp = set()\\n tp.add(0)\\n for i in A:\\n tpp = set()\\n tpp.add(i)\\n for ii in tp:\\n tpp.add(ii|i)\\n tp=tpp\\n for ii in tp:\\n ans.add(ii)\\n return len(ans)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n s = set()\\n res = set()\\n for n in A:\\n s = {n} | {n | el for el in s}\\n res |= s\\n\\n return len(res)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, arr: List[int]) -> int:\\n ans = set()\\n current = set()\\n current.add(0)\\n for i in range(len(arr)):\\n a = arr[i]\\n s = set()\\n s.add(a)\\n for y in current:\\n s.add(a | y)\\n current = s\\n ans |= s\\n return len(ans)\\n \\n # for x in arr:\\n # current = {x | y for y in current} | {x}\\n # # print(current)\\n # ans |= current\\n # # print(ans)\\n # return len(ans)\\n \\n # brute force time complexity :O(n^2)\\n # space complexity:O(n)\\n if not arr:return 0\\n l ,ans = len(arr) ,set()\\n for i in range(l):\\n res = arr[i]\\n ans.add(res)\\n for j in range(i+1,l):\\n res |= arr[j]\\n ans.add(res)\\n return len(ans)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n fullSet = set()\\n setAtI = {0}\\n \\n for i in range(len(A)):\\n setAtI = {A[i]| y for y in setAtI} | {A[i]}\\n fullSet |=setAtI\\n return len(fullSet)\\n \\n \\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n setA = set(A)\\n \\n prev = set()\\n \\n prev.add(A[0])\\n \\n for val in A[1:]:\\n temp = set()\\n \\n for p in prev:\\n temp.add(p|val)\\n setA.add(p|val)\\n prev = temp\\n prev.add(val)\\n return len(setA)\",\n \"import math\\nclass Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = {A[0]}\\n pre = {A[0]}\\n for a in A[1:]:\\n pre = {a|x for x in pre}\\n pre.add(a)\\n for i in pre:\\n ans.add(i) \\n return len(ans)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans=set()\\n vset=set()\\n for a in A:\\n newvset=set()\\n for v in vset:\\n newvset.add(a|v)\\n ans.add(a|v)\\n newvset.add(a)\\n vset=newvset\\n ans.add(a)\\n return len(ans)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n \\n cur = set()\\n res = set()\\n for i in A:\\n temp = set([i])\\n for j in cur:\\n temp.add(i|j)\\n cur = temp\\n for j in cur:\\n res.add(j)\\n return len(res)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n \\n result, prev = set(), set()\\n \\n for num in A:\\n temp = set()\\n temp.add(num)\\n \\n result.add(num)\\n \\n for p in prev:\\n temp.add(p|num)\\n result.add(p|num)\\n \\n prev = temp\\n return len(result)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n S, prev = set(), set()\\n for a in A:\\n temp = set()\\n temp.add(a)\\n S.add(a)\\n for p in prev:\\n temp.add(a|p)\\n S.add(a|p)\\n prev = temp\\n return len(S)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n alive = set()\\n dead = set()\\n for num1 in A:\\n tmp = {num1}\\n for num2 in alive:\\n dead.add(num2)\\n tmp.add(num1|num2)\\n alive = tmp\\n \\n return len(alive|dead)\",\n \"class Solution:\\n \\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n arr_len = len(A)\\n final_result_set = set()\\n pre_result_set = set()\\n pre_result_set.add(A[0])\\n final_result_set.add(A[0])\\n for i in range (1, arr_len):\\n cur_result_set = set()\\n for pre_result in pre_result_set:\\n one_cur_result = pre_result | A[i]\\n cur_result_set.add(one_cur_result)\\n final_result_set.add(one_cur_result)\\n cur_result_set.add(A[i])\\n final_result_set.add(A[i])\\n pre_result_set = cur_result_set\\n return len(final_result_set)\\n \\n \\n \\n \\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A):\\n nums, n, pre = set(), len(A), set()\\n for a in A:\\n pre = {a} | {num | a for num in pre}\\n nums |= pre\\n return len(nums)\\n\\n# @param {Integer[]} a\\n# @return {Integer}\\n#def subarray_bitwise_o_rs(a)\\n # Get subarrays\\n# solutions = {}\\n# iterating_array = a.clone\\n# a.each do |m|\\n# num = m\\n# iterating_array.each do |m|\\n# solutions[num] = 1\\n# num |= m\\n# end\\n# solutions[num] = 1\\n# iterating_array.shift\\n# end\\n# solutions.keys.length\\n#end\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n cur = set()\\n for a in A:\\n cur = {p | a for p in cur} | {a}\\n ans |= cur\\n return len(ans)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n my_set = [set([A[i]]) for i in range(len(A))]\\n \\n for i in range(1, len(A)):\\n for prev_result in my_set[i-1]:\\n my_set[i].add(A[i] | prev_result)\\n \\n return len(set.union(*my_set))\\n \\n \\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n \\n curr=set()\\n ans=set()\\n for a in A:\\n s=set()\\n s.add(a)\\n for i in curr:\\n s.add(a|i)\\n curr=s\\n for t in curr:\\n ans.add(t|a)\\n return len(ans)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n my_set = [set([A[i]]) for i in range(len(A))]\\n \\n for i in range(1, len(A)):\\n for prev_result in my_set[i-1]:\\n res = A[i] | prev_result\\n my_set[i].add(res)\\n \\n return len(set.union(*my_set))\\n \\n \\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n sets=[{i} for i in A]\\n for i in range(1,len(A)):\\n for prev in sets[i-1]:\\n sets[i].add(A[i]|prev)\\n \\n for num in sets[1:]:\\n sets[0]|=num \\n return len(sets[0])\",\n \"from typing import List, Set\\n\\n\\nclass Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n all_results: Set[int] = set()\\n prev_results: Set[int] = set()\\n\\n for start_index in range(len(A)):\\n curr_results: Set[int] = set()\\n curr_results.add(A[start_index])\\n\\n for prev_result in prev_results:\\n curr_results.add(prev_result | A[start_index])\\n\\n all_results |= curr_results\\n prev_results = curr_results\\n return len(all_results)\\n\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n res, curr = set(), set()\\n for a in A:\\n temp = {a}\\n for b in curr:\\n temp.add(a | b)\\n curr = temp\\n for num in curr:\\n res.add(num)\\n return len(res)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n sets=[{i} for i in A]\\n for i in range(1,len(A)):\\n for prev in sets[i-1]:\\n sets[i].add(A[i]|prev)\\n return len(set.union(*sets))\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n prev = set()\\n prev.add(0)\\n \\n for i in range(len(A)):\\n cur = set()\\n cur.add(A[i])\\n \\n for p in prev:\\n res = p | A[i]\\n if res != p:\\n ans.add(p)\\n cur.add(res)\\n \\n prev = cur\\n \\n for p in prev:\\n ans.add(p)\\n \\n if 0 not in A:\\n ans.remove(0)\\n \\n return len(ans)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set()\\n cur = set()\\n for x in A:\\n cur = {y|x for y in cur} | set([x])\\n ans |= cur\\n return len(ans)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n my_set = set(A)\\n curr = 0\\n prev = set()\\n prev.add(A[0])\\n for num in A[1:]:\\n temp = set()\\n for p in prev:\\n temp.add(num | p)\\n my_set.add(num | p)\\n prev = temp\\n prev.add(num)\\n\\n return len(my_set)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n if A == []:\\n return 0\\n # count = [0]\\n # dic = {}\\n # def OR(s):\\n # if len(s) == 1:\\n # return s[0]\\n # res = s[0]\\n # for item in s[1:]:\\n # res = res | item\\n # return res\\n # for i in range(len(A)):\\n # for j in range(i, len(A)):\\n # res = OR(A[i:j+1])\\n # if res in dic:\\n # continue\\n # dic[res] = 0\\n # count[0] += 1\\n # return count[0]\\n my_set = set(A)\\n curr = 0\\n prev = set()\\n prev.add(A[0])\\n for num in A[1:]:\\n temp = set()\\n for p in prev:\\n temp.add(num | p)\\n my_set.add(num | p)\\n prev = temp\\n prev.add(num)\\n\\n return len(my_set)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans = set(A)\\n prev = set([A[0]])\\n for i in A[1:]:\\n temp = set()\\n for p in prev:\\n temp.add(i|p)\\n ans.add(i|p)\\n prev = temp\\n prev.add(i)\\n return len(ans)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # res, cur = set(), set()\\n # for num in A:\\n # cur = {val | num for val in cur} | {num}\\n # res |= cur\\n # return len(res)\\n \\n # list\\n res = []\\n left, right = 0, 0\\n for val in A:\\n right = len(res)\\n res.append(val)\\n for i in range(left, right):\\n if res[-1] != (res[i] | val):\\n res.append(res[i] | val)\\n left = right\\n return len(set(res))\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n res = set()\\n \\n last = set()\\n \\n for x in A:\\n new = {x}\\n \\n for y in last:\\n new.add(x | y)\\n \\n res |= new\\n last = new\\n \\n return len(res)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n vals = set()\\n \\n if len(A) < 2:\\n return len(A)\\n \\n cur = {0}\\n for a in A:\\n cur = {a| y for y in cur} | {a}\\n vals |= cur\\n return len(vals)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A):\\n # Tabulation is a list of sets, one for each number in A. \\n # Each set, at position i, is initialised to containing the element at A[i]\\n tabulation = [set([A[i]]) for i in range(len(A))]\\n \\n # And now we need to go through, updating the sets based on the previous set.\\n for i in range(1, len(A)):\\n for previous_result in tabulation[i - 1]: \\n tabulation[i].add(A[i] | previous_result) \\n \\n # Return the number of unique numbers in the tabulation list.\\n return len(set.union(*tabulation)) if len(A) > 0 else 0\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: list) -> int:\\n results = set()\\n pre = {0}\\n\\n for a in A:\\n '''\\n cur = {a}\\n for prev in pre:\\n cur.add(prev | a)\\n results |= cur\\n pre = cur\\n '''\\n pre = {a | p for p in pre} | {a}\\n results |= pre\\n\\n return len(results)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n s, ans = set(), set()\\n for a in A:\\n s = {a} | {a | b for b in s}\\n ans |= s\\n return len(ans)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # https://blog.csdn.net/fuxuemingzhu/article/details/83511833\\n res = set()\\n cur = set()\\n for a in A:\\n cur = {n | a for n in cur} | {a}\\n res |= cur\\n return len(res)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n s = set()\\n s1 = set()\\n for n in A:\\n s2 = set()\\n for e in s1:\\n s2.add(e|n)\\n s1=s2\\n s1.add(n)\\n s|=s1\\n # print(s)\\n return len(s)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n res = set([])\\n tmp = set([])\\n for i in A:\\n newtmp = set([])\\n for j in tmp:\\n newtmp.add(i|j)\\n res.add(i|j)\\n newtmp.add(i)\\n res.add(i)\\n tmp = newtmp\\n return len(res)\\n \\n \\n \\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # 12:57 8/24/20\\n \\n res, cur = set(), set()\\n for i in A:\\n cur = {i | j for j in cur} | {i}\\n res |= cur\\n return len(res)\\n \\n \\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n ans, frontier = set(), set()\\n \\n for n in A:\\n frontier = {x | n for x in frontier if x|n != -1}\\n frontier.add(n)\\n ans |= frontier\\n \\n \\n return len(ans)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n curr = {0}\\n ans = set()\\n for a in A:\\n curr = {x|a for x in curr } | {a}\\n ans |= curr\\n return len(ans)\\n \\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n my_set = [set([A[i]]) for i in range(len(A))]\\n ans = set(A)\\n \\n for i in range(1, len(A)):\\n for prev_result in my_set[i-1]:\\n res = A[i] | prev_result\\n my_set[i].add(res)\\n ans.add(res)\\n \\n return len(ans)\\n \\n \\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n my_set = set(A)\\n curr = 0\\n prev = set()\\n prev.add(A[0])\\n for num in A[1:]:\\n temp = set()\\n curr |= num\\n my_set.add(curr)\\n prev.add(num)\\n for p in prev:\\n temp.add(num | p)\\n my_set.add(num | p)\\n prev = temp\\n\\n return len(my_set)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n dp = []\\n for i in range(len(A)):\\n if i == 0:\\n dp.append(set([A[i]]))\\n else:\\n inner = set([A[i]])\\n for d in dp[-1]:\\n inner.add(d | A[i])\\n dp.append(inner)\\n total = set()\\n for d in dp:\\n total.update(d)\\n return len(total)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n result = set()\\n curr = set()\\n for num in A:\\n curr = {num | prev_num for prev_num in curr} | {num}\\n result |= curr\\n return len(result)\\n \\n \\n \\n# result = set()\\n# prev = set([0])\\n# for num in A:\\n# curr = set([num])\\n# for prev_num in prev:\\n# curr.add(prev_num | num)\\n# result |= curr\\n# prev = curr\\n# return len(result)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, arr: List[int]) -> int:\\n ans = set()\\n current = {0}\\n for x in arr:\\n # print(x,current)\\n current = {x | y for y in current} | {x}\\n # print(current)\\n ans |= current\\n # print(ans)\\n return len(ans)\\n \\n # brute force time complexity :O(n^2)\\n # space complexity:O(n)\\n if not arr:return 0\\n l ,ans = len(arr) ,set()\\n for i in range(l):\\n res = arr[i]\\n ans.add(res)\\n for j in range(i+1,l):\\n res |= arr[j]\\n ans.add(res)\\n return len(ans)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, a: List[int]) -> int:\\n res, prev = set(), set()\\n res.add(a[0])\\n prev.add(a[0])\\n for i in range(1, len(a)):\\n cur = set()\\n cur.add(a[i])\\n res.add(a[i])\\n for j in prev:\\n cur.add(j|a[i])\\n res.add(j|a[i])\\n prev = cur\\n return len(res)\",\n \"class Solution(object):\\n def subarrayBitwiseORs(self, A):\\n final = set()\\n actual = set()\\n for el in A:\\n actual = {el} | {el2 | el for el2 in actual}\\n final |= actual\\n return len(final)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n mp={0:1} \\n ans={} \\n for a in A:\\n temp={} \\n for m in mp:\\n temp[m|a]=1 \\n temp[a]=1 \\n for t in temp:\\n ans[t]=1 \\n mp={} \\n for t in temp:\\n mp[t]=1 \\n cnt=0 \\n for c in ans:\\n cnt+=1 \\n return cnt\\n \\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n result_set = set()\\n results = set()\\n for num in A:\\n results = {j | num for j in results}\\n results.add(num)\\n result_set.update(results)\\n return len(result_set)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n \\n ans = set()\\n prev = set()\\n \\n for a in A:\\n \\n cur = set(a | b for b in prev)\\n cur.add(a)\\n \\n prev = cur\\n ans |= cur\\n \\n return len(ans)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # O(N^3) to try oring every possible subarray\\n \\n # key fact: for any number k , k | k = k\\n # also 0 | k = k for all k\\n \\n # one small optimization: scan through and delete any 0s or consecutive repeats\\n \\n # keep a list of or results s.t. or[i] = set of all possible results from oring subarrays that end at i\\n # then or[i] = [A[i]] + [A[i] | res for res in or[i - 1]] -> use a set to prune dups at each step\\n # you can just keep or[i] for most recent two i's\\n # \\n if not A:\\n return []\\n # [1, 2, 4]\\n # all_outcomes: {1, 2, 3, 4, 6, 7}\\n # outcomes: {2, 3}\\n # 4: temp {4, 6, 7}\\n \\n # todo(mywang): preprocess array and remove unnecessary stuff\\n # for i in range(len(A))[::-1]:\\n # if (i > 0 and A[i] == A[i - 1]):\\n # A.pop(i)\\n all_outcomes = set()\\n outcomes = set()\\n for elt in A:\\n outcomes = {elt} | {elt | val for val in outcomes}\\n all_outcomes |= outcomes\\n \\n return len(all_outcomes)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # O(N^3) to try oring every possible subarray\\n \\n # key fact: for any number k , k | k = k\\n # also 0 | k = k for all k\\n \\n # one small optimization: scan through and delete any 0s or consecutive repeats\\n \\n # keep a list of or results s.t. or[i] = set of all possible results from oring subarrays that end at i\\n # then or[i] = [A[i]] + [A[i] | res for res in or[i - 1]] -> use a set to prune dups at each step\\n # you can just keep or[i] for most recent two i's\\n # \\n if not A:\\n return []\\n # [1, 2, 4]\\n # all_outcomes: {1, 2, 3, 4, 6, 7}\\n # outcomes: {2, 3}\\n # 4: temp {4, 6, 7}\\n \\n # todo(mywang): preprocess array and remove unnecessary stuff\\n for i in range(len(A))[::-1]:\\n if (i > 0 and A[i] == A[i - 1]):\\n A.pop(i)\\n all_outcomes = set()\\n outcomes = set()\\n for elt in A:\\n outcomes = {elt} | {elt | val for val in outcomes}\\n all_outcomes |= outcomes\\n \\n return len(all_outcomes)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # O(N^3) to try oring every possible subarray\\n \\n # key fact: for any number k , k | k = k\\n # also 0 | k = k for all k\\n \\n # one small optimization: scan through and delete any 0s or consecutive repeats\\n \\n # keep a list of or results s.t. or[i] = set of all possible results from oring subarrays that end at i\\n # then or[i] = [A[i]] + [A[i] | res for res in or[i - 1]] -> use a set to prune dups at each step\\n # you can just keep or[i] for most recent two i's\\n # \\n if not A:\\n return []\\n # [1, 2, 4]\\n # all_outcomes: {1, 2, 3, 4, 6, 7}\\n # outcomes: {2, 3}\\n # 4: temp {4, 6, 7}\\n \\n # todo(mywang): preprocess array and remove unnecessary stuff\\n for i in range(len(A))[::-1]:\\n if (i > 0 and A[i] == A[i - 1]):\\n A.pop(i)\\n all_outcomes = set([A[0]])\\n outcomes = set([A[0]])\\n for elt in A[1:]:\\n temp = {elt} | {elt | val for val in outcomes}\\n outcomes = temp\\n all_outcomes |= outcomes\\n \\n return len(all_outcomes)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n cur,res = set(),set()\\n for i in A:\\n cur = { i|j for j in cur} | {i}\\n res |= cur\\n return len(res)\\n# nums, n = set(), len(A)\\n# for i in range(n):\\n# num = A[i]\\n# for j in range(i, n):\\n# num |= A[j]\\n# nums.add(num)\\n# return len(nums)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n \\n \\n \\n # my solution ... 736 ms ... 100 % ... 40.6 MB ... 15 %\\n # time: O(nlogn)\\n # space: O(logn)\\n \\n res = set()\\n tot = set()\\n for a in A:\\n res = {prev | a for prev in res} | {a} # 得出以当前 a 结尾的 subarray\\n tot |= res # 把结果并入 tot\\n return len(tot)\\n \\n \\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n res = set()\\n \\n cur = set()\\n \\n for x in A:\\n cur = {x} | {x | y for y in cur}\\n res |= cur\\n \\n return len(res)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # Frontier Set \\n # Time complexity: O(NlogW), where N is the length of A, and W is the maximum size of elements in A.\\n # Space complexity: O(NlogW)\\n ans = set()\\n cur = {0}\\n for x in A:\\n cur = {x | y for y in cur} | {x}\\n ans |= cur\\n return len(ans)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # 12:57 8/24/20\\n \\n cur, res = set(),set()\\n for num in A:\\n cur = {num | j for j in cur} # | {num}\\n # cur = set(num | k for k in A)\\n cur.add(num)\\n res.update(cur)\\n \\n return len(res)\\n \\n \\n \\n # res, cur = set(), set()\\n # for i in A:\\n # cur = {i | j for j in cur} | {i}\\n # res |= cur\\n # return len(res)\\n\\n \\n \\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n self.res = set()\\n def helper(idx):\\n if idx < 0:\\n return set()\\n if idx==0:\\n self.res |= {A[idx]}\\n return {A[idx]}\\n val = {A[idx]}|{x|A[idx] for x in helper(idx-1)}\\n self.res |= val\\n return val\\n helper(len(A)-1)\\n return len(self.res)\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n result = set()\\n curr = set()\\n for num in A:\\n curr = {num | prev_num for prev_num in curr}\\n curr.add(num)\\n result.update(curr)\\n return len(result)\\n \\n \\n \\n# result = set()\\n# prev = set([0])\\n# for num in A:\\n# curr = set([num])\\n# for prev_num in prev:\\n# curr.add(prev_num | num)\\n# result |= curr\\n# prev = curr\\n# return len(result)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n my_set = set(A)\\n curr = 0\\n prev = set()\\n prev.add(A[0])\\n for num in A[1:]:\\n temp = set()\\n #curr |= num\\n #my_set.add(curr)\\n \\n for p in prev:\\n temp.add(num | p)\\n my_set.add(num | p)\\n \\n #print(temp)\\n prev = temp\\n prev.add(num)\\n\\n return len(my_set)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, A: List[int]) -> int:\\n # Frontier Set \\n # Time complexity: O(NlogW) = O(30N), where N is the length of A, and W is the maximum size of elements in A.\\n # Space complexity: O(NlogW)\\n ans = set()\\n cur = {0}\\n for x in A:\\n cur = {x | y for y in cur} | {x}\\n ans |= cur\\n return len(ans)\\n\",\n \"class Solution:\\n def subarrayBitwiseORs(self, arr: List[int]) -> int:\\n s = set()\\n prev = set()\\n prev.add(arr[0])\\n s.add(arr[0])\\n \\n for i in range(len(arr)):\\n temp = set()\\n for val in prev:\\n temp.add(val|arr[i])\\n s.add(val|arr[i])\\n \\n prev = temp\\n prev.add(arr[i])\\n s.add(arr[i])\\n \\n return len(s)\"\n]","isConversational":false},"n_sols":{"kind":"number","value":99,"string":"99"},"non_interactive_idx":{"kind":"list like","value":[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,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32,\n 33,\n 34,\n 35,\n 36,\n 37,\n 38,\n 39,\n 40,\n 41,\n 42,\n 43,\n 44,\n 45,\n 46,\n 47,\n 48,\n 49,\n 50,\n 51,\n 52,\n 53,\n 54,\n 55,\n 56,\n 57,\n 58,\n 59,\n 60,\n 61,\n 62,\n 63,\n 64,\n 65,\n 66,\n 67,\n 68,\n 69,\n 70,\n 71,\n 72,\n 73,\n 74,\n 75,\n 76,\n 77,\n 78,\n 79,\n 80,\n 81,\n 82,\n 83,\n 84,\n 85,\n 86,\n 87,\n 88,\n 89,\n 90,\n 91,\n 92,\n 93,\n 94,\n 95,\n 96,\n 97,\n 98\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[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,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":84,"cells":{"problem_id":{"kind":"number","value":219,"string":"219"},"question":{"kind":"string","value":"We are given hours, a list of the number of hours worked per day for a given employee.\nA day is considered to be a tiring day if and only if the number of hours worked is (strictly) greater than 8.\nA well-performing interval is an interval of days for which the number of tiring days is strictly larger than the number of non-tiring days.\nReturn the length of the longest well-performing interval.\n \nExample 1:\nInput: hours = [9,9,6,0,6,6,9]\nOutput: 3\nExplanation: The longest well-performing interval is [9,9,6].\n\n \nConstraints:\n\n1 <= hours.length <= 10000\n0 <= hours[i] <= 16"},"solutions":{"kind":"string","value":"[\"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n ans, count, seen = 0, 0, {}\\n for i, hour in enumerate(hours):\\n count = count + 1 if hour > 8 else count - 1\\n if count > 0:\\n ans = i + 1\\n else:\\n if count not in seen:\\n seen[count] = i\\n if count - 1 in seen:\\n ans = max(ans, i - seen[count - 1])\\n return ans\\n\\n \\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n ans, cum, seen = 0, 0, {}\\n for i, hour in enumerate(hours):\\n cum = cum + 1 if hour > 8 else cum - 1\\n if cum > 0:\\n ans = i + 1\\n else:\\n if cum not in seen:\\n seen[cum] = i\\n if cum - 1 in seen:\\n ans = max(ans, i - seen[cum - 1])\\n return ans\", \"class Solution:\\n def findslavedays(self,hours):\\n a=0\\n b=0\\n slave=0\\n nonslave=0\\n slavedays=0\\n while b<len(hours):\\n # print(a,b,slave,nonslave,slavedays)\\n if slave>nonslave:\\n slavedays=max(slavedays,b-a+slave-nonslave-1)\\n if a==b:\\n if hours[a]<=8:\\n nonslave+=1\\n else:\\n slave+=1\\n b+=1\\n continue\\n if slave<nonslave:\\n if hours[a]<=8:\\n nonslave-=1\\n else:\\n slave-=1\\n a+=1\\n elif slave>=nonslave:\\n if hours[b]<=8:\\n nonslave+=1\\n else:\\n slave+=1\\n b+=1\\n \\n if slave>nonslave:\\n slavedays=max(slavedays,b-a+slave-nonslave-1)\\n print(a,b)\\n while a>0:\\n a-=1\\n if hours[a]<=8:\\n nonslave+=1\\n else:\\n slave+=1\\n if slave>nonslave:\\n slavedays=max(slavedays,b-a+slave-nonslave-1)\\n if slave>nonslave:\\n slavedays=max(slavedays,b-a+slave-nonslave-1) \\n return slavedays\\n def longestWPI(self, hours: List[int]) -> int:\\n isslave=[-1]*len(hours)\\n sumslave=0\\n for i in range(len(isslave)):\\n if hours[i]>8:\\n isslave[i]=1\\n dic={}\\n maxslavedays=0\\n print(isslave)\\n for i in range(len(isslave)):\\n \\n sumslave=isslave[i]+sumslave\\n # print(sumslave)\\n if sumslave>0:\\n maxslavedays=max(maxslavedays,i+1)\\n\\n if sumslave not in dic:\\n dic[sumslave]=i\\n if sumslave-1 in dic:\\n \\n maxslavedays=max(maxslavedays,i-dic[sumslave-1])\\n print(dic)\\n return maxslavedays\\n \\n print(isslave,sumslave)\\n a=-1\\n b=0\\n dic={}\\n dic[0]=-1\\n for i in range(len(isslave)):\\n \\n if sumslave[i]>0:\\n b=i\\n maxslavedays=max(maxslavedays,b-a)\\n if sumslave[i]<=0:\\n a=i\\n return maxslavedays\\n \\n #for i in range(1,len(isslave)):\\n \\n return 0\\n slavelength1=self.findslavedays(hours)\\n slavelength2=self.findslavedays(hours[::-1])\\n return max(slavelength1,slavelength2)\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n score=0\\n dic={}\\n result=0\\n for i,hour in enumerate(hours):\\n if hour >8:\\n score +=1\\n else:\\n score -=1\\n\\n if score>0:\\n result = i+1\\n \\n if score not in dic:\\n dic[score] = i\\n \\n \\n if score-1 in dic:\\n result=max(result, i -dic[score-1])\\n return result \\n \\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n res = score = 0\\n seen = {}\\n for i in range(len(hours)):\\n h = hours[i]\\n score = score + 1 if h > 8 else score - 1\\n if score > 0:\\n res = i + 1\\n seen.setdefault(score, i)\\n if score - 1 in seen:\\n res = max(res, i - seen[score - 1])\\n return res\", \"import bisect\\n\\nclass Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n r, l, l_idx = [], [], []\\n d = []\\n for i, x in enumerate(hours):\\n if i == 0:\\n if x > 8:\\n d.append(1)\\n else:\\n d.append(-1)\\n else:\\n if x > 8:\\n d.append(d[-1] + 1)\\n else:\\n d.append(d[-1] - 1)\\n \\n for i, x in enumerate(d):\\n while len(r) > 0 and r[-1][0] <= x:\\n r.pop()\\n r.append((x, i))\\n if len(l) == 0 or x < l[-1]:\\n l.append(x)\\n l_idx.append(i)\\n \\n ans = 0\\n l.reverse()\\n l_idx.reverse()\\n \\n for x in r:\\n if x[0] > 0:\\n ans = max(ans, x[1] + 1)\\n else:\\n idx = bisect.bisect_right(l, x[0] - 1)\\n if idx >= 1:\\n ans = max(ans, x[1] - l_idx[idx - 1])\\n \\n return ans\\n \\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n nums = []\\n for hour in hours:\\n if hour > 8:\\n nums.append(1)\\n else:\\n nums.append(-1)\\n prevsum, sumv = [], 0\\n for num in nums:\\n sumv += num\\n prevsum.append(sumv)\\n stack = []\\n prevsum = [0] + prevsum\\n for i, val in enumerate(prevsum):\\n if not stack or prevsum[stack[-1]] > val:\\n stack.append(i)\\n i, res = len(prevsum) - 1, 0\\n while i >= 0:\\n while stack and prevsum[stack[-1]] < prevsum[i]:\\n res = max(res, i - stack[-1])\\n stack.pop()\\n i -= 1\\n return res\\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n d = {}\\n d[0] = -1\\n \\n res = 0\\n \\n for i in range(len(hours)):\\n hours[i] = (1 if hours[i] > 8 else -1) + (0 if i == 0 else hours[i-1])\\n \\n if hours[i] not in d:\\n d[hours[i]] = i\\n \\n if hours[i] > 0:\\n res = i+1\\n \\n target = hours[i] - 1\\n \\n if target in d:\\n res = max(res, i - d[target])\\n \\n print(hours)\\n print(d)\\n return res\\n \\n \\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n hours = [1 if i > 8 else -1 for i in hours]\\n hsh = {}\\n vals = [0 for i in hours]\\n sm = 0\\n for i in range(len(hours)-1, -1, -1):\\n sm += hours[i]\\n if sm > 0:\\n vals[i] = max(vals[i], len(hours) - i)\\n hours[i] = sm\\n smo = hours[i] - 1\\n if smo in hsh:\\n v = hsh[smo]\\n vals[i] = max(vals[i], v - i + vals[v])\\n \\n if hours[i] not in hsh:\\n hsh[hours[i]] = i\\n \\n return max(vals)\\n \\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n d = {}\\n P = [0] #prefix sum\\n F = [0 for i in range(len(hours))]\\n res = 0\\n for i in range(len(hours)):\\n P.append(P[-1] + (1 if hours[i] > 8 else -1))\\n if P[-1] > 0:\\n F[i] = i + 1\\n else:\\n s = d.get(P[-1] - 1, -1)\\n if s >= 0:\\n F[i] = max(F[i], i - s + F[s])\\n if P[-1] not in d:\\n d[P[-1]] = i\\n res = max(res, F[i]) \\n\\n return res\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n val = 0\\n result = 0\\n table = dict()\\n for i in range(len(hours)):\\n hour = hours[i]\\n if hour > 8:\\n val += 1\\n else:\\n val -= 1\\n \\n if val > 0:\\n result = i + 1\\n else:\\n if val not in table:\\n table[val] = i\\n if val - 1 in table:\\n dist = i - table[val - 1]\\n if dist > result:\\n result = dist\\n \\n return result\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n sum=0\\n ans=0\\n d={}\\n for i in range(len(hours)):\\n sum=sum+1 if hours[i] >8 else sum-1\\n if sum>0:\\n ans=i+1\\n else:\\n if sum not in d:\\n d[sum]=i\\n if sum-1 in d:\\n ans=max(ans,i-d[sum-1])\\n return ans\\n \\n \\n \\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n seen = {}\\n result,score = 0,0\\n for i,num in enumerate(hours):\\n score += 1 if num > 8 else -1\\n if score > 0:\\n result = i+1\\n elif score -1 in seen:\\n result = max(result, i - seen[score -1])\\n seen.setdefault(score, i)\\n return result\\n \\n \\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n \\n n = len(hours)\\n hashmap = dict()\\n total=0\\n res=0\\n\\n for i in range(n):\\n if hours[i]<=8:\\n total-=1\\n else:\\n total+=1\\n\\n if total>0:\\n res=i+1\\n continue\\n else:\\n if total not in hashmap:\\n hashmap[total] = i\\n if (total-1) in hashmap:\\n res = max(res, i-hashmap[total-1])\\n return res\\n \\n \\n \\n \\n \\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n # Convert array to 0 and 1s\\n bits = [1 if x > 8 else -1 for x in hours]\\n # Problem becomes: find the longest interval bits[i:j] where sum(bits[i:j]) > 0\\n # Get prefix sum of bits\\n pref = [0] * (len(bits)+1)\\n for i in range(1, len(bits)+1):\\n pref[i] = pref[i-1] + bits[i-1]\\n # Problem becomes: find the longest interval pref[i:j] where pref[j] > pref[i]\\n # Sort index of pref by value. Problem becomes: find the largest sorted_pref[j]-sorted_pref[i] where j > i\\n # Greedy to solve the new problem\\n ans = 0\\n min_val = len(bits) + 1\\n for y in sorted(enumerate(pref), key=lambda x: (x[1], -x[0])):\\n min_val = min(min_val, y[0])\\n ans = max(ans, y[0] - min_val)\\n return ans\\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n res = score = 0\\n seen = {}\\n for i, h in enumerate(hours):\\n score = score + 1 if h > 8 else score - 1\\n if score > 0:\\n res = i + 1\\n seen.setdefault(score, i)\\n if score - 1 in seen:\\n res = max(res, i - seen[score - 1])\\n return res\\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n \\n s = 0\\n seen = {}\\n ans = 0\\n \\n for i,h in enumerate(hours):\\n if h > 8:\\n s += 1\\n else:\\n s -= 1\\n \\n if s > 0:\\n ans = i+1\\n \\n seen.setdefault(s, i)\\n \\n if s-1 in seen:\\n ans = max(ans, i-seen[s-1])\\n \\n return ans\\n \\n \\n\\n\", \"class Solution:\\n def longestWPI(self, hours):\\n \\n res = score = 0\\n seen = {}\\n \\n for i, h in enumerate(hours):\\n print((i,h))\\n \\n if h > 8: score += 1\\n else: score -= 1\\n \\n if score > 0:\\n res = i + 1\\n seen.setdefault(score, i)\\n if score - 1 in seen:\\n res = max(res, i - seen[score - 1])\\n return res\\n \\n \\n#tiring_count = 1, not_tiring_count = 0, max_length = 1\\n#tiring_count = 2, not_tiring_count = 0, max_length = 2\\n#tiring_count = 2, not_tiring_count = 1, max_length = 3\\n#tiring_count = 2, not_tiring_count = 2, tiring_count = 0\\n#tiring_count = 0, nt = 3\\n#nt = 4\\n#tiring count += 1\\n \\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n hours = [1 if i > 8 else -1 for i in hours]\\n hsh = {hours[0]:0}\\n for i in range(1, len(hours)):\\n hours[i] += hours[i-1]\\n hsh[hours[i]] = i\\n \\n vals = [i+1 if hours[i] > 0 else 0 for i in range(len(hours))]\\n for i in range(len(hours)):\\n sm = hours[i] + 1\\n if sm in hsh:\\n v = hsh[sm]\\n vals[v] = max(vals[v], v-i+vals[i])\\n \\n return max(vals)\\n \\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n final = 0\\n score = 0\\n stack = {}\\n for i in range(len(hours)):\\n if hours[i] > 8 :\\n score += 1\\n else: \\n score -= 1\\n stack.setdefault(score,i)\\n if score > 0:\\n final = i + 1\\n if score - 1 in stack:\\n final = max(final, i - stack[score-1])\\n return final\\n \\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n L = [1 if i > 8 else -1 for i in hours]\\n K = [1 if i > 8 else -1 for i in hours]\\n mp = {}\\n for i in range(0, len(hours)):\\n if i > 0:\\n s = L[i] = L[i] + L[i - 1]\\n else:\\n s = L[i]\\n if s not in mp:\\n mp[s] = {i: True}\\n else:\\n mp[s][i] = True\\n \\n #print(K)\\n #print(L)\\n result = 0\\n for i, c in enumerate(L):\\n if L[-1] > L[i]:\\n result = max(result, len(K) - i - 1)\\n #print(\\\\\\\"ss\\\\\\\", i, result)\\n if 0 < L[i]:\\n result = max(result, i + 1) \\n #print(\\\\\\\"ddd\\\\\\\", i)\\n \\n if i > 0 and L[i - 1] + 1 in mp:\\n s = mp[L[i - 1] + 1]\\n #print(result, s, i)\\n result = max(result, max(s) - i + 1)\\n #result = max(result, i + 1 - min(s))\\n if L[i] - 1 in mp:\\n s = mp[L[i] - 1]\\n #print(result, s, i)\\n # result = max(result, max(s) - i + 1)\\n result = max(result, i - min(s))\\n #print(result, i)\\n return result\\n\\n \\n def longestWPI(self, hours: List[int]) -> int:\\n mp = {}\\n accu = 0\\n result = 0\\n for i, v in enumerate(hours):\\n accu += 1 if v > 8 else -1\\n # print(accu)\\n if accu > 0:\\n result = max(result, i + 1)\\n print((result, i))\\n if accu - 1 in mp:\\n result = max(result, i - mp[accu-1])\\n print((result, i))\\n if accu not in mp:\\n mp[accu] = i\\n return result\\n \\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n ret = 0\\n overall = 0\\n\\n totals = {}\\n for i, h in enumerate(hours):\\n if h > 8:\\n overall += 1 \\n else:\\n overall -= 1\\n \\n if overall > 0:\\n ret = i + 1\\n else:\\n if overall-1 in totals:\\n length = i - totals[overall-1]\\n ret = max(ret, length)\\n if overall not in totals:\\n totals[overall] = i\\n \\n return ret\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n pre_sum = [0]\\n for i, v in enumerate(hours):\\n hours[i] = 1 if v > 8 else -1\\n pre_sum.append(pre_sum[-1] + hours[i])\\n\\n dec_stack = [] # idx to pre_sum\\n for i, v in enumerate(pre_sum):\\n if len(dec_stack) == 0 or (len(dec_stack) > 0 and v < pre_sum[dec_stack[-1]]):\\n dec_stack.append(i)\\n max_r = -math.inf\\n max_width = 0\\n for r in range(len(pre_sum)-1, -1, -1):\\n n = pre_sum[r]\\n if n < max_r:\\n continue\\n max_r = n\\n while len(dec_stack) > 0:\\n # pop top < n\\n left_idx = dec_stack[-1]\\n if pre_sum[left_idx] < n:\\n dec_stack = dec_stack[0:-1]\\n max_width = max(max_width, r - left_idx)\\n else:\\n break\\n if len(dec_stack) == 0:\\n break\\n return max_width\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n hours = [1 if h > 8 else -1 for h in hours]\\n \\n down = {1: 0}\\n s = 0\\n ans = 0\\n for i,h in enumerate(hours):\\n if h < 0:\\n if s not in down:\\n down[s] = i\\n s += h\\n if s in down:\\n ans = max(ans, i - down[s])\\n if s > 0:\\n ans = max(ans, i+1)\\n return ans\\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n days = [1 if hour > 8 else -1 for hour in hours] #find longest strictly positive subarr\\n prefSums = days[:]\\n for i in range(1, len(hours)):\\n prefSums[i] = days[i] + prefSums[i - 1]\\n result = 0\\n prefixLookup = {}\\n for i in range(len(hours)):\\n sumToHere = prefSums[i] #longest answer ending here \\n if sumToHere >= 1:\\n result = max(result, i + 1)\\n else:\\n earlierPrefSumNeeded = sumToHere - 1\\n if earlierPrefSumNeeded in prefixLookup:\\n result = max(result, i - prefixLookup[earlierPrefSumNeeded])\\n if sumToHere not in prefixLookup:\\n prefixLookup[sumToHere] = i\\n return result\\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n lt = []\\n for hour in hours:\\n if hour > 8:\\n lt.append(1)\\n else:\\n lt.append(-1)\\n seen = {}\\n s = 0\\n mx = 0\\n for idx, ele in enumerate(lt):\\n s += ele\\n print((s, idx, mx))\\n if s > 0 : #atleast more 9\\n mx = max(mx, (idx+1))\\n else: \\n if (s-1) in seen:\\n i = seen[s-1]\\n mx = max(mx, idx-i)\\n if (s) not in seen:\\n seen[s] = idx\\n return mx \\n \\n \\n \\n\", \"# [9,9,6,0,6,6,9]\\n\\n# [1,1,-1,-1,-1,1]\\n# 1 2 1 0 -1 0\\n# [1,1,-1,-1,-1,1, 1]\\nclass Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n prefix = []\\n for hour in hours:\\n if hour > 8:\\n prefix.append(1)\\n else:\\n prefix.append(-1)\\n \\n curr_sum = 0\\n seen = {0:-1}\\n res = 0\\n \\n for i, num in enumerate(prefix):\\n curr_sum += num\\n if curr_sum > 0:\\n res = i + 1\\n \\n if curr_sum - 1 in seen:\\n res = max(res, i - seen[curr_sum - 1])\\n \\n if curr_sum not in seen:\\n seen[curr_sum] = i\\n \\n return res\\n \\n \\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n cur = res = 0\\n seen = {}\\n for i, h in enumerate(hours):\\n cur += 1 if h > 8 else -1\\n if cur > 0: res = max(res, i + 1)\\n else:\\n if cur - 1 in seen:\\n res = max(res, i - seen[cur - 1])\\n if cur not in seen:\\n seen[cur] = i\\n \\n return res\\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n n = len(hours)\\n hours = [1 if x > 8 else -1 for x in hours]\\n s = 0\\n idx = {}\\n ans = 0\\n for i in range(len(hours)):\\n s += hours[i]\\n if s > 0:\\n ans = i + 1\\n if s not in idx:\\n idx[s] = i\\n if (s - 1) in idx:\\n ans = max(ans, i - idx[s - 1])\\n return ans\", \"#https://leetcode.com/problems/longest-well-performing-interval/discuss/334565/JavaC%2B%2BPython-O(N)-Solution-Life-needs-996-and-669\\n \\nclass Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n seen = dict()\\n cnt = 0\\n res = 0\\n for idx, h in enumerate(hours):\\n if h>8:\\n cnt += 1\\n else:\\n cnt -= 1\\n if cnt>0:\\n res = idx+1\\n else:\\n if cnt-1 in seen:\\n res = max(res, idx-seen[cnt-1])\\n if cnt not in seen:\\n seen[cnt] = idx\\n return res\\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n Sum, ans = 0, 0\\n cache = {}\\n for i, n in enumerate(hours):\\n Sum = Sum + 1 if n > 8 else Sum - 1\\n if Sum > 0: ans = i + 1\\n if Sum-1 in cache:\\n ans = max(ans, i - cache[Sum-1])\\n cache.setdefault(Sum, i)\\n return ans\\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n hours = [1 if h > 8 else -1 for h in hours]\\n seen = {}\\n ans = cur = 0\\n for i, h in enumerate(hours):\\n cur += h\\n seen.setdefault(cur, i)\\n if cur > 0:\\n ans = i + 1\\n elif cur - 1 in seen:\\n ans = max(ans, i - seen[cur - 1])\\n return ans\\n \\n # hours = [1 if h > 8 else 0 for h in hours]\\n # acc = [0] + list(accumulate(hours))\\n # i, j = 0, len(hours) - 1\\n # cur = sum(hours)\\n # ans = 0\\n # while i <= j:\\n # if cur > (j - i + 1) // 2:\\n # return j - i + 1\\n \\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n res = score = 0\\n seen = {}\\n for i, h in enumerate(hours):\\n score = score + 1 if h > 8 else score - 1\\n if score > 0:\\n res = i + 1\\n seen.setdefault(score, i)\\n if score - 1 in seen:\\n res = max(res, i - seen[score - 1])\\n return res\", \"class Solution:\\n def longestWPI(self, h: List[int]) -> int:\\n n=len(h)\\n for i in range(n):\\n if h[i]>8:\\n h[i]=1\\n else:\\n h[i]=-1\\n #longest subarray with sum >0\\n pre=[0]*n \\n pre[0]=h[0]\\n maxi=0\\n for i in range(1,n):\\n pre[i]=pre[i-1]+h[i]\\n d={}\\n print(pre)\\n for x in range(n):\\n if pre[x]>0:\\n maxi=x+1\\n if d.get(pre[x]-1,-1)!=-1:\\n #print(i,d[pre[x]])\\n maxi=max(maxi,x-d[pre[x]-1])\\n if d.get(pre[x],-1)==-1:\\n d[pre[x]]=x\\n return maxi\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n i=0\\n prefixSum=0\\n existed={0:0}\\n res=0\\n while i<=len(hours)-1:\\n if hours[i]>=9:\\n prefixSum+=1\\n else:\\n prefixSum-=1\\n \\n if prefixSum not in existed:\\n existed[prefixSum]=i+1\\n if prefixSum-1 in existed:\\n res=max(res, i+1-existed[prefixSum-1])\\n if prefixSum>=1:\\n res=max(res, i+1)\\n i+=1\\n #print(existed)\\n return res\", \"class Solution:\\n # Use an index to store where\\n # score - 1 score\\n # |-----------|----------------|\\n # |--------1-------|\\n def longestWPI(self, hours: List[int]) -> int:\\n score, longest = 0, 0\\n index = {}\\n for i, n in enumerate(hours):\\n score += 1 if n > 8 else -1\\n if score > 0: # more tiring days so far\\n longest = max(longest, i + 1)\\n index.setdefault(score, i) # record the earliest presum with score\\n if score - 1 in index:\\n longest = max(longest, i - index[score - 1])\\n return longest\", \"import bisect\\n\\nclass Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n \\n starts = []\\n startIndexes = []\\n counts = [0] * len(hours)\\n \\n for i in range(len(hours)):\\n if i > 0:\\n counts[i] = counts[i - 1]\\n if hours[i] > 8:\\n counts[i] += 1\\n else:\\n counts[i] -= 1\\n \\n counts = [0] + counts\\n \\n for i in range(len(counts) - 1, -1 , -1):\\n numGood = counts[i]\\n while starts and starts[-1] >= numGood:\\n starts.pop()\\n startIndexes.pop()\\n \\n starts.append(numGood)\\n startIndexes.append(i)\\n \\n maxLen = 0\\n for i, c in enumerate(counts):\\n target = c - 1 \\n # pos1 = len(starts) - 1\\n # while pos1 >= 0 and starts[pos1] > target:\\n # pos1 -= 1\\n pos = bisect.bisect_right(starts, target)\\n if pos == len(starts) or starts[pos] > target:\\n pos -= 1\\n if pos >= 0:\\n lenHere = i - startIndexes[pos]\\n maxLen = max(maxLen, lenHere)\\n \\n return maxLen\\n \\n \\n \\n \\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n hoursLen = len(hours)\\n tDay = []\\n preSum = 0\\n preSumDict = {0:-1}\\n preSumKeys = [0]\\n ans = 0\\n \\n def insertAt(x):\\n l = 0\\n r = len(preSumKeys)-1\\n if x < preSumKeys[l]:\\n return 0\\n if x > preSumKeys[r]:\\n return r + 1\\n while r > l:\\n m = (r + l)//2\\n if preSumKeys[m] < x:\\n l = m + 1\\n else:\\n r = m\\n return l\\n \\n ans = 0\\n for i, hour in enumerate(hours):\\n if hour > 8:\\n tDay.append(1)\\n preSum += 1 \\n else:\\n tDay.append(-1)\\n preSum -= 1 \\n tempIndex = insertAt(preSum)\\n if preSum not in preSumDict:\\n preSumDict[preSum] = i\\n preSumKeys.insert(tempIndex, preSum)\\n if tempIndex > 0:\\n preSumDict[preSumKeys[tempIndex]] = min( preSumDict[preSumKeys[tempIndex-1]], preSumDict[preSumKeys[tempIndex]])\\n ans = max(ans, i - preSumDict[preSumKeys[tempIndex-1]])\\n # print(preSumKeys)\\n # print(preSum)\\n return ans\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n s = 0\\n maxLen = 0\\n seen = {}\\n for idx, hour in enumerate(hours):\\n if hour > 8:\\n s += 1\\n else:\\n s -=1\\n if s > 0:\\n res = idx + 1\\n maxLen = max(maxLen, res)\\n else:\\n if (s-1) in seen:\\n res = (idx - seen[s-1])\\n maxLen = max(maxLen, res)\\n \\n if s not in seen:\\n seen[s] = idx\\n return maxLen \\n \\n \\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n stack,res,first=0,0,{}\\n for day,i in enumerate(hours):\\n stack=stack+1 if i>8 else stack-1\\n first.setdefault(stack, day)\\n if stack>0:res=day+1\\n elif stack-1 in first:\\n res=max(res,day-first[stack-1])\\n return res\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n stack = []\\n ans = accu = 0\\n for i, h in enumerate(hours):\\n if h > 8:\\n accu += 1\\n else:\\n accu -= 1\\n if accu > 0:\\n ans = i + 1\\n else:\\n L, U = -1, len(stack)\\n while L + 1 < U:\\n m = (L + U) // 2\\n if stack[m][1] < accu:\\n U = m\\n else:\\n L = m\\n if U < len(stack):\\n ans = max(ans, i - stack[U][0])\\n if not stack or stack[-1][1] > accu:\\n stack.append((i, accu ))\\n return ans\\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n # ans, cum, seen = 0, 0, {}\\n # for i, hour in enumerate(hours):\\n # cum = cum + 1 if hour > 8 else cum - 1\\n # if cum > 0:\\n # ans = i + 1\\n # else:\\n # if cum not in seen:\\n # seen[cum] = i\\n # if cum - 1 in seen:\\n # ans = max(ans, i - seen[cum - 1])\\n # return ans\\n \\n res = score = 0\\n seen = {}\\n for i, h in enumerate(hours):\\n score = score + 1 if h > 8 else score - 1\\n if score > 0:\\n res = i + 1\\n seen.setdefault(score, i)\\n if score - 1 in seen:\\n res = max(res, i - seen[score - 1])\\n return res\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n total = res = 0\\n index = {}\\n for i, h in enumerate(hours):\\n total += 1 if h > 8 else -1\\n if total > 0:\\n res = i + 1\\n if total - 1 in index:\\n res = max(res, i - index[total-1])\\n index.setdefault(total, i)\\n \\n return res\\n \\n \\n\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n s = []\\n for i in hours:\\n if i > 8:\\n s.append(1)\\n else:\\n s.append(-1)\\n \\n n = len(s)\\n presum = [0]*(n+1)\\n for i in range(1,(n+1)):\\n presum[i] = presum[i-1] + s[i-1]\\n \\n stack = []\\n n = len(presum)\\n for i in range(n):\\n if not stack or presum[stack[-1]] > presum[i]:\\n stack.append(i)\\n res = 0\\n i = n-1\\n while i > res:\\n while stack and presum[stack[-1]] < presum[i]:\\n res = max(res,i-stack[-1])\\n stack.pop()\\n i -=1\\n return res\", \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n presum = 0\\n res = 0\\n mem = {}\\n for i, h in enumerate(hours):\\n presum += (1 if h > 8 else -1)\\n if presum > 0:\\n res = i + 1\\n else:\\n if presum - 1 in mem:\\n res = max(res, i - mem[presum - 1])\\n if presum not in mem:\\n mem[presum] = i\\n return res\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"longestWPI\", \"inputs\": [[[9, 9, 6, 0, 6, 6, 9]]], \"outputs\": [3]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/longest-well-performing-interval/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def longestWPI(self, hours: List[int]) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n ans, count, seen = 0, 0, {}\n for i, hour in enumerate(hours):\n count = count + 1 if hour > 8 else count - 1\n if count > 0:\n ans = i + 1\n else:\n if count not in seen:\n seen[count] = i\n if count - 1 in seen:\n ans = max(ans, i - seen[count - 1])\n return ans\n\n \n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n ans, cum, seen = 0, 0, {}\n for i, hour in enumerate(hours):\n cum = cum + 1 if hour > 8 else cum - 1\n if cum > 0:\n ans = i + 1\n else:\n if cum not in seen:\n seen[cum] = i\n if cum - 1 in seen:\n ans = max(ans, i - seen[cum - 1])\n return ans","class Solution:\n def findslavedays(self,hours):\n a=0\n b=0\n slave=0\n nonslave=0\n slavedays=0\n while b<len(hours):\n # print(a,b,slave,nonslave,slavedays)\n if slave>nonslave:\n slavedays=max(slavedays,b-a+slave-nonslave-1)\n if a==b:\n if hours[a]<=8:\n nonslave+=1\n else:\n slave+=1\n b+=1\n continue\n if slave<nonslave:\n if hours[a]<=8:\n nonslave-=1\n else:\n slave-=1\n a+=1\n elif slave>=nonslave:\n if hours[b]<=8:\n nonslave+=1\n else:\n slave+=1\n b+=1\n \n if slave>nonslave:\n slavedays=max(slavedays,b-a+slave-nonslave-1)\n print(a,b)\n while a>0:\n a-=1\n if hours[a]<=8:\n nonslave+=1\n else:\n slave+=1\n if slave>nonslave:\n slavedays=max(slavedays,b-a+slave-nonslave-1)\n if slave>nonslave:\n slavedays=max(slavedays,b-a+slave-nonslave-1) \n return slavedays\n def longestWPI(self, hours: List[int]) -> int:\n isslave=[-1]*len(hours)\n sumslave=0\n for i in range(len(isslave)):\n if hours[i]>8:\n isslave[i]=1\n dic={}\n maxslavedays=0\n print(isslave)\n for i in range(len(isslave)):\n \n sumslave=isslave[i]+sumslave\n # print(sumslave)\n if sumslave>0:\n maxslavedays=max(maxslavedays,i+1)\n\n if sumslave not in dic:\n dic[sumslave]=i\n if sumslave-1 in dic:\n \n maxslavedays=max(maxslavedays,i-dic[sumslave-1])\n print(dic)\n return maxslavedays\n \n print(isslave,sumslave)\n a=-1\n b=0\n dic={}\n dic[0]=-1\n for i in range(len(isslave)):\n \n if sumslave[i]>0:\n b=i\n maxslavedays=max(maxslavedays,b-a)\n if sumslave[i]<=0:\n a=i\n return maxslavedays\n \n #for i in range(1,len(isslave)):\n \n return 0\n slavelength1=self.findslavedays(hours)\n slavelength2=self.findslavedays(hours[::-1])\n return max(slavelength1,slavelength2)","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n score=0\n dic={}\n result=0\n for i,hour in enumerate(hours):\n if hour >8:\n score +=1\n else:\n score -=1\n\n if score>0:\n result = i+1\n \n if score not in dic:\n dic[score] = i\n \n \n if score-1 in dic:\n result=max(result, i -dic[score-1])\n return result \n \n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n res = score = 0\n seen = {}\n for i in range(len(hours)):\n h = hours[i]\n score = score + 1 if h > 8 else score - 1\n if score > 0:\n res = i + 1\n seen.setdefault(score, i)\n if score - 1 in seen:\n res = max(res, i - seen[score - 1])\n return res","import bisect\n\nclass Solution:\n def longestWPI(self, hours: List[int]) -> int:\n r, l, l_idx = [], [], []\n d = []\n for i, x in enumerate(hours):\n if i == 0:\n if x > 8:\n d.append(1)\n else:\n d.append(-1)\n else:\n if x > 8:\n d.append(d[-1] + 1)\n else:\n d.append(d[-1] - 1)\n \n for i, x in enumerate(d):\n while len(r) > 0 and r[-1][0] <= x:\n r.pop()\n r.append((x, i))\n if len(l) == 0 or x < l[-1]:\n l.append(x)\n l_idx.append(i)\n \n ans = 0\n l.reverse()\n l_idx.reverse()\n \n for x in r:\n if x[0] > 0:\n ans = max(ans, x[1] + 1)\n else:\n idx = bisect.bisect_right(l, x[0] - 1)\n if idx >= 1:\n ans = max(ans, x[1] - l_idx[idx - 1])\n \n return ans\n \n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n nums = []\n for hour in hours:\n if hour > 8:\n nums.append(1)\n else:\n nums.append(-1)\n prevsum, sumv = [], 0\n for num in nums:\n sumv += num\n prevsum.append(sumv)\n stack = []\n prevsum = [0] + prevsum\n for i, val in enumerate(prevsum):\n if not stack or prevsum[stack[-1]] > val:\n stack.append(i)\n i, res = len(prevsum) - 1, 0\n while i >= 0:\n while stack and prevsum[stack[-1]] < prevsum[i]:\n res = max(res, i - stack[-1])\n stack.pop()\n i -= 1\n return res\n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n d = {}\n d[0] = -1\n \n res = 0\n \n for i in range(len(hours)):\n hours[i] = (1 if hours[i] > 8 else -1) + (0 if i == 0 else hours[i-1])\n \n if hours[i] not in d:\n d[hours[i]] = i\n \n if hours[i] > 0:\n res = i+1\n \n target = hours[i] - 1\n \n if target in d:\n res = max(res, i - d[target])\n \n print(hours)\n print(d)\n return res\n \n \n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n hours = [1 if i > 8 else -1 for i in hours]\n hsh = {}\n vals = [0 for i in hours]\n sm = 0\n for i in range(len(hours)-1, -1, -1):\n sm += hours[i]\n if sm > 0:\n vals[i] = max(vals[i], len(hours) - i)\n hours[i] = sm\n smo = hours[i] - 1\n if smo in hsh:\n v = hsh[smo]\n vals[i] = max(vals[i], v - i + vals[v])\n \n if hours[i] not in hsh:\n hsh[hours[i]] = i\n \n return max(vals)\n \n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n d = {}\n P = [0] #prefix sum\n F = [0 for i in range(len(hours))]\n res = 0\n for i in range(len(hours)):\n P.append(P[-1] + (1 if hours[i] > 8 else -1))\n if P[-1] > 0:\n F[i] = i + 1\n else:\n s = d.get(P[-1] - 1, -1)\n if s >= 0:\n F[i] = max(F[i], i - s + F[s])\n if P[-1] not in d:\n d[P[-1]] = i\n res = max(res, F[i]) \n\n return res","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n val = 0\n result = 0\n table = dict()\n for i in range(len(hours)):\n hour = hours[i]\n if hour > 8:\n val += 1\n else:\n val -= 1\n \n if val > 0:\n result = i + 1\n else:\n if val not in table:\n table[val] = i\n if val - 1 in table:\n dist = i - table[val - 1]\n if dist > result:\n result = dist\n \n return result","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n sum=0\n ans=0\n d={}\n for i in range(len(hours)):\n sum=sum+1 if hours[i] >8 else sum-1\n if sum>0:\n ans=i+1\n else:\n if sum not in d:\n d[sum]=i\n if sum-1 in d:\n ans=max(ans,i-d[sum-1])\n return ans\n \n \n \n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n seen = {}\n result,score = 0,0\n for i,num in enumerate(hours):\n score += 1 if num > 8 else -1\n if score > 0:\n result = i+1\n elif score -1 in seen:\n result = max(result, i - seen[score -1])\n seen.setdefault(score, i)\n return result\n \n \n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n \n n = len(hours)\n hashmap = dict()\n total=0\n res=0\n\n for i in range(n):\n if hours[i]<=8:\n total-=1\n else:\n total+=1\n\n if total>0:\n res=i+1\n continue\n else:\n if total not in hashmap:\n hashmap[total] = i\n if (total-1) in hashmap:\n res = max(res, i-hashmap[total-1])\n return res\n \n \n \n \n \n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n # Convert array to 0 and 1s\n bits = [1 if x > 8 else -1 for x in hours]\n # Problem becomes: find the longest interval bits[i:j] where sum(bits[i:j]) > 0\n # Get prefix sum of bits\n pref = [0] * (len(bits)+1)\n for i in range(1, len(bits)+1):\n pref[i] = pref[i-1] + bits[i-1]\n # Problem becomes: find the longest interval pref[i:j] where pref[j] > pref[i]\n # Sort index of pref by value. Problem becomes: find the largest sorted_pref[j]-sorted_pref[i] where j > i\n # Greedy to solve the new problem\n ans = 0\n min_val = len(bits) + 1\n for y in sorted(enumerate(pref), key=lambda x: (x[1], -x[0])):\n min_val = min(min_val, y[0])\n ans = max(ans, y[0] - min_val)\n return ans\n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n res = score = 0\n seen = {}\n for i, h in enumerate(hours):\n score = score + 1 if h > 8 else score - 1\n if score > 0:\n res = i + 1\n seen.setdefault(score, i)\n if score - 1 in seen:\n res = max(res, i - seen[score - 1])\n return res\n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n \n s = 0\n seen = {}\n ans = 0\n \n for i,h in enumerate(hours):\n if h > 8:\n s += 1\n else:\n s -= 1\n \n if s > 0:\n ans = i+1\n \n seen.setdefault(s, i)\n \n if s-1 in seen:\n ans = max(ans, i-seen[s-1])\n \n return ans\n \n \n\n","class Solution:\n def longestWPI(self, hours):\n \n res = score = 0\n seen = {}\n \n for i, h in enumerate(hours):\n print((i,h))\n \n if h > 8: score += 1\n else: score -= 1\n \n if score > 0:\n res = i + 1\n seen.setdefault(score, i)\n if score - 1 in seen:\n res = max(res, i - seen[score - 1])\n return res\n \n \n#tiring_count = 1, not_tiring_count = 0, max_length = 1\n#tiring_count = 2, not_tiring_count = 0, max_length = 2\n#tiring_count = 2, not_tiring_count = 1, max_length = 3\n#tiring_count = 2, not_tiring_count = 2, tiring_count = 0\n#tiring_count = 0, nt = 3\n#nt = 4\n#tiring count += 1\n \n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n hours = [1 if i > 8 else -1 for i in hours]\n hsh = {hours[0]:0}\n for i in range(1, len(hours)):\n hours[i] += hours[i-1]\n hsh[hours[i]] = i\n \n vals = [i+1 if hours[i] > 0 else 0 for i in range(len(hours))]\n for i in range(len(hours)):\n sm = hours[i] + 1\n if sm in hsh:\n v = hsh[sm]\n vals[v] = max(vals[v], v-i+vals[i])\n \n return max(vals)\n \n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n final = 0\n score = 0\n stack = {}\n for i in range(len(hours)):\n if hours[i] > 8 :\n score += 1\n else: \n score -= 1\n stack.setdefault(score,i)\n if score > 0:\n final = i + 1\n if score - 1 in stack:\n final = max(final, i - stack[score-1])\n return final\n \n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n L = [1 if i > 8 else -1 for i in hours]\n K = [1 if i > 8 else -1 for i in hours]\n mp = {}\n for i in range(0, len(hours)):\n if i > 0:\n s = L[i] = L[i] + L[i - 1]\n else:\n s = L[i]\n if s not in mp:\n mp[s] = {i: True}\n else:\n mp[s][i] = True\n \n #print(K)\n #print(L)\n result = 0\n for i, c in enumerate(L):\n if L[-1] > L[i]:\n result = max(result, len(K) - i - 1)\n #print(\\\"ss\\\", i, result)\n if 0 < L[i]:\n result = max(result, i + 1) \n #print(\\\"ddd\\\", i)\n \n if i > 0 and L[i - 1] + 1 in mp:\n s = mp[L[i - 1] + 1]\n #print(result, s, i)\n result = max(result, max(s) - i + 1)\n #result = max(result, i + 1 - min(s))\n if L[i] - 1 in mp:\n s = mp[L[i] - 1]\n #print(result, s, i)\n # result = max(result, max(s) - i + 1)\n result = max(result, i - min(s))\n #print(result, i)\n return result\n\n \n def longestWPI(self, hours: List[int]) -> int:\n mp = {}\n accu = 0\n result = 0\n for i, v in enumerate(hours):\n accu += 1 if v > 8 else -1\n # print(accu)\n if accu > 0:\n result = max(result, i + 1)\n print((result, i))\n if accu - 1 in mp:\n result = max(result, i - mp[accu-1])\n print((result, i))\n if accu not in mp:\n mp[accu] = i\n return result\n \n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n ret = 0\n overall = 0\n\n totals = {}\n for i, h in enumerate(hours):\n if h > 8:\n overall += 1 \n else:\n overall -= 1\n \n if overall > 0:\n ret = i + 1\n else:\n if overall-1 in totals:\n length = i - totals[overall-1]\n ret = max(ret, length)\n if overall not in totals:\n totals[overall] = i\n \n return ret","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n pre_sum = [0]\n for i, v in enumerate(hours):\n hours[i] = 1 if v > 8 else -1\n pre_sum.append(pre_sum[-1] + hours[i])\n\n dec_stack = [] # idx to pre_sum\n for i, v in enumerate(pre_sum):\n if len(dec_stack) == 0 or (len(dec_stack) > 0 and v < pre_sum[dec_stack[-1]]):\n dec_stack.append(i)\n max_r = -math.inf\n max_width = 0\n for r in range(len(pre_sum)-1, -1, -1):\n n = pre_sum[r]\n if n < max_r:\n continue\n max_r = n\n while len(dec_stack) > 0:\n # pop top < n\n left_idx = dec_stack[-1]\n if pre_sum[left_idx] < n:\n dec_stack = dec_stack[0:-1]\n max_width = max(max_width, r - left_idx)\n else:\n break\n if len(dec_stack) == 0:\n break\n return max_width","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n hours = [1 if h > 8 else -1 for h in hours]\n \n down = {1: 0}\n s = 0\n ans = 0\n for i,h in enumerate(hours):\n if h < 0:\n if s not in down:\n down[s] = i\n s += h\n if s in down:\n ans = max(ans, i - down[s])\n if s > 0:\n ans = max(ans, i+1)\n return ans\n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n days = [1 if hour > 8 else -1 for hour in hours] #find longest strictly positive subarr\n prefSums = days[:]\n for i in range(1, len(hours)):\n prefSums[i] = days[i] + prefSums[i - 1]\n result = 0\n prefixLookup = {}\n for i in range(len(hours)):\n sumToHere = prefSums[i] #longest answer ending here \n if sumToHere >= 1:\n result = max(result, i + 1)\n else:\n earlierPrefSumNeeded = sumToHere - 1\n if earlierPrefSumNeeded in prefixLookup:\n result = max(result, i - prefixLookup[earlierPrefSumNeeded])\n if sumToHere not in prefixLookup:\n prefixLookup[sumToHere] = i\n return result\n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n lt = []\n for hour in hours:\n if hour > 8:\n lt.append(1)\n else:\n lt.append(-1)\n seen = {}\n s = 0\n mx = 0\n for idx, ele in enumerate(lt):\n s += ele\n print((s, idx, mx))\n if s > 0 : #atleast more 9\n mx = max(mx, (idx+1))\n else: \n if (s-1) in seen:\n i = seen[s-1]\n mx = max(mx, idx-i)\n if (s) not in seen:\n seen[s] = idx\n return mx \n \n \n \n","# [9,9,6,0,6,6,9]\n\n# [1,1,-1,-1,-1,1]\n# 1 2 1 0 -1 0\n# [1,1,-1,-1,-1,1, 1]\nclass Solution:\n def longestWPI(self, hours: List[int]) -> int:\n prefix = []\n for hour in hours:\n if hour > 8:\n prefix.append(1)\n else:\n prefix.append(-1)\n \n curr_sum = 0\n seen = {0:-1}\n res = 0\n \n for i, num in enumerate(prefix):\n curr_sum += num\n if curr_sum > 0:\n res = i + 1\n \n if curr_sum - 1 in seen:\n res = max(res, i - seen[curr_sum - 1])\n \n if curr_sum not in seen:\n seen[curr_sum] = i\n \n return res\n \n \n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n cur = res = 0\n seen = {}\n for i, h in enumerate(hours):\n cur += 1 if h > 8 else -1\n if cur > 0: res = max(res, i + 1)\n else:\n if cur - 1 in seen:\n res = max(res, i - seen[cur - 1])\n if cur not in seen:\n seen[cur] = i\n \n return res\n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n n = len(hours)\n hours = [1 if x > 8 else -1 for x in hours]\n s = 0\n idx = {}\n ans = 0\n for i in range(len(hours)):\n s += hours[i]\n if s > 0:\n ans = i + 1\n if s not in idx:\n idx[s] = i\n if (s - 1) in idx:\n ans = max(ans, i - idx[s - 1])\n return ans","#https://leetcode.com/problems/longest-well-performing-interval/discuss/334565/JavaC%2B%2BPython-O(N)-Solution-Life-needs-996-and-669\n \nclass Solution:\n def longestWPI(self, hours: List[int]) -> int:\n seen = dict()\n cnt = 0\n res = 0\n for idx, h in enumerate(hours):\n if h>8:\n cnt += 1\n else:\n cnt -= 1\n if cnt>0:\n res = idx+1\n else:\n if cnt-1 in seen:\n res = max(res, idx-seen[cnt-1])\n if cnt not in seen:\n seen[cnt] = idx\n return res\n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n Sum, ans = 0, 0\n cache = {}\n for i, n in enumerate(hours):\n Sum = Sum + 1 if n > 8 else Sum - 1\n if Sum > 0: ans = i + 1\n if Sum-1 in cache:\n ans = max(ans, i - cache[Sum-1])\n cache.setdefault(Sum, i)\n return ans\n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n hours = [1 if h > 8 else -1 for h in hours]\n seen = {}\n ans = cur = 0\n for i, h in enumerate(hours):\n cur += h\n seen.setdefault(cur, i)\n if cur > 0:\n ans = i + 1\n elif cur - 1 in seen:\n ans = max(ans, i - seen[cur - 1])\n return ans\n \n # hours = [1 if h > 8 else 0 for h in hours]\n # acc = [0] + list(accumulate(hours))\n # i, j = 0, len(hours) - 1\n # cur = sum(hours)\n # ans = 0\n # while i <= j:\n # if cur > (j - i + 1) // 2:\n # return j - i + 1\n \n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n res = score = 0\n seen = {}\n for i, h in enumerate(hours):\n score = score + 1 if h > 8 else score - 1\n if score > 0:\n res = i + 1\n seen.setdefault(score, i)\n if score - 1 in seen:\n res = max(res, i - seen[score - 1])\n return res","class Solution:\n def longestWPI(self, h: List[int]) -> int:\n n=len(h)\n for i in range(n):\n if h[i]>8:\n h[i]=1\n else:\n h[i]=-1\n #longest subarray with sum >0\n pre=[0]*n \n pre[0]=h[0]\n maxi=0\n for i in range(1,n):\n pre[i]=pre[i-1]+h[i]\n d={}\n print(pre)\n for x in range(n):\n if pre[x]>0:\n maxi=x+1\n if d.get(pre[x]-1,-1)!=-1:\n #print(i,d[pre[x]])\n maxi=max(maxi,x-d[pre[x]-1])\n if d.get(pre[x],-1)==-1:\n d[pre[x]]=x\n return maxi","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n i=0\n prefixSum=0\n existed={0:0}\n res=0\n while i<=len(hours)-1:\n if hours[i]>=9:\n prefixSum+=1\n else:\n prefixSum-=1\n \n if prefixSum not in existed:\n existed[prefixSum]=i+1\n if prefixSum-1 in existed:\n res=max(res, i+1-existed[prefixSum-1])\n if prefixSum>=1:\n res=max(res, i+1)\n i+=1\n #print(existed)\n return res","class Solution:\n # Use an index to store where\n # score - 1 score\n # |-----------|----------------|\n # |--------1-------|\n def longestWPI(self, hours: List[int]) -> int:\n score, longest = 0, 0\n index = {}\n for i, n in enumerate(hours):\n score += 1 if n > 8 else -1\n if score > 0: # more tiring days so far\n longest = max(longest, i + 1)\n index.setdefault(score, i) # record the earliest presum with score\n if score - 1 in index:\n longest = max(longest, i - index[score - 1])\n return longest","import bisect\n\nclass Solution:\n def longestWPI(self, hours: List[int]) -> int:\n \n starts = []\n startIndexes = []\n counts = [0] * len(hours)\n \n for i in range(len(hours)):\n if i > 0:\n counts[i] = counts[i - 1]\n if hours[i] > 8:\n counts[i] += 1\n else:\n counts[i] -= 1\n \n counts = [0] + counts\n \n for i in range(len(counts) - 1, -1 , -1):\n numGood = counts[i]\n while starts and starts[-1] >= numGood:\n starts.pop()\n startIndexes.pop()\n \n starts.append(numGood)\n startIndexes.append(i)\n \n maxLen = 0\n for i, c in enumerate(counts):\n target = c - 1 \n # pos1 = len(starts) - 1\n # while pos1 >= 0 and starts[pos1] > target:\n # pos1 -= 1\n pos = bisect.bisect_right(starts, target)\n if pos == len(starts) or starts[pos] > target:\n pos -= 1\n if pos >= 0:\n lenHere = i - startIndexes[pos]\n maxLen = max(maxLen, lenHere)\n \n return maxLen\n \n \n \n \n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n hoursLen = len(hours)\n tDay = []\n preSum = 0\n preSumDict = {0:-1}\n preSumKeys = [0]\n ans = 0\n \n def insertAt(x):\n l = 0\n r = len(preSumKeys)-1\n if x < preSumKeys[l]:\n return 0\n if x > preSumKeys[r]:\n return r + 1\n while r > l:\n m = (r + l)//2\n if preSumKeys[m] < x:\n l = m + 1\n else:\n r = m\n return l\n \n ans = 0\n for i, hour in enumerate(hours):\n if hour > 8:\n tDay.append(1)\n preSum += 1 \n else:\n tDay.append(-1)\n preSum -= 1 \n tempIndex = insertAt(preSum)\n if preSum not in preSumDict:\n preSumDict[preSum] = i\n preSumKeys.insert(tempIndex, preSum)\n if tempIndex > 0:\n preSumDict[preSumKeys[tempIndex]] = min( preSumDict[preSumKeys[tempIndex-1]], preSumDict[preSumKeys[tempIndex]])\n ans = max(ans, i - preSumDict[preSumKeys[tempIndex-1]])\n # print(preSumKeys)\n # print(preSum)\n return ans","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n s = 0\n maxLen = 0\n seen = {}\n for idx, hour in enumerate(hours):\n if hour > 8:\n s += 1\n else:\n s -=1\n if s > 0:\n res = idx + 1\n maxLen = max(maxLen, res)\n else:\n if (s-1) in seen:\n res = (idx - seen[s-1])\n maxLen = max(maxLen, res)\n \n if s not in seen:\n seen[s] = idx\n return maxLen \n \n \n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n stack,res,first=0,0,{}\n for day,i in enumerate(hours):\n stack=stack+1 if i>8 else stack-1\n first.setdefault(stack, day)\n if stack>0:res=day+1\n elif stack-1 in first:\n res=max(res,day-first[stack-1])\n return res","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n stack = []\n ans = accu = 0\n for i, h in enumerate(hours):\n if h > 8:\n accu += 1\n else:\n accu -= 1\n if accu > 0:\n ans = i + 1\n else:\n L, U = -1, len(stack)\n while L + 1 < U:\n m = (L + U) // 2\n if stack[m][1] < accu:\n U = m\n else:\n L = m\n if U < len(stack):\n ans = max(ans, i - stack[U][0])\n if not stack or stack[-1][1] > accu:\n stack.append((i, accu ))\n return ans\n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n # ans, cum, seen = 0, 0, {}\n # for i, hour in enumerate(hours):\n # cum = cum + 1 if hour > 8 else cum - 1\n # if cum > 0:\n # ans = i + 1\n # else:\n # if cum not in seen:\n # seen[cum] = i\n # if cum - 1 in seen:\n # ans = max(ans, i - seen[cum - 1])\n # return ans\n \n res = score = 0\n seen = {}\n for i, h in enumerate(hours):\n score = score + 1 if h > 8 else score - 1\n if score > 0:\n res = i + 1\n seen.setdefault(score, i)\n if score - 1 in seen:\n res = max(res, i - seen[score - 1])\n return res","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n total = res = 0\n index = {}\n for i, h in enumerate(hours):\n total += 1 if h > 8 else -1\n if total > 0:\n res = i + 1\n if total - 1 in index:\n res = max(res, i - index[total-1])\n index.setdefault(total, i)\n \n return res\n \n \n","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n s = []\n for i in hours:\n if i > 8:\n s.append(1)\n else:\n s.append(-1)\n \n n = len(s)\n presum = [0]*(n+1)\n for i in range(1,(n+1)):\n presum[i] = presum[i-1] + s[i-1]\n \n stack = []\n n = len(presum)\n for i in range(n):\n if not stack or presum[stack[-1]] > presum[i]:\n stack.append(i)\n res = 0\n i = n-1\n while i > res:\n while stack and presum[stack[-1]] < presum[i]:\n res = max(res,i-stack[-1])\n stack.pop()\n i -=1\n return res","class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n presum = 0\n res = 0\n mem = {}\n for i, h in enumerate(hours):\n presum += (1 if h > 8 else -1)\n if presum > 0:\n res = i + 1\n else:\n if presum - 1 in mem:\n res = max(res, i - mem[presum - 1])\n if presum not in mem:\n mem[presum] = i\n return res"],"string":"[\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n ans, count, seen = 0, 0, {}\\n for i, hour in enumerate(hours):\\n count = count + 1 if hour > 8 else count - 1\\n if count > 0:\\n ans = i + 1\\n else:\\n if count not in seen:\\n seen[count] = i\\n if count - 1 in seen:\\n ans = max(ans, i - seen[count - 1])\\n return ans\\n\\n \\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n ans, cum, seen = 0, 0, {}\\n for i, hour in enumerate(hours):\\n cum = cum + 1 if hour > 8 else cum - 1\\n if cum > 0:\\n ans = i + 1\\n else:\\n if cum not in seen:\\n seen[cum] = i\\n if cum - 1 in seen:\\n ans = max(ans, i - seen[cum - 1])\\n return ans\",\n \"class Solution:\\n def findslavedays(self,hours):\\n a=0\\n b=0\\n slave=0\\n nonslave=0\\n slavedays=0\\n while b<len(hours):\\n # print(a,b,slave,nonslave,slavedays)\\n if slave>nonslave:\\n slavedays=max(slavedays,b-a+slave-nonslave-1)\\n if a==b:\\n if hours[a]<=8:\\n nonslave+=1\\n else:\\n slave+=1\\n b+=1\\n continue\\n if slave<nonslave:\\n if hours[a]<=8:\\n nonslave-=1\\n else:\\n slave-=1\\n a+=1\\n elif slave>=nonslave:\\n if hours[b]<=8:\\n nonslave+=1\\n else:\\n slave+=1\\n b+=1\\n \\n if slave>nonslave:\\n slavedays=max(slavedays,b-a+slave-nonslave-1)\\n print(a,b)\\n while a>0:\\n a-=1\\n if hours[a]<=8:\\n nonslave+=1\\n else:\\n slave+=1\\n if slave>nonslave:\\n slavedays=max(slavedays,b-a+slave-nonslave-1)\\n if slave>nonslave:\\n slavedays=max(slavedays,b-a+slave-nonslave-1) \\n return slavedays\\n def longestWPI(self, hours: List[int]) -> int:\\n isslave=[-1]*len(hours)\\n sumslave=0\\n for i in range(len(isslave)):\\n if hours[i]>8:\\n isslave[i]=1\\n dic={}\\n maxslavedays=0\\n print(isslave)\\n for i in range(len(isslave)):\\n \\n sumslave=isslave[i]+sumslave\\n # print(sumslave)\\n if sumslave>0:\\n maxslavedays=max(maxslavedays,i+1)\\n\\n if sumslave not in dic:\\n dic[sumslave]=i\\n if sumslave-1 in dic:\\n \\n maxslavedays=max(maxslavedays,i-dic[sumslave-1])\\n print(dic)\\n return maxslavedays\\n \\n print(isslave,sumslave)\\n a=-1\\n b=0\\n dic={}\\n dic[0]=-1\\n for i in range(len(isslave)):\\n \\n if sumslave[i]>0:\\n b=i\\n maxslavedays=max(maxslavedays,b-a)\\n if sumslave[i]<=0:\\n a=i\\n return maxslavedays\\n \\n #for i in range(1,len(isslave)):\\n \\n return 0\\n slavelength1=self.findslavedays(hours)\\n slavelength2=self.findslavedays(hours[::-1])\\n return max(slavelength1,slavelength2)\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n score=0\\n dic={}\\n result=0\\n for i,hour in enumerate(hours):\\n if hour >8:\\n score +=1\\n else:\\n score -=1\\n\\n if score>0:\\n result = i+1\\n \\n if score not in dic:\\n dic[score] = i\\n \\n \\n if score-1 in dic:\\n result=max(result, i -dic[score-1])\\n return result \\n \\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n res = score = 0\\n seen = {}\\n for i in range(len(hours)):\\n h = hours[i]\\n score = score + 1 if h > 8 else score - 1\\n if score > 0:\\n res = i + 1\\n seen.setdefault(score, i)\\n if score - 1 in seen:\\n res = max(res, i - seen[score - 1])\\n return res\",\n \"import bisect\\n\\nclass Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n r, l, l_idx = [], [], []\\n d = []\\n for i, x in enumerate(hours):\\n if i == 0:\\n if x > 8:\\n d.append(1)\\n else:\\n d.append(-1)\\n else:\\n if x > 8:\\n d.append(d[-1] + 1)\\n else:\\n d.append(d[-1] - 1)\\n \\n for i, x in enumerate(d):\\n while len(r) > 0 and r[-1][0] <= x:\\n r.pop()\\n r.append((x, i))\\n if len(l) == 0 or x < l[-1]:\\n l.append(x)\\n l_idx.append(i)\\n \\n ans = 0\\n l.reverse()\\n l_idx.reverse()\\n \\n for x in r:\\n if x[0] > 0:\\n ans = max(ans, x[1] + 1)\\n else:\\n idx = bisect.bisect_right(l, x[0] - 1)\\n if idx >= 1:\\n ans = max(ans, x[1] - l_idx[idx - 1])\\n \\n return ans\\n \\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n nums = []\\n for hour in hours:\\n if hour > 8:\\n nums.append(1)\\n else:\\n nums.append(-1)\\n prevsum, sumv = [], 0\\n for num in nums:\\n sumv += num\\n prevsum.append(sumv)\\n stack = []\\n prevsum = [0] + prevsum\\n for i, val in enumerate(prevsum):\\n if not stack or prevsum[stack[-1]] > val:\\n stack.append(i)\\n i, res = len(prevsum) - 1, 0\\n while i >= 0:\\n while stack and prevsum[stack[-1]] < prevsum[i]:\\n res = max(res, i - stack[-1])\\n stack.pop()\\n i -= 1\\n return res\\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n d = {}\\n d[0] = -1\\n \\n res = 0\\n \\n for i in range(len(hours)):\\n hours[i] = (1 if hours[i] > 8 else -1) + (0 if i == 0 else hours[i-1])\\n \\n if hours[i] not in d:\\n d[hours[i]] = i\\n \\n if hours[i] > 0:\\n res = i+1\\n \\n target = hours[i] - 1\\n \\n if target in d:\\n res = max(res, i - d[target])\\n \\n print(hours)\\n print(d)\\n return res\\n \\n \\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n hours = [1 if i > 8 else -1 for i in hours]\\n hsh = {}\\n vals = [0 for i in hours]\\n sm = 0\\n for i in range(len(hours)-1, -1, -1):\\n sm += hours[i]\\n if sm > 0:\\n vals[i] = max(vals[i], len(hours) - i)\\n hours[i] = sm\\n smo = hours[i] - 1\\n if smo in hsh:\\n v = hsh[smo]\\n vals[i] = max(vals[i], v - i + vals[v])\\n \\n if hours[i] not in hsh:\\n hsh[hours[i]] = i\\n \\n return max(vals)\\n \\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n d = {}\\n P = [0] #prefix sum\\n F = [0 for i in range(len(hours))]\\n res = 0\\n for i in range(len(hours)):\\n P.append(P[-1] + (1 if hours[i] > 8 else -1))\\n if P[-1] > 0:\\n F[i] = i + 1\\n else:\\n s = d.get(P[-1] - 1, -1)\\n if s >= 0:\\n F[i] = max(F[i], i - s + F[s])\\n if P[-1] not in d:\\n d[P[-1]] = i\\n res = max(res, F[i]) \\n\\n return res\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n val = 0\\n result = 0\\n table = dict()\\n for i in range(len(hours)):\\n hour = hours[i]\\n if hour > 8:\\n val += 1\\n else:\\n val -= 1\\n \\n if val > 0:\\n result = i + 1\\n else:\\n if val not in table:\\n table[val] = i\\n if val - 1 in table:\\n dist = i - table[val - 1]\\n if dist > result:\\n result = dist\\n \\n return result\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n sum=0\\n ans=0\\n d={}\\n for i in range(len(hours)):\\n sum=sum+1 if hours[i] >8 else sum-1\\n if sum>0:\\n ans=i+1\\n else:\\n if sum not in d:\\n d[sum]=i\\n if sum-1 in d:\\n ans=max(ans,i-d[sum-1])\\n return ans\\n \\n \\n \\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n seen = {}\\n result,score = 0,0\\n for i,num in enumerate(hours):\\n score += 1 if num > 8 else -1\\n if score > 0:\\n result = i+1\\n elif score -1 in seen:\\n result = max(result, i - seen[score -1])\\n seen.setdefault(score, i)\\n return result\\n \\n \\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n \\n n = len(hours)\\n hashmap = dict()\\n total=0\\n res=0\\n\\n for i in range(n):\\n if hours[i]<=8:\\n total-=1\\n else:\\n total+=1\\n\\n if total>0:\\n res=i+1\\n continue\\n else:\\n if total not in hashmap:\\n hashmap[total] = i\\n if (total-1) in hashmap:\\n res = max(res, i-hashmap[total-1])\\n return res\\n \\n \\n \\n \\n \\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n # Convert array to 0 and 1s\\n bits = [1 if x > 8 else -1 for x in hours]\\n # Problem becomes: find the longest interval bits[i:j] where sum(bits[i:j]) > 0\\n # Get prefix sum of bits\\n pref = [0] * (len(bits)+1)\\n for i in range(1, len(bits)+1):\\n pref[i] = pref[i-1] + bits[i-1]\\n # Problem becomes: find the longest interval pref[i:j] where pref[j] > pref[i]\\n # Sort index of pref by value. Problem becomes: find the largest sorted_pref[j]-sorted_pref[i] where j > i\\n # Greedy to solve the new problem\\n ans = 0\\n min_val = len(bits) + 1\\n for y in sorted(enumerate(pref), key=lambda x: (x[1], -x[0])):\\n min_val = min(min_val, y[0])\\n ans = max(ans, y[0] - min_val)\\n return ans\\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n res = score = 0\\n seen = {}\\n for i, h in enumerate(hours):\\n score = score + 1 if h > 8 else score - 1\\n if score > 0:\\n res = i + 1\\n seen.setdefault(score, i)\\n if score - 1 in seen:\\n res = max(res, i - seen[score - 1])\\n return res\\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n \\n s = 0\\n seen = {}\\n ans = 0\\n \\n for i,h in enumerate(hours):\\n if h > 8:\\n s += 1\\n else:\\n s -= 1\\n \\n if s > 0:\\n ans = i+1\\n \\n seen.setdefault(s, i)\\n \\n if s-1 in seen:\\n ans = max(ans, i-seen[s-1])\\n \\n return ans\\n \\n \\n\\n\",\n \"class Solution:\\n def longestWPI(self, hours):\\n \\n res = score = 0\\n seen = {}\\n \\n for i, h in enumerate(hours):\\n print((i,h))\\n \\n if h > 8: score += 1\\n else: score -= 1\\n \\n if score > 0:\\n res = i + 1\\n seen.setdefault(score, i)\\n if score - 1 in seen:\\n res = max(res, i - seen[score - 1])\\n return res\\n \\n \\n#tiring_count = 1, not_tiring_count = 0, max_length = 1\\n#tiring_count = 2, not_tiring_count = 0, max_length = 2\\n#tiring_count = 2, not_tiring_count = 1, max_length = 3\\n#tiring_count = 2, not_tiring_count = 2, tiring_count = 0\\n#tiring_count = 0, nt = 3\\n#nt = 4\\n#tiring count += 1\\n \\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n hours = [1 if i > 8 else -1 for i in hours]\\n hsh = {hours[0]:0}\\n for i in range(1, len(hours)):\\n hours[i] += hours[i-1]\\n hsh[hours[i]] = i\\n \\n vals = [i+1 if hours[i] > 0 else 0 for i in range(len(hours))]\\n for i in range(len(hours)):\\n sm = hours[i] + 1\\n if sm in hsh:\\n v = hsh[sm]\\n vals[v] = max(vals[v], v-i+vals[i])\\n \\n return max(vals)\\n \\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n final = 0\\n score = 0\\n stack = {}\\n for i in range(len(hours)):\\n if hours[i] > 8 :\\n score += 1\\n else: \\n score -= 1\\n stack.setdefault(score,i)\\n if score > 0:\\n final = i + 1\\n if score - 1 in stack:\\n final = max(final, i - stack[score-1])\\n return final\\n \\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n L = [1 if i > 8 else -1 for i in hours]\\n K = [1 if i > 8 else -1 for i in hours]\\n mp = {}\\n for i in range(0, len(hours)):\\n if i > 0:\\n s = L[i] = L[i] + L[i - 1]\\n else:\\n s = L[i]\\n if s not in mp:\\n mp[s] = {i: True}\\n else:\\n mp[s][i] = True\\n \\n #print(K)\\n #print(L)\\n result = 0\\n for i, c in enumerate(L):\\n if L[-1] > L[i]:\\n result = max(result, len(K) - i - 1)\\n #print(\\\\\\\"ss\\\\\\\", i, result)\\n if 0 < L[i]:\\n result = max(result, i + 1) \\n #print(\\\\\\\"ddd\\\\\\\", i)\\n \\n if i > 0 and L[i - 1] + 1 in mp:\\n s = mp[L[i - 1] + 1]\\n #print(result, s, i)\\n result = max(result, max(s) - i + 1)\\n #result = max(result, i + 1 - min(s))\\n if L[i] - 1 in mp:\\n s = mp[L[i] - 1]\\n #print(result, s, i)\\n # result = max(result, max(s) - i + 1)\\n result = max(result, i - min(s))\\n #print(result, i)\\n return result\\n\\n \\n def longestWPI(self, hours: List[int]) -> int:\\n mp = {}\\n accu = 0\\n result = 0\\n for i, v in enumerate(hours):\\n accu += 1 if v > 8 else -1\\n # print(accu)\\n if accu > 0:\\n result = max(result, i + 1)\\n print((result, i))\\n if accu - 1 in mp:\\n result = max(result, i - mp[accu-1])\\n print((result, i))\\n if accu not in mp:\\n mp[accu] = i\\n return result\\n \\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n ret = 0\\n overall = 0\\n\\n totals = {}\\n for i, h in enumerate(hours):\\n if h > 8:\\n overall += 1 \\n else:\\n overall -= 1\\n \\n if overall > 0:\\n ret = i + 1\\n else:\\n if overall-1 in totals:\\n length = i - totals[overall-1]\\n ret = max(ret, length)\\n if overall not in totals:\\n totals[overall] = i\\n \\n return ret\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n pre_sum = [0]\\n for i, v in enumerate(hours):\\n hours[i] = 1 if v > 8 else -1\\n pre_sum.append(pre_sum[-1] + hours[i])\\n\\n dec_stack = [] # idx to pre_sum\\n for i, v in enumerate(pre_sum):\\n if len(dec_stack) == 0 or (len(dec_stack) > 0 and v < pre_sum[dec_stack[-1]]):\\n dec_stack.append(i)\\n max_r = -math.inf\\n max_width = 0\\n for r in range(len(pre_sum)-1, -1, -1):\\n n = pre_sum[r]\\n if n < max_r:\\n continue\\n max_r = n\\n while len(dec_stack) > 0:\\n # pop top < n\\n left_idx = dec_stack[-1]\\n if pre_sum[left_idx] < n:\\n dec_stack = dec_stack[0:-1]\\n max_width = max(max_width, r - left_idx)\\n else:\\n break\\n if len(dec_stack) == 0:\\n break\\n return max_width\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n hours = [1 if h > 8 else -1 for h in hours]\\n \\n down = {1: 0}\\n s = 0\\n ans = 0\\n for i,h in enumerate(hours):\\n if h < 0:\\n if s not in down:\\n down[s] = i\\n s += h\\n if s in down:\\n ans = max(ans, i - down[s])\\n if s > 0:\\n ans = max(ans, i+1)\\n return ans\\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n days = [1 if hour > 8 else -1 for hour in hours] #find longest strictly positive subarr\\n prefSums = days[:]\\n for i in range(1, len(hours)):\\n prefSums[i] = days[i] + prefSums[i - 1]\\n result = 0\\n prefixLookup = {}\\n for i in range(len(hours)):\\n sumToHere = prefSums[i] #longest answer ending here \\n if sumToHere >= 1:\\n result = max(result, i + 1)\\n else:\\n earlierPrefSumNeeded = sumToHere - 1\\n if earlierPrefSumNeeded in prefixLookup:\\n result = max(result, i - prefixLookup[earlierPrefSumNeeded])\\n if sumToHere not in prefixLookup:\\n prefixLookup[sumToHere] = i\\n return result\\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n lt = []\\n for hour in hours:\\n if hour > 8:\\n lt.append(1)\\n else:\\n lt.append(-1)\\n seen = {}\\n s = 0\\n mx = 0\\n for idx, ele in enumerate(lt):\\n s += ele\\n print((s, idx, mx))\\n if s > 0 : #atleast more 9\\n mx = max(mx, (idx+1))\\n else: \\n if (s-1) in seen:\\n i = seen[s-1]\\n mx = max(mx, idx-i)\\n if (s) not in seen:\\n seen[s] = idx\\n return mx \\n \\n \\n \\n\",\n \"# [9,9,6,0,6,6,9]\\n\\n# [1,1,-1,-1,-1,1]\\n# 1 2 1 0 -1 0\\n# [1,1,-1,-1,-1,1, 1]\\nclass Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n prefix = []\\n for hour in hours:\\n if hour > 8:\\n prefix.append(1)\\n else:\\n prefix.append(-1)\\n \\n curr_sum = 0\\n seen = {0:-1}\\n res = 0\\n \\n for i, num in enumerate(prefix):\\n curr_sum += num\\n if curr_sum > 0:\\n res = i + 1\\n \\n if curr_sum - 1 in seen:\\n res = max(res, i - seen[curr_sum - 1])\\n \\n if curr_sum not in seen:\\n seen[curr_sum] = i\\n \\n return res\\n \\n \\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n cur = res = 0\\n seen = {}\\n for i, h in enumerate(hours):\\n cur += 1 if h > 8 else -1\\n if cur > 0: res = max(res, i + 1)\\n else:\\n if cur - 1 in seen:\\n res = max(res, i - seen[cur - 1])\\n if cur not in seen:\\n seen[cur] = i\\n \\n return res\\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n n = len(hours)\\n hours = [1 if x > 8 else -1 for x in hours]\\n s = 0\\n idx = {}\\n ans = 0\\n for i in range(len(hours)):\\n s += hours[i]\\n if s > 0:\\n ans = i + 1\\n if s not in idx:\\n idx[s] = i\\n if (s - 1) in idx:\\n ans = max(ans, i - idx[s - 1])\\n return ans\",\n \"#https://leetcode.com/problems/longest-well-performing-interval/discuss/334565/JavaC%2B%2BPython-O(N)-Solution-Life-needs-996-and-669\\n \\nclass Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n seen = dict()\\n cnt = 0\\n res = 0\\n for idx, h in enumerate(hours):\\n if h>8:\\n cnt += 1\\n else:\\n cnt -= 1\\n if cnt>0:\\n res = idx+1\\n else:\\n if cnt-1 in seen:\\n res = max(res, idx-seen[cnt-1])\\n if cnt not in seen:\\n seen[cnt] = idx\\n return res\\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n Sum, ans = 0, 0\\n cache = {}\\n for i, n in enumerate(hours):\\n Sum = Sum + 1 if n > 8 else Sum - 1\\n if Sum > 0: ans = i + 1\\n if Sum-1 in cache:\\n ans = max(ans, i - cache[Sum-1])\\n cache.setdefault(Sum, i)\\n return ans\\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n hours = [1 if h > 8 else -1 for h in hours]\\n seen = {}\\n ans = cur = 0\\n for i, h in enumerate(hours):\\n cur += h\\n seen.setdefault(cur, i)\\n if cur > 0:\\n ans = i + 1\\n elif cur - 1 in seen:\\n ans = max(ans, i - seen[cur - 1])\\n return ans\\n \\n # hours = [1 if h > 8 else 0 for h in hours]\\n # acc = [0] + list(accumulate(hours))\\n # i, j = 0, len(hours) - 1\\n # cur = sum(hours)\\n # ans = 0\\n # while i <= j:\\n # if cur > (j - i + 1) // 2:\\n # return j - i + 1\\n \\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n res = score = 0\\n seen = {}\\n for i, h in enumerate(hours):\\n score = score + 1 if h > 8 else score - 1\\n if score > 0:\\n res = i + 1\\n seen.setdefault(score, i)\\n if score - 1 in seen:\\n res = max(res, i - seen[score - 1])\\n return res\",\n \"class Solution:\\n def longestWPI(self, h: List[int]) -> int:\\n n=len(h)\\n for i in range(n):\\n if h[i]>8:\\n h[i]=1\\n else:\\n h[i]=-1\\n #longest subarray with sum >0\\n pre=[0]*n \\n pre[0]=h[0]\\n maxi=0\\n for i in range(1,n):\\n pre[i]=pre[i-1]+h[i]\\n d={}\\n print(pre)\\n for x in range(n):\\n if pre[x]>0:\\n maxi=x+1\\n if d.get(pre[x]-1,-1)!=-1:\\n #print(i,d[pre[x]])\\n maxi=max(maxi,x-d[pre[x]-1])\\n if d.get(pre[x],-1)==-1:\\n d[pre[x]]=x\\n return maxi\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n i=0\\n prefixSum=0\\n existed={0:0}\\n res=0\\n while i<=len(hours)-1:\\n if hours[i]>=9:\\n prefixSum+=1\\n else:\\n prefixSum-=1\\n \\n if prefixSum not in existed:\\n existed[prefixSum]=i+1\\n if prefixSum-1 in existed:\\n res=max(res, i+1-existed[prefixSum-1])\\n if prefixSum>=1:\\n res=max(res, i+1)\\n i+=1\\n #print(existed)\\n return res\",\n \"class Solution:\\n # Use an index to store where\\n # score - 1 score\\n # |-----------|----------------|\\n # |--------1-------|\\n def longestWPI(self, hours: List[int]) -> int:\\n score, longest = 0, 0\\n index = {}\\n for i, n in enumerate(hours):\\n score += 1 if n > 8 else -1\\n if score > 0: # more tiring days so far\\n longest = max(longest, i + 1)\\n index.setdefault(score, i) # record the earliest presum with score\\n if score - 1 in index:\\n longest = max(longest, i - index[score - 1])\\n return longest\",\n \"import bisect\\n\\nclass Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n \\n starts = []\\n startIndexes = []\\n counts = [0] * len(hours)\\n \\n for i in range(len(hours)):\\n if i > 0:\\n counts[i] = counts[i - 1]\\n if hours[i] > 8:\\n counts[i] += 1\\n else:\\n counts[i] -= 1\\n \\n counts = [0] + counts\\n \\n for i in range(len(counts) - 1, -1 , -1):\\n numGood = counts[i]\\n while starts and starts[-1] >= numGood:\\n starts.pop()\\n startIndexes.pop()\\n \\n starts.append(numGood)\\n startIndexes.append(i)\\n \\n maxLen = 0\\n for i, c in enumerate(counts):\\n target = c - 1 \\n # pos1 = len(starts) - 1\\n # while pos1 >= 0 and starts[pos1] > target:\\n # pos1 -= 1\\n pos = bisect.bisect_right(starts, target)\\n if pos == len(starts) or starts[pos] > target:\\n pos -= 1\\n if pos >= 0:\\n lenHere = i - startIndexes[pos]\\n maxLen = max(maxLen, lenHere)\\n \\n return maxLen\\n \\n \\n \\n \\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n hoursLen = len(hours)\\n tDay = []\\n preSum = 0\\n preSumDict = {0:-1}\\n preSumKeys = [0]\\n ans = 0\\n \\n def insertAt(x):\\n l = 0\\n r = len(preSumKeys)-1\\n if x < preSumKeys[l]:\\n return 0\\n if x > preSumKeys[r]:\\n return r + 1\\n while r > l:\\n m = (r + l)//2\\n if preSumKeys[m] < x:\\n l = m + 1\\n else:\\n r = m\\n return l\\n \\n ans = 0\\n for i, hour in enumerate(hours):\\n if hour > 8:\\n tDay.append(1)\\n preSum += 1 \\n else:\\n tDay.append(-1)\\n preSum -= 1 \\n tempIndex = insertAt(preSum)\\n if preSum not in preSumDict:\\n preSumDict[preSum] = i\\n preSumKeys.insert(tempIndex, preSum)\\n if tempIndex > 0:\\n preSumDict[preSumKeys[tempIndex]] = min( preSumDict[preSumKeys[tempIndex-1]], preSumDict[preSumKeys[tempIndex]])\\n ans = max(ans, i - preSumDict[preSumKeys[tempIndex-1]])\\n # print(preSumKeys)\\n # print(preSum)\\n return ans\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n s = 0\\n maxLen = 0\\n seen = {}\\n for idx, hour in enumerate(hours):\\n if hour > 8:\\n s += 1\\n else:\\n s -=1\\n if s > 0:\\n res = idx + 1\\n maxLen = max(maxLen, res)\\n else:\\n if (s-1) in seen:\\n res = (idx - seen[s-1])\\n maxLen = max(maxLen, res)\\n \\n if s not in seen:\\n seen[s] = idx\\n return maxLen \\n \\n \\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n stack,res,first=0,0,{}\\n for day,i in enumerate(hours):\\n stack=stack+1 if i>8 else stack-1\\n first.setdefault(stack, day)\\n if stack>0:res=day+1\\n elif stack-1 in first:\\n res=max(res,day-first[stack-1])\\n return res\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n stack = []\\n ans = accu = 0\\n for i, h in enumerate(hours):\\n if h > 8:\\n accu += 1\\n else:\\n accu -= 1\\n if accu > 0:\\n ans = i + 1\\n else:\\n L, U = -1, len(stack)\\n while L + 1 < U:\\n m = (L + U) // 2\\n if stack[m][1] < accu:\\n U = m\\n else:\\n L = m\\n if U < len(stack):\\n ans = max(ans, i - stack[U][0])\\n if not stack or stack[-1][1] > accu:\\n stack.append((i, accu ))\\n return ans\\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n # ans, cum, seen = 0, 0, {}\\n # for i, hour in enumerate(hours):\\n # cum = cum + 1 if hour > 8 else cum - 1\\n # if cum > 0:\\n # ans = i + 1\\n # else:\\n # if cum not in seen:\\n # seen[cum] = i\\n # if cum - 1 in seen:\\n # ans = max(ans, i - seen[cum - 1])\\n # return ans\\n \\n res = score = 0\\n seen = {}\\n for i, h in enumerate(hours):\\n score = score + 1 if h > 8 else score - 1\\n if score > 0:\\n res = i + 1\\n seen.setdefault(score, i)\\n if score - 1 in seen:\\n res = max(res, i - seen[score - 1])\\n return res\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n total = res = 0\\n index = {}\\n for i, h in enumerate(hours):\\n total += 1 if h > 8 else -1\\n if total > 0:\\n res = i + 1\\n if total - 1 in index:\\n res = max(res, i - index[total-1])\\n index.setdefault(total, i)\\n \\n return res\\n \\n \\n\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n s = []\\n for i in hours:\\n if i > 8:\\n s.append(1)\\n else:\\n s.append(-1)\\n \\n n = len(s)\\n presum = [0]*(n+1)\\n for i in range(1,(n+1)):\\n presum[i] = presum[i-1] + s[i-1]\\n \\n stack = []\\n n = len(presum)\\n for i in range(n):\\n if not stack or presum[stack[-1]] > presum[i]:\\n stack.append(i)\\n res = 0\\n i = n-1\\n while i > res:\\n while stack and presum[stack[-1]] < presum[i]:\\n res = max(res,i-stack[-1])\\n stack.pop()\\n i -=1\\n return res\",\n \"class Solution:\\n def longestWPI(self, hours: List[int]) -> int:\\n presum = 0\\n res = 0\\n mem = {}\\n for i, h in enumerate(hours):\\n presum += (1 if h > 8 else -1)\\n if presum > 0:\\n res = i + 1\\n else:\\n if presum - 1 in mem:\\n res = max(res, i - mem[presum - 1])\\n if presum not in mem:\\n mem[presum] = i\\n return res\"\n]","isConversational":false},"n_sols":{"kind":"number","value":45,"string":"45"},"non_interactive_idx":{"kind":"list like","value":[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],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32,\n 33,\n 34,\n 35,\n 36,\n 37,\n 38,\n 39,\n 40,\n 41,\n 42,\n 43,\n 44\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[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],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":85,"cells":{"problem_id":{"kind":"number","value":220,"string":"220"},"question":{"kind":"string","value":"Today, the bookstore owner has a store open for customers.length minutes. Every minute, some number of customers (customers[i]) enter the store, and all those customers leave after the end of that minute.\nOn some minutes, the bookstore owner is grumpy. If the bookstore owner is grumpy on the i-th minute, grumpy[i] = 1, otherwise grumpy[i] = 0. When the bookstore owner is grumpy, the customers of that minute are not satisfied, otherwise they are satisfied.\nThe bookstore owner knows a secret technique to keep themselves not grumpy for X minutes straight, but can only use it once.\nReturn the maximum number of customers that can be satisfied throughout the day.\n \nExample 1:\nInput: customers = [1,0,1,2,1,1,7,5], grumpy = [0,1,0,1,0,1,0,1], X = 3\nOutput: 16\nExplanation: The bookstore owner keeps themselves not grumpy for the last 3 minutes. \nThe maximum number of customers that can be satisfied = 1 + 1 + 1 + 1 + 7 + 5 = 16.\n\n \nNote:\n\n1 <= X <= customers.length == grumpy.length <= 20000\n0 <= customers[i] <= 1000\n0 <= grumpy[i] <= 1"},"solutions":{"kind":"string","value":"[\"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n # feel like its sliding window max\\n \\n window, max_window = 0, 0\\n \\n # init first window\\n for i in range(X):\\n if grumpy[i]: window += customers[i]\\n max_window = window\\n \\n # Sliding Window\\n for i in range(X,len(grumpy)):\\n if grumpy[i-X]: window -= customers[i-X]\\n if grumpy[i]: window += customers[i]\\n \\n if window > max_window: max_window = window\\n \\n # \\n sum = 0\\n for i in range(len(grumpy)):\\n if grumpy[i] == 0: sum += customers[i]\\n return sum + max_window\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n ans=0\\n \\n cust=0\\n for i in range(len(customers)):\\n if grumpy[i]==0:\\n cust+=customers[i]\\n customers[i]=0\\n \\n cur=0\\n best=0\\n \\n for i,c in enumerate(customers):\\n cur+=c\\n if i>=X:\\n cur-=customers[i-X]\\n best=max(best,cur)\\n return cust+best\\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n \\n wn=min(len(customers),X)\\n print(('wn',wn))\\n wList=[0]*len(customers)\\n \\n for i in range(len(customers)):\\n if grumpy[i]:\\n wList[i]=customers[i]\\n else:\\n wList[i]=0\\n \\n print(('list',wList))\\n \\n mwsum=sum(wList[0:wn])\\n nws=mwsum\\n print(mwsum)\\n for j in range(wn,len(wList)):\\n \\n nws=nws-wList[j-wn]+wList[j] if wn>1 else wList[j] \\n mwsum=max(mwsum,nws)\\n print(nws)\\n \\n for i in range(len(customers)):\\n if grumpy[i]==0:\\n mwsum+=customers[i]\\n return mwsum\\n \\n \\n \\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n no_tech = [0] * len(customers)\\n tech = [0] * len(customers)\\n \\n if len(customers) <= X:\\n return sum(customers)\\n \\n if not grumpy[0]:\\n no_tech[0] = customers[0]\\n tech[0] = customers[0]\\n \\n for i in range(1,len(customers)):\\n if grumpy[i]:\\n no_tech[i] = no_tech[i-1]\\n tech[i] = max(sum(customers[max(0, i-X+1):i+1]) + no_tech[i-X], tech[i-1], no_tech[i])\\n else:\\n no_tech[i] = no_tech[i-1] + customers[i]\\n tech[i] = tech[i-1] + customers[i]\\n \\n # print(customers[max(0, (i-X) + 1) : i+1])\\n \\n # print(tech)\\n # print(no_tech)\\n # print()\\n \\n return tech[-1]\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n base = sum(c for c, g in zip(customers, grumpy) if g == 0)\\n ncus = [c if g == 1 else 0 for c, g in zip(customers, grumpy)]\\n length = len(customers)\\n return base + max(sum(ncus[i:i+X]) for i in range(0, length-X+1))\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n base = sum(c for c, g in zip(customers, grumpy) if g == 0)\\n ncus = [c if g == 1 else 0 for c, g in zip(customers, grumpy)]\\n length = len(customers)\\n return base + max(sum(ncus[i:i+X]) for i in range(0, length-X+1))\\n \\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n n = len(customers)\\n res = 0\\n for k in range(len(customers)):\\n if (grumpy[k] == 0):\\n res = res + customers[k]\\n diff = []\\n for j in range(len(customers)):\\n diff.append(customers[j]*grumpy[j])\\n tem = 0\\n for x in range(n - X + 1):\\n tem = max(tem, sum(diff[x:x+X]))\\n return res + tem\\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n gc = []\\n l = len(customers)\\n for i in range(l):\\n gc.append(customers[i]*grumpy[i])\\n \\n # print(gc)\\n ms = 0\\n mi = -1\\n for i in range(l-X+1):\\n s = sum(gc[i:i+X])\\n if s>ms:\\n ms = s\\n mi = i\\n allowed = range(mi, mi+X)\\n ans = 0\\n for i in range(l):\\n if grumpy[i] == 0 or i in allowed:\\n ans+= customers[i]\\n \\n # print(ans)\\n return ans\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n base_count = 0\\n bonus_array = []\\n for i,j in zip(customers,grumpy):\\n if j == 0:\\n base_count += i\\n bonus_array.append(i*j)\\n bonus = 0\\n \\n for i in range(len(customers)-X+1):\\n tmp_bonus = 0\\n tmp_bonus = sum(bonus_array[i:(i+X)])\\n bonus = max(bonus,tmp_bonus)\\n \\n return base_count + bonus\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X>len(customers):\\n return sum(customers)\\n sum1 = [customers[0]]\\n sum2 = []\\n if grumpy[0]==0:\\n sum2.append(customers[0])\\n else:\\n sum2.append(0)\\n \\n for i in range(1,len(customers)):\\n sum1.append(sum1[-1]+customers[i])\\n if grumpy[i]==0:\\n sum2.append(sum2[-1]+customers[i])\\n else:\\n sum2.append(sum2[-1])\\n \\n maxi=sum1[X-1]+ (sum2[-1]-sum2[X-1])\\n for i in range(1,len(customers)-X+1):\\n if (sum1[i+X-1]-sum1[i-1])+(sum2[-1]-sum2[i+X-1]+sum2[i-1])>maxi:\\n maxi = (sum1[i+X-1]-sum1[i-1])+(sum2[-1]-sum2[i+X-1]+sum2[i-1])\\n \\n print(sum1,sum2)\\n return maxi\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n inital_sum = 0\\n tmp_sum = 0\\n res_sum = 0\\n length = len(customers)\\n for i in range(0,len(customers)):\\n if grumpy[i] == 0:\\n inital_sum += customers[i]\\n tmp_sum = inital_sum\\n for j in range(0, X):\\n if grumpy[j] == 1:\\n tmp_sum = tmp_sum + customers[j]\\n res_sum = max(tmp_sum, res_sum)\\n k = 1\\n while ((k+X-1) < length):\\n if grumpy[k-1] == 1:\\n tmp_sum = tmp_sum - customers[k-1]\\n if grumpy[k+X-1] == 1:\\n tmp_sum = tmp_sum + customers[k+X-1]\\n k += 1\\n res_sum = max(tmp_sum, res_sum)\\n return res_sum\\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n totalCusts = 0\\n for idx,custs in enumerate(customers):\\n if grumpy[idx] == 0:\\n totalCusts += customers[idx]\\n customers[idx] = 0\\n rollingSum = 0\\n maxSum = 0\\n for i,n in enumerate(customers):\\n rollingSum += n\\n if i-X >= 0:\\n rollingSum -= customers[i-X]\\n maxSum = max(maxSum, rollingSum)\\n return maxSum+totalCusts\\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n curr_sum = sum([i * abs(j - 1) for i, j in zip(customers, grumpy)])\\n max_sum = curr_sum\\n \\n # first one, check all\\n for i in range(X):\\n curr_sum += customers[i] * grumpy[i]\\n max_sum = max(max_sum, curr_sum)\\n \\n for i in range(1, len(customers) - X + 1):\\n max_sum = max(max_sum, curr_sum)\\n curr_sum -= customers[i - 1] * grumpy[i - 1]\\n curr_sum += customers[i+X - 1] * grumpy[i+X - 1]\\n \\n return max(max_sum, curr_sum)\\n \\n\", \"class Solution:\\n# def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n# satisfiedCount = 0\\n \\n# for i in range(len(customers)):\\n# if grumpy[i] == 0:\\n# satisfiedCount += customers[i]\\n# customers[i] = 0\\n \\n# maxPotentialCount = 0\\n# val = 0\\n \\n# for i in range(len(customers)):\\n# if i < X:\\n# val += customers[i]\\n# continue\\n \\n# maxPotentialCount = max(maxPotentialCount, val)\\n# val -= customers[i - X]\\n# val += customers[i]\\n \\n# maxPotentialCount = max(maxPotentialCount, val)\\n \\n# return satisfiedCount + maxPotentialCount\\n \\n \\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n i = win_of_make_satisfied = satisfied = max_make_satisfied = 0\\n for c, g in zip(customers, grumpy):\\n satisfied += (1 - g) * c\\n win_of_make_satisfied += g * c\\n if i >= X:\\n win_of_make_satisfied -= grumpy[i - X] * customers[i - X]\\n max_make_satisfied = max(win_of_make_satisfied, max_make_satisfied) \\n i += 1 \\n return satisfied + max_make_satisfied\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n satisfiedCustomers = 0\\n for i in range(len(customers)):\\n if grumpy[i] == 0:\\n satisfiedCustomers += customers[i]\\n customers[i] = 0\\n i = 0\\n unsatisfiedWindow = 0\\n while i < X:\\n unsatisfiedWindow += customers[i]\\n i += 1\\n \\n maxUnsatisfiedWindow = unsatisfiedWindow\\n while i < len(customers):\\n unsatisfiedWindow -= customers[i-X]\\n unsatisfiedWindow += customers[i]\\n maxUnsatisfiedWindow = max(maxUnsatisfiedWindow, unsatisfiedWindow)\\n i += 1\\n \\n return satisfiedCustomers + maxUnsatisfiedWindow\\n \\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n max_satisfaction = sum(customers)\\n actual_satisfaction = sum(int(not g) * s for g,s in zip(grumpy, customers))\\n \\n max_s_x = sum(customers[:X])\\n actual_s_x = sum(int(not g) * s for g,s in zip(grumpy[:X], customers[:X]))\\n \\n ans = actual_satisfaction - actual_s_x + max_s_x\\n for i in range(X, len(customers)):\\n max_s_x += customers[i] - customers[i - X]\\n actual_s_x += (customers[i] * int(not grumpy[i])) - (customers[i - X] * int(not grumpy[i - X]))\\n ans = max(ans, actual_satisfaction - actual_s_x + max_s_x)\\n return ans\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n mp = lp = sum(customers[i] for i in range(X) if grumpy[i])\\n mi = 0\\n for i in range(1, len(grumpy) - X + 1):\\n n = customers[i+X-1] if grumpy[i+X-1] else 0\\n o = customers[i-1] if grumpy[i-1] else 0\\n lp += (n - o)\\n if lp > mp:\\n mp = lp\\n mi = i\\n res = sum([customers[i] for i in range(len(grumpy)) if not grumpy[i]])\\n return res + mp\\n \\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n tmpCustomers = customers.copy()\\n totalSatisfied = 0\\n for i in range(len(grumpy)):\\n if grumpy[i] == 0:\\n totalSatisfied += tmpCustomers[i]\\n\\n tmpCustomers[i] = 0\\n \\n \\n window = 0\\n best = 0\\n \\n for i in range(len(tmpCustomers)):\\n window += tmpCustomers[i]\\n if i >= X:\\n window -= tmpCustomers[i-X]\\n best = max(window,best)\\n return totalSatisfied+best\\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n grumpy, grum_sum, cus_sum = [i ^ 1 for i in grumpy], [0] * len(customers), [0] * len(customers)\\n grumpy_customers = [customers[i] * grumpy[i] for i in range(len(customers))]\\n for i, n in enumerate(customers): cus_sum[i] = n + (cus_sum[i - 1] if i > 0 else 0)\\n for i, n in enumerate(grumpy_customers): grum_sum[i] = n + (grum_sum[i - 1] if i > 0 else 0)\\n return max((grum_sum[i - 1] if i > 0 else 0) + cus_sum[i + X - 1] - (cus_sum[i - 1] if i > 0 else 0) + grum_sum[len(customers) - 1] - grum_sum[i + X - 1] for i in range(0, len(customers) - X + 1))\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X == len(customers):\\n return sum(customers)\\n sum_not_grumpy = sum(customers[:X])\\n sum_normal = sum([x*(1-y) for x,y in zip(customers,grumpy)][X:]) #sum(mults[X:])\\n \\n max_customers = sum_not_grumpy+sum_normal\\n for i in range(1,len(customers)-X+1):\\n sum_not_grumpy -= customers[i-1]\\n sum_not_grumpy += customers[i+X-1]\\n sum_normal += customers[i-1]*(1 - grumpy[i-1])\\n sum_normal -= customers[i+X-1]*(1 - grumpy[i+X-1])\\n max_customers = max(max_customers, sum_not_grumpy+sum_normal)\\n\\n return max_customers\\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n # sliding window of possible grumping times\\n satisfied = 0\\n n = len(customers)\\n grumpySum = 0\\n \\n for i in range(X):\\n satisfied += customers[i] if grumpy[i] == 0 else 0\\n \\n saved = customers[i] if grumpy[i] == 1 else 0\\n grumpySum += saved\\n\\n noGrump = grumpySum\\n for i in range(X, n):\\n satisfied += customers[i] if not grumpy[i] else 0\\n \\n saved = customers[i] if grumpy[i] else 0\\n abandon = customers[i - X] if grumpy[i - X] else 0\\n grumpySum = grumpySum + saved - abandon\\n noGrump = max(noGrump, grumpySum)\\n\\n return satisfied + noGrump\\n \\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n gain = 0\\n for i in range(X):\\n if grumpy[i]:\\n gain += customers[i]\\n max_gain = gain\\n for i in range(X, len(customers)):\\n gain = gain + customers[i]*grumpy[i] - customers[i-X]*grumpy[i-X]\\n max_gain = max(max_gain, gain)\\n statify = 0\\n for i in range(len(customers)):\\n statify += customers[i]*(1-grumpy[i])\\n return statify + max_gain\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n n, window_sum = len(customers), 0 \\n for i in range(n):\\n if i < X:\\n window_sum += customers[i]\\n else:\\n window_sum += (1 - grumpy[i]) * customers[i]\\n \\n result = window_sum # \\u6c42\\u5f97\\u6307\\u91dd\\u672a\\u6ed1\\u52d5\\u524d\\u7e3d\\u548c\\n left, right = 0, X\\n \\n while right < n:\\n if grumpy[right] == 1:\\n window_sum += customers[right]\\n if grumpy[left] == 1:\\n window_sum -= customers[left]\\n result = max(result, window_sum)\\n left += 1\\n right += 1\\n \\n return result\\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n satisfy = sum(cust for cust, grump in zip(customers, grumpy) if grump == 0)\\n max_extra = extra = sum(cust for cust, grump in zip(customers[:X], grumpy[:X]) if grump == 1)\\n start, end = 0, X\\n n = len(customers)\\n while end < n:\\n extra += grumpy[end] * customers[end]\\n extra -= grumpy[start] * customers[start]\\n max_extra = max(max_extra, extra)\\n start += 1\\n end += 1\\n return satisfy + max_extra\\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n n = len(customers)\\n if n == 0:\\n return 0\\n \\n running_sum = 0\\n \\n for i in range(n):\\n if i < X:\\n running_sum += customers[i]\\n else:\\n running_sum += customers[i] * (1-grumpy[i])\\n \\n left, right = 0, X\\n ans = running_sum\\n \\n while right < n:\\n if grumpy[right] == 1:\\n running_sum += customers[right]\\n right += 1\\n \\n if grumpy[left] == 1:\\n running_sum -= customers[left]\\n \\n left += 1\\n \\n ans = max(ans, running_sum)\\n \\n return ans\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n n = len(customers)\\n cnt = 0\\n acc = [0]\\n \\n for i in range(n):\\n if grumpy[i]:\\n acc.append(acc[-1]+customers[i])\\n else:\\n acc.append(acc[-1])\\n cnt += customers[i]\\n \\n ans = cnt\\n \\n for i in range(n-X+1):\\n ans = max(ans, cnt+acc[i+X]-acc[i])\\n \\n return ans\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n inital_sum = 0\\n tmp_sum = 0\\n res_sum = 0\\n length = len(customers)\\n for i in range(0,len(customers)):\\n if grumpy[i] == 0:\\n inital_sum += customers[i]\\n tmp_sum = inital_sum\\n print (tmp_sum)\\n for j in range(0, X):\\n if grumpy[j] == 1:\\n tmp_sum = tmp_sum + customers[j]\\n print (tmp_sum)\\n res_sum = max(tmp_sum, res_sum)\\n print (res_sum)\\n k = 1\\n while ((k+X-1) < length):\\n if grumpy[k-1] == 1:\\n tmp_sum = tmp_sum - customers[k-1]\\n if grumpy[k+X-1] == 1:\\n tmp_sum = tmp_sum + customers[k+X-1]\\n k += 1\\n res_sum = max(tmp_sum, res_sum)\\n return res_sum\\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n ans = 0\\n L = len(grumpy)\\n if X >= L:\\n return sum(customers)\\n for i in range(L):\\n if grumpy[i] == 0:\\n ans += customers[i]\\n res = cur_sum = 0\\n for end in range(X):\\n if grumpy[end] == 1:\\n cur_sum += customers[end]\\n res = cur_sum\\n for end in range(X, L):\\n if grumpy[end] == 1:\\n cur_sum += customers[end]\\n if grumpy[end - X] == 1:\\n cur_sum -= customers[end - X]\\n res = max(res, cur_sum)\\n return ans + res\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n already_happy = sum(c for c, h in zip(customers, grumpy) if not h)\\n \\n running = sum(c for c, h in zip(customers[:X], grumpy[:X]) if h)\\n \\n max_happy = running\\n for i in range(1, len(customers) - X + 1):\\n if grumpy[i - 1] == 1:\\n running -= customers[i - 1]\\n if grumpy[i + X - 1] == 1:\\n running += customers[i + X - 1]\\n max_happy = max(running, max_happy) \\n \\n return max_happy + already_happy\\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n \\n \\n L = len(grumpy)\\n if L == X:\\n return sum(customers)\\n # print(L,X)\\n grummpyCustomer = [0 if grumpy[i] == 1 else customers[i] for i in range(L) ]\\n for i in range(1,L):\\n customers[i] += customers[i-1]\\n \\n \\n for i in range(1,L):\\n grummpyCustomer[i] += grummpyCustomer[i-1]\\n \\n \\n \\n result = 0\\n \\n maxSum = grummpyCustomer[-1]\\n for i in range(X, L):\\n result = max(result, customers[i] - customers[i-X] + maxSum - grummpyCustomer[i] + grummpyCustomer[i-X])\\n # print(result)\\n \\n \\n for i in reversed(list(range(1,L))):\\n customers[i] -= customers[i-1]\\n # print(customers)\\n \\n grummpyCustomer = [0 if grumpy[i] == 1 else customers[i] for i in range(L) ]\\n \\n for i in reversed(list(range(L-1))):\\n customers[i] += customers[i+1]\\n \\n for i in reversed(list(range(L-1))):\\n # print(i)\\n grummpyCustomer[i] += grummpyCustomer[i+1]\\n \\n # print(customers[0] - customers[0+X] + grummpyCustomer[0+X])\\n maxSum = grummpyCustomer[0]\\n for i in reversed(list(range(L-X))):\\n # print(i,'ok')\\n result = max(result, customers[i] - customers[i+X] + maxSum - grummpyCustomer[i] + grummpyCustomer[i+X])\\n \\n return result\\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], k: int) -> int:\\n n=len(customers)\\n res=sum([customers[i]*(1-grumpy[i]) for i in range(n)]) # the customers you can obtain while non grumpy\\n best_gain=sum([customers[i]*grumpy[i] for i in range(k)]) # first window\\n gain=best_gain\\n for i in range(k,n):\\n gain+=customers[i]*grumpy[i]-customers[i-k]*grumpy[i-k] # add new, kick out old\\n best_gain=max(gain,best_gain) \\n return res+best_gain\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n max_satisfaction = sum(customers)\\n actual_satisfaction = sum(int(not g) * s for g,s in zip(grumpy, customers))\\n \\n max_s_x = sum(customers[:X])\\n actual_s_x = sum(int(not g) * s for g,s in zip(grumpy[:X], customers[:X]))\\n \\n ans = actual_satisfaction - actual_s_x + max_s_x\\n print(max_satisfaction, actual_satisfaction)\\n print('sssssssss')\\n for i in range(X, len(customers)):\\n print(max_s_x, actual_s_x, customers[i], customers[i - X])\\n max_s_x += customers[i] - customers[i - X]\\n actual_s_x += (customers[i] * int(not grumpy[i])) - (customers[i - X] * int(not grumpy[i - X]))\\n ans = max(ans, actual_satisfaction - actual_s_x + max_s_x)\\n return ans\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n curr = 0\\n max1 = 0\\n left =0\\n for i in range(len(customers)):\\n if i <X:\\n curr += customers[i]\\n else:\\n if grumpy[i] == 0:\\n curr+= customers[i]\\n max1 = curr\\n for i in range(X,len(customers)):\\n if grumpy[i] == 1:\\n curr+=customers[i]\\n if grumpy[left] == 1:\\n curr-=customers[left]\\n left+=1\\n max1 = max(max1,curr)\\n return max1\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X == len(customers):\\n return sum(customers)\\n for i in range(len(grumpy)):\\n grumpy[i] = 0 if grumpy[i] == 1 else 1\\n mults = [x*y for x,y in zip(customers,grumpy)]\\n sum_not_grumpy = sum(customers[:X])\\n not_grumpy = [sum_not_grumpy] \\n for i in range(1,len(customers)-X+1):\\n sum_not_grumpy -= customers[i-1]\\n sum_not_grumpy += customers[i+X-1]\\n not_grumpy.append(sum_not_grumpy)\\n \\n sum_normal = sum(mults[X:])\\n normal_custs = [sum_normal]\\n for i in range(1,len(mults)-X+1):\\n sum_normal += mults[i-1]\\n sum_normal -= mults[i+X-1]\\n normal_custs.append(sum_normal)\\n \\n print(not_grumpy)\\n print(normal_custs)\\n return max([x+y for x,y in zip(not_grumpy,normal_custs)])\\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n old = 0\\n for i in range(len(customers)):\\n if grumpy[i] == 0:\\n old += customers[i]\\n l, r, res = 0, 0, 0\\n while r < len(customers):\\n if grumpy[r] == 1:\\n old += customers[r]\\n if r >= X:\\n if grumpy[l] == 1:\\n old -= customers[l]\\n l += 1\\n res = max(res, old)\\n r += 1\\n return res\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n # we want to find the biggest loss of satisfaction in a X-hr period throughout the day.\\n if len(customers) == X: return sum(customers)\\n maxLoss = 0\\n total = sum([customers[i]*(1-grumpy[i]) for i in range(len(grumpy))])\\n print(total)\\n loss = sum([grumpy[i]*customers[i] for i in range(X)])\\n maxLoss = loss\\n for i in range(X, len(customers)):\\n loss += grumpy[i]*customers[i]\\n loss -= grumpy[i-X]*customers[i-X]\\n maxLoss = max(maxLoss, loss)\\n total += maxLoss\\n return total\\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if not customers:\\n return 0\\n can_be_always_happy = X == len(customers)\\n customers_lost = [0] * (len(customers) + 1)\\n total_customers_lost = 0\\n total_satisfied = 0\\n for idx, customer in enumerate(customers):\\n if grumpy[idx] == 1 and not can_be_always_happy:\\n total_customers_lost += customers[idx]\\n else:\\n total_satisfied += customers[idx]\\n customers_lost[idx + 1] = total_customers_lost\\n\\n max_gain = 0\\n for i in range(X, len(customers_lost)):\\n gain = customers_lost[i] - customers_lost[i - X]\\n max_gain = max(gain, max_gain)\\n\\n return total_satisfied + max_gain\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X == len(customers):\\n return sum(customers)\\n for i in range(len(grumpy)):\\n grumpy[i] = 0 if grumpy[i] == 1 else 1\\n mults = [x*y for x,y in zip(customers,grumpy)]\\n sum_not_grumpy = sum(customers[:X])\\n sum_normal = sum(mults[X:])\\n \\n max_customers = sum_not_grumpy+sum_normal\\n for i in range(1,len(customers)-X+1):\\n sum_not_grumpy -= customers[i-1]\\n sum_not_grumpy += customers[i+X-1]\\n sum_normal += mults[i-1]\\n sum_normal -= mults[i+X-1]\\n max_customers = max(max_customers, sum_not_grumpy+sum_normal)\\n\\n return max_customers\\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X == len(customers):\\n return sum(customers)\\n for i in range(len(grumpy)):\\n grumpy[i] = 0 if grumpy[i] == 1 else 1\\n mults = [x*y for x,y in zip(customers,grumpy)]\\n sum_not_grumpy = sum(customers[:X])\\n #not_grumpy = [sum_not_grumpy] \\n sum_normal = sum(mults[X:])\\n #normal_custs = [sum_normal]\\n \\n max_customers = sum_not_grumpy+sum_normal\\n for i in range(1,len(customers)-X+1):\\n sum_not_grumpy -= customers[i-1]\\n sum_not_grumpy += customers[i+X-1]\\n sum_normal += mults[i-1]\\n sum_normal -= mults[i+X-1]\\n max_customers = max(max_customers, sum_not_grumpy+sum_normal)\\n\\n return max_customers\\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n saved = 0\\n max_saved = 0\\n sumTotal = 0\\n for i, value in enumerate(customers):\\n if i - X >= 0 and grumpy[i - X]:\\n saved -= customers[i - X]\\n if grumpy[i]:\\n saved += value\\n else:\\n sumTotal += value\\n max_saved = max(max_saved, saved)\\n print((saved,max_saved))\\n # print(saved, max_saved, sumTotal)\\n return sumTotal + max_saved\\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n to_ret = sum([c for c, g in zip(customers, grumpy) if g == 0])\\n \\n mt = mf = sum([c for c, g in zip(customers[:X], grumpy[:X]) if g == 1])\\n for t in range(X, len(customers)) :\\n if grumpy[t] == 1 :\\n mt += customers[t]\\n if grumpy[t-X] == 1 :\\n mt -= customers[t-X]\\n mf = max(mf, mt)\\n return to_ret + mf\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n satisfiedCount = 0\\n \\n for i in range(len(customers)):\\n if grumpy[i] == 0:\\n satisfiedCount += customers[i]\\n customers[i] = 0\\n \\n maxPotentialCount = 0\\n val = 0\\n \\n for i in range(len(customers)):\\n if i < X:\\n val += customers[i]\\n continue\\n \\n maxPotentialCount = max(maxPotentialCount, val)\\n val -= customers[i - X]\\n val += customers[i]\\n \\n maxPotentialCount = max(maxPotentialCount, val)\\n \\n return satisfiedCount + maxPotentialCount\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n i = win_of_make_satisfied = satisfied = max_make_satisfied = 0\\n for c, g in zip(customers, grumpy):\\n satisfied += (1 - g) * c\\n win_of_make_satisfied += g * c\\n if i >= X:\\n win_of_make_satisfied -= grumpy[i - X] * customers[i - X]\\n max_make_satisfied = max(win_of_make_satisfied, max_make_satisfied) \\n i += 1 \\n return satisfied + max_make_satisfied\\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n lb, ub = 0, X-1\\n total = sum([customers[i] * (1 - grumpy[i]) for i in range(len(customers))])\\n \\n saved = 0\\n for i in range(X):\\n if grumpy[i]: saved += customers[i]\\n \\n ans = total + saved\\n while ub + 1 < len(grumpy):\\n lb, ub = lb + 1, ub + 1\\n if grumpy[lb-1]:\\n saved -= customers[lb-1]\\n if grumpy[ub]:\\n saved += customers[ub]\\n ans = max(ans, total+saved)\\n return ans\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n gains = [x if grumpy[i] == 1 else 0 for (i, x) in enumerate(customers)]\\n fact = [x if grumpy[i] == 0 else 0 for (i, x) in enumerate(customers)]\\n \\n if X > len(gains):\\n return sum(customers)\\n \\n current_sum = sum(gains[:X])\\n max_gain = current_sum\\n for i in range(1, len(gains) - X + 1):\\n current_sum = current_sum - gains[i - 1] + gains[i + X - 1]\\n max_gain = max(max_gain, current_sum)\\n \\n return sum(fact) + max_gain\\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n n = len(grumpy)\\n if X >= n:\\n return sum(customers)\\n init = sum([customers[i]*(1-grumpy[i]) for i in range(n)])\\n \\n for j in range(X):\\n if grumpy[j] == 1:\\n init += customers[j]\\n max_l = init \\n temp = init\\n for i in range(1, n-X+1):\\n temp -= grumpy[i-1]*customers[i-1]\\n temp += grumpy[i+X-1]*customers[i+X-1]\\n max_l = max(max_l, temp)\\n \\n return max_l\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n initial = sum(num for day, num in enumerate(customers) if grumpy[day] == 0)\\n curr_tricked = 0\\n tricked = 0\\n for ind, num in enumerate(customers):\\n if ind >= X and grumpy[ind-X] == 1:\\n curr_tricked -= customers[ind-X]\\n if grumpy[ind] == 1:\\n curr_tricked += customers[ind]\\n tricked = max(tricked, curr_tricked)\\n return initial + tricked\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n t=0\\n for i in range(len(grumpy)):\\n if grumpy[i]==0:\\n t+=customers[i]\\n customers[i]=0\\n\\n n=sum(customers[:X])\\n m=n\\n for i in range(1,len(customers)-X+1):\\n m=m+customers[i+X-1]-customers[i-1]\\n n=max(m,n)\\n return n+t\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X == len(customers):\\n return sum(customers)\\n sum_not_grumpy = sum(customers[:X])\\n sum_normal = sum([x*(1-y) for x,y in zip(customers[X:],grumpy[X:])]) \\n \\n max_customers = sum_not_grumpy+sum_normal\\n for i in range(1,len(customers)-X+1):\\n sum_not_grumpy -= customers[i-1]\\n sum_not_grumpy += customers[i+X-1]\\n sum_normal += customers[i-1]*(1 - grumpy[i-1])\\n sum_normal -= customers[i+X-1]*(1 - grumpy[i+X-1])\\n max_customers = max(max_customers, sum_not_grumpy+sum_normal)\\n\\n return max_customers\\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n satisfied = 0\\n for i in range(len(grumpy)):\\n if grumpy[i] == 0:\\n satisfied += customers[i]\\n windowMax = 0\\n curr = 0\\n for i in range(len(customers)):\\n curr += ((grumpy[i]) * customers[i])\\n if i >= X:\\n curr -= ((grumpy[i - X]) * customers[i - X])\\n windowMax = max(windowMax, curr)\\n return satisfied + windowMax\\n\", \"import numpy as np\\n\\nclass Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n #satisfiedCustomer = sum(customers) - sum(np.multiply(customers,grumpy))\\n \\n satisfiedCustomer = 0\\n for i in range(len(customers)):\\n if not grumpy[i]:\\n satisfiedCustomer += customers[i]\\n \\n window = 0\\n for i in range(X):\\n if grumpy[i] == 1:\\n window+=customers[i]\\n \\n \\n res = window\\n \\n for i in range(1,len(customers)-X+1):\\n last = i-1\\n if grumpy[last]==1:\\n window -= customers[last]\\n nextIdx = i+X-1\\n if grumpy[nextIdx]==1:\\n window += customers[nextIdx]\\n \\n res = max(res,window)\\n \\n \\n return (res+satisfiedCustomer)\\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n total = sum(c for i, c in enumerate(customers) if grumpy[i] == 0)\\n add = sum(c for i, c in enumerate(customers[:X]) if grumpy[i] == 1)\\n res = total + add\\n #print(total, add, res)\\n for i in range(X, len(customers)):\\n if grumpy[i] == 1:\\n add += customers[i]\\n if grumpy[i - X] == 1:\\n add -= customers[i - X]\\n res = max(res, total + add)\\n #print(total, add, res)\\n return res\\n\", \"class Solution:\\n def maxSatisfied(self, A: List[int], G: List[int], X: int) -> int:\\n res = 0\\n s = 0\\n ws = 0\\n left = []\\n for i in range(len(A)):\\n c, g = A[i], G[i]\\n s += (1-g)*c\\n ws += g*c\\n if i>=X:\\n ws -= A[i-X] * G[i-X]\\n res = max(res, ws)\\n # print(i,j,s,res)\\n return res+s\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n i = win_of_make_satisfied = satisfied = max_make_satisfied = 0\\n for c, g in zip(customers, grumpy):\\n satisfied += (1 - g) * c\\n win_of_make_satisfied += g * c\\n if i >= X:\\n win_of_make_satisfied -= grumpy[i - X] * customers[i - X]\\n max_make_satisfied = max(win_of_make_satisfied, max_make_satisfied) \\n i += 1 \\n return satisfied + max_make_satisfied\\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n n=len(customers)\\n res=sum([customers[i]*(1-grumpy[i]) for i in range(n)])\\n best_gain=sum([customers[i]*grumpy[i] for i in range(X)])\\n gain=best_gain\\n for i in range(X,n):\\n gain+=customers[i]*grumpy[i]-customers[i-X]*grumpy[i-X]\\n best_gain=max(best_gain,gain)\\n return res+best_gain\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X == len(customers):\\n return sum(customers)\\n for i in range(len(grumpy)):\\n grumpy[i] = 0 if grumpy[i] == 1 else 1\\n mults = [x*y for x,y in zip(customers,grumpy)]\\n sum_not_grumpy = sum(customers[:X])\\n not_grumpy = [sum_not_grumpy] \\n sum_normal = sum(mults[X:])\\n normal_custs = [sum_normal]\\n \\n for i in range(1,len(customers)-X+1):\\n sum_not_grumpy -= customers[i-1]\\n sum_not_grumpy += customers[i+X-1]\\n not_grumpy.append(sum_not_grumpy)\\n sum_normal += mults[i-1]\\n sum_normal -= mults[i+X-1]\\n normal_custs.append(sum_normal)\\n \\n return max([x+y for x,y in zip(not_grumpy,normal_custs)])\\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n N = len(grumpy)\\n \\n already_happy = sum(customers[i] for i in range(N) if not grumpy[i])\\n \\n window = sum(customers[i] for i in range(X) if grumpy[i])\\n \\n max_bonus = window\\n for r in range(X, N):\\n window -= customers[r - X] if grumpy[r - X] else 0\\n window += customers[r] if grumpy[r] else 0\\n max_bonus = max(max_bonus, window)\\n \\n return already_happy + max_bonus\", \"class Solution:\\n \\n def maxSatisfied(self, customers: List[int], grumpy: List[int], window_size: int) -> int:\\n \\n\\n already_satisfied = 0\\n for index in range(len(customers)):\\n if grumpy[index] == 0:\\n already_satisfied += customers[index]\\n customers[index] = 0\\n \\n \\n best_satisfied = 0\\n \\n satisfied = 0\\n for index, customer in enumerate(customers):\\n satisfied += customer\\n \\n if index >= window_size:\\n satisfied -= customers[index - window_size]\\n \\n best_satisfied = max(best_satisfied, satisfied)\\n \\n \\n return best_satisfied + already_satisfied\\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n \\n satisfiedCustomer = 0\\n for i in range(len(customers)):\\n if not grumpy[i]:\\n satisfiedCustomer += customers[i]\\n \\n window = 0\\n for i in range(X):\\n if grumpy[i] == 1:\\n window+=customers[i]\\n \\n res = window\\n for i in range(1,len(customers)-X+1):\\n last = i-1\\n if grumpy[last]==1:\\n window -= customers[last]\\n nextIdx = i+X-1\\n if grumpy[nextIdx]==1:\\n window += customers[nextIdx]\\n \\n res = max(res,window)\\n \\n \\n return (res+satisfiedCustomer)\\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n disSatisfy = [c*g for c,g in zip(customers, grumpy)]\\n start = 0\\n grumpy_num = 0\\n for i in range(X):\\n grumpy_num += disSatisfy[i]\\n\\n remaining = grumpy_num\\n for j in range(X, len(customers)):\\n remaining = remaining-disSatisfy[j-X]+disSatisfy[j]\\n if remaining>grumpy_num:\\n grumpy_num = remaining\\n start = j-X+1\\n\\n for k in range(start, start+X):\\n grumpy[k]=0\\n\\n return sum([ c if g==0 else 0 for c,g in zip(customers, grumpy)])\\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int: \\n n = len(customers)\\n \\n start = 0\\n \\n curSatisfaction = sum(customers[i] for i in range(n) if grumpy[i] == 0)\\n \\n maxSatisfaction = 0\\n \\n for end in range(len(customers)):\\n if grumpy[end] == 1:\\n curSatisfaction += customers[end]\\n \\n if end - start + 1 > X:\\n if grumpy[start] == 1:\\n curSatisfaction -= customers[start]\\n start += 1\\n \\n maxSatisfaction = max(maxSatisfaction, curSatisfaction)\\n \\n return maxSatisfaction\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n start=0\\n end=X\\n ans=0\\n for i in range(len(grumpy)):\\n if grumpy[i]==0:\\n ans+=customers[i]\\n t=0\\n for i in range(X):\\n if grumpy[i]==1:\\n t+=customers[i]\\n maxs=0\\n while end<len(grumpy)+1:\\n if t>maxs:\\n maxs=t\\n if end==len(grumpy):\\n break\\n if grumpy[start]==1:\\n t-=customers[start]\\n if grumpy[end]==1:\\n t+=customers[end]\\n start+=1\\n end+=1\\n return ans+maxs\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n total = 0\\n \\n for i in range(len(customers)):\\n total += (1-grumpy[i]) * customers[i]\\n grumpy[i] *= customers[i]\\n \\n maxsum = 0\\n for i in range(X):\\n maxsum += grumpy[i]\\n cur = maxsum\\n for j in range(X, len(grumpy)):\\n i = j-X\\n cur += grumpy[j]\\n cur -= grumpy[i]\\n maxsum = max(maxsum, cur)\\n #print(maxsum)\\n return total + maxsum\\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n n = len(customers)\\n sum_cus = sum(customers)\\n for i in range(n):\\n customers[i] *= grumpy[i]\\n window = 0\\n max_secret_satisfied = -math.inf\\n left, right = 0, 0\\n while right < n:\\n window += customers[right]\\n right += 1\\n while right - left >= X:\\n max_secret_satisfied = max(max_secret_satisfied, window)\\n window -= customers[left]\\n left += 1\\n return sum_cus - (sum(customers) - max_secret_satisfied)\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n #happy owner means happy customer as well \\n happy_owner_cust = 0 \\n \\n for pos in range(len(customers)):\\n if grumpy[pos] == 0: #happy owner \\n happy_owner_cust += customers[pos]\\n customers[pos] = 0 \\n \\n \\n #then build upon using the grumpy owner power. \\n \\n calming_owner_cust = 0 \\n best_calmed_cust = 0 \\n \\n for end in range(len(customers)): \\n calming_owner_cust += customers[end]\\n \\n \\n \\n if end >= X: #subtract out the extra calming technique from the owner \\n calming_owner_cust -= customers[end - X]\\n \\n best_calmed_cust = max(best_calmed_cust, calming_owner_cust)\\n \\n \\n \\n \\n return happy_owner_cust + best_calmed_cust\\n \\n# #TRY 8/10/2020 \\n# class Solution:\\n# def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n# #Input: Customers[i] how many customers enter for that exact minute \\n \\n# #Constraint \\n# #owner -> opens store up to customers.len()\\n# #Every minute there are customers entering the store. And all those customers leave after the end of the minute \\n \\n# #If owner is grumpy on i-th minute grumpy[i] = 1 else grumpy[i] = 0. When the bookstore owner is angry \\n# #The customers of that minute aren't satisfied else if owner isn't grumpy then customers are happy. \\n \\n# # Bookstore owner can be NOT angry for X minutes but can use it ONLY once. \\n \\n# #WANT: max number of customers that are happy throughout the day. \\n \\n \\n# minutes_opened = len(customers) \\n# customer_happy_time = 0 \\n \\n# #Try to basically keep your grumpy minutes down based on the highest number of customers there are. \\n \\n# start = 0 \\n# end = 0 \\n# rush_hour = collections.deque() #this is based on the most amount of customers. \\n# calm_owner = collections.deque()\\n# #Our best number of customer being happy will be based on the largest amount of customers\\n# #That's our best bet. \\n# while end < minutes_opened: \\n# if customers[end] == 0: #No Customers go in owner can be angry \\n# end += 1 \\n# continue \\n \\n# cur_happy_time += customers[end]\\n# if grumpy[end] == 1: #owner angry = customer angry: Just try calming here then. \\n \\n \\n \\n# rush_hour.append(end)\\n\\n# class Solution():\\n# def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n# m = s = tmp = 0\\n# for i in range(len(customers)):\\n# if not grumpy[i]: \\n# s += customers[i] # sum of satisfied customers\\n# customers[i] = 0 \\n# else: tmp += customers[i] # sum of grumpy customers \\n# if i>=X: tmp -= customers[i-X] # remove the leftmost element to keep the sliding window with # of X\\n# m = max(m, tmp) # max # of satisfied grumpy customers with a secret technique\\n# return s+m\\n \\n \\n# class Solution:\\n# def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n# # Part 1 requires counting how many customers\\n# # are already satisfied, and removing them\\n# # from the customer list.\\n# #These customers are those who didn't have to fight with the owner to be happy.\\n# already_satisfied = 0\\n# for i in range(len(grumpy)):\\n# if grumpy[i] == 0: #He's happy so add the customer. \\n# already_satisfied += customers[i]\\n# customers[i] = 0 #set you back to zero to not visit you. When doing the offset for the window \\n \\n# # Part 2 requires finding the optimal number\\n# # of unhappy customers we can make happy.\\n# best_we_can_make_satisfied = 0\\n# current_satisfied = 0\\n# for i, customers_at_time in enumerate(customers):\\n# # if customers[i] == 0: CAN'T DO THIS CUZ WE'RE NOT UPDATING THE WINDOW THEN AT THIS POINT (I.E THE START WINDOW)\\n# # continue\\n# #Add the customer so far\\n# current_satisfied += customers_at_time # Add current to rolling total\\n# if i >= X: # We need to remove some from the rolling total #We need to update and try the grumpy intervals to block out owner from \\n# #Being grumpy so we can add these happy customers but at this point\\n# #There's too much calming power used by owner so we need to remove the beginning window of the current_satisifed. \\n# current_satisfied -= customers[i - X]\\n# best_we_can_make_satisfied = max(best_we_can_make_satisfied, current_satisfied)\\n \\n# # The answer is the sum of the solutions for the 2 parts.\\n# return already_satisfied + best_we_can_make_satisfied\\n \\n \\nclass Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n always_happy = 0 \\n for pos in range(len(customers)): \\n if grumpy[pos] == 0: \\n always_happy += customers[pos]\\n customers[pos] = 0 \\n \\n happy_use = 0 \\n cur_happy_customers = 0 \\n \\n for pos in range(len(customers)): \\n cur_happy_customers += customers[pos]\\n \\n if pos >= X: \\n cur_happy_customers -= customers[pos - X]\\n \\n \\n happy_use = max(happy_use, cur_happy_customers)\\n \\n return always_happy + happy_use \", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if len(customers) <= X:\\n return sum(customers)\\n \\n \\n satisfied_customers = 0\\n current_unsatisfied_customers = 0\\n max_unsatisfied_customers = 0\\n \\n for i in range(len(customers)):\\n if i >= X and grumpy[i-X] == 1:\\n current_unsatisfied_customers -= customers[i-X]\\n \\n if grumpy[i] == 0:\\n satisfied_customers += customers[i]\\n else:\\n current_unsatisfied_customers += customers[i]\\n \\n max_unsatisfied_customers = max(max_unsatisfied_customers, current_unsatisfied_customers)\\n \\n return satisfied_customers + max_unsatisfied_customers\\n \\n \\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X == len(customers):\\n return sum(customers)\\n for i in range(len(grumpy)):\\n grumpy[i] = 0 if grumpy[i] == 1 else 1\\n mults = [x*y for x,y in zip(customers,grumpy)]\\n sum_not_grumpy = sum(customers[:X])\\n not_grumpy = [sum_not_grumpy] \\n sum_normal = sum(mults[X:])\\n normal_custs = [sum_normal]\\n for i in range(1,len(customers)-X+1):\\n sum_not_grumpy -= customers[i-1]\\n sum_not_grumpy += customers[i+X-1]\\n not_grumpy.append(sum_not_grumpy)\\n sum_normal += mults[i-1]\\n sum_normal -= mults[i+X-1]\\n normal_custs.append(sum_normal)\\n \\n \\n \\n \\n print(not_grumpy)\\n print(normal_custs)\\n return max([x+y for x,y in zip(not_grumpy,normal_custs)])\\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n satisfied = 0 \\n for i in range(len(customers)):\\n satisfied += customers[i] * (grumpy[i] == 0)\\n \\n p = X \\n best_imp = sum([customers[i] for i in range(p) if grumpy[i] == 1])\\n imp = best_imp\\n while p < len(grumpy):\\n if grumpy[p] == 1:\\n imp += customers[p]\\n if grumpy[p - X] == 1:\\n imp -= customers[p - X]\\n if imp > best_imp:\\n best_imp = imp\\n \\n p += 1\\n \\n return satisfied + best_imp \\n \\n \\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n i = win_of_make_satisfied = satisfied = max_make_satisfied = 0\\n for c, g in zip(customers, grumpy):\\n satisfied += (1 - g) * c\\n win_of_make_satisfied += g * c\\n if i >= X:\\n win_of_make_satisfied -= grumpy[i - X] * customers[i - X]\\n max_make_satisfied = max(win_of_make_satisfied, max_make_satisfied) \\n i += 1\\n return satisfied + max_make_satisfied\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n curr_running_delta = 0\\n max_delta = (-2**31, None) # max sum, end idx\\n \\n for i in range(len(customers)):\\n curr_running_delta += customers[i]*grumpy[i]\\n \\n if i >= X - 1:\\n if curr_running_delta > max_delta[0]:\\n max_delta = (curr_running_delta, i)\\n \\n if grumpy[i - (X-1)] == 1:\\n curr_running_delta -= customers[i - (X-1)]\\n \\n max_satisfied = 0\\n for i in range(len(customers)):\\n if max_delta[1] - (X-1) <= i <= max_delta[1] or grumpy[i] == 0:\\n max_satisfied += customers[i]\\n \\n return max_satisfied\\n \\n # time O(n)\\n # space O(1)\\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n # sliding window of possible grumping times\\n satisfied = 0\\n n = len(customers)\\n grumpySum = [0]*(n - X + 1)\\n \\n for i in range(X):\\n satisfied += customers[i] if grumpy[i]==0 else 0\\n \\n saved = customers[i] if grumpy[i]==1 else 0\\n grumpySum[0] += saved\\n\\n noGrump = grumpySum[0]\\n for i in range(X, n):\\n satisfied += customers[i] if not grumpy[i] else 0\\n \\n saved = customers[i] if grumpy[i] else 0\\n abandon = customers[i - X] if grumpy[i - X] else 0\\n grumpySum[i - X + 1] = grumpySum[i - X] + saved - abandon\\n noGrump = max(noGrump, grumpySum[i - X + 1])\\n\\n return satisfied + noGrump\\n \\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n without_x = 0\\n for i, b in enumerate(grumpy):\\n if not b:\\n without_x += customers[i]\\n \\n with_x = [0]*len(customers)\\n \\n extra = 0\\n for i, b in enumerate(grumpy[:X]):\\n if b:\\n extra += customers[i]\\n \\n with_x[0] += extra\\n \\n for i in range(len(grumpy)):\\n if i + X >= len(grumpy):\\n break\\n \\n extra -= 0 if not grumpy[i] else customers[i]\\n extra += 0 if not grumpy[i + X ] else customers[i + X]\\n with_x[i + 1] += extra\\n \\n return max(with_x) + without_x\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int],\\n X: int) -> int:\\n already_satisfied = 0\\n for i in range(len(grumpy)):\\n if grumpy[i] == 0:\\n already_satisfied += customers[i]\\n customers[i] = 0\\n\\n best_we_can_make_satisfied = 0\\n current_satisfied = 0\\n for i, customers_at_time in enumerate(customers):\\n current_satisfied += customers_at_time\\n if i >= X:\\n current_satisfied -= customers[i - X]\\n best_we_can_make_satisfied = max(best_we_can_make_satisfied,\\n current_satisfied)\\n return already_satisfied + best_we_can_make_satisfied\\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n zeroTotal = 0\\n for i in range(len(customers)):\\n if grumpy[i] == 0:\\n zeroTotal += customers[i]\\n\\n q = deque()\\n oneTotal = 0\\n largest = 0\\n for i in range(len(customers)):\\n if grumpy[i] == 1:\\n while q and i - q[0][1] >= X:\\n oneTotal -= q.popleft()[0]\\n q.append((customers[i],i))\\n oneTotal += customers[i]\\n largest = max(largest, oneTotal)\\n return zeroTotal + largest\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X == len(customers):\\n return sum(customers)\\n for i in range(len(grumpy)):\\n grumpy[i] = 0 if grumpy[i] == 1 else 1\\n mults = [x*y for x,y in zip(customers,grumpy)]\\n sum_not_grumpy = sum(customers[:X])\\n sum_normal = sum(mults[X:])\\n \\n max_customers = sum_not_grumpy+sum_normal\\n for i in range(1,len(customers)-X+1):\\n sum_not_grumpy -= customers[i-1]\\n sum_not_grumpy += customers[i+X-1]\\n sum_normal += customers[i-1]*grumpy[i-1]#mults[i-1] \\n sum_normal -= customers[i+X-1]*grumpy[i+X-1]#mults[i+X-1]\\n max_customers = max(max_customers, sum_not_grumpy+sum_normal)\\n\\n return max_customers\\n \\n\", \"class Solution:\\n def maxSatisfied(self, c: List[int], g: List[int], X: int) -> int:\\n arr = [0]\\n n = len(g)\\n for i in range(n):\\n arr.append(arr[-1]+(1-g[i])*c[i])\\n \\n c = [0]+c\\n for i in range(n):\\n c[i+1] = c[i]+c[i+1]\\n \\n m = -1\\n for i in range(X,n+1):\\n m = max(m,c[i]-c[i-X]-arr[i]+arr[i-X])\\n \\n print((arr,c,m))\\n \\n return arr[-1]+m\\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n \\n \\n L = len(grumpy)\\n if L == X:\\n return sum(customers)\\n # print(L,X)\\n tempCustomers = customers.copy()\\n grummpyCustomer = [0 if grumpy[i] == 1 else customers[i] for i in range(L) ]\\n for i in range(1,L):\\n tempCustomers[i] += tempCustomers[i-1]\\n \\n \\n for i in range(1,L):\\n grummpyCustomer[i] += grummpyCustomer[i-1]\\n \\n \\n \\n result = 0\\n \\n maxSum = grummpyCustomer[-1]\\n for i in range(X, L):\\n result = max(result, tempCustomers[i] - tempCustomers[i-X] + maxSum - grummpyCustomer[i] + grummpyCustomer[i-X])\\n # print(result)\\n \\n \\n # for i in reversed(range(1,L)):\\n # customers[i] -= customers[i-1]\\n # print(customers)\\n \\n grummpyCustomer = [0 if grumpy[i] == 1 else customers[i] for i in range(L) ]\\n \\n tempCustomers = customers.copy()\\n for i in reversed(list(range(L-1))):\\n tempCustomers[i] += tempCustomers[i+1]\\n \\n for i in reversed(list(range(L-1))):\\n # print(i)\\n grummpyCustomer[i] += grummpyCustomer[i+1]\\n \\n # print(customers[0] - customers[0+X] + grummpyCustomer[0+X])\\n maxSum = grummpyCustomer[0]\\n for i in reversed(list(range(L-X))):\\n # print(i,'ok')\\n result = max(result, tempCustomers[i] - tempCustomers[i+X] + maxSum - grummpyCustomer[i] + grummpyCustomer[i+X])\\n \\n return result\\n\", \"import numpy as np\\n\\nclass Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n customers=np.array(customers)\\n grumpy=np.array(grumpy)\\n total_customers=np.sum(customers)\\n grumpy_array=customers*grumpy\\n secret_array=np.convolve(grumpy_array,np.ones(X,dtype=int),'valid')\\n index=np.where(secret_array==secret_array.max())[0][0]\\n grumpy_array[index:index+X]=0\\n satisfied_customers=total_customers-grumpy_array.sum()\\n return satisfied_customers\\n\", \"import numpy as np\\n\\nclass Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n customers = np.array(customers)\\n grumpy = 1 - np.array(grumpy)\\n l = []\\n m = sum(customers * grumpy)\\n\\n for i in range(len(customers) - X + 1):\\n if i == 0:\\n best_case = sum(customers[0:X])\\n diff = sum(grumpy[0:X] * customers[0:X])\\n\\n grump_days = best_case - diff\\n l.append(grump_days)\\n\\n else:\\n best_case = best_case - customers[i - 1] + customers[i + X - 1]\\n diff = diff - grumpy[i - 1]*customers[i - 1] + grumpy[i + X - 1]*customers[i + X - 1]\\n\\n grump_days = best_case - diff\\n l.append(grump_days)\\n\\n return max(l) + m\", \"import itertools as it\\n\\n\\nclass Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n self.customers = customers\\n self.grumpy = grumpy\\n self.n = len(customers)\\n # if len(grumpy) != self.n:\\n # raise ValueError(f\\\\\\\"Customers {customers} and grumpy {grumpy} arrays must have the same length.\\\\\\\")\\n self.cumulative_customers = list(it.accumulate(customers, initial=0))\\n self.technique_length = X\\n return self.satisfy(0, 1)\\n \\n @lru_cache(None)\\n def satisfy(self, index: int, secret_technique: int) -> int:\\n if index >= self.n:\\n return 0\\n satisfaction = self.customers[index] if self.grumpy[index] == 0 else 0\\n if secret_technique == 0:\\n return satisfaction + self.satisfy(index + 1, 0)\\n ans = max(\\n satisfaction\\n + self.satisfy(index + 1, secret_technique),\\n self.cumulative_customers[min(self.n, index + self.technique_length)]\\n - self.cumulative_customers[index]\\n + self.satisfy(index + self.technique_length, secret_technique - 1),\\n )\\n return ans\\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n i = win_of_make_satisfied = satisfied = max_make_satisfied = 0\\n for c, g in zip(customers, grumpy):\\n satisfied += (1 - g) * c\\n win_of_make_satisfied += g * c\\n if i >= X:\\n win_of_make_satisfied -= grumpy[i - X] * customers[i - X]\\n max_make_satisfied = max(win_of_make_satisfied, max_make_satisfied) \\n i += 1 \\n return satisfied + max_make_satisfied \", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n \\n window = [0] * X\\n for a in range(X):\\n if grumpy[a] == 1:\\n window[a] += customers[a]\\n mySum = 0\\n maxAdded = sum(window)\\n right = X\\n for i in range(len(customers)):\\n if i + X < len(customers):\\n window.pop(0)\\n window.append(customers[i+X] if grumpy[i+X] == 1 else 0)\\n if sum(window) > maxAdded: maxAdded = sum(window)\\n if grumpy[i] == 0: mySum += customers[i] \\n \\n return mySum + maxAdded\\n \\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n s = 0\\n\\n for i in range(0,len(customers)):\\n if grumpy[i] == 0:\\n s += customers[i]\\n customers[i] = 0\\n\\n # print(customers)\\n tmp = [sum(customers[:X])]\\n\\n for i in range(X,len(customers)):\\n\\n tmp = tmp + [tmp[-1] + customers[i] - customers[i-X]]\\n\\n\\n return max(tmp) + s\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n satisfied = []\\n satisfied_before = 0\\n satisfied_after = sum([x[0] for x in zip(customers[X:], grumpy[X:]) if not x[1]])\\n for i in range(len(customers) - X + 1):\\n satisfied.append(satisfied_before + sum(customers[i:i+X]) + satisfied_after)\\n if not grumpy[i]:\\n satisfied_before += customers[i]\\n if (i + X) < len(customers) and not grumpy[i + X]:\\n satisfied_after -= customers[i + X]\\n return max(satisfied)\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n N = len(customers)\\n satisfy = 0\\n unsatisfied = []\\n max_value = 0\\n #Base cases\\n if not customers:\\n return []\\n elif not grumpy or N==1:\\n return sum(customers)\\n \\n \\n for i in range(N):\\n if grumpy[i] == 0:\\n satisfy += customers[i]\\n unsatisfied.append(0)\\n \\n else:\\n unsatisfied.append(customers[i])\\n \\n \\n for j in range(N-X+1):\\n sum1 = sum(unsatisfied[j:j+X])\\n \\n max_value = max(max_value,sum1)\\n return (satisfy + max_value)\\n \\n \\n \\n\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n sums = 0\\n maxs = 0\\n for i in range(len(customers)):\\n sums += customers[i]\\n if grumpy[i] == 1:\\n grumpy[i] = customers[i]\\n sums -= grumpy[i]\\n for i in range(len(grumpy) - X+1):\\n maxs = max(sum(grumpy[i: i+X]), maxs)\\n return sums + maxs\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n orig_satisfied_list = [customers[i] * (1-grumpy[i]) for i in range(len(customers))]\\n orig_satisfied = sum(orig_satisfied_list)\\n grumpy_satisfied_list = [customers[i] - orig_satisfied_list[i] for i in range(len(customers))]\\n diff_list = [max(0, grumpy_satisfied_list[i] - orig_satisfied_list[i]) for i in range(len(customers))]\\n #print(orig_satisfied_list)\\n #print(grumpy_satisfied_list)\\n #print(diff_list)\\n #print([sum(diff_list[i:i+X]) for i in range(len(customers)-X+1)])\\n return orig_satisfied + max([sum(diff_list[i:i+X]) for i in range(len(customers)-X+1)])\", \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n satisfaction = 0\\n unsatisfied = []\\n for i in range(len(customers)):\\n if grumpy[i] == 1:\\n unsatisfied.append(customers[i])\\n else:\\n satisfaction += customers[i]\\n unsatisfied.append(0)\\n max_sum = sum(unsatisfied[:X])\\n for i in range(X, len(unsatisfied)+1):\\n max_sum = max(max_sum, sum(unsatisfied[i-X:i]))\\n satisfaction += max_sum\\n return satisfaction\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"maxSatisfied\", \"inputs\": [[[1, 0, 1, 2, 1, 1, 7, 5], [0, 1, 0, 1, 0, 1, 0, 1], 3]], \"outputs\": [16]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/grumpy-bookstore-owner/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n # feel like its sliding window max\n \n window, max_window = 0, 0\n \n # init first window\n for i in range(X):\n if grumpy[i]: window += customers[i]\n max_window = window\n \n # Sliding Window\n for i in range(X,len(grumpy)):\n if grumpy[i-X]: window -= customers[i-X]\n if grumpy[i]: window += customers[i]\n \n if window > max_window: max_window = window\n \n # \n sum = 0\n for i in range(len(grumpy)):\n if grumpy[i] == 0: sum += customers[i]\n return sum + max_window","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n ans=0\n \n cust=0\n for i in range(len(customers)):\n if grumpy[i]==0:\n cust+=customers[i]\n customers[i]=0\n \n cur=0\n best=0\n \n for i,c in enumerate(customers):\n cur+=c\n if i>=X:\n cur-=customers[i-X]\n best=max(best,cur)\n return cust+best\n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n \n wn=min(len(customers),X)\n print(('wn',wn))\n wList=[0]*len(customers)\n \n for i in range(len(customers)):\n if grumpy[i]:\n wList[i]=customers[i]\n else:\n wList[i]=0\n \n print(('list',wList))\n \n mwsum=sum(wList[0:wn])\n nws=mwsum\n print(mwsum)\n for j in range(wn,len(wList)):\n \n nws=nws-wList[j-wn]+wList[j] if wn>1 else wList[j] \n mwsum=max(mwsum,nws)\n print(nws)\n \n for i in range(len(customers)):\n if grumpy[i]==0:\n mwsum+=customers[i]\n return mwsum\n \n \n \n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n no_tech = [0] * len(customers)\n tech = [0] * len(customers)\n \n if len(customers) <= X:\n return sum(customers)\n \n if not grumpy[0]:\n no_tech[0] = customers[0]\n tech[0] = customers[0]\n \n for i in range(1,len(customers)):\n if grumpy[i]:\n no_tech[i] = no_tech[i-1]\n tech[i] = max(sum(customers[max(0, i-X+1):i+1]) + no_tech[i-X], tech[i-1], no_tech[i])\n else:\n no_tech[i] = no_tech[i-1] + customers[i]\n tech[i] = tech[i-1] + customers[i]\n \n # print(customers[max(0, (i-X) + 1) : i+1])\n \n # print(tech)\n # print(no_tech)\n # print()\n \n return tech[-1]","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n base = sum(c for c, g in zip(customers, grumpy) if g == 0)\n ncus = [c if g == 1 else 0 for c, g in zip(customers, grumpy)]\n length = len(customers)\n return base + max(sum(ncus[i:i+X]) for i in range(0, length-X+1))","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n base = sum(c for c, g in zip(customers, grumpy) if g == 0)\n ncus = [c if g == 1 else 0 for c, g in zip(customers, grumpy)]\n length = len(customers)\n return base + max(sum(ncus[i:i+X]) for i in range(0, length-X+1))\n \n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n n = len(customers)\n res = 0\n for k in range(len(customers)):\n if (grumpy[k] == 0):\n res = res + customers[k]\n diff = []\n for j in range(len(customers)):\n diff.append(customers[j]*grumpy[j])\n tem = 0\n for x in range(n - X + 1):\n tem = max(tem, sum(diff[x:x+X]))\n return res + tem\n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n gc = []\n l = len(customers)\n for i in range(l):\n gc.append(customers[i]*grumpy[i])\n \n # print(gc)\n ms = 0\n mi = -1\n for i in range(l-X+1):\n s = sum(gc[i:i+X])\n if s>ms:\n ms = s\n mi = i\n allowed = range(mi, mi+X)\n ans = 0\n for i in range(l):\n if grumpy[i] == 0 or i in allowed:\n ans+= customers[i]\n \n # print(ans)\n return ans","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n base_count = 0\n bonus_array = []\n for i,j in zip(customers,grumpy):\n if j == 0:\n base_count += i\n bonus_array.append(i*j)\n bonus = 0\n \n for i in range(len(customers)-X+1):\n tmp_bonus = 0\n tmp_bonus = sum(bonus_array[i:(i+X)])\n bonus = max(bonus,tmp_bonus)\n \n return base_count + bonus","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n if X>len(customers):\n return sum(customers)\n sum1 = [customers[0]]\n sum2 = []\n if grumpy[0]==0:\n sum2.append(customers[0])\n else:\n sum2.append(0)\n \n for i in range(1,len(customers)):\n sum1.append(sum1[-1]+customers[i])\n if grumpy[i]==0:\n sum2.append(sum2[-1]+customers[i])\n else:\n sum2.append(sum2[-1])\n \n maxi=sum1[X-1]+ (sum2[-1]-sum2[X-1])\n for i in range(1,len(customers)-X+1):\n if (sum1[i+X-1]-sum1[i-1])+(sum2[-1]-sum2[i+X-1]+sum2[i-1])>maxi:\n maxi = (sum1[i+X-1]-sum1[i-1])+(sum2[-1]-sum2[i+X-1]+sum2[i-1])\n \n print(sum1,sum2)\n return maxi","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n inital_sum = 0\n tmp_sum = 0\n res_sum = 0\n length = len(customers)\n for i in range(0,len(customers)):\n if grumpy[i] == 0:\n inital_sum += customers[i]\n tmp_sum = inital_sum\n for j in range(0, X):\n if grumpy[j] == 1:\n tmp_sum = tmp_sum + customers[j]\n res_sum = max(tmp_sum, res_sum)\n k = 1\n while ((k+X-1) < length):\n if grumpy[k-1] == 1:\n tmp_sum = tmp_sum - customers[k-1]\n if grumpy[k+X-1] == 1:\n tmp_sum = tmp_sum + customers[k+X-1]\n k += 1\n res_sum = max(tmp_sum, res_sum)\n return res_sum\n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n totalCusts = 0\n for idx,custs in enumerate(customers):\n if grumpy[idx] == 0:\n totalCusts += customers[idx]\n customers[idx] = 0\n rollingSum = 0\n maxSum = 0\n for i,n in enumerate(customers):\n rollingSum += n\n if i-X >= 0:\n rollingSum -= customers[i-X]\n maxSum = max(maxSum, rollingSum)\n return maxSum+totalCusts\n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n curr_sum = sum([i * abs(j - 1) for i, j in zip(customers, grumpy)])\n max_sum = curr_sum\n \n # first one, check all\n for i in range(X):\n curr_sum += customers[i] * grumpy[i]\n max_sum = max(max_sum, curr_sum)\n \n for i in range(1, len(customers) - X + 1):\n max_sum = max(max_sum, curr_sum)\n curr_sum -= customers[i - 1] * grumpy[i - 1]\n curr_sum += customers[i+X - 1] * grumpy[i+X - 1]\n \n return max(max_sum, curr_sum)\n \n","class Solution:\n# def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n# satisfiedCount = 0\n \n# for i in range(len(customers)):\n# if grumpy[i] == 0:\n# satisfiedCount += customers[i]\n# customers[i] = 0\n \n# maxPotentialCount = 0\n# val = 0\n \n# for i in range(len(customers)):\n# if i < X:\n# val += customers[i]\n# continue\n \n# maxPotentialCount = max(maxPotentialCount, val)\n# val -= customers[i - X]\n# val += customers[i]\n \n# maxPotentialCount = max(maxPotentialCount, val)\n \n# return satisfiedCount + maxPotentialCount\n \n \n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n i = win_of_make_satisfied = satisfied = max_make_satisfied = 0\n for c, g in zip(customers, grumpy):\n satisfied += (1 - g) * c\n win_of_make_satisfied += g * c\n if i >= X:\n win_of_make_satisfied -= grumpy[i - X] * customers[i - X]\n max_make_satisfied = max(win_of_make_satisfied, max_make_satisfied) \n i += 1 \n return satisfied + max_make_satisfied","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n satisfiedCustomers = 0\n for i in range(len(customers)):\n if grumpy[i] == 0:\n satisfiedCustomers += customers[i]\n customers[i] = 0\n i = 0\n unsatisfiedWindow = 0\n while i < X:\n unsatisfiedWindow += customers[i]\n i += 1\n \n maxUnsatisfiedWindow = unsatisfiedWindow\n while i < len(customers):\n unsatisfiedWindow -= customers[i-X]\n unsatisfiedWindow += customers[i]\n maxUnsatisfiedWindow = max(maxUnsatisfiedWindow, unsatisfiedWindow)\n i += 1\n \n return satisfiedCustomers + maxUnsatisfiedWindow\n \n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n max_satisfaction = sum(customers)\n actual_satisfaction = sum(int(not g) * s for g,s in zip(grumpy, customers))\n \n max_s_x = sum(customers[:X])\n actual_s_x = sum(int(not g) * s for g,s in zip(grumpy[:X], customers[:X]))\n \n ans = actual_satisfaction - actual_s_x + max_s_x\n for i in range(X, len(customers)):\n max_s_x += customers[i] - customers[i - X]\n actual_s_x += (customers[i] * int(not grumpy[i])) - (customers[i - X] * int(not grumpy[i - X]))\n ans = max(ans, actual_satisfaction - actual_s_x + max_s_x)\n return ans","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n mp = lp = sum(customers[i] for i in range(X) if grumpy[i])\n mi = 0\n for i in range(1, len(grumpy) - X + 1):\n n = customers[i+X-1] if grumpy[i+X-1] else 0\n o = customers[i-1] if grumpy[i-1] else 0\n lp += (n - o)\n if lp > mp:\n mp = lp\n mi = i\n res = sum([customers[i] for i in range(len(grumpy)) if not grumpy[i]])\n return res + mp\n \n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n tmpCustomers = customers.copy()\n totalSatisfied = 0\n for i in range(len(grumpy)):\n if grumpy[i] == 0:\n totalSatisfied += tmpCustomers[i]\n\n tmpCustomers[i] = 0\n \n \n window = 0\n best = 0\n \n for i in range(len(tmpCustomers)):\n window += tmpCustomers[i]\n if i >= X:\n window -= tmpCustomers[i-X]\n best = max(window,best)\n return totalSatisfied+best\n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n grumpy, grum_sum, cus_sum = [i ^ 1 for i in grumpy], [0] * len(customers), [0] * len(customers)\n grumpy_customers = [customers[i] * grumpy[i] for i in range(len(customers))]\n for i, n in enumerate(customers): cus_sum[i] = n + (cus_sum[i - 1] if i > 0 else 0)\n for i, n in enumerate(grumpy_customers): grum_sum[i] = n + (grum_sum[i - 1] if i > 0 else 0)\n return max((grum_sum[i - 1] if i > 0 else 0) + cus_sum[i + X - 1] - (cus_sum[i - 1] if i > 0 else 0) + grum_sum[len(customers) - 1] - grum_sum[i + X - 1] for i in range(0, len(customers) - X + 1))","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n if X == len(customers):\n return sum(customers)\n sum_not_grumpy = sum(customers[:X])\n sum_normal = sum([x*(1-y) for x,y in zip(customers,grumpy)][X:]) #sum(mults[X:])\n \n max_customers = sum_not_grumpy+sum_normal\n for i in range(1,len(customers)-X+1):\n sum_not_grumpy -= customers[i-1]\n sum_not_grumpy += customers[i+X-1]\n sum_normal += customers[i-1]*(1 - grumpy[i-1])\n sum_normal -= customers[i+X-1]*(1 - grumpy[i+X-1])\n max_customers = max(max_customers, sum_not_grumpy+sum_normal)\n\n return max_customers\n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n # sliding window of possible grumping times\n satisfied = 0\n n = len(customers)\n grumpySum = 0\n \n for i in range(X):\n satisfied += customers[i] if grumpy[i] == 0 else 0\n \n saved = customers[i] if grumpy[i] == 1 else 0\n grumpySum += saved\n\n noGrump = grumpySum\n for i in range(X, n):\n satisfied += customers[i] if not grumpy[i] else 0\n \n saved = customers[i] if grumpy[i] else 0\n abandon = customers[i - X] if grumpy[i - X] else 0\n grumpySum = grumpySum + saved - abandon\n noGrump = max(noGrump, grumpySum)\n\n return satisfied + noGrump\n \n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n gain = 0\n for i in range(X):\n if grumpy[i]:\n gain += customers[i]\n max_gain = gain\n for i in range(X, len(customers)):\n gain = gain + customers[i]*grumpy[i] - customers[i-X]*grumpy[i-X]\n max_gain = max(max_gain, gain)\n statify = 0\n for i in range(len(customers)):\n statify += customers[i]*(1-grumpy[i])\n return statify + max_gain","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n n, window_sum = len(customers), 0 \n for i in range(n):\n if i < X:\n window_sum += customers[i]\n else:\n window_sum += (1 - grumpy[i]) * customers[i]\n \n result = window_sum # 求得指針未滑動前總和\n left, right = 0, X\n \n while right < n:\n if grumpy[right] == 1:\n window_sum += customers[right]\n if grumpy[left] == 1:\n window_sum -= customers[left]\n result = max(result, window_sum)\n left += 1\n right += 1\n \n return result\n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n satisfy = sum(cust for cust, grump in zip(customers, grumpy) if grump == 0)\n max_extra = extra = sum(cust for cust, grump in zip(customers[:X], grumpy[:X]) if grump == 1)\n start, end = 0, X\n n = len(customers)\n while end < n:\n extra += grumpy[end] * customers[end]\n extra -= grumpy[start] * customers[start]\n max_extra = max(max_extra, extra)\n start += 1\n end += 1\n return satisfy + max_extra\n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n n = len(customers)\n if n == 0:\n return 0\n \n running_sum = 0\n \n for i in range(n):\n if i < X:\n running_sum += customers[i]\n else:\n running_sum += customers[i] * (1-grumpy[i])\n \n left, right = 0, X\n ans = running_sum\n \n while right < n:\n if grumpy[right] == 1:\n running_sum += customers[right]\n right += 1\n \n if grumpy[left] == 1:\n running_sum -= customers[left]\n \n left += 1\n \n ans = max(ans, running_sum)\n \n return ans","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n n = len(customers)\n cnt = 0\n acc = [0]\n \n for i in range(n):\n if grumpy[i]:\n acc.append(acc[-1]+customers[i])\n else:\n acc.append(acc[-1])\n cnt += customers[i]\n \n ans = cnt\n \n for i in range(n-X+1):\n ans = max(ans, cnt+acc[i+X]-acc[i])\n \n return ans","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n inital_sum = 0\n tmp_sum = 0\n res_sum = 0\n length = len(customers)\n for i in range(0,len(customers)):\n if grumpy[i] == 0:\n inital_sum += customers[i]\n tmp_sum = inital_sum\n print (tmp_sum)\n for j in range(0, X):\n if grumpy[j] == 1:\n tmp_sum = tmp_sum + customers[j]\n print (tmp_sum)\n res_sum = max(tmp_sum, res_sum)\n print (res_sum)\n k = 1\n while ((k+X-1) < length):\n if grumpy[k-1] == 1:\n tmp_sum = tmp_sum - customers[k-1]\n if grumpy[k+X-1] == 1:\n tmp_sum = tmp_sum + customers[k+X-1]\n k += 1\n res_sum = max(tmp_sum, res_sum)\n return res_sum\n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n ans = 0\n L = len(grumpy)\n if X >= L:\n return sum(customers)\n for i in range(L):\n if grumpy[i] == 0:\n ans += customers[i]\n res = cur_sum = 0\n for end in range(X):\n if grumpy[end] == 1:\n cur_sum += customers[end]\n res = cur_sum\n for end in range(X, L):\n if grumpy[end] == 1:\n cur_sum += customers[end]\n if grumpy[end - X] == 1:\n cur_sum -= customers[end - X]\n res = max(res, cur_sum)\n return ans + res","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n already_happy = sum(c for c, h in zip(customers, grumpy) if not h)\n \n running = sum(c for c, h in zip(customers[:X], grumpy[:X]) if h)\n \n max_happy = running\n for i in range(1, len(customers) - X + 1):\n if grumpy[i - 1] == 1:\n running -= customers[i - 1]\n if grumpy[i + X - 1] == 1:\n running += customers[i + X - 1]\n max_happy = max(running, max_happy) \n \n return max_happy + already_happy\n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n \n \n L = len(grumpy)\n if L == X:\n return sum(customers)\n # print(L,X)\n grummpyCustomer = [0 if grumpy[i] == 1 else customers[i] for i in range(L) ]\n for i in range(1,L):\n customers[i] += customers[i-1]\n \n \n for i in range(1,L):\n grummpyCustomer[i] += grummpyCustomer[i-1]\n \n \n \n result = 0\n \n maxSum = grummpyCustomer[-1]\n for i in range(X, L):\n result = max(result, customers[i] - customers[i-X] + maxSum - grummpyCustomer[i] + grummpyCustomer[i-X])\n # print(result)\n \n \n for i in reversed(list(range(1,L))):\n customers[i] -= customers[i-1]\n # print(customers)\n \n grummpyCustomer = [0 if grumpy[i] == 1 else customers[i] for i in range(L) ]\n \n for i in reversed(list(range(L-1))):\n customers[i] += customers[i+1]\n \n for i in reversed(list(range(L-1))):\n # print(i)\n grummpyCustomer[i] += grummpyCustomer[i+1]\n \n # print(customers[0] - customers[0+X] + grummpyCustomer[0+X])\n maxSum = grummpyCustomer[0]\n for i in reversed(list(range(L-X))):\n # print(i,'ok')\n result = max(result, customers[i] - customers[i+X] + maxSum - grummpyCustomer[i] + grummpyCustomer[i+X])\n \n return result\n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], k: int) -> int:\n n=len(customers)\n res=sum([customers[i]*(1-grumpy[i]) for i in range(n)]) # the customers you can obtain while non grumpy\n best_gain=sum([customers[i]*grumpy[i] for i in range(k)]) # first window\n gain=best_gain\n for i in range(k,n):\n gain+=customers[i]*grumpy[i]-customers[i-k]*grumpy[i-k] # add new, kick out old\n best_gain=max(gain,best_gain) \n return res+best_gain","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n max_satisfaction = sum(customers)\n actual_satisfaction = sum(int(not g) * s for g,s in zip(grumpy, customers))\n \n max_s_x = sum(customers[:X])\n actual_s_x = sum(int(not g) * s for g,s in zip(grumpy[:X], customers[:X]))\n \n ans = actual_satisfaction - actual_s_x + max_s_x\n print(max_satisfaction, actual_satisfaction)\n print('sssssssss')\n for i in range(X, len(customers)):\n print(max_s_x, actual_s_x, customers[i], customers[i - X])\n max_s_x += customers[i] - customers[i - X]\n actual_s_x += (customers[i] * int(not grumpy[i])) - (customers[i - X] * int(not grumpy[i - X]))\n ans = max(ans, actual_satisfaction - actual_s_x + max_s_x)\n return ans","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n curr = 0\n max1 = 0\n left =0\n for i in range(len(customers)):\n if i <X:\n curr += customers[i]\n else:\n if grumpy[i] == 0:\n curr+= customers[i]\n max1 = curr\n for i in range(X,len(customers)):\n if grumpy[i] == 1:\n curr+=customers[i]\n if grumpy[left] == 1:\n curr-=customers[left]\n left+=1\n max1 = max(max1,curr)\n return max1","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n if X == len(customers):\n return sum(customers)\n for i in range(len(grumpy)):\n grumpy[i] = 0 if grumpy[i] == 1 else 1\n mults = [x*y for x,y in zip(customers,grumpy)]\n sum_not_grumpy = sum(customers[:X])\n not_grumpy = [sum_not_grumpy] \n for i in range(1,len(customers)-X+1):\n sum_not_grumpy -= customers[i-1]\n sum_not_grumpy += customers[i+X-1]\n not_grumpy.append(sum_not_grumpy)\n \n sum_normal = sum(mults[X:])\n normal_custs = [sum_normal]\n for i in range(1,len(mults)-X+1):\n sum_normal += mults[i-1]\n sum_normal -= mults[i+X-1]\n normal_custs.append(sum_normal)\n \n print(not_grumpy)\n print(normal_custs)\n return max([x+y for x,y in zip(not_grumpy,normal_custs)])\n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n old = 0\n for i in range(len(customers)):\n if grumpy[i] == 0:\n old += customers[i]\n l, r, res = 0, 0, 0\n while r < len(customers):\n if grumpy[r] == 1:\n old += customers[r]\n if r >= X:\n if grumpy[l] == 1:\n old -= customers[l]\n l += 1\n res = max(res, old)\n r += 1\n return res","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n # we want to find the biggest loss of satisfaction in a X-hr period throughout the day.\n if len(customers) == X: return sum(customers)\n maxLoss = 0\n total = sum([customers[i]*(1-grumpy[i]) for i in range(len(grumpy))])\n print(total)\n loss = sum([grumpy[i]*customers[i] for i in range(X)])\n maxLoss = loss\n for i in range(X, len(customers)):\n loss += grumpy[i]*customers[i]\n loss -= grumpy[i-X]*customers[i-X]\n maxLoss = max(maxLoss, loss)\n total += maxLoss\n return total\n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n if not customers:\n return 0\n can_be_always_happy = X == len(customers)\n customers_lost = [0] * (len(customers) + 1)\n total_customers_lost = 0\n total_satisfied = 0\n for idx, customer in enumerate(customers):\n if grumpy[idx] == 1 and not can_be_always_happy:\n total_customers_lost += customers[idx]\n else:\n total_satisfied += customers[idx]\n customers_lost[idx + 1] = total_customers_lost\n\n max_gain = 0\n for i in range(X, len(customers_lost)):\n gain = customers_lost[i] - customers_lost[i - X]\n max_gain = max(gain, max_gain)\n\n return total_satisfied + max_gain","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n if X == len(customers):\n return sum(customers)\n for i in range(len(grumpy)):\n grumpy[i] = 0 if grumpy[i] == 1 else 1\n mults = [x*y for x,y in zip(customers,grumpy)]\n sum_not_grumpy = sum(customers[:X])\n sum_normal = sum(mults[X:])\n \n max_customers = sum_not_grumpy+sum_normal\n for i in range(1,len(customers)-X+1):\n sum_not_grumpy -= customers[i-1]\n sum_not_grumpy += customers[i+X-1]\n sum_normal += mults[i-1]\n sum_normal -= mults[i+X-1]\n max_customers = max(max_customers, sum_not_grumpy+sum_normal)\n\n return max_customers\n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n if X == len(customers):\n return sum(customers)\n for i in range(len(grumpy)):\n grumpy[i] = 0 if grumpy[i] == 1 else 1\n mults = [x*y for x,y in zip(customers,grumpy)]\n sum_not_grumpy = sum(customers[:X])\n #not_grumpy = [sum_not_grumpy] \n sum_normal = sum(mults[X:])\n #normal_custs = [sum_normal]\n \n max_customers = sum_not_grumpy+sum_normal\n for i in range(1,len(customers)-X+1):\n sum_not_grumpy -= customers[i-1]\n sum_not_grumpy += customers[i+X-1]\n sum_normal += mults[i-1]\n sum_normal -= mults[i+X-1]\n max_customers = max(max_customers, sum_not_grumpy+sum_normal)\n\n return max_customers\n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n saved = 0\n max_saved = 0\n sumTotal = 0\n for i, value in enumerate(customers):\n if i - X >= 0 and grumpy[i - X]:\n saved -= customers[i - X]\n if grumpy[i]:\n saved += value\n else:\n sumTotal += value\n max_saved = max(max_saved, saved)\n print((saved,max_saved))\n # print(saved, max_saved, sumTotal)\n return sumTotal + max_saved\n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n to_ret = sum([c for c, g in zip(customers, grumpy) if g == 0])\n \n mt = mf = sum([c for c, g in zip(customers[:X], grumpy[:X]) if g == 1])\n for t in range(X, len(customers)) :\n if grumpy[t] == 1 :\n mt += customers[t]\n if grumpy[t-X] == 1 :\n mt -= customers[t-X]\n mf = max(mf, mt)\n return to_ret + mf","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n satisfiedCount = 0\n \n for i in range(len(customers)):\n if grumpy[i] == 0:\n satisfiedCount += customers[i]\n customers[i] = 0\n \n maxPotentialCount = 0\n val = 0\n \n for i in range(len(customers)):\n if i < X:\n val += customers[i]\n continue\n \n maxPotentialCount = max(maxPotentialCount, val)\n val -= customers[i - X]\n val += customers[i]\n \n maxPotentialCount = max(maxPotentialCount, val)\n \n return satisfiedCount + maxPotentialCount","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n i = win_of_make_satisfied = satisfied = max_make_satisfied = 0\n for c, g in zip(customers, grumpy):\n satisfied += (1 - g) * c\n win_of_make_satisfied += g * c\n if i >= X:\n win_of_make_satisfied -= grumpy[i - X] * customers[i - X]\n max_make_satisfied = max(win_of_make_satisfied, max_make_satisfied) \n i += 1 \n return satisfied + max_make_satisfied\n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n lb, ub = 0, X-1\n total = sum([customers[i] * (1 - grumpy[i]) for i in range(len(customers))])\n \n saved = 0\n for i in range(X):\n if grumpy[i]: saved += customers[i]\n \n ans = total + saved\n while ub + 1 < len(grumpy):\n lb, ub = lb + 1, ub + 1\n if grumpy[lb-1]:\n saved -= customers[lb-1]\n if grumpy[ub]:\n saved += customers[ub]\n ans = max(ans, total+saved)\n return ans","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n gains = [x if grumpy[i] == 1 else 0 for (i, x) in enumerate(customers)]\n fact = [x if grumpy[i] == 0 else 0 for (i, x) in enumerate(customers)]\n \n if X > len(gains):\n return sum(customers)\n \n current_sum = sum(gains[:X])\n max_gain = current_sum\n for i in range(1, len(gains) - X + 1):\n current_sum = current_sum - gains[i - 1] + gains[i + X - 1]\n max_gain = max(max_gain, current_sum)\n \n return sum(fact) + max_gain\n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n n = len(grumpy)\n if X >= n:\n return sum(customers)\n init = sum([customers[i]*(1-grumpy[i]) for i in range(n)])\n \n for j in range(X):\n if grumpy[j] == 1:\n init += customers[j]\n max_l = init \n temp = init\n for i in range(1, n-X+1):\n temp -= grumpy[i-1]*customers[i-1]\n temp += grumpy[i+X-1]*customers[i+X-1]\n max_l = max(max_l, temp)\n \n return max_l","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n initial = sum(num for day, num in enumerate(customers) if grumpy[day] == 0)\n curr_tricked = 0\n tricked = 0\n for ind, num in enumerate(customers):\n if ind >= X and grumpy[ind-X] == 1:\n curr_tricked -= customers[ind-X]\n if grumpy[ind] == 1:\n curr_tricked += customers[ind]\n tricked = max(tricked, curr_tricked)\n return initial + tricked","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n t=0\n for i in range(len(grumpy)):\n if grumpy[i]==0:\n t+=customers[i]\n customers[i]=0\n\n n=sum(customers[:X])\n m=n\n for i in range(1,len(customers)-X+1):\n m=m+customers[i+X-1]-customers[i-1]\n n=max(m,n)\n return n+t","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n if X == len(customers):\n return sum(customers)\n sum_not_grumpy = sum(customers[:X])\n sum_normal = sum([x*(1-y) for x,y in zip(customers[X:],grumpy[X:])]) \n \n max_customers = sum_not_grumpy+sum_normal\n for i in range(1,len(customers)-X+1):\n sum_not_grumpy -= customers[i-1]\n sum_not_grumpy += customers[i+X-1]\n sum_normal += customers[i-1]*(1 - grumpy[i-1])\n sum_normal -= customers[i+X-1]*(1 - grumpy[i+X-1])\n max_customers = max(max_customers, sum_not_grumpy+sum_normal)\n\n return max_customers\n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n satisfied = 0\n for i in range(len(grumpy)):\n if grumpy[i] == 0:\n satisfied += customers[i]\n windowMax = 0\n curr = 0\n for i in range(len(customers)):\n curr += ((grumpy[i]) * customers[i])\n if i >= X:\n curr -= ((grumpy[i - X]) * customers[i - X])\n windowMax = max(windowMax, curr)\n return satisfied + windowMax\n","import numpy as np\n\nclass Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n #satisfiedCustomer = sum(customers) - sum(np.multiply(customers,grumpy))\n \n satisfiedCustomer = 0\n for i in range(len(customers)):\n if not grumpy[i]:\n satisfiedCustomer += customers[i]\n \n window = 0\n for i in range(X):\n if grumpy[i] == 1:\n window+=customers[i]\n \n \n res = window\n \n for i in range(1,len(customers)-X+1):\n last = i-1\n if grumpy[last]==1:\n window -= customers[last]\n nextIdx = i+X-1\n if grumpy[nextIdx]==1:\n window += customers[nextIdx]\n \n res = max(res,window)\n \n \n return (res+satisfiedCustomer)\n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n total = sum(c for i, c in enumerate(customers) if grumpy[i] == 0)\n add = sum(c for i, c in enumerate(customers[:X]) if grumpy[i] == 1)\n res = total + add\n #print(total, add, res)\n for i in range(X, len(customers)):\n if grumpy[i] == 1:\n add += customers[i]\n if grumpy[i - X] == 1:\n add -= customers[i - X]\n res = max(res, total + add)\n #print(total, add, res)\n return res\n","class Solution:\n def maxSatisfied(self, A: List[int], G: List[int], X: int) -> int:\n res = 0\n s = 0\n ws = 0\n left = []\n for i in range(len(A)):\n c, g = A[i], G[i]\n s += (1-g)*c\n ws += g*c\n if i>=X:\n ws -= A[i-X] * G[i-X]\n res = max(res, ws)\n # print(i,j,s,res)\n return res+s","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n i = win_of_make_satisfied = satisfied = max_make_satisfied = 0\n for c, g in zip(customers, grumpy):\n satisfied += (1 - g) * c\n win_of_make_satisfied += g * c\n if i >= X:\n win_of_make_satisfied -= grumpy[i - X] * customers[i - X]\n max_make_satisfied = max(win_of_make_satisfied, max_make_satisfied) \n i += 1 \n return satisfied + max_make_satisfied\n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n n=len(customers)\n res=sum([customers[i]*(1-grumpy[i]) for i in range(n)])\n best_gain=sum([customers[i]*grumpy[i] for i in range(X)])\n gain=best_gain\n for i in range(X,n):\n gain+=customers[i]*grumpy[i]-customers[i-X]*grumpy[i-X]\n best_gain=max(best_gain,gain)\n return res+best_gain","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n if X == len(customers):\n return sum(customers)\n for i in range(len(grumpy)):\n grumpy[i] = 0 if grumpy[i] == 1 else 1\n mults = [x*y for x,y in zip(customers,grumpy)]\n sum_not_grumpy = sum(customers[:X])\n not_grumpy = [sum_not_grumpy] \n sum_normal = sum(mults[X:])\n normal_custs = [sum_normal]\n \n for i in range(1,len(customers)-X+1):\n sum_not_grumpy -= customers[i-1]\n sum_not_grumpy += customers[i+X-1]\n not_grumpy.append(sum_not_grumpy)\n sum_normal += mults[i-1]\n sum_normal -= mults[i+X-1]\n normal_custs.append(sum_normal)\n \n return max([x+y for x,y in zip(not_grumpy,normal_custs)])\n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n N = len(grumpy)\n \n already_happy = sum(customers[i] for i in range(N) if not grumpy[i])\n \n window = sum(customers[i] for i in range(X) if grumpy[i])\n \n max_bonus = window\n for r in range(X, N):\n window -= customers[r - X] if grumpy[r - X] else 0\n window += customers[r] if grumpy[r] else 0\n max_bonus = max(max_bonus, window)\n \n return already_happy + max_bonus","class Solution:\n \n def maxSatisfied(self, customers: List[int], grumpy: List[int], window_size: int) -> int:\n \n\n already_satisfied = 0\n for index in range(len(customers)):\n if grumpy[index] == 0:\n already_satisfied += customers[index]\n customers[index] = 0\n \n \n best_satisfied = 0\n \n satisfied = 0\n for index, customer in enumerate(customers):\n satisfied += customer\n \n if index >= window_size:\n satisfied -= customers[index - window_size]\n \n best_satisfied = max(best_satisfied, satisfied)\n \n \n return best_satisfied + already_satisfied\n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n \n satisfiedCustomer = 0\n for i in range(len(customers)):\n if not grumpy[i]:\n satisfiedCustomer += customers[i]\n \n window = 0\n for i in range(X):\n if grumpy[i] == 1:\n window+=customers[i]\n \n res = window\n for i in range(1,len(customers)-X+1):\n last = i-1\n if grumpy[last]==1:\n window -= customers[last]\n nextIdx = i+X-1\n if grumpy[nextIdx]==1:\n window += customers[nextIdx]\n \n res = max(res,window)\n \n \n return (res+satisfiedCustomer)\n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n disSatisfy = [c*g for c,g in zip(customers, grumpy)]\n start = 0\n grumpy_num = 0\n for i in range(X):\n grumpy_num += disSatisfy[i]\n\n remaining = grumpy_num\n for j in range(X, len(customers)):\n remaining = remaining-disSatisfy[j-X]+disSatisfy[j]\n if remaining>grumpy_num:\n grumpy_num = remaining\n start = j-X+1\n\n for k in range(start, start+X):\n grumpy[k]=0\n\n return sum([ c if g==0 else 0 for c,g in zip(customers, grumpy)])\n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int: \n n = len(customers)\n \n start = 0\n \n curSatisfaction = sum(customers[i] for i in range(n) if grumpy[i] == 0)\n \n maxSatisfaction = 0\n \n for end in range(len(customers)):\n if grumpy[end] == 1:\n curSatisfaction += customers[end]\n \n if end - start + 1 > X:\n if grumpy[start] == 1:\n curSatisfaction -= customers[start]\n start += 1\n \n maxSatisfaction = max(maxSatisfaction, curSatisfaction)\n \n return maxSatisfaction","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n start=0\n end=X\n ans=0\n for i in range(len(grumpy)):\n if grumpy[i]==0:\n ans+=customers[i]\n t=0\n for i in range(X):\n if grumpy[i]==1:\n t+=customers[i]\n maxs=0\n while end<len(grumpy)+1:\n if t>maxs:\n maxs=t\n if end==len(grumpy):\n break\n if grumpy[start]==1:\n t-=customers[start]\n if grumpy[end]==1:\n t+=customers[end]\n start+=1\n end+=1\n return ans+maxs","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n total = 0\n \n for i in range(len(customers)):\n total += (1-grumpy[i]) * customers[i]\n grumpy[i] *= customers[i]\n \n maxsum = 0\n for i in range(X):\n maxsum += grumpy[i]\n cur = maxsum\n for j in range(X, len(grumpy)):\n i = j-X\n cur += grumpy[j]\n cur -= grumpy[i]\n maxsum = max(maxsum, cur)\n #print(maxsum)\n return total + maxsum\n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n n = len(customers)\n sum_cus = sum(customers)\n for i in range(n):\n customers[i] *= grumpy[i]\n window = 0\n max_secret_satisfied = -math.inf\n left, right = 0, 0\n while right < n:\n window += customers[right]\n right += 1\n while right - left >= X:\n max_secret_satisfied = max(max_secret_satisfied, window)\n window -= customers[left]\n left += 1\n return sum_cus - (sum(customers) - max_secret_satisfied)","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n #happy owner means happy customer as well \n happy_owner_cust = 0 \n \n for pos in range(len(customers)):\n if grumpy[pos] == 0: #happy owner \n happy_owner_cust += customers[pos]\n customers[pos] = 0 \n \n \n #then build upon using the grumpy owner power. \n \n calming_owner_cust = 0 \n best_calmed_cust = 0 \n \n for end in range(len(customers)): \n calming_owner_cust += customers[end]\n \n \n \n if end >= X: #subtract out the extra calming technique from the owner \n calming_owner_cust -= customers[end - X]\n \n best_calmed_cust = max(best_calmed_cust, calming_owner_cust)\n \n \n \n \n return happy_owner_cust + best_calmed_cust\n \n# #TRY 8/10/2020 \n# class Solution:\n# def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n# #Input: Customers[i] how many customers enter for that exact minute \n \n# #Constraint \n# #owner -> opens store up to customers.len()\n# #Every minute there are customers entering the store. And all those customers leave after the end of the minute \n \n# #If owner is grumpy on i-th minute grumpy[i] = 1 else grumpy[i] = 0. When the bookstore owner is angry \n# #The customers of that minute aren't satisfied else if owner isn't grumpy then customers are happy. \n \n# # Bookstore owner can be NOT angry for X minutes but can use it ONLY once. \n \n# #WANT: max number of customers that are happy throughout the day. \n \n \n# minutes_opened = len(customers) \n# customer_happy_time = 0 \n \n# #Try to basically keep your grumpy minutes down based on the highest number of customers there are. \n \n# start = 0 \n# end = 0 \n# rush_hour = collections.deque() #this is based on the most amount of customers. \n# calm_owner = collections.deque()\n# #Our best number of customer being happy will be based on the largest amount of customers\n# #That's our best bet. \n# while end < minutes_opened: \n# if customers[end] == 0: #No Customers go in owner can be angry \n# end += 1 \n# continue \n \n# cur_happy_time += customers[end]\n# if grumpy[end] == 1: #owner angry = customer angry: Just try calming here then. \n \n \n \n# rush_hour.append(end)\n\n# class Solution():\n# def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n# m = s = tmp = 0\n# for i in range(len(customers)):\n# if not grumpy[i]: \n# s += customers[i] # sum of satisfied customers\n# customers[i] = 0 \n# else: tmp += customers[i] # sum of grumpy customers \n# if i>=X: tmp -= customers[i-X] # remove the leftmost element to keep the sliding window with # of X\n# m = max(m, tmp) # max # of satisfied grumpy customers with a secret technique\n# return s+m\n \n \n# class Solution:\n# def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n# # Part 1 requires counting how many customers\n# # are already satisfied, and removing them\n# # from the customer list.\n# #These customers are those who didn't have to fight with the owner to be happy.\n# already_satisfied = 0\n# for i in range(len(grumpy)):\n# if grumpy[i] == 0: #He's happy so add the customer. \n# already_satisfied += customers[i]\n# customers[i] = 0 #set you back to zero to not visit you. When doing the offset for the window \n \n# # Part 2 requires finding the optimal number\n# # of unhappy customers we can make happy.\n# best_we_can_make_satisfied = 0\n# current_satisfied = 0\n# for i, customers_at_time in enumerate(customers):\n# # if customers[i] == 0: CAN'T DO THIS CUZ WE'RE NOT UPDATING THE WINDOW THEN AT THIS POINT (I.E THE START WINDOW)\n# # continue\n# #Add the customer so far\n# current_satisfied += customers_at_time # Add current to rolling total\n# if i >= X: # We need to remove some from the rolling total #We need to update and try the grumpy intervals to block out owner from \n# #Being grumpy so we can add these happy customers but at this point\n# #There's too much calming power used by owner so we need to remove the beginning window of the current_satisifed. \n# current_satisfied -= customers[i - X]\n# best_we_can_make_satisfied = max(best_we_can_make_satisfied, current_satisfied)\n \n# # The answer is the sum of the solutions for the 2 parts.\n# return already_satisfied + best_we_can_make_satisfied\n \n \nclass Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n always_happy = 0 \n for pos in range(len(customers)): \n if grumpy[pos] == 0: \n always_happy += customers[pos]\n customers[pos] = 0 \n \n happy_use = 0 \n cur_happy_customers = 0 \n \n for pos in range(len(customers)): \n cur_happy_customers += customers[pos]\n \n if pos >= X: \n cur_happy_customers -= customers[pos - X]\n \n \n happy_use = max(happy_use, cur_happy_customers)\n \n return always_happy + happy_use ","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n if len(customers) <= X:\n return sum(customers)\n \n \n satisfied_customers = 0\n current_unsatisfied_customers = 0\n max_unsatisfied_customers = 0\n \n for i in range(len(customers)):\n if i >= X and grumpy[i-X] == 1:\n current_unsatisfied_customers -= customers[i-X]\n \n if grumpy[i] == 0:\n satisfied_customers += customers[i]\n else:\n current_unsatisfied_customers += customers[i]\n \n max_unsatisfied_customers = max(max_unsatisfied_customers, current_unsatisfied_customers)\n \n return satisfied_customers + max_unsatisfied_customers\n \n \n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n if X == len(customers):\n return sum(customers)\n for i in range(len(grumpy)):\n grumpy[i] = 0 if grumpy[i] == 1 else 1\n mults = [x*y for x,y in zip(customers,grumpy)]\n sum_not_grumpy = sum(customers[:X])\n not_grumpy = [sum_not_grumpy] \n sum_normal = sum(mults[X:])\n normal_custs = [sum_normal]\n for i in range(1,len(customers)-X+1):\n sum_not_grumpy -= customers[i-1]\n sum_not_grumpy += customers[i+X-1]\n not_grumpy.append(sum_not_grumpy)\n sum_normal += mults[i-1]\n sum_normal -= mults[i+X-1]\n normal_custs.append(sum_normal)\n \n \n \n \n print(not_grumpy)\n print(normal_custs)\n return max([x+y for x,y in zip(not_grumpy,normal_custs)])\n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n satisfied = 0 \n for i in range(len(customers)):\n satisfied += customers[i] * (grumpy[i] == 0)\n \n p = X \n best_imp = sum([customers[i] for i in range(p) if grumpy[i] == 1])\n imp = best_imp\n while p < len(grumpy):\n if grumpy[p] == 1:\n imp += customers[p]\n if grumpy[p - X] == 1:\n imp -= customers[p - X]\n if imp > best_imp:\n best_imp = imp\n \n p += 1\n \n return satisfied + best_imp \n \n \n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n i = win_of_make_satisfied = satisfied = max_make_satisfied = 0\n for c, g in zip(customers, grumpy):\n satisfied += (1 - g) * c\n win_of_make_satisfied += g * c\n if i >= X:\n win_of_make_satisfied -= grumpy[i - X] * customers[i - X]\n max_make_satisfied = max(win_of_make_satisfied, max_make_satisfied) \n i += 1\n return satisfied + max_make_satisfied","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n curr_running_delta = 0\n max_delta = (-2**31, None) # max sum, end idx\n \n for i in range(len(customers)):\n curr_running_delta += customers[i]*grumpy[i]\n \n if i >= X - 1:\n if curr_running_delta > max_delta[0]:\n max_delta = (curr_running_delta, i)\n \n if grumpy[i - (X-1)] == 1:\n curr_running_delta -= customers[i - (X-1)]\n \n max_satisfied = 0\n for i in range(len(customers)):\n if max_delta[1] - (X-1) <= i <= max_delta[1] or grumpy[i] == 0:\n max_satisfied += customers[i]\n \n return max_satisfied\n \n # time O(n)\n # space O(1)\n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n # sliding window of possible grumping times\n satisfied = 0\n n = len(customers)\n grumpySum = [0]*(n - X + 1)\n \n for i in range(X):\n satisfied += customers[i] if grumpy[i]==0 else 0\n \n saved = customers[i] if grumpy[i]==1 else 0\n grumpySum[0] += saved\n\n noGrump = grumpySum[0]\n for i in range(X, n):\n satisfied += customers[i] if not grumpy[i] else 0\n \n saved = customers[i] if grumpy[i] else 0\n abandon = customers[i - X] if grumpy[i - X] else 0\n grumpySum[i - X + 1] = grumpySum[i - X] + saved - abandon\n noGrump = max(noGrump, grumpySum[i - X + 1])\n\n return satisfied + noGrump\n \n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n without_x = 0\n for i, b in enumerate(grumpy):\n if not b:\n without_x += customers[i]\n \n with_x = [0]*len(customers)\n \n extra = 0\n for i, b in enumerate(grumpy[:X]):\n if b:\n extra += customers[i]\n \n with_x[0] += extra\n \n for i in range(len(grumpy)):\n if i + X >= len(grumpy):\n break\n \n extra -= 0 if not grumpy[i] else customers[i]\n extra += 0 if not grumpy[i + X ] else customers[i + X]\n with_x[i + 1] += extra\n \n return max(with_x) + without_x","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int],\n X: int) -> int:\n already_satisfied = 0\n for i in range(len(grumpy)):\n if grumpy[i] == 0:\n already_satisfied += customers[i]\n customers[i] = 0\n\n best_we_can_make_satisfied = 0\n current_satisfied = 0\n for i, customers_at_time in enumerate(customers):\n current_satisfied += customers_at_time\n if i >= X:\n current_satisfied -= customers[i - X]\n best_we_can_make_satisfied = max(best_we_can_make_satisfied,\n current_satisfied)\n return already_satisfied + best_we_can_make_satisfied\n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n zeroTotal = 0\n for i in range(len(customers)):\n if grumpy[i] == 0:\n zeroTotal += customers[i]\n\n q = deque()\n oneTotal = 0\n largest = 0\n for i in range(len(customers)):\n if grumpy[i] == 1:\n while q and i - q[0][1] >= X:\n oneTotal -= q.popleft()[0]\n q.append((customers[i],i))\n oneTotal += customers[i]\n largest = max(largest, oneTotal)\n return zeroTotal + largest","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n if X == len(customers):\n return sum(customers)\n for i in range(len(grumpy)):\n grumpy[i] = 0 if grumpy[i] == 1 else 1\n mults = [x*y for x,y in zip(customers,grumpy)]\n sum_not_grumpy = sum(customers[:X])\n sum_normal = sum(mults[X:])\n \n max_customers = sum_not_grumpy+sum_normal\n for i in range(1,len(customers)-X+1):\n sum_not_grumpy -= customers[i-1]\n sum_not_grumpy += customers[i+X-1]\n sum_normal += customers[i-1]*grumpy[i-1]#mults[i-1] \n sum_normal -= customers[i+X-1]*grumpy[i+X-1]#mults[i+X-1]\n max_customers = max(max_customers, sum_not_grumpy+sum_normal)\n\n return max_customers\n \n","class Solution:\n def maxSatisfied(self, c: List[int], g: List[int], X: int) -> int:\n arr = [0]\n n = len(g)\n for i in range(n):\n arr.append(arr[-1]+(1-g[i])*c[i])\n \n c = [0]+c\n for i in range(n):\n c[i+1] = c[i]+c[i+1]\n \n m = -1\n for i in range(X,n+1):\n m = max(m,c[i]-c[i-X]-arr[i]+arr[i-X])\n \n print((arr,c,m))\n \n return arr[-1]+m\n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n \n \n L = len(grumpy)\n if L == X:\n return sum(customers)\n # print(L,X)\n tempCustomers = customers.copy()\n grummpyCustomer = [0 if grumpy[i] == 1 else customers[i] for i in range(L) ]\n for i in range(1,L):\n tempCustomers[i] += tempCustomers[i-1]\n \n \n for i in range(1,L):\n grummpyCustomer[i] += grummpyCustomer[i-1]\n \n \n \n result = 0\n \n maxSum = grummpyCustomer[-1]\n for i in range(X, L):\n result = max(result, tempCustomers[i] - tempCustomers[i-X] + maxSum - grummpyCustomer[i] + grummpyCustomer[i-X])\n # print(result)\n \n \n # for i in reversed(range(1,L)):\n # customers[i] -= customers[i-1]\n # print(customers)\n \n grummpyCustomer = [0 if grumpy[i] == 1 else customers[i] for i in range(L) ]\n \n tempCustomers = customers.copy()\n for i in reversed(list(range(L-1))):\n tempCustomers[i] += tempCustomers[i+1]\n \n for i in reversed(list(range(L-1))):\n # print(i)\n grummpyCustomer[i] += grummpyCustomer[i+1]\n \n # print(customers[0] - customers[0+X] + grummpyCustomer[0+X])\n maxSum = grummpyCustomer[0]\n for i in reversed(list(range(L-X))):\n # print(i,'ok')\n result = max(result, tempCustomers[i] - tempCustomers[i+X] + maxSum - grummpyCustomer[i] + grummpyCustomer[i+X])\n \n return result\n","import numpy as np\n\nclass Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n customers=np.array(customers)\n grumpy=np.array(grumpy)\n total_customers=np.sum(customers)\n grumpy_array=customers*grumpy\n secret_array=np.convolve(grumpy_array,np.ones(X,dtype=int),'valid')\n index=np.where(secret_array==secret_array.max())[0][0]\n grumpy_array[index:index+X]=0\n satisfied_customers=total_customers-grumpy_array.sum()\n return satisfied_customers\n","import numpy as np\n\nclass Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n customers = np.array(customers)\n grumpy = 1 - np.array(grumpy)\n l = []\n m = sum(customers * grumpy)\n\n for i in range(len(customers) - X + 1):\n if i == 0:\n best_case = sum(customers[0:X])\n diff = sum(grumpy[0:X] * customers[0:X])\n\n grump_days = best_case - diff\n l.append(grump_days)\n\n else:\n best_case = best_case - customers[i - 1] + customers[i + X - 1]\n diff = diff - grumpy[i - 1]*customers[i - 1] + grumpy[i + X - 1]*customers[i + X - 1]\n\n grump_days = best_case - diff\n l.append(grump_days)\n\n return max(l) + m","import itertools as it\n\n\nclass Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n self.customers = customers\n self.grumpy = grumpy\n self.n = len(customers)\n # if len(grumpy) != self.n:\n # raise ValueError(f\\\"Customers {customers} and grumpy {grumpy} arrays must have the same length.\\\")\n self.cumulative_customers = list(it.accumulate(customers, initial=0))\n self.technique_length = X\n return self.satisfy(0, 1)\n \n @lru_cache(None)\n def satisfy(self, index: int, secret_technique: int) -> int:\n if index >= self.n:\n return 0\n satisfaction = self.customers[index] if self.grumpy[index] == 0 else 0\n if secret_technique == 0:\n return satisfaction + self.satisfy(index + 1, 0)\n ans = max(\n satisfaction\n + self.satisfy(index + 1, secret_technique),\n self.cumulative_customers[min(self.n, index + self.technique_length)]\n - self.cumulative_customers[index]\n + self.satisfy(index + self.technique_length, secret_technique - 1),\n )\n return ans\n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n i = win_of_make_satisfied = satisfied = max_make_satisfied = 0\n for c, g in zip(customers, grumpy):\n satisfied += (1 - g) * c\n win_of_make_satisfied += g * c\n if i >= X:\n win_of_make_satisfied -= grumpy[i - X] * customers[i - X]\n max_make_satisfied = max(win_of_make_satisfied, max_make_satisfied) \n i += 1 \n return satisfied + max_make_satisfied ","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n \n window = [0] * X\n for a in range(X):\n if grumpy[a] == 1:\n window[a] += customers[a]\n mySum = 0\n maxAdded = sum(window)\n right = X\n for i in range(len(customers)):\n if i + X < len(customers):\n window.pop(0)\n window.append(customers[i+X] if grumpy[i+X] == 1 else 0)\n if sum(window) > maxAdded: maxAdded = sum(window)\n if grumpy[i] == 0: mySum += customers[i] \n \n return mySum + maxAdded\n \n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n s = 0\n\n for i in range(0,len(customers)):\n if grumpy[i] == 0:\n s += customers[i]\n customers[i] = 0\n\n # print(customers)\n tmp = [sum(customers[:X])]\n\n for i in range(X,len(customers)):\n\n tmp = tmp + [tmp[-1] + customers[i] - customers[i-X]]\n\n\n return max(tmp) + s","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n satisfied = []\n satisfied_before = 0\n satisfied_after = sum([x[0] for x in zip(customers[X:], grumpy[X:]) if not x[1]])\n for i in range(len(customers) - X + 1):\n satisfied.append(satisfied_before + sum(customers[i:i+X]) + satisfied_after)\n if not grumpy[i]:\n satisfied_before += customers[i]\n if (i + X) < len(customers) and not grumpy[i + X]:\n satisfied_after -= customers[i + X]\n return max(satisfied)","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n N = len(customers)\n satisfy = 0\n unsatisfied = []\n max_value = 0\n #Base cases\n if not customers:\n return []\n elif not grumpy or N==1:\n return sum(customers)\n \n \n for i in range(N):\n if grumpy[i] == 0:\n satisfy += customers[i]\n unsatisfied.append(0)\n \n else:\n unsatisfied.append(customers[i])\n \n \n for j in range(N-X+1):\n sum1 = sum(unsatisfied[j:j+X])\n \n max_value = max(max_value,sum1)\n return (satisfy + max_value)\n \n \n \n","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n sums = 0\n maxs = 0\n for i in range(len(customers)):\n sums += customers[i]\n if grumpy[i] == 1:\n grumpy[i] = customers[i]\n sums -= grumpy[i]\n for i in range(len(grumpy) - X+1):\n maxs = max(sum(grumpy[i: i+X]), maxs)\n return sums + maxs","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n orig_satisfied_list = [customers[i] * (1-grumpy[i]) for i in range(len(customers))]\n orig_satisfied = sum(orig_satisfied_list)\n grumpy_satisfied_list = [customers[i] - orig_satisfied_list[i] for i in range(len(customers))]\n diff_list = [max(0, grumpy_satisfied_list[i] - orig_satisfied_list[i]) for i in range(len(customers))]\n #print(orig_satisfied_list)\n #print(grumpy_satisfied_list)\n #print(diff_list)\n #print([sum(diff_list[i:i+X]) for i in range(len(customers)-X+1)])\n return orig_satisfied + max([sum(diff_list[i:i+X]) for i in range(len(customers)-X+1)])","class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n satisfaction = 0\n unsatisfied = []\n for i in range(len(customers)):\n if grumpy[i] == 1:\n unsatisfied.append(customers[i])\n else:\n satisfaction += customers[i]\n unsatisfied.append(0)\n max_sum = sum(unsatisfied[:X])\n for i in range(X, len(unsatisfied)+1):\n max_sum = max(max_sum, sum(unsatisfied[i-X:i]))\n satisfaction += max_sum\n return satisfaction"],"string":"[\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n # feel like its sliding window max\\n \\n window, max_window = 0, 0\\n \\n # init first window\\n for i in range(X):\\n if grumpy[i]: window += customers[i]\\n max_window = window\\n \\n # Sliding Window\\n for i in range(X,len(grumpy)):\\n if grumpy[i-X]: window -= customers[i-X]\\n if grumpy[i]: window += customers[i]\\n \\n if window > max_window: max_window = window\\n \\n # \\n sum = 0\\n for i in range(len(grumpy)):\\n if grumpy[i] == 0: sum += customers[i]\\n return sum + max_window\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n ans=0\\n \\n cust=0\\n for i in range(len(customers)):\\n if grumpy[i]==0:\\n cust+=customers[i]\\n customers[i]=0\\n \\n cur=0\\n best=0\\n \\n for i,c in enumerate(customers):\\n cur+=c\\n if i>=X:\\n cur-=customers[i-X]\\n best=max(best,cur)\\n return cust+best\\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n \\n wn=min(len(customers),X)\\n print(('wn',wn))\\n wList=[0]*len(customers)\\n \\n for i in range(len(customers)):\\n if grumpy[i]:\\n wList[i]=customers[i]\\n else:\\n wList[i]=0\\n \\n print(('list',wList))\\n \\n mwsum=sum(wList[0:wn])\\n nws=mwsum\\n print(mwsum)\\n for j in range(wn,len(wList)):\\n \\n nws=nws-wList[j-wn]+wList[j] if wn>1 else wList[j] \\n mwsum=max(mwsum,nws)\\n print(nws)\\n \\n for i in range(len(customers)):\\n if grumpy[i]==0:\\n mwsum+=customers[i]\\n return mwsum\\n \\n \\n \\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n no_tech = [0] * len(customers)\\n tech = [0] * len(customers)\\n \\n if len(customers) <= X:\\n return sum(customers)\\n \\n if not grumpy[0]:\\n no_tech[0] = customers[0]\\n tech[0] = customers[0]\\n \\n for i in range(1,len(customers)):\\n if grumpy[i]:\\n no_tech[i] = no_tech[i-1]\\n tech[i] = max(sum(customers[max(0, i-X+1):i+1]) + no_tech[i-X], tech[i-1], no_tech[i])\\n else:\\n no_tech[i] = no_tech[i-1] + customers[i]\\n tech[i] = tech[i-1] + customers[i]\\n \\n # print(customers[max(0, (i-X) + 1) : i+1])\\n \\n # print(tech)\\n # print(no_tech)\\n # print()\\n \\n return tech[-1]\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n base = sum(c for c, g in zip(customers, grumpy) if g == 0)\\n ncus = [c if g == 1 else 0 for c, g in zip(customers, grumpy)]\\n length = len(customers)\\n return base + max(sum(ncus[i:i+X]) for i in range(0, length-X+1))\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n base = sum(c for c, g in zip(customers, grumpy) if g == 0)\\n ncus = [c if g == 1 else 0 for c, g in zip(customers, grumpy)]\\n length = len(customers)\\n return base + max(sum(ncus[i:i+X]) for i in range(0, length-X+1))\\n \\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n n = len(customers)\\n res = 0\\n for k in range(len(customers)):\\n if (grumpy[k] == 0):\\n res = res + customers[k]\\n diff = []\\n for j in range(len(customers)):\\n diff.append(customers[j]*grumpy[j])\\n tem = 0\\n for x in range(n - X + 1):\\n tem = max(tem, sum(diff[x:x+X]))\\n return res + tem\\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n gc = []\\n l = len(customers)\\n for i in range(l):\\n gc.append(customers[i]*grumpy[i])\\n \\n # print(gc)\\n ms = 0\\n mi = -1\\n for i in range(l-X+1):\\n s = sum(gc[i:i+X])\\n if s>ms:\\n ms = s\\n mi = i\\n allowed = range(mi, mi+X)\\n ans = 0\\n for i in range(l):\\n if grumpy[i] == 0 or i in allowed:\\n ans+= customers[i]\\n \\n # print(ans)\\n return ans\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n base_count = 0\\n bonus_array = []\\n for i,j in zip(customers,grumpy):\\n if j == 0:\\n base_count += i\\n bonus_array.append(i*j)\\n bonus = 0\\n \\n for i in range(len(customers)-X+1):\\n tmp_bonus = 0\\n tmp_bonus = sum(bonus_array[i:(i+X)])\\n bonus = max(bonus,tmp_bonus)\\n \\n return base_count + bonus\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X>len(customers):\\n return sum(customers)\\n sum1 = [customers[0]]\\n sum2 = []\\n if grumpy[0]==0:\\n sum2.append(customers[0])\\n else:\\n sum2.append(0)\\n \\n for i in range(1,len(customers)):\\n sum1.append(sum1[-1]+customers[i])\\n if grumpy[i]==0:\\n sum2.append(sum2[-1]+customers[i])\\n else:\\n sum2.append(sum2[-1])\\n \\n maxi=sum1[X-1]+ (sum2[-1]-sum2[X-1])\\n for i in range(1,len(customers)-X+1):\\n if (sum1[i+X-1]-sum1[i-1])+(sum2[-1]-sum2[i+X-1]+sum2[i-1])>maxi:\\n maxi = (sum1[i+X-1]-sum1[i-1])+(sum2[-1]-sum2[i+X-1]+sum2[i-1])\\n \\n print(sum1,sum2)\\n return maxi\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n inital_sum = 0\\n tmp_sum = 0\\n res_sum = 0\\n length = len(customers)\\n for i in range(0,len(customers)):\\n if grumpy[i] == 0:\\n inital_sum += customers[i]\\n tmp_sum = inital_sum\\n for j in range(0, X):\\n if grumpy[j] == 1:\\n tmp_sum = tmp_sum + customers[j]\\n res_sum = max(tmp_sum, res_sum)\\n k = 1\\n while ((k+X-1) < length):\\n if grumpy[k-1] == 1:\\n tmp_sum = tmp_sum - customers[k-1]\\n if grumpy[k+X-1] == 1:\\n tmp_sum = tmp_sum + customers[k+X-1]\\n k += 1\\n res_sum = max(tmp_sum, res_sum)\\n return res_sum\\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n totalCusts = 0\\n for idx,custs in enumerate(customers):\\n if grumpy[idx] == 0:\\n totalCusts += customers[idx]\\n customers[idx] = 0\\n rollingSum = 0\\n maxSum = 0\\n for i,n in enumerate(customers):\\n rollingSum += n\\n if i-X >= 0:\\n rollingSum -= customers[i-X]\\n maxSum = max(maxSum, rollingSum)\\n return maxSum+totalCusts\\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n curr_sum = sum([i * abs(j - 1) for i, j in zip(customers, grumpy)])\\n max_sum = curr_sum\\n \\n # first one, check all\\n for i in range(X):\\n curr_sum += customers[i] * grumpy[i]\\n max_sum = max(max_sum, curr_sum)\\n \\n for i in range(1, len(customers) - X + 1):\\n max_sum = max(max_sum, curr_sum)\\n curr_sum -= customers[i - 1] * grumpy[i - 1]\\n curr_sum += customers[i+X - 1] * grumpy[i+X - 1]\\n \\n return max(max_sum, curr_sum)\\n \\n\",\n \"class Solution:\\n# def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n# satisfiedCount = 0\\n \\n# for i in range(len(customers)):\\n# if grumpy[i] == 0:\\n# satisfiedCount += customers[i]\\n# customers[i] = 0\\n \\n# maxPotentialCount = 0\\n# val = 0\\n \\n# for i in range(len(customers)):\\n# if i < X:\\n# val += customers[i]\\n# continue\\n \\n# maxPotentialCount = max(maxPotentialCount, val)\\n# val -= customers[i - X]\\n# val += customers[i]\\n \\n# maxPotentialCount = max(maxPotentialCount, val)\\n \\n# return satisfiedCount + maxPotentialCount\\n \\n \\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n i = win_of_make_satisfied = satisfied = max_make_satisfied = 0\\n for c, g in zip(customers, grumpy):\\n satisfied += (1 - g) * c\\n win_of_make_satisfied += g * c\\n if i >= X:\\n win_of_make_satisfied -= grumpy[i - X] * customers[i - X]\\n max_make_satisfied = max(win_of_make_satisfied, max_make_satisfied) \\n i += 1 \\n return satisfied + max_make_satisfied\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n satisfiedCustomers = 0\\n for i in range(len(customers)):\\n if grumpy[i] == 0:\\n satisfiedCustomers += customers[i]\\n customers[i] = 0\\n i = 0\\n unsatisfiedWindow = 0\\n while i < X:\\n unsatisfiedWindow += customers[i]\\n i += 1\\n \\n maxUnsatisfiedWindow = unsatisfiedWindow\\n while i < len(customers):\\n unsatisfiedWindow -= customers[i-X]\\n unsatisfiedWindow += customers[i]\\n maxUnsatisfiedWindow = max(maxUnsatisfiedWindow, unsatisfiedWindow)\\n i += 1\\n \\n return satisfiedCustomers + maxUnsatisfiedWindow\\n \\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n max_satisfaction = sum(customers)\\n actual_satisfaction = sum(int(not g) * s for g,s in zip(grumpy, customers))\\n \\n max_s_x = sum(customers[:X])\\n actual_s_x = sum(int(not g) * s for g,s in zip(grumpy[:X], customers[:X]))\\n \\n ans = actual_satisfaction - actual_s_x + max_s_x\\n for i in range(X, len(customers)):\\n max_s_x += customers[i] - customers[i - X]\\n actual_s_x += (customers[i] * int(not grumpy[i])) - (customers[i - X] * int(not grumpy[i - X]))\\n ans = max(ans, actual_satisfaction - actual_s_x + max_s_x)\\n return ans\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n mp = lp = sum(customers[i] for i in range(X) if grumpy[i])\\n mi = 0\\n for i in range(1, len(grumpy) - X + 1):\\n n = customers[i+X-1] if grumpy[i+X-1] else 0\\n o = customers[i-1] if grumpy[i-1] else 0\\n lp += (n - o)\\n if lp > mp:\\n mp = lp\\n mi = i\\n res = sum([customers[i] for i in range(len(grumpy)) if not grumpy[i]])\\n return res + mp\\n \\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n tmpCustomers = customers.copy()\\n totalSatisfied = 0\\n for i in range(len(grumpy)):\\n if grumpy[i] == 0:\\n totalSatisfied += tmpCustomers[i]\\n\\n tmpCustomers[i] = 0\\n \\n \\n window = 0\\n best = 0\\n \\n for i in range(len(tmpCustomers)):\\n window += tmpCustomers[i]\\n if i >= X:\\n window -= tmpCustomers[i-X]\\n best = max(window,best)\\n return totalSatisfied+best\\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n grumpy, grum_sum, cus_sum = [i ^ 1 for i in grumpy], [0] * len(customers), [0] * len(customers)\\n grumpy_customers = [customers[i] * grumpy[i] for i in range(len(customers))]\\n for i, n in enumerate(customers): cus_sum[i] = n + (cus_sum[i - 1] if i > 0 else 0)\\n for i, n in enumerate(grumpy_customers): grum_sum[i] = n + (grum_sum[i - 1] if i > 0 else 0)\\n return max((grum_sum[i - 1] if i > 0 else 0) + cus_sum[i + X - 1] - (cus_sum[i - 1] if i > 0 else 0) + grum_sum[len(customers) - 1] - grum_sum[i + X - 1] for i in range(0, len(customers) - X + 1))\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X == len(customers):\\n return sum(customers)\\n sum_not_grumpy = sum(customers[:X])\\n sum_normal = sum([x*(1-y) for x,y in zip(customers,grumpy)][X:]) #sum(mults[X:])\\n \\n max_customers = sum_not_grumpy+sum_normal\\n for i in range(1,len(customers)-X+1):\\n sum_not_grumpy -= customers[i-1]\\n sum_not_grumpy += customers[i+X-1]\\n sum_normal += customers[i-1]*(1 - grumpy[i-1])\\n sum_normal -= customers[i+X-1]*(1 - grumpy[i+X-1])\\n max_customers = max(max_customers, sum_not_grumpy+sum_normal)\\n\\n return max_customers\\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n # sliding window of possible grumping times\\n satisfied = 0\\n n = len(customers)\\n grumpySum = 0\\n \\n for i in range(X):\\n satisfied += customers[i] if grumpy[i] == 0 else 0\\n \\n saved = customers[i] if grumpy[i] == 1 else 0\\n grumpySum += saved\\n\\n noGrump = grumpySum\\n for i in range(X, n):\\n satisfied += customers[i] if not grumpy[i] else 0\\n \\n saved = customers[i] if grumpy[i] else 0\\n abandon = customers[i - X] if grumpy[i - X] else 0\\n grumpySum = grumpySum + saved - abandon\\n noGrump = max(noGrump, grumpySum)\\n\\n return satisfied + noGrump\\n \\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n gain = 0\\n for i in range(X):\\n if grumpy[i]:\\n gain += customers[i]\\n max_gain = gain\\n for i in range(X, len(customers)):\\n gain = gain + customers[i]*grumpy[i] - customers[i-X]*grumpy[i-X]\\n max_gain = max(max_gain, gain)\\n statify = 0\\n for i in range(len(customers)):\\n statify += customers[i]*(1-grumpy[i])\\n return statify + max_gain\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n n, window_sum = len(customers), 0 \\n for i in range(n):\\n if i < X:\\n window_sum += customers[i]\\n else:\\n window_sum += (1 - grumpy[i]) * customers[i]\\n \\n result = window_sum # 求得指針未滑動前總和\\n left, right = 0, X\\n \\n while right < n:\\n if grumpy[right] == 1:\\n window_sum += customers[right]\\n if grumpy[left] == 1:\\n window_sum -= customers[left]\\n result = max(result, window_sum)\\n left += 1\\n right += 1\\n \\n return result\\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n satisfy = sum(cust for cust, grump in zip(customers, grumpy) if grump == 0)\\n max_extra = extra = sum(cust for cust, grump in zip(customers[:X], grumpy[:X]) if grump == 1)\\n start, end = 0, X\\n n = len(customers)\\n while end < n:\\n extra += grumpy[end] * customers[end]\\n extra -= grumpy[start] * customers[start]\\n max_extra = max(max_extra, extra)\\n start += 1\\n end += 1\\n return satisfy + max_extra\\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n n = len(customers)\\n if n == 0:\\n return 0\\n \\n running_sum = 0\\n \\n for i in range(n):\\n if i < X:\\n running_sum += customers[i]\\n else:\\n running_sum += customers[i] * (1-grumpy[i])\\n \\n left, right = 0, X\\n ans = running_sum\\n \\n while right < n:\\n if grumpy[right] == 1:\\n running_sum += customers[right]\\n right += 1\\n \\n if grumpy[left] == 1:\\n running_sum -= customers[left]\\n \\n left += 1\\n \\n ans = max(ans, running_sum)\\n \\n return ans\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n n = len(customers)\\n cnt = 0\\n acc = [0]\\n \\n for i in range(n):\\n if grumpy[i]:\\n acc.append(acc[-1]+customers[i])\\n else:\\n acc.append(acc[-1])\\n cnt += customers[i]\\n \\n ans = cnt\\n \\n for i in range(n-X+1):\\n ans = max(ans, cnt+acc[i+X]-acc[i])\\n \\n return ans\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n inital_sum = 0\\n tmp_sum = 0\\n res_sum = 0\\n length = len(customers)\\n for i in range(0,len(customers)):\\n if grumpy[i] == 0:\\n inital_sum += customers[i]\\n tmp_sum = inital_sum\\n print (tmp_sum)\\n for j in range(0, X):\\n if grumpy[j] == 1:\\n tmp_sum = tmp_sum + customers[j]\\n print (tmp_sum)\\n res_sum = max(tmp_sum, res_sum)\\n print (res_sum)\\n k = 1\\n while ((k+X-1) < length):\\n if grumpy[k-1] == 1:\\n tmp_sum = tmp_sum - customers[k-1]\\n if grumpy[k+X-1] == 1:\\n tmp_sum = tmp_sum + customers[k+X-1]\\n k += 1\\n res_sum = max(tmp_sum, res_sum)\\n return res_sum\\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n ans = 0\\n L = len(grumpy)\\n if X >= L:\\n return sum(customers)\\n for i in range(L):\\n if grumpy[i] == 0:\\n ans += customers[i]\\n res = cur_sum = 0\\n for end in range(X):\\n if grumpy[end] == 1:\\n cur_sum += customers[end]\\n res = cur_sum\\n for end in range(X, L):\\n if grumpy[end] == 1:\\n cur_sum += customers[end]\\n if grumpy[end - X] == 1:\\n cur_sum -= customers[end - X]\\n res = max(res, cur_sum)\\n return ans + res\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n already_happy = sum(c for c, h in zip(customers, grumpy) if not h)\\n \\n running = sum(c for c, h in zip(customers[:X], grumpy[:X]) if h)\\n \\n max_happy = running\\n for i in range(1, len(customers) - X + 1):\\n if grumpy[i - 1] == 1:\\n running -= customers[i - 1]\\n if grumpy[i + X - 1] == 1:\\n running += customers[i + X - 1]\\n max_happy = max(running, max_happy) \\n \\n return max_happy + already_happy\\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n \\n \\n L = len(grumpy)\\n if L == X:\\n return sum(customers)\\n # print(L,X)\\n grummpyCustomer = [0 if grumpy[i] == 1 else customers[i] for i in range(L) ]\\n for i in range(1,L):\\n customers[i] += customers[i-1]\\n \\n \\n for i in range(1,L):\\n grummpyCustomer[i] += grummpyCustomer[i-1]\\n \\n \\n \\n result = 0\\n \\n maxSum = grummpyCustomer[-1]\\n for i in range(X, L):\\n result = max(result, customers[i] - customers[i-X] + maxSum - grummpyCustomer[i] + grummpyCustomer[i-X])\\n # print(result)\\n \\n \\n for i in reversed(list(range(1,L))):\\n customers[i] -= customers[i-1]\\n # print(customers)\\n \\n grummpyCustomer = [0 if grumpy[i] == 1 else customers[i] for i in range(L) ]\\n \\n for i in reversed(list(range(L-1))):\\n customers[i] += customers[i+1]\\n \\n for i in reversed(list(range(L-1))):\\n # print(i)\\n grummpyCustomer[i] += grummpyCustomer[i+1]\\n \\n # print(customers[0] - customers[0+X] + grummpyCustomer[0+X])\\n maxSum = grummpyCustomer[0]\\n for i in reversed(list(range(L-X))):\\n # print(i,'ok')\\n result = max(result, customers[i] - customers[i+X] + maxSum - grummpyCustomer[i] + grummpyCustomer[i+X])\\n \\n return result\\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], k: int) -> int:\\n n=len(customers)\\n res=sum([customers[i]*(1-grumpy[i]) for i in range(n)]) # the customers you can obtain while non grumpy\\n best_gain=sum([customers[i]*grumpy[i] for i in range(k)]) # first window\\n gain=best_gain\\n for i in range(k,n):\\n gain+=customers[i]*grumpy[i]-customers[i-k]*grumpy[i-k] # add new, kick out old\\n best_gain=max(gain,best_gain) \\n return res+best_gain\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n max_satisfaction = sum(customers)\\n actual_satisfaction = sum(int(not g) * s for g,s in zip(grumpy, customers))\\n \\n max_s_x = sum(customers[:X])\\n actual_s_x = sum(int(not g) * s for g,s in zip(grumpy[:X], customers[:X]))\\n \\n ans = actual_satisfaction - actual_s_x + max_s_x\\n print(max_satisfaction, actual_satisfaction)\\n print('sssssssss')\\n for i in range(X, len(customers)):\\n print(max_s_x, actual_s_x, customers[i], customers[i - X])\\n max_s_x += customers[i] - customers[i - X]\\n actual_s_x += (customers[i] * int(not grumpy[i])) - (customers[i - X] * int(not grumpy[i - X]))\\n ans = max(ans, actual_satisfaction - actual_s_x + max_s_x)\\n return ans\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n curr = 0\\n max1 = 0\\n left =0\\n for i in range(len(customers)):\\n if i <X:\\n curr += customers[i]\\n else:\\n if grumpy[i] == 0:\\n curr+= customers[i]\\n max1 = curr\\n for i in range(X,len(customers)):\\n if grumpy[i] == 1:\\n curr+=customers[i]\\n if grumpy[left] == 1:\\n curr-=customers[left]\\n left+=1\\n max1 = max(max1,curr)\\n return max1\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X == len(customers):\\n return sum(customers)\\n for i in range(len(grumpy)):\\n grumpy[i] = 0 if grumpy[i] == 1 else 1\\n mults = [x*y for x,y in zip(customers,grumpy)]\\n sum_not_grumpy = sum(customers[:X])\\n not_grumpy = [sum_not_grumpy] \\n for i in range(1,len(customers)-X+1):\\n sum_not_grumpy -= customers[i-1]\\n sum_not_grumpy += customers[i+X-1]\\n not_grumpy.append(sum_not_grumpy)\\n \\n sum_normal = sum(mults[X:])\\n normal_custs = [sum_normal]\\n for i in range(1,len(mults)-X+1):\\n sum_normal += mults[i-1]\\n sum_normal -= mults[i+X-1]\\n normal_custs.append(sum_normal)\\n \\n print(not_grumpy)\\n print(normal_custs)\\n return max([x+y for x,y in zip(not_grumpy,normal_custs)])\\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n old = 0\\n for i in range(len(customers)):\\n if grumpy[i] == 0:\\n old += customers[i]\\n l, r, res = 0, 0, 0\\n while r < len(customers):\\n if grumpy[r] == 1:\\n old += customers[r]\\n if r >= X:\\n if grumpy[l] == 1:\\n old -= customers[l]\\n l += 1\\n res = max(res, old)\\n r += 1\\n return res\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n # we want to find the biggest loss of satisfaction in a X-hr period throughout the day.\\n if len(customers) == X: return sum(customers)\\n maxLoss = 0\\n total = sum([customers[i]*(1-grumpy[i]) for i in range(len(grumpy))])\\n print(total)\\n loss = sum([grumpy[i]*customers[i] for i in range(X)])\\n maxLoss = loss\\n for i in range(X, len(customers)):\\n loss += grumpy[i]*customers[i]\\n loss -= grumpy[i-X]*customers[i-X]\\n maxLoss = max(maxLoss, loss)\\n total += maxLoss\\n return total\\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if not customers:\\n return 0\\n can_be_always_happy = X == len(customers)\\n customers_lost = [0] * (len(customers) + 1)\\n total_customers_lost = 0\\n total_satisfied = 0\\n for idx, customer in enumerate(customers):\\n if grumpy[idx] == 1 and not can_be_always_happy:\\n total_customers_lost += customers[idx]\\n else:\\n total_satisfied += customers[idx]\\n customers_lost[idx + 1] = total_customers_lost\\n\\n max_gain = 0\\n for i in range(X, len(customers_lost)):\\n gain = customers_lost[i] - customers_lost[i - X]\\n max_gain = max(gain, max_gain)\\n\\n return total_satisfied + max_gain\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X == len(customers):\\n return sum(customers)\\n for i in range(len(grumpy)):\\n grumpy[i] = 0 if grumpy[i] == 1 else 1\\n mults = [x*y for x,y in zip(customers,grumpy)]\\n sum_not_grumpy = sum(customers[:X])\\n sum_normal = sum(mults[X:])\\n \\n max_customers = sum_not_grumpy+sum_normal\\n for i in range(1,len(customers)-X+1):\\n sum_not_grumpy -= customers[i-1]\\n sum_not_grumpy += customers[i+X-1]\\n sum_normal += mults[i-1]\\n sum_normal -= mults[i+X-1]\\n max_customers = max(max_customers, sum_not_grumpy+sum_normal)\\n\\n return max_customers\\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X == len(customers):\\n return sum(customers)\\n for i in range(len(grumpy)):\\n grumpy[i] = 0 if grumpy[i] == 1 else 1\\n mults = [x*y for x,y in zip(customers,grumpy)]\\n sum_not_grumpy = sum(customers[:X])\\n #not_grumpy = [sum_not_grumpy] \\n sum_normal = sum(mults[X:])\\n #normal_custs = [sum_normal]\\n \\n max_customers = sum_not_grumpy+sum_normal\\n for i in range(1,len(customers)-X+1):\\n sum_not_grumpy -= customers[i-1]\\n sum_not_grumpy += customers[i+X-1]\\n sum_normal += mults[i-1]\\n sum_normal -= mults[i+X-1]\\n max_customers = max(max_customers, sum_not_grumpy+sum_normal)\\n\\n return max_customers\\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n saved = 0\\n max_saved = 0\\n sumTotal = 0\\n for i, value in enumerate(customers):\\n if i - X >= 0 and grumpy[i - X]:\\n saved -= customers[i - X]\\n if grumpy[i]:\\n saved += value\\n else:\\n sumTotal += value\\n max_saved = max(max_saved, saved)\\n print((saved,max_saved))\\n # print(saved, max_saved, sumTotal)\\n return sumTotal + max_saved\\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n to_ret = sum([c for c, g in zip(customers, grumpy) if g == 0])\\n \\n mt = mf = sum([c for c, g in zip(customers[:X], grumpy[:X]) if g == 1])\\n for t in range(X, len(customers)) :\\n if grumpy[t] == 1 :\\n mt += customers[t]\\n if grumpy[t-X] == 1 :\\n mt -= customers[t-X]\\n mf = max(mf, mt)\\n return to_ret + mf\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n satisfiedCount = 0\\n \\n for i in range(len(customers)):\\n if grumpy[i] == 0:\\n satisfiedCount += customers[i]\\n customers[i] = 0\\n \\n maxPotentialCount = 0\\n val = 0\\n \\n for i in range(len(customers)):\\n if i < X:\\n val += customers[i]\\n continue\\n \\n maxPotentialCount = max(maxPotentialCount, val)\\n val -= customers[i - X]\\n val += customers[i]\\n \\n maxPotentialCount = max(maxPotentialCount, val)\\n \\n return satisfiedCount + maxPotentialCount\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n i = win_of_make_satisfied = satisfied = max_make_satisfied = 0\\n for c, g in zip(customers, grumpy):\\n satisfied += (1 - g) * c\\n win_of_make_satisfied += g * c\\n if i >= X:\\n win_of_make_satisfied -= grumpy[i - X] * customers[i - X]\\n max_make_satisfied = max(win_of_make_satisfied, max_make_satisfied) \\n i += 1 \\n return satisfied + max_make_satisfied\\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n lb, ub = 0, X-1\\n total = sum([customers[i] * (1 - grumpy[i]) for i in range(len(customers))])\\n \\n saved = 0\\n for i in range(X):\\n if grumpy[i]: saved += customers[i]\\n \\n ans = total + saved\\n while ub + 1 < len(grumpy):\\n lb, ub = lb + 1, ub + 1\\n if grumpy[lb-1]:\\n saved -= customers[lb-1]\\n if grumpy[ub]:\\n saved += customers[ub]\\n ans = max(ans, total+saved)\\n return ans\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n gains = [x if grumpy[i] == 1 else 0 for (i, x) in enumerate(customers)]\\n fact = [x if grumpy[i] == 0 else 0 for (i, x) in enumerate(customers)]\\n \\n if X > len(gains):\\n return sum(customers)\\n \\n current_sum = sum(gains[:X])\\n max_gain = current_sum\\n for i in range(1, len(gains) - X + 1):\\n current_sum = current_sum - gains[i - 1] + gains[i + X - 1]\\n max_gain = max(max_gain, current_sum)\\n \\n return sum(fact) + max_gain\\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n n = len(grumpy)\\n if X >= n:\\n return sum(customers)\\n init = sum([customers[i]*(1-grumpy[i]) for i in range(n)])\\n \\n for j in range(X):\\n if grumpy[j] == 1:\\n init += customers[j]\\n max_l = init \\n temp = init\\n for i in range(1, n-X+1):\\n temp -= grumpy[i-1]*customers[i-1]\\n temp += grumpy[i+X-1]*customers[i+X-1]\\n max_l = max(max_l, temp)\\n \\n return max_l\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n initial = sum(num for day, num in enumerate(customers) if grumpy[day] == 0)\\n curr_tricked = 0\\n tricked = 0\\n for ind, num in enumerate(customers):\\n if ind >= X and grumpy[ind-X] == 1:\\n curr_tricked -= customers[ind-X]\\n if grumpy[ind] == 1:\\n curr_tricked += customers[ind]\\n tricked = max(tricked, curr_tricked)\\n return initial + tricked\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n t=0\\n for i in range(len(grumpy)):\\n if grumpy[i]==0:\\n t+=customers[i]\\n customers[i]=0\\n\\n n=sum(customers[:X])\\n m=n\\n for i in range(1,len(customers)-X+1):\\n m=m+customers[i+X-1]-customers[i-1]\\n n=max(m,n)\\n return n+t\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X == len(customers):\\n return sum(customers)\\n sum_not_grumpy = sum(customers[:X])\\n sum_normal = sum([x*(1-y) for x,y in zip(customers[X:],grumpy[X:])]) \\n \\n max_customers = sum_not_grumpy+sum_normal\\n for i in range(1,len(customers)-X+1):\\n sum_not_grumpy -= customers[i-1]\\n sum_not_grumpy += customers[i+X-1]\\n sum_normal += customers[i-1]*(1 - grumpy[i-1])\\n sum_normal -= customers[i+X-1]*(1 - grumpy[i+X-1])\\n max_customers = max(max_customers, sum_not_grumpy+sum_normal)\\n\\n return max_customers\\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n satisfied = 0\\n for i in range(len(grumpy)):\\n if grumpy[i] == 0:\\n satisfied += customers[i]\\n windowMax = 0\\n curr = 0\\n for i in range(len(customers)):\\n curr += ((grumpy[i]) * customers[i])\\n if i >= X:\\n curr -= ((grumpy[i - X]) * customers[i - X])\\n windowMax = max(windowMax, curr)\\n return satisfied + windowMax\\n\",\n \"import numpy as np\\n\\nclass Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n #satisfiedCustomer = sum(customers) - sum(np.multiply(customers,grumpy))\\n \\n satisfiedCustomer = 0\\n for i in range(len(customers)):\\n if not grumpy[i]:\\n satisfiedCustomer += customers[i]\\n \\n window = 0\\n for i in range(X):\\n if grumpy[i] == 1:\\n window+=customers[i]\\n \\n \\n res = window\\n \\n for i in range(1,len(customers)-X+1):\\n last = i-1\\n if grumpy[last]==1:\\n window -= customers[last]\\n nextIdx = i+X-1\\n if grumpy[nextIdx]==1:\\n window += customers[nextIdx]\\n \\n res = max(res,window)\\n \\n \\n return (res+satisfiedCustomer)\\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n total = sum(c for i, c in enumerate(customers) if grumpy[i] == 0)\\n add = sum(c for i, c in enumerate(customers[:X]) if grumpy[i] == 1)\\n res = total + add\\n #print(total, add, res)\\n for i in range(X, len(customers)):\\n if grumpy[i] == 1:\\n add += customers[i]\\n if grumpy[i - X] == 1:\\n add -= customers[i - X]\\n res = max(res, total + add)\\n #print(total, add, res)\\n return res\\n\",\n \"class Solution:\\n def maxSatisfied(self, A: List[int], G: List[int], X: int) -> int:\\n res = 0\\n s = 0\\n ws = 0\\n left = []\\n for i in range(len(A)):\\n c, g = A[i], G[i]\\n s += (1-g)*c\\n ws += g*c\\n if i>=X:\\n ws -= A[i-X] * G[i-X]\\n res = max(res, ws)\\n # print(i,j,s,res)\\n return res+s\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n i = win_of_make_satisfied = satisfied = max_make_satisfied = 0\\n for c, g in zip(customers, grumpy):\\n satisfied += (1 - g) * c\\n win_of_make_satisfied += g * c\\n if i >= X:\\n win_of_make_satisfied -= grumpy[i - X] * customers[i - X]\\n max_make_satisfied = max(win_of_make_satisfied, max_make_satisfied) \\n i += 1 \\n return satisfied + max_make_satisfied\\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n n=len(customers)\\n res=sum([customers[i]*(1-grumpy[i]) for i in range(n)])\\n best_gain=sum([customers[i]*grumpy[i] for i in range(X)])\\n gain=best_gain\\n for i in range(X,n):\\n gain+=customers[i]*grumpy[i]-customers[i-X]*grumpy[i-X]\\n best_gain=max(best_gain,gain)\\n return res+best_gain\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X == len(customers):\\n return sum(customers)\\n for i in range(len(grumpy)):\\n grumpy[i] = 0 if grumpy[i] == 1 else 1\\n mults = [x*y for x,y in zip(customers,grumpy)]\\n sum_not_grumpy = sum(customers[:X])\\n not_grumpy = [sum_not_grumpy] \\n sum_normal = sum(mults[X:])\\n normal_custs = [sum_normal]\\n \\n for i in range(1,len(customers)-X+1):\\n sum_not_grumpy -= customers[i-1]\\n sum_not_grumpy += customers[i+X-1]\\n not_grumpy.append(sum_not_grumpy)\\n sum_normal += mults[i-1]\\n sum_normal -= mults[i+X-1]\\n normal_custs.append(sum_normal)\\n \\n return max([x+y for x,y in zip(not_grumpy,normal_custs)])\\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n N = len(grumpy)\\n \\n already_happy = sum(customers[i] for i in range(N) if not grumpy[i])\\n \\n window = sum(customers[i] for i in range(X) if grumpy[i])\\n \\n max_bonus = window\\n for r in range(X, N):\\n window -= customers[r - X] if grumpy[r - X] else 0\\n window += customers[r] if grumpy[r] else 0\\n max_bonus = max(max_bonus, window)\\n \\n return already_happy + max_bonus\",\n \"class Solution:\\n \\n def maxSatisfied(self, customers: List[int], grumpy: List[int], window_size: int) -> int:\\n \\n\\n already_satisfied = 0\\n for index in range(len(customers)):\\n if grumpy[index] == 0:\\n already_satisfied += customers[index]\\n customers[index] = 0\\n \\n \\n best_satisfied = 0\\n \\n satisfied = 0\\n for index, customer in enumerate(customers):\\n satisfied += customer\\n \\n if index >= window_size:\\n satisfied -= customers[index - window_size]\\n \\n best_satisfied = max(best_satisfied, satisfied)\\n \\n \\n return best_satisfied + already_satisfied\\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n \\n satisfiedCustomer = 0\\n for i in range(len(customers)):\\n if not grumpy[i]:\\n satisfiedCustomer += customers[i]\\n \\n window = 0\\n for i in range(X):\\n if grumpy[i] == 1:\\n window+=customers[i]\\n \\n res = window\\n for i in range(1,len(customers)-X+1):\\n last = i-1\\n if grumpy[last]==1:\\n window -= customers[last]\\n nextIdx = i+X-1\\n if grumpy[nextIdx]==1:\\n window += customers[nextIdx]\\n \\n res = max(res,window)\\n \\n \\n return (res+satisfiedCustomer)\\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n disSatisfy = [c*g for c,g in zip(customers, grumpy)]\\n start = 0\\n grumpy_num = 0\\n for i in range(X):\\n grumpy_num += disSatisfy[i]\\n\\n remaining = grumpy_num\\n for j in range(X, len(customers)):\\n remaining = remaining-disSatisfy[j-X]+disSatisfy[j]\\n if remaining>grumpy_num:\\n grumpy_num = remaining\\n start = j-X+1\\n\\n for k in range(start, start+X):\\n grumpy[k]=0\\n\\n return sum([ c if g==0 else 0 for c,g in zip(customers, grumpy)])\\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int: \\n n = len(customers)\\n \\n start = 0\\n \\n curSatisfaction = sum(customers[i] for i in range(n) if grumpy[i] == 0)\\n \\n maxSatisfaction = 0\\n \\n for end in range(len(customers)):\\n if grumpy[end] == 1:\\n curSatisfaction += customers[end]\\n \\n if end - start + 1 > X:\\n if grumpy[start] == 1:\\n curSatisfaction -= customers[start]\\n start += 1\\n \\n maxSatisfaction = max(maxSatisfaction, curSatisfaction)\\n \\n return maxSatisfaction\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n start=0\\n end=X\\n ans=0\\n for i in range(len(grumpy)):\\n if grumpy[i]==0:\\n ans+=customers[i]\\n t=0\\n for i in range(X):\\n if grumpy[i]==1:\\n t+=customers[i]\\n maxs=0\\n while end<len(grumpy)+1:\\n if t>maxs:\\n maxs=t\\n if end==len(grumpy):\\n break\\n if grumpy[start]==1:\\n t-=customers[start]\\n if grumpy[end]==1:\\n t+=customers[end]\\n start+=1\\n end+=1\\n return ans+maxs\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n total = 0\\n \\n for i in range(len(customers)):\\n total += (1-grumpy[i]) * customers[i]\\n grumpy[i] *= customers[i]\\n \\n maxsum = 0\\n for i in range(X):\\n maxsum += grumpy[i]\\n cur = maxsum\\n for j in range(X, len(grumpy)):\\n i = j-X\\n cur += grumpy[j]\\n cur -= grumpy[i]\\n maxsum = max(maxsum, cur)\\n #print(maxsum)\\n return total + maxsum\\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n n = len(customers)\\n sum_cus = sum(customers)\\n for i in range(n):\\n customers[i] *= grumpy[i]\\n window = 0\\n max_secret_satisfied = -math.inf\\n left, right = 0, 0\\n while right < n:\\n window += customers[right]\\n right += 1\\n while right - left >= X:\\n max_secret_satisfied = max(max_secret_satisfied, window)\\n window -= customers[left]\\n left += 1\\n return sum_cus - (sum(customers) - max_secret_satisfied)\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n #happy owner means happy customer as well \\n happy_owner_cust = 0 \\n \\n for pos in range(len(customers)):\\n if grumpy[pos] == 0: #happy owner \\n happy_owner_cust += customers[pos]\\n customers[pos] = 0 \\n \\n \\n #then build upon using the grumpy owner power. \\n \\n calming_owner_cust = 0 \\n best_calmed_cust = 0 \\n \\n for end in range(len(customers)): \\n calming_owner_cust += customers[end]\\n \\n \\n \\n if end >= X: #subtract out the extra calming technique from the owner \\n calming_owner_cust -= customers[end - X]\\n \\n best_calmed_cust = max(best_calmed_cust, calming_owner_cust)\\n \\n \\n \\n \\n return happy_owner_cust + best_calmed_cust\\n \\n# #TRY 8/10/2020 \\n# class Solution:\\n# def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n# #Input: Customers[i] how many customers enter for that exact minute \\n \\n# #Constraint \\n# #owner -> opens store up to customers.len()\\n# #Every minute there are customers entering the store. And all those customers leave after the end of the minute \\n \\n# #If owner is grumpy on i-th minute grumpy[i] = 1 else grumpy[i] = 0. When the bookstore owner is angry \\n# #The customers of that minute aren't satisfied else if owner isn't grumpy then customers are happy. \\n \\n# # Bookstore owner can be NOT angry for X minutes but can use it ONLY once. \\n \\n# #WANT: max number of customers that are happy throughout the day. \\n \\n \\n# minutes_opened = len(customers) \\n# customer_happy_time = 0 \\n \\n# #Try to basically keep your grumpy minutes down based on the highest number of customers there are. \\n \\n# start = 0 \\n# end = 0 \\n# rush_hour = collections.deque() #this is based on the most amount of customers. \\n# calm_owner = collections.deque()\\n# #Our best number of customer being happy will be based on the largest amount of customers\\n# #That's our best bet. \\n# while end < minutes_opened: \\n# if customers[end] == 0: #No Customers go in owner can be angry \\n# end += 1 \\n# continue \\n \\n# cur_happy_time += customers[end]\\n# if grumpy[end] == 1: #owner angry = customer angry: Just try calming here then. \\n \\n \\n \\n# rush_hour.append(end)\\n\\n# class Solution():\\n# def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n# m = s = tmp = 0\\n# for i in range(len(customers)):\\n# if not grumpy[i]: \\n# s += customers[i] # sum of satisfied customers\\n# customers[i] = 0 \\n# else: tmp += customers[i] # sum of grumpy customers \\n# if i>=X: tmp -= customers[i-X] # remove the leftmost element to keep the sliding window with # of X\\n# m = max(m, tmp) # max # of satisfied grumpy customers with a secret technique\\n# return s+m\\n \\n \\n# class Solution:\\n# def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n# # Part 1 requires counting how many customers\\n# # are already satisfied, and removing them\\n# # from the customer list.\\n# #These customers are those who didn't have to fight with the owner to be happy.\\n# already_satisfied = 0\\n# for i in range(len(grumpy)):\\n# if grumpy[i] == 0: #He's happy so add the customer. \\n# already_satisfied += customers[i]\\n# customers[i] = 0 #set you back to zero to not visit you. When doing the offset for the window \\n \\n# # Part 2 requires finding the optimal number\\n# # of unhappy customers we can make happy.\\n# best_we_can_make_satisfied = 0\\n# current_satisfied = 0\\n# for i, customers_at_time in enumerate(customers):\\n# # if customers[i] == 0: CAN'T DO THIS CUZ WE'RE NOT UPDATING THE WINDOW THEN AT THIS POINT (I.E THE START WINDOW)\\n# # continue\\n# #Add the customer so far\\n# current_satisfied += customers_at_time # Add current to rolling total\\n# if i >= X: # We need to remove some from the rolling total #We need to update and try the grumpy intervals to block out owner from \\n# #Being grumpy so we can add these happy customers but at this point\\n# #There's too much calming power used by owner so we need to remove the beginning window of the current_satisifed. \\n# current_satisfied -= customers[i - X]\\n# best_we_can_make_satisfied = max(best_we_can_make_satisfied, current_satisfied)\\n \\n# # The answer is the sum of the solutions for the 2 parts.\\n# return already_satisfied + best_we_can_make_satisfied\\n \\n \\nclass Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n always_happy = 0 \\n for pos in range(len(customers)): \\n if grumpy[pos] == 0: \\n always_happy += customers[pos]\\n customers[pos] = 0 \\n \\n happy_use = 0 \\n cur_happy_customers = 0 \\n \\n for pos in range(len(customers)): \\n cur_happy_customers += customers[pos]\\n \\n if pos >= X: \\n cur_happy_customers -= customers[pos - X]\\n \\n \\n happy_use = max(happy_use, cur_happy_customers)\\n \\n return always_happy + happy_use \",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if len(customers) <= X:\\n return sum(customers)\\n \\n \\n satisfied_customers = 0\\n current_unsatisfied_customers = 0\\n max_unsatisfied_customers = 0\\n \\n for i in range(len(customers)):\\n if i >= X and grumpy[i-X] == 1:\\n current_unsatisfied_customers -= customers[i-X]\\n \\n if grumpy[i] == 0:\\n satisfied_customers += customers[i]\\n else:\\n current_unsatisfied_customers += customers[i]\\n \\n max_unsatisfied_customers = max(max_unsatisfied_customers, current_unsatisfied_customers)\\n \\n return satisfied_customers + max_unsatisfied_customers\\n \\n \\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X == len(customers):\\n return sum(customers)\\n for i in range(len(grumpy)):\\n grumpy[i] = 0 if grumpy[i] == 1 else 1\\n mults = [x*y for x,y in zip(customers,grumpy)]\\n sum_not_grumpy = sum(customers[:X])\\n not_grumpy = [sum_not_grumpy] \\n sum_normal = sum(mults[X:])\\n normal_custs = [sum_normal]\\n for i in range(1,len(customers)-X+1):\\n sum_not_grumpy -= customers[i-1]\\n sum_not_grumpy += customers[i+X-1]\\n not_grumpy.append(sum_not_grumpy)\\n sum_normal += mults[i-1]\\n sum_normal -= mults[i+X-1]\\n normal_custs.append(sum_normal)\\n \\n \\n \\n \\n print(not_grumpy)\\n print(normal_custs)\\n return max([x+y for x,y in zip(not_grumpy,normal_custs)])\\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n satisfied = 0 \\n for i in range(len(customers)):\\n satisfied += customers[i] * (grumpy[i] == 0)\\n \\n p = X \\n best_imp = sum([customers[i] for i in range(p) if grumpy[i] == 1])\\n imp = best_imp\\n while p < len(grumpy):\\n if grumpy[p] == 1:\\n imp += customers[p]\\n if grumpy[p - X] == 1:\\n imp -= customers[p - X]\\n if imp > best_imp:\\n best_imp = imp\\n \\n p += 1\\n \\n return satisfied + best_imp \\n \\n \\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n i = win_of_make_satisfied = satisfied = max_make_satisfied = 0\\n for c, g in zip(customers, grumpy):\\n satisfied += (1 - g) * c\\n win_of_make_satisfied += g * c\\n if i >= X:\\n win_of_make_satisfied -= grumpy[i - X] * customers[i - X]\\n max_make_satisfied = max(win_of_make_satisfied, max_make_satisfied) \\n i += 1\\n return satisfied + max_make_satisfied\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n curr_running_delta = 0\\n max_delta = (-2**31, None) # max sum, end idx\\n \\n for i in range(len(customers)):\\n curr_running_delta += customers[i]*grumpy[i]\\n \\n if i >= X - 1:\\n if curr_running_delta > max_delta[0]:\\n max_delta = (curr_running_delta, i)\\n \\n if grumpy[i - (X-1)] == 1:\\n curr_running_delta -= customers[i - (X-1)]\\n \\n max_satisfied = 0\\n for i in range(len(customers)):\\n if max_delta[1] - (X-1) <= i <= max_delta[1] or grumpy[i] == 0:\\n max_satisfied += customers[i]\\n \\n return max_satisfied\\n \\n # time O(n)\\n # space O(1)\\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n # sliding window of possible grumping times\\n satisfied = 0\\n n = len(customers)\\n grumpySum = [0]*(n - X + 1)\\n \\n for i in range(X):\\n satisfied += customers[i] if grumpy[i]==0 else 0\\n \\n saved = customers[i] if grumpy[i]==1 else 0\\n grumpySum[0] += saved\\n\\n noGrump = grumpySum[0]\\n for i in range(X, n):\\n satisfied += customers[i] if not grumpy[i] else 0\\n \\n saved = customers[i] if grumpy[i] else 0\\n abandon = customers[i - X] if grumpy[i - X] else 0\\n grumpySum[i - X + 1] = grumpySum[i - X] + saved - abandon\\n noGrump = max(noGrump, grumpySum[i - X + 1])\\n\\n return satisfied + noGrump\\n \\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n without_x = 0\\n for i, b in enumerate(grumpy):\\n if not b:\\n without_x += customers[i]\\n \\n with_x = [0]*len(customers)\\n \\n extra = 0\\n for i, b in enumerate(grumpy[:X]):\\n if b:\\n extra += customers[i]\\n \\n with_x[0] += extra\\n \\n for i in range(len(grumpy)):\\n if i + X >= len(grumpy):\\n break\\n \\n extra -= 0 if not grumpy[i] else customers[i]\\n extra += 0 if not grumpy[i + X ] else customers[i + X]\\n with_x[i + 1] += extra\\n \\n return max(with_x) + without_x\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int],\\n X: int) -> int:\\n already_satisfied = 0\\n for i in range(len(grumpy)):\\n if grumpy[i] == 0:\\n already_satisfied += customers[i]\\n customers[i] = 0\\n\\n best_we_can_make_satisfied = 0\\n current_satisfied = 0\\n for i, customers_at_time in enumerate(customers):\\n current_satisfied += customers_at_time\\n if i >= X:\\n current_satisfied -= customers[i - X]\\n best_we_can_make_satisfied = max(best_we_can_make_satisfied,\\n current_satisfied)\\n return already_satisfied + best_we_can_make_satisfied\\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n zeroTotal = 0\\n for i in range(len(customers)):\\n if grumpy[i] == 0:\\n zeroTotal += customers[i]\\n\\n q = deque()\\n oneTotal = 0\\n largest = 0\\n for i in range(len(customers)):\\n if grumpy[i] == 1:\\n while q and i - q[0][1] >= X:\\n oneTotal -= q.popleft()[0]\\n q.append((customers[i],i))\\n oneTotal += customers[i]\\n largest = max(largest, oneTotal)\\n return zeroTotal + largest\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n if X == len(customers):\\n return sum(customers)\\n for i in range(len(grumpy)):\\n grumpy[i] = 0 if grumpy[i] == 1 else 1\\n mults = [x*y for x,y in zip(customers,grumpy)]\\n sum_not_grumpy = sum(customers[:X])\\n sum_normal = sum(mults[X:])\\n \\n max_customers = sum_not_grumpy+sum_normal\\n for i in range(1,len(customers)-X+1):\\n sum_not_grumpy -= customers[i-1]\\n sum_not_grumpy += customers[i+X-1]\\n sum_normal += customers[i-1]*grumpy[i-1]#mults[i-1] \\n sum_normal -= customers[i+X-1]*grumpy[i+X-1]#mults[i+X-1]\\n max_customers = max(max_customers, sum_not_grumpy+sum_normal)\\n\\n return max_customers\\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, c: List[int], g: List[int], X: int) -> int:\\n arr = [0]\\n n = len(g)\\n for i in range(n):\\n arr.append(arr[-1]+(1-g[i])*c[i])\\n \\n c = [0]+c\\n for i in range(n):\\n c[i+1] = c[i]+c[i+1]\\n \\n m = -1\\n for i in range(X,n+1):\\n m = max(m,c[i]-c[i-X]-arr[i]+arr[i-X])\\n \\n print((arr,c,m))\\n \\n return arr[-1]+m\\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n \\n \\n L = len(grumpy)\\n if L == X:\\n return sum(customers)\\n # print(L,X)\\n tempCustomers = customers.copy()\\n grummpyCustomer = [0 if grumpy[i] == 1 else customers[i] for i in range(L) ]\\n for i in range(1,L):\\n tempCustomers[i] += tempCustomers[i-1]\\n \\n \\n for i in range(1,L):\\n grummpyCustomer[i] += grummpyCustomer[i-1]\\n \\n \\n \\n result = 0\\n \\n maxSum = grummpyCustomer[-1]\\n for i in range(X, L):\\n result = max(result, tempCustomers[i] - tempCustomers[i-X] + maxSum - grummpyCustomer[i] + grummpyCustomer[i-X])\\n # print(result)\\n \\n \\n # for i in reversed(range(1,L)):\\n # customers[i] -= customers[i-1]\\n # print(customers)\\n \\n grummpyCustomer = [0 if grumpy[i] == 1 else customers[i] for i in range(L) ]\\n \\n tempCustomers = customers.copy()\\n for i in reversed(list(range(L-1))):\\n tempCustomers[i] += tempCustomers[i+1]\\n \\n for i in reversed(list(range(L-1))):\\n # print(i)\\n grummpyCustomer[i] += grummpyCustomer[i+1]\\n \\n # print(customers[0] - customers[0+X] + grummpyCustomer[0+X])\\n maxSum = grummpyCustomer[0]\\n for i in reversed(list(range(L-X))):\\n # print(i,'ok')\\n result = max(result, tempCustomers[i] - tempCustomers[i+X] + maxSum - grummpyCustomer[i] + grummpyCustomer[i+X])\\n \\n return result\\n\",\n \"import numpy as np\\n\\nclass Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n customers=np.array(customers)\\n grumpy=np.array(grumpy)\\n total_customers=np.sum(customers)\\n grumpy_array=customers*grumpy\\n secret_array=np.convolve(grumpy_array,np.ones(X,dtype=int),'valid')\\n index=np.where(secret_array==secret_array.max())[0][0]\\n grumpy_array[index:index+X]=0\\n satisfied_customers=total_customers-grumpy_array.sum()\\n return satisfied_customers\\n\",\n \"import numpy as np\\n\\nclass Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n customers = np.array(customers)\\n grumpy = 1 - np.array(grumpy)\\n l = []\\n m = sum(customers * grumpy)\\n\\n for i in range(len(customers) - X + 1):\\n if i == 0:\\n best_case = sum(customers[0:X])\\n diff = sum(grumpy[0:X] * customers[0:X])\\n\\n grump_days = best_case - diff\\n l.append(grump_days)\\n\\n else:\\n best_case = best_case - customers[i - 1] + customers[i + X - 1]\\n diff = diff - grumpy[i - 1]*customers[i - 1] + grumpy[i + X - 1]*customers[i + X - 1]\\n\\n grump_days = best_case - diff\\n l.append(grump_days)\\n\\n return max(l) + m\",\n \"import itertools as it\\n\\n\\nclass Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n self.customers = customers\\n self.grumpy = grumpy\\n self.n = len(customers)\\n # if len(grumpy) != self.n:\\n # raise ValueError(f\\\\\\\"Customers {customers} and grumpy {grumpy} arrays must have the same length.\\\\\\\")\\n self.cumulative_customers = list(it.accumulate(customers, initial=0))\\n self.technique_length = X\\n return self.satisfy(0, 1)\\n \\n @lru_cache(None)\\n def satisfy(self, index: int, secret_technique: int) -> int:\\n if index >= self.n:\\n return 0\\n satisfaction = self.customers[index] if self.grumpy[index] == 0 else 0\\n if secret_technique == 0:\\n return satisfaction + self.satisfy(index + 1, 0)\\n ans = max(\\n satisfaction\\n + self.satisfy(index + 1, secret_technique),\\n self.cumulative_customers[min(self.n, index + self.technique_length)]\\n - self.cumulative_customers[index]\\n + self.satisfy(index + self.technique_length, secret_technique - 1),\\n )\\n return ans\\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n i = win_of_make_satisfied = satisfied = max_make_satisfied = 0\\n for c, g in zip(customers, grumpy):\\n satisfied += (1 - g) * c\\n win_of_make_satisfied += g * c\\n if i >= X:\\n win_of_make_satisfied -= grumpy[i - X] * customers[i - X]\\n max_make_satisfied = max(win_of_make_satisfied, max_make_satisfied) \\n i += 1 \\n return satisfied + max_make_satisfied \",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n \\n window = [0] * X\\n for a in range(X):\\n if grumpy[a] == 1:\\n window[a] += customers[a]\\n mySum = 0\\n maxAdded = sum(window)\\n right = X\\n for i in range(len(customers)):\\n if i + X < len(customers):\\n window.pop(0)\\n window.append(customers[i+X] if grumpy[i+X] == 1 else 0)\\n if sum(window) > maxAdded: maxAdded = sum(window)\\n if grumpy[i] == 0: mySum += customers[i] \\n \\n return mySum + maxAdded\\n \\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n s = 0\\n\\n for i in range(0,len(customers)):\\n if grumpy[i] == 0:\\n s += customers[i]\\n customers[i] = 0\\n\\n # print(customers)\\n tmp = [sum(customers[:X])]\\n\\n for i in range(X,len(customers)):\\n\\n tmp = tmp + [tmp[-1] + customers[i] - customers[i-X]]\\n\\n\\n return max(tmp) + s\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n satisfied = []\\n satisfied_before = 0\\n satisfied_after = sum([x[0] for x in zip(customers[X:], grumpy[X:]) if not x[1]])\\n for i in range(len(customers) - X + 1):\\n satisfied.append(satisfied_before + sum(customers[i:i+X]) + satisfied_after)\\n if not grumpy[i]:\\n satisfied_before += customers[i]\\n if (i + X) < len(customers) and not grumpy[i + X]:\\n satisfied_after -= customers[i + X]\\n return max(satisfied)\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n N = len(customers)\\n satisfy = 0\\n unsatisfied = []\\n max_value = 0\\n #Base cases\\n if not customers:\\n return []\\n elif not grumpy or N==1:\\n return sum(customers)\\n \\n \\n for i in range(N):\\n if grumpy[i] == 0:\\n satisfy += customers[i]\\n unsatisfied.append(0)\\n \\n else:\\n unsatisfied.append(customers[i])\\n \\n \\n for j in range(N-X+1):\\n sum1 = sum(unsatisfied[j:j+X])\\n \\n max_value = max(max_value,sum1)\\n return (satisfy + max_value)\\n \\n \\n \\n\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n sums = 0\\n maxs = 0\\n for i in range(len(customers)):\\n sums += customers[i]\\n if grumpy[i] == 1:\\n grumpy[i] = customers[i]\\n sums -= grumpy[i]\\n for i in range(len(grumpy) - X+1):\\n maxs = max(sum(grumpy[i: i+X]), maxs)\\n return sums + maxs\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n orig_satisfied_list = [customers[i] * (1-grumpy[i]) for i in range(len(customers))]\\n orig_satisfied = sum(orig_satisfied_list)\\n grumpy_satisfied_list = [customers[i] - orig_satisfied_list[i] for i in range(len(customers))]\\n diff_list = [max(0, grumpy_satisfied_list[i] - orig_satisfied_list[i]) for i in range(len(customers))]\\n #print(orig_satisfied_list)\\n #print(grumpy_satisfied_list)\\n #print(diff_list)\\n #print([sum(diff_list[i:i+X]) for i in range(len(customers)-X+1)])\\n return orig_satisfied + max([sum(diff_list[i:i+X]) for i in range(len(customers)-X+1)])\",\n \"class Solution:\\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\\n satisfaction = 0\\n unsatisfied = []\\n for i in range(len(customers)):\\n if grumpy[i] == 1:\\n unsatisfied.append(customers[i])\\n else:\\n satisfaction += customers[i]\\n unsatisfied.append(0)\\n max_sum = sum(unsatisfied[:X])\\n for i in range(X, len(unsatisfied)+1):\\n max_sum = max(max_sum, sum(unsatisfied[i-X:i]))\\n satisfaction += max_sum\\n return satisfaction\"\n]","isConversational":false},"n_sols":{"kind":"number","value":88,"string":"88"},"non_interactive_idx":{"kind":"list like","value":[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,80,81,82,83,84,85,86,87],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32,\n 33,\n 34,\n 35,\n 36,\n 37,\n 38,\n 39,\n 40,\n 41,\n 42,\n 43,\n 44,\n 45,\n 46,\n 47,\n 48,\n 49,\n 50,\n 51,\n 52,\n 53,\n 54,\n 55,\n 56,\n 57,\n 58,\n 59,\n 60,\n 61,\n 62,\n 63,\n 64,\n 65,\n 66,\n 67,\n 68,\n 69,\n 70,\n 71,\n 72,\n 73,\n 74,\n 75,\n 76,\n 77,\n 78,\n 79,\n 80,\n 81,\n 82,\n 83,\n 84,\n 85,\n 86,\n 87\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[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,null,null,null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":86,"cells":{"problem_id":{"kind":"number","value":221,"string":"221"},"question":{"kind":"string","value":"Given a string S, consider all duplicated substrings: (contiguous) substrings of S that occur 2 or more times. (The occurrences may overlap.)\nReturn any duplicated substring that has the longest possible length. (If S does not have a duplicated substring, the answer is \"\".)\n \nExample 1:\nInput: \"banana\"\nOutput: \"ana\"\n\nExample 2:\nInput: \"abcd\"\nOutput: \"\"\n\n \nNote:\n\n2 <= S.length <= 10^5\nS consists of lowercase English letters."},"solutions":{"kind":"string","value":"[\"class Solution:\\n def longestDupSubstring(self, S):\\n nums, N = [ord(c) - ord('a') for c in S], len(S)\\n BASE, MOD = 26, 2**32\\n def check(L):\\n cur_hash, seen = 0, set()\\n for val in nums[:L]:\\n cur_hash = (cur_hash * BASE + val) % MOD\\n seen.add(cur_hash)\\n X = pow(BASE, L-1, MOD)\\n for idx, val in enumerate(nums[L:]):\\n cur_hash -= nums[idx] * X\\n cur_hash = (cur_hash * BASE + val) % MOD\\n if cur_hash in seen:\\n return idx + 1\\n seen.add(cur_hash)\\n return -1\\n low, high = 1, N + 1\\n start = 0\\n while low < high:\\n mid = (low + high)//2\\n idx = check(mid)\\n if idx != -1:\\n low = mid + 1\\n start = idx\\n else:\\n high = mid\\n return S[start: start + low - 1]\\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n def has_duplicate(m, S):\\n val, Mod = 0, 2**63-1\\n for i in range(m):\\n val = (26*val + ord(S[i])) % Mod\\n \\n d = set([val])\\n const = 26**m % Mod\\n for i in range(m, len(S)):\\n val = (26*val + ord(S[i]) - ord(S[i-m])*const) % Mod\\n if val in d: return i-m+1\\n d.add(val)\\n return -1\\n \\n l, r = 0, len(S)\\n start, length = -1, 0\\n while l<=r:\\n mid = l + (r-l)//2\\n idx = has_duplicate(mid, S)\\n if idx!=-1:\\n l = mid + 1\\n start, length = idx, mid\\n else:\\n r = mid - 1\\n \\n if start==-1: return ''\\n return S[start:start+length]\\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n A = [ord(c) for c in S]\\n mod = 2**63-1\\n \\n lo = 0\\n hi = len(S)\\n res = 0\\n \\n def test(sz):\\n val = 0\\n p = pow(26,sz,mod)\\n for i in range(sz):\\n val = val*26+A[i]\\n val %= mod\\n seen = {val}\\n for i in range(sz, len(A)):\\n val = val*26+A[i]-A[i-sz]*p\\n val = val%mod\\n if val in seen:\\n return i-sz+1\\n seen.add(val)\\n return -1 \\n \\n while lo < hi:\\n mid = (lo+hi)//2\\n pos = test(mid)\\n if not pos >= 0:\\n hi = mid\\n else:\\n res = pos\\n lo = mid+1\\n \\n return S[res:res+lo-1]\\n \\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n def check(L):\\n base = 26\\n modulo = 2**32\\n AL = base**L%modulo\\n hk = 0\\n for i in range(L):\\n hk = hk*base + nums[i]\\n hk %= modulo\\n hm = {hk:0}\\n for i in range(L, len(S)):\\n hk = (hk*base-nums[i-L]*AL+nums[i])%modulo\\n if hk in hm and S[i-L+1:i+1]==S[hm[hk]:hm[hk]+L]:\\n return i-L+1\\n hm[hk] = i-L+1\\n \\n return -1\\n \\n nums = [ord(c)-ord('a') for c in S]\\n res = -1\\n s, e = 1, len(S)\\n while s<=e:\\n m = s+(e-s)//2\\n pos = check(m)\\n if pos!=-1:\\n res = pos\\n s = m+1\\n else:\\n e = m-1\\n \\n return S[res:res+e]\\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n def test(L):\\n base = 26\\n modulus = 2**32\\n AL = base**L%modulus\\n hk = 0\\n for i in range(L):\\n hk=hk*base+nums[i]\\n hk%=modulus\\n hs=set([hk])\\n \\n for i in range(L, len(S)):\\n hk = hk*base-nums[i-L]*AL+nums[i]\\n hk%=modulus\\n if hk in hs:\\n return i-L+1\\n hs.add(hk)\\n \\n nums = [ord(c)-ord('a') for c in S]\\n start, end = 1, len(S)\\n res = -1\\n while start<=end:\\n mid = start+(end-start)//2\\n pos = test(mid)\\n \\n if pos:\\n res = pos\\n start = mid+1\\n else:\\n end = mid-1\\n \\n return S[res:res+end]\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n n=len(S)\\n mod=10**30\\n ord_a=97\\n \\n def find_len_k_dup(k):\\n hash_val=0\\n seen=set()\\n for i in range(k):\\n hash_val=(hash_val*26+(ord(S[i])-ord_a))%mod\\n seen.add(hash_val)\\n power=26**k%mod\\n \\n for i in range(1,n-k+1):\\n hash_val=((hash_val*26-(ord(S[i-1])-ord_a)*power)%mod+(ord(S[i+k-1])-ord_a))%mod\\n if hash_val in seen:\\n return i\\n seen.add(hash_val)\\n return None\\n \\n# self.s=S\\n# self.n=len(S)\\n# def find_len_k_dup(length):\\n# hash_value = 0\\n# mod_value = 8000*(2**30) # a big number should be okay, if you change the number it might cause a wrong answer\\n# seen = set()\\n# for i in range(length):\\n# hash_value = (hash_value*26+ord(self.s[i])-ord('a'))%mod_value # get the hash value\\n# seen.add(hash_value)\\n# tmp = pow(26, length)%mod_value\\n# for i in range(1,self.n-length+1):\\n# # get the moving hash \\n# hash_value = ((hash_value*26 - (ord(self.s[i-1])-ord('a'))*tmp)%mod_value+ord(self.s[i+length-1])-ord('a'))%mod_value\\n# if hash_value in seen:\\n# return i\\n# else:\\n# seen.add(hash_value)\\n# return None\\n \\n \\n \\n \\n low=0\\n high=len(S)\\n res=''\\n while low<high:\\n \\n mid=(low+high)//2\\n idx=find_len_k_dup(mid)\\n #print(candidate)\\n if idx is not None:\\n res=S[idx:idx+mid]\\n low=mid+1\\n else:\\n high=mid\\n return res\", \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n A = [ord(c) - ord('a') for c in S]\\n mod = 2**63 - 1\\n def isDuplicate(len_s):\\n p = pow(31, len_s, mod)\\n seen = collections.defaultdict(list)\\n cur = reduce(lambda x,y: (x*31+y)%mod, A[:len_s])\\n seen[cur].append(0)\\n for j in range(1, len(A)-len_s+1):\\n cur = (cur*31 - A[j-1]*p + A[j+len_s-1])%mod\\n if cur in seen:\\n for i in seen[cur]:\\n if S[i:i+len_s] == S[j:j+len_s]:\\n return j\\n seen[cur].append(j)\\n return 0\\n \\n l, r = 1, len(S)-1\\n ans = ''\\n while l <= r:\\n mid = l + (r-l)//2\\n pos = isDuplicate(mid)\\n if pos:\\n ans = S[pos:pos+mid]\\n l = mid + 1\\n else:\\n r = mid -1\\n return ans \\n \\n \\n\", \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n A = [ord(c) - ord('a') for c in S]\\n mod = 2**63 - 1\\n \\n def test(L):\\n p = pow(26, L, mod)\\n cur = reduce(lambda x, y: (x * 26 + y) % mod, A[: L], 0)\\n seen = set()\\n seen.add(cur)\\n for i in range(L, len(A)):\\n cur = (cur * 26 + A[i] - A[i - L] * p) % mod\\n if cur in seen:\\n return i - L + 1\\n seen.add(cur)\\n \\n res, lo, hi = 0, 0, len(S)\\n while lo + 1 < hi:\\n mid = lo + (hi - lo) // 2\\n pos = test(mid)\\n if pos:\\n lo = mid\\n else:\\n hi = mid\\n \\n if test(hi):\\n pos = test(hi)\\n return S[pos: pos + hi]\\n pos = test(lo)\\n return S[pos: pos + lo]\\n\", \"class Solution:\\n def longestDupSubstring(self, S):\\n nums = [ord(c) - ord('a') for c in S]\\n #BASE, MOD = 113, 1000000007\\n BASE, MOD = 26, 2**32\\n def check(L):\\n cur_hash, seen = 0, set()\\n for val in nums[:L]:\\n cur_hash = ((cur_hash * BASE) + val) % MOD\\n seen.add(cur_hash)\\n X = pow(BASE, L-1, MOD) # (BASE ** (L-1)) % MOD\\n for i, val in enumerate(nums[L:]):\\n # cur_hash -= nums[i] * (BASE ** (L-1))\\n cur_hash -= nums[i] * X\\n cur_hash = ((cur_hash * BASE) + val) % MOD\\n if cur_hash in seen:\\n return i + 1\\n seen.add(cur_hash)\\n return -1\\n low, high = 1, len(S) + 1\\n res = 0\\n while low < high:\\n mid = (low + high)//2\\n idx = check(mid)\\n if idx != -1:\\n low = mid + 1\\n res = idx\\n else:\\n high = mid\\n return S[res: res + low-1]\\n \\n #while low <= high:\\n # mid = (low + high)//2\\n # idx = check(mid)\\n # if idx != -1:\\n # low = mid + 1\\n # res = idx\\n # else:\\n # high = mid - 1\\n #return S[res: res + low-1]\\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n def checkSubstrings(size):\\n hashed = 0\\n pow_mult = pow(26, size) % mod\\n \\n for i in range(size):\\n hashed *= 26\\n hashed += char_vals[i]\\n \\n hashed %= mod\\n seen = {hashed}\\n \\n for i in range(size, len(S)):\\n hashed = (hashed * 26 - char_vals[i-size] * pow_mult + char_vals[i]) % mod\\n if hashed in seen:\\n return i-size+1\\n seen.add(hashed)\\n \\n return None\\n\\n s, f = 0, len(S)\\n longest = 0\\n \\n char_vals = [ord(c) - ord('a') for c in S]\\n mod = pow(2, 63) - 1\\n \\n while s < f:\\n m = s + (f-s+1) // 2\\n longest_check = checkSubstrings(m)\\n if longest_check:\\n longest = longest_check\\n s = m\\n else:\\n f = m-1\\n \\n return S[longest:longest+s]\\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n # def RabinKarp(text, M, q):\\n # if M == 0: return True\\n # h, t, d = (1<<(8*M-8))%q, 0, 256\\n # dic = defaultdict(list)\\n # for i in range(M): \\n # t = (d * t + ord(text[i]))% q\\n # dic[t].append(i-M+1)\\n # for i in range(len(text) - M):\\n # t = (d*(t-ord(text[i])*h) + ord(text[i + M]))% q\\n # for j in dic[t]:\\n # if text[i+1:i+M+1] == text[j:j+M]:\\n # return (True, text[j:j+M])\\n # dic[t].append(i+1)\\n # return (False, \\\\\\\"\\\\\\\")\\n\\n\\n def check(sz):\\n seen = defaultdict(list)\\n cur, base, MOD = 0, 256, (1<<31) - 1\\n h = (1 << (sz*8)) % MOD\\n for i in range(sz):\\n cur *= base\\n cur += ord(S[i])\\n cur %= MOD\\n seen[cur].append(0)\\n for i in range(sz,len(S)):\\n cur *= base\\n cur += ord(S[i])\\n cur -= ord(S[i-sz])*h \\n cur %= MOD\\n for j in seen[cur]:\\n if S[j:j+sz] == S[i-sz+1:i+1]:\\n return True, S[i-sz+1:i+1]\\n seen[cur].append(i-sz+1)\\n return False, ''\\n\\n lo, hi = 1, len(S)\\n res = ''\\n # MOD = (1<<31) - 1\\n while lo <= hi:\\n mid = (lo+hi)//2\\n flag, tmp = check(mid)\\n # flag, tmp = RabinKarp(S, mid, q)\\n if flag:\\n lo = mid + 1\\n res = tmp\\n # print(mid,res)\\n else:\\n hi = mid - 1\\n # print(lo,hi)\\n return res \\n\\n\\n# class Solution:\\n# def RabinKarp(self,text, M, q):\\n# if M == 0: return True\\n# h, t, d = (1<<(8*M-8))%q, 0, 256\\n\\n# dic = defaultdict(list)\\n\\n# for i in range(M): \\n# t = (d * t + ord(text[i]))% q\\n\\n# dic[t].append(i-M+1)\\n\\n# for i in range(len(text) - M):\\n# t = (d*(t-ord(text[i])*h) + ord(text[i + M]))% q\\n# for j in dic[t]:\\n# if text[i+1:i+M+1] == text[j:j+M]:\\n# return (True, text[j:j+M])\\n# dic[t].append(i+1)\\n# return (False, \\\\\\\"\\\\\\\")\\n\\n# def longestDupSubstring(self, S):\\n# beg, end = 0, len(S)\\n# q = (1<<31) - 1 \\n# Found = \\\\\\\"\\\\\\\"\\n# while beg + 1 < end:\\n# mid = (beg + end)//2\\n# isFound, candidate = self.RabinKarp(S, mid, q)\\n# if isFound:\\n# beg, Found = mid, candidate\\n# else:\\n# end = mid\\n\\n# return Found\\n\", \"class Solution:\\n def search(self, S, mid) -> str:\\n n = len(S)\\n # convert string to array of integers to implement constant time slice\\n self.nums = [ord(S[i]) - ord('a') for i in range(n)]\\n # base value for the rolling hash function\\n base = 26\\n # mod value for the rolling hash function to avoid overflow\\n MOD = 2**32\\n \\n # compute the hash of string S[:L]\\n hash_ = 0\\n for i in range(mid):\\n hash_ = (hash_ * base + self.nums[i]) % MOD\\n \\n # already visited hashes of strings of length L\\n visited = {hash_}\\n # const value to be used often : a**L % mod\\n aL = pow(base, mid, MOD)\\n for start in range(1, n - mid + 1):\\n # compute rolling hash in O(1) time\\n hash_ = (hash_ * base - self.nums[start - 1] * aL + self.nums[start + mid - 1]) % MOD\\n if hash_ in visited:\\n return start\\n visited.add(hash_)\\n return -1\\n \\n def longestDupSubstring(self, S: str) -> str:\\n n = len(S)\\n # convert string to array of integers to implement constant time slice\\n self.nums = [ord(S[i]) - ord('a') for i in range(n)]\\n # base value for the rolling hash function\\n base = 26\\n # mod value for the rolling hash function to avoid overflow\\n MOD = 2**32\\n \\n # binary search, L = repeating string length\\n left, right = 1, n\\n while left <= right:\\n mid = left + (right - left) // 2\\n if self.search(S, mid) != -1:\\n left = mid + 1\\n else:\\n right = mid - 1\\n \\n start = self.search(S, left - 1)\\n return S[start: start + left - 1]\\n \\n \\n \\n \\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n def rk(m):\\n \\n nonlocal idx\\n mp = {}\\n p = b**(m-1)\\n p%=mod\\n \\n y = 0\\n for i in range(m):\\n y = y*b+num[i]\\n y%=mod \\n \\n mp[y] = 0\\n \\n for i in range(1, n-m+1):\\n y = ((y-num[i-1]*p%mod)*b%mod+num[i-1+m])%mod\\n #y = (y-num[i-1]*p)*b+num[i-1+m]\\n \\n if y in mp:\\n idx = i\\n return 0\\n else:\\n mp[y]=i\\n \\n return 1\\n \\n \\n\\n n = len(S)\\n b = 26 # no need to be 128\\n #mod = 10**9+7 # too small => conflict\\n mod = 2**32 # here\\n \\n z = ord('a')\\n num = [ ord(S[i])-z for i in range(n)]\\n \\n l=1\\n r=n\\n idx = 0 # last found duplicate \\n while l<r:\\n \\n m = (l+r)//2\\n \\n if rk(m)>0:\\n r = m\\n else:\\n l = m+1\\n \\n return S[idx:idx+l-1]\\n \\n \\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n def rk(m):\\n \\n mp = {}\\n\\n p = b**(m-1)\\n p%=mod\\n \\n y = 0\\n for i in range(m):\\n y = y*b+num[i]\\n y%=mod \\n \\n mp[y] = 0\\n \\n for i in range(1, n-m+1):\\n y = ((y-num[i-1]*p%mod)*b%mod+num[i-1+m])%mod\\n #y = (y-num[i-1]*p)*b+num[i-1+m]\\n \\n if y not in mp:\\n mp[y]=i\\n else:\\n return i\\n \\n return n\\n \\n \\n \\n \\n n = len(S)\\n \\n b = 26 # no need to be 128\\n \\n #mod = 10**9+7 # too small => conflict\\n mod = 2**32 # here\\n \\n num = []\\n for i in range(n):\\n num.append(ord(S[i])-ord('a'))\\n \\n l=1\\n r=n\\n \\n while l<r:\\n \\n m = (l+r)//2\\n \\n if rk(m)==n:\\n r = m\\n else:\\n l = m+1\\n \\n \\n x = l-1\\n \\n if x==0:\\n return ''\\n \\n k = rk(x)\\n \\n return S[k:k+x]\\n \\n \\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n def rk(m):\\n \\n nonlocal idx\\n st = set()\\n p = b**(m-1)\\n p%=mod\\n \\n y = 0\\n for i in range(m):\\n y = y*b+num[i]\\n \\n y%=mod\\n \\n st.add(y)\\n \\n for i in range(1, n-m+1):\\n y = ((y-num[i-1]*p%mod)*b%mod+num[i-1+m])%mod\\n #y = (y-num[i-1]*p)*b+num[i-1+m]\\n \\n if y in st:\\n idx = i\\n return 0\\n else:\\n st.add(y)\\n \\n return 1\\n \\n \\n\\n n = len(S)\\n b = 26 # no need to be 128\\n #mod = 10**9+7 # too small => conflict\\n mod = 2**32 # here\\n \\n z = ord('a')\\n num = [ ord(S[i])-z for i in range(n)]\\n \\n l=1\\n r=n\\n idx = 0 # last found duplicate \\n while l<r:\\n \\n m = (l+r)//2\\n \\n if rk(m)>0:\\n r = m\\n else:\\n l = m+1\\n \\n return S[idx:idx+l-1]\\n \\n \\n\", \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n \\n A = [ord(c) - ord('a') for c in S]\\n mod = 2**63 - 1\\n\\n def test(L):\\n # print(26, L, mod)\\n p = pow(26, L, mod)\\n cur = reduce(lambda x, y: (x * 26 + y) % mod, A[:L], 0)\\n seen = {cur}\\n for i in range(L, len(S)):\\n cur = (cur * 26 + A[i] - A[i - L] * p) % mod\\n if cur in seen: return i - L + 1\\n seen.add(cur)\\n res, lo, hi = 0, 0, len(S)\\n while lo < hi:\\n mi = (lo + hi + 1) // 2\\n pos = test(mi)\\n if pos:\\n lo = mi\\n res = pos\\n else:\\n hi = mi - 1\\n return S[res:res + lo]\\n \\n# s = [ord(num) - ord(\\\\\\\"a\\\\\\\") for num in S]\\n \\n# mod = 10 ** 9 + 7\\n# def check(l):\\n# cur = 0\\n# seen = set()\\n# maxBASE = pow(26, l-1, mod)\\n# for i in range(len(s)):\\n# if i < l:\\n# cur = (cur * 26 + s[i]) % mod\\n# else:\\n# cur -= maxBASE * s[i-l]\\n# cur = (cur * 26 + s[i]) % mod\\n# if i == l-1:\\n# seen.add(cur)\\n# elif i >= l:\\n# if cur in seen:\\n# return i-l+1\\n# else:\\n# seen.add(cur)\\n# return 0\\n \\n \\n \\n \\n# l = 1\\n# r = len(S) - 1\\n# res = -1\\n# while l < r:\\n# m = (l+r) // 2\\n# pos = check(m)\\n# if pos:\\n# l = m \\n# res = pos\\n# else:\\n# r = m - 1\\n# return S[res:res + l]\\n \\n \\n \\n\", \"class Solution:\\n def longestDupSubstring(self, S):\\n nums, N = [ord(c) - ord('a') for c in S], len(S)\\n BASE, MOD = 26, 2**32\\n def check(L):\\n cur_hash, seen = 0, set()\\n for val in nums[:L]:\\n cur_hash = (cur_hash * BASE + val) % MOD\\n seen.add(cur_hash)\\n X = pow(BASE, L-1, MOD)\\n for idx, val in enumerate(nums[L:]):\\n cur_hash -= nums[idx] * X\\n cur_hash = (cur_hash * BASE + val) % MOD\\n if cur_hash in seen:\\n return idx + 1\\n seen.add(cur_hash)\\n return -1\\n low, high = 1, N + 1\\n start = 0\\n while low < high:\\n mid = (low + high)//2\\n idx = check(mid)\\n if idx != -1:\\n low = mid + 1\\n start = idx\\n else:\\n high = mid\\n return S[start: start + low - 1]\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n self.s=S\\n self.n=len(S)\\n def find_len_k_dup(length):\\n hash_value = 0\\n mod_value = 7919*(2**30) # a big number should be okay, if you change the number it might cause a wrong answer\\n seen = set()\\n for i in range(length):\\n hash_value = (hash_value*26+ord(self.s[i])-ord('a'))%mod_value # get the hash value\\n seen.add(hash_value)\\n tmp = pow(26, length)%mod_value\\n for i in range(1,self.n-length+1):\\n # get the moving hash \\n hash_value = (hash_value*26 - (ord(self.s[i-1])-ord('a'))*tmp+mod_value+ord(self.s[i+length-1])-ord('a'))%mod_value\\n if hash_value in seen:\\n return i\\n else:\\n seen.add(hash_value)\\n return None\\n \\n \\n low=0\\n high=len(S)\\n res=''\\n while low<high:\\n \\n mid=(low+high)//2\\n idx=find_len_k_dup(mid)\\n #print(candidate)\\n if idx is not None:\\n res=S[idx:idx+mid]\\n low=mid+1\\n else:\\n high=mid\\n return res\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n lo = 1\\n hi = len(S)\\n nums = [ord(i) - ord('a') for i in S]\\n self.modulus = 2 ** 32\\n \\n def dup(l):\\n seen = set()\\n hval = 0\\n for i in range(l):\\n hval = (hval*26 + nums[i]) % self.modulus\\n seen.add(hval)\\n al = pow(26,l,self.modulus)\\n for i in range(1,len(S) - l+1):\\n hval = (hval*26 - nums[i-1]*al + nums[i+l-1]) % self.modulus\\n if hval in seen:\\n return i\\n seen.add(hval)\\n return -1\\n \\n start = -1\\n while lo <= hi:\\n mi = lo + (hi-lo)//2\\n begin = dup(mi)\\n if begin != -1:\\n lo = mi + 1\\n start = begin\\n else:\\n hi = mi - 1\\n \\n return S[start: start + lo - 1]\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n N = len(S)\\n l, r = 1, N\\n nums = [ord(x) - ord('a') for x in S]\\n KMAX = 2 ** 63 - 1\\n def check(m):\\n MAXL = pow(26, m, KMAX)\\n total = 0\\n hashset = set()\\n for i in range(m):\\n total = (total * 26 + nums[i]) % KMAX\\n hashset.add(total)\\n for i in range(1, N - m + 1):\\n total = (total * 26 - MAXL * nums[i-1] + nums[i + m - 1]) % KMAX\\n if total in hashset:\\n return i\\n hashset.add(total)\\n return -1 \\n \\n while l < r:\\n m = (l + r) // 2\\n if check(m) < 0:\\n r = m\\n else:\\n l = m + 1\\n idx = check(r - 1) \\n return S[idx: idx + r-1]\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n self.s=S\\n self.n=len(S)\\n def find_len_k_dup(length):\\n hash_value = 0\\n mod_value = 8000*(2**30) # a big number should be okay, if you change the number it might cause a wrong answer\\n seen = set()\\n for i in range(length):\\n hash_value = (hash_value*26+ord(self.s[i])-ord('a'))%mod_value # get the hash value\\n seen.add(hash_value)\\n tmp = pow(26, length)%mod_value\\n for i in range(1,self.n-length+1):\\n # get the moving hash \\n hash_value = ((hash_value*26 - (ord(self.s[i-1])-ord('a'))*tmp)%mod_value+ord(self.s[i+length-1])-ord('a'))%mod_value\\n if hash_value in seen:\\n return i\\n else:\\n seen.add(hash_value)\\n return None\\n \\n \\n low=0\\n high=len(S)\\n res=''\\n while low<high:\\n \\n mid=(low+high)//2\\n idx=find_len_k_dup(mid)\\n #print(candidate)\\n if idx is not None:\\n res=S[idx:idx+mid]\\n low=mid+1\\n else:\\n high=mid\\n return res\", \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n A = [ord(c) - ord('a') for c in S]\\n mod = 2**63 - 1\\n\\n def test(L):\\n p = pow(26, L, mod)\\n cur = reduce(lambda x, y: (x * 26 + y) % mod, A[:L], 0)\\n seen = {cur}\\n for i in range(L, len(S)):\\n cur = (cur * 26 + A[i] - A[i - L] * p) % mod\\n if cur in seen: return i - L + 1\\n seen.add(cur)\\n res, lo, hi = 0, 0, len(S)\\n while lo + 1 < hi:\\n mi = (lo + hi) // 2\\n pos = test(mi)\\n if pos:\\n lo = mi\\n else:\\n hi = mi\\n \\n if test(hi):\\n res = test(hi)\\n return S[res: res + hi]\\n elif test(lo):\\n res = test(lo)\\n return S[res: res + lo]\\n # return ''\\n\", \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S):\\n def evaluateLength(length):\\n power = pow(26, length, mod)\\n current = reduce(lambda x, y: (x*26 + y) % mod, ids[:length], 0)\\n explored = {current}\\n for index in range(length, len(S)):\\n current = (current * 26 + ids[index] - ids[index - length] * power) % mod\\n if current in explored:\\n return index - length + 1\\n explored.add(current)\\n \\n ids = [ord(character) - ord('a') for character in S]\\n mod = 2**63 - 1\\n index, low, high = 0, 0, len(S)\\n while low < high:\\n mid = (high + low + 1) // 2\\n position = evaluateLength(mid)\\n if position:\\n index = position\\n low = mid\\n else:\\n high = mid - 1 \\n return S[index:(index+low)]\\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n N = len(S)\\n l, r = 1, N\\n nums = [ord(x) - ord('a') for x in S]\\n KMAX = 2 ** 63 - 1\\n def check(m):\\n MAXL = pow(26, m, KMAX)\\n total, hashset = 0, set()\\n for i in range(m):\\n total = (total * 26 + nums[i]) % KMAX\\n hashset.add(total)\\n for i in range(1, N - m + 1):\\n total = (total * 26 - MAXL * nums[i-1] + nums[i+m-1]) % KMAX\\n if total in hashset:\\n return i\\n hashset.add(total)\\n return -1\\n \\n while l < r:\\n m = (l + r) // 2\\n if check(m) < 0:\\n r = m\\n else:\\n l = m + 1\\n idx = check(r - 1) \\n return S[idx: idx + r-1]\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n def check(s, L):\\n n = len(s)\\n BASE = 26\\n MOD = 1 << 61 - 1\\n P = pow(26, L, MOD)\\n cur = 0\\n seen = defaultdict(list)\\n \\n for i in range(len(s)):\\n cur = (cur*BASE + ord(s[i]) - ord('a')) % MOD\\n if i >= L:\\n cur = (cur - (ord(s[i-L]) - ord('a')) * P) % MOD\\n \\n if i >= L - 1:\\n if cur in seen:\\n cur_str = s[i-L+1:i+1]\\n for j in seen[cur]:\\n pre_str = s[j-L+1:j+1]\\n if cur_str == pre_str:\\n return cur_str\\n seen[cur].append(i) \\n return ''\\n \\n \\n lo, hi = 1, len(S)\\n ans = ''\\n while lo < hi:\\n mid = (lo + hi) // 2\\n temp = check(S, mid)\\n if temp:\\n ans = temp\\n lo = mid + 1\\n else:\\n hi = mid\\n\\n return ans\\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n p = 239017\\n pows = [[1], [1]]\\n hsh = [[0], [0]]\\n mods = [int(1e9) + 7, int(1e9) + 9]\\n for ch in S:\\n for i in range(len(mods)):\\n hsh[i].append((hsh[i][-1] + ord(ch) * pows[i][-1]) % mods[i])\\n pows[i].append((pows[i][-1] * p) % mods[i]) \\n l = 0\\n r = len(S)\\n substrs = {}\\n ans = ''\\n while r - l > 1:\\n m = (r + l) // 2\\n found = False\\n for i in range(0, len(S) - m + 1):\\n h0 = ((hsh[0][i + m] - hsh[0][i]) * pows[0][-(i + 1)]) % mods[0]\\n h1 = ((hsh[1][i + m] - hsh[1][i]) * pows[1][-(i + 1)]) % mods[1]\\n if (h0, h1) in substrs:\\n found = True\\n ans = S[i: i + m]\\n break\\n else:\\n substrs[(h0, h1)] = True\\n if found:\\n l = m\\n else:\\n r = m\\n substrs.clear()\\n return ans\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n mod = 2 ** 31 - 1\\n base = 26\\n \\n def get_ord(char: str):\\n return ord(char) - ord('a')\\n \\n def find_duplicate(length) -> str:\\n hashes = {}\\n h = 1\\n for i in range(length - 1):\\n h = (h * base) % mod\\n\\n cur = 0\\n for i in range(length):\\n cur = (cur * base + get_ord(S[i])) % mod\\n \\n hashes[cur] = [0]\\n\\n for i in range(1, len(S) - length + 1):\\n cur = ((cur - (get_ord(S[i-1]) * h)) * base + get_ord(S[i + length - 1])) % mod\\n if cur in hashes:\\n for idx in hashes[cur]:\\n if S[idx: idx + length] == S[i: i + length]:\\n return S[i: i + length]\\n hashes[cur].append(i)\\n else:\\n hashes[cur] = [i]\\n return ''\\n \\n \\n def helper(start, end):\\n res = ''\\n while start < end:\\n length = (start + end) // 2 + 1\\n r = find_duplicate(length)\\n if len(r) > len(res):\\n res = r\\n if not r:\\n end = length - 1\\n else:\\n start = length\\n return res\\n\\n return helper(0, len(S) - 1)\", \"class Solution:\\n def findRepSubstrGivenLength(self, nums: List[int], l:int, base:int, modulus:int) -> int:\\n \\n n = len(nums)\\n \\n h = 0\\n for i in range(l):\\n h = (h * base + nums[i]) % modulus\\n \\n seen = {h}\\n \\n for start in range(1, n-l+1):\\n h = (h * base - nums[start - 1] * pow(base, l, modulus) + nums[start + l - 1]) % modulus\\n \\n if h in seen:\\n return start\\n \\n seen.add(h)\\n \\n return -1 \\n \\n \\n def longestDupSubstring(self, S: str) -> str:\\n if not S:\\n return ''\\n \\n nums = [ord(S[i]) - ord('a') for i in range(len(S))]\\n \\n base = 26\\n modulus = 2**32\\n \\n left = 1\\n right = len(S)\\n \\n while left <= right:\\n mid = left + (right - left) // 2\\n \\n if self.findRepSubstrGivenLength(nums, mid, base, modulus) != -1:\\n left = mid + 1\\n else:\\n right = mid -1\\n \\n start = self.findRepSubstrGivenLength(nums, left-1, base, modulus)\\n \\n return S[start: start + left -1] \\n \\n \\n \\n'''\\nclass Solution:\\n class Node:\\n def __init__(self, v='*'): \\n self.value = v\\n self.next = dict()\\n self.occurences = set()\\n \\n \\n def print_tree(self, node, indentation):\\n print(indentation + str(node.value) + \\\\\\\": \\\\\\\" + str(node.occurences))\\n\\n for v in node.next.keys():\\n self.print_tree(node.next[v], indentation + '\\\\\\\\t')\\n \\n \\n def getNode(self, node, v):\\n if v not in node.next.keys():\\n node.next[v] = self.Node(v)\\n\\n return node.next[v]\\n\\n\\n def AddOccurences(self, node, i, S):\\n node.occurences.add(i)\\n\\n if len(node.occurences) == 2:\\n for o in node.occurences:\\n if o + 1 < len(S):\\n self.AddOccurences(self.getNode(node, S[o+1]), o+1, S)\\n\\n\\n if len(node.occurences)>2:\\n if i + 1 < len(S):\\n self.AddOccurences(self.getNode(node, S[i+1]), i+1, S)\\n\\n \\n def getLongestDuplicate(self, node):\\n maxSubstring = ''\\n \\n for v in node.next.keys():\\n if len(node.next[v].occurences)>1:\\n\\n childSubstring = self.getLongestDuplicate(node.next[v])\\n if len(childSubstring) + 1 > len(maxSubstring):\\n maxSubstring = v + childSubstring\\n \\n return maxSubstring\\n \\n \\n def longestDupSubstring(self, S: str) -> str:\\n if not S:\\n return 0\\n \\n if len(set(S)) == 1:\\n return S[0:len(S)-1]\\n\\n root = self.Node()\\n\\n for i in range(len(S)):\\n self.AddOccurences(self.getNode(root, S[i]), i, S)\\n\\n #self.print_tree(root, '')\\n maxDepthDuplicates = self.getLongestDuplicate(root)\\n \\n return maxDepthDuplicates\\n''' \", \"class Solution:\\n def longestDupSubstring(self, S):\\n nums = [ord(c) - ord('a') for c in S]\\n #BASE, MOD = 113, 1000000007\\n BASE, MOD = 26, 2**32\\n def check(L):\\n cur_hash, seen = 0, set()\\n for val in nums[:L]:\\n cur_hash = ((cur_hash * BASE) + val) % MOD\\n seen.add(cur_hash)\\n X = pow(BASE, L-1, MOD) # (BASE ** (L-1)) % MOD\\n for i, val in enumerate(nums[L:]):\\n # cur_hash -= nums[i] * (BASE ** (L-1))\\n cur_hash -= nums[i] * X\\n cur_hash = ((cur_hash * BASE) + val) % MOD\\n if cur_hash in seen:\\n return i + 1\\n seen.add(cur_hash)\\n return -1\\n low, high = 1, len(S)\\n res = 0\\n while low < high:\\n mid = (low + high)//2\\n idx = check(mid)\\n if idx != -1:\\n low = mid + 1\\n res = idx\\n else:\\n high = mid\\n return S[res: res + low-1]\\n \\n #while low <= high:\\n # mid = (low + high)//2\\n # idx = check(mid)\\n # if idx != -1:\\n # low = mid + 1\\n # res = idx\\n # else:\\n # high = mid - 1\\n #return S[res: res + low-1]\\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n def check(Val):\\n base, modulus = 26, 2**32\\n AL = base**Val%modulus\\n hk = 0\\n for i in range(Val):\\n hk = hk*base + ord(S[i])-ord('a')\\n hk %= modulus\\n hm = {hk: 0}\\n \\n for i in range(Val, N):\\n hk = hk*base - (ord(S[i-Val])-ord('a'))*AL + ord(S[i]) - ord('a')\\n hk %= modulus\\n if hk in hm and S[hm[hk]:hm[hk]+Val]==S[i-Val+1:i+1]:\\n return i-Val+1\\n \\n hm[hk] = i-Val+1\\n # print(mid, hm)\\n \\n N = len(S)\\n start, end = 1, N\\n res = 0\\n while start<=end:\\n mid = start+(end-start)//2\\n pos = check(mid)\\n if pos:\\n res = pos\\n start = mid+1\\n else:\\n end = mid-1\\n \\n return S[res:res+end]\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n n = len(S)\\n BASE = 26\\n MOD = (1 << 63) - 1\\n POWS = [1] * n\\n for i in range(1, n):\\n POWS[i] = (POWS[i - 1] * BASE) % MOD\\n def search(k):\\n seen = set()\\n h = 0\\n for i in range(k):\\n h = (h * BASE + ord(S[i]) - 97) % MOD\\n seen.add(h)\\n for i in range(k, n):\\n h = ((h - (ord(S[i - k]) - 97) * POWS[k - 1]) * BASE + ord(S[i]) - 97) % MOD\\n s = S[i - k + 1:i + 1]\\n if h in seen:\\n return i\\n seen.add(h)\\n return -1\\n \\n l, r = 0, n - 1\\n while l <= r:\\n m = (l + r) // 2\\n if search(m) >= 0:\\n l = m + 1\\n else:\\n r = m - 1\\n if r < 0:\\n return ''\\n i = search(r)\\n return S[i - r + 1:i + 1]\", \"class Solution:\\n def search(self, L: int, a: int, modulus: int, n: int, nums: List[int]) -> str:\\n h = 0\\n for i in range(L):\\n h = (h * a + nums[i]) % modulus\\n \\n seen = {h}\\n \\n aL = pow(a, L, modulus)\\n \\n for start in range(1, n-L + 1):\\n h = (h * a - nums[start - 1]* aL + nums[start + L - 1]) % modulus\\n if h in seen:\\n return start\\n seen.add(h)\\n return -1\\n \\n def longestDupSubstring(self, S: str) -> str:\\n n = len(S)\\n nums = [ord(S[i]) - ord('a') for i in range(n)]\\n a = 26\\n modulus = 2 ** 32\\n left, right = 1, n\\n while left <= right:\\n L = left + (right - left) // 2\\n if self.search(L, a, modulus, n, nums) != -1:\\n left = L + 1\\n else:\\n right = L - 1\\n start = self.search(left -1, a, modulus, n, nums)\\n return S[start: start + left - 1]\\n\", \"from collections import defaultdict\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n l, h = 2, len(S)-1\\n res = ''\\n while l <= h:\\n m = l + (h-l) // 2\\n cand = self.find_dup_substr_len_k(S, m)\\n if cand:\\n res = cand\\n l = m+1\\n else:\\n h = m-1\\n return res\\n \\n def find_dup_substr_len_k(self, s, k):\\n MOD = (1 << 63) - 1\\n BASE = 26\\n D = pow(BASE, k-1, MOD)\\n hash_val = 0\\n seen = defaultdict(set)\\n \\n for i in range(len(s)):\\n # update the sliding hash value\\n if i >= k:\\n char_offset = ord(s[i-k]) - ord('a') \\n hash_val = (hash_val - char_offset * D) % MOD\\n char_offset = ord(s[i]) - ord('a') \\n hash_val = (hash_val * BASE + char_offset) % MOD\\n \\n # check hash collision and return string if duplicate found\\n if i >= k-1:\\n if hash_val in seen:\\n cand_i = s[i-k+1:i+1]\\n for j in seen[hash_val]:\\n cand_j = s[j-k+1:j+1]\\n if cand_i == cand_j:\\n return cand_i\\n seen[hash_val].add(i)\\n return ''\\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n def code(t):\\n return ord(t) - ord('a')+1\\n def check(length):\\n seen = collections.defaultdict(list)\\n \\n MOD = 10 ** 9 + 7\\n P = 113\\n INV_P = pow(P, MOD-2, MOD)\\n\\n h = 0\\n power = 1\\n '''\\n h1 = s[0]p^0+s[1]p^1+s[2]p^2 +...+s[length-1]p^(length-1)\\n move next:\\n h2 = s[1]p^0+s[2]p^1+s[3]p^2 +...+s[length]p^(length-1)\\n \\n h2 = (h1 - S[i-length+1])*INV_P % MOD\\n \\n '''\\n for i, x in enumerate(S):\\n h = (h + power*code(x)) % MOD \\n if i < length-1:\\n power = power * P % MOD\\n else:\\n # start: i-(length-1)\\n if h in seen:\\n for j in seen[h]:\\n if S[i-(length-1):i+1] == S[j:j+length]:\\n return S[j:j+length], True\\n seen[h].append(i-(length-1))\\n h = (h-code(S[i-(length-1)]))*INV_P % MOD\\n \\n return '', False\\n \\n res = ''\\n l, r = 1, len(S)-1\\n while l <= r:\\n mid = (l+r)//2\\n sub, is_check = check(mid)\\n if is_check:\\n res = sub\\n l = mid + 1\\n else:\\n r = mid - 1\\n \\n return res\", \"class Solution:\\n \\n def find(self ,s , m) :\\n \\n seen = collections.defaultdict(list)\\n \\n mod = 1<<63 -1\\n base = 26\\n d = pow(26,m-1,mod)\\n chal = 0\\n \\n for i in range(len(s)) :\\n \\n if i >= m :\\n l_chal = ord(s[i-m]) - ord('a')\\n chal = ( chal - l_chal*d)%mod\\n \\n l_chal = ord(s[i]) - ord('a')\\n chal = (chal*base + l_chal)%mod\\n \\n if i >= m-1 :\\n s_i = s[i-m+1 : i +1]\\n if chal in seen :\\n \\n for j in seen[chal] :\\n s_j = s[j-m+1 : j+1]\\n if s_j == s_i :\\n return s_i\\n \\n else :\\n seen[chal].append(i)\\n \\n return ''\\n \\n def longestDupSubstring(self, S: str) -> str:\\n \\n l = 2 \\n h = len(S) -1\\n ans = ''\\n \\n while l <= h :\\n m = (l+h)//2\\n \\n s = self.find(S ,m)\\n \\n if s != '' :\\n ans = s\\n l = m+1\\n \\n else :\\n h = m-1\\n \\n return ans\", \"class Solution:\\n def longestDupSubstring(self, S):\\n nums, N = [ord(c) - ord('a') for c in S], len(S)\\n BASE, MOD = 26, 2**32\\n def check(L):\\n cur_hash, seen = 0, set()\\n for val in nums[:L]:\\n cur_hash = (cur_hash * BASE + val) % MOD\\n seen.add(cur_hash)\\n X = pow(BASE, L-1, MOD)\\n for idx, val in enumerate(nums[L:], start = L):\\n cur_hash -= nums[idx - L] * X\\n cur_hash = (cur_hash * BASE + val) % MOD\\n if cur_hash in seen:\\n return idx - L + 1\\n seen.add(cur_hash)\\n return -1\\n low, high = 1, N + 1\\n start = 0\\n while low < high:\\n mid = (low + high)//2\\n idx = check(mid)\\n if idx != -1:\\n low = mid + 1\\n start = idx\\n else:\\n high = mid\\n return S[start: start + low - 1]\", \"from collections import defaultdict\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n mod = 10 ** 9 + 7\\n def get_rep(l: int) -> str:\\n mp = defaultdict(list) # key: hash_code, value: list of start indexes of substrings\\n a = 13\\n sofar = 0\\n factor = 1\\n for i in range(l):\\n sofar = (sofar * a + ord(S[i])) % mod\\n factor = (factor * a) % mod\\n mp[sofar].append(0)\\n for i in range(l, len(S)):\\n sofar = (sofar * a + ord(S[i]) - factor * ord(S[i - l])) % mod\\n if sofar in mp:\\n for j in mp[sofar]:\\n if S[j: j + l] == S[i - l + 1: i + 1]:\\n return S[i - l + 1: i + 1]\\n mp[sofar].append(i - l + 1)\\n return None\\n \\n low, high = 0, len(S) - 1\\n ans = None\\n while low <= high:\\n mid = (low + high) // 2\\n res = get_rep(mid)\\n if res is None:\\n high = mid - 1\\n else:\\n ans = res\\n low = mid + 1\\n return ans if ans is not None else ''\\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n def search(m, MOD):\\n h = 0\\n for i in range(m):\\n h = (h * 26 + nums[i]) % MOD\\n s = {h}\\n aL = pow(26, m, MOD)\\n for pos in range(1, n - m + 1):\\n h = (h * 26 - nums[pos - 1] * aL + nums[pos + m - 1]) % MOD\\n if h in s:\\n return pos\\n s.add(h)\\n return -1\\n\\n n = len(S)\\n nums = [ord(c) - ord('a') for c in S]\\n l, r = 1, n\\n pos = -1\\n MOD = 2**63 - 1\\n while l <= r:\\n m = (l + r) // 2\\n cur = search(m, MOD)\\n if cur != -1:\\n l = m + 1\\n pos = cur\\n else:\\n r = m - 1\\n return S[pos: pos + l - 1] \", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n base, mod = 26, 2**63 - 1\\n n = len(S)\\n A = [ord(ch) - ord('a') for ch in S]\\n def k_dup(k):\\n curr = 0\\n for i in range(k):\\n curr = (curr * base + A[i]) % mod\\n seen = {curr}\\n for i in range(1, n - k + 1):\\n curr = ( base*curr - pow(base, k, mod)*A[i-1] + A[i+k-1]) % mod\\n if curr in seen:\\n return i\\n seen.add(curr)\\n return 0\\n l, r, ans = 0, n, 0\\n while l < r:\\n mid = (l + r + 1) >> 1\\n pos = k_dup(mid)\\n # print(pos, mid)\\n if pos:\\n l = mid\\n ans = pos\\n else:\\n r = mid - 1\\n return S[ans:ans + l]\\n \\n\", \"class Solution:\\n def longestDupSubstring(self, S):\\n nums = [ord(c) - ord('a') for c in S]\\n BASE, MOD = 26, 2**32 # Wrong: BASE, MOD = 113, 1000000007, too small\\n def check(L):\\n cur_hash, seen = 0, set()\\n for val in nums[:L]:\\n cur_hash = ((cur_hash * BASE) + val) % MOD\\n seen.add(cur_hash)\\n X = pow(BASE, L-1, MOD) # much faster than (BASE ** (L-1)) % MOD\\n for i, val in enumerate(nums[L:]):\\n # cur_hash -= nums[i] * (BASE ** (L-1))\\n cur_hash -= nums[i] * X\\n cur_hash = ((cur_hash * BASE) + val) % MOD\\n if cur_hash in seen:\\n return i + 1\\n seen.add(cur_hash)\\n return -1\\n low, high = 1, len(S) + 1\\n res = 0\\n while low < high:\\n mid = (low + high)//2\\n idx = check(mid)\\n if idx != -1:\\n low = mid + 1\\n res = idx\\n else:\\n high = mid\\n return S[res: res + low-1]\\n \\nclass Solution:\\n def longestDupSubstring(self, S):\\n N = len(S)\\n def check(length):\\n seen = set()\\n for i in range(N - length):\\n hashS = hash(S[i:i+length+1])\\n if hashS in seen:\\n return i\\n seen.add(hashS)\\n return 0\\n\\n low, high = 0, N\\n idx = 0\\n while low < high:\\n mid = (low + high)//2\\n start = check(mid)\\n if start:\\n low = mid + 1\\n idx = start\\n else:\\n high = mid\\n return S[idx:idx + low]\", \"class Solution:\\n def search(self, L: int, base: int, MOD: int, n: int, nums: List[int]) -> str:\\n # compute the hash of string S[:L]\\n h = 0\\n for i in range(L):\\n h = (h * base + nums[i]) % MOD\\n \\n # already seen hashes of strings of length L\\n seen = {h} \\n # const value to be used often : a**L % mod\\n aL = pow(base, L, MOD) \\n for start in range(1, n - L + 1):\\n # compute rolling hash in O(1) time\\n h = (h * base - nums[start - 1] * aL + nums[start + L - 1]) % MOD\\n if h in seen:\\n return start\\n seen.add(h)\\n return -1\\n \\n def longestDupSubstring(self, S: str) -> str:\\n n = len(S)\\n # convert string to array of integers to implement constant time slice\\n nums = [ord(S[i]) - ord('a') for i in range(n)]\\n # base value for the rolling hash function\\n base = 26\\n # mod value for the rolling hash function to avoid overflow\\n MOD = 2**32\\n \\n # binary search, L = repeating string length\\n left, right = 1, n\\n while left <= right:\\n mid = left + (right - left) // 2\\n if self.search(mid, base, MOD, n, nums) != -1:\\n left = mid + 1\\n else:\\n right = mid - 1\\n \\n start = self.search(left - 1, base, MOD, n, nums)\\n return S[start: start + left - 1]\\n \\n \\n \\n \\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n n = len(S)\\n low = 0\\n high = n-1\\n \\n nums = [ord(S[i]) - ord('a') for i in range(n)]\\n \\n def findDuplicate(L):\\n # compute the hash of string S[:L]\\n h = 0\\n a = 26\\n modulus = 2**32\\n for i in range(L):\\n h = (h * a + nums[i]) % modulus\\n\\n # already seen hashes of strings of length L\\n seen = {h}\\n # const value to be used often : a**L % modulus\\n aL = pow(a, L, modulus) \\n for start in range(1, n - L + 1):\\n # compute rolling hash in O(1) time\\n h = (h * a - nums[start - 1] * aL + nums[start + L - 1]) % modulus\\n if h in seen:\\n return start\\n seen.add(h)\\n return -1\\n \\n res = ''\\n while low < high:\\n mid = (low + high + 1)//2\\n start = findDuplicate(mid)\\n if start != -1:\\n low = mid\\n res = S[start:start+mid] \\n else:\\n high = mid-1\\n return res\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n l = 0\\n r = len(S)\\n base = 26\\n mod = 2**32\\n res = [0, 0]\\n nums = [ord(n) - ord('a') for n in S]\\n\\n \\n while l < r:\\n \\n mid = (l+r) // 2\\n h = 0\\n \\n for i in range(0, mid):\\n h = (h*base + nums[i]) % mod\\n \\n dups = set([h])\\n remove = pow(base, mid, mod)\\n \\n for i in range(1, len(nums) - mid + 1):\\n h = (h*base - nums[i-1] * remove + nums[i+mid-1]) % mod\\n \\n if h in dups:\\n res = [i, i+mid]\\n break\\n \\n dups.add(h)\\n # print(mid, h) \\n if res[1] - res[0] < mid:\\n r = mid\\n else:\\n l = mid + 1\\n \\n \\n return S[res[0]:res[1]]\\n \\n \\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n low = 0\\n high = len(S)-1\\n result = ''\\n nums = [ord(i) - ord('a') for i in S]\\n mod = 2**63-1\\n \\n def rabin_karp(size):\\n power = pow(26,size,mod)\\n hash_val = 0\\n hash_set = set()\\n for i in range(size):\\n hash_val = (hash_val*26 + (nums[i]))%mod\\n hash_set.add(hash_val)\\n for i in range(size, len(S)):\\n hash_val = (hash_val*26 - (power*nums[i-size]) + nums[i])%mod\\n if hash_val in hash_set:\\n return i-size+1\\n else:\\n hash_set.add(hash_val)\\n return -1\\n while(low <= high):\\n mid = low + (high-low)//2\\n pos = rabin_karp(mid)\\n if pos == -1:\\n high = mid - 1\\n else:\\n result = S[pos:pos+mid]\\n low = mid+1\\n return result\", \"class Solution:\\n def longestDupSubstring(self, S):\\n nums = [ord(c) - ord('a') for c in S]\\n BASE, MOD = 26, 2**32 # Wrong: BASE, MOD = 113, 1000000007, too small\\n def check(L):\\n cur_hash, seen = 0, set()\\n for val in nums[:L]:\\n cur_hash = ((cur_hash * BASE) + val) % MOD\\n seen.add(cur_hash)\\n X = pow(BASE, L-1, MOD) # much faster than (BASE ** (L-1)) % MOD\\n for i, val in enumerate(nums[L:]):\\n # cur_hash -= nums[i] * (BASE ** (L-1))\\n cur_hash -= nums[i] * X\\n cur_hash = ((cur_hash * BASE) + val) % MOD\\n if cur_hash in seen:\\n return i + 1\\n seen.add(cur_hash)\\n return -1\\n low, high = 1, len(S) + 1\\n res = 0\\n while low < high:\\n mid = (low + high)//2\\n idx = check(mid)\\n if idx != -1:\\n low = mid + 1\\n res = idx\\n else:\\n high = mid\\n return S[res: res + low-1]\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n n=len(S)\\n modulus=2**32\\n a=26 \\n nums=[ord(c)-ord('a') for c in S]\\n def search(L):\\n nonlocal a,n,modulus\\n aL=pow(a,L,modulus)\\n h=0\\n for i in range(L):\\n h=(h*a+nums[i])%modulus\\n seen={h}\\n for start in range(1,n-L+1):\\n h=(h*a-nums[start-1]*aL+nums[start+L-1])%modulus\\n if h in seen:\\n return start\\n seen.add(h)\\n return -1\\n \\n l,r=1,n\\n while l<=r:\\n mid=(l+r)>>1\\n if search(mid)!=-1:\\n l=mid+1\\n else:\\n r=mid-1\\n \\n start=search(r) \\n return S[start:start+r]\", \"class Solution:\\n \\n def rabinKarp(self, L, nums):\\n h = 0\\n a = 26\\n MOD = 2**32\\n for i in range(L):\\n h = (h * a + nums[i]) % MOD\\n \\n aL = pow(a, L, MOD)\\n seen = {h}\\n for start in range(1, len(nums)-L+1):\\n h = (h *a - nums[start-1] * aL + nums[start+L-1]) % MOD\\n if h in seen:\\n return start\\n seen.add(h)\\n return -1\\n \\n def longestDupSubstring(self, S: str) -> str: \\n nums = [ord(ch)-ord('a') for ch in S]\\n l, r = 0, len(S)\\n while l < r:\\n mid = l + (r-l) // 2\\n if self.rabinKarp(mid, nums) != -1:\\n l = mid + 1\\n else:\\n r = mid\\n start = self.rabinKarp(l-1, nums)\\n return S[start:start+l-1] \\n \\n\", \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n # binary search + string hashing\\n from functools import reduce\\n A = [ord(c) - ord('a') for c in S]\\n mod = 2 ** 63 - 1\\n def judge(l):\\n p = 26 ** l % mod\\n cur = reduce(lambda x, y : (x * 26 + y) % mod, A[:l], 0)\\n seen = {cur}\\n for i in range(l, len(S)):\\n cur = (cur * 26 + A[i] - p * A[i - l]) % mod\\n if cur in seen: return i - l + 1\\n seen.add(cur)\\n \\n lo, hi = 0, len(S)\\n res = 0\\n while lo < hi:\\n mi = (lo + hi + 1) // 2\\n pos = judge(mi)\\n if pos:\\n lo = mi\\n res = pos\\n else:\\n hi = mi - 1\\n return S[res : res + lo]\\n\", \"class Solution:\\n # Use binary search to try out all possible lengths of the subtrings\\n # Use a record list to record the hash summation of the substring\\n # Use the number of distinct chara as the hash base\\n # If two substrings are the same, they should have the same hash summation\\n # After minus the before part\\n def longestDupSubstring(self, S: str) -> str:\\n res = ''\\n d,q = len(set(S)), 2**63-1\\n record = [0]*len(S)\\n for i in range(len(S)):\\n if i == 0:record[i] = ord(S[i])\\n else:record[i] = (record[i-1]*d+ord(S[i]))%q\\n def check(mid):\\n h,g = 1,set()\\n for i in range(mid):\\n h = h*d%q\\n for i in range(len(S)-mid+1):\\n count = (record[i+mid-1]-record[i-1]*h)%q if i > 0 else record[i+mid-1]\\n if count not in g:g.add(count)\\n else:return S[i:i+mid]\\n return False\\n l,r = 0,len(S)-1\\n while l<=r:\\n mid = (l+r)//2\\n temp = check(mid)\\n if temp:\\n res = temp\\n l = mid + 1\\n else:r = mid - 1\\n return res\\n \\n \\n# res = \\\\\\\"\\\\\\\"\\n# d, q = len(set(S)), 2**63-1\\n# hashes = [0] * len(S)\\n# for i in range(len(S)):\\n# if i == 0: hashes[i] = ord(S[i])\\n# else: hashes[i] = (hashes[i-1]*d + ord(S[i]))%q\\n# l, r = 0, len(S)-1\\n# while l <= r:\\n# mid = (l+r)//2\\n# temp = self.check(S,mid,hashes,d,q)\\n# if temp:\\n# res = temp\\n# l = mid + 1\\n# else: r = mid - 1\\n# return res\\n \\n# def check(self, S, mid, hashes, d, q):\\n# res = set()\\n# h, g = 1, 0\\n# for i in range(mid):\\n# h = (h*d)%q\\n# for i in range(len(S)-mid+1):\\n# g = (hashes[i+mid-1] - hashes[i-1]*h)%q if i > 0 else hashes[i+mid-1]\\n# if g not in res: res.add(g)\\n# else: return S[i:i+mid]\\n# return False\\n \\n \\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n def rk(m):\\n \\n nonlocal idx\\n st = set()\\n \\n #p = b**(m-1)\\n #p%=mod\\n p= pow(b,m-1,mod) # more efficient to mod at each step than work on a long number\\n \\n y = 0\\n for i in range(m):\\n y = (y*b+num[i])%mod # more efficient to mod at each step than work on a long number\\n \\n st.add(y)\\n \\n for i in range(1, n-m+1):\\n y = ((y-num[i-1]*p%mod)*b%mod+num[i-1+m])%mod\\n #y = (y-num[i-1]*p)*b+num[i-1+m]\\n \\n if y in st:\\n idx = i\\n return 0\\n else:\\n st.add(y)\\n \\n return 1\\n \\n \\n\\n n = len(S)\\n b = 26 # no need to be 128\\n #mod = 10**9+7 # too small => conflict\\n mod = 2**32 # here\\n \\n z = ord('a')\\n num = [ ord(S[i])-z for i in range(n)]\\n \\n l=1\\n r=n\\n idx = 0 # last found duplicate \\n while l<r:\\n \\n m = (l+r)//2\\n \\n if rk(m)>0:\\n r = m\\n else:\\n l = m+1\\n \\n return S[idx:idx+l-1]\\n \\n \\n\", \"p = 2**63 - 1\\n\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n def rabin_karp(mid):\\n cur_hash = 0\\n for i in range(mid):\\n cur_hash = (cur_hash * 26 + nums[i]) % p\\n hashes = {cur_hash}\\n pos = -1\\n max_pow = pow(26, mid, p)\\n for i in range(mid, len(S)):\\n cur_hash = (26*cur_hash-nums[i-mid]*max_pow + nums[i]) % p\\n if cur_hash in hashes:\\n pos = i + 1 - mid\\n hashes.add(cur_hash)\\n return pos\\n\\n\\n low, high = 0, len(S)-1\\n end = 0\\n start = 0\\n nums = [ord(c)-ord('a') for c in S]\\n while low <= high:\\n mid = (low+high) // 2\\n pos = rabin_karp(mid)\\n if pos == -1: # no matching strings found\\n high = mid - 1\\n else:\\n start = pos\\n low = mid + 1\\n return S[start:start+low-1]\\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n def search(m, MOD):\\n h = 0\\n for i in range(m):\\n h = (h * 26 + nums[i]) % MOD\\n s = {h}\\n aL = pow(26, m, MOD)\\n for pos in range(1, n - m + 1):\\n h = (h * 26 - nums[pos - 1] * aL + nums[pos + m - 1]) % MOD\\n if h in s:\\n return pos\\n s.add(h)\\n return -1\\n\\n n = len(S)\\n nums = [ord(c) - ord('a') for c in S]\\n l, r = 1, n\\n pos = -1\\n MOD = 2**63 - 1\\n while l <= r:\\n m = (l + r) // 2\\n cur = search(m, MOD)\\n if cur != -1:\\n l = m + 1\\n pos = cur\\n else:\\n r = m - 1\\n return S[pos: pos + l - 1]\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n N = len(S)\\n l, r = 1, N\\n nums = [ord(x) - ord('a') for x in S]\\n KMAX = 2 ** 63 - 1\\n def check(m):\\n MAXL = pow(26, m, KMAX)\\n total = 0\\n hashset = set()\\n for i in range(m):\\n total = (total * 26 + nums[i]) % KMAX\\n hashset.add(total)\\n for i in range(1, N - m + 1):\\n total = (total * 26 - nums[i-1] * MAXL + nums[i+m-1]) % KMAX\\n if total in hashset:\\n return i\\n hashset.add(total)\\n return -1\\n \\n while l < r:\\n m = (l + r) // 2\\n if check(m) < 0:\\n r = m\\n else:\\n l = m + 1\\n idx = check(r - 1) \\n return S[idx: idx + r-1]\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n ords = [ord(ch) - 97 for ch in S]\\n mod = 2 ** 32\\n seen = set()\\n \\n def has_dup_with_length(length):\\n seen.clear()\\n p = pow(26, length, mod)\\n \\n hashed_prefix = 0\\n for i in range(length):\\n hashed_prefix = (hashed_prefix * 26 + ords[i]) % mod\\n seen.add(hashed_prefix)\\n\\n for i in range(length, len(S)):\\n hashed_prefix = (hashed_prefix * 26 + ords[i] - ords[i - length] * p) % mod\\n if hashed_prefix in seen:\\n return i - length + 1\\n seen.add(hashed_prefix)\\n \\n start, lo, hi = 0, 0, len(S) - 1, \\n while lo < hi:\\n mid_length = (lo + hi + 1) // 2\\n idx = has_dup_with_length(mid_length)\\n if idx:\\n start = idx\\n lo = mid_length\\n else:\\n hi = mid_length - 1\\n return S[start: start + lo]\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n res = ''\\n d,q = len(set(S)), 2**63-1\\n record = [0]*len(S)\\n for i in range(len(S)):\\n if i == 0:record[i] = ord(S[i])\\n else:record[i] = (record[i-1]*d+ord(S[i]))%q\\n def check(mid):\\n h,g = 1,set()\\n for i in range(mid):\\n h = h*d%q\\n for i in range(len(S)-mid+1):\\n count = (record[i+mid-1]-record[i-1]*h)%q if i > 0 else record[i+mid-1]\\n if count not in g:g.add(count)\\n else:return S[i:i+mid]\\n return False\\n l,r = 0,len(S)-1\\n while l<=r:\\n mid = (l+r)//2\\n temp = check(mid)\\n if temp:\\n res = temp\\n l = mid + 1\\n else:r = mid - 1\\n return res\\n \\n \\n# res = \\\\\\\"\\\\\\\"\\n# d, q = len(set(S)), 2**63-1\\n# hashes = [0] * len(S)\\n# for i in range(len(S)):\\n# if i == 0: hashes[i] = ord(S[i])\\n# else: hashes[i] = (hashes[i-1]*d + ord(S[i]))%q\\n# l, r = 0, len(S)-1\\n# while l <= r:\\n# mid = (l+r)//2\\n# temp = self.check(S,mid,hashes,d,q)\\n# if temp:\\n# res = temp\\n# l = mid + 1\\n# else: r = mid - 1\\n# return res\\n \\n# def check(self, S, mid, hashes, d, q):\\n# res = set()\\n# h, g = 1, 0\\n# for i in range(mid):\\n# h = (h*d)%q\\n# for i in range(len(S)-mid+1):\\n# g = (hashes[i+mid-1] - hashes[i-1]*h)%q if i > 0 else hashes[i+mid-1]\\n# if g not in res: res.add(g)\\n# else: return S[i:i+mid]\\n# return False\\n \\n \\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n n = len(S)\\n nums = [ord(S[i]) - ord('a') for i in range(n)]\\n \\n def search(position):\\n h = 0\\n for i in range(position):\\n h = (h * 26 + nums[i]) % 2 ** 32\\n seen = {h}\\n const = 26 ** position % 2 ** 32\\n for start in range(1, n - position + 1):\\n h = (h * 26 - nums[start - 1] * const + nums[start + position - 1]) % 2 ** 32\\n if h in seen:\\n return start\\n seen.add(h)\\n return -1\\n \\n left, right = 1, n\\n while left <= right:\\n pivot = (left + right) // 2\\n if search(pivot) != -1:\\n left = pivot + 1\\n else:\\n right = pivot - 1\\n start = search(left - 1)\\n return S[start: start + left - 1]\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n arr = [ord(ch) - ord('a') for ch in S]\\n n = len(arr)\\n B = 29\\n mod = 2**63 - 1\\n def exists(L):\\n seen = {}\\n P = pow(B, L, mod)\\n h = 0\\n for i in range(n):\\n h = (h * B + arr[i]) % mod\\n if i >= L:\\n h = (h - arr[i-L] * P) % mod\\n if i >= L - 1:\\n if h in seen:\\n return seen[h]\\n seen[h] = i\\n return -1\\n \\n lo, hi = 0, len(S)\\n # cand = ''\\n pos = -1\\n while lo < hi:\\n mid = (lo + hi + 1) // 2\\n idx = exists(mid)\\n if idx != -1:\\n lo = mid\\n # cand = S[idx - mid + 1: idx + 1]\\n pos = idx\\n else:\\n hi = mid - 1\\n return S[pos - lo + 1:pos+1]\\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n self.A = [ord(c) - ord('a') for c in S]\\n \\n start, end = 1, len(S)\\n while start + 1 < end:\\n mid = (start + end) // 2\\n pos = self.check(mid)\\n if pos:\\n start = mid\\n else:\\n end = mid\\n\\n pos = self.check(end)\\n if pos:\\n return S[pos: pos + end]\\n pos = self.check(start)\\n if pos:\\n return S[pos: pos + start]\\n return ''\\n \\n def check(self, length):\\n mod = 2**63 - 1\\n power = pow(26, length, mod)\\n \\n cur = 0\\n for i in range(length):\\n cur = (cur * 26 + self.A[i]) % mod\\n \\n # cur = reduce(lambda x, y: (x * 26 + y) % mod, self.A[:length], 0)\\n seen = {cur}\\n \\n for i in range(length, len(self.A)):\\n cur = (cur * 26 + self.A[i] - self.A[i - length] * power) % mod\\n if cur in seen:\\n return i - length + 1\\n seen.add(cur)\\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n def rk(m):\\n \\n nonlocal idx\\n st = set()\\n p = b**(m-1)\\n p%=mod\\n \\n y = 0\\n for i in range(m):\\n y = (y*b+num[i])%mod\\n \\n st.add(y)\\n \\n for i in range(1, n-m+1):\\n y = ((y-num[i-1]*p%mod)*b%mod+num[i-1+m])%mod\\n #y = (y-num[i-1]*p)*b+num[i-1+m]\\n \\n if y in st:\\n idx = i\\n return 0\\n else:\\n st.add(y)\\n \\n return 1\\n \\n \\n\\n n = len(S)\\n b = 26 # no need to be 128\\n #mod = 10**9+7 # too small => conflict\\n mod = 2**32 # here\\n \\n z = ord('a')\\n num = [ ord(S[i])-z for i in range(n)]\\n \\n l=1\\n r=n\\n idx = 0 # last found duplicate \\n while l<r:\\n \\n m = (l+r)//2\\n \\n if rk(m)>0:\\n r = m\\n else:\\n l = m+1\\n \\n return S[idx:idx+l-1]\\n \\n \\n\", \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n self.A = [ord(c) - ord('a') for c in S]\\n \\n start, end = 1, len(S)\\n while start + 1 < end:\\n mid = (start + end) // 2\\n pos = self.check(mid)\\n if pos:\\n start = mid\\n else:\\n end = mid\\n\\n pos = self.check(end)\\n if pos:\\n return S[pos: pos + end]\\n pos = self.check(start)\\n if pos:\\n return S[pos: pos + start]\\n return ''\\n \\n def check(self, length):\\n mod = 2**63 - 1\\n power = pow(26, length, mod)\\n \\n cur = reduce(lambda x, y: (x * 26 + y) % mod, self.A[:length], 0)\\n seen = {cur}\\n \\n for i in range(length, len(self.A)):\\n cur = (cur * 26 + self.A[i] - self.A[i - length] * power) % mod\\n if cur in seen:\\n return i - length + 1\\n seen.add(cur)\\n\", \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n self.A = [ord(c) - ord('a') for c in S]\\n \\n start, end = 1, len(S)\\n while start + 1 < end:\\n mid = (start + end) // 2\\n pos = self.check(mid)\\n if pos:\\n start = mid\\n else:\\n end = mid\\n\\n pos = self.check(end)\\n if pos:\\n return S[pos: pos + end]\\n pos = self.check(start)\\n if pos:\\n return S[pos: pos + start]\\n return ''\\n \\n def check(self, length):\\n mod = 2**63 - 1\\n power = pow(26, length, mod)\\n \\n # cur = 0\\n # for i in range(length):\\n # cur = (cur * 26 + self.A[i]) % mod\\n \\n cur = reduce(lambda x, y: (x * 26 + y) % mod, self.A[:length], 0)\\n seen = {cur}\\n \\n for i in range(length, len(self.A)):\\n cur = (cur * 26 + self.A[i] - self.A[i - length] * power) % mod\\n if cur in seen:\\n return i - length + 1\\n seen.add(cur)\\n\", \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n self.A = [ord(c) - ord('a') for c in S]\\n \\n start, end = 1, len(S)\\n while start + 1 < end:\\n mid = (start + end) // 2\\n print(mid)\\n pos = self.check(mid)\\n print(pos)\\n if pos:\\n start = mid\\n else:\\n end = mid\\n # print(start, end)\\n pos = self.check(end)\\n # print(pos)\\n if pos:\\n return S[pos: pos + end]\\n pos = self.check(start)\\n if pos:\\n return S[pos: pos + start]\\n return ''\\n \\n def check(self, length):\\n mod = 2**63 - 1\\n power = pow(26, length, mod)\\n \\n cur = reduce(lambda x, y: (x * 26 + y) % mod, self.A[:length], 0)\\n seen = {cur}\\n \\n for i in range(length, len(self.A)):\\n cur = (cur * 26 + self.A[i] - self.A[i - length] * power) % mod\\n if cur in seen:\\n return i - length + 1\\n seen.add(cur)\\n\", \"class Solution:\\n def searchLongestStringOfKLen(self, S, total_len, compare_len):\\n search_len_hash = 0\\n for i in range(compare_len):\\n search_len_hash = (search_len_hash * self.uniq + self.nums[i]) % self.mod\\n\\n tmp_hash = {}\\n tmp_hash[search_len_hash] = True\\n \\n remove_old_power = pow(self.uniq, compare_len, self.mod)\\n for i in range(1, total_len-compare_len+1):\\n search_len_hash = (search_len_hash * self.uniq - (remove_old_power * self.nums[i-1]) + self.nums[i+compare_len-1] )% self.mod\\n if search_len_hash in tmp_hash:\\n return i\\n tmp_hash[search_len_hash] = True\\n \\n return -1\\n \\n \\n def longestDupSubstring(self, S: str) -> str:\\n ls = len(S)\\n end = ls\\n start = 1 \\n mid = 0\\n self.nums = []\\n for i in range(ls):\\n self.nums.append(ord(S[i]) - ord('a'))\\n\\n self.uniq = 26\\n self.mod = 2**32\\n while start <= end:\\n mid = start + (end-start)//2\\n if self.searchLongestStringOfKLen(S, ls, mid) != -1:\\n start = mid + 1\\n else :\\n end = mid - 1\\n \\n ds_sp = self.searchLongestStringOfKLen(S, ls, start -1)\\n return S[ds_sp:ds_sp+start-1]\", \"def check(arr, n, l, mod):\\n p = pow(26, l, mod)\\n window_hash = 0\\n hash_set = set()\\n for i in range(l):\\n window_hash = (26 * window_hash + arr[i]) % mod\\n hash_set.add(window_hash)\\n\\n for i in range(1, n - l + 1):\\n window_hash = (window_hash * 26 - (arr[i - 1]*p) + arr[i + l - 1])%mod\\n if window_hash in hash_set:\\n return i\\n hash_set.add(window_hash)\\n\\n return False\\n\\n\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n n = len(S)\\n min_length, max_length = 1, n\\n ans, prev_len = 0, 0\\n mod = (1 << 63) - 1\\n nums = [ord(S[i]) - ord('a') for i in range(n)]\\n\\n while min_length <= max_length:\\n mid_length = int((max_length + min_length)/2)\\n start = check(nums, n, mid_length, mod)\\n if start != False:\\n if prev_len < mid_length:\\n ans = start\\n prev_len = mid_length\\n min_length = mid_length + 1\\n else:\\n max_length = mid_length - 1\\n \\n return S[ans:ans + prev_len]\\n\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n n=len(S)\\n modulus=2**56\\n a=26 \\n nums=[ord(c)-ord('a') for c in S]\\n def search(L):\\n nonlocal a,n,modulus\\n aL=pow(a,L,modulus)\\n h=0\\n for i in range(L):\\n h=(h*a+nums[i])%modulus\\n seen={h}\\n for start in range(1,n-L+1):\\n h=(h*a-nums[start-1]*aL+nums[start+L-1])%modulus\\n if h in seen:\\n return start\\n seen.add(h)\\n return -1\\n \\n l,r=1,n\\n while l<=r:\\n mid=(l+r)>>1\\n if search(mid)!=-1:\\n l=mid+1\\n else:\\n r=mid-1\\n \\n start=search(r) \\n return S[start:start+r]\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n n = len(S)\\n chars = [ord(c) - 97 for c in S]\\n BASE = 26\\n MOD = (1 << 63) - 1\\n POWS = [1] * n\\n for i in range(1, n):\\n POWS[i] = (POWS[i - 1] * BASE) % MOD\\n def search(k):\\n seen = set()\\n h = 0\\n for i in range(k):\\n h = (h * BASE + chars[i]) % MOD\\n seen.add(h)\\n for i in range(k, n):\\n h = ((h - chars[i - k] * POWS[k - 1]) * BASE + chars[i]) % MOD\\n if h in seen:\\n return i\\n seen.add(h)\\n return -1\\n \\n l, r = 0, n - 1\\n k = 0\\n while l < r:\\n m = (l + r + 1) // 2\\n i = search(m)\\n if i >= 0:\\n k = i\\n l = m\\n else:\\n r = m - 1\\n return S[k - l + 1:k + 1]\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n n = len(S)\\n chars = [ord(c) - 97 for c in S]\\n BASE = 26\\n MOD = (1 << 63) - 1\\n POWS = [1] * n\\n for i in range(1, n):\\n POWS[i] = (POWS[i - 1] * BASE) % MOD\\n def search(k):\\n seen = set()\\n h = 0\\n for i in range(k):\\n h = (h * BASE + chars[i]) % MOD\\n seen.add(h)\\n for i in range(k, n):\\n h = ((h - chars[i - k] * POWS[k - 1]) * BASE + chars[i]) % MOD\\n if h in seen:\\n return i\\n seen.add(h)\\n return -1\\n \\n l, r = 0, n - 1\\n while l <= r:\\n m = (l + r) // 2\\n if search(m) >= 0:\\n l = m + 1\\n else:\\n r = m - 1\\n if r < 0:\\n return ''\\n i = search(r)\\n return S[i - r + 1:i + 1]\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n p = 31\\n m = 100000000003\\n\\n pows = [1] * len(S)\\n invPows = [1] * len(S)\\n for i in range(1, len(S)):\\n pows[i] = pows[i-1] * p % m\\n invPows[i] = pow(pows[i], -1, m)\\n\\n h = [0] * (len(S) + 1)\\n for i in range(len(S)):\\n h[i+1] = (h[i] + (ord(S[i]) - ord('a') + 1) * pows[i]) % m\\n\\n def hasDup(S, sublen):\\n seen = set()\\n for i in range(len(S)- sublen + 1):\\n if (hs := (h[i + sublen] - h[i]) * invPows[i] % m) in seen:\\n return (i, sublen)\\n seen.add(hs)\\n return (0, 0)\\n\\n ans = None\\n lo, hi = 1, len(S)\\n while lo < hi:\\n mid = (lo + hi) // 2\\n if (s := hasDup(S, mid))[1]:\\n lo = mid + 1\\n ans = s\\n else:\\n hi = mid\\n return S[ans[0]:ans[0]+ans[1]] if ans else ''\", \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n def search(m, MOD):\\n h = 0\\n for i in range(m):\\n h = (h * 26 + nums[i]) % MOD\\n s = {h}\\n aL = pow(26, m, MOD)\\n for pos in range(1, n - m + 1):\\n h = (h * 26 - nums[pos - 1] * aL + nums[pos + m - 1]) % MOD\\n if h in s:\\n return pos\\n s.add(h)\\n return -1\\n \\n n = len(S)\\n nums = [ord(c) - ord('a') for c in S]\\n # find length of longest duplicate substring\\n l, r = 1, n\\n pos = 0\\n MOD = 2**63 - 1 # use largest positive of 8 byte integer\\n while l <= r:\\n m = (l + r) // 2\\n # search if there's duplicate for length m substring\\n cur = search(m, MOD)\\n if cur != -1:\\n l = m + 1\\n pos = cur\\n else:\\n r = m - 1\\n return S[pos: pos + l - 1]\", \"from collections import defaultdict\\nfrom functools import reduce\\n\\n\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n mod = (1 << 63 - 1)\\n A = [ord(c) - ord('a') for c in S]\\n \\n def find_dup_of_length(L):\\n p = pow(26, L, mod)\\n h = reduce(lambda x, y: (x * 26 + y) % mod, A[:L], 0)\\n seen = defaultdict(list)\\n seen[h].append(0)\\n \\n for i in range(L, len(S)):\\n h = (h * 26 + A[i] - p * A[i-L]) % mod\\n for start in seen[h]:\\n if S[start:start+L] == S[i-L+1:i+1]:\\n return start\\n \\n seen[h].append(i-L+1)\\n \\n start = 0\\n length = 0\\n low, high = 1, len(S)\\n while low < high:\\n mid = low + (high - low) // 2\\n pos = find_dup_of_length(mid)\\n if pos is not None:\\n start = pos\\n length = mid\\n low = mid + 1\\n else:\\n high = mid\\n \\n return S[start:start+length]\\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"longestDupSubstring\", \"inputs\": [[\"\\\"banana\\\"\"]], \"outputs\": [\"ana\"]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/longest-duplicate-substring/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def longestDupSubstring(self, S: str) -> str:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def longestDupSubstring(self, S):\n nums, N = [ord(c) - ord('a') for c in S], len(S)\n BASE, MOD = 26, 2**32\n def check(L):\n cur_hash, seen = 0, set()\n for val in nums[:L]:\n cur_hash = (cur_hash * BASE + val) % MOD\n seen.add(cur_hash)\n X = pow(BASE, L-1, MOD)\n for idx, val in enumerate(nums[L:]):\n cur_hash -= nums[idx] * X\n cur_hash = (cur_hash * BASE + val) % MOD\n if cur_hash in seen:\n return idx + 1\n seen.add(cur_hash)\n return -1\n low, high = 1, N + 1\n start = 0\n while low < high:\n mid = (low + high)//2\n idx = check(mid)\n if idx != -1:\n low = mid + 1\n start = idx\n else:\n high = mid\n return S[start: start + low - 1]\n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n \n def has_duplicate(m, S):\n val, Mod = 0, 2**63-1\n for i in range(m):\n val = (26*val + ord(S[i])) % Mod\n \n d = set([val])\n const = 26**m % Mod\n for i in range(m, len(S)):\n val = (26*val + ord(S[i]) - ord(S[i-m])*const) % Mod\n if val in d: return i-m+1\n d.add(val)\n return -1\n \n l, r = 0, len(S)\n start, length = -1, 0\n while l<=r:\n mid = l + (r-l)//2\n idx = has_duplicate(mid, S)\n if idx!=-1:\n l = mid + 1\n start, length = idx, mid\n else:\n r = mid - 1\n \n if start==-1: return ''\n return S[start:start+length]\n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n A = [ord(c) for c in S]\n mod = 2**63-1\n \n lo = 0\n hi = len(S)\n res = 0\n \n def test(sz):\n val = 0\n p = pow(26,sz,mod)\n for i in range(sz):\n val = val*26+A[i]\n val %= mod\n seen = {val}\n for i in range(sz, len(A)):\n val = val*26+A[i]-A[i-sz]*p\n val = val%mod\n if val in seen:\n return i-sz+1\n seen.add(val)\n return -1 \n \n while lo < hi:\n mid = (lo+hi)//2\n pos = test(mid)\n if not pos >= 0:\n hi = mid\n else:\n res = pos\n lo = mid+1\n \n return S[res:res+lo-1]\n \n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n def check(L):\n base = 26\n modulo = 2**32\n AL = base**L%modulo\n hk = 0\n for i in range(L):\n hk = hk*base + nums[i]\n hk %= modulo\n hm = {hk:0}\n for i in range(L, len(S)):\n hk = (hk*base-nums[i-L]*AL+nums[i])%modulo\n if hk in hm and S[i-L+1:i+1]==S[hm[hk]:hm[hk]+L]:\n return i-L+1\n hm[hk] = i-L+1\n \n return -1\n \n nums = [ord(c)-ord('a') for c in S]\n res = -1\n s, e = 1, len(S)\n while s<=e:\n m = s+(e-s)//2\n pos = check(m)\n if pos!=-1:\n res = pos\n s = m+1\n else:\n e = m-1\n \n return S[res:res+e]\n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n def test(L):\n base = 26\n modulus = 2**32\n AL = base**L%modulus\n hk = 0\n for i in range(L):\n hk=hk*base+nums[i]\n hk%=modulus\n hs=set([hk])\n \n for i in range(L, len(S)):\n hk = hk*base-nums[i-L]*AL+nums[i]\n hk%=modulus\n if hk in hs:\n return i-L+1\n hs.add(hk)\n \n nums = [ord(c)-ord('a') for c in S]\n start, end = 1, len(S)\n res = -1\n while start<=end:\n mid = start+(end-start)//2\n pos = test(mid)\n \n if pos:\n res = pos\n start = mid+1\n else:\n end = mid-1\n \n return S[res:res+end]","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n \n n=len(S)\n mod=10**30\n ord_a=97\n \n def find_len_k_dup(k):\n hash_val=0\n seen=set()\n for i in range(k):\n hash_val=(hash_val*26+(ord(S[i])-ord_a))%mod\n seen.add(hash_val)\n power=26**k%mod\n \n for i in range(1,n-k+1):\n hash_val=((hash_val*26-(ord(S[i-1])-ord_a)*power)%mod+(ord(S[i+k-1])-ord_a))%mod\n if hash_val in seen:\n return i\n seen.add(hash_val)\n return None\n \n# self.s=S\n# self.n=len(S)\n# def find_len_k_dup(length):\n# hash_value = 0\n# mod_value = 8000*(2**30) # a big number should be okay, if you change the number it might cause a wrong answer\n# seen = set()\n# for i in range(length):\n# hash_value = (hash_value*26+ord(self.s[i])-ord('a'))%mod_value # get the hash value\n# seen.add(hash_value)\n# tmp = pow(26, length)%mod_value\n# for i in range(1,self.n-length+1):\n# # get the moving hash \n# hash_value = ((hash_value*26 - (ord(self.s[i-1])-ord('a'))*tmp)%mod_value+ord(self.s[i+length-1])-ord('a'))%mod_value\n# if hash_value in seen:\n# return i\n# else:\n# seen.add(hash_value)\n# return None\n \n \n \n \n low=0\n high=len(S)\n res=''\n while low<high:\n \n mid=(low+high)//2\n idx=find_len_k_dup(mid)\n #print(candidate)\n if idx is not None:\n res=S[idx:idx+mid]\n low=mid+1\n else:\n high=mid\n return res","from functools import reduce\nclass Solution:\n def longestDupSubstring(self, S: str) -> str:\n A = [ord(c) - ord('a') for c in S]\n mod = 2**63 - 1\n def isDuplicate(len_s):\n p = pow(31, len_s, mod)\n seen = collections.defaultdict(list)\n cur = reduce(lambda x,y: (x*31+y)%mod, A[:len_s])\n seen[cur].append(0)\n for j in range(1, len(A)-len_s+1):\n cur = (cur*31 - A[j-1]*p + A[j+len_s-1])%mod\n if cur in seen:\n for i in seen[cur]:\n if S[i:i+len_s] == S[j:j+len_s]:\n return j\n seen[cur].append(j)\n return 0\n \n l, r = 1, len(S)-1\n ans = ''\n while l <= r:\n mid = l + (r-l)//2\n pos = isDuplicate(mid)\n if pos:\n ans = S[pos:pos+mid]\n l = mid + 1\n else:\n r = mid -1\n return ans \n \n \n","from functools import reduce\nclass Solution:\n def longestDupSubstring(self, S: str) -> str:\n A = [ord(c) - ord('a') for c in S]\n mod = 2**63 - 1\n \n def test(L):\n p = pow(26, L, mod)\n cur = reduce(lambda x, y: (x * 26 + y) % mod, A[: L], 0)\n seen = set()\n seen.add(cur)\n for i in range(L, len(A)):\n cur = (cur * 26 + A[i] - A[i - L] * p) % mod\n if cur in seen:\n return i - L + 1\n seen.add(cur)\n \n res, lo, hi = 0, 0, len(S)\n while lo + 1 < hi:\n mid = lo + (hi - lo) // 2\n pos = test(mid)\n if pos:\n lo = mid\n else:\n hi = mid\n \n if test(hi):\n pos = test(hi)\n return S[pos: pos + hi]\n pos = test(lo)\n return S[pos: pos + lo]\n","class Solution:\n def longestDupSubstring(self, S):\n nums = [ord(c) - ord('a') for c in S]\n #BASE, MOD = 113, 1000000007\n BASE, MOD = 26, 2**32\n def check(L):\n cur_hash, seen = 0, set()\n for val in nums[:L]:\n cur_hash = ((cur_hash * BASE) + val) % MOD\n seen.add(cur_hash)\n X = pow(BASE, L-1, MOD) # (BASE ** (L-1)) % MOD\n for i, val in enumerate(nums[L:]):\n # cur_hash -= nums[i] * (BASE ** (L-1))\n cur_hash -= nums[i] * X\n cur_hash = ((cur_hash * BASE) + val) % MOD\n if cur_hash in seen:\n return i + 1\n seen.add(cur_hash)\n return -1\n low, high = 1, len(S) + 1\n res = 0\n while low < high:\n mid = (low + high)//2\n idx = check(mid)\n if idx != -1:\n low = mid + 1\n res = idx\n else:\n high = mid\n return S[res: res + low-1]\n \n #while low <= high:\n # mid = (low + high)//2\n # idx = check(mid)\n # if idx != -1:\n # low = mid + 1\n # res = idx\n # else:\n # high = mid - 1\n #return S[res: res + low-1]\n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n def checkSubstrings(size):\n hashed = 0\n pow_mult = pow(26, size) % mod\n \n for i in range(size):\n hashed *= 26\n hashed += char_vals[i]\n \n hashed %= mod\n seen = {hashed}\n \n for i in range(size, len(S)):\n hashed = (hashed * 26 - char_vals[i-size] * pow_mult + char_vals[i]) % mod\n if hashed in seen:\n return i-size+1\n seen.add(hashed)\n \n return None\n\n s, f = 0, len(S)\n longest = 0\n \n char_vals = [ord(c) - ord('a') for c in S]\n mod = pow(2, 63) - 1\n \n while s < f:\n m = s + (f-s+1) // 2\n longest_check = checkSubstrings(m)\n if longest_check:\n longest = longest_check\n s = m\n else:\n f = m-1\n \n return S[longest:longest+s]\n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n # def RabinKarp(text, M, q):\n # if M == 0: return True\n # h, t, d = (1<<(8*M-8))%q, 0, 256\n # dic = defaultdict(list)\n # for i in range(M): \n # t = (d * t + ord(text[i]))% q\n # dic[t].append(i-M+1)\n # for i in range(len(text) - M):\n # t = (d*(t-ord(text[i])*h) + ord(text[i + M]))% q\n # for j in dic[t]:\n # if text[i+1:i+M+1] == text[j:j+M]:\n # return (True, text[j:j+M])\n # dic[t].append(i+1)\n # return (False, \\\"\\\")\n\n\n def check(sz):\n seen = defaultdict(list)\n cur, base, MOD = 0, 256, (1<<31) - 1\n h = (1 << (sz*8)) % MOD\n for i in range(sz):\n cur *= base\n cur += ord(S[i])\n cur %= MOD\n seen[cur].append(0)\n for i in range(sz,len(S)):\n cur *= base\n cur += ord(S[i])\n cur -= ord(S[i-sz])*h \n cur %= MOD\n for j in seen[cur]:\n if S[j:j+sz] == S[i-sz+1:i+1]:\n return True, S[i-sz+1:i+1]\n seen[cur].append(i-sz+1)\n return False, ''\n\n lo, hi = 1, len(S)\n res = ''\n # MOD = (1<<31) - 1\n while lo <= hi:\n mid = (lo+hi)//2\n flag, tmp = check(mid)\n # flag, tmp = RabinKarp(S, mid, q)\n if flag:\n lo = mid + 1\n res = tmp\n # print(mid,res)\n else:\n hi = mid - 1\n # print(lo,hi)\n return res \n\n\n# class Solution:\n# def RabinKarp(self,text, M, q):\n# if M == 0: return True\n# h, t, d = (1<<(8*M-8))%q, 0, 256\n\n# dic = defaultdict(list)\n\n# for i in range(M): \n# t = (d * t + ord(text[i]))% q\n\n# dic[t].append(i-M+1)\n\n# for i in range(len(text) - M):\n# t = (d*(t-ord(text[i])*h) + ord(text[i + M]))% q\n# for j in dic[t]:\n# if text[i+1:i+M+1] == text[j:j+M]:\n# return (True, text[j:j+M])\n# dic[t].append(i+1)\n# return (False, \\\"\\\")\n\n# def longestDupSubstring(self, S):\n# beg, end = 0, len(S)\n# q = (1<<31) - 1 \n# Found = \\\"\\\"\n# while beg + 1 < end:\n# mid = (beg + end)//2\n# isFound, candidate = self.RabinKarp(S, mid, q)\n# if isFound:\n# beg, Found = mid, candidate\n# else:\n# end = mid\n\n# return Found\n","class Solution:\n def search(self, S, mid) -> str:\n n = len(S)\n # convert string to array of integers to implement constant time slice\n self.nums = [ord(S[i]) - ord('a') for i in range(n)]\n # base value for the rolling hash function\n base = 26\n # mod value for the rolling hash function to avoid overflow\n MOD = 2**32\n \n # compute the hash of string S[:L]\n hash_ = 0\n for i in range(mid):\n hash_ = (hash_ * base + self.nums[i]) % MOD\n \n # already visited hashes of strings of length L\n visited = {hash_}\n # const value to be used often : a**L % mod\n aL = pow(base, mid, MOD)\n for start in range(1, n - mid + 1):\n # compute rolling hash in O(1) time\n hash_ = (hash_ * base - self.nums[start - 1] * aL + self.nums[start + mid - 1]) % MOD\n if hash_ in visited:\n return start\n visited.add(hash_)\n return -1\n \n def longestDupSubstring(self, S: str) -> str:\n n = len(S)\n # convert string to array of integers to implement constant time slice\n self.nums = [ord(S[i]) - ord('a') for i in range(n)]\n # base value for the rolling hash function\n base = 26\n # mod value for the rolling hash function to avoid overflow\n MOD = 2**32\n \n # binary search, L = repeating string length\n left, right = 1, n\n while left <= right:\n mid = left + (right - left) // 2\n if self.search(S, mid) != -1:\n left = mid + 1\n else:\n right = mid - 1\n \n start = self.search(S, left - 1)\n return S[start: start + left - 1]\n \n \n \n \n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n \n def rk(m):\n \n nonlocal idx\n mp = {}\n p = b**(m-1)\n p%=mod\n \n y = 0\n for i in range(m):\n y = y*b+num[i]\n y%=mod \n \n mp[y] = 0\n \n for i in range(1, n-m+1):\n y = ((y-num[i-1]*p%mod)*b%mod+num[i-1+m])%mod\n #y = (y-num[i-1]*p)*b+num[i-1+m]\n \n if y in mp:\n idx = i\n return 0\n else:\n mp[y]=i\n \n return 1\n \n \n\n n = len(S)\n b = 26 # no need to be 128\n #mod = 10**9+7 # too small => conflict\n mod = 2**32 # here\n \n z = ord('a')\n num = [ ord(S[i])-z for i in range(n)]\n \n l=1\n r=n\n idx = 0 # last found duplicate \n while l<r:\n \n m = (l+r)//2\n \n if rk(m)>0:\n r = m\n else:\n l = m+1\n \n return S[idx:idx+l-1]\n \n \n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n \n def rk(m):\n \n mp = {}\n\n p = b**(m-1)\n p%=mod\n \n y = 0\n for i in range(m):\n y = y*b+num[i]\n y%=mod \n \n mp[y] = 0\n \n for i in range(1, n-m+1):\n y = ((y-num[i-1]*p%mod)*b%mod+num[i-1+m])%mod\n #y = (y-num[i-1]*p)*b+num[i-1+m]\n \n if y not in mp:\n mp[y]=i\n else:\n return i\n \n return n\n \n \n \n \n n = len(S)\n \n b = 26 # no need to be 128\n \n #mod = 10**9+7 # too small => conflict\n mod = 2**32 # here\n \n num = []\n for i in range(n):\n num.append(ord(S[i])-ord('a'))\n \n l=1\n r=n\n \n while l<r:\n \n m = (l+r)//2\n \n if rk(m)==n:\n r = m\n else:\n l = m+1\n \n \n x = l-1\n \n if x==0:\n return ''\n \n k = rk(x)\n \n return S[k:k+x]\n \n \n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n \n def rk(m):\n \n nonlocal idx\n st = set()\n p = b**(m-1)\n p%=mod\n \n y = 0\n for i in range(m):\n y = y*b+num[i]\n \n y%=mod\n \n st.add(y)\n \n for i in range(1, n-m+1):\n y = ((y-num[i-1]*p%mod)*b%mod+num[i-1+m])%mod\n #y = (y-num[i-1]*p)*b+num[i-1+m]\n \n if y in st:\n idx = i\n return 0\n else:\n st.add(y)\n \n return 1\n \n \n\n n = len(S)\n b = 26 # no need to be 128\n #mod = 10**9+7 # too small => conflict\n mod = 2**32 # here\n \n z = ord('a')\n num = [ ord(S[i])-z for i in range(n)]\n \n l=1\n r=n\n idx = 0 # last found duplicate \n while l<r:\n \n m = (l+r)//2\n \n if rk(m)>0:\n r = m\n else:\n l = m+1\n \n return S[idx:idx+l-1]\n \n \n","from functools import reduce\nclass Solution:\n def longestDupSubstring(self, S: str) -> str:\n \n \n A = [ord(c) - ord('a') for c in S]\n mod = 2**63 - 1\n\n def test(L):\n # print(26, L, mod)\n p = pow(26, L, mod)\n cur = reduce(lambda x, y: (x * 26 + y) % mod, A[:L], 0)\n seen = {cur}\n for i in range(L, len(S)):\n cur = (cur * 26 + A[i] - A[i - L] * p) % mod\n if cur in seen: return i - L + 1\n seen.add(cur)\n res, lo, hi = 0, 0, len(S)\n while lo < hi:\n mi = (lo + hi + 1) // 2\n pos = test(mi)\n if pos:\n lo = mi\n res = pos\n else:\n hi = mi - 1\n return S[res:res + lo]\n \n# s = [ord(num) - ord(\\\"a\\\") for num in S]\n \n# mod = 10 ** 9 + 7\n# def check(l):\n# cur = 0\n# seen = set()\n# maxBASE = pow(26, l-1, mod)\n# for i in range(len(s)):\n# if i < l:\n# cur = (cur * 26 + s[i]) % mod\n# else:\n# cur -= maxBASE * s[i-l]\n# cur = (cur * 26 + s[i]) % mod\n# if i == l-1:\n# seen.add(cur)\n# elif i >= l:\n# if cur in seen:\n# return i-l+1\n# else:\n# seen.add(cur)\n# return 0\n \n \n \n \n# l = 1\n# r = len(S) - 1\n# res = -1\n# while l < r:\n# m = (l+r) // 2\n# pos = check(m)\n# if pos:\n# l = m \n# res = pos\n# else:\n# r = m - 1\n# return S[res:res + l]\n \n \n \n","class Solution:\n def longestDupSubstring(self, S):\n nums, N = [ord(c) - ord('a') for c in S], len(S)\n BASE, MOD = 26, 2**32\n def check(L):\n cur_hash, seen = 0, set()\n for val in nums[:L]:\n cur_hash = (cur_hash * BASE + val) % MOD\n seen.add(cur_hash)\n X = pow(BASE, L-1, MOD)\n for idx, val in enumerate(nums[L:]):\n cur_hash -= nums[idx] * X\n cur_hash = (cur_hash * BASE + val) % MOD\n if cur_hash in seen:\n return idx + 1\n seen.add(cur_hash)\n return -1\n low, high = 1, N + 1\n start = 0\n while low < high:\n mid = (low + high)//2\n idx = check(mid)\n if idx != -1:\n low = mid + 1\n start = idx\n else:\n high = mid\n return S[start: start + low - 1]","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n self.s=S\n self.n=len(S)\n def find_len_k_dup(length):\n hash_value = 0\n mod_value = 7919*(2**30) # a big number should be okay, if you change the number it might cause a wrong answer\n seen = set()\n for i in range(length):\n hash_value = (hash_value*26+ord(self.s[i])-ord('a'))%mod_value # get the hash value\n seen.add(hash_value)\n tmp = pow(26, length)%mod_value\n for i in range(1,self.n-length+1):\n # get the moving hash \n hash_value = (hash_value*26 - (ord(self.s[i-1])-ord('a'))*tmp+mod_value+ord(self.s[i+length-1])-ord('a'))%mod_value\n if hash_value in seen:\n return i\n else:\n seen.add(hash_value)\n return None\n \n \n low=0\n high=len(S)\n res=''\n while low<high:\n \n mid=(low+high)//2\n idx=find_len_k_dup(mid)\n #print(candidate)\n if idx is not None:\n res=S[idx:idx+mid]\n low=mid+1\n else:\n high=mid\n return res","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n \n lo = 1\n hi = len(S)\n nums = [ord(i) - ord('a') for i in S]\n self.modulus = 2 ** 32\n \n def dup(l):\n seen = set()\n hval = 0\n for i in range(l):\n hval = (hval*26 + nums[i]) % self.modulus\n seen.add(hval)\n al = pow(26,l,self.modulus)\n for i in range(1,len(S) - l+1):\n hval = (hval*26 - nums[i-1]*al + nums[i+l-1]) % self.modulus\n if hval in seen:\n return i\n seen.add(hval)\n return -1\n \n start = -1\n while lo <= hi:\n mi = lo + (hi-lo)//2\n begin = dup(mi)\n if begin != -1:\n lo = mi + 1\n start = begin\n else:\n hi = mi - 1\n \n return S[start: start + lo - 1]","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n N = len(S)\n l, r = 1, N\n nums = [ord(x) - ord('a') for x in S]\n KMAX = 2 ** 63 - 1\n def check(m):\n MAXL = pow(26, m, KMAX)\n total = 0\n hashset = set()\n for i in range(m):\n total = (total * 26 + nums[i]) % KMAX\n hashset.add(total)\n for i in range(1, N - m + 1):\n total = (total * 26 - MAXL * nums[i-1] + nums[i + m - 1]) % KMAX\n if total in hashset:\n return i\n hashset.add(total)\n return -1 \n \n while l < r:\n m = (l + r) // 2\n if check(m) < 0:\n r = m\n else:\n l = m + 1\n idx = check(r - 1) \n return S[idx: idx + r-1]","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n self.s=S\n self.n=len(S)\n def find_len_k_dup(length):\n hash_value = 0\n mod_value = 8000*(2**30) # a big number should be okay, if you change the number it might cause a wrong answer\n seen = set()\n for i in range(length):\n hash_value = (hash_value*26+ord(self.s[i])-ord('a'))%mod_value # get the hash value\n seen.add(hash_value)\n tmp = pow(26, length)%mod_value\n for i in range(1,self.n-length+1):\n # get the moving hash \n hash_value = ((hash_value*26 - (ord(self.s[i-1])-ord('a'))*tmp)%mod_value+ord(self.s[i+length-1])-ord('a'))%mod_value\n if hash_value in seen:\n return i\n else:\n seen.add(hash_value)\n return None\n \n \n low=0\n high=len(S)\n res=''\n while low<high:\n \n mid=(low+high)//2\n idx=find_len_k_dup(mid)\n #print(candidate)\n if idx is not None:\n res=S[idx:idx+mid]\n low=mid+1\n else:\n high=mid\n return res","from functools import reduce\nclass Solution:\n def longestDupSubstring(self, S: str) -> str:\n A = [ord(c) - ord('a') for c in S]\n mod = 2**63 - 1\n\n def test(L):\n p = pow(26, L, mod)\n cur = reduce(lambda x, y: (x * 26 + y) % mod, A[:L], 0)\n seen = {cur}\n for i in range(L, len(S)):\n cur = (cur * 26 + A[i] - A[i - L] * p) % mod\n if cur in seen: return i - L + 1\n seen.add(cur)\n res, lo, hi = 0, 0, len(S)\n while lo + 1 < hi:\n mi = (lo + hi) // 2\n pos = test(mi)\n if pos:\n lo = mi\n else:\n hi = mi\n \n if test(hi):\n res = test(hi)\n return S[res: res + hi]\n elif test(lo):\n res = test(lo)\n return S[res: res + lo]\n # return ''\n","from functools import reduce\nclass Solution:\n def longestDupSubstring(self, S):\n def evaluateLength(length):\n power = pow(26, length, mod)\n current = reduce(lambda x, y: (x*26 + y) % mod, ids[:length], 0)\n explored = {current}\n for index in range(length, len(S)):\n current = (current * 26 + ids[index] - ids[index - length] * power) % mod\n if current in explored:\n return index - length + 1\n explored.add(current)\n \n ids = [ord(character) - ord('a') for character in S]\n mod = 2**63 - 1\n index, low, high = 0, 0, len(S)\n while low < high:\n mid = (high + low + 1) // 2\n position = evaluateLength(mid)\n if position:\n index = position\n low = mid\n else:\n high = mid - 1 \n return S[index:(index+low)]\n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n N = len(S)\n l, r = 1, N\n nums = [ord(x) - ord('a') for x in S]\n KMAX = 2 ** 63 - 1\n def check(m):\n MAXL = pow(26, m, KMAX)\n total, hashset = 0, set()\n for i in range(m):\n total = (total * 26 + nums[i]) % KMAX\n hashset.add(total)\n for i in range(1, N - m + 1):\n total = (total * 26 - MAXL * nums[i-1] + nums[i+m-1]) % KMAX\n if total in hashset:\n return i\n hashset.add(total)\n return -1\n \n while l < r:\n m = (l + r) // 2\n if check(m) < 0:\n r = m\n else:\n l = m + 1\n idx = check(r - 1) \n return S[idx: idx + r-1]","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n \n def check(s, L):\n n = len(s)\n BASE = 26\n MOD = 1 << 61 - 1\n P = pow(26, L, MOD)\n cur = 0\n seen = defaultdict(list)\n \n for i in range(len(s)):\n cur = (cur*BASE + ord(s[i]) - ord('a')) % MOD\n if i >= L:\n cur = (cur - (ord(s[i-L]) - ord('a')) * P) % MOD\n \n if i >= L - 1:\n if cur in seen:\n cur_str = s[i-L+1:i+1]\n for j in seen[cur]:\n pre_str = s[j-L+1:j+1]\n if cur_str == pre_str:\n return cur_str\n seen[cur].append(i) \n return ''\n \n \n lo, hi = 1, len(S)\n ans = ''\n while lo < hi:\n mid = (lo + hi) // 2\n temp = check(S, mid)\n if temp:\n ans = temp\n lo = mid + 1\n else:\n hi = mid\n\n return ans\n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n p = 239017\n pows = [[1], [1]]\n hsh = [[0], [0]]\n mods = [int(1e9) + 7, int(1e9) + 9]\n for ch in S:\n for i in range(len(mods)):\n hsh[i].append((hsh[i][-1] + ord(ch) * pows[i][-1]) % mods[i])\n pows[i].append((pows[i][-1] * p) % mods[i]) \n l = 0\n r = len(S)\n substrs = {}\n ans = ''\n while r - l > 1:\n m = (r + l) // 2\n found = False\n for i in range(0, len(S) - m + 1):\n h0 = ((hsh[0][i + m] - hsh[0][i]) * pows[0][-(i + 1)]) % mods[0]\n h1 = ((hsh[1][i + m] - hsh[1][i]) * pows[1][-(i + 1)]) % mods[1]\n if (h0, h1) in substrs:\n found = True\n ans = S[i: i + m]\n break\n else:\n substrs[(h0, h1)] = True\n if found:\n l = m\n else:\n r = m\n substrs.clear()\n return ans","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n \n mod = 2 ** 31 - 1\n base = 26\n \n def get_ord(char: str):\n return ord(char) - ord('a')\n \n def find_duplicate(length) -> str:\n hashes = {}\n h = 1\n for i in range(length - 1):\n h = (h * base) % mod\n\n cur = 0\n for i in range(length):\n cur = (cur * base + get_ord(S[i])) % mod\n \n hashes[cur] = [0]\n\n for i in range(1, len(S) - length + 1):\n cur = ((cur - (get_ord(S[i-1]) * h)) * base + get_ord(S[i + length - 1])) % mod\n if cur in hashes:\n for idx in hashes[cur]:\n if S[idx: idx + length] == S[i: i + length]:\n return S[i: i + length]\n hashes[cur].append(i)\n else:\n hashes[cur] = [i]\n return ''\n \n \n def helper(start, end):\n res = ''\n while start < end:\n length = (start + end) // 2 + 1\n r = find_duplicate(length)\n if len(r) > len(res):\n res = r\n if not r:\n end = length - 1\n else:\n start = length\n return res\n\n return helper(0, len(S) - 1)","class Solution:\n def findRepSubstrGivenLength(self, nums: List[int], l:int, base:int, modulus:int) -> int:\n \n n = len(nums)\n \n h = 0\n for i in range(l):\n h = (h * base + nums[i]) % modulus\n \n seen = {h}\n \n for start in range(1, n-l+1):\n h = (h * base - nums[start - 1] * pow(base, l, modulus) + nums[start + l - 1]) % modulus\n \n if h in seen:\n return start\n \n seen.add(h)\n \n return -1 \n \n \n def longestDupSubstring(self, S: str) -> str:\n if not S:\n return ''\n \n nums = [ord(S[i]) - ord('a') for i in range(len(S))]\n \n base = 26\n modulus = 2**32\n \n left = 1\n right = len(S)\n \n while left <= right:\n mid = left + (right - left) // 2\n \n if self.findRepSubstrGivenLength(nums, mid, base, modulus) != -1:\n left = mid + 1\n else:\n right = mid -1\n \n start = self.findRepSubstrGivenLength(nums, left-1, base, modulus)\n \n return S[start: start + left -1] \n \n \n \n'''\nclass Solution:\n class Node:\n def __init__(self, v='*'): \n self.value = v\n self.next = dict()\n self.occurences = set()\n \n \n def print_tree(self, node, indentation):\n print(indentation + str(node.value) + \\\": \\\" + str(node.occurences))\n\n for v in node.next.keys():\n self.print_tree(node.next[v], indentation + '\\\\t')\n \n \n def getNode(self, node, v):\n if v not in node.next.keys():\n node.next[v] = self.Node(v)\n\n return node.next[v]\n\n\n def AddOccurences(self, node, i, S):\n node.occurences.add(i)\n\n if len(node.occurences) == 2:\n for o in node.occurences:\n if o + 1 < len(S):\n self.AddOccurences(self.getNode(node, S[o+1]), o+1, S)\n\n\n if len(node.occurences)>2:\n if i + 1 < len(S):\n self.AddOccurences(self.getNode(node, S[i+1]), i+1, S)\n\n \n def getLongestDuplicate(self, node):\n maxSubstring = ''\n \n for v in node.next.keys():\n if len(node.next[v].occurences)>1:\n\n childSubstring = self.getLongestDuplicate(node.next[v])\n if len(childSubstring) + 1 > len(maxSubstring):\n maxSubstring = v + childSubstring\n \n return maxSubstring\n \n \n def longestDupSubstring(self, S: str) -> str:\n if not S:\n return 0\n \n if len(set(S)) == 1:\n return S[0:len(S)-1]\n\n root = self.Node()\n\n for i in range(len(S)):\n self.AddOccurences(self.getNode(root, S[i]), i, S)\n\n #self.print_tree(root, '')\n maxDepthDuplicates = self.getLongestDuplicate(root)\n \n return maxDepthDuplicates\n''' ","class Solution:\n def longestDupSubstring(self, S):\n nums = [ord(c) - ord('a') for c in S]\n #BASE, MOD = 113, 1000000007\n BASE, MOD = 26, 2**32\n def check(L):\n cur_hash, seen = 0, set()\n for val in nums[:L]:\n cur_hash = ((cur_hash * BASE) + val) % MOD\n seen.add(cur_hash)\n X = pow(BASE, L-1, MOD) # (BASE ** (L-1)) % MOD\n for i, val in enumerate(nums[L:]):\n # cur_hash -= nums[i] * (BASE ** (L-1))\n cur_hash -= nums[i] * X\n cur_hash = ((cur_hash * BASE) + val) % MOD\n if cur_hash in seen:\n return i + 1\n seen.add(cur_hash)\n return -1\n low, high = 1, len(S)\n res = 0\n while low < high:\n mid = (low + high)//2\n idx = check(mid)\n if idx != -1:\n low = mid + 1\n res = idx\n else:\n high = mid\n return S[res: res + low-1]\n \n #while low <= high:\n # mid = (low + high)//2\n # idx = check(mid)\n # if idx != -1:\n # low = mid + 1\n # res = idx\n # else:\n # high = mid - 1\n #return S[res: res + low-1]\n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n def check(Val):\n base, modulus = 26, 2**32\n AL = base**Val%modulus\n hk = 0\n for i in range(Val):\n hk = hk*base + ord(S[i])-ord('a')\n hk %= modulus\n hm = {hk: 0}\n \n for i in range(Val, N):\n hk = hk*base - (ord(S[i-Val])-ord('a'))*AL + ord(S[i]) - ord('a')\n hk %= modulus\n if hk in hm and S[hm[hk]:hm[hk]+Val]==S[i-Val+1:i+1]:\n return i-Val+1\n \n hm[hk] = i-Val+1\n # print(mid, hm)\n \n N = len(S)\n start, end = 1, N\n res = 0\n while start<=end:\n mid = start+(end-start)//2\n pos = check(mid)\n if pos:\n res = pos\n start = mid+1\n else:\n end = mid-1\n \n return S[res:res+end]","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n n = len(S)\n BASE = 26\n MOD = (1 << 63) - 1\n POWS = [1] * n\n for i in range(1, n):\n POWS[i] = (POWS[i - 1] * BASE) % MOD\n def search(k):\n seen = set()\n h = 0\n for i in range(k):\n h = (h * BASE + ord(S[i]) - 97) % MOD\n seen.add(h)\n for i in range(k, n):\n h = ((h - (ord(S[i - k]) - 97) * POWS[k - 1]) * BASE + ord(S[i]) - 97) % MOD\n s = S[i - k + 1:i + 1]\n if h in seen:\n return i\n seen.add(h)\n return -1\n \n l, r = 0, n - 1\n while l <= r:\n m = (l + r) // 2\n if search(m) >= 0:\n l = m + 1\n else:\n r = m - 1\n if r < 0:\n return ''\n i = search(r)\n return S[i - r + 1:i + 1]","class Solution:\n def search(self, L: int, a: int, modulus: int, n: int, nums: List[int]) -> str:\n h = 0\n for i in range(L):\n h = (h * a + nums[i]) % modulus\n \n seen = {h}\n \n aL = pow(a, L, modulus)\n \n for start in range(1, n-L + 1):\n h = (h * a - nums[start - 1]* aL + nums[start + L - 1]) % modulus\n if h in seen:\n return start\n seen.add(h)\n return -1\n \n def longestDupSubstring(self, S: str) -> str:\n n = len(S)\n nums = [ord(S[i]) - ord('a') for i in range(n)]\n a = 26\n modulus = 2 ** 32\n left, right = 1, n\n while left <= right:\n L = left + (right - left) // 2\n if self.search(L, a, modulus, n, nums) != -1:\n left = L + 1\n else:\n right = L - 1\n start = self.search(left -1, a, modulus, n, nums)\n return S[start: start + left - 1]\n","from collections import defaultdict\nclass Solution:\n def longestDupSubstring(self, S: str) -> str:\n l, h = 2, len(S)-1\n res = ''\n while l <= h:\n m = l + (h-l) // 2\n cand = self.find_dup_substr_len_k(S, m)\n if cand:\n res = cand\n l = m+1\n else:\n h = m-1\n return res\n \n def find_dup_substr_len_k(self, s, k):\n MOD = (1 << 63) - 1\n BASE = 26\n D = pow(BASE, k-1, MOD)\n hash_val = 0\n seen = defaultdict(set)\n \n for i in range(len(s)):\n # update the sliding hash value\n if i >= k:\n char_offset = ord(s[i-k]) - ord('a') \n hash_val = (hash_val - char_offset * D) % MOD\n char_offset = ord(s[i]) - ord('a') \n hash_val = (hash_val * BASE + char_offset) % MOD\n \n # check hash collision and return string if duplicate found\n if i >= k-1:\n if hash_val in seen:\n cand_i = s[i-k+1:i+1]\n for j in seen[hash_val]:\n cand_j = s[j-k+1:j+1]\n if cand_i == cand_j:\n return cand_i\n seen[hash_val].add(i)\n return ''\n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n \n def code(t):\n return ord(t) - ord('a')+1\n def check(length):\n seen = collections.defaultdict(list)\n \n MOD = 10 ** 9 + 7\n P = 113\n INV_P = pow(P, MOD-2, MOD)\n\n h = 0\n power = 1\n '''\n h1 = s[0]p^0+s[1]p^1+s[2]p^2 +...+s[length-1]p^(length-1)\n move next:\n h2 = s[1]p^0+s[2]p^1+s[3]p^2 +...+s[length]p^(length-1)\n \n h2 = (h1 - S[i-length+1])*INV_P % MOD\n \n '''\n for i, x in enumerate(S):\n h = (h + power*code(x)) % MOD \n if i < length-1:\n power = power * P % MOD\n else:\n # start: i-(length-1)\n if h in seen:\n for j in seen[h]:\n if S[i-(length-1):i+1] == S[j:j+length]:\n return S[j:j+length], True\n seen[h].append(i-(length-1))\n h = (h-code(S[i-(length-1)]))*INV_P % MOD\n \n return '', False\n \n res = ''\n l, r = 1, len(S)-1\n while l <= r:\n mid = (l+r)//2\n sub, is_check = check(mid)\n if is_check:\n res = sub\n l = mid + 1\n else:\n r = mid - 1\n \n return res","class Solution:\n \n def find(self ,s , m) :\n \n seen = collections.defaultdict(list)\n \n mod = 1<<63 -1\n base = 26\n d = pow(26,m-1,mod)\n chal = 0\n \n for i in range(len(s)) :\n \n if i >= m :\n l_chal = ord(s[i-m]) - ord('a')\n chal = ( chal - l_chal*d)%mod\n \n l_chal = ord(s[i]) - ord('a')\n chal = (chal*base + l_chal)%mod\n \n if i >= m-1 :\n s_i = s[i-m+1 : i +1]\n if chal in seen :\n \n for j in seen[chal] :\n s_j = s[j-m+1 : j+1]\n if s_j == s_i :\n return s_i\n \n else :\n seen[chal].append(i)\n \n return ''\n \n def longestDupSubstring(self, S: str) -> str:\n \n l = 2 \n h = len(S) -1\n ans = ''\n \n while l <= h :\n m = (l+h)//2\n \n s = self.find(S ,m)\n \n if s != '' :\n ans = s\n l = m+1\n \n else :\n h = m-1\n \n return ans","class Solution:\n def longestDupSubstring(self, S):\n nums, N = [ord(c) - ord('a') for c in S], len(S)\n BASE, MOD = 26, 2**32\n def check(L):\n cur_hash, seen = 0, set()\n for val in nums[:L]:\n cur_hash = (cur_hash * BASE + val) % MOD\n seen.add(cur_hash)\n X = pow(BASE, L-1, MOD)\n for idx, val in enumerate(nums[L:], start = L):\n cur_hash -= nums[idx - L] * X\n cur_hash = (cur_hash * BASE + val) % MOD\n if cur_hash in seen:\n return idx - L + 1\n seen.add(cur_hash)\n return -1\n low, high = 1, N + 1\n start = 0\n while low < high:\n mid = (low + high)//2\n idx = check(mid)\n if idx != -1:\n low = mid + 1\n start = idx\n else:\n high = mid\n return S[start: start + low - 1]","from collections import defaultdict\nclass Solution:\n def longestDupSubstring(self, S: str) -> str:\n mod = 10 ** 9 + 7\n def get_rep(l: int) -> str:\n mp = defaultdict(list) # key: hash_code, value: list of start indexes of substrings\n a = 13\n sofar = 0\n factor = 1\n for i in range(l):\n sofar = (sofar * a + ord(S[i])) % mod\n factor = (factor * a) % mod\n mp[sofar].append(0)\n for i in range(l, len(S)):\n sofar = (sofar * a + ord(S[i]) - factor * ord(S[i - l])) % mod\n if sofar in mp:\n for j in mp[sofar]:\n if S[j: j + l] == S[i - l + 1: i + 1]:\n return S[i - l + 1: i + 1]\n mp[sofar].append(i - l + 1)\n return None\n \n low, high = 0, len(S) - 1\n ans = None\n while low <= high:\n mid = (low + high) // 2\n res = get_rep(mid)\n if res is None:\n high = mid - 1\n else:\n ans = res\n low = mid + 1\n return ans if ans is not None else ''\n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n def search(m, MOD):\n h = 0\n for i in range(m):\n h = (h * 26 + nums[i]) % MOD\n s = {h}\n aL = pow(26, m, MOD)\n for pos in range(1, n - m + 1):\n h = (h * 26 - nums[pos - 1] * aL + nums[pos + m - 1]) % MOD\n if h in s:\n return pos\n s.add(h)\n return -1\n\n n = len(S)\n nums = [ord(c) - ord('a') for c in S]\n l, r = 1, n\n pos = -1\n MOD = 2**63 - 1\n while l <= r:\n m = (l + r) // 2\n cur = search(m, MOD)\n if cur != -1:\n l = m + 1\n pos = cur\n else:\n r = m - 1\n return S[pos: pos + l - 1] ","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n base, mod = 26, 2**63 - 1\n n = len(S)\n A = [ord(ch) - ord('a') for ch in S]\n def k_dup(k):\n curr = 0\n for i in range(k):\n curr = (curr * base + A[i]) % mod\n seen = {curr}\n for i in range(1, n - k + 1):\n curr = ( base*curr - pow(base, k, mod)*A[i-1] + A[i+k-1]) % mod\n if curr in seen:\n return i\n seen.add(curr)\n return 0\n l, r, ans = 0, n, 0\n while l < r:\n mid = (l + r + 1) >> 1\n pos = k_dup(mid)\n # print(pos, mid)\n if pos:\n l = mid\n ans = pos\n else:\n r = mid - 1\n return S[ans:ans + l]\n \n","class Solution:\n def longestDupSubstring(self, S):\n nums = [ord(c) - ord('a') for c in S]\n BASE, MOD = 26, 2**32 # Wrong: BASE, MOD = 113, 1000000007, too small\n def check(L):\n cur_hash, seen = 0, set()\n for val in nums[:L]:\n cur_hash = ((cur_hash * BASE) + val) % MOD\n seen.add(cur_hash)\n X = pow(BASE, L-1, MOD) # much faster than (BASE ** (L-1)) % MOD\n for i, val in enumerate(nums[L:]):\n # cur_hash -= nums[i] * (BASE ** (L-1))\n cur_hash -= nums[i] * X\n cur_hash = ((cur_hash * BASE) + val) % MOD\n if cur_hash in seen:\n return i + 1\n seen.add(cur_hash)\n return -1\n low, high = 1, len(S) + 1\n res = 0\n while low < high:\n mid = (low + high)//2\n idx = check(mid)\n if idx != -1:\n low = mid + 1\n res = idx\n else:\n high = mid\n return S[res: res + low-1]\n \nclass Solution:\n def longestDupSubstring(self, S):\n N = len(S)\n def check(length):\n seen = set()\n for i in range(N - length):\n hashS = hash(S[i:i+length+1])\n if hashS in seen:\n return i\n seen.add(hashS)\n return 0\n\n low, high = 0, N\n idx = 0\n while low < high:\n mid = (low + high)//2\n start = check(mid)\n if start:\n low = mid + 1\n idx = start\n else:\n high = mid\n return S[idx:idx + low]","class Solution:\n def search(self, L: int, base: int, MOD: int, n: int, nums: List[int]) -> str:\n # compute the hash of string S[:L]\n h = 0\n for i in range(L):\n h = (h * base + nums[i]) % MOD\n \n # already seen hashes of strings of length L\n seen = {h} \n # const value to be used often : a**L % mod\n aL = pow(base, L, MOD) \n for start in range(1, n - L + 1):\n # compute rolling hash in O(1) time\n h = (h * base - nums[start - 1] * aL + nums[start + L - 1]) % MOD\n if h in seen:\n return start\n seen.add(h)\n return -1\n \n def longestDupSubstring(self, S: str) -> str:\n n = len(S)\n # convert string to array of integers to implement constant time slice\n nums = [ord(S[i]) - ord('a') for i in range(n)]\n # base value for the rolling hash function\n base = 26\n # mod value for the rolling hash function to avoid overflow\n MOD = 2**32\n \n # binary search, L = repeating string length\n left, right = 1, n\n while left <= right:\n mid = left + (right - left) // 2\n if self.search(mid, base, MOD, n, nums) != -1:\n left = mid + 1\n else:\n right = mid - 1\n \n start = self.search(left - 1, base, MOD, n, nums)\n return S[start: start + left - 1]\n \n \n \n \n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n n = len(S)\n low = 0\n high = n-1\n \n nums = [ord(S[i]) - ord('a') for i in range(n)]\n \n def findDuplicate(L):\n # compute the hash of string S[:L]\n h = 0\n a = 26\n modulus = 2**32\n for i in range(L):\n h = (h * a + nums[i]) % modulus\n\n # already seen hashes of strings of length L\n seen = {h}\n # const value to be used often : a**L % modulus\n aL = pow(a, L, modulus) \n for start in range(1, n - L + 1):\n # compute rolling hash in O(1) time\n h = (h * a - nums[start - 1] * aL + nums[start + L - 1]) % modulus\n if h in seen:\n return start\n seen.add(h)\n return -1\n \n res = ''\n while low < high:\n mid = (low + high + 1)//2\n start = findDuplicate(mid)\n if start != -1:\n low = mid\n res = S[start:start+mid] \n else:\n high = mid-1\n return res","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n \n l = 0\n r = len(S)\n base = 26\n mod = 2**32\n res = [0, 0]\n nums = [ord(n) - ord('a') for n in S]\n\n \n while l < r:\n \n mid = (l+r) // 2\n h = 0\n \n for i in range(0, mid):\n h = (h*base + nums[i]) % mod\n \n dups = set([h])\n remove = pow(base, mid, mod)\n \n for i in range(1, len(nums) - mid + 1):\n h = (h*base - nums[i-1] * remove + nums[i+mid-1]) % mod\n \n if h in dups:\n res = [i, i+mid]\n break\n \n dups.add(h)\n # print(mid, h) \n if res[1] - res[0] < mid:\n r = mid\n else:\n l = mid + 1\n \n \n return S[res[0]:res[1]]\n \n \n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n low = 0\n high = len(S)-1\n result = ''\n nums = [ord(i) - ord('a') for i in S]\n mod = 2**63-1\n \n def rabin_karp(size):\n power = pow(26,size,mod)\n hash_val = 0\n hash_set = set()\n for i in range(size):\n hash_val = (hash_val*26 + (nums[i]))%mod\n hash_set.add(hash_val)\n for i in range(size, len(S)):\n hash_val = (hash_val*26 - (power*nums[i-size]) + nums[i])%mod\n if hash_val in hash_set:\n return i-size+1\n else:\n hash_set.add(hash_val)\n return -1\n while(low <= high):\n mid = low + (high-low)//2\n pos = rabin_karp(mid)\n if pos == -1:\n high = mid - 1\n else:\n result = S[pos:pos+mid]\n low = mid+1\n return result","class Solution:\n def longestDupSubstring(self, S):\n nums = [ord(c) - ord('a') for c in S]\n BASE, MOD = 26, 2**32 # Wrong: BASE, MOD = 113, 1000000007, too small\n def check(L):\n cur_hash, seen = 0, set()\n for val in nums[:L]:\n cur_hash = ((cur_hash * BASE) + val) % MOD\n seen.add(cur_hash)\n X = pow(BASE, L-1, MOD) # much faster than (BASE ** (L-1)) % MOD\n for i, val in enumerate(nums[L:]):\n # cur_hash -= nums[i] * (BASE ** (L-1))\n cur_hash -= nums[i] * X\n cur_hash = ((cur_hash * BASE) + val) % MOD\n if cur_hash in seen:\n return i + 1\n seen.add(cur_hash)\n return -1\n low, high = 1, len(S) + 1\n res = 0\n while low < high:\n mid = (low + high)//2\n idx = check(mid)\n if idx != -1:\n low = mid + 1\n res = idx\n else:\n high = mid\n return S[res: res + low-1]","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n n=len(S)\n modulus=2**32\n a=26 \n nums=[ord(c)-ord('a') for c in S]\n def search(L):\n nonlocal a,n,modulus\n aL=pow(a,L,modulus)\n h=0\n for i in range(L):\n h=(h*a+nums[i])%modulus\n seen={h}\n for start in range(1,n-L+1):\n h=(h*a-nums[start-1]*aL+nums[start+L-1])%modulus\n if h in seen:\n return start\n seen.add(h)\n return -1\n \n l,r=1,n\n while l<=r:\n mid=(l+r)>>1\n if search(mid)!=-1:\n l=mid+1\n else:\n r=mid-1\n \n start=search(r) \n return S[start:start+r]","class Solution:\n \n def rabinKarp(self, L, nums):\n h = 0\n a = 26\n MOD = 2**32\n for i in range(L):\n h = (h * a + nums[i]) % MOD\n \n aL = pow(a, L, MOD)\n seen = {h}\n for start in range(1, len(nums)-L+1):\n h = (h *a - nums[start-1] * aL + nums[start+L-1]) % MOD\n if h in seen:\n return start\n seen.add(h)\n return -1\n \n def longestDupSubstring(self, S: str) -> str: \n nums = [ord(ch)-ord('a') for ch in S]\n l, r = 0, len(S)\n while l < r:\n mid = l + (r-l) // 2\n if self.rabinKarp(mid, nums) != -1:\n l = mid + 1\n else:\n r = mid\n start = self.rabinKarp(l-1, nums)\n return S[start:start+l-1] \n \n","from functools import reduce\nclass Solution:\n def longestDupSubstring(self, S: str) -> str:\n # binary search + string hashing\n from functools import reduce\n A = [ord(c) - ord('a') for c in S]\n mod = 2 ** 63 - 1\n def judge(l):\n p = 26 ** l % mod\n cur = reduce(lambda x, y : (x * 26 + y) % mod, A[:l], 0)\n seen = {cur}\n for i in range(l, len(S)):\n cur = (cur * 26 + A[i] - p * A[i - l]) % mod\n if cur in seen: return i - l + 1\n seen.add(cur)\n \n lo, hi = 0, len(S)\n res = 0\n while lo < hi:\n mi = (lo + hi + 1) // 2\n pos = judge(mi)\n if pos:\n lo = mi\n res = pos\n else:\n hi = mi - 1\n return S[res : res + lo]\n","class Solution:\n # Use binary search to try out all possible lengths of the subtrings\n # Use a record list to record the hash summation of the substring\n # Use the number of distinct chara as the hash base\n # If two substrings are the same, they should have the same hash summation\n # After minus the before part\n def longestDupSubstring(self, S: str) -> str:\n res = ''\n d,q = len(set(S)), 2**63-1\n record = [0]*len(S)\n for i in range(len(S)):\n if i == 0:record[i] = ord(S[i])\n else:record[i] = (record[i-1]*d+ord(S[i]))%q\n def check(mid):\n h,g = 1,set()\n for i in range(mid):\n h = h*d%q\n for i in range(len(S)-mid+1):\n count = (record[i+mid-1]-record[i-1]*h)%q if i > 0 else record[i+mid-1]\n if count not in g:g.add(count)\n else:return S[i:i+mid]\n return False\n l,r = 0,len(S)-1\n while l<=r:\n mid = (l+r)//2\n temp = check(mid)\n if temp:\n res = temp\n l = mid + 1\n else:r = mid - 1\n return res\n \n \n# res = \\\"\\\"\n# d, q = len(set(S)), 2**63-1\n# hashes = [0] * len(S)\n# for i in range(len(S)):\n# if i == 0: hashes[i] = ord(S[i])\n# else: hashes[i] = (hashes[i-1]*d + ord(S[i]))%q\n# l, r = 0, len(S)-1\n# while l <= r:\n# mid = (l+r)//2\n# temp = self.check(S,mid,hashes,d,q)\n# if temp:\n# res = temp\n# l = mid + 1\n# else: r = mid - 1\n# return res\n \n# def check(self, S, mid, hashes, d, q):\n# res = set()\n# h, g = 1, 0\n# for i in range(mid):\n# h = (h*d)%q\n# for i in range(len(S)-mid+1):\n# g = (hashes[i+mid-1] - hashes[i-1]*h)%q if i > 0 else hashes[i+mid-1]\n# if g not in res: res.add(g)\n# else: return S[i:i+mid]\n# return False\n \n \n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n \n def rk(m):\n \n nonlocal idx\n st = set()\n \n #p = b**(m-1)\n #p%=mod\n p= pow(b,m-1,mod) # more efficient to mod at each step than work on a long number\n \n y = 0\n for i in range(m):\n y = (y*b+num[i])%mod # more efficient to mod at each step than work on a long number\n \n st.add(y)\n \n for i in range(1, n-m+1):\n y = ((y-num[i-1]*p%mod)*b%mod+num[i-1+m])%mod\n #y = (y-num[i-1]*p)*b+num[i-1+m]\n \n if y in st:\n idx = i\n return 0\n else:\n st.add(y)\n \n return 1\n \n \n\n n = len(S)\n b = 26 # no need to be 128\n #mod = 10**9+7 # too small => conflict\n mod = 2**32 # here\n \n z = ord('a')\n num = [ ord(S[i])-z for i in range(n)]\n \n l=1\n r=n\n idx = 0 # last found duplicate \n while l<r:\n \n m = (l+r)//2\n \n if rk(m)>0:\n r = m\n else:\n l = m+1\n \n return S[idx:idx+l-1]\n \n \n","p = 2**63 - 1\n\nclass Solution:\n def longestDupSubstring(self, S: str) -> str:\n def rabin_karp(mid):\n cur_hash = 0\n for i in range(mid):\n cur_hash = (cur_hash * 26 + nums[i]) % p\n hashes = {cur_hash}\n pos = -1\n max_pow = pow(26, mid, p)\n for i in range(mid, len(S)):\n cur_hash = (26*cur_hash-nums[i-mid]*max_pow + nums[i]) % p\n if cur_hash in hashes:\n pos = i + 1 - mid\n hashes.add(cur_hash)\n return pos\n\n\n low, high = 0, len(S)-1\n end = 0\n start = 0\n nums = [ord(c)-ord('a') for c in S]\n while low <= high:\n mid = (low+high) // 2\n pos = rabin_karp(mid)\n if pos == -1: # no matching strings found\n high = mid - 1\n else:\n start = pos\n low = mid + 1\n return S[start:start+low-1]\n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n def search(m, MOD):\n h = 0\n for i in range(m):\n h = (h * 26 + nums[i]) % MOD\n s = {h}\n aL = pow(26, m, MOD)\n for pos in range(1, n - m + 1):\n h = (h * 26 - nums[pos - 1] * aL + nums[pos + m - 1]) % MOD\n if h in s:\n return pos\n s.add(h)\n return -1\n\n n = len(S)\n nums = [ord(c) - ord('a') for c in S]\n l, r = 1, n\n pos = -1\n MOD = 2**63 - 1\n while l <= r:\n m = (l + r) // 2\n cur = search(m, MOD)\n if cur != -1:\n l = m + 1\n pos = cur\n else:\n r = m - 1\n return S[pos: pos + l - 1]","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n N = len(S)\n l, r = 1, N\n nums = [ord(x) - ord('a') for x in S]\n KMAX = 2 ** 63 - 1\n def check(m):\n MAXL = pow(26, m, KMAX)\n total = 0\n hashset = set()\n for i in range(m):\n total = (total * 26 + nums[i]) % KMAX\n hashset.add(total)\n for i in range(1, N - m + 1):\n total = (total * 26 - nums[i-1] * MAXL + nums[i+m-1]) % KMAX\n if total in hashset:\n return i\n hashset.add(total)\n return -1\n \n while l < r:\n m = (l + r) // 2\n if check(m) < 0:\n r = m\n else:\n l = m + 1\n idx = check(r - 1) \n return S[idx: idx + r-1]","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n ords = [ord(ch) - 97 for ch in S]\n mod = 2 ** 32\n seen = set()\n \n def has_dup_with_length(length):\n seen.clear()\n p = pow(26, length, mod)\n \n hashed_prefix = 0\n for i in range(length):\n hashed_prefix = (hashed_prefix * 26 + ords[i]) % mod\n seen.add(hashed_prefix)\n\n for i in range(length, len(S)):\n hashed_prefix = (hashed_prefix * 26 + ords[i] - ords[i - length] * p) % mod\n if hashed_prefix in seen:\n return i - length + 1\n seen.add(hashed_prefix)\n \n start, lo, hi = 0, 0, len(S) - 1, \n while lo < hi:\n mid_length = (lo + hi + 1) // 2\n idx = has_dup_with_length(mid_length)\n if idx:\n start = idx\n lo = mid_length\n else:\n hi = mid_length - 1\n return S[start: start + lo]","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n res = ''\n d,q = len(set(S)), 2**63-1\n record = [0]*len(S)\n for i in range(len(S)):\n if i == 0:record[i] = ord(S[i])\n else:record[i] = (record[i-1]*d+ord(S[i]))%q\n def check(mid):\n h,g = 1,set()\n for i in range(mid):\n h = h*d%q\n for i in range(len(S)-mid+1):\n count = (record[i+mid-1]-record[i-1]*h)%q if i > 0 else record[i+mid-1]\n if count not in g:g.add(count)\n else:return S[i:i+mid]\n return False\n l,r = 0,len(S)-1\n while l<=r:\n mid = (l+r)//2\n temp = check(mid)\n if temp:\n res = temp\n l = mid + 1\n else:r = mid - 1\n return res\n \n \n# res = \\\"\\\"\n# d, q = len(set(S)), 2**63-1\n# hashes = [0] * len(S)\n# for i in range(len(S)):\n# if i == 0: hashes[i] = ord(S[i])\n# else: hashes[i] = (hashes[i-1]*d + ord(S[i]))%q\n# l, r = 0, len(S)-1\n# while l <= r:\n# mid = (l+r)//2\n# temp = self.check(S,mid,hashes,d,q)\n# if temp:\n# res = temp\n# l = mid + 1\n# else: r = mid - 1\n# return res\n \n# def check(self, S, mid, hashes, d, q):\n# res = set()\n# h, g = 1, 0\n# for i in range(mid):\n# h = (h*d)%q\n# for i in range(len(S)-mid+1):\n# g = (hashes[i+mid-1] - hashes[i-1]*h)%q if i > 0 else hashes[i+mid-1]\n# if g not in res: res.add(g)\n# else: return S[i:i+mid]\n# return False\n \n \n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n n = len(S)\n nums = [ord(S[i]) - ord('a') for i in range(n)]\n \n def search(position):\n h = 0\n for i in range(position):\n h = (h * 26 + nums[i]) % 2 ** 32\n seen = {h}\n const = 26 ** position % 2 ** 32\n for start in range(1, n - position + 1):\n h = (h * 26 - nums[start - 1] * const + nums[start + position - 1]) % 2 ** 32\n if h in seen:\n return start\n seen.add(h)\n return -1\n \n left, right = 1, n\n while left <= right:\n pivot = (left + right) // 2\n if search(pivot) != -1:\n left = pivot + 1\n else:\n right = pivot - 1\n start = search(left - 1)\n return S[start: start + left - 1]","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n \n arr = [ord(ch) - ord('a') for ch in S]\n n = len(arr)\n B = 29\n mod = 2**63 - 1\n def exists(L):\n seen = {}\n P = pow(B, L, mod)\n h = 0\n for i in range(n):\n h = (h * B + arr[i]) % mod\n if i >= L:\n h = (h - arr[i-L] * P) % mod\n if i >= L - 1:\n if h in seen:\n return seen[h]\n seen[h] = i\n return -1\n \n lo, hi = 0, len(S)\n # cand = ''\n pos = -1\n while lo < hi:\n mid = (lo + hi + 1) // 2\n idx = exists(mid)\n if idx != -1:\n lo = mid\n # cand = S[idx - mid + 1: idx + 1]\n pos = idx\n else:\n hi = mid - 1\n return S[pos - lo + 1:pos+1]\n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n self.A = [ord(c) - ord('a') for c in S]\n \n start, end = 1, len(S)\n while start + 1 < end:\n mid = (start + end) // 2\n pos = self.check(mid)\n if pos:\n start = mid\n else:\n end = mid\n\n pos = self.check(end)\n if pos:\n return S[pos: pos + end]\n pos = self.check(start)\n if pos:\n return S[pos: pos + start]\n return ''\n \n def check(self, length):\n mod = 2**63 - 1\n power = pow(26, length, mod)\n \n cur = 0\n for i in range(length):\n cur = (cur * 26 + self.A[i]) % mod\n \n # cur = reduce(lambda x, y: (x * 26 + y) % mod, self.A[:length], 0)\n seen = {cur}\n \n for i in range(length, len(self.A)):\n cur = (cur * 26 + self.A[i] - self.A[i - length] * power) % mod\n if cur in seen:\n return i - length + 1\n seen.add(cur)\n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n \n def rk(m):\n \n nonlocal idx\n st = set()\n p = b**(m-1)\n p%=mod\n \n y = 0\n for i in range(m):\n y = (y*b+num[i])%mod\n \n st.add(y)\n \n for i in range(1, n-m+1):\n y = ((y-num[i-1]*p%mod)*b%mod+num[i-1+m])%mod\n #y = (y-num[i-1]*p)*b+num[i-1+m]\n \n if y in st:\n idx = i\n return 0\n else:\n st.add(y)\n \n return 1\n \n \n\n n = len(S)\n b = 26 # no need to be 128\n #mod = 10**9+7 # too small => conflict\n mod = 2**32 # here\n \n z = ord('a')\n num = [ ord(S[i])-z for i in range(n)]\n \n l=1\n r=n\n idx = 0 # last found duplicate \n while l<r:\n \n m = (l+r)//2\n \n if rk(m)>0:\n r = m\n else:\n l = m+1\n \n return S[idx:idx+l-1]\n \n \n","from functools import reduce\nclass Solution:\n def longestDupSubstring(self, S: str) -> str:\n self.A = [ord(c) - ord('a') for c in S]\n \n start, end = 1, len(S)\n while start + 1 < end:\n mid = (start + end) // 2\n pos = self.check(mid)\n if pos:\n start = mid\n else:\n end = mid\n\n pos = self.check(end)\n if pos:\n return S[pos: pos + end]\n pos = self.check(start)\n if pos:\n return S[pos: pos + start]\n return ''\n \n def check(self, length):\n mod = 2**63 - 1\n power = pow(26, length, mod)\n \n cur = reduce(lambda x, y: (x * 26 + y) % mod, self.A[:length], 0)\n seen = {cur}\n \n for i in range(length, len(self.A)):\n cur = (cur * 26 + self.A[i] - self.A[i - length] * power) % mod\n if cur in seen:\n return i - length + 1\n seen.add(cur)\n","from functools import reduce\nclass Solution:\n def longestDupSubstring(self, S: str) -> str:\n self.A = [ord(c) - ord('a') for c in S]\n \n start, end = 1, len(S)\n while start + 1 < end:\n mid = (start + end) // 2\n pos = self.check(mid)\n if pos:\n start = mid\n else:\n end = mid\n\n pos = self.check(end)\n if pos:\n return S[pos: pos + end]\n pos = self.check(start)\n if pos:\n return S[pos: pos + start]\n return ''\n \n def check(self, length):\n mod = 2**63 - 1\n power = pow(26, length, mod)\n \n # cur = 0\n # for i in range(length):\n # cur = (cur * 26 + self.A[i]) % mod\n \n cur = reduce(lambda x, y: (x * 26 + y) % mod, self.A[:length], 0)\n seen = {cur}\n \n for i in range(length, len(self.A)):\n cur = (cur * 26 + self.A[i] - self.A[i - length] * power) % mod\n if cur in seen:\n return i - length + 1\n seen.add(cur)\n","from functools import reduce\nclass Solution:\n def longestDupSubstring(self, S: str) -> str:\n self.A = [ord(c) - ord('a') for c in S]\n \n start, end = 1, len(S)\n while start + 1 < end:\n mid = (start + end) // 2\n print(mid)\n pos = self.check(mid)\n print(pos)\n if pos:\n start = mid\n else:\n end = mid\n # print(start, end)\n pos = self.check(end)\n # print(pos)\n if pos:\n return S[pos: pos + end]\n pos = self.check(start)\n if pos:\n return S[pos: pos + start]\n return ''\n \n def check(self, length):\n mod = 2**63 - 1\n power = pow(26, length, mod)\n \n cur = reduce(lambda x, y: (x * 26 + y) % mod, self.A[:length], 0)\n seen = {cur}\n \n for i in range(length, len(self.A)):\n cur = (cur * 26 + self.A[i] - self.A[i - length] * power) % mod\n if cur in seen:\n return i - length + 1\n seen.add(cur)\n","class Solution:\n def searchLongestStringOfKLen(self, S, total_len, compare_len):\n search_len_hash = 0\n for i in range(compare_len):\n search_len_hash = (search_len_hash * self.uniq + self.nums[i]) % self.mod\n\n tmp_hash = {}\n tmp_hash[search_len_hash] = True\n \n remove_old_power = pow(self.uniq, compare_len, self.mod)\n for i in range(1, total_len-compare_len+1):\n search_len_hash = (search_len_hash * self.uniq - (remove_old_power * self.nums[i-1]) + self.nums[i+compare_len-1] )% self.mod\n if search_len_hash in tmp_hash:\n return i\n tmp_hash[search_len_hash] = True\n \n return -1\n \n \n def longestDupSubstring(self, S: str) -> str:\n ls = len(S)\n end = ls\n start = 1 \n mid = 0\n self.nums = []\n for i in range(ls):\n self.nums.append(ord(S[i]) - ord('a'))\n\n self.uniq = 26\n self.mod = 2**32\n while start <= end:\n mid = start + (end-start)//2\n if self.searchLongestStringOfKLen(S, ls, mid) != -1:\n start = mid + 1\n else :\n end = mid - 1\n \n ds_sp = self.searchLongestStringOfKLen(S, ls, start -1)\n return S[ds_sp:ds_sp+start-1]","def check(arr, n, l, mod):\n p = pow(26, l, mod)\n window_hash = 0\n hash_set = set()\n for i in range(l):\n window_hash = (26 * window_hash + arr[i]) % mod\n hash_set.add(window_hash)\n\n for i in range(1, n - l + 1):\n window_hash = (window_hash * 26 - (arr[i - 1]*p) + arr[i + l - 1])%mod\n if window_hash in hash_set:\n return i\n hash_set.add(window_hash)\n\n return False\n\n\nclass Solution:\n def longestDupSubstring(self, S: str) -> str:\n \n n = len(S)\n min_length, max_length = 1, n\n ans, prev_len = 0, 0\n mod = (1 << 63) - 1\n nums = [ord(S[i]) - ord('a') for i in range(n)]\n\n while min_length <= max_length:\n mid_length = int((max_length + min_length)/2)\n start = check(nums, n, mid_length, mod)\n if start != False:\n if prev_len < mid_length:\n ans = start\n prev_len = mid_length\n min_length = mid_length + 1\n else:\n max_length = mid_length - 1\n \n return S[ans:ans + prev_len]\n","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n n=len(S)\n modulus=2**56\n a=26 \n nums=[ord(c)-ord('a') for c in S]\n def search(L):\n nonlocal a,n,modulus\n aL=pow(a,L,modulus)\n h=0\n for i in range(L):\n h=(h*a+nums[i])%modulus\n seen={h}\n for start in range(1,n-L+1):\n h=(h*a-nums[start-1]*aL+nums[start+L-1])%modulus\n if h in seen:\n return start\n seen.add(h)\n return -1\n \n l,r=1,n\n while l<=r:\n mid=(l+r)>>1\n if search(mid)!=-1:\n l=mid+1\n else:\n r=mid-1\n \n start=search(r) \n return S[start:start+r]","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n n = len(S)\n chars = [ord(c) - 97 for c in S]\n BASE = 26\n MOD = (1 << 63) - 1\n POWS = [1] * n\n for i in range(1, n):\n POWS[i] = (POWS[i - 1] * BASE) % MOD\n def search(k):\n seen = set()\n h = 0\n for i in range(k):\n h = (h * BASE + chars[i]) % MOD\n seen.add(h)\n for i in range(k, n):\n h = ((h - chars[i - k] * POWS[k - 1]) * BASE + chars[i]) % MOD\n if h in seen:\n return i\n seen.add(h)\n return -1\n \n l, r = 0, n - 1\n k = 0\n while l < r:\n m = (l + r + 1) // 2\n i = search(m)\n if i >= 0:\n k = i\n l = m\n else:\n r = m - 1\n return S[k - l + 1:k + 1]","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n n = len(S)\n chars = [ord(c) - 97 for c in S]\n BASE = 26\n MOD = (1 << 63) - 1\n POWS = [1] * n\n for i in range(1, n):\n POWS[i] = (POWS[i - 1] * BASE) % MOD\n def search(k):\n seen = set()\n h = 0\n for i in range(k):\n h = (h * BASE + chars[i]) % MOD\n seen.add(h)\n for i in range(k, n):\n h = ((h - chars[i - k] * POWS[k - 1]) * BASE + chars[i]) % MOD\n if h in seen:\n return i\n seen.add(h)\n return -1\n \n l, r = 0, n - 1\n while l <= r:\n m = (l + r) // 2\n if search(m) >= 0:\n l = m + 1\n else:\n r = m - 1\n if r < 0:\n return ''\n i = search(r)\n return S[i - r + 1:i + 1]","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n p = 31\n m = 100000000003\n\n pows = [1] * len(S)\n invPows = [1] * len(S)\n for i in range(1, len(S)):\n pows[i] = pows[i-1] * p % m\n invPows[i] = pow(pows[i], -1, m)\n\n h = [0] * (len(S) + 1)\n for i in range(len(S)):\n h[i+1] = (h[i] + (ord(S[i]) - ord('a') + 1) * pows[i]) % m\n\n def hasDup(S, sublen):\n seen = set()\n for i in range(len(S)- sublen + 1):\n if (hs := (h[i + sublen] - h[i]) * invPows[i] % m) in seen:\n return (i, sublen)\n seen.add(hs)\n return (0, 0)\n\n ans = None\n lo, hi = 1, len(S)\n while lo < hi:\n mid = (lo + hi) // 2\n if (s := hasDup(S, mid))[1]:\n lo = mid + 1\n ans = s\n else:\n hi = mid\n return S[ans[0]:ans[0]+ans[1]] if ans else ''","class Solution:\n def longestDupSubstring(self, S: str) -> str:\n def search(m, MOD):\n h = 0\n for i in range(m):\n h = (h * 26 + nums[i]) % MOD\n s = {h}\n aL = pow(26, m, MOD)\n for pos in range(1, n - m + 1):\n h = (h * 26 - nums[pos - 1] * aL + nums[pos + m - 1]) % MOD\n if h in s:\n return pos\n s.add(h)\n return -1\n \n n = len(S)\n nums = [ord(c) - ord('a') for c in S]\n # find length of longest duplicate substring\n l, r = 1, n\n pos = 0\n MOD = 2**63 - 1 # use largest positive of 8 byte integer\n while l <= r:\n m = (l + r) // 2\n # search if there's duplicate for length m substring\n cur = search(m, MOD)\n if cur != -1:\n l = m + 1\n pos = cur\n else:\n r = m - 1\n return S[pos: pos + l - 1]","from collections import defaultdict\nfrom functools import reduce\n\n\nclass Solution:\n def longestDupSubstring(self, S: str) -> str:\n mod = (1 << 63 - 1)\n A = [ord(c) - ord('a') for c in S]\n \n def find_dup_of_length(L):\n p = pow(26, L, mod)\n h = reduce(lambda x, y: (x * 26 + y) % mod, A[:L], 0)\n seen = defaultdict(list)\n seen[h].append(0)\n \n for i in range(L, len(S)):\n h = (h * 26 + A[i] - p * A[i-L]) % mod\n for start in seen[h]:\n if S[start:start+L] == S[i-L+1:i+1]:\n return start\n \n seen[h].append(i-L+1)\n \n start = 0\n length = 0\n low, high = 1, len(S)\n while low < high:\n mid = low + (high - low) // 2\n pos = find_dup_of_length(mid)\n if pos is not None:\n start = pos\n length = mid\n low = mid + 1\n else:\n high = mid\n \n return S[start:start+length]\n"],"string":"[\n \"class Solution:\\n def longestDupSubstring(self, S):\\n nums, N = [ord(c) - ord('a') for c in S], len(S)\\n BASE, MOD = 26, 2**32\\n def check(L):\\n cur_hash, seen = 0, set()\\n for val in nums[:L]:\\n cur_hash = (cur_hash * BASE + val) % MOD\\n seen.add(cur_hash)\\n X = pow(BASE, L-1, MOD)\\n for idx, val in enumerate(nums[L:]):\\n cur_hash -= nums[idx] * X\\n cur_hash = (cur_hash * BASE + val) % MOD\\n if cur_hash in seen:\\n return idx + 1\\n seen.add(cur_hash)\\n return -1\\n low, high = 1, N + 1\\n start = 0\\n while low < high:\\n mid = (low + high)//2\\n idx = check(mid)\\n if idx != -1:\\n low = mid + 1\\n start = idx\\n else:\\n high = mid\\n return S[start: start + low - 1]\\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n def has_duplicate(m, S):\\n val, Mod = 0, 2**63-1\\n for i in range(m):\\n val = (26*val + ord(S[i])) % Mod\\n \\n d = set([val])\\n const = 26**m % Mod\\n for i in range(m, len(S)):\\n val = (26*val + ord(S[i]) - ord(S[i-m])*const) % Mod\\n if val in d: return i-m+1\\n d.add(val)\\n return -1\\n \\n l, r = 0, len(S)\\n start, length = -1, 0\\n while l<=r:\\n mid = l + (r-l)//2\\n idx = has_duplicate(mid, S)\\n if idx!=-1:\\n l = mid + 1\\n start, length = idx, mid\\n else:\\n r = mid - 1\\n \\n if start==-1: return ''\\n return S[start:start+length]\\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n A = [ord(c) for c in S]\\n mod = 2**63-1\\n \\n lo = 0\\n hi = len(S)\\n res = 0\\n \\n def test(sz):\\n val = 0\\n p = pow(26,sz,mod)\\n for i in range(sz):\\n val = val*26+A[i]\\n val %= mod\\n seen = {val}\\n for i in range(sz, len(A)):\\n val = val*26+A[i]-A[i-sz]*p\\n val = val%mod\\n if val in seen:\\n return i-sz+1\\n seen.add(val)\\n return -1 \\n \\n while lo < hi:\\n mid = (lo+hi)//2\\n pos = test(mid)\\n if not pos >= 0:\\n hi = mid\\n else:\\n res = pos\\n lo = mid+1\\n \\n return S[res:res+lo-1]\\n \\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n def check(L):\\n base = 26\\n modulo = 2**32\\n AL = base**L%modulo\\n hk = 0\\n for i in range(L):\\n hk = hk*base + nums[i]\\n hk %= modulo\\n hm = {hk:0}\\n for i in range(L, len(S)):\\n hk = (hk*base-nums[i-L]*AL+nums[i])%modulo\\n if hk in hm and S[i-L+1:i+1]==S[hm[hk]:hm[hk]+L]:\\n return i-L+1\\n hm[hk] = i-L+1\\n \\n return -1\\n \\n nums = [ord(c)-ord('a') for c in S]\\n res = -1\\n s, e = 1, len(S)\\n while s<=e:\\n m = s+(e-s)//2\\n pos = check(m)\\n if pos!=-1:\\n res = pos\\n s = m+1\\n else:\\n e = m-1\\n \\n return S[res:res+e]\\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n def test(L):\\n base = 26\\n modulus = 2**32\\n AL = base**L%modulus\\n hk = 0\\n for i in range(L):\\n hk=hk*base+nums[i]\\n hk%=modulus\\n hs=set([hk])\\n \\n for i in range(L, len(S)):\\n hk = hk*base-nums[i-L]*AL+nums[i]\\n hk%=modulus\\n if hk in hs:\\n return i-L+1\\n hs.add(hk)\\n \\n nums = [ord(c)-ord('a') for c in S]\\n start, end = 1, len(S)\\n res = -1\\n while start<=end:\\n mid = start+(end-start)//2\\n pos = test(mid)\\n \\n if pos:\\n res = pos\\n start = mid+1\\n else:\\n end = mid-1\\n \\n return S[res:res+end]\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n n=len(S)\\n mod=10**30\\n ord_a=97\\n \\n def find_len_k_dup(k):\\n hash_val=0\\n seen=set()\\n for i in range(k):\\n hash_val=(hash_val*26+(ord(S[i])-ord_a))%mod\\n seen.add(hash_val)\\n power=26**k%mod\\n \\n for i in range(1,n-k+1):\\n hash_val=((hash_val*26-(ord(S[i-1])-ord_a)*power)%mod+(ord(S[i+k-1])-ord_a))%mod\\n if hash_val in seen:\\n return i\\n seen.add(hash_val)\\n return None\\n \\n# self.s=S\\n# self.n=len(S)\\n# def find_len_k_dup(length):\\n# hash_value = 0\\n# mod_value = 8000*(2**30) # a big number should be okay, if you change the number it might cause a wrong answer\\n# seen = set()\\n# for i in range(length):\\n# hash_value = (hash_value*26+ord(self.s[i])-ord('a'))%mod_value # get the hash value\\n# seen.add(hash_value)\\n# tmp = pow(26, length)%mod_value\\n# for i in range(1,self.n-length+1):\\n# # get the moving hash \\n# hash_value = ((hash_value*26 - (ord(self.s[i-1])-ord('a'))*tmp)%mod_value+ord(self.s[i+length-1])-ord('a'))%mod_value\\n# if hash_value in seen:\\n# return i\\n# else:\\n# seen.add(hash_value)\\n# return None\\n \\n \\n \\n \\n low=0\\n high=len(S)\\n res=''\\n while low<high:\\n \\n mid=(low+high)//2\\n idx=find_len_k_dup(mid)\\n #print(candidate)\\n if idx is not None:\\n res=S[idx:idx+mid]\\n low=mid+1\\n else:\\n high=mid\\n return res\",\n \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n A = [ord(c) - ord('a') for c in S]\\n mod = 2**63 - 1\\n def isDuplicate(len_s):\\n p = pow(31, len_s, mod)\\n seen = collections.defaultdict(list)\\n cur = reduce(lambda x,y: (x*31+y)%mod, A[:len_s])\\n seen[cur].append(0)\\n for j in range(1, len(A)-len_s+1):\\n cur = (cur*31 - A[j-1]*p + A[j+len_s-1])%mod\\n if cur in seen:\\n for i in seen[cur]:\\n if S[i:i+len_s] == S[j:j+len_s]:\\n return j\\n seen[cur].append(j)\\n return 0\\n \\n l, r = 1, len(S)-1\\n ans = ''\\n while l <= r:\\n mid = l + (r-l)//2\\n pos = isDuplicate(mid)\\n if pos:\\n ans = S[pos:pos+mid]\\n l = mid + 1\\n else:\\n r = mid -1\\n return ans \\n \\n \\n\",\n \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n A = [ord(c) - ord('a') for c in S]\\n mod = 2**63 - 1\\n \\n def test(L):\\n p = pow(26, L, mod)\\n cur = reduce(lambda x, y: (x * 26 + y) % mod, A[: L], 0)\\n seen = set()\\n seen.add(cur)\\n for i in range(L, len(A)):\\n cur = (cur * 26 + A[i] - A[i - L] * p) % mod\\n if cur in seen:\\n return i - L + 1\\n seen.add(cur)\\n \\n res, lo, hi = 0, 0, len(S)\\n while lo + 1 < hi:\\n mid = lo + (hi - lo) // 2\\n pos = test(mid)\\n if pos:\\n lo = mid\\n else:\\n hi = mid\\n \\n if test(hi):\\n pos = test(hi)\\n return S[pos: pos + hi]\\n pos = test(lo)\\n return S[pos: pos + lo]\\n\",\n \"class Solution:\\n def longestDupSubstring(self, S):\\n nums = [ord(c) - ord('a') for c in S]\\n #BASE, MOD = 113, 1000000007\\n BASE, MOD = 26, 2**32\\n def check(L):\\n cur_hash, seen = 0, set()\\n for val in nums[:L]:\\n cur_hash = ((cur_hash * BASE) + val) % MOD\\n seen.add(cur_hash)\\n X = pow(BASE, L-1, MOD) # (BASE ** (L-1)) % MOD\\n for i, val in enumerate(nums[L:]):\\n # cur_hash -= nums[i] * (BASE ** (L-1))\\n cur_hash -= nums[i] * X\\n cur_hash = ((cur_hash * BASE) + val) % MOD\\n if cur_hash in seen:\\n return i + 1\\n seen.add(cur_hash)\\n return -1\\n low, high = 1, len(S) + 1\\n res = 0\\n while low < high:\\n mid = (low + high)//2\\n idx = check(mid)\\n if idx != -1:\\n low = mid + 1\\n res = idx\\n else:\\n high = mid\\n return S[res: res + low-1]\\n \\n #while low <= high:\\n # mid = (low + high)//2\\n # idx = check(mid)\\n # if idx != -1:\\n # low = mid + 1\\n # res = idx\\n # else:\\n # high = mid - 1\\n #return S[res: res + low-1]\\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n def checkSubstrings(size):\\n hashed = 0\\n pow_mult = pow(26, size) % mod\\n \\n for i in range(size):\\n hashed *= 26\\n hashed += char_vals[i]\\n \\n hashed %= mod\\n seen = {hashed}\\n \\n for i in range(size, len(S)):\\n hashed = (hashed * 26 - char_vals[i-size] * pow_mult + char_vals[i]) % mod\\n if hashed in seen:\\n return i-size+1\\n seen.add(hashed)\\n \\n return None\\n\\n s, f = 0, len(S)\\n longest = 0\\n \\n char_vals = [ord(c) - ord('a') for c in S]\\n mod = pow(2, 63) - 1\\n \\n while s < f:\\n m = s + (f-s+1) // 2\\n longest_check = checkSubstrings(m)\\n if longest_check:\\n longest = longest_check\\n s = m\\n else:\\n f = m-1\\n \\n return S[longest:longest+s]\\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n # def RabinKarp(text, M, q):\\n # if M == 0: return True\\n # h, t, d = (1<<(8*M-8))%q, 0, 256\\n # dic = defaultdict(list)\\n # for i in range(M): \\n # t = (d * t + ord(text[i]))% q\\n # dic[t].append(i-M+1)\\n # for i in range(len(text) - M):\\n # t = (d*(t-ord(text[i])*h) + ord(text[i + M]))% q\\n # for j in dic[t]:\\n # if text[i+1:i+M+1] == text[j:j+M]:\\n # return (True, text[j:j+M])\\n # dic[t].append(i+1)\\n # return (False, \\\\\\\"\\\\\\\")\\n\\n\\n def check(sz):\\n seen = defaultdict(list)\\n cur, base, MOD = 0, 256, (1<<31) - 1\\n h = (1 << (sz*8)) % MOD\\n for i in range(sz):\\n cur *= base\\n cur += ord(S[i])\\n cur %= MOD\\n seen[cur].append(0)\\n for i in range(sz,len(S)):\\n cur *= base\\n cur += ord(S[i])\\n cur -= ord(S[i-sz])*h \\n cur %= MOD\\n for j in seen[cur]:\\n if S[j:j+sz] == S[i-sz+1:i+1]:\\n return True, S[i-sz+1:i+1]\\n seen[cur].append(i-sz+1)\\n return False, ''\\n\\n lo, hi = 1, len(S)\\n res = ''\\n # MOD = (1<<31) - 1\\n while lo <= hi:\\n mid = (lo+hi)//2\\n flag, tmp = check(mid)\\n # flag, tmp = RabinKarp(S, mid, q)\\n if flag:\\n lo = mid + 1\\n res = tmp\\n # print(mid,res)\\n else:\\n hi = mid - 1\\n # print(lo,hi)\\n return res \\n\\n\\n# class Solution:\\n# def RabinKarp(self,text, M, q):\\n# if M == 0: return True\\n# h, t, d = (1<<(8*M-8))%q, 0, 256\\n\\n# dic = defaultdict(list)\\n\\n# for i in range(M): \\n# t = (d * t + ord(text[i]))% q\\n\\n# dic[t].append(i-M+1)\\n\\n# for i in range(len(text) - M):\\n# t = (d*(t-ord(text[i])*h) + ord(text[i + M]))% q\\n# for j in dic[t]:\\n# if text[i+1:i+M+1] == text[j:j+M]:\\n# return (True, text[j:j+M])\\n# dic[t].append(i+1)\\n# return (False, \\\\\\\"\\\\\\\")\\n\\n# def longestDupSubstring(self, S):\\n# beg, end = 0, len(S)\\n# q = (1<<31) - 1 \\n# Found = \\\\\\\"\\\\\\\"\\n# while beg + 1 < end:\\n# mid = (beg + end)//2\\n# isFound, candidate = self.RabinKarp(S, mid, q)\\n# if isFound:\\n# beg, Found = mid, candidate\\n# else:\\n# end = mid\\n\\n# return Found\\n\",\n \"class Solution:\\n def search(self, S, mid) -> str:\\n n = len(S)\\n # convert string to array of integers to implement constant time slice\\n self.nums = [ord(S[i]) - ord('a') for i in range(n)]\\n # base value for the rolling hash function\\n base = 26\\n # mod value for the rolling hash function to avoid overflow\\n MOD = 2**32\\n \\n # compute the hash of string S[:L]\\n hash_ = 0\\n for i in range(mid):\\n hash_ = (hash_ * base + self.nums[i]) % MOD\\n \\n # already visited hashes of strings of length L\\n visited = {hash_}\\n # const value to be used often : a**L % mod\\n aL = pow(base, mid, MOD)\\n for start in range(1, n - mid + 1):\\n # compute rolling hash in O(1) time\\n hash_ = (hash_ * base - self.nums[start - 1] * aL + self.nums[start + mid - 1]) % MOD\\n if hash_ in visited:\\n return start\\n visited.add(hash_)\\n return -1\\n \\n def longestDupSubstring(self, S: str) -> str:\\n n = len(S)\\n # convert string to array of integers to implement constant time slice\\n self.nums = [ord(S[i]) - ord('a') for i in range(n)]\\n # base value for the rolling hash function\\n base = 26\\n # mod value for the rolling hash function to avoid overflow\\n MOD = 2**32\\n \\n # binary search, L = repeating string length\\n left, right = 1, n\\n while left <= right:\\n mid = left + (right - left) // 2\\n if self.search(S, mid) != -1:\\n left = mid + 1\\n else:\\n right = mid - 1\\n \\n start = self.search(S, left - 1)\\n return S[start: start + left - 1]\\n \\n \\n \\n \\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n def rk(m):\\n \\n nonlocal idx\\n mp = {}\\n p = b**(m-1)\\n p%=mod\\n \\n y = 0\\n for i in range(m):\\n y = y*b+num[i]\\n y%=mod \\n \\n mp[y] = 0\\n \\n for i in range(1, n-m+1):\\n y = ((y-num[i-1]*p%mod)*b%mod+num[i-1+m])%mod\\n #y = (y-num[i-1]*p)*b+num[i-1+m]\\n \\n if y in mp:\\n idx = i\\n return 0\\n else:\\n mp[y]=i\\n \\n return 1\\n \\n \\n\\n n = len(S)\\n b = 26 # no need to be 128\\n #mod = 10**9+7 # too small => conflict\\n mod = 2**32 # here\\n \\n z = ord('a')\\n num = [ ord(S[i])-z for i in range(n)]\\n \\n l=1\\n r=n\\n idx = 0 # last found duplicate \\n while l<r:\\n \\n m = (l+r)//2\\n \\n if rk(m)>0:\\n r = m\\n else:\\n l = m+1\\n \\n return S[idx:idx+l-1]\\n \\n \\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n def rk(m):\\n \\n mp = {}\\n\\n p = b**(m-1)\\n p%=mod\\n \\n y = 0\\n for i in range(m):\\n y = y*b+num[i]\\n y%=mod \\n \\n mp[y] = 0\\n \\n for i in range(1, n-m+1):\\n y = ((y-num[i-1]*p%mod)*b%mod+num[i-1+m])%mod\\n #y = (y-num[i-1]*p)*b+num[i-1+m]\\n \\n if y not in mp:\\n mp[y]=i\\n else:\\n return i\\n \\n return n\\n \\n \\n \\n \\n n = len(S)\\n \\n b = 26 # no need to be 128\\n \\n #mod = 10**9+7 # too small => conflict\\n mod = 2**32 # here\\n \\n num = []\\n for i in range(n):\\n num.append(ord(S[i])-ord('a'))\\n \\n l=1\\n r=n\\n \\n while l<r:\\n \\n m = (l+r)//2\\n \\n if rk(m)==n:\\n r = m\\n else:\\n l = m+1\\n \\n \\n x = l-1\\n \\n if x==0:\\n return ''\\n \\n k = rk(x)\\n \\n return S[k:k+x]\\n \\n \\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n def rk(m):\\n \\n nonlocal idx\\n st = set()\\n p = b**(m-1)\\n p%=mod\\n \\n y = 0\\n for i in range(m):\\n y = y*b+num[i]\\n \\n y%=mod\\n \\n st.add(y)\\n \\n for i in range(1, n-m+1):\\n y = ((y-num[i-1]*p%mod)*b%mod+num[i-1+m])%mod\\n #y = (y-num[i-1]*p)*b+num[i-1+m]\\n \\n if y in st:\\n idx = i\\n return 0\\n else:\\n st.add(y)\\n \\n return 1\\n \\n \\n\\n n = len(S)\\n b = 26 # no need to be 128\\n #mod = 10**9+7 # too small => conflict\\n mod = 2**32 # here\\n \\n z = ord('a')\\n num = [ ord(S[i])-z for i in range(n)]\\n \\n l=1\\n r=n\\n idx = 0 # last found duplicate \\n while l<r:\\n \\n m = (l+r)//2\\n \\n if rk(m)>0:\\n r = m\\n else:\\n l = m+1\\n \\n return S[idx:idx+l-1]\\n \\n \\n\",\n \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n \\n A = [ord(c) - ord('a') for c in S]\\n mod = 2**63 - 1\\n\\n def test(L):\\n # print(26, L, mod)\\n p = pow(26, L, mod)\\n cur = reduce(lambda x, y: (x * 26 + y) % mod, A[:L], 0)\\n seen = {cur}\\n for i in range(L, len(S)):\\n cur = (cur * 26 + A[i] - A[i - L] * p) % mod\\n if cur in seen: return i - L + 1\\n seen.add(cur)\\n res, lo, hi = 0, 0, len(S)\\n while lo < hi:\\n mi = (lo + hi + 1) // 2\\n pos = test(mi)\\n if pos:\\n lo = mi\\n res = pos\\n else:\\n hi = mi - 1\\n return S[res:res + lo]\\n \\n# s = [ord(num) - ord(\\\\\\\"a\\\\\\\") for num in S]\\n \\n# mod = 10 ** 9 + 7\\n# def check(l):\\n# cur = 0\\n# seen = set()\\n# maxBASE = pow(26, l-1, mod)\\n# for i in range(len(s)):\\n# if i < l:\\n# cur = (cur * 26 + s[i]) % mod\\n# else:\\n# cur -= maxBASE * s[i-l]\\n# cur = (cur * 26 + s[i]) % mod\\n# if i == l-1:\\n# seen.add(cur)\\n# elif i >= l:\\n# if cur in seen:\\n# return i-l+1\\n# else:\\n# seen.add(cur)\\n# return 0\\n \\n \\n \\n \\n# l = 1\\n# r = len(S) - 1\\n# res = -1\\n# while l < r:\\n# m = (l+r) // 2\\n# pos = check(m)\\n# if pos:\\n# l = m \\n# res = pos\\n# else:\\n# r = m - 1\\n# return S[res:res + l]\\n \\n \\n \\n\",\n \"class Solution:\\n def longestDupSubstring(self, S):\\n nums, N = [ord(c) - ord('a') for c in S], len(S)\\n BASE, MOD = 26, 2**32\\n def check(L):\\n cur_hash, seen = 0, set()\\n for val in nums[:L]:\\n cur_hash = (cur_hash * BASE + val) % MOD\\n seen.add(cur_hash)\\n X = pow(BASE, L-1, MOD)\\n for idx, val in enumerate(nums[L:]):\\n cur_hash -= nums[idx] * X\\n cur_hash = (cur_hash * BASE + val) % MOD\\n if cur_hash in seen:\\n return idx + 1\\n seen.add(cur_hash)\\n return -1\\n low, high = 1, N + 1\\n start = 0\\n while low < high:\\n mid = (low + high)//2\\n idx = check(mid)\\n if idx != -1:\\n low = mid + 1\\n start = idx\\n else:\\n high = mid\\n return S[start: start + low - 1]\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n self.s=S\\n self.n=len(S)\\n def find_len_k_dup(length):\\n hash_value = 0\\n mod_value = 7919*(2**30) # a big number should be okay, if you change the number it might cause a wrong answer\\n seen = set()\\n for i in range(length):\\n hash_value = (hash_value*26+ord(self.s[i])-ord('a'))%mod_value # get the hash value\\n seen.add(hash_value)\\n tmp = pow(26, length)%mod_value\\n for i in range(1,self.n-length+1):\\n # get the moving hash \\n hash_value = (hash_value*26 - (ord(self.s[i-1])-ord('a'))*tmp+mod_value+ord(self.s[i+length-1])-ord('a'))%mod_value\\n if hash_value in seen:\\n return i\\n else:\\n seen.add(hash_value)\\n return None\\n \\n \\n low=0\\n high=len(S)\\n res=''\\n while low<high:\\n \\n mid=(low+high)//2\\n idx=find_len_k_dup(mid)\\n #print(candidate)\\n if idx is not None:\\n res=S[idx:idx+mid]\\n low=mid+1\\n else:\\n high=mid\\n return res\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n lo = 1\\n hi = len(S)\\n nums = [ord(i) - ord('a') for i in S]\\n self.modulus = 2 ** 32\\n \\n def dup(l):\\n seen = set()\\n hval = 0\\n for i in range(l):\\n hval = (hval*26 + nums[i]) % self.modulus\\n seen.add(hval)\\n al = pow(26,l,self.modulus)\\n for i in range(1,len(S) - l+1):\\n hval = (hval*26 - nums[i-1]*al + nums[i+l-1]) % self.modulus\\n if hval in seen:\\n return i\\n seen.add(hval)\\n return -1\\n \\n start = -1\\n while lo <= hi:\\n mi = lo + (hi-lo)//2\\n begin = dup(mi)\\n if begin != -1:\\n lo = mi + 1\\n start = begin\\n else:\\n hi = mi - 1\\n \\n return S[start: start + lo - 1]\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n N = len(S)\\n l, r = 1, N\\n nums = [ord(x) - ord('a') for x in S]\\n KMAX = 2 ** 63 - 1\\n def check(m):\\n MAXL = pow(26, m, KMAX)\\n total = 0\\n hashset = set()\\n for i in range(m):\\n total = (total * 26 + nums[i]) % KMAX\\n hashset.add(total)\\n for i in range(1, N - m + 1):\\n total = (total * 26 - MAXL * nums[i-1] + nums[i + m - 1]) % KMAX\\n if total in hashset:\\n return i\\n hashset.add(total)\\n return -1 \\n \\n while l < r:\\n m = (l + r) // 2\\n if check(m) < 0:\\n r = m\\n else:\\n l = m + 1\\n idx = check(r - 1) \\n return S[idx: idx + r-1]\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n self.s=S\\n self.n=len(S)\\n def find_len_k_dup(length):\\n hash_value = 0\\n mod_value = 8000*(2**30) # a big number should be okay, if you change the number it might cause a wrong answer\\n seen = set()\\n for i in range(length):\\n hash_value = (hash_value*26+ord(self.s[i])-ord('a'))%mod_value # get the hash value\\n seen.add(hash_value)\\n tmp = pow(26, length)%mod_value\\n for i in range(1,self.n-length+1):\\n # get the moving hash \\n hash_value = ((hash_value*26 - (ord(self.s[i-1])-ord('a'))*tmp)%mod_value+ord(self.s[i+length-1])-ord('a'))%mod_value\\n if hash_value in seen:\\n return i\\n else:\\n seen.add(hash_value)\\n return None\\n \\n \\n low=0\\n high=len(S)\\n res=''\\n while low<high:\\n \\n mid=(low+high)//2\\n idx=find_len_k_dup(mid)\\n #print(candidate)\\n if idx is not None:\\n res=S[idx:idx+mid]\\n low=mid+1\\n else:\\n high=mid\\n return res\",\n \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n A = [ord(c) - ord('a') for c in S]\\n mod = 2**63 - 1\\n\\n def test(L):\\n p = pow(26, L, mod)\\n cur = reduce(lambda x, y: (x * 26 + y) % mod, A[:L], 0)\\n seen = {cur}\\n for i in range(L, len(S)):\\n cur = (cur * 26 + A[i] - A[i - L] * p) % mod\\n if cur in seen: return i - L + 1\\n seen.add(cur)\\n res, lo, hi = 0, 0, len(S)\\n while lo + 1 < hi:\\n mi = (lo + hi) // 2\\n pos = test(mi)\\n if pos:\\n lo = mi\\n else:\\n hi = mi\\n \\n if test(hi):\\n res = test(hi)\\n return S[res: res + hi]\\n elif test(lo):\\n res = test(lo)\\n return S[res: res + lo]\\n # return ''\\n\",\n \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S):\\n def evaluateLength(length):\\n power = pow(26, length, mod)\\n current = reduce(lambda x, y: (x*26 + y) % mod, ids[:length], 0)\\n explored = {current}\\n for index in range(length, len(S)):\\n current = (current * 26 + ids[index] - ids[index - length] * power) % mod\\n if current in explored:\\n return index - length + 1\\n explored.add(current)\\n \\n ids = [ord(character) - ord('a') for character in S]\\n mod = 2**63 - 1\\n index, low, high = 0, 0, len(S)\\n while low < high:\\n mid = (high + low + 1) // 2\\n position = evaluateLength(mid)\\n if position:\\n index = position\\n low = mid\\n else:\\n high = mid - 1 \\n return S[index:(index+low)]\\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n N = len(S)\\n l, r = 1, N\\n nums = [ord(x) - ord('a') for x in S]\\n KMAX = 2 ** 63 - 1\\n def check(m):\\n MAXL = pow(26, m, KMAX)\\n total, hashset = 0, set()\\n for i in range(m):\\n total = (total * 26 + nums[i]) % KMAX\\n hashset.add(total)\\n for i in range(1, N - m + 1):\\n total = (total * 26 - MAXL * nums[i-1] + nums[i+m-1]) % KMAX\\n if total in hashset:\\n return i\\n hashset.add(total)\\n return -1\\n \\n while l < r:\\n m = (l + r) // 2\\n if check(m) < 0:\\n r = m\\n else:\\n l = m + 1\\n idx = check(r - 1) \\n return S[idx: idx + r-1]\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n def check(s, L):\\n n = len(s)\\n BASE = 26\\n MOD = 1 << 61 - 1\\n P = pow(26, L, MOD)\\n cur = 0\\n seen = defaultdict(list)\\n \\n for i in range(len(s)):\\n cur = (cur*BASE + ord(s[i]) - ord('a')) % MOD\\n if i >= L:\\n cur = (cur - (ord(s[i-L]) - ord('a')) * P) % MOD\\n \\n if i >= L - 1:\\n if cur in seen:\\n cur_str = s[i-L+1:i+1]\\n for j in seen[cur]:\\n pre_str = s[j-L+1:j+1]\\n if cur_str == pre_str:\\n return cur_str\\n seen[cur].append(i) \\n return ''\\n \\n \\n lo, hi = 1, len(S)\\n ans = ''\\n while lo < hi:\\n mid = (lo + hi) // 2\\n temp = check(S, mid)\\n if temp:\\n ans = temp\\n lo = mid + 1\\n else:\\n hi = mid\\n\\n return ans\\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n p = 239017\\n pows = [[1], [1]]\\n hsh = [[0], [0]]\\n mods = [int(1e9) + 7, int(1e9) + 9]\\n for ch in S:\\n for i in range(len(mods)):\\n hsh[i].append((hsh[i][-1] + ord(ch) * pows[i][-1]) % mods[i])\\n pows[i].append((pows[i][-1] * p) % mods[i]) \\n l = 0\\n r = len(S)\\n substrs = {}\\n ans = ''\\n while r - l > 1:\\n m = (r + l) // 2\\n found = False\\n for i in range(0, len(S) - m + 1):\\n h0 = ((hsh[0][i + m] - hsh[0][i]) * pows[0][-(i + 1)]) % mods[0]\\n h1 = ((hsh[1][i + m] - hsh[1][i]) * pows[1][-(i + 1)]) % mods[1]\\n if (h0, h1) in substrs:\\n found = True\\n ans = S[i: i + m]\\n break\\n else:\\n substrs[(h0, h1)] = True\\n if found:\\n l = m\\n else:\\n r = m\\n substrs.clear()\\n return ans\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n mod = 2 ** 31 - 1\\n base = 26\\n \\n def get_ord(char: str):\\n return ord(char) - ord('a')\\n \\n def find_duplicate(length) -> str:\\n hashes = {}\\n h = 1\\n for i in range(length - 1):\\n h = (h * base) % mod\\n\\n cur = 0\\n for i in range(length):\\n cur = (cur * base + get_ord(S[i])) % mod\\n \\n hashes[cur] = [0]\\n\\n for i in range(1, len(S) - length + 1):\\n cur = ((cur - (get_ord(S[i-1]) * h)) * base + get_ord(S[i + length - 1])) % mod\\n if cur in hashes:\\n for idx in hashes[cur]:\\n if S[idx: idx + length] == S[i: i + length]:\\n return S[i: i + length]\\n hashes[cur].append(i)\\n else:\\n hashes[cur] = [i]\\n return ''\\n \\n \\n def helper(start, end):\\n res = ''\\n while start < end:\\n length = (start + end) // 2 + 1\\n r = find_duplicate(length)\\n if len(r) > len(res):\\n res = r\\n if not r:\\n end = length - 1\\n else:\\n start = length\\n return res\\n\\n return helper(0, len(S) - 1)\",\n \"class Solution:\\n def findRepSubstrGivenLength(self, nums: List[int], l:int, base:int, modulus:int) -> int:\\n \\n n = len(nums)\\n \\n h = 0\\n for i in range(l):\\n h = (h * base + nums[i]) % modulus\\n \\n seen = {h}\\n \\n for start in range(1, n-l+1):\\n h = (h * base - nums[start - 1] * pow(base, l, modulus) + nums[start + l - 1]) % modulus\\n \\n if h in seen:\\n return start\\n \\n seen.add(h)\\n \\n return -1 \\n \\n \\n def longestDupSubstring(self, S: str) -> str:\\n if not S:\\n return ''\\n \\n nums = [ord(S[i]) - ord('a') for i in range(len(S))]\\n \\n base = 26\\n modulus = 2**32\\n \\n left = 1\\n right = len(S)\\n \\n while left <= right:\\n mid = left + (right - left) // 2\\n \\n if self.findRepSubstrGivenLength(nums, mid, base, modulus) != -1:\\n left = mid + 1\\n else:\\n right = mid -1\\n \\n start = self.findRepSubstrGivenLength(nums, left-1, base, modulus)\\n \\n return S[start: start + left -1] \\n \\n \\n \\n'''\\nclass Solution:\\n class Node:\\n def __init__(self, v='*'): \\n self.value = v\\n self.next = dict()\\n self.occurences = set()\\n \\n \\n def print_tree(self, node, indentation):\\n print(indentation + str(node.value) + \\\\\\\": \\\\\\\" + str(node.occurences))\\n\\n for v in node.next.keys():\\n self.print_tree(node.next[v], indentation + '\\\\\\\\t')\\n \\n \\n def getNode(self, node, v):\\n if v not in node.next.keys():\\n node.next[v] = self.Node(v)\\n\\n return node.next[v]\\n\\n\\n def AddOccurences(self, node, i, S):\\n node.occurences.add(i)\\n\\n if len(node.occurences) == 2:\\n for o in node.occurences:\\n if o + 1 < len(S):\\n self.AddOccurences(self.getNode(node, S[o+1]), o+1, S)\\n\\n\\n if len(node.occurences)>2:\\n if i + 1 < len(S):\\n self.AddOccurences(self.getNode(node, S[i+1]), i+1, S)\\n\\n \\n def getLongestDuplicate(self, node):\\n maxSubstring = ''\\n \\n for v in node.next.keys():\\n if len(node.next[v].occurences)>1:\\n\\n childSubstring = self.getLongestDuplicate(node.next[v])\\n if len(childSubstring) + 1 > len(maxSubstring):\\n maxSubstring = v + childSubstring\\n \\n return maxSubstring\\n \\n \\n def longestDupSubstring(self, S: str) -> str:\\n if not S:\\n return 0\\n \\n if len(set(S)) == 1:\\n return S[0:len(S)-1]\\n\\n root = self.Node()\\n\\n for i in range(len(S)):\\n self.AddOccurences(self.getNode(root, S[i]), i, S)\\n\\n #self.print_tree(root, '')\\n maxDepthDuplicates = self.getLongestDuplicate(root)\\n \\n return maxDepthDuplicates\\n''' \",\n \"class Solution:\\n def longestDupSubstring(self, S):\\n nums = [ord(c) - ord('a') for c in S]\\n #BASE, MOD = 113, 1000000007\\n BASE, MOD = 26, 2**32\\n def check(L):\\n cur_hash, seen = 0, set()\\n for val in nums[:L]:\\n cur_hash = ((cur_hash * BASE) + val) % MOD\\n seen.add(cur_hash)\\n X = pow(BASE, L-1, MOD) # (BASE ** (L-1)) % MOD\\n for i, val in enumerate(nums[L:]):\\n # cur_hash -= nums[i] * (BASE ** (L-1))\\n cur_hash -= nums[i] * X\\n cur_hash = ((cur_hash * BASE) + val) % MOD\\n if cur_hash in seen:\\n return i + 1\\n seen.add(cur_hash)\\n return -1\\n low, high = 1, len(S)\\n res = 0\\n while low < high:\\n mid = (low + high)//2\\n idx = check(mid)\\n if idx != -1:\\n low = mid + 1\\n res = idx\\n else:\\n high = mid\\n return S[res: res + low-1]\\n \\n #while low <= high:\\n # mid = (low + high)//2\\n # idx = check(mid)\\n # if idx != -1:\\n # low = mid + 1\\n # res = idx\\n # else:\\n # high = mid - 1\\n #return S[res: res + low-1]\\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n def check(Val):\\n base, modulus = 26, 2**32\\n AL = base**Val%modulus\\n hk = 0\\n for i in range(Val):\\n hk = hk*base + ord(S[i])-ord('a')\\n hk %= modulus\\n hm = {hk: 0}\\n \\n for i in range(Val, N):\\n hk = hk*base - (ord(S[i-Val])-ord('a'))*AL + ord(S[i]) - ord('a')\\n hk %= modulus\\n if hk in hm and S[hm[hk]:hm[hk]+Val]==S[i-Val+1:i+1]:\\n return i-Val+1\\n \\n hm[hk] = i-Val+1\\n # print(mid, hm)\\n \\n N = len(S)\\n start, end = 1, N\\n res = 0\\n while start<=end:\\n mid = start+(end-start)//2\\n pos = check(mid)\\n if pos:\\n res = pos\\n start = mid+1\\n else:\\n end = mid-1\\n \\n return S[res:res+end]\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n n = len(S)\\n BASE = 26\\n MOD = (1 << 63) - 1\\n POWS = [1] * n\\n for i in range(1, n):\\n POWS[i] = (POWS[i - 1] * BASE) % MOD\\n def search(k):\\n seen = set()\\n h = 0\\n for i in range(k):\\n h = (h * BASE + ord(S[i]) - 97) % MOD\\n seen.add(h)\\n for i in range(k, n):\\n h = ((h - (ord(S[i - k]) - 97) * POWS[k - 1]) * BASE + ord(S[i]) - 97) % MOD\\n s = S[i - k + 1:i + 1]\\n if h in seen:\\n return i\\n seen.add(h)\\n return -1\\n \\n l, r = 0, n - 1\\n while l <= r:\\n m = (l + r) // 2\\n if search(m) >= 0:\\n l = m + 1\\n else:\\n r = m - 1\\n if r < 0:\\n return ''\\n i = search(r)\\n return S[i - r + 1:i + 1]\",\n \"class Solution:\\n def search(self, L: int, a: int, modulus: int, n: int, nums: List[int]) -> str:\\n h = 0\\n for i in range(L):\\n h = (h * a + nums[i]) % modulus\\n \\n seen = {h}\\n \\n aL = pow(a, L, modulus)\\n \\n for start in range(1, n-L + 1):\\n h = (h * a - nums[start - 1]* aL + nums[start + L - 1]) % modulus\\n if h in seen:\\n return start\\n seen.add(h)\\n return -1\\n \\n def longestDupSubstring(self, S: str) -> str:\\n n = len(S)\\n nums = [ord(S[i]) - ord('a') for i in range(n)]\\n a = 26\\n modulus = 2 ** 32\\n left, right = 1, n\\n while left <= right:\\n L = left + (right - left) // 2\\n if self.search(L, a, modulus, n, nums) != -1:\\n left = L + 1\\n else:\\n right = L - 1\\n start = self.search(left -1, a, modulus, n, nums)\\n return S[start: start + left - 1]\\n\",\n \"from collections import defaultdict\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n l, h = 2, len(S)-1\\n res = ''\\n while l <= h:\\n m = l + (h-l) // 2\\n cand = self.find_dup_substr_len_k(S, m)\\n if cand:\\n res = cand\\n l = m+1\\n else:\\n h = m-1\\n return res\\n \\n def find_dup_substr_len_k(self, s, k):\\n MOD = (1 << 63) - 1\\n BASE = 26\\n D = pow(BASE, k-1, MOD)\\n hash_val = 0\\n seen = defaultdict(set)\\n \\n for i in range(len(s)):\\n # update the sliding hash value\\n if i >= k:\\n char_offset = ord(s[i-k]) - ord('a') \\n hash_val = (hash_val - char_offset * D) % MOD\\n char_offset = ord(s[i]) - ord('a') \\n hash_val = (hash_val * BASE + char_offset) % MOD\\n \\n # check hash collision and return string if duplicate found\\n if i >= k-1:\\n if hash_val in seen:\\n cand_i = s[i-k+1:i+1]\\n for j in seen[hash_val]:\\n cand_j = s[j-k+1:j+1]\\n if cand_i == cand_j:\\n return cand_i\\n seen[hash_val].add(i)\\n return ''\\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n def code(t):\\n return ord(t) - ord('a')+1\\n def check(length):\\n seen = collections.defaultdict(list)\\n \\n MOD = 10 ** 9 + 7\\n P = 113\\n INV_P = pow(P, MOD-2, MOD)\\n\\n h = 0\\n power = 1\\n '''\\n h1 = s[0]p^0+s[1]p^1+s[2]p^2 +...+s[length-1]p^(length-1)\\n move next:\\n h2 = s[1]p^0+s[2]p^1+s[3]p^2 +...+s[length]p^(length-1)\\n \\n h2 = (h1 - S[i-length+1])*INV_P % MOD\\n \\n '''\\n for i, x in enumerate(S):\\n h = (h + power*code(x)) % MOD \\n if i < length-1:\\n power = power * P % MOD\\n else:\\n # start: i-(length-1)\\n if h in seen:\\n for j in seen[h]:\\n if S[i-(length-1):i+1] == S[j:j+length]:\\n return S[j:j+length], True\\n seen[h].append(i-(length-1))\\n h = (h-code(S[i-(length-1)]))*INV_P % MOD\\n \\n return '', False\\n \\n res = ''\\n l, r = 1, len(S)-1\\n while l <= r:\\n mid = (l+r)//2\\n sub, is_check = check(mid)\\n if is_check:\\n res = sub\\n l = mid + 1\\n else:\\n r = mid - 1\\n \\n return res\",\n \"class Solution:\\n \\n def find(self ,s , m) :\\n \\n seen = collections.defaultdict(list)\\n \\n mod = 1<<63 -1\\n base = 26\\n d = pow(26,m-1,mod)\\n chal = 0\\n \\n for i in range(len(s)) :\\n \\n if i >= m :\\n l_chal = ord(s[i-m]) - ord('a')\\n chal = ( chal - l_chal*d)%mod\\n \\n l_chal = ord(s[i]) - ord('a')\\n chal = (chal*base + l_chal)%mod\\n \\n if i >= m-1 :\\n s_i = s[i-m+1 : i +1]\\n if chal in seen :\\n \\n for j in seen[chal] :\\n s_j = s[j-m+1 : j+1]\\n if s_j == s_i :\\n return s_i\\n \\n else :\\n seen[chal].append(i)\\n \\n return ''\\n \\n def longestDupSubstring(self, S: str) -> str:\\n \\n l = 2 \\n h = len(S) -1\\n ans = ''\\n \\n while l <= h :\\n m = (l+h)//2\\n \\n s = self.find(S ,m)\\n \\n if s != '' :\\n ans = s\\n l = m+1\\n \\n else :\\n h = m-1\\n \\n return ans\",\n \"class Solution:\\n def longestDupSubstring(self, S):\\n nums, N = [ord(c) - ord('a') for c in S], len(S)\\n BASE, MOD = 26, 2**32\\n def check(L):\\n cur_hash, seen = 0, set()\\n for val in nums[:L]:\\n cur_hash = (cur_hash * BASE + val) % MOD\\n seen.add(cur_hash)\\n X = pow(BASE, L-1, MOD)\\n for idx, val in enumerate(nums[L:], start = L):\\n cur_hash -= nums[idx - L] * X\\n cur_hash = (cur_hash * BASE + val) % MOD\\n if cur_hash in seen:\\n return idx - L + 1\\n seen.add(cur_hash)\\n return -1\\n low, high = 1, N + 1\\n start = 0\\n while low < high:\\n mid = (low + high)//2\\n idx = check(mid)\\n if idx != -1:\\n low = mid + 1\\n start = idx\\n else:\\n high = mid\\n return S[start: start + low - 1]\",\n \"from collections import defaultdict\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n mod = 10 ** 9 + 7\\n def get_rep(l: int) -> str:\\n mp = defaultdict(list) # key: hash_code, value: list of start indexes of substrings\\n a = 13\\n sofar = 0\\n factor = 1\\n for i in range(l):\\n sofar = (sofar * a + ord(S[i])) % mod\\n factor = (factor * a) % mod\\n mp[sofar].append(0)\\n for i in range(l, len(S)):\\n sofar = (sofar * a + ord(S[i]) - factor * ord(S[i - l])) % mod\\n if sofar in mp:\\n for j in mp[sofar]:\\n if S[j: j + l] == S[i - l + 1: i + 1]:\\n return S[i - l + 1: i + 1]\\n mp[sofar].append(i - l + 1)\\n return None\\n \\n low, high = 0, len(S) - 1\\n ans = None\\n while low <= high:\\n mid = (low + high) // 2\\n res = get_rep(mid)\\n if res is None:\\n high = mid - 1\\n else:\\n ans = res\\n low = mid + 1\\n return ans if ans is not None else ''\\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n def search(m, MOD):\\n h = 0\\n for i in range(m):\\n h = (h * 26 + nums[i]) % MOD\\n s = {h}\\n aL = pow(26, m, MOD)\\n for pos in range(1, n - m + 1):\\n h = (h * 26 - nums[pos - 1] * aL + nums[pos + m - 1]) % MOD\\n if h in s:\\n return pos\\n s.add(h)\\n return -1\\n\\n n = len(S)\\n nums = [ord(c) - ord('a') for c in S]\\n l, r = 1, n\\n pos = -1\\n MOD = 2**63 - 1\\n while l <= r:\\n m = (l + r) // 2\\n cur = search(m, MOD)\\n if cur != -1:\\n l = m + 1\\n pos = cur\\n else:\\n r = m - 1\\n return S[pos: pos + l - 1] \",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n base, mod = 26, 2**63 - 1\\n n = len(S)\\n A = [ord(ch) - ord('a') for ch in S]\\n def k_dup(k):\\n curr = 0\\n for i in range(k):\\n curr = (curr * base + A[i]) % mod\\n seen = {curr}\\n for i in range(1, n - k + 1):\\n curr = ( base*curr - pow(base, k, mod)*A[i-1] + A[i+k-1]) % mod\\n if curr in seen:\\n return i\\n seen.add(curr)\\n return 0\\n l, r, ans = 0, n, 0\\n while l < r:\\n mid = (l + r + 1) >> 1\\n pos = k_dup(mid)\\n # print(pos, mid)\\n if pos:\\n l = mid\\n ans = pos\\n else:\\n r = mid - 1\\n return S[ans:ans + l]\\n \\n\",\n \"class Solution:\\n def longestDupSubstring(self, S):\\n nums = [ord(c) - ord('a') for c in S]\\n BASE, MOD = 26, 2**32 # Wrong: BASE, MOD = 113, 1000000007, too small\\n def check(L):\\n cur_hash, seen = 0, set()\\n for val in nums[:L]:\\n cur_hash = ((cur_hash * BASE) + val) % MOD\\n seen.add(cur_hash)\\n X = pow(BASE, L-1, MOD) # much faster than (BASE ** (L-1)) % MOD\\n for i, val in enumerate(nums[L:]):\\n # cur_hash -= nums[i] * (BASE ** (L-1))\\n cur_hash -= nums[i] * X\\n cur_hash = ((cur_hash * BASE) + val) % MOD\\n if cur_hash in seen:\\n return i + 1\\n seen.add(cur_hash)\\n return -1\\n low, high = 1, len(S) + 1\\n res = 0\\n while low < high:\\n mid = (low + high)//2\\n idx = check(mid)\\n if idx != -1:\\n low = mid + 1\\n res = idx\\n else:\\n high = mid\\n return S[res: res + low-1]\\n \\nclass Solution:\\n def longestDupSubstring(self, S):\\n N = len(S)\\n def check(length):\\n seen = set()\\n for i in range(N - length):\\n hashS = hash(S[i:i+length+1])\\n if hashS in seen:\\n return i\\n seen.add(hashS)\\n return 0\\n\\n low, high = 0, N\\n idx = 0\\n while low < high:\\n mid = (low + high)//2\\n start = check(mid)\\n if start:\\n low = mid + 1\\n idx = start\\n else:\\n high = mid\\n return S[idx:idx + low]\",\n \"class Solution:\\n def search(self, L: int, base: int, MOD: int, n: int, nums: List[int]) -> str:\\n # compute the hash of string S[:L]\\n h = 0\\n for i in range(L):\\n h = (h * base + nums[i]) % MOD\\n \\n # already seen hashes of strings of length L\\n seen = {h} \\n # const value to be used often : a**L % mod\\n aL = pow(base, L, MOD) \\n for start in range(1, n - L + 1):\\n # compute rolling hash in O(1) time\\n h = (h * base - nums[start - 1] * aL + nums[start + L - 1]) % MOD\\n if h in seen:\\n return start\\n seen.add(h)\\n return -1\\n \\n def longestDupSubstring(self, S: str) -> str:\\n n = len(S)\\n # convert string to array of integers to implement constant time slice\\n nums = [ord(S[i]) - ord('a') for i in range(n)]\\n # base value for the rolling hash function\\n base = 26\\n # mod value for the rolling hash function to avoid overflow\\n MOD = 2**32\\n \\n # binary search, L = repeating string length\\n left, right = 1, n\\n while left <= right:\\n mid = left + (right - left) // 2\\n if self.search(mid, base, MOD, n, nums) != -1:\\n left = mid + 1\\n else:\\n right = mid - 1\\n \\n start = self.search(left - 1, base, MOD, n, nums)\\n return S[start: start + left - 1]\\n \\n \\n \\n \\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n n = len(S)\\n low = 0\\n high = n-1\\n \\n nums = [ord(S[i]) - ord('a') for i in range(n)]\\n \\n def findDuplicate(L):\\n # compute the hash of string S[:L]\\n h = 0\\n a = 26\\n modulus = 2**32\\n for i in range(L):\\n h = (h * a + nums[i]) % modulus\\n\\n # already seen hashes of strings of length L\\n seen = {h}\\n # const value to be used often : a**L % modulus\\n aL = pow(a, L, modulus) \\n for start in range(1, n - L + 1):\\n # compute rolling hash in O(1) time\\n h = (h * a - nums[start - 1] * aL + nums[start + L - 1]) % modulus\\n if h in seen:\\n return start\\n seen.add(h)\\n return -1\\n \\n res = ''\\n while low < high:\\n mid = (low + high + 1)//2\\n start = findDuplicate(mid)\\n if start != -1:\\n low = mid\\n res = S[start:start+mid] \\n else:\\n high = mid-1\\n return res\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n l = 0\\n r = len(S)\\n base = 26\\n mod = 2**32\\n res = [0, 0]\\n nums = [ord(n) - ord('a') for n in S]\\n\\n \\n while l < r:\\n \\n mid = (l+r) // 2\\n h = 0\\n \\n for i in range(0, mid):\\n h = (h*base + nums[i]) % mod\\n \\n dups = set([h])\\n remove = pow(base, mid, mod)\\n \\n for i in range(1, len(nums) - mid + 1):\\n h = (h*base - nums[i-1] * remove + nums[i+mid-1]) % mod\\n \\n if h in dups:\\n res = [i, i+mid]\\n break\\n \\n dups.add(h)\\n # print(mid, h) \\n if res[1] - res[0] < mid:\\n r = mid\\n else:\\n l = mid + 1\\n \\n \\n return S[res[0]:res[1]]\\n \\n \\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n low = 0\\n high = len(S)-1\\n result = ''\\n nums = [ord(i) - ord('a') for i in S]\\n mod = 2**63-1\\n \\n def rabin_karp(size):\\n power = pow(26,size,mod)\\n hash_val = 0\\n hash_set = set()\\n for i in range(size):\\n hash_val = (hash_val*26 + (nums[i]))%mod\\n hash_set.add(hash_val)\\n for i in range(size, len(S)):\\n hash_val = (hash_val*26 - (power*nums[i-size]) + nums[i])%mod\\n if hash_val in hash_set:\\n return i-size+1\\n else:\\n hash_set.add(hash_val)\\n return -1\\n while(low <= high):\\n mid = low + (high-low)//2\\n pos = rabin_karp(mid)\\n if pos == -1:\\n high = mid - 1\\n else:\\n result = S[pos:pos+mid]\\n low = mid+1\\n return result\",\n \"class Solution:\\n def longestDupSubstring(self, S):\\n nums = [ord(c) - ord('a') for c in S]\\n BASE, MOD = 26, 2**32 # Wrong: BASE, MOD = 113, 1000000007, too small\\n def check(L):\\n cur_hash, seen = 0, set()\\n for val in nums[:L]:\\n cur_hash = ((cur_hash * BASE) + val) % MOD\\n seen.add(cur_hash)\\n X = pow(BASE, L-1, MOD) # much faster than (BASE ** (L-1)) % MOD\\n for i, val in enumerate(nums[L:]):\\n # cur_hash -= nums[i] * (BASE ** (L-1))\\n cur_hash -= nums[i] * X\\n cur_hash = ((cur_hash * BASE) + val) % MOD\\n if cur_hash in seen:\\n return i + 1\\n seen.add(cur_hash)\\n return -1\\n low, high = 1, len(S) + 1\\n res = 0\\n while low < high:\\n mid = (low + high)//2\\n idx = check(mid)\\n if idx != -1:\\n low = mid + 1\\n res = idx\\n else:\\n high = mid\\n return S[res: res + low-1]\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n n=len(S)\\n modulus=2**32\\n a=26 \\n nums=[ord(c)-ord('a') for c in S]\\n def search(L):\\n nonlocal a,n,modulus\\n aL=pow(a,L,modulus)\\n h=0\\n for i in range(L):\\n h=(h*a+nums[i])%modulus\\n seen={h}\\n for start in range(1,n-L+1):\\n h=(h*a-nums[start-1]*aL+nums[start+L-1])%modulus\\n if h in seen:\\n return start\\n seen.add(h)\\n return -1\\n \\n l,r=1,n\\n while l<=r:\\n mid=(l+r)>>1\\n if search(mid)!=-1:\\n l=mid+1\\n else:\\n r=mid-1\\n \\n start=search(r) \\n return S[start:start+r]\",\n \"class Solution:\\n \\n def rabinKarp(self, L, nums):\\n h = 0\\n a = 26\\n MOD = 2**32\\n for i in range(L):\\n h = (h * a + nums[i]) % MOD\\n \\n aL = pow(a, L, MOD)\\n seen = {h}\\n for start in range(1, len(nums)-L+1):\\n h = (h *a - nums[start-1] * aL + nums[start+L-1]) % MOD\\n if h in seen:\\n return start\\n seen.add(h)\\n return -1\\n \\n def longestDupSubstring(self, S: str) -> str: \\n nums = [ord(ch)-ord('a') for ch in S]\\n l, r = 0, len(S)\\n while l < r:\\n mid = l + (r-l) // 2\\n if self.rabinKarp(mid, nums) != -1:\\n l = mid + 1\\n else:\\n r = mid\\n start = self.rabinKarp(l-1, nums)\\n return S[start:start+l-1] \\n \\n\",\n \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n # binary search + string hashing\\n from functools import reduce\\n A = [ord(c) - ord('a') for c in S]\\n mod = 2 ** 63 - 1\\n def judge(l):\\n p = 26 ** l % mod\\n cur = reduce(lambda x, y : (x * 26 + y) % mod, A[:l], 0)\\n seen = {cur}\\n for i in range(l, len(S)):\\n cur = (cur * 26 + A[i] - p * A[i - l]) % mod\\n if cur in seen: return i - l + 1\\n seen.add(cur)\\n \\n lo, hi = 0, len(S)\\n res = 0\\n while lo < hi:\\n mi = (lo + hi + 1) // 2\\n pos = judge(mi)\\n if pos:\\n lo = mi\\n res = pos\\n else:\\n hi = mi - 1\\n return S[res : res + lo]\\n\",\n \"class Solution:\\n # Use binary search to try out all possible lengths of the subtrings\\n # Use a record list to record the hash summation of the substring\\n # Use the number of distinct chara as the hash base\\n # If two substrings are the same, they should have the same hash summation\\n # After minus the before part\\n def longestDupSubstring(self, S: str) -> str:\\n res = ''\\n d,q = len(set(S)), 2**63-1\\n record = [0]*len(S)\\n for i in range(len(S)):\\n if i == 0:record[i] = ord(S[i])\\n else:record[i] = (record[i-1]*d+ord(S[i]))%q\\n def check(mid):\\n h,g = 1,set()\\n for i in range(mid):\\n h = h*d%q\\n for i in range(len(S)-mid+1):\\n count = (record[i+mid-1]-record[i-1]*h)%q if i > 0 else record[i+mid-1]\\n if count not in g:g.add(count)\\n else:return S[i:i+mid]\\n return False\\n l,r = 0,len(S)-1\\n while l<=r:\\n mid = (l+r)//2\\n temp = check(mid)\\n if temp:\\n res = temp\\n l = mid + 1\\n else:r = mid - 1\\n return res\\n \\n \\n# res = \\\\\\\"\\\\\\\"\\n# d, q = len(set(S)), 2**63-1\\n# hashes = [0] * len(S)\\n# for i in range(len(S)):\\n# if i == 0: hashes[i] = ord(S[i])\\n# else: hashes[i] = (hashes[i-1]*d + ord(S[i]))%q\\n# l, r = 0, len(S)-1\\n# while l <= r:\\n# mid = (l+r)//2\\n# temp = self.check(S,mid,hashes,d,q)\\n# if temp:\\n# res = temp\\n# l = mid + 1\\n# else: r = mid - 1\\n# return res\\n \\n# def check(self, S, mid, hashes, d, q):\\n# res = set()\\n# h, g = 1, 0\\n# for i in range(mid):\\n# h = (h*d)%q\\n# for i in range(len(S)-mid+1):\\n# g = (hashes[i+mid-1] - hashes[i-1]*h)%q if i > 0 else hashes[i+mid-1]\\n# if g not in res: res.add(g)\\n# else: return S[i:i+mid]\\n# return False\\n \\n \\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n def rk(m):\\n \\n nonlocal idx\\n st = set()\\n \\n #p = b**(m-1)\\n #p%=mod\\n p= pow(b,m-1,mod) # more efficient to mod at each step than work on a long number\\n \\n y = 0\\n for i in range(m):\\n y = (y*b+num[i])%mod # more efficient to mod at each step than work on a long number\\n \\n st.add(y)\\n \\n for i in range(1, n-m+1):\\n y = ((y-num[i-1]*p%mod)*b%mod+num[i-1+m])%mod\\n #y = (y-num[i-1]*p)*b+num[i-1+m]\\n \\n if y in st:\\n idx = i\\n return 0\\n else:\\n st.add(y)\\n \\n return 1\\n \\n \\n\\n n = len(S)\\n b = 26 # no need to be 128\\n #mod = 10**9+7 # too small => conflict\\n mod = 2**32 # here\\n \\n z = ord('a')\\n num = [ ord(S[i])-z for i in range(n)]\\n \\n l=1\\n r=n\\n idx = 0 # last found duplicate \\n while l<r:\\n \\n m = (l+r)//2\\n \\n if rk(m)>0:\\n r = m\\n else:\\n l = m+1\\n \\n return S[idx:idx+l-1]\\n \\n \\n\",\n \"p = 2**63 - 1\\n\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n def rabin_karp(mid):\\n cur_hash = 0\\n for i in range(mid):\\n cur_hash = (cur_hash * 26 + nums[i]) % p\\n hashes = {cur_hash}\\n pos = -1\\n max_pow = pow(26, mid, p)\\n for i in range(mid, len(S)):\\n cur_hash = (26*cur_hash-nums[i-mid]*max_pow + nums[i]) % p\\n if cur_hash in hashes:\\n pos = i + 1 - mid\\n hashes.add(cur_hash)\\n return pos\\n\\n\\n low, high = 0, len(S)-1\\n end = 0\\n start = 0\\n nums = [ord(c)-ord('a') for c in S]\\n while low <= high:\\n mid = (low+high) // 2\\n pos = rabin_karp(mid)\\n if pos == -1: # no matching strings found\\n high = mid - 1\\n else:\\n start = pos\\n low = mid + 1\\n return S[start:start+low-1]\\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n def search(m, MOD):\\n h = 0\\n for i in range(m):\\n h = (h * 26 + nums[i]) % MOD\\n s = {h}\\n aL = pow(26, m, MOD)\\n for pos in range(1, n - m + 1):\\n h = (h * 26 - nums[pos - 1] * aL + nums[pos + m - 1]) % MOD\\n if h in s:\\n return pos\\n s.add(h)\\n return -1\\n\\n n = len(S)\\n nums = [ord(c) - ord('a') for c in S]\\n l, r = 1, n\\n pos = -1\\n MOD = 2**63 - 1\\n while l <= r:\\n m = (l + r) // 2\\n cur = search(m, MOD)\\n if cur != -1:\\n l = m + 1\\n pos = cur\\n else:\\n r = m - 1\\n return S[pos: pos + l - 1]\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n N = len(S)\\n l, r = 1, N\\n nums = [ord(x) - ord('a') for x in S]\\n KMAX = 2 ** 63 - 1\\n def check(m):\\n MAXL = pow(26, m, KMAX)\\n total = 0\\n hashset = set()\\n for i in range(m):\\n total = (total * 26 + nums[i]) % KMAX\\n hashset.add(total)\\n for i in range(1, N - m + 1):\\n total = (total * 26 - nums[i-1] * MAXL + nums[i+m-1]) % KMAX\\n if total in hashset:\\n return i\\n hashset.add(total)\\n return -1\\n \\n while l < r:\\n m = (l + r) // 2\\n if check(m) < 0:\\n r = m\\n else:\\n l = m + 1\\n idx = check(r - 1) \\n return S[idx: idx + r-1]\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n ords = [ord(ch) - 97 for ch in S]\\n mod = 2 ** 32\\n seen = set()\\n \\n def has_dup_with_length(length):\\n seen.clear()\\n p = pow(26, length, mod)\\n \\n hashed_prefix = 0\\n for i in range(length):\\n hashed_prefix = (hashed_prefix * 26 + ords[i]) % mod\\n seen.add(hashed_prefix)\\n\\n for i in range(length, len(S)):\\n hashed_prefix = (hashed_prefix * 26 + ords[i] - ords[i - length] * p) % mod\\n if hashed_prefix in seen:\\n return i - length + 1\\n seen.add(hashed_prefix)\\n \\n start, lo, hi = 0, 0, len(S) - 1, \\n while lo < hi:\\n mid_length = (lo + hi + 1) // 2\\n idx = has_dup_with_length(mid_length)\\n if idx:\\n start = idx\\n lo = mid_length\\n else:\\n hi = mid_length - 1\\n return S[start: start + lo]\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n res = ''\\n d,q = len(set(S)), 2**63-1\\n record = [0]*len(S)\\n for i in range(len(S)):\\n if i == 0:record[i] = ord(S[i])\\n else:record[i] = (record[i-1]*d+ord(S[i]))%q\\n def check(mid):\\n h,g = 1,set()\\n for i in range(mid):\\n h = h*d%q\\n for i in range(len(S)-mid+1):\\n count = (record[i+mid-1]-record[i-1]*h)%q if i > 0 else record[i+mid-1]\\n if count not in g:g.add(count)\\n else:return S[i:i+mid]\\n return False\\n l,r = 0,len(S)-1\\n while l<=r:\\n mid = (l+r)//2\\n temp = check(mid)\\n if temp:\\n res = temp\\n l = mid + 1\\n else:r = mid - 1\\n return res\\n \\n \\n# res = \\\\\\\"\\\\\\\"\\n# d, q = len(set(S)), 2**63-1\\n# hashes = [0] * len(S)\\n# for i in range(len(S)):\\n# if i == 0: hashes[i] = ord(S[i])\\n# else: hashes[i] = (hashes[i-1]*d + ord(S[i]))%q\\n# l, r = 0, len(S)-1\\n# while l <= r:\\n# mid = (l+r)//2\\n# temp = self.check(S,mid,hashes,d,q)\\n# if temp:\\n# res = temp\\n# l = mid + 1\\n# else: r = mid - 1\\n# return res\\n \\n# def check(self, S, mid, hashes, d, q):\\n# res = set()\\n# h, g = 1, 0\\n# for i in range(mid):\\n# h = (h*d)%q\\n# for i in range(len(S)-mid+1):\\n# g = (hashes[i+mid-1] - hashes[i-1]*h)%q if i > 0 else hashes[i+mid-1]\\n# if g not in res: res.add(g)\\n# else: return S[i:i+mid]\\n# return False\\n \\n \\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n n = len(S)\\n nums = [ord(S[i]) - ord('a') for i in range(n)]\\n \\n def search(position):\\n h = 0\\n for i in range(position):\\n h = (h * 26 + nums[i]) % 2 ** 32\\n seen = {h}\\n const = 26 ** position % 2 ** 32\\n for start in range(1, n - position + 1):\\n h = (h * 26 - nums[start - 1] * const + nums[start + position - 1]) % 2 ** 32\\n if h in seen:\\n return start\\n seen.add(h)\\n return -1\\n \\n left, right = 1, n\\n while left <= right:\\n pivot = (left + right) // 2\\n if search(pivot) != -1:\\n left = pivot + 1\\n else:\\n right = pivot - 1\\n start = search(left - 1)\\n return S[start: start + left - 1]\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n arr = [ord(ch) - ord('a') for ch in S]\\n n = len(arr)\\n B = 29\\n mod = 2**63 - 1\\n def exists(L):\\n seen = {}\\n P = pow(B, L, mod)\\n h = 0\\n for i in range(n):\\n h = (h * B + arr[i]) % mod\\n if i >= L:\\n h = (h - arr[i-L] * P) % mod\\n if i >= L - 1:\\n if h in seen:\\n return seen[h]\\n seen[h] = i\\n return -1\\n \\n lo, hi = 0, len(S)\\n # cand = ''\\n pos = -1\\n while lo < hi:\\n mid = (lo + hi + 1) // 2\\n idx = exists(mid)\\n if idx != -1:\\n lo = mid\\n # cand = S[idx - mid + 1: idx + 1]\\n pos = idx\\n else:\\n hi = mid - 1\\n return S[pos - lo + 1:pos+1]\\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n self.A = [ord(c) - ord('a') for c in S]\\n \\n start, end = 1, len(S)\\n while start + 1 < end:\\n mid = (start + end) // 2\\n pos = self.check(mid)\\n if pos:\\n start = mid\\n else:\\n end = mid\\n\\n pos = self.check(end)\\n if pos:\\n return S[pos: pos + end]\\n pos = self.check(start)\\n if pos:\\n return S[pos: pos + start]\\n return ''\\n \\n def check(self, length):\\n mod = 2**63 - 1\\n power = pow(26, length, mod)\\n \\n cur = 0\\n for i in range(length):\\n cur = (cur * 26 + self.A[i]) % mod\\n \\n # cur = reduce(lambda x, y: (x * 26 + y) % mod, self.A[:length], 0)\\n seen = {cur}\\n \\n for i in range(length, len(self.A)):\\n cur = (cur * 26 + self.A[i] - self.A[i - length] * power) % mod\\n if cur in seen:\\n return i - length + 1\\n seen.add(cur)\\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n def rk(m):\\n \\n nonlocal idx\\n st = set()\\n p = b**(m-1)\\n p%=mod\\n \\n y = 0\\n for i in range(m):\\n y = (y*b+num[i])%mod\\n \\n st.add(y)\\n \\n for i in range(1, n-m+1):\\n y = ((y-num[i-1]*p%mod)*b%mod+num[i-1+m])%mod\\n #y = (y-num[i-1]*p)*b+num[i-1+m]\\n \\n if y in st:\\n idx = i\\n return 0\\n else:\\n st.add(y)\\n \\n return 1\\n \\n \\n\\n n = len(S)\\n b = 26 # no need to be 128\\n #mod = 10**9+7 # too small => conflict\\n mod = 2**32 # here\\n \\n z = ord('a')\\n num = [ ord(S[i])-z for i in range(n)]\\n \\n l=1\\n r=n\\n idx = 0 # last found duplicate \\n while l<r:\\n \\n m = (l+r)//2\\n \\n if rk(m)>0:\\n r = m\\n else:\\n l = m+1\\n \\n return S[idx:idx+l-1]\\n \\n \\n\",\n \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n self.A = [ord(c) - ord('a') for c in S]\\n \\n start, end = 1, len(S)\\n while start + 1 < end:\\n mid = (start + end) // 2\\n pos = self.check(mid)\\n if pos:\\n start = mid\\n else:\\n end = mid\\n\\n pos = self.check(end)\\n if pos:\\n return S[pos: pos + end]\\n pos = self.check(start)\\n if pos:\\n return S[pos: pos + start]\\n return ''\\n \\n def check(self, length):\\n mod = 2**63 - 1\\n power = pow(26, length, mod)\\n \\n cur = reduce(lambda x, y: (x * 26 + y) % mod, self.A[:length], 0)\\n seen = {cur}\\n \\n for i in range(length, len(self.A)):\\n cur = (cur * 26 + self.A[i] - self.A[i - length] * power) % mod\\n if cur in seen:\\n return i - length + 1\\n seen.add(cur)\\n\",\n \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n self.A = [ord(c) - ord('a') for c in S]\\n \\n start, end = 1, len(S)\\n while start + 1 < end:\\n mid = (start + end) // 2\\n pos = self.check(mid)\\n if pos:\\n start = mid\\n else:\\n end = mid\\n\\n pos = self.check(end)\\n if pos:\\n return S[pos: pos + end]\\n pos = self.check(start)\\n if pos:\\n return S[pos: pos + start]\\n return ''\\n \\n def check(self, length):\\n mod = 2**63 - 1\\n power = pow(26, length, mod)\\n \\n # cur = 0\\n # for i in range(length):\\n # cur = (cur * 26 + self.A[i]) % mod\\n \\n cur = reduce(lambda x, y: (x * 26 + y) % mod, self.A[:length], 0)\\n seen = {cur}\\n \\n for i in range(length, len(self.A)):\\n cur = (cur * 26 + self.A[i] - self.A[i - length] * power) % mod\\n if cur in seen:\\n return i - length + 1\\n seen.add(cur)\\n\",\n \"from functools import reduce\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n self.A = [ord(c) - ord('a') for c in S]\\n \\n start, end = 1, len(S)\\n while start + 1 < end:\\n mid = (start + end) // 2\\n print(mid)\\n pos = self.check(mid)\\n print(pos)\\n if pos:\\n start = mid\\n else:\\n end = mid\\n # print(start, end)\\n pos = self.check(end)\\n # print(pos)\\n if pos:\\n return S[pos: pos + end]\\n pos = self.check(start)\\n if pos:\\n return S[pos: pos + start]\\n return ''\\n \\n def check(self, length):\\n mod = 2**63 - 1\\n power = pow(26, length, mod)\\n \\n cur = reduce(lambda x, y: (x * 26 + y) % mod, self.A[:length], 0)\\n seen = {cur}\\n \\n for i in range(length, len(self.A)):\\n cur = (cur * 26 + self.A[i] - self.A[i - length] * power) % mod\\n if cur in seen:\\n return i - length + 1\\n seen.add(cur)\\n\",\n \"class Solution:\\n def searchLongestStringOfKLen(self, S, total_len, compare_len):\\n search_len_hash = 0\\n for i in range(compare_len):\\n search_len_hash = (search_len_hash * self.uniq + self.nums[i]) % self.mod\\n\\n tmp_hash = {}\\n tmp_hash[search_len_hash] = True\\n \\n remove_old_power = pow(self.uniq, compare_len, self.mod)\\n for i in range(1, total_len-compare_len+1):\\n search_len_hash = (search_len_hash * self.uniq - (remove_old_power * self.nums[i-1]) + self.nums[i+compare_len-1] )% self.mod\\n if search_len_hash in tmp_hash:\\n return i\\n tmp_hash[search_len_hash] = True\\n \\n return -1\\n \\n \\n def longestDupSubstring(self, S: str) -> str:\\n ls = len(S)\\n end = ls\\n start = 1 \\n mid = 0\\n self.nums = []\\n for i in range(ls):\\n self.nums.append(ord(S[i]) - ord('a'))\\n\\n self.uniq = 26\\n self.mod = 2**32\\n while start <= end:\\n mid = start + (end-start)//2\\n if self.searchLongestStringOfKLen(S, ls, mid) != -1:\\n start = mid + 1\\n else :\\n end = mid - 1\\n \\n ds_sp = self.searchLongestStringOfKLen(S, ls, start -1)\\n return S[ds_sp:ds_sp+start-1]\",\n \"def check(arr, n, l, mod):\\n p = pow(26, l, mod)\\n window_hash = 0\\n hash_set = set()\\n for i in range(l):\\n window_hash = (26 * window_hash + arr[i]) % mod\\n hash_set.add(window_hash)\\n\\n for i in range(1, n - l + 1):\\n window_hash = (window_hash * 26 - (arr[i - 1]*p) + arr[i + l - 1])%mod\\n if window_hash in hash_set:\\n return i\\n hash_set.add(window_hash)\\n\\n return False\\n\\n\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n \\n n = len(S)\\n min_length, max_length = 1, n\\n ans, prev_len = 0, 0\\n mod = (1 << 63) - 1\\n nums = [ord(S[i]) - ord('a') for i in range(n)]\\n\\n while min_length <= max_length:\\n mid_length = int((max_length + min_length)/2)\\n start = check(nums, n, mid_length, mod)\\n if start != False:\\n if prev_len < mid_length:\\n ans = start\\n prev_len = mid_length\\n min_length = mid_length + 1\\n else:\\n max_length = mid_length - 1\\n \\n return S[ans:ans + prev_len]\\n\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n n=len(S)\\n modulus=2**56\\n a=26 \\n nums=[ord(c)-ord('a') for c in S]\\n def search(L):\\n nonlocal a,n,modulus\\n aL=pow(a,L,modulus)\\n h=0\\n for i in range(L):\\n h=(h*a+nums[i])%modulus\\n seen={h}\\n for start in range(1,n-L+1):\\n h=(h*a-nums[start-1]*aL+nums[start+L-1])%modulus\\n if h in seen:\\n return start\\n seen.add(h)\\n return -1\\n \\n l,r=1,n\\n while l<=r:\\n mid=(l+r)>>1\\n if search(mid)!=-1:\\n l=mid+1\\n else:\\n r=mid-1\\n \\n start=search(r) \\n return S[start:start+r]\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n n = len(S)\\n chars = [ord(c) - 97 for c in S]\\n BASE = 26\\n MOD = (1 << 63) - 1\\n POWS = [1] * n\\n for i in range(1, n):\\n POWS[i] = (POWS[i - 1] * BASE) % MOD\\n def search(k):\\n seen = set()\\n h = 0\\n for i in range(k):\\n h = (h * BASE + chars[i]) % MOD\\n seen.add(h)\\n for i in range(k, n):\\n h = ((h - chars[i - k] * POWS[k - 1]) * BASE + chars[i]) % MOD\\n if h in seen:\\n return i\\n seen.add(h)\\n return -1\\n \\n l, r = 0, n - 1\\n k = 0\\n while l < r:\\n m = (l + r + 1) // 2\\n i = search(m)\\n if i >= 0:\\n k = i\\n l = m\\n else:\\n r = m - 1\\n return S[k - l + 1:k + 1]\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n n = len(S)\\n chars = [ord(c) - 97 for c in S]\\n BASE = 26\\n MOD = (1 << 63) - 1\\n POWS = [1] * n\\n for i in range(1, n):\\n POWS[i] = (POWS[i - 1] * BASE) % MOD\\n def search(k):\\n seen = set()\\n h = 0\\n for i in range(k):\\n h = (h * BASE + chars[i]) % MOD\\n seen.add(h)\\n for i in range(k, n):\\n h = ((h - chars[i - k] * POWS[k - 1]) * BASE + chars[i]) % MOD\\n if h in seen:\\n return i\\n seen.add(h)\\n return -1\\n \\n l, r = 0, n - 1\\n while l <= r:\\n m = (l + r) // 2\\n if search(m) >= 0:\\n l = m + 1\\n else:\\n r = m - 1\\n if r < 0:\\n return ''\\n i = search(r)\\n return S[i - r + 1:i + 1]\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n p = 31\\n m = 100000000003\\n\\n pows = [1] * len(S)\\n invPows = [1] * len(S)\\n for i in range(1, len(S)):\\n pows[i] = pows[i-1] * p % m\\n invPows[i] = pow(pows[i], -1, m)\\n\\n h = [0] * (len(S) + 1)\\n for i in range(len(S)):\\n h[i+1] = (h[i] + (ord(S[i]) - ord('a') + 1) * pows[i]) % m\\n\\n def hasDup(S, sublen):\\n seen = set()\\n for i in range(len(S)- sublen + 1):\\n if (hs := (h[i + sublen] - h[i]) * invPows[i] % m) in seen:\\n return (i, sublen)\\n seen.add(hs)\\n return (0, 0)\\n\\n ans = None\\n lo, hi = 1, len(S)\\n while lo < hi:\\n mid = (lo + hi) // 2\\n if (s := hasDup(S, mid))[1]:\\n lo = mid + 1\\n ans = s\\n else:\\n hi = mid\\n return S[ans[0]:ans[0]+ans[1]] if ans else ''\",\n \"class Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n def search(m, MOD):\\n h = 0\\n for i in range(m):\\n h = (h * 26 + nums[i]) % MOD\\n s = {h}\\n aL = pow(26, m, MOD)\\n for pos in range(1, n - m + 1):\\n h = (h * 26 - nums[pos - 1] * aL + nums[pos + m - 1]) % MOD\\n if h in s:\\n return pos\\n s.add(h)\\n return -1\\n \\n n = len(S)\\n nums = [ord(c) - ord('a') for c in S]\\n # find length of longest duplicate substring\\n l, r = 1, n\\n pos = 0\\n MOD = 2**63 - 1 # use largest positive of 8 byte integer\\n while l <= r:\\n m = (l + r) // 2\\n # search if there's duplicate for length m substring\\n cur = search(m, MOD)\\n if cur != -1:\\n l = m + 1\\n pos = cur\\n else:\\n r = m - 1\\n return S[pos: pos + l - 1]\",\n \"from collections import defaultdict\\nfrom functools import reduce\\n\\n\\nclass Solution:\\n def longestDupSubstring(self, S: str) -> str:\\n mod = (1 << 63 - 1)\\n A = [ord(c) - ord('a') for c in S]\\n \\n def find_dup_of_length(L):\\n p = pow(26, L, mod)\\n h = reduce(lambda x, y: (x * 26 + y) % mod, A[:L], 0)\\n seen = defaultdict(list)\\n seen[h].append(0)\\n \\n for i in range(L, len(S)):\\n h = (h * 26 + A[i] - p * A[i-L]) % mod\\n for start in seen[h]:\\n if S[start:start+L] == S[i-L+1:i+1]:\\n return start\\n \\n seen[h].append(i-L+1)\\n \\n start = 0\\n length = 0\\n low, high = 1, len(S)\\n while low < high:\\n mid = low + (high - low) // 2\\n pos = find_dup_of_length(mid)\\n if pos is not None:\\n start = pos\\n length = mid\\n low = mid + 1\\n else:\\n high = mid\\n \\n return S[start:start+length]\\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":70,"string":"70"},"non_interactive_idx":{"kind":"list like","value":[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],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32,\n 33,\n 34,\n 35,\n 36,\n 37,\n 38,\n 39,\n 40,\n 41,\n 42,\n 43,\n 44,\n 45,\n 46,\n 47,\n 48,\n 49,\n 50,\n 51,\n 52,\n 53,\n 54,\n 55,\n 56,\n 57,\n 58,\n 59,\n 60,\n 61,\n 62,\n 63,\n 64,\n 65,\n 66,\n 67,\n 68,\n 69\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[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],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":87,"cells":{"problem_id":{"kind":"number","value":223,"string":"223"},"question":{"kind":"string","value":"Given an array of citations sorted in ascending order (each citation is a non-negative integer) of a researcher, write a function to compute the researcher's h-index.\n\nAccording to the definition of h-index on Wikipedia: \"A scientist has index h if h of his/her N papers have at least h citations each, and the other N − h papers have no more than h citations each.\"\n\nExample:\n\n\nInput: citations = [0,1,3,5,6]\nOutput: 3 \nExplanation: [0,1,3,5,6] means the researcher has 5 papers in total and each of them had \n received 0, 1, 3, 5, 6 citations respectively. \n Since the researcher has 3 papers with at least 3 citations each and the remaining \n two with no more than 3 citations each, her h-index is 3.\n\nNote:\n\nIf there are several possible values for h, the maximum one is taken as the h-index.\n\nFollow up:\n\n\n This is a follow up problem to H-Index, where citations is now guaranteed to be sorted in ascending order.\n Could you solve it in logarithmic time complexity?"},"solutions":{"kind":"string","value":"[\"class Solution(object):\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n n = len(citations)\\n l = 0\\n r = n-1\\n while l <= r:\\n m = (l + r) // 2\\n if m == 0 and citations[m] >= n - m or citations[m-1] < n - (m-1) and citations[m] >= n-m:\\n return n-m\\n if citations[m] < n - m:\\n l = m+1\\n else:\\n r = m\\n return 0\\n\", \"class Solution:\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n n = len(citations)\\n l, r = 0, n - 1\\n while l <= r:\\n m = (l + r) // 2\\n if citations[m] >= n - m:\\n r = m - 1\\n else:\\n l = m + 1\\n return n - r - 1\", \"class Solution:\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n c = citations\\n if not c:\\n return 0\\n s, e = 0, len(c) - 1\\n if c[s] >= len(c):\\n return len(c)\\n if c[e] < 1:\\n return 0\\n while s < e - 1:\\n m = s + int((e - s) / 2)\\n if c[m] >= len(c) - m:\\n e = m\\n else:\\n s = m\\n return len(c) - e\", \"class Solution:\\n \\\"\\\"\\\"\\n time: O(logn)\\n \\\"\\\"\\\"\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n if not citations:\\n return 0\\n \\n n = len(citations)\\n left, right = 0, n - 1\\n \\n while left + 1 < right:\\n mid = (left + right) // 2\\n \\n if citations[mid] >= n - mid:\\n right = mid\\n else:\\n left = mid\\n \\n for mid in (left, right):\\n if citations[mid] >= n - mid:\\n return n - mid\\n \\n return 0\", \"class Solution:\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n h = 0\\n count = 0\\n for c in citations[::-1]:\\n if c <= count:\\n return count\\n count += 1\\n return count\\n\", \"class Solution:\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n l, r, res = 0, len(citations) - 1, 0\\n while l <= r:\\n mid = (l + r) // 2\\n if len(citations) - mid <= citations[mid]: res, r = len(citations) - mid, r - 1\\n else: l = mid + 1\\n return res \", \"class Solution:\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n citations.sort(reverse=True)\\n for idx in range(len(citations)):\\n if idx + 1> citations[idx]:\\n return idx\\n return len(citations)\\n\", \"class Solution:\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n citations.sort()\\n for i in range(len(citations)-1, -1, -1):\\n if citations[i] >= len(citations)-i and (i == 0 or citations[i-1] <= len(citations)-i):\\n return len(citations)-i\\n return 0\", \"class Solution:\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n \\n # my solution......beat 95 %\\n \\n l = len(citations)\\n if l == 0: return 0\\n if l == 1:\\n if citations[0] == 0: return 0\\n else: return 1\\n if min(citations) >= l: return l\\n \\n citations = citations[::-1]\\n count = 0\\n thres = 0\\n i = 0\\n while i < len(citations):\\n if thres >= count:\\n thres = citations[i]\\n count += 1\\n i += 1\\n else:\\n return count-1\\n return count-1\\n \\n \\n \\n \\n\", \"class Solution:\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n \\n # my solution......beat 100 %\\n \\n l = len(citations)\\n if l == 0: return 0 # shit testcase: []\\n if l == 1:\\n if citations[0] == 0: return 0 # shit testcase: [0]\\n else: return 1 # for testcase: [1], [2] or [100] etc...\\n if min(citations) >= l: return l # for testcase: [2,3], [5,8], [3,4,5], [7,8,9,9] etc...\\n \\n citations = citations[::-1]\\n count = 0\\n thres = 0 # (count, thres): this author has \\\"count\\\" articles with citations >= thres\\n i = 0\\n while i < len(citations):\\n if thres >= count:\\n thres = citations[i]\\n count += 1\\n i += 1\\n else:\\n return count - 1\\n return count - 1\\n \\n \\n \\n \\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"hIndex\", \"inputs\": [[[0, 1, 3, 5, 6]]], \"outputs\": [3]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/h-index-ii/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def hIndex(self, citations: List[int]) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution(object):\n def hIndex(self, citations):\n \"\"\"\n :type citations: List[int]\n :rtype: int\n \"\"\"\n n = len(citations)\n l = 0\n r = n-1\n while l <= r:\n m = (l + r) // 2\n if m == 0 and citations[m] >= n - m or citations[m-1] < n - (m-1) and citations[m] >= n-m:\n return n-m\n if citations[m] < n - m:\n l = m+1\n else:\n r = m\n return 0\n","class Solution:\n def hIndex(self, citations):\n \"\"\"\n :type citations: List[int]\n :rtype: int\n \"\"\"\n n = len(citations)\n l, r = 0, n - 1\n while l <= r:\n m = (l + r) // 2\n if citations[m] >= n - m:\n r = m - 1\n else:\n l = m + 1\n return n - r - 1","class Solution:\n def hIndex(self, citations):\n \"\"\"\n :type citations: List[int]\n :rtype: int\n \"\"\"\n c = citations\n if not c:\n return 0\n s, e = 0, len(c) - 1\n if c[s] >= len(c):\n return len(c)\n if c[e] < 1:\n return 0\n while s < e - 1:\n m = s + int((e - s) / 2)\n if c[m] >= len(c) - m:\n e = m\n else:\n s = m\n return len(c) - e","class Solution:\n \"\"\"\n time: O(logn)\n \"\"\"\n def hIndex(self, citations):\n \"\"\"\n :type citations: List[int]\n :rtype: int\n \"\"\"\n if not citations:\n return 0\n \n n = len(citations)\n left, right = 0, n - 1\n \n while left + 1 < right:\n mid = (left + right) // 2\n \n if citations[mid] >= n - mid:\n right = mid\n else:\n left = mid\n \n for mid in (left, right):\n if citations[mid] >= n - mid:\n return n - mid\n \n return 0","class Solution:\n def hIndex(self, citations):\n \"\"\"\n :type citations: List[int]\n :rtype: int\n \"\"\"\n h = 0\n count = 0\n for c in citations[::-1]:\n if c <= count:\n return count\n count += 1\n return count\n","class Solution:\n def hIndex(self, citations):\n \"\"\"\n :type citations: List[int]\n :rtype: int\n \"\"\"\n l, r, res = 0, len(citations) - 1, 0\n while l <= r:\n mid = (l + r) // 2\n if len(citations) - mid <= citations[mid]: res, r = len(citations) - mid, r - 1\n else: l = mid + 1\n return res ","class Solution:\n def hIndex(self, citations):\n \"\"\"\n :type citations: List[int]\n :rtype: int\n \"\"\"\n citations.sort(reverse=True)\n for idx in range(len(citations)):\n if idx + 1> citations[idx]:\n return idx\n return len(citations)\n","class Solution:\n def hIndex(self, citations):\n \"\"\"\n :type citations: List[int]\n :rtype: int\n \"\"\"\n citations.sort()\n for i in range(len(citations)-1, -1, -1):\n if citations[i] >= len(citations)-i and (i == 0 or citations[i-1] <= len(citations)-i):\n return len(citations)-i\n return 0","class Solution:\n def hIndex(self, citations):\n \"\"\"\n :type citations: List[int]\n :rtype: int\n \"\"\"\n \n \n # my solution......beat 95 %\n \n l = len(citations)\n if l == 0: return 0\n if l == 1:\n if citations[0] == 0: return 0\n else: return 1\n if min(citations) >= l: return l\n \n citations = citations[::-1]\n count = 0\n thres = 0\n i = 0\n while i < len(citations):\n if thres >= count:\n thres = citations[i]\n count += 1\n i += 1\n else:\n return count-1\n return count-1\n \n \n \n \n","class Solution:\n def hIndex(self, citations):\n \"\"\"\n :type citations: List[int]\n :rtype: int\n \"\"\"\n \n \n # my solution......beat 100 %\n \n l = len(citations)\n if l == 0: return 0 # shit testcase: []\n if l == 1:\n if citations[0] == 0: return 0 # shit testcase: [0]\n else: return 1 # for testcase: [1], [2] or [100] etc...\n if min(citations) >= l: return l # for testcase: [2,3], [5,8], [3,4,5], [7,8,9,9] etc...\n \n citations = citations[::-1]\n count = 0\n thres = 0 # (count, thres): this author has \"count\" articles with citations >= thres\n i = 0\n while i < len(citations):\n if thres >= count:\n thres = citations[i]\n count += 1\n i += 1\n else:\n return count - 1\n return count - 1\n \n \n \n \n"],"string":"[\n \"class Solution(object):\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n n = len(citations)\\n l = 0\\n r = n-1\\n while l <= r:\\n m = (l + r) // 2\\n if m == 0 and citations[m] >= n - m or citations[m-1] < n - (m-1) and citations[m] >= n-m:\\n return n-m\\n if citations[m] < n - m:\\n l = m+1\\n else:\\n r = m\\n return 0\\n\",\n \"class Solution:\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n n = len(citations)\\n l, r = 0, n - 1\\n while l <= r:\\n m = (l + r) // 2\\n if citations[m] >= n - m:\\n r = m - 1\\n else:\\n l = m + 1\\n return n - r - 1\",\n \"class Solution:\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n c = citations\\n if not c:\\n return 0\\n s, e = 0, len(c) - 1\\n if c[s] >= len(c):\\n return len(c)\\n if c[e] < 1:\\n return 0\\n while s < e - 1:\\n m = s + int((e - s) / 2)\\n if c[m] >= len(c) - m:\\n e = m\\n else:\\n s = m\\n return len(c) - e\",\n \"class Solution:\\n \\\"\\\"\\\"\\n time: O(logn)\\n \\\"\\\"\\\"\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n if not citations:\\n return 0\\n \\n n = len(citations)\\n left, right = 0, n - 1\\n \\n while left + 1 < right:\\n mid = (left + right) // 2\\n \\n if citations[mid] >= n - mid:\\n right = mid\\n else:\\n left = mid\\n \\n for mid in (left, right):\\n if citations[mid] >= n - mid:\\n return n - mid\\n \\n return 0\",\n \"class Solution:\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n h = 0\\n count = 0\\n for c in citations[::-1]:\\n if c <= count:\\n return count\\n count += 1\\n return count\\n\",\n \"class Solution:\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n l, r, res = 0, len(citations) - 1, 0\\n while l <= r:\\n mid = (l + r) // 2\\n if len(citations) - mid <= citations[mid]: res, r = len(citations) - mid, r - 1\\n else: l = mid + 1\\n return res \",\n \"class Solution:\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n citations.sort(reverse=True)\\n for idx in range(len(citations)):\\n if idx + 1> citations[idx]:\\n return idx\\n return len(citations)\\n\",\n \"class Solution:\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n citations.sort()\\n for i in range(len(citations)-1, -1, -1):\\n if citations[i] >= len(citations)-i and (i == 0 or citations[i-1] <= len(citations)-i):\\n return len(citations)-i\\n return 0\",\n \"class Solution:\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n \\n # my solution......beat 95 %\\n \\n l = len(citations)\\n if l == 0: return 0\\n if l == 1:\\n if citations[0] == 0: return 0\\n else: return 1\\n if min(citations) >= l: return l\\n \\n citations = citations[::-1]\\n count = 0\\n thres = 0\\n i = 0\\n while i < len(citations):\\n if thres >= count:\\n thres = citations[i]\\n count += 1\\n i += 1\\n else:\\n return count-1\\n return count-1\\n \\n \\n \\n \\n\",\n \"class Solution:\\n def hIndex(self, citations):\\n \\\"\\\"\\\"\\n :type citations: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n \\n # my solution......beat 100 %\\n \\n l = len(citations)\\n if l == 0: return 0 # shit testcase: []\\n if l == 1:\\n if citations[0] == 0: return 0 # shit testcase: [0]\\n else: return 1 # for testcase: [1], [2] or [100] etc...\\n if min(citations) >= l: return l # for testcase: [2,3], [5,8], [3,4,5], [7,8,9,9] etc...\\n \\n citations = citations[::-1]\\n count = 0\\n thres = 0 # (count, thres): this author has \\\"count\\\" articles with citations >= thres\\n i = 0\\n while i < len(citations):\\n if thres >= count:\\n thres = citations[i]\\n count += 1\\n i += 1\\n else:\\n return count - 1\\n return count - 1\\n \\n \\n \\n \\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":10,"string":"10"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4,5,6,7,8,9],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":88,"cells":{"problem_id":{"kind":"number","value":224,"string":"224"},"question":{"kind":"string","value":"Given a string S and a string T, count the number of distinct subsequences of S which equals T.\n\nA subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, \"ACE\" is a subsequence of \"ABCDE\" while \"AEC\" is not).\n\nExample 1:\n\n\nInput: S = \"rabbbit\", T = \"rabbit\"\nOutput: 3\nExplanation:\n\nAs shown below, there are 3 ways you can generate \"rabbit\" from S.\n(The caret symbol ^ means the chosen letters)\n\nrabbbit\n^^^^ ^^\nrabbbit\n^^ ^^^^\nrabbbit\n^^^ ^^^\n\n\nExample 2:\n\n\nInput: S = \"babgbag\", T = \"bag\"\nOutput: 5\nExplanation:\n\nAs shown below, there are 5 ways you can generate \"bag\" from S.\n(The caret symbol ^ means the chosen letters)\n\nbabgbag\n^^ ^\nbabgbag\n^^ ^\nbabgbag\n^ ^^\nbabgbag\n ^ ^^\nbabgbag\n ^^^"},"solutions":{"kind":"string","value":"[\"class Solution:\\n def numDistinct(self, s, t):\\n \\\"\\\"\\\"\\n :type s: str\\n :type t: str\\n :rtype: int\\n \\\"\\\"\\\"\\n setOft=set(t)\\n news=\\\"\\\"\\n for ch in s:\\n if ch in setOft:\\n news+=ch\\n dp=[[1 for i in range(len(news)+1)] for j in range(len(t)+1)]\\n for j in range(1,len(t)+1):\\n dp[j][0]=0\\n \\n for i in range(len(t)):\\n for j in range(len(news)):\\n if t[i]==news[j]:\\n dp[i+1][j+1]=dp[i][j]+dp[i+1][j]\\n else:\\n dp[i+1][j+1]=dp[i+1][j]\\n return dp[len(t)][len(news)]\\n\", \"class Solution:\\n def __init__(self):\\n self.dp = {}\\n self.s = \\\"\\\"\\n self.t = \\\"\\\"\\n self.letter2Indices = {}\\n \\n def numDistinct(self, s, t):\\n \\\"\\\"\\\"\\n :type s: str\\n :type t: str\\n :rtype: int\\n \\\"\\\"\\\"\\n if len(s) < len(t):\\n return 0\\n if not t:\\n return 1\\n \\n self.s = s.lower()\\n self.t = t.lower()\\n length = len(s)\\n for i in range(len(t)):\\n self.dp[i] = [-1] * length\\n for i in range(length):\\n letter = self.s[i]\\n if letter in self.letter2Indices:\\n self.letter2Indices[letter].append(i)\\n else:\\n self.letter2Indices[letter] = list([i])\\n \\n return self.numSubseq(0, 0)\\n \\n def numSubseq(self, startS, startT):\\n if startT >= len(self.t):\\n return 1\\n if startS >= len(self.s):\\n return 0\\n \\n if self.dp[startT][startS] >= 0:\\n return self.dp[startT][startS]\\n \\n letter = self.t[startT]\\n count = 0\\n firstMatch = -1\\n if letter in self.letter2Indices:\\n for i in self.letter2Indices[letter]:\\n if i >= startS:\\n count += self.numSubseq(i+1, startT+1)\\n if firstMatch < 0:\\n # We can directly fill dp[startT][startS:firstMatch-1] with the same number\\n firstMatch = i\\n \\n self.dp[startT][startS] = count\\n for i in range(startS + 1, firstMatch):\\n self.dp[startT][i] = count\\n return count\\n \\n \\n \\n \\n \\n \\n \\n \\n\", \"class Solution:\\n def numDistinct(self, s, t):\\n \\\"\\\"\\\"\\n :type s: str\\n :type t: str\\n :rtype: int\\n \\\"\\\"\\\"\\n result = (len(t) + 1) * [0]\\n result[0] = 1\\n for j in range(len(s)):\\n for i in reversed(range(len(t))):\\n if s[j] == t[i]:\\n result[i + 1] += result[i]\\n return result[-1]\", \"class Solution:\\n def numDistinct(self, s, t):\\n \\\"\\\"\\\"\\n :type s: str\\n :type t: str\\n :rtype: int\\n \\\"\\\"\\\"\\n row = len(s) + 1\\n col = len(t) + 1\\n dp = [0]*col\\n dp[0] = 1\\n for i in range(1, row):\\n pre = dp[:]\\n # print(pre)\\n for j in range(1, col):\\n if s[i-1] == t[j-1]:\\n dp[j] += pre[j-1]\\n # print(dp)\\n return dp[-1]\\n \\n\", \"class Solution:\\n def numDistinct(self, s, t):\\n \\\"\\\"\\\"\\n :type s: str\\n :type t: str\\n :rtype: int\\n \\\"\\\"\\\"\\n if len(s) < len(t):\\n return 0\\n dp = [0] * len(s)\\n for i in range(len(s)):\\n dp[i] = dp[i-1] if i > 0 else 0\\n if s[i] == t[0]:\\n dp[i] += 1\\n \\n for i, ti in enumerate(t[1:]):\\n dp2 = [0] * len(s)\\n for j in range(i+1, len(s)):\\n dp2[j] = dp2[j-1]\\n if s[j] == ti:\\n dp2[j] += dp[j-1]\\n dp = dp2\\n return dp[-1]\\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"numDistinct\", \"inputs\": [[\"\\\"rabbbit\\\"\", \"\\\"rabbit\\\"\"]], \"outputs\": [3]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/distinct-subsequences/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def numDistinct(self, s: str, t: str) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def numDistinct(self, s, t):\n \"\"\"\n :type s: str\n :type t: str\n :rtype: int\n \"\"\"\n setOft=set(t)\n news=\"\"\n for ch in s:\n if ch in setOft:\n news+=ch\n dp=[[1 for i in range(len(news)+1)] for j in range(len(t)+1)]\n for j in range(1,len(t)+1):\n dp[j][0]=0\n \n for i in range(len(t)):\n for j in range(len(news)):\n if t[i]==news[j]:\n dp[i+1][j+1]=dp[i][j]+dp[i+1][j]\n else:\n dp[i+1][j+1]=dp[i+1][j]\n return dp[len(t)][len(news)]\n","class Solution:\n def __init__(self):\n self.dp = {}\n self.s = \"\"\n self.t = \"\"\n self.letter2Indices = {}\n \n def numDistinct(self, s, t):\n \"\"\"\n :type s: str\n :type t: str\n :rtype: int\n \"\"\"\n if len(s) < len(t):\n return 0\n if not t:\n return 1\n \n self.s = s.lower()\n self.t = t.lower()\n length = len(s)\n for i in range(len(t)):\n self.dp[i] = [-1] * length\n for i in range(length):\n letter = self.s[i]\n if letter in self.letter2Indices:\n self.letter2Indices[letter].append(i)\n else:\n self.letter2Indices[letter] = list([i])\n \n return self.numSubseq(0, 0)\n \n def numSubseq(self, startS, startT):\n if startT >= len(self.t):\n return 1\n if startS >= len(self.s):\n return 0\n \n if self.dp[startT][startS] >= 0:\n return self.dp[startT][startS]\n \n letter = self.t[startT]\n count = 0\n firstMatch = -1\n if letter in self.letter2Indices:\n for i in self.letter2Indices[letter]:\n if i >= startS:\n count += self.numSubseq(i+1, startT+1)\n if firstMatch < 0:\n # We can directly fill dp[startT][startS:firstMatch-1] with the same number\n firstMatch = i\n \n self.dp[startT][startS] = count\n for i in range(startS + 1, firstMatch):\n self.dp[startT][i] = count\n return count\n \n \n \n \n \n \n \n \n","class Solution:\n def numDistinct(self, s, t):\n \"\"\"\n :type s: str\n :type t: str\n :rtype: int\n \"\"\"\n result = (len(t) + 1) * [0]\n result[0] = 1\n for j in range(len(s)):\n for i in reversed(range(len(t))):\n if s[j] == t[i]:\n result[i + 1] += result[i]\n return result[-1]","class Solution:\n def numDistinct(self, s, t):\n \"\"\"\n :type s: str\n :type t: str\n :rtype: int\n \"\"\"\n row = len(s) + 1\n col = len(t) + 1\n dp = [0]*col\n dp[0] = 1\n for i in range(1, row):\n pre = dp[:]\n # print(pre)\n for j in range(1, col):\n if s[i-1] == t[j-1]:\n dp[j] += pre[j-1]\n # print(dp)\n return dp[-1]\n \n","class Solution:\n def numDistinct(self, s, t):\n \"\"\"\n :type s: str\n :type t: str\n :rtype: int\n \"\"\"\n if len(s) < len(t):\n return 0\n dp = [0] * len(s)\n for i in range(len(s)):\n dp[i] = dp[i-1] if i > 0 else 0\n if s[i] == t[0]:\n dp[i] += 1\n \n for i, ti in enumerate(t[1:]):\n dp2 = [0] * len(s)\n for j in range(i+1, len(s)):\n dp2[j] = dp2[j-1]\n if s[j] == ti:\n dp2[j] += dp[j-1]\n dp = dp2\n return dp[-1]\n"],"string":"[\n \"class Solution:\\n def numDistinct(self, s, t):\\n \\\"\\\"\\\"\\n :type s: str\\n :type t: str\\n :rtype: int\\n \\\"\\\"\\\"\\n setOft=set(t)\\n news=\\\"\\\"\\n for ch in s:\\n if ch in setOft:\\n news+=ch\\n dp=[[1 for i in range(len(news)+1)] for j in range(len(t)+1)]\\n for j in range(1,len(t)+1):\\n dp[j][0]=0\\n \\n for i in range(len(t)):\\n for j in range(len(news)):\\n if t[i]==news[j]:\\n dp[i+1][j+1]=dp[i][j]+dp[i+1][j]\\n else:\\n dp[i+1][j+1]=dp[i+1][j]\\n return dp[len(t)][len(news)]\\n\",\n \"class Solution:\\n def __init__(self):\\n self.dp = {}\\n self.s = \\\"\\\"\\n self.t = \\\"\\\"\\n self.letter2Indices = {}\\n \\n def numDistinct(self, s, t):\\n \\\"\\\"\\\"\\n :type s: str\\n :type t: str\\n :rtype: int\\n \\\"\\\"\\\"\\n if len(s) < len(t):\\n return 0\\n if not t:\\n return 1\\n \\n self.s = s.lower()\\n self.t = t.lower()\\n length = len(s)\\n for i in range(len(t)):\\n self.dp[i] = [-1] * length\\n for i in range(length):\\n letter = self.s[i]\\n if letter in self.letter2Indices:\\n self.letter2Indices[letter].append(i)\\n else:\\n self.letter2Indices[letter] = list([i])\\n \\n return self.numSubseq(0, 0)\\n \\n def numSubseq(self, startS, startT):\\n if startT >= len(self.t):\\n return 1\\n if startS >= len(self.s):\\n return 0\\n \\n if self.dp[startT][startS] >= 0:\\n return self.dp[startT][startS]\\n \\n letter = self.t[startT]\\n count = 0\\n firstMatch = -1\\n if letter in self.letter2Indices:\\n for i in self.letter2Indices[letter]:\\n if i >= startS:\\n count += self.numSubseq(i+1, startT+1)\\n if firstMatch < 0:\\n # We can directly fill dp[startT][startS:firstMatch-1] with the same number\\n firstMatch = i\\n \\n self.dp[startT][startS] = count\\n for i in range(startS + 1, firstMatch):\\n self.dp[startT][i] = count\\n return count\\n \\n \\n \\n \\n \\n \\n \\n \\n\",\n \"class Solution:\\n def numDistinct(self, s, t):\\n \\\"\\\"\\\"\\n :type s: str\\n :type t: str\\n :rtype: int\\n \\\"\\\"\\\"\\n result = (len(t) + 1) * [0]\\n result[0] = 1\\n for j in range(len(s)):\\n for i in reversed(range(len(t))):\\n if s[j] == t[i]:\\n result[i + 1] += result[i]\\n return result[-1]\",\n \"class Solution:\\n def numDistinct(self, s, t):\\n \\\"\\\"\\\"\\n :type s: str\\n :type t: str\\n :rtype: int\\n \\\"\\\"\\\"\\n row = len(s) + 1\\n col = len(t) + 1\\n dp = [0]*col\\n dp[0] = 1\\n for i in range(1, row):\\n pre = dp[:]\\n # print(pre)\\n for j in range(1, col):\\n if s[i-1] == t[j-1]:\\n dp[j] += pre[j-1]\\n # print(dp)\\n return dp[-1]\\n \\n\",\n \"class Solution:\\n def numDistinct(self, s, t):\\n \\\"\\\"\\\"\\n :type s: str\\n :type t: str\\n :rtype: int\\n \\\"\\\"\\\"\\n if len(s) < len(t):\\n return 0\\n dp = [0] * len(s)\\n for i in range(len(s)):\\n dp[i] = dp[i-1] if i > 0 else 0\\n if s[i] == t[0]:\\n dp[i] += 1\\n \\n for i, ti in enumerate(t[1:]):\\n dp2 = [0] * len(s)\\n for j in range(i+1, len(s)):\\n dp2[j] = dp2[j-1]\\n if s[j] == ti:\\n dp2[j] += dp[j-1]\\n dp = dp2\\n return dp[-1]\\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":5,"string":"5"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":89,"cells":{"problem_id":{"kind":"number","value":225,"string":"225"},"question":{"kind":"string","value":"There are N dominoes in a line, and we place each domino vertically upright.\nIn the beginning, we simultaneously push some of the dominoes either to the left or to the right.\n\nAfter each second, each domino that is falling to the left pushes the adjacent domino on the left.\nSimilarly, the dominoes falling to the right push their adjacent dominoes standing on the right.\nWhen a vertical domino has dominoes falling on it from both sides, it stays still due to the balance of the forces.\nFor the purposes of this question, we will consider that a falling domino expends no additional force to a falling or already fallen domino.\nGiven a string \"S\" representing the initial state. S[i] = 'L', if the i-th domino has been pushed to the left; S[i] = 'R', if the i-th domino has been pushed to the right; S[i] = '.', if the i-th domino has not been pushed.\nReturn a string representing the final state. \nExample 1:\nInput: \".L.R...LR..L..\"\nOutput: \"LL.RR.LLRRLL..\"\n\nExample 2:\nInput: \"RR.L\"\nOutput: \"RR.L\"\nExplanation: The first domino expends no additional force on the second domino.\n\nNote:\n\n0 <= N <= 10^5\nString dominoes contains only 'L', 'R' and '.'"},"solutions":{"kind":"string","value":"[\"INF = float('inf')\\nclass Solution:\\n def pushDominoes(self, dominoes: str) -> str:\\n n = len(dominoes)\\n d1 = [-1] * n\\n d2 = [-1] * n\\n \\n cnt = INF\\n for i in range(n - 1, -1, -1):\\n if dominoes[i] == 'L':\\n cnt = 0\\n elif dominoes[i] == '.':\\n cnt += 1\\n elif dominoes[i] == 'R':\\n cnt = INF\\n d1[i] = cnt\\n \\n cnt = INF\\n for i in range(n):\\n if dominoes[i] == 'R':\\n cnt = 0\\n elif dominoes[i] == '.':\\n cnt += 1\\n elif dominoes[i] == 'L':\\n cnt = INF\\n d2[i] = cnt\\n \\n ret = []\\n for i in range(n):\\n if d1[i] == d2[i]:\\n ret.append('.')\\n elif d1[i] < d2[i]:\\n ret.append('L')\\n else:\\n ret.append('R')\\n return ''.join(ret)\", \"class Solution:\\n def pushDominoes(self, dominoes: str) -> str:\\n n = len(dominoes)\\n \\n d = [0] * n\\n \\n force = 0\\n \\n for i in range(n):\\n c = dominoes[i]\\n \\n if c == 'R':\\n force = n\\n elif c == 'L':\\n force = 0\\n else:\\n force = max(force - 1, 0)\\n \\n d[i] += force\\n \\n force = 0\\n \\n for i in range(n-1, -1, -1):\\n c = dominoes[i]\\n \\n if c == 'R':\\n force = 0\\n elif c == 'L':\\n force = n\\n else:\\n force = max(force - 1, 0)\\n \\n d[i] -= force\\n \\n def inner():\\n for f in d:\\n if f == 0:\\n yield '.'\\n elif f > 0:\\n yield 'R'\\n else:\\n yield 'L'\\n \\n return ''.join(inner())\", \"class Solution:\\n def pushDominoes(self, dominoes: str) -> str:\\n n = len(dominoes)\\n force = [0] * n\\n f = 0\\n for i in range(n):\\n if dominoes[i] == 'R':\\n f = n\\n elif dominoes[i] == 'L':\\n f = 0\\n else:\\n f = max(f-1, 0)\\n force[i] += f\\n for i in range(n-1, -1, -1):\\n if dominoes[i] == 'L':\\n f = n\\n elif dominoes[i] == 'R':\\n f = 0\\n else:\\n f = max(f-1, 0)\\n force[i] -= f\\n return ''.join('.' if f==0 else 'R' if f > 0 else 'L' for f in force)\", \"class Solution:\\n def pushDominoes(self, dominoes: str) -> str:\\n l = len(dominoes)\\n right_force = [0]*l\\n left_force = [0]*l\\n force1 = 0\\n force2 = 0\\n for i in range(l):\\n if dominoes[i]=='R':\\n force1 = l\\n elif dominoes[i]=='L':\\n force1 = 0\\n else:\\n force1 = max(force1 - 1, 0)\\n right_force[i] += force1\\n for i in range(l-1, -1, -1):\\n if dominoes[i]=='L':\\n force2 = l\\n elif dominoes[i]=='R':\\n force2 = 0\\n else:\\n force2 = max(force2 - 1, 0)\\n left_force[i] += force2\\n\\n result = ''\\n for i in range(l):\\n if right_force[i] > left_force[i]:\\n result += 'R'\\n elif right_force[i] < left_force[i]:\\n result += 'L'\\n else:\\n result += '.'\\n return result\", \"class Solution:\\n def pushDominoes(self, dominoes: str) -> str:\\n forces = [0] * len(dominoes)\\n max_force = len(dominoes)\\n\\n force = 0\\n for i, d in enumerate(dominoes):\\n if d == 'R':\\n force = max_force\\n elif d == 'L': # have to use elif here, not if\\n force = 0\\n else:\\n force = max(0, force - 1)\\n forces[i] += force\\n\\n force = 0\\n for i in range(len(dominoes) - 1, -1, -1):\\n d = dominoes[i]\\n if d == 'L':\\n force = max_force\\n elif d == 'R':\\n force = 0\\n else:\\n force = max(0, force - 1)\\n forces[i] -= force\\n \\n print(forces)\\n\\n result = ''\\n for f in forces:\\n if f == 0:\\n result += '.'\\n elif f > 0:\\n result += 'R'\\n else:\\n result += 'L'\\n return result\\n \\n# TC: O(N)\\n# SC: O(N)\\n\", \"class Solution:\\n def pushDominoes(self, dominoes: str) -> str:\\n n = len(dominoes)\\n balance = [0] * len(dominoes)\\n \\n b = 0\\n for index,c in enumerate(dominoes):\\n if c == 'R':\\n b = n\\n elif c == 'L':\\n b = 0\\n else:\\n b = max(b - 1, 0)\\n balance[index] += b\\n\\n b = 0\\n for index,c in enumerate(reversed(dominoes)):\\n index = -index - 1\\n if c == 'R':\\n b = 0\\n elif c == 'L':\\n b = n\\n else:\\n b = max(b - 1, 0)\\n balance[index] -= b\\n\\n result = ['.'] * len(dominoes)\\n for i in range(len(dominoes)):\\n if dominoes[i] == 'R' or dominoes[i] == 'L':\\n result[i] = dominoes[i]\\n elif balance[i] > 0:\\n result[i] = 'R'\\n elif balance[i] < 0:\\n result[i] = 'L'\\n return ''.join(result)\\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"pushDominoes\", \"inputs\": [[\"\\\".L.R...LR..L..\\\"\"]], \"outputs\": [\"LLL.RR.LLRRLL...\"]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/push-dominoes/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def pushDominoes(self, dominoes: str) -> str:\n "},"solutions_list":{"kind":"list like","value":["INF = float('inf')\nclass Solution:\n def pushDominoes(self, dominoes: str) -> str:\n n = len(dominoes)\n d1 = [-1] * n\n d2 = [-1] * n\n \n cnt = INF\n for i in range(n - 1, -1, -1):\n if dominoes[i] == 'L':\n cnt = 0\n elif dominoes[i] == '.':\n cnt += 1\n elif dominoes[i] == 'R':\n cnt = INF\n d1[i] = cnt\n \n cnt = INF\n for i in range(n):\n if dominoes[i] == 'R':\n cnt = 0\n elif dominoes[i] == '.':\n cnt += 1\n elif dominoes[i] == 'L':\n cnt = INF\n d2[i] = cnt\n \n ret = []\n for i in range(n):\n if d1[i] == d2[i]:\n ret.append('.')\n elif d1[i] < d2[i]:\n ret.append('L')\n else:\n ret.append('R')\n return ''.join(ret)","class Solution:\n def pushDominoes(self, dominoes: str) -> str:\n n = len(dominoes)\n \n d = [0] * n\n \n force = 0\n \n for i in range(n):\n c = dominoes[i]\n \n if c == 'R':\n force = n\n elif c == 'L':\n force = 0\n else:\n force = max(force - 1, 0)\n \n d[i] += force\n \n force = 0\n \n for i in range(n-1, -1, -1):\n c = dominoes[i]\n \n if c == 'R':\n force = 0\n elif c == 'L':\n force = n\n else:\n force = max(force - 1, 0)\n \n d[i] -= force\n \n def inner():\n for f in d:\n if f == 0:\n yield '.'\n elif f > 0:\n yield 'R'\n else:\n yield 'L'\n \n return ''.join(inner())","class Solution:\n def pushDominoes(self, dominoes: str) -> str:\n n = len(dominoes)\n force = [0] * n\n f = 0\n for i in range(n):\n if dominoes[i] == 'R':\n f = n\n elif dominoes[i] == 'L':\n f = 0\n else:\n f = max(f-1, 0)\n force[i] += f\n for i in range(n-1, -1, -1):\n if dominoes[i] == 'L':\n f = n\n elif dominoes[i] == 'R':\n f = 0\n else:\n f = max(f-1, 0)\n force[i] -= f\n return ''.join('.' if f==0 else 'R' if f > 0 else 'L' for f in force)","class Solution:\n def pushDominoes(self, dominoes: str) -> str:\n l = len(dominoes)\n right_force = [0]*l\n left_force = [0]*l\n force1 = 0\n force2 = 0\n for i in range(l):\n if dominoes[i]=='R':\n force1 = l\n elif dominoes[i]=='L':\n force1 = 0\n else:\n force1 = max(force1 - 1, 0)\n right_force[i] += force1\n for i in range(l-1, -1, -1):\n if dominoes[i]=='L':\n force2 = l\n elif dominoes[i]=='R':\n force2 = 0\n else:\n force2 = max(force2 - 1, 0)\n left_force[i] += force2\n\n result = ''\n for i in range(l):\n if right_force[i] > left_force[i]:\n result += 'R'\n elif right_force[i] < left_force[i]:\n result += 'L'\n else:\n result += '.'\n return result","class Solution:\n def pushDominoes(self, dominoes: str) -> str:\n forces = [0] * len(dominoes)\n max_force = len(dominoes)\n\n force = 0\n for i, d in enumerate(dominoes):\n if d == 'R':\n force = max_force\n elif d == 'L': # have to use elif here, not if\n force = 0\n else:\n force = max(0, force - 1)\n forces[i] += force\n\n force = 0\n for i in range(len(dominoes) - 1, -1, -1):\n d = dominoes[i]\n if d == 'L':\n force = max_force\n elif d == 'R':\n force = 0\n else:\n force = max(0, force - 1)\n forces[i] -= force\n \n print(forces)\n\n result = ''\n for f in forces:\n if f == 0:\n result += '.'\n elif f > 0:\n result += 'R'\n else:\n result += 'L'\n return result\n \n# TC: O(N)\n# SC: O(N)\n","class Solution:\n def pushDominoes(self, dominoes: str) -> str:\n n = len(dominoes)\n balance = [0] * len(dominoes)\n \n b = 0\n for index,c in enumerate(dominoes):\n if c == 'R':\n b = n\n elif c == 'L':\n b = 0\n else:\n b = max(b - 1, 0)\n balance[index] += b\n\n b = 0\n for index,c in enumerate(reversed(dominoes)):\n index = -index - 1\n if c == 'R':\n b = 0\n elif c == 'L':\n b = n\n else:\n b = max(b - 1, 0)\n balance[index] -= b\n\n result = ['.'] * len(dominoes)\n for i in range(len(dominoes)):\n if dominoes[i] == 'R' or dominoes[i] == 'L':\n result[i] = dominoes[i]\n elif balance[i] > 0:\n result[i] = 'R'\n elif balance[i] < 0:\n result[i] = 'L'\n return ''.join(result)\n"],"string":"[\n \"INF = float('inf')\\nclass Solution:\\n def pushDominoes(self, dominoes: str) -> str:\\n n = len(dominoes)\\n d1 = [-1] * n\\n d2 = [-1] * n\\n \\n cnt = INF\\n for i in range(n - 1, -1, -1):\\n if dominoes[i] == 'L':\\n cnt = 0\\n elif dominoes[i] == '.':\\n cnt += 1\\n elif dominoes[i] == 'R':\\n cnt = INF\\n d1[i] = cnt\\n \\n cnt = INF\\n for i in range(n):\\n if dominoes[i] == 'R':\\n cnt = 0\\n elif dominoes[i] == '.':\\n cnt += 1\\n elif dominoes[i] == 'L':\\n cnt = INF\\n d2[i] = cnt\\n \\n ret = []\\n for i in range(n):\\n if d1[i] == d2[i]:\\n ret.append('.')\\n elif d1[i] < d2[i]:\\n ret.append('L')\\n else:\\n ret.append('R')\\n return ''.join(ret)\",\n \"class Solution:\\n def pushDominoes(self, dominoes: str) -> str:\\n n = len(dominoes)\\n \\n d = [0] * n\\n \\n force = 0\\n \\n for i in range(n):\\n c = dominoes[i]\\n \\n if c == 'R':\\n force = n\\n elif c == 'L':\\n force = 0\\n else:\\n force = max(force - 1, 0)\\n \\n d[i] += force\\n \\n force = 0\\n \\n for i in range(n-1, -1, -1):\\n c = dominoes[i]\\n \\n if c == 'R':\\n force = 0\\n elif c == 'L':\\n force = n\\n else:\\n force = max(force - 1, 0)\\n \\n d[i] -= force\\n \\n def inner():\\n for f in d:\\n if f == 0:\\n yield '.'\\n elif f > 0:\\n yield 'R'\\n else:\\n yield 'L'\\n \\n return ''.join(inner())\",\n \"class Solution:\\n def pushDominoes(self, dominoes: str) -> str:\\n n = len(dominoes)\\n force = [0] * n\\n f = 0\\n for i in range(n):\\n if dominoes[i] == 'R':\\n f = n\\n elif dominoes[i] == 'L':\\n f = 0\\n else:\\n f = max(f-1, 0)\\n force[i] += f\\n for i in range(n-1, -1, -1):\\n if dominoes[i] == 'L':\\n f = n\\n elif dominoes[i] == 'R':\\n f = 0\\n else:\\n f = max(f-1, 0)\\n force[i] -= f\\n return ''.join('.' if f==0 else 'R' if f > 0 else 'L' for f in force)\",\n \"class Solution:\\n def pushDominoes(self, dominoes: str) -> str:\\n l = len(dominoes)\\n right_force = [0]*l\\n left_force = [0]*l\\n force1 = 0\\n force2 = 0\\n for i in range(l):\\n if dominoes[i]=='R':\\n force1 = l\\n elif dominoes[i]=='L':\\n force1 = 0\\n else:\\n force1 = max(force1 - 1, 0)\\n right_force[i] += force1\\n for i in range(l-1, -1, -1):\\n if dominoes[i]=='L':\\n force2 = l\\n elif dominoes[i]=='R':\\n force2 = 0\\n else:\\n force2 = max(force2 - 1, 0)\\n left_force[i] += force2\\n\\n result = ''\\n for i in range(l):\\n if right_force[i] > left_force[i]:\\n result += 'R'\\n elif right_force[i] < left_force[i]:\\n result += 'L'\\n else:\\n result += '.'\\n return result\",\n \"class Solution:\\n def pushDominoes(self, dominoes: str) -> str:\\n forces = [0] * len(dominoes)\\n max_force = len(dominoes)\\n\\n force = 0\\n for i, d in enumerate(dominoes):\\n if d == 'R':\\n force = max_force\\n elif d == 'L': # have to use elif here, not if\\n force = 0\\n else:\\n force = max(0, force - 1)\\n forces[i] += force\\n\\n force = 0\\n for i in range(len(dominoes) - 1, -1, -1):\\n d = dominoes[i]\\n if d == 'L':\\n force = max_force\\n elif d == 'R':\\n force = 0\\n else:\\n force = max(0, force - 1)\\n forces[i] -= force\\n \\n print(forces)\\n\\n result = ''\\n for f in forces:\\n if f == 0:\\n result += '.'\\n elif f > 0:\\n result += 'R'\\n else:\\n result += 'L'\\n return result\\n \\n# TC: O(N)\\n# SC: O(N)\\n\",\n \"class Solution:\\n def pushDominoes(self, dominoes: str) -> str:\\n n = len(dominoes)\\n balance = [0] * len(dominoes)\\n \\n b = 0\\n for index,c in enumerate(dominoes):\\n if c == 'R':\\n b = n\\n elif c == 'L':\\n b = 0\\n else:\\n b = max(b - 1, 0)\\n balance[index] += b\\n\\n b = 0\\n for index,c in enumerate(reversed(dominoes)):\\n index = -index - 1\\n if c == 'R':\\n b = 0\\n elif c == 'L':\\n b = n\\n else:\\n b = max(b - 1, 0)\\n balance[index] -= b\\n\\n result = ['.'] * len(dominoes)\\n for i in range(len(dominoes)):\\n if dominoes[i] == 'R' or dominoes[i] == 'L':\\n result[i] = dominoes[i]\\n elif balance[i] > 0:\\n result[i] = 'R'\\n elif balance[i] < 0:\\n result[i] = 'L'\\n return ''.join(result)\\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":6,"string":"6"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4,5],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":90,"cells":{"problem_id":{"kind":"number","value":226,"string":"226"},"question":{"kind":"string","value":"Given an array A of non-negative integers, the array is squareful if for every pair of adjacent elements, their sum is a perfect square.\nReturn the number of permutations of A that are squareful. Two permutations A1 and A2 differ if and only if there is some index i such that A1[i] != A2[i].\n \nExample 1:\nInput: [1,17,8]\nOutput: 2\nExplanation: \n[1,8,17] and [17,8,1] are the valid permutations.\n\nExample 2:\nInput: [2,2,2]\nOutput: 1\n\n \nNote:\n\n1 <= A.length <= 12\n0 <= A[i] <= 1e9"},"solutions":{"kind":"string","value":"[\"\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n\\n A.sort()\\n self.ans = 0\\n\\n def check(A, i, path):\\n return int((A[i] + path[-1])**0.5 + 0.0)**2 == A[i] + path[-1]\\n\\n def dfs(A, path):\\n if not A:\\n self.ans += 1\\n return\\n\\n for i in range(len(A)):\\n if i > 0 and A[i] == A[i - 1]:\\n continue\\n if not path or (path and check(A, i, path)):\\n dfs(A[:i] + A[i + 1:], path + [A[i]])\\n\\n dfs(A, [])\\n return self.ans\\n\", \"from copy import copy\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n \\n d = dict()\\n count = dict()\\n lim = len(A)\\n blank = dict()\\n for i in range(0,lim-1): \\n try:\\n count[A[i]]+=1\\n except:\\n blank[A[i]]=0\\n count[A[i]]=1\\n for j in range(i+1,lim):\\n if ((A[i]+A[j])**.5).is_integer():\\n try:\\n d[A[i]].add(A[j])\\n except:\\n d[A[i]] = set()\\n d[A[i]].add(A[j])\\n try:\\n d[A[j]].add(A[i])\\n except:\\n d[A[j]] = set()\\n d[A[j]].add(A[i])\\n try:\\n count[A[-1]]+=1\\n except:\\n count[A[-1]]=1\\n blank[A[-1]]=0\\n \\n check = sorted(A)\\n if d==dict():return 0\\n f = set()\\n c = 0\\n def r(val,ld,l,lth):\\n if lth==lim:\\n f.add(tuple(l))\\n else:\\n if val in d:\\n for x in d[val]:\\n s = copy(ld)\\n if s[x]<=count[x]:\\n s[x]+=1\\n r(x,s,l+[x],lth+1)\\n \\n for x in set(A):\\n r(x,blank,[x],1)\\n for x in f:\\n if sorted(list(x))==check:c+=1\\n return c\\n\", \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n def get_valid():\\n ans = 0\\n seen = set()\\n visited = set()\\n while q:\\n cur, remaining = q.popleft()\\n if not remaining and cur not in seen:\\n ans += 1\\n for i, n in enumerate(remaining):\\n sq = (cur[-1] + n) ** .5\\n if float(int(sq)) == sq:\\n add = cur + (n,)\\n remain = remaining[:i] + remaining[i+1:]\\n if (add, remain) not in visited:\\n q.append((add, remain))\\n visited.add((add, remain))\\n return ans\\n\\n q = deque()\\n for i, num in enumerate(A):\\n q.append(((num, ), tuple(A[:i] + A[i+1:])))\\n\\n return get_valid()\", \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n c = collections.Counter(A)\\n cand = {i: {j for j in c if int((i + j)**0.5) ** 2 == i + j} for i in c}\\n\\n def dfs(x, left=len(A) - 1):\\n c[x] -= 1\\n count = sum(dfs(y, left - 1) for y in cand[x] if c[y]) if left else 1\\n c[x] += 1\\n return count\\n return sum(map(dfs, c))\", \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n ''' \\n # graph of indices, works if we don't have duplicate elements\\n graph = collections.defaultdict(list)\\n for i in range(len(A)):\\n for j in range(i+1, len(A)):\\n if int((A[i]+A[j])**0.5)**2==(A[i]+A[j]):\\n graph[i] += [j]\\n graph[j] += [i]\\n # source node\\n graph[-1] = [i for i in range(len(A))]\\n def dfs(node, visited):\\n if len(visited)==len(A):\\n return 1\\n res = 0\\n for neighbor in graph[node]:\\n if neighbor in visited:\\n continue\\n res += dfs(neighbor, visited|{neighbor})\\n return res\\n return dfs(-1, set())\\n ''' \\n candidates = collections.Counter(A)\\n graph = {x: [y for y in candidates if int((x+y)**0.5)**2==x+y] for x in candidates}\\n # source node\\n graph[-1] = [x for x in candidates]\\n def dfs(node, node_left):\\n if node_left==0:\\n return 1\\n res = 0\\n for n in graph[node]:\\n if candidates[n]==0:\\n continue\\n candidates[n] -= 1\\n res += dfs(n, node_left-1)\\n candidates[n] += 1\\n return res\\n return dfs(-1, len(A))\", \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n #visited = [False] * len(A)\\n \\n visited = collections.Counter(A)\\n \\n ans = [0]\\n self.calc(A, visited, [], ans)\\n \\n return ans[0]\\n \\n def calc(self, A, visited, tmp, ans):\\n if len(tmp) == len(A): \\n ans[0] += 1\\n #print(tmp)\\n \\n for i in list(visited.keys()):\\n if visited[i] == 0:\\n continue\\n \\n visited[i] -= 1\\n tmp.append(i)\\n \\n if len(tmp) < 2 or (tmp[-1] + tmp[-2])**(0.5) == int((tmp[-1] + tmp[-2])**(0.5)):\\n self.calc(A, visited, tmp, ans)\\n \\n tmp.pop()\\n visited[i] += 1\\n\", \"class Solution:\\n def numSquarefulPerms(self, nums: List[int]) -> int:\\n #nums.sort()\\n self.ans = 0\\n \\n def isSquare(v):\\n x = int(v**0.5)\\n return x * x == v\\n \\n def dfs(pos):\\n \\n if pos >= len(nums):\\n self.ans += 1\\n return\\n \\n used = set()\\n for i in range(pos, len(nums)):\\n if nums[i] in used:\\n continue\\n used.add(nums[i])\\n nums[pos], nums[i] = nums[i], nums[pos]\\n \\n if (pos == 0) or ( pos > 0 and isSquare(nums[pos] + nums[pos-1])):\\n dfs(pos+1)\\n nums[pos], nums[i] = nums[i], nums[pos]\\n dfs(0)\\n return self.ans\", \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n n = len(A)\\n A = sorted(A)\\n # g[i][j] = 1 if A[i], A[j] are squareful\\n g = [[0] * n for _ in range(n)]\\n # dp[s][i]: number of ways to reach state s and ends with node i\\n dp = [[0] * n for _ in range(1 << n)]\\n \\n for i in range(n):\\n for j in range(n):\\n if i == j:\\n continue\\n r = int((A[i] + A[j]) ** 0.5)\\n if r ** 2 == A[i] + A[j]:\\n g[i][j] = 1\\n \\n for i in range(n):\\n if i == 0 or A[i] != A[i - 1]:\\n dp[(1 << i)][i] = 1\\n \\n ans = 0\\n for s in range(1 << n):\\n for i in range(n):\\n if not dp[s][i]:\\n continue\\n for j in range(n):\\n if not g[i][j]:\\n continue\\n if s & (1 << j):\\n continue\\n if j > 0 and not (s & (1 << (j - 1))) and A[j - 1] == A[j]:\\n continue\\n dp[s | (1 << j)][j] += dp[s][i]\\n \\n for i in range(n):\\n ans += dp[(1 << n) - 1][i]\\n \\n return ans\\n\", \"# https://zxi.mytechroad.com/blog/searching/leetcode-996-number-of-squareful-arrays/\\n# g[i][j]: if i and j are squareful\\n# dp[s][i]: # of ways to reach state s (binary mask of nodes visited) that ends with node i\\n# dp[s | (1 << j)][j] += dp[s][i] if g[i][j]\\n# \\u5148\\u5bf9\\u6570\\u7ec4\\u6392\\u5e8f, \\u7136\\u540e\\u8ba1\\u7b97\\u51fa\\u6240\\u6709\\u7684 g[i][j]\\n# for i in range(n) \\u521d\\u59cb\\u5316 dp[(1 << i)][i] = 1, \\u8868\\u793a\\u53ea\\u6709\\u4e00\\u4e2a\\u6570\\u5b57 i \\u7684\\u60c5\\u51b5, \\u6bcf\\u4e2a\\u90fd\\u662f\\u4e00\\u79cd\\n# \\u5982\\u679c\\u6709\\u591a\\u4e2a\\u91cd\\u590d\\u7684\\u6570\\u5b57, \\u53ea\\u7528\\u7b2c\\u4e00\\u4e2a\\u6570\\u5b57\\u4f5c\\u4e3a\\u5f00\\u5934\\n# ans = sum(dp[(1 << n) - 1][i])\\n# O(n^2*2^n) time complexity, O(2^n) space complexity\\nimport math\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n n = len(A)\\n A = sorted(A)\\n g = [[False] * n for _ in range(n)]\\n dp = [[0] * n for _ in range(1 << n)]\\n \\n for i in range(n):\\n for j in range(n):\\n if i == j:\\n continue\\n if int((A[i] + A[j]) ** 0.5 + 0.5) ** 2 == A[i] + A[j]:\\n g[i][j] = True\\n\\n for i in range(n):\\n if i > 0 and A[i] == A[i - 1]: # For the same numbers, only the first one can be the starting point\\n continue\\n dp[1 << i][i] = 1\\n\\n for s in range(1 << n):\\n for i in range(n):\\n if dp[s][i] <= 0: # \\u5982\\u679c dp[s][i] <= 0, \\u8bf4\\u660e\\u6ca1\\u6709\\u4ee5 i \\u7ed3\\u5c3e\\u7684\\u60c5\\u51b5, \\u8df3\\u8fc7\\n continue\\n for j in range(n): # \\u5c1d\\u8bd5\\u8ba9\\u4efb\\u610f\\u4e00\\u4e2a\\u6570\\u5b57\\u8fde\\u63a5\\u5728\\u6700\\u540e\\u9762\\n if not g[i][j] or (s & (1 << j)): # \\u5982\\u679c i, j \\u4e0d\\u662f squareful \\u6216 j \\u5df2\\u7ecf\\u4f7f\\u7528\\u8fc7, \\u8df3\\u8fc7\\n continue\\n if j > 0 and not (s & (1 << (j - 1))) and A[j] == A[j - 1]: # \\u51fa\\u73b0\\u91cd\\u590d\\u7684\\u53ea\\u4f7f\\u7528\\u7b2c\\u4e00\\u4e2a\\n continue\\n dp[s | (1 << j)][j] += dp[s][i]\\n \\n res = 0\\n for i in range(n):\\n res += dp[(1 << n) - 1][i]\\n return res\\n\", \"import numpy as np\\nclass Solution:\\n graph = {}\\n count = {}\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n self.graph = {}\\n self.count = {}\\n for i in A:\\n if i in self.count:\\n self.count[i] += 1\\n else:\\n self.count[i] = 1\\n self.graph[i] = []\\n \\n for i in self.count:\\n for j in self.count:\\n r = int(np.sqrt(i + j))\\n if r * r == i + j:\\n self.graph[i].append(j)\\n ans = 0\\n L = len(A)\\n for i in self.graph:\\n ans += self.dfs(i, L-1)\\n return ans\\n \\n def dfs(self, i, L):\\n self.count[i] -= 1\\n ans = 1\\n if L != 0:\\n ans = 0\\n for j in self.graph[i]:\\n if self.count[j] != 0:\\n ans += self.dfs(j, L - 1)\\n self.count[i] += 1\\n return ans\\n \\n\", \"import numpy as np\\n\\n\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n N = len(A)\\n count = collections.Counter(A)\\n graph = collections.defaultdict(list)\\n for x in count:\\n for y in count:\\n if int((x + y) ** (0.5)) ** 2 == (x + y):\\n graph[x].append(y)\\n \\n def dfs(x, todo):\\n count[x] -= 1\\n if todo == 0:\\n ans = 1\\n else:\\n ans = 0\\n for y in graph[x]:\\n if count[y]:\\n ans += dfs(y, todo - 1)\\n \\n count[x] += 1\\n return ans\\n \\n return sum(dfs(x, N - 1) for x in count)\", \"import numpy as np\\nclass Solution:\\n graph = {}\\n count = {}\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n self.graph = {}\\n self.count = {}\\n for i in A:\\n if i in self.count:\\n self.count[i] += 1\\n else:\\n self.count[i] = 1\\n self.graph[i] = []\\n \\n for i in self.count:\\n for j in self.count:\\n r = int(np.sqrt(i + j))\\n if r * r == i + j:\\n self.graph[i].append(j)\\n ans = 0\\n L = len(A)\\n print((self.count))\\n print((self.graph))\\n for i in self.graph:\\n ans += self.dfs(i, L-1)\\n return ans\\n \\n def dfs(self, i, L):\\n self.count[i] -= 1\\n ans = 1\\n if L != 0:\\n ans = 0\\n for j in self.graph[i]:\\n if self.count[j] != 0:\\n ans += self.dfs(j, L - 1)\\n self.count[i] += 1\\n return ans\\n \\n\", \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n def edge(x, y):\\n return int((x + y) ** 0.5) ** 2 == (x + y)\\n \\n def dfs(x, t):\\n count[x] -= 1\\n if t == 0:\\n ans = 1\\n else:\\n ans = 0\\n for y in graph[x]:\\n if count[y]:\\n ans += dfs(y, t - 1)\\n count[x] += 1\\n return ans\\n \\n N = len(A)\\n count = collections.Counter(A)\\n graph = collections.defaultdict(list)\\n for x in count:\\n for y in count:\\n if edge(x, y):\\n graph[x].append(y)\\n \\n return sum(dfs(x, N - 1) for x in count)\\n\", \"from functools import lru_cache\\n\\n\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n def edge(x, y):\\n r = math.sqrt(x + y)\\n return int(r) ** 2 == (x + y)\\n \\n @lru_cache(None)\\n def dfs(node, seen):\\n if seen == (1 << N) - 1:\\n return 1\\n \\n ans = 0\\n for n in graph[node]:\\n nxt = seen | (1 << n)\\n if nxt == seen:\\n continue\\n ans += dfs(n, nxt)\\n return ans\\n \\n \\n N = len(A)\\n count = collections.Counter(A)\\n graph = [[] for _ in range(N)]\\n \\n for i in range(N):\\n for j in range(i + 1, N):\\n if edge(A[i], A[j]):\\n graph[i].append(j)\\n graph[j].append(i)\\n \\n ans = sum(dfs(i, 1 << i) for i in range(N))\\n for v in count.values():\\n ans //= math.factorial(v)\\n \\n return ans\", \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n import math\\n \\n def is_not_square(num): \\n return int(math.sqrt(num) + 0.5) ** 2 != num\\n \\n memo = {}\\n def perms(arr):\\n key = tuple(sorted(arr))\\n \\n if key in memo: return memo[key]\\n if len(arr) <= 1: return [arr]\\n \\n permutations = []\\n seen = set()\\n for i in range(len(arr)):\\n el = arr[i]\\n rest = arr[:i] + arr[i+1:]\\n # if all([is_not_square(el+n) for n in rest]): continue\\n if el not in seen:\\n sub_perms = perms(rest)\\n if not sub_perms: continue\\n for p in sub_perms:\\n if not is_not_square(el + p[0]):\\n permutations.append([el] + p)\\n seen.add(arr[i])\\n \\n memo[key] = permutations\\n return permutations\\n \\n \\n return len(perms(A))\\n \\n\", \"from functools import lru_cache\\n\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n N = len(A)\\n \\n def valid(x,y):\\n return (math.sqrt(x+y)).is_integer()\\n \\n graph = [[] for _ in range(N)]\\n \\n for i,x in enumerate(A):\\n for j in range(i):\\n if valid(x,A[j]):\\n graph[i].append(j)\\n graph[j].append(i)\\n \\n # FINDING NO OF HAMILTONIAN PATH\\n \\n @lru_cache(None)\\n def dfs(node,visited):\\n if visited == (1<<N) - 1:\\n return 1\\n \\n ans = 0\\n for val in graph[node]:\\n if (visited & 1<<val)==0:\\n ans+= dfs(val,visited | 1<<val)\\n return ans\\n \\n ans = sum(dfs(i,1<<i) for i in range(N))\\n count = collections.Counter(A)\\n for v in count.values():\\n ans //= math.factorial(v)\\n return ans\", \"from functools import lru_cache\\n\\nclass Solution:\\n def numSquarefulPerms(self, A):\\n N = len(A)\\n\\n def edge(x, y):\\n r = math.sqrt(x+y)\\n return int(r + 0.5) ** 2 == x+y\\n\\n graph = [[] for _ in range(len(A))]\\n for i, x in enumerate(A):\\n for j in range(i):\\n if edge(x, A[j]):\\n graph[i].append(j)\\n graph[j].append(i)\\n\\n # find num of hamiltonian paths in graph\\n\\n @lru_cache(None)\\n def dfs(node, visited):\\n if visited == (1 << N) - 1:\\n return 1\\n\\n ans = 0\\n for nei in graph[node]:\\n if (visited >> nei) & 1 == 0:\\n ans += dfs(nei, visited | (1 << nei))\\n return ans\\n\\n ans = sum(dfs(i, 1<<i) for i in range(N))\\n count = collections.Counter(A)\\n for v in count.values():\\n ans //= math.factorial(v)\\n return ans\", \"from functools import lru_cache\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n N = len(A)\\n\\n def edge(x, y):\\n r = math.sqrt(x+y)\\n return int(r + 0.5) ** 2 == x+y\\n\\n graph = [[] for _ in range(len(A))]\\n for i, x in enumerate(A):\\n for j in range(i):\\n if edge(x, A[j]):\\n graph[i].append(j)\\n graph[j].append(i)\\n\\n # find num of hamiltonian paths in graph\\n\\n @lru_cache(None)\\n def dfs(node, visited):\\n if visited == (1 << N) - 1:\\n return 1\\n\\n ans = 0\\n for nei in graph[node]:\\n if (visited >> nei) & 1 == 0:\\n ans += dfs(nei, visited | (1 << nei))\\n return ans\\n\\n ans = sum(dfs(i, 1<<i) for i in range(N))\\n count = collections.Counter(A)\\n for v in count.values():\\n ans //= math.factorial(v)\\n return ans\", \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n N = len(A)\\n\\n def edge(x, y):\\n r = math.sqrt(x+y)\\n return int(r + 0.5) ** 2 == x+y\\n\\n graph = [[] for _ in range(len(A))]\\n for i, x in enumerate(A):\\n for j in range(i):\\n if edge(x, A[j]):\\n graph[i].append(j)\\n graph[j].append(i)\\n\\n # find num of hamiltonian paths in graph\\n\\n @lru_cache(None)\\n def dfs(node, visited):\\n if visited == (1 << N) - 1:\\n return 1\\n\\n ans = 0\\n for nei in graph[node]:\\n if (visited >> nei) & 1 == 0:\\n ans += dfs(nei, visited | (1 << nei))\\n return ans\\n\\n ans = sum(dfs(i, 1<<i) for i in range(N))\\n count = collections.Counter(A)\\n for v in count.values():\\n ans //= math.factorial(v)\\n return ans\", \"\\n\\n\\ndef getPermutations(array):\\n ans = set()\\n def helper(arr,i,ans):\\n if i==len(arr)-1:\\n\\n ans.add(tuple(arr))\\n return\\n \\n for j in range(i,len(arr)):\\n if not (arr[i]==arr[j] and i!=j):\\n test = (i<=1) or (((arr[i-1]+arr[i-2])**0.5)==int((arr[i-1]+arr[i-2])**0.5))\\n swap(arr,i,j)\\n if (test):\\n helper(arr,i+1,ans)\\n \\n swap(arr,i,j)\\n \\n def swap(arr,i,j):\\n arr[i],arr[j]=arr[j],arr[i]\\n \\n helper(array,0,ans)\\n return ans\\n\\nclass Solution:\\n \\n \\n \\n def numSquarefulPerms(self, A: List[int]) -> int:\\n va = getPermutations(A)\\n \\n valid = 0\\n # print(va)\\n for a in va:\\n isValid = True\\n # print(a)\\n for idx in range(1,len(a)):\\n \\n if ((a[idx]+a[idx-1])**0.5)!=int((a[idx]+a[idx-1])**0.5):\\n # print(a,idx)\\n isValid = False\\n break\\n \\n if isValid:\\n # print(a)\\n valid+=1\\n \\n # print(valid)\\n return valid\\n \\n\", \"from functools import lru_cache\\n\\nclass Solution:\\n def numSquarefulPerms(self, A):\\n N = len(A)\\n\\n def edge(x, y):\\n r = math.sqrt(x+y)\\n return int(r + 0.5) ** 2 == x+y\\n\\n graph = [[] for _ in range(len(A))]\\n for i, x in enumerate(A):\\n for j in range(i):\\n if edge(x, A[j]):\\n graph[i].append(j)\\n graph[j].append(i)\\n\\n # find num of hamiltonian paths in graph\\n @lru_cache(None)\\n def dfs(node, visited):\\n if visited == (1 << N) - 1:\\n return 1\\n ans = 0\\n for nei in graph[node]:\\n if (visited >> nei) & 1 == 0:\\n ans += dfs(nei, visited | (1 << nei))\\n return ans\\n\\n ans = sum(dfs(i, 1<<i) for i in range(N))\\n count = collections.Counter(A)\\n for v in count.values():\\n ans //= math.factorial(v)\\n return ans\", \"class Solution:\\n def numSquarefulPerms(self, A):\\n A.sort()\\n N = len(A)\\n graph = [[0] * N for _ in range(N)]\\n\\n for i in range(N):\\n for j in range(N):\\n if i==j: continue\\n if int((A[i]+A[j])**0.5)**2==(A[i]+A[j]):\\n graph[i][j]=1\\n graph[j][i]=1\\n\\n\\n dp=[[0]*N for i in range(1<<N)]\\n for i in range(N):\\n dp[1<<i][i]=1\\n for s in range(1<<N):\\n for i in range(N):\\n if not dp[s][i]: continue\\n for j in range(N):\\n if not graph[i][j]: continue\\n if s&(1<<j): continue\\n if j>0 and s&(1<<(j-1)) and A[j]==A[j-1]:continue\\n dp[s|(1<<j)][j]+=dp[s][i]\\n\\n ans=0\\n for i in range(N):\\n ans+=dp[-1][i]\\n\\n return ans\\n \\n\\n \\n\", \"from collections import Counter\\n\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n \\n counts = Counter(A)\\n graph = {x: [] for x in counts}\\n \\n for x in counts:\\n for y in counts:\\n r = int((x + y) ** 0.5 + 0.5)\\n if r * r == x + y:\\n graph[x].append(y)\\n \\n def dfs(x, todo):\\n counts[x] -= 1\\n if todo == 0:\\n res = 1\\n else:\\n res = 0\\n for y in graph[x]:\\n if counts[y] > 0:\\n res += dfs(y, todo - 1)\\n\\n counts[x] += 1\\n return res\\n \\n \\n return sum(dfs(x, len(A) - 1) for x in counts)\", \"from collections import Counter\\nfrom functools import lru_cache\\nimport math\\n\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n # Backtracking\\n # Time complexity: O(N^N)\\n # Space complexity: O(N)\\n # N = len(A)\\n # count = Counter(A)\\n\\n # graph = {x: [] for x in count}\\n # for x in count:\\n # for y in count:\\n # if int((x + y) ** .5 + 0.5) ** 2 == x + y:\\n # graph[x].append(y)\\n\\n # def dfs(x, todo):\\n # count[x] -= 1\\n # if todo == 0:\\n # ans = 1\\n # else:\\n # ans = 0\\n # for y in graph[x]:\\n # if count[y]:\\n # ans += dfs(y, todo - 1)\\n\\n # count[x] += 1\\n # return ans\\n\\n # return sum(dfs(x, len(A) - 1) for x in count)\\n\\n\\n # Dynamic Programming\\n # Time complexity: O(N^2 x 2^N) = O(sum_{k=1}^{N} C_N^K x C_k^2)\\n # Space complexity: O(N x 2^N)\\n N = len(A)\\n\\n def edge(x, y):\\n r = math.sqrt(x + y)\\n return int(r + 0.5) ** 2 == x + y\\n\\n graph = [[] for _ in range(len(A))]\\n for i, x in enumerate(A):\\n for j in range(i):\\n if edge(x, A[j]):\\n graph[i].append(j)\\n graph[j].append(i)\\n\\n # find num of hamiltonian paths in graph\\n @lru_cache(None)\\n def dfs(node, visited):\\n if visited == (1 << N) - 1:\\n return 1\\n\\n ans = 0\\n for nei in graph[node]:\\n if (visited >> nei) & 1 == 0:\\n ans += dfs(nei, visited | 1 << nei)\\n return ans\\n\\n ans = sum(dfs(i, 1 << i) for i in range(N))\\n count = Counter(A)\\n for v in list(count.values()):\\n ans //= math.factorial(v)\\n return ans\\n\\n\\n # c = Counter(A)\\n # cand = {i: {j for j in c if int((i+j)**.5) ** 2 == i + j} for i in c}\\n # self.res = 0\\n\\n # def dfs(x, left=len(A)-1):\\n # c[x] -= 1\\n # if left == 0:\\n # self.res += 1\\n # for y in cand[x]:\\n # if c[y]:\\n # dfs(y, left - 1)\\n # c[x] += 1\\n\\n # for x in c: dfs(x)\\n # return self.res\\n\\n\\n # def backtrack(i, A):\\n # if i > 1:\\n # val = A[i - 2] + A[i - 1]\\n # is_square = math.sqrt(val) == math.floor(math.sqrt(val))\\n # if not is_square:\\n # return\\n\\n # if i == len(A):\\n # output.append(A)\\n # return\\n\\n # for j in range(i, len(A)):\\n # A[i], A[j] = A[j], A[i]\\n # search = (i, A[i], tuple(A[:i]))\\n # if search not in seen:\\n # seen.add(search)\\n # backtrack(i + 1, A)\\n\\n # A[i], A[j] = A[j], A[i]\\n\\n # output, seen = [], set()\\n # backtrack(0, A)\\n # return len(output)\\n\\n\", \"class Solution:\\n \\n def dfs(self, pos):\\n if pos==self.n:\\n self.ans += 1\\n return\\n \\n last = None\\n for i, val in enumerate(self.a):\\n if self.usable[i]:\\n if val == last:\\n continue\\n if pos-1 >= 0 and (val + self.rec[pos-1]) not in self.square:\\n continue\\n \\n self.usable[i] = False\\n self.rec[pos] = val\\n self.dfs(pos + 1)\\n self.usable[i] = True\\n last = val\\n \\n def numSquarefulPerms(self, A: List[int]) -> int:\\n \\n self.a = sorted(A)\\n self.square=set()\\n i = 0 # not 1\\n while i*i <= self.a[-1]*2:\\n self.square.add(i*i)\\n i += 1\\n \\n #print(self.square)\\n self.ans = 0\\n self.n = len(self.a) \\n self.usable = [True]*self.n\\n self.rec = [None]*self.n\\n self.dfs(0)\\n return self.ans\\n \\n \\n \\n\", \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n \\n d = defaultdict(int)\\n res = 0\\n \\n ps = {}\\n i = 0\\n while i*i <= 2*max(A):\\n ps[i*i]=True\\n i += 1\\n \\n def ok(x):\\n return x in ps\\n \\n def solve(x):\\n nonlocal res\\n # takes some number X and multiset D. Returns answer of the problem for numbers in D such that first number is X\\n if not len(d):\\n res += 1\\n return\\n for k in list(d.keys()):\\n if not ok(x + k): continue\\n d[k] -= 1\\n if d[k] == 0: del d[k]\\n solve(k)\\n d[k] += 1\\n \\n \\n for x in A: d[x] += 1\\n for k in list(d.keys()):\\n d[k] -= 1\\n if not d[k]: del d[k]\\n solve(k)\\n d[k] += 1\\n \\n return res\\n \\n\", \"from typing import List\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def helper(self, last_num, used, partners, index):\\n if index == len(used):\\n return 1\\n total = 0\\n # print(partners, partners[last_num])\\n for partner, partner_list in partners[last_num].items():\\n for partner_index in partner_list:\\n if not used[partner_index]:\\n used[partner_index] = True\\n total += self.helper(partner, used, partners, index+1)\\n used[partner_index] = False\\n break\\n return total\\n\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n squares = set()\\n i = 0\\n partners = defaultdict(lambda: defaultdict(set))\\n while i * i <= 200000000:\\n squares.add(i*i)\\n i += 1\\n for i in range(len(A)):\\n for j in range(i+1, len(A), 1):\\n if A[i] + A[j] in squares:\\n partners[A[i]][A[j]].add(j)\\n partners[A[j]][A[i]].add(i)\\n unique_nums = dict()\\n for i, num in enumerate(A):\\n unique_nums[num] = i\\n used = [False for _ in A]\\n total = 0\\n for num, i in unique_nums.items():\\n used[i] = True\\n total += self.helper(num, used, partners, 1)\\n used[i] = False\\n return total\", \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n\\n A.sort()\\n self.ans = 0\\n\\n def check(A, i, path):\\n return int((A[i] + path[-1])**0.5 + 0.0)**2 == A[i] + path[-1]\\n\\n def dfs(A, path):\\n if len(A) == 0:\\n self.ans += 1\\n return\\n\\n for i in range(len(A)):\\n if i > 0 and A[i] == A[i - 1]:\\n continue\\n if len(path) == 0 or (len(path) > 0 and check(A, i, path)):\\n dfs(A[:i] + A[i + 1:], path + [A[i]])\\n\\n dfs(A, [])\\n return self.ans\\n\", \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n def edge(x, y):\\n return int((x + y) ** 0.5) ** 2 == (x + y)\\n \\n def dfs(x, t):\\n count[x] -= 1\\n if t == 0:\\n ans = 1\\n else:\\n ans = 0\\n for y in graph[x]:\\n if count[y]:\\n ans += dfs(y, t - 1)\\n count[x] += 1\\n return ans\\n \\n N = len(A)\\n count = collections.Counter(A)\\n graph = collections.defaultdict(list)\\n for x in count:\\n for y in count:\\n if edge(x, y):\\n graph[x].append(y)\\n \\n return sum(dfs(x, N - 1) for x in count)\\n \\n \\n \\n \\n \\n\", \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n A.sort()\\n n = len(A)\\n visited = [False] * n\\n res = []\\n self.count = 0\\n def dfs(curr):\\n if len(curr) == n:\\n self.count += 1\\n return \\n for i in range(n):\\n if visited[i]: continue \\n if i > 0 and A[i] == A[i - 1] and not visited[i - 1]: continue \\n if len(curr) > 0 and (int((curr[-1] + A[i]) ** 0.5))**2 != curr[-1] + A[i]: continue \\n visited[i] = True\\n dfs(curr + [A[i]])\\n visited[i] = False\\n dfs([])\\n return self.count\\n\", \"from math import sqrt\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n return self.backtrack(A, 0, set())\\n \\n def isPerfect(self, num):\\n return int(sqrt(num))**2 == num\\n \\n def backtrack(self, permutation, j, seen):\\n permutation_tuple = (j,) + tuple(permutation)\\n if permutation_tuple in seen: return 0\\n seen.add(permutation_tuple)\\n if j == len(permutation):\\n return 1\\n total = 0\\n for i in range(j, len(permutation)):\\n self.swap(permutation, i, j)\\n if j == 0 or self.isPerfect(permutation[j] + permutation[j-1]):\\n total += self.backtrack(permutation, j+1, seen)\\n self.swap(permutation, i, j)\\n return total\\n \\n def swap(self, array, i, j):\\n array[i], array[j] = array[j], array[i]\\n\", \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n count ={}\\n for i in A:\\n count[i]=count.get(i,0)+1\\n graph = {x: [] for x in A}\\n for x in count:\\n for y in count:\\n if int((x + y) ** 0.5 + 0.5) ** 2 == x + y:\\n graph[x].append(y)\\n def dfs(x, todo):\\n count[x] -= 1\\n if todo == 0:\\n ans = 1\\n else:\\n ans = 0\\n for y in graph[x]:\\n if count[y]:\\n ans += dfs(y, todo - 1)\\n count[x] += 1\\n return ans\\n\\n return sum(dfs(x, len(A) - 1) for x in count)\\n\", \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n c = {}\\n for i in A:\\n c[i]=c.get(i,0)+1\\n cand = {i: [j for j in c if int((i + j)**0.5) ** 2 == i + j] for i in c}\\n\\n def dfs(x, left=len(A) - 1):\\n c[x] -= 1\\n count = sum(dfs(y, left - 1) for y in cand[x] if c[y]) if left else 1\\n c[x] += 1\\n return count\\n return sum(map(dfs, c))\\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"numSquarefulPerms\", \"inputs\": [[[1, 17, 8]]], \"outputs\": [2]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/number-of-squareful-arrays/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n "},"solutions_list":{"kind":"list like","value":["\nclass Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n\n A.sort()\n self.ans = 0\n\n def check(A, i, path):\n return int((A[i] + path[-1])**0.5 + 0.0)**2 == A[i] + path[-1]\n\n def dfs(A, path):\n if not A:\n self.ans += 1\n return\n\n for i in range(len(A)):\n if i > 0 and A[i] == A[i - 1]:\n continue\n if not path or (path and check(A, i, path)):\n dfs(A[:i] + A[i + 1:], path + [A[i]])\n\n dfs(A, [])\n return self.ans\n","from copy import copy\nclass Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n \n d = dict()\n count = dict()\n lim = len(A)\n blank = dict()\n for i in range(0,lim-1): \n try:\n count[A[i]]+=1\n except:\n blank[A[i]]=0\n count[A[i]]=1\n for j in range(i+1,lim):\n if ((A[i]+A[j])**.5).is_integer():\n try:\n d[A[i]].add(A[j])\n except:\n d[A[i]] = set()\n d[A[i]].add(A[j])\n try:\n d[A[j]].add(A[i])\n except:\n d[A[j]] = set()\n d[A[j]].add(A[i])\n try:\n count[A[-1]]+=1\n except:\n count[A[-1]]=1\n blank[A[-1]]=0\n \n check = sorted(A)\n if d==dict():return 0\n f = set()\n c = 0\n def r(val,ld,l,lth):\n if lth==lim:\n f.add(tuple(l))\n else:\n if val in d:\n for x in d[val]:\n s = copy(ld)\n if s[x]<=count[x]:\n s[x]+=1\n r(x,s,l+[x],lth+1)\n \n for x in set(A):\n r(x,blank,[x],1)\n for x in f:\n if sorted(list(x))==check:c+=1\n return c\n","class Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n def get_valid():\n ans = 0\n seen = set()\n visited = set()\n while q:\n cur, remaining = q.popleft()\n if not remaining and cur not in seen:\n ans += 1\n for i, n in enumerate(remaining):\n sq = (cur[-1] + n) ** .5\n if float(int(sq)) == sq:\n add = cur + (n,)\n remain = remaining[:i] + remaining[i+1:]\n if (add, remain) not in visited:\n q.append((add, remain))\n visited.add((add, remain))\n return ans\n\n q = deque()\n for i, num in enumerate(A):\n q.append(((num, ), tuple(A[:i] + A[i+1:])))\n\n return get_valid()","class Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n c = collections.Counter(A)\n cand = {i: {j for j in c if int((i + j)**0.5) ** 2 == i + j} for i in c}\n\n def dfs(x, left=len(A) - 1):\n c[x] -= 1\n count = sum(dfs(y, left - 1) for y in cand[x] if c[y]) if left else 1\n c[x] += 1\n return count\n return sum(map(dfs, c))","class Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n ''' \n # graph of indices, works if we don't have duplicate elements\n graph = collections.defaultdict(list)\n for i in range(len(A)):\n for j in range(i+1, len(A)):\n if int((A[i]+A[j])**0.5)**2==(A[i]+A[j]):\n graph[i] += [j]\n graph[j] += [i]\n # source node\n graph[-1] = [i for i in range(len(A))]\n def dfs(node, visited):\n if len(visited)==len(A):\n return 1\n res = 0\n for neighbor in graph[node]:\n if neighbor in visited:\n continue\n res += dfs(neighbor, visited|{neighbor})\n return res\n return dfs(-1, set())\n ''' \n candidates = collections.Counter(A)\n graph = {x: [y for y in candidates if int((x+y)**0.5)**2==x+y] for x in candidates}\n # source node\n graph[-1] = [x for x in candidates]\n def dfs(node, node_left):\n if node_left==0:\n return 1\n res = 0\n for n in graph[node]:\n if candidates[n]==0:\n continue\n candidates[n] -= 1\n res += dfs(n, node_left-1)\n candidates[n] += 1\n return res\n return dfs(-1, len(A))","class Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n #visited = [False] * len(A)\n \n visited = collections.Counter(A)\n \n ans = [0]\n self.calc(A, visited, [], ans)\n \n return ans[0]\n \n def calc(self, A, visited, tmp, ans):\n if len(tmp) == len(A): \n ans[0] += 1\n #print(tmp)\n \n for i in list(visited.keys()):\n if visited[i] == 0:\n continue\n \n visited[i] -= 1\n tmp.append(i)\n \n if len(tmp) < 2 or (tmp[-1] + tmp[-2])**(0.5) == int((tmp[-1] + tmp[-2])**(0.5)):\n self.calc(A, visited, tmp, ans)\n \n tmp.pop()\n visited[i] += 1\n","class Solution:\n def numSquarefulPerms(self, nums: List[int]) -> int:\n #nums.sort()\n self.ans = 0\n \n def isSquare(v):\n x = int(v**0.5)\n return x * x == v\n \n def dfs(pos):\n \n if pos >= len(nums):\n self.ans += 1\n return\n \n used = set()\n for i in range(pos, len(nums)):\n if nums[i] in used:\n continue\n used.add(nums[i])\n nums[pos], nums[i] = nums[i], nums[pos]\n \n if (pos == 0) or ( pos > 0 and isSquare(nums[pos] + nums[pos-1])):\n dfs(pos+1)\n nums[pos], nums[i] = nums[i], nums[pos]\n dfs(0)\n return self.ans","class Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n n = len(A)\n A = sorted(A)\n # g[i][j] = 1 if A[i], A[j] are squareful\n g = [[0] * n for _ in range(n)]\n # dp[s][i]: number of ways to reach state s and ends with node i\n dp = [[0] * n for _ in range(1 << n)]\n \n for i in range(n):\n for j in range(n):\n if i == j:\n continue\n r = int((A[i] + A[j]) ** 0.5)\n if r ** 2 == A[i] + A[j]:\n g[i][j] = 1\n \n for i in range(n):\n if i == 0 or A[i] != A[i - 1]:\n dp[(1 << i)][i] = 1\n \n ans = 0\n for s in range(1 << n):\n for i in range(n):\n if not dp[s][i]:\n continue\n for j in range(n):\n if not g[i][j]:\n continue\n if s & (1 << j):\n continue\n if j > 0 and not (s & (1 << (j - 1))) and A[j - 1] == A[j]:\n continue\n dp[s | (1 << j)][j] += dp[s][i]\n \n for i in range(n):\n ans += dp[(1 << n) - 1][i]\n \n return ans\n","# https://zxi.mytechroad.com/blog/searching/leetcode-996-number-of-squareful-arrays/\n# g[i][j]: if i and j are squareful\n# dp[s][i]: # of ways to reach state s (binary mask of nodes visited) that ends with node i\n# dp[s | (1 << j)][j] += dp[s][i] if g[i][j]\n# 先对数组排序, 然后计算出所有的 g[i][j]\n# for i in range(n) 初始化 dp[(1 << i)][i] = 1, 表示只有一个数字 i 的情况, 每个都是一种\n# 如果有多个重复的数字, 只用第一个数字作为开头\n# ans = sum(dp[(1 << n) - 1][i])\n# O(n^2*2^n) time complexity, O(2^n) space complexity\nimport math\nclass Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n n = len(A)\n A = sorted(A)\n g = [[False] * n for _ in range(n)]\n dp = [[0] * n for _ in range(1 << n)]\n \n for i in range(n):\n for j in range(n):\n if i == j:\n continue\n if int((A[i] + A[j]) ** 0.5 + 0.5) ** 2 == A[i] + A[j]:\n g[i][j] = True\n\n for i in range(n):\n if i > 0 and A[i] == A[i - 1]: # For the same numbers, only the first one can be the starting point\n continue\n dp[1 << i][i] = 1\n\n for s in range(1 << n):\n for i in range(n):\n if dp[s][i] <= 0: # 如果 dp[s][i] <= 0, 说明没有以 i 结尾的情况, 跳过\n continue\n for j in range(n): # 尝试让任意一个数字连接在最后面\n if not g[i][j] or (s & (1 << j)): # 如果 i, j 不是 squareful 或 j 已经使用过, 跳过\n continue\n if j > 0 and not (s & (1 << (j - 1))) and A[j] == A[j - 1]: # 出现重复的只使用第一个\n continue\n dp[s | (1 << j)][j] += dp[s][i]\n \n res = 0\n for i in range(n):\n res += dp[(1 << n) - 1][i]\n return res\n","import numpy as np\nclass Solution:\n graph = {}\n count = {}\n def numSquarefulPerms(self, A: List[int]) -> int:\n self.graph = {}\n self.count = {}\n for i in A:\n if i in self.count:\n self.count[i] += 1\n else:\n self.count[i] = 1\n self.graph[i] = []\n \n for i in self.count:\n for j in self.count:\n r = int(np.sqrt(i + j))\n if r * r == i + j:\n self.graph[i].append(j)\n ans = 0\n L = len(A)\n for i in self.graph:\n ans += self.dfs(i, L-1)\n return ans\n \n def dfs(self, i, L):\n self.count[i] -= 1\n ans = 1\n if L != 0:\n ans = 0\n for j in self.graph[i]:\n if self.count[j] != 0:\n ans += self.dfs(j, L - 1)\n self.count[i] += 1\n return ans\n \n","import numpy as np\n\n\nclass Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n N = len(A)\n count = collections.Counter(A)\n graph = collections.defaultdict(list)\n for x in count:\n for y in count:\n if int((x + y) ** (0.5)) ** 2 == (x + y):\n graph[x].append(y)\n \n def dfs(x, todo):\n count[x] -= 1\n if todo == 0:\n ans = 1\n else:\n ans = 0\n for y in graph[x]:\n if count[y]:\n ans += dfs(y, todo - 1)\n \n count[x] += 1\n return ans\n \n return sum(dfs(x, N - 1) for x in count)","import numpy as np\nclass Solution:\n graph = {}\n count = {}\n def numSquarefulPerms(self, A: List[int]) -> int:\n self.graph = {}\n self.count = {}\n for i in A:\n if i in self.count:\n self.count[i] += 1\n else:\n self.count[i] = 1\n self.graph[i] = []\n \n for i in self.count:\n for j in self.count:\n r = int(np.sqrt(i + j))\n if r * r == i + j:\n self.graph[i].append(j)\n ans = 0\n L = len(A)\n print((self.count))\n print((self.graph))\n for i in self.graph:\n ans += self.dfs(i, L-1)\n return ans\n \n def dfs(self, i, L):\n self.count[i] -= 1\n ans = 1\n if L != 0:\n ans = 0\n for j in self.graph[i]:\n if self.count[j] != 0:\n ans += self.dfs(j, L - 1)\n self.count[i] += 1\n return ans\n \n","class Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n def edge(x, y):\n return int((x + y) ** 0.5) ** 2 == (x + y)\n \n def dfs(x, t):\n count[x] -= 1\n if t == 0:\n ans = 1\n else:\n ans = 0\n for y in graph[x]:\n if count[y]:\n ans += dfs(y, t - 1)\n count[x] += 1\n return ans\n \n N = len(A)\n count = collections.Counter(A)\n graph = collections.defaultdict(list)\n for x in count:\n for y in count:\n if edge(x, y):\n graph[x].append(y)\n \n return sum(dfs(x, N - 1) for x in count)\n","from functools import lru_cache\n\n\nclass Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n def edge(x, y):\n r = math.sqrt(x + y)\n return int(r) ** 2 == (x + y)\n \n @lru_cache(None)\n def dfs(node, seen):\n if seen == (1 << N) - 1:\n return 1\n \n ans = 0\n for n in graph[node]:\n nxt = seen | (1 << n)\n if nxt == seen:\n continue\n ans += dfs(n, nxt)\n return ans\n \n \n N = len(A)\n count = collections.Counter(A)\n graph = [[] for _ in range(N)]\n \n for i in range(N):\n for j in range(i + 1, N):\n if edge(A[i], A[j]):\n graph[i].append(j)\n graph[j].append(i)\n \n ans = sum(dfs(i, 1 << i) for i in range(N))\n for v in count.values():\n ans //= math.factorial(v)\n \n return ans","class Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n import math\n \n def is_not_square(num): \n return int(math.sqrt(num) + 0.5) ** 2 != num\n \n memo = {}\n def perms(arr):\n key = tuple(sorted(arr))\n \n if key in memo: return memo[key]\n if len(arr) <= 1: return [arr]\n \n permutations = []\n seen = set()\n for i in range(len(arr)):\n el = arr[i]\n rest = arr[:i] + arr[i+1:]\n # if all([is_not_square(el+n) for n in rest]): continue\n if el not in seen:\n sub_perms = perms(rest)\n if not sub_perms: continue\n for p in sub_perms:\n if not is_not_square(el + p[0]):\n permutations.append([el] + p)\n seen.add(arr[i])\n \n memo[key] = permutations\n return permutations\n \n \n return len(perms(A))\n \n","from functools import lru_cache\n\nclass Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n N = len(A)\n \n def valid(x,y):\n return (math.sqrt(x+y)).is_integer()\n \n graph = [[] for _ in range(N)]\n \n for i,x in enumerate(A):\n for j in range(i):\n if valid(x,A[j]):\n graph[i].append(j)\n graph[j].append(i)\n \n # FINDING NO OF HAMILTONIAN PATH\n \n @lru_cache(None)\n def dfs(node,visited):\n if visited == (1<<N) - 1:\n return 1\n \n ans = 0\n for val in graph[node]:\n if (visited & 1<<val)==0:\n ans+= dfs(val,visited | 1<<val)\n return ans\n \n ans = sum(dfs(i,1<<i) for i in range(N))\n count = collections.Counter(A)\n for v in count.values():\n ans //= math.factorial(v)\n return ans","from functools import lru_cache\n\nclass Solution:\n def numSquarefulPerms(self, A):\n N = len(A)\n\n def edge(x, y):\n r = math.sqrt(x+y)\n return int(r + 0.5) ** 2 == x+y\n\n graph = [[] for _ in range(len(A))]\n for i, x in enumerate(A):\n for j in range(i):\n if edge(x, A[j]):\n graph[i].append(j)\n graph[j].append(i)\n\n # find num of hamiltonian paths in graph\n\n @lru_cache(None)\n def dfs(node, visited):\n if visited == (1 << N) - 1:\n return 1\n\n ans = 0\n for nei in graph[node]:\n if (visited >> nei) & 1 == 0:\n ans += dfs(nei, visited | (1 << nei))\n return ans\n\n ans = sum(dfs(i, 1<<i) for i in range(N))\n count = collections.Counter(A)\n for v in count.values():\n ans //= math.factorial(v)\n return ans","from functools import lru_cache\nclass Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n N = len(A)\n\n def edge(x, y):\n r = math.sqrt(x+y)\n return int(r + 0.5) ** 2 == x+y\n\n graph = [[] for _ in range(len(A))]\n for i, x in enumerate(A):\n for j in range(i):\n if edge(x, A[j]):\n graph[i].append(j)\n graph[j].append(i)\n\n # find num of hamiltonian paths in graph\n\n @lru_cache(None)\n def dfs(node, visited):\n if visited == (1 << N) - 1:\n return 1\n\n ans = 0\n for nei in graph[node]:\n if (visited >> nei) & 1 == 0:\n ans += dfs(nei, visited | (1 << nei))\n return ans\n\n ans = sum(dfs(i, 1<<i) for i in range(N))\n count = collections.Counter(A)\n for v in count.values():\n ans //= math.factorial(v)\n return ans","class Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n N = len(A)\n\n def edge(x, y):\n r = math.sqrt(x+y)\n return int(r + 0.5) ** 2 == x+y\n\n graph = [[] for _ in range(len(A))]\n for i, x in enumerate(A):\n for j in range(i):\n if edge(x, A[j]):\n graph[i].append(j)\n graph[j].append(i)\n\n # find num of hamiltonian paths in graph\n\n @lru_cache(None)\n def dfs(node, visited):\n if visited == (1 << N) - 1:\n return 1\n\n ans = 0\n for nei in graph[node]:\n if (visited >> nei) & 1 == 0:\n ans += dfs(nei, visited | (1 << nei))\n return ans\n\n ans = sum(dfs(i, 1<<i) for i in range(N))\n count = collections.Counter(A)\n for v in count.values():\n ans //= math.factorial(v)\n return ans","\n\n\ndef getPermutations(array):\n ans = set()\n def helper(arr,i,ans):\n if i==len(arr)-1:\n\n ans.add(tuple(arr))\n return\n \n for j in range(i,len(arr)):\n if not (arr[i]==arr[j] and i!=j):\n test = (i<=1) or (((arr[i-1]+arr[i-2])**0.5)==int((arr[i-1]+arr[i-2])**0.5))\n swap(arr,i,j)\n if (test):\n helper(arr,i+1,ans)\n \n swap(arr,i,j)\n \n def swap(arr,i,j):\n arr[i],arr[j]=arr[j],arr[i]\n \n helper(array,0,ans)\n return ans\n\nclass Solution:\n \n \n \n def numSquarefulPerms(self, A: List[int]) -> int:\n va = getPermutations(A)\n \n valid = 0\n # print(va)\n for a in va:\n isValid = True\n # print(a)\n for idx in range(1,len(a)):\n \n if ((a[idx]+a[idx-1])**0.5)!=int((a[idx]+a[idx-1])**0.5):\n # print(a,idx)\n isValid = False\n break\n \n if isValid:\n # print(a)\n valid+=1\n \n # print(valid)\n return valid\n \n","from functools import lru_cache\n\nclass Solution:\n def numSquarefulPerms(self, A):\n N = len(A)\n\n def edge(x, y):\n r = math.sqrt(x+y)\n return int(r + 0.5) ** 2 == x+y\n\n graph = [[] for _ in range(len(A))]\n for i, x in enumerate(A):\n for j in range(i):\n if edge(x, A[j]):\n graph[i].append(j)\n graph[j].append(i)\n\n # find num of hamiltonian paths in graph\n @lru_cache(None)\n def dfs(node, visited):\n if visited == (1 << N) - 1:\n return 1\n ans = 0\n for nei in graph[node]:\n if (visited >> nei) & 1 == 0:\n ans += dfs(nei, visited | (1 << nei))\n return ans\n\n ans = sum(dfs(i, 1<<i) for i in range(N))\n count = collections.Counter(A)\n for v in count.values():\n ans //= math.factorial(v)\n return ans","class Solution:\n def numSquarefulPerms(self, A):\n A.sort()\n N = len(A)\n graph = [[0] * N for _ in range(N)]\n\n for i in range(N):\n for j in range(N):\n if i==j: continue\n if int((A[i]+A[j])**0.5)**2==(A[i]+A[j]):\n graph[i][j]=1\n graph[j][i]=1\n\n\n dp=[[0]*N for i in range(1<<N)]\n for i in range(N):\n dp[1<<i][i]=1\n for s in range(1<<N):\n for i in range(N):\n if not dp[s][i]: continue\n for j in range(N):\n if not graph[i][j]: continue\n if s&(1<<j): continue\n if j>0 and s&(1<<(j-1)) and A[j]==A[j-1]:continue\n dp[s|(1<<j)][j]+=dp[s][i]\n\n ans=0\n for i in range(N):\n ans+=dp[-1][i]\n\n return ans\n \n\n \n","from collections import Counter\n\nclass Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n \n counts = Counter(A)\n graph = {x: [] for x in counts}\n \n for x in counts:\n for y in counts:\n r = int((x + y) ** 0.5 + 0.5)\n if r * r == x + y:\n graph[x].append(y)\n \n def dfs(x, todo):\n counts[x] -= 1\n if todo == 0:\n res = 1\n else:\n res = 0\n for y in graph[x]:\n if counts[y] > 0:\n res += dfs(y, todo - 1)\n\n counts[x] += 1\n return res\n \n \n return sum(dfs(x, len(A) - 1) for x in counts)","from collections import Counter\nfrom functools import lru_cache\nimport math\n\nclass Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n # Backtracking\n # Time complexity: O(N^N)\n # Space complexity: O(N)\n # N = len(A)\n # count = Counter(A)\n\n # graph = {x: [] for x in count}\n # for x in count:\n # for y in count:\n # if int((x + y) ** .5 + 0.5) ** 2 == x + y:\n # graph[x].append(y)\n\n # def dfs(x, todo):\n # count[x] -= 1\n # if todo == 0:\n # ans = 1\n # else:\n # ans = 0\n # for y in graph[x]:\n # if count[y]:\n # ans += dfs(y, todo - 1)\n\n # count[x] += 1\n # return ans\n\n # return sum(dfs(x, len(A) - 1) for x in count)\n\n\n # Dynamic Programming\n # Time complexity: O(N^2 x 2^N) = O(sum_{k=1}^{N} C_N^K x C_k^2)\n # Space complexity: O(N x 2^N)\n N = len(A)\n\n def edge(x, y):\n r = math.sqrt(x + y)\n return int(r + 0.5) ** 2 == x + y\n\n graph = [[] for _ in range(len(A))]\n for i, x in enumerate(A):\n for j in range(i):\n if edge(x, A[j]):\n graph[i].append(j)\n graph[j].append(i)\n\n # find num of hamiltonian paths in graph\n @lru_cache(None)\n def dfs(node, visited):\n if visited == (1 << N) - 1:\n return 1\n\n ans = 0\n for nei in graph[node]:\n if (visited >> nei) & 1 == 0:\n ans += dfs(nei, visited | 1 << nei)\n return ans\n\n ans = sum(dfs(i, 1 << i) for i in range(N))\n count = Counter(A)\n for v in list(count.values()):\n ans //= math.factorial(v)\n return ans\n\n\n # c = Counter(A)\n # cand = {i: {j for j in c if int((i+j)**.5) ** 2 == i + j} for i in c}\n # self.res = 0\n\n # def dfs(x, left=len(A)-1):\n # c[x] -= 1\n # if left == 0:\n # self.res += 1\n # for y in cand[x]:\n # if c[y]:\n # dfs(y, left - 1)\n # c[x] += 1\n\n # for x in c: dfs(x)\n # return self.res\n\n\n # def backtrack(i, A):\n # if i > 1:\n # val = A[i - 2] + A[i - 1]\n # is_square = math.sqrt(val) == math.floor(math.sqrt(val))\n # if not is_square:\n # return\n\n # if i == len(A):\n # output.append(A)\n # return\n\n # for j in range(i, len(A)):\n # A[i], A[j] = A[j], A[i]\n # search = (i, A[i], tuple(A[:i]))\n # if search not in seen:\n # seen.add(search)\n # backtrack(i + 1, A)\n\n # A[i], A[j] = A[j], A[i]\n\n # output, seen = [], set()\n # backtrack(0, A)\n # return len(output)\n\n","class Solution:\n \n def dfs(self, pos):\n if pos==self.n:\n self.ans += 1\n return\n \n last = None\n for i, val in enumerate(self.a):\n if self.usable[i]:\n if val == last:\n continue\n if pos-1 >= 0 and (val + self.rec[pos-1]) not in self.square:\n continue\n \n self.usable[i] = False\n self.rec[pos] = val\n self.dfs(pos + 1)\n self.usable[i] = True\n last = val\n \n def numSquarefulPerms(self, A: List[int]) -> int:\n \n self.a = sorted(A)\n self.square=set()\n i = 0 # not 1\n while i*i <= self.a[-1]*2:\n self.square.add(i*i)\n i += 1\n \n #print(self.square)\n self.ans = 0\n self.n = len(self.a) \n self.usable = [True]*self.n\n self.rec = [None]*self.n\n self.dfs(0)\n return self.ans\n \n \n \n","class Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n \n d = defaultdict(int)\n res = 0\n \n ps = {}\n i = 0\n while i*i <= 2*max(A):\n ps[i*i]=True\n i += 1\n \n def ok(x):\n return x in ps\n \n def solve(x):\n nonlocal res\n # takes some number X and multiset D. Returns answer of the problem for numbers in D such that first number is X\n if not len(d):\n res += 1\n return\n for k in list(d.keys()):\n if not ok(x + k): continue\n d[k] -= 1\n if d[k] == 0: del d[k]\n solve(k)\n d[k] += 1\n \n \n for x in A: d[x] += 1\n for k in list(d.keys()):\n d[k] -= 1\n if not d[k]: del d[k]\n solve(k)\n d[k] += 1\n \n return res\n \n","from typing import List\nfrom collections import defaultdict\n\nclass Solution:\n def helper(self, last_num, used, partners, index):\n if index == len(used):\n return 1\n total = 0\n # print(partners, partners[last_num])\n for partner, partner_list in partners[last_num].items():\n for partner_index in partner_list:\n if not used[partner_index]:\n used[partner_index] = True\n total += self.helper(partner, used, partners, index+1)\n used[partner_index] = False\n break\n return total\n\n def numSquarefulPerms(self, A: List[int]) -> int:\n squares = set()\n i = 0\n partners = defaultdict(lambda: defaultdict(set))\n while i * i <= 200000000:\n squares.add(i*i)\n i += 1\n for i in range(len(A)):\n for j in range(i+1, len(A), 1):\n if A[i] + A[j] in squares:\n partners[A[i]][A[j]].add(j)\n partners[A[j]][A[i]].add(i)\n unique_nums = dict()\n for i, num in enumerate(A):\n unique_nums[num] = i\n used = [False for _ in A]\n total = 0\n for num, i in unique_nums.items():\n used[i] = True\n total += self.helper(num, used, partners, 1)\n used[i] = False\n return total","class Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n\n A.sort()\n self.ans = 0\n\n def check(A, i, path):\n return int((A[i] + path[-1])**0.5 + 0.0)**2 == A[i] + path[-1]\n\n def dfs(A, path):\n if len(A) == 0:\n self.ans += 1\n return\n\n for i in range(len(A)):\n if i > 0 and A[i] == A[i - 1]:\n continue\n if len(path) == 0 or (len(path) > 0 and check(A, i, path)):\n dfs(A[:i] + A[i + 1:], path + [A[i]])\n\n dfs(A, [])\n return self.ans\n","class Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n def edge(x, y):\n return int((x + y) ** 0.5) ** 2 == (x + y)\n \n def dfs(x, t):\n count[x] -= 1\n if t == 0:\n ans = 1\n else:\n ans = 0\n for y in graph[x]:\n if count[y]:\n ans += dfs(y, t - 1)\n count[x] += 1\n return ans\n \n N = len(A)\n count = collections.Counter(A)\n graph = collections.defaultdict(list)\n for x in count:\n for y in count:\n if edge(x, y):\n graph[x].append(y)\n \n return sum(dfs(x, N - 1) for x in count)\n \n \n \n \n \n","class Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n A.sort()\n n = len(A)\n visited = [False] * n\n res = []\n self.count = 0\n def dfs(curr):\n if len(curr) == n:\n self.count += 1\n return \n for i in range(n):\n if visited[i]: continue \n if i > 0 and A[i] == A[i - 1] and not visited[i - 1]: continue \n if len(curr) > 0 and (int((curr[-1] + A[i]) ** 0.5))**2 != curr[-1] + A[i]: continue \n visited[i] = True\n dfs(curr + [A[i]])\n visited[i] = False\n dfs([])\n return self.count\n","from math import sqrt\nclass Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n return self.backtrack(A, 0, set())\n \n def isPerfect(self, num):\n return int(sqrt(num))**2 == num\n \n def backtrack(self, permutation, j, seen):\n permutation_tuple = (j,) + tuple(permutation)\n if permutation_tuple in seen: return 0\n seen.add(permutation_tuple)\n if j == len(permutation):\n return 1\n total = 0\n for i in range(j, len(permutation)):\n self.swap(permutation, i, j)\n if j == 0 or self.isPerfect(permutation[j] + permutation[j-1]):\n total += self.backtrack(permutation, j+1, seen)\n self.swap(permutation, i, j)\n return total\n \n def swap(self, array, i, j):\n array[i], array[j] = array[j], array[i]\n","class Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n count ={}\n for i in A:\n count[i]=count.get(i,0)+1\n graph = {x: [] for x in A}\n for x in count:\n for y in count:\n if int((x + y) ** 0.5 + 0.5) ** 2 == x + y:\n graph[x].append(y)\n def dfs(x, todo):\n count[x] -= 1\n if todo == 0:\n ans = 1\n else:\n ans = 0\n for y in graph[x]:\n if count[y]:\n ans += dfs(y, todo - 1)\n count[x] += 1\n return ans\n\n return sum(dfs(x, len(A) - 1) for x in count)\n","class Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n c = {}\n for i in A:\n c[i]=c.get(i,0)+1\n cand = {i: [j for j in c if int((i + j)**0.5) ** 2 == i + j] for i in c}\n\n def dfs(x, left=len(A) - 1):\n c[x] -= 1\n count = sum(dfs(y, left - 1) for y in cand[x] if c[y]) if left else 1\n c[x] += 1\n return count\n return sum(map(dfs, c))\n"],"string":"[\n \"\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n\\n A.sort()\\n self.ans = 0\\n\\n def check(A, i, path):\\n return int((A[i] + path[-1])**0.5 + 0.0)**2 == A[i] + path[-1]\\n\\n def dfs(A, path):\\n if not A:\\n self.ans += 1\\n return\\n\\n for i in range(len(A)):\\n if i > 0 and A[i] == A[i - 1]:\\n continue\\n if not path or (path and check(A, i, path)):\\n dfs(A[:i] + A[i + 1:], path + [A[i]])\\n\\n dfs(A, [])\\n return self.ans\\n\",\n \"from copy import copy\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n \\n d = dict()\\n count = dict()\\n lim = len(A)\\n blank = dict()\\n for i in range(0,lim-1): \\n try:\\n count[A[i]]+=1\\n except:\\n blank[A[i]]=0\\n count[A[i]]=1\\n for j in range(i+1,lim):\\n if ((A[i]+A[j])**.5).is_integer():\\n try:\\n d[A[i]].add(A[j])\\n except:\\n d[A[i]] = set()\\n d[A[i]].add(A[j])\\n try:\\n d[A[j]].add(A[i])\\n except:\\n d[A[j]] = set()\\n d[A[j]].add(A[i])\\n try:\\n count[A[-1]]+=1\\n except:\\n count[A[-1]]=1\\n blank[A[-1]]=0\\n \\n check = sorted(A)\\n if d==dict():return 0\\n f = set()\\n c = 0\\n def r(val,ld,l,lth):\\n if lth==lim:\\n f.add(tuple(l))\\n else:\\n if val in d:\\n for x in d[val]:\\n s = copy(ld)\\n if s[x]<=count[x]:\\n s[x]+=1\\n r(x,s,l+[x],lth+1)\\n \\n for x in set(A):\\n r(x,blank,[x],1)\\n for x in f:\\n if sorted(list(x))==check:c+=1\\n return c\\n\",\n \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n def get_valid():\\n ans = 0\\n seen = set()\\n visited = set()\\n while q:\\n cur, remaining = q.popleft()\\n if not remaining and cur not in seen:\\n ans += 1\\n for i, n in enumerate(remaining):\\n sq = (cur[-1] + n) ** .5\\n if float(int(sq)) == sq:\\n add = cur + (n,)\\n remain = remaining[:i] + remaining[i+1:]\\n if (add, remain) not in visited:\\n q.append((add, remain))\\n visited.add((add, remain))\\n return ans\\n\\n q = deque()\\n for i, num in enumerate(A):\\n q.append(((num, ), tuple(A[:i] + A[i+1:])))\\n\\n return get_valid()\",\n \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n c = collections.Counter(A)\\n cand = {i: {j for j in c if int((i + j)**0.5) ** 2 == i + j} for i in c}\\n\\n def dfs(x, left=len(A) - 1):\\n c[x] -= 1\\n count = sum(dfs(y, left - 1) for y in cand[x] if c[y]) if left else 1\\n c[x] += 1\\n return count\\n return sum(map(dfs, c))\",\n \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n ''' \\n # graph of indices, works if we don't have duplicate elements\\n graph = collections.defaultdict(list)\\n for i in range(len(A)):\\n for j in range(i+1, len(A)):\\n if int((A[i]+A[j])**0.5)**2==(A[i]+A[j]):\\n graph[i] += [j]\\n graph[j] += [i]\\n # source node\\n graph[-1] = [i for i in range(len(A))]\\n def dfs(node, visited):\\n if len(visited)==len(A):\\n return 1\\n res = 0\\n for neighbor in graph[node]:\\n if neighbor in visited:\\n continue\\n res += dfs(neighbor, visited|{neighbor})\\n return res\\n return dfs(-1, set())\\n ''' \\n candidates = collections.Counter(A)\\n graph = {x: [y for y in candidates if int((x+y)**0.5)**2==x+y] for x in candidates}\\n # source node\\n graph[-1] = [x for x in candidates]\\n def dfs(node, node_left):\\n if node_left==0:\\n return 1\\n res = 0\\n for n in graph[node]:\\n if candidates[n]==0:\\n continue\\n candidates[n] -= 1\\n res += dfs(n, node_left-1)\\n candidates[n] += 1\\n return res\\n return dfs(-1, len(A))\",\n \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n #visited = [False] * len(A)\\n \\n visited = collections.Counter(A)\\n \\n ans = [0]\\n self.calc(A, visited, [], ans)\\n \\n return ans[0]\\n \\n def calc(self, A, visited, tmp, ans):\\n if len(tmp) == len(A): \\n ans[0] += 1\\n #print(tmp)\\n \\n for i in list(visited.keys()):\\n if visited[i] == 0:\\n continue\\n \\n visited[i] -= 1\\n tmp.append(i)\\n \\n if len(tmp) < 2 or (tmp[-1] + tmp[-2])**(0.5) == int((tmp[-1] + tmp[-2])**(0.5)):\\n self.calc(A, visited, tmp, ans)\\n \\n tmp.pop()\\n visited[i] += 1\\n\",\n \"class Solution:\\n def numSquarefulPerms(self, nums: List[int]) -> int:\\n #nums.sort()\\n self.ans = 0\\n \\n def isSquare(v):\\n x = int(v**0.5)\\n return x * x == v\\n \\n def dfs(pos):\\n \\n if pos >= len(nums):\\n self.ans += 1\\n return\\n \\n used = set()\\n for i in range(pos, len(nums)):\\n if nums[i] in used:\\n continue\\n used.add(nums[i])\\n nums[pos], nums[i] = nums[i], nums[pos]\\n \\n if (pos == 0) or ( pos > 0 and isSquare(nums[pos] + nums[pos-1])):\\n dfs(pos+1)\\n nums[pos], nums[i] = nums[i], nums[pos]\\n dfs(0)\\n return self.ans\",\n \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n n = len(A)\\n A = sorted(A)\\n # g[i][j] = 1 if A[i], A[j] are squareful\\n g = [[0] * n for _ in range(n)]\\n # dp[s][i]: number of ways to reach state s and ends with node i\\n dp = [[0] * n for _ in range(1 << n)]\\n \\n for i in range(n):\\n for j in range(n):\\n if i == j:\\n continue\\n r = int((A[i] + A[j]) ** 0.5)\\n if r ** 2 == A[i] + A[j]:\\n g[i][j] = 1\\n \\n for i in range(n):\\n if i == 0 or A[i] != A[i - 1]:\\n dp[(1 << i)][i] = 1\\n \\n ans = 0\\n for s in range(1 << n):\\n for i in range(n):\\n if not dp[s][i]:\\n continue\\n for j in range(n):\\n if not g[i][j]:\\n continue\\n if s & (1 << j):\\n continue\\n if j > 0 and not (s & (1 << (j - 1))) and A[j - 1] == A[j]:\\n continue\\n dp[s | (1 << j)][j] += dp[s][i]\\n \\n for i in range(n):\\n ans += dp[(1 << n) - 1][i]\\n \\n return ans\\n\",\n \"# https://zxi.mytechroad.com/blog/searching/leetcode-996-number-of-squareful-arrays/\\n# g[i][j]: if i and j are squareful\\n# dp[s][i]: # of ways to reach state s (binary mask of nodes visited) that ends with node i\\n# dp[s | (1 << j)][j] += dp[s][i] if g[i][j]\\n# 先对数组排序, 然后计算出所有的 g[i][j]\\n# for i in range(n) 初始化 dp[(1 << i)][i] = 1, 表示只有一个数字 i 的情况, 每个都是一种\\n# 如果有多个重复的数字, 只用第一个数字作为开头\\n# ans = sum(dp[(1 << n) - 1][i])\\n# O(n^2*2^n) time complexity, O(2^n) space complexity\\nimport math\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n n = len(A)\\n A = sorted(A)\\n g = [[False] * n for _ in range(n)]\\n dp = [[0] * n for _ in range(1 << n)]\\n \\n for i in range(n):\\n for j in range(n):\\n if i == j:\\n continue\\n if int((A[i] + A[j]) ** 0.5 + 0.5) ** 2 == A[i] + A[j]:\\n g[i][j] = True\\n\\n for i in range(n):\\n if i > 0 and A[i] == A[i - 1]: # For the same numbers, only the first one can be the starting point\\n continue\\n dp[1 << i][i] = 1\\n\\n for s in range(1 << n):\\n for i in range(n):\\n if dp[s][i] <= 0: # 如果 dp[s][i] <= 0, 说明没有以 i 结尾的情况, 跳过\\n continue\\n for j in range(n): # 尝试让任意一个数字连接在最后面\\n if not g[i][j] or (s & (1 << j)): # 如果 i, j 不是 squareful 或 j 已经使用过, 跳过\\n continue\\n if j > 0 and not (s & (1 << (j - 1))) and A[j] == A[j - 1]: # 出现重复的只使用第一个\\n continue\\n dp[s | (1 << j)][j] += dp[s][i]\\n \\n res = 0\\n for i in range(n):\\n res += dp[(1 << n) - 1][i]\\n return res\\n\",\n \"import numpy as np\\nclass Solution:\\n graph = {}\\n count = {}\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n self.graph = {}\\n self.count = {}\\n for i in A:\\n if i in self.count:\\n self.count[i] += 1\\n else:\\n self.count[i] = 1\\n self.graph[i] = []\\n \\n for i in self.count:\\n for j in self.count:\\n r = int(np.sqrt(i + j))\\n if r * r == i + j:\\n self.graph[i].append(j)\\n ans = 0\\n L = len(A)\\n for i in self.graph:\\n ans += self.dfs(i, L-1)\\n return ans\\n \\n def dfs(self, i, L):\\n self.count[i] -= 1\\n ans = 1\\n if L != 0:\\n ans = 0\\n for j in self.graph[i]:\\n if self.count[j] != 0:\\n ans += self.dfs(j, L - 1)\\n self.count[i] += 1\\n return ans\\n \\n\",\n \"import numpy as np\\n\\n\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n N = len(A)\\n count = collections.Counter(A)\\n graph = collections.defaultdict(list)\\n for x in count:\\n for y in count:\\n if int((x + y) ** (0.5)) ** 2 == (x + y):\\n graph[x].append(y)\\n \\n def dfs(x, todo):\\n count[x] -= 1\\n if todo == 0:\\n ans = 1\\n else:\\n ans = 0\\n for y in graph[x]:\\n if count[y]:\\n ans += dfs(y, todo - 1)\\n \\n count[x] += 1\\n return ans\\n \\n return sum(dfs(x, N - 1) for x in count)\",\n \"import numpy as np\\nclass Solution:\\n graph = {}\\n count = {}\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n self.graph = {}\\n self.count = {}\\n for i in A:\\n if i in self.count:\\n self.count[i] += 1\\n else:\\n self.count[i] = 1\\n self.graph[i] = []\\n \\n for i in self.count:\\n for j in self.count:\\n r = int(np.sqrt(i + j))\\n if r * r == i + j:\\n self.graph[i].append(j)\\n ans = 0\\n L = len(A)\\n print((self.count))\\n print((self.graph))\\n for i in self.graph:\\n ans += self.dfs(i, L-1)\\n return ans\\n \\n def dfs(self, i, L):\\n self.count[i] -= 1\\n ans = 1\\n if L != 0:\\n ans = 0\\n for j in self.graph[i]:\\n if self.count[j] != 0:\\n ans += self.dfs(j, L - 1)\\n self.count[i] += 1\\n return ans\\n \\n\",\n \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n def edge(x, y):\\n return int((x + y) ** 0.5) ** 2 == (x + y)\\n \\n def dfs(x, t):\\n count[x] -= 1\\n if t == 0:\\n ans = 1\\n else:\\n ans = 0\\n for y in graph[x]:\\n if count[y]:\\n ans += dfs(y, t - 1)\\n count[x] += 1\\n return ans\\n \\n N = len(A)\\n count = collections.Counter(A)\\n graph = collections.defaultdict(list)\\n for x in count:\\n for y in count:\\n if edge(x, y):\\n graph[x].append(y)\\n \\n return sum(dfs(x, N - 1) for x in count)\\n\",\n \"from functools import lru_cache\\n\\n\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n def edge(x, y):\\n r = math.sqrt(x + y)\\n return int(r) ** 2 == (x + y)\\n \\n @lru_cache(None)\\n def dfs(node, seen):\\n if seen == (1 << N) - 1:\\n return 1\\n \\n ans = 0\\n for n in graph[node]:\\n nxt = seen | (1 << n)\\n if nxt == seen:\\n continue\\n ans += dfs(n, nxt)\\n return ans\\n \\n \\n N = len(A)\\n count = collections.Counter(A)\\n graph = [[] for _ in range(N)]\\n \\n for i in range(N):\\n for j in range(i + 1, N):\\n if edge(A[i], A[j]):\\n graph[i].append(j)\\n graph[j].append(i)\\n \\n ans = sum(dfs(i, 1 << i) for i in range(N))\\n for v in count.values():\\n ans //= math.factorial(v)\\n \\n return ans\",\n \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n import math\\n \\n def is_not_square(num): \\n return int(math.sqrt(num) + 0.5) ** 2 != num\\n \\n memo = {}\\n def perms(arr):\\n key = tuple(sorted(arr))\\n \\n if key in memo: return memo[key]\\n if len(arr) <= 1: return [arr]\\n \\n permutations = []\\n seen = set()\\n for i in range(len(arr)):\\n el = arr[i]\\n rest = arr[:i] + arr[i+1:]\\n # if all([is_not_square(el+n) for n in rest]): continue\\n if el not in seen:\\n sub_perms = perms(rest)\\n if not sub_perms: continue\\n for p in sub_perms:\\n if not is_not_square(el + p[0]):\\n permutations.append([el] + p)\\n seen.add(arr[i])\\n \\n memo[key] = permutations\\n return permutations\\n \\n \\n return len(perms(A))\\n \\n\",\n \"from functools import lru_cache\\n\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n N = len(A)\\n \\n def valid(x,y):\\n return (math.sqrt(x+y)).is_integer()\\n \\n graph = [[] for _ in range(N)]\\n \\n for i,x in enumerate(A):\\n for j in range(i):\\n if valid(x,A[j]):\\n graph[i].append(j)\\n graph[j].append(i)\\n \\n # FINDING NO OF HAMILTONIAN PATH\\n \\n @lru_cache(None)\\n def dfs(node,visited):\\n if visited == (1<<N) - 1:\\n return 1\\n \\n ans = 0\\n for val in graph[node]:\\n if (visited & 1<<val)==0:\\n ans+= dfs(val,visited | 1<<val)\\n return ans\\n \\n ans = sum(dfs(i,1<<i) for i in range(N))\\n count = collections.Counter(A)\\n for v in count.values():\\n ans //= math.factorial(v)\\n return ans\",\n \"from functools import lru_cache\\n\\nclass Solution:\\n def numSquarefulPerms(self, A):\\n N = len(A)\\n\\n def edge(x, y):\\n r = math.sqrt(x+y)\\n return int(r + 0.5) ** 2 == x+y\\n\\n graph = [[] for _ in range(len(A))]\\n for i, x in enumerate(A):\\n for j in range(i):\\n if edge(x, A[j]):\\n graph[i].append(j)\\n graph[j].append(i)\\n\\n # find num of hamiltonian paths in graph\\n\\n @lru_cache(None)\\n def dfs(node, visited):\\n if visited == (1 << N) - 1:\\n return 1\\n\\n ans = 0\\n for nei in graph[node]:\\n if (visited >> nei) & 1 == 0:\\n ans += dfs(nei, visited | (1 << nei))\\n return ans\\n\\n ans = sum(dfs(i, 1<<i) for i in range(N))\\n count = collections.Counter(A)\\n for v in count.values():\\n ans //= math.factorial(v)\\n return ans\",\n \"from functools import lru_cache\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n N = len(A)\\n\\n def edge(x, y):\\n r = math.sqrt(x+y)\\n return int(r + 0.5) ** 2 == x+y\\n\\n graph = [[] for _ in range(len(A))]\\n for i, x in enumerate(A):\\n for j in range(i):\\n if edge(x, A[j]):\\n graph[i].append(j)\\n graph[j].append(i)\\n\\n # find num of hamiltonian paths in graph\\n\\n @lru_cache(None)\\n def dfs(node, visited):\\n if visited == (1 << N) - 1:\\n return 1\\n\\n ans = 0\\n for nei in graph[node]:\\n if (visited >> nei) & 1 == 0:\\n ans += dfs(nei, visited | (1 << nei))\\n return ans\\n\\n ans = sum(dfs(i, 1<<i) for i in range(N))\\n count = collections.Counter(A)\\n for v in count.values():\\n ans //= math.factorial(v)\\n return ans\",\n \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n N = len(A)\\n\\n def edge(x, y):\\n r = math.sqrt(x+y)\\n return int(r + 0.5) ** 2 == x+y\\n\\n graph = [[] for _ in range(len(A))]\\n for i, x in enumerate(A):\\n for j in range(i):\\n if edge(x, A[j]):\\n graph[i].append(j)\\n graph[j].append(i)\\n\\n # find num of hamiltonian paths in graph\\n\\n @lru_cache(None)\\n def dfs(node, visited):\\n if visited == (1 << N) - 1:\\n return 1\\n\\n ans = 0\\n for nei in graph[node]:\\n if (visited >> nei) & 1 == 0:\\n ans += dfs(nei, visited | (1 << nei))\\n return ans\\n\\n ans = sum(dfs(i, 1<<i) for i in range(N))\\n count = collections.Counter(A)\\n for v in count.values():\\n ans //= math.factorial(v)\\n return ans\",\n \"\\n\\n\\ndef getPermutations(array):\\n ans = set()\\n def helper(arr,i,ans):\\n if i==len(arr)-1:\\n\\n ans.add(tuple(arr))\\n return\\n \\n for j in range(i,len(arr)):\\n if not (arr[i]==arr[j] and i!=j):\\n test = (i<=1) or (((arr[i-1]+arr[i-2])**0.5)==int((arr[i-1]+arr[i-2])**0.5))\\n swap(arr,i,j)\\n if (test):\\n helper(arr,i+1,ans)\\n \\n swap(arr,i,j)\\n \\n def swap(arr,i,j):\\n arr[i],arr[j]=arr[j],arr[i]\\n \\n helper(array,0,ans)\\n return ans\\n\\nclass Solution:\\n \\n \\n \\n def numSquarefulPerms(self, A: List[int]) -> int:\\n va = getPermutations(A)\\n \\n valid = 0\\n # print(va)\\n for a in va:\\n isValid = True\\n # print(a)\\n for idx in range(1,len(a)):\\n \\n if ((a[idx]+a[idx-1])**0.5)!=int((a[idx]+a[idx-1])**0.5):\\n # print(a,idx)\\n isValid = False\\n break\\n \\n if isValid:\\n # print(a)\\n valid+=1\\n \\n # print(valid)\\n return valid\\n \\n\",\n \"from functools import lru_cache\\n\\nclass Solution:\\n def numSquarefulPerms(self, A):\\n N = len(A)\\n\\n def edge(x, y):\\n r = math.sqrt(x+y)\\n return int(r + 0.5) ** 2 == x+y\\n\\n graph = [[] for _ in range(len(A))]\\n for i, x in enumerate(A):\\n for j in range(i):\\n if edge(x, A[j]):\\n graph[i].append(j)\\n graph[j].append(i)\\n\\n # find num of hamiltonian paths in graph\\n @lru_cache(None)\\n def dfs(node, visited):\\n if visited == (1 << N) - 1:\\n return 1\\n ans = 0\\n for nei in graph[node]:\\n if (visited >> nei) & 1 == 0:\\n ans += dfs(nei, visited | (1 << nei))\\n return ans\\n\\n ans = sum(dfs(i, 1<<i) for i in range(N))\\n count = collections.Counter(A)\\n for v in count.values():\\n ans //= math.factorial(v)\\n return ans\",\n \"class Solution:\\n def numSquarefulPerms(self, A):\\n A.sort()\\n N = len(A)\\n graph = [[0] * N for _ in range(N)]\\n\\n for i in range(N):\\n for j in range(N):\\n if i==j: continue\\n if int((A[i]+A[j])**0.5)**2==(A[i]+A[j]):\\n graph[i][j]=1\\n graph[j][i]=1\\n\\n\\n dp=[[0]*N for i in range(1<<N)]\\n for i in range(N):\\n dp[1<<i][i]=1\\n for s in range(1<<N):\\n for i in range(N):\\n if not dp[s][i]: continue\\n for j in range(N):\\n if not graph[i][j]: continue\\n if s&(1<<j): continue\\n if j>0 and s&(1<<(j-1)) and A[j]==A[j-1]:continue\\n dp[s|(1<<j)][j]+=dp[s][i]\\n\\n ans=0\\n for i in range(N):\\n ans+=dp[-1][i]\\n\\n return ans\\n \\n\\n \\n\",\n \"from collections import Counter\\n\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n \\n counts = Counter(A)\\n graph = {x: [] for x in counts}\\n \\n for x in counts:\\n for y in counts:\\n r = int((x + y) ** 0.5 + 0.5)\\n if r * r == x + y:\\n graph[x].append(y)\\n \\n def dfs(x, todo):\\n counts[x] -= 1\\n if todo == 0:\\n res = 1\\n else:\\n res = 0\\n for y in graph[x]:\\n if counts[y] > 0:\\n res += dfs(y, todo - 1)\\n\\n counts[x] += 1\\n return res\\n \\n \\n return sum(dfs(x, len(A) - 1) for x in counts)\",\n \"from collections import Counter\\nfrom functools import lru_cache\\nimport math\\n\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n # Backtracking\\n # Time complexity: O(N^N)\\n # Space complexity: O(N)\\n # N = len(A)\\n # count = Counter(A)\\n\\n # graph = {x: [] for x in count}\\n # for x in count:\\n # for y in count:\\n # if int((x + y) ** .5 + 0.5) ** 2 == x + y:\\n # graph[x].append(y)\\n\\n # def dfs(x, todo):\\n # count[x] -= 1\\n # if todo == 0:\\n # ans = 1\\n # else:\\n # ans = 0\\n # for y in graph[x]:\\n # if count[y]:\\n # ans += dfs(y, todo - 1)\\n\\n # count[x] += 1\\n # return ans\\n\\n # return sum(dfs(x, len(A) - 1) for x in count)\\n\\n\\n # Dynamic Programming\\n # Time complexity: O(N^2 x 2^N) = O(sum_{k=1}^{N} C_N^K x C_k^2)\\n # Space complexity: O(N x 2^N)\\n N = len(A)\\n\\n def edge(x, y):\\n r = math.sqrt(x + y)\\n return int(r + 0.5) ** 2 == x + y\\n\\n graph = [[] for _ in range(len(A))]\\n for i, x in enumerate(A):\\n for j in range(i):\\n if edge(x, A[j]):\\n graph[i].append(j)\\n graph[j].append(i)\\n\\n # find num of hamiltonian paths in graph\\n @lru_cache(None)\\n def dfs(node, visited):\\n if visited == (1 << N) - 1:\\n return 1\\n\\n ans = 0\\n for nei in graph[node]:\\n if (visited >> nei) & 1 == 0:\\n ans += dfs(nei, visited | 1 << nei)\\n return ans\\n\\n ans = sum(dfs(i, 1 << i) for i in range(N))\\n count = Counter(A)\\n for v in list(count.values()):\\n ans //= math.factorial(v)\\n return ans\\n\\n\\n # c = Counter(A)\\n # cand = {i: {j for j in c if int((i+j)**.5) ** 2 == i + j} for i in c}\\n # self.res = 0\\n\\n # def dfs(x, left=len(A)-1):\\n # c[x] -= 1\\n # if left == 0:\\n # self.res += 1\\n # for y in cand[x]:\\n # if c[y]:\\n # dfs(y, left - 1)\\n # c[x] += 1\\n\\n # for x in c: dfs(x)\\n # return self.res\\n\\n\\n # def backtrack(i, A):\\n # if i > 1:\\n # val = A[i - 2] + A[i - 1]\\n # is_square = math.sqrt(val) == math.floor(math.sqrt(val))\\n # if not is_square:\\n # return\\n\\n # if i == len(A):\\n # output.append(A)\\n # return\\n\\n # for j in range(i, len(A)):\\n # A[i], A[j] = A[j], A[i]\\n # search = (i, A[i], tuple(A[:i]))\\n # if search not in seen:\\n # seen.add(search)\\n # backtrack(i + 1, A)\\n\\n # A[i], A[j] = A[j], A[i]\\n\\n # output, seen = [], set()\\n # backtrack(0, A)\\n # return len(output)\\n\\n\",\n \"class Solution:\\n \\n def dfs(self, pos):\\n if pos==self.n:\\n self.ans += 1\\n return\\n \\n last = None\\n for i, val in enumerate(self.a):\\n if self.usable[i]:\\n if val == last:\\n continue\\n if pos-1 >= 0 and (val + self.rec[pos-1]) not in self.square:\\n continue\\n \\n self.usable[i] = False\\n self.rec[pos] = val\\n self.dfs(pos + 1)\\n self.usable[i] = True\\n last = val\\n \\n def numSquarefulPerms(self, A: List[int]) -> int:\\n \\n self.a = sorted(A)\\n self.square=set()\\n i = 0 # not 1\\n while i*i <= self.a[-1]*2:\\n self.square.add(i*i)\\n i += 1\\n \\n #print(self.square)\\n self.ans = 0\\n self.n = len(self.a) \\n self.usable = [True]*self.n\\n self.rec = [None]*self.n\\n self.dfs(0)\\n return self.ans\\n \\n \\n \\n\",\n \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n \\n d = defaultdict(int)\\n res = 0\\n \\n ps = {}\\n i = 0\\n while i*i <= 2*max(A):\\n ps[i*i]=True\\n i += 1\\n \\n def ok(x):\\n return x in ps\\n \\n def solve(x):\\n nonlocal res\\n # takes some number X and multiset D. Returns answer of the problem for numbers in D such that first number is X\\n if not len(d):\\n res += 1\\n return\\n for k in list(d.keys()):\\n if not ok(x + k): continue\\n d[k] -= 1\\n if d[k] == 0: del d[k]\\n solve(k)\\n d[k] += 1\\n \\n \\n for x in A: d[x] += 1\\n for k in list(d.keys()):\\n d[k] -= 1\\n if not d[k]: del d[k]\\n solve(k)\\n d[k] += 1\\n \\n return res\\n \\n\",\n \"from typing import List\\nfrom collections import defaultdict\\n\\nclass Solution:\\n def helper(self, last_num, used, partners, index):\\n if index == len(used):\\n return 1\\n total = 0\\n # print(partners, partners[last_num])\\n for partner, partner_list in partners[last_num].items():\\n for partner_index in partner_list:\\n if not used[partner_index]:\\n used[partner_index] = True\\n total += self.helper(partner, used, partners, index+1)\\n used[partner_index] = False\\n break\\n return total\\n\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n squares = set()\\n i = 0\\n partners = defaultdict(lambda: defaultdict(set))\\n while i * i <= 200000000:\\n squares.add(i*i)\\n i += 1\\n for i in range(len(A)):\\n for j in range(i+1, len(A), 1):\\n if A[i] + A[j] in squares:\\n partners[A[i]][A[j]].add(j)\\n partners[A[j]][A[i]].add(i)\\n unique_nums = dict()\\n for i, num in enumerate(A):\\n unique_nums[num] = i\\n used = [False for _ in A]\\n total = 0\\n for num, i in unique_nums.items():\\n used[i] = True\\n total += self.helper(num, used, partners, 1)\\n used[i] = False\\n return total\",\n \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n\\n A.sort()\\n self.ans = 0\\n\\n def check(A, i, path):\\n return int((A[i] + path[-1])**0.5 + 0.0)**2 == A[i] + path[-1]\\n\\n def dfs(A, path):\\n if len(A) == 0:\\n self.ans += 1\\n return\\n\\n for i in range(len(A)):\\n if i > 0 and A[i] == A[i - 1]:\\n continue\\n if len(path) == 0 or (len(path) > 0 and check(A, i, path)):\\n dfs(A[:i] + A[i + 1:], path + [A[i]])\\n\\n dfs(A, [])\\n return self.ans\\n\",\n \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n def edge(x, y):\\n return int((x + y) ** 0.5) ** 2 == (x + y)\\n \\n def dfs(x, t):\\n count[x] -= 1\\n if t == 0:\\n ans = 1\\n else:\\n ans = 0\\n for y in graph[x]:\\n if count[y]:\\n ans += dfs(y, t - 1)\\n count[x] += 1\\n return ans\\n \\n N = len(A)\\n count = collections.Counter(A)\\n graph = collections.defaultdict(list)\\n for x in count:\\n for y in count:\\n if edge(x, y):\\n graph[x].append(y)\\n \\n return sum(dfs(x, N - 1) for x in count)\\n \\n \\n \\n \\n \\n\",\n \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n A.sort()\\n n = len(A)\\n visited = [False] * n\\n res = []\\n self.count = 0\\n def dfs(curr):\\n if len(curr) == n:\\n self.count += 1\\n return \\n for i in range(n):\\n if visited[i]: continue \\n if i > 0 and A[i] == A[i - 1] and not visited[i - 1]: continue \\n if len(curr) > 0 and (int((curr[-1] + A[i]) ** 0.5))**2 != curr[-1] + A[i]: continue \\n visited[i] = True\\n dfs(curr + [A[i]])\\n visited[i] = False\\n dfs([])\\n return self.count\\n\",\n \"from math import sqrt\\nclass Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n return self.backtrack(A, 0, set())\\n \\n def isPerfect(self, num):\\n return int(sqrt(num))**2 == num\\n \\n def backtrack(self, permutation, j, seen):\\n permutation_tuple = (j,) + tuple(permutation)\\n if permutation_tuple in seen: return 0\\n seen.add(permutation_tuple)\\n if j == len(permutation):\\n return 1\\n total = 0\\n for i in range(j, len(permutation)):\\n self.swap(permutation, i, j)\\n if j == 0 or self.isPerfect(permutation[j] + permutation[j-1]):\\n total += self.backtrack(permutation, j+1, seen)\\n self.swap(permutation, i, j)\\n return total\\n \\n def swap(self, array, i, j):\\n array[i], array[j] = array[j], array[i]\\n\",\n \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n count ={}\\n for i in A:\\n count[i]=count.get(i,0)+1\\n graph = {x: [] for x in A}\\n for x in count:\\n for y in count:\\n if int((x + y) ** 0.5 + 0.5) ** 2 == x + y:\\n graph[x].append(y)\\n def dfs(x, todo):\\n count[x] -= 1\\n if todo == 0:\\n ans = 1\\n else:\\n ans = 0\\n for y in graph[x]:\\n if count[y]:\\n ans += dfs(y, todo - 1)\\n count[x] += 1\\n return ans\\n\\n return sum(dfs(x, len(A) - 1) for x in count)\\n\",\n \"class Solution:\\n def numSquarefulPerms(self, A: List[int]) -> int:\\n c = {}\\n for i in A:\\n c[i]=c.get(i,0)+1\\n cand = {i: [j for j in c if int((i + j)**0.5) ** 2 == i + j] for i in c}\\n\\n def dfs(x, left=len(A) - 1):\\n c[x] -= 1\\n count = sum(dfs(y, left - 1) for y in cand[x] if c[y]) if left else 1\\n c[x] += 1\\n return count\\n return sum(map(dfs, c))\\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":33,"string":"33"},"non_interactive_idx":{"kind":"list like","value":[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],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[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],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":91,"cells":{"problem_id":{"kind":"number","value":227,"string":"227"},"question":{"kind":"string","value":"Given an array A of 0s and 1s, we may change up to K values from 0 to 1.\nReturn the length of the longest (contiguous) subarray that contains only 1s. \n \n\nExample 1:\nInput: A = [1,1,1,0,0,0,1,1,1,1,0], K = 2\nOutput: 6\nExplanation: \n[1,1,1,0,0,1,1,1,1,1,1]\nBolded numbers were flipped from 0 to 1. The longest subarray is underlined.\n\nExample 2:\nInput: A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3\nOutput: 10\nExplanation: \n[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]\nBolded numbers were flipped from 0 to 1. The longest subarray is underlined.\n\n \nNote:\n\n1 <= A.length <= 20000\n0 <= K <= A.length\nA[i] is 0 or 1"},"solutions":{"kind":"string","value":"[\"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n hulu = []\\n cnt = 0\\n num = A[0]\\n for x in A:\\n if x == num:\\n cnt += 1\\n else:\\n hulu.append([num,cnt])\\n cnt = 1\\n num = x\\n if cnt>0:\\n hulu.append([num,cnt])\\n \\n # print(hulu)\\n \\n output = 0\\n \\n if A[0] == 1:\\n start = 0\\n else:\\n start = 1\\n if len(hulu)<2:\\n return min(K,len(A))\\n \\n end = start\\n \\n usage = 0\\n ones = hulu[start][1]\\n while end+2<len(hulu) and usage+hulu[end+1][1]<=K:\\n usage += hulu[end+1][1]\\n ones += hulu[end+2][1]\\n end += 2\\n \\n output = ones+K\\n \\n # print([start,end,usage,ones])\\n \\n start += 2\\n \\n while start<len(hulu):\\n ones -= hulu[start-2][1]\\n usage -= hulu[start-1][1]\\n if start>end:\\n end = start\\n ones = hulu[start][1]\\n usage = 0\\n while end+2<len(hulu) and usage+hulu[end+1][1]<=K:\\n usage += hulu[end+1][1]\\n ones += hulu[end+2][1]\\n end += 2\\n # print([start,end,usage,ones])\\n \\n output = max(output,ones+K)\\n start += 2\\n \\n return min(output,len(A))\\n \\n \\n \\n \\n \\n \\n \\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n if len(A) - sum(A) <= K:\\n return len(A)\\n \\n left = right = 0\\n \\n for right in range(len(A)):\\n if A[right] == 0:\\n K-=1\\n \\n if K < 0:\\n \\n if A[left] == 0:\\n K+=1\\n \\n left += 1\\n \\n return right-left + 1\\n\", \"'''\\n[1,1,1,0,0,0,1,1,1,1,0]\\n i\\n j\\n'''\\n\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n left,right=0,0\\n alen=len(A)\\n \\n while right < alen:\\n \\n if A[right] == 0:\\n K-=1\\n \\n if K < 0:\\n if A[left] == 0:\\n K+=1\\n left+=1\\n right+=1\\n \\n return right - left\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n window_start, max_length, max_ones_count = 0, 0, 0\\n \\n # Try to extend the range [window_start, window_end]\\n for window_end in range(len(A)):\\n if A[window_end] == 1:\\n max_ones_count += 1\\n\\n # Current window size is from window_start to window_end, overall we have a maximum of 1s\\n # repeating 'max_ones_count' times, this means we can have a window with 'max_ones_count' 1s\\n # and the remaining are 0s which should replace with 1s.\\n # now, if the remaining 1s are more than 'k', it is the time to shrink the window as we\\n # are not allowed to replace more than 'k' 0s\\n if (window_end - window_start + 1 - max_ones_count) > K:\\n if A[window_start] == 1:\\n max_ones_count -= 1\\n window_start += 1\\n\\n max_length = max(max_length, window_end - window_start + 1)\\n return max_length\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i,j,count,res = 0,0, 0,0\\n while j<len(A):\\n if A[j]==0:\\n count+=1\\n while count>K:\\n if A[i]==0:\\n count-=1\\n i+=1\\n res= max(res, j-i+1)\\n j+=1\\n return res\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n start, end = 0, 0\\n max_len = 0\\n numzeros = 0\\n while end < len(A):\\n if A[end] == 0:\\n numzeros += 1\\n while numzeros > K:\\n # shrink window\\n if A[start] == 0:\\n numzeros -= 1\\n start += 1\\n max_len = max(max_len, end - start + 1)\\n end += 1\\n return max_len\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n res = 0\\n start, end = 0, 0\\n cnt = 0\\n while end < len(A) and start < len(A):\\n if A[end] == 1:\\n res = max(res, end - start + 1)\\n end += 1\\n elif A[end] == 0 and cnt < K:\\n res = max(res, end - start + 1)\\n cnt += 1\\n end += 1\\n else:\\n if A[start] == 0 and K > 0:\\n cnt -= 1\\n start += 1\\n if start > end:\\n end = start\\n return res\\n \\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n #brute force, linear scan NAIVE APPROACH \\n #start with the largest size and move down, time limit exceeded \\n '''\\n for size in range(len(A)-1, -1, -1): \\n i = 0\\n j = i+size\\n count = 0\\n for ind in range(i, j+1):\\n if A[ind] == 0: \\n count += 1\\n \\n while j < len(A): \\n if count <= K: \\n return size+1\\n else:\\n if A[i] == 0: count -= 1\\n if j < len(A)-1 and A[j+1] == 0: count += 1\\n j += 1\\n i += 1\\n \\n return 0\\n '''\\n \\n #use dynamic variant of sliding window technique\\n maxConsecutiveOnes = 0\\n windowStart = 0\\n currZeroes = 0\\n #iterate through the array linearly and see if the number of 0s is <= K\\n for windowEnd in range(len(A)): \\n if A[windowEnd] == 0: \\n currZeroes += 1\\n \\n #shrinks window \\n while currZeroes > K:\\n if A[windowStart] == 0: \\n currZeroes -= 1\\n \\n windowStart += 1\\n\\n \\n maxConsecutiveOnes = max(maxConsecutiveOnes, windowEnd - windowStart + 1)\\n \\n \\n \\n return maxConsecutiveOnes\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left=0\\n right=0\\n for right in range(len(A)):\\n if A[right]==0:\\n K-=1\\n if K<0:\\n if A[left]==0:\\n K+=1\\n left+=1\\n return right -left +1\\n\", \"class Solution:\\n def longestOnes(self, arr: List[int], K: int) -> int:\\n left = 0\\n \\n for right in range(len(arr)):\\n K -= 1 - arr[right]\\n if K < 0:\\n K += 1 - arr[left]\\n left += 1\\n \\n \\n return right - left + 1\\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], k: int) -> int:\\n leftPtr=0\\n rightPtr=0\\n windowSize=[]\\n \\n while rightPtr<=len(A)-1:\\n if A[rightPtr]==0:\\n k-=1\\n if k<0:\\n if A[leftPtr]==0:\\n k+=1\\n \\n leftPtr+=1\\n rightPtr+=1\\n \\n \\n return rightPtr-leftPtr\\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left = 0\\n for right in range(len(A)):\\n K -= int(A[right] == 0)\\n if K < 0:\\n K += 1 - A[left]\\n left += 1\\n return right - left + 1\\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n start = 0\\n end = 0\\n l = len(A)\\n count = 0\\n max_len = 0\\n while end < l:\\n # print(start, end)\\n if A[end] == 1:\\n max_len = max(max_len, end-start+1)\\n end = end + 1\\n else:\\n if count < K:\\n max_len = max(max_len, end-start +1)\\n count = count+1\\n end = end + 1\\n else:\\n while start <= end and count >= K:\\n if A[start] == 0:\\n count = count -1\\n start = start + 1\\n \\n \\n \\n return max_len\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left = 0\\n for right in range(len(A)):\\n \\n # If we included a zero in the window we reduce the value of K.\\n # Since K is the maximum zeros allowed in a window.\\n K -= (1 - A[right])\\n # A negative K denotes we have consumed all allowed flips and window has\\n # more than allowed zeros, thus increment left pointer by 1 to keep the window size same.\\n if K < 0:\\n # If the left element to be thrown out is zero we increase K.\\n K += 1 - A[left]\\n left += 1\\n return right - left + 1\", \"def solve(arr,n,k):\\n prefix=[0]\\n for i in range(0,n):\\n if(arr[i]==0):\\n prefix.append(prefix[-1]+1)\\n else:\\n prefix.append(prefix[-1])\\n low=0\\n high=n+1\\n ans=0\\n while(low<high):\\n f=0\\n mid=low+(high-low)//2\\n for i in range(mid,n+1):\\n if(prefix[i]-prefix[i-mid]<=k):\\n ans=max(ans,mid)\\n f=1\\n if(f==1):\\n low=mid+1\\n else:\\n high=mid\\n return ans\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n return solve(A,len(A),K)\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n ans , i , c = 0 , 0 , [ ]\\n for j in range( len( A ) ) :\\n if A[ j ] == 0 :\\n c += j ,\\n while len( c ) > K :\\n i = c.pop( 0 ) + 1\\n ans = max( ans , j - i + 1 )\\n return ans\\n#Sanyam Rajpal\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], k: int) -> int:\\n res = 0\\n i = j = 0\\n \\n move = 1\\n while i<len(A) and j<len(A):\\n if move==1:\\n if A[j]==0:\\n if k == 0:\\n move = 0\\n print(i,j)\\n res = max(res,j-i)\\n k -= 1\\n j += 1\\n if move==0:\\n if A[i]==0:\\n k += 1\\n move = 1\\n i += 1\\n \\n return max(res,j-i)\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n start, end = 0, 0\\n \\n for end in range(len(A)):\\n if A[end] == 0:\\n K -= 1\\n if K < 0:\\n if A[start] == 0:\\n K += 1\\n start += 1\\n \\n return end - start + 1\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n ans = 0\\n l = 0\\n r = 0\\n prefix = [0 for i in range(len(A))]\\n for i in range(len(A)):\\n if (i==0):\\n prefix[i] = A[0]\\n else:\\n prefix[i] = A[i] + prefix[i-1]\\n \\n if (K>=len(A)-prefix[-1]):\\n return len(A)\\n \\n \\n while (r<len(A) and l<len(A)):\\n while (r<len(A)):\\n if (l==0):\\n this_sum = prefix[r]\\n else:\\n this_sum = prefix[r] - prefix[l-1]\\n \\n if (r-l+1-this_sum>K):\\n r-=1\\n break\\n \\n r+=1\\n \\n if (r>=len(A)):\\n if (r-l>ans):\\n #print (l,r,ans)\\n ans = r-l\\n break\\n \\n if (r-l+1>ans):\\n #print (l,r,ans)\\n ans = r-l+1\\n \\n #r+=1\\n while (l<len(A) and A[l] == 1):\\n l+=1\\n \\n l+=1\\n \\n return ans\\n \\n \\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n count=0\\n maxCount=-1\\n first=0\\n for i in range(len(A)):\\n if A[i]==0 and K!=0:\\n count+=1\\n K-=1\\n elif A[i]==0 and K==0:\\n while A[first]!=0:\\n first+=1\\n count-=1\\n first+=1\\n else:\\n count+=1\\n maxCount=max(maxCount,count)\\n return maxCount\\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n # don't reduce window - time O(n); space O(1)\\n left = 0\\n for right in range(len(A)):\\n K -= (1 - A[right])\\n if K < 0:\\n K += (1 - A[left])\\n left += 1\\n \\n return right - left + 1\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i, j = 0, 0\\n count = 0\\n out = 0\\n for i in range(len(A)):\\n if A[i] == 0:\\n count += 1\\n while count > K and j < len(A):\\n if A[j] == 0:\\n count -= 1\\n j += 1\\n out = max(out, i - j + 1)\\n return out\\n \\n\", \"class Solution:\\n def longestOnes(self, a: List[int], K: int) -> int:\\n i = 0\\n j = 0\\n ml = 0\\n while i < len(a):\\n if a[i] == 0:\\n K -= 1\\n while K < 0:\\n if a[j] == 0:\\n K += 1\\n j += 1\\n ml = max(ml, i-j+1)\\n i += 1\\n return ml\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n '''naive\\n \\n \\n sliding window\\n keep growing sliding window rhs as num of 0s in window is >k\\n when num 0s == k, slide lhs of window until k > num 0s again\\n keep track of largest sliding window'''\\n \\n \\n if not A:\\n return 0\\n \\n best_window_len = 0\\n p, q = 0, 0\\n \\n num_zeros = 0\\n #if A[q] == 0: num_zeros += 1\\n \\n while q < len(A):\\n if A[q] == 0: num_zeros += 1\\n #print(p, q, q - p)\\n if num_zeros > K:\\n best_window_len = max(q - p, best_window_len)\\n #print(\\\\\\\"running best:\\\\\\\", best_window_len)\\n while num_zeros > K:\\n if A[p] == 0:\\n num_zeros -= 1\\n p += 1\\n q+=1\\n \\n best_window_len = max(q - p, best_window_len)\\n #if p == 0:\\n #best_window_len+=1\\n #print(best_window_len)\\n return best_window_len\\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n subarrays = []\\n start = -1\\n i = 0\\n while i < len(A):\\n if A[i] == 1:\\n if start == -1:\\n start = i\\n else:\\n if start != -1:\\n subarrays.append([start, i])\\n start = -1\\n i += 1\\n if A[i-1] == 1:\\n subarrays.append([start, i])\\n print(subarrays)\\n \\n if K == 0:\\n result = 0\\n for arr in subarrays:\\n if arr[1] - arr[0] > result:\\n result = arr[1] - arr[0]\\n return result\\n \\n window = []\\n start = []\\n end = []\\n result = 0\\n for i in range(len(A)):\\n if A[i] == 0: \\n if len(window) == K:\\n window.pop(0)\\n window.append(i)\\n left = window[0] - 1\\n right = window[-1] + 1\\n while left >= 0 and A[left] != 0:\\n left -=1\\n while right < len(A) and A[right] != 0:\\n right += 1\\n if right - left > result:\\n result = right - left\\n # for i in range(start, len(subarrays)):\\n # if subarrays[i][0] > window[0]:\\n # break\\n # start = i\\n # for i in range(len(subarrays)-1, end-1, -1):\\n # if subarrays[i][1] < window[-1]:\\n # break\\n # end = i\\n \\n # result = 0\\n # for curr_k in range(K, 0, -1)\\n # i = 0\\n # while i < len(subarrays) - 1:\\n # gap = subarrays[i][1] + subarrays[i][0] - 1\\n # if gap == curr_k:\\n return result - 1\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n start = end = 0\\n res = 0\\n map = collections.defaultdict(int)\\n while end < len(A):\\n map[A[end]] += 1\\n while end - start + 1 - map[1] > K:\\n map[A[start]] -= 1\\n start += 1\\n res = max(res, end-start+1)\\n end += 1\\n \\n return res\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n begins = [-1] * (K+1)\\n cur = [0] * (K+1)\\n maxL = 0\\n curMax = 0\\n for i, a in enumerate(A):\\n if a == 0:\\n maxL = max(maxL, curMax)\\n begins.pop(0)\\n begins.append(i)\\n curMax -= cur.pop(0)\\n curMax += 1 if begins[0] == -1 else 0\\n cur.append(0)\\n else:\\n cur[-1] += 1\\n curMax += 1\\n return max(maxL, curMax)\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n right = 0\\n for i in range(len(A)):\\n if A[i] == 0:\\n A[i] = 1\\n else:\\n A[i] = 0\\n tot = A[0]\\n res = 0\\n \\n for left in range(len(A)):\\n while tot <= K:\\n right = right + 1\\n if right >= len(A):\\n break\\n tot = tot + A[right]\\n res = max(res, right - left)\\n if right >= len(A) - 1:\\n break\\n if A[left] == 1:\\n tot = tot - 1\\n \\n return res\\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n if A.count(0) <= K:\\n return len(A)\\n \\n res = 0\\n i = 0\\n for j in range(len(A)):\\n if A[j] == 0:\\n K -= 1\\n res = max(res, j-i)\\n while K < 0 and i <= j:\\n if A[i] == 0:\\n K += 1\\n i += 1\\n \\n return max(res, len(A)-i)\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n k = K\\n j = ans = 0\\n for i in range(len(A)):\\n if not A[i]:\\n k -= 1\\n \\n while k<0:\\n if not A[j]:\\n k += 1\\n j += 1\\n ans = max(ans, i-j+1)\\n \\n return ans\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i, res = 0, 0\\n for j in range(len(A)):\\n K -= 1 - A[j]\\n while K < 0:\\n K += 1 - A[i]\\n i += 1\\n res = max(res, j - i + 1)\\n return res\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left, right = 0,0\\n max_window = 0\\n zero_positions = []\\n num_violations = 0\\n while right < len(A):\\n if A[right] == 0:\\n num_violations +=1\\n zero_positions.append(right)\\n if num_violations > K:\\n left = zero_positions[0] +1\\n zero_positions.pop(0)\\n num_violations -=1\\n right +=1\\n max_window = max(max_window, right - left)\\n return max_window\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n z_count = 0\\n l = 0\\n result = 0\\n for i in range(len(A)):\\n if not A[i]:\\n z_count+=1\\n if z_count <= K:\\n result = max(result, i-l+1)\\n while l < i and z_count>K:\\n if not A[l]:\\n z_count-=1\\n l+=1\\n\\n \\n return result\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n longest = start = end = zeroes = 0\\n while end < len(A):\\n num = A[end]\\n\\n if not num:\\n zeroes += 1\\n end += 1\\n while zeroes > K:\\n if A[start] == 0:\\n zeroes -= 1\\n start += 1\\n longest = max(longest, end - start)\\n return longest \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n res = 0\\n i, j, N = 0, 0, len(A)\\n remaining = K if A[i] == 1 else K - 1\\n while i < N:\\n # resetting\\n if i > j:\\n j = i\\n remaining = K if A[i] == 1 else K - 1\\n\\n # stretch\\n while j + 1 < N and remaining >= 0:\\n if A[j + 1] == 0:\\n if remaining > 0:\\n remaining -= 1\\n else:\\n break\\n j += 1\\n res = max(res, j - i + 1)\\n\\n # pay debt\\n if A[i] == 0:\\n remaining += 1\\n i += 1\\n return res\", \"class Solution:\\n def longestOnes(self, x: List[int], K: int) -> int:\\n \\n buf = collections.deque()\\n n = len(x)\\n i = 0\\n unused = K\\n start = -1\\n maxlen = float('-inf')\\n while i < n:\\n if x[i] == 0:\\n if unused > 0:\\n buf.append(i)\\n unused -= 1\\n maxlen = max(i - start, maxlen)\\n else:\\n if buf:\\n start = buf.popleft()\\n maxlen = max(i - start, maxlen)\\n buf.append(i)\\n else:\\n # K == 0\\n maxlen = max(i - 1 - start, maxlen)\\n start = i\\n else:\\n maxlen = max(i - start, maxlen)\\n \\n \\n i += 1\\n return maxlen if n > 0 else n\", \"# 1,1,1,0,0,0,1,1,1,1,0\\n# max=5,k=0 [ ]\\n\\n# 1,1,1,0,0,0,1,1,1,1,0\\n# max=5,k=-1 [ ]\\n\\n# 1,1,1,0,0,0,1,1,1,1,0\\n# max=6,k=0 [ ]\\n\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n l = 0\\n for r in range(len(A)):\\n if A[r] == 0:\\n K-=1\\n \\n if K<0:\\n if A[l] == 0:\\n K+=1\\n l+=1\\n return r-l+1\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n lo = 0\\n hi = len(A)\\n A = [0] + [1-x for x in A]\\n n = len(A)\\n for i in range(1, n):\\n A[i] += A[i-1]\\n \\n while lo < hi:\\n mid = (lo + hi + 1) // 2\\n \\n if min(A[i] - A[i-mid] for i in range(mid, len(A))) <= K:\\n lo = mid\\n else:\\n hi = mid - 1\\n \\n return lo\\n\", \"'''\\n\\nInput: A = [1,1,1,0,0,0,1,1,1,1,0], K = 2\\nOutput: 6\\n\\n\\n\\n\\n\\n\\n\\n'''\\n\\n\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n '''\\n Sliding window technique\\n '''\\n # if there's no array\\n if not A:\\n return 0\\n \\n # define a window\\n window = 0\\n \\n # define start of the window\\n start = 0\\n \\n # maximum allowed ones\\n max_ones = 0\\n \\n # iterate over A\\n for it, value in enumerate (A):\\n \\n # add value to window\\n window += value\\n \\n # eviction reached?\\n # [1,1,1,0,0,0,1,1,1,1,0]\\n if it - start + 1 > window + K:\\n window -= A[start]\\n start += 1\\n \\n # figure the maximum ones possible\\n max_ones = max (max_ones, window + K)\\n \\n return min (max_ones, len (A))\", \"class Solution:\\n def longestOnes(self, A: List[int], k: int) -> int:\\n \\n \\n \\n ans=0\\n i=0\\n \\n for j,c in enumerate(A):\\n k-=(1-c)\\n if k<0:\\n k+=1-A[i]\\n i+=1\\n ans=max(ans,j-i+1)\\n return max(ans,j-i+1)\\n \\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left=0\\n right=0\\n maxlength=0\\n hashmap={}\\n count=0\\n while right<len(A):\\n hashmap[A[right]]=hashmap.get(A[right],0)+1\\n while A[right]==0 and hashmap[A[right]]>K:\\n hashmap[A[left]]-=1\\n left+=1\\n maxlength=max(maxlength,right-left+1)\\n right+=1\\n return maxlength\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left = 0\\n right = 0\\n contains = 0\\n max_len = 0\\n \\n while right < len(A):\\n if A[right] == 0:\\n contains += 1\\n \\n if contains > K:\\n while contains > K:\\n if A[left] == 0:\\n contains -= 1\\n left += 1\\n max_len = max(max_len, right - left + 1)\\n right += 1\\n \\n return max_len\\n \\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n l = len(A)\\n end = 0\\n start = 0\\n ans = 0\\n count = 0\\n for i in range(l):\\n if A[i] == 1:\\n count += 1\\n if end - start + 1 - count <= K:\\n ans = max(ans, end - start + 1)\\n else:\\n if A[start] == 1:\\n count -= 1\\n start += 1\\n end += 1\\n return ans\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n lo, hi = 0, 0\\n zmax = 0\\n n_k = 0\\n while hi < len(A):\\n # print(f\\\\\\\"{lo},{hi}, {zmax}\\\\\\\")\\n if A[hi] == 0:\\n n_k += 1\\n # break\\n \\n while n_k > K:\\n if A[lo] == 0:\\n n_k-=1\\n lo+=1\\n \\n zmax = max(zmax, hi-lo+1)\\n \\n \\n hi+=1\\n return zmax\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left=0\\n for right in range(len(A)):\\n K-=1-A[right]\\n \\n if K<0:\\n K +=1-A[left]\\n left+=1\\n return right-left+1\\n \\n \\n \\n\", \"class Solution:\\n def findMaxConsecutiveOnes(self, nums: List[int]) -> int:\\n if len(nums) == 0:\\n return 0 \\n\\n # left - on the first 1 of the island\\n # right - on the last 1 of that island\\n left = 0\\n while left < len(nums) and nums[left] != 1:\\n left += 1\\n\\n right = left \\n while right + 1 < len(nums) and nums[right + 1] == 1:\\n right += 1\\n\\n if right == len(nums):\\n return 0\\n\\n maxOnes = right - left + 1\\n\\n while left < len(nums):\\n left = right + 1\\n while left < len(nums) and nums[left] != 1:\\n left += 1\\n\\n right = left \\n while right + 1 < len(nums) and nums[right + 1] == 1:\\n right += 1\\n\\n maxOnes = max(maxOnes, right - left + 1)\\n\\n return maxOnes\\n \\n \\n def longestOnes(self, A: List[int], K: int) -> int:\\n if K == 0:\\n return self.findMaxConsecutiveOnes(A)\\n \\n if len(A) == 0:\\n return 0\\n\\n left, right = 0, 0\\n\\n # Pre-condition: In the [left, right] we have exactly K zeros,\\n # and you can't move right any more\\n\\n # Move right to K-th zero\\n if A[right] == 0:\\n K -= 1\\n while right + 1 < len(A) and K > 0:\\n right += 1\\n if A[right] == 0:\\n K -= 1\\n\\n # Move more if there are 1s to the right of K-th zero \\n while right + 1 < len(A) and A[right + 1] == 1:\\n right += 1\\n\\n maxSize = right - left + 1\\n\\n while right < len(A):\\n # Move left off of a zero, and then move right accordingly to include 1 more zero\\n while left < len(A) and A[left] != 0:\\n left += 1\\n if left < len(A):\\n left += 1\\n else:\\n return maxSize\\n\\n\\n # Move right to include one more zero \\n right += 1\\n while right + 1 < len(A) and A[right + 1] == 1:\\n right += 1\\n\\n maxSize = max(maxSize, right - left + 1)\\n \\n return maxSize \", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n # find the maximum subarray with max of K 0's \\n # this will help find the maximum number of 1s \\n \\n # [1,1,1,0,0,0,1,1,1,1,0]\\n # fast = 5\\n # slow = 0\\n # lastZero = 3, 4, 5\\n # slow = 3\\n slow = fast = 0\\n maxOnes = -1\\n lastZero = collections.deque()\\n while fast < len(A):\\n if A[fast] == 0:\\n lastZero.append(fast)\\n if len(lastZero) > K:\\n slow = lastZero.popleft() + 1\\n fast += 1 \\n maxOnes = max(maxOnes, (fast - slow))\\n \\n if maxOnes == -1:\\n return len(A)\\n return maxOnes\\n \\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n st,ed = 0,0\\n ans = 0\\n \\n longest = 0\\n k = 0\\n while ed < len(A):\\n while ed < len(A):\\n if A[ed] == 1:\\n longest += 1\\n elif k < K:\\n k += 1\\n longest += 1\\n else:\\n break\\n \\n ed += 1\\n \\n ans = max(longest, ans) \\n while st <= ed and st < len(A):\\n longest -= 1\\n if A[st] == 0:\\n k -= 1\\n st += 1\\n break\\n \\n st += 1\\n \\n return ans\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n onecount = 0 \\n start = 0\\n ans = 0\\n \\n for end in range(len(A)):\\n if A[end] == 1: \\n onecount += 1\\n \\n if end - start + 1 - onecount > K:\\n if A[start] == 1: onecount -= 1\\n start += 1\\n \\n ans = max(ans , end - start +1)\\n \\n return ans\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n start, end, max_length, num_0 = 0, 0, 0, int(not A[0])\\n while end < len(A) - 1:\\n if num_0 > K:\\n if A[start] == 0:\\n num_0 -= 1\\n start += 1\\n end += 1\\n if A[end] == 0:\\n num_0 += 1\\n if num_0 <= K:\\n max_length = end - start + 1\\n return max_length\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n startWindow = 0\\n maxLength = 0\\n nZerosInsideWindow = 0\\n \\n for endWindow, el in enumerate(A):\\n nZerosInsideWindow += (el == 0)\\n \\n while nZerosInsideWindow > K:\\n firstElement = A[startWindow]\\n nZerosInsideWindow -= (firstElement == 0)\\n startWindow += 1\\n \\n maxLength = max(maxLength, endWindow - startWindow + 1)\\n \\n return maxLength\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n n = len(A)\\n if n == 0:\\n return 0\\n \\n head = 0\\n tail = 0\\n num_zeros = 0\\n max_subseq = 0\\n while head < n:\\n if A[head] == 1:\\n head += 1\\n else:\\n num_zeros += 1\\n max_subseq = max(max_subseq, head-tail)\\n if num_zeros > K:\\n while A[tail] == 1:\\n tail += 1\\n tail += 1\\n num_zeros -= 1\\n head += 1\\n max_subseq = max(max_subseq, n-tail)\\n return max_subseq\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n allowance = K\\n currSum = 0\\n left = 0\\n maxSum = 0\\n for i in range(len(A)):\\n if A[i] == 1:\\n currSum += 1\\n else:\\n allowance -= 1\\n while allowance < 0:\\n if A[left] == 1:\\n currSum -= 1\\n else:\\n allowance += 1\\n left += 1\\n maxSum = max(maxSum, K - allowance + currSum)\\n return maxSum\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n res = 0\\n i = 0\\n for j in range(len(A)):\\n if A[j] == 0:\\n K -= 1\\n res = max(res, j - i)\\n while K < 0:\\n if A[i] == 0:\\n K += 1\\n i += 1\\n return max(res, len(A) - i)\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n res = 0\\n i = 0\\n for j in range(len(A)):\\n if A[j]==0:\\n K-=1\\n res = max(res,j-i)\\n \\n while K<0:\\n if(A[i]==0):\\n K+=1\\n i += 1\\n \\n return max(res,len(A)-i)\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left = right = 0\\n \\n for right in range(len(A)):\\n # if we encounter a 0 the we decrement K\\n if A[right] == 0:\\n K -= 1\\n # else no impact to K\\n \\n # if K < 0 then we need to move the left part of the window forward\\n # to try and remove the extra 0's\\n if K < 0:\\n # if the left one was zero then we adjust K\\n if A[left] == 0:\\n K += 1\\n # regardless of whether we had a 1 or a 0 we can move left side by 1\\n # if we keep seeing 1's the window still keeps moving as-is\\n left += 1\\n \\n return right - left + 1\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int: \\n res = 0\\n i = 0\\n for j in range(len(A)):\\n if A[j] == 0:\\n K -= 1\\n res = max(res, j-i)\\n while K < 0 and i <= j:\\n if A[i] == 0:\\n K += 1\\n i += 1\\n \\n return max(res, len(A)-i)\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n \\n i = 0\\n res = 0\\n for j, a in enumerate(A): \\n if a == 0:\\n K-=1 \\n while K < 0:\\n if A[i] == 0:\\n K+=1\\n i+=1 \\n else:\\n res = max(res, j-i+1)\\n return res\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n l, ans = 0, 0\\n for r in range(len(A)):\\n if A[r] == 0:\\n K -= 1\\n while K < 0:\\n if A[l] == 0:\\n K += 1\\n l += 1\\n ans = max(ans, r+1-l)\\n \\n return ans\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n if A == None or len(A) == 0 or K == None:\\n return 0\\n if len(A) <= K:\\n return K\\n \\n left = 0\\n flip = 0\\n maxlength = 0\\n for i, num in enumerate(A):\\n if A[i] == 0:\\n flip += 1\\n if flip <= K:\\n maxlength = max(maxlength, i - left + 1)\\n \\n while left < i and flip > K:\\n if A[left] == 0:\\n flip -=1\\n left += 1\\n\\n return maxlength\\n \\n \\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n count, n, l = 0, len(A), 0\\n ans = 0\\n for r in range(n):\\n count += 1 - A[r]\\n while count > K:\\n count -= 1 - A[l]\\n l += 1\\n ans = max(ans, r-l+1)\\n return ans\\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n ans = 0\\n l = 0\\n for r in range(len(A)):\\n if A[r] == 0:\\n K -= 1\\n while K < 0:\\n if A[l] == 0:\\n K += 1\\n l += 1\\n ans = max(ans, r+1-l)\\n \\n return ans\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n windowstart, curr0,res = 0,0, 0\\n currwindow = {1:0 , 0:0}\\n \\n \\n for windowend in range(len(A)):\\n\\n # add the new element into the current window,\\n currwindow[A[windowend]] +=1\\n # check if the least common number is above k\\n curr0 = currwindow[0]\\n\\n # if yes, increase the window start \\n if curr0 > K :\\n currwindow[A[windowstart]] -=1\\n windowstart +=1\\n \\n # look for the window size and max with the max and the current length\\n res = max (res, windowend-windowstart +1 )\\n\\n return res \", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n count_1 = 0\\n zero_inx = []\\n res = 0\\n zero_before = -1\\n for i in range(len(A)):\\n if A[i] == 1:\\n count_1 += 1\\n else:\\n zero_inx.append(i)\\n if K > 0:\\n K -= 1\\n count_1 += 1\\n elif K == 0:\\n res = max(res,count_1)\\n first_0 = zero_inx.pop(0)\\n count_1 -= (first_0 - zero_before - 1)\\n zero_before = first_0\\n res = max(res, count_1)\\n return res\", \"class Solution:\\n def longestOnes(self, arr: List[int], k: int) -> int:\\n start_index = 0\\n longest_ones = 0\\n max_length = 0\\n for end_index in range(len(arr)):\\n if arr[end_index] == 1:\\n longest_ones += 1\\n if longest_ones+k <= (end_index - start_index):\\n if arr[start_index] == 1:\\n longest_ones -= 1\\n start_index += 1\\n max_length = max(max_length, end_index-start_index+1)\\n return max_length\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n if A == None or len(A) == 0 or K == None:\\n return 0\\n if len(A) <= K:\\n return K\\n \\n left = 0\\n count_of_zero = 0\\n maxlength = 0\\n for i, num in enumerate(A):\\n if A[i] == 0:\\n count_of_zero += 1\\n if count_of_zero <= K:\\n maxlength = max(maxlength, i - left + 1)\\n \\n while left < i and count_of_zero > K:\\n if A[left] == 0:\\n count_of_zero -=1\\n left += 1\\n\\n return maxlength\\n \\n \\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n l = 0\\n res = 0\\n for h in range(len(A)):\\n K -= 1 - A[h]\\n if K < 0:\\n K += 1 - A[l]\\n l += 1\\n return h-l+1\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i = 0\\n j = 0\\n \\n numZeros = 0\\n \\n bestSize = 0\\n while j < len(A):\\n if A[j] == 1:\\n pass\\n elif A[j] == 0:\\n numZeros += 1\\n while numZeros > K:\\n if i >= 0 and A[i] == 0:\\n numZeros -= 1\\n i += 1\\n bestSize = max(bestSize, j - i + 1)\\n j += 1\\n return bestSize\", \"\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n s, e = 0, 0\\n r_k = K\\n result = 0\\n while e < len(A):\\n if A[e] == 0:\\n r_k -= 1\\n\\n while r_k < 0:\\n if A[s] == 0:\\n r_k += 1\\n s += 1\\n\\n result = max(result, e - s + 1)\\n\\n e+=1\\n\\n return result\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n res = -1\\n start, count = 0, 0 # start is beginning of window, count is number of 1s\\n # i is end of window, hence len of window is i-start+1\\n \\n for i in range(len(A)):\\n if A[i]==1: count += 1\\n while (i-start+1-count > K):\\n if A[start]==1: count -= 1\\n start += 1\\n res = max(res, i-start+1)\\n \\n return res\\n \\n\", \"class Solution:\\n def longestOnes(self, s: List[int], k: int) -> int:\\n l = 0\\n c_frequency = {0:0, 1:0}\\n longest_str_len = 0\\n for r in range(len(s)):\\n \\n if s[r] == 0:\\n c_frequency[0] += 1\\n else:\\n c_frequency[1] += 1\\n \\n # Replacements cost = cells count between left and right - highest frequency\\n cells_count = r - l + 1\\n if c_frequency[0] <= k or c_frequency[0] == 0:\\n longest_str_len = max(longest_str_len, cells_count)\\n \\n else:\\n if c_frequency[s[l]] != 0:\\n c_frequency[s[l]] -= 1\\n l += 1\\n \\n return longest_str_len\", \"class Solution:\\n def longestOnes(self, A, K):\\n window_start, max_length, max_ones_count = 0, 0, 0\\n for window_end in range(0, len(A)):\\n if A[window_end] == 1:\\n max_ones_count += 1\\n while window_end - window_start + 1 - max_ones_count > K:\\n if A[window_start] == 1:\\n max_ones_count -= 1\\n window_start += 1\\n max_length = max(max_length, window_end - window_start + 1)\\n return max_length\\n\", \"import bisect\\n\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n ans = countzeroes = 0\\n counter = {0: -1}\\n for i, num in enumerate(A):\\n if num==0:\\n countzeroes+=1\\n if countzeroes not in counter:\\n counter[countzeroes] = i\\n j = counter[max(0, countzeroes-K)]\\n ans = max(ans, i-j)\\n \\n return ans\\n\", \"import bisect\\n\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n ans = countzeroes = 0\\n counter = {0: -1}\\n for i in range(len(A)):\\n num = A[i]\\n if num==0:\\n countzeroes+=1\\n if countzeroes not in counter:\\n counter[countzeroes] = i\\n j = counter[max(0, countzeroes-K)]\\n ans = max(ans, i-j)\\n \\n return ans\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n l,r = 0, -1\\n optim = 0\\n while r < len(A):\\n while r < len(A):\\n r += 1\\n if r == len(A):\\n break\\n if A[r] == 0:\\n K -= 1\\n if K < 0:\\n break\\n else:\\n optim = max(optim, r-l+1)\\n if r == len(A):\\n break\\n while l < r:\\n if A[l] == 0:\\n K += 1\\n l += 1\\n if K >= 0:\\n break\\n return optim\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n count = maxS = j = 0\\n \\n for i, a in enumerate(A):\\n if a == 0:\\n count += 1\\n \\n while j < len(A) and count > K:\\n if A[j] == 0:\\n count -= 1\\n j += 1\\n \\n maxS = max(maxS, i-j+1)\\n \\n return maxS\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n windowstart,most_common,res=0,0,0\\n currentwindow={1:0, 0:0}\\n \\n for windowend in range(len(A)):\\n\\n currentwindow[A[windowend]] +=1\\n\\n most_common = currentwindow[1]\\n\\n \\n #having this means we have to reduce the length of the window\\n if (windowend-windowstart+1 - most_common > K):\\n \\n currentwindow[A[windowstart]] -=1\\n windowstart +=1\\n\\n res = max(res,windowend-windowstart+1)\\n \\n return res\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left = 0\\n for right in range(len(A)):\\n # If we included a zero in the window we reduce the value of K.\\n # Since K is the maximum zeros allowed in a window.\\n K -= 1 - A[right]\\n # A negative K denotes we have consumed all allowed flips and window has\\n # more than allowed zeros, thus increment left pointer by 1 to keep the window size same.\\n if K < 0:\\n # If the left element to be thrown out is zero we increase K.\\n K += 1 - A[left]\\n left += 1\\n return right - left + 1\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n zeros, ones, max_len = 0, 0,0\\n def element_found(element, inc):\\n nonlocal zeros, ones, max_len\\n if element == 0:\\n zeros += inc\\n else:\\n ones += inc\\n \\n start = 0\\n for element in A:\\n element_found(element, 1)\\n \\n while zeros > K:\\n start,start_element = start+1, A[start]\\n element_found(start_element, -1)\\n \\n max_len = max(max_len, zeros + ones)\\n return max_len\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n if not A:\\n return 0\\n \\n n = len(A)\\n \\n cur_max = 0\\n counter = 0\\n index = []\\n prev = -1\\n \\n for i in range(n):\\n if A[i] == 1:\\n counter += 1\\n else:\\n if K > 0:\\n K -= 1\\n counter += 1\\n index.append(i)\\n else:\\n if index:\\n counter += 1\\n temp = index.pop(0)\\n counter -= temp - prev\\n prev = temp\\n index.append(i)\\n else:\\n counter = 0\\n \\n cur_max = max(cur_max, counter)\\n \\n return cur_max\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n left = 0\\n right = 0 \\n \\n k = K\\n max_ans = 0\\n so_far = 0\\n while(right < len(A)):\\n if(A[right]==1):\\n right+=1\\n else:\\n if(k>0):\\n right+=1\\n k-=1\\n else:\\n if(A[left]==0):\\n k+=1\\n left+=1\\n \\n max_ans = max(max_ans, right-left)\\n \\n return max_ans\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n zeros_indices = []\\n for i in range(len(A)):\\n if A[i] == 0:\\n zeros_indices.append(i)\\n\\n longest_ones = 0\\n\\n\\n longest_yet = 0\\n for i in range(len(A)):\\n if A[i] == 1:\\n longest_yet += 1\\n longest_ones = max(longest_ones, longest_yet)\\n else:\\n longest_yet = 0\\n if K == 0:\\n return longest_ones\\n\\n if K >= len(zeros_indices):\\n return len(A)\\n\\n\\n # [0, 1, 4, 5, 9, 12, 13, 14]\\n zero_order = -1\\n for i in range(len(A)):\\n if A[i] == 0:\\n zero_order += 1\\n right_cons_ones = left_cons_ones = 0\\n if zero_order + K < len(zeros_indices):\\n nxt = zero_order + K\\n right_cons_ones = zeros_indices[nxt] - zeros_indices[zero_order]\\n else:\\n nxt = len(zeros_indices) - 1\\n right_cons_ones = zeros_indices[nxt] - zeros_indices[zero_order]\\n right_cons_ones += len(A) - zeros_indices[nxt]\\n if not zero_order == 0: \\n left_cons_ones = zeros_indices[zero_order] - zeros_indices[zero_order-1] - 1\\n longest_ones = max(longest_ones, right_cons_ones + left_cons_ones)\\n return longest_ones\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n hash_count = dict()\\n hash_count[1] = 0\\n start = 0\\n max_count = 0\\n max_result = 0\\n for end in range(len(A)):\\n if A[end] == 1:\\n hash_count[A[end]] += 1 \\n max_count = max(max_count, hash_count[1])\\n if max_count + K < ( end - start + 1 ):\\n if A[start] == 1 and hash_count.get(1):\\n hash_count[1] -= 1\\n start += 1\\n max_result = max(max_result, end-start + 1)\\n return max_result\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n max_length = 0\\n start = 0\\n end = 1 \\n \\n zeros = 0\\n \\n if len(A) == 0:\\n return 0\\n if len(A) == 1:\\n return 1\\n \\n zeros = 2 - sum(A[:2])\\n \\n while end < len(A):\\n \\n valid = zeros <= K\\n \\n if valid:\\n max_length = max(max_length, (end - start)+1)\\n end += 1\\n if end == len(A):\\n return max_length\\n \\n if A[end] == 0:\\n zeros += 1\\n else:\\n if A[start] == 0:\\n zeros -= 1\\n start += 1\\n return max_length\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int: \\n K_original = K\\n i = 0\\n ans = 0\\n curr = 0\\n \\n j =0 \\n while(j<len(A)):\\n if A[j]==1 or K>0:\\n curr += 1\\n else:\\n curr = 0\\n K-=1 if (A[j]==0 and K>0) else 0\\n j+=1\\n ans = max(curr, ans)\\n if K_original>0 and K==0:\\n while(j<len(A) and A[j]==1):\\n curr+=1\\n j+=1\\n ans = max(curr, ans)\\n while(i<=j and i<len(A) and K==0):\\n if A[i]==0:\\n K+=1\\n i+=1\\n curr -=1 \\n # print(i,j,K, curr, ans)\\n return ans\\n\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n hash_count = dict()\\n hash_count[1] = 0\\n start = 0\\n max_count = 0\\n max_result = 0\\n for end in range(len(A)):\\n if A[end] == 1:\\n hash_count[A[end]] += 1 \\n max_count = max(max_count, hash_count[1])\\n #print(f\\\\\\\" {max_count + K} comp {end - start + 1}\\\\\\\")\\n if max_count + K < ( end - start + 1 ):\\n if A[start] == 1 and hash_count.get(1):\\n hash_count[1] -= 1\\n start += 1\\n max_result = max(max_result, end-start + 1)\\n #print(max_result)\\n return max_result\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left, right = 0, 0\\n k = 0\\n flipped = set()\\n longest = 0\\n while right < len(A):\\n if A[right] == 1:\\n longest = max(longest, right - left + 1)\\n right += 1\\n elif A[right] == 0 and k < K:\\n flipped.add(right)\\n longest = max(longest, right - left + 1)\\n right += 1\\n k += 1\\n elif left == right:\\n right += 1\\n left += 1\\n else:\\n if left in flipped:\\n flipped.discard(left)\\n k -= 1\\n left += 1\\n \\n \\n return longest\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n ct = Counter()\\n pt, max_len = 0, 0\\n for i, elem in enumerate(A):\\n ct[elem] += 1\\n if ct[0] <= K:\\n max_len = max(max_len, (i - pt + 1))\\n if ct[0] > K:\\n ct[A[pt]] -= 1\\n \\n pt += 1\\n\\n return max_len\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n left = 0\\n for right in range(len(A)):\\n # If we included a zero in the window we reduce the value of K.\\n # Since K is the maximum zeros allowed in a window.\\n K -= 1 - A[right]\\n # A negative K denotes we have consumed all allowed flips and window has\\n # more than allowed zeros, thus increment left pointer by 1 to keep the window size same.\\n if K < 0:\\n # If the left element to be thrown out is zero we increase K.\\n K += 1 - A[left]\\n left += 1\\n print(len(A),right)\\n return right - left + 1\", \"from collections import deque\\n\\n\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n substited_indexes = deque()\\n start = 0\\n best = 0\\n \\n index = 0\\n while index < len(A):\\n num = A[index]\\n \\n if num == 0:\\n if K > 0:\\n K -= 1\\n A[index] = 1\\n substited_indexes.append(index)\\n elif K == 0 and len(substited_indexes) == 0:\\n start = index + 1\\n else:\\n start = substited_indexes.popleft()\\n A[start] = 0\\n start += 1\\n K += 1\\n continue\\n \\n index += 1\\n best = max(best, index - start)\\n \\n return best\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n max_length = 0\\n start = 0\\n end = 1\\n ones = 1\\n\\n if len(A) == 0:\\n return 0\\n if len(A) == 1:\\n return 1\\n\\n ones = A[0] + A[1]\\n\\n while end < len(A):\\n\\n valid = ((end - start) + 1) - ones <= K\\n\\n if valid:\\n max_length = max(max_length, (end - start) + 1)\\n end += 1\\n if end == len(A):\\n return max_length\\n ones += A[end]\\n else:\\n ones -= A[start]\\n start += 1\\n return max_length\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n answer, length = 0, 0\\n inds = []\\n for i, num in enumerate(A):\\n if num == 1:\\n length += 1\\n elif len(inds) < K:\\n inds.append(i)\\n length += 1\\n elif K == 0:\\n length = 0\\n else:\\n last_index = inds.pop(0)\\n inds.append(i)\\n length = (i - inds[0]) + (inds[0] - last_index)\\n answer = max(answer, length)\\n return answer\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n max_length = 0\\n start = 0\\n end = 1\\n ones = 1\\n\\n if len(A) == 0:\\n return 0\\n if len(A) == 1:\\n return 1\\n\\n ones = sum(A[:2])\\n\\n while end < len(A):\\n\\n valid = ((end - start) + 1) - ones <= K\\n\\n if valid:\\n max_length = max(max_length, (end - start) + 1)\\n end += 1\\n if end == len(A):\\n return max_length\\n ones += A[end]\\n else:\\n ones -= A[start]\\n start += 1\\n return max_length\\n\", \"import bisect\\n\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n ans = 0\\n countzeroes = 0\\n prefix = []\\n for i, num in enumerate(A):\\n prefix.append(countzeroes)\\n if num==0:\\n countzeroes+=1\\n j = bisect.bisect_left(prefix, countzeroes-K)\\n ans = max(ans, i-j + 1) \\n return ans\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n counter = 0\\n i = 0 \\n j = 0\\n res=0\\n \\n for i in range(0,len(A)):\\n \\n if A[i] == 0:\\n counter+=1\\n \\n while counter>K and j<len(A):\\n if A[j]==0:\\n counter-=1\\n j+=1 \\n res= max(res,i-j+1)\\n print(res)\\n \\n return res\\n\", \"class Solution:\\n def longestOnes(self, A, K: int) -> int:\\n ans = count = 0\\n j = 0 # valid range is [i:j]\\n for i in range(len(A)):\\n if i > 0 and A[i - 1] == 0:\\n count -= 1\\n\\n while j < len(A) and (A[j] or count < K):\\n if A[j] == 1:\\n j += 1\\n elif count < K:\\n count += 1\\n j += 1\\n\\n ans = max(ans, j - i)\\n\\n return ans\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n l = 0\\n r = 0\\n max_count = K\\n\\n while (l < len(A) and r < len(A)):\\n \\n while(r < len(A)):\\n if A[r] == 1:\\n r += 1\\n elif K > 0:\\n r += 1\\n K -= 1\\n else:\\n break\\n if r - l + 1> max_count:\\n max_count = r - l\\n print(l,r,max_count)\\n if A[l] == 0:\\n K += 1\\n l += 1\\n\\n return max_count\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n hashMap = {}\\n windowStart = 0\\n m = 0\\n hashMap[1] = 0\\n for windowEnd in range(len(A)):\\n if A[windowEnd] not in hashMap:\\n hashMap[A[windowEnd]] = 0\\n hashMap[A[windowEnd]] += 1\\n \\n while sum(hashMap.values()) - hashMap[1] > K:\\n hashMap[A[windowStart]] -= 1\\n windowStart += 1\\n m = max(m, windowEnd - windowStart + 1)\\n return m\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left = 0\\n maxLen = 0\\n oneFreq = 0\\n maxFreq = 0\\n\\n for right in range(len(A)):\\n oneFreq += A[right]\\n maxFreq = max(maxFreq, oneFreq)\\n\\n if right - left + 1 - maxFreq > K:\\n oneFreq -= A[left]\\n left += 1\\n\\n maxLen = max(maxLen, right - left + 1)\\n\\n return maxLen\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i,j,n = 0,0,len(A)\\n \\n for x in A:\\n j+=1\\n if x==0:\\n K-=1\\n if K<0:\\n if A[i]==0:\\n K+=1\\n i+=1\\n return j-i\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n ans = 0\\n lo = 0\\n hi = 0\\n \\n d = collections.defaultdict(int)\\n while(hi<len(A)):\\n d[A[hi]]+=1\\n \\n while d[0]>K:\\n d[A[lo]]-=1\\n if d[A[lo]] == 0: del d[A[lo]]\\n lo+=1\\n ans = max(ans, hi-lo+1)\\n hi+=1\\n return ans\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n '''naive\\n \\n \\n sliding window\\n keep growing sliding window rhs as num of 0s in window is >k\\n when num 0s == k, slide lhs of window until k > num 0s again\\n keep track of largest sliding window'''\\n \\n \\n if not A:\\n return 0\\n \\n best_window_len = 0\\n p, q = 0, 0\\n \\n num_zeros = 0\\n\\n while q < len(A):\\n if A[q] == 0: num_zeros += 1\\n #print(p, q, q - p)\\n if num_zeros > K:\\n best_window_len = max(q - p, best_window_len)\\n #print(\\\\\\\"running best:\\\\\\\", best_window_len)\\n while num_zeros > K:\\n if A[p] == 0:\\n num_zeros -= 1\\n p += 1\\n q+=1\\n \\n best_window_len = max(q - p, best_window_len)\\n return best_window_len\\n \\n\", \"class Solution:\\n def longestOnes(self, arr: List[int], k: int) -> int:\\n hashmap=dict()\\n max_len=length=start_index=0\\n hashmap[0]=0\\n hashmap[1]=0\\n for i in arr:\\n hashmap[i]+=1\\n if hashmap[0]>k:\\n hashmap[arr[start_index]]-=1\\n start_index+=1\\n max_len=max(max_len,sum(hashmap.values()))\\n\\n return max_len\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n # c1 and c0 are the count of 1 and 0 between left and right\\n left,right=0,0\\n n,c1,c0=len(A),0,0\\n ans=0\\n while True:\\n if c0<=K:\\n # it is a legal interval\\n ans=max(ans, right-left)\\n # move right\\n if right<n:\\n right+=1\\n x=A[right-1]\\n if x: c1+=1\\n else: c0+=1\\n else: return ans\\n else:\\n # move left\\n x=A[left]\\n left+=1\\n if x: c1-=1\\n else: c0-=1\\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n count = 0\\n max_count = 0\\n\\n buf = K\\n l = r = 0\\n needs_buf = False\\n while l < len(A) and r < len(A):\\n if A[r] == 1:\\n count += 1\\n r += 1\\n elif A[r] == 0:\\n if buf:\\n buf -= 1\\n count += 1\\n r += 1\\n else:\\n needs_buf = True\\n \\n if needs_buf:\\n if A[l] == 0:\\n buf += 1\\n needs_buf = False\\n count -= 1\\n l += 1\\n\\n if count > max_count:\\n max_count = count\\n # print(A[l:r])\\n\\n # print(f'l: {l}, r: {r}')\\n return max_count\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n s,e,z,l = 0,0,0,0\\n ans = 0\\n while e<len(A):\\n if A[e] == 0:\\n z += 1\\n while z>K:\\n if A[s] == 0:\\n z -= 1\\n s += 1\\n l -= 1\\n l += 1\\n ans = max(ans, l)\\n e += 1\\n return ans\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n res = 0\\n zeros = 0\\n n = len(A)\\n i = 0\\n for j in range(n):\\n zeros += A[j] == 0\\n if zeros <= K:\\n res = max(res, j-i+1)\\n if zeros > K:\\n zeros -= A[i] == 0\\n i += 1\\n return res\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left = 0\\n # right = 0\\n zeros = 0\\n res = 0\\n \\n for right in range(len(A)):\\n \\n if A[right] == 0:\\n zeros += 1\\n \\n while zeros > K:\\n left += 1\\n if A[left-1] == 0:\\n zeros -= 1\\n \\n res = max(res, right - left + 1)\\n \\n # if res == 0:\\n # return 0\\n \\n return res\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i = 0\\n for j in range(len(A)):\\n K -= 1 - A[j]\\n if K < 0:\\n K += 1 - A[i]\\n i += 1\\n return j - i + 1\\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n start, end = 0,0\\n max_len = 0\\n numzeros = 0\\n while end < len(A):\\n if A[end] == 0:\\n numzeros += 1\\n while numzeros > K:\\n # shrink window\\n if A[start] == 0:\\n numzeros -= 1\\n start += 1\\n max_len = max(max_len, end-start+1)\\n end += 1\\n return max_len\\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n result = 0\\n zero_allowed = K\\n left = 0\\n \\n for right, x in enumerate(A):\\n if x==0:\\n zero_allowed -= 1\\n if zero_allowed>=0 and (right - left + 1) > result:\\n result = right - left + 1\\n \\n while zero_allowed < 0 and (right - left + 1) > result:\\n if A[left]==0:\\n zero_allowed += 1\\n left += 1\\n \\n return result\", \"class Solution:\\n def longestOnes(self, arr: List[int], k: int) -> int:\\n start, max_length = 0,0\\n count_0 = 0\\n\\n for end in range(len(arr)):\\n\\n if arr[end] == 0:\\n count_0 += 1\\n\\n while count_0 > k:\\n if arr[start] == 0:\\n count_0 -= 1\\n start += 1\\n max_length = max(max_length, end - start + 1)\\n return max_length\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n zeroes = []\\n count = 0\\n maxCount = 0\\n for i in range(len(A)):\\n if A[i] == 0:\\n zeroes.insert(0,i)\\n \\n if len(zeroes) > K:\\n count = i - zeroes.pop()\\n else:\\n count += 1\\n maxCount = max(maxCount, count)\\n return maxCount\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n curr_k = 0\\n pointer_start = 0\\n pointer_end = 0\\n max_ones = 0\\n curr_ones = 0\\n while pointer_end < len(A):\\n if A[pointer_end] == 0:\\n if curr_k >= K:\\n if A[pointer_start] == 0:\\n curr_k -= 1\\n pointer_start += 1\\n curr_ones -= 1\\n else:\\n pointer_end += 1\\n curr_ones += 1\\n curr_k += 1\\n else:\\n pointer_end += 1\\n curr_ones += 1\\n max_ones = max(curr_ones, max_ones)\\n return max_ones\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n ## intuition: probably use sliding windows\\n \\n l=0\\n r=0\\n val=0\\n if A[0]==0:\\n val=1\\n maxlength = 0\\n \\n \\n while r<len(A)-1:\\n while val<=K and r<len(A)-1:\\n if A[r+1]==0:\\n val+=1\\n r+=1\\n if r==len(A)-1 and val<=K:\\n maxlength = max(maxlength, r-l+1)\\n elif val>K:\\n ##this must mean that A[r]==0\\n maxlength = max(maxlength, r-l)\\n # print(l,r,maxlength, val)\\n while val>K:\\n if A[l]==0:\\n val-=1\\n l+=1\\n \\n return maxlength\\n \\n \\n \\n \\n\", \"import math\\nimport random\\nimport string\\nfrom functools import lru_cache\\nfrom operator import truediv\\nfrom typing import List\\nimport collections\\nimport functools\\nimport heapq\\nimport itertools\\nimport sys\\nfrom functools import lru_cache\\nfrom typing import List\\nimport numpy as np\\nimport collections\\nimport functools\\nimport heapq\\nimport itertools\\nimport sys\\nfrom functools import lru_cache\\nfrom typing import List\\n\\n'''\\n\\u53cd\\u8f6cK\\u4e2a\\u4f4d\\u7f6e\\u76840\\u4e3a1\\uff0c\\u95ee\\u6700\\u957f\\u8fde\\u7eed1\\u7684\\u957f\\u5ea6\\u3002\\n\\nInput: A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3\\nOutput: 10\\nExplanation: \\n[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]\\nBolded numbers were flipped from 0 to 1. The longest subarray is underlined.\\n\\n\\n\\u601d\\u8def\\uff1a\\u6ed1\\u52a8\\u7a97\\u53e3\\u3002\\n\\u4e3b\\u8981\\u601d\\u60f3\\uff0c\\u5f00\\u533a\\u95f4\\u4f38\\u7f29\\u5de6\\u53f3\\u8fb9\\u754c\\u3002\\u95ed\\u533a\\u95f4\\u4e0d\\u597d\\u5904\\u7406\\u521d\\u59cb\\u60c5\\u51b5\\u3002\\n\\n'''\\n\\n\\nclass Solution:\\n def longestOnes1(self, A: List[int], K: int) -> int:\\n # \\u5f00\\u533a\\u95f4[start, end)\\n start = 0\\n end = 0\\n ret = 0\\n while end < len(A):\\n if A[end] == 1:\\n end += 1\\n else:\\n if K > 0:\\n end += 1\\n K -= 1\\n else:\\n if A[start] == 0:\\n K += 1\\n start += 1\\n ret = max(ret, end - start)\\n return ret\\n\\n def longestOnes(self, A, K):\\n i = 0\\n for j in range(len(A)):\\n K -= 1 - A[j]\\n if K < 0:\\n K += 1 - A[i]\\n i += 1\\n return j - i + 1\\n\\n# A = [0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1]\\n# K = 3\\n# \\n# r = Solution()\\n# a = r.longestOnes(A, K)\\n# print(a)\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n if not A:\\n return 0\\n \\n \\n ans = 0\\n count = [0, 0]\\n max_count = 0\\n l = 0\\n for r in range(len(A)):\\n # update the count\\n count[A[r]] += 1\\n max_count = max(max_count, count[1])\\n if r - l + 1 - max_count > K:\\n count[A[l]] -= 1\\n l += 1\\n else:\\n ans = max(ans, r - l + 1)\\n \\n return ans\\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n le = 0\\n for ri in range(len(A)):\\n K -= (1-A[ri]) # \\u5982\\u679cA[ri]\\u662f0, k \\u8981\\u51cf\\u53bb1\\n \\n print (le, ri)\\n if K < 0:\\n K += (1 - A[le])\\n le += 1\\n return ri - le + 1\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n n = len(A)\\n\\n res = 0\\n j, count0 = 0, 0\\n for i in range(n):\\n if not A[i]:\\n count0 += 1\\n if count0 > K:\\n res = max(res, i - j)\\n while A[j]:\\n j += 1\\n j += 1\\n count0 -= 1\\n \\n res = max(res, i - j + 1)\\n return res\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i = 0\\n j = 0\\n maxValue = 0\\n numZeros = 0\\n while j < len(A):\\n if not A[j]:\\n if numZeros < K:\\n numZeros += 1\\n j += 1\\n else:\\n maxValue = max(maxValue, j-i)\\n while i <= j and A[i]:\\n i += 1\\n i += 1\\n j += 1\\n else:\\n j += 1\\n maxValue = max(maxValue, j-i)\\n return maxValue\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n zeroes = []\\n count = 0\\n maxCount = 0\\n j = 0\\n for i in range(len(A)):\\n \\n if A[i] == 0:\\n zeroes.insert(0,i)\\n\\n if len(zeroes) > K:\\n count = i - zeroes.pop()\\n else:\\n count += 1\\n maxCount = max(maxCount, count)\\n return maxCount\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i,j=0,0\\n res=0\\n zeroes=K\\n count=[0]\\n while i<len(A):\\n if A[i]==0:\\n zeroes-=1\\n if zeroes<0:\\n if A[j]==0:\\n zeroes+=1\\n j+=1\\n i+=1\\n res=max(res,i-j)\\n return res\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left = 0\\n for right in range(len(A)):\\n K -= 1 - A[right]\\n if K < 0:\\n K += 1 - A[left]\\n left += 1\\n return right - left + 1\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n maxOnes = 0\\n start = 0\\n maxZeroes = 0\\n \\n for i in range(len(A)):\\n if A[i] == 0:\\n maxZeroes += 1\\n \\n while maxZeroes > K:\\n if A[start] == 0:\\n maxZeroes -= 1\\n \\n start += 1\\n \\n maxOnes = max(maxOnes,i-start + 1)\\n \\n return maxOnes\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n start = 0\\n ans = 0\\n nn = [0, 0]\\n \\n for i, a in enumerate(A):\\n nn[a] += 1\\n while nn[0] > K:\\n nn[A[start]] -= 1\\n start += 1\\n \\n ans = max(ans, nn[0] + nn[1])\\n return ans\", \"import bisect \\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n n = len(A)\\n zeros = 0\\n dp = [0]*n\\n ans = 0\\n\\n for i in range(n):\\n if A[i]==0:\\n zeros+=1\\n dp[i]=zeros\\n # print(dp)\\n for i in range(n):\\n val = dp[i]\\n if A[i]==1:\\n right = bisect.bisect_left(dp,val+K+1)\\n else:\\n right = bisect.bisect_left(dp,val+K)\\n # print(i,right)\\n delta = right-i\\n ans = max(ans,delta)\\n # print(i,ans,right)\\n return ans \", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n left = right = 0\\n \\n for right in range(len(A)):\\n if A[right] == 0:\\n K-=1\\n \\n if K < 0:\\n \\n if A[left] == 0:\\n K+=1\\n \\n left += 1\\n \\n return right-left + 1\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n queue = []\\n i = ans = 0\\n for j in range(len(A)):\\n if(A[j] != 1):\\n if(len(queue) == K):\\n try:\\n i = queue.pop(0)+1\\n except:\\n i=j+1\\n if(len(queue) < K):\\n queue.append(j)\\n ans = max(ans, j-i+1)\\n return ans\", \"from collections import deque\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n q=deque()\\n cnt=0\\n max_cnt=0\\n for i in range(len(A)):\\n if A[i]==0:\\n q.append(i)\\n if len(q)>K:\\n max_cnt=max(max_cnt,cnt)\\n cnt=i-q[0]\\n q.popleft()\\n else:\\n cnt+=1\\n else:\\n cnt+=1\\n max_cnt=max(max_cnt,cnt)\\n return max_cnt\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n l = 0\\n r = 0\\n m = len(A)\\n count = 0\\n max_count = 0\\n while r < m:\\n if A[r] == 1:\\n count += 1\\n while r - l + 1 - count > K:\\n if A[l] == 1:\\n count -= 1\\n l += 1\\n max_count = max(r-l+1, max_count)\\n r += 1\\n return max_count\\n\", \"class Solution:\\n def longestOnes(self, A, K):\\n if not A:\\n return 0\\n n = len(A)\\n right = 0\\n cnt = 0\\n res = 0\\n for left in range(n):\\n while right <= n - 1 and (cnt < K or A[right] == 1):\\n cnt += (A[right] == 0)\\n right += 1\\n res = max(res, right - left)\\n cnt -= (A[left] == 0)\\n return res\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n pre_sum = [A[0]]\\n for i in range(1,len(A)):\\n pre_sum.append(pre_sum[-1]+A[i])\\n \\n def cal(l,r):\\n if (l == 0):\\n return pre_sum[r]\\n else:\\n return pre_sum[r] - pre_sum[l-1]\\n \\n l = 0\\n r = 0\\n ans = K\\n while (l<len(A)):\\n #print (l,r)\\n while (r<len(A) and (r-l+1)-cal(l,r)<=K ):\\n ans = max(ans,r-l+1)\\n r = r + 1\\n #print (r)\\n \\n if (r==len(A)):\\n break\\n \\n while ( l<len(A) and (r-l+1)-cal(l,r)>K ):\\n l = l + 1\\n #print (l)\\n \\n return ans\\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i=j=maxCount=maxlen=0\\n d={0:0,1:0}\\n while(i<len(A)):\\n d[A[i]]+=1\\n while(d[0]>K):\\n d[A[j]]-=1\\n j+=1\\n maxlen=max(maxlen,i-j+1)\\n i+=1\\n return maxlen\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i, ans = 0, 0\\n for j, num in enumerate(A):\\n if num == 0:\\n K -= 1\\n while K < 0:\\n if A[i] == 0:\\n K += 1\\n i += 1\\n ans = max(ans, j-i+1)\\n return ans\\n \\n ans = 0\\n start, end = 0, 0\\n \\n while end < len(A):\\n if A[end] == 1:\\n ans = max(ans, end-start+1)\\n end+=1\\n else:\\n if K != 0:\\n ans = max(ans, end-start+1)\\n end+=1\\n K -= 1\\n else:\\n if A[start] == 0:\\n K+=1\\n start+=1\\n return ans\\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n le, ri = 0, 0\\n max_len = 0\\n while ri < len(A):\\n if A[ri] == 0:\\n K -= 1\\n ri += 1\\n if K >= 0:\\n max_len= max(max_len, ri - le)\\n print((le, ri))\\n while K < 0 and le < ri:\\n if A[le] == 0:\\n K += 1\\n le += 1\\n \\n return max_len\\n \\n\", \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left,right = 0,0\\n num_zeros = 0\\n window_size = 0\\n \\n while right < len(A):\\n if A[right] == 0:\\n num_zeros += 1\\n while num_zeros > K:\\n if A[left] == 0:\\n num_zeros -= 1\\n left += 1 \\n window_size = max(window_size,right-left+1)\\n right += 1\\n \\n return window_size \", \"import math\\nimport random\\nimport string\\nfrom functools import lru_cache\\nfrom operator import truediv\\nfrom typing import List\\nimport collections\\nimport functools\\nimport heapq\\nimport itertools\\nimport sys\\nfrom functools import lru_cache\\nfrom typing import List\\nimport numpy as np\\nimport collections\\nimport functools\\nimport heapq\\nimport itertools\\nimport sys\\nfrom functools import lru_cache\\nfrom typing import List\\n\\n'''\\n\\u53cd\\u8f6cK\\u4e2a\\u4f4d\\u7f6e\\u76840\\u4e3a1\\uff0c\\u95ee\\u6700\\u957f\\u8fde\\u7eed1\\u7684\\u957f\\u5ea6\\u3002\\n\\nInput: A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3\\nOutput: 10\\nExplanation: \\n[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]\\nBolded numbers were flipped from 0 to 1. The longest subarray is underlined.\\n\\n\\n\\u601d\\u8def\\uff1a\\u6ed1\\u52a8\\u7a97\\u53e3\\u3002\\n\\u4e3b\\u8981\\u601d\\u60f3\\uff0c\\u5f00\\u533a\\u95f4\\u4f38\\u7f29\\u5de6\\u53f3\\u8fb9\\u754c\\u3002\\u95ed\\u533a\\u95f4\\u4e0d\\u597d\\u5904\\u7406\\u521d\\u59cb\\u60c5\\u51b5\\u3002\\n\\n'''\\n\\n\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n # \\u5f00\\u533a\\u95f4[start, end)\\n start = 0\\n end = 0\\n ret = 0\\n while end < len(A):\\n if A[end] == 1:\\n end += 1\\n else:\\n if K > 0:\\n end += 1\\n K -= 1\\n else:\\n if A[start] == 0:\\n K += 1\\n start += 1\\n ret = max(ret, end - start)\\n return ret\\n\\n\\n# A = [0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1]\\n# K = 3\\n# \\n# r = Solution()\\n# a = r.longestOnes(A, K)\\n# print(a)\\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"longestOnes\", \"inputs\": [[[1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0], 2]], \"outputs\": [6]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/max-consecutive-ones-iii/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n hulu = []\n cnt = 0\n num = A[0]\n for x in A:\n if x == num:\n cnt += 1\n else:\n hulu.append([num,cnt])\n cnt = 1\n num = x\n if cnt>0:\n hulu.append([num,cnt])\n \n # print(hulu)\n \n output = 0\n \n if A[0] == 1:\n start = 0\n else:\n start = 1\n if len(hulu)<2:\n return min(K,len(A))\n \n end = start\n \n usage = 0\n ones = hulu[start][1]\n while end+2<len(hulu) and usage+hulu[end+1][1]<=K:\n usage += hulu[end+1][1]\n ones += hulu[end+2][1]\n end += 2\n \n output = ones+K\n \n # print([start,end,usage,ones])\n \n start += 2\n \n while start<len(hulu):\n ones -= hulu[start-2][1]\n usage -= hulu[start-1][1]\n if start>end:\n end = start\n ones = hulu[start][1]\n usage = 0\n while end+2<len(hulu) and usage+hulu[end+1][1]<=K:\n usage += hulu[end+1][1]\n ones += hulu[end+2][1]\n end += 2\n # print([start,end,usage,ones])\n \n output = max(output,ones+K)\n start += 2\n \n return min(output,len(A))\n \n \n \n \n \n \n \n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n if len(A) - sum(A) <= K:\n return len(A)\n \n left = right = 0\n \n for right in range(len(A)):\n if A[right] == 0:\n K-=1\n \n if K < 0:\n \n if A[left] == 0:\n K+=1\n \n left += 1\n \n return right-left + 1\n","'''\n[1,1,1,0,0,0,1,1,1,1,0]\n i\n j\n'''\n\nclass Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n left,right=0,0\n alen=len(A)\n \n while right < alen:\n \n if A[right] == 0:\n K-=1\n \n if K < 0:\n if A[left] == 0:\n K+=1\n left+=1\n right+=1\n \n return right - left","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n window_start, max_length, max_ones_count = 0, 0, 0\n \n # Try to extend the range [window_start, window_end]\n for window_end in range(len(A)):\n if A[window_end] == 1:\n max_ones_count += 1\n\n # Current window size is from window_start to window_end, overall we have a maximum of 1s\n # repeating 'max_ones_count' times, this means we can have a window with 'max_ones_count' 1s\n # and the remaining are 0s which should replace with 1s.\n # now, if the remaining 1s are more than 'k', it is the time to shrink the window as we\n # are not allowed to replace more than 'k' 0s\n if (window_end - window_start + 1 - max_ones_count) > K:\n if A[window_start] == 1:\n max_ones_count -= 1\n window_start += 1\n\n max_length = max(max_length, window_end - window_start + 1)\n return max_length","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n i,j,count,res = 0,0, 0,0\n while j<len(A):\n if A[j]==0:\n count+=1\n while count>K:\n if A[i]==0:\n count-=1\n i+=1\n res= max(res, j-i+1)\n j+=1\n return res","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n start, end = 0, 0\n max_len = 0\n numzeros = 0\n while end < len(A):\n if A[end] == 0:\n numzeros += 1\n while numzeros > K:\n # shrink window\n if A[start] == 0:\n numzeros -= 1\n start += 1\n max_len = max(max_len, end - start + 1)\n end += 1\n return max_len","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n res = 0\n start, end = 0, 0\n cnt = 0\n while end < len(A) and start < len(A):\n if A[end] == 1:\n res = max(res, end - start + 1)\n end += 1\n elif A[end] == 0 and cnt < K:\n res = max(res, end - start + 1)\n cnt += 1\n end += 1\n else:\n if A[start] == 0 and K > 0:\n cnt -= 1\n start += 1\n if start > end:\n end = start\n return res\n \n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n #brute force, linear scan NAIVE APPROACH \n #start with the largest size and move down, time limit exceeded \n '''\n for size in range(len(A)-1, -1, -1): \n i = 0\n j = i+size\n count = 0\n for ind in range(i, j+1):\n if A[ind] == 0: \n count += 1\n \n while j < len(A): \n if count <= K: \n return size+1\n else:\n if A[i] == 0: count -= 1\n if j < len(A)-1 and A[j+1] == 0: count += 1\n j += 1\n i += 1\n \n return 0\n '''\n \n #use dynamic variant of sliding window technique\n maxConsecutiveOnes = 0\n windowStart = 0\n currZeroes = 0\n #iterate through the array linearly and see if the number of 0s is <= K\n for windowEnd in range(len(A)): \n if A[windowEnd] == 0: \n currZeroes += 1\n \n #shrinks window \n while currZeroes > K:\n if A[windowStart] == 0: \n currZeroes -= 1\n \n windowStart += 1\n\n \n maxConsecutiveOnes = max(maxConsecutiveOnes, windowEnd - windowStart + 1)\n \n \n \n return maxConsecutiveOnes","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n left=0\n right=0\n for right in range(len(A)):\n if A[right]==0:\n K-=1\n if K<0:\n if A[left]==0:\n K+=1\n left+=1\n return right -left +1\n","class Solution:\n def longestOnes(self, arr: List[int], K: int) -> int:\n left = 0\n \n for right in range(len(arr)):\n K -= 1 - arr[right]\n if K < 0:\n K += 1 - arr[left]\n left += 1\n \n \n return right - left + 1\n \n","class Solution:\n def longestOnes(self, A: List[int], k: int) -> int:\n leftPtr=0\n rightPtr=0\n windowSize=[]\n \n while rightPtr<=len(A)-1:\n if A[rightPtr]==0:\n k-=1\n if k<0:\n if A[leftPtr]==0:\n k+=1\n \n leftPtr+=1\n rightPtr+=1\n \n \n return rightPtr-leftPtr\n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n left = 0\n for right in range(len(A)):\n K -= int(A[right] == 0)\n if K < 0:\n K += 1 - A[left]\n left += 1\n return right - left + 1\n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n start = 0\n end = 0\n l = len(A)\n count = 0\n max_len = 0\n while end < l:\n # print(start, end)\n if A[end] == 1:\n max_len = max(max_len, end-start+1)\n end = end + 1\n else:\n if count < K:\n max_len = max(max_len, end-start +1)\n count = count+1\n end = end + 1\n else:\n while start <= end and count >= K:\n if A[start] == 0:\n count = count -1\n start = start + 1\n \n \n \n return max_len\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n left = 0\n for right in range(len(A)):\n \n # If we included a zero in the window we reduce the value of K.\n # Since K is the maximum zeros allowed in a window.\n K -= (1 - A[right])\n # A negative K denotes we have consumed all allowed flips and window has\n # more than allowed zeros, thus increment left pointer by 1 to keep the window size same.\n if K < 0:\n # If the left element to be thrown out is zero we increase K.\n K += 1 - A[left]\n left += 1\n return right - left + 1","def solve(arr,n,k):\n prefix=[0]\n for i in range(0,n):\n if(arr[i]==0):\n prefix.append(prefix[-1]+1)\n else:\n prefix.append(prefix[-1])\n low=0\n high=n+1\n ans=0\n while(low<high):\n f=0\n mid=low+(high-low)//2\n for i in range(mid,n+1):\n if(prefix[i]-prefix[i-mid]<=k):\n ans=max(ans,mid)\n f=1\n if(f==1):\n low=mid+1\n else:\n high=mid\n return ans\nclass Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n return solve(A,len(A),K)\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n ans , i , c = 0 , 0 , [ ]\n for j in range( len( A ) ) :\n if A[ j ] == 0 :\n c += j ,\n while len( c ) > K :\n i = c.pop( 0 ) + 1\n ans = max( ans , j - i + 1 )\n return ans\n#Sanyam Rajpal\n","class Solution:\n def longestOnes(self, A: List[int], k: int) -> int:\n res = 0\n i = j = 0\n \n move = 1\n while i<len(A) and j<len(A):\n if move==1:\n if A[j]==0:\n if k == 0:\n move = 0\n print(i,j)\n res = max(res,j-i)\n k -= 1\n j += 1\n if move==0:\n if A[i]==0:\n k += 1\n move = 1\n i += 1\n \n return max(res,j-i)","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n start, end = 0, 0\n \n for end in range(len(A)):\n if A[end] == 0:\n K -= 1\n if K < 0:\n if A[start] == 0:\n K += 1\n start += 1\n \n return end - start + 1\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n ans = 0\n l = 0\n r = 0\n prefix = [0 for i in range(len(A))]\n for i in range(len(A)):\n if (i==0):\n prefix[i] = A[0]\n else:\n prefix[i] = A[i] + prefix[i-1]\n \n if (K>=len(A)-prefix[-1]):\n return len(A)\n \n \n while (r<len(A) and l<len(A)):\n while (r<len(A)):\n if (l==0):\n this_sum = prefix[r]\n else:\n this_sum = prefix[r] - prefix[l-1]\n \n if (r-l+1-this_sum>K):\n r-=1\n break\n \n r+=1\n \n if (r>=len(A)):\n if (r-l>ans):\n #print (l,r,ans)\n ans = r-l\n break\n \n if (r-l+1>ans):\n #print (l,r,ans)\n ans = r-l+1\n \n #r+=1\n while (l<len(A) and A[l] == 1):\n l+=1\n \n l+=1\n \n return ans\n \n \n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n count=0\n maxCount=-1\n first=0\n for i in range(len(A)):\n if A[i]==0 and K!=0:\n count+=1\n K-=1\n elif A[i]==0 and K==0:\n while A[first]!=0:\n first+=1\n count-=1\n first+=1\n else:\n count+=1\n maxCount=max(maxCount,count)\n return maxCount\n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n # don't reduce window - time O(n); space O(1)\n left = 0\n for right in range(len(A)):\n K -= (1 - A[right])\n if K < 0:\n K += (1 - A[left])\n left += 1\n \n return right - left + 1","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n i, j = 0, 0\n count = 0\n out = 0\n for i in range(len(A)):\n if A[i] == 0:\n count += 1\n while count > K and j < len(A):\n if A[j] == 0:\n count -= 1\n j += 1\n out = max(out, i - j + 1)\n return out\n \n","class Solution:\n def longestOnes(self, a: List[int], K: int) -> int:\n i = 0\n j = 0\n ml = 0\n while i < len(a):\n if a[i] == 0:\n K -= 1\n while K < 0:\n if a[j] == 0:\n K += 1\n j += 1\n ml = max(ml, i-j+1)\n i += 1\n return ml","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n '''naive\n \n \n sliding window\n keep growing sliding window rhs as num of 0s in window is >k\n when num 0s == k, slide lhs of window until k > num 0s again\n keep track of largest sliding window'''\n \n \n if not A:\n return 0\n \n best_window_len = 0\n p, q = 0, 0\n \n num_zeros = 0\n #if A[q] == 0: num_zeros += 1\n \n while q < len(A):\n if A[q] == 0: num_zeros += 1\n #print(p, q, q - p)\n if num_zeros > K:\n best_window_len = max(q - p, best_window_len)\n #print(\\\"running best:\\\", best_window_len)\n while num_zeros > K:\n if A[p] == 0:\n num_zeros -= 1\n p += 1\n q+=1\n \n best_window_len = max(q - p, best_window_len)\n #if p == 0:\n #best_window_len+=1\n #print(best_window_len)\n return best_window_len\n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n subarrays = []\n start = -1\n i = 0\n while i < len(A):\n if A[i] == 1:\n if start == -1:\n start = i\n else:\n if start != -1:\n subarrays.append([start, i])\n start = -1\n i += 1\n if A[i-1] == 1:\n subarrays.append([start, i])\n print(subarrays)\n \n if K == 0:\n result = 0\n for arr in subarrays:\n if arr[1] - arr[0] > result:\n result = arr[1] - arr[0]\n return result\n \n window = []\n start = []\n end = []\n result = 0\n for i in range(len(A)):\n if A[i] == 0: \n if len(window) == K:\n window.pop(0)\n window.append(i)\n left = window[0] - 1\n right = window[-1] + 1\n while left >= 0 and A[left] != 0:\n left -=1\n while right < len(A) and A[right] != 0:\n right += 1\n if right - left > result:\n result = right - left\n # for i in range(start, len(subarrays)):\n # if subarrays[i][0] > window[0]:\n # break\n # start = i\n # for i in range(len(subarrays)-1, end-1, -1):\n # if subarrays[i][1] < window[-1]:\n # break\n # end = i\n \n # result = 0\n # for curr_k in range(K, 0, -1)\n # i = 0\n # while i < len(subarrays) - 1:\n # gap = subarrays[i][1] + subarrays[i][0] - 1\n # if gap == curr_k:\n return result - 1","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n start = end = 0\n res = 0\n map = collections.defaultdict(int)\n while end < len(A):\n map[A[end]] += 1\n while end - start + 1 - map[1] > K:\n map[A[start]] -= 1\n start += 1\n res = max(res, end-start+1)\n end += 1\n \n return res\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n begins = [-1] * (K+1)\n cur = [0] * (K+1)\n maxL = 0\n curMax = 0\n for i, a in enumerate(A):\n if a == 0:\n maxL = max(maxL, curMax)\n begins.pop(0)\n begins.append(i)\n curMax -= cur.pop(0)\n curMax += 1 if begins[0] == -1 else 0\n cur.append(0)\n else:\n cur[-1] += 1\n curMax += 1\n return max(maxL, curMax)","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n right = 0\n for i in range(len(A)):\n if A[i] == 0:\n A[i] = 1\n else:\n A[i] = 0\n tot = A[0]\n res = 0\n \n for left in range(len(A)):\n while tot <= K:\n right = right + 1\n if right >= len(A):\n break\n tot = tot + A[right]\n res = max(res, right - left)\n if right >= len(A) - 1:\n break\n if A[left] == 1:\n tot = tot - 1\n \n return res\n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n if A.count(0) <= K:\n return len(A)\n \n res = 0\n i = 0\n for j in range(len(A)):\n if A[j] == 0:\n K -= 1\n res = max(res, j-i)\n while K < 0 and i <= j:\n if A[i] == 0:\n K += 1\n i += 1\n \n return max(res, len(A)-i)\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n k = K\n j = ans = 0\n for i in range(len(A)):\n if not A[i]:\n k -= 1\n \n while k<0:\n if not A[j]:\n k += 1\n j += 1\n ans = max(ans, i-j+1)\n \n return ans","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n i, res = 0, 0\n for j in range(len(A)):\n K -= 1 - A[j]\n while K < 0:\n K += 1 - A[i]\n i += 1\n res = max(res, j - i + 1)\n return res","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n left, right = 0,0\n max_window = 0\n zero_positions = []\n num_violations = 0\n while right < len(A):\n if A[right] == 0:\n num_violations +=1\n zero_positions.append(right)\n if num_violations > K:\n left = zero_positions[0] +1\n zero_positions.pop(0)\n num_violations -=1\n right +=1\n max_window = max(max_window, right - left)\n return max_window","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n z_count = 0\n l = 0\n result = 0\n for i in range(len(A)):\n if not A[i]:\n z_count+=1\n if z_count <= K:\n result = max(result, i-l+1)\n while l < i and z_count>K:\n if not A[l]:\n z_count-=1\n l+=1\n\n \n return result\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n longest = start = end = zeroes = 0\n while end < len(A):\n num = A[end]\n\n if not num:\n zeroes += 1\n end += 1\n while zeroes > K:\n if A[start] == 0:\n zeroes -= 1\n start += 1\n longest = max(longest, end - start)\n return longest \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n res = 0\n i, j, N = 0, 0, len(A)\n remaining = K if A[i] == 1 else K - 1\n while i < N:\n # resetting\n if i > j:\n j = i\n remaining = K if A[i] == 1 else K - 1\n\n # stretch\n while j + 1 < N and remaining >= 0:\n if A[j + 1] == 0:\n if remaining > 0:\n remaining -= 1\n else:\n break\n j += 1\n res = max(res, j - i + 1)\n\n # pay debt\n if A[i] == 0:\n remaining += 1\n i += 1\n return res","class Solution:\n def longestOnes(self, x: List[int], K: int) -> int:\n \n buf = collections.deque()\n n = len(x)\n i = 0\n unused = K\n start = -1\n maxlen = float('-inf')\n while i < n:\n if x[i] == 0:\n if unused > 0:\n buf.append(i)\n unused -= 1\n maxlen = max(i - start, maxlen)\n else:\n if buf:\n start = buf.popleft()\n maxlen = max(i - start, maxlen)\n buf.append(i)\n else:\n # K == 0\n maxlen = max(i - 1 - start, maxlen)\n start = i\n else:\n maxlen = max(i - start, maxlen)\n \n \n i += 1\n return maxlen if n > 0 else n","# 1,1,1,0,0,0,1,1,1,1,0\n# max=5,k=0 [ ]\n\n# 1,1,1,0,0,0,1,1,1,1,0\n# max=5,k=-1 [ ]\n\n# 1,1,1,0,0,0,1,1,1,1,0\n# max=6,k=0 [ ]\n\nclass Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n l = 0\n for r in range(len(A)):\n if A[r] == 0:\n K-=1\n \n if K<0:\n if A[l] == 0:\n K+=1\n l+=1\n return r-l+1\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n lo = 0\n hi = len(A)\n A = [0] + [1-x for x in A]\n n = len(A)\n for i in range(1, n):\n A[i] += A[i-1]\n \n while lo < hi:\n mid = (lo + hi + 1) // 2\n \n if min(A[i] - A[i-mid] for i in range(mid, len(A))) <= K:\n lo = mid\n else:\n hi = mid - 1\n \n return lo\n","'''\n\nInput: A = [1,1,1,0,0,0,1,1,1,1,0], K = 2\nOutput: 6\n\n\n\n\n\n\n\n'''\n\n\nclass Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n '''\n Sliding window technique\n '''\n # if there's no array\n if not A:\n return 0\n \n # define a window\n window = 0\n \n # define start of the window\n start = 0\n \n # maximum allowed ones\n max_ones = 0\n \n # iterate over A\n for it, value in enumerate (A):\n \n # add value to window\n window += value\n \n # eviction reached?\n # [1,1,1,0,0,0,1,1,1,1,0]\n if it - start + 1 > window + K:\n window -= A[start]\n start += 1\n \n # figure the maximum ones possible\n max_ones = max (max_ones, window + K)\n \n return min (max_ones, len (A))","class Solution:\n def longestOnes(self, A: List[int], k: int) -> int:\n \n \n \n ans=0\n i=0\n \n for j,c in enumerate(A):\n k-=(1-c)\n if k<0:\n k+=1-A[i]\n i+=1\n ans=max(ans,j-i+1)\n return max(ans,j-i+1)\n \n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n left=0\n right=0\n maxlength=0\n hashmap={}\n count=0\n while right<len(A):\n hashmap[A[right]]=hashmap.get(A[right],0)+1\n while A[right]==0 and hashmap[A[right]]>K:\n hashmap[A[left]]-=1\n left+=1\n maxlength=max(maxlength,right-left+1)\n right+=1\n return maxlength\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n left = 0\n right = 0\n contains = 0\n max_len = 0\n \n while right < len(A):\n if A[right] == 0:\n contains += 1\n \n if contains > K:\n while contains > K:\n if A[left] == 0:\n contains -= 1\n left += 1\n max_len = max(max_len, right - left + 1)\n right += 1\n \n return max_len\n \n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n l = len(A)\n end = 0\n start = 0\n ans = 0\n count = 0\n for i in range(l):\n if A[i] == 1:\n count += 1\n if end - start + 1 - count <= K:\n ans = max(ans, end - start + 1)\n else:\n if A[start] == 1:\n count -= 1\n start += 1\n end += 1\n return ans\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n lo, hi = 0, 0\n zmax = 0\n n_k = 0\n while hi < len(A):\n # print(f\\\"{lo},{hi}, {zmax}\\\")\n if A[hi] == 0:\n n_k += 1\n # break\n \n while n_k > K:\n if A[lo] == 0:\n n_k-=1\n lo+=1\n \n zmax = max(zmax, hi-lo+1)\n \n \n hi+=1\n return zmax","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n left=0\n for right in range(len(A)):\n K-=1-A[right]\n \n if K<0:\n K +=1-A[left]\n left+=1\n return right-left+1\n \n \n \n","class Solution:\n def findMaxConsecutiveOnes(self, nums: List[int]) -> int:\n if len(nums) == 0:\n return 0 \n\n # left - on the first 1 of the island\n # right - on the last 1 of that island\n left = 0\n while left < len(nums) and nums[left] != 1:\n left += 1\n\n right = left \n while right + 1 < len(nums) and nums[right + 1] == 1:\n right += 1\n\n if right == len(nums):\n return 0\n\n maxOnes = right - left + 1\n\n while left < len(nums):\n left = right + 1\n while left < len(nums) and nums[left] != 1:\n left += 1\n\n right = left \n while right + 1 < len(nums) and nums[right + 1] == 1:\n right += 1\n\n maxOnes = max(maxOnes, right - left + 1)\n\n return maxOnes\n \n \n def longestOnes(self, A: List[int], K: int) -> int:\n if K == 0:\n return self.findMaxConsecutiveOnes(A)\n \n if len(A) == 0:\n return 0\n\n left, right = 0, 0\n\n # Pre-condition: In the [left, right] we have exactly K zeros,\n # and you can't move right any more\n\n # Move right to K-th zero\n if A[right] == 0:\n K -= 1\n while right + 1 < len(A) and K > 0:\n right += 1\n if A[right] == 0:\n K -= 1\n\n # Move more if there are 1s to the right of K-th zero \n while right + 1 < len(A) and A[right + 1] == 1:\n right += 1\n\n maxSize = right - left + 1\n\n while right < len(A):\n # Move left off of a zero, and then move right accordingly to include 1 more zero\n while left < len(A) and A[left] != 0:\n left += 1\n if left < len(A):\n left += 1\n else:\n return maxSize\n\n\n # Move right to include one more zero \n right += 1\n while right + 1 < len(A) and A[right + 1] == 1:\n right += 1\n\n maxSize = max(maxSize, right - left + 1)\n \n return maxSize ","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n # find the maximum subarray with max of K 0's \n # this will help find the maximum number of 1s \n \n # [1,1,1,0,0,0,1,1,1,1,0]\n # fast = 5\n # slow = 0\n # lastZero = 3, 4, 5\n # slow = 3\n slow = fast = 0\n maxOnes = -1\n lastZero = collections.deque()\n while fast < len(A):\n if A[fast] == 0:\n lastZero.append(fast)\n if len(lastZero) > K:\n slow = lastZero.popleft() + 1\n fast += 1 \n maxOnes = max(maxOnes, (fast - slow))\n \n if maxOnes == -1:\n return len(A)\n return maxOnes\n \n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n st,ed = 0,0\n ans = 0\n \n longest = 0\n k = 0\n while ed < len(A):\n while ed < len(A):\n if A[ed] == 1:\n longest += 1\n elif k < K:\n k += 1\n longest += 1\n else:\n break\n \n ed += 1\n \n ans = max(longest, ans) \n while st <= ed and st < len(A):\n longest -= 1\n if A[st] == 0:\n k -= 1\n st += 1\n break\n \n st += 1\n \n return ans","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n onecount = 0 \n start = 0\n ans = 0\n \n for end in range(len(A)):\n if A[end] == 1: \n onecount += 1\n \n if end - start + 1 - onecount > K:\n if A[start] == 1: onecount -= 1\n start += 1\n \n ans = max(ans , end - start +1)\n \n return ans","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n start, end, max_length, num_0 = 0, 0, 0, int(not A[0])\n while end < len(A) - 1:\n if num_0 > K:\n if A[start] == 0:\n num_0 -= 1\n start += 1\n end += 1\n if A[end] == 0:\n num_0 += 1\n if num_0 <= K:\n max_length = end - start + 1\n return max_length","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n startWindow = 0\n maxLength = 0\n nZerosInsideWindow = 0\n \n for endWindow, el in enumerate(A):\n nZerosInsideWindow += (el == 0)\n \n while nZerosInsideWindow > K:\n firstElement = A[startWindow]\n nZerosInsideWindow -= (firstElement == 0)\n startWindow += 1\n \n maxLength = max(maxLength, endWindow - startWindow + 1)\n \n return maxLength\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n n = len(A)\n if n == 0:\n return 0\n \n head = 0\n tail = 0\n num_zeros = 0\n max_subseq = 0\n while head < n:\n if A[head] == 1:\n head += 1\n else:\n num_zeros += 1\n max_subseq = max(max_subseq, head-tail)\n if num_zeros > K:\n while A[tail] == 1:\n tail += 1\n tail += 1\n num_zeros -= 1\n head += 1\n max_subseq = max(max_subseq, n-tail)\n return max_subseq\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n allowance = K\n currSum = 0\n left = 0\n maxSum = 0\n for i in range(len(A)):\n if A[i] == 1:\n currSum += 1\n else:\n allowance -= 1\n while allowance < 0:\n if A[left] == 1:\n currSum -= 1\n else:\n allowance += 1\n left += 1\n maxSum = max(maxSum, K - allowance + currSum)\n return maxSum\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n res = 0\n i = 0\n for j in range(len(A)):\n if A[j] == 0:\n K -= 1\n res = max(res, j - i)\n while K < 0:\n if A[i] == 0:\n K += 1\n i += 1\n return max(res, len(A) - i)","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n res = 0\n i = 0\n for j in range(len(A)):\n if A[j]==0:\n K-=1\n res = max(res,j-i)\n \n while K<0:\n if(A[i]==0):\n K+=1\n i += 1\n \n return max(res,len(A)-i)","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n left = right = 0\n \n for right in range(len(A)):\n # if we encounter a 0 the we decrement K\n if A[right] == 0:\n K -= 1\n # else no impact to K\n \n # if K < 0 then we need to move the left part of the window forward\n # to try and remove the extra 0's\n if K < 0:\n # if the left one was zero then we adjust K\n if A[left] == 0:\n K += 1\n # regardless of whether we had a 1 or a 0 we can move left side by 1\n # if we keep seeing 1's the window still keeps moving as-is\n left += 1\n \n return right - left + 1\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int: \n res = 0\n i = 0\n for j in range(len(A)):\n if A[j] == 0:\n K -= 1\n res = max(res, j-i)\n while K < 0 and i <= j:\n if A[i] == 0:\n K += 1\n i += 1\n \n return max(res, len(A)-i)\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n \n i = 0\n res = 0\n for j, a in enumerate(A): \n if a == 0:\n K-=1 \n while K < 0:\n if A[i] == 0:\n K+=1\n i+=1 \n else:\n res = max(res, j-i+1)\n return res","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n l, ans = 0, 0\n for r in range(len(A)):\n if A[r] == 0:\n K -= 1\n while K < 0:\n if A[l] == 0:\n K += 1\n l += 1\n ans = max(ans, r+1-l)\n \n return ans","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n if A == None or len(A) == 0 or K == None:\n return 0\n if len(A) <= K:\n return K\n \n left = 0\n flip = 0\n maxlength = 0\n for i, num in enumerate(A):\n if A[i] == 0:\n flip += 1\n if flip <= K:\n maxlength = max(maxlength, i - left + 1)\n \n while left < i and flip > K:\n if A[left] == 0:\n flip -=1\n left += 1\n\n return maxlength\n \n \n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n count, n, l = 0, len(A), 0\n ans = 0\n for r in range(n):\n count += 1 - A[r]\n while count > K:\n count -= 1 - A[l]\n l += 1\n ans = max(ans, r-l+1)\n return ans\n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n ans = 0\n l = 0\n for r in range(len(A)):\n if A[r] == 0:\n K -= 1\n while K < 0:\n if A[l] == 0:\n K += 1\n l += 1\n ans = max(ans, r+1-l)\n \n return ans","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n windowstart, curr0,res = 0,0, 0\n currwindow = {1:0 , 0:0}\n \n \n for windowend in range(len(A)):\n\n # add the new element into the current window,\n currwindow[A[windowend]] +=1\n # check if the least common number is above k\n curr0 = currwindow[0]\n\n # if yes, increase the window start \n if curr0 > K :\n currwindow[A[windowstart]] -=1\n windowstart +=1\n \n # look for the window size and max with the max and the current length\n res = max (res, windowend-windowstart +1 )\n\n return res ","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n count_1 = 0\n zero_inx = []\n res = 0\n zero_before = -1\n for i in range(len(A)):\n if A[i] == 1:\n count_1 += 1\n else:\n zero_inx.append(i)\n if K > 0:\n K -= 1\n count_1 += 1\n elif K == 0:\n res = max(res,count_1)\n first_0 = zero_inx.pop(0)\n count_1 -= (first_0 - zero_before - 1)\n zero_before = first_0\n res = max(res, count_1)\n return res","class Solution:\n def longestOnes(self, arr: List[int], k: int) -> int:\n start_index = 0\n longest_ones = 0\n max_length = 0\n for end_index in range(len(arr)):\n if arr[end_index] == 1:\n longest_ones += 1\n if longest_ones+k <= (end_index - start_index):\n if arr[start_index] == 1:\n longest_ones -= 1\n start_index += 1\n max_length = max(max_length, end_index-start_index+1)\n return max_length\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n if A == None or len(A) == 0 or K == None:\n return 0\n if len(A) <= K:\n return K\n \n left = 0\n count_of_zero = 0\n maxlength = 0\n for i, num in enumerate(A):\n if A[i] == 0:\n count_of_zero += 1\n if count_of_zero <= K:\n maxlength = max(maxlength, i - left + 1)\n \n while left < i and count_of_zero > K:\n if A[left] == 0:\n count_of_zero -=1\n left += 1\n\n return maxlength\n \n \n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n l = 0\n res = 0\n for h in range(len(A)):\n K -= 1 - A[h]\n if K < 0:\n K += 1 - A[l]\n l += 1\n return h-l+1","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n i = 0\n j = 0\n \n numZeros = 0\n \n bestSize = 0\n while j < len(A):\n if A[j] == 1:\n pass\n elif A[j] == 0:\n numZeros += 1\n while numZeros > K:\n if i >= 0 and A[i] == 0:\n numZeros -= 1\n i += 1\n bestSize = max(bestSize, j - i + 1)\n j += 1\n return bestSize","\nclass Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n s, e = 0, 0\n r_k = K\n result = 0\n while e < len(A):\n if A[e] == 0:\n r_k -= 1\n\n while r_k < 0:\n if A[s] == 0:\n r_k += 1\n s += 1\n\n result = max(result, e - s + 1)\n\n e+=1\n\n return result\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n res = -1\n start, count = 0, 0 # start is beginning of window, count is number of 1s\n # i is end of window, hence len of window is i-start+1\n \n for i in range(len(A)):\n if A[i]==1: count += 1\n while (i-start+1-count > K):\n if A[start]==1: count -= 1\n start += 1\n res = max(res, i-start+1)\n \n return res\n \n","class Solution:\n def longestOnes(self, s: List[int], k: int) -> int:\n l = 0\n c_frequency = {0:0, 1:0}\n longest_str_len = 0\n for r in range(len(s)):\n \n if s[r] == 0:\n c_frequency[0] += 1\n else:\n c_frequency[1] += 1\n \n # Replacements cost = cells count between left and right - highest frequency\n cells_count = r - l + 1\n if c_frequency[0] <= k or c_frequency[0] == 0:\n longest_str_len = max(longest_str_len, cells_count)\n \n else:\n if c_frequency[s[l]] != 0:\n c_frequency[s[l]] -= 1\n l += 1\n \n return longest_str_len","class Solution:\n def longestOnes(self, A, K):\n window_start, max_length, max_ones_count = 0, 0, 0\n for window_end in range(0, len(A)):\n if A[window_end] == 1:\n max_ones_count += 1\n while window_end - window_start + 1 - max_ones_count > K:\n if A[window_start] == 1:\n max_ones_count -= 1\n window_start += 1\n max_length = max(max_length, window_end - window_start + 1)\n return max_length\n","import bisect\n\nclass Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n ans = countzeroes = 0\n counter = {0: -1}\n for i, num in enumerate(A):\n if num==0:\n countzeroes+=1\n if countzeroes not in counter:\n counter[countzeroes] = i\n j = counter[max(0, countzeroes-K)]\n ans = max(ans, i-j)\n \n return ans\n","import bisect\n\nclass Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n ans = countzeroes = 0\n counter = {0: -1}\n for i in range(len(A)):\n num = A[i]\n if num==0:\n countzeroes+=1\n if countzeroes not in counter:\n counter[countzeroes] = i\n j = counter[max(0, countzeroes-K)]\n ans = max(ans, i-j)\n \n return ans\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n l,r = 0, -1\n optim = 0\n while r < len(A):\n while r < len(A):\n r += 1\n if r == len(A):\n break\n if A[r] == 0:\n K -= 1\n if K < 0:\n break\n else:\n optim = max(optim, r-l+1)\n if r == len(A):\n break\n while l < r:\n if A[l] == 0:\n K += 1\n l += 1\n if K >= 0:\n break\n return optim","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n count = maxS = j = 0\n \n for i, a in enumerate(A):\n if a == 0:\n count += 1\n \n while j < len(A) and count > K:\n if A[j] == 0:\n count -= 1\n j += 1\n \n maxS = max(maxS, i-j+1)\n \n return maxS","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n windowstart,most_common,res=0,0,0\n currentwindow={1:0, 0:0}\n \n for windowend in range(len(A)):\n\n currentwindow[A[windowend]] +=1\n\n most_common = currentwindow[1]\n\n \n #having this means we have to reduce the length of the window\n if (windowend-windowstart+1 - most_common > K):\n \n currentwindow[A[windowstart]] -=1\n windowstart +=1\n\n res = max(res,windowend-windowstart+1)\n \n return res","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n left = 0\n for right in range(len(A)):\n # If we included a zero in the window we reduce the value of K.\n # Since K is the maximum zeros allowed in a window.\n K -= 1 - A[right]\n # A negative K denotes we have consumed all allowed flips and window has\n # more than allowed zeros, thus increment left pointer by 1 to keep the window size same.\n if K < 0:\n # If the left element to be thrown out is zero we increase K.\n K += 1 - A[left]\n left += 1\n return right - left + 1","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n zeros, ones, max_len = 0, 0,0\n def element_found(element, inc):\n nonlocal zeros, ones, max_len\n if element == 0:\n zeros += inc\n else:\n ones += inc\n \n start = 0\n for element in A:\n element_found(element, 1)\n \n while zeros > K:\n start,start_element = start+1, A[start]\n element_found(start_element, -1)\n \n max_len = max(max_len, zeros + ones)\n return max_len\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n if not A:\n return 0\n \n n = len(A)\n \n cur_max = 0\n counter = 0\n index = []\n prev = -1\n \n for i in range(n):\n if A[i] == 1:\n counter += 1\n else:\n if K > 0:\n K -= 1\n counter += 1\n index.append(i)\n else:\n if index:\n counter += 1\n temp = index.pop(0)\n counter -= temp - prev\n prev = temp\n index.append(i)\n else:\n counter = 0\n \n cur_max = max(cur_max, counter)\n \n return cur_max","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n left = 0\n right = 0 \n \n k = K\n max_ans = 0\n so_far = 0\n while(right < len(A)):\n if(A[right]==1):\n right+=1\n else:\n if(k>0):\n right+=1\n k-=1\n else:\n if(A[left]==0):\n k+=1\n left+=1\n \n max_ans = max(max_ans, right-left)\n \n return max_ans","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n zeros_indices = []\n for i in range(len(A)):\n if A[i] == 0:\n zeros_indices.append(i)\n\n longest_ones = 0\n\n\n longest_yet = 0\n for i in range(len(A)):\n if A[i] == 1:\n longest_yet += 1\n longest_ones = max(longest_ones, longest_yet)\n else:\n longest_yet = 0\n if K == 0:\n return longest_ones\n\n if K >= len(zeros_indices):\n return len(A)\n\n\n # [0, 1, 4, 5, 9, 12, 13, 14]\n zero_order = -1\n for i in range(len(A)):\n if A[i] == 0:\n zero_order += 1\n right_cons_ones = left_cons_ones = 0\n if zero_order + K < len(zeros_indices):\n nxt = zero_order + K\n right_cons_ones = zeros_indices[nxt] - zeros_indices[zero_order]\n else:\n nxt = len(zeros_indices) - 1\n right_cons_ones = zeros_indices[nxt] - zeros_indices[zero_order]\n right_cons_ones += len(A) - zeros_indices[nxt]\n if not zero_order == 0: \n left_cons_ones = zeros_indices[zero_order] - zeros_indices[zero_order-1] - 1\n longest_ones = max(longest_ones, right_cons_ones + left_cons_ones)\n return longest_ones","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n hash_count = dict()\n hash_count[1] = 0\n start = 0\n max_count = 0\n max_result = 0\n for end in range(len(A)):\n if A[end] == 1:\n hash_count[A[end]] += 1 \n max_count = max(max_count, hash_count[1])\n if max_count + K < ( end - start + 1 ):\n if A[start] == 1 and hash_count.get(1):\n hash_count[1] -= 1\n start += 1\n max_result = max(max_result, end-start + 1)\n return max_result\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n max_length = 0\n start = 0\n end = 1 \n \n zeros = 0\n \n if len(A) == 0:\n return 0\n if len(A) == 1:\n return 1\n \n zeros = 2 - sum(A[:2])\n \n while end < len(A):\n \n valid = zeros <= K\n \n if valid:\n max_length = max(max_length, (end - start)+1)\n end += 1\n if end == len(A):\n return max_length\n \n if A[end] == 0:\n zeros += 1\n else:\n if A[start] == 0:\n zeros -= 1\n start += 1\n return max_length\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int: \n K_original = K\n i = 0\n ans = 0\n curr = 0\n \n j =0 \n while(j<len(A)):\n if A[j]==1 or K>0:\n curr += 1\n else:\n curr = 0\n K-=1 if (A[j]==0 and K>0) else 0\n j+=1\n ans = max(curr, ans)\n if K_original>0 and K==0:\n while(j<len(A) and A[j]==1):\n curr+=1\n j+=1\n ans = max(curr, ans)\n while(i<=j and i<len(A) and K==0):\n if A[i]==0:\n K+=1\n i+=1\n curr -=1 \n # print(i,j,K, curr, ans)\n return ans\n\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n hash_count = dict()\n hash_count[1] = 0\n start = 0\n max_count = 0\n max_result = 0\n for end in range(len(A)):\n if A[end] == 1:\n hash_count[A[end]] += 1 \n max_count = max(max_count, hash_count[1])\n #print(f\\\" {max_count + K} comp {end - start + 1}\\\")\n if max_count + K < ( end - start + 1 ):\n if A[start] == 1 and hash_count.get(1):\n hash_count[1] -= 1\n start += 1\n max_result = max(max_result, end-start + 1)\n #print(max_result)\n return max_result\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n left, right = 0, 0\n k = 0\n flipped = set()\n longest = 0\n while right < len(A):\n if A[right] == 1:\n longest = max(longest, right - left + 1)\n right += 1\n elif A[right] == 0 and k < K:\n flipped.add(right)\n longest = max(longest, right - left + 1)\n right += 1\n k += 1\n elif left == right:\n right += 1\n left += 1\n else:\n if left in flipped:\n flipped.discard(left)\n k -= 1\n left += 1\n \n \n return longest","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n ct = Counter()\n pt, max_len = 0, 0\n for i, elem in enumerate(A):\n ct[elem] += 1\n if ct[0] <= K:\n max_len = max(max_len, (i - pt + 1))\n if ct[0] > K:\n ct[A[pt]] -= 1\n \n pt += 1\n\n return max_len\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n left = 0\n for right in range(len(A)):\n # If we included a zero in the window we reduce the value of K.\n # Since K is the maximum zeros allowed in a window.\n K -= 1 - A[right]\n # A negative K denotes we have consumed all allowed flips and window has\n # more than allowed zeros, thus increment left pointer by 1 to keep the window size same.\n if K < 0:\n # If the left element to be thrown out is zero we increase K.\n K += 1 - A[left]\n left += 1\n print(len(A),right)\n return right - left + 1","from collections import deque\n\n\nclass Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n substited_indexes = deque()\n start = 0\n best = 0\n \n index = 0\n while index < len(A):\n num = A[index]\n \n if num == 0:\n if K > 0:\n K -= 1\n A[index] = 1\n substited_indexes.append(index)\n elif K == 0 and len(substited_indexes) == 0:\n start = index + 1\n else:\n start = substited_indexes.popleft()\n A[start] = 0\n start += 1\n K += 1\n continue\n \n index += 1\n best = max(best, index - start)\n \n return best\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n max_length = 0\n start = 0\n end = 1\n ones = 1\n\n if len(A) == 0:\n return 0\n if len(A) == 1:\n return 1\n\n ones = A[0] + A[1]\n\n while end < len(A):\n\n valid = ((end - start) + 1) - ones <= K\n\n if valid:\n max_length = max(max_length, (end - start) + 1)\n end += 1\n if end == len(A):\n return max_length\n ones += A[end]\n else:\n ones -= A[start]\n start += 1\n return max_length\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n answer, length = 0, 0\n inds = []\n for i, num in enumerate(A):\n if num == 1:\n length += 1\n elif len(inds) < K:\n inds.append(i)\n length += 1\n elif K == 0:\n length = 0\n else:\n last_index = inds.pop(0)\n inds.append(i)\n length = (i - inds[0]) + (inds[0] - last_index)\n answer = max(answer, length)\n return answer","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n max_length = 0\n start = 0\n end = 1\n ones = 1\n\n if len(A) == 0:\n return 0\n if len(A) == 1:\n return 1\n\n ones = sum(A[:2])\n\n while end < len(A):\n\n valid = ((end - start) + 1) - ones <= K\n\n if valid:\n max_length = max(max_length, (end - start) + 1)\n end += 1\n if end == len(A):\n return max_length\n ones += A[end]\n else:\n ones -= A[start]\n start += 1\n return max_length\n","import bisect\n\nclass Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n ans = 0\n countzeroes = 0\n prefix = []\n for i, num in enumerate(A):\n prefix.append(countzeroes)\n if num==0:\n countzeroes+=1\n j = bisect.bisect_left(prefix, countzeroes-K)\n ans = max(ans, i-j + 1) \n return ans\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n counter = 0\n i = 0 \n j = 0\n res=0\n \n for i in range(0,len(A)):\n \n if A[i] == 0:\n counter+=1\n \n while counter>K and j<len(A):\n if A[j]==0:\n counter-=1\n j+=1 \n res= max(res,i-j+1)\n print(res)\n \n return res\n","class Solution:\n def longestOnes(self, A, K: int) -> int:\n ans = count = 0\n j = 0 # valid range is [i:j]\n for i in range(len(A)):\n if i > 0 and A[i - 1] == 0:\n count -= 1\n\n while j < len(A) and (A[j] or count < K):\n if A[j] == 1:\n j += 1\n elif count < K:\n count += 1\n j += 1\n\n ans = max(ans, j - i)\n\n return ans\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n l = 0\n r = 0\n max_count = K\n\n while (l < len(A) and r < len(A)):\n \n while(r < len(A)):\n if A[r] == 1:\n r += 1\n elif K > 0:\n r += 1\n K -= 1\n else:\n break\n if r - l + 1> max_count:\n max_count = r - l\n print(l,r,max_count)\n if A[l] == 0:\n K += 1\n l += 1\n\n return max_count","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n hashMap = {}\n windowStart = 0\n m = 0\n hashMap[1] = 0\n for windowEnd in range(len(A)):\n if A[windowEnd] not in hashMap:\n hashMap[A[windowEnd]] = 0\n hashMap[A[windowEnd]] += 1\n \n while sum(hashMap.values()) - hashMap[1] > K:\n hashMap[A[windowStart]] -= 1\n windowStart += 1\n m = max(m, windowEnd - windowStart + 1)\n return m\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n left = 0\n maxLen = 0\n oneFreq = 0\n maxFreq = 0\n\n for right in range(len(A)):\n oneFreq += A[right]\n maxFreq = max(maxFreq, oneFreq)\n\n if right - left + 1 - maxFreq > K:\n oneFreq -= A[left]\n left += 1\n\n maxLen = max(maxLen, right - left + 1)\n\n return maxLen","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n i,j,n = 0,0,len(A)\n \n for x in A:\n j+=1\n if x==0:\n K-=1\n if K<0:\n if A[i]==0:\n K+=1\n i+=1\n return j-i\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n ans = 0\n lo = 0\n hi = 0\n \n d = collections.defaultdict(int)\n while(hi<len(A)):\n d[A[hi]]+=1\n \n while d[0]>K:\n d[A[lo]]-=1\n if d[A[lo]] == 0: del d[A[lo]]\n lo+=1\n ans = max(ans, hi-lo+1)\n hi+=1\n return ans","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n '''naive\n \n \n sliding window\n keep growing sliding window rhs as num of 0s in window is >k\n when num 0s == k, slide lhs of window until k > num 0s again\n keep track of largest sliding window'''\n \n \n if not A:\n return 0\n \n best_window_len = 0\n p, q = 0, 0\n \n num_zeros = 0\n\n while q < len(A):\n if A[q] == 0: num_zeros += 1\n #print(p, q, q - p)\n if num_zeros > K:\n best_window_len = max(q - p, best_window_len)\n #print(\\\"running best:\\\", best_window_len)\n while num_zeros > K:\n if A[p] == 0:\n num_zeros -= 1\n p += 1\n q+=1\n \n best_window_len = max(q - p, best_window_len)\n return best_window_len\n \n","class Solution:\n def longestOnes(self, arr: List[int], k: int) -> int:\n hashmap=dict()\n max_len=length=start_index=0\n hashmap[0]=0\n hashmap[1]=0\n for i in arr:\n hashmap[i]+=1\n if hashmap[0]>k:\n hashmap[arr[start_index]]-=1\n start_index+=1\n max_len=max(max_len,sum(hashmap.values()))\n\n return max_len","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n # c1 and c0 are the count of 1 and 0 between left and right\n left,right=0,0\n n,c1,c0=len(A),0,0\n ans=0\n while True:\n if c0<=K:\n # it is a legal interval\n ans=max(ans, right-left)\n # move right\n if right<n:\n right+=1\n x=A[right-1]\n if x: c1+=1\n else: c0+=1\n else: return ans\n else:\n # move left\n x=A[left]\n left+=1\n if x: c1-=1\n else: c0-=1\n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n count = 0\n max_count = 0\n\n buf = K\n l = r = 0\n needs_buf = False\n while l < len(A) and r < len(A):\n if A[r] == 1:\n count += 1\n r += 1\n elif A[r] == 0:\n if buf:\n buf -= 1\n count += 1\n r += 1\n else:\n needs_buf = True\n \n if needs_buf:\n if A[l] == 0:\n buf += 1\n needs_buf = False\n count -= 1\n l += 1\n\n if count > max_count:\n max_count = count\n # print(A[l:r])\n\n # print(f'l: {l}, r: {r}')\n return max_count","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n s,e,z,l = 0,0,0,0\n ans = 0\n while e<len(A):\n if A[e] == 0:\n z += 1\n while z>K:\n if A[s] == 0:\n z -= 1\n s += 1\n l -= 1\n l += 1\n ans = max(ans, l)\n e += 1\n return ans","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n res = 0\n zeros = 0\n n = len(A)\n i = 0\n for j in range(n):\n zeros += A[j] == 0\n if zeros <= K:\n res = max(res, j-i+1)\n if zeros > K:\n zeros -= A[i] == 0\n i += 1\n return res\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n left = 0\n # right = 0\n zeros = 0\n res = 0\n \n for right in range(len(A)):\n \n if A[right] == 0:\n zeros += 1\n \n while zeros > K:\n left += 1\n if A[left-1] == 0:\n zeros -= 1\n \n res = max(res, right - left + 1)\n \n # if res == 0:\n # return 0\n \n return res","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n i = 0\n for j in range(len(A)):\n K -= 1 - A[j]\n if K < 0:\n K += 1 - A[i]\n i += 1\n return j - i + 1\n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n start, end = 0,0\n max_len = 0\n numzeros = 0\n while end < len(A):\n if A[end] == 0:\n numzeros += 1\n while numzeros > K:\n # shrink window\n if A[start] == 0:\n numzeros -= 1\n start += 1\n max_len = max(max_len, end-start+1)\n end += 1\n return max_len\n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n result = 0\n zero_allowed = K\n left = 0\n \n for right, x in enumerate(A):\n if x==0:\n zero_allowed -= 1\n if zero_allowed>=0 and (right - left + 1) > result:\n result = right - left + 1\n \n while zero_allowed < 0 and (right - left + 1) > result:\n if A[left]==0:\n zero_allowed += 1\n left += 1\n \n return result","class Solution:\n def longestOnes(self, arr: List[int], k: int) -> int:\n start, max_length = 0,0\n count_0 = 0\n\n for end in range(len(arr)):\n\n if arr[end] == 0:\n count_0 += 1\n\n while count_0 > k:\n if arr[start] == 0:\n count_0 -= 1\n start += 1\n max_length = max(max_length, end - start + 1)\n return max_length","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n zeroes = []\n count = 0\n maxCount = 0\n for i in range(len(A)):\n if A[i] == 0:\n zeroes.insert(0,i)\n \n if len(zeroes) > K:\n count = i - zeroes.pop()\n else:\n count += 1\n maxCount = max(maxCount, count)\n return maxCount\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n curr_k = 0\n pointer_start = 0\n pointer_end = 0\n max_ones = 0\n curr_ones = 0\n while pointer_end < len(A):\n if A[pointer_end] == 0:\n if curr_k >= K:\n if A[pointer_start] == 0:\n curr_k -= 1\n pointer_start += 1\n curr_ones -= 1\n else:\n pointer_end += 1\n curr_ones += 1\n curr_k += 1\n else:\n pointer_end += 1\n curr_ones += 1\n max_ones = max(curr_ones, max_ones)\n return max_ones","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n ## intuition: probably use sliding windows\n \n l=0\n r=0\n val=0\n if A[0]==0:\n val=1\n maxlength = 0\n \n \n while r<len(A)-1:\n while val<=K and r<len(A)-1:\n if A[r+1]==0:\n val+=1\n r+=1\n if r==len(A)-1 and val<=K:\n maxlength = max(maxlength, r-l+1)\n elif val>K:\n ##this must mean that A[r]==0\n maxlength = max(maxlength, r-l)\n # print(l,r,maxlength, val)\n while val>K:\n if A[l]==0:\n val-=1\n l+=1\n \n return maxlength\n \n \n \n \n","import math\nimport random\nimport string\nfrom functools import lru_cache\nfrom operator import truediv\nfrom typing import List\nimport collections\nimport functools\nimport heapq\nimport itertools\nimport sys\nfrom functools import lru_cache\nfrom typing import List\nimport numpy as np\nimport collections\nimport functools\nimport heapq\nimport itertools\nimport sys\nfrom functools import lru_cache\nfrom typing import List\n\n'''\n反转K个位置的0为1，问最长连续1的长度。\n\nInput: A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3\nOutput: 10\nExplanation: \n[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]\nBolded numbers were flipped from 0 to 1. The longest subarray is underlined.\n\n\n思路：滑动窗口。\n主要思想，开区间伸缩左右边界。闭区间不好处理初始情况。\n\n'''\n\n\nclass Solution:\n def longestOnes1(self, A: List[int], K: int) -> int:\n # 开区间[start, end)\n start = 0\n end = 0\n ret = 0\n while end < len(A):\n if A[end] == 1:\n end += 1\n else:\n if K > 0:\n end += 1\n K -= 1\n else:\n if A[start] == 0:\n K += 1\n start += 1\n ret = max(ret, end - start)\n return ret\n\n def longestOnes(self, A, K):\n i = 0\n for j in range(len(A)):\n K -= 1 - A[j]\n if K < 0:\n K += 1 - A[i]\n i += 1\n return j - i + 1\n\n# A = [0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1]\n# K = 3\n# \n# r = Solution()\n# a = r.longestOnes(A, K)\n# print(a)\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n if not A:\n return 0\n \n \n ans = 0\n count = [0, 0]\n max_count = 0\n l = 0\n for r in range(len(A)):\n # update the count\n count[A[r]] += 1\n max_count = max(max_count, count[1])\n if r - l + 1 - max_count > K:\n count[A[l]] -= 1\n l += 1\n else:\n ans = max(ans, r - l + 1)\n \n return ans\n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n le = 0\n for ri in range(len(A)):\n K -= (1-A[ri]) # 如果A[ri]是0, k 要减去1\n \n print (le, ri)\n if K < 0:\n K += (1 - A[le])\n le += 1\n return ri - le + 1","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n n = len(A)\n\n res = 0\n j, count0 = 0, 0\n for i in range(n):\n if not A[i]:\n count0 += 1\n if count0 > K:\n res = max(res, i - j)\n while A[j]:\n j += 1\n j += 1\n count0 -= 1\n \n res = max(res, i - j + 1)\n return res\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n i = 0\n j = 0\n maxValue = 0\n numZeros = 0\n while j < len(A):\n if not A[j]:\n if numZeros < K:\n numZeros += 1\n j += 1\n else:\n maxValue = max(maxValue, j-i)\n while i <= j and A[i]:\n i += 1\n i += 1\n j += 1\n else:\n j += 1\n maxValue = max(maxValue, j-i)\n return maxValue\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n zeroes = []\n count = 0\n maxCount = 0\n j = 0\n for i in range(len(A)):\n \n if A[i] == 0:\n zeroes.insert(0,i)\n\n if len(zeroes) > K:\n count = i - zeroes.pop()\n else:\n count += 1\n maxCount = max(maxCount, count)\n return maxCount\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n i,j=0,0\n res=0\n zeroes=K\n count=[0]\n while i<len(A):\n if A[i]==0:\n zeroes-=1\n if zeroes<0:\n if A[j]==0:\n zeroes+=1\n j+=1\n i+=1\n res=max(res,i-j)\n return res","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n left = 0\n for right in range(len(A)):\n K -= 1 - A[right]\n if K < 0:\n K += 1 - A[left]\n left += 1\n return right - left + 1","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n maxOnes = 0\n start = 0\n maxZeroes = 0\n \n for i in range(len(A)):\n if A[i] == 0:\n maxZeroes += 1\n \n while maxZeroes > K:\n if A[start] == 0:\n maxZeroes -= 1\n \n start += 1\n \n maxOnes = max(maxOnes,i-start + 1)\n \n return maxOnes","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n start = 0\n ans = 0\n nn = [0, 0]\n \n for i, a in enumerate(A):\n nn[a] += 1\n while nn[0] > K:\n nn[A[start]] -= 1\n start += 1\n \n ans = max(ans, nn[0] + nn[1])\n return ans","import bisect \nclass Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n n = len(A)\n zeros = 0\n dp = [0]*n\n ans = 0\n\n for i in range(n):\n if A[i]==0:\n zeros+=1\n dp[i]=zeros\n # print(dp)\n for i in range(n):\n val = dp[i]\n if A[i]==1:\n right = bisect.bisect_left(dp,val+K+1)\n else:\n right = bisect.bisect_left(dp,val+K)\n # print(i,right)\n delta = right-i\n ans = max(ans,delta)\n # print(i,ans,right)\n return ans ","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n left = right = 0\n \n for right in range(len(A)):\n if A[right] == 0:\n K-=1\n \n if K < 0:\n \n if A[left] == 0:\n K+=1\n \n left += 1\n \n return right-left + 1\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n queue = []\n i = ans = 0\n for j in range(len(A)):\n if(A[j] != 1):\n if(len(queue) == K):\n try:\n i = queue.pop(0)+1\n except:\n i=j+1\n if(len(queue) < K):\n queue.append(j)\n ans = max(ans, j-i+1)\n return ans","from collections import deque\nclass Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n q=deque()\n cnt=0\n max_cnt=0\n for i in range(len(A)):\n if A[i]==0:\n q.append(i)\n if len(q)>K:\n max_cnt=max(max_cnt,cnt)\n cnt=i-q[0]\n q.popleft()\n else:\n cnt+=1\n else:\n cnt+=1\n max_cnt=max(max_cnt,cnt)\n return max_cnt","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n l = 0\n r = 0\n m = len(A)\n count = 0\n max_count = 0\n while r < m:\n if A[r] == 1:\n count += 1\n while r - l + 1 - count > K:\n if A[l] == 1:\n count -= 1\n l += 1\n max_count = max(r-l+1, max_count)\n r += 1\n return max_count\n","class Solution:\n def longestOnes(self, A, K):\n if not A:\n return 0\n n = len(A)\n right = 0\n cnt = 0\n res = 0\n for left in range(n):\n while right <= n - 1 and (cnt < K or A[right] == 1):\n cnt += (A[right] == 0)\n right += 1\n res = max(res, right - left)\n cnt -= (A[left] == 0)\n return res","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n \n pre_sum = [A[0]]\n for i in range(1,len(A)):\n pre_sum.append(pre_sum[-1]+A[i])\n \n def cal(l,r):\n if (l == 0):\n return pre_sum[r]\n else:\n return pre_sum[r] - pre_sum[l-1]\n \n l = 0\n r = 0\n ans = K\n while (l<len(A)):\n #print (l,r)\n while (r<len(A) and (r-l+1)-cal(l,r)<=K ):\n ans = max(ans,r-l+1)\n r = r + 1\n #print (r)\n \n if (r==len(A)):\n break\n \n while ( l<len(A) and (r-l+1)-cal(l,r)>K ):\n l = l + 1\n #print (l)\n \n return ans\n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n i=j=maxCount=maxlen=0\n d={0:0,1:0}\n while(i<len(A)):\n d[A[i]]+=1\n while(d[0]>K):\n d[A[j]]-=1\n j+=1\n maxlen=max(maxlen,i-j+1)\n i+=1\n return maxlen","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n i, ans = 0, 0\n for j, num in enumerate(A):\n if num == 0:\n K -= 1\n while K < 0:\n if A[i] == 0:\n K += 1\n i += 1\n ans = max(ans, j-i+1)\n return ans\n \n ans = 0\n start, end = 0, 0\n \n while end < len(A):\n if A[end] == 1:\n ans = max(ans, end-start+1)\n end+=1\n else:\n if K != 0:\n ans = max(ans, end-start+1)\n end+=1\n K -= 1\n else:\n if A[start] == 0:\n K+=1\n start+=1\n return ans\n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n le, ri = 0, 0\n max_len = 0\n while ri < len(A):\n if A[ri] == 0:\n K -= 1\n ri += 1\n if K >= 0:\n max_len= max(max_len, ri - le)\n print((le, ri))\n while K < 0 and le < ri:\n if A[le] == 0:\n K += 1\n le += 1\n \n return max_len\n \n","class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n left,right = 0,0\n num_zeros = 0\n window_size = 0\n \n while right < len(A):\n if A[right] == 0:\n num_zeros += 1\n while num_zeros > K:\n if A[left] == 0:\n num_zeros -= 1\n left += 1 \n window_size = max(window_size,right-left+1)\n right += 1\n \n return window_size ","import math\nimport random\nimport string\nfrom functools import lru_cache\nfrom operator import truediv\nfrom typing import List\nimport collections\nimport functools\nimport heapq\nimport itertools\nimport sys\nfrom functools import lru_cache\nfrom typing import List\nimport numpy as np\nimport collections\nimport functools\nimport heapq\nimport itertools\nimport sys\nfrom functools import lru_cache\nfrom typing import List\n\n'''\n反转K个位置的0为1，问最长连续1的长度。\n\nInput: A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3\nOutput: 10\nExplanation: \n[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]\nBolded numbers were flipped from 0 to 1. The longest subarray is underlined.\n\n\n思路：滑动窗口。\n主要思想，开区间伸缩左右边界。闭区间不好处理初始情况。\n\n'''\n\n\nclass Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n # 开区间[start, end)\n start = 0\n end = 0\n ret = 0\n while end < len(A):\n if A[end] == 1:\n end += 1\n else:\n if K > 0:\n end += 1\n K -= 1\n else:\n if A[start] == 0:\n K += 1\n start += 1\n ret = max(ret, end - start)\n return ret\n\n\n# A = [0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1]\n# K = 3\n# \n# r = Solution()\n# a = r.longestOnes(A, K)\n# print(a)\n"],"string":"[\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n hulu = []\\n cnt = 0\\n num = A[0]\\n for x in A:\\n if x == num:\\n cnt += 1\\n else:\\n hulu.append([num,cnt])\\n cnt = 1\\n num = x\\n if cnt>0:\\n hulu.append([num,cnt])\\n \\n # print(hulu)\\n \\n output = 0\\n \\n if A[0] == 1:\\n start = 0\\n else:\\n start = 1\\n if len(hulu)<2:\\n return min(K,len(A))\\n \\n end = start\\n \\n usage = 0\\n ones = hulu[start][1]\\n while end+2<len(hulu) and usage+hulu[end+1][1]<=K:\\n usage += hulu[end+1][1]\\n ones += hulu[end+2][1]\\n end += 2\\n \\n output = ones+K\\n \\n # print([start,end,usage,ones])\\n \\n start += 2\\n \\n while start<len(hulu):\\n ones -= hulu[start-2][1]\\n usage -= hulu[start-1][1]\\n if start>end:\\n end = start\\n ones = hulu[start][1]\\n usage = 0\\n while end+2<len(hulu) and usage+hulu[end+1][1]<=K:\\n usage += hulu[end+1][1]\\n ones += hulu[end+2][1]\\n end += 2\\n # print([start,end,usage,ones])\\n \\n output = max(output,ones+K)\\n start += 2\\n \\n return min(output,len(A))\\n \\n \\n \\n \\n \\n \\n \\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n if len(A) - sum(A) <= K:\\n return len(A)\\n \\n left = right = 0\\n \\n for right in range(len(A)):\\n if A[right] == 0:\\n K-=1\\n \\n if K < 0:\\n \\n if A[left] == 0:\\n K+=1\\n \\n left += 1\\n \\n return right-left + 1\\n\",\n \"'''\\n[1,1,1,0,0,0,1,1,1,1,0]\\n i\\n j\\n'''\\n\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n left,right=0,0\\n alen=len(A)\\n \\n while right < alen:\\n \\n if A[right] == 0:\\n K-=1\\n \\n if K < 0:\\n if A[left] == 0:\\n K+=1\\n left+=1\\n right+=1\\n \\n return right - left\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n window_start, max_length, max_ones_count = 0, 0, 0\\n \\n # Try to extend the range [window_start, window_end]\\n for window_end in range(len(A)):\\n if A[window_end] == 1:\\n max_ones_count += 1\\n\\n # Current window size is from window_start to window_end, overall we have a maximum of 1s\\n # repeating 'max_ones_count' times, this means we can have a window with 'max_ones_count' 1s\\n # and the remaining are 0s which should replace with 1s.\\n # now, if the remaining 1s are more than 'k', it is the time to shrink the window as we\\n # are not allowed to replace more than 'k' 0s\\n if (window_end - window_start + 1 - max_ones_count) > K:\\n if A[window_start] == 1:\\n max_ones_count -= 1\\n window_start += 1\\n\\n max_length = max(max_length, window_end - window_start + 1)\\n return max_length\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i,j,count,res = 0,0, 0,0\\n while j<len(A):\\n if A[j]==0:\\n count+=1\\n while count>K:\\n if A[i]==0:\\n count-=1\\n i+=1\\n res= max(res, j-i+1)\\n j+=1\\n return res\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n start, end = 0, 0\\n max_len = 0\\n numzeros = 0\\n while end < len(A):\\n if A[end] == 0:\\n numzeros += 1\\n while numzeros > K:\\n # shrink window\\n if A[start] == 0:\\n numzeros -= 1\\n start += 1\\n max_len = max(max_len, end - start + 1)\\n end += 1\\n return max_len\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n res = 0\\n start, end = 0, 0\\n cnt = 0\\n while end < len(A) and start < len(A):\\n if A[end] == 1:\\n res = max(res, end - start + 1)\\n end += 1\\n elif A[end] == 0 and cnt < K:\\n res = max(res, end - start + 1)\\n cnt += 1\\n end += 1\\n else:\\n if A[start] == 0 and K > 0:\\n cnt -= 1\\n start += 1\\n if start > end:\\n end = start\\n return res\\n \\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n #brute force, linear scan NAIVE APPROACH \\n #start with the largest size and move down, time limit exceeded \\n '''\\n for size in range(len(A)-1, -1, -1): \\n i = 0\\n j = i+size\\n count = 0\\n for ind in range(i, j+1):\\n if A[ind] == 0: \\n count += 1\\n \\n while j < len(A): \\n if count <= K: \\n return size+1\\n else:\\n if A[i] == 0: count -= 1\\n if j < len(A)-1 and A[j+1] == 0: count += 1\\n j += 1\\n i += 1\\n \\n return 0\\n '''\\n \\n #use dynamic variant of sliding window technique\\n maxConsecutiveOnes = 0\\n windowStart = 0\\n currZeroes = 0\\n #iterate through the array linearly and see if the number of 0s is <= K\\n for windowEnd in range(len(A)): \\n if A[windowEnd] == 0: \\n currZeroes += 1\\n \\n #shrinks window \\n while currZeroes > K:\\n if A[windowStart] == 0: \\n currZeroes -= 1\\n \\n windowStart += 1\\n\\n \\n maxConsecutiveOnes = max(maxConsecutiveOnes, windowEnd - windowStart + 1)\\n \\n \\n \\n return maxConsecutiveOnes\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left=0\\n right=0\\n for right in range(len(A)):\\n if A[right]==0:\\n K-=1\\n if K<0:\\n if A[left]==0:\\n K+=1\\n left+=1\\n return right -left +1\\n\",\n \"class Solution:\\n def longestOnes(self, arr: List[int], K: int) -> int:\\n left = 0\\n \\n for right in range(len(arr)):\\n K -= 1 - arr[right]\\n if K < 0:\\n K += 1 - arr[left]\\n left += 1\\n \\n \\n return right - left + 1\\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], k: int) -> int:\\n leftPtr=0\\n rightPtr=0\\n windowSize=[]\\n \\n while rightPtr<=len(A)-1:\\n if A[rightPtr]==0:\\n k-=1\\n if k<0:\\n if A[leftPtr]==0:\\n k+=1\\n \\n leftPtr+=1\\n rightPtr+=1\\n \\n \\n return rightPtr-leftPtr\\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left = 0\\n for right in range(len(A)):\\n K -= int(A[right] == 0)\\n if K < 0:\\n K += 1 - A[left]\\n left += 1\\n return right - left + 1\\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n start = 0\\n end = 0\\n l = len(A)\\n count = 0\\n max_len = 0\\n while end < l:\\n # print(start, end)\\n if A[end] == 1:\\n max_len = max(max_len, end-start+1)\\n end = end + 1\\n else:\\n if count < K:\\n max_len = max(max_len, end-start +1)\\n count = count+1\\n end = end + 1\\n else:\\n while start <= end and count >= K:\\n if A[start] == 0:\\n count = count -1\\n start = start + 1\\n \\n \\n \\n return max_len\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left = 0\\n for right in range(len(A)):\\n \\n # If we included a zero in the window we reduce the value of K.\\n # Since K is the maximum zeros allowed in a window.\\n K -= (1 - A[right])\\n # A negative K denotes we have consumed all allowed flips and window has\\n # more than allowed zeros, thus increment left pointer by 1 to keep the window size same.\\n if K < 0:\\n # If the left element to be thrown out is zero we increase K.\\n K += 1 - A[left]\\n left += 1\\n return right - left + 1\",\n \"def solve(arr,n,k):\\n prefix=[0]\\n for i in range(0,n):\\n if(arr[i]==0):\\n prefix.append(prefix[-1]+1)\\n else:\\n prefix.append(prefix[-1])\\n low=0\\n high=n+1\\n ans=0\\n while(low<high):\\n f=0\\n mid=low+(high-low)//2\\n for i in range(mid,n+1):\\n if(prefix[i]-prefix[i-mid]<=k):\\n ans=max(ans,mid)\\n f=1\\n if(f==1):\\n low=mid+1\\n else:\\n high=mid\\n return ans\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n return solve(A,len(A),K)\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n ans , i , c = 0 , 0 , [ ]\\n for j in range( len( A ) ) :\\n if A[ j ] == 0 :\\n c += j ,\\n while len( c ) > K :\\n i = c.pop( 0 ) + 1\\n ans = max( ans , j - i + 1 )\\n return ans\\n#Sanyam Rajpal\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], k: int) -> int:\\n res = 0\\n i = j = 0\\n \\n move = 1\\n while i<len(A) and j<len(A):\\n if move==1:\\n if A[j]==0:\\n if k == 0:\\n move = 0\\n print(i,j)\\n res = max(res,j-i)\\n k -= 1\\n j += 1\\n if move==0:\\n if A[i]==0:\\n k += 1\\n move = 1\\n i += 1\\n \\n return max(res,j-i)\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n start, end = 0, 0\\n \\n for end in range(len(A)):\\n if A[end] == 0:\\n K -= 1\\n if K < 0:\\n if A[start] == 0:\\n K += 1\\n start += 1\\n \\n return end - start + 1\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n ans = 0\\n l = 0\\n r = 0\\n prefix = [0 for i in range(len(A))]\\n for i in range(len(A)):\\n if (i==0):\\n prefix[i] = A[0]\\n else:\\n prefix[i] = A[i] + prefix[i-1]\\n \\n if (K>=len(A)-prefix[-1]):\\n return len(A)\\n \\n \\n while (r<len(A) and l<len(A)):\\n while (r<len(A)):\\n if (l==0):\\n this_sum = prefix[r]\\n else:\\n this_sum = prefix[r] - prefix[l-1]\\n \\n if (r-l+1-this_sum>K):\\n r-=1\\n break\\n \\n r+=1\\n \\n if (r>=len(A)):\\n if (r-l>ans):\\n #print (l,r,ans)\\n ans = r-l\\n break\\n \\n if (r-l+1>ans):\\n #print (l,r,ans)\\n ans = r-l+1\\n \\n #r+=1\\n while (l<len(A) and A[l] == 1):\\n l+=1\\n \\n l+=1\\n \\n return ans\\n \\n \\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n count=0\\n maxCount=-1\\n first=0\\n for i in range(len(A)):\\n if A[i]==0 and K!=0:\\n count+=1\\n K-=1\\n elif A[i]==0 and K==0:\\n while A[first]!=0:\\n first+=1\\n count-=1\\n first+=1\\n else:\\n count+=1\\n maxCount=max(maxCount,count)\\n return maxCount\\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n # don't reduce window - time O(n); space O(1)\\n left = 0\\n for right in range(len(A)):\\n K -= (1 - A[right])\\n if K < 0:\\n K += (1 - A[left])\\n left += 1\\n \\n return right - left + 1\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i, j = 0, 0\\n count = 0\\n out = 0\\n for i in range(len(A)):\\n if A[i] == 0:\\n count += 1\\n while count > K and j < len(A):\\n if A[j] == 0:\\n count -= 1\\n j += 1\\n out = max(out, i - j + 1)\\n return out\\n \\n\",\n \"class Solution:\\n def longestOnes(self, a: List[int], K: int) -> int:\\n i = 0\\n j = 0\\n ml = 0\\n while i < len(a):\\n if a[i] == 0:\\n K -= 1\\n while K < 0:\\n if a[j] == 0:\\n K += 1\\n j += 1\\n ml = max(ml, i-j+1)\\n i += 1\\n return ml\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n '''naive\\n \\n \\n sliding window\\n keep growing sliding window rhs as num of 0s in window is >k\\n when num 0s == k, slide lhs of window until k > num 0s again\\n keep track of largest sliding window'''\\n \\n \\n if not A:\\n return 0\\n \\n best_window_len = 0\\n p, q = 0, 0\\n \\n num_zeros = 0\\n #if A[q] == 0: num_zeros += 1\\n \\n while q < len(A):\\n if A[q] == 0: num_zeros += 1\\n #print(p, q, q - p)\\n if num_zeros > K:\\n best_window_len = max(q - p, best_window_len)\\n #print(\\\\\\\"running best:\\\\\\\", best_window_len)\\n while num_zeros > K:\\n if A[p] == 0:\\n num_zeros -= 1\\n p += 1\\n q+=1\\n \\n best_window_len = max(q - p, best_window_len)\\n #if p == 0:\\n #best_window_len+=1\\n #print(best_window_len)\\n return best_window_len\\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n subarrays = []\\n start = -1\\n i = 0\\n while i < len(A):\\n if A[i] == 1:\\n if start == -1:\\n start = i\\n else:\\n if start != -1:\\n subarrays.append([start, i])\\n start = -1\\n i += 1\\n if A[i-1] == 1:\\n subarrays.append([start, i])\\n print(subarrays)\\n \\n if K == 0:\\n result = 0\\n for arr in subarrays:\\n if arr[1] - arr[0] > result:\\n result = arr[1] - arr[0]\\n return result\\n \\n window = []\\n start = []\\n end = []\\n result = 0\\n for i in range(len(A)):\\n if A[i] == 0: \\n if len(window) == K:\\n window.pop(0)\\n window.append(i)\\n left = window[0] - 1\\n right = window[-1] + 1\\n while left >= 0 and A[left] != 0:\\n left -=1\\n while right < len(A) and A[right] != 0:\\n right += 1\\n if right - left > result:\\n result = right - left\\n # for i in range(start, len(subarrays)):\\n # if subarrays[i][0] > window[0]:\\n # break\\n # start = i\\n # for i in range(len(subarrays)-1, end-1, -1):\\n # if subarrays[i][1] < window[-1]:\\n # break\\n # end = i\\n \\n # result = 0\\n # for curr_k in range(K, 0, -1)\\n # i = 0\\n # while i < len(subarrays) - 1:\\n # gap = subarrays[i][1] + subarrays[i][0] - 1\\n # if gap == curr_k:\\n return result - 1\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n start = end = 0\\n res = 0\\n map = collections.defaultdict(int)\\n while end < len(A):\\n map[A[end]] += 1\\n while end - start + 1 - map[1] > K:\\n map[A[start]] -= 1\\n start += 1\\n res = max(res, end-start+1)\\n end += 1\\n \\n return res\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n begins = [-1] * (K+1)\\n cur = [0] * (K+1)\\n maxL = 0\\n curMax = 0\\n for i, a in enumerate(A):\\n if a == 0:\\n maxL = max(maxL, curMax)\\n begins.pop(0)\\n begins.append(i)\\n curMax -= cur.pop(0)\\n curMax += 1 if begins[0] == -1 else 0\\n cur.append(0)\\n else:\\n cur[-1] += 1\\n curMax += 1\\n return max(maxL, curMax)\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n right = 0\\n for i in range(len(A)):\\n if A[i] == 0:\\n A[i] = 1\\n else:\\n A[i] = 0\\n tot = A[0]\\n res = 0\\n \\n for left in range(len(A)):\\n while tot <= K:\\n right = right + 1\\n if right >= len(A):\\n break\\n tot = tot + A[right]\\n res = max(res, right - left)\\n if right >= len(A) - 1:\\n break\\n if A[left] == 1:\\n tot = tot - 1\\n \\n return res\\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n if A.count(0) <= K:\\n return len(A)\\n \\n res = 0\\n i = 0\\n for j in range(len(A)):\\n if A[j] == 0:\\n K -= 1\\n res = max(res, j-i)\\n while K < 0 and i <= j:\\n if A[i] == 0:\\n K += 1\\n i += 1\\n \\n return max(res, len(A)-i)\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n k = K\\n j = ans = 0\\n for i in range(len(A)):\\n if not A[i]:\\n k -= 1\\n \\n while k<0:\\n if not A[j]:\\n k += 1\\n j += 1\\n ans = max(ans, i-j+1)\\n \\n return ans\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i, res = 0, 0\\n for j in range(len(A)):\\n K -= 1 - A[j]\\n while K < 0:\\n K += 1 - A[i]\\n i += 1\\n res = max(res, j - i + 1)\\n return res\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left, right = 0,0\\n max_window = 0\\n zero_positions = []\\n num_violations = 0\\n while right < len(A):\\n if A[right] == 0:\\n num_violations +=1\\n zero_positions.append(right)\\n if num_violations > K:\\n left = zero_positions[0] +1\\n zero_positions.pop(0)\\n num_violations -=1\\n right +=1\\n max_window = max(max_window, right - left)\\n return max_window\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n z_count = 0\\n l = 0\\n result = 0\\n for i in range(len(A)):\\n if not A[i]:\\n z_count+=1\\n if z_count <= K:\\n result = max(result, i-l+1)\\n while l < i and z_count>K:\\n if not A[l]:\\n z_count-=1\\n l+=1\\n\\n \\n return result\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n longest = start = end = zeroes = 0\\n while end < len(A):\\n num = A[end]\\n\\n if not num:\\n zeroes += 1\\n end += 1\\n while zeroes > K:\\n if A[start] == 0:\\n zeroes -= 1\\n start += 1\\n longest = max(longest, end - start)\\n return longest \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n res = 0\\n i, j, N = 0, 0, len(A)\\n remaining = K if A[i] == 1 else K - 1\\n while i < N:\\n # resetting\\n if i > j:\\n j = i\\n remaining = K if A[i] == 1 else K - 1\\n\\n # stretch\\n while j + 1 < N and remaining >= 0:\\n if A[j + 1] == 0:\\n if remaining > 0:\\n remaining -= 1\\n else:\\n break\\n j += 1\\n res = max(res, j - i + 1)\\n\\n # pay debt\\n if A[i] == 0:\\n remaining += 1\\n i += 1\\n return res\",\n \"class Solution:\\n def longestOnes(self, x: List[int], K: int) -> int:\\n \\n buf = collections.deque()\\n n = len(x)\\n i = 0\\n unused = K\\n start = -1\\n maxlen = float('-inf')\\n while i < n:\\n if x[i] == 0:\\n if unused > 0:\\n buf.append(i)\\n unused -= 1\\n maxlen = max(i - start, maxlen)\\n else:\\n if buf:\\n start = buf.popleft()\\n maxlen = max(i - start, maxlen)\\n buf.append(i)\\n else:\\n # K == 0\\n maxlen = max(i - 1 - start, maxlen)\\n start = i\\n else:\\n maxlen = max(i - start, maxlen)\\n \\n \\n i += 1\\n return maxlen if n > 0 else n\",\n \"# 1,1,1,0,0,0,1,1,1,1,0\\n# max=5,k=0 [ ]\\n\\n# 1,1,1,0,0,0,1,1,1,1,0\\n# max=5,k=-1 [ ]\\n\\n# 1,1,1,0,0,0,1,1,1,1,0\\n# max=6,k=0 [ ]\\n\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n l = 0\\n for r in range(len(A)):\\n if A[r] == 0:\\n K-=1\\n \\n if K<0:\\n if A[l] == 0:\\n K+=1\\n l+=1\\n return r-l+1\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n lo = 0\\n hi = len(A)\\n A = [0] + [1-x for x in A]\\n n = len(A)\\n for i in range(1, n):\\n A[i] += A[i-1]\\n \\n while lo < hi:\\n mid = (lo + hi + 1) // 2\\n \\n if min(A[i] - A[i-mid] for i in range(mid, len(A))) <= K:\\n lo = mid\\n else:\\n hi = mid - 1\\n \\n return lo\\n\",\n \"'''\\n\\nInput: A = [1,1,1,0,0,0,1,1,1,1,0], K = 2\\nOutput: 6\\n\\n\\n\\n\\n\\n\\n\\n'''\\n\\n\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n '''\\n Sliding window technique\\n '''\\n # if there's no array\\n if not A:\\n return 0\\n \\n # define a window\\n window = 0\\n \\n # define start of the window\\n start = 0\\n \\n # maximum allowed ones\\n max_ones = 0\\n \\n # iterate over A\\n for it, value in enumerate (A):\\n \\n # add value to window\\n window += value\\n \\n # eviction reached?\\n # [1,1,1,0,0,0,1,1,1,1,0]\\n if it - start + 1 > window + K:\\n window -= A[start]\\n start += 1\\n \\n # figure the maximum ones possible\\n max_ones = max (max_ones, window + K)\\n \\n return min (max_ones, len (A))\",\n \"class Solution:\\n def longestOnes(self, A: List[int], k: int) -> int:\\n \\n \\n \\n ans=0\\n i=0\\n \\n for j,c in enumerate(A):\\n k-=(1-c)\\n if k<0:\\n k+=1-A[i]\\n i+=1\\n ans=max(ans,j-i+1)\\n return max(ans,j-i+1)\\n \\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left=0\\n right=0\\n maxlength=0\\n hashmap={}\\n count=0\\n while right<len(A):\\n hashmap[A[right]]=hashmap.get(A[right],0)+1\\n while A[right]==0 and hashmap[A[right]]>K:\\n hashmap[A[left]]-=1\\n left+=1\\n maxlength=max(maxlength,right-left+1)\\n right+=1\\n return maxlength\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left = 0\\n right = 0\\n contains = 0\\n max_len = 0\\n \\n while right < len(A):\\n if A[right] == 0:\\n contains += 1\\n \\n if contains > K:\\n while contains > K:\\n if A[left] == 0:\\n contains -= 1\\n left += 1\\n max_len = max(max_len, right - left + 1)\\n right += 1\\n \\n return max_len\\n \\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n l = len(A)\\n end = 0\\n start = 0\\n ans = 0\\n count = 0\\n for i in range(l):\\n if A[i] == 1:\\n count += 1\\n if end - start + 1 - count <= K:\\n ans = max(ans, end - start + 1)\\n else:\\n if A[start] == 1:\\n count -= 1\\n start += 1\\n end += 1\\n return ans\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n lo, hi = 0, 0\\n zmax = 0\\n n_k = 0\\n while hi < len(A):\\n # print(f\\\\\\\"{lo},{hi}, {zmax}\\\\\\\")\\n if A[hi] == 0:\\n n_k += 1\\n # break\\n \\n while n_k > K:\\n if A[lo] == 0:\\n n_k-=1\\n lo+=1\\n \\n zmax = max(zmax, hi-lo+1)\\n \\n \\n hi+=1\\n return zmax\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left=0\\n for right in range(len(A)):\\n K-=1-A[right]\\n \\n if K<0:\\n K +=1-A[left]\\n left+=1\\n return right-left+1\\n \\n \\n \\n\",\n \"class Solution:\\n def findMaxConsecutiveOnes(self, nums: List[int]) -> int:\\n if len(nums) == 0:\\n return 0 \\n\\n # left - on the first 1 of the island\\n # right - on the last 1 of that island\\n left = 0\\n while left < len(nums) and nums[left] != 1:\\n left += 1\\n\\n right = left \\n while right + 1 < len(nums) and nums[right + 1] == 1:\\n right += 1\\n\\n if right == len(nums):\\n return 0\\n\\n maxOnes = right - left + 1\\n\\n while left < len(nums):\\n left = right + 1\\n while left < len(nums) and nums[left] != 1:\\n left += 1\\n\\n right = left \\n while right + 1 < len(nums) and nums[right + 1] == 1:\\n right += 1\\n\\n maxOnes = max(maxOnes, right - left + 1)\\n\\n return maxOnes\\n \\n \\n def longestOnes(self, A: List[int], K: int) -> int:\\n if K == 0:\\n return self.findMaxConsecutiveOnes(A)\\n \\n if len(A) == 0:\\n return 0\\n\\n left, right = 0, 0\\n\\n # Pre-condition: In the [left, right] we have exactly K zeros,\\n # and you can't move right any more\\n\\n # Move right to K-th zero\\n if A[right] == 0:\\n K -= 1\\n while right + 1 < len(A) and K > 0:\\n right += 1\\n if A[right] == 0:\\n K -= 1\\n\\n # Move more if there are 1s to the right of K-th zero \\n while right + 1 < len(A) and A[right + 1] == 1:\\n right += 1\\n\\n maxSize = right - left + 1\\n\\n while right < len(A):\\n # Move left off of a zero, and then move right accordingly to include 1 more zero\\n while left < len(A) and A[left] != 0:\\n left += 1\\n if left < len(A):\\n left += 1\\n else:\\n return maxSize\\n\\n\\n # Move right to include one more zero \\n right += 1\\n while right + 1 < len(A) and A[right + 1] == 1:\\n right += 1\\n\\n maxSize = max(maxSize, right - left + 1)\\n \\n return maxSize \",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n # find the maximum subarray with max of K 0's \\n # this will help find the maximum number of 1s \\n \\n # [1,1,1,0,0,0,1,1,1,1,0]\\n # fast = 5\\n # slow = 0\\n # lastZero = 3, 4, 5\\n # slow = 3\\n slow = fast = 0\\n maxOnes = -1\\n lastZero = collections.deque()\\n while fast < len(A):\\n if A[fast] == 0:\\n lastZero.append(fast)\\n if len(lastZero) > K:\\n slow = lastZero.popleft() + 1\\n fast += 1 \\n maxOnes = max(maxOnes, (fast - slow))\\n \\n if maxOnes == -1:\\n return len(A)\\n return maxOnes\\n \\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n st,ed = 0,0\\n ans = 0\\n \\n longest = 0\\n k = 0\\n while ed < len(A):\\n while ed < len(A):\\n if A[ed] == 1:\\n longest += 1\\n elif k < K:\\n k += 1\\n longest += 1\\n else:\\n break\\n \\n ed += 1\\n \\n ans = max(longest, ans) \\n while st <= ed and st < len(A):\\n longest -= 1\\n if A[st] == 0:\\n k -= 1\\n st += 1\\n break\\n \\n st += 1\\n \\n return ans\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n onecount = 0 \\n start = 0\\n ans = 0\\n \\n for end in range(len(A)):\\n if A[end] == 1: \\n onecount += 1\\n \\n if end - start + 1 - onecount > K:\\n if A[start] == 1: onecount -= 1\\n start += 1\\n \\n ans = max(ans , end - start +1)\\n \\n return ans\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n start, end, max_length, num_0 = 0, 0, 0, int(not A[0])\\n while end < len(A) - 1:\\n if num_0 > K:\\n if A[start] == 0:\\n num_0 -= 1\\n start += 1\\n end += 1\\n if A[end] == 0:\\n num_0 += 1\\n if num_0 <= K:\\n max_length = end - start + 1\\n return max_length\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n startWindow = 0\\n maxLength = 0\\n nZerosInsideWindow = 0\\n \\n for endWindow, el in enumerate(A):\\n nZerosInsideWindow += (el == 0)\\n \\n while nZerosInsideWindow > K:\\n firstElement = A[startWindow]\\n nZerosInsideWindow -= (firstElement == 0)\\n startWindow += 1\\n \\n maxLength = max(maxLength, endWindow - startWindow + 1)\\n \\n return maxLength\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n n = len(A)\\n if n == 0:\\n return 0\\n \\n head = 0\\n tail = 0\\n num_zeros = 0\\n max_subseq = 0\\n while head < n:\\n if A[head] == 1:\\n head += 1\\n else:\\n num_zeros += 1\\n max_subseq = max(max_subseq, head-tail)\\n if num_zeros > K:\\n while A[tail] == 1:\\n tail += 1\\n tail += 1\\n num_zeros -= 1\\n head += 1\\n max_subseq = max(max_subseq, n-tail)\\n return max_subseq\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n allowance = K\\n currSum = 0\\n left = 0\\n maxSum = 0\\n for i in range(len(A)):\\n if A[i] == 1:\\n currSum += 1\\n else:\\n allowance -= 1\\n while allowance < 0:\\n if A[left] == 1:\\n currSum -= 1\\n else:\\n allowance += 1\\n left += 1\\n maxSum = max(maxSum, K - allowance + currSum)\\n return maxSum\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n res = 0\\n i = 0\\n for j in range(len(A)):\\n if A[j] == 0:\\n K -= 1\\n res = max(res, j - i)\\n while K < 0:\\n if A[i] == 0:\\n K += 1\\n i += 1\\n return max(res, len(A) - i)\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n res = 0\\n i = 0\\n for j in range(len(A)):\\n if A[j]==0:\\n K-=1\\n res = max(res,j-i)\\n \\n while K<0:\\n if(A[i]==0):\\n K+=1\\n i += 1\\n \\n return max(res,len(A)-i)\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left = right = 0\\n \\n for right in range(len(A)):\\n # if we encounter a 0 the we decrement K\\n if A[right] == 0:\\n K -= 1\\n # else no impact to K\\n \\n # if K < 0 then we need to move the left part of the window forward\\n # to try and remove the extra 0's\\n if K < 0:\\n # if the left one was zero then we adjust K\\n if A[left] == 0:\\n K += 1\\n # regardless of whether we had a 1 or a 0 we can move left side by 1\\n # if we keep seeing 1's the window still keeps moving as-is\\n left += 1\\n \\n return right - left + 1\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int: \\n res = 0\\n i = 0\\n for j in range(len(A)):\\n if A[j] == 0:\\n K -= 1\\n res = max(res, j-i)\\n while K < 0 and i <= j:\\n if A[i] == 0:\\n K += 1\\n i += 1\\n \\n return max(res, len(A)-i)\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n \\n i = 0\\n res = 0\\n for j, a in enumerate(A): \\n if a == 0:\\n K-=1 \\n while K < 0:\\n if A[i] == 0:\\n K+=1\\n i+=1 \\n else:\\n res = max(res, j-i+1)\\n return res\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n l, ans = 0, 0\\n for r in range(len(A)):\\n if A[r] == 0:\\n K -= 1\\n while K < 0:\\n if A[l] == 0:\\n K += 1\\n l += 1\\n ans = max(ans, r+1-l)\\n \\n return ans\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n if A == None or len(A) == 0 or K == None:\\n return 0\\n if len(A) <= K:\\n return K\\n \\n left = 0\\n flip = 0\\n maxlength = 0\\n for i, num in enumerate(A):\\n if A[i] == 0:\\n flip += 1\\n if flip <= K:\\n maxlength = max(maxlength, i - left + 1)\\n \\n while left < i and flip > K:\\n if A[left] == 0:\\n flip -=1\\n left += 1\\n\\n return maxlength\\n \\n \\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n count, n, l = 0, len(A), 0\\n ans = 0\\n for r in range(n):\\n count += 1 - A[r]\\n while count > K:\\n count -= 1 - A[l]\\n l += 1\\n ans = max(ans, r-l+1)\\n return ans\\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n ans = 0\\n l = 0\\n for r in range(len(A)):\\n if A[r] == 0:\\n K -= 1\\n while K < 0:\\n if A[l] == 0:\\n K += 1\\n l += 1\\n ans = max(ans, r+1-l)\\n \\n return ans\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n windowstart, curr0,res = 0,0, 0\\n currwindow = {1:0 , 0:0}\\n \\n \\n for windowend in range(len(A)):\\n\\n # add the new element into the current window,\\n currwindow[A[windowend]] +=1\\n # check if the least common number is above k\\n curr0 = currwindow[0]\\n\\n # if yes, increase the window start \\n if curr0 > K :\\n currwindow[A[windowstart]] -=1\\n windowstart +=1\\n \\n # look for the window size and max with the max and the current length\\n res = max (res, windowend-windowstart +1 )\\n\\n return res \",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n count_1 = 0\\n zero_inx = []\\n res = 0\\n zero_before = -1\\n for i in range(len(A)):\\n if A[i] == 1:\\n count_1 += 1\\n else:\\n zero_inx.append(i)\\n if K > 0:\\n K -= 1\\n count_1 += 1\\n elif K == 0:\\n res = max(res,count_1)\\n first_0 = zero_inx.pop(0)\\n count_1 -= (first_0 - zero_before - 1)\\n zero_before = first_0\\n res = max(res, count_1)\\n return res\",\n \"class Solution:\\n def longestOnes(self, arr: List[int], k: int) -> int:\\n start_index = 0\\n longest_ones = 0\\n max_length = 0\\n for end_index in range(len(arr)):\\n if arr[end_index] == 1:\\n longest_ones += 1\\n if longest_ones+k <= (end_index - start_index):\\n if arr[start_index] == 1:\\n longest_ones -= 1\\n start_index += 1\\n max_length = max(max_length, end_index-start_index+1)\\n return max_length\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n if A == None or len(A) == 0 or K == None:\\n return 0\\n if len(A) <= K:\\n return K\\n \\n left = 0\\n count_of_zero = 0\\n maxlength = 0\\n for i, num in enumerate(A):\\n if A[i] == 0:\\n count_of_zero += 1\\n if count_of_zero <= K:\\n maxlength = max(maxlength, i - left + 1)\\n \\n while left < i and count_of_zero > K:\\n if A[left] == 0:\\n count_of_zero -=1\\n left += 1\\n\\n return maxlength\\n \\n \\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n l = 0\\n res = 0\\n for h in range(len(A)):\\n K -= 1 - A[h]\\n if K < 0:\\n K += 1 - A[l]\\n l += 1\\n return h-l+1\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i = 0\\n j = 0\\n \\n numZeros = 0\\n \\n bestSize = 0\\n while j < len(A):\\n if A[j] == 1:\\n pass\\n elif A[j] == 0:\\n numZeros += 1\\n while numZeros > K:\\n if i >= 0 and A[i] == 0:\\n numZeros -= 1\\n i += 1\\n bestSize = max(bestSize, j - i + 1)\\n j += 1\\n return bestSize\",\n \"\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n s, e = 0, 0\\n r_k = K\\n result = 0\\n while e < len(A):\\n if A[e] == 0:\\n r_k -= 1\\n\\n while r_k < 0:\\n if A[s] == 0:\\n r_k += 1\\n s += 1\\n\\n result = max(result, e - s + 1)\\n\\n e+=1\\n\\n return result\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n res = -1\\n start, count = 0, 0 # start is beginning of window, count is number of 1s\\n # i is end of window, hence len of window is i-start+1\\n \\n for i in range(len(A)):\\n if A[i]==1: count += 1\\n while (i-start+1-count > K):\\n if A[start]==1: count -= 1\\n start += 1\\n res = max(res, i-start+1)\\n \\n return res\\n \\n\",\n \"class Solution:\\n def longestOnes(self, s: List[int], k: int) -> int:\\n l = 0\\n c_frequency = {0:0, 1:0}\\n longest_str_len = 0\\n for r in range(len(s)):\\n \\n if s[r] == 0:\\n c_frequency[0] += 1\\n else:\\n c_frequency[1] += 1\\n \\n # Replacements cost = cells count between left and right - highest frequency\\n cells_count = r - l + 1\\n if c_frequency[0] <= k or c_frequency[0] == 0:\\n longest_str_len = max(longest_str_len, cells_count)\\n \\n else:\\n if c_frequency[s[l]] != 0:\\n c_frequency[s[l]] -= 1\\n l += 1\\n \\n return longest_str_len\",\n \"class Solution:\\n def longestOnes(self, A, K):\\n window_start, max_length, max_ones_count = 0, 0, 0\\n for window_end in range(0, len(A)):\\n if A[window_end] == 1:\\n max_ones_count += 1\\n while window_end - window_start + 1 - max_ones_count > K:\\n if A[window_start] == 1:\\n max_ones_count -= 1\\n window_start += 1\\n max_length = max(max_length, window_end - window_start + 1)\\n return max_length\\n\",\n \"import bisect\\n\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n ans = countzeroes = 0\\n counter = {0: -1}\\n for i, num in enumerate(A):\\n if num==0:\\n countzeroes+=1\\n if countzeroes not in counter:\\n counter[countzeroes] = i\\n j = counter[max(0, countzeroes-K)]\\n ans = max(ans, i-j)\\n \\n return ans\\n\",\n \"import bisect\\n\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n ans = countzeroes = 0\\n counter = {0: -1}\\n for i in range(len(A)):\\n num = A[i]\\n if num==0:\\n countzeroes+=1\\n if countzeroes not in counter:\\n counter[countzeroes] = i\\n j = counter[max(0, countzeroes-K)]\\n ans = max(ans, i-j)\\n \\n return ans\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n l,r = 0, -1\\n optim = 0\\n while r < len(A):\\n while r < len(A):\\n r += 1\\n if r == len(A):\\n break\\n if A[r] == 0:\\n K -= 1\\n if K < 0:\\n break\\n else:\\n optim = max(optim, r-l+1)\\n if r == len(A):\\n break\\n while l < r:\\n if A[l] == 0:\\n K += 1\\n l += 1\\n if K >= 0:\\n break\\n return optim\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n count = maxS = j = 0\\n \\n for i, a in enumerate(A):\\n if a == 0:\\n count += 1\\n \\n while j < len(A) and count > K:\\n if A[j] == 0:\\n count -= 1\\n j += 1\\n \\n maxS = max(maxS, i-j+1)\\n \\n return maxS\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n windowstart,most_common,res=0,0,0\\n currentwindow={1:0, 0:0}\\n \\n for windowend in range(len(A)):\\n\\n currentwindow[A[windowend]] +=1\\n\\n most_common = currentwindow[1]\\n\\n \\n #having this means we have to reduce the length of the window\\n if (windowend-windowstart+1 - most_common > K):\\n \\n currentwindow[A[windowstart]] -=1\\n windowstart +=1\\n\\n res = max(res,windowend-windowstart+1)\\n \\n return res\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left = 0\\n for right in range(len(A)):\\n # If we included a zero in the window we reduce the value of K.\\n # Since K is the maximum zeros allowed in a window.\\n K -= 1 - A[right]\\n # A negative K denotes we have consumed all allowed flips and window has\\n # more than allowed zeros, thus increment left pointer by 1 to keep the window size same.\\n if K < 0:\\n # If the left element to be thrown out is zero we increase K.\\n K += 1 - A[left]\\n left += 1\\n return right - left + 1\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n zeros, ones, max_len = 0, 0,0\\n def element_found(element, inc):\\n nonlocal zeros, ones, max_len\\n if element == 0:\\n zeros += inc\\n else:\\n ones += inc\\n \\n start = 0\\n for element in A:\\n element_found(element, 1)\\n \\n while zeros > K:\\n start,start_element = start+1, A[start]\\n element_found(start_element, -1)\\n \\n max_len = max(max_len, zeros + ones)\\n return max_len\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n if not A:\\n return 0\\n \\n n = len(A)\\n \\n cur_max = 0\\n counter = 0\\n index = []\\n prev = -1\\n \\n for i in range(n):\\n if A[i] == 1:\\n counter += 1\\n else:\\n if K > 0:\\n K -= 1\\n counter += 1\\n index.append(i)\\n else:\\n if index:\\n counter += 1\\n temp = index.pop(0)\\n counter -= temp - prev\\n prev = temp\\n index.append(i)\\n else:\\n counter = 0\\n \\n cur_max = max(cur_max, counter)\\n \\n return cur_max\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n left = 0\\n right = 0 \\n \\n k = K\\n max_ans = 0\\n so_far = 0\\n while(right < len(A)):\\n if(A[right]==1):\\n right+=1\\n else:\\n if(k>0):\\n right+=1\\n k-=1\\n else:\\n if(A[left]==0):\\n k+=1\\n left+=1\\n \\n max_ans = max(max_ans, right-left)\\n \\n return max_ans\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n zeros_indices = []\\n for i in range(len(A)):\\n if A[i] == 0:\\n zeros_indices.append(i)\\n\\n longest_ones = 0\\n\\n\\n longest_yet = 0\\n for i in range(len(A)):\\n if A[i] == 1:\\n longest_yet += 1\\n longest_ones = max(longest_ones, longest_yet)\\n else:\\n longest_yet = 0\\n if K == 0:\\n return longest_ones\\n\\n if K >= len(zeros_indices):\\n return len(A)\\n\\n\\n # [0, 1, 4, 5, 9, 12, 13, 14]\\n zero_order = -1\\n for i in range(len(A)):\\n if A[i] == 0:\\n zero_order += 1\\n right_cons_ones = left_cons_ones = 0\\n if zero_order + K < len(zeros_indices):\\n nxt = zero_order + K\\n right_cons_ones = zeros_indices[nxt] - zeros_indices[zero_order]\\n else:\\n nxt = len(zeros_indices) - 1\\n right_cons_ones = zeros_indices[nxt] - zeros_indices[zero_order]\\n right_cons_ones += len(A) - zeros_indices[nxt]\\n if not zero_order == 0: \\n left_cons_ones = zeros_indices[zero_order] - zeros_indices[zero_order-1] - 1\\n longest_ones = max(longest_ones, right_cons_ones + left_cons_ones)\\n return longest_ones\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n hash_count = dict()\\n hash_count[1] = 0\\n start = 0\\n max_count = 0\\n max_result = 0\\n for end in range(len(A)):\\n if A[end] == 1:\\n hash_count[A[end]] += 1 \\n max_count = max(max_count, hash_count[1])\\n if max_count + K < ( end - start + 1 ):\\n if A[start] == 1 and hash_count.get(1):\\n hash_count[1] -= 1\\n start += 1\\n max_result = max(max_result, end-start + 1)\\n return max_result\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n max_length = 0\\n start = 0\\n end = 1 \\n \\n zeros = 0\\n \\n if len(A) == 0:\\n return 0\\n if len(A) == 1:\\n return 1\\n \\n zeros = 2 - sum(A[:2])\\n \\n while end < len(A):\\n \\n valid = zeros <= K\\n \\n if valid:\\n max_length = max(max_length, (end - start)+1)\\n end += 1\\n if end == len(A):\\n return max_length\\n \\n if A[end] == 0:\\n zeros += 1\\n else:\\n if A[start] == 0:\\n zeros -= 1\\n start += 1\\n return max_length\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int: \\n K_original = K\\n i = 0\\n ans = 0\\n curr = 0\\n \\n j =0 \\n while(j<len(A)):\\n if A[j]==1 or K>0:\\n curr += 1\\n else:\\n curr = 0\\n K-=1 if (A[j]==0 and K>0) else 0\\n j+=1\\n ans = max(curr, ans)\\n if K_original>0 and K==0:\\n while(j<len(A) and A[j]==1):\\n curr+=1\\n j+=1\\n ans = max(curr, ans)\\n while(i<=j and i<len(A) and K==0):\\n if A[i]==0:\\n K+=1\\n i+=1\\n curr -=1 \\n # print(i,j,K, curr, ans)\\n return ans\\n\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n hash_count = dict()\\n hash_count[1] = 0\\n start = 0\\n max_count = 0\\n max_result = 0\\n for end in range(len(A)):\\n if A[end] == 1:\\n hash_count[A[end]] += 1 \\n max_count = max(max_count, hash_count[1])\\n #print(f\\\\\\\" {max_count + K} comp {end - start + 1}\\\\\\\")\\n if max_count + K < ( end - start + 1 ):\\n if A[start] == 1 and hash_count.get(1):\\n hash_count[1] -= 1\\n start += 1\\n max_result = max(max_result, end-start + 1)\\n #print(max_result)\\n return max_result\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left, right = 0, 0\\n k = 0\\n flipped = set()\\n longest = 0\\n while right < len(A):\\n if A[right] == 1:\\n longest = max(longest, right - left + 1)\\n right += 1\\n elif A[right] == 0 and k < K:\\n flipped.add(right)\\n longest = max(longest, right - left + 1)\\n right += 1\\n k += 1\\n elif left == right:\\n right += 1\\n left += 1\\n else:\\n if left in flipped:\\n flipped.discard(left)\\n k -= 1\\n left += 1\\n \\n \\n return longest\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n ct = Counter()\\n pt, max_len = 0, 0\\n for i, elem in enumerate(A):\\n ct[elem] += 1\\n if ct[0] <= K:\\n max_len = max(max_len, (i - pt + 1))\\n if ct[0] > K:\\n ct[A[pt]] -= 1\\n \\n pt += 1\\n\\n return max_len\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n left = 0\\n for right in range(len(A)):\\n # If we included a zero in the window we reduce the value of K.\\n # Since K is the maximum zeros allowed in a window.\\n K -= 1 - A[right]\\n # A negative K denotes we have consumed all allowed flips and window has\\n # more than allowed zeros, thus increment left pointer by 1 to keep the window size same.\\n if K < 0:\\n # If the left element to be thrown out is zero we increase K.\\n K += 1 - A[left]\\n left += 1\\n print(len(A),right)\\n return right - left + 1\",\n \"from collections import deque\\n\\n\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n substited_indexes = deque()\\n start = 0\\n best = 0\\n \\n index = 0\\n while index < len(A):\\n num = A[index]\\n \\n if num == 0:\\n if K > 0:\\n K -= 1\\n A[index] = 1\\n substited_indexes.append(index)\\n elif K == 0 and len(substited_indexes) == 0:\\n start = index + 1\\n else:\\n start = substited_indexes.popleft()\\n A[start] = 0\\n start += 1\\n K += 1\\n continue\\n \\n index += 1\\n best = max(best, index - start)\\n \\n return best\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n max_length = 0\\n start = 0\\n end = 1\\n ones = 1\\n\\n if len(A) == 0:\\n return 0\\n if len(A) == 1:\\n return 1\\n\\n ones = A[0] + A[1]\\n\\n while end < len(A):\\n\\n valid = ((end - start) + 1) - ones <= K\\n\\n if valid:\\n max_length = max(max_length, (end - start) + 1)\\n end += 1\\n if end == len(A):\\n return max_length\\n ones += A[end]\\n else:\\n ones -= A[start]\\n start += 1\\n return max_length\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n answer, length = 0, 0\\n inds = []\\n for i, num in enumerate(A):\\n if num == 1:\\n length += 1\\n elif len(inds) < K:\\n inds.append(i)\\n length += 1\\n elif K == 0:\\n length = 0\\n else:\\n last_index = inds.pop(0)\\n inds.append(i)\\n length = (i - inds[0]) + (inds[0] - last_index)\\n answer = max(answer, length)\\n return answer\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n max_length = 0\\n start = 0\\n end = 1\\n ones = 1\\n\\n if len(A) == 0:\\n return 0\\n if len(A) == 1:\\n return 1\\n\\n ones = sum(A[:2])\\n\\n while end < len(A):\\n\\n valid = ((end - start) + 1) - ones <= K\\n\\n if valid:\\n max_length = max(max_length, (end - start) + 1)\\n end += 1\\n if end == len(A):\\n return max_length\\n ones += A[end]\\n else:\\n ones -= A[start]\\n start += 1\\n return max_length\\n\",\n \"import bisect\\n\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n ans = 0\\n countzeroes = 0\\n prefix = []\\n for i, num in enumerate(A):\\n prefix.append(countzeroes)\\n if num==0:\\n countzeroes+=1\\n j = bisect.bisect_left(prefix, countzeroes-K)\\n ans = max(ans, i-j + 1) \\n return ans\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n counter = 0\\n i = 0 \\n j = 0\\n res=0\\n \\n for i in range(0,len(A)):\\n \\n if A[i] == 0:\\n counter+=1\\n \\n while counter>K and j<len(A):\\n if A[j]==0:\\n counter-=1\\n j+=1 \\n res= max(res,i-j+1)\\n print(res)\\n \\n return res\\n\",\n \"class Solution:\\n def longestOnes(self, A, K: int) -> int:\\n ans = count = 0\\n j = 0 # valid range is [i:j]\\n for i in range(len(A)):\\n if i > 0 and A[i - 1] == 0:\\n count -= 1\\n\\n while j < len(A) and (A[j] or count < K):\\n if A[j] == 1:\\n j += 1\\n elif count < K:\\n count += 1\\n j += 1\\n\\n ans = max(ans, j - i)\\n\\n return ans\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n l = 0\\n r = 0\\n max_count = K\\n\\n while (l < len(A) and r < len(A)):\\n \\n while(r < len(A)):\\n if A[r] == 1:\\n r += 1\\n elif K > 0:\\n r += 1\\n K -= 1\\n else:\\n break\\n if r - l + 1> max_count:\\n max_count = r - l\\n print(l,r,max_count)\\n if A[l] == 0:\\n K += 1\\n l += 1\\n\\n return max_count\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n hashMap = {}\\n windowStart = 0\\n m = 0\\n hashMap[1] = 0\\n for windowEnd in range(len(A)):\\n if A[windowEnd] not in hashMap:\\n hashMap[A[windowEnd]] = 0\\n hashMap[A[windowEnd]] += 1\\n \\n while sum(hashMap.values()) - hashMap[1] > K:\\n hashMap[A[windowStart]] -= 1\\n windowStart += 1\\n m = max(m, windowEnd - windowStart + 1)\\n return m\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left = 0\\n maxLen = 0\\n oneFreq = 0\\n maxFreq = 0\\n\\n for right in range(len(A)):\\n oneFreq += A[right]\\n maxFreq = max(maxFreq, oneFreq)\\n\\n if right - left + 1 - maxFreq > K:\\n oneFreq -= A[left]\\n left += 1\\n\\n maxLen = max(maxLen, right - left + 1)\\n\\n return maxLen\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i,j,n = 0,0,len(A)\\n \\n for x in A:\\n j+=1\\n if x==0:\\n K-=1\\n if K<0:\\n if A[i]==0:\\n K+=1\\n i+=1\\n return j-i\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n ans = 0\\n lo = 0\\n hi = 0\\n \\n d = collections.defaultdict(int)\\n while(hi<len(A)):\\n d[A[hi]]+=1\\n \\n while d[0]>K:\\n d[A[lo]]-=1\\n if d[A[lo]] == 0: del d[A[lo]]\\n lo+=1\\n ans = max(ans, hi-lo+1)\\n hi+=1\\n return ans\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n '''naive\\n \\n \\n sliding window\\n keep growing sliding window rhs as num of 0s in window is >k\\n when num 0s == k, slide lhs of window until k > num 0s again\\n keep track of largest sliding window'''\\n \\n \\n if not A:\\n return 0\\n \\n best_window_len = 0\\n p, q = 0, 0\\n \\n num_zeros = 0\\n\\n while q < len(A):\\n if A[q] == 0: num_zeros += 1\\n #print(p, q, q - p)\\n if num_zeros > K:\\n best_window_len = max(q - p, best_window_len)\\n #print(\\\\\\\"running best:\\\\\\\", best_window_len)\\n while num_zeros > K:\\n if A[p] == 0:\\n num_zeros -= 1\\n p += 1\\n q+=1\\n \\n best_window_len = max(q - p, best_window_len)\\n return best_window_len\\n \\n\",\n \"class Solution:\\n def longestOnes(self, arr: List[int], k: int) -> int:\\n hashmap=dict()\\n max_len=length=start_index=0\\n hashmap[0]=0\\n hashmap[1]=0\\n for i in arr:\\n hashmap[i]+=1\\n if hashmap[0]>k:\\n hashmap[arr[start_index]]-=1\\n start_index+=1\\n max_len=max(max_len,sum(hashmap.values()))\\n\\n return max_len\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n # c1 and c0 are the count of 1 and 0 between left and right\\n left,right=0,0\\n n,c1,c0=len(A),0,0\\n ans=0\\n while True:\\n if c0<=K:\\n # it is a legal interval\\n ans=max(ans, right-left)\\n # move right\\n if right<n:\\n right+=1\\n x=A[right-1]\\n if x: c1+=1\\n else: c0+=1\\n else: return ans\\n else:\\n # move left\\n x=A[left]\\n left+=1\\n if x: c1-=1\\n else: c0-=1\\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n count = 0\\n max_count = 0\\n\\n buf = K\\n l = r = 0\\n needs_buf = False\\n while l < len(A) and r < len(A):\\n if A[r] == 1:\\n count += 1\\n r += 1\\n elif A[r] == 0:\\n if buf:\\n buf -= 1\\n count += 1\\n r += 1\\n else:\\n needs_buf = True\\n \\n if needs_buf:\\n if A[l] == 0:\\n buf += 1\\n needs_buf = False\\n count -= 1\\n l += 1\\n\\n if count > max_count:\\n max_count = count\\n # print(A[l:r])\\n\\n # print(f'l: {l}, r: {r}')\\n return max_count\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n s,e,z,l = 0,0,0,0\\n ans = 0\\n while e<len(A):\\n if A[e] == 0:\\n z += 1\\n while z>K:\\n if A[s] == 0:\\n z -= 1\\n s += 1\\n l -= 1\\n l += 1\\n ans = max(ans, l)\\n e += 1\\n return ans\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n res = 0\\n zeros = 0\\n n = len(A)\\n i = 0\\n for j in range(n):\\n zeros += A[j] == 0\\n if zeros <= K:\\n res = max(res, j-i+1)\\n if zeros > K:\\n zeros -= A[i] == 0\\n i += 1\\n return res\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left = 0\\n # right = 0\\n zeros = 0\\n res = 0\\n \\n for right in range(len(A)):\\n \\n if A[right] == 0:\\n zeros += 1\\n \\n while zeros > K:\\n left += 1\\n if A[left-1] == 0:\\n zeros -= 1\\n \\n res = max(res, right - left + 1)\\n \\n # if res == 0:\\n # return 0\\n \\n return res\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i = 0\\n for j in range(len(A)):\\n K -= 1 - A[j]\\n if K < 0:\\n K += 1 - A[i]\\n i += 1\\n return j - i + 1\\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n start, end = 0,0\\n max_len = 0\\n numzeros = 0\\n while end < len(A):\\n if A[end] == 0:\\n numzeros += 1\\n while numzeros > K:\\n # shrink window\\n if A[start] == 0:\\n numzeros -= 1\\n start += 1\\n max_len = max(max_len, end-start+1)\\n end += 1\\n return max_len\\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n result = 0\\n zero_allowed = K\\n left = 0\\n \\n for right, x in enumerate(A):\\n if x==0:\\n zero_allowed -= 1\\n if zero_allowed>=0 and (right - left + 1) > result:\\n result = right - left + 1\\n \\n while zero_allowed < 0 and (right - left + 1) > result:\\n if A[left]==0:\\n zero_allowed += 1\\n left += 1\\n \\n return result\",\n \"class Solution:\\n def longestOnes(self, arr: List[int], k: int) -> int:\\n start, max_length = 0,0\\n count_0 = 0\\n\\n for end in range(len(arr)):\\n\\n if arr[end] == 0:\\n count_0 += 1\\n\\n while count_0 > k:\\n if arr[start] == 0:\\n count_0 -= 1\\n start += 1\\n max_length = max(max_length, end - start + 1)\\n return max_length\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n zeroes = []\\n count = 0\\n maxCount = 0\\n for i in range(len(A)):\\n if A[i] == 0:\\n zeroes.insert(0,i)\\n \\n if len(zeroes) > K:\\n count = i - zeroes.pop()\\n else:\\n count += 1\\n maxCount = max(maxCount, count)\\n return maxCount\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n curr_k = 0\\n pointer_start = 0\\n pointer_end = 0\\n max_ones = 0\\n curr_ones = 0\\n while pointer_end < len(A):\\n if A[pointer_end] == 0:\\n if curr_k >= K:\\n if A[pointer_start] == 0:\\n curr_k -= 1\\n pointer_start += 1\\n curr_ones -= 1\\n else:\\n pointer_end += 1\\n curr_ones += 1\\n curr_k += 1\\n else:\\n pointer_end += 1\\n curr_ones += 1\\n max_ones = max(curr_ones, max_ones)\\n return max_ones\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n ## intuition: probably use sliding windows\\n \\n l=0\\n r=0\\n val=0\\n if A[0]==0:\\n val=1\\n maxlength = 0\\n \\n \\n while r<len(A)-1:\\n while val<=K and r<len(A)-1:\\n if A[r+1]==0:\\n val+=1\\n r+=1\\n if r==len(A)-1 and val<=K:\\n maxlength = max(maxlength, r-l+1)\\n elif val>K:\\n ##this must mean that A[r]==0\\n maxlength = max(maxlength, r-l)\\n # print(l,r,maxlength, val)\\n while val>K:\\n if A[l]==0:\\n val-=1\\n l+=1\\n \\n return maxlength\\n \\n \\n \\n \\n\",\n \"import math\\nimport random\\nimport string\\nfrom functools import lru_cache\\nfrom operator import truediv\\nfrom typing import List\\nimport collections\\nimport functools\\nimport heapq\\nimport itertools\\nimport sys\\nfrom functools import lru_cache\\nfrom typing import List\\nimport numpy as np\\nimport collections\\nimport functools\\nimport heapq\\nimport itertools\\nimport sys\\nfrom functools import lru_cache\\nfrom typing import List\\n\\n'''\\n反转K个位置的0为1，问最长连续1的长度。\\n\\nInput: A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3\\nOutput: 10\\nExplanation: \\n[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]\\nBolded numbers were flipped from 0 to 1. The longest subarray is underlined.\\n\\n\\n思路：滑动窗口。\\n主要思想，开区间伸缩左右边界。闭区间不好处理初始情况。\\n\\n'''\\n\\n\\nclass Solution:\\n def longestOnes1(self, A: List[int], K: int) -> int:\\n # 开区间[start, end)\\n start = 0\\n end = 0\\n ret = 0\\n while end < len(A):\\n if A[end] == 1:\\n end += 1\\n else:\\n if K > 0:\\n end += 1\\n K -= 1\\n else:\\n if A[start] == 0:\\n K += 1\\n start += 1\\n ret = max(ret, end - start)\\n return ret\\n\\n def longestOnes(self, A, K):\\n i = 0\\n for j in range(len(A)):\\n K -= 1 - A[j]\\n if K < 0:\\n K += 1 - A[i]\\n i += 1\\n return j - i + 1\\n\\n# A = [0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1]\\n# K = 3\\n# \\n# r = Solution()\\n# a = r.longestOnes(A, K)\\n# print(a)\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n if not A:\\n return 0\\n \\n \\n ans = 0\\n count = [0, 0]\\n max_count = 0\\n l = 0\\n for r in range(len(A)):\\n # update the count\\n count[A[r]] += 1\\n max_count = max(max_count, count[1])\\n if r - l + 1 - max_count > K:\\n count[A[l]] -= 1\\n l += 1\\n else:\\n ans = max(ans, r - l + 1)\\n \\n return ans\\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n le = 0\\n for ri in range(len(A)):\\n K -= (1-A[ri]) # 如果A[ri]是0, k 要减去1\\n \\n print (le, ri)\\n if K < 0:\\n K += (1 - A[le])\\n le += 1\\n return ri - le + 1\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n n = len(A)\\n\\n res = 0\\n j, count0 = 0, 0\\n for i in range(n):\\n if not A[i]:\\n count0 += 1\\n if count0 > K:\\n res = max(res, i - j)\\n while A[j]:\\n j += 1\\n j += 1\\n count0 -= 1\\n \\n res = max(res, i - j + 1)\\n return res\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i = 0\\n j = 0\\n maxValue = 0\\n numZeros = 0\\n while j < len(A):\\n if not A[j]:\\n if numZeros < K:\\n numZeros += 1\\n j += 1\\n else:\\n maxValue = max(maxValue, j-i)\\n while i <= j and A[i]:\\n i += 1\\n i += 1\\n j += 1\\n else:\\n j += 1\\n maxValue = max(maxValue, j-i)\\n return maxValue\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n zeroes = []\\n count = 0\\n maxCount = 0\\n j = 0\\n for i in range(len(A)):\\n \\n if A[i] == 0:\\n zeroes.insert(0,i)\\n\\n if len(zeroes) > K:\\n count = i - zeroes.pop()\\n else:\\n count += 1\\n maxCount = max(maxCount, count)\\n return maxCount\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i,j=0,0\\n res=0\\n zeroes=K\\n count=[0]\\n while i<len(A):\\n if A[i]==0:\\n zeroes-=1\\n if zeroes<0:\\n if A[j]==0:\\n zeroes+=1\\n j+=1\\n i+=1\\n res=max(res,i-j)\\n return res\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left = 0\\n for right in range(len(A)):\\n K -= 1 - A[right]\\n if K < 0:\\n K += 1 - A[left]\\n left += 1\\n return right - left + 1\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n maxOnes = 0\\n start = 0\\n maxZeroes = 0\\n \\n for i in range(len(A)):\\n if A[i] == 0:\\n maxZeroes += 1\\n \\n while maxZeroes > K:\\n if A[start] == 0:\\n maxZeroes -= 1\\n \\n start += 1\\n \\n maxOnes = max(maxOnes,i-start + 1)\\n \\n return maxOnes\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n start = 0\\n ans = 0\\n nn = [0, 0]\\n \\n for i, a in enumerate(A):\\n nn[a] += 1\\n while nn[0] > K:\\n nn[A[start]] -= 1\\n start += 1\\n \\n ans = max(ans, nn[0] + nn[1])\\n return ans\",\n \"import bisect \\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n n = len(A)\\n zeros = 0\\n dp = [0]*n\\n ans = 0\\n\\n for i in range(n):\\n if A[i]==0:\\n zeros+=1\\n dp[i]=zeros\\n # print(dp)\\n for i in range(n):\\n val = dp[i]\\n if A[i]==1:\\n right = bisect.bisect_left(dp,val+K+1)\\n else:\\n right = bisect.bisect_left(dp,val+K)\\n # print(i,right)\\n delta = right-i\\n ans = max(ans,delta)\\n # print(i,ans,right)\\n return ans \",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n left = right = 0\\n \\n for right in range(len(A)):\\n if A[right] == 0:\\n K-=1\\n \\n if K < 0:\\n \\n if A[left] == 0:\\n K+=1\\n \\n left += 1\\n \\n return right-left + 1\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n queue = []\\n i = ans = 0\\n for j in range(len(A)):\\n if(A[j] != 1):\\n if(len(queue) == K):\\n try:\\n i = queue.pop(0)+1\\n except:\\n i=j+1\\n if(len(queue) < K):\\n queue.append(j)\\n ans = max(ans, j-i+1)\\n return ans\",\n \"from collections import deque\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n q=deque()\\n cnt=0\\n max_cnt=0\\n for i in range(len(A)):\\n if A[i]==0:\\n q.append(i)\\n if len(q)>K:\\n max_cnt=max(max_cnt,cnt)\\n cnt=i-q[0]\\n q.popleft()\\n else:\\n cnt+=1\\n else:\\n cnt+=1\\n max_cnt=max(max_cnt,cnt)\\n return max_cnt\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n l = 0\\n r = 0\\n m = len(A)\\n count = 0\\n max_count = 0\\n while r < m:\\n if A[r] == 1:\\n count += 1\\n while r - l + 1 - count > K:\\n if A[l] == 1:\\n count -= 1\\n l += 1\\n max_count = max(r-l+1, max_count)\\n r += 1\\n return max_count\\n\",\n \"class Solution:\\n def longestOnes(self, A, K):\\n if not A:\\n return 0\\n n = len(A)\\n right = 0\\n cnt = 0\\n res = 0\\n for left in range(n):\\n while right <= n - 1 and (cnt < K or A[right] == 1):\\n cnt += (A[right] == 0)\\n right += 1\\n res = max(res, right - left)\\n cnt -= (A[left] == 0)\\n return res\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n \\n pre_sum = [A[0]]\\n for i in range(1,len(A)):\\n pre_sum.append(pre_sum[-1]+A[i])\\n \\n def cal(l,r):\\n if (l == 0):\\n return pre_sum[r]\\n else:\\n return pre_sum[r] - pre_sum[l-1]\\n \\n l = 0\\n r = 0\\n ans = K\\n while (l<len(A)):\\n #print (l,r)\\n while (r<len(A) and (r-l+1)-cal(l,r)<=K ):\\n ans = max(ans,r-l+1)\\n r = r + 1\\n #print (r)\\n \\n if (r==len(A)):\\n break\\n \\n while ( l<len(A) and (r-l+1)-cal(l,r)>K ):\\n l = l + 1\\n #print (l)\\n \\n return ans\\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i=j=maxCount=maxlen=0\\n d={0:0,1:0}\\n while(i<len(A)):\\n d[A[i]]+=1\\n while(d[0]>K):\\n d[A[j]]-=1\\n j+=1\\n maxlen=max(maxlen,i-j+1)\\n i+=1\\n return maxlen\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n i, ans = 0, 0\\n for j, num in enumerate(A):\\n if num == 0:\\n K -= 1\\n while K < 0:\\n if A[i] == 0:\\n K += 1\\n i += 1\\n ans = max(ans, j-i+1)\\n return ans\\n \\n ans = 0\\n start, end = 0, 0\\n \\n while end < len(A):\\n if A[end] == 1:\\n ans = max(ans, end-start+1)\\n end+=1\\n else:\\n if K != 0:\\n ans = max(ans, end-start+1)\\n end+=1\\n K -= 1\\n else:\\n if A[start] == 0:\\n K+=1\\n start+=1\\n return ans\\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n le, ri = 0, 0\\n max_len = 0\\n while ri < len(A):\\n if A[ri] == 0:\\n K -= 1\\n ri += 1\\n if K >= 0:\\n max_len= max(max_len, ri - le)\\n print((le, ri))\\n while K < 0 and le < ri:\\n if A[le] == 0:\\n K += 1\\n le += 1\\n \\n return max_len\\n \\n\",\n \"class Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n left,right = 0,0\\n num_zeros = 0\\n window_size = 0\\n \\n while right < len(A):\\n if A[right] == 0:\\n num_zeros += 1\\n while num_zeros > K:\\n if A[left] == 0:\\n num_zeros -= 1\\n left += 1 \\n window_size = max(window_size,right-left+1)\\n right += 1\\n \\n return window_size \",\n \"import math\\nimport random\\nimport string\\nfrom functools import lru_cache\\nfrom operator import truediv\\nfrom typing import List\\nimport collections\\nimport functools\\nimport heapq\\nimport itertools\\nimport sys\\nfrom functools import lru_cache\\nfrom typing import List\\nimport numpy as np\\nimport collections\\nimport functools\\nimport heapq\\nimport itertools\\nimport sys\\nfrom functools import lru_cache\\nfrom typing import List\\n\\n'''\\n反转K个位置的0为1，问最长连续1的长度。\\n\\nInput: A = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], K = 3\\nOutput: 10\\nExplanation: \\n[0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]\\nBolded numbers were flipped from 0 to 1. The longest subarray is underlined.\\n\\n\\n思路：滑动窗口。\\n主要思想，开区间伸缩左右边界。闭区间不好处理初始情况。\\n\\n'''\\n\\n\\nclass Solution:\\n def longestOnes(self, A: List[int], K: int) -> int:\\n # 开区间[start, end)\\n start = 0\\n end = 0\\n ret = 0\\n while end < len(A):\\n if A[end] == 1:\\n end += 1\\n else:\\n if K > 0:\\n end += 1\\n K -= 1\\n else:\\n if A[start] == 0:\\n K += 1\\n start += 1\\n ret = max(ret, end - start)\\n return ret\\n\\n\\n# A = [0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1]\\n# K = 3\\n# \\n# r = Solution()\\n# a = r.longestOnes(A, K)\\n# print(a)\\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":137,"string":"137"},"non_interactive_idx":{"kind":"list like","value":[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,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32,\n 33,\n 34,\n 35,\n 36,\n 37,\n 38,\n 39,\n 40,\n 41,\n 42,\n 43,\n 44,\n 45,\n 46,\n 47,\n 48,\n 49,\n 50,\n 51,\n 52,\n 53,\n 54,\n 55,\n 56,\n 57,\n 58,\n 59,\n 60,\n 61,\n 62,\n 63,\n 64,\n 65,\n 66,\n 67,\n 68,\n 69,\n 70,\n 71,\n 72,\n 73,\n 74,\n 75,\n 76,\n 77,\n 78,\n 79,\n 80,\n 81,\n 82,\n 83,\n 84,\n 85,\n 86,\n 87,\n 88,\n 89,\n 90,\n 91,\n 92,\n 93,\n 94,\n 95,\n 96,\n 97,\n 98,\n 99,\n 100,\n 101,\n 102,\n 103,\n 104,\n 105,\n 106,\n 107,\n 108,\n 109,\n 110,\n 111,\n 112,\n 113,\n 114,\n 115,\n 116,\n 117,\n 118,\n 119,\n 120,\n 121,\n 122,\n 123,\n 124,\n 125,\n 126,\n 127,\n 128,\n 129,\n 130,\n 131,\n 132,\n 133,\n 134,\n 135,\n 136\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[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,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],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":92,"cells":{"problem_id":{"kind":"number","value":229,"string":"229"},"question":{"kind":"string","value":"Given an array of integers A with even length, return true if and only if it is possible to reorder it such that A[2 * i + 1] = 2 * A[2 * i] for every 0 <= i < len(A) / 2.\n\n\n\n\n\n\n\n\n \nExample 1:\nInput: A = [3,1,3,6]\nOutput: false\n\nExample 2:\nInput: A = [2,1,2,6]\nOutput: false\n\nExample 3:\nInput: A = [4,-2,2,-4]\nOutput: true\nExplanation: We can take two groups, [-2,-4] and [2,4] to form [-2,-4,2,4] or [2,4,-2,-4].\n\nExample 4:\nInput: A = [1,2,4,16,8,4]\nOutput: false\n\n \nConstraints:\n\n0 <= A.length <= 3 * 104\nA.length is even.\n-105 <= A[i] <= 105"},"solutions":{"kind":"string","value":"[\"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cache=Counter(A)\\n c_list=sorted(list(cache),key=abs)\\n for x in c_list:\\n if cache[x]>cache[2*x]:\\n return False\\n cache[2*x]-=cache[x]\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cache=collections.Counter(A)\\n c_list=sorted(list(cache),key=abs)\\n for x in c_list:\\n if cache[x]>cache[2*x]:\\n return False\\n cache[2*x]-=cache[x]\\n return True\", \"from collections import Counter\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if len(A) % 2 == 1: return False\\n if not A: return True\\n nums = sorted(set(A))\\n nums = [x for x in nums if x < 0][::-1] + [x for x in nums if x >= 0]\\n c = Counter(A)\\n done = set()\\n for num in nums:\\n if num in done:\\n continue\\n if 2*num not in c:\\n return False\\n if c[2*num] < c[num]:\\n return False\\n \\n c[2*num] -= c[num]\\n if c[2*num] == 0: \\n done.add(2*num)\\n \\n c[num] = 0\\n done.add(num)\\n \\n return True\", \"import collections\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n ''' Place all values into dicts and start counting from the bottom\\n '''\\n if not A:\\n return True\\n \\n pos = collections.defaultdict(int)\\n neg = collections.defaultdict(int)\\n zero = 0\\n \\n # O(n)\\n for v in A:\\n if v > 0:\\n pos[v] += 1\\n if v < 0:\\n neg[-v] += 1\\n if v == 0:\\n zero += 1\\n \\n b = self.check(pos)\\n if not b:\\n return False\\n b = self.check(neg)\\n if not b:\\n return False\\n \\n return zero % 2 == 0\\n \\n \\n def check(self, d):\\n \\n # worst case O(n), done n times\\n while d:\\n v = min(d) \\n if not 2 * v in d:\\n return False\\n if d[v] > d[2 * v]:\\n return False\\n\\n elif d[v] == d[2*v]:\\n del d[v]\\n del d[2*v]\\n else:\\n d[2*v] -= d[v]\\n del d[v]\\n return True\\n \\n \\n \\n \\n \\n\", \"\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n ''' Place all values into dicts and start counting from the bottom\\n '''\\n if not A:\\n return True\\n \\n pos = {}\\n neg = {}\\n zero = 0\\n \\n # O(n)\\n for v in A:\\n if v > 0:\\n pos[v] = pos.get(v, 0) + 1\\n if v < 0:\\n neg[-v] = neg.get(-v, 0) + 1\\n if v == 0:\\n zero += 1\\n \\n b = self.check(pos)\\n if not b:\\n return False\\n b = self.check(neg)\\n if not b:\\n return False\\n \\n return zero % 2 == 0\\n \\n \\n def check(self, d):\\n \\n # worst case O(n), done n times\\n while d:\\n v = min(d) \\n if not 2 * v in d:\\n return False\\n if d[v] > d[2 * v]:\\n return False\\n\\n elif d[v] == d[2*v]:\\n del d[v]\\n del d[2*v]\\n else:\\n d[2*v] -= d[v]\\n del d[v]\\n return True\\n \\n \\n \\n \\n \\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n i = 0\\n j = 0\\n A.sort()\\n while i < len(A) and A[i] <= 0:\\n if A[i] % 2 != 0:\\n return False\\n while j < len(A) and A[j] < 0 and 2 * A[j] < A[i]:\\n j += 1\\n if j >= len(A) or 2 * A[j] > A[i]:\\n return False\\n A[j] = None\\n j += 1\\n i += 1\\n while i < len(A) and A[i] is None:\\n i += 1\\n \\n while i < len(A):\\n while j < len(A) and A[j] < 2 * A[i]:\\n j += 1\\n if j >= len(A) or A[j] > 2 * A[i]:\\n return False\\n A[j] = None\\n j += 1\\n i += 1\\n while i < len(A) and A[i] is None:\\n i += 1\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = {}\\n zero_count = 0\\n for num in A:\\n if num == 0:\\n zero_count += 1\\n elif num in count:\\n count[num] += 1\\n else:\\n count[num] = 1\\n if zero_count % 2 != 0:\\n return False\\n \\n A.sort()\\n for num in A:\\n double = num * 2\\n if num in count and double in count:\\n count[double] -= 1\\n count[num] -= 1\\n if count[double] == 0:\\n count.pop(double)\\n if count[num] == 0:\\n count.pop(num)\\n \\n return count == {}\\n \\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if len(A) % 2 == 1:\\n return False\\n \\n count = collections.defaultdict(int)\\n for num in A:\\n count[num] += 1\\n A.sort()\\n for num in A:\\n if count[num] > 0:\\n # print(f\\\\\\\"checking {num}\\\\\\\")\\n double = num * 2\\n # print(half, double)\\n\\n if double in count and count[double] > 0:\\n # print(\\\\\\\"found\\\\\\\", double)\\n count[num] -= 1 \\n count[double] -= 1\\n # print(count)\\n # print(\\\\\\\"all good\\\\\\\")\\n # print(count) \\n for num in count:\\n if count[num] != 0:\\n return False\\n return True\\n \\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = collections.Counter(A)\\n\\n for x in sorted(A, key=abs):\\n if(count[x] == 0):\\n continue\\n if(count[2*x] == 0):\\n return False\\n count[x] -= 1\\n count[2*x] -= 1\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cache=dict()\\n for a in A:\\n cache[a]=cache.get(a,0)+1\\n while len(cache)>0:\\n temp=[abs(k) for k in cache.keys()]\\n curr=min(temp)\\n if curr==0:\\n if cache[0]%2>0:\\n return False\\n else:\\n cache.pop(0)\\n else:\\n if curr in cache:\\n if cache[curr]==0:\\n cache.pop(curr)\\n elif (2*curr not in cache) or cache[2*curr]<cache[curr]:\\n return False\\n else:\\n cache[2*curr]-=cache[curr]\\n cache.pop(curr)\\n if -curr in cache:\\n if cache[-curr]==0:\\n cache.pop(-curr)\\n elif (-2*curr not in cache) or cache[-2*curr]<cache[-curr]:\\n return False\\n else:\\n cache[-2*curr]-=cache[-curr]\\n cache.pop(-curr)\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n ''' Place all values into dicts and start counting from the bottom\\n '''\\n counter = collections.Counter(A)\\n \\n for v in sorted(counter, key = abs):\\n if counter[2 * v] < counter[v]:\\n return False\\n counter[2 * v] -= counter[v]\\n return True\\n \\n \\n \\n \\n \\n \\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n counts = defaultdict(int)\\n for x in sorted(A):\\n counts[x] += 1\\n if x < 0 and x * 2 in counts:\\n while counts[x] > 0 and counts[x * 2] > 0:\\n counts[x] -= 1\\n counts[x * 2] -= 1\\n if x >= 0 and x / 2 in counts:\\n while counts[x] > 0 and counts[x / 2] > 0:\\n counts[x] -= 1\\n counts[x / 2] -= 1\\n return sum(c for v, c in counts.items()) == 0\", \"import collections\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n ''' Place all values into dicts and start counting from the bottom\\n '''\\n if not A:\\n return True\\n \\n counter = collections.Counter(A)\\n \\n for v in sorted(counter, key = abs):\\n if counter[2 * v] < counter[v]:\\n return False\\n counter[2 * v] -= counter[v]\\n return True\\n \\n \\n \\n \\n \\n \\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n result = True\\n numLen = len(A)\\n C = Counter(A)\\n val = list(C.keys())\\n val.sort()\\n for i in range(len(val)):\\n if val[i] < 0:\\n if val[i] % 2 == 0:\\n if val[i]/2 in val and C[val[i]/2] >= C[val[i]]:\\n C[val[i] / 2] = C[val[i]/2] - C[val[i]]\\n C[val[i]] = 0\\n else:\\n result = False\\n # break\\n else:\\n if val[i] * 2 in val and C[val[i]*2] >= C[val[i]]:\\n C[val[i] * 2] = C[val[i]*2] - C[val[i]]\\n C[val[i]] = 0\\n else:\\n result = False\\n # Break\\n nums = list(C.values())\\n if nums == [0]*len(nums):\\n result = True\\n else:\\n result = False\\n return result\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n dd = Counter(A)\\n A.sort(key = lambda a : abs(a))\\n\\n for a in A:\\n if a in dd and dd[a]:\\n if 2*a in dd and dd[2*a]:\\n dd[a] -= 1\\n dd[2*a] -= 1\\n if dd[a] == 0:\\n del dd[a]\\n if dd[a*2] == 0:\\n del dd[a*2]\\n else:\\n return False\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n pos = [x for x in A if x >= 0]\\n neg = [x for x in A if x < 0]\\n for L in (pos,neg):\\n count = collections.Counter(L)\\n for x in sorted(L, key=abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort(key=lambda x: (x>0, abs(x)))\\n right = 1\\n size = len(A)\\n for i in range(size):\\n if A[i] is None:\\n continue\\n\\n while right < size and 2 * A[i] != A[right]:\\n right += 1\\n\\n if right == size:\\n return False\\n\\n A[right] = None\\n\\n return True\", \"class Solution:\\n def canReorderDoubled(self, arr):\\n arr.sort()\\n negl = [x for x in arr if x < 0][::-1]\\n posl = [x for x in arr if x >= 0]\\n cnt = {}\\n for x in arr:\\n if x not in cnt:\\n cnt[x] = 1\\n else:\\n cnt[x] = cnt[x] + 1\\n\\n while True :\\n x = None\\n if negl != [] :\\n x = negl.pop(0)\\n else:\\n if posl != [] :\\n x = posl.pop(0)\\n else:\\n break\\n if cnt[x] == 0 :\\n continue\\n y = x * 2\\n if y not in cnt:\\n return False\\n else:\\n if cnt[y] > 0 and cnt[x] > 0:\\n cnt[y] = cnt[y] - 1\\n cnt[x] = cnt[x] - 1\\n else:\\n return False\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n seen = {}\\n \\n A.sort()\\n for i in A:\\n #Logic for checking half and double of number\\n if i/2 in seen:\\n seen[i/2] -= 1\\n if seen[i/2] == 0:\\n del seen[i/2]\\n \\n elif 2*i in seen:\\n seen[2*i] -= 1\\n if seen[2*i] == 0:\\n del seen[2*i]\\n else:\\n if i in seen:\\n seen[i] += 1\\n else:\\n seen[i] = 1\\n \\n return not bool(seen)\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n counter=Counter(A)\\n for a in sorted(A, key=abs):\\n if counter[a]==0:\\n continue\\n if counter[2*a]==0:\\n return False\\n counter[a]-=1\\n counter[2*a]-=1\\n return True\\n\", \"import collections\\nclass Solution:\\n def canReorderDoubled(self, a: List[int]) -> bool:\\n count=collections.Counter(a)\\n for elem in sorted(a,key=abs):\\n if count[elem]==0:\\n continue\\n if count[2*elem]==0:\\n return False\\n count[elem]-=1\\n count[2*elem]-=1\\n return True\\n\", \"from collections import defaultdict\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if not A:\\n return True\\n \\n count = 0\\n d = defaultdict(int)\\n for i in A:\\n d[i] += 1\\n \\n for num in sorted(A):\\n if num*2 in d and d[num] and d[num*2]:\\n d[num] -= 1\\n d[num*2] -= 1\\n count += 1\\n \\n return count == (len(A) // 2)\\n\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n # Eliminate zero\\n negative = []\\n positive = []\\n \\n zero_numbers = 0\\n for a in A:\\n if a < 0:\\n negative.append(abs(a))\\n elif a > 0:\\n positive.append(a)\\n else:\\n zero_numbers += 1\\n \\n if zero_numbers % 2:\\n return False\\n \\n negative.sort()\\n positive.sort()\\n # print(negative, positive)\\n \\n return self.helper(negative) and self.helper(positive)\\n \\n def helper(self, nums): \\n while nums:\\n cur_num = nums[0]\\n idx = self.binarySearch(nums, 2 * cur_num)\\n # print('helper',nums[0], idx)\\n if idx == -1:\\n return False\\n nums.pop(idx)\\n nums.pop(0)\\n if len(nums) == 1:\\n return False\\n \\n return True\\n \\n def binarySearch(self, nums, key):\\n \\n head = 0\\n tail = len(nums) - 1\\n # print(nums, key)\\n \\n while head <= tail:\\n mid = (head + tail)//2\\n if nums[mid] > key:\\n tail = mid - 1\\n elif nums[mid] < key:\\n head = mid + 1\\n else:\\n return mid\\n \\n return -1\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = collections.Counter(A)\\n for a in sorted(count, key = lambda x: abs(x)):\\n if count[a] > count[2 * a]:\\n return False\\n count[2 * a] -= count[a]\\n return True\", \"import numpy as np\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n a = np.array(sorted(A))\\n non_pos_idxs = np.where(a >= 0)[0]\\n if len(non_pos_idxs) > 0:\\n non_pos_idx = non_pos_idxs[0]\\n else:\\n non_pos_idx = len(a)\\n b = a[:non_pos_idx][::-1]\\n a = a[non_pos_idx:]\\n if len(b) % 2 != 0:\\n return False\\n \\n if not self.check_doubled(a):\\n return False\\n if not self.check_doubled(b):\\n return False\\n return True\\n \\n def check_doubled(self, a):\\n if len(a) == 0:\\n return True\\n count_dict = {}\\n for val in a:\\n if count_dict.get(val, 0) > 0:\\n count_dict[val] -= 1\\n else:\\n count_dict[2 * val] = count_dict.get(2 * val, 0) + 1\\n for val in list(count_dict.values()):\\n if val > 0:\\n return False\\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n seen = {}\\n A.sort()\\n for ind,i in enumerate(A):\\n #Logic for checking half and double of number\\n if i/2 in seen:\\n seen[i/2] -= 1\\n if seen[i/2] == 0:\\n del seen[i/2]\\n \\n elif 2*i in seen:\\n seen[2*i] -= 1\\n if seen[2*i] == 0:\\n del seen[2*i]\\n else:\\n if i in seen:\\n seen[i] += 1\\n else:\\n seen[i] = 1\\n \\n print(seen)\\n \\n return not bool(seen)\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if not A:\\n return True\\n d=defaultdict(int)\\n for x in A:\\n d[x]+=1\\n n=len(A)//2\\n A.sort()\\n for x in A:\\n if d[x]>0:\\n if 2*x in d and d[2*x]>0:\\n d[2*x]-=1\\n d[x]-=1\\n n-=1\\n if n==0:\\n return True\\n #print(x,d,n)\\n return False\\n \\n \\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort()\\n d = collections.defaultdict(int)\\n for a in A:\\n if d[2*a] > 0:\\n d[2*a] -= 1\\n elif d[a/2] > 0:\\n d[a/2] -= 1\\n else:\\n d[a] += 1\\n return not any(d.values())\\n\", \"from collections import Counter\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n counts = [0]*(10**5+1)\\n for a in A:\\n if a >= 0:\\n counts[a] += 1\\n for i in range(10**5+1):\\n while counts[i] != 0:\\n counts[i] -= 1\\n if counts[i] < 0:\\n return False\\n counts[2*i] -= 1\\n if counts[2*i] < 0:\\n return False\\n if not all(n == 0 for n in counts):\\n return False\\n\\n for a in A:\\n if a < 0:\\n counts[-a] += 1\\n for i in range(10**5+1):\\n while counts[i] != 0:\\n counts[i] -= 1\\n if counts[i] < 0:\\n return False\\n counts[2*i] -= 1\\n if counts[2*i] < 0:\\n return False\\n if not all(n == 0 for n in counts):\\n return False\\n return True\", \"class Solution:\\n def canReorderDoubled(self, arr: List[int]) -> bool:\\n dicti=dict()\\n for var in arr:\\n if var in list(dicti.keys()):\\n dicti[var]+=1\\n else:\\n dicti[var]=1\\n arr.sort(key=lambda x: abs(x))\\n for var in arr:\\n if dicti[var]==0:\\n continue\\n if(2*var not in list(dicti.keys())):\\n return False\\n if dicti[2*var]<=0:\\n return False\\n dicti[var]-=1\\n dicti[2*var]-=1\\n return True\\n\\n\", \"class Solution:\\n def get_result(self, sl, d):\\n for k in sl:\\n if d[k]==0:\\n continue\\n if 2*k not in d:\\n return False\\n v = d[k]\\n v2 = d[2*k]\\n if v>v2:\\n return False\\n d[k] -= v\\n d[2*k] -= v\\n return True\\n \\n def canReorderDoubled(self, A: List[int]) -> bool:\\n d = dict()\\n num_zeros = 0\\n for a in A:\\n if a==0:\\n num_zeros += 1\\n continue\\n if a in d:\\n d[a] += 1\\n else:\\n d[a] = 1\\n neg = [k for k in list(d.keys()) if k<0]\\n pos = [k for k in list(d.keys()) if k>0]\\n if num_zeros%2!=0:\\n return False\\n sorted_pos = sorted(pos)\\n sorted_neg = sorted(neg, reverse=True)\\n res = self.get_result(sorted_pos, d)\\n if not res:\\n return False\\n res = self.get_result(sorted_neg, d)\\n if not res:\\n return False\\n return sum(list(d.values()))==0\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cnt = collections.Counter(A)\\n # It handles the case where there is odd number of 0, since the total number is even, there should be a number which cannot match because of the extra 0\\n for k in sorted(cnt, key=abs):\\n if cnt[k] > cnt[2*k]:\\n return False\\n \\n cnt[2*k] -= cnt[k]\\n \\n return True\", \"from collections import Counter\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n # Greedy\\n # Time complexity: O(NlogN)\\n # Space complexity: O(N)\\n # count = Counter(A)\\n # for x in sorted(A, key=abs):\\n # if count[x] == 0: continue\\n # if count[2 * x] == 0: return False\\n # count[x] -= 1\\n # count[2 * x] -= 1\\n # return True\\n\\n\\n count = Counter(A)\\n for x in sorted(count, key=abs):\\n if count[x] > count[2 * x]:\\n return False\\n count[2 * x] -= count[x]\\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = collections.Counter(A)\\n for i in sorted(count, key=abs):\\n count[2*i] -= count[i]\\n if count[2*i] < 0:\\n return False\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n freq = dict()\\n for i in A:\\n freq[i] = freq.get(i, 0) + 1\\n\\n for k in sorted(list(freq.keys()), key=lambda x: abs(x)):\\n if freq[k] == 0: continue\\n if freq[k] > freq.get(2*k, 0):\\n return False\\n freq[2*k] -= freq[k]\\n \\n return True\\n\", \"from collections import Counter\\n \\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if not A: return True\\n c = Counter(A)\\n keys = sorted(c.keys())\\n for k in keys:\\n if k == 0:\\n if c[k] % 2 == 0:\\n c[k] = 0\\n else:\\n return False\\n if k < 0 and c[k] > 0:\\n if k/2 in c:\\n c[k/2] -= c[k]\\n c[k] = 0\\n if k > 0 and c[k] > 0:\\n if k*2 in c:\\n c[k*2] -= c[k]\\n c[k] = 0\\n \\n return set(c.values()) == {0}\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cache=collections.Counter(A)\\n c_list=sorted(list(cache),key=lambda x: (abs(x),x))\\n for x in c_list:\\n if cache[x]>cache[2*x]:\\n return False\\n cache[2*x]-=cache[x]\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n d = collections.Counter(A)\\n if 0 in d:\\n if d[0] & 1 == 1:\\n return False\\n d.pop(0)\\n\\n keys = sorted(d.keys())\\n for i in keys:\\n if i in d:\\n if i < 0:\\n if i / 2 not in d:\\n return False\\n if d[i] > d[i/2]:\\n return False\\n d[i/2] -= d[i]\\n if d[i/2] == 0:\\n d.pop(i/2)\\n d.pop(i)\\n else:\\n if i * 2 not in d:\\n return False\\n if d[i] > d[i*2]:\\n return False\\n d[i*2] -= d[i]\\n if d[i*2] == 0:\\n d.pop(i*2)\\n d.pop(i)\\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort()\\n B = OrderedDict()\\n for x in A:\\n if x in B:\\n B[x] += 1\\n else:\\n B[x] = 1\\n \\n while B:\\n x = next(iter(B))\\n freq = B.pop(x)\\n \\n #print(x,freq)\\n \\n if x<0:\\n if x%2:\\n return False\\n if (x//2 not in B) or B[x//2]<freq:\\n return False\\n B[x//2] -= freq\\n if B[x//2] == 0:\\n B.pop(x//2)\\n \\n elif x==0:\\n if freq%2:\\n return False\\n \\n else:\\n if (x*2 not in B) or B[x*2]<freq:\\n return False\\n B[x*2] -= freq\\n if B[x*2] == 0:\\n B.pop(x*2)\\n \\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n c = collections.Counter(A)\\n cc = sorted(c, key=abs)\\n #print(cc)\\n for x in cc:\\n #print(str(x), end=\\\\\\\": \\\\\\\")\\n #print(c)\\n if c[x] > c[2 * x]:\\n return False\\n c[2 * x] -= c[x]\\n #print(c)\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n neg = dict()\\n pos = dict()\\n zero = 0\\n for n in A:\\n if n < 0:\\n if -n not in neg:\\n neg[-n] = 0\\n neg[-n] += 1\\n elif n >0:\\n if n not in pos:\\n pos[n] = 0\\n pos[n] += 1\\n else:\\n zero += 1\\n if zero % 2 != 0:\\n return False\\n #print(pos,neg)\\n def helper(nums):\\n num_sorted = sorted(list(nums.keys()),reverse = True)\\n while num_sorted:\\n a = num_sorted.pop()\\n if nums[a] == 0:\\n continue\\n if 2*a not in nums or nums[a]>nums[2*a]:\\n return False\\n nums[2*a] -= nums[a]\\n return True\\n return helper(pos) and helper(neg)\\n \\n\", \"from collections import defaultdict\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort()\\n s = defaultdict(int)\\n for a in A:\\n if a <= 0:\\n if 2 * a in s:\\n s[2*a] -= 1\\n if not s[2*a]:\\n del s[2*a]\\n else:\\n s[a] += 1\\n else:\\n if a % 2 == 0 and a // 2 in s:\\n s[a // 2] -= 1\\n if not s[a // 2]:\\n del s[a // 2]\\n else:\\n s[a] += 1\\n return not s\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n hashtable = {}\\n zero_count = 0\\n for i in range(len(A)):\\n if A[i]==0:\\n zero_count+=1\\n continue\\n if A[i] in list(hashtable.keys()):\\n hashtable[A[i]]+=1\\n \\n else:\\n hashtable[A[i]]=1\\n \\n \\n if zero_count%2==1:\\n return False\\n else:\\n key_list = []\\n pair_count = 0\\n for key in list(hashtable.keys()):\\n key_list.append(key)\\n \\n key_list.sort()\\n \\n for key in key_list:\\n if key%2==0 and key//2 in list(hashtable.keys()):\\n m = min(hashtable[key],hashtable[key//2])\\n hashtable[key]-=m\\n hashtable[key//2]-=m\\n pair_count+=m\\n \\n if pair_count*2 + zero_count==len(A):\\n return True\\n else:\\n return False\\n \\n \\n\", \"from collections import Counter\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n # O(NlogN) time \\n # O(N) space\\n \\n if not A:\\n return True\\n \\n counts = Counter(A) \\n \\n for key in sorted(counts.keys()):\\n if counts[key] == 0:\\n continue\\n \\n factor = .5 if key < 0 else 2\\n if counts[key] > counts[factor*key]:\\n return False\\n counts[factor*key] -= counts[key]\\n \\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort(key=lambda x: abs(x))\\n freq = dict()\\n\\n for i in A:\\n freq[i] = freq.get(i, 0) + 1\\n\\n for k in sorted(list(freq.keys()), key=lambda x: abs(x)):\\n if freq[k] == 0: continue\\n if freq[k] > freq.get(2*k, 0):\\n return False\\n freq[2*k] -= freq[k]\\n \\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n D = {}\\n for x in A:\\n D[x] = D.get(x, 0) + 1\\n \\n D = dict([x for x in sorted(list(D.items()), key =lambda x:x[0] )])\\n \\n for x in D:\\n while D[x] > 0:\\n D[x] -= 1\\n if x <= 0:\\n pair_x = x / 2\\n else:\\n pair_x = x * 2\\n \\n if D.get(pair_x, 0) > 0:\\n D[pair_x] -= 1\\n else:\\n return False\\n \\n return True\\n \\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cnt = collections.Counter(A)\\n for k in sorted(cnt, key=abs):\\n a = cnt[k]\\n if cnt[k] == 0:\\n continue\\n b = cnt.get(2 * k, 0)\\n if b < a:\\n return False\\n cnt[2 * k] -= a\\n \\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n def update_map(count, small, large):\\n small_count = count[small]\\n large_count = count[large]\\n min_count = min(small_count, large_count)\\n \\n count[small] += -min_count\\n if small != large:\\n count[large] += -min_count\\n \\n if not A:\\n return True\\n element_count = {}\\n ordered_elements = list(set(A))\\n ordered_elements.sort()\\n \\n for number in A:\\n if number not in element_count:\\n element_count[number] = 0\\n element_count[number] += 1\\n \\n for number in ordered_elements:\\n number_count = element_count[number]\\n double_number = number * 2\\n if double_number in element_count:\\n update_map(element_count, number, double_number)\\n \\n for number in element_count:\\n if element_count[number] != 0:\\n return False\\n return True\\n \\n \\n\", \"from collections import Counter\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n c=Counter(A)\\n A=sorted(A)\\n for num,v in sorted(list(c.items()), key= lambda item:item[0]):\\n if num>0 and c[num]>0:\\n if c[num]!=0 and c[num]>c[2*num]:\\n return False\\n c[2*num]-=c[num]\\n c[num]=0\\n elif num<0 and c[num]>0:\\n if num%2==1:\\n return False\\n if c[num]!=0 and c[num]>c[num//2]:\\n return False\\n c[num//2]-=c[num]\\n c[num]=0\\n return True\\n \\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if not A:\\n return True\\n positive_heap = []\\n negative_heap = []\\n zero = 0\\n positive_d = defaultdict(int)\\n negative_d = defaultdict(int)\\n for i in A:\\n if i == 0:\\n zero += 1\\n elif i < 0:\\n heappush(negative_heap, -i)\\n negative_d[-i] += 1\\n else:\\n heappush(positive_heap, i)\\n positive_d[i] += 1\\n if zero % 2 != 0:\\n return False\\n if not self.check(positive_heap, positive_d):\\n return False\\n if not self.check(negative_heap, negative_d):\\n return False\\n return True\\n \\n def check(self, h, d):\\n for _ in range(len(h)):\\n i = heappop(h)\\n if d[i] == 0:\\n continue\\n if 2*i not in d:\\n return False\\n elif d[2*i] < d[i]:\\n return False\\n else:\\n d[2*i] -= d[i]\\n d[i] = 0\\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n zcount = 0\\n pos = []\\n neg = []\\n for n in A:\\n if n==0:\\n zcount+=1\\n elif n>0:\\n pos.append(n)\\n else:\\n neg.append(-n)\\n def verifypos(A):\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\\n return verifypos(pos) and verifypos(neg)\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = collections.Counter(A)\\n for x in sorted(A, key=abs):\\n if count[x] == 0:\\n continue\\n if x == 0 and x % 2:\\n return False\\n if count[x] > count[2 * x]:\\n return False\\n count[x], count[2 * x] = 0, count[2 * x] - count[x]\\n \\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n D = {}\\n for x in A:\\n D[x] = D.get(x, 0) + 1\\n D = dict([kv for kv in sorted(list(D.items()), key =lambda x:x[0] )])\\n \\n for x in D:\\n while D[x] > 0:\\n D[x] -= 1\\n if x <= 0:\\n pair_x = x / 2\\n else:\\n pair_x = x * 2\\n \\n if D.get(pair_x, 0) > 0:\\n D[pair_x] -= 1\\n else:\\n return False\\n \\n return True\\n \\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort()\\n dic = {}\\n for i in A:\\n if i % 2 == 0 and i/2 in dic:\\n i = i / 2\\n dic[i] -= 1\\n if dic[i] == 0:\\n del dic[i]\\n elif i * 2 in dic:\\n i = i * 2\\n dic[i] -= 1\\n if dic[i] == 0:\\n del dic[i]\\n else:\\n dic[i] = dic.setdefault(i, 0) + 1\\n continue\\n return len(dic) == 0\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n # https://blog.csdn.net/fuxuemingzhu/article/details/84925747\\n A.sort()\\n N = len(A)\\n count = collections.Counter(A)\\n for i in range(N):\\n if A[i] == 0 or A[i] not in count: continue\\n elif A[i] < 0:\\n if A[i] % 2 == 1 or count[A[i] / 2] == 0:\\n return False\\n else:\\n count[A[i] / 2] -= count[A[i]]\\n if count[A[i] / 2] == 0:\\n del count[A[i] / 2]\\n del count[A[i]]\\n else:\\n if count[A[i] * 2] == 0:\\n return False\\n else:\\n count[A[i] * 2] -= count[A[i]]\\n if count[A[i] * 2] == 0:\\n del count[A[i] * 2]\\n del count[A[i]]\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n c = collections.Counter(A)\\n for x in sorted(c):\\n if c[x] == 0: continue\\n\\n if c[x] < 0:\\n return False\\n if x == 0:\\n if c[x] % 2 != 0:\\n return False\\n else:\\n continue\\n if x > 0:\\n temp = 2*x\\n elif x % 2:\\n return False\\n else:\\n \\n temp = x//2\\n\\n\\n if c[temp] < c[x]:\\n return False\\n else:\\n c[temp] -= c[x]\\n\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n pos_set = set()\\n neg_set = set()\\n pos_dict = {}\\n neg_dict = {}\\n pos_count = 0\\n for num in A:\\n if num >= 0:\\n pos_set.add(num)\\n pos_dict[num] = 1 + pos_dict.get(num,0)\\n pos_count += 1\\n else:\\n neg_set.add(abs(num))\\n neg_dict[abs(num)] = 1 + neg_dict.get(abs(num),0)\\n if pos_count % 2 != 0:\\n return False\\n else:\\n return self.helper(pos_set,pos_dict) and self.helper(neg_set,neg_dict)\\n \\n def helper(self,set_,dict_):\\n sorted_ = sorted(list(set_))\\n for num in sorted_:\\n if num * 2 in sorted_ and num != 0:\\n small_ = dict_[num] \\n large_ = dict_[num * 2]\\n usage = min(small_,large_)\\n dict_[num] -= usage\\n dict_[num * 2] -= usage\\n elif num == 0:\\n if dict_[0] % 2 != 0:\\n return False\\n else:\\n dict_[0] = 0\\n \\n for key in dict_:\\n if dict_[key] != 0:\\n return False\\n return True\\n \\n\", \"from collections import Counter\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if not A: return True\\n C = Counter(A)\\n K = sorted(C.keys())\\n for k in K:\\n if k == 0:\\n if C[k] & 1:\\n return False\\n else:\\n C[k] = 0\\n if k < 0 and C[k] > 0:\\n if k % 2 == 0 and (k // 2 in C):\\n C[k//2] -= C[k]\\n C[k] = 0\\n if k > 0 and C[k] > 0:\\n if k * 2 in C:\\n C[k*2] -= C[k]\\n C[k] = 0\\n return set(C.values()) == {0}\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n c = Counter(A)\\n for n in sorted(list(c.keys()), key=abs):\\n while c[n] > 0 and c[(double := 2 * n)] > 0:\\n c[n] -= 1\\n c[double] -= 1\\n return all(not v for v in list(c.values()))\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n def factorize(num):\\n power = 0\\n while num % 2 == 0:\\n num, power = num//2, power+1\\n return (num, power)\\n \\n counts = defaultdict(lambda : [0]*17)\\n zeros = 0\\n for a in A:\\n if a == 0:\\n zeros += 1\\n else:\\n n, p = factorize(a)\\n counts[n][p] += 1\\n \\n if zeros % 2 == 1:\\n return False\\n \\n \\n for key in counts:\\n carry = 0\\n for p in counts[key]:\\n carry = p - carry\\n if carry < 0: return False\\n if carry != 0: return False\\n \\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n # https://www.cnblogs.com/seyjs/p/10092569.html\\n A.sort()\\n dic = {}\\n for i in A:\\n if i % 2 == 0 and i/2 in dic:\\n i = i / 2\\n dic[i] -= 1\\n if dic[i] == 0:\\n del dic[i]\\n elif i * 2 in dic:\\n i = i * 2\\n dic[i] -= 1\\n if dic[i] == 0:\\n del dic[i]\\n else:\\n dic[i] = dic.setdefault(i, 0) + 1\\n continue\\n return len(dic) == 0\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort(key=lambda x: abs(x))\\n c={}\\n for v in A:\\n if v/2 in c:\\n c[v/2]-=1\\n if not c[v/2]:\\n del c[v/2]\\n else:\\n if v not in c: c[v]=0\\n c[v]+=1\\n return len(c)==0\", \"import collections\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n neg = collections.Counter()\\n pos = collections.Counter()\\n for n in A:\\n if n >= 0:\\n pos[n] += 1\\n else:\\n neg[n] += 1\\n \\n for n in sorted(neg, reverse = True):\\n if neg[n*2] < neg[n]:\\n return False\\n neg[n*2] -= neg[n]\\n del neg[n]\\n if neg[n*2] == 0:\\n del neg[n*2]\\n if len(neg) != 0:\\n return False\\n for n in sorted(pos):\\n if pos[n*2] < pos[n]:\\n return False\\n pos[n*2] -= pos[n]\\n del pos[n]\\n if pos[n*2] == 0:\\n del pos[n*2]\\n if len(pos) != 0:\\n return False\\n return True\\n \\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort()\\n freq = dict()\\n for i in A:\\n freq[i] = freq.get(i, 0) + 1\\n for i in A:\\n if freq.get(i, 0) == 0: continue\\n\\n if i < 0:\\n if i % 2 != 0:\\n return False\\n elif not freq.get(i // 2, 0) > 0:\\n return False\\n elif i > 0 and not freq.get(i * 2, 0) > 0:\\n return False\\n \\n if i < 0:\\n freq[i // 2] -= 1\\n else:\\n freq[i*2] -=1\\n freq[i] -= 1\\n \\n return True\\n\", \"from collections import Counter\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n negs = [a for a in A if a < 0]\\n pos = [a for a in A if a > 0]\\n zeros = [a for a in A if a == 0]\\n \\n if any(map(lambda x: len(x) % 2 != 0, [negs, pos, zeros])):\\n return False\\n \\n if not self.is_valid(negs, True) or not self.is_valid(pos, False):\\n return False\\n return True\\n \\n \\n def is_valid(self, A, neg=False):\\n A = sorted(A)\\n N = len(A)\\n \\n if neg:\\n A = A[::-1]\\n\\n c = Counter(A)\\n for a in A:\\n if c[a] == 0:\\n continue\\n target = a * 2\\n if c[target] == 0:\\n return False\\n c[a] -= 1\\n c[target] -= 1\\n return True\", \"from collections import defaultdict\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n A.sort()\\n \\n arr = defaultdict(int)\\n \\n for item in A:\\n \\n if 2*item in arr and arr[2*item] > 0:\\n arr[2*item] -= 1\\n elif item % 2 == 0 and (item // 2) in arr and arr[item // 2] > 0:\\n arr[item // 2] -= 1\\n else:\\n arr[item] += 1\\n \\n \\n return sum([x for x in arr.values() if x != 0]) == 0\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x]==0: continue # x may be end of a pair\\n if count[2*x]==0: \\n return False # x exsist, we have to match it with a 2x\\n count[2*x] -= 1\\n count[x] -= 1\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cache=Counter(A)\\n c_list=sorted(list(cache),key=abs)\\n for x in c_list:\\n if cache[x]>cache[2*x]:\\n return False\\n cache[2*x]-=cache[x]\\n return True\\n \\n '''\\n if not A:\\n return True\\n positive_heap = []\\n negative_heap = []\\n zero = 0\\n positive_d = defaultdict(int)\\n negative_d = defaultdict(int)\\n for i in A:\\n if i == 0:\\n zero += 1\\n elif i < 0:\\n heappush(negative_heap, -i)\\n negative_d[-i] += 1\\n else:\\n heappush(positive_heap, i)\\n positive_d[i] += 1\\n if zero % 2 != 0:\\n return False\\n if not self.check(positive_heap, positive_d):\\n return False\\n if not self.check(negative_heap, negative_d):\\n return False\\n return True\\n \\n def check(self, h, d):\\n for _ in range(len(h)):\\n i = heappop(h)\\n if d[i] == 0:\\n continue\\n if 2*i not in d:\\n return False\\n elif d[2*i] < d[i]:\\n return False\\n else:\\n d[2*i] -= d[i]\\n d[i] = 0\\n return True\\n '''\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n table = collections.defaultdict(int)\\n for num in A:\\n table[num] += 1\\n A.sort()\\n for num in A:\\n if table[num] == 0:\\n continue\\n pair = num * 2\\n if num < 0:\\n pair = num / 2\\n if table[pair] < 1:\\n return False\\n table[num] -= 1\\n table[pair] -= 1\\n return True\\n \\n \\n \\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count=collections.Counter(A)\\n for x in sorted(A,key=abs):\\n if count[x]==0:\\n continue\\n if count[2*x]==0:\\n return False\\n count[x]-=1\\n count[2*x]-=1\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n \\n ## Time Complexity: O(N LOG N) , Space: O(N)\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n # Array of Doubled Pairs 9/24 8/31/20\\n # 1:43 9/1/2020\\n# c = collections.Counter(A)\\n# for x in sorted(c, key=abs):\\n# if c[x] > c[x * 2]:\\n# return False\\n# c[x*2] -= c[x]\\n \\n# return True\\n \\n\\n \\n A = [abs(num) for num in A ]\\n A.sort()\\n dic = collections.defaultdict(collections.deque)\\n for i, num in enumerate(A):\\n dic[num].append(i)\\n \\n visited = [0]*len(A)\\n cnt = 0\\n i = 0\\n # while cnt < len(A) // 2 :\\n while i < len(A):\\n if visited[i]:\\n i += 1\\n continue\\n val, val_double = A[i], 2 * A[i]\\n if val_double in dic and dic[val_double]:\\n if val not in dic or not dic[val]:\\n return False\\n dic[val].popleft()\\n if not dic[val_double]:\\n return False\\n index = dic[val_double].popleft()\\n visited[index] = 1\\n \\n else:\\n return False\\n i += 1\\n # cnt += 1\\n \\n return True\\n \\n# A = [abs(num) for num in A ]\\n# A.sort()\\n# dic = collections.defaultdict(int)\\n# for num in A:\\n# dic[num] += 1\\n \\n# visited = [0]*len(A)\\n# cnt = 0\\n# i = 0\\n# while cnt < len(A) // 2 :\\n# if visited[i]:\\n# i += 1\\n# continue\\n# val_small = A[i]\\n# if 2*val_small in dic:\\n# dic[2*val_small] -= 1\\n# dic[val_small] -= 1\\n# if dic[2*val_small] < 0 or dic[val_small] < 0:\\n# return False\\n# search_index = A.index(2*val_small, i+1)\\n# while visited[search_index]:\\n# search_index = A.index(2*val_small, search_index+1)\\n# visited[search_index] = 1\\n# else:\\n# return False\\n# i += 1\\n# cnt += 1\\n \\n# return True\\n \\n\\n \\n \\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n counts = collections.Counter(A)\\n count = 0\\n A.sort()\\n for num in A: #range(0,len(A)//2):\\n #num = A[i] \\n if counts[num] and counts[num * 2]:\\n counts[num*2]-=1\\n counts[num]-=1\\n count+=1\\n return count*2 == len(A) \", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n counter = collections.Counter(A)\\n for e in sorted(A, key=abs):\\n if 2*e in counter and counter[2*e] > 0 and counter[e] > 0: \\n counter[e] -= 1\\n counter[2*e] -= 1\\n print(counter)\\n return sum(counter.values()) == 0\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort()\\n seen = Counter()\\n for num in A:\\n if num>0 and num%2:\\n seen[num]+=1\\n continue\\n elem = 2*num if num<0 else num//2\\n if seen[elem]>0:\\n seen[elem]-=1\\n else:\\n seen[num]+=1\\n\\n if sum(seen.values()):\\n return False\\n return True\", \"from collections import Counter\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n # if len(A)%2==1:\\n # return False\\n # counter = Counter(A)\\n # # print(counter)\\n # Skey = set(counter.keys())\\n # key = counter.keys()\\n # for i in key:\\n # if 2*i in Skey:\\n # counter[i]=0\\n # counter[i*2]-=counter[i]\\n # val = list(counter.values())\\n # print(val)\\n # for i in val:\\n # if i !=0:\\n # return False\\n # return True\\n \\n cnt = collections.Counter(A)\\n for a in sorted(A, key = abs):\\n if cnt[a] and cnt[a * 2]:\\n cnt[a] -= 1\\n cnt[a * 2] -= 1 \\n return all(cnt[a] == 0 for a in A)\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cache=collections.Counter(A)\\n c_list=sorted(cache, key=lambda x: abs(x))\\n print(cache, c_list)\\n for x in c_list:\\n if cache[x]>cache[2*x]:\\n return False\\n cache[2*x]-=cache[x]\\n return True\", \"import numpy as np\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort()\\n statdict = {}\\n flag = True\\n# print(A)\\n for i in A:\\n# print(statdict)\\n if i in statdict:\\n statdict[i] = statdict[i] + 1\\n elif i < 0:\\n if i*2 in statdict:\\n statdict[i*2] = statdict[i*2] - 1\\n if statdict[i*2] == 0:\\n statdict.pop(i*2)\\n else:\\n statdict[i] = 1\\n else:\\n if (i%2 == 0) and i/2 in statdict:\\n statdict[int(i/2)] = statdict[int(i/2)] - 1\\n if statdict[int(i/2)] == 0:\\n statdict.pop(int(i/2))\\n else:\\n statdict[i] = 1\\n return (len(statdict) == 0) or (len(statdict) == 1 and 0 in statdict and statdict[0] % 2 == 0)\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n c = collections.Counter(A)\\n \\n for i in sorted(A, key=abs):\\n if c[i] and c[i*2]:\\n c[i] -= 1\\n c[i*2] -= 1\\n \\n return all(c[i] == 0 for i in A)\\n \\n \\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n B = []\\n for x in A:\\n if x>0:\\n B.append(x)\\n else:\\n B.append(-x)\\n count = collections.Counter(B)\\n for x in sorted(B):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n else:\\n count[x] -=1\\n count[2*x] -=1\\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n D1 = collections.Counter()\\n D2 = collections.Counter()\\n zero = 0\\n \\n for a in A:\\n if a < 0:\\n D1[a] += 1\\n else:\\n D2[a] += 1\\n \\n for d in sorted(D1, reverse=1):\\n if D1[d]:\\n if D1[ d*2 ] < D1[d]:\\n return False\\n D1[ d*2 ] -= D1[d]\\n\\n for d in sorted(D2):\\n if D2[d]:\\n if D2[ d*2 ] < D2[d]:\\n return False\\n D2[ d*2 ] -= D2[d]\\n \\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n n = len(A)\\n #A[2*i+1] = 2*A[2*i]\\n #[-2,-4,2,4]\\n #A[1] == 2*A[0]\\n #A[3] == 2*A[2]\\n neg = sorted(list([x for x in A if x<0]))\\n pos = sorted(list([x for x in A if x>0]), reverse=True)\\n nl, pl = len(neg), len(pos)\\n if nl % 2 or pl % 2: return False\\n d1 = collections.Counter(neg)\\n cnt = 0\\n for i in range(nl):\\n if d1[2*neg[i]] > 0:\\n d1[2*neg[i]] -= 1\\n d1[neg[i]] -= 1\\n cnt += 1\\n if cnt < nl // 2: return False \\n d2 = collections.Counter(pos)\\n cnt = 0\\n for i in range(pl): \\n if d2[2*pos[i]] > 0:\\n print((pos[i]*2, pos[i]))\\n d2[2*pos[i]] -= 1\\n d2[pos[i]] -= 1\\n cnt += 1\\n if cnt < pl // 2: return False \\n return True \\n\", \"class Solution(object):\\n def canReorderDoubled(self, A):\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\", \"from collections import Counter\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort()\\n d=Counter()\\n c=[]\\n e=[]\\n for i in A:\\n if(i<0):\\n c.append(i)\\n elif(i>=0):\\n e.append(i)\\n c.sort(reverse=True)\\n c.extend(e)\\n A=c\\n print(A)\\n for i in A:\\n d[i]+=1\\n if(d[0]%2!=0):\\n return False\\n d[0]=0\\n for i in A:\\n if(2*i in d)and(d[i]<=d[2*i]):\\n d[2*i]-=d[i]\\n d[i]=0\\n elif(d[i]==0):\\n continue\\n else:\\n return False\\n return True\\n \\n \\n \\n \\n\", \"from collections import Counter\\nfrom typing import List\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n d = dict()\\n num_zeros = 0\\n for x in A:\\n if x == 0:\\n num_zeros += 1\\n continue\\n x = abs(x)\\n y = x\\n while y % 2 == 0:\\n y //= 2\\n if y in d:\\n d[y].update([x])\\n else:\\n d[y] = Counter([x])\\n \\n if num_zeros % 2:\\n return False\\n\\n for base, counter in d.items():\\n keys = sorted(counter)\\n for key in keys:\\n if counter[key] <= counter[2 * key]:\\n counter[2 * key] -= counter[key]\\n counter[key] -= counter[key]\\n else:\\n return False\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n c=collections.Counter(A)\\n \\n for x in sorted(A,key=abs):\\n if c[x]==0:\\n continue\\n if c[2*x]==0:\\n return False\\n c[x]-=1\\n c[2*x]-=1\\n return True\\n\", \"# 20201007 12:08 \\u9009\\u53c2\\u8003\\u7b54\\u6848\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cache=Counter(A)\\n c_list=sorted(list(cache),key=abs)\\n for x in c_list:\\n if cache[x]>cache[2*x]:\\n return False\\n cache[2*x]-=cache[x]\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n counter=collections.Counter(A)\\n counter=dict(sorted(counter.items(),key=lambda x:abs(x[0])))\\n nums=[]\\n for num in counter.keys():\\n for _ in range(counter[num]):\\n nums.append(num)\\n for num in nums:\\n if counter[num]:\\n if 2*num in counter and counter[2*num]!=0:\\n counter[num]-=1\\n counter[num*2]-=1\\n else:\\n return False\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if len(A) == 0 :\\n return True\\n \\n mydict = {}\\n for _ in range(0,len(A)):\\n if A[_] in mydict:\\n mydict[A[_]] += 1\\n else:\\n mydict[A[_]] = 1\\n \\n A_sorted = sorted(A)\\n \\n #print(A_sorted)\\n #print(mydict)\\n not_valid = set()\\n for num in A_sorted:\\n if len(mydict) == 0:\\n return True \\n if num in not_valid:\\n continue\\n \\n if (2 * num) in mydict and num in mydict:\\n double = 2*num\\n mydict[num] -= 1\\n mydict[double] -= 1\\n\\n if mydict[num] == 0:\\n mydict.pop(num)\\n not_valid.add(num)\\n #deals with duplicates\\n if num == double:\\n continue\\n elif mydict[2*num] == 0:\\n mydict.pop(2*num)\\n not_valid.add(2*num)\\n elif (num/2 in mydict and num in mydict):\\n half = num/2\\n mydict[num] -= 1\\n mydict[num/2] -= 1\\n\\n if mydict[num] == 0:\\n mydict.pop(num)\\n not_valid.add(num)\\n if mydict[num/2] == 0:\\n mydict.pop(num/2)\\n not_valid.add(num/2)\\n else:\\n return False\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n # Divide an conquer\\n # Sort items according to their magnitude\\n # For each item, make sure it's double exists later in the list\\n # When a double is used, mark it with a mask\\n \\n used = [False]*len(A)\\n A.sort(key = lambda n: abs(n))\\n bank = collections.Counter(A)\\n \\n for num in A:\\n \\n if bank[num] == 0:\\n continue\\n \\n bank[num] -= 1\\n if bank.get(2*num, 0) == 0:\\n return False\\n bank[2*num] -= 1\\n \\n return True\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n\", \"from collections import Counter\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n # Greedy\\n # Time complexity: O(NlogN)\\n # Space complexity: O(N)\\n count = Counter(A)\\n for x in sorted(A, key=abs):\\n if count[x] == 0: continue\\n if count[2 * x] == 0: return False\\n count[x] -= 1\\n count[2 * x] -= 1\\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A_sorted = sorted(A, key=abs)\\n count = collections.Counter(A)\\n for a in A_sorted:\\n if count[a] == 0: \\n continue\\n if count[a * 2] == 0:\\n return False\\n count[a] -= 1\\n count[a * 2] -= 1\\n \\n return True\", \"class Solution(object):\\n def canReorderDoubled(self, A):\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\\n\", \"class Solution(object):\\n def canReorderDoubled(self, A):\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n c = collections.Counter(A)\\n for k in sorted(c, key=abs):\\n if c[k] > c.get(2*k, 0):\\n return False\\n c[2*k] -= c[k]\\n \\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n st = {}\\n A = sorted(A,reverse=True)\\n for i in A:\\n if i in st:st[i]+=1\\n else: st[i] = 1\\n #print(st)\\n for num in A:\\n if (num*2) in st and st[num] > 0 and st[(num*2)] > 0:\\n st[num*2]-=1\\n st[num]-=1\\n #print(num,st)\\n for num in st:\\n if st[num] > 0:return False\\n return True\\n\", \"from collections import Counter\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count_a = Counter(A)\\n A.sort(key=lambda x: abs(x))\\n for elem in A:\\n if count_a[elem] == 0: continue\\n if count_a[elem * 2] == 0: return False\\n count_a[elem] -= 1\\n count_a[elem * 2] -= 1\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0:\\n continue\\n if count[x*2] == 0:\\n return False\\n count[x] -= 1\\n count[2*x] -= 1\\n \\n return True\\n \\n \\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n A.sort() \\n map = {}\\n \\n for item in A:\\n if item in map : map[item] +=1\\n else : map[item] =1\\n \\n for item in A:\\n if map[item]==0 : continue\\n if item <0 :\\n if item/2 in map : \\n if map[item/2]==0 : return False\\n map[item] -=1\\n map[item/2] -=1\\n else : return False\\n else :\\n if item *2 in map:\\n if map[2*item]==0: return False\\n map[item] -=1\\n map[item*2] -=1\\n else : return False\\n \\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n seen = dict()\\n for x in A:\\n if x not in seen:\\n seen[x] = 0\\n seen[x] += 1\\n\\n for x in sorted(seen, key=lambda x : x**2):\\n if seen[x] == 0:\\n continue\\n if (2*x not in seen) or (seen[x] > seen[2*x]):\\n return False\\n else:\\n seen[2*x] -= seen[x]\\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n print(x)\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\", \"from collections import Counter\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n a = sorted(A,key=lambda x:abs(x),reverse = True)\\n b = dict(Counter(A))\\n while a:\\n \\n aa = a.pop()\\n if aa in b:\\n\\n b[aa] -= 1\\n if b[aa]==0:\\n del b[aa]\\n\\n if 2*aa in b:\\n b[2*aa] -= 1\\n else:\\n return False\\n if b[2*aa]==0:\\n del b[2*aa]\\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\\n \\n \\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n counter = collections.Counter(A)\\n for x in sorted(counter,key=abs):\\n if counter[x] > counter[2*x]:\\n return False\\n counter[2*x] -= counter[x]\\n return True \", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if len(A) % 2 == 1:\\n return False\\n \\n count = collections.defaultdict(int)\\n for num in A:\\n count[num] += 1\\n A.sort()\\n for num in A:\\n if count[num] > 0:\\n double = num * 2\\n if double in count and count[double] > 0:\\n # print(\\\\\\\"found\\\\\\\", double)\\n count[num] -= 1 \\n count[double] -= 1\\n \\n for num in count:\\n if count[num] != 0:\\n return False\\n return True\\n \\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n c = collections.Counter(A)\\n for x in sorted(c, key=abs):\\n if c[x] > c[2 * x]:\\n return False\\n c[2 * x] -= c[x]\\n return True\\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n d={}\\n for i in A:\\n if i in d:\\n d[i]+=1\\n else:\\n d[i]=1\\n A.sort()\\n \\n if 0 in d:\\n if d[0]%2!=0:\\n return False\\n d.pop(0)\\n \\n for i in A:\\n #print(i,d)\\n if i not in d:\\n continue\\n \\n if i*2 in d:\\n if d[i]>d[i*2]:\\n d[i]-=d[i*2]\\n d[i*2]=0\\n else:\\n d[i*2]-=d[i]\\n d[i]=0\\n if d[i]==0:\\n d.pop(i)\\n if d[i*2]==0:\\n d.pop(i*2)\\n elif i%2==0 and i//2 in d:\\n if d[i]>d[i//2]:\\n d[i]-=d[i//2]\\n d[i//2]=0\\n else:\\n d[i//2]-=d[i]\\n d[i]=0\\n if d[i]==0:\\n d.pop(i)\\n if d[i//2]==0:\\n d.pop(i//2)\\n else:\\n return False\\n return len(d)==0\\n\", \"import collections\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n ''' Place all values into dicts and start counting from the bottom\\n '''\\n counter = collections.Counter(A)\\n \\n for v in sorted(counter, key = abs):\\n if counter[2 * v] < counter[v]:\\n return False\\n counter[2 * v] -= counter[v]\\n return True\\n \\n \\n \\n \\n \\n \\n\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A = sorted(A, key=lambda x: abs(x))\\n M = Counter()\\n \\n for e in A:\\n M[e] += 1\\n \\n # print(M)\\n # print(A)\\n \\n for e in A:\\n # print(e, M[2*e], M)\\n if M[e] and M[2*e]:\\n M[2*e] -= 1\\n M[e] -= 1\\n # print('->', 2*e, M[2*e])\\n elif M[e]:\\n # print(M, e)\\n return False\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x]==0: continue\\n if count[2*x]==0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n return True\", \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n dic=collections.defaultdict(int)\\n for i in range(len(A)):\\n dic[A[i]]+=1\\n ki=list(dic.keys())\\n ki.sort(key=lambda x:abs(x))\\n for k in ki:\\n if dic[2*k]<dic[k]:\\n return False\\n dic[2*k]-=dic[k]\\n dic[k]=0\\n return True\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"canReorderDoubled\", \"inputs\": [[[3, 1, 3, 6]]], \"outputs\": [false]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/array-of-doubled-pairs/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n cache=Counter(A)\n c_list=sorted(list(cache),key=abs)\n for x in c_list:\n if cache[x]>cache[2*x]:\n return False\n cache[2*x]-=cache[x]\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n cache=collections.Counter(A)\n c_list=sorted(list(cache),key=abs)\n for x in c_list:\n if cache[x]>cache[2*x]:\n return False\n cache[2*x]-=cache[x]\n return True","from collections import Counter\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n if len(A) % 2 == 1: return False\n if not A: return True\n nums = sorted(set(A))\n nums = [x for x in nums if x < 0][::-1] + [x for x in nums if x >= 0]\n c = Counter(A)\n done = set()\n for num in nums:\n if num in done:\n continue\n if 2*num not in c:\n return False\n if c[2*num] < c[num]:\n return False\n \n c[2*num] -= c[num]\n if c[2*num] == 0: \n done.add(2*num)\n \n c[num] = 0\n done.add(num)\n \n return True","import collections\n\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n ''' Place all values into dicts and start counting from the bottom\n '''\n if not A:\n return True\n \n pos = collections.defaultdict(int)\n neg = collections.defaultdict(int)\n zero = 0\n \n # O(n)\n for v in A:\n if v > 0:\n pos[v] += 1\n if v < 0:\n neg[-v] += 1\n if v == 0:\n zero += 1\n \n b = self.check(pos)\n if not b:\n return False\n b = self.check(neg)\n if not b:\n return False\n \n return zero % 2 == 0\n \n \n def check(self, d):\n \n # worst case O(n), done n times\n while d:\n v = min(d) \n if not 2 * v in d:\n return False\n if d[v] > d[2 * v]:\n return False\n\n elif d[v] == d[2*v]:\n del d[v]\n del d[2*v]\n else:\n d[2*v] -= d[v]\n del d[v]\n return True\n \n \n \n \n \n","\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n ''' Place all values into dicts and start counting from the bottom\n '''\n if not A:\n return True\n \n pos = {}\n neg = {}\n zero = 0\n \n # O(n)\n for v in A:\n if v > 0:\n pos[v] = pos.get(v, 0) + 1\n if v < 0:\n neg[-v] = neg.get(-v, 0) + 1\n if v == 0:\n zero += 1\n \n b = self.check(pos)\n if not b:\n return False\n b = self.check(neg)\n if not b:\n return False\n \n return zero % 2 == 0\n \n \n def check(self, d):\n \n # worst case O(n), done n times\n while d:\n v = min(d) \n if not 2 * v in d:\n return False\n if d[v] > d[2 * v]:\n return False\n\n elif d[v] == d[2*v]:\n del d[v]\n del d[2*v]\n else:\n d[2*v] -= d[v]\n del d[v]\n return True\n \n \n \n \n \n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n i = 0\n j = 0\n A.sort()\n while i < len(A) and A[i] <= 0:\n if A[i] % 2 != 0:\n return False\n while j < len(A) and A[j] < 0 and 2 * A[j] < A[i]:\n j += 1\n if j >= len(A) or 2 * A[j] > A[i]:\n return False\n A[j] = None\n j += 1\n i += 1\n while i < len(A) and A[i] is None:\n i += 1\n \n while i < len(A):\n while j < len(A) and A[j] < 2 * A[i]:\n j += 1\n if j >= len(A) or A[j] > 2 * A[i]:\n return False\n A[j] = None\n j += 1\n i += 1\n while i < len(A) and A[i] is None:\n i += 1\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n count = {}\n zero_count = 0\n for num in A:\n if num == 0:\n zero_count += 1\n elif num in count:\n count[num] += 1\n else:\n count[num] = 1\n if zero_count % 2 != 0:\n return False\n \n A.sort()\n for num in A:\n double = num * 2\n if num in count and double in count:\n count[double] -= 1\n count[num] -= 1\n if count[double] == 0:\n count.pop(double)\n if count[num] == 0:\n count.pop(num)\n \n return count == {}\n \n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n if len(A) % 2 == 1:\n return False\n \n count = collections.defaultdict(int)\n for num in A:\n count[num] += 1\n A.sort()\n for num in A:\n if count[num] > 0:\n # print(f\\\"checking {num}\\\")\n double = num * 2\n # print(half, double)\n\n if double in count and count[double] > 0:\n # print(\\\"found\\\", double)\n count[num] -= 1 \n count[double] -= 1\n # print(count)\n # print(\\\"all good\\\")\n # print(count) \n for num in count:\n if count[num] != 0:\n return False\n return True\n \n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n count = collections.Counter(A)\n\n for x in sorted(A, key=abs):\n if(count[x] == 0):\n continue\n if(count[2*x] == 0):\n return False\n count[x] -= 1\n count[2*x] -= 1\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n cache=dict()\n for a in A:\n cache[a]=cache.get(a,0)+1\n while len(cache)>0:\n temp=[abs(k) for k in cache.keys()]\n curr=min(temp)\n if curr==0:\n if cache[0]%2>0:\n return False\n else:\n cache.pop(0)\n else:\n if curr in cache:\n if cache[curr]==0:\n cache.pop(curr)\n elif (2*curr not in cache) or cache[2*curr]<cache[curr]:\n return False\n else:\n cache[2*curr]-=cache[curr]\n cache.pop(curr)\n if -curr in cache:\n if cache[-curr]==0:\n cache.pop(-curr)\n elif (-2*curr not in cache) or cache[-2*curr]<cache[-curr]:\n return False\n else:\n cache[-2*curr]-=cache[-curr]\n cache.pop(-curr)\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n ''' Place all values into dicts and start counting from the bottom\n '''\n counter = collections.Counter(A)\n \n for v in sorted(counter, key = abs):\n if counter[2 * v] < counter[v]:\n return False\n counter[2 * v] -= counter[v]\n return True\n \n \n \n \n \n \n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n counts = defaultdict(int)\n for x in sorted(A):\n counts[x] += 1\n if x < 0 and x * 2 in counts:\n while counts[x] > 0 and counts[x * 2] > 0:\n counts[x] -= 1\n counts[x * 2] -= 1\n if x >= 0 and x / 2 in counts:\n while counts[x] > 0 and counts[x / 2] > 0:\n counts[x] -= 1\n counts[x / 2] -= 1\n return sum(c for v, c in counts.items()) == 0","import collections\n\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n ''' Place all values into dicts and start counting from the bottom\n '''\n if not A:\n return True\n \n counter = collections.Counter(A)\n \n for v in sorted(counter, key = abs):\n if counter[2 * v] < counter[v]:\n return False\n counter[2 * v] -= counter[v]\n return True\n \n \n \n \n \n \n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n result = True\n numLen = len(A)\n C = Counter(A)\n val = list(C.keys())\n val.sort()\n for i in range(len(val)):\n if val[i] < 0:\n if val[i] % 2 == 0:\n if val[i]/2 in val and C[val[i]/2] >= C[val[i]]:\n C[val[i] / 2] = C[val[i]/2] - C[val[i]]\n C[val[i]] = 0\n else:\n result = False\n # break\n else:\n if val[i] * 2 in val and C[val[i]*2] >= C[val[i]]:\n C[val[i] * 2] = C[val[i]*2] - C[val[i]]\n C[val[i]] = 0\n else:\n result = False\n # Break\n nums = list(C.values())\n if nums == [0]*len(nums):\n result = True\n else:\n result = False\n return result","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n \n dd = Counter(A)\n A.sort(key = lambda a : abs(a))\n\n for a in A:\n if a in dd and dd[a]:\n if 2*a in dd and dd[2*a]:\n dd[a] -= 1\n dd[2*a] -= 1\n if dd[a] == 0:\n del dd[a]\n if dd[a*2] == 0:\n del dd[a*2]\n else:\n return False\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n pos = [x for x in A if x >= 0]\n neg = [x for x in A if x < 0]\n for L in (pos,neg):\n count = collections.Counter(L)\n for x in sorted(L, key=abs):\n if count[x] == 0: continue\n if count[2*x] == 0: return False\n count[x] -= 1\n count[2*x] -= 1\n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n A.sort(key=lambda x: (x>0, abs(x)))\n right = 1\n size = len(A)\n for i in range(size):\n if A[i] is None:\n continue\n\n while right < size and 2 * A[i] != A[right]:\n right += 1\n\n if right == size:\n return False\n\n A[right] = None\n\n return True","class Solution:\n def canReorderDoubled(self, arr):\n arr.sort()\n negl = [x for x in arr if x < 0][::-1]\n posl = [x for x in arr if x >= 0]\n cnt = {}\n for x in arr:\n if x not in cnt:\n cnt[x] = 1\n else:\n cnt[x] = cnt[x] + 1\n\n while True :\n x = None\n if negl != [] :\n x = negl.pop(0)\n else:\n if posl != [] :\n x = posl.pop(0)\n else:\n break\n if cnt[x] == 0 :\n continue\n y = x * 2\n if y not in cnt:\n return False\n else:\n if cnt[y] > 0 and cnt[x] > 0:\n cnt[y] = cnt[y] - 1\n cnt[x] = cnt[x] - 1\n else:\n return False\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n seen = {}\n \n A.sort()\n for i in A:\n #Logic for checking half and double of number\n if i/2 in seen:\n seen[i/2] -= 1\n if seen[i/2] == 0:\n del seen[i/2]\n \n elif 2*i in seen:\n seen[2*i] -= 1\n if seen[2*i] == 0:\n del seen[2*i]\n else:\n if i in seen:\n seen[i] += 1\n else:\n seen[i] = 1\n \n return not bool(seen)","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n counter=Counter(A)\n for a in sorted(A, key=abs):\n if counter[a]==0:\n continue\n if counter[2*a]==0:\n return False\n counter[a]-=1\n counter[2*a]-=1\n return True\n","import collections\nclass Solution:\n def canReorderDoubled(self, a: List[int]) -> bool:\n count=collections.Counter(a)\n for elem in sorted(a,key=abs):\n if count[elem]==0:\n continue\n if count[2*elem]==0:\n return False\n count[elem]-=1\n count[2*elem]-=1\n return True\n","from collections import defaultdict\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n if not A:\n return True\n \n count = 0\n d = defaultdict(int)\n for i in A:\n d[i] += 1\n \n for num in sorted(A):\n if num*2 in d and d[num] and d[num*2]:\n d[num] -= 1\n d[num*2] -= 1\n count += 1\n \n return count == (len(A) // 2)\n\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n # Eliminate zero\n negative = []\n positive = []\n \n zero_numbers = 0\n for a in A:\n if a < 0:\n negative.append(abs(a))\n elif a > 0:\n positive.append(a)\n else:\n zero_numbers += 1\n \n if zero_numbers % 2:\n return False\n \n negative.sort()\n positive.sort()\n # print(negative, positive)\n \n return self.helper(negative) and self.helper(positive)\n \n def helper(self, nums): \n while nums:\n cur_num = nums[0]\n idx = self.binarySearch(nums, 2 * cur_num)\n # print('helper',nums[0], idx)\n if idx == -1:\n return False\n nums.pop(idx)\n nums.pop(0)\n if len(nums) == 1:\n return False\n \n return True\n \n def binarySearch(self, nums, key):\n \n head = 0\n tail = len(nums) - 1\n # print(nums, key)\n \n while head <= tail:\n mid = (head + tail)//2\n if nums[mid] > key:\n tail = mid - 1\n elif nums[mid] < key:\n head = mid + 1\n else:\n return mid\n \n return -1","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n count = collections.Counter(A)\n for a in sorted(count, key = lambda x: abs(x)):\n if count[a] > count[2 * a]:\n return False\n count[2 * a] -= count[a]\n return True","import numpy as np\n\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n a = np.array(sorted(A))\n non_pos_idxs = np.where(a >= 0)[0]\n if len(non_pos_idxs) > 0:\n non_pos_idx = non_pos_idxs[0]\n else:\n non_pos_idx = len(a)\n b = a[:non_pos_idx][::-1]\n a = a[non_pos_idx:]\n if len(b) % 2 != 0:\n return False\n \n if not self.check_doubled(a):\n return False\n if not self.check_doubled(b):\n return False\n return True\n \n def check_doubled(self, a):\n if len(a) == 0:\n return True\n count_dict = {}\n for val in a:\n if count_dict.get(val, 0) > 0:\n count_dict[val] -= 1\n else:\n count_dict[2 * val] = count_dict.get(2 * val, 0) + 1\n for val in list(count_dict.values()):\n if val > 0:\n return False\n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n seen = {}\n A.sort()\n for ind,i in enumerate(A):\n #Logic for checking half and double of number\n if i/2 in seen:\n seen[i/2] -= 1\n if seen[i/2] == 0:\n del seen[i/2]\n \n elif 2*i in seen:\n seen[2*i] -= 1\n if seen[2*i] == 0:\n del seen[2*i]\n else:\n if i in seen:\n seen[i] += 1\n else:\n seen[i] = 1\n \n print(seen)\n \n return not bool(seen)","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n if not A:\n return True\n d=defaultdict(int)\n for x in A:\n d[x]+=1\n n=len(A)//2\n A.sort()\n for x in A:\n if d[x]>0:\n if 2*x in d and d[2*x]>0:\n d[2*x]-=1\n d[x]-=1\n n-=1\n if n==0:\n return True\n #print(x,d,n)\n return False\n \n \n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n A.sort()\n d = collections.defaultdict(int)\n for a in A:\n if d[2*a] > 0:\n d[2*a] -= 1\n elif d[a/2] > 0:\n d[a/2] -= 1\n else:\n d[a] += 1\n return not any(d.values())\n","from collections import Counter\n\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n counts = [0]*(10**5+1)\n for a in A:\n if a >= 0:\n counts[a] += 1\n for i in range(10**5+1):\n while counts[i] != 0:\n counts[i] -= 1\n if counts[i] < 0:\n return False\n counts[2*i] -= 1\n if counts[2*i] < 0:\n return False\n if not all(n == 0 for n in counts):\n return False\n\n for a in A:\n if a < 0:\n counts[-a] += 1\n for i in range(10**5+1):\n while counts[i] != 0:\n counts[i] -= 1\n if counts[i] < 0:\n return False\n counts[2*i] -= 1\n if counts[2*i] < 0:\n return False\n if not all(n == 0 for n in counts):\n return False\n return True","class Solution:\n def canReorderDoubled(self, arr: List[int]) -> bool:\n dicti=dict()\n for var in arr:\n if var in list(dicti.keys()):\n dicti[var]+=1\n else:\n dicti[var]=1\n arr.sort(key=lambda x: abs(x))\n for var in arr:\n if dicti[var]==0:\n continue\n if(2*var not in list(dicti.keys())):\n return False\n if dicti[2*var]<=0:\n return False\n dicti[var]-=1\n dicti[2*var]-=1\n return True\n\n","class Solution:\n def get_result(self, sl, d):\n for k in sl:\n if d[k]==0:\n continue\n if 2*k not in d:\n return False\n v = d[k]\n v2 = d[2*k]\n if v>v2:\n return False\n d[k] -= v\n d[2*k] -= v\n return True\n \n def canReorderDoubled(self, A: List[int]) -> bool:\n d = dict()\n num_zeros = 0\n for a in A:\n if a==0:\n num_zeros += 1\n continue\n if a in d:\n d[a] += 1\n else:\n d[a] = 1\n neg = [k for k in list(d.keys()) if k<0]\n pos = [k for k in list(d.keys()) if k>0]\n if num_zeros%2!=0:\n return False\n sorted_pos = sorted(pos)\n sorted_neg = sorted(neg, reverse=True)\n res = self.get_result(sorted_pos, d)\n if not res:\n return False\n res = self.get_result(sorted_neg, d)\n if not res:\n return False\n return sum(list(d.values()))==0\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n cnt = collections.Counter(A)\n # It handles the case where there is odd number of 0, since the total number is even, there should be a number which cannot match because of the extra 0\n for k in sorted(cnt, key=abs):\n if cnt[k] > cnt[2*k]:\n return False\n \n cnt[2*k] -= cnt[k]\n \n return True","from collections import Counter\n\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n # Greedy\n # Time complexity: O(NlogN)\n # Space complexity: O(N)\n # count = Counter(A)\n # for x in sorted(A, key=abs):\n # if count[x] == 0: continue\n # if count[2 * x] == 0: return False\n # count[x] -= 1\n # count[2 * x] -= 1\n # return True\n\n\n count = Counter(A)\n for x in sorted(count, key=abs):\n if count[x] > count[2 * x]:\n return False\n count[2 * x] -= count[x]\n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n count = collections.Counter(A)\n for i in sorted(count, key=abs):\n count[2*i] -= count[i]\n if count[2*i] < 0:\n return False\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n freq = dict()\n for i in A:\n freq[i] = freq.get(i, 0) + 1\n\n for k in sorted(list(freq.keys()), key=lambda x: abs(x)):\n if freq[k] == 0: continue\n if freq[k] > freq.get(2*k, 0):\n return False\n freq[2*k] -= freq[k]\n \n return True\n","from collections import Counter\n \n\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n if not A: return True\n c = Counter(A)\n keys = sorted(c.keys())\n for k in keys:\n if k == 0:\n if c[k] % 2 == 0:\n c[k] = 0\n else:\n return False\n if k < 0 and c[k] > 0:\n if k/2 in c:\n c[k/2] -= c[k]\n c[k] = 0\n if k > 0 and c[k] > 0:\n if k*2 in c:\n c[k*2] -= c[k]\n c[k] = 0\n \n return set(c.values()) == {0}\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n cache=collections.Counter(A)\n c_list=sorted(list(cache),key=lambda x: (abs(x),x))\n for x in c_list:\n if cache[x]>cache[2*x]:\n return False\n cache[2*x]-=cache[x]\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n d = collections.Counter(A)\n if 0 in d:\n if d[0] & 1 == 1:\n return False\n d.pop(0)\n\n keys = sorted(d.keys())\n for i in keys:\n if i in d:\n if i < 0:\n if i / 2 not in d:\n return False\n if d[i] > d[i/2]:\n return False\n d[i/2] -= d[i]\n if d[i/2] == 0:\n d.pop(i/2)\n d.pop(i)\n else:\n if i * 2 not in d:\n return False\n if d[i] > d[i*2]:\n return False\n d[i*2] -= d[i]\n if d[i*2] == 0:\n d.pop(i*2)\n d.pop(i)\n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n A.sort()\n B = OrderedDict()\n for x in A:\n if x in B:\n B[x] += 1\n else:\n B[x] = 1\n \n while B:\n x = next(iter(B))\n freq = B.pop(x)\n \n #print(x,freq)\n \n if x<0:\n if x%2:\n return False\n if (x//2 not in B) or B[x//2]<freq:\n return False\n B[x//2] -= freq\n if B[x//2] == 0:\n B.pop(x//2)\n \n elif x==0:\n if freq%2:\n return False\n \n else:\n if (x*2 not in B) or B[x*2]<freq:\n return False\n B[x*2] -= freq\n if B[x*2] == 0:\n B.pop(x*2)\n \n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n c = collections.Counter(A)\n cc = sorted(c, key=abs)\n #print(cc)\n for x in cc:\n #print(str(x), end=\\\": \\\")\n #print(c)\n if c[x] > c[2 * x]:\n return False\n c[2 * x] -= c[x]\n #print(c)\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n neg = dict()\n pos = dict()\n zero = 0\n for n in A:\n if n < 0:\n if -n not in neg:\n neg[-n] = 0\n neg[-n] += 1\n elif n >0:\n if n not in pos:\n pos[n] = 0\n pos[n] += 1\n else:\n zero += 1\n if zero % 2 != 0:\n return False\n #print(pos,neg)\n def helper(nums):\n num_sorted = sorted(list(nums.keys()),reverse = True)\n while num_sorted:\n a = num_sorted.pop()\n if nums[a] == 0:\n continue\n if 2*a not in nums or nums[a]>nums[2*a]:\n return False\n nums[2*a] -= nums[a]\n return True\n return helper(pos) and helper(neg)\n \n","from collections import defaultdict\n\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n A.sort()\n s = defaultdict(int)\n for a in A:\n if a <= 0:\n if 2 * a in s:\n s[2*a] -= 1\n if not s[2*a]:\n del s[2*a]\n else:\n s[a] += 1\n else:\n if a % 2 == 0 and a // 2 in s:\n s[a // 2] -= 1\n if not s[a // 2]:\n del s[a // 2]\n else:\n s[a] += 1\n return not s","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n \n hashtable = {}\n zero_count = 0\n for i in range(len(A)):\n if A[i]==0:\n zero_count+=1\n continue\n if A[i] in list(hashtable.keys()):\n hashtable[A[i]]+=1\n \n else:\n hashtable[A[i]]=1\n \n \n if zero_count%2==1:\n return False\n else:\n key_list = []\n pair_count = 0\n for key in list(hashtable.keys()):\n key_list.append(key)\n \n key_list.sort()\n \n for key in key_list:\n if key%2==0 and key//2 in list(hashtable.keys()):\n m = min(hashtable[key],hashtable[key//2])\n hashtable[key]-=m\n hashtable[key//2]-=m\n pair_count+=m\n \n if pair_count*2 + zero_count==len(A):\n return True\n else:\n return False\n \n \n","from collections import Counter\n\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n # O(NlogN) time \n # O(N) space\n \n if not A:\n return True\n \n counts = Counter(A) \n \n for key in sorted(counts.keys()):\n if counts[key] == 0:\n continue\n \n factor = .5 if key < 0 else 2\n if counts[key] > counts[factor*key]:\n return False\n counts[factor*key] -= counts[key]\n \n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n A.sort(key=lambda x: abs(x))\n freq = dict()\n\n for i in A:\n freq[i] = freq.get(i, 0) + 1\n\n for k in sorted(list(freq.keys()), key=lambda x: abs(x)):\n if freq[k] == 0: continue\n if freq[k] > freq.get(2*k, 0):\n return False\n freq[2*k] -= freq[k]\n \n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n \n D = {}\n for x in A:\n D[x] = D.get(x, 0) + 1\n \n D = dict([x for x in sorted(list(D.items()), key =lambda x:x[0] )])\n \n for x in D:\n while D[x] > 0:\n D[x] -= 1\n if x <= 0:\n pair_x = x / 2\n else:\n pair_x = x * 2\n \n if D.get(pair_x, 0) > 0:\n D[pair_x] -= 1\n else:\n return False\n \n return True\n \n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n cnt = collections.Counter(A)\n for k in sorted(cnt, key=abs):\n a = cnt[k]\n if cnt[k] == 0:\n continue\n b = cnt.get(2 * k, 0)\n if b < a:\n return False\n cnt[2 * k] -= a\n \n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n def update_map(count, small, large):\n small_count = count[small]\n large_count = count[large]\n min_count = min(small_count, large_count)\n \n count[small] += -min_count\n if small != large:\n count[large] += -min_count\n \n if not A:\n return True\n element_count = {}\n ordered_elements = list(set(A))\n ordered_elements.sort()\n \n for number in A:\n if number not in element_count:\n element_count[number] = 0\n element_count[number] += 1\n \n for number in ordered_elements:\n number_count = element_count[number]\n double_number = number * 2\n if double_number in element_count:\n update_map(element_count, number, double_number)\n \n for number in element_count:\n if element_count[number] != 0:\n return False\n return True\n \n \n","from collections import Counter\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n c=Counter(A)\n A=sorted(A)\n for num,v in sorted(list(c.items()), key= lambda item:item[0]):\n if num>0 and c[num]>0:\n if c[num]!=0 and c[num]>c[2*num]:\n return False\n c[2*num]-=c[num]\n c[num]=0\n elif num<0 and c[num]>0:\n if num%2==1:\n return False\n if c[num]!=0 and c[num]>c[num//2]:\n return False\n c[num//2]-=c[num]\n c[num]=0\n return True\n \n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n if not A:\n return True\n positive_heap = []\n negative_heap = []\n zero = 0\n positive_d = defaultdict(int)\n negative_d = defaultdict(int)\n for i in A:\n if i == 0:\n zero += 1\n elif i < 0:\n heappush(negative_heap, -i)\n negative_d[-i] += 1\n else:\n heappush(positive_heap, i)\n positive_d[i] += 1\n if zero % 2 != 0:\n return False\n if not self.check(positive_heap, positive_d):\n return False\n if not self.check(negative_heap, negative_d):\n return False\n return True\n \n def check(self, h, d):\n for _ in range(len(h)):\n i = heappop(h)\n if d[i] == 0:\n continue\n if 2*i not in d:\n return False\n elif d[2*i] < d[i]:\n return False\n else:\n d[2*i] -= d[i]\n d[i] = 0\n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n zcount = 0\n pos = []\n neg = []\n for n in A:\n if n==0:\n zcount+=1\n elif n>0:\n pos.append(n)\n else:\n neg.append(-n)\n def verifypos(A):\n count = collections.Counter(A)\n for x in sorted(A, key = abs):\n if count[x] == 0: continue\n if count[2*x] == 0: return False\n count[x] -= 1\n count[2*x] -= 1\n\n return True\n return verifypos(pos) and verifypos(neg)","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n count = collections.Counter(A)\n for x in sorted(A, key=abs):\n if count[x] == 0:\n continue\n if x == 0 and x % 2:\n return False\n if count[x] > count[2 * x]:\n return False\n count[x], count[2 * x] = 0, count[2 * x] - count[x]\n \n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n \n D = {}\n for x in A:\n D[x] = D.get(x, 0) + 1\n D = dict([kv for kv in sorted(list(D.items()), key =lambda x:x[0] )])\n \n for x in D:\n while D[x] > 0:\n D[x] -= 1\n if x <= 0:\n pair_x = x / 2\n else:\n pair_x = x * 2\n \n if D.get(pair_x, 0) > 0:\n D[pair_x] -= 1\n else:\n return False\n \n return True\n \n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n A.sort()\n dic = {}\n for i in A:\n if i % 2 == 0 and i/2 in dic:\n i = i / 2\n dic[i] -= 1\n if dic[i] == 0:\n del dic[i]\n elif i * 2 in dic:\n i = i * 2\n dic[i] -= 1\n if dic[i] == 0:\n del dic[i]\n else:\n dic[i] = dic.setdefault(i, 0) + 1\n continue\n return len(dic) == 0","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n # https://blog.csdn.net/fuxuemingzhu/article/details/84925747\n A.sort()\n N = len(A)\n count = collections.Counter(A)\n for i in range(N):\n if A[i] == 0 or A[i] not in count: continue\n elif A[i] < 0:\n if A[i] % 2 == 1 or count[A[i] / 2] == 0:\n return False\n else:\n count[A[i] / 2] -= count[A[i]]\n if count[A[i] / 2] == 0:\n del count[A[i] / 2]\n del count[A[i]]\n else:\n if count[A[i] * 2] == 0:\n return False\n else:\n count[A[i] * 2] -= count[A[i]]\n if count[A[i] * 2] == 0:\n del count[A[i] * 2]\n del count[A[i]]\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n c = collections.Counter(A)\n for x in sorted(c):\n if c[x] == 0: continue\n\n if c[x] < 0:\n return False\n if x == 0:\n if c[x] % 2 != 0:\n return False\n else:\n continue\n if x > 0:\n temp = 2*x\n elif x % 2:\n return False\n else:\n \n temp = x//2\n\n\n if c[temp] < c[x]:\n return False\n else:\n c[temp] -= c[x]\n\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n pos_set = set()\n neg_set = set()\n pos_dict = {}\n neg_dict = {}\n pos_count = 0\n for num in A:\n if num >= 0:\n pos_set.add(num)\n pos_dict[num] = 1 + pos_dict.get(num,0)\n pos_count += 1\n else:\n neg_set.add(abs(num))\n neg_dict[abs(num)] = 1 + neg_dict.get(abs(num),0)\n if pos_count % 2 != 0:\n return False\n else:\n return self.helper(pos_set,pos_dict) and self.helper(neg_set,neg_dict)\n \n def helper(self,set_,dict_):\n sorted_ = sorted(list(set_))\n for num in sorted_:\n if num * 2 in sorted_ and num != 0:\n small_ = dict_[num] \n large_ = dict_[num * 2]\n usage = min(small_,large_)\n dict_[num] -= usage\n dict_[num * 2] -= usage\n elif num == 0:\n if dict_[0] % 2 != 0:\n return False\n else:\n dict_[0] = 0\n \n for key in dict_:\n if dict_[key] != 0:\n return False\n return True\n \n","from collections import Counter\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n if not A: return True\n C = Counter(A)\n K = sorted(C.keys())\n for k in K:\n if k == 0:\n if C[k] & 1:\n return False\n else:\n C[k] = 0\n if k < 0 and C[k] > 0:\n if k % 2 == 0 and (k // 2 in C):\n C[k//2] -= C[k]\n C[k] = 0\n if k > 0 and C[k] > 0:\n if k * 2 in C:\n C[k*2] -= C[k]\n C[k] = 0\n return set(C.values()) == {0}","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n c = Counter(A)\n for n in sorted(list(c.keys()), key=abs):\n while c[n] > 0 and c[(double := 2 * n)] > 0:\n c[n] -= 1\n c[double] -= 1\n return all(not v for v in list(c.values()))\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n \n def factorize(num):\n power = 0\n while num % 2 == 0:\n num, power = num//2, power+1\n return (num, power)\n \n counts = defaultdict(lambda : [0]*17)\n zeros = 0\n for a in A:\n if a == 0:\n zeros += 1\n else:\n n, p = factorize(a)\n counts[n][p] += 1\n \n if zeros % 2 == 1:\n return False\n \n \n for key in counts:\n carry = 0\n for p in counts[key]:\n carry = p - carry\n if carry < 0: return False\n if carry != 0: return False\n \n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n # https://www.cnblogs.com/seyjs/p/10092569.html\n A.sort()\n dic = {}\n for i in A:\n if i % 2 == 0 and i/2 in dic:\n i = i / 2\n dic[i] -= 1\n if dic[i] == 0:\n del dic[i]\n elif i * 2 in dic:\n i = i * 2\n dic[i] -= 1\n if dic[i] == 0:\n del dic[i]\n else:\n dic[i] = dic.setdefault(i, 0) + 1\n continue\n return len(dic) == 0","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n A.sort(key=lambda x: abs(x))\n c={}\n for v in A:\n if v/2 in c:\n c[v/2]-=1\n if not c[v/2]:\n del c[v/2]\n else:\n if v not in c: c[v]=0\n c[v]+=1\n return len(c)==0","import collections\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n neg = collections.Counter()\n pos = collections.Counter()\n for n in A:\n if n >= 0:\n pos[n] += 1\n else:\n neg[n] += 1\n \n for n in sorted(neg, reverse = True):\n if neg[n*2] < neg[n]:\n return False\n neg[n*2] -= neg[n]\n del neg[n]\n if neg[n*2] == 0:\n del neg[n*2]\n if len(neg) != 0:\n return False\n for n in sorted(pos):\n if pos[n*2] < pos[n]:\n return False\n pos[n*2] -= pos[n]\n del pos[n]\n if pos[n*2] == 0:\n del pos[n*2]\n if len(pos) != 0:\n return False\n return True\n \n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n A.sort()\n freq = dict()\n for i in A:\n freq[i] = freq.get(i, 0) + 1\n for i in A:\n if freq.get(i, 0) == 0: continue\n\n if i < 0:\n if i % 2 != 0:\n return False\n elif not freq.get(i // 2, 0) > 0:\n return False\n elif i > 0 and not freq.get(i * 2, 0) > 0:\n return False\n \n if i < 0:\n freq[i // 2] -= 1\n else:\n freq[i*2] -=1\n freq[i] -= 1\n \n return True\n","from collections import Counter\n\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n \n negs = [a for a in A if a < 0]\n pos = [a for a in A if a > 0]\n zeros = [a for a in A if a == 0]\n \n if any(map(lambda x: len(x) % 2 != 0, [negs, pos, zeros])):\n return False\n \n if not self.is_valid(negs, True) or not self.is_valid(pos, False):\n return False\n return True\n \n \n def is_valid(self, A, neg=False):\n A = sorted(A)\n N = len(A)\n \n if neg:\n A = A[::-1]\n\n c = Counter(A)\n for a in A:\n if c[a] == 0:\n continue\n target = a * 2\n if c[target] == 0:\n return False\n c[a] -= 1\n c[target] -= 1\n return True","from collections import defaultdict\n\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n \n A.sort()\n \n arr = defaultdict(int)\n \n for item in A:\n \n if 2*item in arr and arr[2*item] > 0:\n arr[2*item] -= 1\n elif item % 2 == 0 and (item // 2) in arr and arr[item // 2] > 0:\n arr[item // 2] -= 1\n else:\n arr[item] += 1\n \n \n return sum([x for x in arr.values() if x != 0]) == 0","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n \n count = collections.Counter(A)\n for x in sorted(A, key = abs):\n if count[x] == 0: continue\n if count[2*x] == 0: return False\n count[x] -= 1\n count[2*x] -= 1\n\n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n count = Counter(A)\n for x in sorted(A, key = abs):\n if count[x]==0: continue # x may be end of a pair\n if count[2*x]==0: \n return False # x exsist, we have to match it with a 2x\n count[2*x] -= 1\n count[x] -= 1\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n cache=Counter(A)\n c_list=sorted(list(cache),key=abs)\n for x in c_list:\n if cache[x]>cache[2*x]:\n return False\n cache[2*x]-=cache[x]\n return True\n \n '''\n if not A:\n return True\n positive_heap = []\n negative_heap = []\n zero = 0\n positive_d = defaultdict(int)\n negative_d = defaultdict(int)\n for i in A:\n if i == 0:\n zero += 1\n elif i < 0:\n heappush(negative_heap, -i)\n negative_d[-i] += 1\n else:\n heappush(positive_heap, i)\n positive_d[i] += 1\n if zero % 2 != 0:\n return False\n if not self.check(positive_heap, positive_d):\n return False\n if not self.check(negative_heap, negative_d):\n return False\n return True\n \n def check(self, h, d):\n for _ in range(len(h)):\n i = heappop(h)\n if d[i] == 0:\n continue\n if 2*i not in d:\n return False\n elif d[2*i] < d[i]:\n return False\n else:\n d[2*i] -= d[i]\n d[i] = 0\n return True\n '''\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n table = collections.defaultdict(int)\n for num in A:\n table[num] += 1\n A.sort()\n for num in A:\n if table[num] == 0:\n continue\n pair = num * 2\n if num < 0:\n pair = num / 2\n if table[pair] < 1:\n return False\n table[num] -= 1\n table[pair] -= 1\n return True\n \n \n \n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n count=collections.Counter(A)\n for x in sorted(A,key=abs):\n if count[x]==0:\n continue\n if count[2*x]==0:\n return False\n count[x]-=1\n count[2*x]-=1\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n \n \n ## Time Complexity: O(N LOG N) , Space: O(N)\n count = collections.Counter(A)\n for x in sorted(A, key = abs):\n if count[x] == 0: continue\n if count[2*x] == 0: return False\n count[x] -= 1\n count[2*x] -= 1\n\n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n count = Counter(A)\n for x in sorted(A, key = abs):\n if count[x] == 0: continue\n if count[2*x] == 0: return False\n count[x] -= 1\n count[2*x] -= 1\n\n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n # Array of Doubled Pairs 9/24 8/31/20\n # 1:43 9/1/2020\n# c = collections.Counter(A)\n# for x in sorted(c, key=abs):\n# if c[x] > c[x * 2]:\n# return False\n# c[x*2] -= c[x]\n \n# return True\n \n\n \n A = [abs(num) for num in A ]\n A.sort()\n dic = collections.defaultdict(collections.deque)\n for i, num in enumerate(A):\n dic[num].append(i)\n \n visited = [0]*len(A)\n cnt = 0\n i = 0\n # while cnt < len(A) // 2 :\n while i < len(A):\n if visited[i]:\n i += 1\n continue\n val, val_double = A[i], 2 * A[i]\n if val_double in dic and dic[val_double]:\n if val not in dic or not dic[val]:\n return False\n dic[val].popleft()\n if not dic[val_double]:\n return False\n index = dic[val_double].popleft()\n visited[index] = 1\n \n else:\n return False\n i += 1\n # cnt += 1\n \n return True\n \n# A = [abs(num) for num in A ]\n# A.sort()\n# dic = collections.defaultdict(int)\n# for num in A:\n# dic[num] += 1\n \n# visited = [0]*len(A)\n# cnt = 0\n# i = 0\n# while cnt < len(A) // 2 :\n# if visited[i]:\n# i += 1\n# continue\n# val_small = A[i]\n# if 2*val_small in dic:\n# dic[2*val_small] -= 1\n# dic[val_small] -= 1\n# if dic[2*val_small] < 0 or dic[val_small] < 0:\n# return False\n# search_index = A.index(2*val_small, i+1)\n# while visited[search_index]:\n# search_index = A.index(2*val_small, search_index+1)\n# visited[search_index] = 1\n# else:\n# return False\n# i += 1\n# cnt += 1\n \n# return True\n \n\n \n \n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n counts = collections.Counter(A)\n count = 0\n A.sort()\n for num in A: #range(0,len(A)//2):\n #num = A[i] \n if counts[num] and counts[num * 2]:\n counts[num*2]-=1\n counts[num]-=1\n count+=1\n return count*2 == len(A) ","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n counter = collections.Counter(A)\n for e in sorted(A, key=abs):\n if 2*e in counter and counter[2*e] > 0 and counter[e] > 0: \n counter[e] -= 1\n counter[2*e] -= 1\n print(counter)\n return sum(counter.values()) == 0","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n A.sort()\n seen = Counter()\n for num in A:\n if num>0 and num%2:\n seen[num]+=1\n continue\n elem = 2*num if num<0 else num//2\n if seen[elem]>0:\n seen[elem]-=1\n else:\n seen[num]+=1\n\n if sum(seen.values()):\n return False\n return True","from collections import Counter\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n # if len(A)%2==1:\n # return False\n # counter = Counter(A)\n # # print(counter)\n # Skey = set(counter.keys())\n # key = counter.keys()\n # for i in key:\n # if 2*i in Skey:\n # counter[i]=0\n # counter[i*2]-=counter[i]\n # val = list(counter.values())\n # print(val)\n # for i in val:\n # if i !=0:\n # return False\n # return True\n \n cnt = collections.Counter(A)\n for a in sorted(A, key = abs):\n if cnt[a] and cnt[a * 2]:\n cnt[a] -= 1\n cnt[a * 2] -= 1 \n return all(cnt[a] == 0 for a in A)","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n cache=collections.Counter(A)\n c_list=sorted(cache, key=lambda x: abs(x))\n print(cache, c_list)\n for x in c_list:\n if cache[x]>cache[2*x]:\n return False\n cache[2*x]-=cache[x]\n return True","import numpy as np\n\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n A.sort()\n statdict = {}\n flag = True\n# print(A)\n for i in A:\n# print(statdict)\n if i in statdict:\n statdict[i] = statdict[i] + 1\n elif i < 0:\n if i*2 in statdict:\n statdict[i*2] = statdict[i*2] - 1\n if statdict[i*2] == 0:\n statdict.pop(i*2)\n else:\n statdict[i] = 1\n else:\n if (i%2 == 0) and i/2 in statdict:\n statdict[int(i/2)] = statdict[int(i/2)] - 1\n if statdict[int(i/2)] == 0:\n statdict.pop(int(i/2))\n else:\n statdict[i] = 1\n return (len(statdict) == 0) or (len(statdict) == 1 and 0 in statdict and statdict[0] % 2 == 0)","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n c = collections.Counter(A)\n \n for i in sorted(A, key=abs):\n if c[i] and c[i*2]:\n c[i] -= 1\n c[i*2] -= 1\n \n return all(c[i] == 0 for i in A)\n \n \n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n B = []\n for x in A:\n if x>0:\n B.append(x)\n else:\n B.append(-x)\n count = collections.Counter(B)\n for x in sorted(B):\n if count[x] == 0: continue\n if count[2*x] == 0: return False\n else:\n count[x] -=1\n count[2*x] -=1\n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n \n D1 = collections.Counter()\n D2 = collections.Counter()\n zero = 0\n \n for a in A:\n if a < 0:\n D1[a] += 1\n else:\n D2[a] += 1\n \n for d in sorted(D1, reverse=1):\n if D1[d]:\n if D1[ d*2 ] < D1[d]:\n return False\n D1[ d*2 ] -= D1[d]\n\n for d in sorted(D2):\n if D2[d]:\n if D2[ d*2 ] < D2[d]:\n return False\n D2[ d*2 ] -= D2[d]\n \n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n n = len(A)\n #A[2*i+1] = 2*A[2*i]\n #[-2,-4,2,4]\n #A[1] == 2*A[0]\n #A[3] == 2*A[2]\n neg = sorted(list([x for x in A if x<0]))\n pos = sorted(list([x for x in A if x>0]), reverse=True)\n nl, pl = len(neg), len(pos)\n if nl % 2 or pl % 2: return False\n d1 = collections.Counter(neg)\n cnt = 0\n for i in range(nl):\n if d1[2*neg[i]] > 0:\n d1[2*neg[i]] -= 1\n d1[neg[i]] -= 1\n cnt += 1\n if cnt < nl // 2: return False \n d2 = collections.Counter(pos)\n cnt = 0\n for i in range(pl): \n if d2[2*pos[i]] > 0:\n print((pos[i]*2, pos[i]))\n d2[2*pos[i]] -= 1\n d2[pos[i]] -= 1\n cnt += 1\n if cnt < pl // 2: return False \n return True \n","class Solution(object):\n def canReorderDoubled(self, A):\n count = collections.Counter(A)\n for x in sorted(A, key = abs):\n if count[x] == 0: continue\n if count[2*x] == 0: return False\n count[x] -= 1\n count[2*x] -= 1\n\n return True","from collections import Counter\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n A.sort()\n d=Counter()\n c=[]\n e=[]\n for i in A:\n if(i<0):\n c.append(i)\n elif(i>=0):\n e.append(i)\n c.sort(reverse=True)\n c.extend(e)\n A=c\n print(A)\n for i in A:\n d[i]+=1\n if(d[0]%2!=0):\n return False\n d[0]=0\n for i in A:\n if(2*i in d)and(d[i]<=d[2*i]):\n d[2*i]-=d[i]\n d[i]=0\n elif(d[i]==0):\n continue\n else:\n return False\n return True\n \n \n \n \n","from collections import Counter\nfrom typing import List\n\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n d = dict()\n num_zeros = 0\n for x in A:\n if x == 0:\n num_zeros += 1\n continue\n x = abs(x)\n y = x\n while y % 2 == 0:\n y //= 2\n if y in d:\n d[y].update([x])\n else:\n d[y] = Counter([x])\n \n if num_zeros % 2:\n return False\n\n for base, counter in d.items():\n keys = sorted(counter)\n for key in keys:\n if counter[key] <= counter[2 * key]:\n counter[2 * key] -= counter[key]\n counter[key] -= counter[key]\n else:\n return False\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n c=collections.Counter(A)\n \n for x in sorted(A,key=abs):\n if c[x]==0:\n continue\n if c[2*x]==0:\n return False\n c[x]-=1\n c[2*x]-=1\n return True\n","# 20201007 12:08 选参考答案\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n cache=Counter(A)\n c_list=sorted(list(cache),key=abs)\n for x in c_list:\n if cache[x]>cache[2*x]:\n return False\n cache[2*x]-=cache[x]\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n counter=collections.Counter(A)\n counter=dict(sorted(counter.items(),key=lambda x:abs(x[0])))\n nums=[]\n for num in counter.keys():\n for _ in range(counter[num]):\n nums.append(num)\n for num in nums:\n if counter[num]:\n if 2*num in counter and counter[2*num]!=0:\n counter[num]-=1\n counter[num*2]-=1\n else:\n return False\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n count = collections.Counter(A)\n for x in sorted(A, key = abs):\n if count[x] == 0: continue\n if count[2*x] == 0: return False\n count[x] -= 1\n count[2*x] -= 1\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n if len(A) == 0 :\n return True\n \n mydict = {}\n for _ in range(0,len(A)):\n if A[_] in mydict:\n mydict[A[_]] += 1\n else:\n mydict[A[_]] = 1\n \n A_sorted = sorted(A)\n \n #print(A_sorted)\n #print(mydict)\n not_valid = set()\n for num in A_sorted:\n if len(mydict) == 0:\n return True \n if num in not_valid:\n continue\n \n if (2 * num) in mydict and num in mydict:\n double = 2*num\n mydict[num] -= 1\n mydict[double] -= 1\n\n if mydict[num] == 0:\n mydict.pop(num)\n not_valid.add(num)\n #deals with duplicates\n if num == double:\n continue\n elif mydict[2*num] == 0:\n mydict.pop(2*num)\n not_valid.add(2*num)\n elif (num/2 in mydict and num in mydict):\n half = num/2\n mydict[num] -= 1\n mydict[num/2] -= 1\n\n if mydict[num] == 0:\n mydict.pop(num)\n not_valid.add(num)\n if mydict[num/2] == 0:\n mydict.pop(num/2)\n not_valid.add(num/2)\n else:\n return False","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n \n # Divide an conquer\n # Sort items according to their magnitude\n # For each item, make sure it's double exists later in the list\n # When a double is used, mark it with a mask\n \n used = [False]*len(A)\n A.sort(key = lambda n: abs(n))\n bank = collections.Counter(A)\n \n for num in A:\n \n if bank[num] == 0:\n continue\n \n bank[num] -= 1\n if bank.get(2*num, 0) == 0:\n return False\n bank[2*num] -= 1\n \n return True\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n","from collections import Counter\n\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n # Greedy\n # Time complexity: O(NlogN)\n # Space complexity: O(N)\n count = Counter(A)\n for x in sorted(A, key=abs):\n if count[x] == 0: continue\n if count[2 * x] == 0: return False\n count[x] -= 1\n count[2 * x] -= 1\n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n A_sorted = sorted(A, key=abs)\n count = collections.Counter(A)\n for a in A_sorted:\n if count[a] == 0: \n continue\n if count[a * 2] == 0:\n return False\n count[a] -= 1\n count[a * 2] -= 1\n \n return True","class Solution(object):\n def canReorderDoubled(self, A):\n count = collections.Counter(A)\n for x in sorted(A, key = abs):\n if count[x] == 0: continue\n if count[2*x] == 0: return False\n count[x] -= 1\n count[2*x] -= 1\n\n return True\n","class Solution(object):\n def canReorderDoubled(self, A):\n count = collections.Counter(A)\n for x in sorted(A, key = abs):\n if count[x] == 0: continue\n if count[2*x] == 0: return False\n count[x] -= 1\n count[2*x] -= 1\n\n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n c = collections.Counter(A)\n for k in sorted(c, key=abs):\n if c[k] > c.get(2*k, 0):\n return False\n c[2*k] -= c[k]\n \n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n st = {}\n A = sorted(A,reverse=True)\n for i in A:\n if i in st:st[i]+=1\n else: st[i] = 1\n #print(st)\n for num in A:\n if (num*2) in st and st[num] > 0 and st[(num*2)] > 0:\n st[num*2]-=1\n st[num]-=1\n #print(num,st)\n for num in st:\n if st[num] > 0:return False\n return True\n","from collections import Counter\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n count_a = Counter(A)\n A.sort(key=lambda x: abs(x))\n for elem in A:\n if count_a[elem] == 0: continue\n if count_a[elem * 2] == 0: return False\n count_a[elem] -= 1\n count_a[elem * 2] -= 1\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n count = collections.Counter(A)\n for x in sorted(A, key = abs):\n if count[x] == 0:\n continue\n if count[x*2] == 0:\n return False\n count[x] -= 1\n count[2*x] -= 1\n \n return True\n \n \n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n \n A.sort() \n map = {}\n \n for item in A:\n if item in map : map[item] +=1\n else : map[item] =1\n \n for item in A:\n if map[item]==0 : continue\n if item <0 :\n if item/2 in map : \n if map[item/2]==0 : return False\n map[item] -=1\n map[item/2] -=1\n else : return False\n else :\n if item *2 in map:\n if map[2*item]==0: return False\n map[item] -=1\n map[item*2] -=1\n else : return False\n \n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n seen = dict()\n for x in A:\n if x not in seen:\n seen[x] = 0\n seen[x] += 1\n\n for x in sorted(seen, key=lambda x : x**2):\n if seen[x] == 0:\n continue\n if (2*x not in seen) or (seen[x] > seen[2*x]):\n return False\n else:\n seen[2*x] -= seen[x]\n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n count = collections.Counter(A)\n for x in sorted(A, key = abs):\n print(x)\n if count[x] == 0: continue\n if count[2*x] == 0: return False\n count[x] -= 1\n count[2*x] -= 1\n\n return True","from collections import Counter\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n a = sorted(A,key=lambda x:abs(x),reverse = True)\n b = dict(Counter(A))\n while a:\n \n aa = a.pop()\n if aa in b:\n\n b[aa] -= 1\n if b[aa]==0:\n del b[aa]\n\n if 2*aa in b:\n b[2*aa] -= 1\n else:\n return False\n if b[2*aa]==0:\n del b[2*aa]\n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n \n count = collections.Counter(A)\n for x in sorted(A, key = abs):\n if count[x] == 0: continue\n if count[2*x] == 0: return False\n count[x] -= 1\n count[2*x] -= 1\n\n return True\n \n \n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n counter = collections.Counter(A)\n for x in sorted(counter,key=abs):\n if counter[x] > counter[2*x]:\n return False\n counter[2*x] -= counter[x]\n return True ","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n if len(A) % 2 == 1:\n return False\n \n count = collections.defaultdict(int)\n for num in A:\n count[num] += 1\n A.sort()\n for num in A:\n if count[num] > 0:\n double = num * 2\n if double in count and count[double] > 0:\n # print(\\\"found\\\", double)\n count[num] -= 1 \n count[double] -= 1\n \n for num in count:\n if count[num] != 0:\n return False\n return True\n \n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n c = collections.Counter(A)\n for x in sorted(c, key=abs):\n if c[x] > c[2 * x]:\n return False\n c[2 * x] -= c[x]\n return True\n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n d={}\n for i in A:\n if i in d:\n d[i]+=1\n else:\n d[i]=1\n A.sort()\n \n if 0 in d:\n if d[0]%2!=0:\n return False\n d.pop(0)\n \n for i in A:\n #print(i,d)\n if i not in d:\n continue\n \n if i*2 in d:\n if d[i]>d[i*2]:\n d[i]-=d[i*2]\n d[i*2]=0\n else:\n d[i*2]-=d[i]\n d[i]=0\n if d[i]==0:\n d.pop(i)\n if d[i*2]==0:\n d.pop(i*2)\n elif i%2==0 and i//2 in d:\n if d[i]>d[i//2]:\n d[i]-=d[i//2]\n d[i//2]=0\n else:\n d[i//2]-=d[i]\n d[i]=0\n if d[i]==0:\n d.pop(i)\n if d[i//2]==0:\n d.pop(i//2)\n else:\n return False\n return len(d)==0\n","import collections\n\nclass Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n ''' Place all values into dicts and start counting from the bottom\n '''\n counter = collections.Counter(A)\n \n for v in sorted(counter, key = abs):\n if counter[2 * v] < counter[v]:\n return False\n counter[2 * v] -= counter[v]\n return True\n \n \n \n \n \n \n","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n A = sorted(A, key=lambda x: abs(x))\n M = Counter()\n \n for e in A:\n M[e] += 1\n \n # print(M)\n # print(A)\n \n for e in A:\n # print(e, M[2*e], M)\n if M[e] and M[2*e]:\n M[2*e] -= 1\n M[e] -= 1\n # print('->', 2*e, M[2*e])\n elif M[e]:\n # print(M, e)\n return False\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n count = collections.Counter(A)\n for x in sorted(A, key = abs):\n if count[x]==0: continue\n if count[2*x]==0: return False\n count[x] -= 1\n count[2*x] -= 1\n return True","class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n dic=collections.defaultdict(int)\n for i in range(len(A)):\n dic[A[i]]+=1\n ki=list(dic.keys())\n ki.sort(key=lambda x:abs(x))\n for k in ki:\n if dic[2*k]<dic[k]:\n return False\n dic[2*k]-=dic[k]\n dic[k]=0\n return True"],"string":"[\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cache=Counter(A)\\n c_list=sorted(list(cache),key=abs)\\n for x in c_list:\\n if cache[x]>cache[2*x]:\\n return False\\n cache[2*x]-=cache[x]\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cache=collections.Counter(A)\\n c_list=sorted(list(cache),key=abs)\\n for x in c_list:\\n if cache[x]>cache[2*x]:\\n return False\\n cache[2*x]-=cache[x]\\n return True\",\n \"from collections import Counter\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if len(A) % 2 == 1: return False\\n if not A: return True\\n nums = sorted(set(A))\\n nums = [x for x in nums if x < 0][::-1] + [x for x in nums if x >= 0]\\n c = Counter(A)\\n done = set()\\n for num in nums:\\n if num in done:\\n continue\\n if 2*num not in c:\\n return False\\n if c[2*num] < c[num]:\\n return False\\n \\n c[2*num] -= c[num]\\n if c[2*num] == 0: \\n done.add(2*num)\\n \\n c[num] = 0\\n done.add(num)\\n \\n return True\",\n \"import collections\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n ''' Place all values into dicts and start counting from the bottom\\n '''\\n if not A:\\n return True\\n \\n pos = collections.defaultdict(int)\\n neg = collections.defaultdict(int)\\n zero = 0\\n \\n # O(n)\\n for v in A:\\n if v > 0:\\n pos[v] += 1\\n if v < 0:\\n neg[-v] += 1\\n if v == 0:\\n zero += 1\\n \\n b = self.check(pos)\\n if not b:\\n return False\\n b = self.check(neg)\\n if not b:\\n return False\\n \\n return zero % 2 == 0\\n \\n \\n def check(self, d):\\n \\n # worst case O(n), done n times\\n while d:\\n v = min(d) \\n if not 2 * v in d:\\n return False\\n if d[v] > d[2 * v]:\\n return False\\n\\n elif d[v] == d[2*v]:\\n del d[v]\\n del d[2*v]\\n else:\\n d[2*v] -= d[v]\\n del d[v]\\n return True\\n \\n \\n \\n \\n \\n\",\n \"\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n ''' Place all values into dicts and start counting from the bottom\\n '''\\n if not A:\\n return True\\n \\n pos = {}\\n neg = {}\\n zero = 0\\n \\n # O(n)\\n for v in A:\\n if v > 0:\\n pos[v] = pos.get(v, 0) + 1\\n if v < 0:\\n neg[-v] = neg.get(-v, 0) + 1\\n if v == 0:\\n zero += 1\\n \\n b = self.check(pos)\\n if not b:\\n return False\\n b = self.check(neg)\\n if not b:\\n return False\\n \\n return zero % 2 == 0\\n \\n \\n def check(self, d):\\n \\n # worst case O(n), done n times\\n while d:\\n v = min(d) \\n if not 2 * v in d:\\n return False\\n if d[v] > d[2 * v]:\\n return False\\n\\n elif d[v] == d[2*v]:\\n del d[v]\\n del d[2*v]\\n else:\\n d[2*v] -= d[v]\\n del d[v]\\n return True\\n \\n \\n \\n \\n \\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n i = 0\\n j = 0\\n A.sort()\\n while i < len(A) and A[i] <= 0:\\n if A[i] % 2 != 0:\\n return False\\n while j < len(A) and A[j] < 0 and 2 * A[j] < A[i]:\\n j += 1\\n if j >= len(A) or 2 * A[j] > A[i]:\\n return False\\n A[j] = None\\n j += 1\\n i += 1\\n while i < len(A) and A[i] is None:\\n i += 1\\n \\n while i < len(A):\\n while j < len(A) and A[j] < 2 * A[i]:\\n j += 1\\n if j >= len(A) or A[j] > 2 * A[i]:\\n return False\\n A[j] = None\\n j += 1\\n i += 1\\n while i < len(A) and A[i] is None:\\n i += 1\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = {}\\n zero_count = 0\\n for num in A:\\n if num == 0:\\n zero_count += 1\\n elif num in count:\\n count[num] += 1\\n else:\\n count[num] = 1\\n if zero_count % 2 != 0:\\n return False\\n \\n A.sort()\\n for num in A:\\n double = num * 2\\n if num in count and double in count:\\n count[double] -= 1\\n count[num] -= 1\\n if count[double] == 0:\\n count.pop(double)\\n if count[num] == 0:\\n count.pop(num)\\n \\n return count == {}\\n \\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if len(A) % 2 == 1:\\n return False\\n \\n count = collections.defaultdict(int)\\n for num in A:\\n count[num] += 1\\n A.sort()\\n for num in A:\\n if count[num] > 0:\\n # print(f\\\\\\\"checking {num}\\\\\\\")\\n double = num * 2\\n # print(half, double)\\n\\n if double in count and count[double] > 0:\\n # print(\\\\\\\"found\\\\\\\", double)\\n count[num] -= 1 \\n count[double] -= 1\\n # print(count)\\n # print(\\\\\\\"all good\\\\\\\")\\n # print(count) \\n for num in count:\\n if count[num] != 0:\\n return False\\n return True\\n \\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = collections.Counter(A)\\n\\n for x in sorted(A, key=abs):\\n if(count[x] == 0):\\n continue\\n if(count[2*x] == 0):\\n return False\\n count[x] -= 1\\n count[2*x] -= 1\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cache=dict()\\n for a in A:\\n cache[a]=cache.get(a,0)+1\\n while len(cache)>0:\\n temp=[abs(k) for k in cache.keys()]\\n curr=min(temp)\\n if curr==0:\\n if cache[0]%2>0:\\n return False\\n else:\\n cache.pop(0)\\n else:\\n if curr in cache:\\n if cache[curr]==0:\\n cache.pop(curr)\\n elif (2*curr not in cache) or cache[2*curr]<cache[curr]:\\n return False\\n else:\\n cache[2*curr]-=cache[curr]\\n cache.pop(curr)\\n if -curr in cache:\\n if cache[-curr]==0:\\n cache.pop(-curr)\\n elif (-2*curr not in cache) or cache[-2*curr]<cache[-curr]:\\n return False\\n else:\\n cache[-2*curr]-=cache[-curr]\\n cache.pop(-curr)\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n ''' Place all values into dicts and start counting from the bottom\\n '''\\n counter = collections.Counter(A)\\n \\n for v in sorted(counter, key = abs):\\n if counter[2 * v] < counter[v]:\\n return False\\n counter[2 * v] -= counter[v]\\n return True\\n \\n \\n \\n \\n \\n \\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n counts = defaultdict(int)\\n for x in sorted(A):\\n counts[x] += 1\\n if x < 0 and x * 2 in counts:\\n while counts[x] > 0 and counts[x * 2] > 0:\\n counts[x] -= 1\\n counts[x * 2] -= 1\\n if x >= 0 and x / 2 in counts:\\n while counts[x] > 0 and counts[x / 2] > 0:\\n counts[x] -= 1\\n counts[x / 2] -= 1\\n return sum(c for v, c in counts.items()) == 0\",\n \"import collections\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n ''' Place all values into dicts and start counting from the bottom\\n '''\\n if not A:\\n return True\\n \\n counter = collections.Counter(A)\\n \\n for v in sorted(counter, key = abs):\\n if counter[2 * v] < counter[v]:\\n return False\\n counter[2 * v] -= counter[v]\\n return True\\n \\n \\n \\n \\n \\n \\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n result = True\\n numLen = len(A)\\n C = Counter(A)\\n val = list(C.keys())\\n val.sort()\\n for i in range(len(val)):\\n if val[i] < 0:\\n if val[i] % 2 == 0:\\n if val[i]/2 in val and C[val[i]/2] >= C[val[i]]:\\n C[val[i] / 2] = C[val[i]/2] - C[val[i]]\\n C[val[i]] = 0\\n else:\\n result = False\\n # break\\n else:\\n if val[i] * 2 in val and C[val[i]*2] >= C[val[i]]:\\n C[val[i] * 2] = C[val[i]*2] - C[val[i]]\\n C[val[i]] = 0\\n else:\\n result = False\\n # Break\\n nums = list(C.values())\\n if nums == [0]*len(nums):\\n result = True\\n else:\\n result = False\\n return result\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n dd = Counter(A)\\n A.sort(key = lambda a : abs(a))\\n\\n for a in A:\\n if a in dd and dd[a]:\\n if 2*a in dd and dd[2*a]:\\n dd[a] -= 1\\n dd[2*a] -= 1\\n if dd[a] == 0:\\n del dd[a]\\n if dd[a*2] == 0:\\n del dd[a*2]\\n else:\\n return False\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n pos = [x for x in A if x >= 0]\\n neg = [x for x in A if x < 0]\\n for L in (pos,neg):\\n count = collections.Counter(L)\\n for x in sorted(L, key=abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort(key=lambda x: (x>0, abs(x)))\\n right = 1\\n size = len(A)\\n for i in range(size):\\n if A[i] is None:\\n continue\\n\\n while right < size and 2 * A[i] != A[right]:\\n right += 1\\n\\n if right == size:\\n return False\\n\\n A[right] = None\\n\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, arr):\\n arr.sort()\\n negl = [x for x in arr if x < 0][::-1]\\n posl = [x for x in arr if x >= 0]\\n cnt = {}\\n for x in arr:\\n if x not in cnt:\\n cnt[x] = 1\\n else:\\n cnt[x] = cnt[x] + 1\\n\\n while True :\\n x = None\\n if negl != [] :\\n x = negl.pop(0)\\n else:\\n if posl != [] :\\n x = posl.pop(0)\\n else:\\n break\\n if cnt[x] == 0 :\\n continue\\n y = x * 2\\n if y not in cnt:\\n return False\\n else:\\n if cnt[y] > 0 and cnt[x] > 0:\\n cnt[y] = cnt[y] - 1\\n cnt[x] = cnt[x] - 1\\n else:\\n return False\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n seen = {}\\n \\n A.sort()\\n for i in A:\\n #Logic for checking half and double of number\\n if i/2 in seen:\\n seen[i/2] -= 1\\n if seen[i/2] == 0:\\n del seen[i/2]\\n \\n elif 2*i in seen:\\n seen[2*i] -= 1\\n if seen[2*i] == 0:\\n del seen[2*i]\\n else:\\n if i in seen:\\n seen[i] += 1\\n else:\\n seen[i] = 1\\n \\n return not bool(seen)\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n counter=Counter(A)\\n for a in sorted(A, key=abs):\\n if counter[a]==0:\\n continue\\n if counter[2*a]==0:\\n return False\\n counter[a]-=1\\n counter[2*a]-=1\\n return True\\n\",\n \"import collections\\nclass Solution:\\n def canReorderDoubled(self, a: List[int]) -> bool:\\n count=collections.Counter(a)\\n for elem in sorted(a,key=abs):\\n if count[elem]==0:\\n continue\\n if count[2*elem]==0:\\n return False\\n count[elem]-=1\\n count[2*elem]-=1\\n return True\\n\",\n \"from collections import defaultdict\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if not A:\\n return True\\n \\n count = 0\\n d = defaultdict(int)\\n for i in A:\\n d[i] += 1\\n \\n for num in sorted(A):\\n if num*2 in d and d[num] and d[num*2]:\\n d[num] -= 1\\n d[num*2] -= 1\\n count += 1\\n \\n return count == (len(A) // 2)\\n\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n # Eliminate zero\\n negative = []\\n positive = []\\n \\n zero_numbers = 0\\n for a in A:\\n if a < 0:\\n negative.append(abs(a))\\n elif a > 0:\\n positive.append(a)\\n else:\\n zero_numbers += 1\\n \\n if zero_numbers % 2:\\n return False\\n \\n negative.sort()\\n positive.sort()\\n # print(negative, positive)\\n \\n return self.helper(negative) and self.helper(positive)\\n \\n def helper(self, nums): \\n while nums:\\n cur_num = nums[0]\\n idx = self.binarySearch(nums, 2 * cur_num)\\n # print('helper',nums[0], idx)\\n if idx == -1:\\n return False\\n nums.pop(idx)\\n nums.pop(0)\\n if len(nums) == 1:\\n return False\\n \\n return True\\n \\n def binarySearch(self, nums, key):\\n \\n head = 0\\n tail = len(nums) - 1\\n # print(nums, key)\\n \\n while head <= tail:\\n mid = (head + tail)//2\\n if nums[mid] > key:\\n tail = mid - 1\\n elif nums[mid] < key:\\n head = mid + 1\\n else:\\n return mid\\n \\n return -1\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = collections.Counter(A)\\n for a in sorted(count, key = lambda x: abs(x)):\\n if count[a] > count[2 * a]:\\n return False\\n count[2 * a] -= count[a]\\n return True\",\n \"import numpy as np\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n a = np.array(sorted(A))\\n non_pos_idxs = np.where(a >= 0)[0]\\n if len(non_pos_idxs) > 0:\\n non_pos_idx = non_pos_idxs[0]\\n else:\\n non_pos_idx = len(a)\\n b = a[:non_pos_idx][::-1]\\n a = a[non_pos_idx:]\\n if len(b) % 2 != 0:\\n return False\\n \\n if not self.check_doubled(a):\\n return False\\n if not self.check_doubled(b):\\n return False\\n return True\\n \\n def check_doubled(self, a):\\n if len(a) == 0:\\n return True\\n count_dict = {}\\n for val in a:\\n if count_dict.get(val, 0) > 0:\\n count_dict[val] -= 1\\n else:\\n count_dict[2 * val] = count_dict.get(2 * val, 0) + 1\\n for val in list(count_dict.values()):\\n if val > 0:\\n return False\\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n seen = {}\\n A.sort()\\n for ind,i in enumerate(A):\\n #Logic for checking half and double of number\\n if i/2 in seen:\\n seen[i/2] -= 1\\n if seen[i/2] == 0:\\n del seen[i/2]\\n \\n elif 2*i in seen:\\n seen[2*i] -= 1\\n if seen[2*i] == 0:\\n del seen[2*i]\\n else:\\n if i in seen:\\n seen[i] += 1\\n else:\\n seen[i] = 1\\n \\n print(seen)\\n \\n return not bool(seen)\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if not A:\\n return True\\n d=defaultdict(int)\\n for x in A:\\n d[x]+=1\\n n=len(A)//2\\n A.sort()\\n for x in A:\\n if d[x]>0:\\n if 2*x in d and d[2*x]>0:\\n d[2*x]-=1\\n d[x]-=1\\n n-=1\\n if n==0:\\n return True\\n #print(x,d,n)\\n return False\\n \\n \\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort()\\n d = collections.defaultdict(int)\\n for a in A:\\n if d[2*a] > 0:\\n d[2*a] -= 1\\n elif d[a/2] > 0:\\n d[a/2] -= 1\\n else:\\n d[a] += 1\\n return not any(d.values())\\n\",\n \"from collections import Counter\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n counts = [0]*(10**5+1)\\n for a in A:\\n if a >= 0:\\n counts[a] += 1\\n for i in range(10**5+1):\\n while counts[i] != 0:\\n counts[i] -= 1\\n if counts[i] < 0:\\n return False\\n counts[2*i] -= 1\\n if counts[2*i] < 0:\\n return False\\n if not all(n == 0 for n in counts):\\n return False\\n\\n for a in A:\\n if a < 0:\\n counts[-a] += 1\\n for i in range(10**5+1):\\n while counts[i] != 0:\\n counts[i] -= 1\\n if counts[i] < 0:\\n return False\\n counts[2*i] -= 1\\n if counts[2*i] < 0:\\n return False\\n if not all(n == 0 for n in counts):\\n return False\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, arr: List[int]) -> bool:\\n dicti=dict()\\n for var in arr:\\n if var in list(dicti.keys()):\\n dicti[var]+=1\\n else:\\n dicti[var]=1\\n arr.sort(key=lambda x: abs(x))\\n for var in arr:\\n if dicti[var]==0:\\n continue\\n if(2*var not in list(dicti.keys())):\\n return False\\n if dicti[2*var]<=0:\\n return False\\n dicti[var]-=1\\n dicti[2*var]-=1\\n return True\\n\\n\",\n \"class Solution:\\n def get_result(self, sl, d):\\n for k in sl:\\n if d[k]==0:\\n continue\\n if 2*k not in d:\\n return False\\n v = d[k]\\n v2 = d[2*k]\\n if v>v2:\\n return False\\n d[k] -= v\\n d[2*k] -= v\\n return True\\n \\n def canReorderDoubled(self, A: List[int]) -> bool:\\n d = dict()\\n num_zeros = 0\\n for a in A:\\n if a==0:\\n num_zeros += 1\\n continue\\n if a in d:\\n d[a] += 1\\n else:\\n d[a] = 1\\n neg = [k for k in list(d.keys()) if k<0]\\n pos = [k for k in list(d.keys()) if k>0]\\n if num_zeros%2!=0:\\n return False\\n sorted_pos = sorted(pos)\\n sorted_neg = sorted(neg, reverse=True)\\n res = self.get_result(sorted_pos, d)\\n if not res:\\n return False\\n res = self.get_result(sorted_neg, d)\\n if not res:\\n return False\\n return sum(list(d.values()))==0\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cnt = collections.Counter(A)\\n # It handles the case where there is odd number of 0, since the total number is even, there should be a number which cannot match because of the extra 0\\n for k in sorted(cnt, key=abs):\\n if cnt[k] > cnt[2*k]:\\n return False\\n \\n cnt[2*k] -= cnt[k]\\n \\n return True\",\n \"from collections import Counter\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n # Greedy\\n # Time complexity: O(NlogN)\\n # Space complexity: O(N)\\n # count = Counter(A)\\n # for x in sorted(A, key=abs):\\n # if count[x] == 0: continue\\n # if count[2 * x] == 0: return False\\n # count[x] -= 1\\n # count[2 * x] -= 1\\n # return True\\n\\n\\n count = Counter(A)\\n for x in sorted(count, key=abs):\\n if count[x] > count[2 * x]:\\n return False\\n count[2 * x] -= count[x]\\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = collections.Counter(A)\\n for i in sorted(count, key=abs):\\n count[2*i] -= count[i]\\n if count[2*i] < 0:\\n return False\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n freq = dict()\\n for i in A:\\n freq[i] = freq.get(i, 0) + 1\\n\\n for k in sorted(list(freq.keys()), key=lambda x: abs(x)):\\n if freq[k] == 0: continue\\n if freq[k] > freq.get(2*k, 0):\\n return False\\n freq[2*k] -= freq[k]\\n \\n return True\\n\",\n \"from collections import Counter\\n \\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if not A: return True\\n c = Counter(A)\\n keys = sorted(c.keys())\\n for k in keys:\\n if k == 0:\\n if c[k] % 2 == 0:\\n c[k] = 0\\n else:\\n return False\\n if k < 0 and c[k] > 0:\\n if k/2 in c:\\n c[k/2] -= c[k]\\n c[k] = 0\\n if k > 0 and c[k] > 0:\\n if k*2 in c:\\n c[k*2] -= c[k]\\n c[k] = 0\\n \\n return set(c.values()) == {0}\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cache=collections.Counter(A)\\n c_list=sorted(list(cache),key=lambda x: (abs(x),x))\\n for x in c_list:\\n if cache[x]>cache[2*x]:\\n return False\\n cache[2*x]-=cache[x]\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n d = collections.Counter(A)\\n if 0 in d:\\n if d[0] & 1 == 1:\\n return False\\n d.pop(0)\\n\\n keys = sorted(d.keys())\\n for i in keys:\\n if i in d:\\n if i < 0:\\n if i / 2 not in d:\\n return False\\n if d[i] > d[i/2]:\\n return False\\n d[i/2] -= d[i]\\n if d[i/2] == 0:\\n d.pop(i/2)\\n d.pop(i)\\n else:\\n if i * 2 not in d:\\n return False\\n if d[i] > d[i*2]:\\n return False\\n d[i*2] -= d[i]\\n if d[i*2] == 0:\\n d.pop(i*2)\\n d.pop(i)\\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort()\\n B = OrderedDict()\\n for x in A:\\n if x in B:\\n B[x] += 1\\n else:\\n B[x] = 1\\n \\n while B:\\n x = next(iter(B))\\n freq = B.pop(x)\\n \\n #print(x,freq)\\n \\n if x<0:\\n if x%2:\\n return False\\n if (x//2 not in B) or B[x//2]<freq:\\n return False\\n B[x//2] -= freq\\n if B[x//2] == 0:\\n B.pop(x//2)\\n \\n elif x==0:\\n if freq%2:\\n return False\\n \\n else:\\n if (x*2 not in B) or B[x*2]<freq:\\n return False\\n B[x*2] -= freq\\n if B[x*2] == 0:\\n B.pop(x*2)\\n \\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n c = collections.Counter(A)\\n cc = sorted(c, key=abs)\\n #print(cc)\\n for x in cc:\\n #print(str(x), end=\\\\\\\": \\\\\\\")\\n #print(c)\\n if c[x] > c[2 * x]:\\n return False\\n c[2 * x] -= c[x]\\n #print(c)\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n neg = dict()\\n pos = dict()\\n zero = 0\\n for n in A:\\n if n < 0:\\n if -n not in neg:\\n neg[-n] = 0\\n neg[-n] += 1\\n elif n >0:\\n if n not in pos:\\n pos[n] = 0\\n pos[n] += 1\\n else:\\n zero += 1\\n if zero % 2 != 0:\\n return False\\n #print(pos,neg)\\n def helper(nums):\\n num_sorted = sorted(list(nums.keys()),reverse = True)\\n while num_sorted:\\n a = num_sorted.pop()\\n if nums[a] == 0:\\n continue\\n if 2*a not in nums or nums[a]>nums[2*a]:\\n return False\\n nums[2*a] -= nums[a]\\n return True\\n return helper(pos) and helper(neg)\\n \\n\",\n \"from collections import defaultdict\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort()\\n s = defaultdict(int)\\n for a in A:\\n if a <= 0:\\n if 2 * a in s:\\n s[2*a] -= 1\\n if not s[2*a]:\\n del s[2*a]\\n else:\\n s[a] += 1\\n else:\\n if a % 2 == 0 and a // 2 in s:\\n s[a // 2] -= 1\\n if not s[a // 2]:\\n del s[a // 2]\\n else:\\n s[a] += 1\\n return not s\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n hashtable = {}\\n zero_count = 0\\n for i in range(len(A)):\\n if A[i]==0:\\n zero_count+=1\\n continue\\n if A[i] in list(hashtable.keys()):\\n hashtable[A[i]]+=1\\n \\n else:\\n hashtable[A[i]]=1\\n \\n \\n if zero_count%2==1:\\n return False\\n else:\\n key_list = []\\n pair_count = 0\\n for key in list(hashtable.keys()):\\n key_list.append(key)\\n \\n key_list.sort()\\n \\n for key in key_list:\\n if key%2==0 and key//2 in list(hashtable.keys()):\\n m = min(hashtable[key],hashtable[key//2])\\n hashtable[key]-=m\\n hashtable[key//2]-=m\\n pair_count+=m\\n \\n if pair_count*2 + zero_count==len(A):\\n return True\\n else:\\n return False\\n \\n \\n\",\n \"from collections import Counter\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n # O(NlogN) time \\n # O(N) space\\n \\n if not A:\\n return True\\n \\n counts = Counter(A) \\n \\n for key in sorted(counts.keys()):\\n if counts[key] == 0:\\n continue\\n \\n factor = .5 if key < 0 else 2\\n if counts[key] > counts[factor*key]:\\n return False\\n counts[factor*key] -= counts[key]\\n \\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort(key=lambda x: abs(x))\\n freq = dict()\\n\\n for i in A:\\n freq[i] = freq.get(i, 0) + 1\\n\\n for k in sorted(list(freq.keys()), key=lambda x: abs(x)):\\n if freq[k] == 0: continue\\n if freq[k] > freq.get(2*k, 0):\\n return False\\n freq[2*k] -= freq[k]\\n \\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n D = {}\\n for x in A:\\n D[x] = D.get(x, 0) + 1\\n \\n D = dict([x for x in sorted(list(D.items()), key =lambda x:x[0] )])\\n \\n for x in D:\\n while D[x] > 0:\\n D[x] -= 1\\n if x <= 0:\\n pair_x = x / 2\\n else:\\n pair_x = x * 2\\n \\n if D.get(pair_x, 0) > 0:\\n D[pair_x] -= 1\\n else:\\n return False\\n \\n return True\\n \\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cnt = collections.Counter(A)\\n for k in sorted(cnt, key=abs):\\n a = cnt[k]\\n if cnt[k] == 0:\\n continue\\n b = cnt.get(2 * k, 0)\\n if b < a:\\n return False\\n cnt[2 * k] -= a\\n \\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n def update_map(count, small, large):\\n small_count = count[small]\\n large_count = count[large]\\n min_count = min(small_count, large_count)\\n \\n count[small] += -min_count\\n if small != large:\\n count[large] += -min_count\\n \\n if not A:\\n return True\\n element_count = {}\\n ordered_elements = list(set(A))\\n ordered_elements.sort()\\n \\n for number in A:\\n if number not in element_count:\\n element_count[number] = 0\\n element_count[number] += 1\\n \\n for number in ordered_elements:\\n number_count = element_count[number]\\n double_number = number * 2\\n if double_number in element_count:\\n update_map(element_count, number, double_number)\\n \\n for number in element_count:\\n if element_count[number] != 0:\\n return False\\n return True\\n \\n \\n\",\n \"from collections import Counter\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n c=Counter(A)\\n A=sorted(A)\\n for num,v in sorted(list(c.items()), key= lambda item:item[0]):\\n if num>0 and c[num]>0:\\n if c[num]!=0 and c[num]>c[2*num]:\\n return False\\n c[2*num]-=c[num]\\n c[num]=0\\n elif num<0 and c[num]>0:\\n if num%2==1:\\n return False\\n if c[num]!=0 and c[num]>c[num//2]:\\n return False\\n c[num//2]-=c[num]\\n c[num]=0\\n return True\\n \\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if not A:\\n return True\\n positive_heap = []\\n negative_heap = []\\n zero = 0\\n positive_d = defaultdict(int)\\n negative_d = defaultdict(int)\\n for i in A:\\n if i == 0:\\n zero += 1\\n elif i < 0:\\n heappush(negative_heap, -i)\\n negative_d[-i] += 1\\n else:\\n heappush(positive_heap, i)\\n positive_d[i] += 1\\n if zero % 2 != 0:\\n return False\\n if not self.check(positive_heap, positive_d):\\n return False\\n if not self.check(negative_heap, negative_d):\\n return False\\n return True\\n \\n def check(self, h, d):\\n for _ in range(len(h)):\\n i = heappop(h)\\n if d[i] == 0:\\n continue\\n if 2*i not in d:\\n return False\\n elif d[2*i] < d[i]:\\n return False\\n else:\\n d[2*i] -= d[i]\\n d[i] = 0\\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n zcount = 0\\n pos = []\\n neg = []\\n for n in A:\\n if n==0:\\n zcount+=1\\n elif n>0:\\n pos.append(n)\\n else:\\n neg.append(-n)\\n def verifypos(A):\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\\n return verifypos(pos) and verifypos(neg)\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = collections.Counter(A)\\n for x in sorted(A, key=abs):\\n if count[x] == 0:\\n continue\\n if x == 0 and x % 2:\\n return False\\n if count[x] > count[2 * x]:\\n return False\\n count[x], count[2 * x] = 0, count[2 * x] - count[x]\\n \\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n D = {}\\n for x in A:\\n D[x] = D.get(x, 0) + 1\\n D = dict([kv for kv in sorted(list(D.items()), key =lambda x:x[0] )])\\n \\n for x in D:\\n while D[x] > 0:\\n D[x] -= 1\\n if x <= 0:\\n pair_x = x / 2\\n else:\\n pair_x = x * 2\\n \\n if D.get(pair_x, 0) > 0:\\n D[pair_x] -= 1\\n else:\\n return False\\n \\n return True\\n \\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort()\\n dic = {}\\n for i in A:\\n if i % 2 == 0 and i/2 in dic:\\n i = i / 2\\n dic[i] -= 1\\n if dic[i] == 0:\\n del dic[i]\\n elif i * 2 in dic:\\n i = i * 2\\n dic[i] -= 1\\n if dic[i] == 0:\\n del dic[i]\\n else:\\n dic[i] = dic.setdefault(i, 0) + 1\\n continue\\n return len(dic) == 0\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n # https://blog.csdn.net/fuxuemingzhu/article/details/84925747\\n A.sort()\\n N = len(A)\\n count = collections.Counter(A)\\n for i in range(N):\\n if A[i] == 0 or A[i] not in count: continue\\n elif A[i] < 0:\\n if A[i] % 2 == 1 or count[A[i] / 2] == 0:\\n return False\\n else:\\n count[A[i] / 2] -= count[A[i]]\\n if count[A[i] / 2] == 0:\\n del count[A[i] / 2]\\n del count[A[i]]\\n else:\\n if count[A[i] * 2] == 0:\\n return False\\n else:\\n count[A[i] * 2] -= count[A[i]]\\n if count[A[i] * 2] == 0:\\n del count[A[i] * 2]\\n del count[A[i]]\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n c = collections.Counter(A)\\n for x in sorted(c):\\n if c[x] == 0: continue\\n\\n if c[x] < 0:\\n return False\\n if x == 0:\\n if c[x] % 2 != 0:\\n return False\\n else:\\n continue\\n if x > 0:\\n temp = 2*x\\n elif x % 2:\\n return False\\n else:\\n \\n temp = x//2\\n\\n\\n if c[temp] < c[x]:\\n return False\\n else:\\n c[temp] -= c[x]\\n\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n pos_set = set()\\n neg_set = set()\\n pos_dict = {}\\n neg_dict = {}\\n pos_count = 0\\n for num in A:\\n if num >= 0:\\n pos_set.add(num)\\n pos_dict[num] = 1 + pos_dict.get(num,0)\\n pos_count += 1\\n else:\\n neg_set.add(abs(num))\\n neg_dict[abs(num)] = 1 + neg_dict.get(abs(num),0)\\n if pos_count % 2 != 0:\\n return False\\n else:\\n return self.helper(pos_set,pos_dict) and self.helper(neg_set,neg_dict)\\n \\n def helper(self,set_,dict_):\\n sorted_ = sorted(list(set_))\\n for num in sorted_:\\n if num * 2 in sorted_ and num != 0:\\n small_ = dict_[num] \\n large_ = dict_[num * 2]\\n usage = min(small_,large_)\\n dict_[num] -= usage\\n dict_[num * 2] -= usage\\n elif num == 0:\\n if dict_[0] % 2 != 0:\\n return False\\n else:\\n dict_[0] = 0\\n \\n for key in dict_:\\n if dict_[key] != 0:\\n return False\\n return True\\n \\n\",\n \"from collections import Counter\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if not A: return True\\n C = Counter(A)\\n K = sorted(C.keys())\\n for k in K:\\n if k == 0:\\n if C[k] & 1:\\n return False\\n else:\\n C[k] = 0\\n if k < 0 and C[k] > 0:\\n if k % 2 == 0 and (k // 2 in C):\\n C[k//2] -= C[k]\\n C[k] = 0\\n if k > 0 and C[k] > 0:\\n if k * 2 in C:\\n C[k*2] -= C[k]\\n C[k] = 0\\n return set(C.values()) == {0}\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n c = Counter(A)\\n for n in sorted(list(c.keys()), key=abs):\\n while c[n] > 0 and c[(double := 2 * n)] > 0:\\n c[n] -= 1\\n c[double] -= 1\\n return all(not v for v in list(c.values()))\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n def factorize(num):\\n power = 0\\n while num % 2 == 0:\\n num, power = num//2, power+1\\n return (num, power)\\n \\n counts = defaultdict(lambda : [0]*17)\\n zeros = 0\\n for a in A:\\n if a == 0:\\n zeros += 1\\n else:\\n n, p = factorize(a)\\n counts[n][p] += 1\\n \\n if zeros % 2 == 1:\\n return False\\n \\n \\n for key in counts:\\n carry = 0\\n for p in counts[key]:\\n carry = p - carry\\n if carry < 0: return False\\n if carry != 0: return False\\n \\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n # https://www.cnblogs.com/seyjs/p/10092569.html\\n A.sort()\\n dic = {}\\n for i in A:\\n if i % 2 == 0 and i/2 in dic:\\n i = i / 2\\n dic[i] -= 1\\n if dic[i] == 0:\\n del dic[i]\\n elif i * 2 in dic:\\n i = i * 2\\n dic[i] -= 1\\n if dic[i] == 0:\\n del dic[i]\\n else:\\n dic[i] = dic.setdefault(i, 0) + 1\\n continue\\n return len(dic) == 0\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort(key=lambda x: abs(x))\\n c={}\\n for v in A:\\n if v/2 in c:\\n c[v/2]-=1\\n if not c[v/2]:\\n del c[v/2]\\n else:\\n if v not in c: c[v]=0\\n c[v]+=1\\n return len(c)==0\",\n \"import collections\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n neg = collections.Counter()\\n pos = collections.Counter()\\n for n in A:\\n if n >= 0:\\n pos[n] += 1\\n else:\\n neg[n] += 1\\n \\n for n in sorted(neg, reverse = True):\\n if neg[n*2] < neg[n]:\\n return False\\n neg[n*2] -= neg[n]\\n del neg[n]\\n if neg[n*2] == 0:\\n del neg[n*2]\\n if len(neg) != 0:\\n return False\\n for n in sorted(pos):\\n if pos[n*2] < pos[n]:\\n return False\\n pos[n*2] -= pos[n]\\n del pos[n]\\n if pos[n*2] == 0:\\n del pos[n*2]\\n if len(pos) != 0:\\n return False\\n return True\\n \\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort()\\n freq = dict()\\n for i in A:\\n freq[i] = freq.get(i, 0) + 1\\n for i in A:\\n if freq.get(i, 0) == 0: continue\\n\\n if i < 0:\\n if i % 2 != 0:\\n return False\\n elif not freq.get(i // 2, 0) > 0:\\n return False\\n elif i > 0 and not freq.get(i * 2, 0) > 0:\\n return False\\n \\n if i < 0:\\n freq[i // 2] -= 1\\n else:\\n freq[i*2] -=1\\n freq[i] -= 1\\n \\n return True\\n\",\n \"from collections import Counter\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n negs = [a for a in A if a < 0]\\n pos = [a for a in A if a > 0]\\n zeros = [a for a in A if a == 0]\\n \\n if any(map(lambda x: len(x) % 2 != 0, [negs, pos, zeros])):\\n return False\\n \\n if not self.is_valid(negs, True) or not self.is_valid(pos, False):\\n return False\\n return True\\n \\n \\n def is_valid(self, A, neg=False):\\n A = sorted(A)\\n N = len(A)\\n \\n if neg:\\n A = A[::-1]\\n\\n c = Counter(A)\\n for a in A:\\n if c[a] == 0:\\n continue\\n target = a * 2\\n if c[target] == 0:\\n return False\\n c[a] -= 1\\n c[target] -= 1\\n return True\",\n \"from collections import defaultdict\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n A.sort()\\n \\n arr = defaultdict(int)\\n \\n for item in A:\\n \\n if 2*item in arr and arr[2*item] > 0:\\n arr[2*item] -= 1\\n elif item % 2 == 0 and (item // 2) in arr and arr[item // 2] > 0:\\n arr[item // 2] -= 1\\n else:\\n arr[item] += 1\\n \\n \\n return sum([x for x in arr.values() if x != 0]) == 0\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x]==0: continue # x may be end of a pair\\n if count[2*x]==0: \\n return False # x exsist, we have to match it with a 2x\\n count[2*x] -= 1\\n count[x] -= 1\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cache=Counter(A)\\n c_list=sorted(list(cache),key=abs)\\n for x in c_list:\\n if cache[x]>cache[2*x]:\\n return False\\n cache[2*x]-=cache[x]\\n return True\\n \\n '''\\n if not A:\\n return True\\n positive_heap = []\\n negative_heap = []\\n zero = 0\\n positive_d = defaultdict(int)\\n negative_d = defaultdict(int)\\n for i in A:\\n if i == 0:\\n zero += 1\\n elif i < 0:\\n heappush(negative_heap, -i)\\n negative_d[-i] += 1\\n else:\\n heappush(positive_heap, i)\\n positive_d[i] += 1\\n if zero % 2 != 0:\\n return False\\n if not self.check(positive_heap, positive_d):\\n return False\\n if not self.check(negative_heap, negative_d):\\n return False\\n return True\\n \\n def check(self, h, d):\\n for _ in range(len(h)):\\n i = heappop(h)\\n if d[i] == 0:\\n continue\\n if 2*i not in d:\\n return False\\n elif d[2*i] < d[i]:\\n return False\\n else:\\n d[2*i] -= d[i]\\n d[i] = 0\\n return True\\n '''\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n table = collections.defaultdict(int)\\n for num in A:\\n table[num] += 1\\n A.sort()\\n for num in A:\\n if table[num] == 0:\\n continue\\n pair = num * 2\\n if num < 0:\\n pair = num / 2\\n if table[pair] < 1:\\n return False\\n table[num] -= 1\\n table[pair] -= 1\\n return True\\n \\n \\n \\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count=collections.Counter(A)\\n for x in sorted(A,key=abs):\\n if count[x]==0:\\n continue\\n if count[2*x]==0:\\n return False\\n count[x]-=1\\n count[2*x]-=1\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n \\n ## Time Complexity: O(N LOG N) , Space: O(N)\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n # Array of Doubled Pairs 9/24 8/31/20\\n # 1:43 9/1/2020\\n# c = collections.Counter(A)\\n# for x in sorted(c, key=abs):\\n# if c[x] > c[x * 2]:\\n# return False\\n# c[x*2] -= c[x]\\n \\n# return True\\n \\n\\n \\n A = [abs(num) for num in A ]\\n A.sort()\\n dic = collections.defaultdict(collections.deque)\\n for i, num in enumerate(A):\\n dic[num].append(i)\\n \\n visited = [0]*len(A)\\n cnt = 0\\n i = 0\\n # while cnt < len(A) // 2 :\\n while i < len(A):\\n if visited[i]:\\n i += 1\\n continue\\n val, val_double = A[i], 2 * A[i]\\n if val_double in dic and dic[val_double]:\\n if val not in dic or not dic[val]:\\n return False\\n dic[val].popleft()\\n if not dic[val_double]:\\n return False\\n index = dic[val_double].popleft()\\n visited[index] = 1\\n \\n else:\\n return False\\n i += 1\\n # cnt += 1\\n \\n return True\\n \\n# A = [abs(num) for num in A ]\\n# A.sort()\\n# dic = collections.defaultdict(int)\\n# for num in A:\\n# dic[num] += 1\\n \\n# visited = [0]*len(A)\\n# cnt = 0\\n# i = 0\\n# while cnt < len(A) // 2 :\\n# if visited[i]:\\n# i += 1\\n# continue\\n# val_small = A[i]\\n# if 2*val_small in dic:\\n# dic[2*val_small] -= 1\\n# dic[val_small] -= 1\\n# if dic[2*val_small] < 0 or dic[val_small] < 0:\\n# return False\\n# search_index = A.index(2*val_small, i+1)\\n# while visited[search_index]:\\n# search_index = A.index(2*val_small, search_index+1)\\n# visited[search_index] = 1\\n# else:\\n# return False\\n# i += 1\\n# cnt += 1\\n \\n# return True\\n \\n\\n \\n \\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n counts = collections.Counter(A)\\n count = 0\\n A.sort()\\n for num in A: #range(0,len(A)//2):\\n #num = A[i] \\n if counts[num] and counts[num * 2]:\\n counts[num*2]-=1\\n counts[num]-=1\\n count+=1\\n return count*2 == len(A) \",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n counter = collections.Counter(A)\\n for e in sorted(A, key=abs):\\n if 2*e in counter and counter[2*e] > 0 and counter[e] > 0: \\n counter[e] -= 1\\n counter[2*e] -= 1\\n print(counter)\\n return sum(counter.values()) == 0\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort()\\n seen = Counter()\\n for num in A:\\n if num>0 and num%2:\\n seen[num]+=1\\n continue\\n elem = 2*num if num<0 else num//2\\n if seen[elem]>0:\\n seen[elem]-=1\\n else:\\n seen[num]+=1\\n\\n if sum(seen.values()):\\n return False\\n return True\",\n \"from collections import Counter\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n # if len(A)%2==1:\\n # return False\\n # counter = Counter(A)\\n # # print(counter)\\n # Skey = set(counter.keys())\\n # key = counter.keys()\\n # for i in key:\\n # if 2*i in Skey:\\n # counter[i]=0\\n # counter[i*2]-=counter[i]\\n # val = list(counter.values())\\n # print(val)\\n # for i in val:\\n # if i !=0:\\n # return False\\n # return True\\n \\n cnt = collections.Counter(A)\\n for a in sorted(A, key = abs):\\n if cnt[a] and cnt[a * 2]:\\n cnt[a] -= 1\\n cnt[a * 2] -= 1 \\n return all(cnt[a] == 0 for a in A)\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cache=collections.Counter(A)\\n c_list=sorted(cache, key=lambda x: abs(x))\\n print(cache, c_list)\\n for x in c_list:\\n if cache[x]>cache[2*x]:\\n return False\\n cache[2*x]-=cache[x]\\n return True\",\n \"import numpy as np\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort()\\n statdict = {}\\n flag = True\\n# print(A)\\n for i in A:\\n# print(statdict)\\n if i in statdict:\\n statdict[i] = statdict[i] + 1\\n elif i < 0:\\n if i*2 in statdict:\\n statdict[i*2] = statdict[i*2] - 1\\n if statdict[i*2] == 0:\\n statdict.pop(i*2)\\n else:\\n statdict[i] = 1\\n else:\\n if (i%2 == 0) and i/2 in statdict:\\n statdict[int(i/2)] = statdict[int(i/2)] - 1\\n if statdict[int(i/2)] == 0:\\n statdict.pop(int(i/2))\\n else:\\n statdict[i] = 1\\n return (len(statdict) == 0) or (len(statdict) == 1 and 0 in statdict and statdict[0] % 2 == 0)\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n c = collections.Counter(A)\\n \\n for i in sorted(A, key=abs):\\n if c[i] and c[i*2]:\\n c[i] -= 1\\n c[i*2] -= 1\\n \\n return all(c[i] == 0 for i in A)\\n \\n \\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n B = []\\n for x in A:\\n if x>0:\\n B.append(x)\\n else:\\n B.append(-x)\\n count = collections.Counter(B)\\n for x in sorted(B):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n else:\\n count[x] -=1\\n count[2*x] -=1\\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n D1 = collections.Counter()\\n D2 = collections.Counter()\\n zero = 0\\n \\n for a in A:\\n if a < 0:\\n D1[a] += 1\\n else:\\n D2[a] += 1\\n \\n for d in sorted(D1, reverse=1):\\n if D1[d]:\\n if D1[ d*2 ] < D1[d]:\\n return False\\n D1[ d*2 ] -= D1[d]\\n\\n for d in sorted(D2):\\n if D2[d]:\\n if D2[ d*2 ] < D2[d]:\\n return False\\n D2[ d*2 ] -= D2[d]\\n \\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n n = len(A)\\n #A[2*i+1] = 2*A[2*i]\\n #[-2,-4,2,4]\\n #A[1] == 2*A[0]\\n #A[3] == 2*A[2]\\n neg = sorted(list([x for x in A if x<0]))\\n pos = sorted(list([x for x in A if x>0]), reverse=True)\\n nl, pl = len(neg), len(pos)\\n if nl % 2 or pl % 2: return False\\n d1 = collections.Counter(neg)\\n cnt = 0\\n for i in range(nl):\\n if d1[2*neg[i]] > 0:\\n d1[2*neg[i]] -= 1\\n d1[neg[i]] -= 1\\n cnt += 1\\n if cnt < nl // 2: return False \\n d2 = collections.Counter(pos)\\n cnt = 0\\n for i in range(pl): \\n if d2[2*pos[i]] > 0:\\n print((pos[i]*2, pos[i]))\\n d2[2*pos[i]] -= 1\\n d2[pos[i]] -= 1\\n cnt += 1\\n if cnt < pl // 2: return False \\n return True \\n\",\n \"class Solution(object):\\n def canReorderDoubled(self, A):\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\",\n \"from collections import Counter\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A.sort()\\n d=Counter()\\n c=[]\\n e=[]\\n for i in A:\\n if(i<0):\\n c.append(i)\\n elif(i>=0):\\n e.append(i)\\n c.sort(reverse=True)\\n c.extend(e)\\n A=c\\n print(A)\\n for i in A:\\n d[i]+=1\\n if(d[0]%2!=0):\\n return False\\n d[0]=0\\n for i in A:\\n if(2*i in d)and(d[i]<=d[2*i]):\\n d[2*i]-=d[i]\\n d[i]=0\\n elif(d[i]==0):\\n continue\\n else:\\n return False\\n return True\\n \\n \\n \\n \\n\",\n \"from collections import Counter\\nfrom typing import List\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n d = dict()\\n num_zeros = 0\\n for x in A:\\n if x == 0:\\n num_zeros += 1\\n continue\\n x = abs(x)\\n y = x\\n while y % 2 == 0:\\n y //= 2\\n if y in d:\\n d[y].update([x])\\n else:\\n d[y] = Counter([x])\\n \\n if num_zeros % 2:\\n return False\\n\\n for base, counter in d.items():\\n keys = sorted(counter)\\n for key in keys:\\n if counter[key] <= counter[2 * key]:\\n counter[2 * key] -= counter[key]\\n counter[key] -= counter[key]\\n else:\\n return False\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n c=collections.Counter(A)\\n \\n for x in sorted(A,key=abs):\\n if c[x]==0:\\n continue\\n if c[2*x]==0:\\n return False\\n c[x]-=1\\n c[2*x]-=1\\n return True\\n\",\n \"# 20201007 12:08 选参考答案\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n cache=Counter(A)\\n c_list=sorted(list(cache),key=abs)\\n for x in c_list:\\n if cache[x]>cache[2*x]:\\n return False\\n cache[2*x]-=cache[x]\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n counter=collections.Counter(A)\\n counter=dict(sorted(counter.items(),key=lambda x:abs(x[0])))\\n nums=[]\\n for num in counter.keys():\\n for _ in range(counter[num]):\\n nums.append(num)\\n for num in nums:\\n if counter[num]:\\n if 2*num in counter and counter[2*num]!=0:\\n counter[num]-=1\\n counter[num*2]-=1\\n else:\\n return False\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if len(A) == 0 :\\n return True\\n \\n mydict = {}\\n for _ in range(0,len(A)):\\n if A[_] in mydict:\\n mydict[A[_]] += 1\\n else:\\n mydict[A[_]] = 1\\n \\n A_sorted = sorted(A)\\n \\n #print(A_sorted)\\n #print(mydict)\\n not_valid = set()\\n for num in A_sorted:\\n if len(mydict) == 0:\\n return True \\n if num in not_valid:\\n continue\\n \\n if (2 * num) in mydict and num in mydict:\\n double = 2*num\\n mydict[num] -= 1\\n mydict[double] -= 1\\n\\n if mydict[num] == 0:\\n mydict.pop(num)\\n not_valid.add(num)\\n #deals with duplicates\\n if num == double:\\n continue\\n elif mydict[2*num] == 0:\\n mydict.pop(2*num)\\n not_valid.add(2*num)\\n elif (num/2 in mydict and num in mydict):\\n half = num/2\\n mydict[num] -= 1\\n mydict[num/2] -= 1\\n\\n if mydict[num] == 0:\\n mydict.pop(num)\\n not_valid.add(num)\\n if mydict[num/2] == 0:\\n mydict.pop(num/2)\\n not_valid.add(num/2)\\n else:\\n return False\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n # Divide an conquer\\n # Sort items according to their magnitude\\n # For each item, make sure it's double exists later in the list\\n # When a double is used, mark it with a mask\\n \\n used = [False]*len(A)\\n A.sort(key = lambda n: abs(n))\\n bank = collections.Counter(A)\\n \\n for num in A:\\n \\n if bank[num] == 0:\\n continue\\n \\n bank[num] -= 1\\n if bank.get(2*num, 0) == 0:\\n return False\\n bank[2*num] -= 1\\n \\n return True\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n\",\n \"from collections import Counter\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n # Greedy\\n # Time complexity: O(NlogN)\\n # Space complexity: O(N)\\n count = Counter(A)\\n for x in sorted(A, key=abs):\\n if count[x] == 0: continue\\n if count[2 * x] == 0: return False\\n count[x] -= 1\\n count[2 * x] -= 1\\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A_sorted = sorted(A, key=abs)\\n count = collections.Counter(A)\\n for a in A_sorted:\\n if count[a] == 0: \\n continue\\n if count[a * 2] == 0:\\n return False\\n count[a] -= 1\\n count[a * 2] -= 1\\n \\n return True\",\n \"class Solution(object):\\n def canReorderDoubled(self, A):\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\\n\",\n \"class Solution(object):\\n def canReorderDoubled(self, A):\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n c = collections.Counter(A)\\n for k in sorted(c, key=abs):\\n if c[k] > c.get(2*k, 0):\\n return False\\n c[2*k] -= c[k]\\n \\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n st = {}\\n A = sorted(A,reverse=True)\\n for i in A:\\n if i in st:st[i]+=1\\n else: st[i] = 1\\n #print(st)\\n for num in A:\\n if (num*2) in st and st[num] > 0 and st[(num*2)] > 0:\\n st[num*2]-=1\\n st[num]-=1\\n #print(num,st)\\n for num in st:\\n if st[num] > 0:return False\\n return True\\n\",\n \"from collections import Counter\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count_a = Counter(A)\\n A.sort(key=lambda x: abs(x))\\n for elem in A:\\n if count_a[elem] == 0: continue\\n if count_a[elem * 2] == 0: return False\\n count_a[elem] -= 1\\n count_a[elem * 2] -= 1\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0:\\n continue\\n if count[x*2] == 0:\\n return False\\n count[x] -= 1\\n count[2*x] -= 1\\n \\n return True\\n \\n \\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n A.sort() \\n map = {}\\n \\n for item in A:\\n if item in map : map[item] +=1\\n else : map[item] =1\\n \\n for item in A:\\n if map[item]==0 : continue\\n if item <0 :\\n if item/2 in map : \\n if map[item/2]==0 : return False\\n map[item] -=1\\n map[item/2] -=1\\n else : return False\\n else :\\n if item *2 in map:\\n if map[2*item]==0: return False\\n map[item] -=1\\n map[item*2] -=1\\n else : return False\\n \\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n seen = dict()\\n for x in A:\\n if x not in seen:\\n seen[x] = 0\\n seen[x] += 1\\n\\n for x in sorted(seen, key=lambda x : x**2):\\n if seen[x] == 0:\\n continue\\n if (2*x not in seen) or (seen[x] > seen[2*x]):\\n return False\\n else:\\n seen[2*x] -= seen[x]\\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n print(x)\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\",\n \"from collections import Counter\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n a = sorted(A,key=lambda x:abs(x),reverse = True)\\n b = dict(Counter(A))\\n while a:\\n \\n aa = a.pop()\\n if aa in b:\\n\\n b[aa] -= 1\\n if b[aa]==0:\\n del b[aa]\\n\\n if 2*aa in b:\\n b[2*aa] -= 1\\n else:\\n return False\\n if b[2*aa]==0:\\n del b[2*aa]\\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n \\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x] == 0: continue\\n if count[2*x] == 0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n\\n return True\\n \\n \\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n counter = collections.Counter(A)\\n for x in sorted(counter,key=abs):\\n if counter[x] > counter[2*x]:\\n return False\\n counter[2*x] -= counter[x]\\n return True \",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n if len(A) % 2 == 1:\\n return False\\n \\n count = collections.defaultdict(int)\\n for num in A:\\n count[num] += 1\\n A.sort()\\n for num in A:\\n if count[num] > 0:\\n double = num * 2\\n if double in count and count[double] > 0:\\n # print(\\\\\\\"found\\\\\\\", double)\\n count[num] -= 1 \\n count[double] -= 1\\n \\n for num in count:\\n if count[num] != 0:\\n return False\\n return True\\n \\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n c = collections.Counter(A)\\n for x in sorted(c, key=abs):\\n if c[x] > c[2 * x]:\\n return False\\n c[2 * x] -= c[x]\\n return True\\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n d={}\\n for i in A:\\n if i in d:\\n d[i]+=1\\n else:\\n d[i]=1\\n A.sort()\\n \\n if 0 in d:\\n if d[0]%2!=0:\\n return False\\n d.pop(0)\\n \\n for i in A:\\n #print(i,d)\\n if i not in d:\\n continue\\n \\n if i*2 in d:\\n if d[i]>d[i*2]:\\n d[i]-=d[i*2]\\n d[i*2]=0\\n else:\\n d[i*2]-=d[i]\\n d[i]=0\\n if d[i]==0:\\n d.pop(i)\\n if d[i*2]==0:\\n d.pop(i*2)\\n elif i%2==0 and i//2 in d:\\n if d[i]>d[i//2]:\\n d[i]-=d[i//2]\\n d[i//2]=0\\n else:\\n d[i//2]-=d[i]\\n d[i]=0\\n if d[i]==0:\\n d.pop(i)\\n if d[i//2]==0:\\n d.pop(i//2)\\n else:\\n return False\\n return len(d)==0\\n\",\n \"import collections\\n\\nclass Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n ''' Place all values into dicts and start counting from the bottom\\n '''\\n counter = collections.Counter(A)\\n \\n for v in sorted(counter, key = abs):\\n if counter[2 * v] < counter[v]:\\n return False\\n counter[2 * v] -= counter[v]\\n return True\\n \\n \\n \\n \\n \\n \\n\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n A = sorted(A, key=lambda x: abs(x))\\n M = Counter()\\n \\n for e in A:\\n M[e] += 1\\n \\n # print(M)\\n # print(A)\\n \\n for e in A:\\n # print(e, M[2*e], M)\\n if M[e] and M[2*e]:\\n M[2*e] -= 1\\n M[e] -= 1\\n # print('->', 2*e, M[2*e])\\n elif M[e]:\\n # print(M, e)\\n return False\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n count = collections.Counter(A)\\n for x in sorted(A, key = abs):\\n if count[x]==0: continue\\n if count[2*x]==0: return False\\n count[x] -= 1\\n count[2*x] -= 1\\n return True\",\n \"class Solution:\\n def canReorderDoubled(self, A: List[int]) -> bool:\\n dic=collections.defaultdict(int)\\n for i in range(len(A)):\\n dic[A[i]]+=1\\n ki=list(dic.keys())\\n ki.sort(key=lambda x:abs(x))\\n for k in ki:\\n if dic[2*k]<dic[k]:\\n return False\\n dic[2*k]-=dic[k]\\n dic[k]=0\\n return True\"\n]","isConversational":false},"n_sols":{"kind":"number","value":114,"string":"114"},"non_interactive_idx":{"kind":"list like","value":[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,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32,\n 33,\n 34,\n 35,\n 36,\n 37,\n 38,\n 39,\n 40,\n 41,\n 42,\n 43,\n 44,\n 45,\n 46,\n 47,\n 48,\n 49,\n 50,\n 51,\n 52,\n 53,\n 54,\n 55,\n 56,\n 57,\n 58,\n 59,\n 60,\n 61,\n 62,\n 63,\n 64,\n 65,\n 66,\n 67,\n 68,\n 69,\n 70,\n 71,\n 72,\n 73,\n 74,\n 75,\n 76,\n 77,\n 78,\n 79,\n 80,\n 81,\n 82,\n 83,\n 84,\n 85,\n 86,\n 87,\n 88,\n 89,\n 90,\n 91,\n 92,\n 93,\n 94,\n 95,\n 96,\n 97,\n 98,\n 99,\n 100,\n 101,\n 102,\n 103,\n 104,\n 105,\n 106,\n 107,\n 108,\n 109,\n 110,\n 111,\n 112,\n 113\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[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,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],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":93,"cells":{"problem_id":{"kind":"number","value":230,"string":"230"},"question":{"kind":"string","value":"Given a non-negative integer num represented as a string, remove k digits from the number so that the new number is the smallest possible.\n\n\nNote:\n\nThe length of num is less than 10002 and will be ≥ k.\nThe given num does not contain any leading zero.\n\n\n\n\nExample 1:\n\nInput: num = \"1432219\", k = 3\nOutput: \"1219\"\nExplanation: Remove the three digits 4, 3, and 2 to form the new number 1219 which is the smallest.\n\n\n\nExample 2:\n\nInput: num = \"10200\", k = 1\nOutput: \"200\"\nExplanation: Remove the leading 1 and the number is 200. Note that the output must not contain leading zeroes.\n\n\n\nExample 3:\n\nInput: num = \"10\", k = 2\nOutput: \"0\"\nExplanation: Remove all the digits from the number and it is left with nothing which is 0."},"solutions":{"kind":"string","value":"[\"class Solution:\\n def removeKdigits(self, num, k):\\n \\\"\\\"\\\"\\n :type num: str\\n :type k: int\\n :rtype: str\\n \\\"\\\"\\\"\\n out=[]\\n for digit in num:\\n while k and out and out[-1] > digit:\\n out.pop()\\n k-=1\\n out.append(digit)\\n return ''.join(out[:-k or None]).lstrip('0') or \\\"0\\\"\", \"class Solution:\\n def removeKdigits(self, num, k):\\n \\\"\\\"\\\"\\n :type num: str\\n :type k: int\\n :rtype: str\\n \\\"\\\"\\\"\\n if(num == \\\"\\\"): return \\\"\\\"\\n arr = [i for i in list(num)]\\n stack = [arr[0]]\\n out = 0\\n for i in range(1, len(arr)):\\n while(out < k and len(stack)>0 and arr[i] < stack[-1]):\\n stack.pop()\\n out += 1\\n stack.append(arr[i])\\n diff = k - out\\n for i in range(diff): stack.pop()\\n res = \\\"\\\".join(stack).lstrip(\\\"0\\\")\\n if(res == \\\"\\\"): return \\\"0\\\"\\n return res\\n\", \"class Solution(object):\\n def removeKdigits(self, num, k):\\n \\\"\\\"\\\"\\n :type num: str\\n :type k: int\\n :rtype: str\\n \\\"\\\"\\\"\\n if k == len(num):\\n return \\\"0\\\"\\n stack = []\\n cnt = 0\\n for i, ch in enumerate(num):\\n if cnt == k:\\n for j in range(i, len(num)):\\n stack.append(num[j])\\n break\\n if not stack or ch >= stack[-1]:\\n stack.append(ch)\\n else:\\n while stack and ch < stack[-1] and cnt < k:\\n stack.pop()\\n cnt += 1\\n stack.append(ch)\\n while cnt < k:\\n stack.pop()\\n cnt += 1\\n i = 0\\n while i < len(stack) and stack[i] == '0':\\n i += 1\\n if i == len(stack):\\n return \\\"0\\\"\\n return ''.join(stack[i:])\", \"class Solution:\\n def removeKdigits(self, num, k):\\n \\\"\\\"\\\"\\n :type num: str\\n :type k: int\\n :rtype: str\\n \\\"\\\"\\\"\\n while True:\\n if k == 0:\\n return num if num != \\\"\\\" else \\\"0\\\"\\n if num == \\\"\\\":\\n return \\\"0\\\"\\n index = 0\\n num_len = len(num)\\n while True:\\n if index == num_len - 1:\\n num = num[:-1]\\n k -= 1\\n break\\n if num[index] > num[index + 1]:\\n new_num = num[:index] + num[index+1:]\\n num = new_num.lstrip(\\\"0\\\")\\n k -= 1\\n break\\n index += 1\", \"class Solution:\\n def removeKdigits(self, num, k):\\n \\\"\\\"\\\"\\n :type num: str\\n :type k: int\\n :rtype: str\\n \\\"\\\"\\\"\\n stack = []\\n i = 0\\n num += '0'\\n while i < len(num):\\n while stack and stack[-1] > num[i] and k > 0:\\n stack.pop()\\n k -= 1\\n if (stack or num[i] != '0') and i < len(num)-1: \\n stack.append(num[i]) \\n i += 1\\n res = ''.join(stack)\\n return res if res else '0'\\n \\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"removeKdigits\", \"inputs\": [[\"\\\"1432219\\\"\", 3]], \"outputs\": [\"\\\"1219\\\"\"]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/remove-k-digits/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def removeKdigits(self, num: str, k: int) -> str:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def removeKdigits(self, num, k):\n \"\"\"\n :type num: str\n :type k: int\n :rtype: str\n \"\"\"\n out=[]\n for digit in num:\n while k and out and out[-1] > digit:\n out.pop()\n k-=1\n out.append(digit)\n return ''.join(out[:-k or None]).lstrip('0') or \"0\"","class Solution:\n def removeKdigits(self, num, k):\n \"\"\"\n :type num: str\n :type k: int\n :rtype: str\n \"\"\"\n if(num == \"\"): return \"\"\n arr = [i for i in list(num)]\n stack = [arr[0]]\n out = 0\n for i in range(1, len(arr)):\n while(out < k and len(stack)>0 and arr[i] < stack[-1]):\n stack.pop()\n out += 1\n stack.append(arr[i])\n diff = k - out\n for i in range(diff): stack.pop()\n res = \"\".join(stack).lstrip(\"0\")\n if(res == \"\"): return \"0\"\n return res\n","class Solution(object):\n def removeKdigits(self, num, k):\n \"\"\"\n :type num: str\n :type k: int\n :rtype: str\n \"\"\"\n if k == len(num):\n return \"0\"\n stack = []\n cnt = 0\n for i, ch in enumerate(num):\n if cnt == k:\n for j in range(i, len(num)):\n stack.append(num[j])\n break\n if not stack or ch >= stack[-1]:\n stack.append(ch)\n else:\n while stack and ch < stack[-1] and cnt < k:\n stack.pop()\n cnt += 1\n stack.append(ch)\n while cnt < k:\n stack.pop()\n cnt += 1\n i = 0\n while i < len(stack) and stack[i] == '0':\n i += 1\n if i == len(stack):\n return \"0\"\n return ''.join(stack[i:])","class Solution:\n def removeKdigits(self, num, k):\n \"\"\"\n :type num: str\n :type k: int\n :rtype: str\n \"\"\"\n while True:\n if k == 0:\n return num if num != \"\" else \"0\"\n if num == \"\":\n return \"0\"\n index = 0\n num_len = len(num)\n while True:\n if index == num_len - 1:\n num = num[:-1]\n k -= 1\n break\n if num[index] > num[index + 1]:\n new_num = num[:index] + num[index+1:]\n num = new_num.lstrip(\"0\")\n k -= 1\n break\n index += 1","class Solution:\n def removeKdigits(self, num, k):\n \"\"\"\n :type num: str\n :type k: int\n :rtype: str\n \"\"\"\n stack = []\n i = 0\n num += '0'\n while i < len(num):\n while stack and stack[-1] > num[i] and k > 0:\n stack.pop()\n k -= 1\n if (stack or num[i] != '0') and i < len(num)-1: \n stack.append(num[i]) \n i += 1\n res = ''.join(stack)\n return res if res else '0'\n \n"],"string":"[\n \"class Solution:\\n def removeKdigits(self, num, k):\\n \\\"\\\"\\\"\\n :type num: str\\n :type k: int\\n :rtype: str\\n \\\"\\\"\\\"\\n out=[]\\n for digit in num:\\n while k and out and out[-1] > digit:\\n out.pop()\\n k-=1\\n out.append(digit)\\n return ''.join(out[:-k or None]).lstrip('0') or \\\"0\\\"\",\n \"class Solution:\\n def removeKdigits(self, num, k):\\n \\\"\\\"\\\"\\n :type num: str\\n :type k: int\\n :rtype: str\\n \\\"\\\"\\\"\\n if(num == \\\"\\\"): return \\\"\\\"\\n arr = [i for i in list(num)]\\n stack = [arr[0]]\\n out = 0\\n for i in range(1, len(arr)):\\n while(out < k and len(stack)>0 and arr[i] < stack[-1]):\\n stack.pop()\\n out += 1\\n stack.append(arr[i])\\n diff = k - out\\n for i in range(diff): stack.pop()\\n res = \\\"\\\".join(stack).lstrip(\\\"0\\\")\\n if(res == \\\"\\\"): return \\\"0\\\"\\n return res\\n\",\n \"class Solution(object):\\n def removeKdigits(self, num, k):\\n \\\"\\\"\\\"\\n :type num: str\\n :type k: int\\n :rtype: str\\n \\\"\\\"\\\"\\n if k == len(num):\\n return \\\"0\\\"\\n stack = []\\n cnt = 0\\n for i, ch in enumerate(num):\\n if cnt == k:\\n for j in range(i, len(num)):\\n stack.append(num[j])\\n break\\n if not stack or ch >= stack[-1]:\\n stack.append(ch)\\n else:\\n while stack and ch < stack[-1] and cnt < k:\\n stack.pop()\\n cnt += 1\\n stack.append(ch)\\n while cnt < k:\\n stack.pop()\\n cnt += 1\\n i = 0\\n while i < len(stack) and stack[i] == '0':\\n i += 1\\n if i == len(stack):\\n return \\\"0\\\"\\n return ''.join(stack[i:])\",\n \"class Solution:\\n def removeKdigits(self, num, k):\\n \\\"\\\"\\\"\\n :type num: str\\n :type k: int\\n :rtype: str\\n \\\"\\\"\\\"\\n while True:\\n if k == 0:\\n return num if num != \\\"\\\" else \\\"0\\\"\\n if num == \\\"\\\":\\n return \\\"0\\\"\\n index = 0\\n num_len = len(num)\\n while True:\\n if index == num_len - 1:\\n num = num[:-1]\\n k -= 1\\n break\\n if num[index] > num[index + 1]:\\n new_num = num[:index] + num[index+1:]\\n num = new_num.lstrip(\\\"0\\\")\\n k -= 1\\n break\\n index += 1\",\n \"class Solution:\\n def removeKdigits(self, num, k):\\n \\\"\\\"\\\"\\n :type num: str\\n :type k: int\\n :rtype: str\\n \\\"\\\"\\\"\\n stack = []\\n i = 0\\n num += '0'\\n while i < len(num):\\n while stack and stack[-1] > num[i] and k > 0:\\n stack.pop()\\n k -= 1\\n if (stack or num[i] != '0') and i < len(num)-1: \\n stack.append(num[i]) \\n i += 1\\n res = ''.join(stack)\\n return res if res else '0'\\n \\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":5,"string":"5"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":94,"cells":{"problem_id":{"kind":"number","value":231,"string":"231"},"question":{"kind":"string","value":"Given an unsorted integer array, find the smallest missing positive integer.\n\nExample 1:\n\n\nInput: [1,2,0]\nOutput: 3\n\n\nExample 2:\n\n\nInput: [3,4,-1,1]\nOutput: 2\n\n\nExample 3:\n\n\nInput: [7,8,9,11,12]\nOutput: 1\n\n\nNote:\n\nYour algorithm should run in O(n) time and uses constant extra space."},"solutions":{"kind":"string","value":"[\"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n nums = sorted(set(nums), key=lambda x: x)\\n result = 0\\n for i in range(len(nums)):\\n if nums[i] <= 0:\\n continue\\n elif nums[i] == result + 1:\\n result += 1\\n else:\\n break\\n return result + 1\", \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n if not nums:\\n return 1\\n for index in range(len(nums)):\\n while nums[index] != index + 1:\\n tmp = nums[index]\\n if tmp <= 0 or tmp > len(nums) or tmp == nums[tmp - 1]:\\n break\\n nums[index] = nums[tmp - 1]\\n nums[tmp - 1] = tmp\\n for index in range(len(nums)):\\n if nums[index] != index + 1:\\n return index + 1\\n return len(nums) + 1\\n\", \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n minSet = set()\\n maxSet = set()\\n nums = set(nums)\\n for num in nums:\\n \\n if num > 0:\\n if num + 1 in minSet:\\n minSet.remove(num + 1)\\n minSet.add(num)\\n if num - 1 in maxSet:\\n maxSet.remove(num - 1)\\n minSet.remove(num)\\n elif num - 1 in maxSet:\\n maxSet.remove(num - 1)\\n maxSet.add(num)\\n if num + 1 in minSet:\\n maxSet.remove(num)\\n minSet.remove(num + 1)\\n else:\\n minSet.add(num)\\n maxSet.add(num)\\n # print(\\\"min set:\\\", minSet)\\n # print(\\\"max set:\\\", maxSet)\\n if len(minSet) == 0 or len(maxSet) == 0:\\n return 1\\n return min(maxSet) + 1 if min(minSet) == 1 else 1\", \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n i = 0\\n n = len(nums)\\n \\n if not nums:\\n return(1)\\n while (i <n):\\n while ((nums[i] != i) and (nums[i] > 0) and (i<n) and (nums[i] < n) and (nums[i] != nums[nums[i]])):\\n temp = nums[nums[i]]\\n nums[nums[i]] = nums[i]\\n nums[i] = temp\\n i = i + 1\\n \\n i = 1\\n while(i<n):\\n if(nums[i] != i):\\n return(i)\\n i=i+1\\n if(nums[0] == n):\\n return(n+1)\\n else:\\n return(n)\\n \\n\", \"class Solution:\\n def firstMissingPositive(self, nums):\\n for i in range(len(nums)):\\n while 0 <= nums[i]-1 < len(nums) and nums[nums[i]-1] != nums[i]:\\n tmp = nums[i]-1\\n nums[i], nums[tmp] = nums[tmp], nums[i]\\n for i in range(len(nums)):\\n if nums[i] != i+1:\\n return i+1\\n return len(nums)+1\", \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n if nums == []:\\n return(1)\\n for _ in range(5):\\n for i in range(len(nums)):\\n if ((i + 1) != nums[i]) and (0 < nums[i] <= len(nums)):\\n nums[nums[i]-1], nums[i] = nums[i], nums[nums[i]-1]\\n #print(nums, 'up')\\n else:\\n pass\\n #print(nums)\\n for i in range(len(nums))[::-1]:\\n if ((i + 1) != nums[i]) and (0 < nums[i] <= len(nums)):\\n nums[nums[i]-1], nums[i] = nums[i], nums[nums[i]-1]\\n \\n else:\\n pass\\n #print(nums)\\n for i in range(len(nums)):\\n if not i+1 == nums[i]:\\n #print(nums)\\n return(i+1)\\n if sorted(nums) == nums:\\n return(len(nums)+1)\\n\", \"class Solution:\\n \\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n A=nums\\n n = len(A)\\n for index in range(n):\\n element = A[index]\\n while True:\\n if element <= 0 or element > n or element == A[element - 1]:\\n break\\n A[element - 1], element = element, A[element - 1]\\n for index in range(n):\\n if A[index] != index + 1:\\n return index + 1\\n return n + 1\\n \\n\", \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n i = 0\\n \\n while i < len(nums):\\n tmp = nums[i]\\n # exchange to its right idx\\n while tmp != i + 1 and tmp > 0 and tmp < len(nums):\\n nums[i] = nums[tmp-1]\\n nums[tmp-1] = tmp\\n if tmp == nums[i]:\\n break\\n tmp = nums[i]\\n i += 1\\n print(nums)\\n \\n for i in range(len(nums)):\\n if nums[i] != i+1:\\n return i+1\\n return len(nums) + 1\\n\", \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n # put numbers to their places\\n # [-1,0,2,1] -> [1,2,0,0]\\n for i in range(len(nums)):\\n if nums[i] < 0:\\n nums[i] = 0\\n \\n if nums[i] > 0 and nums[i] != i + 1:\\n j, nums[i] = nums[i], 0\\n while 0 < j <= len(nums) and nums[j-1] != j:\\n next_j = nums[j-1]\\n nums[j-1] = j\\n j = next_j\\n \\n for i, num in enumerate(nums):\\n if not num:\\n return i+1\\n \\n if nums and nums[-1] > 0:\\n return nums[-1] + 1\\n \\n return 1\\n\", \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n minSet = set()\\n maxSet = set()\\n nums = set(nums)\\n for num in nums:\\n \\n if num > 0:\\n if num + 1 in minSet:\\n minSet.remove(num + 1)\\n minSet.add(num)\\n if num - 1 in maxSet:\\n maxSet.remove(num - 1)\\n minSet.remove(num)\\n elif num - 1 in maxSet:\\n maxSet.remove(num - 1)\\n maxSet.add(num)\\n if num + 1 in minSet:\\n maxSet.remove(num)\\n minSet.remove(num + 1)\\n else:\\n minSet.add(num)\\n maxSet.add(num)\\n print(\\\"min set:\\\", minSet)\\n print(\\\"max set:\\\", maxSet)\\n if len(minSet) == 0 or len(maxSet) == 0:\\n return 1\\n return min(maxSet) + 1 if min(minSet) == 1 else 1\", \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n nums.append(0)\\n for i in range(len(nums)):\\n while 0 < nums[i] < len(nums) and nums[i] != i and nums[i] != nums[nums[i]]:\\n temp = nums[nums[i]]\\n nums[nums[i]] = nums[i]\\n nums[i] = temp\\n print((temp, nums))\\n for i in range(1, len(nums)):\\n if nums[i] != i:\\n return i\\n return len(nums)\\n\", \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n if not nums: return 1\\n n = len(nums)\\n for i in range(len(nums)):\\n while nums[i] > 0 and nums[i] <= n and nums[i] != nums[nums[i] - 1]:\\n tmp = nums[i]\\n nums[i] = nums[tmp - 1]\\n nums[tmp - 1] = tmp\\n for j in range(len(nums)):\\n if nums[j] != j + 1: return j + 1\\n return n + 1\\n\", \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n lnums=len(nums)\\n for i in range(lnums):\\n while 0<nums[i]<=lnums and nums[i]!=nums[nums[i]-1]:\\n tmp=nums[i]\\n print((i,tmp,nums))\\n nums[tmp-1],nums[i]=nums[i],nums[tmp-1]\\n print((i,tmp,nums))\\n for i in range(lnums):\\n if nums[i]!=i+1:\\n return i+1\\n return lnums+1\\n \\n \\n\", \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n if nums == []:\\n return(1)\\n for _ in range(10):\\n for i in range(len(nums)):\\n if ((i + 1) != nums[i]) and (0 < nums[i] <= len(nums)):\\n nums[nums[i]-1], nums[i] = nums[i], nums[nums[i]-1]\\n #print(nums, 'up')\\n else:\\n pass\\n #print(nums)\\n for i in range(len(nums))[::-1]:\\n if ((i + 1) != nums[i]) and (0 < nums[i] <= len(nums)):\\n nums[nums[i]-1], nums[i] = nums[i], nums[nums[i]-1]\\n \\n else:\\n pass\\n #print(nums)\\n for i in range(len(nums)):\\n if not i+1 == nums[i]:\\n #print(nums)\\n return(i+1)\\n if sorted(nums) == nums:\\n return(len(nums)+1)\\n\", \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n if len(nums) == 0:\\n return 1\\n nums.append(0)\\n \\n for i in reversed(range(len(nums))):\\n n = nums[i]\\n while n>=0 and n<len(nums) and i != n:\\n nums[n], nums[i] = nums[i], nums[n]\\n if n == nums[i]:\\n break\\n n = nums[i]\\n print(nums)\\n \\n \\n for i,n in enumerate(nums):\\n if i==0:\\n continue\\n if i != n:\\n return i\\n return nums[-1]+1\", \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n n = len(nums)\\n for i in range(n):\\n while nums[i] > 0 and nums[i] <= n and nums[i] != i+1 and nums[i] != nums[nums[i]-1]:\\n nums[nums[i] - 1], nums[i] = nums[i], nums[nums[i]-1]\\n for i in range(n):\\n if nums[i] != i + 1:\\n return i + 1\\n return n + 1\\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"firstMissingPositive\", \"inputs\": [[[0, 1, 2, 0]]], \"outputs\": [3]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/first-missing-positive/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def firstMissingPositive(self, nums: List[int]) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def firstMissingPositive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n nums = sorted(set(nums), key=lambda x: x)\n result = 0\n for i in range(len(nums)):\n if nums[i] <= 0:\n continue\n elif nums[i] == result + 1:\n result += 1\n else:\n break\n return result + 1","class Solution:\n def firstMissingPositive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n if not nums:\n return 1\n for index in range(len(nums)):\n while nums[index] != index + 1:\n tmp = nums[index]\n if tmp <= 0 or tmp > len(nums) or tmp == nums[tmp - 1]:\n break\n nums[index] = nums[tmp - 1]\n nums[tmp - 1] = tmp\n for index in range(len(nums)):\n if nums[index] != index + 1:\n return index + 1\n return len(nums) + 1\n","class Solution:\n def firstMissingPositive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n minSet = set()\n maxSet = set()\n nums = set(nums)\n for num in nums:\n \n if num > 0:\n if num + 1 in minSet:\n minSet.remove(num + 1)\n minSet.add(num)\n if num - 1 in maxSet:\n maxSet.remove(num - 1)\n minSet.remove(num)\n elif num - 1 in maxSet:\n maxSet.remove(num - 1)\n maxSet.add(num)\n if num + 1 in minSet:\n maxSet.remove(num)\n minSet.remove(num + 1)\n else:\n minSet.add(num)\n maxSet.add(num)\n # print(\"min set:\", minSet)\n # print(\"max set:\", maxSet)\n if len(minSet) == 0 or len(maxSet) == 0:\n return 1\n return min(maxSet) + 1 if min(minSet) == 1 else 1","class Solution:\n def firstMissingPositive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n i = 0\n n = len(nums)\n \n if not nums:\n return(1)\n while (i <n):\n while ((nums[i] != i) and (nums[i] > 0) and (i<n) and (nums[i] < n) and (nums[i] != nums[nums[i]])):\n temp = nums[nums[i]]\n nums[nums[i]] = nums[i]\n nums[i] = temp\n i = i + 1\n \n i = 1\n while(i<n):\n if(nums[i] != i):\n return(i)\n i=i+1\n if(nums[0] == n):\n return(n+1)\n else:\n return(n)\n \n","class Solution:\n def firstMissingPositive(self, nums):\n for i in range(len(nums)):\n while 0 <= nums[i]-1 < len(nums) and nums[nums[i]-1] != nums[i]:\n tmp = nums[i]-1\n nums[i], nums[tmp] = nums[tmp], nums[i]\n for i in range(len(nums)):\n if nums[i] != i+1:\n return i+1\n return len(nums)+1","class Solution:\n def firstMissingPositive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n \n if nums == []:\n return(1)\n for _ in range(5):\n for i in range(len(nums)):\n if ((i + 1) != nums[i]) and (0 < nums[i] <= len(nums)):\n nums[nums[i]-1], nums[i] = nums[i], nums[nums[i]-1]\n #print(nums, 'up')\n else:\n pass\n #print(nums)\n for i in range(len(nums))[::-1]:\n if ((i + 1) != nums[i]) and (0 < nums[i] <= len(nums)):\n nums[nums[i]-1], nums[i] = nums[i], nums[nums[i]-1]\n \n else:\n pass\n #print(nums)\n for i in range(len(nums)):\n if not i+1 == nums[i]:\n #print(nums)\n return(i+1)\n if sorted(nums) == nums:\n return(len(nums)+1)\n","class Solution:\n \n def firstMissingPositive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n A=nums\n n = len(A)\n for index in range(n):\n element = A[index]\n while True:\n if element <= 0 or element > n or element == A[element - 1]:\n break\n A[element - 1], element = element, A[element - 1]\n for index in range(n):\n if A[index] != index + 1:\n return index + 1\n return n + 1\n \n","class Solution:\n def firstMissingPositive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n i = 0\n \n while i < len(nums):\n tmp = nums[i]\n # exchange to its right idx\n while tmp != i + 1 and tmp > 0 and tmp < len(nums):\n nums[i] = nums[tmp-1]\n nums[tmp-1] = tmp\n if tmp == nums[i]:\n break\n tmp = nums[i]\n i += 1\n print(nums)\n \n for i in range(len(nums)):\n if nums[i] != i+1:\n return i+1\n return len(nums) + 1\n","class Solution:\n def firstMissingPositive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n \n # put numbers to their places\n # [-1,0,2,1] -> [1,2,0,0]\n for i in range(len(nums)):\n if nums[i] < 0:\n nums[i] = 0\n \n if nums[i] > 0 and nums[i] != i + 1:\n j, nums[i] = nums[i], 0\n while 0 < j <= len(nums) and nums[j-1] != j:\n next_j = nums[j-1]\n nums[j-1] = j\n j = next_j\n \n for i, num in enumerate(nums):\n if not num:\n return i+1\n \n if nums and nums[-1] > 0:\n return nums[-1] + 1\n \n return 1\n","class Solution:\n def firstMissingPositive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n minSet = set()\n maxSet = set()\n nums = set(nums)\n for num in nums:\n \n if num > 0:\n if num + 1 in minSet:\n minSet.remove(num + 1)\n minSet.add(num)\n if num - 1 in maxSet:\n maxSet.remove(num - 1)\n minSet.remove(num)\n elif num - 1 in maxSet:\n maxSet.remove(num - 1)\n maxSet.add(num)\n if num + 1 in minSet:\n maxSet.remove(num)\n minSet.remove(num + 1)\n else:\n minSet.add(num)\n maxSet.add(num)\n print(\"min set:\", minSet)\n print(\"max set:\", maxSet)\n if len(minSet) == 0 or len(maxSet) == 0:\n return 1\n return min(maxSet) + 1 if min(minSet) == 1 else 1","class Solution:\n def firstMissingPositive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n nums.append(0)\n for i in range(len(nums)):\n while 0 < nums[i] < len(nums) and nums[i] != i and nums[i] != nums[nums[i]]:\n temp = nums[nums[i]]\n nums[nums[i]] = nums[i]\n nums[i] = temp\n print((temp, nums))\n for i in range(1, len(nums)):\n if nums[i] != i:\n return i\n return len(nums)\n","class Solution:\n def firstMissingPositive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n if not nums: return 1\n n = len(nums)\n for i in range(len(nums)):\n while nums[i] > 0 and nums[i] <= n and nums[i] != nums[nums[i] - 1]:\n tmp = nums[i]\n nums[i] = nums[tmp - 1]\n nums[tmp - 1] = tmp\n for j in range(len(nums)):\n if nums[j] != j + 1: return j + 1\n return n + 1\n","class Solution:\n def firstMissingPositive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n lnums=len(nums)\n for i in range(lnums):\n while 0<nums[i]<=lnums and nums[i]!=nums[nums[i]-1]:\n tmp=nums[i]\n print((i,tmp,nums))\n nums[tmp-1],nums[i]=nums[i],nums[tmp-1]\n print((i,tmp,nums))\n for i in range(lnums):\n if nums[i]!=i+1:\n return i+1\n return lnums+1\n \n \n","class Solution:\n def firstMissingPositive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n \n if nums == []:\n return(1)\n for _ in range(10):\n for i in range(len(nums)):\n if ((i + 1) != nums[i]) and (0 < nums[i] <= len(nums)):\n nums[nums[i]-1], nums[i] = nums[i], nums[nums[i]-1]\n #print(nums, 'up')\n else:\n pass\n #print(nums)\n for i in range(len(nums))[::-1]:\n if ((i + 1) != nums[i]) and (0 < nums[i] <= len(nums)):\n nums[nums[i]-1], nums[i] = nums[i], nums[nums[i]-1]\n \n else:\n pass\n #print(nums)\n for i in range(len(nums)):\n if not i+1 == nums[i]:\n #print(nums)\n return(i+1)\n if sorted(nums) == nums:\n return(len(nums)+1)\n","class Solution:\n def firstMissingPositive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n if len(nums) == 0:\n return 1\n nums.append(0)\n \n for i in reversed(range(len(nums))):\n n = nums[i]\n while n>=0 and n<len(nums) and i != n:\n nums[n], nums[i] = nums[i], nums[n]\n if n == nums[i]:\n break\n n = nums[i]\n print(nums)\n \n \n for i,n in enumerate(nums):\n if i==0:\n continue\n if i != n:\n return i\n return nums[-1]+1","class Solution:\n def firstMissingPositive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n n = len(nums)\n for i in range(n):\n while nums[i] > 0 and nums[i] <= n and nums[i] != i+1 and nums[i] != nums[nums[i]-1]:\n nums[nums[i] - 1], nums[i] = nums[i], nums[nums[i]-1]\n for i in range(n):\n if nums[i] != i + 1:\n return i + 1\n return n + 1\n"],"string":"[\n \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n nums = sorted(set(nums), key=lambda x: x)\\n result = 0\\n for i in range(len(nums)):\\n if nums[i] <= 0:\\n continue\\n elif nums[i] == result + 1:\\n result += 1\\n else:\\n break\\n return result + 1\",\n \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n if not nums:\\n return 1\\n for index in range(len(nums)):\\n while nums[index] != index + 1:\\n tmp = nums[index]\\n if tmp <= 0 or tmp > len(nums) or tmp == nums[tmp - 1]:\\n break\\n nums[index] = nums[tmp - 1]\\n nums[tmp - 1] = tmp\\n for index in range(len(nums)):\\n if nums[index] != index + 1:\\n return index + 1\\n return len(nums) + 1\\n\",\n \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n minSet = set()\\n maxSet = set()\\n nums = set(nums)\\n for num in nums:\\n \\n if num > 0:\\n if num + 1 in minSet:\\n minSet.remove(num + 1)\\n minSet.add(num)\\n if num - 1 in maxSet:\\n maxSet.remove(num - 1)\\n minSet.remove(num)\\n elif num - 1 in maxSet:\\n maxSet.remove(num - 1)\\n maxSet.add(num)\\n if num + 1 in minSet:\\n maxSet.remove(num)\\n minSet.remove(num + 1)\\n else:\\n minSet.add(num)\\n maxSet.add(num)\\n # print(\\\"min set:\\\", minSet)\\n # print(\\\"max set:\\\", maxSet)\\n if len(minSet) == 0 or len(maxSet) == 0:\\n return 1\\n return min(maxSet) + 1 if min(minSet) == 1 else 1\",\n \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n i = 0\\n n = len(nums)\\n \\n if not nums:\\n return(1)\\n while (i <n):\\n while ((nums[i] != i) and (nums[i] > 0) and (i<n) and (nums[i] < n) and (nums[i] != nums[nums[i]])):\\n temp = nums[nums[i]]\\n nums[nums[i]] = nums[i]\\n nums[i] = temp\\n i = i + 1\\n \\n i = 1\\n while(i<n):\\n if(nums[i] != i):\\n return(i)\\n i=i+1\\n if(nums[0] == n):\\n return(n+1)\\n else:\\n return(n)\\n \\n\",\n \"class Solution:\\n def firstMissingPositive(self, nums):\\n for i in range(len(nums)):\\n while 0 <= nums[i]-1 < len(nums) and nums[nums[i]-1] != nums[i]:\\n tmp = nums[i]-1\\n nums[i], nums[tmp] = nums[tmp], nums[i]\\n for i in range(len(nums)):\\n if nums[i] != i+1:\\n return i+1\\n return len(nums)+1\",\n \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n if nums == []:\\n return(1)\\n for _ in range(5):\\n for i in range(len(nums)):\\n if ((i + 1) != nums[i]) and (0 < nums[i] <= len(nums)):\\n nums[nums[i]-1], nums[i] = nums[i], nums[nums[i]-1]\\n #print(nums, 'up')\\n else:\\n pass\\n #print(nums)\\n for i in range(len(nums))[::-1]:\\n if ((i + 1) != nums[i]) and (0 < nums[i] <= len(nums)):\\n nums[nums[i]-1], nums[i] = nums[i], nums[nums[i]-1]\\n \\n else:\\n pass\\n #print(nums)\\n for i in range(len(nums)):\\n if not i+1 == nums[i]:\\n #print(nums)\\n return(i+1)\\n if sorted(nums) == nums:\\n return(len(nums)+1)\\n\",\n \"class Solution:\\n \\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n A=nums\\n n = len(A)\\n for index in range(n):\\n element = A[index]\\n while True:\\n if element <= 0 or element > n or element == A[element - 1]:\\n break\\n A[element - 1], element = element, A[element - 1]\\n for index in range(n):\\n if A[index] != index + 1:\\n return index + 1\\n return n + 1\\n \\n\",\n \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n i = 0\\n \\n while i < len(nums):\\n tmp = nums[i]\\n # exchange to its right idx\\n while tmp != i + 1 and tmp > 0 and tmp < len(nums):\\n nums[i] = nums[tmp-1]\\n nums[tmp-1] = tmp\\n if tmp == nums[i]:\\n break\\n tmp = nums[i]\\n i += 1\\n print(nums)\\n \\n for i in range(len(nums)):\\n if nums[i] != i+1:\\n return i+1\\n return len(nums) + 1\\n\",\n \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n # put numbers to their places\\n # [-1,0,2,1] -> [1,2,0,0]\\n for i in range(len(nums)):\\n if nums[i] < 0:\\n nums[i] = 0\\n \\n if nums[i] > 0 and nums[i] != i + 1:\\n j, nums[i] = nums[i], 0\\n while 0 < j <= len(nums) and nums[j-1] != j:\\n next_j = nums[j-1]\\n nums[j-1] = j\\n j = next_j\\n \\n for i, num in enumerate(nums):\\n if not num:\\n return i+1\\n \\n if nums and nums[-1] > 0:\\n return nums[-1] + 1\\n \\n return 1\\n\",\n \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n minSet = set()\\n maxSet = set()\\n nums = set(nums)\\n for num in nums:\\n \\n if num > 0:\\n if num + 1 in minSet:\\n minSet.remove(num + 1)\\n minSet.add(num)\\n if num - 1 in maxSet:\\n maxSet.remove(num - 1)\\n minSet.remove(num)\\n elif num - 1 in maxSet:\\n maxSet.remove(num - 1)\\n maxSet.add(num)\\n if num + 1 in minSet:\\n maxSet.remove(num)\\n minSet.remove(num + 1)\\n else:\\n minSet.add(num)\\n maxSet.add(num)\\n print(\\\"min set:\\\", minSet)\\n print(\\\"max set:\\\", maxSet)\\n if len(minSet) == 0 or len(maxSet) == 0:\\n return 1\\n return min(maxSet) + 1 if min(minSet) == 1 else 1\",\n \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n nums.append(0)\\n for i in range(len(nums)):\\n while 0 < nums[i] < len(nums) and nums[i] != i and nums[i] != nums[nums[i]]:\\n temp = nums[nums[i]]\\n nums[nums[i]] = nums[i]\\n nums[i] = temp\\n print((temp, nums))\\n for i in range(1, len(nums)):\\n if nums[i] != i:\\n return i\\n return len(nums)\\n\",\n \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n if not nums: return 1\\n n = len(nums)\\n for i in range(len(nums)):\\n while nums[i] > 0 and nums[i] <= n and nums[i] != nums[nums[i] - 1]:\\n tmp = nums[i]\\n nums[i] = nums[tmp - 1]\\n nums[tmp - 1] = tmp\\n for j in range(len(nums)):\\n if nums[j] != j + 1: return j + 1\\n return n + 1\\n\",\n \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n lnums=len(nums)\\n for i in range(lnums):\\n while 0<nums[i]<=lnums and nums[i]!=nums[nums[i]-1]:\\n tmp=nums[i]\\n print((i,tmp,nums))\\n nums[tmp-1],nums[i]=nums[i],nums[tmp-1]\\n print((i,tmp,nums))\\n for i in range(lnums):\\n if nums[i]!=i+1:\\n return i+1\\n return lnums+1\\n \\n \\n\",\n \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n if nums == []:\\n return(1)\\n for _ in range(10):\\n for i in range(len(nums)):\\n if ((i + 1) != nums[i]) and (0 < nums[i] <= len(nums)):\\n nums[nums[i]-1], nums[i] = nums[i], nums[nums[i]-1]\\n #print(nums, 'up')\\n else:\\n pass\\n #print(nums)\\n for i in range(len(nums))[::-1]:\\n if ((i + 1) != nums[i]) and (0 < nums[i] <= len(nums)):\\n nums[nums[i]-1], nums[i] = nums[i], nums[nums[i]-1]\\n \\n else:\\n pass\\n #print(nums)\\n for i in range(len(nums)):\\n if not i+1 == nums[i]:\\n #print(nums)\\n return(i+1)\\n if sorted(nums) == nums:\\n return(len(nums)+1)\\n\",\n \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n if len(nums) == 0:\\n return 1\\n nums.append(0)\\n \\n for i in reversed(range(len(nums))):\\n n = nums[i]\\n while n>=0 and n<len(nums) and i != n:\\n nums[n], nums[i] = nums[i], nums[n]\\n if n == nums[i]:\\n break\\n n = nums[i]\\n print(nums)\\n \\n \\n for i,n in enumerate(nums):\\n if i==0:\\n continue\\n if i != n:\\n return i\\n return nums[-1]+1\",\n \"class Solution:\\n def firstMissingPositive(self, nums):\\n \\\"\\\"\\\"\\n :type nums: List[int]\\n :rtype: int\\n \\\"\\\"\\\"\\n n = len(nums)\\n for i in range(n):\\n while nums[i] > 0 and nums[i] <= n and nums[i] != i+1 and nums[i] != nums[nums[i]-1]:\\n nums[nums[i] - 1], nums[i] = nums[i], nums[nums[i]-1]\\n for i in range(n):\\n if nums[i] != i + 1:\\n return i + 1\\n return n + 1\\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":16,"string":"16"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":95,"cells":{"problem_id":{"kind":"number","value":232,"string":"232"},"question":{"kind":"string","value":"In LOL world, there is a hero called Teemo and his attacking can make his enemy Ashe be in poisoned condition. Now, given the Teemo's attacking ascending time series towards Ashe and the poisoning time duration per Teemo's attacking, you need to output the total time that Ashe is in poisoned condition.\n\n\nYou may assume that Teemo attacks at the very beginning of a specific time point, and makes Ashe be in poisoned condition immediately.\n\nExample 1:\n\nInput: [1,4], 2\nOutput: 4\nExplanation: At time point 1, Teemo starts attacking Ashe and makes Ashe be poisoned immediately. This poisoned status will last 2 seconds until the end of time point 2. And at time point 4, Teemo attacks Ashe again, and causes Ashe to be in poisoned status for another 2 seconds. So you finally need to output 4.\n\n\n\n\nExample 2:\n\nInput: [1,2], 2\nOutput: 3\nExplanation: At time point 1, Teemo starts attacking Ashe and makes Ashe be poisoned. This poisoned status will last 2 seconds until the end of time point 2. However, at the beginning of time point 2, Teemo attacks Ashe again who is already in poisoned status. Since the poisoned status won't add up together, though the second poisoning attack will still work at time point 2, it will stop at the end of time point 3. So you finally need to output 3.\n\n\n\n\nNote:\n\nYou may assume the length of given time series array won't exceed 10000.\nYou may assume the numbers in the Teemo's attacking time series and his poisoning time duration per attacking are non-negative integers, which won't exceed 10,000,000."},"solutions":{"kind":"string","value":"[\"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if not timeSeries:\\n return 0\\n prev = timeSeries[0]\\n ret = 0\\n count = 0\\n for t in timeSeries[1:]:\\n diff = t - prev\\n if diff > duration:\\n count += 1\\n else:\\n ret += diff \\n prev = t;\\n ret += (count+1)*duration \\n return ret\\n\", \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if not timeSeries:\\n return 0\\n \\n previous_time = timeSeries[0]\\n total_time = duration\\n for time in timeSeries[1:]:\\n if time - previous_time < duration:\\n total_time += time - previous_time\\n previous_time =time\\n else:\\n total_time += duration\\n previous_time =time\\n \\n return total_time\", \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n res = 0\\n # i=0\\n if timeSeries == []:\\n return 0\\n last = timeSeries[0]\\n cur = timeSeries[0]\\n for i in range(1,len(timeSeries)):\\n if (timeSeries[i]-cur) < duration:\\n cur = timeSeries[i]\\n continue\\n else:\\n res+=cur-last+duration\\n last = timeSeries[i]\\n cur = timeSeries[i]\\n # print(\\\"i\\\",i,\\\"res\\\",res)\\n # i+=1\\n res+=cur-last+duration\\n \\n return res\", \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n total = 0\\n last = float('-inf')\\n for t in timeSeries:\\n total += duration\\n if last+duration > t:\\n total -= (last+duration) - t\\n last = t\\n return total\", \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n totalBlind = 0\\n lastBlindEnd = 0\\n ts = sorted(timeSeries)\\n for time in ts:\\n if time < lastBlindEnd:\\n totalBlind += time + duration - lastBlindEnd\\n else:\\n totalBlind += duration \\n lastBlindEnd = time + duration\\n return totalBlind\", \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if not timeSeries:\\n return 0\\n length = len(timeSeries)\\n if length == 1:\\n return duration\\n result = duration\\n \\n start_time, end_time = timeSeries[0], timeSeries[0] + duration - 1\\n for t in timeSeries[1:]:\\n if t <= end_time:\\n result += t + duration -1 - end_time\\n end_time = t + duration - 1\\n else:\\n result += duration \\n start_time, end_time = t, t + duration -1\\n return result\\n\", \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n return sum(min(duration, b - a) for a, b in zip(timeSeries, timeSeries[1:] + [10e7]))\\n\", \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if not timeSeries:\\n return 0\\n \\n total_poisoned_time = 0\\n \\n for i in range(len(timeSeries) - 1):\\n if timeSeries[i + 1] <= timeSeries[i] + duration:\\n total_poisoned_time += timeSeries[i + 1] - timeSeries[i]\\n else:\\n total_poisoned_time += duration\\n \\n total_poisoned_time += duration\\n \\n return total_poisoned_time\\n \\n\", \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n \\n \\n l = len(timeSeries)\\n if l == 0:\\n return 0\\n if l == 1:\\n return duration\\n \\n T = 0\\n i = 1\\n while i < l:\\n if timeSeries[i]-timeSeries[i-1] >= duration:\\n T += duration\\n else:\\n T += timeSeries[i]-timeSeries[i-1]\\n i += 1\\n T += duration\\n return T\", \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n '''\\n res = []\\n for time in timeSeries:\\n if res and res[-1][1] > time:\\n res[-1][1] = time\\n res.append([time, time+duration])\\n return sum([t[1]-t[0] for t in res])\\n '''\\n res = 0\\n cur = 0\\n for time in timeSeries:\\n res += min(duration, time+duration-cur)\\n cur = time+duration\\n return res\\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"findPoisonedDuration\", \"inputs\": [[[1, 4], 2]], \"outputs\": [4]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/teemo-attacking/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def findPoisonedDuration(self, timeSeries: List[int], duration: int) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def findPoisonedDuration(self, timeSeries, duration):\n \"\"\"\n :type timeSeries: List[int]\n :type duration: int\n :rtype: int\n \"\"\"\n if not timeSeries:\n return 0\n prev = timeSeries[0]\n ret = 0\n count = 0\n for t in timeSeries[1:]:\n diff = t - prev\n if diff > duration:\n count += 1\n else:\n ret += diff \n prev = t;\n ret += (count+1)*duration \n return ret\n","class Solution:\n def findPoisonedDuration(self, timeSeries, duration):\n \"\"\"\n :type timeSeries: List[int]\n :type duration: int\n :rtype: int\n \"\"\"\n if not timeSeries:\n return 0\n \n previous_time = timeSeries[0]\n total_time = duration\n for time in timeSeries[1:]:\n if time - previous_time < duration:\n total_time += time - previous_time\n previous_time =time\n else:\n total_time += duration\n previous_time =time\n \n return total_time","class Solution:\n def findPoisonedDuration(self, timeSeries, duration):\n \"\"\"\n :type timeSeries: List[int]\n :type duration: int\n :rtype: int\n \"\"\"\n res = 0\n # i=0\n if timeSeries == []:\n return 0\n last = timeSeries[0]\n cur = timeSeries[0]\n for i in range(1,len(timeSeries)):\n if (timeSeries[i]-cur) < duration:\n cur = timeSeries[i]\n continue\n else:\n res+=cur-last+duration\n last = timeSeries[i]\n cur = timeSeries[i]\n # print(\"i\",i,\"res\",res)\n # i+=1\n res+=cur-last+duration\n \n return res","class Solution:\n def findPoisonedDuration(self, timeSeries, duration):\n \"\"\"\n :type timeSeries: List[int]\n :type duration: int\n :rtype: int\n \"\"\"\n total = 0\n last = float('-inf')\n for t in timeSeries:\n total += duration\n if last+duration > t:\n total -= (last+duration) - t\n last = t\n return total","class Solution:\n def findPoisonedDuration(self, timeSeries, duration):\n \"\"\"\n :type timeSeries: List[int]\n :type duration: int\n :rtype: int\n \"\"\"\n totalBlind = 0\n lastBlindEnd = 0\n ts = sorted(timeSeries)\n for time in ts:\n if time < lastBlindEnd:\n totalBlind += time + duration - lastBlindEnd\n else:\n totalBlind += duration \n lastBlindEnd = time + duration\n return totalBlind","class Solution:\n def findPoisonedDuration(self, timeSeries, duration):\n \"\"\"\n :type timeSeries: List[int]\n :type duration: int\n :rtype: int\n \"\"\"\n if not timeSeries:\n return 0\n length = len(timeSeries)\n if length == 1:\n return duration\n result = duration\n \n start_time, end_time = timeSeries[0], timeSeries[0] + duration - 1\n for t in timeSeries[1:]:\n if t <= end_time:\n result += t + duration -1 - end_time\n end_time = t + duration - 1\n else:\n result += duration \n start_time, end_time = t, t + duration -1\n return result\n","class Solution:\n def findPoisonedDuration(self, timeSeries, duration):\n \"\"\"\n :type timeSeries: List[int]\n :type duration: int\n :rtype: int\n \"\"\"\n return sum(min(duration, b - a) for a, b in zip(timeSeries, timeSeries[1:] + [10e7]))\n","class Solution:\n def findPoisonedDuration(self, timeSeries, duration):\n \"\"\"\n :type timeSeries: List[int]\n :type duration: int\n :rtype: int\n \"\"\"\n if not timeSeries:\n return 0\n \n total_poisoned_time = 0\n \n for i in range(len(timeSeries) - 1):\n if timeSeries[i + 1] <= timeSeries[i] + duration:\n total_poisoned_time += timeSeries[i + 1] - timeSeries[i]\n else:\n total_poisoned_time += duration\n \n total_poisoned_time += duration\n \n return total_poisoned_time\n \n","class Solution:\n def findPoisonedDuration(self, timeSeries, duration):\n \"\"\"\n :type timeSeries: List[int]\n :type duration: int\n :rtype: int\n \"\"\"\n \n \n \n l = len(timeSeries)\n if l == 0:\n return 0\n if l == 1:\n return duration\n \n T = 0\n i = 1\n while i < l:\n if timeSeries[i]-timeSeries[i-1] >= duration:\n T += duration\n else:\n T += timeSeries[i]-timeSeries[i-1]\n i += 1\n T += duration\n return T","class Solution:\n def findPoisonedDuration(self, timeSeries, duration):\n \"\"\"\n :type timeSeries: List[int]\n :type duration: int\n :rtype: int\n \"\"\"\n '''\n res = []\n for time in timeSeries:\n if res and res[-1][1] > time:\n res[-1][1] = time\n res.append([time, time+duration])\n return sum([t[1]-t[0] for t in res])\n '''\n res = 0\n cur = 0\n for time in timeSeries:\n res += min(duration, time+duration-cur)\n cur = time+duration\n return res\n"],"string":"[\n \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if not timeSeries:\\n return 0\\n prev = timeSeries[0]\\n ret = 0\\n count = 0\\n for t in timeSeries[1:]:\\n diff = t - prev\\n if diff > duration:\\n count += 1\\n else:\\n ret += diff \\n prev = t;\\n ret += (count+1)*duration \\n return ret\\n\",\n \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if not timeSeries:\\n return 0\\n \\n previous_time = timeSeries[0]\\n total_time = duration\\n for time in timeSeries[1:]:\\n if time - previous_time < duration:\\n total_time += time - previous_time\\n previous_time =time\\n else:\\n total_time += duration\\n previous_time =time\\n \\n return total_time\",\n \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n res = 0\\n # i=0\\n if timeSeries == []:\\n return 0\\n last = timeSeries[0]\\n cur = timeSeries[0]\\n for i in range(1,len(timeSeries)):\\n if (timeSeries[i]-cur) < duration:\\n cur = timeSeries[i]\\n continue\\n else:\\n res+=cur-last+duration\\n last = timeSeries[i]\\n cur = timeSeries[i]\\n # print(\\\"i\\\",i,\\\"res\\\",res)\\n # i+=1\\n res+=cur-last+duration\\n \\n return res\",\n \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n total = 0\\n last = float('-inf')\\n for t in timeSeries:\\n total += duration\\n if last+duration > t:\\n total -= (last+duration) - t\\n last = t\\n return total\",\n \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n totalBlind = 0\\n lastBlindEnd = 0\\n ts = sorted(timeSeries)\\n for time in ts:\\n if time < lastBlindEnd:\\n totalBlind += time + duration - lastBlindEnd\\n else:\\n totalBlind += duration \\n lastBlindEnd = time + duration\\n return totalBlind\",\n \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if not timeSeries:\\n return 0\\n length = len(timeSeries)\\n if length == 1:\\n return duration\\n result = duration\\n \\n start_time, end_time = timeSeries[0], timeSeries[0] + duration - 1\\n for t in timeSeries[1:]:\\n if t <= end_time:\\n result += t + duration -1 - end_time\\n end_time = t + duration - 1\\n else:\\n result += duration \\n start_time, end_time = t, t + duration -1\\n return result\\n\",\n \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n return sum(min(duration, b - a) for a, b in zip(timeSeries, timeSeries[1:] + [10e7]))\\n\",\n \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n if not timeSeries:\\n return 0\\n \\n total_poisoned_time = 0\\n \\n for i in range(len(timeSeries) - 1):\\n if timeSeries[i + 1] <= timeSeries[i] + duration:\\n total_poisoned_time += timeSeries[i + 1] - timeSeries[i]\\n else:\\n total_poisoned_time += duration\\n \\n total_poisoned_time += duration\\n \\n return total_poisoned_time\\n \\n\",\n \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n \\n \\n \\n l = len(timeSeries)\\n if l == 0:\\n return 0\\n if l == 1:\\n return duration\\n \\n T = 0\\n i = 1\\n while i < l:\\n if timeSeries[i]-timeSeries[i-1] >= duration:\\n T += duration\\n else:\\n T += timeSeries[i]-timeSeries[i-1]\\n i += 1\\n T += duration\\n return T\",\n \"class Solution:\\n def findPoisonedDuration(self, timeSeries, duration):\\n \\\"\\\"\\\"\\n :type timeSeries: List[int]\\n :type duration: int\\n :rtype: int\\n \\\"\\\"\\\"\\n '''\\n res = []\\n for time in timeSeries:\\n if res and res[-1][1] > time:\\n res[-1][1] = time\\n res.append([time, time+duration])\\n return sum([t[1]-t[0] for t in res])\\n '''\\n res = 0\\n cur = 0\\n for time in timeSeries:\\n res += min(duration, time+duration-cur)\\n cur = time+duration\\n return res\\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":10,"string":"10"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4,5,6,7,8,9],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":96,"cells":{"problem_id":{"kind":"number","value":233,"string":"233"},"question":{"kind":"string","value":"In a N x N grid composed of 1 x 1 squares, each 1 x 1 square consists of a /, \\, or blank space. These characters divide the square into contiguous regions.\n(Note that backslash characters are escaped, so a \\ is represented as \"\\\\\".)\nReturn the number of regions.\n \n\n\n\n\n\n\n\n\n\n\n\n\n\nExample 1:\nInput:\n[\n \" /\",\n \"/ \"\n]\nOutput: 2\nExplanation: The 2x2 grid is as follows:\n\n\n\nExample 2:\nInput:\n[\n \" /\",\n \" \"\n]\nOutput: 1\nExplanation: The 2x2 grid is as follows:\n\n\n\nExample 3:\nInput:\n[\n \"\\\\/\",\n \"/\\\\\"\n]\nOutput: 4\nExplanation: (Recall that because \\ characters are escaped, \"\\\\/\" refers to \\/, and \"/\\\\\" refers to /\\.)\nThe 2x2 grid is as follows:\n\n\n\nExample 4:\nInput:\n[\n \"/\\\\\",\n \"\\\\/\"\n]\nOutput: 5\nExplanation: (Recall that because \\ characters are escaped, \"/\\\\\" refers to /\\, and \"\\\\/\" refers to \\/.)\nThe 2x2 grid is as follows:\n\n\n\nExample 5:\nInput:\n[\n \"//\",\n \"/ \"\n]\nOutput: 3\nExplanation: The 2x2 grid is as follows:\n\n\n \nNote:\n\n1 <= grid.length == grid[0].length <= 30\ngrid[i][j] is either '/', '\\', or ' '."},"solutions":{"kind":"string","value":"[\"from itertools import chain\\nclass Solution:\\n def regionsBySlashes(self, grid):\\n grid = self.convert_grid(grid)\\n print(*(list(map(str, x)) for x in grid), sep='\\\\\\n')\\n return len([self.destroy_island(x, y, grid) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v == 0])\\n\\n @staticmethod\\n def convert_grid(grid):\\n new_grid = [[0] * len(grid[0]) * 2 for _ in range(len(grid) * 2)]\\n for (x, y, v) in ((x, y, v) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v in '\\\\\\\\\\\\\\\\/'):\\n new_grid[y * 2 + 0][x * 2 + (1 if v == '/' else 0)] = v\\n new_grid[y * 2 + 1][x * 2 + (0 if v == '/' else 1)] = v\\n return new_grid\\n\\n def destroy_island(self, x, y, grid):\\n grid[y][x] = 1\\n for c in Solution.search(x, y, grid):\\n self.destroy_island(c[0], c[1], grid)\\n\\n @staticmethod\\n def search(x, y, grid):\\n in_bounds = lambda c:0 <= c[1] < len(grid) and 0 <= c[0] < len(grid[c[1]])\\n check_orthog = lambda c:in_bounds(c) and grid[c[1]][c[0]] == 0\\n def check_diag(c):\\n if not in_bounds(c) or grid[c[1]][c[0]] != 0: return False\\n d_x, d_y = c[0] - x, c[1] - y\\n sep = '\\\\\\\\\\\\\\\\' if ((d_x > 0 > d_y) or (d_x < 0 < d_y)) else '/'\\n return not (grid[y + d_y][x] == sep and grid[y][x + d_x] == sep)\\n yield from chain(filter(check_orthog, ((x-1, y), (x+1, y), (x, y-1), (x, y+1))),\\n filter(check_diag, ((x + 1, y + 1), (x + 1, y - 1), (x - 1, y + 1), (x - 1, y - 1))))\", \"class DSU:\\n def __init__(self):\\n self.parent = {}\\n \\n def find(self, x):\\n if x not in self.parent:\\n self.parent[x] = x\\n if self.parent[x] != x:\\n self.parent[x] = self.find(self.parent[x])\\n \\n return self.parent[x]\\n \\n def union(self, x, y):\\n xroot, yroot = self.find(x), self.find(y)\\n if xroot != yroot:\\n self.parent[yroot] = xroot\\n\\nclass Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n n = len(grid)\\n dsu = DSU()\\n \\n for i in range(n):\\n for j in range(n):\\n if i > 0:\\n dsu.union((i - 1, j, 2), (i, j, 0))\\n if j > 0:\\n dsu.union((i, j - 1, 1), (i, j, 3))\\n if grid[i][j] != '/':\\n dsu.union((i, j, 0), (i, j, 1))\\n dsu.union((i, j, 2), (i, j, 3))\\n if grid[i][j] != '\\\\\\\\\\\\\\\\':\\n dsu.union((i, j, 3), (i, j, 0))\\n dsu.union((i, j, 1), (i, j, 2))\\n \\n seen = set()\\n for key in dsu.parent.keys():\\n temp = dsu.find(key)\\n seen.add(temp)\\n \\n return len(seen)\", \"from typing import List\\n\\nclass DS:\\n \\n def __init__(self, n):\\n self.sizes = [1] * n\\n self.roots = [i for i in range(n)]\\n \\n def query(self, x):\\n root = x\\n while root != self.roots[root]:\\n self.roots[root] = self.roots[self.roots[root]]\\n root = self.roots[root]\\n return root\\n \\n def union(self, x, y):\\n xRoot, yRoot = self.query(x), self.query(y)\\n s, l = (xRoot, yRoot) if self.sizes[xRoot] < self.sizes[yRoot] else (yRoot, xRoot)\\n self.roots[s] = l\\n self.sizes[l] += self.sizes[s] \\n\\nclass Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n n = len(grid)\\n nodes = DS(4 * n * n)\\n getIndex = lambda r, c, k: 4 * (n * r + c) + k\\n for i in range(n):\\n for j in range(n):\\n if i > 0: nodes.union(getIndex(i, j, 0), getIndex(i - 1, j, 2))\\n if i < n - 1: nodes.union(getIndex(i, j, 2), getIndex(i + 1, j, 0))\\n if j > 0: nodes.union(getIndex(i, j, 3), getIndex(i, j - 1, 1))\\n if j < n - 1: nodes.union(getIndex(i, j, 1), getIndex(i, j + 1, 3))\\n if grid[i][j] != '/':\\n nodes.union(getIndex(i, j, 0), getIndex(i, j, 1))\\n nodes.union(getIndex(i, j, 3), getIndex(i, j, 2))\\n if grid[i][j] != '\\\\\\\\\\\\\\\\':\\n nodes.union(getIndex(i, j, 0), getIndex(i, j, 3))\\n nodes.union(getIndex(i, j, 1), getIndex(i, j, 2))\\n return sum(i == nodes.query(i) for i in range(4 * n * n))\", \"class Solution:\\n f = {}\\n def find(self, x):\\n self.f.setdefault(x,x)\\n if self.f[x] != x: \\n self.f[x] = self.find(self.f[x])\\n return self.f[x]\\n \\n def union(self, x, y):\\n self.f[self.find(x)] = self.find(y)\\n \\n def regionsBySlashes(self, grid: List[str]) -> int:\\n self.f = {}\\n for row in range(len(grid)):\\n for col in range(len(grid)):\\n if row: \\n self.union((row-1,col,2),(row,col,0))\\n if col: \\n self.union((row,col-1,3),(row,col,1))\\n if grid[row][col] != '/':\\n self.union((row,col,0),(row,col,3))\\n self.union((row,col,1),(row,col,2))\\n if grid[row][col] != '\\\\\\\\\\\\\\\\':\\n self.union((row,col,0), (row,col,1))\\n self.union((row,col,2), (row,col,3))\\n \\n return len(set(map(self.find,self.f)))\\n \\n\", \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n for i in range(len(grid)):\\n grid[i] = grid[i].replace('\\\\\\\\\\\\\\\\', '*')\\n N = len(grid)\\n record = [[[0,0,0,0] for j in range(N)] for i in range(N)]\\n #visited = set()\\n #print(grid)\\n count = 0\\n def dfs(i,j,k):\\n if 0 <= i < N and 0 <= j < N and record[i][j][k] == 0:\\n if grid[i][j] == '*':\\n if k <= 1:\\n record[i][j][0] = record[i][j][1] = count\\n dfs(i-1, j, 2)\\n dfs(i, j+1, 3)\\n else:\\n record[i][j][2] = record[i][j][3] = count\\n dfs(i+1, j, 0)\\n dfs(i, j-1, 1)\\n elif grid[i][j] == '/':\\n if 1 <= k <= 2:\\n record[i][j][1] = record[i][j][2] = count\\n dfs(i+1, j, 0)\\n dfs(i, j+1, 3)\\n else:\\n record[i][j][0] = record[i][j][3] = count\\n dfs(i-1, j, 2)\\n dfs(i, j-1, 1)\\n else:\\n record[i][j][0] = record[i][j][1] = record[i][j][2] = record[i][j][3] = count\\n dfs(i-1, j, 2)\\n dfs(i, j+1, 3)\\n dfs(i+1, j, 0)\\n dfs(i, j-1, 1)\\n \\n for i in range(N):\\n for j in range(N):\\n for k in range(4):\\n if record[i][j][k] == 0:\\n count += 1\\n dfs(i,j,k)\\n return count\", \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n \\n N = len(grid)\\n \\n matrix = [list(s) for s in grid]\\n \\n parent = list(range(N * N * 4))\\n print(parent)\\n def find(x):\\n depth = 0\\n while parent[x] != x:\\n x = parent[x]\\n depth += 1\\n return x, depth\\n \\n def union(x, y):\\n print((x, y))\\n (rx, dx), (ry, dy) = find(x), find(y)\\n if dx < dy:\\n parent[rx] = ry\\n else:\\n parent[ry] = rx\\n \\n def isValid(i, j):\\n if i >= N or i < 0 or j >= N or j < 0:\\n return False\\n return True\\n\\n # dirs = [(0, 1), (-1, 0)]\\n for i in range(N):\\n for j in range(N):\\n idtop = (i * N + j) * 4\\n if matrix[i][j] == '/':\\n union(idtop + 1, idtop + 2)\\n union(idtop, idtop + 3)\\n elif matrix[i][j] == '\\\\\\\\\\\\\\\\':\\n union(idtop, idtop + 1)\\n union(idtop + 2, idtop + 3) \\n else:\\n union(idtop, idtop + 1)\\n union(idtop, idtop + 2)\\n union(idtop, idtop + 3)\\n if isValid(i-1, j):\\n union(idtop, 4 *((i-1) * N + j) + 2)\\n if isValid(i, j-1):\\n union(idtop + 3, 4 * (i * N + j - 1) + 1)\\n return len(set(find(x)[0] for x in range(4 * N * N)))\\n \\n\", \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n m, n = len(grid), len(grid[0])\\n print(m, n)\\n mat = [[0] * (4*n) for _ in range(4*m)]\\n for i in range(m):\\n for j in range(n):\\n if grid[i][j] == '/':\\n mat[4*i][4*j+3] = 1\\n mat[4*i+1][4*j+2] = 1\\n mat[4*i+2][4*j+1] = 1\\n mat[4*i+3][4*j] = 1\\n elif grid[i][j] == '\\\\\\\\\\\\\\\\':\\n mat[4*i][4*j] = 1\\n mat[4*i+1][4*j+1] = 1\\n mat[4*i+2][4*j+2] = 1\\n mat[4*i+3][4*j+3] = 1\\n # print(mat)\\n dirs = [[-1,0],[1,0],[0,1],[0,-1]]\\n def dfs(i, j):\\n visit[i][j] = 1\\n for d in dirs:\\n x, y = i+d[0], j+d[1]\\n if 0<=x<(4*m) and 0<=y<(4*n) and not mat[x][y]:\\n mat[x][y] = 1\\n if not visit[x][y]:\\n dfs(x, y)\\n \\n visit = [[0]*(4*n) for _ in range(4*m)]\\n res = 0\\n for i in range(4*m):\\n for j in range(4*n):\\n if not mat[i][j]:\\n res += 1\\n dfs(i, j)\\n return res\", \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n n = len(grid)\\n seen = [[[0,0,0,0] for x in range(n)] for y in range(n)]\\n # top 1, left 2, bottom 3, right 0\\n def dfs(x, y, loc):\\n #print(x,y)\\n if not ( 0<=x<n and 0<=y<n) or seen[x][y][loc] == 1:\\n return\\n seen[x][y][loc] = 1\\n \\n if grid[x][y] == '/':\\n if loc == 0:\\n dfs(x+1,y,2)\\n seen[x][y][3] = 1\\n dfs(x, y+1, 1)\\n elif loc == 3:\\n dfs(x,y+1,1)\\n seen[x][y][0] = 1\\n dfs(x+1, y, 2)\\n elif loc == 1:\\n dfs(x,y-1,3)\\n seen[x][y][2] = 1\\n dfs(x-1, y, 0)\\n else:\\n dfs(x-1,y,0)\\n seen[x][y][1] = 1\\n dfs(x, y-1, 3)\\n elif grid[x][y] == '\\\\\\\\\\\\\\\\':\\n if loc == 0:\\n dfs(x+1,y,2)\\n seen[x][y][1] = 1\\n dfs(x, y-1, 3) \\n elif loc == 3:\\n dfs(x,y+1,1)\\n seen[x][y][2] = 1\\n dfs(x-1, y, 0)\\n elif loc == 1:\\n dfs(x,y-1,3)\\n seen[x][y][0] = 1\\n dfs(x+1, y, 2)\\n else:\\n dfs(x-1,y,0)\\n seen[x][y][3] = 1\\n dfs(x, y+1, 1)\\n else:\\n seen[x][y][1] = 1\\n dfs(x, y-1, 3)\\n seen[x][y][2] = 1\\n dfs(x-1, y, 0)\\n seen[x][y][0] = 1\\n dfs(x+1, y, 2)\\n seen[x][y][3] = 1\\n dfs(x, y+1, 1)\\n count = 0\\n for i in range(n):\\n for j in range(n):\\n for loc in range(4):\\n k = seen[i][j][loc]\\n if k == 0:\\n #print(i,j,k, seen)\\n count += 1\\n dfs(i,j,loc)\\n return count\", \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n \\n N = len(grid)\\n base = N * (N + 1)\\n parent = [i for i in range(2 * base)]\\n \\n def find(x):\\n if parent[x] != parent[parent[x]]:\\n parent[x] = find(parent[x])\\n return parent[x]\\n \\n def union(x, y):\\n parent[find(x)] = find(y)\\n return find(y)\\n \\n for i in range(N):\\n for j in range(N):\\n up, down, left, right = i * N + j, (i + 1) * N + j, base + i * (N + 1) + j, base + i * (N + 1) + j + 1\\n \\n if grid[i][j] == '/':\\n union(up, left)\\n union(down, right)\\n elif grid[i][j] == '\\\\\\\\\\\\\\\\':\\n union(up, right)\\n union(down, left)\\n else:\\n union(up, left)\\n union(down, right)\\n union(left, right)\\n \\n comp = set()\\n for i in range(2 * base):\\n comp.add(find(i))\\n \\n return len(comp)\", \"class Solution:\\n \\n def regionsBySlashes(self, grid: List[str]):\\n def minAnglePoint(p1, p2, options):\\n minAngle = 10.0 # a ridiculously big number\\n for p3 in options:\\n a = (p2[0] - p1[0], p2[1] - p1[1])\\n b = (p3[0] - p2[0], p3[1] - p2[1])\\n dot = a[0] * b[0] + a[1] * b[1]\\n det = a[0] * b[1] - a[1] * b[0]\\n ang = math.atan2(det, dot)\\n if ang < minAngle: \\n minAngle = ang\\n res = p3\\n return res, minAngle\\n\\n N = len(grid)\\n M = dict()\\n for i in range(N):\\n M[(i + 1, 0)] = [(i, 0)]\\n M[(N, i + 1)] = [(N, i)]\\n M[(N - i - 1, N)] = [(N - i, N)]\\n M[(0, N - i - 1)] = [(0, N - i)]\\n for y in range(N):\\n x = 0\\n for c in grid[y]:\\n if c == '/':\\n if (x + 1, y) in M: \\n M[(x + 1, y)].append((x, y + 1))\\n else: \\n M[(x + 1, y)] = [(x, y + 1)]\\n if (x, y + 1) in M:\\n M[(x, y + 1)].append((x + 1, y))\\n else:\\n M[(x, y + 1)] = [(x + 1, y)]\\n elif c == '\\\\\\\\\\\\\\\\':\\n if (x, y) in M: \\n M[(x, y)].append((x + 1, y + 1))\\n else:\\n M[(x, y)] = [(x + 1, y + 1)]\\n if (x + 1, y + 1) in M: \\n M[(x + 1, y + 1)].append((x, y))\\n else:\\n M[(x + 1, y + 1)] = [(x, y)]\\n x += 1\\n innerangle = round(-2 * math.pi, 4)\\n points = sorted(M)\\n regions = set()\\n for i in range(len(points)):\\n if points[i] not in M: continue\\n startpoint = points[i]\\n region = {startpoint}\\n point = firststep = M[startpoint][0]\\n M[startpoint].remove(point)\\n prev = startpoint\\n angSum = 0\\n while point != startpoint:\\n region.add(point)\\n links = M[point]\\n nxt, ang = minAnglePoint(prev, point, links)\\n angSum += ang\\n if len(links) == 1: \\n del M[point]\\n else:\\n M[point].remove(nxt)\\n prev = point\\n point = nxt\\n if len(M[startpoint]) == 0: \\n del M[startpoint]\\n \\n _, ang = minAnglePoint(prev, point, [firststep])\\n angSum = round(angSum + ang, 4)\\n if angSum == innerangle: # it is a valid region\\n regions.add(frozenset(region))\\n return len(regions)\", \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n N = len(grid)\\n new_grid = [[0]*(2*N) for _ in range(2*N)]\\n count = 0\\n \\n for i in range(N):\\n for j in range(N):\\n if grid[i][j] == '/':\\n new_grid[2*i][2*j+1] = 1\\n new_grid[2*i+1][2*j] = 1\\n elif grid[i][j] == '\\\\\\\\\\\\\\\\':\\n new_grid[2*i][2*j] = 1\\n new_grid[2*i+1][2*j+1] = 1\\n \\n def dfs(grid, i, j):\\n # starting with a seed (0 in location i,j), build up an open space\\n if grid[i][j] == 1:\\n return None\\n grid[i][j] = 1 # mark as visited\\n if i < len(grid)-1: # (make sure i+1 exists)\\n dfs(grid, i+1, j) # search down \\n if j < len(grid)-1: \\n dfs(grid, i, j+1)# search right\\n if i > 0:\\n dfs(grid, i-1, j) # search up\\n if j > 0:\\n dfs(grid, i, j-1) #search left\\n # search dl\\n if i < len(grid)-1 and j > 0 and i%2==j%2:\\n dfs(grid, i+1, j-1)\\n # search ur\\n if i > 0 and j < len(grid)-1 and i%2==j%2:\\n dfs(grid, i-1, j+1)\\n # search dr\\n if i < len(grid)-1 and j < len(grid)-1 and i%2!=j%2:\\n dfs(grid, i+1, j+1)\\n # search ul\\n if i > 0 and j > 0 and i%2!=j%2:\\n dfs(grid, i-1, j-1)\\n \\n # search for seeds (new islands)\\n for i in range(2*N):\\n for j in range(2*N):\\n if new_grid[i][j] == 0:\\n count += 1\\n dfs(new_grid, i, j) # seed an island\\n \\n return count\\n \\n\", \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n nrow = len(grid)\\n ncol = len(grid[0])\\n newgrid = []\\n for i in range(nrow*3):\\n newgrid.append([0]*ncol*3)\\n for r in range(nrow):\\n for c in range(ncol):\\n if grid[r][c] == '\\\\\\\\\\\\\\\\':\\n newgrid[r*3][c*3] = 1\\n newgrid[r*3+1][c*3+1] = 1\\n newgrid[r*3+2][c*3+2] = 1\\n elif grid[r][c] == '/':\\n newgrid[r*3+2][c*3] = 1\\n newgrid[r*3+1][c*3+1] = 1\\n newgrid[r*3][c*3+2] = 1\\n \\n def countIsland(newgrid):\\n count = 0\\n def dfs(r,c):\\n if newgrid[r][c] == 0:\\n newgrid[r][c] =1\\n if r < len(newgrid) -1 and newgrid[r+1][c] ==0:\\n dfs(r+1,c)\\n if c < len(newgrid[0]) -1 and newgrid[r][c+1] ==0:\\n dfs(r,c+1)\\n if r > 0 and newgrid[r-1][c] ==0:\\n dfs(r-1,c)\\n if c > 0 and newgrid[r][c-1] ==0:\\n dfs(r,c-1)\\n \\n \\n for r1 in range(len(newgrid)):\\n for c1 in range(len(newgrid[0])):\\n if newgrid[r1][c1] == 0:\\n dfs(r1,c1)\\n count+=1\\n else:\\n pass\\n return(count)\\n \\n return(countIsland(newgrid))\", \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n N = len(grid) \\n D = list(range(N*N*4))\\n res = [len(D)]\\n def find(D,i):\\n if D[i]==i:\\n return i\\n return find(D,D[i])\\n \\n def union(D,i,j):\\n pi = find(D,i)\\n pj = find(D,j)\\n if pi==pj:\\n return\\n else:\\n D[pi] = pj\\n res[0] -= 1\\n \\n def idx(i,j,e):\\n return (i*N+j)*4+e\\n \\n \\n \\n for i in range(N):\\n for j in range(N):\\n if i>0:\\n union(D,idx(i-1,j,2),idx(i,j,0))\\n if j>0:\\n union(D,idx(i,j-1,1,),idx(i,j,3))\\n if grid[i][j]!='/':\\n union(D,idx(i,j,0),idx(i,j,1))\\n union(D,idx(i,j,2),idx(i,j,3))\\n if grid[i][j]!='\\\\\\\\\\\\\\\\':\\n union(D,idx(i,j,0),idx(i,j,3))\\n union(D,idx(i,j,1),idx(i,j,2))\\n return res[0]\\n \\n \\n \\n\", \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n m, n = len(grid), len(grid[0])\\n parent = {}\\n def find(x):\\n if parent[x] != x:\\n parent[x] = find(parent[x])\\n return parent[x]\\n \\n def union(x, y):\\n rx, ry = find(x), find(y)\\n if rx == ry:\\n return False\\n parent[rx] = ry\\n return True\\n \\n res = m * n * 4\\n for i in range(m):\\n for j in range(n):\\n for k in range(4):\\n parent[(i, j, k)] = (i, j, k)\\n if grid[i][j] == '/':\\n if union((i, j, 0), (i, j, 3)):\\n res -= 1\\n if union((i, j, 1), (i, j, 2)):\\n res -= 1\\n elif grid[i][j] == '\\\\\\\\\\\\\\\\':\\n if union((i, j, 0), (i, j, 1)):\\n res -= 1\\n if union((i, j, 2), (i, j, 3)):\\n res -= 1\\n else:\\n if union((i, j, 0), (i, j, 1)):\\n res -= 1\\n if union((i, j, 2), (i, j, 3)):\\n res -= 1\\n if union((i, j, 0), (i, j, 3)):\\n res -= 1\\n \\n if i > 0:\\n if union((i, j, 0), (i - 1, j, 2)):\\n res -= 1\\n if j > 0:\\n if union((i, j, 3), (i, j - 1, 1)):\\n res -= 1\\n return res\", \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n self.N = len(grid)#n\\u884c\\n print((self.N))\\n pre = list(range(self.N*self.N*4))#\\u6240\\u6709\\u5143\\u7d20\\u81ea\\u5df1\\u662f\\u81ea\\u5df1\\u7684\\u7236\\u8282\\u70b9[0,1,2,3,4,5,6,...]\\n self.count = self.N*self.N*4 #\\u603b\\u5171\\u7684\\u533a\\u57df\\u6570\\u91cf\\n for r in range(self.N):\\n line = grid[r]\\n for c in range(self.N):\\n w = line[c]\\n if r > 0:\\n self.union(pre, self.g(r - 1, c, 2), self.g(r, c, 0))\\n if c > 0:\\n self.union(pre, self.g(r, c - 1, 1), self.g(r, c, 3))\\n if w != '/':\\n self.union(pre, self.g(r, c, 0), self.g(r, c, 1))\\n self.union(pre, self.g(r, c, 3), self.g(r, c, 2))\\n if w != '\\\\\\\\\\\\\\\\':\\n self.union(pre, self.g(r, c, 0), self.g(r, c, 3))\\n self.union(pre, self.g(r, c, 1), self.g(r, c, 2))\\n return self.count \\n \\n def find(self,pre,x):\\n if x == pre[x]:\\n return x\\n \\n return self.find(pre,pre[x])\\n def union(self, pre, a, b):\\n pa = self.find(pre, a)\\n pb = self.find(pre, b)\\n if (pa == pb):\\n return\\n pre[pa] = pb\\n self.count -= 1\\n \\n def g(self, r, c, i):\\n return (r * self.N + c) * 4 + i\\n\", \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n f = {}\\n def find(x):\\n if (x not in f):\\n f[x] = x\\n elif(f[x] != x):\\n f[x] = find(f[x])\\n return f[x]\\n def merge(x,y):\\n rx,ry = find(x),find(y)\\n f[rx] = ry\\n\\n rows, cols = len(grid), len(grid[0]) if grid else 0\\n for i in range(rows):\\n for j in range(cols):\\n cur = (i * cols + j) * 4\\n up, left = ((i - 1) * cols + j) * 4, (i * cols + j - 1) * 4\\n cl, cr, cd = cur + 3, cur + 1, cur + 2\\n lr,ud = left + 1, up + 2\\n if (grid[i][j] == '/'):\\n merge(cur, cl)\\n merge(cr, cd)\\n elif (grid[i][j] == '\\\\\\\\\\\\\\\\'):\\n merge(cur, cr)\\n merge(cl, cd)\\n else:\\n merge(cur, cr)\\n merge(cl, cd)\\n merge(cur, cl)\\n if (i >= 1):\\n merge(cur,ud)\\n if (j >= 1):\\n merge(cl,lr)\\n res = 0\\n for i in range(rows):\\n for j in range(cols):\\n cur = (i * cols + j) * 4\\n for dx in range(4):\\n if (cur+dx == find(cur+dx)):\\n res += 1\\n return res\\n\", \"class UnionFind:\\n def __init__(self, N):\\n self.par = list(range(N))\\n self.rank = [0]*N\\n \\n def find(self, x):\\n if self.par[x] != x:\\n self.par[x] = self.find(self.par[x])\\n return self.par[x]\\n \\n def union(self, x, y):\\n px, py = self.find(x), self.find(y)\\n if px==py: return\\n \\n if self.rank[px]<self.rank[py]:\\n self.par[px] = py\\n elif self.rank[px]>self.rank[py]:\\n self.par[py] = px\\n else:\\n self.par[py] = px\\n self.rank[px] += 1\\n \\nclass Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n N = len(grid)\\n uf = UnionFind(4*N*N)\\n \\n for i in range(N):\\n for j in range(N):\\n idx = 4*(i*N+j)\\n if grid[i][j]!='/':\\n uf.union(idx, idx+1)\\n uf.union(idx+2, idx+3)\\n if grid[i][j]!='\\\\\\\\\\\\\\\\':\\n uf.union(idx, idx+3)\\n uf.union(idx+1, idx+2)\\n\\n if i:\\n uf.union(idx, idx-4*N+2)\\n if j:\\n uf.union(idx+3, idx-4+1)\\n # print(uf.par)\\n return sum(uf.find(x)==x for x in range(4*N*N))\", \"class Unionset:\\n def __init__(self,N):\\n self.parent=[x for x in range(N)]\\n self.rank=[0 for x in range(N)]\\n def find(self,x):\\n if self.parent[x]!=x:\\n self.parent[x]=self.find(self.parent[x])\\n return self.parent[x]\\n def union(self,x,y):\\n xx=self.find(x)\\n yy=self.find(y)\\n if self.parent[xx]==self.parent[yy]:\\n return True\\n if self.rank[xx]>self.rank[yy]:\\n self.parent[yy]=self.parent[xx]\\n elif self.rank[xx]<self.rank[yy]:\\n self.parent[xx]=self.parent[yy]\\n else:\\n self.rank[xx]+=1\\n self.parent[yy]=self.parent[xx]\\n return False\\n \\n \\nclass Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n n=len(grid)\\n ds=Unionset(n*n*4)\\n #print(ds.parent)\\n for r in range(n):\\n for c in range(n):\\n root=4*(r*n+c)\\n if grid[r][c]=='/':\\n ds.union(root,root+1)\\n ds.union(root+2,root+3)\\n elif grid[r][c]=='\\\\\\\\\\\\\\\\':\\n ds.union(root,root+2)\\n ds.union(root+1,root+3)\\n else:\\n ds.union(root,root+1)\\n ds.union(root+1,root+2)\\n ds.union(root+2,root+3)\\n #print(grid[r][c])\\n #print(\\\\\\\"first\\\\\\\",ds.parent)\\n if r+1<n:\\n ds.union(root+3,root+(4*n))\\n if c+1<n:\\n ds.union(root+2,root+5)\\n #print(\\\\\\\"second\\\\\\\",ds.parent)\\n tot=0\\n for i in range(4*n*n):\\n if ds.find(i)==i:\\n tot+=1\\n return tot\\n\", \"#\\n# *-------*\\n# | \\\\\\\\ 0 / |\\n# | 3 * 1 |\\n# | / 2 \\\\\\\\ |\\n# *-------*\\nclass DSU:\\n def __init__(self, N):\\n self.pres = list(range(N)) # \\u521d\\u59cb\\uff0c\\u6bcf\\u4e2a\\u8282\\u70b9\\u6307\\u5411\\u81ea\\u5df1\\n def setRoot(self, i, root):\\n while self.pres[i] != root:\\n t = self.pres[i]\\n self.pres[i] = root\\n i = t\\n return \\n def findRoot(self, i):\\n root = i\\n while root != self.pres[root]:\\n root = self.pres[root]\\n self.setRoot(i, root)\\n return root\\n def merge(self, i, j):\\n root = self.findRoot(i)\\n self.setRoot(j, root)\\n \\n \\nclass Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n def getPos(N, h, w, i):\\n return N*4 * h + 4*w + i\\n\\n # \\u501f\\u9274\\u4e09\\u89d2\\u9762\\u7247\\u601d\\u8def\\n N = len(grid)\\n NN4 = N*N*4\\n dsu = DSU(NN4)\\n \\n # \\u5408\\u5e76\\u4e34\\u8fd1\\u77e9\\u5f62\\n for h in range(N):\\n for w in range(N):\\n p = getPos(N, h, w, 0)\\n pR = getPos(N, h, w+1, 0)\\n pD = getPos(N, h+1, w, 0) \\n pRD= getPos(N, h+1, w+1, 0)\\n if h < N-1:\\n dsu.merge(p+2, pD+0)\\n if w < N-1:\\n dsu.merge(p+1, pR+3)\\n \\n\\n # \\u68c0\\u67e5\\u8f93\\u5165\\u7f51\\u683c\\n for h in range(N):\\n for w in range(N):\\n p = getPos(N, h, w, 0)\\n if grid[h][w] == '/':\\n dsu.merge(p+0, p+3)\\n dsu.merge(p+1, p+2)\\n elif grid[h][w] == '\\\\\\\\\\\\\\\\':\\n dsu.merge(p+0, p+1)\\n dsu.merge(p+2, p+3)\\n else:\\n dsu.merge(p+0, p+1)\\n dsu.merge(p+0, p+2)\\n dsu.merge(p+0, p+3)\\n \\n return sum(dsu.findRoot(x) == x for x in range(NN4))\\n\\n\", \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n N = len(grid)\\n new_grid = [[0]*(2*N) for _ in range(2*N)]\\n count = 0\\n \\n for i in range(N):\\n for j in range(N):\\n if grid[i][j] == '/':\\n new_grid[2*i][2*j+1] = 1\\n new_grid[2*i+1][2*j] = 1\\n elif grid[i][j] == '\\\\\\\\\\\\\\\\':\\n new_grid[2*i][2*j] = 1\\n new_grid[2*i+1][2*j+1] = 1\\n \\n def dfs(grid, i, j):\\n # starting with a seed (0 in location i,j), build up an open space\\n if grid[i][j] == 1:\\n return None\\n grid[i][j] = 1 # mark as visited\\n if i < len(grid)-1: # (make sure i+1 exists)\\n dfs(grid, i+1, j) # search down \\n if j < len(grid)-1: \\n dfs(grid, i, j+1)# search right\\n if i > 0:\\n dfs(grid, i-1, j) # search up\\n if j > 0:\\n dfs(grid, i, j-1) #search left\\n # search dl\\n if i < len(grid)-1 and j > 0 and i%2==j%2:\\n dfs(grid, i+1, j-1)\\n # search ur\\n if i > 0 and j < len(grid)-1 and i%2==j%2:\\n dfs(grid, i-1, j+1)\\n # search dr\\n if i < len(grid)-1 and j < len(grid)-1 and i%2!=j%2:\\n dfs(grid, i+1, j+1)\\n # search ul\\n if i > 0 and j > 0 and i%2!=j%2:\\n dfs(grid, i-1, j-1)\\n \\n \\n \\n \\n # search for seeds\\n for i in range(2*N):\\n for j in range(2*N):\\n if new_grid[i][j] == 0:\\n count += 1\\n dfs(new_grid, i, j) # seed an island\\n \\n return count\\n \\n \\n\", \"class Solution:\\n def regionsBySlashes(self, grid):\\n n = len(grid)\\n g = [[0 for _ in range(n*3)] for _ in range(n*3)]\\n \\n def dfs(i, j):\\n if 0 <= i < (n*3) and 0 <= j < (n*3) and g[i][j] == 0:\\n g[i][j] = 1\\n for k in [1, -1]:\\n dfs(i+k, j)\\n dfs(i, j+k)\\n \\n for i in range(n):\\n for j in range(n):\\n if grid[i][j] == '/':\\n g[i*3][(j*3) + 2] = 1\\n g[(i*3) + 1][(j*3) + 1] = 1\\n g[(i*3) + 2][j*3] = 1\\n elif grid[i][j] == '\\\\\\\\\\\\\\\\':\\n g[i*3][j*3] = 1\\n g[(i*3) + 1][(j*3) + 1] = 1\\n g[(i*3) + 2][(j*3) + 2] = 1\\n res = 0\\n for i in range(n*3):\\n for j in range(n*3):\\n if g[i][j] == 0:\\n dfs(i, j)\\n res += 1\\n return res\", \"class Solution:\\n def regionsBySlashes(self, g: List[str]) -> int:\\n \\n n = len(g)\\n \\n grid = [[0]*(n*3) for j in range(n*3)]\\n \\n for i in range(n):\\n \\n for j in range(n):\\n \\n if g[i][j] == '/':\\n \\n grid[i*3][j*3+2] = 1\\n \\n grid[i*3+1][j*3+1] = 1\\n \\n grid[i*3+2][j*3] = 1\\n \\n elif g[i][j] == '\\\\\\\\\\\\\\\\':\\n \\n grid[i*3][j*3] = 1\\n \\n grid[i*3+1][j*3+1] = 1\\n \\n grid[i*3+2][j*3+2] = 1\\n \\n \\n def dfs(i,j):\\n \\n grid[i][j] = 1\\n \\n for r in [(i+1,j), (i,j+1), (i-1,j), (i,j-1)]:\\n \\n xx,yy = r\\n \\n if xx < 0 or yy < 0 or xx >= len(grid) or yy >= len(grid[0]) or grid[xx][yy] == 1:\\n continue\\n \\n dfs(xx,yy)\\n \\n \\n count = 0\\n \\n for i in range(n*3):\\n for j in range(n*3):\\n \\n if grid[i][j] == 0:\\n \\n dfs(i,j)\\n \\n count += 1\\n \\n return count\", \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n if not grid:\\n return 0\\n \\n rows, cols = len(grid), len(grid[0])\\n new_grid = [[0] * 3 * cols for _ in range(3 * rows)]\\n visited = [[False] * 3 * cols for _ in range(3 * rows)]\\n \\n for i in range(rows):\\n line = grid[i]\\n \\n for j in range(len(line)):\\n if line[j] == '/':\\n new_grid[3 * i][3 * j + 2] = 1\\n new_grid[3 * i + 1][3 * j + 1] = 1\\n new_grid[3 * i + 2][3 * j] = 1\\n elif line[j] == '\\\\\\\\\\\\\\\\':\\n new_grid[3 * i][3 * j] = 1\\n new_grid[3 * i + 1][3 * j + 1] = 1\\n new_grid[3 * i + 2][3 * j + 2] = 1\\n \\n def dfs(i, j):\\n if i < 0 or j < 0 or i >= 3 * rows or j >= 3 * cols or new_grid[i][j] == 1 or visited[i][j]:\\n return\\n \\n visited[i][j] = True\\n \\n dfs(i, j + 1)\\n dfs(i + 1, j)\\n dfs(i, j - 1)\\n dfs(i - 1, j)\\n \\n count = 0\\n \\n for i in range(3 * rows):\\n for j in range(3 * cols):\\n if not visited[i][j] and new_grid[i][j] == 0:\\n dfs(i, j)\\n count += 1\\n \\n return count\", \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n n = len(grid)\\n m, ans = [[[0, 0, 0, 0] for j in range(n)] for i in range(n)], 0\\n \\n def dfs(i, j, k):\\n if 0 <= i < n and 0 <= j < n and not m[i][j][k]:\\n if grid[i][j] == '/':\\n if 1 <= k <= 2:\\n m[i][j][1] = m[i][j][2] = ans\\n dfs(i, j+1, 3)\\n dfs(i+1, j, 0)\\n else:\\n m[i][j][0] = m[i][j][3] = ans \\n dfs(i-1, j, 2)\\n dfs(i, j-1, 1)\\n elif grid[i][j] == '\\\\\\\\\\\\\\\\':\\n if k <= 1:\\n m[i][j][0] = m[i][j][1] = ans\\n dfs(i-1, j, 2)\\n dfs(i, j+1, 3)\\n else:\\n m[i][j][2] = m[i][j][3] = ans \\n dfs(i+1, j, 0)\\n dfs(i, j-1, 1)\\n else:\\n m[i][j][0] = m[i][j][1] = m[i][j][2] = m[i][j][3] = ans \\n dfs(i-1, j, 2)\\n dfs(i, j-1, 1)\\n dfs(i+1, j, 0)\\n dfs(i, j+1, 3)\\n \\n \\n for i in range(n):\\n for j in range(n):\\n for k in range(4):\\n if not m[i][j][k]:\\n ans += 1\\n dfs(i, j, k)\\n \\n return ans \\n\", \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n if len(grid) == 0 or len(grid[0]) == 0:\\n return 0\\n \\n roots = {}\\n \\n def find(x):\\n roots.setdefault(x, x)\\n \\n if roots[x] != x:\\n roots[x] = find(roots[x])\\n \\n return roots[x]\\n \\n def union(x, y):\\n roots[find(x)] = find(y)\\n \\n # k=0 top\\n # k=1 right\\n # k=2 bottom\\n # k=3 left\\n \\n for i in range(len(grid)):\\n for j in range(len(grid[0])):\\n if i > 0:\\n union((i-1, j, 2), (i, j, 0))\\n \\n if j > 0:\\n union((i, j-1, 1), (i, j, 3))\\n \\n if grid[i][j] != '/':\\n union((i, j, 0), (i, j, 1))\\n union((i, j, 2), (i, j, 3))\\n \\n if grid[i][j] != '\\\\\\\\\\\\\\\\':\\n union((i, j, 0), (i, j, 3))\\n union((i, j, 1), (i, j, 2))\\n \\n return len(set(find(x) for x in list(roots.keys())))\\n\", \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n \\n N = len(grid)\\n \\n matrix = grid\\n \\n parent = list(range(N * N * 4))\\n # print(parent)\\n def find(x):\\n depth = 0\\n while parent[x] != x:\\n x = parent[x]\\n depth += 1\\n return x, depth\\n \\n def union(x, y):\\n # print(x, y)\\n (rx, dx), (ry, dy) = find(x), find(y)\\n if dx < dy:\\n parent[rx] = ry\\n else:\\n parent[ry] = rx\\n \\n def isValid(i, j):\\n if i >= N or i < 0 or j >= N or j < 0:\\n return False\\n return True\\n\\n for i in range(N):\\n for j in range(N):\\n idtop = (i * N + j) * 4\\n if matrix[i][j] == '/':\\n union(idtop + 1, idtop + 2)\\n union(idtop, idtop + 3)\\n elif matrix[i][j] == '\\\\\\\\\\\\\\\\':\\n union(idtop, idtop + 1)\\n union(idtop + 2, idtop + 3) \\n else:\\n union(idtop, idtop + 1)\\n union(idtop, idtop + 2)\\n union(idtop, idtop + 3)\\n if isValid(i-1, j):\\n union(idtop, 4 *((i-1) * N + j) + 2)\\n if isValid(i, j-1):\\n union(idtop + 3, 4 * (i * N + j - 1) + 1)\\n return sum(find(x)[0] == x for x in range(4 * N * N))\\n \\n\", \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n \\n root = {}\\n \\n def find(x):\\n root.setdefault(x, x)\\n if root[x] != x: # not find( root[x] )\\n root[x] = find( root[x] )\\n return root[x]\\n \\n def union(x, y):\\n rx, ry = find(x), find(y)\\n \\n if rx != ry:\\n root[ry] = find(rx)\\n \\n for i in range(len(grid)):\\n for j in range(len(grid)):\\n if i:\\n union( (i-1,j, 2), (i,j, 0) )\\n if j:\\n union( (i,j-1, 1), (i,j, 3) )\\n if grid[i][j] == '/':\\n union( (i,j, 0), (i,j, 3) )\\n union( (i,j, 1), (i,j, 2) )\\n elif grid[i][j] == '\\\\\\\\\\\\\\\\':\\n union( (i,j, 0), (i,j, 1) )\\n union( (i,j, 2), (i,j, 3) )\\n else:\\n union( (i,j, 0), (i,j, 1) )\\n union( (i,j, 0), (i,j, 2) )\\n union( (i,j, 0), (i,j, 3) )\\n \\n return len( set( map(find, list(root.keys())) ) )\\n \\n \\n\", \"from itertools import chain\\nclass Solution:\\n def regionsBySlashes(self, grid):\\n grid = convert_grid(grid)\\n return len([destroy_island(x, y, grid) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v == 0])\\n\\ndef destroy_island(x, y, grid):\\n grid[y][x] = 1\\n for c in search(x, y, grid):\\n destroy_island(c[0], c[1], grid)\\n\\ndef search(x, y, grid):\\n in_bounds = lambda c:0 <= c[1] < len(grid) and 0 <= c[0] < len(grid[c[1]])\\n check_orthog = lambda c:in_bounds(c) and grid[c[1]][c[0]] == 0\\n def check_diag(c):\\n if not in_bounds(c) or grid[c[1]][c[0]] != 0: return False\\n d_x, d_y = c[0] - x, c[1] - y\\n sep = '\\\\\\\\\\\\\\\\' if ((d_x > 0 > d_y) or (d_x < 0 < d_y)) else '/'\\n return grid[y + d_y][x] != sep or grid[y][x + d_x] != sep\\n yield from chain(filter(check_orthog, ((x-1, y), (x+1, y), (x, y-1), (x, y+1))),\\n filter(check_diag, ((x + 1, y + 1), (x + 1, y - 1), (x - 1, y + 1), (x - 1, y - 1))))\\n\\ndef convert_grid(grid):\\n new_grid = [[0] * len(grid[0]) * 2 for _ in range(len(grid) * 2)]\\n for (x, y, v) in ((x, y, v) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v in '\\\\\\\\\\\\\\\\/'):\\n new_grid[y * 2 + 0][x * 2 + (1 if v == '/' else 0)] = v\\n new_grid[y * 2 + 1][x * 2 + (0 if v == '/' else 1)] = v\\n return new_grid\", \"from itertools import chain\\nclass Solution:\\n def regionsBySlashes(self, grid):\\n grid = convert_grid(grid)\\n return len([destroy_island(x, y, grid) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v == 0])\\n\\ndef destroy_island(x, y, grid):\\n grid[y][x] = 1\\n for c in search(x, y, grid):\\n destroy_island(c[0], c[1], grid)\\n\\ndef search(x, y, grid):\\n in_bounds = lambda c:0 <= c[1] < len(grid) and 0 <= c[0] < len(grid[c[1]])\\n check_orthog = lambda c:in_bounds(c) and grid[c[1]][c[0]] == 0\\n def check_diag(c):\\n if not in_bounds(c) or grid[c[1]][c[0]] != 0: return False\\n d_x, d_y = c[0] - x, c[1] - y\\n sep = '\\\\\\\\\\\\\\\\' if ((d_x > 0 > d_y) or (d_x < 0 < d_y)) else '/'\\n return not (grid[y + d_y][x] == sep and grid[y][x + d_x] == sep)\\n yield from chain(filter(check_orthog, ((x-1, y), (x+1, y), (x, y-1), (x, y+1))),\\n filter(check_diag, ((x + 1, y + 1), (x + 1, y - 1), (x - 1, y + 1), (x - 1, y - 1))))\\n\\ndef convert_grid(grid):\\n new_grid = [[0] * len(grid[0]) * 2 for _ in range(len(grid) * 2)]\\n for (x, y, v) in ((x, y, v) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v in '\\\\\\\\\\\\\\\\/'):\\n new_grid[y * 2 + 0][x * 2 + (1 if v == '/' else 0)] = v\\n new_grid[y * 2 + 1][x * 2 + (0 if v == '/' else 1)] = v\\n return new_grid\", \"from itertools import chain\\nclass Solution:\\n def regionsBySlashes(self, grid):\\n grid = convert_grid(grid)\\n print(*(list(map(str, x)) for x in grid), sep='\\\\\\n')\\n return len([destroy_island(x, y, grid) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v == 0])\\n\\ndef destroy_island(x, y, grid):\\n grid[y][x] = 1\\n for c in search(x, y, grid):\\n destroy_island(c[0], c[1], grid)\\n\\ndef search(x, y, grid):\\n in_bounds = lambda c:0 <= c[1] < len(grid) and 0 <= c[0] < len(grid[c[1]])\\n check_orthog = lambda c:in_bounds(c) and grid[c[1]][c[0]] == 0\\n def check_diag(c):\\n if not in_bounds(c) or grid[c[1]][c[0]] != 0: return False\\n d_x, d_y = c[0] - x, c[1] - y\\n sep = '\\\\\\\\\\\\\\\\' if ((d_x > 0 > d_y) or (d_x < 0 < d_y)) else '/'\\n return grid[y + d_y][x] != sep or grid[y][x + d_x] != sep\\n yield from chain(filter(check_orthog, ((x-1, y), (x+1, y), (x, y-1), (x, y+1))),\\n filter(check_diag, ((x + 1, y + 1), (x + 1, y - 1), (x - 1, y + 1), (x - 1, y - 1))))\\n\\ndef convert_grid(grid):\\n new_grid = [[0] * len(grid[0]) * 2 for _ in range(len(grid) * 2)]\\n for (x, y, v) in ((x, y, v) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v in '\\\\\\\\\\\\\\\\/'):\\n new_grid[y * 2 + 0][x * 2 + (1 if v == '/' else 0)] = v\\n new_grid[y * 2 + 1][x * 2 + (0 if v == '/' else 1)] = v\\n return new_grid\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"regionsBySlashes\", \"inputs\": [[[\"\\\" /\\\"\", \"\\\"/ \\\"\"]]], \"outputs\": [2]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/regions-cut-by-slashes/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n "},"solutions_list":{"kind":"list like","value":["from itertools import chain\nclass Solution:\n def regionsBySlashes(self, grid):\n grid = self.convert_grid(grid)\n print(*(list(map(str, x)) for x in grid), sep='\\\n')\n return len([self.destroy_island(x, y, grid) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v == 0])\n\n @staticmethod\n def convert_grid(grid):\n new_grid = [[0] * len(grid[0]) * 2 for _ in range(len(grid) * 2)]\n for (x, y, v) in ((x, y, v) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v in '\\\\\\\\/'):\n new_grid[y * 2 + 0][x * 2 + (1 if v == '/' else 0)] = v\n new_grid[y * 2 + 1][x * 2 + (0 if v == '/' else 1)] = v\n return new_grid\n\n def destroy_island(self, x, y, grid):\n grid[y][x] = 1\n for c in Solution.search(x, y, grid):\n self.destroy_island(c[0], c[1], grid)\n\n @staticmethod\n def search(x, y, grid):\n in_bounds = lambda c:0 <= c[1] < len(grid) and 0 <= c[0] < len(grid[c[1]])\n check_orthog = lambda c:in_bounds(c) and grid[c[1]][c[0]] == 0\n def check_diag(c):\n if not in_bounds(c) or grid[c[1]][c[0]] != 0: return False\n d_x, d_y = c[0] - x, c[1] - y\n sep = '\\\\\\\\' if ((d_x > 0 > d_y) or (d_x < 0 < d_y)) else '/'\n return not (grid[y + d_y][x] == sep and grid[y][x + d_x] == sep)\n yield from chain(filter(check_orthog, ((x-1, y), (x+1, y), (x, y-1), (x, y+1))),\n filter(check_diag, ((x + 1, y + 1), (x + 1, y - 1), (x - 1, y + 1), (x - 1, y - 1))))","class DSU:\n def __init__(self):\n self.parent = {}\n \n def find(self, x):\n if x not in self.parent:\n self.parent[x] = x\n if self.parent[x] != x:\n self.parent[x] = self.find(self.parent[x])\n \n return self.parent[x]\n \n def union(self, x, y):\n xroot, yroot = self.find(x), self.find(y)\n if xroot != yroot:\n self.parent[yroot] = xroot\n\nclass Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n n = len(grid)\n dsu = DSU()\n \n for i in range(n):\n for j in range(n):\n if i > 0:\n dsu.union((i - 1, j, 2), (i, j, 0))\n if j > 0:\n dsu.union((i, j - 1, 1), (i, j, 3))\n if grid[i][j] != '/':\n dsu.union((i, j, 0), (i, j, 1))\n dsu.union((i, j, 2), (i, j, 3))\n if grid[i][j] != '\\\\\\\\':\n dsu.union((i, j, 3), (i, j, 0))\n dsu.union((i, j, 1), (i, j, 2))\n \n seen = set()\n for key in dsu.parent.keys():\n temp = dsu.find(key)\n seen.add(temp)\n \n return len(seen)","from typing import List\n\nclass DS:\n \n def __init__(self, n):\n self.sizes = [1] * n\n self.roots = [i for i in range(n)]\n \n def query(self, x):\n root = x\n while root != self.roots[root]:\n self.roots[root] = self.roots[self.roots[root]]\n root = self.roots[root]\n return root\n \n def union(self, x, y):\n xRoot, yRoot = self.query(x), self.query(y)\n s, l = (xRoot, yRoot) if self.sizes[xRoot] < self.sizes[yRoot] else (yRoot, xRoot)\n self.roots[s] = l\n self.sizes[l] += self.sizes[s] \n\nclass Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n n = len(grid)\n nodes = DS(4 * n * n)\n getIndex = lambda r, c, k: 4 * (n * r + c) + k\n for i in range(n):\n for j in range(n):\n if i > 0: nodes.union(getIndex(i, j, 0), getIndex(i - 1, j, 2))\n if i < n - 1: nodes.union(getIndex(i, j, 2), getIndex(i + 1, j, 0))\n if j > 0: nodes.union(getIndex(i, j, 3), getIndex(i, j - 1, 1))\n if j < n - 1: nodes.union(getIndex(i, j, 1), getIndex(i, j + 1, 3))\n if grid[i][j] != '/':\n nodes.union(getIndex(i, j, 0), getIndex(i, j, 1))\n nodes.union(getIndex(i, j, 3), getIndex(i, j, 2))\n if grid[i][j] != '\\\\\\\\':\n nodes.union(getIndex(i, j, 0), getIndex(i, j, 3))\n nodes.union(getIndex(i, j, 1), getIndex(i, j, 2))\n return sum(i == nodes.query(i) for i in range(4 * n * n))","class Solution:\n f = {}\n def find(self, x):\n self.f.setdefault(x,x)\n if self.f[x] != x: \n self.f[x] = self.find(self.f[x])\n return self.f[x]\n \n def union(self, x, y):\n self.f[self.find(x)] = self.find(y)\n \n def regionsBySlashes(self, grid: List[str]) -> int:\n self.f = {}\n for row in range(len(grid)):\n for col in range(len(grid)):\n if row: \n self.union((row-1,col,2),(row,col,0))\n if col: \n self.union((row,col-1,3),(row,col,1))\n if grid[row][col] != '/':\n self.union((row,col,0),(row,col,3))\n self.union((row,col,1),(row,col,2))\n if grid[row][col] != '\\\\\\\\':\n self.union((row,col,0), (row,col,1))\n self.union((row,col,2), (row,col,3))\n \n return len(set(map(self.find,self.f)))\n \n","class Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n for i in range(len(grid)):\n grid[i] = grid[i].replace('\\\\\\\\', '*')\n N = len(grid)\n record = [[[0,0,0,0] for j in range(N)] for i in range(N)]\n #visited = set()\n #print(grid)\n count = 0\n def dfs(i,j,k):\n if 0 <= i < N and 0 <= j < N and record[i][j][k] == 0:\n if grid[i][j] == '*':\n if k <= 1:\n record[i][j][0] = record[i][j][1] = count\n dfs(i-1, j, 2)\n dfs(i, j+1, 3)\n else:\n record[i][j][2] = record[i][j][3] = count\n dfs(i+1, j, 0)\n dfs(i, j-1, 1)\n elif grid[i][j] == '/':\n if 1 <= k <= 2:\n record[i][j][1] = record[i][j][2] = count\n dfs(i+1, j, 0)\n dfs(i, j+1, 3)\n else:\n record[i][j][0] = record[i][j][3] = count\n dfs(i-1, j, 2)\n dfs(i, j-1, 1)\n else:\n record[i][j][0] = record[i][j][1] = record[i][j][2] = record[i][j][3] = count\n dfs(i-1, j, 2)\n dfs(i, j+1, 3)\n dfs(i+1, j, 0)\n dfs(i, j-1, 1)\n \n for i in range(N):\n for j in range(N):\n for k in range(4):\n if record[i][j][k] == 0:\n count += 1\n dfs(i,j,k)\n return count","class Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n \n N = len(grid)\n \n matrix = [list(s) for s in grid]\n \n parent = list(range(N * N * 4))\n print(parent)\n def find(x):\n depth = 0\n while parent[x] != x:\n x = parent[x]\n depth += 1\n return x, depth\n \n def union(x, y):\n print((x, y))\n (rx, dx), (ry, dy) = find(x), find(y)\n if dx < dy:\n parent[rx] = ry\n else:\n parent[ry] = rx\n \n def isValid(i, j):\n if i >= N or i < 0 or j >= N or j < 0:\n return False\n return True\n\n # dirs = [(0, 1), (-1, 0)]\n for i in range(N):\n for j in range(N):\n idtop = (i * N + j) * 4\n if matrix[i][j] == '/':\n union(idtop + 1, idtop + 2)\n union(idtop, idtop + 3)\n elif matrix[i][j] == '\\\\\\\\':\n union(idtop, idtop + 1)\n union(idtop + 2, idtop + 3) \n else:\n union(idtop, idtop + 1)\n union(idtop, idtop + 2)\n union(idtop, idtop + 3)\n if isValid(i-1, j):\n union(idtop, 4 *((i-1) * N + j) + 2)\n if isValid(i, j-1):\n union(idtop + 3, 4 * (i * N + j - 1) + 1)\n return len(set(find(x)[0] for x in range(4 * N * N)))\n \n","class Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n m, n = len(grid), len(grid[0])\n print(m, n)\n mat = [[0] * (4*n) for _ in range(4*m)]\n for i in range(m):\n for j in range(n):\n if grid[i][j] == '/':\n mat[4*i][4*j+3] = 1\n mat[4*i+1][4*j+2] = 1\n mat[4*i+2][4*j+1] = 1\n mat[4*i+3][4*j] = 1\n elif grid[i][j] == '\\\\\\\\':\n mat[4*i][4*j] = 1\n mat[4*i+1][4*j+1] = 1\n mat[4*i+2][4*j+2] = 1\n mat[4*i+3][4*j+3] = 1\n # print(mat)\n dirs = [[-1,0],[1,0],[0,1],[0,-1]]\n def dfs(i, j):\n visit[i][j] = 1\n for d in dirs:\n x, y = i+d[0], j+d[1]\n if 0<=x<(4*m) and 0<=y<(4*n) and not mat[x][y]:\n mat[x][y] = 1\n if not visit[x][y]:\n dfs(x, y)\n \n visit = [[0]*(4*n) for _ in range(4*m)]\n res = 0\n for i in range(4*m):\n for j in range(4*n):\n if not mat[i][j]:\n res += 1\n dfs(i, j)\n return res","class Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n n = len(grid)\n seen = [[[0,0,0,0] for x in range(n)] for y in range(n)]\n # top 1, left 2, bottom 3, right 0\n def dfs(x, y, loc):\n #print(x,y)\n if not ( 0<=x<n and 0<=y<n) or seen[x][y][loc] == 1:\n return\n seen[x][y][loc] = 1\n \n if grid[x][y] == '/':\n if loc == 0:\n dfs(x+1,y,2)\n seen[x][y][3] = 1\n dfs(x, y+1, 1)\n elif loc == 3:\n dfs(x,y+1,1)\n seen[x][y][0] = 1\n dfs(x+1, y, 2)\n elif loc == 1:\n dfs(x,y-1,3)\n seen[x][y][2] = 1\n dfs(x-1, y, 0)\n else:\n dfs(x-1,y,0)\n seen[x][y][1] = 1\n dfs(x, y-1, 3)\n elif grid[x][y] == '\\\\\\\\':\n if loc == 0:\n dfs(x+1,y,2)\n seen[x][y][1] = 1\n dfs(x, y-1, 3) \n elif loc == 3:\n dfs(x,y+1,1)\n seen[x][y][2] = 1\n dfs(x-1, y, 0)\n elif loc == 1:\n dfs(x,y-1,3)\n seen[x][y][0] = 1\n dfs(x+1, y, 2)\n else:\n dfs(x-1,y,0)\n seen[x][y][3] = 1\n dfs(x, y+1, 1)\n else:\n seen[x][y][1] = 1\n dfs(x, y-1, 3)\n seen[x][y][2] = 1\n dfs(x-1, y, 0)\n seen[x][y][0] = 1\n dfs(x+1, y, 2)\n seen[x][y][3] = 1\n dfs(x, y+1, 1)\n count = 0\n for i in range(n):\n for j in range(n):\n for loc in range(4):\n k = seen[i][j][loc]\n if k == 0:\n #print(i,j,k, seen)\n count += 1\n dfs(i,j,loc)\n return count","class Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n \n N = len(grid)\n base = N * (N + 1)\n parent = [i for i in range(2 * base)]\n \n def find(x):\n if parent[x] != parent[parent[x]]:\n parent[x] = find(parent[x])\n return parent[x]\n \n def union(x, y):\n parent[find(x)] = find(y)\n return find(y)\n \n for i in range(N):\n for j in range(N):\n up, down, left, right = i * N + j, (i + 1) * N + j, base + i * (N + 1) + j, base + i * (N + 1) + j + 1\n \n if grid[i][j] == '/':\n union(up, left)\n union(down, right)\n elif grid[i][j] == '\\\\\\\\':\n union(up, right)\n union(down, left)\n else:\n union(up, left)\n union(down, right)\n union(left, right)\n \n comp = set()\n for i in range(2 * base):\n comp.add(find(i))\n \n return len(comp)","class Solution:\n \n def regionsBySlashes(self, grid: List[str]):\n def minAnglePoint(p1, p2, options):\n minAngle = 10.0 # a ridiculously big number\n for p3 in options:\n a = (p2[0] - p1[0], p2[1] - p1[1])\n b = (p3[0] - p2[0], p3[1] - p2[1])\n dot = a[0] * b[0] + a[1] * b[1]\n det = a[0] * b[1] - a[1] * b[0]\n ang = math.atan2(det, dot)\n if ang < minAngle: \n minAngle = ang\n res = p3\n return res, minAngle\n\n N = len(grid)\n M = dict()\n for i in range(N):\n M[(i + 1, 0)] = [(i, 0)]\n M[(N, i + 1)] = [(N, i)]\n M[(N - i - 1, N)] = [(N - i, N)]\n M[(0, N - i - 1)] = [(0, N - i)]\n for y in range(N):\n x = 0\n for c in grid[y]:\n if c == '/':\n if (x + 1, y) in M: \n M[(x + 1, y)].append((x, y + 1))\n else: \n M[(x + 1, y)] = [(x, y + 1)]\n if (x, y + 1) in M:\n M[(x, y + 1)].append((x + 1, y))\n else:\n M[(x, y + 1)] = [(x + 1, y)]\n elif c == '\\\\\\\\':\n if (x, y) in M: \n M[(x, y)].append((x + 1, y + 1))\n else:\n M[(x, y)] = [(x + 1, y + 1)]\n if (x + 1, y + 1) in M: \n M[(x + 1, y + 1)].append((x, y))\n else:\n M[(x + 1, y + 1)] = [(x, y)]\n x += 1\n innerangle = round(-2 * math.pi, 4)\n points = sorted(M)\n regions = set()\n for i in range(len(points)):\n if points[i] not in M: continue\n startpoint = points[i]\n region = {startpoint}\n point = firststep = M[startpoint][0]\n M[startpoint].remove(point)\n prev = startpoint\n angSum = 0\n while point != startpoint:\n region.add(point)\n links = M[point]\n nxt, ang = minAnglePoint(prev, point, links)\n angSum += ang\n if len(links) == 1: \n del M[point]\n else:\n M[point].remove(nxt)\n prev = point\n point = nxt\n if len(M[startpoint]) == 0: \n del M[startpoint]\n \n _, ang = minAnglePoint(prev, point, [firststep])\n angSum = round(angSum + ang, 4)\n if angSum == innerangle: # it is a valid region\n regions.add(frozenset(region))\n return len(regions)","class Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n N = len(grid)\n new_grid = [[0]*(2*N) for _ in range(2*N)]\n count = 0\n \n for i in range(N):\n for j in range(N):\n if grid[i][j] == '/':\n new_grid[2*i][2*j+1] = 1\n new_grid[2*i+1][2*j] = 1\n elif grid[i][j] == '\\\\\\\\':\n new_grid[2*i][2*j] = 1\n new_grid[2*i+1][2*j+1] = 1\n \n def dfs(grid, i, j):\n # starting with a seed (0 in location i,j), build up an open space\n if grid[i][j] == 1:\n return None\n grid[i][j] = 1 # mark as visited\n if i < len(grid)-1: # (make sure i+1 exists)\n dfs(grid, i+1, j) # search down \n if j < len(grid)-1: \n dfs(grid, i, j+1)# search right\n if i > 0:\n dfs(grid, i-1, j) # search up\n if j > 0:\n dfs(grid, i, j-1) #search left\n # search dl\n if i < len(grid)-1 and j > 0 and i%2==j%2:\n dfs(grid, i+1, j-1)\n # search ur\n if i > 0 and j < len(grid)-1 and i%2==j%2:\n dfs(grid, i-1, j+1)\n # search dr\n if i < len(grid)-1 and j < len(grid)-1 and i%2!=j%2:\n dfs(grid, i+1, j+1)\n # search ul\n if i > 0 and j > 0 and i%2!=j%2:\n dfs(grid, i-1, j-1)\n \n # search for seeds (new islands)\n for i in range(2*N):\n for j in range(2*N):\n if new_grid[i][j] == 0:\n count += 1\n dfs(new_grid, i, j) # seed an island\n \n return count\n \n","class Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n nrow = len(grid)\n ncol = len(grid[0])\n newgrid = []\n for i in range(nrow*3):\n newgrid.append([0]*ncol*3)\n for r in range(nrow):\n for c in range(ncol):\n if grid[r][c] == '\\\\\\\\':\n newgrid[r*3][c*3] = 1\n newgrid[r*3+1][c*3+1] = 1\n newgrid[r*3+2][c*3+2] = 1\n elif grid[r][c] == '/':\n newgrid[r*3+2][c*3] = 1\n newgrid[r*3+1][c*3+1] = 1\n newgrid[r*3][c*3+2] = 1\n \n def countIsland(newgrid):\n count = 0\n def dfs(r,c):\n if newgrid[r][c] == 0:\n newgrid[r][c] =1\n if r < len(newgrid) -1 and newgrid[r+1][c] ==0:\n dfs(r+1,c)\n if c < len(newgrid[0]) -1 and newgrid[r][c+1] ==0:\n dfs(r,c+1)\n if r > 0 and newgrid[r-1][c] ==0:\n dfs(r-1,c)\n if c > 0 and newgrid[r][c-1] ==0:\n dfs(r,c-1)\n \n \n for r1 in range(len(newgrid)):\n for c1 in range(len(newgrid[0])):\n if newgrid[r1][c1] == 0:\n dfs(r1,c1)\n count+=1\n else:\n pass\n return(count)\n \n return(countIsland(newgrid))","class Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n N = len(grid) \n D = list(range(N*N*4))\n res = [len(D)]\n def find(D,i):\n if D[i]==i:\n return i\n return find(D,D[i])\n \n def union(D,i,j):\n pi = find(D,i)\n pj = find(D,j)\n if pi==pj:\n return\n else:\n D[pi] = pj\n res[0] -= 1\n \n def idx(i,j,e):\n return (i*N+j)*4+e\n \n \n \n for i in range(N):\n for j in range(N):\n if i>0:\n union(D,idx(i-1,j,2),idx(i,j,0))\n if j>0:\n union(D,idx(i,j-1,1,),idx(i,j,3))\n if grid[i][j]!='/':\n union(D,idx(i,j,0),idx(i,j,1))\n union(D,idx(i,j,2),idx(i,j,3))\n if grid[i][j]!='\\\\\\\\':\n union(D,idx(i,j,0),idx(i,j,3))\n union(D,idx(i,j,1),idx(i,j,2))\n return res[0]\n \n \n \n","class Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n m, n = len(grid), len(grid[0])\n parent = {}\n def find(x):\n if parent[x] != x:\n parent[x] = find(parent[x])\n return parent[x]\n \n def union(x, y):\n rx, ry = find(x), find(y)\n if rx == ry:\n return False\n parent[rx] = ry\n return True\n \n res = m * n * 4\n for i in range(m):\n for j in range(n):\n for k in range(4):\n parent[(i, j, k)] = (i, j, k)\n if grid[i][j] == '/':\n if union((i, j, 0), (i, j, 3)):\n res -= 1\n if union((i, j, 1), (i, j, 2)):\n res -= 1\n elif grid[i][j] == '\\\\\\\\':\n if union((i, j, 0), (i, j, 1)):\n res -= 1\n if union((i, j, 2), (i, j, 3)):\n res -= 1\n else:\n if union((i, j, 0), (i, j, 1)):\n res -= 1\n if union((i, j, 2), (i, j, 3)):\n res -= 1\n if union((i, j, 0), (i, j, 3)):\n res -= 1\n \n if i > 0:\n if union((i, j, 0), (i - 1, j, 2)):\n res -= 1\n if j > 0:\n if union((i, j, 3), (i, j - 1, 1)):\n res -= 1\n return res","class Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n self.N = len(grid)#n行\n print((self.N))\n pre = list(range(self.N*self.N*4))#所有元素自己是自己的父节点[0,1,2,3,4,5,6,...]\n self.count = self.N*self.N*4 #总共的区域数量\n for r in range(self.N):\n line = grid[r]\n for c in range(self.N):\n w = line[c]\n if r > 0:\n self.union(pre, self.g(r - 1, c, 2), self.g(r, c, 0))\n if c > 0:\n self.union(pre, self.g(r, c - 1, 1), self.g(r, c, 3))\n if w != '/':\n self.union(pre, self.g(r, c, 0), self.g(r, c, 1))\n self.union(pre, self.g(r, c, 3), self.g(r, c, 2))\n if w != '\\\\\\\\':\n self.union(pre, self.g(r, c, 0), self.g(r, c, 3))\n self.union(pre, self.g(r, c, 1), self.g(r, c, 2))\n return self.count \n \n def find(self,pre,x):\n if x == pre[x]:\n return x\n \n return self.find(pre,pre[x])\n def union(self, pre, a, b):\n pa = self.find(pre, a)\n pb = self.find(pre, b)\n if (pa == pb):\n return\n pre[pa] = pb\n self.count -= 1\n \n def g(self, r, c, i):\n return (r * self.N + c) * 4 + i\n","class Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n f = {}\n def find(x):\n if (x not in f):\n f[x] = x\n elif(f[x] != x):\n f[x] = find(f[x])\n return f[x]\n def merge(x,y):\n rx,ry = find(x),find(y)\n f[rx] = ry\n\n rows, cols = len(grid), len(grid[0]) if grid else 0\n for i in range(rows):\n for j in range(cols):\n cur = (i * cols + j) * 4\n up, left = ((i - 1) * cols + j) * 4, (i * cols + j - 1) * 4\n cl, cr, cd = cur + 3, cur + 1, cur + 2\n lr,ud = left + 1, up + 2\n if (grid[i][j] == '/'):\n merge(cur, cl)\n merge(cr, cd)\n elif (grid[i][j] == '\\\\\\\\'):\n merge(cur, cr)\n merge(cl, cd)\n else:\n merge(cur, cr)\n merge(cl, cd)\n merge(cur, cl)\n if (i >= 1):\n merge(cur,ud)\n if (j >= 1):\n merge(cl,lr)\n res = 0\n for i in range(rows):\n for j in range(cols):\n cur = (i * cols + j) * 4\n for dx in range(4):\n if (cur+dx == find(cur+dx)):\n res += 1\n return res\n","class UnionFind:\n def __init__(self, N):\n self.par = list(range(N))\n self.rank = [0]*N\n \n def find(self, x):\n if self.par[x] != x:\n self.par[x] = self.find(self.par[x])\n return self.par[x]\n \n def union(self, x, y):\n px, py = self.find(x), self.find(y)\n if px==py: return\n \n if self.rank[px]<self.rank[py]:\n self.par[px] = py\n elif self.rank[px]>self.rank[py]:\n self.par[py] = px\n else:\n self.par[py] = px\n self.rank[px] += 1\n \nclass Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n N = len(grid)\n uf = UnionFind(4*N*N)\n \n for i in range(N):\n for j in range(N):\n idx = 4*(i*N+j)\n if grid[i][j]!='/':\n uf.union(idx, idx+1)\n uf.union(idx+2, idx+3)\n if grid[i][j]!='\\\\\\\\':\n uf.union(idx, idx+3)\n uf.union(idx+1, idx+2)\n\n if i:\n uf.union(idx, idx-4*N+2)\n if j:\n uf.union(idx+3, idx-4+1)\n # print(uf.par)\n return sum(uf.find(x)==x for x in range(4*N*N))","class Unionset:\n def __init__(self,N):\n self.parent=[x for x in range(N)]\n self.rank=[0 for x in range(N)]\n def find(self,x):\n if self.parent[x]!=x:\n self.parent[x]=self.find(self.parent[x])\n return self.parent[x]\n def union(self,x,y):\n xx=self.find(x)\n yy=self.find(y)\n if self.parent[xx]==self.parent[yy]:\n return True\n if self.rank[xx]>self.rank[yy]:\n self.parent[yy]=self.parent[xx]\n elif self.rank[xx]<self.rank[yy]:\n self.parent[xx]=self.parent[yy]\n else:\n self.rank[xx]+=1\n self.parent[yy]=self.parent[xx]\n return False\n \n \nclass Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n n=len(grid)\n ds=Unionset(n*n*4)\n #print(ds.parent)\n for r in range(n):\n for c in range(n):\n root=4*(r*n+c)\n if grid[r][c]=='/':\n ds.union(root,root+1)\n ds.union(root+2,root+3)\n elif grid[r][c]=='\\\\\\\\':\n ds.union(root,root+2)\n ds.union(root+1,root+3)\n else:\n ds.union(root,root+1)\n ds.union(root+1,root+2)\n ds.union(root+2,root+3)\n #print(grid[r][c])\n #print(\\\"first\\\",ds.parent)\n if r+1<n:\n ds.union(root+3,root+(4*n))\n if c+1<n:\n ds.union(root+2,root+5)\n #print(\\\"second\\\",ds.parent)\n tot=0\n for i in range(4*n*n):\n if ds.find(i)==i:\n tot+=1\n return tot\n","#\n# *-------*\n# | \\\\ 0 / |\n# | 3 * 1 |\n# | / 2 \\\\ |\n# *-------*\nclass DSU:\n def __init__(self, N):\n self.pres = list(range(N)) # 初始，每个节点指向自己\n def setRoot(self, i, root):\n while self.pres[i] != root:\n t = self.pres[i]\n self.pres[i] = root\n i = t\n return \n def findRoot(self, i):\n root = i\n while root != self.pres[root]:\n root = self.pres[root]\n self.setRoot(i, root)\n return root\n def merge(self, i, j):\n root = self.findRoot(i)\n self.setRoot(j, root)\n \n \nclass Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n def getPos(N, h, w, i):\n return N*4 * h + 4*w + i\n\n # 借鉴三角面片思路\n N = len(grid)\n NN4 = N*N*4\n dsu = DSU(NN4)\n \n # 合并临近矩形\n for h in range(N):\n for w in range(N):\n p = getPos(N, h, w, 0)\n pR = getPos(N, h, w+1, 0)\n pD = getPos(N, h+1, w, 0) \n pRD= getPos(N, h+1, w+1, 0)\n if h < N-1:\n dsu.merge(p+2, pD+0)\n if w < N-1:\n dsu.merge(p+1, pR+3)\n \n\n # 检查输入网格\n for h in range(N):\n for w in range(N):\n p = getPos(N, h, w, 0)\n if grid[h][w] == '/':\n dsu.merge(p+0, p+3)\n dsu.merge(p+1, p+2)\n elif grid[h][w] == '\\\\\\\\':\n dsu.merge(p+0, p+1)\n dsu.merge(p+2, p+3)\n else:\n dsu.merge(p+0, p+1)\n dsu.merge(p+0, p+2)\n dsu.merge(p+0, p+3)\n \n return sum(dsu.findRoot(x) == x for x in range(NN4))\n\n","class Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n N = len(grid)\n new_grid = [[0]*(2*N) for _ in range(2*N)]\n count = 0\n \n for i in range(N):\n for j in range(N):\n if grid[i][j] == '/':\n new_grid[2*i][2*j+1] = 1\n new_grid[2*i+1][2*j] = 1\n elif grid[i][j] == '\\\\\\\\':\n new_grid[2*i][2*j] = 1\n new_grid[2*i+1][2*j+1] = 1\n \n def dfs(grid, i, j):\n # starting with a seed (0 in location i,j), build up an open space\n if grid[i][j] == 1:\n return None\n grid[i][j] = 1 # mark as visited\n if i < len(grid)-1: # (make sure i+1 exists)\n dfs(grid, i+1, j) # search down \n if j < len(grid)-1: \n dfs(grid, i, j+1)# search right\n if i > 0:\n dfs(grid, i-1, j) # search up\n if j > 0:\n dfs(grid, i, j-1) #search left\n # search dl\n if i < len(grid)-1 and j > 0 and i%2==j%2:\n dfs(grid, i+1, j-1)\n # search ur\n if i > 0 and j < len(grid)-1 and i%2==j%2:\n dfs(grid, i-1, j+1)\n # search dr\n if i < len(grid)-1 and j < len(grid)-1 and i%2!=j%2:\n dfs(grid, i+1, j+1)\n # search ul\n if i > 0 and j > 0 and i%2!=j%2:\n dfs(grid, i-1, j-1)\n \n \n \n \n # search for seeds\n for i in range(2*N):\n for j in range(2*N):\n if new_grid[i][j] == 0:\n count += 1\n dfs(new_grid, i, j) # seed an island\n \n return count\n \n \n","class Solution:\n def regionsBySlashes(self, grid):\n n = len(grid)\n g = [[0 for _ in range(n*3)] for _ in range(n*3)]\n \n def dfs(i, j):\n if 0 <= i < (n*3) and 0 <= j < (n*3) and g[i][j] == 0:\n g[i][j] = 1\n for k in [1, -1]:\n dfs(i+k, j)\n dfs(i, j+k)\n \n for i in range(n):\n for j in range(n):\n if grid[i][j] == '/':\n g[i*3][(j*3) + 2] = 1\n g[(i*3) + 1][(j*3) + 1] = 1\n g[(i*3) + 2][j*3] = 1\n elif grid[i][j] == '\\\\\\\\':\n g[i*3][j*3] = 1\n g[(i*3) + 1][(j*3) + 1] = 1\n g[(i*3) + 2][(j*3) + 2] = 1\n res = 0\n for i in range(n*3):\n for j in range(n*3):\n if g[i][j] == 0:\n dfs(i, j)\n res += 1\n return res","class Solution:\n def regionsBySlashes(self, g: List[str]) -> int:\n \n n = len(g)\n \n grid = [[0]*(n*3) for j in range(n*3)]\n \n for i in range(n):\n \n for j in range(n):\n \n if g[i][j] == '/':\n \n grid[i*3][j*3+2] = 1\n \n grid[i*3+1][j*3+1] = 1\n \n grid[i*3+2][j*3] = 1\n \n elif g[i][j] == '\\\\\\\\':\n \n grid[i*3][j*3] = 1\n \n grid[i*3+1][j*3+1] = 1\n \n grid[i*3+2][j*3+2] = 1\n \n \n def dfs(i,j):\n \n grid[i][j] = 1\n \n for r in [(i+1,j), (i,j+1), (i-1,j), (i,j-1)]:\n \n xx,yy = r\n \n if xx < 0 or yy < 0 or xx >= len(grid) or yy >= len(grid[0]) or grid[xx][yy] == 1:\n continue\n \n dfs(xx,yy)\n \n \n count = 0\n \n for i in range(n*3):\n for j in range(n*3):\n \n if grid[i][j] == 0:\n \n dfs(i,j)\n \n count += 1\n \n return count","class Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n if not grid:\n return 0\n \n rows, cols = len(grid), len(grid[0])\n new_grid = [[0] * 3 * cols for _ in range(3 * rows)]\n visited = [[False] * 3 * cols for _ in range(3 * rows)]\n \n for i in range(rows):\n line = grid[i]\n \n for j in range(len(line)):\n if line[j] == '/':\n new_grid[3 * i][3 * j + 2] = 1\n new_grid[3 * i + 1][3 * j + 1] = 1\n new_grid[3 * i + 2][3 * j] = 1\n elif line[j] == '\\\\\\\\':\n new_grid[3 * i][3 * j] = 1\n new_grid[3 * i + 1][3 * j + 1] = 1\n new_grid[3 * i + 2][3 * j + 2] = 1\n \n def dfs(i, j):\n if i < 0 or j < 0 or i >= 3 * rows or j >= 3 * cols or new_grid[i][j] == 1 or visited[i][j]:\n return\n \n visited[i][j] = True\n \n dfs(i, j + 1)\n dfs(i + 1, j)\n dfs(i, j - 1)\n dfs(i - 1, j)\n \n count = 0\n \n for i in range(3 * rows):\n for j in range(3 * cols):\n if not visited[i][j] and new_grid[i][j] == 0:\n dfs(i, j)\n count += 1\n \n return count","class Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n n = len(grid)\n m, ans = [[[0, 0, 0, 0] for j in range(n)] for i in range(n)], 0\n \n def dfs(i, j, k):\n if 0 <= i < n and 0 <= j < n and not m[i][j][k]:\n if grid[i][j] == '/':\n if 1 <= k <= 2:\n m[i][j][1] = m[i][j][2] = ans\n dfs(i, j+1, 3)\n dfs(i+1, j, 0)\n else:\n m[i][j][0] = m[i][j][3] = ans \n dfs(i-1, j, 2)\n dfs(i, j-1, 1)\n elif grid[i][j] == '\\\\\\\\':\n if k <= 1:\n m[i][j][0] = m[i][j][1] = ans\n dfs(i-1, j, 2)\n dfs(i, j+1, 3)\n else:\n m[i][j][2] = m[i][j][3] = ans \n dfs(i+1, j, 0)\n dfs(i, j-1, 1)\n else:\n m[i][j][0] = m[i][j][1] = m[i][j][2] = m[i][j][3] = ans \n dfs(i-1, j, 2)\n dfs(i, j-1, 1)\n dfs(i+1, j, 0)\n dfs(i, j+1, 3)\n \n \n for i in range(n):\n for j in range(n):\n for k in range(4):\n if not m[i][j][k]:\n ans += 1\n dfs(i, j, k)\n \n return ans \n","class Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n if len(grid) == 0 or len(grid[0]) == 0:\n return 0\n \n roots = {}\n \n def find(x):\n roots.setdefault(x, x)\n \n if roots[x] != x:\n roots[x] = find(roots[x])\n \n return roots[x]\n \n def union(x, y):\n roots[find(x)] = find(y)\n \n # k=0 top\n # k=1 right\n # k=2 bottom\n # k=3 left\n \n for i in range(len(grid)):\n for j in range(len(grid[0])):\n if i > 0:\n union((i-1, j, 2), (i, j, 0))\n \n if j > 0:\n union((i, j-1, 1), (i, j, 3))\n \n if grid[i][j] != '/':\n union((i, j, 0), (i, j, 1))\n union((i, j, 2), (i, j, 3))\n \n if grid[i][j] != '\\\\\\\\':\n union((i, j, 0), (i, j, 3))\n union((i, j, 1), (i, j, 2))\n \n return len(set(find(x) for x in list(roots.keys())))\n","class Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n \n N = len(grid)\n \n matrix = grid\n \n parent = list(range(N * N * 4))\n # print(parent)\n def find(x):\n depth = 0\n while parent[x] != x:\n x = parent[x]\n depth += 1\n return x, depth\n \n def union(x, y):\n # print(x, y)\n (rx, dx), (ry, dy) = find(x), find(y)\n if dx < dy:\n parent[rx] = ry\n else:\n parent[ry] = rx\n \n def isValid(i, j):\n if i >= N or i < 0 or j >= N or j < 0:\n return False\n return True\n\n for i in range(N):\n for j in range(N):\n idtop = (i * N + j) * 4\n if matrix[i][j] == '/':\n union(idtop + 1, idtop + 2)\n union(idtop, idtop + 3)\n elif matrix[i][j] == '\\\\\\\\':\n union(idtop, idtop + 1)\n union(idtop + 2, idtop + 3) \n else:\n union(idtop, idtop + 1)\n union(idtop, idtop + 2)\n union(idtop, idtop + 3)\n if isValid(i-1, j):\n union(idtop, 4 *((i-1) * N + j) + 2)\n if isValid(i, j-1):\n union(idtop + 3, 4 * (i * N + j - 1) + 1)\n return sum(find(x)[0] == x for x in range(4 * N * N))\n \n","class Solution:\n def regionsBySlashes(self, grid: List[str]) -> int:\n \n root = {}\n \n def find(x):\n root.setdefault(x, x)\n if root[x] != x: # not find( root[x] )\n root[x] = find( root[x] )\n return root[x]\n \n def union(x, y):\n rx, ry = find(x), find(y)\n \n if rx != ry:\n root[ry] = find(rx)\n \n for i in range(len(grid)):\n for j in range(len(grid)):\n if i:\n union( (i-1,j, 2), (i,j, 0) )\n if j:\n union( (i,j-1, 1), (i,j, 3) )\n if grid[i][j] == '/':\n union( (i,j, 0), (i,j, 3) )\n union( (i,j, 1), (i,j, 2) )\n elif grid[i][j] == '\\\\\\\\':\n union( (i,j, 0), (i,j, 1) )\n union( (i,j, 2), (i,j, 3) )\n else:\n union( (i,j, 0), (i,j, 1) )\n union( (i,j, 0), (i,j, 2) )\n union( (i,j, 0), (i,j, 3) )\n \n return len( set( map(find, list(root.keys())) ) )\n \n \n","from itertools import chain\nclass Solution:\n def regionsBySlashes(self, grid):\n grid = convert_grid(grid)\n return len([destroy_island(x, y, grid) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v == 0])\n\ndef destroy_island(x, y, grid):\n grid[y][x] = 1\n for c in search(x, y, grid):\n destroy_island(c[0], c[1], grid)\n\ndef search(x, y, grid):\n in_bounds = lambda c:0 <= c[1] < len(grid) and 0 <= c[0] < len(grid[c[1]])\n check_orthog = lambda c:in_bounds(c) and grid[c[1]][c[0]] == 0\n def check_diag(c):\n if not in_bounds(c) or grid[c[1]][c[0]] != 0: return False\n d_x, d_y = c[0] - x, c[1] - y\n sep = '\\\\\\\\' if ((d_x > 0 > d_y) or (d_x < 0 < d_y)) else '/'\n return grid[y + d_y][x] != sep or grid[y][x + d_x] != sep\n yield from chain(filter(check_orthog, ((x-1, y), (x+1, y), (x, y-1), (x, y+1))),\n filter(check_diag, ((x + 1, y + 1), (x + 1, y - 1), (x - 1, y + 1), (x - 1, y - 1))))\n\ndef convert_grid(grid):\n new_grid = [[0] * len(grid[0]) * 2 for _ in range(len(grid) * 2)]\n for (x, y, v) in ((x, y, v) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v in '\\\\\\\\/'):\n new_grid[y * 2 + 0][x * 2 + (1 if v == '/' else 0)] = v\n new_grid[y * 2 + 1][x * 2 + (0 if v == '/' else 1)] = v\n return new_grid","from itertools import chain\nclass Solution:\n def regionsBySlashes(self, grid):\n grid = convert_grid(grid)\n return len([destroy_island(x, y, grid) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v == 0])\n\ndef destroy_island(x, y, grid):\n grid[y][x] = 1\n for c in search(x, y, grid):\n destroy_island(c[0], c[1], grid)\n\ndef search(x, y, grid):\n in_bounds = lambda c:0 <= c[1] < len(grid) and 0 <= c[0] < len(grid[c[1]])\n check_orthog = lambda c:in_bounds(c) and grid[c[1]][c[0]] == 0\n def check_diag(c):\n if not in_bounds(c) or grid[c[1]][c[0]] != 0: return False\n d_x, d_y = c[0] - x, c[1] - y\n sep = '\\\\\\\\' if ((d_x > 0 > d_y) or (d_x < 0 < d_y)) else '/'\n return not (grid[y + d_y][x] == sep and grid[y][x + d_x] == sep)\n yield from chain(filter(check_orthog, ((x-1, y), (x+1, y), (x, y-1), (x, y+1))),\n filter(check_diag, ((x + 1, y + 1), (x + 1, y - 1), (x - 1, y + 1), (x - 1, y - 1))))\n\ndef convert_grid(grid):\n new_grid = [[0] * len(grid[0]) * 2 for _ in range(len(grid) * 2)]\n for (x, y, v) in ((x, y, v) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v in '\\\\\\\\/'):\n new_grid[y * 2 + 0][x * 2 + (1 if v == '/' else 0)] = v\n new_grid[y * 2 + 1][x * 2 + (0 if v == '/' else 1)] = v\n return new_grid","from itertools import chain\nclass Solution:\n def regionsBySlashes(self, grid):\n grid = convert_grid(grid)\n print(*(list(map(str, x)) for x in grid), sep='\\\n')\n return len([destroy_island(x, y, grid) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v == 0])\n\ndef destroy_island(x, y, grid):\n grid[y][x] = 1\n for c in search(x, y, grid):\n destroy_island(c[0], c[1], grid)\n\ndef search(x, y, grid):\n in_bounds = lambda c:0 <= c[1] < len(grid) and 0 <= c[0] < len(grid[c[1]])\n check_orthog = lambda c:in_bounds(c) and grid[c[1]][c[0]] == 0\n def check_diag(c):\n if not in_bounds(c) or grid[c[1]][c[0]] != 0: return False\n d_x, d_y = c[0] - x, c[1] - y\n sep = '\\\\\\\\' if ((d_x > 0 > d_y) or (d_x < 0 < d_y)) else '/'\n return grid[y + d_y][x] != sep or grid[y][x + d_x] != sep\n yield from chain(filter(check_orthog, ((x-1, y), (x+1, y), (x, y-1), (x, y+1))),\n filter(check_diag, ((x + 1, y + 1), (x + 1, y - 1), (x - 1, y + 1), (x - 1, y - 1))))\n\ndef convert_grid(grid):\n new_grid = [[0] * len(grid[0]) * 2 for _ in range(len(grid) * 2)]\n for (x, y, v) in ((x, y, v) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v in '\\\\\\\\/'):\n new_grid[y * 2 + 0][x * 2 + (1 if v == '/' else 0)] = v\n new_grid[y * 2 + 1][x * 2 + (0 if v == '/' else 1)] = v\n return new_grid"],"string":"[\n \"from itertools import chain\\nclass Solution:\\n def regionsBySlashes(self, grid):\\n grid = self.convert_grid(grid)\\n print(*(list(map(str, x)) for x in grid), sep='\\\\\\n')\\n return len([self.destroy_island(x, y, grid) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v == 0])\\n\\n @staticmethod\\n def convert_grid(grid):\\n new_grid = [[0] * len(grid[0]) * 2 for _ in range(len(grid) * 2)]\\n for (x, y, v) in ((x, y, v) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v in '\\\\\\\\\\\\\\\\/'):\\n new_grid[y * 2 + 0][x * 2 + (1 if v == '/' else 0)] = v\\n new_grid[y * 2 + 1][x * 2 + (0 if v == '/' else 1)] = v\\n return new_grid\\n\\n def destroy_island(self, x, y, grid):\\n grid[y][x] = 1\\n for c in Solution.search(x, y, grid):\\n self.destroy_island(c[0], c[1], grid)\\n\\n @staticmethod\\n def search(x, y, grid):\\n in_bounds = lambda c:0 <= c[1] < len(grid) and 0 <= c[0] < len(grid[c[1]])\\n check_orthog = lambda c:in_bounds(c) and grid[c[1]][c[0]] == 0\\n def check_diag(c):\\n if not in_bounds(c) or grid[c[1]][c[0]] != 0: return False\\n d_x, d_y = c[0] - x, c[1] - y\\n sep = '\\\\\\\\\\\\\\\\' if ((d_x > 0 > d_y) or (d_x < 0 < d_y)) else '/'\\n return not (grid[y + d_y][x] == sep and grid[y][x + d_x] == sep)\\n yield from chain(filter(check_orthog, ((x-1, y), (x+1, y), (x, y-1), (x, y+1))),\\n filter(check_diag, ((x + 1, y + 1), (x + 1, y - 1), (x - 1, y + 1), (x - 1, y - 1))))\",\n \"class DSU:\\n def __init__(self):\\n self.parent = {}\\n \\n def find(self, x):\\n if x not in self.parent:\\n self.parent[x] = x\\n if self.parent[x] != x:\\n self.parent[x] = self.find(self.parent[x])\\n \\n return self.parent[x]\\n \\n def union(self, x, y):\\n xroot, yroot = self.find(x), self.find(y)\\n if xroot != yroot:\\n self.parent[yroot] = xroot\\n\\nclass Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n n = len(grid)\\n dsu = DSU()\\n \\n for i in range(n):\\n for j in range(n):\\n if i > 0:\\n dsu.union((i - 1, j, 2), (i, j, 0))\\n if j > 0:\\n dsu.union((i, j - 1, 1), (i, j, 3))\\n if grid[i][j] != '/':\\n dsu.union((i, j, 0), (i, j, 1))\\n dsu.union((i, j, 2), (i, j, 3))\\n if grid[i][j] != '\\\\\\\\\\\\\\\\':\\n dsu.union((i, j, 3), (i, j, 0))\\n dsu.union((i, j, 1), (i, j, 2))\\n \\n seen = set()\\n for key in dsu.parent.keys():\\n temp = dsu.find(key)\\n seen.add(temp)\\n \\n return len(seen)\",\n \"from typing import List\\n\\nclass DS:\\n \\n def __init__(self, n):\\n self.sizes = [1] * n\\n self.roots = [i for i in range(n)]\\n \\n def query(self, x):\\n root = x\\n while root != self.roots[root]:\\n self.roots[root] = self.roots[self.roots[root]]\\n root = self.roots[root]\\n return root\\n \\n def union(self, x, y):\\n xRoot, yRoot = self.query(x), self.query(y)\\n s, l = (xRoot, yRoot) if self.sizes[xRoot] < self.sizes[yRoot] else (yRoot, xRoot)\\n self.roots[s] = l\\n self.sizes[l] += self.sizes[s] \\n\\nclass Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n n = len(grid)\\n nodes = DS(4 * n * n)\\n getIndex = lambda r, c, k: 4 * (n * r + c) + k\\n for i in range(n):\\n for j in range(n):\\n if i > 0: nodes.union(getIndex(i, j, 0), getIndex(i - 1, j, 2))\\n if i < n - 1: nodes.union(getIndex(i, j, 2), getIndex(i + 1, j, 0))\\n if j > 0: nodes.union(getIndex(i, j, 3), getIndex(i, j - 1, 1))\\n if j < n - 1: nodes.union(getIndex(i, j, 1), getIndex(i, j + 1, 3))\\n if grid[i][j] != '/':\\n nodes.union(getIndex(i, j, 0), getIndex(i, j, 1))\\n nodes.union(getIndex(i, j, 3), getIndex(i, j, 2))\\n if grid[i][j] != '\\\\\\\\\\\\\\\\':\\n nodes.union(getIndex(i, j, 0), getIndex(i, j, 3))\\n nodes.union(getIndex(i, j, 1), getIndex(i, j, 2))\\n return sum(i == nodes.query(i) for i in range(4 * n * n))\",\n \"class Solution:\\n f = {}\\n def find(self, x):\\n self.f.setdefault(x,x)\\n if self.f[x] != x: \\n self.f[x] = self.find(self.f[x])\\n return self.f[x]\\n \\n def union(self, x, y):\\n self.f[self.find(x)] = self.find(y)\\n \\n def regionsBySlashes(self, grid: List[str]) -> int:\\n self.f = {}\\n for row in range(len(grid)):\\n for col in range(len(grid)):\\n if row: \\n self.union((row-1,col,2),(row,col,0))\\n if col: \\n self.union((row,col-1,3),(row,col,1))\\n if grid[row][col] != '/':\\n self.union((row,col,0),(row,col,3))\\n self.union((row,col,1),(row,col,2))\\n if grid[row][col] != '\\\\\\\\\\\\\\\\':\\n self.union((row,col,0), (row,col,1))\\n self.union((row,col,2), (row,col,3))\\n \\n return len(set(map(self.find,self.f)))\\n \\n\",\n \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n for i in range(len(grid)):\\n grid[i] = grid[i].replace('\\\\\\\\\\\\\\\\', '*')\\n N = len(grid)\\n record = [[[0,0,0,0] for j in range(N)] for i in range(N)]\\n #visited = set()\\n #print(grid)\\n count = 0\\n def dfs(i,j,k):\\n if 0 <= i < N and 0 <= j < N and record[i][j][k] == 0:\\n if grid[i][j] == '*':\\n if k <= 1:\\n record[i][j][0] = record[i][j][1] = count\\n dfs(i-1, j, 2)\\n dfs(i, j+1, 3)\\n else:\\n record[i][j][2] = record[i][j][3] = count\\n dfs(i+1, j, 0)\\n dfs(i, j-1, 1)\\n elif grid[i][j] == '/':\\n if 1 <= k <= 2:\\n record[i][j][1] = record[i][j][2] = count\\n dfs(i+1, j, 0)\\n dfs(i, j+1, 3)\\n else:\\n record[i][j][0] = record[i][j][3] = count\\n dfs(i-1, j, 2)\\n dfs(i, j-1, 1)\\n else:\\n record[i][j][0] = record[i][j][1] = record[i][j][2] = record[i][j][3] = count\\n dfs(i-1, j, 2)\\n dfs(i, j+1, 3)\\n dfs(i+1, j, 0)\\n dfs(i, j-1, 1)\\n \\n for i in range(N):\\n for j in range(N):\\n for k in range(4):\\n if record[i][j][k] == 0:\\n count += 1\\n dfs(i,j,k)\\n return count\",\n \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n \\n N = len(grid)\\n \\n matrix = [list(s) for s in grid]\\n \\n parent = list(range(N * N * 4))\\n print(parent)\\n def find(x):\\n depth = 0\\n while parent[x] != x:\\n x = parent[x]\\n depth += 1\\n return x, depth\\n \\n def union(x, y):\\n print((x, y))\\n (rx, dx), (ry, dy) = find(x), find(y)\\n if dx < dy:\\n parent[rx] = ry\\n else:\\n parent[ry] = rx\\n \\n def isValid(i, j):\\n if i >= N or i < 0 or j >= N or j < 0:\\n return False\\n return True\\n\\n # dirs = [(0, 1), (-1, 0)]\\n for i in range(N):\\n for j in range(N):\\n idtop = (i * N + j) * 4\\n if matrix[i][j] == '/':\\n union(idtop + 1, idtop + 2)\\n union(idtop, idtop + 3)\\n elif matrix[i][j] == '\\\\\\\\\\\\\\\\':\\n union(idtop, idtop + 1)\\n union(idtop + 2, idtop + 3) \\n else:\\n union(idtop, idtop + 1)\\n union(idtop, idtop + 2)\\n union(idtop, idtop + 3)\\n if isValid(i-1, j):\\n union(idtop, 4 *((i-1) * N + j) + 2)\\n if isValid(i, j-1):\\n union(idtop + 3, 4 * (i * N + j - 1) + 1)\\n return len(set(find(x)[0] for x in range(4 * N * N)))\\n \\n\",\n \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n m, n = len(grid), len(grid[0])\\n print(m, n)\\n mat = [[0] * (4*n) for _ in range(4*m)]\\n for i in range(m):\\n for j in range(n):\\n if grid[i][j] == '/':\\n mat[4*i][4*j+3] = 1\\n mat[4*i+1][4*j+2] = 1\\n mat[4*i+2][4*j+1] = 1\\n mat[4*i+3][4*j] = 1\\n elif grid[i][j] == '\\\\\\\\\\\\\\\\':\\n mat[4*i][4*j] = 1\\n mat[4*i+1][4*j+1] = 1\\n mat[4*i+2][4*j+2] = 1\\n mat[4*i+3][4*j+3] = 1\\n # print(mat)\\n dirs = [[-1,0],[1,0],[0,1],[0,-1]]\\n def dfs(i, j):\\n visit[i][j] = 1\\n for d in dirs:\\n x, y = i+d[0], j+d[1]\\n if 0<=x<(4*m) and 0<=y<(4*n) and not mat[x][y]:\\n mat[x][y] = 1\\n if not visit[x][y]:\\n dfs(x, y)\\n \\n visit = [[0]*(4*n) for _ in range(4*m)]\\n res = 0\\n for i in range(4*m):\\n for j in range(4*n):\\n if not mat[i][j]:\\n res += 1\\n dfs(i, j)\\n return res\",\n \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n n = len(grid)\\n seen = [[[0,0,0,0] for x in range(n)] for y in range(n)]\\n # top 1, left 2, bottom 3, right 0\\n def dfs(x, y, loc):\\n #print(x,y)\\n if not ( 0<=x<n and 0<=y<n) or seen[x][y][loc] == 1:\\n return\\n seen[x][y][loc] = 1\\n \\n if grid[x][y] == '/':\\n if loc == 0:\\n dfs(x+1,y,2)\\n seen[x][y][3] = 1\\n dfs(x, y+1, 1)\\n elif loc == 3:\\n dfs(x,y+1,1)\\n seen[x][y][0] = 1\\n dfs(x+1, y, 2)\\n elif loc == 1:\\n dfs(x,y-1,3)\\n seen[x][y][2] = 1\\n dfs(x-1, y, 0)\\n else:\\n dfs(x-1,y,0)\\n seen[x][y][1] = 1\\n dfs(x, y-1, 3)\\n elif grid[x][y] == '\\\\\\\\\\\\\\\\':\\n if loc == 0:\\n dfs(x+1,y,2)\\n seen[x][y][1] = 1\\n dfs(x, y-1, 3) \\n elif loc == 3:\\n dfs(x,y+1,1)\\n seen[x][y][2] = 1\\n dfs(x-1, y, 0)\\n elif loc == 1:\\n dfs(x,y-1,3)\\n seen[x][y][0] = 1\\n dfs(x+1, y, 2)\\n else:\\n dfs(x-1,y,0)\\n seen[x][y][3] = 1\\n dfs(x, y+1, 1)\\n else:\\n seen[x][y][1] = 1\\n dfs(x, y-1, 3)\\n seen[x][y][2] = 1\\n dfs(x-1, y, 0)\\n seen[x][y][0] = 1\\n dfs(x+1, y, 2)\\n seen[x][y][3] = 1\\n dfs(x, y+1, 1)\\n count = 0\\n for i in range(n):\\n for j in range(n):\\n for loc in range(4):\\n k = seen[i][j][loc]\\n if k == 0:\\n #print(i,j,k, seen)\\n count += 1\\n dfs(i,j,loc)\\n return count\",\n \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n \\n N = len(grid)\\n base = N * (N + 1)\\n parent = [i for i in range(2 * base)]\\n \\n def find(x):\\n if parent[x] != parent[parent[x]]:\\n parent[x] = find(parent[x])\\n return parent[x]\\n \\n def union(x, y):\\n parent[find(x)] = find(y)\\n return find(y)\\n \\n for i in range(N):\\n for j in range(N):\\n up, down, left, right = i * N + j, (i + 1) * N + j, base + i * (N + 1) + j, base + i * (N + 1) + j + 1\\n \\n if grid[i][j] == '/':\\n union(up, left)\\n union(down, right)\\n elif grid[i][j] == '\\\\\\\\\\\\\\\\':\\n union(up, right)\\n union(down, left)\\n else:\\n union(up, left)\\n union(down, right)\\n union(left, right)\\n \\n comp = set()\\n for i in range(2 * base):\\n comp.add(find(i))\\n \\n return len(comp)\",\n \"class Solution:\\n \\n def regionsBySlashes(self, grid: List[str]):\\n def minAnglePoint(p1, p2, options):\\n minAngle = 10.0 # a ridiculously big number\\n for p3 in options:\\n a = (p2[0] - p1[0], p2[1] - p1[1])\\n b = (p3[0] - p2[0], p3[1] - p2[1])\\n dot = a[0] * b[0] + a[1] * b[1]\\n det = a[0] * b[1] - a[1] * b[0]\\n ang = math.atan2(det, dot)\\n if ang < minAngle: \\n minAngle = ang\\n res = p3\\n return res, minAngle\\n\\n N = len(grid)\\n M = dict()\\n for i in range(N):\\n M[(i + 1, 0)] = [(i, 0)]\\n M[(N, i + 1)] = [(N, i)]\\n M[(N - i - 1, N)] = [(N - i, N)]\\n M[(0, N - i - 1)] = [(0, N - i)]\\n for y in range(N):\\n x = 0\\n for c in grid[y]:\\n if c == '/':\\n if (x + 1, y) in M: \\n M[(x + 1, y)].append((x, y + 1))\\n else: \\n M[(x + 1, y)] = [(x, y + 1)]\\n if (x, y + 1) in M:\\n M[(x, y + 1)].append((x + 1, y))\\n else:\\n M[(x, y + 1)] = [(x + 1, y)]\\n elif c == '\\\\\\\\\\\\\\\\':\\n if (x, y) in M: \\n M[(x, y)].append((x + 1, y + 1))\\n else:\\n M[(x, y)] = [(x + 1, y + 1)]\\n if (x + 1, y + 1) in M: \\n M[(x + 1, y + 1)].append((x, y))\\n else:\\n M[(x + 1, y + 1)] = [(x, y)]\\n x += 1\\n innerangle = round(-2 * math.pi, 4)\\n points = sorted(M)\\n regions = set()\\n for i in range(len(points)):\\n if points[i] not in M: continue\\n startpoint = points[i]\\n region = {startpoint}\\n point = firststep = M[startpoint][0]\\n M[startpoint].remove(point)\\n prev = startpoint\\n angSum = 0\\n while point != startpoint:\\n region.add(point)\\n links = M[point]\\n nxt, ang = minAnglePoint(prev, point, links)\\n angSum += ang\\n if len(links) == 1: \\n del M[point]\\n else:\\n M[point].remove(nxt)\\n prev = point\\n point = nxt\\n if len(M[startpoint]) == 0: \\n del M[startpoint]\\n \\n _, ang = minAnglePoint(prev, point, [firststep])\\n angSum = round(angSum + ang, 4)\\n if angSum == innerangle: # it is a valid region\\n regions.add(frozenset(region))\\n return len(regions)\",\n \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n N = len(grid)\\n new_grid = [[0]*(2*N) for _ in range(2*N)]\\n count = 0\\n \\n for i in range(N):\\n for j in range(N):\\n if grid[i][j] == '/':\\n new_grid[2*i][2*j+1] = 1\\n new_grid[2*i+1][2*j] = 1\\n elif grid[i][j] == '\\\\\\\\\\\\\\\\':\\n new_grid[2*i][2*j] = 1\\n new_grid[2*i+1][2*j+1] = 1\\n \\n def dfs(grid, i, j):\\n # starting with a seed (0 in location i,j), build up an open space\\n if grid[i][j] == 1:\\n return None\\n grid[i][j] = 1 # mark as visited\\n if i < len(grid)-1: # (make sure i+1 exists)\\n dfs(grid, i+1, j) # search down \\n if j < len(grid)-1: \\n dfs(grid, i, j+1)# search right\\n if i > 0:\\n dfs(grid, i-1, j) # search up\\n if j > 0:\\n dfs(grid, i, j-1) #search left\\n # search dl\\n if i < len(grid)-1 and j > 0 and i%2==j%2:\\n dfs(grid, i+1, j-1)\\n # search ur\\n if i > 0 and j < len(grid)-1 and i%2==j%2:\\n dfs(grid, i-1, j+1)\\n # search dr\\n if i < len(grid)-1 and j < len(grid)-1 and i%2!=j%2:\\n dfs(grid, i+1, j+1)\\n # search ul\\n if i > 0 and j > 0 and i%2!=j%2:\\n dfs(grid, i-1, j-1)\\n \\n # search for seeds (new islands)\\n for i in range(2*N):\\n for j in range(2*N):\\n if new_grid[i][j] == 0:\\n count += 1\\n dfs(new_grid, i, j) # seed an island\\n \\n return count\\n \\n\",\n \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n nrow = len(grid)\\n ncol = len(grid[0])\\n newgrid = []\\n for i in range(nrow*3):\\n newgrid.append([0]*ncol*3)\\n for r in range(nrow):\\n for c in range(ncol):\\n if grid[r][c] == '\\\\\\\\\\\\\\\\':\\n newgrid[r*3][c*3] = 1\\n newgrid[r*3+1][c*3+1] = 1\\n newgrid[r*3+2][c*3+2] = 1\\n elif grid[r][c] == '/':\\n newgrid[r*3+2][c*3] = 1\\n newgrid[r*3+1][c*3+1] = 1\\n newgrid[r*3][c*3+2] = 1\\n \\n def countIsland(newgrid):\\n count = 0\\n def dfs(r,c):\\n if newgrid[r][c] == 0:\\n newgrid[r][c] =1\\n if r < len(newgrid) -1 and newgrid[r+1][c] ==0:\\n dfs(r+1,c)\\n if c < len(newgrid[0]) -1 and newgrid[r][c+1] ==0:\\n dfs(r,c+1)\\n if r > 0 and newgrid[r-1][c] ==0:\\n dfs(r-1,c)\\n if c > 0 and newgrid[r][c-1] ==0:\\n dfs(r,c-1)\\n \\n \\n for r1 in range(len(newgrid)):\\n for c1 in range(len(newgrid[0])):\\n if newgrid[r1][c1] == 0:\\n dfs(r1,c1)\\n count+=1\\n else:\\n pass\\n return(count)\\n \\n return(countIsland(newgrid))\",\n \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n N = len(grid) \\n D = list(range(N*N*4))\\n res = [len(D)]\\n def find(D,i):\\n if D[i]==i:\\n return i\\n return find(D,D[i])\\n \\n def union(D,i,j):\\n pi = find(D,i)\\n pj = find(D,j)\\n if pi==pj:\\n return\\n else:\\n D[pi] = pj\\n res[0] -= 1\\n \\n def idx(i,j,e):\\n return (i*N+j)*4+e\\n \\n \\n \\n for i in range(N):\\n for j in range(N):\\n if i>0:\\n union(D,idx(i-1,j,2),idx(i,j,0))\\n if j>0:\\n union(D,idx(i,j-1,1,),idx(i,j,3))\\n if grid[i][j]!='/':\\n union(D,idx(i,j,0),idx(i,j,1))\\n union(D,idx(i,j,2),idx(i,j,3))\\n if grid[i][j]!='\\\\\\\\\\\\\\\\':\\n union(D,idx(i,j,0),idx(i,j,3))\\n union(D,idx(i,j,1),idx(i,j,2))\\n return res[0]\\n \\n \\n \\n\",\n \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n m, n = len(grid), len(grid[0])\\n parent = {}\\n def find(x):\\n if parent[x] != x:\\n parent[x] = find(parent[x])\\n return parent[x]\\n \\n def union(x, y):\\n rx, ry = find(x), find(y)\\n if rx == ry:\\n return False\\n parent[rx] = ry\\n return True\\n \\n res = m * n * 4\\n for i in range(m):\\n for j in range(n):\\n for k in range(4):\\n parent[(i, j, k)] = (i, j, k)\\n if grid[i][j] == '/':\\n if union((i, j, 0), (i, j, 3)):\\n res -= 1\\n if union((i, j, 1), (i, j, 2)):\\n res -= 1\\n elif grid[i][j] == '\\\\\\\\\\\\\\\\':\\n if union((i, j, 0), (i, j, 1)):\\n res -= 1\\n if union((i, j, 2), (i, j, 3)):\\n res -= 1\\n else:\\n if union((i, j, 0), (i, j, 1)):\\n res -= 1\\n if union((i, j, 2), (i, j, 3)):\\n res -= 1\\n if union((i, j, 0), (i, j, 3)):\\n res -= 1\\n \\n if i > 0:\\n if union((i, j, 0), (i - 1, j, 2)):\\n res -= 1\\n if j > 0:\\n if union((i, j, 3), (i, j - 1, 1)):\\n res -= 1\\n return res\",\n \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n self.N = len(grid)#n行\\n print((self.N))\\n pre = list(range(self.N*self.N*4))#所有元素自己是自己的父节点[0,1,2,3,4,5,6,...]\\n self.count = self.N*self.N*4 #总共的区域数量\\n for r in range(self.N):\\n line = grid[r]\\n for c in range(self.N):\\n w = line[c]\\n if r > 0:\\n self.union(pre, self.g(r - 1, c, 2), self.g(r, c, 0))\\n if c > 0:\\n self.union(pre, self.g(r, c - 1, 1), self.g(r, c, 3))\\n if w != '/':\\n self.union(pre, self.g(r, c, 0), self.g(r, c, 1))\\n self.union(pre, self.g(r, c, 3), self.g(r, c, 2))\\n if w != '\\\\\\\\\\\\\\\\':\\n self.union(pre, self.g(r, c, 0), self.g(r, c, 3))\\n self.union(pre, self.g(r, c, 1), self.g(r, c, 2))\\n return self.count \\n \\n def find(self,pre,x):\\n if x == pre[x]:\\n return x\\n \\n return self.find(pre,pre[x])\\n def union(self, pre, a, b):\\n pa = self.find(pre, a)\\n pb = self.find(pre, b)\\n if (pa == pb):\\n return\\n pre[pa] = pb\\n self.count -= 1\\n \\n def g(self, r, c, i):\\n return (r * self.N + c) * 4 + i\\n\",\n \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n f = {}\\n def find(x):\\n if (x not in f):\\n f[x] = x\\n elif(f[x] != x):\\n f[x] = find(f[x])\\n return f[x]\\n def merge(x,y):\\n rx,ry = find(x),find(y)\\n f[rx] = ry\\n\\n rows, cols = len(grid), len(grid[0]) if grid else 0\\n for i in range(rows):\\n for j in range(cols):\\n cur = (i * cols + j) * 4\\n up, left = ((i - 1) * cols + j) * 4, (i * cols + j - 1) * 4\\n cl, cr, cd = cur + 3, cur + 1, cur + 2\\n lr,ud = left + 1, up + 2\\n if (grid[i][j] == '/'):\\n merge(cur, cl)\\n merge(cr, cd)\\n elif (grid[i][j] == '\\\\\\\\\\\\\\\\'):\\n merge(cur, cr)\\n merge(cl, cd)\\n else:\\n merge(cur, cr)\\n merge(cl, cd)\\n merge(cur, cl)\\n if (i >= 1):\\n merge(cur,ud)\\n if (j >= 1):\\n merge(cl,lr)\\n res = 0\\n for i in range(rows):\\n for j in range(cols):\\n cur = (i * cols + j) * 4\\n for dx in range(4):\\n if (cur+dx == find(cur+dx)):\\n res += 1\\n return res\\n\",\n \"class UnionFind:\\n def __init__(self, N):\\n self.par = list(range(N))\\n self.rank = [0]*N\\n \\n def find(self, x):\\n if self.par[x] != x:\\n self.par[x] = self.find(self.par[x])\\n return self.par[x]\\n \\n def union(self, x, y):\\n px, py = self.find(x), self.find(y)\\n if px==py: return\\n \\n if self.rank[px]<self.rank[py]:\\n self.par[px] = py\\n elif self.rank[px]>self.rank[py]:\\n self.par[py] = px\\n else:\\n self.par[py] = px\\n self.rank[px] += 1\\n \\nclass Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n N = len(grid)\\n uf = UnionFind(4*N*N)\\n \\n for i in range(N):\\n for j in range(N):\\n idx = 4*(i*N+j)\\n if grid[i][j]!='/':\\n uf.union(idx, idx+1)\\n uf.union(idx+2, idx+3)\\n if grid[i][j]!='\\\\\\\\\\\\\\\\':\\n uf.union(idx, idx+3)\\n uf.union(idx+1, idx+2)\\n\\n if i:\\n uf.union(idx, idx-4*N+2)\\n if j:\\n uf.union(idx+3, idx-4+1)\\n # print(uf.par)\\n return sum(uf.find(x)==x for x in range(4*N*N))\",\n \"class Unionset:\\n def __init__(self,N):\\n self.parent=[x for x in range(N)]\\n self.rank=[0 for x in range(N)]\\n def find(self,x):\\n if self.parent[x]!=x:\\n self.parent[x]=self.find(self.parent[x])\\n return self.parent[x]\\n def union(self,x,y):\\n xx=self.find(x)\\n yy=self.find(y)\\n if self.parent[xx]==self.parent[yy]:\\n return True\\n if self.rank[xx]>self.rank[yy]:\\n self.parent[yy]=self.parent[xx]\\n elif self.rank[xx]<self.rank[yy]:\\n self.parent[xx]=self.parent[yy]\\n else:\\n self.rank[xx]+=1\\n self.parent[yy]=self.parent[xx]\\n return False\\n \\n \\nclass Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n n=len(grid)\\n ds=Unionset(n*n*4)\\n #print(ds.parent)\\n for r in range(n):\\n for c in range(n):\\n root=4*(r*n+c)\\n if grid[r][c]=='/':\\n ds.union(root,root+1)\\n ds.union(root+2,root+3)\\n elif grid[r][c]=='\\\\\\\\\\\\\\\\':\\n ds.union(root,root+2)\\n ds.union(root+1,root+3)\\n else:\\n ds.union(root,root+1)\\n ds.union(root+1,root+2)\\n ds.union(root+2,root+3)\\n #print(grid[r][c])\\n #print(\\\\\\\"first\\\\\\\",ds.parent)\\n if r+1<n:\\n ds.union(root+3,root+(4*n))\\n if c+1<n:\\n ds.union(root+2,root+5)\\n #print(\\\\\\\"second\\\\\\\",ds.parent)\\n tot=0\\n for i in range(4*n*n):\\n if ds.find(i)==i:\\n tot+=1\\n return tot\\n\",\n \"#\\n# *-------*\\n# | \\\\\\\\ 0 / |\\n# | 3 * 1 |\\n# | / 2 \\\\\\\\ |\\n# *-------*\\nclass DSU:\\n def __init__(self, N):\\n self.pres = list(range(N)) # 初始，每个节点指向自己\\n def setRoot(self, i, root):\\n while self.pres[i] != root:\\n t = self.pres[i]\\n self.pres[i] = root\\n i = t\\n return \\n def findRoot(self, i):\\n root = i\\n while root != self.pres[root]:\\n root = self.pres[root]\\n self.setRoot(i, root)\\n return root\\n def merge(self, i, j):\\n root = self.findRoot(i)\\n self.setRoot(j, root)\\n \\n \\nclass Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n def getPos(N, h, w, i):\\n return N*4 * h + 4*w + i\\n\\n # 借鉴三角面片思路\\n N = len(grid)\\n NN4 = N*N*4\\n dsu = DSU(NN4)\\n \\n # 合并临近矩形\\n for h in range(N):\\n for w in range(N):\\n p = getPos(N, h, w, 0)\\n pR = getPos(N, h, w+1, 0)\\n pD = getPos(N, h+1, w, 0) \\n pRD= getPos(N, h+1, w+1, 0)\\n if h < N-1:\\n dsu.merge(p+2, pD+0)\\n if w < N-1:\\n dsu.merge(p+1, pR+3)\\n \\n\\n # 检查输入网格\\n for h in range(N):\\n for w in range(N):\\n p = getPos(N, h, w, 0)\\n if grid[h][w] == '/':\\n dsu.merge(p+0, p+3)\\n dsu.merge(p+1, p+2)\\n elif grid[h][w] == '\\\\\\\\\\\\\\\\':\\n dsu.merge(p+0, p+1)\\n dsu.merge(p+2, p+3)\\n else:\\n dsu.merge(p+0, p+1)\\n dsu.merge(p+0, p+2)\\n dsu.merge(p+0, p+3)\\n \\n return sum(dsu.findRoot(x) == x for x in range(NN4))\\n\\n\",\n \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n N = len(grid)\\n new_grid = [[0]*(2*N) for _ in range(2*N)]\\n count = 0\\n \\n for i in range(N):\\n for j in range(N):\\n if grid[i][j] == '/':\\n new_grid[2*i][2*j+1] = 1\\n new_grid[2*i+1][2*j] = 1\\n elif grid[i][j] == '\\\\\\\\\\\\\\\\':\\n new_grid[2*i][2*j] = 1\\n new_grid[2*i+1][2*j+1] = 1\\n \\n def dfs(grid, i, j):\\n # starting with a seed (0 in location i,j), build up an open space\\n if grid[i][j] == 1:\\n return None\\n grid[i][j] = 1 # mark as visited\\n if i < len(grid)-1: # (make sure i+1 exists)\\n dfs(grid, i+1, j) # search down \\n if j < len(grid)-1: \\n dfs(grid, i, j+1)# search right\\n if i > 0:\\n dfs(grid, i-1, j) # search up\\n if j > 0:\\n dfs(grid, i, j-1) #search left\\n # search dl\\n if i < len(grid)-1 and j > 0 and i%2==j%2:\\n dfs(grid, i+1, j-1)\\n # search ur\\n if i > 0 and j < len(grid)-1 and i%2==j%2:\\n dfs(grid, i-1, j+1)\\n # search dr\\n if i < len(grid)-1 and j < len(grid)-1 and i%2!=j%2:\\n dfs(grid, i+1, j+1)\\n # search ul\\n if i > 0 and j > 0 and i%2!=j%2:\\n dfs(grid, i-1, j-1)\\n \\n \\n \\n \\n # search for seeds\\n for i in range(2*N):\\n for j in range(2*N):\\n if new_grid[i][j] == 0:\\n count += 1\\n dfs(new_grid, i, j) # seed an island\\n \\n return count\\n \\n \\n\",\n \"class Solution:\\n def regionsBySlashes(self, grid):\\n n = len(grid)\\n g = [[0 for _ in range(n*3)] for _ in range(n*3)]\\n \\n def dfs(i, j):\\n if 0 <= i < (n*3) and 0 <= j < (n*3) and g[i][j] == 0:\\n g[i][j] = 1\\n for k in [1, -1]:\\n dfs(i+k, j)\\n dfs(i, j+k)\\n \\n for i in range(n):\\n for j in range(n):\\n if grid[i][j] == '/':\\n g[i*3][(j*3) + 2] = 1\\n g[(i*3) + 1][(j*3) + 1] = 1\\n g[(i*3) + 2][j*3] = 1\\n elif grid[i][j] == '\\\\\\\\\\\\\\\\':\\n g[i*3][j*3] = 1\\n g[(i*3) + 1][(j*3) + 1] = 1\\n g[(i*3) + 2][(j*3) + 2] = 1\\n res = 0\\n for i in range(n*3):\\n for j in range(n*3):\\n if g[i][j] == 0:\\n dfs(i, j)\\n res += 1\\n return res\",\n \"class Solution:\\n def regionsBySlashes(self, g: List[str]) -> int:\\n \\n n = len(g)\\n \\n grid = [[0]*(n*3) for j in range(n*3)]\\n \\n for i in range(n):\\n \\n for j in range(n):\\n \\n if g[i][j] == '/':\\n \\n grid[i*3][j*3+2] = 1\\n \\n grid[i*3+1][j*3+1] = 1\\n \\n grid[i*3+2][j*3] = 1\\n \\n elif g[i][j] == '\\\\\\\\\\\\\\\\':\\n \\n grid[i*3][j*3] = 1\\n \\n grid[i*3+1][j*3+1] = 1\\n \\n grid[i*3+2][j*3+2] = 1\\n \\n \\n def dfs(i,j):\\n \\n grid[i][j] = 1\\n \\n for r in [(i+1,j), (i,j+1), (i-1,j), (i,j-1)]:\\n \\n xx,yy = r\\n \\n if xx < 0 or yy < 0 or xx >= len(grid) or yy >= len(grid[0]) or grid[xx][yy] == 1:\\n continue\\n \\n dfs(xx,yy)\\n \\n \\n count = 0\\n \\n for i in range(n*3):\\n for j in range(n*3):\\n \\n if grid[i][j] == 0:\\n \\n dfs(i,j)\\n \\n count += 1\\n \\n return count\",\n \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n if not grid:\\n return 0\\n \\n rows, cols = len(grid), len(grid[0])\\n new_grid = [[0] * 3 * cols for _ in range(3 * rows)]\\n visited = [[False] * 3 * cols for _ in range(3 * rows)]\\n \\n for i in range(rows):\\n line = grid[i]\\n \\n for j in range(len(line)):\\n if line[j] == '/':\\n new_grid[3 * i][3 * j + 2] = 1\\n new_grid[3 * i + 1][3 * j + 1] = 1\\n new_grid[3 * i + 2][3 * j] = 1\\n elif line[j] == '\\\\\\\\\\\\\\\\':\\n new_grid[3 * i][3 * j] = 1\\n new_grid[3 * i + 1][3 * j + 1] = 1\\n new_grid[3 * i + 2][3 * j + 2] = 1\\n \\n def dfs(i, j):\\n if i < 0 or j < 0 or i >= 3 * rows or j >= 3 * cols or new_grid[i][j] == 1 or visited[i][j]:\\n return\\n \\n visited[i][j] = True\\n \\n dfs(i, j + 1)\\n dfs(i + 1, j)\\n dfs(i, j - 1)\\n dfs(i - 1, j)\\n \\n count = 0\\n \\n for i in range(3 * rows):\\n for j in range(3 * cols):\\n if not visited[i][j] and new_grid[i][j] == 0:\\n dfs(i, j)\\n count += 1\\n \\n return count\",\n \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n n = len(grid)\\n m, ans = [[[0, 0, 0, 0] for j in range(n)] for i in range(n)], 0\\n \\n def dfs(i, j, k):\\n if 0 <= i < n and 0 <= j < n and not m[i][j][k]:\\n if grid[i][j] == '/':\\n if 1 <= k <= 2:\\n m[i][j][1] = m[i][j][2] = ans\\n dfs(i, j+1, 3)\\n dfs(i+1, j, 0)\\n else:\\n m[i][j][0] = m[i][j][3] = ans \\n dfs(i-1, j, 2)\\n dfs(i, j-1, 1)\\n elif grid[i][j] == '\\\\\\\\\\\\\\\\':\\n if k <= 1:\\n m[i][j][0] = m[i][j][1] = ans\\n dfs(i-1, j, 2)\\n dfs(i, j+1, 3)\\n else:\\n m[i][j][2] = m[i][j][3] = ans \\n dfs(i+1, j, 0)\\n dfs(i, j-1, 1)\\n else:\\n m[i][j][0] = m[i][j][1] = m[i][j][2] = m[i][j][3] = ans \\n dfs(i-1, j, 2)\\n dfs(i, j-1, 1)\\n dfs(i+1, j, 0)\\n dfs(i, j+1, 3)\\n \\n \\n for i in range(n):\\n for j in range(n):\\n for k in range(4):\\n if not m[i][j][k]:\\n ans += 1\\n dfs(i, j, k)\\n \\n return ans \\n\",\n \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n if len(grid) == 0 or len(grid[0]) == 0:\\n return 0\\n \\n roots = {}\\n \\n def find(x):\\n roots.setdefault(x, x)\\n \\n if roots[x] != x:\\n roots[x] = find(roots[x])\\n \\n return roots[x]\\n \\n def union(x, y):\\n roots[find(x)] = find(y)\\n \\n # k=0 top\\n # k=1 right\\n # k=2 bottom\\n # k=3 left\\n \\n for i in range(len(grid)):\\n for j in range(len(grid[0])):\\n if i > 0:\\n union((i-1, j, 2), (i, j, 0))\\n \\n if j > 0:\\n union((i, j-1, 1), (i, j, 3))\\n \\n if grid[i][j] != '/':\\n union((i, j, 0), (i, j, 1))\\n union((i, j, 2), (i, j, 3))\\n \\n if grid[i][j] != '\\\\\\\\\\\\\\\\':\\n union((i, j, 0), (i, j, 3))\\n union((i, j, 1), (i, j, 2))\\n \\n return len(set(find(x) for x in list(roots.keys())))\\n\",\n \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n \\n N = len(grid)\\n \\n matrix = grid\\n \\n parent = list(range(N * N * 4))\\n # print(parent)\\n def find(x):\\n depth = 0\\n while parent[x] != x:\\n x = parent[x]\\n depth += 1\\n return x, depth\\n \\n def union(x, y):\\n # print(x, y)\\n (rx, dx), (ry, dy) = find(x), find(y)\\n if dx < dy:\\n parent[rx] = ry\\n else:\\n parent[ry] = rx\\n \\n def isValid(i, j):\\n if i >= N or i < 0 or j >= N or j < 0:\\n return False\\n return True\\n\\n for i in range(N):\\n for j in range(N):\\n idtop = (i * N + j) * 4\\n if matrix[i][j] == '/':\\n union(idtop + 1, idtop + 2)\\n union(idtop, idtop + 3)\\n elif matrix[i][j] == '\\\\\\\\\\\\\\\\':\\n union(idtop, idtop + 1)\\n union(idtop + 2, idtop + 3) \\n else:\\n union(idtop, idtop + 1)\\n union(idtop, idtop + 2)\\n union(idtop, idtop + 3)\\n if isValid(i-1, j):\\n union(idtop, 4 *((i-1) * N + j) + 2)\\n if isValid(i, j-1):\\n union(idtop + 3, 4 * (i * N + j - 1) + 1)\\n return sum(find(x)[0] == x for x in range(4 * N * N))\\n \\n\",\n \"class Solution:\\n def regionsBySlashes(self, grid: List[str]) -> int:\\n \\n root = {}\\n \\n def find(x):\\n root.setdefault(x, x)\\n if root[x] != x: # not find( root[x] )\\n root[x] = find( root[x] )\\n return root[x]\\n \\n def union(x, y):\\n rx, ry = find(x), find(y)\\n \\n if rx != ry:\\n root[ry] = find(rx)\\n \\n for i in range(len(grid)):\\n for j in range(len(grid)):\\n if i:\\n union( (i-1,j, 2), (i,j, 0) )\\n if j:\\n union( (i,j-1, 1), (i,j, 3) )\\n if grid[i][j] == '/':\\n union( (i,j, 0), (i,j, 3) )\\n union( (i,j, 1), (i,j, 2) )\\n elif grid[i][j] == '\\\\\\\\\\\\\\\\':\\n union( (i,j, 0), (i,j, 1) )\\n union( (i,j, 2), (i,j, 3) )\\n else:\\n union( (i,j, 0), (i,j, 1) )\\n union( (i,j, 0), (i,j, 2) )\\n union( (i,j, 0), (i,j, 3) )\\n \\n return len( set( map(find, list(root.keys())) ) )\\n \\n \\n\",\n \"from itertools import chain\\nclass Solution:\\n def regionsBySlashes(self, grid):\\n grid = convert_grid(grid)\\n return len([destroy_island(x, y, grid) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v == 0])\\n\\ndef destroy_island(x, y, grid):\\n grid[y][x] = 1\\n for c in search(x, y, grid):\\n destroy_island(c[0], c[1], grid)\\n\\ndef search(x, y, grid):\\n in_bounds = lambda c:0 <= c[1] < len(grid) and 0 <= c[0] < len(grid[c[1]])\\n check_orthog = lambda c:in_bounds(c) and grid[c[1]][c[0]] == 0\\n def check_diag(c):\\n if not in_bounds(c) or grid[c[1]][c[0]] != 0: return False\\n d_x, d_y = c[0] - x, c[1] - y\\n sep = '\\\\\\\\\\\\\\\\' if ((d_x > 0 > d_y) or (d_x < 0 < d_y)) else '/'\\n return grid[y + d_y][x] != sep or grid[y][x + d_x] != sep\\n yield from chain(filter(check_orthog, ((x-1, y), (x+1, y), (x, y-1), (x, y+1))),\\n filter(check_diag, ((x + 1, y + 1), (x + 1, y - 1), (x - 1, y + 1), (x - 1, y - 1))))\\n\\ndef convert_grid(grid):\\n new_grid = [[0] * len(grid[0]) * 2 for _ in range(len(grid) * 2)]\\n for (x, y, v) in ((x, y, v) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v in '\\\\\\\\\\\\\\\\/'):\\n new_grid[y * 2 + 0][x * 2 + (1 if v == '/' else 0)] = v\\n new_grid[y * 2 + 1][x * 2 + (0 if v == '/' else 1)] = v\\n return new_grid\",\n \"from itertools import chain\\nclass Solution:\\n def regionsBySlashes(self, grid):\\n grid = convert_grid(grid)\\n return len([destroy_island(x, y, grid) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v == 0])\\n\\ndef destroy_island(x, y, grid):\\n grid[y][x] = 1\\n for c in search(x, y, grid):\\n destroy_island(c[0], c[1], grid)\\n\\ndef search(x, y, grid):\\n in_bounds = lambda c:0 <= c[1] < len(grid) and 0 <= c[0] < len(grid[c[1]])\\n check_orthog = lambda c:in_bounds(c) and grid[c[1]][c[0]] == 0\\n def check_diag(c):\\n if not in_bounds(c) or grid[c[1]][c[0]] != 0: return False\\n d_x, d_y = c[0] - x, c[1] - y\\n sep = '\\\\\\\\\\\\\\\\' if ((d_x > 0 > d_y) or (d_x < 0 < d_y)) else '/'\\n return not (grid[y + d_y][x] == sep and grid[y][x + d_x] == sep)\\n yield from chain(filter(check_orthog, ((x-1, y), (x+1, y), (x, y-1), (x, y+1))),\\n filter(check_diag, ((x + 1, y + 1), (x + 1, y - 1), (x - 1, y + 1), (x - 1, y - 1))))\\n\\ndef convert_grid(grid):\\n new_grid = [[0] * len(grid[0]) * 2 for _ in range(len(grid) * 2)]\\n for (x, y, v) in ((x, y, v) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v in '\\\\\\\\\\\\\\\\/'):\\n new_grid[y * 2 + 0][x * 2 + (1 if v == '/' else 0)] = v\\n new_grid[y * 2 + 1][x * 2 + (0 if v == '/' else 1)] = v\\n return new_grid\",\n \"from itertools import chain\\nclass Solution:\\n def regionsBySlashes(self, grid):\\n grid = convert_grid(grid)\\n print(*(list(map(str, x)) for x in grid), sep='\\\\\\n')\\n return len([destroy_island(x, y, grid) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v == 0])\\n\\ndef destroy_island(x, y, grid):\\n grid[y][x] = 1\\n for c in search(x, y, grid):\\n destroy_island(c[0], c[1], grid)\\n\\ndef search(x, y, grid):\\n in_bounds = lambda c:0 <= c[1] < len(grid) and 0 <= c[0] < len(grid[c[1]])\\n check_orthog = lambda c:in_bounds(c) and grid[c[1]][c[0]] == 0\\n def check_diag(c):\\n if not in_bounds(c) or grid[c[1]][c[0]] != 0: return False\\n d_x, d_y = c[0] - x, c[1] - y\\n sep = '\\\\\\\\\\\\\\\\' if ((d_x > 0 > d_y) or (d_x < 0 < d_y)) else '/'\\n return grid[y + d_y][x] != sep or grid[y][x + d_x] != sep\\n yield from chain(filter(check_orthog, ((x-1, y), (x+1, y), (x, y-1), (x, y+1))),\\n filter(check_diag, ((x + 1, y + 1), (x + 1, y - 1), (x - 1, y + 1), (x - 1, y - 1))))\\n\\ndef convert_grid(grid):\\n new_grid = [[0] * len(grid[0]) * 2 for _ in range(len(grid) * 2)]\\n for (x, y, v) in ((x, y, v) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v in '\\\\\\\\\\\\\\\\/'):\\n new_grid[y * 2 + 0][x * 2 + (1 if v == '/' else 0)] = v\\n new_grid[y * 2 + 1][x * 2 + (0 if v == '/' else 1)] = v\\n return new_grid\"\n]","isConversational":false},"n_sols":{"kind":"number","value":30,"string":"30"},"non_interactive_idx":{"kind":"list like","value":[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],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[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],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":97,"cells":{"problem_id":{"kind":"number","value":234,"string":"234"},"question":{"kind":"string","value":"Given a string S of '(' and ')' parentheses, we add the minimum number of parentheses ( '(' or ')', and in any positions ) so that the resulting parentheses string is valid.\nFormally, a parentheses string is valid if and only if:\n\nIt is the empty string, or\nIt can be written as AB (A concatenated with B), where A and B are valid strings, or\nIt can be written as (A), where A is a valid string.\n\nGiven a parentheses string, return the minimum number of parentheses we must add to make the resulting string valid.\n \nExample 1:\nInput: \"())\"\nOutput: 1\n\n\nExample 2:\nInput: \"(((\"\nOutput: 3\n\n\nExample 3:\nInput: \"()\"\nOutput: 0\n\n\nExample 4:\nInput: \"()))((\"\nOutput: 4\n \n\n\n\nNote:\n\nS.length <= 1000\nS only consists of '(' and ')' characters."},"solutions":{"kind":"string","value":"[\"class Solution:\\n def minAddToMakeValid(self, S: str) -> int:\\n if not S:\\n return 0\\n \\n stack = []\\n \\n add = 0\\n for c in S:\\n if c == '(':\\n stack.append(c)\\n elif c == ')':\\n if stack:\\n stack.pop()\\n else:\\n add += 1\\n \\n add += len(stack)\\n \\n return add\", \"class Solution:\\n def minAddToMakeValid(self, S: str) -> int:\\n res,need=0,0\\n for i in range(len(S)):\\n if S[i]=='(':\\n need+=1\\n if S[i]==')':\\n need-=1\\n if need==-1:\\n need=0\\n res+=1\\n return res+need\\n\", \"class Solution:\\n def minAddToMakeValid(self, S: str) -> int:\\n if not S:\\n return 0\\n N = len(S)\\n open_brackets = [0]*N\\n close_brackets = [0]*N\\n \\n ans = 0\\n for i, c in enumerate(S):\\n if i>0:\\n open_brackets[i] = open_brackets[i-1]\\n close_brackets[i] = close_brackets[i-1]\\n if c == '(':\\n open_brackets[i] += 1\\n elif c == ')':\\n close_brackets[i] += 1\\n \\n if close_brackets[i] > open_brackets[i]:\\n diff = close_brackets[i]-open_brackets[i]\\n ans += diff\\n open_brackets[i] += diff\\n \\n return ans+open_brackets[-1]-close_brackets[-1]\\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"minAddToMakeValid\", \"inputs\": [[\"\\\"())\\\"\"]], \"outputs\": [1]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/minimum-add-to-make-parentheses-valid/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def minAddToMakeValid(self, S: str) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def minAddToMakeValid(self, S: str) -> int:\n if not S:\n return 0\n \n stack = []\n \n add = 0\n for c in S:\n if c == '(':\n stack.append(c)\n elif c == ')':\n if stack:\n stack.pop()\n else:\n add += 1\n \n add += len(stack)\n \n return add","class Solution:\n def minAddToMakeValid(self, S: str) -> int:\n res,need=0,0\n for i in range(len(S)):\n if S[i]=='(':\n need+=1\n if S[i]==')':\n need-=1\n if need==-1:\n need=0\n res+=1\n return res+need\n","class Solution:\n def minAddToMakeValid(self, S: str) -> int:\n if not S:\n return 0\n N = len(S)\n open_brackets = [0]*N\n close_brackets = [0]*N\n \n ans = 0\n for i, c in enumerate(S):\n if i>0:\n open_brackets[i] = open_brackets[i-1]\n close_brackets[i] = close_brackets[i-1]\n if c == '(':\n open_brackets[i] += 1\n elif c == ')':\n close_brackets[i] += 1\n \n if close_brackets[i] > open_brackets[i]:\n diff = close_brackets[i]-open_brackets[i]\n ans += diff\n open_brackets[i] += diff\n \n return ans+open_brackets[-1]-close_brackets[-1]\n"],"string":"[\n \"class Solution:\\n def minAddToMakeValid(self, S: str) -> int:\\n if not S:\\n return 0\\n \\n stack = []\\n \\n add = 0\\n for c in S:\\n if c == '(':\\n stack.append(c)\\n elif c == ')':\\n if stack:\\n stack.pop()\\n else:\\n add += 1\\n \\n add += len(stack)\\n \\n return add\",\n \"class Solution:\\n def minAddToMakeValid(self, S: str) -> int:\\n res,need=0,0\\n for i in range(len(S)):\\n if S[i]=='(':\\n need+=1\\n if S[i]==')':\\n need-=1\\n if need==-1:\\n need=0\\n res+=1\\n return res+need\\n\",\n \"class Solution:\\n def minAddToMakeValid(self, S: str) -> int:\\n if not S:\\n return 0\\n N = len(S)\\n open_brackets = [0]*N\\n close_brackets = [0]*N\\n \\n ans = 0\\n for i, c in enumerate(S):\\n if i>0:\\n open_brackets[i] = open_brackets[i-1]\\n close_brackets[i] = close_brackets[i-1]\\n if c == '(':\\n open_brackets[i] += 1\\n elif c == ')':\\n close_brackets[i] += 1\\n \\n if close_brackets[i] > open_brackets[i]:\\n diff = close_brackets[i]-open_brackets[i]\\n ans += diff\\n open_brackets[i] += diff\\n \\n return ans+open_brackets[-1]-close_brackets[-1]\\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":3,"string":"3"},"non_interactive_idx":{"kind":"list like","value":[0,1,2],"string":"[\n 0,\n 1,\n 2\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null],"string":"[\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":98,"cells":{"problem_id":{"kind":"number","value":236,"string":"236"},"question":{"kind":"string","value":"A string of '0's and '1's is monotone increasing if it consists of some number of '0's (possibly 0), followed by some number of '1's (also possibly 0.)\nWe are given a string S of '0's and '1's, and we may flip any '0' to a '1' or a '1' to a '0'.\nReturn the minimum number of flips to make S monotone increasing.\n \n\nExample 1:\nInput: \"00110\"\nOutput: 1\nExplanation: We flip the last digit to get 00111.\n\n\nExample 2:\nInput: \"010110\"\nOutput: 2\nExplanation: We flip to get 011111, or alternatively 000111.\n\n\nExample 3:\nInput: \"00011000\"\nOutput: 2\nExplanation: We flip to get 00000000.\n\n \nNote:\n\n1 <= S.length <= 20000\nS only consists of '0' and '1' characters."},"solutions":{"kind":"string","value":"[\"class Solution:\\n def minFlipsMonoIncr(self, S: str) -> int:\\n onesSoFar = 0\\n partial = 0\\n \\n for n in S:\\n if n == '0':\\n partial = min(onesSoFar, partial+1) \\n else:\\n onesSoFar += 1\\n \\n return partial\\n\", \"class Solution:\\n def minFlipsMonoIncr(self, S: str) -> int:\\n \\n if not S:\\n return 0\\n \\n n = len(S)\\n if n == 1:\\n return 0\\n \\n total_1s = 0\\n total_0s = 0\\n for char in S:\\n if char == '1':\\n total_1s += 1\\n else:\\n total_0s += 1\\n \\n if total_1s == 0 or total_0s == 0:\\n return 0\\n \\n prefix_sum = 0\\n ans = float('inf')\\n for i in range(n):\\n prefix_sum += 1 if S[i] == '1' else 0\\n ans = min(ans, prefix_sum + ((n - i - 1) - (total_1s - prefix_sum)))\\n return min(ans, total_0s, total_1s)\", \"class Solution:\\n def minFlipsMonoIncr(self, S: str) -> int:\\n at0 = 0\\n at1 = 0\\n \\n num0 = 0\\n for a in S:\\n if a=='0':\\n at1 = min(at1,at0) + 1\\n else:\\n at1 = min(at1,at0)\\n at0 += 1\\n \\n #print(at0,at1)\\n return min(at1,at0)\", \"class Solution:\\n def minFlipsMonoIncr(self, S: str) -> int:\\n str_len = len(S)\\n count_arr = [[0,0] for x in range(str_len)]\\n one_start_idx = -1\\n for i in range(len(S)):\\n if S[i]=='0':\\n if i==0:\\n count_arr[i][0] +=1\\n count_arr[i][1] = 0\\n else:\\n count_arr[i][0] = count_arr[i-1][0]+1\\n count_arr[i][1] = count_arr[i-1][1]\\n else:\\n if i==0:\\n count_arr[i][1] +=1\\n else:\\n count_arr[i][1] = count_arr[i-1][1]+1\\n count_arr[i][0] = count_arr[i-1][0]\\n \\n if one_start_idx == -1:\\n one_start_idx = i\\n \\n total_flips = []\\n total_flips.append(min(count_arr[str_len-1][0], count_arr[str_len-1][1]))\\n \\n for i in range(one_start_idx, str_len):\\n if i==0:\\n total_flips.append(count_arr[str_len-1][0]-count_arr[i][0])\\n elif i==str_len-1: \\n total_flips.append(count_arr[str_len-1][0])\\n \\n else:\\n total_flips.append(count_arr[i-1][1]+count_arr[str_len-1][0]-count_arr[i][0])\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n return min(total_flips) \\n \\n \\n\", \"class Solution:\\n def minFlipsMonoIncr(self, S: str) -> int:\\n dp = 0\\n ones = 0\\n\\n for c in S:\\n if c == '0':\\n # \\u7d50\\u5c3e\\u70ba 1 \\u7684\\u7ffb\\u6cd5\\u7684\\u6700\\u5c0f\\u6b65\\u9a5f\\u6578 = 1 + dp[i-1]\\n # \\u7d50\\u5c3e\\u70ba 0 \\u7684\\u7ffb\\u6cd5\\u7684\\u6700\\u5c0f\\u6b65\\u9a5f\\u6578 = \\u524d\\u9762 1 \\u7684\\u500b\\u6578\\n # \\u6240\\u4ee5 dp[i] = min(1 + dp[i-1], # of 1s)\\n dp = min(1 + dp, ones)\\n else:\\n # \\u7d50\\u5c3e\\u70ba 1 \\u7684\\u7ffb\\u6cd5\\u7684\\u6700\\u5c0f\\u6b65\\u9a5f\\u6578 = dp[i-1]\\n # \\u7d50\\u5c3e\\u70ba 0 \\u7684\\u7ffb\\u6cd5\\u7684\\u6700\\u5c0f\\u6b65\\u9a5f\\u6578 = 1 + \\u524d\\u9762 1 \\u7684\\u500b\\u6578\\n # \\u6240\\u4ee5 dp[i] = min(dp[i-1], 1 + # of 1s)\\n dp = min(dp, 1 + ones)\\n ones += 1\\n\\n return dp\\n\", \"class Solution:\\n def minFlipsMonoIncr(self, S: str) -> int:\\n # n = len(S)\\n # zero = [0 for i in range(n)]\\n # one = [0 for i in range(n)]\\n # zero[0] = int(S[0])\\n # one[0] = 1 - zero[0]\\n # for i in range(1, n):\\n # if S[i] == '1':\\n # one[i] = min(one[i-1], zero[i-1])\\n # zero[i] = zero[i-1] + 1\\n # elif S[i] == '0':\\n # one[i] = min(one[i-1], zero[i-1]) + 1\\n # zero[i] = zero[i-1]\\n # return min(zero[n-1], one[n-1])\\n \\n flip, one = 0, 0\\n for i in S:\\n if i == '1':\\n one += 1\\n else:\\n flip += 1\\n flip = min(one, flip)\\n return flip\", \"class Solution:\\n def minFlipsMonoIncr(self, S: str) -> int:\\n \\n n, prefix, total, res = len(S), 0, S.count('1'), sys.maxsize\\n for i in range(n + 1):\\n res = min(res, prefix + len(S) - i - total + prefix)\\n if i < n: prefix += 1 if S[i] == '1' else 0\\n return res\\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"minFlipsMonoIncr\", \"inputs\": [[\"\\\"00110\\\"\"]], \"outputs\": [2]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/flip-string-to-monotone-increasing/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def minFlipsMonoIncr(self, S: str) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def minFlipsMonoIncr(self, S: str) -> int:\n onesSoFar = 0\n partial = 0\n \n for n in S:\n if n == '0':\n partial = min(onesSoFar, partial+1) \n else:\n onesSoFar += 1\n \n return partial\n","class Solution:\n def minFlipsMonoIncr(self, S: str) -> int:\n \n if not S:\n return 0\n \n n = len(S)\n if n == 1:\n return 0\n \n total_1s = 0\n total_0s = 0\n for char in S:\n if char == '1':\n total_1s += 1\n else:\n total_0s += 1\n \n if total_1s == 0 or total_0s == 0:\n return 0\n \n prefix_sum = 0\n ans = float('inf')\n for i in range(n):\n prefix_sum += 1 if S[i] == '1' else 0\n ans = min(ans, prefix_sum + ((n - i - 1) - (total_1s - prefix_sum)))\n return min(ans, total_0s, total_1s)","class Solution:\n def minFlipsMonoIncr(self, S: str) -> int:\n at0 = 0\n at1 = 0\n \n num0 = 0\n for a in S:\n if a=='0':\n at1 = min(at1,at0) + 1\n else:\n at1 = min(at1,at0)\n at0 += 1\n \n #print(at0,at1)\n return min(at1,at0)","class Solution:\n def minFlipsMonoIncr(self, S: str) -> int:\n str_len = len(S)\n count_arr = [[0,0] for x in range(str_len)]\n one_start_idx = -1\n for i in range(len(S)):\n if S[i]=='0':\n if i==0:\n count_arr[i][0] +=1\n count_arr[i][1] = 0\n else:\n count_arr[i][0] = count_arr[i-1][0]+1\n count_arr[i][1] = count_arr[i-1][1]\n else:\n if i==0:\n count_arr[i][1] +=1\n else:\n count_arr[i][1] = count_arr[i-1][1]+1\n count_arr[i][0] = count_arr[i-1][0]\n \n if one_start_idx == -1:\n one_start_idx = i\n \n total_flips = []\n total_flips.append(min(count_arr[str_len-1][0], count_arr[str_len-1][1]))\n \n for i in range(one_start_idx, str_len):\n if i==0:\n total_flips.append(count_arr[str_len-1][0]-count_arr[i][0])\n elif i==str_len-1: \n total_flips.append(count_arr[str_len-1][0])\n \n else:\n total_flips.append(count_arr[i-1][1]+count_arr[str_len-1][0]-count_arr[i][0])\n \n \n \n \n \n \n \n \n \n return min(total_flips) \n \n \n","class Solution:\n def minFlipsMonoIncr(self, S: str) -> int:\n dp = 0\n ones = 0\n\n for c in S:\n if c == '0':\n # 結尾為 1 的翻法的最小步驟數 = 1 + dp[i-1]\n # 結尾為 0 的翻法的最小步驟數 = 前面 1 的個數\n # 所以 dp[i] = min(1 + dp[i-1], # of 1s)\n dp = min(1 + dp, ones)\n else:\n # 結尾為 1 的翻法的最小步驟數 = dp[i-1]\n # 結尾為 0 的翻法的最小步驟數 = 1 + 前面 1 的個數\n # 所以 dp[i] = min(dp[i-1], 1 + # of 1s)\n dp = min(dp, 1 + ones)\n ones += 1\n\n return dp\n","class Solution:\n def minFlipsMonoIncr(self, S: str) -> int:\n # n = len(S)\n # zero = [0 for i in range(n)]\n # one = [0 for i in range(n)]\n # zero[0] = int(S[0])\n # one[0] = 1 - zero[0]\n # for i in range(1, n):\n # if S[i] == '1':\n # one[i] = min(one[i-1], zero[i-1])\n # zero[i] = zero[i-1] + 1\n # elif S[i] == '0':\n # one[i] = min(one[i-1], zero[i-1]) + 1\n # zero[i] = zero[i-1]\n # return min(zero[n-1], one[n-1])\n \n flip, one = 0, 0\n for i in S:\n if i == '1':\n one += 1\n else:\n flip += 1\n flip = min(one, flip)\n return flip","class Solution:\n def minFlipsMonoIncr(self, S: str) -> int:\n \n n, prefix, total, res = len(S), 0, S.count('1'), sys.maxsize\n for i in range(n + 1):\n res = min(res, prefix + len(S) - i - total + prefix)\n if i < n: prefix += 1 if S[i] == '1' else 0\n return res\n"],"string":"[\n \"class Solution:\\n def minFlipsMonoIncr(self, S: str) -> int:\\n onesSoFar = 0\\n partial = 0\\n \\n for n in S:\\n if n == '0':\\n partial = min(onesSoFar, partial+1) \\n else:\\n onesSoFar += 1\\n \\n return partial\\n\",\n \"class Solution:\\n def minFlipsMonoIncr(self, S: str) -> int:\\n \\n if not S:\\n return 0\\n \\n n = len(S)\\n if n == 1:\\n return 0\\n \\n total_1s = 0\\n total_0s = 0\\n for char in S:\\n if char == '1':\\n total_1s += 1\\n else:\\n total_0s += 1\\n \\n if total_1s == 0 or total_0s == 0:\\n return 0\\n \\n prefix_sum = 0\\n ans = float('inf')\\n for i in range(n):\\n prefix_sum += 1 if S[i] == '1' else 0\\n ans = min(ans, prefix_sum + ((n - i - 1) - (total_1s - prefix_sum)))\\n return min(ans, total_0s, total_1s)\",\n \"class Solution:\\n def minFlipsMonoIncr(self, S: str) -> int:\\n at0 = 0\\n at1 = 0\\n \\n num0 = 0\\n for a in S:\\n if a=='0':\\n at1 = min(at1,at0) + 1\\n else:\\n at1 = min(at1,at0)\\n at0 += 1\\n \\n #print(at0,at1)\\n return min(at1,at0)\",\n \"class Solution:\\n def minFlipsMonoIncr(self, S: str) -> int:\\n str_len = len(S)\\n count_arr = [[0,0] for x in range(str_len)]\\n one_start_idx = -1\\n for i in range(len(S)):\\n if S[i]=='0':\\n if i==0:\\n count_arr[i][0] +=1\\n count_arr[i][1] = 0\\n else:\\n count_arr[i][0] = count_arr[i-1][0]+1\\n count_arr[i][1] = count_arr[i-1][1]\\n else:\\n if i==0:\\n count_arr[i][1] +=1\\n else:\\n count_arr[i][1] = count_arr[i-1][1]+1\\n count_arr[i][0] = count_arr[i-1][0]\\n \\n if one_start_idx == -1:\\n one_start_idx = i\\n \\n total_flips = []\\n total_flips.append(min(count_arr[str_len-1][0], count_arr[str_len-1][1]))\\n \\n for i in range(one_start_idx, str_len):\\n if i==0:\\n total_flips.append(count_arr[str_len-1][0]-count_arr[i][0])\\n elif i==str_len-1: \\n total_flips.append(count_arr[str_len-1][0])\\n \\n else:\\n total_flips.append(count_arr[i-1][1]+count_arr[str_len-1][0]-count_arr[i][0])\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n return min(total_flips) \\n \\n \\n\",\n \"class Solution:\\n def minFlipsMonoIncr(self, S: str) -> int:\\n dp = 0\\n ones = 0\\n\\n for c in S:\\n if c == '0':\\n # 結尾為 1 的翻法的最小步驟數 = 1 + dp[i-1]\\n # 結尾為 0 的翻法的最小步驟數 = 前面 1 的個數\\n # 所以 dp[i] = min(1 + dp[i-1], # of 1s)\\n dp = min(1 + dp, ones)\\n else:\\n # 結尾為 1 的翻法的最小步驟數 = dp[i-1]\\n # 結尾為 0 的翻法的最小步驟數 = 1 + 前面 1 的個數\\n # 所以 dp[i] = min(dp[i-1], 1 + # of 1s)\\n dp = min(dp, 1 + ones)\\n ones += 1\\n\\n return dp\\n\",\n \"class Solution:\\n def minFlipsMonoIncr(self, S: str) -> int:\\n # n = len(S)\\n # zero = [0 for i in range(n)]\\n # one = [0 for i in range(n)]\\n # zero[0] = int(S[0])\\n # one[0] = 1 - zero[0]\\n # for i in range(1, n):\\n # if S[i] == '1':\\n # one[i] = min(one[i-1], zero[i-1])\\n # zero[i] = zero[i-1] + 1\\n # elif S[i] == '0':\\n # one[i] = min(one[i-1], zero[i-1]) + 1\\n # zero[i] = zero[i-1]\\n # return min(zero[n-1], one[n-1])\\n \\n flip, one = 0, 0\\n for i in S:\\n if i == '1':\\n one += 1\\n else:\\n flip += 1\\n flip = min(one, flip)\\n return flip\",\n \"class Solution:\\n def minFlipsMonoIncr(self, S: str) -> int:\\n \\n n, prefix, total, res = len(S), 0, S.count('1'), sys.maxsize\\n for i in range(n + 1):\\n res = min(res, prefix + len(S) - i - total + prefix)\\n if i < n: prefix += 1 if S[i] == '1' else 0\\n return res\\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":7,"string":"7"},"non_interactive_idx":{"kind":"list like","value":[0,1,2,3,4,5,6],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[null,null,null,null,null,null,null],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}},{"rowIdx":99,"cells":{"problem_id":{"kind":"number","value":237,"string":"237"},"question":{"kind":"string","value":"In an array A of 0s and 1s, how many non-empty subarrays have sum S?\n \nExample 1:\nInput: A = [1,0,1,0,1], S = 2\nOutput: 4\nExplanation: \nThe 4 subarrays are bolded below:\n[1,0,1,0,1]\n[1,0,1,0,1]\n[1,0,1,0,1]\n[1,0,1,0,1]\n\n \nNote:\n\nA.length <= 30000\n0 <= S <= A.length\nA[i] is either 0 or 1."},"solutions":{"kind":"string","value":"[\"class Solution:\\n def numSubarraysWithSum(self, pl, S):\\n ans = 0\\n \\n if(S == 0):\\n c = 0\\n for i in range(len(pl)):\\n if(pl[i] == 0):\\n c+=1\\n else:\\n c = 0\\n ans +=c\\n return ans;\\n \\n \\n \\n \\n \\n \\n l = [-1]\\n \\n for i in range(len(pl)):\\n if(pl[i] == 1 ):\\n l.append(i)\\n \\n l.append(len(pl))\\n \\n ans = 0\\n \\n for i in range(1,len(l)-S):\\n \\n ans += (l[i]-l[i-1])*(l[i+S] - l[i+S-1])\\n \\n return ans\\n \\n \\n \\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n size = len(A)\\n l, r, total, cnt = [0] * 4\\n if S == 0:\\n l = 1\\n for x in A:\\n if x == 0:\\n cnt += l\\n l += 1\\n else:\\n l = 1\\n return cnt\\n while r < size and total < S:\\n total += A[r]\\n r += 1\\n if r == size and total < S:\\n return 0\\n while r < size:\\n cnt1, cnt2 = 1, 1\\n while l < r and A[l] == 0:\\n l += 1\\n cnt1 += 1\\n while r < size and A[r] == 0:\\n r += 1\\n cnt2 += 1\\n cnt += cnt1 * cnt2\\n l += 1\\n r += 1\\n if A[-1] == 1:\\n cnt += 1\\n while l < size and A[l] == 0:\\n cnt += 1\\n l += 1\\n return cnt \\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n P = [0]\\n \\n for x in A:\\n P.append(P[-1] + x)\\n \\n count = collections.Counter()\\n \\n \\n ans = 0\\n \\n for x in P:\\n ans += count[x]\\n count[x + S] += 1\\n \\n \\n return ans\", \"class Solution(object):\\n def numSubarraysWithSum(self, A, S):\\n P = [0]\\n for x in A: P.append(P[-1] + x)\\n count = collections.Counter()\\n\\n ans = 0\\n for x in P:\\n ans += count[x]\\n count[x + S] += 1\\n\\n return ans\\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n n = len(A)\\n suma = [0]*(n+1)\\n \\n for i in range(1,n+1):\\n suma[i] = suma[i-1]+A[i-1]\\n \\n left = 0\\n res =0\\n m = collections.defaultdict(lambda:0)\\n m[0]=1\\n for i in range(n):\\n if suma[i+1]-S in m:\\n res += m[suma[i+1]-S]\\n \\n m[suma[i+1]] += 1\\n \\n return res\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n def atMostK(A, S):\\n if S < 0:\\n return 0\\n i = res = 0\\n\\n for j in range(len(A)):\\n S -= A[j]\\n while S < 0:\\n S += A[i]\\n i += 1\\n res += j - i + 1 #\\u6240\\u4ee5\\u5c0f\\u4e8e\\u7684\\u4e5f\\u662f\\u7b97\\u4e86\\u7684\\n return res\\n return atMostK(A, S) - atMostK(A, S - 1)\\n \\n \\n# \\u7531\\u4e8e\\u6570\\u7ec4\\u4ec5\\u5305\\u542b 0 \\u548c 1\\uff0c \\u90a3\\u4e48\\u95ee\\u9898\\u53ef\\u4ee5\\u8f6c\\u5316\\u4e3a\\u7ed9\\u5b9a\\u4e00\\u4e2a0\\uff0c1\\u6570\\u7ec4\\uff0c\\u4f60\\u53ef\\u4ee5\\u9009\\u62e9S\\u4e2a1\\u548c\\u4efb\\u610f\\u4e2a0\\uff0c\\u4f60\\u53ef\\u4ee5\\u6709\\u591a\\u5c11\\u9009\\u62e9\\uff1f\\n\\n# \\u800c\\u4e0a\\u8ff0\\u95ee\\u9898\\u53ef\\u4ee5\\u8f6c\\u5316\\u4e3a\\u7ed9\\u5b9a\\u4e00\\u4e2a0\\uff0c1\\u6570\\u7ec4\\uff0c\\u4f60\\u53ef\\u4ee5\\u9009\\u62e9\\u6700\\u591aS\\u4e2a1\\u548c\\u4efb\\u610f\\u4e2a0\\uff0c\\u4f60\\u7684\\u9009\\u62e9\\u6570\\u51cf\\u53bb \\u7ed9\\u5b9a\\u4e00\\u4e2a0\\uff0c1\\u6570\\u7ec4\\uff0c\\u4f60\\u53ef\\u4ee5\\u9009\\u62e9\\u6700\\u591aS - 1\\u4e2a1\\u548c\\u4efb\\u610f\\u4e2a0\\uff0c\\u4f60\\u7684\\u9009\\u62e9\\u6570\\u3002\\n\\n# \\u6700\\u591axxxx \\u8fd9\\u79cd\\u53ef\\u4ee5\\u4f7f\\u7528\\u53ef\\u53d8\\u6ed1\\u52a8\\u7a97\\u53e3\\u6a21\\u677f\\u89e3\\u51b3\\u3002\\n\\n#\\u8fd9\\u9053\\u9898\\u548c\\u524d\\u7f00\\u548c\\u4e4b\\u95f4\\u7684\\u5173\\u7cfb\\u662f\\u4ec0\\u4e48\\u5462\\uff1f\\n\\n\\n# At most (s) is the count of subarrays whose sum <= s, at most (s-1) is the count of subarrays whose sum <= s-1, if you subtract them, all you get is subarrays whose sum exactly == s.\\uff08\\u524d\\u7f00\\u548c\\uff09\\n\\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n def atMost(S):\\n if S < 0: return 0\\n res = i = 0\\n for j in range(len(A)):\\n S -= A[j]\\n while S < 0:\\n S += A[i]\\n i += 1\\n res += j - i + 1\\n return res\\n return atMost(S) - atMost(S - 1)\\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n \\n P = [0]\\n for x in A:\\n P.append(P[-1]+x)\\n count = collections.Counter()\\n \\n ans = 0\\n for x in P:\\n ans += count[x]\\n count[x+S] +=1\\n return ans\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n container = [0]\\n for num in A:\\n container.append(container[-1] + num)\\n \\n count = Counter()\\n \\n ans = 0\\n for num in container:\\n # if count at num empty, just adds 0\\n ans += count[num]\\n # puts num + S into count with a count of 1 or increments num + S by 1\\n count[num+S] += 1\\n \\n return ans\\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n def findZerosBefore(index, array):\\n zerosBefore = 0\\n index -= 1\\n while (index >= 0 and array[index] != 1):\\n zerosBefore += 1\\n index -= 1\\n return zerosBefore\\n \\n def findZerosAfter(index, array):\\n zerosAfter = 0\\n index += 1\\n while (index < len(array) and array[index] != 1):\\n zerosAfter += 1\\n index += 1\\n return zerosAfter\\n def zeroString(index, array):\\n zeros = 0\\n while (index < len(array) and array[index] != 1):\\n zeros += 1\\n index += 1\\n \\n return zeros\\n \\n def zeroCombs(n):\\n combs = 0\\n for i in range(n, 0, -1):\\n combs = combs + n - i + 1\\n return combs\\n \\n def firstZero(index, array):\\n if (index == 0):\\n return True\\n if (array[index - 1] == 1):\\n return True\\n else:\\n return False\\n \\n total = 0\\n \\n if (S > 0):\\n # get indices of all ocurrences of 1 in 'A'\\n one_array = [i for i, one in enumerate(A) if one == 1]\\n print(one_array)\\n start_index = []\\n end_index = []\\n\\n for n in range(len(one_array)):\\n if (n + S - 1 < len(one_array)):\\n start_index.append(one_array[n])\\n end_index.append(one_array[n + (S - 1)])\\n print(start_index)\\n print(end_index)\\n for i in range(len(start_index)):\\n Bef = findZerosBefore(start_index[i], A)\\n print(Bef)\\n Aft = findZerosAfter(end_index[i], A)\\n total = total + Bef + Aft + (Bef * Aft) + 1\\n \\n if (S == 0):\\n zero_array = [i for i, zero in enumerate(A) if zero == 0]\\n for n in range(len(zero_array)):\\n if (firstZero(zero_array[n], A)):\\n sticky = zeroString(zero_array[n], A)\\n total = int(total + (sticky**2 + sticky)/2)\\n \\n return total\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n def findZerosBefore(index, array):\\n zerosBefore = 0\\n index -= 1\\n while (index >= 0 and array[index] != 1):\\n zerosBefore += 1\\n index -= 1\\n return zerosBefore\\n \\n def findZerosAfter(index, array):\\n zerosAfter = 0\\n index += 1\\n while (index < len(array) and array[index] != 1):\\n zerosAfter += 1\\n index += 1\\n return zerosAfter\\n def zeroString(index, array):\\n zeros = 0\\n while (index < len(array) and array[index] != 1):\\n zeros += 1\\n index += 1\\n \\n return zeros\\n \\n def zeroCombs(n):\\n combs = 0\\n for i in range(n, 0, -1):\\n combs = combs + n - i + 1\\n return combs\\n \\n def firstZero(index, array):\\n if (index == 0):\\n return True\\n if (array[index - 1] == 1):\\n return True\\n else:\\n return False\\n \\n total = 0\\n \\n if (S > 0):\\n # get indices of all ocurrences of 1 in 'A'\\n one_array = [i for i, one in enumerate(A) if one == 1]\\n print(one_array)\\n start_index = []\\n end_index = []\\n\\n for n in range(len(one_array)):\\n if (n + S - 1 < len(one_array)):\\n start_index.append(one_array[n])\\n end_index.append(one_array[n + (S - 1)])\\n print(start_index)\\n print(end_index)\\n for i in range(len(start_index)):\\n Bef = findZerosBefore(start_index[i], A)\\n print(Bef)\\n Aft = findZerosAfter(end_index[i], A)\\n total = total + Bef + Aft + (Bef * Aft) + 1\\n \\n if (S == 0):\\n zero_array = [i for i, zero in enumerate(A) if zero == 0]\\n for n in range(len(zero_array)):\\n if (firstZero(zero_array[n], A)):\\n sticky = zeroString(zero_array[n], A)\\n total = total + zeroCombs(sticky)\\n \\n return total\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n i, s, res, count = 0, 0, 0, 1\\n \\n for j in range(len(A)): \\n s += A[j]\\n \\n while s > S:\\n s -= A[i]\\n i += 1\\n count = 1\\n while i < j and A[i] == 0:\\n i += 1\\n count += 1\\n \\n if s == S and i <= j:\\n res += count\\n \\n return res\\n\", \"from collections import Counter\\n\\n'''\\nlet P[i] = sum(A[:i])\\nfor each j\\n count # of i's \\n where P[j] - P[i] = S where i < j\\n'''\\n\\nclass Solution:\\n def numSubarraysWithSum(self, A, k):\\n count = Counter({0:1})\\n ans = psum = 0\\n \\n for v in A:\\n psum += v\\n ans += count[psum - k]\\n count[psum] += 1\\n \\n return ans\", \"class Solution:\\n \\n def f(self, A):\\n ret = 0\\n \\n cnt = 0\\n for a in A:\\n if not cnt:\\n if not a:\\n cnt += 1\\n else:\\n if not a:\\n cnt += 1\\n else:\\n ret += (cnt*(cnt+1)) // 2\\n cnt = 0\\n\\n if cnt: ret += (cnt*(cnt+1)) // 2\\n \\n return ret\\n pass\\n\\n def numSubarraysWithSum(self, A: List[int], k: int) -> int:\\n ret = 0\\n \\n if not k: return self.f(A)\\n \\n mp = { 0 : 1 }\\n cnt = 0\\n\\n for a in A:\\n cnt += a\\n \\n if cnt not in mp:\\n mp[cnt] = 0\\n mp[cnt] += 1\\n \\n if cnt - k in mp:\\n ret += mp[cnt - k]\\n \\n return ret\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n h = {0: 1}\\n count = summ = 0\\n \\n for i in range(0, len(A)):\\n summ += A[i]\\n if summ - S in h:\\n count += h[summ-S]\\n if summ not in h:\\n h[summ] = 0\\n h[summ]+=1\\n \\n return count\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n dp = []\\n oneIndices = [-1]\\n ans = 0\\n for i, num in enumerate(A):\\n if num == 1:\\n oneIndices.append(i)\\n if len(oneIndices) >= S + 1:\\n if S == 0:\\n ans += (i - oneIndices[-S-1])\\n else:\\n ans += (oneIndices[-S] - oneIndices[-S-1])\\n return ans\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n return self.at_most(A, S) - self.at_most(A, S-1)\\n \\n def at_most(self, A, S):\\n if S < 0:\\n return 0\\n \\n start = 0\\n res = 0\\n for end in range(len(A)):\\n S -= A[end]\\n while start < len(A) and S < 0:\\n S += A[start]\\n start += 1\\n \\n res += (end - start + 1)\\n # print(res) \\n return res\", \"class Solution:\\n def numSubarraysWithSum(self, nums: List[int], target: int) -> int:\\n return self._at_most(nums, target) - self._at_most(nums, target - 1)\\n \\n def _at_most(self, nums, target):\\n cnt = 0\\n sums = 0\\n i = 0\\n for j in range(len(nums)):\\n sums += nums[j]\\n \\n while i <= j and sums > target:\\n sums -= nums[i]\\n i += 1\\n \\n if sums <= target:\\n cnt += j - i + 1\\n \\n return cnt\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n csum = [0]\\n for a in A: csum.append(csum[-1]+a)\\n counter = collections.Counter()\\n ans = 0\\n print(csum)\\n for p in csum:\\n ans += counter[p-S]\\n #print('with',p,'found',counter[p-S],p-S)\\n counter[p]+=1\\n return ans\", \"import collections\\nclass Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n cache=collections.Counter({0:1})\\n currentSum=0\\n count=0\\n for num in A:\\n currentSum+=num\\n count+=cache[currentSum-S]\\n cache[currentSum]+=1\\n return count\", \"class Solution:\\n def numSubarraysWithSum(self, A, S):\\n c = collections.Counter({0: 1})\\n psum = res = 0\\n for i in A:\\n psum += i\\n res += c[psum - S]\\n c[psum] += 1\\n return res\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n n = len(A)\\n prefix = [0 for _ in range(n+1)]\\n for i in range(n):\\n prefix[i+1] = prefix[i] + A[i]\\n \\n def at_most_k(k: int) -> int:\\n begin, end = 0, 1\\n cnt = 0\\n while end < n+1:\\n while begin < end and prefix[end] - prefix[begin] > k:\\n begin += 1\\n cnt += end - begin\\n end += 1\\n return cnt\\n\\n return at_most_k(S) - at_most_k(S-1)\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n def atMost(S):\\n if S < 0: return 0\\n res = i = 0\\n for j in range(len(A)):\\n S -= A[j]\\n while S < 0:\\n S += A[i]\\n i += 1\\n res += j - i + 1\\n return res\\n return atMost(S) - atMost(S - 1) \\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n return self.atMost(A, S) - self.atMost(A, S-1)\\n \\n def atMost(self, A, S):\\n res = 0\\n i = 0\\n pre_sum = 0\\n for j, val in enumerate(A):\\n pre_sum += val\\n while pre_sum > S and i <= j:\\n print(pre_sum, i)\\n pre_sum -= A[i]\\n i += 1\\n res += j-i+1\\n return res\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n if len(A)==0:\\n return 0\\n \\n def atmost(m):\\n if m<0:\\n return 0\\n \\n res=i=0\\n for j in range(len(A)):\\n m-=A[j]\\n while(m<0):\\n m+=A[i]\\n i+=1\\n res+=(j-i+1)\\n return res\\n \\n return atmost(S)-atmost(S-1)\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n def atMost(S):\\n ans,l,tmp = 0,0,0\\n\\n for r in range(len(A)):\\n tmp = tmp + A[r]\\n while (tmp > S and l <= r): \\n tmp = tmp- A[l]\\n l = l + 1\\n ans += r - l + 1\\n return ans\\n\\n return atMost(S) - atMost(S - 1)\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n # HashMap\\n # count = {0:1}\\n # presum = res = 0\\n # for num in A:\\n # presum += num\\n # if presum - S in count:\\n # res += count[presum - S]\\n # count[presum] = count.get(presum, 0) + 1\\n # return res\\n \\n # two pointers\\n # def atMost(k):\\n # n = len(A)\\n # left = presum = res = 0\\n # for right in range(n):\\n # presum += A[right]\\n # while left <= right and presum > k:\\n # presum -= A[left]\\n # left += 1\\n # res += right - left + 1\\n # return res\\n # return atMost(S) - atMost(S - 1)\\n \\n left = res = cur_sum = count = 0\\n for right in range(len(A)):\\n cur_sum += A[right]\\n if A[right] == 1:\\n count = 0\\n while left <= right and cur_sum >= S:\\n if cur_sum == S:\\n count += 1\\n cur_sum -= A[left]\\n left += 1\\n res += count\\n return res\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n '''\\n Subarray sum = k problem\\n '''\\n \\n cur = 0\\n res = 0\\n dp = collections.defaultdict(int)\\n dp[0] = 1\\n for i in range(len(A)):\\n cur+=A[i]\\n diff = cur-S\\n if diff in dp:\\n res+=dp[diff]\\n dp[cur]+=1\\n \\n return res\\n\", \"class Solution:\\n def numSubarraysWithSum(self, A, S):\\n return self.numSubarraysAtMostSum(A, S) - self.numSubarraysAtMostSum(A, S - 1)\\n \\n def numSubarraysAtMostSum(self, A, S):\\n if S < 0:\\n return 0\\n if not A:\\n return 0\\n n = len(A)\\n right = 0\\n now_sum = 0\\n res = 0\\n for left in range(n):\\n while right <= n - 1 and (now_sum < S or A[right] == 0):\\n now_sum += A[right]\\n right += 1\\n res += right - left\\n now_sum -= A[left]\\n return res \", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n # n = len(A)\\n # l = 0\\n # sums = 0\\n # add = 1\\n # ans = 0\\n # for r in range(n):\\n # sums += A[r]\\n # while sums > S or A[l] == 0:\\n # if sums > S:\\n # add = 1\\n # else:\\n # add += 1\\n # sums -= A[l]\\n # l += 1\\n # if sums == S:\\n # ans += add\\n # return ans\\n \\n hashmap = {0:1}\\n preSum = 0\\n ans = 0\\n for i in range(len(A)):\\n preSum += A[i]\\n if preSum - S in hashmap:\\n ans += hashmap[preSum -S]\\n hashmap[preSum] = 1 if preSum not in hashmap else hashmap[preSum] + 1\\n return ans\\n \\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n if not A or S < 0:\\n return 0\\n \\n map = Counter()\\n map[0] = 1\\n sum = 0\\n res = 0\\n for num in A:\\n sum += num\\n if sum - S in map:\\n res += map[sum-S]\\n map[sum] += 1\\n return res\\n\", \"class Solution:\\n def numSubarraysWithSum(self, nums: List[int], k: int) -> int:\\n if not nums: return 0\\n\\n counter = collections.defaultdict(int)\\n counter[0] = 1\\n cumsum = 0\\n ans = 0\\n for i in range(len(nums)):\\n cumsum += nums[i]\\n if cumsum-k in counter:\\n ans += counter[cumsum-k]\\n counter[cumsum] += 1\\n return ans\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n size = len(A)\\n prefix = {0: 1}\\n cnt = 0\\n ans = 0\\n \\n for i, num in enumerate(A):\\n if num == 1: cnt += 1\\n if cnt - S in prefix:\\n ans += prefix[cnt-S]\\n prefix[cnt] = prefix.get(cnt, 0) + 1\\n \\n return ans\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n A = [0] + list(itertools.accumulate(A))\\n hm = Counter()\\n res = 0\\n for i in A:\\n res += hm[i]\\n hm[i+S] += 1\\n return res\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n count = {0:1}\\n prefix = 0\\n result = 0\\n \\n for a in A:\\n prefix = (prefix+a)\\n #print(prefix)\\n if prefix-S in count:\\n result += count[prefix-S]\\n if prefix in count:\\n count[prefix] += 1\\n else:\\n count[prefix] = 1\\n return result \\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n \\n if S==0 and sum(A)==0:\\n return len(A)*(len(A)+1)//2\\n \\n \\n def atmost(s):\\n \\n if s<0:\\n return 0\\n sumi=s\\n l=0\\n r=0\\n count=0\\n \\n \\n while r<len(A):\\n \\n sumi-=A[r]\\n \\n while sumi<0:\\n sumi+=A[l]\\n l+=1\\n \\n count+=(r-l+1)\\n r+=1\\n \\n return count\\n \\n \\n return atmost(S) - atmost(S-1)\\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n d = {0: 1}\\n ss = 0\\n for i in A:\\n ss += i\\n d[ss] = d.get(ss,0)+1\\n res = 0\\n print(d)\\n if S > 0:\\n for i in range(ss-S+1):\\n res += d[i]*d[i+S]\\n if S == 0:\\n for i in range(ss+1):\\n res += d[i]*(d[i]-1)//2\\n return res \\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n counter=collections.Counter({0:1})\\n s=0\\n c=0\\n for a in A:\\n s+=a\\n c+=counter[s-S]\\n counter[s]+=1\\n return c\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n P = [0]\\n for x in A: P.append(P[-1] + x)\\n count = collections.Counter()\\n\\n ans = 0\\n for x in P:\\n ans += count[x]\\n count[x + S] += 1\\n\\n return ans\\n# count=0\\n# ind = 0\\n# while ind < len(A):\\n# sum=A[ind]\\n# if sum == S:\\n# count += 1\\n# if A[ind] == 1:\\n# for y in A[ind+1:]:\\n# sum += y\\n# if sum == S:\\n# count += 1\\n# elif sum > S:\\n# break\\n# ind += 1\\n# else:\\n# zc = 1\\n# zero = True\\n# for y in A[ind+1:]:\\n# sum += y\\n# if y == 0 and zero:\\n# zc += 1\\n# else:\\n# zero = False\\n# if sum == S:\\n# count += zc\\n# elif sum > S:\\n# break\\n# ind += zc\\n# return count\\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n p = [0]\\n for i in A:\\n p.append(p[-1]+i)\\n cnt = collections.Counter()\\n\\n res = 0\\n for i in p:\\n res += cnt[i]\\n cnt[i+S] += 1\\n return res\\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n \\n d = defaultdict(int)\\n d[0] = 1\\n psum = res = 0\\n for a in A:\\n psum += a \\n res += d[psum - S]\\n d[psum]+=1 \\n return res\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n \\n P = [0]\\n for x in A: P.append(P[-1] + x)\\n count = collections.Counter()\\n\\n ans = 0\\n for x in P:\\n ans += count[x]\\n count[x + S] += 1\\n\\n return ans\\n \\n \\n\\n \\n \\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n numToFreq = {}\\n numToFreq[0] = 1\\n now_sum = 0\\n ans = 0\\n for num in A:\\n now_sum += num\\n if now_sum == S:\\n ans += (numToFreq[0])\\n elif now_sum > S:\\n if now_sum - S in numToFreq:\\n ans += (numToFreq[now_sum - S])\\n \\n if now_sum not in numToFreq:\\n numToFreq[now_sum] = 0\\n numToFreq[now_sum] += 1\\n return ans\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n n = len(A)\\n \\n def num_subar_at_most(lim):\\n subarr_ct = 0\\n r_sum = 0\\n li = 0\\n for ri in range(n):\\n r_sum += A[ri]\\n while li <= ri and r_sum > lim:\\n r_sum -= A[li]\\n li += 1\\n subarr_ct += ri - li + 1\\n return subarr_ct\\n \\n return num_subar_at_most(S) - num_subar_at_most(S - 1)\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n cumsum = 0\\n dic = {0:[-1]}\\n ans = 0\\n for i,num in enumerate(A):\\n cumsum += num\\n dic[cumsum] = dic.get(cumsum,[]) + [i]\\n ans += len(dic.get(cumsum-S,[]))\\n #print(ans,dic)\\n return ans - (0 if S else len(A))\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n ans=0\\n il,ih,sl,sh=0,0,0,0\\n for j,x in enumerate(A):\\n sl+=x\\n while il<j and sl>S:\\n sl-=A[il]\\n il+=1\\n \\n sh+=x\\n while ih<j and (sh>S or sh==S and not A[ih]):\\n sh-=A[ih]\\n ih+=1\\n \\n if sl==S:\\n ans+=ih-il+1\\n return ans\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n \\n count = 0\\n output = 0\\n left = 0\\n \\n for right in range(len(A)):\\n S -= A[right]\\n if A[right] == 1:\\n count = 0\\n while left <= right and S <= 0:\\n if S == 0:\\n count += 1\\n S += A[left]\\n left += 1\\n output += count\\n \\n return output\\n \\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n def helper(k):\\n if k < 0:\\n return 0\\n num = 0\\n i = 0\\n for j in range(len(A)):\\n k -= A[j]\\n \\n while k < 0:\\n k += A[i]\\n i += 1\\n num += j-i+1\\n return num\\n return helper(S)-helper(S-1)\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n c = collections.Counter({0: 1})\\n psum = res = 0\\n for i in A:\\n psum += i\\n res += c[psum - S]\\n c[psum] += 1\\n return res\\n\\n \\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n n = len(A)\\n \\n i, j, total, res = 0, 0, 0, 0\\n while j < n:\\n total += A[j]\\n while i < j and total > S:\\n total -= A[i]\\n i += 1\\n if total == S:\\n res += 1\\n # There could be multiple 0 between i & j.\\n k = i\\n while k < j and A[k] == 0:\\n k += 1\\n res += 1\\n j += 1\\n return res\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n i, s, res, count = 0, 0, 0, 1\\n \\n for j in range(len(A)): \\n s += A[j]\\n while i < j and (s > S or A[i] == 0):\\n if A[i]:\\n s -= A[i]\\n count = 1\\n else:\\n count += 1 \\n i += 1 \\n \\n if s == S:\\n res += count\\n \\n return res\\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n result = 0\\n left, right, count = 0, 0, 0\\n for right in range(len(A)):\\n S -= A[right]\\n if A[right] == 1:\\n count = 0\\n while S <= 0 and left <= right:\\n if S == 0:\\n count += 1\\n S += A[left]\\n left += 1\\n result += count\\n return result\\n \\n \\n \\n \\n \\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n \\n count = {0:1}\\n total = maxS = 0\\n \\n for num in A:\\n total += num\\n maxS += count.get(total-S,0)\\n count[total] = count.get(total,0)+1\\n\\n return maxS\\n \\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n ctr = collections.Counter({0:1})\\n prefix = res = 0\\n for a in A:\\n prefix += a\\n res += ctr[prefix - S]\\n ctr[prefix] += 1\\n return res\\n\", \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n c = collections.Counter({0: 1})\\n psum = res = 0\\n for i in A:\\n psum += i\\n res += c[psum - S]\\n c[psum] += 1\\n return res\\n\"]"},"input_output":{"kind":"string","value":"{\"fn_name\": \"numSubarraysWithSum\", \"inputs\": [[[1, 0, 1, 0, 1], 2]], \"outputs\": [4]}"},"difficulty":{"kind":"string","value":"interview"},"url":{"kind":"string","value":"https://leetcode.com/problems/binary-subarrays-with-sum/"},"starter_code":{"kind":"string","value":"\nclass Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n "},"solutions_list":{"kind":"list like","value":["class Solution:\n def numSubarraysWithSum(self, pl, S):\n ans = 0\n \n if(S == 0):\n c = 0\n for i in range(len(pl)):\n if(pl[i] == 0):\n c+=1\n else:\n c = 0\n ans +=c\n return ans;\n \n \n \n \n \n \n l = [-1]\n \n for i in range(len(pl)):\n if(pl[i] == 1 ):\n l.append(i)\n \n l.append(len(pl))\n \n ans = 0\n \n for i in range(1,len(l)-S):\n \n ans += (l[i]-l[i-1])*(l[i+S] - l[i+S-1])\n \n return ans\n \n \n \n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n size = len(A)\n l, r, total, cnt = [0] * 4\n if S == 0:\n l = 1\n for x in A:\n if x == 0:\n cnt += l\n l += 1\n else:\n l = 1\n return cnt\n while r < size and total < S:\n total += A[r]\n r += 1\n if r == size and total < S:\n return 0\n while r < size:\n cnt1, cnt2 = 1, 1\n while l < r and A[l] == 0:\n l += 1\n cnt1 += 1\n while r < size and A[r] == 0:\n r += 1\n cnt2 += 1\n cnt += cnt1 * cnt2\n l += 1\n r += 1\n if A[-1] == 1:\n cnt += 1\n while l < size and A[l] == 0:\n cnt += 1\n l += 1\n return cnt \n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n P = [0]\n \n for x in A:\n P.append(P[-1] + x)\n \n count = collections.Counter()\n \n \n ans = 0\n \n for x in P:\n ans += count[x]\n count[x + S] += 1\n \n \n return ans","class Solution(object):\n def numSubarraysWithSum(self, A, S):\n P = [0]\n for x in A: P.append(P[-1] + x)\n count = collections.Counter()\n\n ans = 0\n for x in P:\n ans += count[x]\n count[x + S] += 1\n\n return ans\n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n n = len(A)\n suma = [0]*(n+1)\n \n for i in range(1,n+1):\n suma[i] = suma[i-1]+A[i-1]\n \n left = 0\n res =0\n m = collections.defaultdict(lambda:0)\n m[0]=1\n for i in range(n):\n if suma[i+1]-S in m:\n res += m[suma[i+1]-S]\n \n m[suma[i+1]] += 1\n \n return res","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n def atMostK(A, S):\n if S < 0:\n return 0\n i = res = 0\n\n for j in range(len(A)):\n S -= A[j]\n while S < 0:\n S += A[i]\n i += 1\n res += j - i + 1 #所以小于的也是算了的\n return res\n return atMostK(A, S) - atMostK(A, S - 1)\n \n \n# 由于数组仅包含 0 和 1， 那么问题可以转化为给定一个0，1数组，你可以选择S个1和任意个0，你可以有多少选择？\n\n# 而上述问题可以转化为给定一个0，1数组，你可以选择最多S个1和任意个0，你的选择数减去 给定一个0，1数组，你可以选择最多S - 1个1和任意个0，你的选择数。\n\n# 最多xxxx 这种可以使用可变滑动窗口模板解决。\n\n#这道题和前缀和之间的关系是什么呢？\n\n\n# At most (s) is the count of subarrays whose sum <= s, at most (s-1) is the count of subarrays whose sum <= s-1, if you subtract them, all you get is subarrays whose sum exactly == s.（前缀和）\n\n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n def atMost(S):\n if S < 0: return 0\n res = i = 0\n for j in range(len(A)):\n S -= A[j]\n while S < 0:\n S += A[i]\n i += 1\n res += j - i + 1\n return res\n return atMost(S) - atMost(S - 1)\n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n \n P = [0]\n for x in A:\n P.append(P[-1]+x)\n count = collections.Counter()\n \n ans = 0\n for x in P:\n ans += count[x]\n count[x+S] +=1\n return ans","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n container = [0]\n for num in A:\n container.append(container[-1] + num)\n \n count = Counter()\n \n ans = 0\n for num in container:\n # if count at num empty, just adds 0\n ans += count[num]\n # puts num + S into count with a count of 1 or increments num + S by 1\n count[num+S] += 1\n \n return ans\n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n def findZerosBefore(index, array):\n zerosBefore = 0\n index -= 1\n while (index >= 0 and array[index] != 1):\n zerosBefore += 1\n index -= 1\n return zerosBefore\n \n def findZerosAfter(index, array):\n zerosAfter = 0\n index += 1\n while (index < len(array) and array[index] != 1):\n zerosAfter += 1\n index += 1\n return zerosAfter\n def zeroString(index, array):\n zeros = 0\n while (index < len(array) and array[index] != 1):\n zeros += 1\n index += 1\n \n return zeros\n \n def zeroCombs(n):\n combs = 0\n for i in range(n, 0, -1):\n combs = combs + n - i + 1\n return combs\n \n def firstZero(index, array):\n if (index == 0):\n return True\n if (array[index - 1] == 1):\n return True\n else:\n return False\n \n total = 0\n \n if (S > 0):\n # get indices of all ocurrences of 1 in 'A'\n one_array = [i for i, one in enumerate(A) if one == 1]\n print(one_array)\n start_index = []\n end_index = []\n\n for n in range(len(one_array)):\n if (n + S - 1 < len(one_array)):\n start_index.append(one_array[n])\n end_index.append(one_array[n + (S - 1)])\n print(start_index)\n print(end_index)\n for i in range(len(start_index)):\n Bef = findZerosBefore(start_index[i], A)\n print(Bef)\n Aft = findZerosAfter(end_index[i], A)\n total = total + Bef + Aft + (Bef * Aft) + 1\n \n if (S == 0):\n zero_array = [i for i, zero in enumerate(A) if zero == 0]\n for n in range(len(zero_array)):\n if (firstZero(zero_array[n], A)):\n sticky = zeroString(zero_array[n], A)\n total = int(total + (sticky**2 + sticky)/2)\n \n return total\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n def findZerosBefore(index, array):\n zerosBefore = 0\n index -= 1\n while (index >= 0 and array[index] != 1):\n zerosBefore += 1\n index -= 1\n return zerosBefore\n \n def findZerosAfter(index, array):\n zerosAfter = 0\n index += 1\n while (index < len(array) and array[index] != 1):\n zerosAfter += 1\n index += 1\n return zerosAfter\n def zeroString(index, array):\n zeros = 0\n while (index < len(array) and array[index] != 1):\n zeros += 1\n index += 1\n \n return zeros\n \n def zeroCombs(n):\n combs = 0\n for i in range(n, 0, -1):\n combs = combs + n - i + 1\n return combs\n \n def firstZero(index, array):\n if (index == 0):\n return True\n if (array[index - 1] == 1):\n return True\n else:\n return False\n \n total = 0\n \n if (S > 0):\n # get indices of all ocurrences of 1 in 'A'\n one_array = [i for i, one in enumerate(A) if one == 1]\n print(one_array)\n start_index = []\n end_index = []\n\n for n in range(len(one_array)):\n if (n + S - 1 < len(one_array)):\n start_index.append(one_array[n])\n end_index.append(one_array[n + (S - 1)])\n print(start_index)\n print(end_index)\n for i in range(len(start_index)):\n Bef = findZerosBefore(start_index[i], A)\n print(Bef)\n Aft = findZerosAfter(end_index[i], A)\n total = total + Bef + Aft + (Bef * Aft) + 1\n \n if (S == 0):\n zero_array = [i for i, zero in enumerate(A) if zero == 0]\n for n in range(len(zero_array)):\n if (firstZero(zero_array[n], A)):\n sticky = zeroString(zero_array[n], A)\n total = total + zeroCombs(sticky)\n \n return total\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n i, s, res, count = 0, 0, 0, 1\n \n for j in range(len(A)): \n s += A[j]\n \n while s > S:\n s -= A[i]\n i += 1\n count = 1\n while i < j and A[i] == 0:\n i += 1\n count += 1\n \n if s == S and i <= j:\n res += count\n \n return res\n","from collections import Counter\n\n'''\nlet P[i] = sum(A[:i])\nfor each j\n count # of i's \n where P[j] - P[i] = S where i < j\n'''\n\nclass Solution:\n def numSubarraysWithSum(self, A, k):\n count = Counter({0:1})\n ans = psum = 0\n \n for v in A:\n psum += v\n ans += count[psum - k]\n count[psum] += 1\n \n return ans","class Solution:\n \n def f(self, A):\n ret = 0\n \n cnt = 0\n for a in A:\n if not cnt:\n if not a:\n cnt += 1\n else:\n if not a:\n cnt += 1\n else:\n ret += (cnt*(cnt+1)) // 2\n cnt = 0\n\n if cnt: ret += (cnt*(cnt+1)) // 2\n \n return ret\n pass\n\n def numSubarraysWithSum(self, A: List[int], k: int) -> int:\n ret = 0\n \n if not k: return self.f(A)\n \n mp = { 0 : 1 }\n cnt = 0\n\n for a in A:\n cnt += a\n \n if cnt not in mp:\n mp[cnt] = 0\n mp[cnt] += 1\n \n if cnt - k in mp:\n ret += mp[cnt - k]\n \n return ret","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n h = {0: 1}\n count = summ = 0\n \n for i in range(0, len(A)):\n summ += A[i]\n if summ - S in h:\n count += h[summ-S]\n if summ not in h:\n h[summ] = 0\n h[summ]+=1\n \n return count","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n dp = []\n oneIndices = [-1]\n ans = 0\n for i, num in enumerate(A):\n if num == 1:\n oneIndices.append(i)\n if len(oneIndices) >= S + 1:\n if S == 0:\n ans += (i - oneIndices[-S-1])\n else:\n ans += (oneIndices[-S] - oneIndices[-S-1])\n return ans","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n return self.at_most(A, S) - self.at_most(A, S-1)\n \n def at_most(self, A, S):\n if S < 0:\n return 0\n \n start = 0\n res = 0\n for end in range(len(A)):\n S -= A[end]\n while start < len(A) and S < 0:\n S += A[start]\n start += 1\n \n res += (end - start + 1)\n # print(res) \n return res","class Solution:\n def numSubarraysWithSum(self, nums: List[int], target: int) -> int:\n return self._at_most(nums, target) - self._at_most(nums, target - 1)\n \n def _at_most(self, nums, target):\n cnt = 0\n sums = 0\n i = 0\n for j in range(len(nums)):\n sums += nums[j]\n \n while i <= j and sums > target:\n sums -= nums[i]\n i += 1\n \n if sums <= target:\n cnt += j - i + 1\n \n return cnt","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n csum = [0]\n for a in A: csum.append(csum[-1]+a)\n counter = collections.Counter()\n ans = 0\n print(csum)\n for p in csum:\n ans += counter[p-S]\n #print('with',p,'found',counter[p-S],p-S)\n counter[p]+=1\n return ans","import collections\nclass Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n cache=collections.Counter({0:1})\n currentSum=0\n count=0\n for num in A:\n currentSum+=num\n count+=cache[currentSum-S]\n cache[currentSum]+=1\n return count","class Solution:\n def numSubarraysWithSum(self, A, S):\n c = collections.Counter({0: 1})\n psum = res = 0\n for i in A:\n psum += i\n res += c[psum - S]\n c[psum] += 1\n return res","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n n = len(A)\n prefix = [0 for _ in range(n+1)]\n for i in range(n):\n prefix[i+1] = prefix[i] + A[i]\n \n def at_most_k(k: int) -> int:\n begin, end = 0, 1\n cnt = 0\n while end < n+1:\n while begin < end and prefix[end] - prefix[begin] > k:\n begin += 1\n cnt += end - begin\n end += 1\n return cnt\n\n return at_most_k(S) - at_most_k(S-1)","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n def atMost(S):\n if S < 0: return 0\n res = i = 0\n for j in range(len(A)):\n S -= A[j]\n while S < 0:\n S += A[i]\n i += 1\n res += j - i + 1\n return res\n return atMost(S) - atMost(S - 1) \n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n return self.atMost(A, S) - self.atMost(A, S-1)\n \n def atMost(self, A, S):\n res = 0\n i = 0\n pre_sum = 0\n for j, val in enumerate(A):\n pre_sum += val\n while pre_sum > S and i <= j:\n print(pre_sum, i)\n pre_sum -= A[i]\n i += 1\n res += j-i+1\n return res","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n if len(A)==0:\n return 0\n \n def atmost(m):\n if m<0:\n return 0\n \n res=i=0\n for j in range(len(A)):\n m-=A[j]\n while(m<0):\n m+=A[i]\n i+=1\n res+=(j-i+1)\n return res\n \n return atmost(S)-atmost(S-1)","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n def atMost(S):\n ans,l,tmp = 0,0,0\n\n for r in range(len(A)):\n tmp = tmp + A[r]\n while (tmp > S and l <= r): \n tmp = tmp- A[l]\n l = l + 1\n ans += r - l + 1\n return ans\n\n return atMost(S) - atMost(S - 1)","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n # HashMap\n # count = {0:1}\n # presum = res = 0\n # for num in A:\n # presum += num\n # if presum - S in count:\n # res += count[presum - S]\n # count[presum] = count.get(presum, 0) + 1\n # return res\n \n # two pointers\n # def atMost(k):\n # n = len(A)\n # left = presum = res = 0\n # for right in range(n):\n # presum += A[right]\n # while left <= right and presum > k:\n # presum -= A[left]\n # left += 1\n # res += right - left + 1\n # return res\n # return atMost(S) - atMost(S - 1)\n \n left = res = cur_sum = count = 0\n for right in range(len(A)):\n cur_sum += A[right]\n if A[right] == 1:\n count = 0\n while left <= right and cur_sum >= S:\n if cur_sum == S:\n count += 1\n cur_sum -= A[left]\n left += 1\n res += count\n return res","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n '''\n Subarray sum = k problem\n '''\n \n cur = 0\n res = 0\n dp = collections.defaultdict(int)\n dp[0] = 1\n for i in range(len(A)):\n cur+=A[i]\n diff = cur-S\n if diff in dp:\n res+=dp[diff]\n dp[cur]+=1\n \n return res\n","class Solution:\n def numSubarraysWithSum(self, A, S):\n return self.numSubarraysAtMostSum(A, S) - self.numSubarraysAtMostSum(A, S - 1)\n \n def numSubarraysAtMostSum(self, A, S):\n if S < 0:\n return 0\n if not A:\n return 0\n n = len(A)\n right = 0\n now_sum = 0\n res = 0\n for left in range(n):\n while right <= n - 1 and (now_sum < S or A[right] == 0):\n now_sum += A[right]\n right += 1\n res += right - left\n now_sum -= A[left]\n return res ","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n # n = len(A)\n # l = 0\n # sums = 0\n # add = 1\n # ans = 0\n # for r in range(n):\n # sums += A[r]\n # while sums > S or A[l] == 0:\n # if sums > S:\n # add = 1\n # else:\n # add += 1\n # sums -= A[l]\n # l += 1\n # if sums == S:\n # ans += add\n # return ans\n \n hashmap = {0:1}\n preSum = 0\n ans = 0\n for i in range(len(A)):\n preSum += A[i]\n if preSum - S in hashmap:\n ans += hashmap[preSum -S]\n hashmap[preSum] = 1 if preSum not in hashmap else hashmap[preSum] + 1\n return ans\n \n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n if not A or S < 0:\n return 0\n \n map = Counter()\n map[0] = 1\n sum = 0\n res = 0\n for num in A:\n sum += num\n if sum - S in map:\n res += map[sum-S]\n map[sum] += 1\n return res\n","class Solution:\n def numSubarraysWithSum(self, nums: List[int], k: int) -> int:\n if not nums: return 0\n\n counter = collections.defaultdict(int)\n counter[0] = 1\n cumsum = 0\n ans = 0\n for i in range(len(nums)):\n cumsum += nums[i]\n if cumsum-k in counter:\n ans += counter[cumsum-k]\n counter[cumsum] += 1\n return ans","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n size = len(A)\n prefix = {0: 1}\n cnt = 0\n ans = 0\n \n for i, num in enumerate(A):\n if num == 1: cnt += 1\n if cnt - S in prefix:\n ans += prefix[cnt-S]\n prefix[cnt] = prefix.get(cnt, 0) + 1\n \n return ans","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n A = [0] + list(itertools.accumulate(A))\n hm = Counter()\n res = 0\n for i in A:\n res += hm[i]\n hm[i+S] += 1\n return res","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n count = {0:1}\n prefix = 0\n result = 0\n \n for a in A:\n prefix = (prefix+a)\n #print(prefix)\n if prefix-S in count:\n result += count[prefix-S]\n if prefix in count:\n count[prefix] += 1\n else:\n count[prefix] = 1\n return result \n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n \n if S==0 and sum(A)==0:\n return len(A)*(len(A)+1)//2\n \n \n def atmost(s):\n \n if s<0:\n return 0\n sumi=s\n l=0\n r=0\n count=0\n \n \n while r<len(A):\n \n sumi-=A[r]\n \n while sumi<0:\n sumi+=A[l]\n l+=1\n \n count+=(r-l+1)\n r+=1\n \n return count\n \n \n return atmost(S) - atmost(S-1)\n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n d = {0: 1}\n ss = 0\n for i in A:\n ss += i\n d[ss] = d.get(ss,0)+1\n res = 0\n print(d)\n if S > 0:\n for i in range(ss-S+1):\n res += d[i]*d[i+S]\n if S == 0:\n for i in range(ss+1):\n res += d[i]*(d[i]-1)//2\n return res \n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n counter=collections.Counter({0:1})\n s=0\n c=0\n for a in A:\n s+=a\n c+=counter[s-S]\n counter[s]+=1\n return c","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n P = [0]\n for x in A: P.append(P[-1] + x)\n count = collections.Counter()\n\n ans = 0\n for x in P:\n ans += count[x]\n count[x + S] += 1\n\n return ans\n# count=0\n# ind = 0\n# while ind < len(A):\n# sum=A[ind]\n# if sum == S:\n# count += 1\n# if A[ind] == 1:\n# for y in A[ind+1:]:\n# sum += y\n# if sum == S:\n# count += 1\n# elif sum > S:\n# break\n# ind += 1\n# else:\n# zc = 1\n# zero = True\n# for y in A[ind+1:]:\n# sum += y\n# if y == 0 and zero:\n# zc += 1\n# else:\n# zero = False\n# if sum == S:\n# count += zc\n# elif sum > S:\n# break\n# ind += zc\n# return count\n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n p = [0]\n for i in A:\n p.append(p[-1]+i)\n cnt = collections.Counter()\n\n res = 0\n for i in p:\n res += cnt[i]\n cnt[i+S] += 1\n return res\n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n \n d = defaultdict(int)\n d[0] = 1\n psum = res = 0\n for a in A:\n psum += a \n res += d[psum - S]\n d[psum]+=1 \n return res","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n \n P = [0]\n for x in A: P.append(P[-1] + x)\n count = collections.Counter()\n\n ans = 0\n for x in P:\n ans += count[x]\n count[x + S] += 1\n\n return ans\n \n \n\n \n \n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n numToFreq = {}\n numToFreq[0] = 1\n now_sum = 0\n ans = 0\n for num in A:\n now_sum += num\n if now_sum == S:\n ans += (numToFreq[0])\n elif now_sum > S:\n if now_sum - S in numToFreq:\n ans += (numToFreq[now_sum - S])\n \n if now_sum not in numToFreq:\n numToFreq[now_sum] = 0\n numToFreq[now_sum] += 1\n return ans","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n n = len(A)\n \n def num_subar_at_most(lim):\n subarr_ct = 0\n r_sum = 0\n li = 0\n for ri in range(n):\n r_sum += A[ri]\n while li <= ri and r_sum > lim:\n r_sum -= A[li]\n li += 1\n subarr_ct += ri - li + 1\n return subarr_ct\n \n return num_subar_at_most(S) - num_subar_at_most(S - 1)","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n cumsum = 0\n dic = {0:[-1]}\n ans = 0\n for i,num in enumerate(A):\n cumsum += num\n dic[cumsum] = dic.get(cumsum,[]) + [i]\n ans += len(dic.get(cumsum-S,[]))\n #print(ans,dic)\n return ans - (0 if S else len(A))","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n ans=0\n il,ih,sl,sh=0,0,0,0\n for j,x in enumerate(A):\n sl+=x\n while il<j and sl>S:\n sl-=A[il]\n il+=1\n \n sh+=x\n while ih<j and (sh>S or sh==S and not A[ih]):\n sh-=A[ih]\n ih+=1\n \n if sl==S:\n ans+=ih-il+1\n return ans","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n \n count = 0\n output = 0\n left = 0\n \n for right in range(len(A)):\n S -= A[right]\n if A[right] == 1:\n count = 0\n while left <= right and S <= 0:\n if S == 0:\n count += 1\n S += A[left]\n left += 1\n output += count\n \n return output\n \n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n def helper(k):\n if k < 0:\n return 0\n num = 0\n i = 0\n for j in range(len(A)):\n k -= A[j]\n \n while k < 0:\n k += A[i]\n i += 1\n num += j-i+1\n return num\n return helper(S)-helper(S-1)","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n c = collections.Counter({0: 1})\n psum = res = 0\n for i in A:\n psum += i\n res += c[psum - S]\n c[psum] += 1\n return res\n\n \n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n n = len(A)\n \n i, j, total, res = 0, 0, 0, 0\n while j < n:\n total += A[j]\n while i < j and total > S:\n total -= A[i]\n i += 1\n if total == S:\n res += 1\n # There could be multiple 0 between i & j.\n k = i\n while k < j and A[k] == 0:\n k += 1\n res += 1\n j += 1\n return res","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n i, s, res, count = 0, 0, 0, 1\n \n for j in range(len(A)): \n s += A[j]\n while i < j and (s > S or A[i] == 0):\n if A[i]:\n s -= A[i]\n count = 1\n else:\n count += 1 \n i += 1 \n \n if s == S:\n res += count\n \n return res\n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n result = 0\n left, right, count = 0, 0, 0\n for right in range(len(A)):\n S -= A[right]\n if A[right] == 1:\n count = 0\n while S <= 0 and left <= right:\n if S == 0:\n count += 1\n S += A[left]\n left += 1\n result += count\n return result\n \n \n \n \n \n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n \n count = {0:1}\n total = maxS = 0\n \n for num in A:\n total += num\n maxS += count.get(total-S,0)\n count[total] = count.get(total,0)+1\n\n return maxS\n \n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n ctr = collections.Counter({0:1})\n prefix = res = 0\n for a in A:\n prefix += a\n res += ctr[prefix - S]\n ctr[prefix] += 1\n return res\n","class Solution:\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\n c = collections.Counter({0: 1})\n psum = res = 0\n for i in A:\n psum += i\n res += c[psum - S]\n c[psum] += 1\n return res\n"],"string":"[\n \"class Solution:\\n def numSubarraysWithSum(self, pl, S):\\n ans = 0\\n \\n if(S == 0):\\n c = 0\\n for i in range(len(pl)):\\n if(pl[i] == 0):\\n c+=1\\n else:\\n c = 0\\n ans +=c\\n return ans;\\n \\n \\n \\n \\n \\n \\n l = [-1]\\n \\n for i in range(len(pl)):\\n if(pl[i] == 1 ):\\n l.append(i)\\n \\n l.append(len(pl))\\n \\n ans = 0\\n \\n for i in range(1,len(l)-S):\\n \\n ans += (l[i]-l[i-1])*(l[i+S] - l[i+S-1])\\n \\n return ans\\n \\n \\n \\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n size = len(A)\\n l, r, total, cnt = [0] * 4\\n if S == 0:\\n l = 1\\n for x in A:\\n if x == 0:\\n cnt += l\\n l += 1\\n else:\\n l = 1\\n return cnt\\n while r < size and total < S:\\n total += A[r]\\n r += 1\\n if r == size and total < S:\\n return 0\\n while r < size:\\n cnt1, cnt2 = 1, 1\\n while l < r and A[l] == 0:\\n l += 1\\n cnt1 += 1\\n while r < size and A[r] == 0:\\n r += 1\\n cnt2 += 1\\n cnt += cnt1 * cnt2\\n l += 1\\n r += 1\\n if A[-1] == 1:\\n cnt += 1\\n while l < size and A[l] == 0:\\n cnt += 1\\n l += 1\\n return cnt \\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n P = [0]\\n \\n for x in A:\\n P.append(P[-1] + x)\\n \\n count = collections.Counter()\\n \\n \\n ans = 0\\n \\n for x in P:\\n ans += count[x]\\n count[x + S] += 1\\n \\n \\n return ans\",\n \"class Solution(object):\\n def numSubarraysWithSum(self, A, S):\\n P = [0]\\n for x in A: P.append(P[-1] + x)\\n count = collections.Counter()\\n\\n ans = 0\\n for x in P:\\n ans += count[x]\\n count[x + S] += 1\\n\\n return ans\\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n n = len(A)\\n suma = [0]*(n+1)\\n \\n for i in range(1,n+1):\\n suma[i] = suma[i-1]+A[i-1]\\n \\n left = 0\\n res =0\\n m = collections.defaultdict(lambda:0)\\n m[0]=1\\n for i in range(n):\\n if suma[i+1]-S in m:\\n res += m[suma[i+1]-S]\\n \\n m[suma[i+1]] += 1\\n \\n return res\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n def atMostK(A, S):\\n if S < 0:\\n return 0\\n i = res = 0\\n\\n for j in range(len(A)):\\n S -= A[j]\\n while S < 0:\\n S += A[i]\\n i += 1\\n res += j - i + 1 #所以小于的也是算了的\\n return res\\n return atMostK(A, S) - atMostK(A, S - 1)\\n \\n \\n# 由于数组仅包含 0 和 1， 那么问题可以转化为给定一个0，1数组，你可以选择S个1和任意个0，你可以有多少选择？\\n\\n# 而上述问题可以转化为给定一个0，1数组，你可以选择最多S个1和任意个0，你的选择数减去 给定一个0，1数组，你可以选择最多S - 1个1和任意个0，你的选择数。\\n\\n# 最多xxxx 这种可以使用可变滑动窗口模板解决。\\n\\n#这道题和前缀和之间的关系是什么呢？\\n\\n\\n# At most (s) is the count of subarrays whose sum <= s, at most (s-1) is the count of subarrays whose sum <= s-1, if you subtract them, all you get is subarrays whose sum exactly == s.（前缀和）\\n\\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n def atMost(S):\\n if S < 0: return 0\\n res = i = 0\\n for j in range(len(A)):\\n S -= A[j]\\n while S < 0:\\n S += A[i]\\n i += 1\\n res += j - i + 1\\n return res\\n return atMost(S) - atMost(S - 1)\\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n \\n P = [0]\\n for x in A:\\n P.append(P[-1]+x)\\n count = collections.Counter()\\n \\n ans = 0\\n for x in P:\\n ans += count[x]\\n count[x+S] +=1\\n return ans\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n container = [0]\\n for num in A:\\n container.append(container[-1] + num)\\n \\n count = Counter()\\n \\n ans = 0\\n for num in container:\\n # if count at num empty, just adds 0\\n ans += count[num]\\n # puts num + S into count with a count of 1 or increments num + S by 1\\n count[num+S] += 1\\n \\n return ans\\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n def findZerosBefore(index, array):\\n zerosBefore = 0\\n index -= 1\\n while (index >= 0 and array[index] != 1):\\n zerosBefore += 1\\n index -= 1\\n return zerosBefore\\n \\n def findZerosAfter(index, array):\\n zerosAfter = 0\\n index += 1\\n while (index < len(array) and array[index] != 1):\\n zerosAfter += 1\\n index += 1\\n return zerosAfter\\n def zeroString(index, array):\\n zeros = 0\\n while (index < len(array) and array[index] != 1):\\n zeros += 1\\n index += 1\\n \\n return zeros\\n \\n def zeroCombs(n):\\n combs = 0\\n for i in range(n, 0, -1):\\n combs = combs + n - i + 1\\n return combs\\n \\n def firstZero(index, array):\\n if (index == 0):\\n return True\\n if (array[index - 1] == 1):\\n return True\\n else:\\n return False\\n \\n total = 0\\n \\n if (S > 0):\\n # get indices of all ocurrences of 1 in 'A'\\n one_array = [i for i, one in enumerate(A) if one == 1]\\n print(one_array)\\n start_index = []\\n end_index = []\\n\\n for n in range(len(one_array)):\\n if (n + S - 1 < len(one_array)):\\n start_index.append(one_array[n])\\n end_index.append(one_array[n + (S - 1)])\\n print(start_index)\\n print(end_index)\\n for i in range(len(start_index)):\\n Bef = findZerosBefore(start_index[i], A)\\n print(Bef)\\n Aft = findZerosAfter(end_index[i], A)\\n total = total + Bef + Aft + (Bef * Aft) + 1\\n \\n if (S == 0):\\n zero_array = [i for i, zero in enumerate(A) if zero == 0]\\n for n in range(len(zero_array)):\\n if (firstZero(zero_array[n], A)):\\n sticky = zeroString(zero_array[n], A)\\n total = int(total + (sticky**2 + sticky)/2)\\n \\n return total\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n def findZerosBefore(index, array):\\n zerosBefore = 0\\n index -= 1\\n while (index >= 0 and array[index] != 1):\\n zerosBefore += 1\\n index -= 1\\n return zerosBefore\\n \\n def findZerosAfter(index, array):\\n zerosAfter = 0\\n index += 1\\n while (index < len(array) and array[index] != 1):\\n zerosAfter += 1\\n index += 1\\n return zerosAfter\\n def zeroString(index, array):\\n zeros = 0\\n while (index < len(array) and array[index] != 1):\\n zeros += 1\\n index += 1\\n \\n return zeros\\n \\n def zeroCombs(n):\\n combs = 0\\n for i in range(n, 0, -1):\\n combs = combs + n - i + 1\\n return combs\\n \\n def firstZero(index, array):\\n if (index == 0):\\n return True\\n if (array[index - 1] == 1):\\n return True\\n else:\\n return False\\n \\n total = 0\\n \\n if (S > 0):\\n # get indices of all ocurrences of 1 in 'A'\\n one_array = [i for i, one in enumerate(A) if one == 1]\\n print(one_array)\\n start_index = []\\n end_index = []\\n\\n for n in range(len(one_array)):\\n if (n + S - 1 < len(one_array)):\\n start_index.append(one_array[n])\\n end_index.append(one_array[n + (S - 1)])\\n print(start_index)\\n print(end_index)\\n for i in range(len(start_index)):\\n Bef = findZerosBefore(start_index[i], A)\\n print(Bef)\\n Aft = findZerosAfter(end_index[i], A)\\n total = total + Bef + Aft + (Bef * Aft) + 1\\n \\n if (S == 0):\\n zero_array = [i for i, zero in enumerate(A) if zero == 0]\\n for n in range(len(zero_array)):\\n if (firstZero(zero_array[n], A)):\\n sticky = zeroString(zero_array[n], A)\\n total = total + zeroCombs(sticky)\\n \\n return total\\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n \\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n i, s, res, count = 0, 0, 0, 1\\n \\n for j in range(len(A)): \\n s += A[j]\\n \\n while s > S:\\n s -= A[i]\\n i += 1\\n count = 1\\n while i < j and A[i] == 0:\\n i += 1\\n count += 1\\n \\n if s == S and i <= j:\\n res += count\\n \\n return res\\n\",\n \"from collections import Counter\\n\\n'''\\nlet P[i] = sum(A[:i])\\nfor each j\\n count # of i's \\n where P[j] - P[i] = S where i < j\\n'''\\n\\nclass Solution:\\n def numSubarraysWithSum(self, A, k):\\n count = Counter({0:1})\\n ans = psum = 0\\n \\n for v in A:\\n psum += v\\n ans += count[psum - k]\\n count[psum] += 1\\n \\n return ans\",\n \"class Solution:\\n \\n def f(self, A):\\n ret = 0\\n \\n cnt = 0\\n for a in A:\\n if not cnt:\\n if not a:\\n cnt += 1\\n else:\\n if not a:\\n cnt += 1\\n else:\\n ret += (cnt*(cnt+1)) // 2\\n cnt = 0\\n\\n if cnt: ret += (cnt*(cnt+1)) // 2\\n \\n return ret\\n pass\\n\\n def numSubarraysWithSum(self, A: List[int], k: int) -> int:\\n ret = 0\\n \\n if not k: return self.f(A)\\n \\n mp = { 0 : 1 }\\n cnt = 0\\n\\n for a in A:\\n cnt += a\\n \\n if cnt not in mp:\\n mp[cnt] = 0\\n mp[cnt] += 1\\n \\n if cnt - k in mp:\\n ret += mp[cnt - k]\\n \\n return ret\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n h = {0: 1}\\n count = summ = 0\\n \\n for i in range(0, len(A)):\\n summ += A[i]\\n if summ - S in h:\\n count += h[summ-S]\\n if summ not in h:\\n h[summ] = 0\\n h[summ]+=1\\n \\n return count\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n dp = []\\n oneIndices = [-1]\\n ans = 0\\n for i, num in enumerate(A):\\n if num == 1:\\n oneIndices.append(i)\\n if len(oneIndices) >= S + 1:\\n if S == 0:\\n ans += (i - oneIndices[-S-1])\\n else:\\n ans += (oneIndices[-S] - oneIndices[-S-1])\\n return ans\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n return self.at_most(A, S) - self.at_most(A, S-1)\\n \\n def at_most(self, A, S):\\n if S < 0:\\n return 0\\n \\n start = 0\\n res = 0\\n for end in range(len(A)):\\n S -= A[end]\\n while start < len(A) and S < 0:\\n S += A[start]\\n start += 1\\n \\n res += (end - start + 1)\\n # print(res) \\n return res\",\n \"class Solution:\\n def numSubarraysWithSum(self, nums: List[int], target: int) -> int:\\n return self._at_most(nums, target) - self._at_most(nums, target - 1)\\n \\n def _at_most(self, nums, target):\\n cnt = 0\\n sums = 0\\n i = 0\\n for j in range(len(nums)):\\n sums += nums[j]\\n \\n while i <= j and sums > target:\\n sums -= nums[i]\\n i += 1\\n \\n if sums <= target:\\n cnt += j - i + 1\\n \\n return cnt\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n csum = [0]\\n for a in A: csum.append(csum[-1]+a)\\n counter = collections.Counter()\\n ans = 0\\n print(csum)\\n for p in csum:\\n ans += counter[p-S]\\n #print('with',p,'found',counter[p-S],p-S)\\n counter[p]+=1\\n return ans\",\n \"import collections\\nclass Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n cache=collections.Counter({0:1})\\n currentSum=0\\n count=0\\n for num in A:\\n currentSum+=num\\n count+=cache[currentSum-S]\\n cache[currentSum]+=1\\n return count\",\n \"class Solution:\\n def numSubarraysWithSum(self, A, S):\\n c = collections.Counter({0: 1})\\n psum = res = 0\\n for i in A:\\n psum += i\\n res += c[psum - S]\\n c[psum] += 1\\n return res\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n n = len(A)\\n prefix = [0 for _ in range(n+1)]\\n for i in range(n):\\n prefix[i+1] = prefix[i] + A[i]\\n \\n def at_most_k(k: int) -> int:\\n begin, end = 0, 1\\n cnt = 0\\n while end < n+1:\\n while begin < end and prefix[end] - prefix[begin] > k:\\n begin += 1\\n cnt += end - begin\\n end += 1\\n return cnt\\n\\n return at_most_k(S) - at_most_k(S-1)\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n def atMost(S):\\n if S < 0: return 0\\n res = i = 0\\n for j in range(len(A)):\\n S -= A[j]\\n while S < 0:\\n S += A[i]\\n i += 1\\n res += j - i + 1\\n return res\\n return atMost(S) - atMost(S - 1) \\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n return self.atMost(A, S) - self.atMost(A, S-1)\\n \\n def atMost(self, A, S):\\n res = 0\\n i = 0\\n pre_sum = 0\\n for j, val in enumerate(A):\\n pre_sum += val\\n while pre_sum > S and i <= j:\\n print(pre_sum, i)\\n pre_sum -= A[i]\\n i += 1\\n res += j-i+1\\n return res\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n if len(A)==0:\\n return 0\\n \\n def atmost(m):\\n if m<0:\\n return 0\\n \\n res=i=0\\n for j in range(len(A)):\\n m-=A[j]\\n while(m<0):\\n m+=A[i]\\n i+=1\\n res+=(j-i+1)\\n return res\\n \\n return atmost(S)-atmost(S-1)\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n def atMost(S):\\n ans,l,tmp = 0,0,0\\n\\n for r in range(len(A)):\\n tmp = tmp + A[r]\\n while (tmp > S and l <= r): \\n tmp = tmp- A[l]\\n l = l + 1\\n ans += r - l + 1\\n return ans\\n\\n return atMost(S) - atMost(S - 1)\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n # HashMap\\n # count = {0:1}\\n # presum = res = 0\\n # for num in A:\\n # presum += num\\n # if presum - S in count:\\n # res += count[presum - S]\\n # count[presum] = count.get(presum, 0) + 1\\n # return res\\n \\n # two pointers\\n # def atMost(k):\\n # n = len(A)\\n # left = presum = res = 0\\n # for right in range(n):\\n # presum += A[right]\\n # while left <= right and presum > k:\\n # presum -= A[left]\\n # left += 1\\n # res += right - left + 1\\n # return res\\n # return atMost(S) - atMost(S - 1)\\n \\n left = res = cur_sum = count = 0\\n for right in range(len(A)):\\n cur_sum += A[right]\\n if A[right] == 1:\\n count = 0\\n while left <= right and cur_sum >= S:\\n if cur_sum == S:\\n count += 1\\n cur_sum -= A[left]\\n left += 1\\n res += count\\n return res\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n '''\\n Subarray sum = k problem\\n '''\\n \\n cur = 0\\n res = 0\\n dp = collections.defaultdict(int)\\n dp[0] = 1\\n for i in range(len(A)):\\n cur+=A[i]\\n diff = cur-S\\n if diff in dp:\\n res+=dp[diff]\\n dp[cur]+=1\\n \\n return res\\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A, S):\\n return self.numSubarraysAtMostSum(A, S) - self.numSubarraysAtMostSum(A, S - 1)\\n \\n def numSubarraysAtMostSum(self, A, S):\\n if S < 0:\\n return 0\\n if not A:\\n return 0\\n n = len(A)\\n right = 0\\n now_sum = 0\\n res = 0\\n for left in range(n):\\n while right <= n - 1 and (now_sum < S or A[right] == 0):\\n now_sum += A[right]\\n right += 1\\n res += right - left\\n now_sum -= A[left]\\n return res \",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n # n = len(A)\\n # l = 0\\n # sums = 0\\n # add = 1\\n # ans = 0\\n # for r in range(n):\\n # sums += A[r]\\n # while sums > S or A[l] == 0:\\n # if sums > S:\\n # add = 1\\n # else:\\n # add += 1\\n # sums -= A[l]\\n # l += 1\\n # if sums == S:\\n # ans += add\\n # return ans\\n \\n hashmap = {0:1}\\n preSum = 0\\n ans = 0\\n for i in range(len(A)):\\n preSum += A[i]\\n if preSum - S in hashmap:\\n ans += hashmap[preSum -S]\\n hashmap[preSum] = 1 if preSum not in hashmap else hashmap[preSum] + 1\\n return ans\\n \\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n if not A or S < 0:\\n return 0\\n \\n map = Counter()\\n map[0] = 1\\n sum = 0\\n res = 0\\n for num in A:\\n sum += num\\n if sum - S in map:\\n res += map[sum-S]\\n map[sum] += 1\\n return res\\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, nums: List[int], k: int) -> int:\\n if not nums: return 0\\n\\n counter = collections.defaultdict(int)\\n counter[0] = 1\\n cumsum = 0\\n ans = 0\\n for i in range(len(nums)):\\n cumsum += nums[i]\\n if cumsum-k in counter:\\n ans += counter[cumsum-k]\\n counter[cumsum] += 1\\n return ans\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n size = len(A)\\n prefix = {0: 1}\\n cnt = 0\\n ans = 0\\n \\n for i, num in enumerate(A):\\n if num == 1: cnt += 1\\n if cnt - S in prefix:\\n ans += prefix[cnt-S]\\n prefix[cnt] = prefix.get(cnt, 0) + 1\\n \\n return ans\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n A = [0] + list(itertools.accumulate(A))\\n hm = Counter()\\n res = 0\\n for i in A:\\n res += hm[i]\\n hm[i+S] += 1\\n return res\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n count = {0:1}\\n prefix = 0\\n result = 0\\n \\n for a in A:\\n prefix = (prefix+a)\\n #print(prefix)\\n if prefix-S in count:\\n result += count[prefix-S]\\n if prefix in count:\\n count[prefix] += 1\\n else:\\n count[prefix] = 1\\n return result \\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n \\n if S==0 and sum(A)==0:\\n return len(A)*(len(A)+1)//2\\n \\n \\n def atmost(s):\\n \\n if s<0:\\n return 0\\n sumi=s\\n l=0\\n r=0\\n count=0\\n \\n \\n while r<len(A):\\n \\n sumi-=A[r]\\n \\n while sumi<0:\\n sumi+=A[l]\\n l+=1\\n \\n count+=(r-l+1)\\n r+=1\\n \\n return count\\n \\n \\n return atmost(S) - atmost(S-1)\\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n d = {0: 1}\\n ss = 0\\n for i in A:\\n ss += i\\n d[ss] = d.get(ss,0)+1\\n res = 0\\n print(d)\\n if S > 0:\\n for i in range(ss-S+1):\\n res += d[i]*d[i+S]\\n if S == 0:\\n for i in range(ss+1):\\n res += d[i]*(d[i]-1)//2\\n return res \\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n counter=collections.Counter({0:1})\\n s=0\\n c=0\\n for a in A:\\n s+=a\\n c+=counter[s-S]\\n counter[s]+=1\\n return c\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n P = [0]\\n for x in A: P.append(P[-1] + x)\\n count = collections.Counter()\\n\\n ans = 0\\n for x in P:\\n ans += count[x]\\n count[x + S] += 1\\n\\n return ans\\n# count=0\\n# ind = 0\\n# while ind < len(A):\\n# sum=A[ind]\\n# if sum == S:\\n# count += 1\\n# if A[ind] == 1:\\n# for y in A[ind+1:]:\\n# sum += y\\n# if sum == S:\\n# count += 1\\n# elif sum > S:\\n# break\\n# ind += 1\\n# else:\\n# zc = 1\\n# zero = True\\n# for y in A[ind+1:]:\\n# sum += y\\n# if y == 0 and zero:\\n# zc += 1\\n# else:\\n# zero = False\\n# if sum == S:\\n# count += zc\\n# elif sum > S:\\n# break\\n# ind += zc\\n# return count\\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n p = [0]\\n for i in A:\\n p.append(p[-1]+i)\\n cnt = collections.Counter()\\n\\n res = 0\\n for i in p:\\n res += cnt[i]\\n cnt[i+S] += 1\\n return res\\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n \\n d = defaultdict(int)\\n d[0] = 1\\n psum = res = 0\\n for a in A:\\n psum += a \\n res += d[psum - S]\\n d[psum]+=1 \\n return res\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n \\n P = [0]\\n for x in A: P.append(P[-1] + x)\\n count = collections.Counter()\\n\\n ans = 0\\n for x in P:\\n ans += count[x]\\n count[x + S] += 1\\n\\n return ans\\n \\n \\n\\n \\n \\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n numToFreq = {}\\n numToFreq[0] = 1\\n now_sum = 0\\n ans = 0\\n for num in A:\\n now_sum += num\\n if now_sum == S:\\n ans += (numToFreq[0])\\n elif now_sum > S:\\n if now_sum - S in numToFreq:\\n ans += (numToFreq[now_sum - S])\\n \\n if now_sum not in numToFreq:\\n numToFreq[now_sum] = 0\\n numToFreq[now_sum] += 1\\n return ans\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n n = len(A)\\n \\n def num_subar_at_most(lim):\\n subarr_ct = 0\\n r_sum = 0\\n li = 0\\n for ri in range(n):\\n r_sum += A[ri]\\n while li <= ri and r_sum > lim:\\n r_sum -= A[li]\\n li += 1\\n subarr_ct += ri - li + 1\\n return subarr_ct\\n \\n return num_subar_at_most(S) - num_subar_at_most(S - 1)\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n cumsum = 0\\n dic = {0:[-1]}\\n ans = 0\\n for i,num in enumerate(A):\\n cumsum += num\\n dic[cumsum] = dic.get(cumsum,[]) + [i]\\n ans += len(dic.get(cumsum-S,[]))\\n #print(ans,dic)\\n return ans - (0 if S else len(A))\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n ans=0\\n il,ih,sl,sh=0,0,0,0\\n for j,x in enumerate(A):\\n sl+=x\\n while il<j and sl>S:\\n sl-=A[il]\\n il+=1\\n \\n sh+=x\\n while ih<j and (sh>S or sh==S and not A[ih]):\\n sh-=A[ih]\\n ih+=1\\n \\n if sl==S:\\n ans+=ih-il+1\\n return ans\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n \\n count = 0\\n output = 0\\n left = 0\\n \\n for right in range(len(A)):\\n S -= A[right]\\n if A[right] == 1:\\n count = 0\\n while left <= right and S <= 0:\\n if S == 0:\\n count += 1\\n S += A[left]\\n left += 1\\n output += count\\n \\n return output\\n \\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n def helper(k):\\n if k < 0:\\n return 0\\n num = 0\\n i = 0\\n for j in range(len(A)):\\n k -= A[j]\\n \\n while k < 0:\\n k += A[i]\\n i += 1\\n num += j-i+1\\n return num\\n return helper(S)-helper(S-1)\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n c = collections.Counter({0: 1})\\n psum = res = 0\\n for i in A:\\n psum += i\\n res += c[psum - S]\\n c[psum] += 1\\n return res\\n\\n \\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n n = len(A)\\n \\n i, j, total, res = 0, 0, 0, 0\\n while j < n:\\n total += A[j]\\n while i < j and total > S:\\n total -= A[i]\\n i += 1\\n if total == S:\\n res += 1\\n # There could be multiple 0 between i & j.\\n k = i\\n while k < j and A[k] == 0:\\n k += 1\\n res += 1\\n j += 1\\n return res\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n i, s, res, count = 0, 0, 0, 1\\n \\n for j in range(len(A)): \\n s += A[j]\\n while i < j and (s > S or A[i] == 0):\\n if A[i]:\\n s -= A[i]\\n count = 1\\n else:\\n count += 1 \\n i += 1 \\n \\n if s == S:\\n res += count\\n \\n return res\\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n result = 0\\n left, right, count = 0, 0, 0\\n for right in range(len(A)):\\n S -= A[right]\\n if A[right] == 1:\\n count = 0\\n while S <= 0 and left <= right:\\n if S == 0:\\n count += 1\\n S += A[left]\\n left += 1\\n result += count\\n return result\\n \\n \\n \\n \\n \\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n \\n count = {0:1}\\n total = maxS = 0\\n \\n for num in A:\\n total += num\\n maxS += count.get(total-S,0)\\n count[total] = count.get(total,0)+1\\n\\n return maxS\\n \\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n ctr = collections.Counter({0:1})\\n prefix = res = 0\\n for a in A:\\n prefix += a\\n res += ctr[prefix - S]\\n ctr[prefix] += 1\\n return res\\n\",\n \"class Solution:\\n def numSubarraysWithSum(self, A: List[int], S: int) -> int:\\n c = collections.Counter({0: 1})\\n psum = res = 0\\n for i in A:\\n psum += i\\n res += c[psum - S]\\n c[psum] += 1\\n return res\\n\"\n]","isConversational":false},"n_sols":{"kind":"number","value":55,"string":"55"},"non_interactive_idx":{"kind":"list like","value":[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],"string":"[\n 0,\n 1,\n 2,\n 3,\n 4,\n 5,\n 6,\n 7,\n 8,\n 9,\n 10,\n 11,\n 12,\n 13,\n 14,\n 15,\n 16,\n 17,\n 18,\n 19,\n 20,\n 21,\n 22,\n 23,\n 24,\n 25,\n 26,\n 27,\n 28,\n 29,\n 30,\n 31,\n 32,\n 33,\n 34,\n 35,\n 36,\n 37,\n 38,\n 39,\n 40,\n 41,\n 42,\n 43,\n 44,\n 45,\n 46,\n 47,\n 48,\n 49,\n 50,\n 51,\n 52,\n 53,\n 54\n]","isConversational":false},"interaction_reason":{"kind":"list like","value":[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],"string":"[\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null,\n null\n]","isConversational":false},"requires_input()":{"kind":"bool","value":false,"string":"false"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":0,"numItemsPerPage":100,"numTotalItems":2973,"offset":0,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NjQ4NTYwNywic3ViIjoiL2RhdGFzZXRzL2p2ZWxqYS9hcHBzX3Jlc2h1ZmZsZWRfZmlsdGVyZWQiLCJleHAiOjE3NzY0ODkyMDcsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.3-wEqEvEuDE0EwLDBioX6kYk-5e4IH9wkAKqVwSBNDCuwicMtRLLINNJQhwDPynP2zJOim-bjVtAUgZwedg_Bw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":2973,"numBytesParquet":31138406},{"config":"default","split":"test","numRows":331,"numBytesParquet":4310065}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
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 ... | ["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 ... | {"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 ... | 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... | [
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 answe... | ["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)... | {"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... | 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
... | ["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 ... | {"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 ... | 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... | {"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",
"... | 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 rules:
The number of unique characters in the substring must be less than or equal to maxLetters.
The substring size must be between minSize and maxSize inclusive.
Example 1:
Input: s = "aababcaab", maxLetters = 2, minSiz... | ["class Solution:\n def maxFreq(self, s: str, maxLetters: int, minSize: int, maxSize: int) -> int:\n n = len(s)\n count = collections.Counter(s[i : i + minSize] for i in range(0, n - minSize + 1))\n res = 0 \n for k, v in count.items():\n if len(set(k)) <= maxLetters:\n ... | {"fn_name": "maxFreq", "inputs": [["\"aababcaab\"", 2, 3, 4]], "outputs": [2]} | interview | https://leetcode.com/problems/maximum-number-of-occurrences-of-a-substring/ |
class Solution:
def maxFreq(self, s: str, maxLetters: int, minSize: int, maxSize: int) -> int:
| [
"class Solution:\n def maxFreq(self, s: str, maxLetters: int, minSize: int, maxSize: int) -> int:\n n = len(s)\n count = collections.Counter(s[i : i + minSize] for i in range(0, n - minSize + 1))\n res = 0 \n for k, v in count.items():\n if len(set(k)) <= maxLetters:\n ... | 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,
36,
37,
38,
39,
40,
41,
42,
43,
44,
45,
46,
47,
48,
49,
50,
51,
52,
53,
54... | [
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 |
127 | There is a group of G members, and a list of various crimes they could commit.
The ith crime generates a profit[i] and requires group[i] members to participate in it.
If a member participates in one crime, that member can't participate in another crime.
Let's call a profitable scheme any subset of these crimes that gen... | ["class Solution:\n def profitableSchemes(self, G: int, P: int, group: List[int], profit: List[int]) -> int:\n MOD = 10**9 + 7\n group_len, profit_len = len(group),len(profit)\n dp = [[0]*(G+1) for _ in range(P+1)]\n dp[0][0] = 1\n for pro, gro in zip(profit,group):\n dp... | {"fn_name": "profitableSchemes", "inputs": [[5, 3, [2, 2], [2, 3]]], "outputs": [2]} | interview | https://leetcode.com/problems/profitable-schemes/ |
class Solution:
def profitableSchemes(self, G: int, P: int, group: List[int], profit: List[int]) -> int:
| [
"class Solution:\n def profitableSchemes(self, G: int, P: int, group: List[int], profit: List[int]) -> int:\n MOD = 10**9 + 7\n group_len, profit_len = len(group),len(profit)\n dp = [[0]*(G+1) for _ in range(P+1)]\n dp[0][0] = 1\n for pro, gro in zip(profit,group):\n ... | 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,
36,
37,
38,
39,
40,
41,
42,
43,
44,
45,
46,
47,
48,
49,
50,
51,
52,
53,
54... | [
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 |
128 | Implement a basic calculator to evaluate a simple expression string.
The expression string may contain open ( and closing parentheses ), the plus + or minus sign -, non-negative integers and empty spaces .
Example 1:
Input: "1 + 1"
Output: 2
Example 2:
Input: " 2-1 + 2 "
Output: 3
Example 3:
Input: "(1+(4+5... | ["class Solution:\n def calculate(self, s):\n \"\"\"\n :type s: str\n :rtype: int\n \"\"\"\n res = 0\n num = 0\n sign = 1\n stk = []\n \n for c in s:\n if c.isdigit():\n num = 10 * num + (ord(c) - ord('0'))\n ... | {"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 :rtype: int\n \"\"\"\n res = 0\n num = 0\n sign = 1\n stk = []\n \n for c in s:\n if c.isdigit():\n num = 10 * num + (ord(c) - ord('0'))\n ... | 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 two sightseeing spots i and j have distance j - i between them.
The score of a pair (i < j) of sightseeing spots is (A[i] + A[j] + i - j) : the sum of the values of the sightseeing spots, minus the distance between them.
... | ["class Solution:\n def maxScoreSightseeingPair(self, A: List[int]) -> int:\n curmaxsight = A[0] - 1\n curmaxpair = 0\n for sight in A[1:]:\n if sight + curmaxsight > curmaxpair:\n curmaxpair = sight + curmaxsight\n if sight > curmaxsight:\n cu... | {"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 = A[0] - 1\n curmaxpair = 0\n for sight in A[1:]:\n if sight + curmaxsight > curmaxpair:\n curmaxpair = sight + curmaxsight\n if sight > curmaxsight:\n ... | 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,
36,
37,
38,
39,
40,
41,
42,
43,
44,
45,
46,
47,
48,
49,
50,
51,
52,
53,
54... | [
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 |
130 | A program was supposed to print an array of integers. The program forgot to print whitespaces and the array is printed as a string of digits and all we know is that all integers in the array were in the range [1, k] and there are no leading zeros in the array.
Given the string s and the integer k. There can be multiple... | ["class Solution:\n def numberOfArrays(self, s: str, k: int) -> int:\n dp = [-1] * len(s)\n return self.dfs(s, k, 0, dp)\n \n def dfs(self, s: str, k: int, start: int, dp: List[int]) -> int:\n if start == len(s):\n return 1\n if s[start] == '0':\n return 0\n ... | {"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)\n return self.dfs(s, k, 0, dp)\n \n def dfs(self, s: str, k: int, start: int, dp: List[int]) -> int:\n if start == len(s):\n return 1\n if s[start] == '0':\n return 0\n... | 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 of.
The syntax for these expressions is given as follows.
An expression is either an integer, a let-expression, an add-expression, a mult-expression, or an assigned variable. Expressions always evaluate to a single inte... | ["class Solution(object):\n \tdef parse(self,expression,d,i):\n \t\tcount = 0\n \t\tstart = i\n \t\tif expression[i] == \"(\":\n \t\t\tcount += 1\n \t\t\ti += 1\n \t\t\twhile count != 0:\n \t\t\t\tif expression[i] == \"(\":\n \t\t\t\t\tcount += 1\n \t\t\t\telif expression[i] == \")\":\n \t\t\t\t\tcount -= 1\n \t\t\t\ti... | {"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\tif expression[i] == \"(\":\n \t\t\tcount += 1\n \t\t\ti += 1\n \t\t\twhile count != 0:\n \t\t\t\tif expression[i] == \"(\":\n \t\t\t\t\tcount += 1\n \t\t\t\telif expression[i] == \")\":\n \t\t\t\t\tcount -= 1\n \t\t\t... | 1 | [
0
] | [
null
] | false |
132 | In a country popular for train travel, you have planned some train travelling one year in advance. The days of the year that you will travel is given as an array days. Each day is an integer from 1 to 365.
Train tickets are sold in 3 different ways:
a 1-day pass is sold for costs[0] dollars;
a 7-day pass is sold for... | ["class Solution:\n def mincostTickets(self, days: List[int], costs: List[int]) -> int:\n dp = [0] + [-1 for i in range(days[-1])]\n \n for day in days:\n dp[day] = 0\n \n for i in range(1, len(dp)):\n if dp[i] == -1:\n dp[i] = dp[i-1]\n ... | {"fn_name": "mincostTickets", "inputs": [[[1, 4, 6, 7, 8, 20], [2, 7, 15]]], "outputs": [11]} | interview | https://leetcode.com/problems/minimum-cost-for-tickets/ |
class Solution:
def mincostTickets(self, days: List[int], costs: List[int]) -> int:
| [
"class Solution:\n def mincostTickets(self, days: List[int], costs: List[int]) -> int:\n dp = [0] + [-1 for i in range(days[-1])]\n \n for day in days:\n dp[day] = 0\n \n for i in range(1, len(dp)):\n if dp[i] == -1:\n dp[i] = dp[i-1]\n ... | 21 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
133 | You are given a string containing only 4 kinds of characters 'Q', 'W', 'E' and 'R'.
A string is said to be balanced if each of its characters appears n/4 times where n is the length of the string.
Return the minimum length of the substring that can be replaced with any other string of the same length to make the origin... | ["class Solution:\n def balancedString(self, s: str) -> int:\n # minimum window so that outside is possible\n if len(s) //4 != len(s) / 4: return -1 \n ans, lb, n_cnt = len(s), 0, collections.Counter(s)\n\n i = 0\n while i < len(s): \n n_cnt[s[i]] -= 1 \n ... | {"fn_name": "balancedString", "inputs": [["\"QWER\""]], "outputs": [-1]} | interview | https://leetcode.com/problems/replace-the-substring-for-balanced-string/ |
class Solution:
def balancedString(self, s: str) -> int:
| [
"class Solution:\n def balancedString(self, s: str) -> int:\n # minimum window so that outside is possible\n if len(s) //4 != len(s) / 4: return -1 \n ans, lb, n_cnt = len(s), 0, collections.Counter(s)\n\n i = 0\n while i < len(s): \n n_cnt[s[i]] -= 1 \n ... | 7 | [
0,
1,
2,
3,
4,
5,
6
] | [
null,
null,
null,
null,
null,
null,
null
] | false |
135 | Given two sequences pushed and popped with distinct values, return true if and only if this could have been the result of a sequence of push and pop operations on an initially empty stack.
Example 1:
Input: pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
Output: true
Explanation: We might do the following sequence:
push(... | ["class Solution:\n def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:\n j = 0\n l = []\n for i in pushed:\n l.append(i)\n while l and (l[-1] == popped[j]):\n l.pop()\n j += 1\n if l:\n return Fals... | {"fn_name": "validateStackSequences", "inputs": [[[1, 2, 3, 4, 5], [4, 5, 3, 2, 1]]], "outputs": [true]} | interview | https://leetcode.com/problems/validate-stack-sequences/ |
class Solution:
def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:
| [
"class Solution:\n def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:\n j = 0\n l = []\n for i in pushed:\n l.append(i)\n while l and (l[-1] == popped[j]):\n l.pop()\n j += 1\n if l:\n return F... | 20 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
137 | Given an integer n, you must transform it into 0 using the following operations any number of times:
Change the rightmost (0th) bit in the binary representation of n.
Change the ith bit in the binary representation of n if the (i-1)th bit is set to 1 and the (i-2)th through 0th bits are set to 0.
Return the minimum n... | ["class Solution:\n def minimumOneBitOperations(self, n: int) -> int:\n s = 0\n m = n\n while m:\n s += m & 1\n m >>= 1\n\n k = 1\n while s:\n s -= bool(n & k)\n n ^= (s & 1) and k\n k <<= 1\n\n return n", "class Solutio... | {"fn_name": "minimumOneBitOperations", "inputs": [[0]], "outputs": [0]} | interview | https://leetcode.com/problems/minimum-one-bit-operations-to-make-integers-zero/ |
class Solution:
def minimumOneBitOperations(self, n: int) -> int:
| [
"class Solution:\n def minimumOneBitOperations(self, n: int) -> int:\n s = 0\n m = n\n while m:\n s += m & 1\n m >>= 1\n\n k = 1\n while s:\n s -= bool(n & k)\n n ^= (s & 1) and k\n k <<= 1\n\n return n",
"class So... | 8 | [
0,
1,
2,
3,
4,
5,
6,
7
] | [
null,
null,
null,
null,
null,
null,
null,
null
] | false |
138 | Given an array of integers nums, find the maximum length of a subarray where the product of all its elements is positive.
A subarray of an array is a consecutive sequence of zero or more values taken out of that array.
Return the maximum length of a subarray with positive product.
Example 1:
Input: nums = [1,-2,-3,4]... | ["class Solution:\n def getMaxLen(self, nums: List[int]) -> int:\n maxx = 0\n nums.append(0)\n \n # starting position\n # where we find a 0\n i = -1\n minusarr = []\n \n for j,n in enumerate(nums):\n if n == 0:\n # now figure ou... | {"fn_name": "getMaxLen", "inputs": [[[1, -2, -3, 4]]], "outputs": [4]} | interview | https://leetcode.com/problems/maximum-length-of-subarray-with-positive-product/ |
class Solution:
def getMaxLen(self, nums: List[int]) -> int:
| [
"class Solution:\n def getMaxLen(self, nums: List[int]) -> int:\n maxx = 0\n nums.append(0)\n \n # starting position\n # where we find a 0\n i = -1\n minusarr = []\n \n for j,n in enumerate(nums):\n if n == 0:\n # now figure... | 253 | [
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... | [
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 |
139 | We are given an array A of N lowercase letter strings, all of the same length.
Now, we may choose any set of deletion indices, and for each string, we delete all the characters in those indices.
For example, if we have an array A = ["abcdef","uvwxyz"] and deletion indices {0, 2, 3}, then the final array after deletions... | ["class Solution:\n def minDeletionSize(self, A: List[str]) -> int:\n def isSorted(arr, i, j):\n return all(arr[k] <= arr[k+1] for k in range(i, j))\n ans = 0\n ranges = [[0, len(A)-1]]\n for col in zip(*A):\n if not ranges:\n break\n if all... | {"fn_name": "minDeletionSize", "inputs": [[["\"ca\"", "\"bb\"", "\"ac\""]]], "outputs": [1]} | interview | https://leetcode.com/problems/delete-columns-to-make-sorted-ii/ |
class Solution:
def minDeletionSize(self, A: List[str]) -> int:
| [
"class Solution:\n def minDeletionSize(self, A: List[str]) -> int:\n def isSorted(arr, i, j):\n return all(arr[k] <= arr[k+1] for k in range(i, j))\n ans = 0\n ranges = [[0, len(A)-1]]\n for col in zip(*A):\n if not ranges:\n break\n if ... | 9 | [
0,
1,
2,
3,
4,
5,
6,
7,
8
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
140 | Given a non-empty array of numbers, a0, a1, a2, … , an-1, where 0 ≤ ai < 231.
Find the maximum result of ai XOR aj, where 0 ≤ i, j < n.
Could you do this in O(n) runtime?
Example:
Input: [3, 10, 5, 25, 2, 8]
Output: 28
Explanation: The maximum result is 5 ^ 25 = 28. | ["class Solution:\n def findMaximumXOR(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n ans = 0\n for bit in range(31, -1, -1) :\n ans = (ans << 1) + 1\n pre = set()\n for n in nums :\n p = (n >... | {"fn_name": "findMaximumXOR", "inputs": [[[3, 10, 5, 25, 2, 8]]], "outputs": [28]} | interview | https://leetcode.com/problems/maximum-xor-of-two-numbers-in-an-array/ |
class Solution:
def findMaximumXOR(self, nums: List[int]) -> int:
| [
"class Solution:\n def findMaximumXOR(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n ans = 0\n for bit in range(31, -1, -1) :\n ans = (ans << 1) + 1\n pre = set()\n for n in nums :\n p = (... | 2 | [
0,
1
] | [
null,
null
] | false |
142 | Given a list of strings, you need to find the longest uncommon subsequence among them. The longest uncommon subsequence is defined as the longest subsequence of one of these strings and this subsequence should not be any subsequence of the other strings.
A subsequence is a sequence that can be derived from one seque... | ["class Solution:\n def findLUSlength(self, strs):\n \"\"\"\n :type strs: List[str]\n :rtype: int\n \"\"\"\n def isSubseq(s1, s2):\n i, m=0, len(s1)\n for c in s2:\n if i==m: return True\n if s1[i]==c: i+=1\n ... | {"fn_name": "findLUSlength", "inputs": [[["\"aba\"", "\"cdc\"", "\"eae\""]]], "outputs": [5]} | interview | https://leetcode.com/problems/longest-uncommon-subsequence-ii/ |
class Solution:
def findLUSlength(self, strs: List[str]) -> int:
| [
"class Solution:\n def findLUSlength(self, strs):\n \"\"\"\n :type strs: List[str]\n :rtype: int\n \"\"\"\n def isSubseq(s1, s2):\n i, m=0, len(s1)\n for c in s2:\n if i==m: return True\n if s1[i]==c: i+=1\n ... | 11 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
143 | In a row of trees, the i-th tree produces fruit with type tree[i].
You start at any tree of your choice, then repeatedly perform the following steps:
Add one piece of fruit from this tree to your baskets. If you cannot, stop.
Move to the next tree to the right of the current tree. If there is no tree to the right, s... | ["class Solution:\n def totalFruit(self, tree: List[int]) -> int:\n prior_fruit = tree[0]\n prior_fruit_counter = 0\n fruits_in_basket = [tree[0]]\n fruits_in_basket_counter = 0\n max_fib = -1\n for fruit in tree: \n if prior_fruit == fruit:\n prior... | {"fn_name": "totalFruit", "inputs": [[[1, 2, 1]]], "outputs": [3]} | interview | https://leetcode.com/problems/fruit-into-baskets/ |
class Solution:
def totalFruit(self, tree: List[int]) -> int:
| [
"class Solution:\n def totalFruit(self, tree: List[int]) -> int:\n prior_fruit = tree[0]\n prior_fruit_counter = 0\n fruits_in_basket = [tree[0]]\n fruits_in_basket_counter = 0\n max_fib = -1\n for fruit in tree: \n if prior_fruit == fruit:\n pr... | 206 | [
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... | [
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 |
144 | Initially on a notepad only one character 'A' is present. You can perform two operations on this notepad for each step:
Copy All: You can copy all the characters present on the notepad (partial copy is not allowed).
Paste: You can paste the characters which are copied last time.
Given a number n. You have to get ... | ["class Solution:\n def minSteps(self, n):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n primeFactors=[]\n for i in range(2,int(n**.5)+1):\n while n%i==0:\n primeFactors.append(i)\n n=n//i\n if n>1:\n ... | {"fn_name": "minSteps", "inputs": [[3]], "outputs": [3]} | interview | https://leetcode.com/problems/2-keys-keyboard/ |
class Solution:
def minSteps(self, n: int) -> int:
| [
"class Solution:\n def minSteps(self, n):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n primeFactors=[]\n for i in range(2,int(n**.5)+1):\n while n%i==0:\n primeFactors.append(i)\n n=n//i\n if n>1:\n ... | 11 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
145 | You have 4 cards each containing a number from 1 to 9. You need to judge whether they could operated through *, /, +, -, (, ) to get the value of 24.
Example 1:
Input: [4, 1, 8, 7]
Output: True
Explanation: (8-4) * (7-1) = 24
Example 2:
Input: [1, 2, 1, 2]
Output: False
Note:
The division operator / represe... | ["class Solution(object):\n def judgePoint24(self, nums):\n bad = '\ub5a2\ube3b\uac01\uac4e\ub0c7\uac05\uac38\uae9a\ubd5f\uc223\uc684\ubd74\ubd5e\ub93c\uac08\uac0c\ub914\ub58c\uc60a\uba54\ub284\uc22d\uceb8\uae36\uae9b\uc616\uac0d\ub1d0\uca62\uacf4\ub4c7\uac6f\uad84\uc615\uc679\ub21e\uc1b4\uac43\ub057\uae2c\... | {"fn_name": "judgePoint24", "inputs": [[[4, 1, 8, 7]]], "outputs": [true]} | interview | https://leetcode.com/problems/24-game/ |
class Solution:
def judgePoint24(self, nums: List[int]) -> bool:
| [
"class Solution(object):\n def judgePoint24(self, nums):\n bad = '떢븻각걎냇갅갸꺚뵟숣욄뵴뵞뤼갈갌뤔떌옊메늄숭캸긶꺛옖갍뇐쩢곴듇걯궄옕왹눞솴걃끗긬땉궿가쌀낐걄숤뺴늘걘꽸숢걂갋갃쫐꼔솾쩡쇔솿끛뤜간븺쩬웨딴옠뤛갂뵪덠놤빐옋귒늂갰갖놥궾갆옌뼘묰거갎긷낤겼'\n return chr(int(''.join(map(str, sorted(nums)))) + 42921) not in bad\n",
"class Solution:\n def judgePoint24(self, nums):\n ... | 6 | [
0,
1,
2,
3,
4,
5
] | [
null,
null,
null,
null,
null,
null
] | false |
146 | Given an encoded string, return it's decoded string.
The encoding rule is: k[encoded_string], where the encoded_string inside the square brackets is being repeated exactly k times. Note that k is guaranteed to be a positive integer.
You may assume that the input string is always valid; No extra white spaces, square... | ["class Solution:\n def decodeString(self, s):\n \"\"\"\n :type s: str\n :rtype: str\n \"\"\"\n stack = []\n stack.append([\"\", 1])\n num = \"\"\n for ch in s:\n if ch.isdigit():\n num += ch\n elif ch == '[':\n ... | {"fn_name": "decodeString", "inputs": [["\"3[a]2[bc]\""]], "outputs": ["\"aaabcbc\""]} | interview | https://leetcode.com/problems/decode-string/ |
class Solution:
def decodeString(self, s: str) -> str:
| [
"class Solution:\n def decodeString(self, s):\n \"\"\"\n :type s: str\n :rtype: str\n \"\"\"\n stack = []\n stack.append([\"\", 1])\n num = \"\"\n for ch in s:\n if ch.isdigit():\n num += ch\n elif ch == '[':\n... | 6 | [
0,
1,
2,
3,
4,
5
] | [
null,
null,
null,
null,
null,
null
] | false |
147 | There are n engineers numbered from 1 to n and two arrays: speed and efficiency, where speed[i] and efficiency[i] represent the speed and efficiency for the i-th engineer respectively. Return the maximum performance of a team composed of at most k engineers, since the answer can be a huge number, return this modulo 10^... | ["class Solution:\n def maxPerformance(self, n: int, speed: List[int], efficiency: List[int], k: int) -> int:\n mod = 10**9+7\n \n order = sorted(range(n), key=lambda i: efficiency[i], reverse=True)\n\n heap = []\n filled = 0\n rec = 0\n speed_sum = 0\n\n for i... | {"fn_name": "maxPerformance", "inputs": [[6, [2, 10, 3, 1, 5, 8], [5, 4, 3, 9, 7, 2], 2]], "outputs": [60]} | interview | https://leetcode.com/problems/maximum-performance-of-a-team/ |
class Solution:
def maxPerformance(self, n: int, speed: List[int], efficiency: List[int], k: int) -> int:
| [
"class Solution:\n def maxPerformance(self, n: int, speed: List[int], efficiency: List[int], k: int) -> int:\n mod = 10**9+7\n \n order = sorted(range(n), key=lambda i: efficiency[i], reverse=True)\n\n heap = []\n filled = 0\n rec = 0\n speed_sum = 0\n\n fo... | 70 | [
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... | [
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 |
148 | We have jobs: difficulty[i] is the difficulty of the ith job, and profit[i] is the profit of the ith job.
Now we have some workers. worker[i] is the ability of the ith worker, which means that this worker can only complete a job with difficulty at most worker[i].
Every worker can be assigned at most one job, but one ... | ["class Solution:\n def maxProfitAssignment(self, difficulty: List[int], profit: List[int], worker: List[int]) -> int:\n ws = sorted(worker, reverse=True)\n dp = sorted(zip(difficulty, profit), key=lambda x: x[1], reverse=True)\n # print(list(dp))\n \n i = 0\n total = 0\n ... | {"fn_name": "maxProfitAssignment", "inputs": [[[2, 4, 6, 8, 10], [10, 20, 30, 40, 50], [4, 5, 6, 7]]], "outputs": [100]} | interview | https://leetcode.com/problems/most-profit-assigning-work/ |
class Solution:
def maxProfitAssignment(self, difficulty: List[int], profit: List[int], worker: List[int]) -> int:
| [
"class Solution:\n def maxProfitAssignment(self, difficulty: List[int], profit: List[int], worker: List[int]) -> int:\n ws = sorted(worker, reverse=True)\n dp = sorted(zip(difficulty, profit), key=lambda x: x[1], reverse=True)\n # print(list(dp))\n \n i = 0\n total = 0\n... | 89 | [
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... | [
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 |
150 | Given an array A, partition it into two (contiguous) subarrays left and right so that:
Every element in left is less than or equal to every element in right.
left and right are non-empty.
left has the smallest possible size.
Return the length of left after such a partitioning. It is guaranteed that such a partitioni... | ["class Solution:\n def partitionDisjoint(self, A: List[int]) -> int:\n biggest = A[0]\n newbiggest = A[0]\n lenL = 1\n total = 1\n for itr in A[1:]:\n total += 1\n if itr < biggest:\n lenL = total\n biggest = newbiggest\n ... | {"fn_name": "partitionDisjoint", "inputs": [[[5, 0, 3, 8, 6]]], "outputs": [3]} | interview | https://leetcode.com/problems/partition-array-into-disjoint-intervals/ |
class Solution:
def partitionDisjoint(self, A: List[int]) -> int:
| [
"class Solution:\n def partitionDisjoint(self, A: List[int]) -> int:\n biggest = A[0]\n newbiggest = A[0]\n lenL = 1\n total = 1\n for itr in A[1:]:\n total += 1\n if itr < biggest:\n lenL = total\n biggest = newbiggest\n ... | 51 | [
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,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
41,
42,
43,
44,
45,
46,
47,
48,
49,
50
] | [
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,
"syntax-error: cannot use starred expression here",
null,
null,
null,
... | false |
151 | A password is considered strong if below conditions are all met:
It has at least 6 characters and at most 20 characters.
It must contain at least one lowercase letter, at least one uppercase letter, and at least one digit.
It must NOT contain three repeating characters in a row ("...aaa..." is weak, but "...aa..... | ["class Solution:\n def strongPasswordChecker(self, s):\n \"\"\"\n :type s: str\n :rtype: int\n \"\"\"\n def length_requirement(password):\n length = len(password)\n # positive means addition, negative means deletion\n if length < 6:\n ... | {"fn_name": "strongPasswordChecker", "inputs": [["\"a\""]], "outputs": [3]} | interview | https://leetcode.com/problems/strong-password-checker/ |
class Solution:
def strongPasswordChecker(self, s: str) -> int:
| [
"class Solution:\n def strongPasswordChecker(self, s):\n \"\"\"\n :type s: str\n :rtype: int\n \"\"\"\n def length_requirement(password):\n length = len(password)\n # positive means addition, negative means deletion\n if length < 6:\n ... | 2 | [
0,
1
] | [
null,
null
] | false |
153 | Remember the story of Little Match Girl? By now, you know exactly what matchsticks the little match girl has, please find out a way you can make one square by using up all those matchsticks. You should not break any stick, but you can link them up, and each matchstick must be used exactly one time.
Your input will be... | ["class Solution:\n def makesquare(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: bool\n \"\"\"\n if len(nums) < 4:\n return False\n \n length = sum(nums)\n if length % 4:\n return False\n length = (int) (length... | {"fn_name": "makesquare", "inputs": [[[1, 1, 2, 2, 2]]], "outputs": [true]} | interview | https://leetcode.com/problems/matchsticks-to-square/ |
class Solution:
def makesquare(self, nums: List[int]) -> bool:
| [
"class Solution:\n def makesquare(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: bool\n \"\"\"\n if len(nums) < 4:\n return False\n \n length = sum(nums)\n if length % 4:\n return False\n length = (int) (len... | 4 | [
0,
1,
2,
3
] | [
null,
null,
null,
null
] | false |
154 | Given a rectangular cake with height h and width w, and two arrays of integers horizontalCuts and verticalCuts where horizontalCuts[i] is the distance from the top of the rectangular cake to the ith horizontal cut and similarly, verticalCuts[j] is the distance from the left of the rectangular cake to the jth vertical c... | ["class Solution:\n def maxArea(self, h: int, w: int, horizontalCuts: List[int], verticalCuts: List[int]) -> int:\n mod = int(1e9)+7\n return ( ( self.getMax(horizontalCuts, h) % mod ) * ( self.getMax(verticalCuts, w) % mod ) ) % mod\n \n def getMax(self, cuts, size):\n if len(cuts) ==... | {"fn_name": "maxArea", "inputs": [[5, 4, [1, 2, 4], [1, 3]]], "outputs": [4]} | interview | https://leetcode.com/problems/maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/ |
class Solution:
def maxArea(self, h: int, w: int, horizontalCuts: List[int], verticalCuts: List[int]) -> int:
| [
"class Solution:\n def maxArea(self, h: int, w: int, horizontalCuts: List[int], verticalCuts: List[int]) -> int:\n mod = int(1e9)+7\n return ( ( self.getMax(horizontalCuts, h) % mod ) * ( self.getMax(verticalCuts, w) % mod ) ) % mod\n \n def getMax(self, cuts, size):\n if len(cuts)... | 51 | [
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
] | [
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 |
155 | Given an array of integers arr and an integer d. In one step you can jump from index i to index:
i + x where: i + x < arr.length and 0 < x <= d.
i - x where: i - x >= 0 and 0 < x <= d.
In addition, you can only jump from index i to index j if arr[i] > arr[j] and arr[i] > arr[k] for all indices k between i and j (Mo... | ["class Solution:\n def maxJumps(self, arr: List[int], d: int) -> int:\n dp = [1] * (len(arr) + 1)\n stack = []\n for i, n in enumerate(arr + [1000000]):\n while stack and arr[stack[-1]] < n:\n same_height_idx = [stack.pop()]\n while stack and arr[stack[-... | {"fn_name": "maxJumps", "inputs": [[[6, 4, 14, 6, 8, 13, 9, 7, 10, 6, 12], 2]], "outputs": [4]} | interview | https://leetcode.com/problems/jump-game-v/ |
class Solution:
def maxJumps(self, arr: List[int], d: int) -> int:
| [
"class Solution:\n def maxJumps(self, arr: List[int], d: int) -> int:\n dp = [1] * (len(arr) + 1)\n stack = []\n for i, n in enumerate(arr + [1000000]):\n while stack and arr[stack[-1]] < n:\n same_height_idx = [stack.pop()]\n while stack and arr[stac... | 120 | [
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... | [
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 |
156 | Given two strings str1 and str2, return the shortest string that has both str1 and str2 as subsequences. If multiple answers exist, you may return any of them.
(A string S is a subsequence of string T if deleting some number of characters from T (possibly 0, and the characters are chosen anywhere from T) results in th... | ["import sys\n\ndef dp(s1, s2, i, j, mem):\n if (i, j) in mem:\n return mem[(i, j)]\n elif i >= len(s1) and j >= len(s2):\n res = ''\n elif i >= len(s1):\n res = s2[j:]\n elif j >= len(s2):\n res = s1[i:]\n else:\n if s1[i] == s2[j]:\n res = s1[i] + dp(s1, s2... | {"fn_name": "shortestCommonSupersequence", "inputs": [["\"abac\"", "\"cab\""]], "outputs": ["\"cabac\""]} | interview | https://leetcode.com/problems/shortest-common-supersequence/ |
class Solution:
def shortestCommonSupersequence(self, str1: str, str2: str) -> str:
| [
"import sys\n\ndef dp(s1, s2, i, j, mem):\n if (i, j) in mem:\n return mem[(i, j)]\n elif i >= len(s1) and j >= len(s2):\n res = ''\n elif i >= len(s1):\n res = s2[j:]\n elif j >= len(s2):\n res = s1[i:]\n else:\n if s1[i] == s2[j]:\n res = s1[i] + dp(s1,... | 58 | [
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... | [
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 |
157 | Given an input string (s) and a pattern (p), implement wildcard pattern matching with support for '?' and '*'.
'?' Matches any single character.
'*' Matches any sequence of characters (including the empty sequence).
The matching should cover the entire input string (not partial).
Note:
s could be empty an... | ["class Solution:\n def isMatch(self, s, p):\n \"\"\"\n :type s: str\n :type p: str\n :rtype: bool\n \"\"\"\n '''\u7ef4\u62a4\u4e24\u4e2a\u4e0b\u6807\uff0c\u9010\u4e2a\u6bd4\u8f83\uff0c\u5982\u679cpj\u4e3a*\uff0c\u5219\u8bb0\u5f55*\u7684\u4f4d\u7f6e\uff0c\u5c06*\u540e... | {"fn_name": "isMatch", "inputs": [["\"aa\"", "\"a\""]], "outputs": [false]} | interview | https://leetcode.com/problems/wildcard-matching/ |
class Solution:
def isMatch(self, s: str, p: str) -> bool:
| [
"class Solution:\n def isMatch(self, s, p):\n \"\"\"\n :type s: str\n :type p: str\n :rtype: bool\n \"\"\"\n '''维护两个下标，逐个比较，如果pj为*，则记录*的位置，将*后一个元素与si进行比较，如果不相等，则将i从记录的位置+1，重新比较'''\n i=0\n j=0\n star=-1\n lenp=len(p)\n while ... | 4 | [
0,
1,
2,
3
] | [
null,
null,
null,
null
] | false |
158 | Strings A and B are K-similar (for some non-negative integer K) if we can swap the positions of two letters in A exactly K times so that the resulting string equals B.
Given two anagrams A and B, return the smallest K for which A and B are K-similar.
Example 1:
Input: A = "ab", B = "ba"
Output: 1
Example 2:
Input: A ... | ["class Solution:\n def kSimilarity(self, A: str, B: str) -> int:\n a = ''\n b = ''\n \n for i in range(len(A)):\n if A[i] != B[i]:\n a+=A[i]\n b+=B[i]\n \n return self.dfs(a,b)\n \n def dfs(self,a,b):\n if not... | {"fn_name": "kSimilarity", "inputs": [["\"ab\"", "\"ba\""]], "outputs": [1]} | interview | https://leetcode.com/problems/k-similar-strings/ |
class Solution:
def kSimilarity(self, A: str, B: str) -> int:
| [
"class Solution:\n def kSimilarity(self, A: str, B: str) -> int:\n a = ''\n b = ''\n \n for i in range(len(A)):\n if A[i] != B[i]:\n a+=A[i]\n b+=B[i]\n \n return self.dfs(a,b)\n \n def dfs(self,a,b):\n if ... | 99 | [
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... | [
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 |
159 | Given an integer array nums and an integer k, return the maximum sum of a non-empty subsequence of that array such that for every two consecutive integers in the subsequence, nums[i] and nums[j], where i < j, the condition j - i <= k is satisfied.
A subsequence of an array is obtained by deleting some number of element... | ["from collections import deque\nclass Solution:\n def constrainedSubsetSum(self, nums, k):\n N, queue = len(nums), deque()\n dp = [val for val in nums]\n for i, val in enumerate(nums):\n if queue and (i - queue[0] > k):\n queue.popleft()\n if queue and dp[qu... | {"fn_name": "constrainedSubsetSum", "inputs": [[[10, 2, -10, 5, 20], 2]], "outputs": [37]} | interview | https://leetcode.com/problems/constrained-subsequence-sum/ |
class Solution:
def constrainedSubsetSum(self, nums: List[int], k: int) -> int:
| [
"from collections import deque\nclass Solution:\n def constrainedSubsetSum(self, nums, k):\n N, queue = len(nums), deque()\n dp = [val for val in nums]\n for i, val in enumerate(nums):\n if queue and (i - queue[0] > k):\n queue.popleft()\n if queue and dp... | 77 | [
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... | [
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 |
160 | Alex and Lee play a game with piles of stones. There are an even number of piles arranged in a row, and each pile has a positive integer number of stones piles[i].
The objective of the game is to end with the most stones. The total number of stones is odd, so there are no ties.
Alex and Lee take turns, with Alex star... | ["class Solution:\n def stoneGame(self, piles: List[int]) -> bool:\n return True", "class Solution:\n def stoneGame(self, piles: List[int]) -> bool:\n return 1;\n", "class Solution:\n def recur(self,i,j,piles,n,dp,s):\n if j==i+1:\n return max(piles[i],piles[j])\n if dp[i... | {"fn_name": "stoneGame", "inputs": [[[5, 3, 4, 5]]], "outputs": [true]} | interview | https://leetcode.com/problems/stone-game/ |
class Solution:
def stoneGame(self, piles: List[int]) -> bool:
| [
"class Solution:\n def stoneGame(self, piles: List[int]) -> bool:\n return True",
"class Solution:\n def stoneGame(self, piles: List[int]) -> bool:\n return 1;\n",
"class Solution:\n def recur(self,i,j,piles,n,dp,s):\n if j==i+1:\n return max(piles[i],piles[j])\n ... | 181 | [
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... | [
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 |
161 | One way to serialize a binary tree is to use pre-order traversal. When we encounter a non-null node, we record the node's value. If it is a null node, we record using a sentinel value such as #.
_9_
/ \
3 2
/ \ / \
4 1 # 6
/ \ / \ / \
# # # # # #
For example, the above binary tree can... | ["class Solution(object):\n def isValidSerialization(self, preorder):\n \"\"\"\n :type preorder: str\n :rtype: bool\n \"\"\"\n # remember how many empty slots we have\n # non-null nodes occupy one slot but create two new slots\n # null nodes occupy one slot\n ... | {"fn_name": "isValidSerialization", "inputs": [["\"9,3,4,#,#,1,#,#,2,#,6,#,#\""]], "outputs": [false]} | interview | https://leetcode.com/problems/verify-preorder-serialization-of-a-binary-tree/ |
class Solution:
def isValidSerialization(self, preorder: str) -> bool:
| [
"class Solution(object):\n def isValidSerialization(self, preorder):\n \"\"\"\n :type preorder: str\n :rtype: bool\n \"\"\"\n # remember how many empty slots we have\n # non-null nodes occupy one slot but create two new slots\n # null nodes occupy one slot... | 10 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
162 | Given two strings text1 and text2, return the length of their longest common subsequence.
A subsequence of a string is a new string generated from the original string with some characters(can be none) deleted without changing the relative order of the remaining characters. (eg, "ace" is a subsequence of "abcde" while "... | ["class Solution:\n def longestCommonSubsequence(self, a: str, b: str) -> int:\n last, current = [0] * (len(b) + 1), [0] * (len(b) + 1)\n \n for i in range(len(a) - 1, -1, -1):\n for j in range(len(b) - 1, -1, -1):\n if a[i] == b[j]:\n current[j] = 1 ... | {"fn_name": "longestCommonSubsequence", "inputs": [["\"abcde\"", "\"ace\""]], "outputs": [5]} | interview | https://leetcode.com/problems/longest-common-subsequence/ |
class Solution:
def longestCommonSubsequence(self, text1: str, text2: str) -> int:
| [
"class Solution:\n def longestCommonSubsequence(self, a: str, b: str) -> int:\n last, current = [0] * (len(b) + 1), [0] * (len(b) + 1)\n \n for i in range(len(a) - 1, -1, -1):\n for j in range(len(b) - 1, -1, -1):\n if a[i] == b[j]:\n current[j] =... | 274 | [
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... | [
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 |
163 | Given a string s and a string t, check if s is subsequence of t.
You may assume that there is only lower case English letters in both s and t. t is potentially a very long (length ~= 500,000) string, and s is a short string (
A subsequence of a string is a new string which is formed from the original string by del... | ["class Solution:\n def isSubsequence(self, s, t):\n \"\"\"\n :type s: str\n :type t: str\n :rtype: bool\n \"\"\"\n if len(s) > len(t):\n return False\n for i in s:\n if i in t:\n index = t.find(i)\n t = ... | {"fn_name": "isSubsequence", "inputs": [["\"abc\"", "\"ahbgdc\""]], "outputs": [true]} | interview | https://leetcode.com/problems/is-subsequence/ |
class Solution:
def isSubsequence(self, s: str, t: str) -> bool:
| [
"class Solution:\n def isSubsequence(self, s, t):\n \"\"\"\n :type s: str\n :type t: str\n :rtype: bool\n \"\"\"\n if len(s) > len(t):\n return False\n for i in s:\n if i in t:\n index = t.find(i)\n t... | 11 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
165 | Given a string and a string dictionary, find the longest string in the dictionary that can be formed by deleting some characters of the given string. If there are more than one possible results, return the longest word with the smallest lexicographical order. If there is no possible result, return the empty string.
Ex... | ["class Solution:\n def findLongestWord(self, s, d):\n \"\"\"\n :type s: str\n :type d: List[str]\n :rtype: str\n \"\"\"\n result = ''\n for word in d:\n lo = 0\n for l in word:\n lo = s.find(l, lo)+1\n i... | {"fn_name": "findLongestWord", "inputs": [["\"abpcplea\"", ["\"ale\"", "\"apple\"", "\"monkey\"", "\"plea\""]]], "outputs": ["\"apple\""]} | interview | https://leetcode.com/problems/longest-word-in-dictionary-through-deleting/ |
class Solution:
def findLongestWord(self, s: str, d: List[str]) -> str:
| [
"class Solution:\n def findLongestWord(self, s, d):\n \"\"\"\n :type s: str\n :type d: List[str]\n :rtype: str\n \"\"\"\n result = ''\n for word in d:\n lo = 0\n for l in word:\n lo = s.find(l, lo)+1\n ... | 4 | [
0,
1,
2,
3
] | [
null,
null,
null,
null
] | false |
166 | Given 3 positives numbers a, b and c. Return the minimum flips required in some bits of a and b to make ( a OR b == c ). (bitwise OR operation).
Flip operation consists of change any single bit 1 to 0 or change the bit 0 to 1 in their binary representation.
Example 1:
Input: a = 2, b = 6, c = 5
Output: 3
Explanation... | ["class Solution:\n def minFlips(self, a: int, b: int, c: int) -> int:\n flips = 0\n print(bin(a))\n print(bin(b))\n print(bin(c))\n while a or b or c:\n # print(a, b, c)\n if c % 2:\n if not (a % 2 or b % 2):\n flips += 1\n ... | {"fn_name": "minFlips", "inputs": [[2, 6, 5]], "outputs": [3]} | interview | https://leetcode.com/problems/minimum-flips-to-make-a-or-b-equal-to-c/ |
class Solution:
def minFlips(self, a: int, b: int, c: int) -> int:
| [
"class Solution:\n def minFlips(self, a: int, b: int, c: int) -> int:\n flips = 0\n print(bin(a))\n print(bin(b))\n print(bin(c))\n while a or b or c:\n # print(a, b, c)\n if c % 2:\n if not (a % 2 or b % 2):\n flips += 1\... | 7 | [
0,
1,
2,
3,
4,
5,
6
] | [
null,
null,
null,
null,
null,
null,
null
] | false |
167 | You are given K eggs, and you have access to a building with N floors from 1 to N.
Each egg is identical in function, and if an egg breaks, you cannot drop it again.
You know that there exists a floor F with 0 <= F <= N such that any egg dropped at a floor higher than F will break, and any egg dropped at or below floo... | ["class Solution:\n def superEggDrop(self, K: int, N: int) -> int:\n def f(t):\n a=0\n r=1\n for i in range(1, K+1):\n r *= (t-i+1)\n r//=i\n a+=r\n if a>=N: \n break\n return a\n ... | {"fn_name": "superEggDrop", "inputs": [[1, 2]], "outputs": [2]} | interview | https://leetcode.com/problems/super-egg-drop/ |
class Solution:
def superEggDrop(self, K: int, N: int) -> int:
| [
"class Solution:\n def superEggDrop(self, K: int, N: int) -> int:\n def f(t):\n a=0\n r=1\n for i in range(1, K+1):\n r *= (t-i+1)\n r//=i\n a+=r\n if a>=N: \n break\n return a\n ... | 179 | [
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... | [
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 |
168 | Given a string s and an integer k. You should construct k non-empty palindrome strings using all the characters in s.
Return True if you can use all the characters in s to construct k palindrome strings or False otherwise.
Example 1:
Input: s = "annabelle", k = 2
Output: true
Explanation: You can construct two palind... | ["from collections import Counter\nclass Solution:\n def canConstruct(self, s: str, k: int) -> bool:\n if k > len(s): #return False\n return False\n counter = Counter(s)\n odd_counts = 0\n \n for char in counter:\n if counter[char] % 2 == 1:\n o... | {"fn_name": "canConstruct", "inputs": [["\"annabelle\"", 2]], "outputs": [true]} | interview | https://leetcode.com/problems/construct-k-palindrome-strings/ |
class Solution:
def canConstruct(self, s: str, k: int) -> bool:
| [
"from collections import Counter\nclass Solution:\n def canConstruct(self, s: str, k: int) -> bool:\n if k > len(s): #return False\n return False\n counter = Counter(s)\n odd_counts = 0\n \n for char in counter:\n if counter[char] % 2 == 1:\n ... | 35 | [
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
] | [
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 |
169 | Given a positive integer n, break it into the sum of at least two positive integers and maximize the product of those integers. Return the maximum product you can get.
For example, given n = 2, return 1 (2 = 1 + 1); given n = 10, return 36 (10 = 3 + 3 + 4).
Note: You may assume that n is not less than 2 and not l... | ["class Solution:\n def integerBreak(self, n):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n if n==2:return 1\n if n==3:return 2\n res=1\n while n>4:\n n=n-3\n res*=3\n return res*n\n", "class Solution:\n def inte... | {"fn_name": "integerBreak", "inputs": [[2]], "outputs": [1]} | interview | https://leetcode.com/problems/integer-break/ |
class Solution:
def integerBreak(self, n: int) -> int:
| [
"class Solution:\n def integerBreak(self, n):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n if n==2:return 1\n if n==3:return 2\n res=1\n while n>4:\n n=n-3\n res*=3\n return res*n\n",
"class Solution:\n def... | 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 |
170 | Given an integer array arr, remove a subarray (can be empty) from arr such that the remaining elements in arr are non-decreasing.
A subarray is a contiguous subsequence of the array.
Return the length of the shortest subarray to remove.
Example 1:
Input: arr = [1,2,3,10,4,2,3,5]
Output: 3
Explanation: The shortest su... | ["class Solution:\n def findLengthOfShortestSubarray(self, arr: List[int]) -> int:\n n = len(arr)\n if n<=1: \n return 0\n l,r = n,-1\n \n for i in range(1,n):\n if arr[i]<arr[i-1]:\n l = i\n break\n # monotonicially increa... | {"fn_name": "findLengthOfShortestSubarray", "inputs": [[[1, 2, 3, 10, 4, 2, 3, 5]]], "outputs": [3]} | interview | https://leetcode.com/problems/shortest-subarray-to-be-removed-to-make-array-sorted/ |
class Solution:
def findLengthOfShortestSubarray(self, arr: List[int]) -> int:
| [
"class Solution:\n def findLengthOfShortestSubarray(self, arr: List[int]) -> int:\n n = len(arr)\n if n<=1: \n return 0\n l,r = n,-1\n \n for i in range(1,n):\n if arr[i]<arr[i-1]:\n l = i\n break\n # monotonicially inc... | 131 | [
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... | [
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 |
172 | You are given an integer num. You will apply the following steps exactly two times:
Pick a digit x (0 <= x <= 9).
Pick another digit y (0 <= y <= 9). The digit y can be equal to x.
Replace all the occurrences of x in the decimal representation of num by y.
The new integer cannot have any leading zeros, also the new in... | ["class Solution:\n def maxDiff(self, num: int) -> int:\n if num < 10: return 8\n a = b = str(num)\n i = 0\n while i < len(a):\n if a[i] == '9':\n i += 1\n else:\n a = a.replace(a[i], '9')\n break\n\n if b[0] != '1'... | {"fn_name": "maxDiff", "inputs": [[555]], "outputs": [888]} | interview | https://leetcode.com/problems/max-difference-you-can-get-from-changing-an-integer/ |
class Solution:
def maxDiff(self, num: int) -> int:
| [
"class Solution:\n def maxDiff(self, num: int) -> int:\n if num < 10: return 8\n a = b = str(num)\n i = 0\n while i < len(a):\n if a[i] == '9':\n i += 1\n else:\n a = a.replace(a[i], '9')\n break\n\n if b[0] != ... | 9 | [
0,
1,
2,
3,
4,
5,
6,
7,
8
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
173 | Given an array of integers arr of even length n and an integer k.
We want to divide the array into exactly n / 2 pairs such that the sum of each pair is divisible by k.
Return True If you can find a way to do that or False otherwise.
Example 1:
Input: arr = [1,2,3,4,5,10,6,7,8,9], k = 5
Output: true
Explanation: Pair... | ["class Solution:\n def canArrange(self, arr: List[int], k: int) -> bool:\n freq = [0] * k\n \n for n in arr:\n freq[n%k] += 1\n \n if freq[0] % 2: return False\n \n for i in range(1, (k//2)+1):\n if freq[i] != freq[k-i]: return False\n \n ... | {"fn_name": "canArrange", "inputs": [[[1, 2, 3, 4, 5, 10, 6, 7, 8, 9], 5]], "outputs": [true]} | interview | https://leetcode.com/problems/check-if-array-pairs-are-divisible-by-k/ |
class Solution:
def canArrange(self, arr: List[int], k: int) -> bool:
| [
"class Solution:\n def canArrange(self, arr: List[int], k: int) -> bool:\n freq = [0] * k\n \n for n in arr:\n freq[n%k] += 1\n \n if freq[0] % 2: return False\n \n for i in range(1, (k//2)+1):\n if freq[i] != freq[k-i]: return False\n \n ... | 100 | [
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... | [
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 |
174 | Suppose we abstract our file system by a string in the following manner:
The string "dir\n\tsubdir1\n\tsubdir2\n\t\tfile.ext" represents:
dir
subdir1
subdir2
file.ext
The directory dir contains an empty sub-directory subdir1 and a sub-directory subdir2 containing a file file.ext.
The string "dir\n\... | ["class Solution:\n def lengthLongestPath(self, input):\n \"\"\"\n :type input: str\n :rtype: int\n \"\"\"\n dict={0:0}\n maxlen=0\n line=input.split(\"\\n\")\n for i in line:\n name=i.lstrip('\\t')\n print(name)\n p... | {"fn_name": "lengthLongestPath", "inputs": [["\"dir\\n\\tsubdir1\\n\\tsubdir2\\n\\t\\tfile.ext\""]], "outputs": [41]} | interview | https://leetcode.com/problems/longest-absolute-file-path/ |
class Solution:
def lengthLongestPath(self, input: str) -> int:
| [
"class Solution:\n def lengthLongestPath(self, input):\n \"\"\"\n :type input: str\n :rtype: int\n \"\"\"\n dict={0:0}\n maxlen=0\n line=input.split(\"\\n\")\n for i in line:\n name=i.lstrip('\\t')\n print(name)\n ... | 11 | [
3,
9
] | [
"builtin input()",
"builtin input()",
"builtin input()",
null,
"builtin input()",
"builtin input()",
"builtin input()",
"builtin input()",
"builtin input()",
null,
"builtin input()"
] | false |
175 | Given a positive integer n, find the number of non-negative integers less than or equal to n, whose binary representations do NOT contain consecutive ones.
Example 1:
Input: 5
Output: 5
Explanation:
Here are the non-negative integers
Note:
1 9 | ["class Solution:\n def findIntegers(self, num):\n \"\"\"\n :type num: int\n :rtype: int\n \"\"\"\n dp=[1,2]\n for i in range(2,32):\n dp.append(dp[i-1]+dp[i-2])\n \n bnum=bin(num)[2:]\n size=len(bnum)\n ans=dp[size]\n ... | {"fn_name": "findIntegers", "inputs": [[1]], "outputs": [2]} | interview | https://leetcode.com/problems/non-negative-integers-without-consecutive-ones/ |
class Solution:
def findIntegers(self, num: int) -> int:
| [
"class Solution:\n def findIntegers(self, num):\n \"\"\"\n :type num: int\n :rtype: int\n \"\"\"\n dp=[1,2]\n for i in range(2,32):\n dp.append(dp[i-1]+dp[i-2])\n \n bnum=bin(num)[2:]\n size=len(bnum)\n ans=dp[size]\n ... | 8 | [
0,
1,
2,
3,
4,
5,
6,
7
] | [
null,
null,
null,
null,
null,
null,
null,
null
] | false |
176 | Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.
Below is one possible representation of s1 = "great":
great
/ \
gr eat
/ \ / \
g r e at
/ \
a t
To scramble the string, we may choose any non-leaf node... | ["class Solution:\n def isScramble(self, A, B):\n if len(A) != len(B) or sorted(A) != sorted(B):\n return False\n \n if len(A) == 1 or A == B:\n return True\n \n for i in range(1, len(A)):\n if self.isScramble(A[:i], B[:i]) and self.isScramble(A[i:], B[i:]... | {"fn_name": "isScramble", "inputs": [["\"great\"", "\"rgeat\""]], "outputs": [true]} | interview | https://leetcode.com/problems/scramble-string/ |
class Solution:
def isScramble(self, s1: str, s2: str) -> bool:
| [
"class Solution:\n def isScramble(self, A, B):\n if len(A) != len(B) or sorted(A) != sorted(B):\n return False\n \n if len(A) == 1 or A == B:\n return True\n \n for i in range(1, len(A)):\n if self.isScramble(A[:i], B[:i]) and self.isScramble(A[i:], B[... | 10 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
177 | Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).
Example:
Input: S = "ADOBECODEBANC", T = "ABC"
Output: "BANC"
Note:
If there is no such window in S that covers all characters in T, return the empty string "".
If there is s... | ["class Solution:\n def minWindow(self, s, t):\n \"\"\"\n :type s: str\n :type t: str\n :rtype: str\n \"\"\"\n left=-1\n right = 0\n result = \"\"\n totalMatch = 0\n d = {}\n for c in t:\n d[c] = d.get(c, 0) + 1\n \n... | {"fn_name": "minWindow", "inputs": [["\"ADOBECODEBANC\"", "\"ABC\""]], "outputs": ["\"ADOBECODEBANC\""]} | interview | https://leetcode.com/problems/minimum-window-substring/ |
class Solution:
def minWindow(self, s: str, t: str) -> str:
| [
"class Solution:\n def minWindow(self, s, t):\n \"\"\"\n :type s: str\n :type t: str\n :rtype: str\n \"\"\"\n left=-1\n right = 0\n result = \"\"\n totalMatch = 0\n d = {}\n for c in t:\n d[c] = d.get(c, 0) + 1\n... | 4 | [
0,
1,
2,
3
] | [
null,
null,
null,
null
] | false |
178 | Given an unsorted array of integers, find the length of longest increasing subsequence.
Example:
Input: [10,9,2,5,3,7,101,18]
Output: 4
Explanation: The longest increasing subsequence is [2,3,7,101], therefore the length is 4.
Note:
There may be more than one LIS combination, it is only necessary for yo... | ["class Solution:\n def lengthOfLIS(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n if len(nums) == 0:\n return 0\n res = [nums[0]]\n def binarySearch(l,target):\n left , right = 0 , len(l)-1\n while l... | {"fn_name": "lengthOfLIS", "inputs": [[[10, 9, 2, 5, 3, 7, 101, 18]]], "outputs": [4]} | interview | https://leetcode.com/problems/longest-increasing-subsequence/ |
class Solution:
def lengthOfLIS(self, nums: List[int]) -> int:
| [
"class Solution:\n def lengthOfLIS(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n if len(nums) == 0:\n return 0\n res = [nums[0]]\n def binarySearch(l,target):\n left , right = 0 , len(l)-1\n whil... | 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 |
181 | Say you have an array for which the ith element is the price of a given stock on day i.
Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times) with the following restrictions:
You may not engage in multiple... | ["class Solution:\n def maxProfit(self, prices):\n \"\"\"\n :type prices: List[int]\n :rtype: int\n \"\"\"\n n = len(prices)\n \n if n < 2: return 0\n \n sells = [0] * n\n buys = [0] * n\n \n buys[0] = -prices[0]\n ... | {"fn_name": "maxProfit", "inputs": [[[1, 2, 3, 0, 2]]], "outputs": [3]} | interview | https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/ |
class Solution:
def maxProfit(self, prices: List[int]) -> int:
| [
"class Solution:\n def maxProfit(self, prices):\n \"\"\"\n :type prices: List[int]\n :rtype: int\n \"\"\"\n n = len(prices)\n \n if n < 2: return 0\n \n sells = [0] * n\n buys = [0] * n\n \n buys[0] = -prices[0]\n ... | 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 |
182 | Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.
The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. Thanks Marcos for cont... | ["class Solution:\n def trap(self, height):\n \"\"\"\n :type height: List[int]\n :rtype: int\n \"\"\"\n if not height:\n return 0\n result = 0\n left = 0\n right = len(height) - 1\n while left < right:\n if height[left] ... | {"fn_name": "trap", "inputs": [[[0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1]]], "outputs": [6]} | interview | https://leetcode.com/problems/trapping-rain-water/ |
class Solution:
def trap(self, height: List[int]) -> int:
| [
"class Solution:\n def trap(self, height):\n \"\"\"\n :type height: List[int]\n :rtype: int\n \"\"\"\n if not height:\n return 0\n result = 0\n left = 0\n right = len(height) - 1\n while left < right:\n if height[lef... | 13 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
183 | Given two arrays nums1 and nums2.
Return the maximum dot product between non-empty subsequences of nums1 and nums2 with the same length.
A subsequence of a array is a new array which is formed from the original array by deleting some (can be none) of the characters without disturbing the relative positions of the remai... | ["class Solution:\n def maxDotProduct(self, nums1: List[int], nums2: List[int]) -> int:\n \n # DP(a=index of last, b=index of last) = max of:\n # DP(a-1, b)\n # DP(a-1, i) + nums1[a] * max_or_min(nums2[i+1:b+1])\n # same for b\n \n INF = int(1e9)\n n, m =... | {"fn_name": "maxDotProduct", "inputs": [[[2, 1, -2, 5], [3, 0, -6]]], "outputs": [18]} | interview | https://leetcode.com/problems/max-dot-product-of-two-subsequences/ |
class Solution:
def maxDotProduct(self, nums1: List[int], nums2: List[int]) -> int:
| [
"class Solution:\n def maxDotProduct(self, nums1: List[int], nums2: List[int]) -> int:\n \n # DP(a=index of last, b=index of last) = max of:\n # DP(a-1, b)\n # DP(a-1, i) + nums1[a] * max_or_min(nums2[i+1:b+1])\n # same for b\n \n INF = int(1e9)\n n, ... | 82 | [
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... | [
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 |
185 | Given a binary string s and an integer k.
Return True if every binary code of length k is a substring of s. Otherwise, return False.
Example 1:
Input: s = "00110110", k = 2
Output: true
Explanation: The binary codes of length 2 are "00", "01", "10" and "11". They can be all found as substrings at indicies 0, 1, 3 and... | ["class Solution:\n def hasAllCodes(self, s: str, k: int) -> bool:\n if len(s) < 2 ** k + k - 1:\n return False # Cannot be a string, as this is the de brujin length\n target = 2 ** k\n seen = set()\n cur_len = 0\n for end in range(k, len(s) + 1):\n chunk = s[... | {"fn_name": "hasAllCodes", "inputs": [["\"00110110\"", 2]], "outputs": [true]} | interview | https://leetcode.com/problems/check-if-a-string-contains-all-binary-codes-of-size-k/ |
class Solution:
def hasAllCodes(self, s: str, k: int) -> bool:
| [
"class Solution:\n def hasAllCodes(self, s: str, k: int) -> bool:\n if len(s) < 2 ** k + k - 1:\n return False # Cannot be a string, as this is the de brujin length\n target = 2 ** k\n seen = set()\n cur_len = 0\n for end in range(k, len(s) + 1):\n chunk =... | 38 | [
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
] | [
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 |
186 | Given an array of integers cost and an integer target. Return the maximum integer you can paint under the following rules:
The cost of painting a digit (i+1) is given by cost[i] (0 indexed).
The total cost used must be equal to target.
Integer does not have digits 0.
Since the answer may be too large, return it as st... | ["class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n dp = [0] + [-target]*target\n for t in range(1, target+1):\n dp[t] = max([dp[t-i] for i in cost if i<=t]+[dp[t]]) + 1\n if dp[-1]<=0: return '0'\n res = ''\n for i in range(8, -1, -1):\n ... | {"fn_name": "largestNumber", "inputs": [[[4, 3, 2, 5, 6, 7, 2, 5, 5], 9]], "outputs": ["7772"]} | interview | https://leetcode.com/problems/form-largest-integer-with-digits-that-add-up-to-target/ |
class Solution:
def largestNumber(self, cost: List[int], target: int) -> str:
| [
"class Solution:\n def largestNumber(self, cost: List[int], target: int) -> str:\n dp = [0] + [-target]*target\n for t in range(1, target+1):\n dp[t] = max([dp[t-i] for i in cost if i<=t]+[dp[t]]) + 1\n if dp[-1]<=0: return '0'\n res = ''\n for i in range(8, -1, -1):... | 48 | [
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
] | [
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 |
187 | You are the operator of a Centennial Wheel that has four gondolas, and each gondola has room for up to four people. You have the ability to rotate the gondolas counterclockwise, which costs you runningCost dollars.
You are given an array customers of length n where customers[i] is the number of new customers arriving j... | ["class Solution:\n def minOperationsMaxProfit(self, customers: List[int], boardingCost: int, runningCost: int) -> int:\n if runningCost >= 4 * boardingCost:\n return -1\n result = sum(customers) // 4\n if (sum(customers) % 4) * boardingCost > runningCost:\n result += 1\n ... | {"fn_name": "minOperationsMaxProfit", "inputs": [[[8, 3], 5, 6]], "outputs": [3]} | interview | https://leetcode.com/problems/maximum-profit-of-operating-a-centennial-wheel/ |
class Solution:
def minOperationsMaxProfit(self, customers: List[int], boardingCost: int, runningCost: int) -> int:
| [
"class Solution:\n def minOperationsMaxProfit(self, customers: List[int], boardingCost: int, runningCost: int) -> int:\n if runningCost >= 4 * boardingCost:\n return -1\n result = sum(customers) // 4\n if (sum(customers) % 4) * boardingCost > runningCost:\n result += 1\... | 572 | [
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... | [
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 |
188 | Convert a non-negative integer to its english words representation. Given input is guaranteed to be less than 231 - 1.
Example 1:
Input: 123
Output: "One Hundred Twenty Three"
Example 2:
Input: 12345
Output: "Twelve Thousand Three Hundred Forty Five"
Example 3:
Input: 1234567
Output: "One Million Two Hundred ... | ["class Solution:\n V1 = [\"\", \"One\", \"Two\", \"Three\", \"Four\", \"Five\", \"Six\", \"Seven\", \"Eight\", \"Nine\", \"Ten\",\n \"Eleven\", \"Twelve\", \"Thirteen\", \"Fourteen\", \"Fifteen\", \"Sixteen\", \"Seventeen\", \"Eighteen\", \"Nineteen\"]\n V2 = [\"\", \"\", \"Twenty\", \"Thirty\", \"Fo... | {"fn_name": "numberToWords", "inputs": [[123]], "outputs": ["One Hundred Twenty Three"]} | interview | https://leetcode.com/problems/integer-to-english-words/ |
class Solution:
def numberToWords(self, num: int) -> str:
| [
"class Solution:\n V1 = [\"\", \"One\", \"Two\", \"Three\", \"Four\", \"Five\", \"Six\", \"Seven\", \"Eight\", \"Nine\", \"Ten\",\n \"Eleven\", \"Twelve\", \"Thirteen\", \"Fourteen\", \"Fifteen\", \"Sixteen\", \"Seventeen\", \"Eighteen\", \"Nineteen\"]\n V2 = [\"\", \"\", \"Twenty\", \"Thirty\", \... | 10 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
190 | Given two integer arrays A and B, return the maximum length of an subarray that appears in both arrays.
Example 1:
Input:
A: [1,2,3,2,1]
B: [3,2,1,4,7]
Output: 3
Explanation:
The repeated subarray with maximum length is [3, 2, 1].
Note:
1
0 | ["class Solution:\n def findLength(self, A, B):\n def check(length):\n seen = {A[i:i+length]\n for i in range(len(A) - length + 1)}\n return any(B[j:j+length] in seen\n for j in range(len(B) - length + 1))\n \n A = ''.join(map(chr, A... | {"fn_name": "findLength", "inputs": [[[1, 2, 3, 2, 1], [3, 2, 1, 4, 7]]], "outputs": [3]} | interview | https://leetcode.com/problems/maximum-length-of-repeated-subarray/ |
class Solution:
def findLength(self, A: List[int], B: List[int]) -> int:
| [
"class Solution:\n def findLength(self, A, B):\n def check(length):\n seen = {A[i:i+length]\n for i in range(len(A) - length + 1)}\n return any(B[j:j+length] in seen\n for j in range(len(B) - length + 1))\n \n A = ''.join(map(chr... | 1 | [
0
] | [
null
] | false |
191 | Given an array of digits, you can write numbers using each digits[i] as many times as we want. For example, if digits = ['1','3','5'], we may write numbers such as '13', '551', and '1351315'.
Return the number of positive integers that can be generated that are less than or equal to a given integer n.
Example 1:
Inp... | ["class Solution:\n def atMostNGivenDigitSet(self, digits: List[str], n: int) -> int:\n \n count = 0\n length = 1\n n_str = str(n)\n while length < len(n_str):\n count+= len(digits)**length\n length+=1\n\n digits_sorted = sorted(digits)\n\n\n ## ... | {"fn_name": "atMostNGivenDigitSet", "inputs": [[["\"1\"", "\"3\"", "\"5\"", "\"7\""], 100]], "outputs": [84]} | interview | https://leetcode.com/problems/numbers-at-most-n-given-digit-set/ |
class Solution:
def atMostNGivenDigitSet(self, digits: List[str], n: int) -> int:
| [
"class Solution:\n def atMostNGivenDigitSet(self, digits: List[str], n: int) -> int:\n \n count = 0\n length = 1\n n_str = str(n)\n while length < len(n_str):\n count+= len(digits)**length\n length+=1\n\n digits_sorted = sorted(digits)\n\n\n ... | 3 | [
0,
1,
2
] | [
null,
null,
null
] | false |
192 | There are 3n piles of coins of varying size, you and your friends will take piles of coins as follows:
In each step, you will choose any 3 piles of coins (not necessarily consecutive).
Of your choice, Alice will pick the pile with the maximum number of coins.
You will pick the next pile with maximum number of coins.
Y... | ["class Solution:\n def maxCoins(self, piles: List[int]) -> int:\n piles.sort()\n \n i = 0\n j = len(piles) - 1\n \n max_coins = 0\n for i in range(len(piles) // 3, len(piles), 2):\n max_coins += piles[i]\n \n return max_coins", "class Solutio... | {"fn_name": "maxCoins", "inputs": [[[1, 2, 2, 4, 7, 8]]], "outputs": [9]} | interview | https://leetcode.com/problems/maximum-number-of-coins-you-can-get/ |
class Solution:
def maxCoins(self, piles: List[int]) -> int:
| [
"class Solution:\n def maxCoins(self, piles: List[int]) -> int:\n piles.sort()\n \n i = 0\n j = len(piles) - 1\n \n max_coins = 0\n for i in range(len(piles) // 3, len(piles), 2):\n max_coins += piles[i]\n \n return max_coins",
"class So... | 245 | [
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... | [
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 |
193 | Given an array arr. You can choose a set of integers and remove all the occurrences of these integers in the array.
Return the minimum size of the set so that at least half of the integers of the array are removed.
Example 1:
Input: arr = [3,3,3,3,5,5,5,2,2,7]
Output: 2
Explanation: Choosing {3,7} will make the new ... | ["from heapq import *\nfrom collections import Counter\n\nclass Solution:\n def minSetSize(self, arr: List[int]) -> int:\n \n counter = Counter(arr)\n size = len(arr)\n \n # unique elements (remove half of them)\n if len(counter) == size:\n return (size - 1) // 2 ... | {"fn_name": "minSetSize", "inputs": [[[3, 3, 3, 3, 5, 5, 5, 2, 2, 7]]], "outputs": [2]} | interview | https://leetcode.com/problems/reduce-array-size-to-the-half/ |
class Solution:
def minSetSize(self, arr: List[int]) -> int:
| [
"from heapq import *\nfrom collections import Counter\n\nclass Solution:\n def minSetSize(self, arr: List[int]) -> int:\n \n counter = Counter(arr)\n size = len(arr)\n \n # unique elements (remove half of them)\n if len(counter) == size:\n return (size - 1) //... | 120 | [
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... | [
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 |
194 | Given an array of integers nums and a positive integer k, find whether it's possible to divide this array into k non-empty subsets whose sums are all equal.
Example 1:
Input: nums = [4, 3, 2, 3, 5, 2, 1], k = 4
Output: True
Explanation: It's possible to divide it into 4 subsets (5), (1, 4), (2,3), (2,3) with equal su... | ["class Solution:\n def canPartitionKSubsets(self, nums, k):\n \"\"\"\n :type nums: List[int]\n :type k: int\n :rtype: bool\n \"\"\"\n target,rem=divmod(sum(nums),k)\n if rem or max(nums)>target: return False\n n=len(nums)\n seen=[0]*n\n ... | {"fn_name": "canPartitionKSubsets", "inputs": [[[5, 4, 3, 3, 2, 2, 1], 4]], "outputs": [true]} | interview | https://leetcode.com/problems/partition-to-k-equal-sum-subsets/ |
class Solution:
def canPartitionKSubsets(self, nums: List[int], k: int) -> bool:
| [
"class Solution:\n def canPartitionKSubsets(self, nums, k):\n \"\"\"\n :type nums: List[int]\n :type k: int\n :rtype: bool\n \"\"\"\n target,rem=divmod(sum(nums),k)\n if rem or max(nums)>target: return False\n n=len(nums)\n seen=[0]*n\n ... | 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 |
195 | Given an array of integers A, find the number of triples of indices (i, j, k) such that:
0 <= i < A.length
0 <= j < A.length
0 <= k < A.length
A[i] & A[j] & A[k] == 0, where & represents the bitwise-AND operator.
Example 1:
Input: [2,1,3]
Output: 12
Explanation: We could choose the following i, j, k triples:
(i=0, ... | ["class Solution:\n def countTriplets(self, A: List[int]) -> int:\n counters = [0] * (1 << 16)\n counters[0] = len(A)\n for num in A:\n mask = (~num) & ((1 << 16) - 1)\n sm = mask\n while sm != 0:\n counters[sm] += 1\n sm = (sm - 1) ... | {"fn_name": "countTriplets", "inputs": [[[2, 1, 3]]], "outputs": [12]} | interview | https://leetcode.com/problems/triples-with-bitwise-and-equal-to-zero/ |
class Solution:
def countTriplets(self, A: List[int]) -> int:
| [
"class Solution:\n def countTriplets(self, A: List[int]) -> int:\n counters = [0] * (1 << 16)\n counters[0] = len(A)\n for num in A:\n mask = (~num) & ((1 << 16) - 1)\n sm = mask\n while sm != 0:\n counters[sm] += 1\n sm = (sm - ... | 61 | [
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... | [
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 |
196 | Given a circular array C of integers represented by A, find the maximum possible sum of a non-empty subarray of C.
Here, a circular array means the end of the array connects to the beginning of the array. (Formally, C[i] = A[i] when 0 <= i < A.length, and C[i+A.length] = C[i] when i >= 0.)
Also, a subarray may only in... | ["class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n N = len(A)\n if(N==0):\n return 0\n curr_max = A[0]\n global_max = A[0]\n curr_min = A[0]\n global_min = A[0]\n flag = 0 \n if(A[0]>=0):\n flag=1\n \n f... | {"fn_name": "maxSubarraySumCircular", "inputs": [[[-2, 3, -2, 1]]], "outputs": [3]} | interview | https://leetcode.com/problems/maximum-sum-circular-subarray/ |
class Solution:
def maxSubarraySumCircular(self, A: List[int]) -> int:
| [
"class Solution:\n def maxSubarraySumCircular(self, A: List[int]) -> int:\n N = len(A)\n if(N==0):\n return 0\n curr_max = A[0]\n global_max = A[0]\n curr_min = A[0]\n global_min = A[0]\n flag = 0 \n if(A[0]>=0):\n flag=1\n \n ... | 124 | [
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... | [
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 |
197 | Given a string s, determine if it is valid.
A string s is valid if, starting with an empty string t = "", you can transform t into s after performing the following operation any number of times:
Insert string "abc" into any position in t. More formally, t becomes tleft + "abc" + tright, where t == tleft + tright. Note... | ["class Solution:\n def isValid(self, s: str) -> bool:\n if not s:\n return True\n return self.isValid(s.replace('abc', '')) if s.replace('abc', '') != s else False\n", "class Solution:\n def isValid(self, S: str) -> bool:\n stack = []\n for i in S:\n if i == 'c':... | {"fn_name": "isValid", "inputs": [["\"aabcbc\""]], "outputs": [false]} | interview | https://leetcode.com/problems/check-if-word-is-valid-after-substitutions/ |
class Solution:
def isValid(self, s: str) -> bool:
| [
"class Solution:\n def isValid(self, s: str) -> bool:\n if not s:\n return True\n return self.isValid(s.replace('abc', '')) if s.replace('abc', '') != s else False\n",
"class Solution:\n def isValid(self, S: str) -> bool:\n stack = []\n for i in S:\n if i ==... | 38 | [
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
] | [
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 |
198 | You are given two strings s and t of the same length. You want to change s to t. Changing the i-th character of s to i-th character of t costs |s[i] - t[i]| that is, the absolute difference between the ASCII values of the characters.
You are also given an integer maxCost.
Return the maximum length of a substring of s t... | ["class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n dist = [ abs( ord(s[i]) - ord(t[i]) ) for i in range(len(s))]\n \n# i = 0\n# cur = 0\n# res = 0\n# for j in range(len(s)):\n# cur += dist[j]\n# while cur>maxCost... | {"fn_name": "equalSubstring", "inputs": [["\"abcd\"", "\"bcdf\"", 3]], "outputs": [4]} | interview | https://leetcode.com/problems/get-equal-substrings-within-budget/ |
class Solution:
def equalSubstring(self, s: str, t: str, maxCost: int) -> int:
| [
"class Solution:\n def equalSubstring(self, s: str, t: str, maxCost: int) -> int:\n dist = [ abs( ord(s[i]) - ord(t[i]) ) for i in range(len(s))]\n \n# i = 0\n# cur = 0\n# res = 0\n# for j in range(len(s)):\n# cur += dist[j]\n# while cur>maxC... | 34 | [
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
] | [
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 |
199 | Given an unsorted array of integers, find the length of the longest consecutive elements sequence.
Your algorithm should run in O(n) complexity.
Example:
Input: [100, 4, 200, 1, 3, 2]
Output: 4
Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4. | ["class Solution:\n def longestConsecutive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n longest_streak = 0\n num_set = set(nums)\n for num in num_set:\n if num - 1 not in num_set:\n current_num = num\n ... | {"fn_name": "longestConsecutive", "inputs": [[[100, 4, 200, 1, 3, 2]]], "outputs": [4]} | interview | https://leetcode.com/problems/longest-consecutive-sequence/ |
class Solution:
def longestConsecutive(self, nums: List[int]) -> int:
| [
"class Solution:\n def longestConsecutive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n longest_streak = 0\n num_set = set(nums)\n for num in num_set:\n if num - 1 not in num_set:\n current_num = num\n ... | 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 |
200 | Given an integer k, return the minimum number of Fibonacci numbers whose sum is equal to k. The same Fibonacci number can be used multiple times.
The Fibonacci numbers are defined as:
F1 = 1
F2 = 1
Fn = Fn-1 + Fn-2 for n > 2.
It is guaranteed that for the given constraints we can always find such Fibonacci numbers th... | ["class Solution:\n def findMinFibonacciNumbers(self, k: int) -> int:\n fib = [1, 1] # initializing a Fibonacci table with F[0] and F[1]\n i = 1 # index that will represent the last filled index of table\n temp = fib[0] + fib[1] # initial value of values to be appended\n while temp < k: #... | {"fn_name": "findMinFibonacciNumbers", "inputs": [[7]], "outputs": [2]} | interview | https://leetcode.com/problems/find-the-minimum-number-of-fibonacci-numbers-whose-sum-is-k/ |
class Solution:
def findMinFibonacciNumbers(self, k: int) -> int:
| [
"class Solution:\n def findMinFibonacciNumbers(self, k: int) -> int:\n fib = [1, 1] # initializing a Fibonacci table with F[0] and F[1]\n i = 1 # index that will represent the last filled index of table\n temp = fib[0] + fib[1] # initial value of values to be appended\n while temp < k... | 12 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
201 | Given n, how many structurally unique BST's (binary search trees) that store values 1 ... n?
Example:
Input: 3
Output: 5
Explanation:
Given n = 3, there are a total of 5 unique BST's:
1 3 3 2 1
\ / / / \ \
3 2 1 1 3 2
/ / \ ... | ["class Solution:\n hash = {}\n def numTrees(self, n):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n # return base case\n if n == 0:\n return 1\n if n == 1 or n == 2:\n return n\n \n # try fetching from hash\n ... | {"fn_name": "numTrees", "inputs": [[3]], "outputs": [5]} | interview | https://leetcode.com/problems/unique-binary-search-trees/ |
class Solution:
def numTrees(self, n: int) -> int:
| [
"class Solution:\n hash = {}\n def numTrees(self, n):\n \"\"\"\n :type n: int\n :rtype: int\n \"\"\"\n # return base case\n if n == 0:\n return 1\n if n == 1 or n == 2:\n return n\n \n # try fetching from hash\n ... | 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 |
202 | Let's call any (contiguous) subarray B (of A) a mountain if the following properties hold:
B.length >= 3
There exists some 0 < i < B.length - 1 such that B[0] < B[1] < ... B[i-1] < B[i] > B[i+1] > ... > B[B.length - 1]
(Note that B could be any subarray of A, including the entire array A.)
Given an array A of integer... | ["class Solution:\n def longestMountain(self, A: List[int]) -> int:\n up=0\n down=0\n ans=0\n for i in range(0,len(A)-1):\n if A[i]<A[i+1]:\n if down==0:\n up+=1\n else:\n up=1\n down=0\n ... | {"fn_name": "longestMountain", "inputs": [[[2, 1, 4, 7, 3, 2, 5]]], "outputs": [5]} | interview | https://leetcode.com/problems/longest-mountain-in-array/ |
class Solution:
def longestMountain(self, A: List[int]) -> int:
| [
"class Solution:\n def longestMountain(self, A: List[int]) -> int:\n up=0\n down=0\n ans=0\n for i in range(0,len(A)-1):\n if A[i]<A[i+1]:\n if down==0:\n up+=1\n else:\n up=1\n down=0\n ... | 38 | [
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
] | [
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 |
203 | A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).
The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
How many possible unique paths are there?
Above... | ["class Solution:\n def uniquePaths(self, m, n):\n \"\"\"\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n def f(n):\n ret = 1\n for i in range(1, n+1):\n ret *= i\n return ret\n return f(m+n-2)//(f(m-1... | {"fn_name": "uniquePaths", "inputs": [[3, 7]], "outputs": [28]} | interview | https://leetcode.com/problems/unique-paths/ |
class Solution:
def uniquePaths(self, m: int, n: int) -> int:
| [
"class Solution:\n def uniquePaths(self, m, n):\n \"\"\"\n :type m: int\n :type n: int\n :rtype: int\n \"\"\"\n def f(n):\n ret = 1\n for i in range(1, n+1):\n ret *= i\n return ret\n return f(m+n-2)//(f(... | 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 |
204 | Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
(i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]).
You are given a target value to search. If found in the array return its index, otherwise return -1.
You may assume no duplicate exists in the array.
Your algorithm's ... | ["class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: int\n \"\"\"\n # left = 0\n # right = len(nums) - 1\n # while left <= right: \n # mid = int((left + right)/2)\n # ... | {"fn_name": "search", "inputs": [[[4, 5, 6, 7, 0, 1, 2], 0]], "outputs": [4]} | interview | https://leetcode.com/problems/search-in-rotated-sorted-array/ |
class Solution:
def search(self, nums: List[int], target: int) -> int:
| [
"class Solution:\n def search(self, nums, target):\n \"\"\"\n :type nums: List[int]\n :type target: int\n :rtype: int\n \"\"\"\n # left = 0\n # right = len(nums) - 1\n # while left <= right: \n # mid = int((left + right)/2)\n # ... | 12 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
205 | In the computer world, use restricted resource you have to generate maximum benefit is what we always want to pursue.
For now, suppose you are a dominator of m 0s and n 1s respectively. On the other hand, there is an array with strings consisting of only 0s and 1s.
Now your task is to find the maximum number of strin... | ["class Solution:\n def getMax(self, arr, m, n):\n res = 0\n \n for e in arr:\n if m >= e[0] and n >= e[1]:\n res += 1\n m -= e[0]\n n -= e[1]\n \n return res\n \n def findMaxForm(self, strs, m, n):\n \"\"\"\n :t... | {"fn_name": "findMaxForm", "inputs": [[["\"10\"", "\"0001\"", "\"111001\"", "\"1\"", "\"0\""], 5, 3]], "outputs": [4]} | interview | https://leetcode.com/problems/ones-and-zeroes/ |
class Solution:
def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
| [
"class Solution:\n def getMax(self, arr, m, n):\n res = 0\n \n for e in arr:\n if m >= e[0] and n >= e[1]:\n res += 1\n m -= e[0]\n n -= e[1]\n \n return res\n \n def findMaxForm(self, strs, m, n):\n \"\"\"\n ... | 4 | [
0,
1,
2,
3
] | [
null,
null,
null,
null
] | false |
206 | Given an array of scores that are non-negative integers. Player 1 picks one of the numbers from either end of the array followed by the player 2 and then player 1 and so on. Each time a player picks a number, that number will not be available for the next player. This continues until all the scores have been chosen. Th... | ["class Solution:\n def PredictTheWinner(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: bool\n \"\"\"\n if not nums: return True\n n = len(nums)\n if n & 1 == 0: return True\n \n dp = [0] * n\n for i in range(n-1, -1, -1):\n ... | {"fn_name": "PredictTheWinner", "inputs": [[[1, 5, 2]]], "outputs": [false]} | interview | https://leetcode.com/problems/predict-the-winner/ |
class Solution:
def PredictTheWinner(self, nums: List[int]) -> bool:
| [
"class Solution:\n def PredictTheWinner(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: bool\n \"\"\"\n if not nums: return True\n n = len(nums)\n if n & 1 == 0: return True\n \n dp = [0] * n\n for i in range(n-1, -1, -1):\n... | 13 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
207 | Given a list of non negative integers, arrange them such that they form the largest number.
Example 1:
Input: [10,2]
Output: "210"
Example 2:
Input: [3,30,34,5,9]
Output: "9534330"
Note: The result may be very large, so you need to return a string instead of an integer. | ["class Solution:\n def largestNumber(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: str\n \"\"\"\n nums = [str(n) for n in nums]\n \n nums.sort(reverse=True)\n \n for i in range(1, len(nums)):\n if len(nums[i-1]) > len(num... | {"fn_name": "largestNumber", "inputs": [[[10, 2]]], "outputs": ["210"]} | interview | https://leetcode.com/problems/largest-number/ |
class Solution:
def largestNumber(self, nums: List[int]) -> str:
| [
"class Solution:\n def largestNumber(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: str\n \"\"\"\n nums = [str(n) for n in nums]\n \n nums.sort(reverse=True)\n \n for i in range(1, len(nums)):\n if len(nums[i-1]) > len(... | 11 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
208 | In the world of Dota2, there are two parties: the Radiant and the Dire.
The Dota2 senate consists of senators coming from two parties. Now the senate wants to make a decision about a change in the Dota2 game. The voting for this change is a round-based procedure. In each round, each senator can exercise one of the t... | ["class Solution:\n def predictPartyVictory(self, senate):\n \"\"\"\n :type senate: str\n :rtype: str\n \"\"\"\n num = 0 # num of Reeding R\n while ('R' in senate and 'D' in senate):\n res = []\n for i in senate:\n if i=='R':\n... | {"fn_name": "predictPartyVictory", "inputs": [["\"RD\""]], "outputs": ["Dire"]} | interview | https://leetcode.com/problems/dota2-senate/ |
class Solution:
def predictPartyVictory(self, senate: str) -> str:
| [
"class Solution:\n def predictPartyVictory(self, senate):\n \"\"\"\n :type senate: str\n :rtype: str\n \"\"\"\n num = 0 # num of Reeding R\n while ('R' in senate and 'D' in senate):\n res = []\n for i in senate:\n if i=='R'... | 6 | [
0,
1,
2,
3,
4,
5
] | [
null,
null,
null,
null,
null,
null
] | false |
209 | There are N piles of stones arranged in a row. The i-th pile has stones[i] stones.
A move consists of merging exactly K consecutive piles into one pile, and the cost of this move is equal to the total number of stones in these K piles.
Find the minimum cost to merge all piles of stones into one pile. If it is impossi... | ["class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n n = len(stones)\n if (n - 1) % (K - 1) != 0:\n return -1\n prefix = [0]\n for s in stones:\n prefix.append(prefix[-1] + s)\n @lru_cache(None)\n def dp(i, j):\n if ... | {"fn_name": "mergeStones", "inputs": [[[3, 2, 4, 1], 2]], "outputs": [20]} | interview | https://leetcode.com/problems/minimum-cost-to-merge-stones/ |
class Solution:
def mergeStones(self, stones: List[int], K: int) -> int:
| [
"class Solution:\n def mergeStones(self, stones: List[int], K: int) -> int:\n n = len(stones)\n if (n - 1) % (K - 1) != 0:\n return -1\n prefix = [0]\n for s in stones:\n prefix.append(prefix[-1] + s)\n @lru_cache(None)\n def dp(i, j):\n ... | 28 | [
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
] | [
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 |
210 | Given an array of integers, find out whether there are two distinct indices i and j in the array such that the absolute difference between nums[i] and nums[j] is at most t and the absolute difference between i and j is at most k.
Example 1:
Input: nums = [1,2,3,1], k = 3, t = 0
Output: true
Example 2:
Input: n... | ["class Solution:\n def containsNearbyAlmostDuplicate(self, nums, k, t):\n \"\"\"\n :type nums: List[int]\n :type k: int\n :type t: int\n :rtype: bool\n \"\"\"\n if len(nums) < 2 or k <= 0 or t < 0: return False\n if t == 0:\n visited = set... | {"fn_name": "containsNearbyAlmostDuplicate", "inputs": [[[1, 2, 3, 1], 3, 0]], "outputs": [true]} | interview | https://leetcode.com/problems/contains-duplicate-iii/ |
class Solution:
def containsNearbyAlmostDuplicate(self, nums: List[int], k: int, t: int) -> bool:
| [
"class Solution:\n def containsNearbyAlmostDuplicate(self, nums, k, t):\n \"\"\"\n :type nums: List[int]\n :type k: int\n :type t: int\n :rtype: bool\n \"\"\"\n if len(nums) < 2 or k <= 0 or t < 0: return False\n if t == 0:\n visited = ... | 11 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
212 | Given an array of unique integers, each integer is strictly greater than 1.
We make a binary tree using these integers and each number may be used for any number of times.
Each non-leaf node's value should be equal to the product of the values of it's children.
How many binary trees can we make? Return the answer modu... | ["class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n \n mod = 10**9 + 7\n\n nums_set = set(A)\n nums = A.copy()\n nums.sort()\n counts = {}\n total = 0\n\n for n in nums:\n n_count = 1\n for d in nums:\n ... | {"fn_name": "numFactoredBinaryTrees", "inputs": [[[2, 4]]], "outputs": [3]} | interview | https://leetcode.com/problems/binary-trees-with-factors/ |
class Solution:
def numFactoredBinaryTrees(self, A: List[int]) -> int:
| [
"class Solution:\n def numFactoredBinaryTrees(self, A: List[int]) -> int:\n \n mod = 10**9 + 7\n\n nums_set = set(A)\n nums = A.copy()\n nums.sort()\n counts = {}\n total = 0\n\n for n in nums:\n n_count = 1\n for d in nums:\n ... | 83 | [
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... | [
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 |
213 | Implement pow(x, n), which calculates x raised to the power n (xn).
Example 1:
Input: 2.00000, 10
Output: 1024.00000
Example 2:
Input: 2.10000, 3
Output: 9.26100
Example 3:
Input: 2.00000, -2
Output: 0.25000
Explanation: 2-2 = 1/22 = 1/4 = 0.25
Note:
-100.0 < x < 100.0
n is a 32-bit signed ... | ["class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n if n == 0:\n return 1\n if abs(n) == 1:\n if n == 1:\n return x\n else:\n return ... | {"fn_name": "myPow", "inputs": [[2.0, 10]], "outputs": [1024.0]} | interview | https://leetcode.com/problems/powx-n/ |
class Solution:
def myPow(self, x: float, n: int) -> float:
| [
"class Solution:\n def myPow(self, x, n):\n \"\"\"\n :type x: float\n :type n: int\n :rtype: float\n \"\"\"\n if n == 0:\n return 1\n if abs(n) == 1:\n if n == 1:\n return x\n else:\n retu... | 17 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
214 | Given an array nums of integers, a move consists of choosing any element and decreasing it by 1.
An array A is a zigzag array if either:
Every even-indexed element is greater than adjacent elements, ie. A[0] > A[1] < A[2] > A[3] < A[4] > ...
OR, every odd-indexed element is greater than adjacent elements, ie. A[0] < A... | ["class Solution:\n def movesToMakeZigzag(self, nums):\n n = len(nums)\n res0 = 0\n for i in range(0, n, 2):\n nei = min(nums[j] for j in [i - 1, i + 1] if 0 <= j <= n-1)\n if nums[i] >= nei:\n res0 += nums[i] - nei + 1\n res1 = 0\n for i in ran... | {"fn_name": "movesToMakeZigzag", "inputs": [[[1, 2, 3]]], "outputs": [2]} | interview | https://leetcode.com/problems/decrease-elements-to-make-array-zigzag/ |
class Solution:
def movesToMakeZigzag(self, nums: List[int]) -> int:
| [
"class Solution:\n def movesToMakeZigzag(self, nums):\n n = len(nums)\n res0 = 0\n for i in range(0, n, 2):\n nei = min(nums[j] for j in [i - 1, i + 1] if 0 <= j <= n-1)\n if nums[i] >= nei:\n res0 += nums[i] - nei + 1\n res1 = 0\n for i in ... | 6 | [
0,
1,
2,
3,
4,
5
] | [
null,
null,
null,
null,
null,
null
] | false |
215 | Given an array nums of positive integers. Your task is to select some subset of nums, multiply each element by an integer and add all these numbers. The array is said to be good if you can obtain a sum of 1 from the array by any possible subset and multiplicand.
Return True if the array is good otherwise return False.
... | ["class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n n = nums[0]\n \n for i in nums:\n n = gcd(i,n)\n \n if n==1:\n return True\n return False\n", "class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n ... | {"fn_name": "isGoodArray", "inputs": [[[12, 5, 7, 23]]], "outputs": [true]} | interview | https://leetcode.com/problems/check-if-it-is-a-good-array/ |
class Solution:
def isGoodArray(self, nums: List[int]) -> bool:
| [
"class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n n = nums[0]\n \n for i in nums:\n n = gcd(i,n)\n \n if n==1:\n return True\n return False\n",
"class Solution:\n def isGoodArray(self, nums: List[int]) -> bool:\n ... | 39 | [
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
] | [
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 |
216 | Given the string croakOfFrogs, which represents a combination of the string "croak" from different frogs, that is, multiple frogs can croak at the same time, so multiple “croak” are mixed. Return the minimum number of different frogs to finish all the croak in the given string.
A valid "croak" means a frog is printing ... | ["class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n # valid string? can be seperated into full croaks:\n ### dict of letters. c, r, o, a, k should all be equal, nothing else in\n if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':\n retu... | {"fn_name": "minNumberOfFrogs", "inputs": [["\"croakcroak\""]], "outputs": [-1]} | interview | https://leetcode.com/problems/minimum-number-of-frogs-croaking/ |
class Solution:
def minNumberOfFrogs(self, croakOfFrogs: str) -> int:
| [
"class Solution:\n def minNumberOfFrogs(self, croakOfFrogs: str) -> int:\n # valid string? can be seperated into full croaks:\n ### dict of letters. c, r, o, a, k should all be equal, nothing else in\n if len(croakOfFrogs)%5!=0 or croakOfFrogs[0]!='c' or croakOfFrogs[-1]!='k':\n r... | 29 | [
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
] | [
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 |
217 | We have an array A of non-negative integers.
For every (contiguous) subarray B = [A[i], A[i+1], ..., A[j]] (with i <= j), we take the bitwise OR of all the elements in B, obtaining a result A[i] | A[i+1] | ... | A[j].
Return the number of possible results. (Results that occur more than once are only counted once in th... | ["class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n res = set()\n cur = set()\n for a in A:\n cur = {a | i for i in cur}\n cur |= {a}\n res |= cur\n return len(res)", "class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> ... | {"fn_name": "subarrayBitwiseORs", "inputs": [[[0]]], "outputs": [1]} | interview | https://leetcode.com/problems/bitwise-ors-of-subarrays/ |
class Solution:
def subarrayBitwiseORs(self, A: List[int]) -> int:
| [
"class Solution:\n def subarrayBitwiseORs(self, A: List[int]) -> int:\n res = set()\n cur = set()\n for a in A:\n cur = {a | i for i in cur}\n cur |= {a}\n res |= cur\n return len(res)",
"class Solution:\n def subarrayBitwiseORs(self, A: List[int]... | 99 | [
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... | [
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 |
219 | We are given hours, a list of the number of hours worked per day for a given employee.
A day is considered to be a tiring day if and only if the number of hours worked is (strictly) greater than 8.
A well-performing interval is an interval of days for which the number of tiring days is strictly larger than the number o... | ["class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n ans, count, seen = 0, 0, {}\n for i, hour in enumerate(hours):\n count = count + 1 if hour > 8 else count - 1\n if count > 0:\n ans = i + 1\n else:\n if count not in seen:... | {"fn_name": "longestWPI", "inputs": [[[9, 9, 6, 0, 6, 6, 9]]], "outputs": [3]} | interview | https://leetcode.com/problems/longest-well-performing-interval/ |
class Solution:
def longestWPI(self, hours: List[int]) -> int:
| [
"class Solution:\n def longestWPI(self, hours: List[int]) -> int:\n ans, count, seen = 0, 0, {}\n for i, hour in enumerate(hours):\n count = count + 1 if hour > 8 else count - 1\n if count > 0:\n ans = i + 1\n else:\n if count not in se... | 45 | [
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
] | [
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 |
220 | Today, the bookstore owner has a store open for customers.length minutes. Every minute, some number of customers (customers[i]) enter the store, and all those customers leave after the end of that minute.
On some minutes, the bookstore owner is grumpy. If the bookstore owner is grumpy on the i-th minute, grumpy[i] = ... | ["class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n # feel like its sliding window max\n \n window, max_window = 0, 0\n \n # init first window\n for i in range(X):\n if grumpy[i]: window += customers[i]\n ma... | {"fn_name": "maxSatisfied", "inputs": [[[1, 0, 1, 2, 1, 1, 7, 5], [0, 1, 0, 1, 0, 1, 0, 1], 3]], "outputs": [16]} | interview | https://leetcode.com/problems/grumpy-bookstore-owner/ |
class Solution:
def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:
| [
"class Solution:\n def maxSatisfied(self, customers: List[int], grumpy: List[int], X: int) -> int:\n # feel like its sliding window max\n \n window, max_window = 0, 0\n \n # init first window\n for i in range(X):\n if grumpy[i]: window += customers[i]\n ... | 88 | [
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... | [
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 |
221 | Given a string S, consider all duplicated substrings: (contiguous) substrings of S that occur 2 or more times. (The occurrences may overlap.)
Return any duplicated substring that has the longest possible length. (If S does not have a duplicated substring, the answer is "".)
Example 1:
Input: "banana"
Output: "ana"
... | ["class Solution:\n def longestDupSubstring(self, S):\n nums, N = [ord(c) - ord('a') for c in S], len(S)\n BASE, MOD = 26, 2**32\n def check(L):\n cur_hash, seen = 0, set()\n for val in nums[:L]:\n cur_hash = (cur_hash * BASE + val) % MOD\n seen.ad... | {"fn_name": "longestDupSubstring", "inputs": [["\"banana\""]], "outputs": ["ana"]} | interview | https://leetcode.com/problems/longest-duplicate-substring/ |
class Solution:
def longestDupSubstring(self, S: str) -> str:
| [
"class Solution:\n def longestDupSubstring(self, S):\n nums, N = [ord(c) - ord('a') for c in S], len(S)\n BASE, MOD = 26, 2**32\n def check(L):\n cur_hash, seen = 0, set()\n for val in nums[:L]:\n cur_hash = (cur_hash * BASE + val) % MOD\n seen... | 70 | [
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... | [
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 |
223 | Given an array of citations sorted in ascending order (each citation is a non-negative integer) of a researcher, write a function to compute the researcher's h-index.
According to the definition of h-index on Wikipedia: "A scientist has index h if h of his/her N papers have at least h citations each, and the other N −... | ["class Solution(object):\n def hIndex(self, citations):\n \"\"\"\n :type citations: List[int]\n :rtype: int\n \"\"\"\n n = len(citations)\n l = 0\n r = n-1\n while l <= r:\n m = (l + r) // 2\n if m == 0 and citations[m] >= n - ... | {"fn_name": "hIndex", "inputs": [[[0, 1, 3, 5, 6]]], "outputs": [3]} | interview | https://leetcode.com/problems/h-index-ii/ |
class Solution:
def hIndex(self, citations: List[int]) -> int:
| [
"class Solution(object):\n def hIndex(self, citations):\n \"\"\"\n :type citations: List[int]\n :rtype: int\n \"\"\"\n n = len(citations)\n l = 0\n r = n-1\n while l <= r:\n m = (l + r) // 2\n if m == 0 and citations[m] >= n... | 10 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
224 | Given a string S and a string T, count the number of distinct subsequences of S which equals T.
A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, "ACE" is a subs... | ["class Solution:\n def numDistinct(self, s, t):\n \"\"\"\n :type s: str\n :type t: str\n :rtype: int\n \"\"\"\n setOft=set(t)\n news=\"\"\n for ch in s:\n if ch in setOft:\n news+=ch\n dp=[[1 for i in range(len(news... | {"fn_name": "numDistinct", "inputs": [["\"rabbbit\"", "\"rabbit\""]], "outputs": [3]} | interview | https://leetcode.com/problems/distinct-subsequences/ |
class Solution:
def numDistinct(self, s: str, t: str) -> int:
| [
"class Solution:\n def numDistinct(self, s, t):\n \"\"\"\n :type s: str\n :type t: str\n :rtype: int\n \"\"\"\n setOft=set(t)\n news=\"\"\n for ch in s:\n if ch in setOft:\n news+=ch\n dp=[[1 for i in range(len(n... | 5 | [
0,
1,
2,
3,
4
] | [
null,
null,
null,
null,
null
] | false |
225 | There are N dominoes in a line, and we place each domino vertically upright.
In the beginning, we simultaneously push some of the dominoes either to the left or to the right.
After each second, each domino that is falling to the left pushes the adjacent domino on the left.
Similarly, the dominoes falling to the right ... | ["INF = float('inf')\nclass Solution:\n def pushDominoes(self, dominoes: str) -> str:\n n = len(dominoes)\n d1 = [-1] * n\n d2 = [-1] * n\n \n cnt = INF\n for i in range(n - 1, -1, -1):\n if dominoes[i] == 'L':\n cnt = 0\n elif dominoes[i... | {"fn_name": "pushDominoes", "inputs": [["\".L.R...LR..L..\""]], "outputs": ["LLL.RR.LLRRLL..."]} | interview | https://leetcode.com/problems/push-dominoes/ |
class Solution:
def pushDominoes(self, dominoes: str) -> str:
| [
"INF = float('inf')\nclass Solution:\n def pushDominoes(self, dominoes: str) -> str:\n n = len(dominoes)\n d1 = [-1] * n\n d2 = [-1] * n\n \n cnt = INF\n for i in range(n - 1, -1, -1):\n if dominoes[i] == 'L':\n cnt = 0\n elif dominoe... | 6 | [
0,
1,
2,
3,
4,
5
] | [
null,
null,
null,
null,
null,
null
] | false |
226 | Given an array A of non-negative integers, the array is squareful if for every pair of adjacent elements, their sum is a perfect square.
Return the number of permutations of A that are squareful. Two permutations A1 and A2 differ if and only if there is some index i such that A1[i] != A2[i].
Example 1:
Input: [1,17,... | ["\nclass Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n\n A.sort()\n self.ans = 0\n\n def check(A, i, path):\n return int((A[i] + path[-1])**0.5 + 0.0)**2 == A[i] + path[-1]\n\n def dfs(A, path):\n if not A:\n self.ans += 1\n ... | {"fn_name": "numSquarefulPerms", "inputs": [[[1, 17, 8]]], "outputs": [2]} | interview | https://leetcode.com/problems/number-of-squareful-arrays/ |
class Solution:
def numSquarefulPerms(self, A: List[int]) -> int:
| [
"\nclass Solution:\n def numSquarefulPerms(self, A: List[int]) -> int:\n\n A.sort()\n self.ans = 0\n\n def check(A, i, path):\n return int((A[i] + path[-1])**0.5 + 0.0)**2 == A[i] + path[-1]\n\n def dfs(A, path):\n if not A:\n self.ans += 1\n ... | 33 | [
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
] | [
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 |
227 | Given an array A of 0s and 1s, we may change up to K values from 0 to 1.
Return the length of the longest (contiguous) subarray that contains only 1s.
Example 1:
Input: A = [1,1,1,0,0,0,1,1,1,1,0], K = 2
Output: 6
Explanation:
[1,1,1,0,0,1,1,1,1,1,1]
Bolded numbers were flipped from 0 to 1. The longest subarray i... | ["class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n hulu = []\n cnt = 0\n num = A[0]\n for x in A:\n if x == num:\n cnt += 1\n else:\n hulu.append([num,cnt])\n cnt = 1\n num = x\n ... | {"fn_name": "longestOnes", "inputs": [[[1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0], 2]], "outputs": [6]} | interview | https://leetcode.com/problems/max-consecutive-ones-iii/ |
class Solution:
def longestOnes(self, A: List[int], K: int) -> int:
| [
"class Solution:\n def longestOnes(self, A: List[int], K: int) -> int:\n hulu = []\n cnt = 0\n num = A[0]\n for x in A:\n if x == num:\n cnt += 1\n else:\n hulu.append([num,cnt])\n cnt = 1\n num = x\n ... | 137 | [
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... | [
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 |
229 | Given an array of integers A with even length, return true if and only if it is possible to reorder it such that A[2 * i + 1] = 2 * A[2 * i] for every 0 <= i < len(A) / 2.
Example 1:
Input: A = [3,1,3,6]
Output: false
Example 2:
Input: A = [2,1,2,6]
Output: false
Example 3:
Input: A = [4,-2,2,-4]
Output: tr... | ["class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n cache=Counter(A)\n c_list=sorted(list(cache),key=abs)\n for x in c_list:\n if cache[x]>cache[2*x]:\n return False\n cache[2*x]-=cache[x]\n return True", "class Solution:\n def ... | {"fn_name": "canReorderDoubled", "inputs": [[[3, 1, 3, 6]]], "outputs": [false]} | interview | https://leetcode.com/problems/array-of-doubled-pairs/ |
class Solution:
def canReorderDoubled(self, A: List[int]) -> bool:
| [
"class Solution:\n def canReorderDoubled(self, A: List[int]) -> bool:\n cache=Counter(A)\n c_list=sorted(list(cache),key=abs)\n for x in c_list:\n if cache[x]>cache[2*x]:\n return False\n cache[2*x]-=cache[x]\n return True",
"class Solution:\n ... | 114 | [
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... | [
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 |
230 | Given a non-negative integer num represented as a string, remove k digits from the number so that the new number is the smallest possible.
Note:
The length of num is less than 10002 and will be ≥ k.
The given num does not contain any leading zero.
Example 1:
Input: num = "1432219", k = 3
Output: "1219"
Explanat... | ["class Solution:\n def removeKdigits(self, num, k):\n \"\"\"\n :type num: str\n :type k: int\n :rtype: str\n \"\"\"\n out=[]\n for digit in num:\n while k and out and out[-1] > digit:\n out.pop()\n k-=1\n ... | {"fn_name": "removeKdigits", "inputs": [["\"1432219\"", 3]], "outputs": ["\"1219\""]} | interview | https://leetcode.com/problems/remove-k-digits/ |
class Solution:
def removeKdigits(self, num: str, k: int) -> str:
| [
"class Solution:\n def removeKdigits(self, num, k):\n \"\"\"\n :type num: str\n :type k: int\n :rtype: str\n \"\"\"\n out=[]\n for digit in num:\n while k and out and out[-1] > digit:\n out.pop()\n k-=1\n ... | 5 | [
0,
1,
2,
3,
4
] | [
null,
null,
null,
null,
null
] | false |
231 | Given an unsorted integer array, find the smallest missing positive integer.
Example 1:
Input: [1,2,0]
Output: 3
Example 2:
Input: [3,4,-1,1]
Output: 2
Example 3:
Input: [7,8,9,11,12]
Output: 1
Note:
Your algorithm should run in O(n) time and uses constant extra space. | ["class Solution:\n def firstMissingPositive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n nums = sorted(set(nums), key=lambda x: x)\n result = 0\n for i in range(len(nums)):\n if nums[i] <= 0:\n continue\n ... | {"fn_name": "firstMissingPositive", "inputs": [[[0, 1, 2, 0]]], "outputs": [3]} | interview | https://leetcode.com/problems/first-missing-positive/ |
class Solution:
def firstMissingPositive(self, nums: List[int]) -> int:
| [
"class Solution:\n def firstMissingPositive(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n nums = sorted(set(nums), key=lambda x: x)\n result = 0\n for i in range(len(nums)):\n if nums[i] <= 0:\n continue... | 16 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
232 | In LOL world, there is a hero called Teemo and his attacking can make his enemy Ashe be in poisoned condition. Now, given the Teemo's attacking ascending time series towards Ashe and the poisoning time duration per Teemo's attacking, you need to output the total time that Ashe is in poisoned condition.
You may assume... | ["class Solution:\n def findPoisonedDuration(self, timeSeries, duration):\n \"\"\"\n :type timeSeries: List[int]\n :type duration: int\n :rtype: int\n \"\"\"\n if not timeSeries:\n return 0\n prev = timeSeries[0]\n ret = 0\n count =... | {"fn_name": "findPoisonedDuration", "inputs": [[[1, 4], 2]], "outputs": [4]} | interview | https://leetcode.com/problems/teemo-attacking/ |
class Solution:
def findPoisonedDuration(self, timeSeries: List[int], duration: int) -> int:
| [
"class Solution:\n def findPoisonedDuration(self, timeSeries, duration):\n \"\"\"\n :type timeSeries: List[int]\n :type duration: int\n :rtype: int\n \"\"\"\n if not timeSeries:\n return 0\n prev = timeSeries[0]\n ret = 0\n coun... | 10 | [
0,
1,
2,
3,
4,
5,
6,
7,
8,
9
] | [
null,
null,
null,
null,
null,
null,
null,
null,
null,
null
] | false |
233 | In a N x N grid composed of 1 x 1 squares, each 1 x 1 square consists of a /, \, or blank space. These characters divide the square into contiguous regions.
(Note that backslash characters are escaped, so a \ is represented as "\\".)
Return the number of regions.
Example 1:
Input:
[
" /",
"/ "
]
Out... | ["from itertools import chain\nclass Solution:\n def regionsBySlashes(self, grid):\n grid = self.convert_grid(grid)\n print(*(list(map(str, x)) for x in grid), sep='\\\n')\n return len([self.destroy_island(x, y, grid) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v == 0])\n\n @st... | {"fn_name": "regionsBySlashes", "inputs": [[["\" /\"", "\"/ \""]]], "outputs": [2]} | interview | https://leetcode.com/problems/regions-cut-by-slashes/ |
class Solution:
def regionsBySlashes(self, grid: List[str]) -> int:
| [
"from itertools import chain\nclass Solution:\n def regionsBySlashes(self, grid):\n grid = self.convert_grid(grid)\n print(*(list(map(str, x)) for x in grid), sep='\\\n')\n return len([self.destroy_island(x, y, grid) for y in range(len(grid)) for x,v in enumerate(grid[y]) if v == 0])\n\n ... | 30 | [
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
] | [
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 |
234 | Given a string S of '(' and ')' parentheses, we add the minimum number of parentheses ( '(' or ')', and in any positions ) so that the resulting parentheses string is valid.
Formally, a parentheses string is valid if and only if:
It is the empty string, or
It can be written as AB (A concatenated with B), where A and B... | ["class Solution:\n def minAddToMakeValid(self, S: str) -> int:\n if not S:\n return 0\n \n stack = []\n \n add = 0\n for c in S:\n if c == '(':\n stack.append(c)\n elif c == ')':\n if stack:\n ... | {"fn_name": "minAddToMakeValid", "inputs": [["\"())\""]], "outputs": [1]} | interview | https://leetcode.com/problems/minimum-add-to-make-parentheses-valid/ |
class Solution:
def minAddToMakeValid(self, S: str) -> int:
| [
"class Solution:\n def minAddToMakeValid(self, S: str) -> int:\n if not S:\n return 0\n \n stack = []\n \n add = 0\n for c in S:\n if c == '(':\n stack.append(c)\n elif c == ')':\n if stack:\n ... | 3 | [
0,
1,
2
] | [
null,
null,
null
] | false |
236 | A string of '0's and '1's is monotone increasing if it consists of some number of '0's (possibly 0), followed by some number of '1's (also possibly 0.)
We are given a string S of '0's and '1's, and we may flip any '0' to a '1' or a '1' to a '0'.
Return the minimum number of flips to make S monotone increasing.
Examp... | ["class Solution:\n def minFlipsMonoIncr(self, S: str) -> int:\n onesSoFar = 0\n partial = 0\n \n for n in S:\n if n == '0':\n partial = min(onesSoFar, partial+1) \n else:\n onesSoFar += 1\n \n return partial\n", "clas... | {"fn_name": "minFlipsMonoIncr", "inputs": [["\"00110\""]], "outputs": [2]} | interview | https://leetcode.com/problems/flip-string-to-monotone-increasing/ |
class Solution:
def minFlipsMonoIncr(self, S: str) -> int:
| [
"class Solution:\n def minFlipsMonoIncr(self, S: str) -> int:\n onesSoFar = 0\n partial = 0\n \n for n in S:\n if n == '0':\n partial = min(onesSoFar, partial+1) \n else:\n onesSoFar += 1\n \n return partial\n",
... | 7 | [
0,
1,
2,
3,
4,
5,
6
] | [
null,
null,
null,
null,
null,
null,
null
] | false |
237 | In an array A of 0s and 1s, how many non-empty subarrays have sum S?
Example 1:
Input: A = [1,0,1,0,1], S = 2
Output: 4
Explanation:
The 4 subarrays are bolded below:
[1,0,1,0,1]
[1,0,1,0,1]
[1,0,1,0,1]
[1,0,1,0,1]
Note:
A.length <= 30000
0 <= S <= A.length
A[i] is either 0 or 1. | ["class Solution:\n def numSubarraysWithSum(self, pl, S):\n ans = 0\n \n if(S == 0):\n c = 0\n for i in range(len(pl)):\n if(pl[i] == 0):\n c+=1\n else:\n c = 0\n ans +=c\n return ... | {"fn_name": "numSubarraysWithSum", "inputs": [[[1, 0, 1, 0, 1], 2]], "outputs": [4]} | interview | https://leetcode.com/problems/binary-subarrays-with-sum/ |
class Solution:
def numSubarraysWithSum(self, A: List[int], S: int) -> int:
| [
"class Solution:\n def numSubarraysWithSum(self, pl, S):\n ans = 0\n \n if(S == 0):\n c = 0\n for i in range(len(pl)):\n if(pl[i] == 0):\n c+=1\n else:\n c = 0\n ans +=c\n retu... | 55 | [
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... | [
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.