Solutions

Author: trinhminhtriet

solutions/2300-2399/2327.number-of-people-aware-of-a-secret/Solution.rs

@@ -0,0 +1,31 @@
+impl Solution {
+    pub fn people_aware_of_secret(n: i32, delay: i32, forget: i32) -> i32 {
+        let n = n as usize;
+        let delay = delay as usize;
+        let forget = forget as usize;
+        let m = (n << 1) + 10;
+        let modulo: i64 = 1_000_000_007;
+
+        let mut d = vec![0i64; m];
+        let mut cnt = vec![0i64; m];
+
+        cnt[1] = 1;
+        for i in 1..=n {
+            if cnt[i] > 0 {
+                d[i] = (d[i] + cnt[i]) % modulo;
+                d[i + forget] = (d[i + forget] - cnt[i] + modulo) % modulo;
+                let mut nxt = i + delay;
+                while nxt < i + forget {
+                    cnt[nxt] = (cnt[nxt] + cnt[i]) % modulo;
+                    nxt += 1;
+                }
+            }
+        }
+
+        let mut ans: i64 = 0;
+        for i in 1..=n {
+            ans = (ans + d[i]) % modulo;
+        }
+        ans as i32
+    }
+}

solutions/3000-3099/3005.count-elements-with-maximum-frequency/Solution.rs

@@ -0,0 +1,19 @@
+impl Solution {
+    pub fn max_frequency_elements(nums: Vec<i32>) -> i32 {
+        let mut cnt = [0; 101];
+        for &x in &nums {
+            cnt[x as usize] += 1;
+        }
+        let mut ans = 0;
+        let mut mx = -1;
+        for &x in &cnt {
+            if mx < x {
+                mx = x;
+                ans = x;
+            } else if mx == x {
+                ans += x;
+            }
+        }
+        ans
+    }
+}

solutions/3600-3699/3672.sum-of-weighted-modes-in-subarrays/Solution.cpp

@@ -0,0 +1,38 @@
+class Solution {
+public:
+    long long modeWeight(vector<int>& nums, int k) {
+        unordered_map<int, int> cnt;
+        priority_queue<pair<int, int>> pq; // {freq, -val}
+
+        for (int i = 0; i < k; i++) {
+            int x = nums[i];
+            cnt[x]++;
+            pq.push({cnt[x], -x});
+        }
+
+        auto get_mode = [&]() {
+            while (true) {
+                auto [freq, negVal] = pq.top();
+                int val = -negVal;
+                if (cnt[val] == freq) {
+                    return 1LL * freq * val;
+                }
+                pq.pop();
+            }
+        };
+
+        long long ans = 0;
+        ans += get_mode();
+
+        for (int i = k; i < nums.size(); i++) {
+            int x = nums[i], y = nums[i - k];
+            cnt[x]++;
+            cnt[y]--;
+            pq.push({cnt[x], -x});
+            pq.push({cnt[y], -y});
+            ans += get_mode();
+        }
+
+        return ans;
+    }
+};

solutions/3600-3699/3672.sum-of-weighted-modes-in-subarrays/Solution.go

