leetcode

Author: ayoubzulfiqar

PutMarblesInBags/put_marbles_in_bags.dart

@@ -0,0 +1,97 @@
+/*
+
+
+-* 2551. Put Marbles in Bags *-
+
+
+You have k bags. You are given a 0-indexed integer array weights where weights[i] is the weight of the ith marble. You are also given the integer k.
+
+Divide the marbles into the k bags according to the following rules:
+
+No bag is empty.
+If the ith marble and jth marble are in a bag, then all marbles with an index between the ith and jth indices should also be in that same bag.
+If a bag consists of all the marbles with an index from i to j inclusively, then the cost of the bag is weights[i] + weights[j].
+The score after distributing the marbles is the sum of the costs of all the k bags.
+
+Return the difference between the maximum and minimum scores among marble distributions.
+
+ 
+
+Example 1:
+
+Input: weights = [1,3,5,1], k = 2
+Output: 4
+Explanation: 
+The distribution [1],[3,5,1] results in the minimal score of (1+1) + (3+1) = 6. 
+The distribution [1,3],[5,1], results in the maximal score of (1+3) + (5+1) = 10. 
+Thus, we return their difference 10 - 6 = 4.
+Example 2:
+
+Input: weights = [1, 3], k = 2
+Output: 0
+Explanation: The only distribution possible is [1],[3]. 
+Since both the maximal and minimal score are the same, we return 0.
+ 
+
+Constraints:
+
+1 <= k <= weights.length <= 105
+1 <= weights[i] <= 109
+
+
+*/
+
+class A {
+  int putMarbles(List<int> weights, int k) {
+    final List<int> sums = List.empty();
+    k--;
+
+    for (int i = 0; i < weights.length - 1; i++) {
+      sums.add(weights[i] + weights[i + 1]);
+    }
+
+    sums.sort();
+
+    int ans1 = 0;
+    int ans2 = 0;
+
+    for (int i = 0; i < sums.length - k; i++) {
+      ans1 += sums[i];
+    }
+
+    for (int i = k; i < sums.length; i++) {
+      ans2 += sums[i];
+    }
+
+    return ans2 - ans1;
+  }
+}
+
+class Solution {
+  int putMarbles(List<int> weights, int k) {
+    List<int> pqMax = [];
+    List<int> pqMin = [];
+
+    for (int i = 1; i <= weights.length - 1; i++) {
+      pqMax.add(i);
+      pqMax.sort((a, b) =>
+          (weights[a] + weights[a - 1]).compareTo(weights[b] + weights[b - 1]));
+      if (pqMax.length > k - 1) pqMax.removeAt(0);
+
+      pqMin.add(i);
+      pqMin.sort((a, b) =>
+          (weights[b] + weights[b - 1]).compareTo(weights[a] + weights[a - 1]));
+      if (pqMin.length > k - 1) pqMin.removeAt(0);
+    }
+
+    int sumMax = pqMax
+        .map((index) => weights[index] + weights[index - 1])
+        .fold(0, (sum, element) => sum + element);
+
+    int sumMin = pqMin
+        .map((index) => weights[index] + weights[index - 1])
+        .fold(0, (sum, element) => sum + element);
+
+    return (sumMax - sumMin).abs();
+  }
+}

PutMarblesInBags/put_marbles_in_bags.go

@@ -0,0 +1,66 @@
+package main
+
+import "container/heap"
+
+type MinHeap []int
+
+func (h MinHeap) Len() int           { return len(h) }
+func (h MinHeap) Less(i, j int) bool { return h[i] < h[j] }
+func (h MinHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+
+func (h *MinHeap) Push(x interface{}) {
+	*h = append(*h, x.(int))
+}
+
+func (h *MinHeap) Pop() interface{} {
+	old := *h
+	n := len(old)
+	x := old[n-1]
+	*h = old[:n-1]
+	return x
+}
+
+type MaxHeap []int
+
+func (h MaxHeap) Len() int           { return len(h) }
+func (h MaxHeap) Less(i, j int) bool { return h[i] > h[j] }
+func (h MaxHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+
+func (h *MaxHeap) Push(x interface{}) {
+	*h = append(*h, x.(int))
+}
+
+func (h *MaxHeap) Pop() interface{} {
+	old := *h
+	n := len(old)
+	x := old[n-1]
+	*h = old[:n-1]
+	return x
+}
+
+func putMarbles(weights []int, k int) int64 {
+	maxQ := &MaxHeap{}
+	minQ := &MinHeap{}
+	heap.Init(maxQ)
+	heap.Init(minQ)
+
+	n := len(weights)
+	for i := 0; i < n-1; i++ {
+		heap.Push(maxQ, weights[i]+weights[i+1])
+		if maxQ.Len() == k {
+			heap.Pop(maxQ)
+		}
+
+		heap.Push(minQ, weights[i]+weights[i+1])
+		if minQ.Len() == k {
+			heap.Pop(minQ)
+		}
+	}
+
+	var diff int64
+	for len(*minQ) > 0 {
+		diff += int64(heap.Pop(minQ).(int)) - int64(heap.Pop(maxQ).(int))
+	}
+
+	return diff
+}

PutMarblesInBags/put_marbles_in_bags.md

@@ -244,6 +244,7 @@ This repo contain leetcode solution using DART and GO programming language. Most
 - [**137.** Single Number II](SingleNumberII/single_number_ii.dart)
 - [**1493.** Longest Subarray of 1's After Deleting One Element](LongestSubarrayOf1SAfterDeletingOneElement/longest_subarray_of_1s_after_deleting_one_element.dart)
 - [**2024.** Maximize the Confusion of an Exam](MaximizeTheConfusionOfAnExam/maximize_the_confusion_of_an_exam.dart)
+- [**2551.** Put Marbles in Bags](PutMarblesInBags)
 
 ## Reach me via