🚀 07-May-2021

Author: sureshmangs

Diff for: competitive programming/codeforces/1371A - Magical Sticks.cpp

@@ -0,0 +1,55 @@
+/*
+A penguin Rocher has n sticks. He has exactly one stick with length i for all 1=i=n.
+
+He can connect some sticks. If he connects two sticks that have lengths a and b, he gets one stick with length a+b. Two sticks, that were used in the operation disappear from his set and the new connected stick appears in his set and can be used for the next connections.
+
+He wants to create the maximum number of sticks that have the same length. It is not necessary to make all sticks have the same length, some sticks can have the other length. How many sticks with the equal length he can create?
+
+Input
+The input consists of multiple test cases. The first line contains a single integer t (1=t=1000) — the number of test cases. Next t lines contain descriptions of test cases.
+
+For each test case, the only line contains a single integer n (1=n=109).
+
+Output
+For each test case, print a single integer  — the answer to the problem.
+
+Example
+inputCopy
+4
+1
+2
+3
+4
+outputCopy
+1
+1
+2
+2
+Note
+In the third case, he can connect two sticks with lengths 1 and 2 and he will get one stick with length 3. So, he will have two sticks with lengths 3.
+
+In the fourth case, he can connect two sticks with lengths 1 and 3 and he will get one stick with length 4. After that, he will have three sticks with lengths {2,4,4}, so two sticks have the same length, and one stick has the other length.
+*/
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    
+    int t;
+    cin >> t;
+    
+    while (t--) {
+	    int n;
+	    cin >> n;
+	    
+	   	if (n % 2) cout << (long long)ceil(n / 2.0) << endl;
+	   	else cout << (long long)n / 2 << endl;
+	}
+  	
+    return 0;
+}
+

Diff for: competitive programming/codeforces/1385B - Restore the Permutation by Merger.cpp

@@ -0,0 +1,76 @@
+/*
+A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4,3,5,1,2], [3,2,1] are permutations, and [1,1], [0,1], [2,2,1,4] are not.
+
+There was a permutation p[1…n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.
+
+For example, if p=[3,1,2] some possible results are: [3,1,2,3,1,2], [3,3,1,1,2,2], [3,1,3,1,2,2]. The following sequences are not possible results of a merging: [1,3,2,1,2,3], [3,1,2,3,2,1], [3,3,1,2,2,1].
+
+For example, if p=[2,1] the possible results are: [2,2,1,1], [2,1,2,1]. The following sequences are not possible results of a merging: [1,1,2,2], [2,1,1,2], [1,2,2,1].
+
+Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.
+
+You have to answer t independent test cases.
+
+Input
+The first line of the input contains one integer t (1=t=400) — the number of test cases. Then t test cases follow.
+
+The first line of the test case contains one integer n (1=n=50) — the length of permutation. The second line of the test case contains 2n integers a1,a2,…,a2n (1=ai=n), where ai is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.
+
+Output
+For each test case, print the answer: n integers p1,p2,…,pn (1=pi=n), representing the initial permutation. It is guaranteed that the answer exists and is unique.
+
+Example
+inputCopy
+5
+2
+1 1 2 2
+4
+1 3 1 4 3 4 2 2
+5
+1 2 1 2 3 4 3 5 4 5
+3
+1 2 3 1 2 3
+4
+2 3 2 4 1 3 4 1
+outputCopy
+1 2 
+1 3 4 2 
+1 2 3 4 5 
+1 2 3 
+2 3 4 1 
+*/
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    
+    int t;
+    cin >> t;
+    
+    while (t--) {
+	    int n;
+	    cin >> n;
+	    
+	   unordered_set <int> s;
+	   
+	   for (int i = 0; i < 2 * n; i++) {
+	   		int a;
+	   		cin >> a;
+	   		
+	   		if (s.find(a) == s.end()) {
+	   			s.insert(a);
+	   		    cout << a << " ";
+			   }
+	   }
+	   
+	   cout << endl;
+	}
+  	
+    return 0;
+}
+

Diff for: competitive programming/codeforces/1515A - Phoenix and Gold.cpp

