304 North Cardinal St.
Dorchester Center, MA 02124

# Biweekly Contest 71 LeetCode Solution

## Problem 1 – Minimum Sum of Four Digit Number After Splitting Digits Leetcode Solution

You are given a positive integer `num` consisting of exactly four digits. Split `num` into two new integers `new1` and `new2` by using the digits found in `num`Leading zeros are allowed in `new1` and `new2`, and all the digits found in `num` must be used.

• For example, given `num = 2932`, you have the following digits: two `2`‘s, one `9` and one `3`. Some of the possible pairs `[new1, new2]` are `[22, 93]``[23, 92]``[223, 9]` and `[2, 329]`.

Return the minimum possible sum of `new1` and `new2`.

Example 1:

``````Input: num = 2932
Output: 52
Explanation: Some possible pairs [new1, new2] are [29, 23], [223, 9], etc.
The minimum sum can be obtained by the pair [29, 23]: 29 + 23 = 52.
``````

Example 2:

``````Input: num = 4009
Output: 13
Explanation: Some possible pairs [new1, new2] are [0, 49], [490, 0], etc.
The minimum sum can be obtained by the pair [4, 9]: 4 + 9 = 13.
``````

Constraints:

• `1000 <= num <= 9999`

### Minimum Sum of Four Digit Number After Splitting Digits Leetcode Solution in C++

``````class Solution{
public:
int minimumSum(int num){
string s = to_string(num);
sort(s.begin(), s.end());
int res = (s - '0' + s - '0') * 10 + s - '0' + s - '0';
return res;
}
};
``````

### Minimum Sum of Four Digit Number After Splitting Digits Leetcode Solution in Java

``````class Solution
{
public int minimumSum(int num)
{
int[] dig = new int; // For each digit
int cur = 0;
while(num > 0) // Getting each digit
{
dig[cur++] = num % 10;
num /= 10;
}
Arrays.sort(dig); // Ascending order
int num1 = dig * 10 + dig; // 1st and 3rd digit
int num2 = dig * 10 + dig; // 2nd and 4th digit
return num1 + num2;
}
}
``````

### Minimum Sum of Four Digit Number After Splitting Digits Leetcode Solution in Python

``````class Solution:
def minimumSum(self, num: int) -> int:
s = list(str(num))
s.sort()
s1 = s+s
s2 = s+s
sum = int(s1)+int(s2)

return sum
``````

## Problem 2 – Partition Array According to Given Pivot Leetcode Solution

You are given a 0-indexed integer array `nums` and an integer `pivot`. Rearrange `nums` such that the following conditions are satisfied:

• Every element less than `pivot` appears before every element greater than `pivot`.
• Every element equal to `pivot` appears in between the elements less than and greater than `pivot`.
• The relative order of the elements less than `pivot` and the elements greater than `pivot` is maintained.
• More formally, consider every `pi``pj` where `pi` is the new position of the `ith` element and `pj` is the new position of the `jth` element. For elements less than `pivot`, if `i < j` and `nums[i] < pivot` and `nums[j] < pivot`, then `pi < pj`. Similarly for elements greater than `pivot`, if `i < j` and `nums[i] > pivot` and `nums[j] > pivot`, then `pi < pj`.

Return `nums` after the rearrangement.

Example 1:

``````Input: nums = [9,12,5,10,14,3,10], pivot = 10
Output: [9,5,3,10,10,12,14]
Explanation:
The elements 9, 5, and 3 are less than the pivot so they are on the left side of the array.
The elements 12 and 14 are greater than the pivot so they are on the right side of the array.
The relative ordering of the elements less than and greater than pivot is also maintained. [9, 5, 3] and [12, 14] are the respective orderings.
``````

Example 2:

``````Input: nums = [-3,4,3,2], pivot = 2
Output: [-3,2,4,3]
Explanation:
The element -3 is less than the pivot so it is on the left side of the array.
The elements 4 and 3 are greater than the pivot so they are on the right side of the array.
The relative ordering of the elements less than and greater than pivot is also maintained. [-3] and [4, 3] are the respective orderings.
``````

Constraints:

• `1 <= nums.length <= 105`
• `-106 <= nums[i] <= 106`
• `pivot` equals to an element of `nums`.

### Partition Array According to Given Pivot Leetcode Solution in C++

