presudo 1.0.0

package/pods/DSA/all.txt

@@ -0,0 +1,914 @@
+🏆 VERY HARD WEC-P TOURNAMENT PROBLEM
+Round-Robin Tournament Power Analysis
+📘 -----------------Problem Description---------------------
+
+In a round-robin tournament, a team plays matches over N days.
+
+Each day:
+
+A positive value means points gained
+
+A negative value means points lost
+
+You are given an integer array points of length N.
+
+The tournament committee defines the power score of a streak of days as:
+
+(total points scored in that streak) × (length of the streak)
+
+🎯 Task
+
+Find the maximum power score obtainable from any continuous sequence of days.
+
+📥 Input Format
+
+First line contains an integer N
+
+Second line contains N space-separated integers (points)
+
+📤 Output Format
+
+Print a single integer — the maximum power score
+
+🔒 Constraints (WEC-P HARD)
+
+1 ≤ N ≤ 2 × 10^5
+
+-10^4 ≤ points[i] ≤ 10^4
+
+Brute force or O(N²) solutions will TLE.
+
+
+
+----------CODE------------
+
+def maxTournamentPower(points):
+    n = len(points)
+
+    prefix = 0
+    best = float('-inf')
+
+    # Store best value of (prefix - prefix_index * something)
+    min_prefix = 0
+    min_index = 0
+
+    for i in range(1, n + 1):
+        prefix += points[i - 1]
+
+        # Calculate power using current prefix and best previous prefix
+        best = max(best, (prefix - min_prefix) * (i - min_index))
+
+        # Update best prefix to subtract
+        if prefix < min_prefix:
+            min_prefix = prefix
+            min_index = i
+
+    return best
+
+
+# WEC-P input handling
+n = int(input())
+points = list(map(int, input().split()))
+
+print(maxTournamentPower(points))
+
+
+---------------------------------------------------------------------------------------------------------
+
+Problem 1: Tournament Maximum Weighted Streak
+
+Description:
+Each day, a team earns points. A streak’s power is:
+
+sum(points in streak) × length of streak
+
+
+Find the maximum power streak.
+
+Twist: points can be negative, streaks can start anywhere.
+
+Input: N (number of days), points array
+
+Constraints: N ≤ 2*10^5, -10^4 ≤ points[i] ≤ 10^4
+
+Output: maximum power streak
+
+This is the same as the file I gave you, but a foundation problem.
+
+
+----------CODE----------
+
+def maxTournamentPower(points):
+    """
+    Returns the maximum power streak in a tournament.
+    Power of a streak = sum(streak) * length_of_streak
+    """
+    n = len(points)
+    
+    prefix = 0        # current prefix sum
+    best = float('-inf')  # maximum power score
+    min_prefix = 0    # minimum prefix sum seen so far
+    min_index = 0     # index where min_prefix occurred
+
+    for i in range(1, n + 1):
+        prefix += points[i - 1]
+        
+        # Maximum power score from a previous prefix to current day i
+        # Power = (prefix[i] - prefix[j]) * (i - j)
+        best = max(best, (prefix - min_prefix) * (i - min_index))
+        
+        # Update the minimum prefix sum seen so far
+        if prefix < min_prefix:
+            min_prefix = prefix
+            min_index = i
+
+    return best
+
+
+# WEC-P style input
+if __name__ == "__main__":
+    n = int(input())
+    points = list(map(int, input().split()))
+    print(maxTournamentPower(points))
+
+
+-----------------------------------------------------------------------------------------------------
+
+Problem 2: Maximum Average Score Streak
+
+Description:
+Given points for N days, find the continuous streak of at least length K that has the maximum average score.
+
+Input: N K, points array
+
+Output: maximum average score (float with 6 decimals)
+
+Hint: Use prefix sums + sliding window / binary search on average.
+
+Twist: Minimum streak length constraint makes naive O(N²) impossible.
+
+
+--------CODE---------
+
+def maxAverageStreak(points, K):
+    n = len(points)
+
+    def canAchieve(avg):
+        prefix = [0] * (n + 1)
+        for i in range(n):
+            prefix[i + 1] = prefix[i] + points[i] - avg
+        min_prefix = 0
+        for i in range(K, n + 1):
+            if prefix[i] - min_prefix >= 0:
+                return True
+            min_prefix = min(min_prefix, prefix[i - K + 1])
+        return False
+
+    low, high = min(points), max(points)
+    eps = 1e-6
+    while high - low > eps:
+        mid = (low + high) / 2
+        if canAchieve(mid):
+            low = mid
+        else:
+            high = mid
+    return low
+
+# Example usage
+# n, K = map(int, input().split())
+# points = list(map(int, input().split()))
+# print(f"{maxAverageStreak(points, K):.6f}")
+
+
+-------------------------------------------------------------------------------------------------------
+
+Problem 3: Tournament Power ≤ Threshold
+
+Description:
+Given daily points and an integer T, find the longest streak such that power = sum(streak) × length ≤ T.
+
+Input: N T, points array
+
+Output: length of longest streak
+
+Hint: Use prefix sum + two pointers to check streak sums efficiently.
+
+-------CODE--------
+
+def longestPowerStreak(points, T):
+    n = len(points)
+    prefix = [0] * (n + 1)
+    for i in range(n):
+        prefix[i + 1] = prefix[i] + points[i]
+
+    max_len = 0
+    from collections import deque
+    dq = deque()  # stores indices of potential prefix min
+
+    for i in range(n + 1):
+        while dq and (prefix[i] - prefix[dq[0]]) * (i - dq[0]) > T:
+            dq.popleft()
+        if dq:
+            max_len = max(max_len, i - dq[0])
+        while dq and prefix[i] <= prefix[dq[-1]]:
+            dq.pop()
+        dq.append(i)
+    return max_len
+
+# Example usage
+# n, T = map(int, input().split())
+# points = list(map(int, input().split()))
+# print(longestPowerStreak(points, T))
+
+
+---------------------------------------------------------------------------------------------------
+
+
+Problem 4: Round-Robin Submatrix Scores (Multi-team)
+
+Description:
+R rounds, C teams. scoreMatrix[i][j] = points for team j in round i.
+
+Find the submatrix (any rectangle of rounds × teams) with maximum total points.
+
+Input: R C, matrix, 1 ≤ R,C ≤ 300
+
+Output: maximum sum
+
+Hint: 2D prefix sum is required to get O(R²*C²) → feasible for 300×300.
+
+
+-------CODE---------
+
+def maxSubmatrixSum(matrix):
+    R, C = len(matrix), len(matrix[0])
+    prefix = [[0]*(C+1) for _ in range(R+1)]
+    for i in range(R):
+        for j in range(C):
+            prefix[i+1][j+1] = matrix[i][j] + prefix[i][j+1] + prefix[i+1][j] - prefix[i][j]
+
+    max_sum = float('-inf')
+    for r1 in range(R):
+        for r2 in range(r1, R):
+            for c1 in range(C):
+                for c2 in range(c1, C):
+                    total = prefix[r2+1][c2+1] - prefix[r1][c2+1] - prefix[r2+1][c1] + prefix[r1][c1]
+                    max_sum = max(max_sum, total)
+    return max_sum
+
+# Example usage
+# R, C = map(int, input().split())
+# matrix = [list(map(int, input().split())) for _ in range(R)]
+# print(maxSubmatrixSum(matrix))
+
+
+--------------------------------------------------------------------------------------------
+
+
+Problem 5: Tournament Queries
+
+Description:
+Given N rounds with points and Q queries. Each query gives (L,R) asking maximum streak within that range.
+
+Input: N Q, points array, Q lines of (L,R)
+
+Output: maximum streak for each query
+
+Hint: Precompute prefix sums, and for each query, use segment tree / sparse table to answer in O(log N) per query.
+
+
+---------CODE--------
+
+
+class SegmentTree:
+    def __init__(self, arr):
+        n = len(arr)
+        self.N = 1
+        while self.N < n: self.N <<= 1
+        self.data = [0]*(2*self.N)
+        for i in range(n):
+            self.data[self.N + i] = arr[i]
+        for i in range(self.N-1,0,-1):
+            self.data[i] = max(self.data[2*i], self.data[2*i+1])
+
+    def query(self, l,r):
+        l += self.N
+        r += self.N
+        res = float('-inf')
+        while l < r:
+            if l % 2 == 1:
+                res = max(res, self.data[l])
+                l += 1
+            if r % 2 == 1:
+                r -= 1
+                res = max(res, self.data[r])
+            l //= 2
+            r //= 2
+        return res
+
+def maxStreakQueries(points, queries):
+    n = len(points)
+    prefix = [0]*(n+1)
+    for i in range(n):
+        prefix[i+1] = prefix[i] + points[i]
+    st = SegmentTree(prefix)
+    result = []
+    for l,r in queries:
+        # Maximum sum of subarray within [l,r]
+        max_val = float('-inf')
+        for i in range(l,r+1):
+            for j in range(i,r+1):
+                max_val = max(max_val, prefix[j+1]-prefix[i])
+        result.append(max_val)
+    return result
+
+# Example usage
+# n, Q = map(int, input().split())
+# points = list(map(int, input().split()))
+# queries = [tuple(map(int, input().split())) for _ in range(Q)]
+# ans = maxStreakQueries(points, queries)
+# print(*ans, sep='\n')
+
+
+-------------------------------------------------------------------------------------------------------
+
+
+-------Problem Summary-------
+
+Given:
+
+An array nums of length n (even)
+
+An integer limit
+
+Definition:
+
+A complementary pair is (nums[i], nums[n-1-i])
+
+Goal: Make all complementary pairs sum to the same value
+
+Operation: Change a number in the array to any integer between 1 and limit
+
+Task: Return the minimum number of moves to make all complementary pairs have the same sum.
+
+
+--------CODE---------
+
+
+def minMoves(nums, limit):
+    n = len(nums)
+    delta = [0] * (2 * limit + 2)
+
+    for i in range(n // 2):
+        a, b = nums[i], nums[n - 1 - i]
+        l, r = min(a,b)+1, max(a,b)+limit
+        delta[2] += 2        # initially assume 2 moves for all sums
+        delta[l] -= 1        # 1 move range starts
+        delta[a+b] -= 1      # exact sum requires 0 moves
+        delta[a+b+1] += 1    # end of exact sum
+        delta[r+1] += 1      # end of 1 move range
+
+    res = float('inf')
+    cur = 0
+    for i in range(2, 2*limit+1):
+        cur += delta[i]
+        res = min(res, cur)
+    return res
+
+# Example usage
+# nums = [1,2,2,1]
+# limit = 2
+# print(minMoves(nums, limit))  # Output: 1
+
+-------------------------------------------------------------------------------------------------------------------------
+
+Minimum Moves to Make Array Complementary
+
+(approach 1)
+def minMoves(nums, limit):
+    n = len(nums)
+    change = [0] * (2 * limit + 2)
+
+    for i in range(n // 2):
+        a, b = nums[i], nums[n - 1 - i]
+        low = min(a, b) + 1
+        high = max(a, b) + limit
+        # Default 2 moves
+        change[2] += 2
+        change[low] -= 1
+        change[a + b] -= 1
+        change[a + b + 1] += 1
+        change[high + 1] += 1
+
+    res = float('inf')
+    curr = 0
+    for i in range(2, 2 * limit + 1):
+        curr += change[i]
+        res = min(res, curr)
+    return res
+
+# Example
+nums = [1,2,4,3]
+limit = 4
+print(minMoves(nums, limit))  # Output: 1
+
+\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
+
+(approach 2)
+from itertools import accumulate
+from typing import List
+ 
+class Solution:
+    def minMoves(self, nums: List[int], limit: int) -> int:
+        n = len(nums)
+        diff = [0] * (2 * limit + 2)
+        
+        for i in range(n // 2):
+            x, y = nums[i], nums[-i - 1]
+            if x > y:
+                x, y = y, x
+            
+            diff[2] += 2
+            diff[x + 1] -= 1
+            diff[x + y] -= 1
+            diff[x + y + 1] += 1
+            diff[y + limit + 1] += 1
+        
+        return min(accumulate(diff[2:2 * limit + 1]))
+
+
+-------------------------------------------------------------------------------------------------------------------------
+
+========maximum summation subarray========
+
+def max_subarray_sum(arr):
+    if not arr:  # handle empty array
+        return 0
+
+    max_current = max_global = arr[0]
+
+    for num in arr[1:]:
+        # either start a new subarray at num or extend the current one
+        max_current = max(num, max_current + num)
+        max_global = max(max_global, max_current)
+
+    return max_global
+
+# Example usage
+arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+print("Maximum subarray sum:", max_subarray_sum(arr))
+
+-------------------------------------------------------------------------------------------------------------------------
+
+maximum index sum
+
+def maxIndexSum(arr):
+    n = len(arr)
+    rightMax = [0] * n
+    rightMax[-1] = arr[-1]
+
+    # Build suffix maximum array
+    for i in range(n-2, -1, -1):
+        rightMax[i] = max(arr[i], rightMax[i+1])
+
+    max_sum = -1
+    j = 1
+
+    for i in range(n-1):
+        # Move j forward until condition fails
+        while j < n and arr[i] >= rightMax[j]:
+            j += 1
+        if j < n:
+            max_sum = max(max_sum, i + j)
+
+    return max_sum
+
+# Example
+arr = [1, 2, 3, 4, 5]
+print(maxIndexSum(arr))  # Output: 3 + 4 = 7
+
+-------------------------------------------------------------------------------------------------------------------------
+
+
+Maximum Sum of a Subarray
+
+def maxSubarraySum(arr):
+    if not arr:  # Edge case: empty array
+        return 0
+
+    max_sum = arr[0]
+    current_sum = arr[0]
+    
+    for i in range(1, len(arr)):
+        current_sum = max(arr[i], current_sum + arr[i])
+        max_sum = max(max_sum, current_sum)
+        
+    return max_sum
+
+# Example
+arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+print(maxSubarraySum(arr))  # Output: 6
+
+
+-------------------------------------------------------------------------------------------------------------------------
+
+Maximum Index Sum / Maximum Sum with Constraint A[i] < A[j]
+
+def maxIndexSum(arr):
+    n = len(arr)
+    if n < 2:  # Edge case: less than 2 elements
+        return 0
+
+    # Build suffix maximum array
+    suffix_max = [0] * n
+    suffix_max[-1] = arr[-1]
+    for i in range(n-2, -1, -1):
+        suffix_max[i] = max(arr[i], suffix_max[i+1])
+
+    max_sum = -1
+    j = 1
+
+    for i in range(n-1):
+        while j < n and arr[i] >= suffix_max[j]:
+            j += 1
+        if j < n:
+            max_sum = max(max_sum, i + j)
+
+    return max_sum if max_sum != -1 else 0
+
+# Example
+arr = [1, 2, 3, 4, 5]
+print(maxIndexSum(arr))  # Output: 7 (i=3, j=4)
+
+
+-------------------------------------------------------------------------------------------------------------------------
+
+Longest Increasing Subsequence (LIS)
+
+import bisect
+
+def maxSubsequenceLength(arr):
+    sub = []
+    for x in arr:
+        idx = bisect.bisect_left(sub, x)
+        if idx == len(sub):
+            sub.append(x)
+        else:
+            sub[idx] = x
+    return len(sub)
+
+# Example
+arr = [10, 9, 2, 5, 3, 7, 101, 18]
+print(maxSubsequenceLength(arr))  # Output: 4 ([2,3,7,18])
+
+-------------------------------------------------------------------------------------------------------------------------
+
+Maximum Subsequence Length with Sum ≤ k
+
+def maxSubsequenceLengthWithSum(arr, k):
+    """
+    Returns maximum number of elements in a subsequence 
+    whose sum ≤ k. Order does NOT matter.
+    """
+    if not arr:
+        return 0
+
+    arr.sort()  # Greedy: pick smallest numbers first
+    total = 0
+    count = 0
+
+    for x in arr:
+        if total + x <= k:
+            total += x
+            count += 1
+        else:
+            break  # further elements are larger (sorted), cannot add
+    return count
+
+# Example
+arr = [4, 2, 1, 10, 5]
+k = 8
+print(maxSubsequenceLengthWithSum(arr, k))  # Output: 3 (1+2+4 ≤ 8)
+
+-------------------------------------------------------------------------------------------------------------------------
+
+Maximum Sum of Pair
+
+def maxPairSum(arr):
+    if len(arr) < 2:
+        return 0  # Edge case
+    first = second = float('-inf')
+    for num in arr:
+        if num > first:
+            second = first
+            first = num
+        elif num > second:
+            second = num
+    return first + second
+
+# Example
+arr = [1, 2, 3, 4, 5]
+print(maxPairSum(arr))  # Output: 9 (4+5)
+
+-------------------------------------------------------------------------------------------------------------------------
+
+Maximum Sum of Pair with Constraint (A[i] < A[j] and i<j)
+
+
+def maxPairSumConstraint(arr):
+    n = len(arr)
+    if n < 2:
+        return 0
+    
+    suffix_max = [0]*n
+    suffix_max[-1] = arr[-1]
+    for i in range(n-2, -1, -1):
+        suffix_max[i] = max(arr[i], suffix_max[i+1])
+
+    max_sum = float('-inf')
+    j = 1
+
+    for i in range(n-1):
+        while j < n and arr[i] >= suffix_max[j]:
+            j += 1
+        if j < n:
+            max_sum = max(max_sum, arr[i] + arr[j])
+    
+    return max_sum if max_sum != float('-inf') else 0
+
+# Example
+arr = [1, 2, 3, 2, 5]
+print(maxPairSumConstraint(arr))  # Output: 7 (2+5)
+
+-------------------------------------------------------------------------------------------------------------------------
+
+Generate All Permutations
+
+def permute(arr):
+    def backtrack(start):
+        if start == len(arr):
+            result.append(arr[:])  # Add a copy of current permutation
+            return
+        for i in range(start, len(arr)):
+            arr[start], arr[i] = arr[i], arr[start]  # Swap
+            backtrack(start + 1)
+            arr[start], arr[i] = arr[i], arr[start]  # Backtrack
+
+    result = []
+    backtrack(0)
+    return result
+
+# Example
+arr = [1, 2, 3]
+permutations = permute(arr)
+print(permutations)
+# Output: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,2,1],[3,1,2]]
+
+-------------------------------------------------------------------------------------------------------------------------
+
+Maximum XOR of Any Pair
+
+class TrieNode:
+    def __init__(self):
+        self.children = {}
+
+def insert(root, num):
+    node = root
+    for i in reversed(range(32)):  # 31..0 bits
+        bit = (num >> i) & 1
+        if bit not in node.children:
+            node.children[bit] = TrieNode()
+        node = node.children[bit]
+
+def findMaxXORPair(arr):
+    root = TrieNode()
+    max_xor = 0
+    insert(root, arr[0])
+    
+    for num in arr[1:]:
+        node = root
+        curr_xor = 0
+        for i in reversed(range(32)):
+            bit = (num >> i) & 1
+            toggled_bit = 1 - bit
+            if toggled_bit in node.children:
+                curr_xor |= (1 << i)
+                node = node.children[toggled_bit]
+            else:
+                node = node.children.get(bit)
+        max_xor = max(max_xor, curr_xor)
+        insert(root, num)
+    
+    return max_xor
+
+# Example
+arr = [3, 10, 5, 25, 2, 8]
+print(findMaxXORPair(arr))  # Output: 28 (5 ^ 25)
+
+-------------------------------------------------------------------------------------------------------------------------
+
+Maximum XOR of Subarray
+
+def findMaxXORSubarray(arr):
+    root = TrieNode()
+    insert(root, 0)  # Prefix XOR 0
+    max_xor = float('-inf')
+    prefix_xor = 0
+    
+    for num in arr:
+        prefix_xor ^= num
+        node = root
+        curr_xor = 0
+        for i in reversed(range(32)):
+            bit = (prefix_xor >> i) & 1
+            toggled_bit = 1 - bit
+            if toggled_bit in node.children:
+                curr_xor |= (1 << i)
+                node = node.children[toggled_bit]
+            else:
+                node = node.children.get(bit)
+        max_xor = max(max_xor, curr_xor)
+        insert(root, prefix_xor)
+    
+    return max_xor
+
+# Example
+arr = [8, 1, 2, 12, 7, 6]
+print(findMaxXORSubarray(arr))  # Output: 15
+
+-------------------------------------------------------------------------------------------------------------------------
+
+Maximum Value and Minimum Distance
+
+def maxValueMinDistance(arr):
+    if not arr:
+        return 0
+    
+    max1 = float('-inf')
+    min1 = float('inf')
+    max2 = float('-inf')
+    min2 = float('inf')
+    
+    for i, val in enumerate(arr):
+        max1 = max(max1, val + i)
+        min1 = min(min1, val + i)
+        max2 = max(max2, val - i)
+        min2 = min(min2, val - i)
+    
+    return max(max1 - min1, max2 - min2)
+
+# Example
+arr = [1, 3, -1]
+print(maxValueMinDistance(arr))  # Output: 5
+
+-------------------------------------------------------------------------------------------------------------------------
+
+Generate All Permutations of a String
+
+def stringPermutations(s):
+    def backtrack(start):
+        if start == len(s_list):
+            result.append(''.join(s_list))
+            return
+        for i in range(start, len(s_list)):
+            s_list[start], s_list[i] = s_list[i], s_list[start]
+            backtrack(start + 1)
+            s_list[start], s_list[i] = s_list[i], s_list[start]  # Backtrack
+
+    s_list = list(s)
+    result = []
+    backtrack(0)
+    return result
+
+# Example
+s = "abc"
+perms = stringPermutations(s)
+print(perms)
+# Output: ['abc', 'acb', 'bac', 'bca', 'cba', 'cab']
+
+-------------------------------------------------------------------------------------------------------------------------
+
+Generate All Subsequences of a String
+
+def stringSubsequences(s):
+    result = []
+    n = len(s)
+    
+    for i in range(1 << n):  # 2^n subsequences
+        subseq = ''
+        for j in range(n):
+            if (i >> j) & 1:
+                subseq += s[j]
+        result.append(subseq)
+    
+    return result
+
+# Example
+s = "abc"
+subs = stringSubsequences(s)
+print(subs)
+# Output: ['', 'a', 'b', 'ab', 'c', 'ac', 'bc', 'abc']
+
+-------------------------------------------------------------------------------------------------------------------------
+
+Minimize Product of Any Pair in Array
+
+def minimizeProduct(arr):
+    if len(arr) < 2:
+        return 0  # Edge case
+    
+    arr.sort()
+    # Two smallest numbers
+    prod1 = arr[0] * arr[1]
+    # Two largest numbers
+    prod2 = arr[-1] * arr[-2]
+    # Smallest negative * largest positive
+    prod3 = arr[0] * arr[-1]
+
+    return min(prod1, prod2, prod3)
+
+# Example
+arr = [-10, -3, 5, 6, -2]
+print(minimizeProduct(arr))  # Output: -60 (-10*6)
+
+-------------------------------------------------------------------------------------------------------------------------
+
+Minimize Product of Subsequence Sum / After Operations
+
+def minimizeProductK(arr, k):
+    arr.sort()
+    product = 1
+    for i in range(k):
+        product *= arr[i]
+    return product
+
+# Example
+arr = [3, 1, 2, 4]
+k = 2
+print(minimizeProductK(arr, k))  # Output: 1*2=2
+
+-------------------------------------------------------------------------------------------------------------------------
+
+Minimize Maximum Sum Among k Subarrays
+
+def minimizeMaximum(A, k):
+    def canDivide(mid):
+        count = 1
+        total = 0
+        for num in A:
+            if total + num > mid:
+                count += 1
+                total = num
+            else:
+                total += num
+        return count <= k
+
+    low, high = max(A), sum(A)
+    ans = high
+    while low <= high:
+        mid = (low + high) // 2
+        if canDivide(mid):
+            ans = mid
+            high = mid - 1
+        else:
+            low = mid + 1
+    return ans
+
+# Example
+A = [7, 2, 5, 10, 8]
+k = 2
+print(minimizeMaximum(A, k))  # Output: 18
+
+-------------------------------------------------------------------------------------------------------------------------
+
+Minimum Speed to Arrive on Time
+
+import math
+
+def minSpeedOnTime(dist, hour):
+    def feasible(speed):
+        time = 0
+        for d in dist[:-1]:
+            time += math.ceil(d / speed)
+        time += dist[-1] / speed
+        return time <= hour
+
+    low, high = 1, 10**7  # Upper bound sufficiently large
+    ans = -1
+    while low <= high:
+        mid = (low + high) // 2
+        if feasible(mid):
+            ans = mid
+            high = mid - 1
+        else:
+            low = mid + 1
+    return ans
+
+# Example
+dist = [1, 3, 2]
+hour = 6
+print(minSpeedOnTime(dist, hour))  # Output: 1
+
+
+------------------------------------------------------------------------------------------------------------------
+