@@ -0,0 +1,97 @@
+/*
+Phoenix has collected n pieces of gold, and he wants to weigh them together so he can feel rich. The i-th piece of gold has weight wi. All weights are distinct. He will put his n pieces of gold on a weight scale, one piece at a time.
+
+The scale has an unusual defect: if the total weight on it is exactly x, it will explode. Can he put all n gold pieces onto the scale in some order, without the scale exploding during the process? If so, help him find some possible order.
+
+Formally, rearrange the array w so that for each i (1=i=n), ?j=1iwj?x.
+
+Input
+The input consists of multiple test cases. The first line contains an integer t (1=t=1000) — the number of test cases.
+
+The first line of each test case contains two integers n and x (1=n=100; 1=x=104) — the number of gold pieces that Phoenix has and the weight to avoid, respectively.
+
+The second line of each test case contains n space-separated integers (1=wi=100) — the weights of the gold pieces. It is guaranteed that the weights are pairwise distinct.
+
+Output
+For each test case, if Phoenix cannot place all n pieces without the scale exploding, print NO. Otherwise, print YES followed by the rearranged array w. If there are multiple solutions, print any.
+
+Example
+inputCopy
+3
+3 2
+3 2 1
+5 3
+1 2 3 4 8
+1 5
+5
+outputCopy
+YES
+3 2 1
+YES
+8 1 2 3 4
+NO
+Note
+In the first test case, Phoenix puts the gold piece with weight 3 on the scale first, then the piece with weight 2, and finally the piece with weight 1. The total weight on the scale is 3, then 5, then 6. The scale does not explode because the total weight on the scale is never 2.
+
+In the second test case, the total weight on the scale is 8, 9, 11, 14, then 18. It is never 3.
+
+In the third test case, Phoenix must put the gold piece with weight 5 on the scale, and the scale will always explode
+*/
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+ 
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    
+    int t;
+    cin >> t;
+    
+    while (t--) {
+    	int n, x;
+    	cin >> n >> x;
+    	
+    	queue <int> q;
+    	
+    	int sum = 0;
+    	
+    	for (int i = 0; i < n; i++) {
+    		int ch;
+    		cin >> ch;
+    		q.push(ch);
+    		sum += ch;
+		}
+		
+		if (sum == x) {
+			cout << "NO" << endl;
+		} else {
+			sum = x;	
+			cout << "YES" << endl;
+			int first = q.front();
+			q.pop();
+			
+			if (first == x) {
+				q.push(first);
+			} else {
+				sum -= first;
+				cout << first << " ";;
+			}
+			
+			while (!q.empty()) {
+				int tmp = q.front();
+				q.pop();
+				if (tmp == sum) q.push(tmp);
+				else {
+					cout << tmp << " ";
+					sum -= tmp;
+				}
+			}
+			cout << endl;
+		}
+	}
+  	
+    return 0;
+}

Diff for: competitive programming/codeforces/1515B - Phoenix and Puzzle.cpp

@@ -0,0 +1,51 @@
+/*
+Phoenix is playing with a new puzzle, which consists of n identical puzzle pieces. Each puzzle piece is a right isosceles triangle as shown below.
+
+A puzzle piece
+The goal of the puzzle is to create a square using the n pieces. He is allowed to rotate and move the pieces around, but none of them can overlap and all n pieces must be used (of course, the square shouldn't contain any holes as well). Can he do it?
+
+Input
+The input consists of multiple test cases. The first line contains an integer t (1=t=104) — the number of test cases.
+
+The first line of each test case contains an integer n (1=n=109) — the number of puzzle pieces.
+
+Output
+For each test case, if Phoenix can create a square with the n puzzle pieces, print YES. Otherwise, print NO.
+
+Example
+inputCopy
+3
+2
+4
+6
+outputCopy
+YES
+YES
+NO
+*/
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+ 
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    
+    int t;
+    cin >> t;
+    
+    while (t--) {
+    	int n;
+    	cin >> n;
+    	
+    	int a = sqrt(n / 2);
+    	int b = sqrt(n / 4);
+    	
+    	a * a * 2 == n || b * b * 4 == n ? cout << "YES\n" : cout << "NO\n";
+    	
+	}
+  	
+    return 0;
+}

Diff for: competitive programming/codeforces/1519A - Red and Blue Beans.cpp

@@ -0,0 +1,72 @@
+/*
+You have r red and b blue beans. You'd like to distribute them among several (maybe, one) packets in such a way that each packet:
+
+has at least one red bean (or the number of red beans ri=1);
+has at least one blue bean (or the number of blue beans bi=1);
+the number of red and blue beans should differ in no more than d (or |ri-bi|=d)
+Can you distribute all beans?
+
+Input
+The first line contains the single integer t (1=t=1000) — the number of test cases.
+
+The first and only line of each test case contains three integers r, b, and d (1=r,b=109; 0=d=109) — the number of red and blue beans and the maximum absolute difference in each packet.
+
+Output
+For each test case, if you can distribute all beans, print YES. Otherwise, print NO.
+
+You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answer).
+
+Example
+inputCopy
+4
+1 1 0
+2 7 3
+6 1 4
+5 4 0
+outputCopy
+YES
+YES
+NO
+NO
+Note
+In the first test case, you can form one packet with 1 red and 1 blue bean. The absolute difference |1-1|=0=d.
+
+In the second test case, you can form two packets: 1 red and 4 blue beans in the first packet and 1 red and 3 blue beans in the second one.
+
+In the third test case, since b=1, you can form only one packet with 6 red and 1 blue beans. The absolute difference |6-1|=5>d.
+
+In the fourth test case, since d=0 so each packet should contain the same number of red and blue beans, but r?b.
+*/
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+ 
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    
+    int t;
+    cin >> t;
+    
+    while (t--) {
+    	int r, b, d;
+    	cin >> r >> b >> d;
+    	
+    	if (r == b) cout << "YES\n";
+    	else if (r > b) {
+    		int tmp = ceil(float(r) / b); 
+    		tmp -= 1;
+    		if (tmp <= d) cout << "YES\n";
+    		else cout << "NO\n";
+		} else {
+			int tmp = ceil(float(b) / r);
+    		tmp -= 1;
+    		if (tmp <= d) cout << "YES\n";
+    		else cout << "NO\n";
+		}
+	}
+  	
+    return 0;
+}