first commit

Author: DenzelPenzel

Apartments/main.py

@@ -0,0 +1,53 @@
+"""
+There are n applicants and m free apartments. Your task is to distribute the apartments so that as many applicants as possible will get an apartment.
+
+Each applicant has a desired apartment size, and they will accept any apartment whose size is close enough to the desired size.
+
+Input
+
+The first input line has three integers n, m, and k: the number of applicants, the number of apartments, and the maximum allowed difference.
+
+The next line contains n integers a1,a2,…,an: the desired apartment size of each applicant. If the desired size of an applicant is x, he or she will accept any apartment whose size is between x−k and x+k.
+
+The last line contains m integers b1,b2,…,bm: the size of each apartment.
+
+Output
+
+Print one integer: the number of applicants who will get an apartment.
+
+Constraints
+1≤n,m≤2⋅105
+0≤k≤109
+1≤ai,bi≤109
+Example
+
+Input:
+4 3 5
+60 45 80 60
+30 60 75
+
+Output:
+2
+"""
+
+import collections
+
+if __name__ == '__main__':
+    people_cnt, apt, diff = list(map(int, input().split()))
+    prefer_size = collections.deque(list(sorted(map(int, input().split()))))
+    actual_size = list(sorted(map(int, input().split())))
+
+    res = 0
+
+    for i in range(len(actual_size)):
+        while prefer_size and prefer_size[0] + diff < actual_size[i]:
+            prefer_size.popleft()
+
+        if not prefer_size:
+            break
+
+        if prefer_size[0] - diff <= actual_size[i] <= prefer_size[0] + diff:
+            prefer_size.popleft()
+            res += 1
+
+    print(res)

Array Division/main.py

@@ -0,0 +1,60 @@
+"""
+You are given an array containing n positive integers.
+
+Your task is to divide the array into k subarrays so that the maximum sum in a subarray is as small as possible.
+
+Input
+
+The first input line contains two integers n and k: the size of the array and the number of subarrays in the division.
+
+The next line contains n integers x1,x2,…,xn: the contents of the array.
+
+Output
+
+Print one integer: the maximum sum in a subarray in the optimal division.
+
+Constraints
+1≤n≤2⋅105
+1≤k≤n
+1≤xi≤109
+Example
+
+Input:
+5 3
+2 4 7 3 5
+
+Output:
+8
+
+Explanation: An optimal division is [2,4],[7],[3,5] where the sums of the subarrays are 6,7,8. The largest sum is the last sum 8.
+"""
+
+if __name__ == '__main__':
+    n, k = list(map(int, input().split()))
+    A = list(map(int, input().split()))
+
+    lo, hi = max(A), sum(A) + 1
+
+    while lo < hi:
+        mid = lo + ((hi - lo) >> 1)
+
+        cnt_sub = 1
+        prefix = 0
+
+        for i in range(len(A)):
+            if prefix + A[i] <= mid:
+                prefix += A[i]
+            else:
+                prefix = A[i]
+                cnt_sub += 1
+
+        if cnt_sub <= k:
+            hi = mid
+        else:
+            lo = mid + 1
+
+    print(lo)
+
+
+
+

Collecting Numbers II/main.py

@@ -0,0 +1,37 @@
+"""
+You are given an array that contains each number between 1…n exactly once. Your task is to collect the numbers from 1 to n in increasing order.
+
+On each round, you go through the array from left to right and collect as many numbers as possible.
+
+Given m operations that swap two numbers in the array, your task is to report the number of rounds after each operation.
+
+Input
+
+The first line has two integers n and m: the array size and the number of operations.
+
+The next line has n integers x1,x2,…,xn: the numbers in the array.
+
+Finally, there are m lines that describe the operations. Each line has two integers a and b: the numbers at positions a and b are swapped.
+
+Output
+
+Print m integers: the number of rounds after each swap.
+
+Constraints
+1≤n,m≤2⋅105
+1≤a,b≤n
+Example
+
+Input:
+5 3
+4 2 1 5 3
+2 3
+1 5
+2 3
+
+Output:
+2
+3
+4
+"""
+

Collecting Numbers/main.py

@@ -0,0 +1,43 @@
+"""
+Time limit: 1.00 s Memory limit: 512 MB
+You are given an array that contains each number between 1…n exactly once. Your task is to collect the numbers from 1 to n in increasing order.
+
+On each round, you go through the array from left to right and collect as many numbers as possible. What will be the total number of rounds?
+
+Input
+
+The first line has an integer n: the array size.
+
+The next line has n integers x1,x2,…,xn: the numbers in the array.
+
+Output
+
+Print one integer: the number of rounds.
+
+Constraints
+1≤n≤2⋅105
+Example
+
+Input:
+5
+4 2 1 5 3
+
+Output:
+3
+"""
+
+import bisect
+from typing import List
+
+if __name__ == '__main__':
+    n = int(input())
+    A = list(map(int, input().split()))
+    seen = set()
+    res = 1
+
+    for x in A:
+        if x + 1 in seen:
+            res += 1
+        seen.add(x)
+
+    print(res)