``````class Solution
{
public:
vector<int> pivotArray(vector<int> &nums, int pivot)
{
int low = 0;
int same = 0;
int high;
for (auto n : nums)
{
if (n < pivot)
{
++low;
}
else if (n == pivot)
{
++same;
}
}
vector<int> res(nums.size());
high = same + low;
same = low;
low = 0;
for (auto n : nums)
{
if (n < pivot)
{
res[low++] = n;
}
else if (n == pivot)
{
res[same++] = n;
}
else
{
res[high++] = n;
}
}
return res;
}
};
``````

### Partition Array According to Given Pivot Leetcode Solution in Java

``````    public int[] pivotArray(int[] nums, int pivot) {

int n = nums.length, pivotFreq = 0, i = 0;
int[] ans = new int[n];

for (int num : nums) {
if (num < pivot) {
ans[i++] = num;
}else if (num == pivot) {
++pivotFreq;
}
}

while (pivotFreq-- > 0) {
ans[i++] = pivot;
}

for (int num : nums) {
if (num > pivot) {
ans[i++] = num;
}
}

return ans;
}
``````

### Partition Array According to Given Pivot Leetcode Solution in Python 3

``````    def pivotArray(self, nums: List[int], pivot: int) -> List[int]:
pivotFreq, ans = 0, []

for num in nums:
if num < pivot:
ans.append(num)
elif num == pivot:
pivotFreq += 1

ans.extend([pivot] * pivotFreq)

for num in nums:
if num > pivot:
ans.append(num)

return ans
``````

### Partition Array According to Given Pivot Leetcode Solution in Python

``````class Solution:
def pivotArray(self, nums: List[int], pivot: int) -> List[int]:

ans=[]

nums.remove(pivot)

i=0
ans.append(pivot)

for j in nums:
if j<pivot:
ans.insert(i,j)
i=i+1
elif j==pivot:
ans.insert(i+1,j)
else:
ans.append(j)

return ans
``````

## Problem 3 – Minimum Cost to Set Cooking Time Leetcode Solution

A generic microwave supports cooking times for:

• at least `1` second.
• at most `99` minutes and `99` seconds.

To set the cooking time, you push at most four digits. The microwave normalizes what you push as four digits by prepending zeroes. It interprets the first two digits as the minutes and the last two digits as the seconds. It then adds them up as the cooking time. For example,

• You push `9` `5` `4` (three digits). It is normalized as `0954` and interpreted as `9` minutes and `54` seconds.
• You push `0` `0` `0` `8` (four digits). It is interpreted as `0` minutes and `8` seconds.
• You push `8` `0` `9` `0`. It is interpreted as `80` minutes and `90` seconds.
• You push `8` `1` `3` `0`. It is interpreted as `81` minutes and `30` seconds.

You are given integers `startAt``moveCost``pushCost`, and `targetSeconds`Initially, your finger is on the digit `startAt`. Moving the finger above any specific digit costs `moveCost` units of fatigue. Pushing the digit below the finger once costs `pushCost` units of fatigue.

There can be multiple ways to set the microwave to cook for `targetSeconds` seconds but you are interested in the way with the minimum cost.

Return the minimum cost to set `targetSeconds` seconds of cooking time.

Remember that one minute consists of `60` seconds.

Example 1:

``````Input: startAt = 1, moveCost = 2, pushCost = 1, targetSeconds = 600
Output: 6
Explanation: The following are the possible ways to set the cooking time.
- 1 0 0 0, interpreted as 10 minutes and 0 seconds.
The finger is already on digit 1, pushes 1 (with cost 1), moves to 0 (with cost 2), pushes 0 (with cost 1), pushes 0 (with cost 1), and pushes 0 (with cost 1).
The cost is: 1 + 2 + 1 + 1 + 1 = 6. This is the minimum cost.
- 0 9 6 0, interpreted as 9 minutes and 60 seconds. That is also 600 seconds.
The finger moves to 0 (with cost 2), pushes 0 (with cost 1), moves to 9 (with cost 2), pushes 9 (with cost 1), moves to 6 (with cost 2), pushes 6 (with cost 1), moves to 0 (with cost 2), and pushes 0 (with cost 1).
The cost is: 2 + 1 + 2 + 1 + 2 + 1 + 2 + 1 = 12.
- 9 6 0, normalized as 0960 and interpreted as 9 minutes and 60 seconds.
The finger moves to 9 (with cost 2), pushes 9 (with cost 1), moves to 6 (with cost 2), pushes 6 (with cost 1), moves to 0 (with cost 2), and pushes 0 (with cost 1).
The cost is: 2 + 1 + 2 + 1 + 2 + 1 = 9.
``````