@@ -0,0 +1,61 @@
+func modeWeight(nums []int, k int) int64 {
+	cnt := make(map[int]int)
+	pq := &MaxHeap{}
+	heap.Init(pq)
+
+	for i := 0; i < k; i++ {
+		x := nums[i]
+		cnt[x]++
+		heap.Push(pq, pair{cnt[x], x})
+	}
+
+	getMode := func() int64 {
+		for {
+			top := (*pq)[0]
+			if cnt[top.val] == top.freq {
+				return int64(top.freq) * int64(top.val)
+			}
+			heap.Pop(pq)
+		}
+	}
+
+	var ans int64
+	ans += getMode()
+
+	for i := k; i < len(nums); i++ {
+		x, y := nums[i], nums[i-k]
+		cnt[x]++
+		cnt[y]--
+		heap.Push(pq, pair{cnt[x], x})
+		heap.Push(pq, pair{cnt[y], y})
+		ans += getMode()
+	}
+
+	return ans
+}
+
+type pair struct {
+	freq int
+	val  int
+}
+
+type MaxHeap []pair
+
+func (h MaxHeap) Len() int { return len(h) }
+func (h MaxHeap) Less(i, j int) bool {
+	if h[i].freq != h[j].freq {
+		return h[i].freq > h[j].freq
+	}
+	return h[i].val < h[j].val
+}
+func (h MaxHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
+func (h *MaxHeap) Push(x any) {
+	*h = append(*h, x.(pair))
+}
+func (h *MaxHeap) Pop() any {
+	old := *h
+	n := len(old)
+	x := old[n-1]
+	*h = old[:n-1]
+	return x
+}

solutions/3600-3699/3672.sum-of-weighted-modes-in-subarrays/Solution.java

@@ -0,0 +1,40 @@
+class Solution {
+    public long modeWeight(int[] nums, int k) {
+        Map<Integer, Integer> cnt = new HashMap<>();
+        PriorityQueue<int[]> pq = new PriorityQueue<>(
+            (a, b) -> a[0] != b[0] ? Integer.compare(a[0], b[0]) : Integer.compare(a[1], b[1]));
+
+        for (int i = 0; i < k; i++) {
+            int x = nums[i];
+            cnt.merge(x, 1, Integer::sum);
+            pq.offer(new int[] {-cnt.get(x), x});
+        }
+
+        long ans = 0;
+
+        Supplier<Long> getMode = () -> {
+            while (true) {
+                int[] top = pq.peek();
+                int val = top[1];
+                int freq = -top[0];
+                if (cnt.getOrDefault(val, 0) == freq) {
+                    return 1L * freq * val;
+                }
+                pq.poll();
+            }
+        };
+
+        ans += getMode.get();
+
+        for (int i = k; i < nums.length; i++) {
+            int x = nums[i], y = nums[i - k];
+            cnt.merge(x, 1, Integer::sum);
+            pq.offer(new int[] {-cnt.get(x), x});
+            cnt.merge(y, -1, Integer::sum);
+            pq.offer(new int[] {-cnt.get(y), y});
+            ans += getMode.get();
+        }
+
+        return ans;
+    }
+}

solutions/3600-3699/3672.sum-of-weighted-modes-in-subarrays/Solution.py

@@ -0,0 +1,27 @@
+class Solution:
+    def modeWeight(self, nums: List[int], k: int) -> int:
+        pq = []
+        cnt = defaultdict(int)
+        for x in nums[:k]:
+            cnt[x] += 1
+            heappush(pq, (-cnt[x], x))
+
+        def get_mode() -> int:
+            while -pq[0][0] != cnt[pq[0][1]]:
+                heappop(pq)
+            freq, val = -pq[0][0], pq[0][1]
+            return freq * val
+
+        ans = 0
+        ans += get_mode()
+
+        for i in range(k, len(nums)):
+            x, y = nums[i], nums[i - k]
+            cnt[x] += 1
+            cnt[y] -= 1
+            heappush(pq, (-cnt[x], x))
+            heappush(pq, (-cnt[y], y))
+
+            ans += get_mode()
+
+        return ans

solutions/3600-3699/3673.find-zombie-sessions/Solution.py

@@ -0,0 +1,31 @@
+import pandas as pd
+
+
+def find_zombie_sessions(app_events: pd.DataFrame) -> pd.DataFrame:
+    if not pd.api.types.is_datetime64_any_dtype(app_events["event_timestamp"]):
+        app_events["event_timestamp"] = pd.to_datetime(app_events["event_timestamp"])
+
+    grouped = app_events.groupby(["session_id", "user_id"])
+
+    result = grouped.agg(
+        session_duration_minutes=(
+            "event_timestamp",
+            lambda x: (x.max() - x.min()).total_seconds() // 60,
+        ),
+        scroll_count=("event_type", lambda x: (x == "scroll").sum()),
+        click_count=("event_type", lambda x: (x == "click").sum()),
+        purchase_count=("event_type", lambda x: (x == "purchase").sum()),
+    ).reset_index()
+
+    result = result[
+        (result["session_duration_minutes"] >= 30)
+        & (result["click_count"] / result["scroll_count"] < 0.2)
+        & (result["purchase_count"] == 0)
+        & (result["scroll_count"] >= 5)
+    ]
+
+    result = result.sort_values(
+        by=["scroll_count", "session_id"], ascending=[False, True]
+    ).reset_index(drop=True)
+
+    return result[["session_id", "user_id", "session_duration_minutes", "scroll_count"]]

solutions/3600-3699/3673.find-zombie-sessions/Solution.sql

@@ -0,0 +1,14 @@
+# Write your MySQL query statement below
+SELECT
+    session_id,
+    user_id,
+    TIMESTAMPDIFF(MINUTE, MIN(event_timestamp), MAX(event_timestamp)) session_duration_minutes,
+    SUM(event_type = 'scroll') scroll_count
+FROM app_events
+GROUP BY session_id
+HAVING
+    session_duration_minutes >= 30
+    AND SUM(event_type = 'click') / SUM(event_type = 'scroll') < 0.2
+    AND SUM(event_type = 'purchase') = 0
+    AND SUM(event_type = 'scroll') >= 5
+ORDER BY scroll_count DESC, session_id;