Concert Tickets/consert_tickets.cpp

@@ -0,0 +1,24 @@
+#include <iostream>
+#include <set>
+#include <vector>
+ 
+using namespace std;
+ 
+int main() {
+  int n, m, x;
+  cin >> n >> m;
+  multiset<int, greater<int>> h;
+  while (n--) {
+    cin >> x;
+    h.insert(x);
+  }
+  while (m--) {
+    cin >> x;
+    auto it = h.lower_bound(x);
+    if (it == h.end()) cout << "-1\n";
+    else {
+      cout << *it << endl;
+      h.erase(it);
+    }
+  }
+}

Concert Tickets/main.py

@@ -0,0 +1,21 @@
+import bisect
+
+if __name__ == '__main__':
+    n, m = list(map(int, input().split()))
+    ticket_prices = list(sorted(map(int, input().split())))
+    user_price = list(map(int, input().split()))
+
+    for x in user_price:    
+        if not ticket_prices:
+            print(-1)
+        else:
+            idx = bisect.bisect_left(ticket_prices, x)
+            if (idx == 0 and ticket_prices[idx] > x):
+                print(-1)
+            else:
+                if idx < len(ticket_prices) and ticket_prices[idx] == x:
+                    print(ticket_prices[idx])
+                    del ticket_prices[idx]
+                else:
+                    print(ticket_prices[idx - 1])
+                    del ticket_prices[idx - 1]

Distinct Numbers/main.py

@@ -0,0 +1,37 @@
+"""
+You are given a list of n integers, and your task is to calculate the number of distinct values in the list.
+
+Input
+
+The first input line has an integer n: the number of values.
+
+The second line has n integers x1,x2,…,xn.
+
+Output
+
+Print one integers: the number of distinct values.
+
+Constraints
+1≤n≤2⋅105
+1≤xi≤109
+Example
+
+Input:
+5
+2 3 2 2 3
+
+Output:
+2
+"""
+
+from typing import List
+
+
+def test(n: int, A: List[int]):
+    return len(set(A))
+
+
+if __name__ == '__main__':
+    x = input().split()
+    y = list(map(int, input().split()))
+    print(test(int(x[0]), y))

Factory Machines/main.py

@@ -0,0 +1,30 @@
+from utils.read_write_io import IOWrapper
+import sys
+
+if __name__ == '__main__':
+    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
+
+    input = lambda: list(map(int, sys.stdin.readline().rstrip("\n").split(" ")))
+
+    n, t = input()
+    A = input()
+
+    lo, hi = 1, int(1e18)
+    res = float('inf')
+
+    while lo < hi:
+        mid = lo + ((hi - lo) >> 1)
+        
+        cur_time = 0
+
+        for x in A:
+            cur_time += mid // x
+            if cur_time >= t:
+                break
+
+        if cur_time < t:
+            lo = mid + 1
+        else:
+            hi = mid
+
+    print(lo)

Ferris Wheel/main.py

@@ -0,0 +1,54 @@
+"""
+There are n children who want to go to a Ferris wheel, and your task is to find a gondola for each child.
+
+Each gondola may have one or two children in it, and in addition, the total weight in a gondola may not exceed x. 
+
+You know the weight of every child.
+
+What is the minimum number of gondolas needed for the children?
+
+Input
+
+The first input line contains two integers n and x: the number of children and the maximum allowed weight.
+
+The next line contains n integers p1,p2,…,pn: the weight of each child.
+
+Output
+
+Print one integer: the minimum number of gondolas.
+
+Constraints
+1≤n≤2⋅105
+1≤x≤109
+1≤pi≤x
+Example
+
+Input:
+4 10
+7 2 3 9
+
+Output:
+3
+"""
+
+
+if __name__ == '__main__':
+    n, max_weight = list(map(int, input().split()))
+    A = list(map(int, input().split()))
+
+    A.sort()
+    i, j = 0, len(A) - 1
+    res = 0
+    pairs = [False] * n
+
+    while i < j:
+        if i != j and A[i] + A[j] <= max_weight:
+            pairs[i] = pairs[j] = True
+            res += 1
+            i, j = i + 1, j - 1
+        else:
+            j -= 1
+
+    print(res + sum([1 for x in pairs if not x]))
+    
+