Example 2:

``````Input: startAt = 0, moveCost = 1, pushCost = 2, targetSeconds = 76
Output: 6
Explanation: The optimal way is to push two digits: 7 6, interpreted as 76 seconds.
The finger moves to 7 (with cost 1), pushes 7 (with cost 2), moves to 6 (with cost 1), and pushes 6 (with cost 2). The total cost is: 1 + 2 + 1 + 2 = 6
Note other possible ways are 0076, 076, 0116, and 116, but none of them produces the minimum cost.
``````

Constraints:

• `0 <= startAt <= 9`
• `1 <= moveCost, pushCost <= 105`
• `1 <= targetSeconds <= 6039`

### Minimum Cost to Set Cooking Time Leetcode Solution in C++

``````int minCostSetTime(int startAt, int moveCost, int pushCost, int targetSeconds) {
auto cost = [&](int pos, int m, int s){
if (min(m, s) < 0 || max(m, s) > 99)
return INT_MAX;
int res = 0;
for (auto digit : to_string(m * 100 + s)) {
res += pushCost + (pos == digit - '0' ? 0 : moveCost);
pos = digit - '0';
}
return res;
};
int m = targetSeconds / 60, s = targetSeconds % 60;
return min(cost(startAt, m, s), cost(startAt, m - 1, s + 60));
}
``````

### Minimum Cost to Set Cooking Time Leetcode Solution in Java

``````class Solution {
public int minCostSetTime(int startAt, int moveCost, int pushCost, int tar) {

int min=tar/60, sec=tar%60, minCost=(moveCost+pushCost)*4;

if(min>99) { min--; sec+=60; } // this is required to do because if tar>=6000 then min is 100 which is not possible as it atmost can be 99mins

while(min>=0&&sec<=99) { // this while loop will work for atmost 2 iterations
tar=min*100+sec;
char arr[]=(""+tar).toCharArray();
int sameMove=0;
for(int i=0;i<arr.length-1;i++)
if(arr[i]==arr[i+1])
sameMove++;
if(startAt==arr-'0')
minCost=Math.min(minCost,pushCost*arr.length+moveCost*(arr.length-1-sameMove));
else
minCost=Math.min(minCost,pushCost*arr.length+moveCost*(arr.length-sameMove));
min--; sec+=60;
}
return minCost;
}
}
``````

### Minimum Cost to Set Cooking Time Leetcode Solution in Python

``````def minCostSetTime(self, start: int, mC: int, pC: int, TS: int) -> int:
def helper(mins, secs):
pre, cost, ss = str(start), 0, str(secs)
if mins != 0:
if len(ss) < 2:
ss = "0" + ss
ss = str(mins) + ss
for ch in ss:
if ch != pre:
cost += mC
cost += pC
pre = ch
return cost

mins, secs = divmod(TS, 60)
ans = math.inf

if mins < 100:
ans = min(ans, helper(mins, secs))
if secs < 40:
ans = min(ans, helper(mins - 1, secs + 60))
return ans
``````

## Problem 4 – Minimum Difference in Sums After Removal of Elements Leetcode Solution

You are given a 0-indexed integer array `nums` consisting of `3 * n` elements.

You are allowed to remove any subsequence of elements of size exactly `n` from `nums`. The remaining `2 * n` elements will be divided into two equal parts:

• The first `n` elements belonging to the first part and their sum is `sumfirst`.
• The next `n` elements belonging to the second part and their sum is `sumsecond`.

The difference in sums of the two parts is denoted as `sumfirst - sumsecond`.

• For example, if `sumfirst = 3` and `sumsecond = 2`, their difference is `1`.
• Similarly, if `sumfirst = 2` and `sumsecond = 3`, their difference is `-1`.

Return the minimum difference possible between the sums of the two parts after the removal of `n` elements.

Example 1:

``````Input: nums = [3,1,2]
Output: -1
Explanation: Here, nums has 3 elements, so n = 1.
Thus we have to remove 1 element from nums and divide the array into two equal parts.
- If we remove nums = 3, the array will be [1,2]. The difference in sums of the two parts will be 1 - 2 = -1.
- If we remove nums = 1, the array will be [3,2]. The difference in sums of the two parts will be 3 - 2 = 1.
- If we remove nums = 2, the array will be [3,1]. The difference in sums of the two parts will be 3 - 1 = 2.
The minimum difference between sums of the two parts is min(-1,1,2) = -1.
``````

Example 2:

``````Input: nums = [7,9,5,8,1,3]
Output: 1
Explanation: Here n = 2. So we must remove 2 elements and divide the remaining array into two parts containing two elements each.
If we remove nums = 5 and nums = 8, the resultant array will be [7,9,1,3]. The difference in sums will be (7+9) - (1+3) = 12.
To obtain the minimum difference, we should remove nums = 9 and nums = 1. The resultant array becomes [7,5,8,3]. The difference in sums of the two parts is (7+5) - (8+3) = 1.
It can be shown that it is not possible to obtain a difference smaller than 1.
``````

Constraints:

• `nums.length == 3 * n`
• `1 <= n <= 105`
• `1 <= nums[i] <= 105`

### Minimum Difference in Sums After Removal of Elements Leetcode Solution in Python

``````def minimumDifference(self, A: List[int]) -> int:
n = len(A) // 3

# Build pre_min using min-heap.
pre_min, cur_min = [sum(A[:n])], sum(A[:n])
pre_hp = [-x for x in A[:n]]
heapq.heapify(pre_hp)
for i in range(n, 2 * n):
cur_pop = -heapq.heappop(pre_hp)
cur_min -= cur_pop
cur_min += min(cur_pop, A[i])
pre_min.append(cur_min)
heapq.heappush(pre_hp, -min(cur_pop, A[i]))

# Build suf_max.
suf_max, cur_max = [sum(A[2*n:])], sum(A[2*n:])
suf_hp = [x for x in A[2*n:]]
heapq.heapify(suf_hp)
for i in range(2 * n - 1, n - 1, -1):
cur_pop = heapq.heappop(suf_hp)
cur_max -= cur_pop
cur_max += max(cur_pop, A[i])
suf_max.append(cur_max)
heapq.heappush(suf_hp, max(cur_pop, A[i]))
suf_max = suf_max[::-1]

# Iterate over pre_min and suf_max and get the minimum difference.
ans = math.inf
for a, b in zip(pre_min, suf_max):
ans = min(ans, a - b)
return ans
``````

### Minimum Difference in Sums After Removal of Elements Leetcode Solution in C++

``````class Solution {
public:
long long minimumDifference(vector<int>& A) {
priority_queue<int> L; // storing the smallest N digits in the first part
priority_queue<int,vector<int>, greater<>> R; // storing the greatest N digits in the right part
long N = A.size() / 3, left = 0, right = 0, ans = LLONG_MAX;
vector<long> tmp(A.size());
for (int i = A.size() - 1; i >= N; --i) { // calculate the greatest N digits in the right part
R.push(A[i]);
right += A[i];
if (R.size() > N) {
right -= R.top();
R.pop();
}
if (R.size() == N) tmp[i] = right; // `tmp[i]` is the maximum sum of `N` digits in `A[i:]`
}
for (int i = 0; i < A.size() - N; ++i) {
L.push(A[i]);
left += A[i];
if (L.size() > N) {
left -= L.top();
L.pop();
}
if (L.size() == N) ans = min(ans, left - tmp[i + 1]);
}
return ans;
}
};
``````

### Minimum Difference in Sums After Removal of Elements Leetcode Solution in Java

``````class Solution {
public long minimumDifference(int[] nums) {
int n = nums.length / 3;
PriorityQueue<Integer> left = new PriorityQueue<>((a, b) -> b - a);
PriorityQueue<Integer> right = new PriorityQueue<>();
long[] minLeft = new long[3 * n];

long leftSum = 0;
long rightSum = 0;

for (int i = 0; i < n; i++) {
leftSum += nums[i];
}

minLeft[n-1] = leftSum;

for (int i = n; i < 2 * n; i++) {
leftSum += nums[i];
leftSum -= left.poll();
minLeft[i] = leftSum;
}

for (int i = 3 * n - 1; i >= 2 * n; i--) {
rightSum += nums[i];
}

long res = minLeft[2 * n - 1] - rightSum;

for (int i = 2 * n - 1; i >= n; i--) {
rightSum += nums[i];
rightSum -= right.poll();
res = Math.min(res, minLeft[i - 1] - rightSum);
}

return res;
}
}
``````

### Minimum Difference in Sums After Removal of Elements Leetcode Solution in Python 3

``````def minimumDifference(self, nums: List[int]) -> int:
n = len(nums) // 3
# two heap queues, we keep n smallest elements in first, and n greatest elements in second
first, second = list(), list()
sum_1, sum_2 = 0, 0

for i in range(n):
heapq.heappush(first, -nums[i])
sum_1 += nums[i]
for i in range(2 * n, 3 * n):
heapq.heappush(second, nums[i])
sum_2 += nums[i]

# divide nums into two parts: nums[:i] & nums[i + 1:]
# i can only be in range(n + 1, 2 * n)
sum_first = [sum_1] # sum_first stores sum of n smallest elements for i in range(n + 1, 2 * n)
sum_second = [sum_2] # sum_second stores sum of n greatest elements for i in range(2 * n - 1, n, -1)

middle = nums[n : 2 * n]
for i in middle:
rep = heapq.heappushpop(first, -i)
sum_1 += i + rep
sum_first.append(sum_1)

for i in middle[::-1]:
rep = heapq.heappushpop(second, i)
sum_2 += i - rep
sum_second.append(sum_2)

# then sum_first[k] & sum_second[n - 1 - k] will be a pair for the same i
return min(i - j for i, j in zip(sum_first, sum_second[::-1]))
``````

### Minimum Difference in Sums After Removal of Elements Leetcode Solution in C#

``````public class Solution {
public long MinimumDifference(int[] nums) {
PriorityQueue<long,long> left = new PriorityQueue<long,long>();
PriorityQueue<long,long> right = new PriorityQueue<long,long>();
int n = nums.Length/3;

long[] sumLeft = new long[n+1];
long[] sumRight = new long[n+1];
long tLeft = 0;
long tRight = 0;
for(int i=0;i<n;i++){
tLeft += nums[i];
left.Enqueue(nums[i],-nums[i]);
tRight += nums[nums.Length-1-i];
right.Enqueue(nums[nums.Length-1-i],nums[nums.Length-1-i]);
}
sumLeft = tLeft;
sumRight= tRight;
for(int i=1;i<n+1;i++){
long t = left.Dequeue();
if(t>nums[n-1+i]){
sumLeft[i] = sumLeft[i-1]-t+nums[n-1+i];
left.Enqueue(nums[n-1+i],-nums[n-1+i]);
}else{
left.Enqueue(t,-t);
sumLeft[i] = sumLeft[i-1];
}

}

for(int i=1;i<n+1;i++){
long t = right.Dequeue();
if(t<nums[2*n-i]){
sumRight[i] = sumRight[i-1]-t+nums[2*n-i];
right.Enqueue(nums[2*n-i],nums[2*n-i]);
}else{
right.Enqueue(t,t);
sumRight[i] = sumRight[i-1];
}
}
long res = sumLeft;
for(int i=0;i<n+1;i++)
res = Math.Min(res,sumLeft[i]-sumRight[n-i]);

return res;

}
}
``````
##### Biweekly Contest 71 LeetCode Solution Review:

In our experience, we suggest you solve this Biweekly Contest 71 LeetCode Solution and gain some new skills from Professionals completely free and we assure you will be worth it.

If you are stuck anywhere between any coding problem, just visit Queslers to get the Biweekly Contest 71 LeetCode Solution

Find on LeetCode

##### Conclusion:

I hope this Biweekly Contest 71 LeetCode Solution would be useful for you to learn something new from this problem. If it helped you then don’t forget to bookmark our site for more Coding Solutions.

This Problem is intended for audiences of all experiences who are interested in learning about Data Science in a business context; there are no prerequisites.

Keep Learning!

More Coding Solutions >>

LeetCode Solutions

Hacker Rank Solutions

CodeChef Solutions