├── .gitignore
├── smallestRestrictedPalindrome.cpp
├── countDerangementInversions.cpp
├── minCostAddSubDouble.cpp
├── minBin.cpp
├── prisonBreak.cpp
├── README.md
├── minRectArea.cpp
├── special binary string.cpp
├── huffmanDecode.cpp
├── energyDifference.cpp
├── consecutivePrimes.cpp
├── minCostOddPrimeSum.cpp
├── travelingIsFun.cpp
├── nutanixSportsMeet.cpp
├── circularSubstring.cpp
├── .github
    ├── CONTRIBUTING.md
    ├── CODE_OF_CONDUCT.md
    └── LICENSE
├── superStack.cpp
├── Find Number of pairs.cpp
├── Palindrome And Substring.cpp
├── turnstile.cpp
├── findTheShape.cpp
├── killingZombies.cpp
├── scientificFarmer.cpp
└── maxCoins.cpp


/.gitignore:
--------------------------------------------------------------------------------
1 | 
2 | *.o
3 | *.out


--------------------------------------------------------------------------------
/smallestRestrictedPalindrome.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | IITR Flipkart 2018
 3 | 
 4 | Given a string s, return a string t satisfying the following:
 5 | 1. s contains t
 6 | 2. t is a palindrome
 7 | 3. t is largest possible
 8 | If multiple t exists, return the lexicographically smallest t.
 9 | 
10 | 1 <= |s| <= 100000
11 | 
12 | O(|s| + 26)
13 | */
14 | string smallestRestrictedPalindrome(string s) {
15 | 	int c[26] = {};
16 | 	for (char ch : s) c[ch - 'a']++;
17 | 	string t = "";
18 | 	for (int i = 0; i < 26; i++) {
19 | 		for (int j = c[i] >> 1; j--; ) {
20 | 			t += (char)('a' + i);
21 | 		}
22 | 	}
23 | 	int fl = 0;
24 | 	for (int i = 0; not fl and i < 26; i++) {
25 | 		if (c[i] & 1) {
26 | 			t += (char)('a' + i);
27 | 			fl = 1;
28 | 		}
29 | 	}
30 | 	int n = t.size() - fl;
31 | 	for (int i = n; i--; ) {
32 | 		t += t[i];
33 | 	}
34 | 	return t;
35 | }
36 | 


--------------------------------------------------------------------------------
/countDerangementInversions.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | ThoughtSpot IITK 2018
 3 | 
 4 | Given n, find the sum of number of inversions over all derangements of length n.
 5 | As the number can be very large, print it modulo 1000000007.
 6 | 
 7 | Inversion in array A is a pair (i,j) where i < j and A[i] > A[j].
 8 | Derangement of length n is a permutation of 1..n such that A[i] != i for any i.
 9 | 
10 | 1 <= n <= 20
11 | 
12 | Formula taken from here - https://oeis.org/A216239
13 | O(n)
14 | */
15 | int countDerangementInversions(int n) {
16 | 	const int MOD = 1E9 + 7;
17 | 	const int inv12 = (MOD + 1) / 12;
18 | 
19 | 	long long ans = 0;
20 | 	for (long long k = n - 1, v = n * (n - 1); k--; ) {
21 | 		long long x = v * (3 * n + k) * (n - k - 1) % MOD;
22 | 		if (k & 1) x = MOD - x;
23 | 		ans = (ans + x) % MOD;
24 | 		v = v * k % MOD;
25 | 	}
26 | 	return ans * inv12 % MOD;
27 | }


--------------------------------------------------------------------------------
/minCostAddSubDouble.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Walmart Labs IIT Dhanbad 2018
 3 | 
 4 | For a given number N, following operations are allowed:
 5 | 1. N -> N + 1
 6 | 2. N -> N - 1 (provided N > 0)
 7 | 3. N -> 2 * N
 8 | Cost of operation 1 and 2 is equal to A and cost of operation 3 is B.
 9 | Find the minimum cost to reach X starting from 0.
10 | 
11 | 1 <= X <= 100000
12 | 0 <= A, B <= 1000000
13 | O(X)
14 | */
15 | inline void Min(int &a, int b) {
16 |     if (a > b) a = b;
17 | }
18 | int find_min_cost(int A, int B, int X) {
19 |     vector<int> ans(4 * X, -1);
20 |     ans[0] = 0;
21 |     for (int i = 1; i <= X; i++) {
22 |         ans[i] = ans[i - 1] + A;
23 |         
24 |         if (i & 1) Min(ans[i], ans[i >> 1] + B + A);
25 |         else Min(ans[i], ans[i >> 1] + B);
26 |         
27 |         if (ans[i + 1] != -1) Min(ans[i], ans[i + 1] + A);
28 |         ans[i << 1 | 1] = ans[i] + B + A;
29 |         ans[i << 1] = ans[i] + B;
30 |     }
31 |     return ans[X];
32 | }
33 | 


--------------------------------------------------------------------------------
/minBin.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Goldman Sachs IITD 2018
 3 | 
 4 | We are given an array of size N, we can delete a subset b1b2b3...bk from the 
 5 | array if 2^b1 + 2^b2 + …..2^bk = 2^x for non-negative integer x where ^ is the
 6 | power operator. Find the minimum number of steps required to delete the 
 7 | complete array.
 8 | 
 9 | 0 <= ai <= 1000000
10 | 1 <= N <= 1000000
11 | 
12 | Approach: The problem boils down to finding the number of set-bits in 
13 | the summation 2^a0 + 2^a1 + 2^a2 + ... which can be done by counting the number
14 | of ai's for each ai and then using the same logic as you do for adding up two 
15 | decimal numbers but instead of base-10, use base-2
16 | 
17 | O(N + L + log L) where L is the upper bound on value of ai
18 | */
19 | int minBin(vector<int> a) {
20 | 	const int L = 1E6; // max possible value of ai
21 | 	vector<int> cnt(L + 30);
22 | 	for (int ai : a) cnt[ai]++;
23 | 
24 | 	int ans = (cnt[0] & 1);
25 | 	for (int i = 1; i < L + 30; i++) {
26 | 		cnt[i] += cnt[i - 1] >> 1;
27 | 		if (cnt[i] & 1) ans++;
28 | 	}
29 | 	return ans;
30 | }


--------------------------------------------------------------------------------
/prisonBreak.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | IITR Razorpay 2018
 3 | 
 4 | Consider a prison gate having N horizontal rods and M vertical rods.
 5 | You are also provided with two vectors hor and ver containing the 
 6 | row number of missing horizontal rods and vertical rods respectively.
 7 | Return the area of biggest hole in the prison gate.
 8 | 
 9 | 1 <= N, M <= 1000000
10 | 1 <= hor[i] <= N
11 | 1 <= ver[i] <= M
12 | All the elements of a vector are distinct
13 | 
14 | O(N + M)
15 | 
16 | SKIPPING... O(AlogA + BlogB) where A = hor.size() and B = ver.size()
17 | */
18 | #include<bits/stdc++.h>
19 | using namespace std;
20 | 
21 | long int prison(int n, int m, vector<int> hor, vector<int> ver) {
22 | 	vector<bool> xs(n + 1), ys(m + 1);
23 | 	for (int h : hor) xs[h] = true;
24 | 	for (int v : ver) ys[v] = true;
25 | 	int xm = 0, ym = 0;
26 | 	for (int i = 1, j = 0; i <= n; i++) {
27 | 		if (not xs[i]) j = 0;
28 | 		else xm = max(xm, ++j);
29 | 	}
30 | 	for (int i = 1, j = 0; i <= m; i++) {
31 | 		if (not ys[i]) j = 0;
32 | 		else ym = max(ym, ++j);
33 | 	}
34 | 	return (long int)(xm + 1) * (ym + 1);
35 | }
36 | 
37 | int main() {
38 | 	cout << prison(10, 10, {}, {});
39 | 	return 0;
40 | }
41 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Introduction
 2 | 
 3 | This repo contains coding problems previously appeared in online campus placement tests across IITs, NITs, and other top engineering colleges in India.
 4 | 
 5 | # Template
 6 | 
 7 | Each file is structured as follows:
 8 | - There is a commented block at the top which has following informations in order
 9 |   - First line is Company name, college name, and year of appearance of the problem
10 |   - Next block of lines clearly explains the Problem Statement
11 |   - Next block of lines contains relevant constraints on input variables as appeared in the PS
12 |   - Next block of lines (optional) explains the approach used to solve the problem
13 |   - Last line (optional) mentions the runtime and/or space complexity of the approach used
14 | - Then follows a working solution to the mentioned problem in any language, mostly `C++`. Other preferred languages are `Java` and `Python`.
15 | - Whenever applicable, external links are provided in the commented block relevant to the problem or solution approach.
16 | 
17 | # Contributing
18 | 
19 | Please read the [Contribution](.github/CONTRIBUTING.md) page and add any relevant problems as a contributor.


--------------------------------------------------------------------------------
/minRectArea.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Flipkart IIT Kanpur 2018
 3 | 
 4 | Given two vectors of length n representing the x and y 
 5 | coordinates of cartesian points, find the minimum possible area 
 6 | of a rectangle which can be formed using four distinct points which has sides parallel to the x & y axis.
 7 | If non rectangle can be formed, return -1.
 8 | 
 9 | 1 <= n <= 1000
10 | */
11 | #include <bits/stdc++.h>
12 | using namespace std;
13 | #define int long long
14 | 
15 | const int INF = 1E15;
16 | int getMinArea(vector<int> x, vector<int> y) {
17 |     map<pair<int,int>, set<int>> m;
18 |     int n = x.size();
19 |     for (int i = 0; i < n; i++) {
20 |         for (int j = 0; j < i; j++) {
21 |             if (x[i] == x[j]) {
22 |                 m[{min(y[i], y[j]), max(y[i], y[j])}].insert(x[i]);
23 |             }
24 |         }
25 |     }
26 |     
27 |     int ans = INF;
28 |     for (auto &p : m) {
29 |         int a = p.first.second - p.first.first;
30 |         vector<int> xs(p.second.begin(), p.second.end());
31 |         int sz = xs.size();
32 |         for (int i = 1; i < sz; i++) {
33 |             ans = min(ans, a * (xs[i] - xs[i - 1]));
34 |         }
35 |     }
36 |     return (ans < INF ? ans : -1);
37 | }
38 | 
39 | signed main() {
40 |     cout << getMinArea(
41 |         {1,1,2,2,3,3,4,4},
42 |         {1,3,1,8,1,8,1,3}
43 |     ) << '\n';
44 |     return 0;
45 | }
46 | 


--------------------------------------------------------------------------------
/special binary string.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | 
 3 | CITRIX IIT Guwahti 2019
 4 | 
 5 | Special binary strings are binary strings with the following two properties:
 6 | 
 7 | The number of 0's is equal to the number of 1's.
 8 | Every prefix of the binary string has at least as many 1's as 0's.
 9 | Given a special string S, a move consists of choosing two consecutive, non-empty, 
10 | special substrings of S, and swapping them. (Two strings are consecutive if the last
11 | character of the first string is exactly one index before the first character of the second string.)
12 | 
13 | At the end of any number of moves, what is the lexicographically largest resulting string possible?
14 | 
15 | */
16 | 
17 |     string makeLargestSpecial(string S) {
18 |         int i=0, count=0;
19 |         vector<string> res;
20 |         for(int j=0;j<S.length();j++){
21 |             if(S[j]=='1')
22 |                 count++;
23 |             else
24 |                 count--;
25 |             if(count==0){
26 |                 res.push_back('1' + makeLargestSpecial(S.substr(i+1,j-i-1)) +'0');
27 |                 i = j+1;
28 |             }
29 |             
30 |         }
31 |         sort(res.begin(),res.end(),greater<string>());
32 |         
33 |         string r = "";
34 |         for(auto s:res){
35 |             r+=s;
36 |         }
37 |         return r;
38 |     }
39 | 


--------------------------------------------------------------------------------
/huffmanDecode.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | BNY Mellon IITK 2018
 3 | 
 4 | Given an encoded string and the Huffman codes for each character, print the
 5 | decoded string. Huffman codes are provided as an array of strings where the key-
 6 | value pair are separated by a tab and appear as an array element. It is ensured
 7 | that the key will be a character and value will be a binary string.
 8 | 
 9 | average O(n) space and time
10 | Replacing unordered_map with map gives O(n log n) time and O(n) space
11 | */
12 | #include <vector>
13 | #include <cassert>
14 | #include <iostream>
15 | #include <unordered_map>
16 | using namespace std;
17 | 
18 | string huffmanDecode(vector<string> codes, string encoded) {
19 |     int n = codes.size();
20 |     unordered_map<string,char> ids;
21 |     for (int i = 0; i < n; i++) {
22 |         char key = codes[i][0];
23 |         string val = codes[i].substr(2);
24 |         ids[val] = key;
25 |     }
26 |     string decoded = "", cur = "";
27 |     for (char c : encoded) {
28 |         cur += c;
29 |         if (ids.find(cur) != ids.end()) {
30 |             decoded += ids[cur];
31 |             cur = "";
32 |         }
33 |     }
34 |     if (cur != "") {
35 |         decoded += ids[cur];
36 |     }
37 |     return decoded;
38 | }
39 | 
40 | int main() {
41 |     // Driver Program to test above function
42 |     assert(huffmanDecode(
43 |         {"a\t01", "b\t110", "c\t101", "d\t0010", "\n\t1111"},
44 |         "1100010110111101") == "bdb\na");
45 |     return 0;
46 | }


--------------------------------------------------------------------------------
/energyDifference.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Samsung Delhi IITD 2018
 3 | 
 4 | Initially you have H amount of energy and D distance to travel. You may travel
 5 | with any of the given 5 speeds. But you may only travel in units of 1 km. For 
 6 | each km distance traveled, you will spend corresponding amount of energy.
 7 | e.g. the given speeds are:
 8 | 
 9 | Cost of traveling 1 km: [4, 5, 2, 3, 6]
10 | Time taken to travel 1 km: [200, 210, 230, 235, 215]
11 | 
12 | Find minimum time required to cover total D km with remaining H >= 0
13 | 
14 | 1 <= H <= 4000
15 | 1 <= D <= 1000
16 | */
17 | 
18 | #include <bits/stdc++.h>
19 | using namespace std;
20 | const int INF = 2E9;
21 | 
22 | int dp[4040][1010][5];
23 | inline int fun(int i, int j, int k, vector<int> &a, vector<int> &b) {
24 |     if (i < 0) return INF;
25 |     if (j == 0) return 0;
26 |     if (k < 0) return INF;
27 |     if (dp[i][j][k] != -1) return dp[i][j][k];
28 |     return dp[i][j][k] = min(fun(i, j, k - 1, a, b), b[k] + fun(i - a[k], j - 1, k, a, b));
29 | }
30 | 
31 | int getMinTime(vector<int> &cost, vector<int> &time, int H, int D) {
32 |     memset(dp, -1, sizeof dp);
33 |     return fun(H, D, 4, cost, time);
34 | }
35 | 
36 | int main() {
37 |     int t (14);
38 |     vector<int> cost {4, 5, 2, 3, 6};
39 |     vector<int> time {200, 210, 230, 235, 215};
40 |     cout << getMinTime(cost, time, t, 4);
41 |     return 0;
42 | }
43 | 
44 | /* Verify for the following t values..
45 |  * 
46 |  * t = 16, 17, … -> 800
47 |  * t = 14, 15 -> 830
48 |  * t = 13 -> 860
49 |  */


--------------------------------------------------------------------------------
/consecutivePrimes.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | IITR Flipkart 2018
 3 | 
 4 | Given an array A of N integers, return the length of maximum
 5 | subarray where all the elements are prime. It is known that
 6 | the difference between the smallest and largest element of 
 7 | the array is less than or equal to 10^6.
 8 | 
 9 | 1 <= N <= 10^5
10 | 1 <= A_i <= 10^9
11 | max{mod(A_i - A_j)} <= 10^6 for all 1 <= i, j <= N
12 | 
13 | O(K * log K + N) where K is the difference between minimum
14 | and maximum element
15 | */
16 | 
17 | #include <bits/stdc++.h>
18 | using namespace std;
19 | 
20 | const int size = 1E9;
21 | int consecutiveprimes(vector<int> a) {
22 | 	int n = a.size();
23 | 	int mi = a[0], ma = a[0];
24 | 	for (int &ai : a) {
25 | 		if (mi > ai) mi = ai;
26 | 		if (ma < ai) ma = ai;
27 | 	}
28 | 	vector<int> notp(ma - mi + 1);
29 | 	for (int p = 2; p * p <= ma; p++) {
30 | 		int i = max(2, mi / p) * p;
31 | 		while (i < mi) i += p;
32 | 		while (i <= ma) {
33 | 			notp[i - mi] = 1;
34 | 			i += p;
35 | 		}
36 | 	}
37 | 	int cnt = 0, i = 0;
38 | 	for (int &ai : a) {
39 | 		assert(ai >= mi);
40 | 		assert(notp[ai - mi] xor (10001 <= i and i <= 40000));
41 | 		ai = (ai > 1 and not notp[ai - mi]);
42 | 		if (ai) cnt++;
43 | 		i++;
44 | 	}
45 | 	int consec = 0, cur = 0;
46 | 	for (int &ai : a) {
47 | 		if (not ai) cur = 0;
48 | 		else consec = max(consec, ++cur);
49 | 	}
50 | 	return consec;
51 | }
52 | 
53 | 
54 | int main() {
55 | 	int n; cin >> n;
56 | 	vector<int> a(n);
57 | 	for (int i = 0; i < n; i++) {
58 | 		cin >> a[i];
59 | 	}
60 | 	cout << consecutiveprimes(a) << '\n';
61 | 	return 0;
62 | }
63 | 


--------------------------------------------------------------------------------
/minCostOddPrimeSum.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Walmart Labs IITG 2018
 3 | 
 4 | Following operations are defined:
 5 | 1. X -> X + 1
 6 | 2. X -> X - 1
 7 | Cost of operation 1 and 2 are cost_inc and cost_dec respectively. Given a number
 8 | N, find the minimum cost to reach a number M such that M can be represented as a
 9 | sum of two different single-digit odd prime numbers with positive powers.
10 | 
11 | O(k*logn) where k is very small. For n <= 1E8, there are less than 500 possible M
12 | */
13 | #include <set>
14 | int minCostOddPrimeSum(int n, int cost_dec, int cost_inc) {
15 |     const int N = 1E6; // N represents the upper bound on input n. Adjust.
16 |     const int LIM = 2 * N + 10;
17 | 
18 |     std::set<int> st;
19 |     for (int p : {3, 5, 7}) {
20 |         for (int q : {3, 5, 7}) {
21 |             if (p <= q) continue;
22 |             // p^i + q^j
23 |             int pi = p;
24 |             while (pi <= LIM) {
25 |                 int qj = q;
26 |                 while (pi + qj <= LIM) {
27 |                     st.insert(pi + qj);
28 |                     qj *= q;
29 |                 }
30 |                 pi *= p;
31 |             }
32 |         }
33 |     }
34 | 
35 |     int lo = 0, hi;
36 |     for (int x : st) {
37 |         if (x == n) {
38 |             return 0;
39 |         }
40 |         
41 |         if (x < n) {
42 |             lo = x;
43 |         }
44 |         else {
45 |             hi = x;
46 |             break;
47 |         }
48 |     }
49 |     
50 |     int ans = (hi - n) * cost_inc;
51 |     int ans1 = (n - lo) * cost_dec;
52 |     if (lo and ans > ans1) ans = ans1;
53 |     return ans;
54 | }


--------------------------------------------------------------------------------
/travelingIsFun.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Flipkart IIT Kanpur 2018
 3 | 
 4 | https://www.hackerrank.com/contests/hack-it-to-win-it-paypal/challenges/q4-traveling-is-fun
 5 | */
 6 | 
 7 | #include <bits/stdc++.h>
 8 | using namespace std;
 9 | #define int long long
10 | 
11 | struct dsu {
12 |     vector<int> par, sz;
13 |     dsu(int n): par(n), sz(n, 1) {
14 |         for (int i = 0; i < n; i++) {
15 |             par[i] = i;
16 |         }
17 |     }
18 |     int root(int a) {
19 |         if (a == par[a]) return a;
20 |         return par[a] = root(par[a]);
21 |     }
22 |     void merge(int a, int b) {
23 |         a = root(a);
24 |         b = root(b);
25 |         if (a == b) return;
26 |         if (sz[a] < sz[b]) swap(a, b);
27 |         sz[a] += sz[b];
28 |         par[b] = a;
29 |     }
30 | };
31 | 
32 | vector<int> findReachable(int n, int g, vector<int> from, vector<int> to) {
33 |     dsu d(n);
34 |     for (int k = g + 1; k <= n; k++) {
35 |         for (int x = 2 * k; x <= n; x += k) {
36 |             d.merge(x - 1, x - k - 1);
37 |         }
38 |     }
39 | 
40 |     int m = from.size();
41 |     vector<int> ans;
42 |     for (int i = 0; i < m; i++) {
43 |         ans.push_back(d.root(from[i] - 1) == d.root(to[i] - 1));
44 |     }
45 |     return ans;
46 | }
47 | 
48 | signed main() {
49 |     vector<int> from {10, 4, 3, 6};
50 |     vector<int> to {3, 6, 2, 9};
51 |     vector<int> reachable = findReachable(10, 1, from, to);
52 |     for (int i = 0; i < 4; i++) {
53 |         cout << "From " << from[i] << " to " << to[i] << ": ";
54 |         cout << (reachable[i] ? "Possible" : "Not possible") << '\n';
55 |     }
56 |     return 0;
57 | }


--------------------------------------------------------------------------------
/nutanixSportsMeet.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Nutanix IISc 2018
 3 | 
 4 | Given destination x = M, initial positions of participants x[1], x[2], .. x[N],
 5 | and constant speeds of participants y[1], y[2], .. y[N], the race goes on in a
 6 | single line formation such that noone can overtake someone else. Hence, if a 
 7 | person with higher speed meets another person with a lower speed during the race
 8 | then he starts moving at the lower speed for rest of the race.
 9 | 
10 | Find the number of groups that will reach the destination. If two people meet
11 | at the destination, they are also assumed to form a group.
12 | 
13 | 1 <= #testcases <= 10
14 | 0 <= N <= 10^5
15 | 1 <= M <= 10^6
16 | 1 <= x[i] < M
17 | 1 <= y[i] <= 10^6
18 | 
19 | All x[i] are guaranteed to be different.
20 | 
21 | O(n log n)
22 | */
23 | 
24 | #include <bits/stdc++.h>
25 | using namespace std;
26 | const double eps = 1E-12;
27 | 
28 | int main() {
29 |     int t; cin >> t;
30 |     while (t--) {
31 |         int n, m; cin >> n >> m;
32 |         vector<int> x(n);
33 |         for (int i = 0; i < n; i++) {
34 |             cin >> x[i];
35 |         }
36 | 
37 |         vector<pair<int,double>> xts;
38 |         for (int i = 0; i < n; i++) {
39 |             double yi; cin >> yi;
40 |             xts.emplace_back(-x[i], (m - x[i]) / yi);
41 |         }
42 |         sort(xts.begin(), xts.end());
43 | 
44 |         int ans = 0;
45 |         double cur = 0;
46 |         for (auto xt : xts) {
47 |             if (xt.second > cur + eps) {
48 |                 cur = xt.second;
49 |                 ans++;
50 |             }
51 |         }
52 |         cout << ans << '\n';
53 |     }
54 | }


--------------------------------------------------------------------------------
/circularSubstring.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a source string and a target string, find the minimum length of a circular
 3 | substring of the source string which contains the target string. If no such 
 4 | substring exists, return -1. Circular substring means any substring of the
 5 | rotated source string.
 6 | 
 7 | For e.g. if source string is "shit" then all circular strings will be
 8 | {"shit", "hits", "itsh", "tshi"}. String x contains string y if all characters 
 9 | appear at least the same number of times in x as it appears in y.
10 | 
11 | E.g. for source "kecrha" and target "ack", the best possible answer can be for
12 | the circular string "hakecr" where the relevant substring is "akec" containing 
13 | "ack". Hence the final answer is 4
14 | 
15 | 1 <= length of strings <= 100000
16 | O(N + 26) solution
17 | */
18 | 
19 | #include <iostream>
20 | using namespace std;
21 | 
22 | int CircularSubstring(string source, string target) {
23 |     int n = source.size();
24 |     source += source;
25 | 
26 |     int a[26] = {}, nz = 0;
27 |     for (char c : target) {
28 |         if (not a[c - 'a']++) {
29 |             nz++;
30 |         }
31 |     }
32 | 
33 |     int min_len = 2 * n;
34 |     for (int i = 0, j = 0; i < 2 * n; i++) {
35 |         if (not --a[source[i] - 'a']) {
36 |             nz--;
37 |         }
38 |         while (a[source[j] - 'a'] < 0) {
39 |             a[source[j++] - 'a']++;
40 |         }
41 |         if (not nz) {
42 |             min_len = min(min_len, i - j + 1);
43 |         }
44 |     }
45 |     return min_len > n ? -1 : min_len;
46 | }
47 | 
48 | int main() {
49 |     // your code goes here
50 |     cout << CircularSubstring("kecrha", "ack") << '\n';
51 |     return 0;
52 | }


--------------------------------------------------------------------------------
/.github/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # Contributing
 2 | 
 3 | When contributing to this repository, please first discuss the change you wish to make via issue,
 4 | email, or any other method with the owners of this repository before making a change. 
 5 | 
 6 | Please note we have a code of conduct, please follow it in all your interactions with the project.
 7 | 
 8 | ## Steps before creating a Pull request
 9 | 
10 | 1. Please check the [template](../README.md#template) and adhere to the specific format in your submitted file
11 | 2. Please try to write clean and indented code. Sparsely occuring concise comments are also fine but not mandatory
12 | 3. Please ensure that the commit message follows the following format - Company name, College name, Year
13 | 4. Please ensure that the filename describes the problem statement as clearly as possible
14 | 
15 | ## Contributing workflow
16 | 
17 | Here’s how we suggest you go about proposing a change to this project:
18 | 
19 | 1. [Fork this project][fork] to your account.
20 | 2. [Create a branch][branch] for the change you intend to make.
21 | 3. Make your changes to your fork adhereing to the [guidelines][pull] above.
22 | 4. [Send a pull request][pr] from your fork’s branch to our `master` branch.
23 | 
24 | Using the web-based interface to make changes is fine too, and will help you by automatically 
25 | forking the project and prompting to send a pull request too.
26 | 
27 | [run]: https://www.cs.cmu.edu/~adamchik/15-121/lectures/Algorithmic%20Complexity/complexity.html
28 | [fork]: https://help.github.com/articles/fork-a-repo/
29 | [branch]: https://help.github.com/articles/creating-and-deleting-branches-within-your-repository
30 | [pull]: #steps-before-creating-a-pull-request
31 | [pr]: https://help.github.com/articles/using-pull-requests/


--------------------------------------------------------------------------------
/superStack.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Fractal Analytics IITK 2018
 3 | 
 4 | Maintain a stack which can handle the following operations:
 5 | 
 6 | "push k": Push k at the top of stack
 7 | "pop": Remove the topmost element from the stack
 8 | "inc e k": Add k to the bottom e elements of the stack
 9 | 
10 | pop is never called on an empty stack.
11 | 
12 | Given a vector of strings where each string is an operation as
13 | defined above, print the top element after every operation. If
14 | the stack is empty at some point, print "EMPTY" instead.
15 | 
16 | 1 <= #operations <= 1E5
17 | 1 <= k <= size of stack at the time of operation
18 | */
19 | #include <bits/stdc++.h>
20 | using namespace std;
21 | 
22 | void superStack(vector<string> ops) {
23 |     int n = ops.size();
24 |     vector<int> a(n), b(n);
25 | 
26 |     int k = 0;
27 |     for (string op : ops) {
28 |         stringstream strin(op);
29 |         
30 |         string optype;
31 |         strin >> optype;
32 |         if (optype == "push") {
33 |             int x;
34 |             strin >> x;
35 |             a[k++] = x;
36 |         }
37 |         if (optype == "pop") {
38 |             if (--k) b[k - 1] += b[k];
39 |             b[k] = 0;
40 |         }
41 |         if (optype == "inc") {
42 |             int x, y;
43 |             strin >> x >> y;
44 |             b[x - 1] += y;
45 |         }
46 | 
47 |         if (not k) {
48 |             cout << "EMPTY";
49 |         }
50 |         else {
51 |             cout << a[k - 1] + b[k - 1];
52 |         }
53 |         cout << " ";
54 |     }
55 | }
56 | 
57 | int main() {
58 |     vector<string> operations = {
59 |         "push 4", "pop", "push 3", "push 5", "inc 2 1",
60 |         "pop", "push 5", "push -1", "inc 1 5", "pop"
61 |     };
62 |     superStack(operations);
63 |     return 0;
64 | }


--------------------------------------------------------------------------------
/Find Number of pairs.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | BNY Mellon IITK 2018
 3 | 
 4 | Given N, find the number of ordered pairs of positive integers (x,y) satisfying
 5 | the following relation:
 6 | 1/x + 1/y = 1/N!
 7 | 
 8 | 0 <= N <= 100000
 9 | time O(N * log log N)
10 | space O(N)
11 | */
12 | #include <iostream>
13 | #include <vector>
14 | using namespace std;
15 | /*
16 |  * Let k = N!. We solve for general 1/x + 1/y = 1/k
17 |  * 
18 |  * x, y > 0 hence x, y > k. Let
19 |  *     p = #ordered pairs where x=y
20 |  *     q = #ordered pairs where x<y
21 |  *     r = #ordered pairs where x>y
22 |  * 
23 |  * Clearly, p = 1 and q = r. Our final answer becomes 1 + 2q. Let’s solve for q
24 |  * 
25 |  * Since x < y, we get x ∊ (k, 2k). Also, y = x * k / (x - k)
26 |  * 
27 |  * Let x’ = x - k. Then x’ ∊ (0, k) and y = (x’ + k) * k / x’ is an integer
28 |  * greater than x. Hence, x’ divides k^2 and x ∊ (0, 2k) which is already true
29 |  * 
30 |  * It means there exists a pair of type (ii) corresponding to x’ ∊ (0, k)
31 |  * whenever x’ divides k^2. Hence q = #divisors of k^2 less than k
32 |  * 
33 |  * Hence final answer becomes #divisors of k^2. Recall k = N!
34 |  */
35 | const int mod = 1E9 + 7;
36 | 
37 | int main() {
38 |     int n; cin >> n;
39 |     int ans = 1;
40 |     vector<bool> isprime(n + 1, true);
41 |     for (int i = 2; i <= n; i++) {
42 |         // check if prime
43 |         if (isprime[i]) {
44 |             // mark all multiples non-prime
45 |             for (int imul = 2 * i; imul <= n; imul += i) {
46 |                 isprime[imul] = false;
47 |             }
48 |             // update ans
49 |             int ncopy = n, ipower = 0;
50 |             while (ncopy) ipower += ncopy /= i;
51 |             ans = (1LL + 2 * ipower) * ans % mod;
52 |         }
53 |     }
54 |     cout << ans;
55 |     return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/Palindrome And Substring.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Walmart Labs IIT Dhanbad 2018
 3 | 
 4 | Given strings A and B, find the minimum number of manipulation done in string A
 5 | to achieve the following:
 6 | 1. A is a palindrome
 7 | 2. B is a substring in A
 8 | Here manipulation is defined as changing a character to some other character
 9 | 
10 | 1 <= String Lengths <= 5000
11 | O(N^2)
12 | */
13 | 
14 | #include <iostream>
15 | using namespace std;
16 | 
17 | int palSubstring(string &a, string &b) {
18 |     int n = a.size(), m = b.size();
19 | 
20 |     int ans = n + 1;
21 |     for (int i = 0; i <= n - m; i++) {
22 |         // Assuming A[i .. i + m - 1] is equal to B
23 |         int cost = 0, error = 0;
24 |         
25 |         string s = a;
26 |         for (int j = 0; j < m; j++) {
27 |             if (s[i + j] != b[j]) {
28 |                 s[i + j] = b[j];
29 |                 cost++;
30 |             }
31 |         }
32 |         
33 |         for (int j = 0; j < n / 2; j++) {
34 |             if (s[j] != s[n - 1 - j]) {
35 |                 // ensure that at least one of the characters is modifiable
36 |                 // j < i or n - 1 - j > i + m - 1
37 |                 if (j < max(i, n - m - i)) cost++;
38 |                 else error++;
39 |             }
40 |         }
41 | 
42 |         if (ans > cost and not error) {
43 |             ans = cost;
44 |         }
45 |     }
46 |     return (ans > n ? -1 : ans);
47 | }
48 | 
49 | int main() {
50 |     int t; cin >> t;
51 |     while (t--) {
52 |         string a, b; cin >> a >> b;
53 |         cout << palSubstring(a, b) << '\n';
54 |     }
55 |     return 0;
56 | }
57 | 
58 | /*
59 | SAMPLE INPUT:
60 | 7
61 | xycdabyx abcd
62 | acba abc
63 | abcba abc
64 | aaaa bbb
65 | aa ab
66 | aba c
67 | abba c
68 | 
69 | SAMPLE OUTPUT:
70 | 6
71 | -1
72 | 0
73 | 4
74 | -1
75 | 1
76 | 2
77 | */


--------------------------------------------------------------------------------
/turnstile.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Rivigo IITK 2018
 3 | 
 4 | There is a gate in an amusement park. There is an entrance queue and an exit queue.
 5 | Given two arrays of length n, time[] and direction[] such that time[i] represents 
 6 | the time when person_i reaches the gate and direction[i] represents whether the 
 7 | person is joining the entrance queue or exit queue, output an array timestamp[] 
 8 | of length n such that timestamp[i] represents the time when person_i crosses the 
 9 | gate. The gate operates as follows:
10 | 
11 | If the gate was used at time t - 1 for entrance, then entry queue will be preferred.
12 | Else If the gate was used at time t - 1 for exit, then exit queue will be preferred.
13 | Else exit queue will be preferred.
14 | 
15 | 1 <= n <= 10^5
16 | 1 <= time[i] <= 10^9
17 | time[i] <= time[i+1]
18 | direction[i] = 0 means entrance, direction[i] = 1 means exit.
19 | 
20 | O(n)
21 | */
22 | vector<int> getTimeStamps(vector<int> time, vector<int> dir) {
23 |     int n = time.size();
24 |     time.push_back(1E9 + 1E6);
25 |     vector<int> out(n);
26 |     queue<int> q[2]; // enter(0), exit(1)
27 |     for (int i = 0, t = time[0], fl = -1; i < n; i++) {
28 |         q[dir[i]].push(i);
29 |         while (t < time[i + 1]) {
30 |             if (not q[0].empty() and not fl) {
31 |                 out[q[0].front()] = t++;
32 |                 q[0].pop();
33 |                 fl = 0;
34 |             }
35 |             else if (not q[1].empty()) {
36 |                 out[q[1].front()] = t++;
37 |                 q[1].pop();
38 |                 fl = 1;
39 |             }
40 |             else if (not q[0].empty()) {
41 |                 out[q[0].front()] = t++;
42 |                 q[0].pop();
43 |                 fl = 0;
44 |             }
45 |             else {
46 |                 t = time[i + 1];
47 |                 fl = -1;
48 |             }
49 |         }
50 |     }
51 |     return out;
52 | }


--------------------------------------------------------------------------------
/findTheShape.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Nutanix IITD 2018
 3 | 
 4 | We are given the inorder and postorder traversal of a Binary tree. The data in 
 5 | the nodes are alphanumeric characters. Had to classify the tree shape into one 
 6 | of the following types:
 7 | 
 8 | / (forward slash) if the shape of tree is like a forward slash
 9 | \ (Backward slash) if the shape is like a backward slash
10 | < (less than) if the tree shape is like
11 | > (greater than)
12 | ^ (exponent symbol) if the shape of tree is like
13 | # (hash) if none of the above
14 | 
15 | Below figures are for further clarity (a, b, c represent nodes) :
16 | 
17 |          a         a               a         a
18 |         /           \             /           \            a
19 | (/)    b      (\)    b      (<)  b      (>)    b    (^)   / \    (#) all other
20 |       /               \           \           /          b   c
21 |      c                 c           c         c
22 | */
23 | #include <iostream>
24 | #include <algorithm>
25 | using namespace std;
26 | 
27 | bool check(string s, string t) { // O(n^2)
28 |     // >T .. <T
29 |     for (int i = s.size(); --i; ) {
30 |         string tir(t.substr(0, i));
31 |         reverse(tir.begin(), tir.end());
32 |         if (s.substr(0, i) == tir and s.substr(i) == t.substr(i)) {
33 |             return true;
34 |         }
35 |     }
36 |     return false;
37 | }
38 | 
39 | string solve() {
40 |     string s, t; cin >> s >> t;
41 |     string sr(s); reverse(sr.begin(), sr.end());
42 |     string tr(t); reverse(tr.begin(), tr.end());
43 |     if (s == t) return "/"; // T .. T
44 |     if (s == tr) return "\\"; // > .. <
45 |     if (check(s, t)) return "<"; // >T .. <T
46 |     if (check(sr, t)) return ">"; // >T .. T<
47 |     if (check(sr, tr)) return "^"; // T> .. T<
48 |     return "#"; // else
49 | }
50 | 
51 | int main() {
52 |     // your code goes here
53 |     int t; cin >> t;
54 |     while (t--) {
55 |         cout << solve() << '\n';
56 |     }
57 |     return 0;
58 | }


--------------------------------------------------------------------------------
/killingZombies.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Nutanix IISc 2018
 3 | https://www.codechef.com/problems/CLKLZM
 4 | 
 5 | O(n + m log m)
 6 | */
 7 | 
 8 | #include <bits/stdc++.h>
 9 | using namespace std;
10 | #define int long long
11 | 
12 | signed main() {
13 |     // your code goes here
14 |     ios_base::sync_with_stdio(false); cin.tie(NULL);
15 |     int cases; cin >> cases;
16 |     while (cases--) {
17 |         int n, m; cin >> n >> m;
18 |         
19 |         vector<int> a(n);
20 |         for (int i = 0; i < n; i++) {
21 |             cin >> a[i];
22 |         }
23 | 
24 |         vector<pair<pair<int,int>,int>> b(m);
25 |         for (int i = 0; i < m; i++) {
26 |             int l, r, k; cin >> l >> r >> k;
27 |             b[i] = {{l - 1, r - 1}, k};
28 |         }
29 |         sort(b.begin(), b.end(), [](pair<pair<int,int>,int> l, pair<pair<int,int>,int> r) {
30 |             if (l.first.first == r.first.first) return l.first.second > r.first.second;
31 |             return l.first.first < r.first.first;
32 |         });
33 | 
34 |         vector<int> c(n);
35 |         int j = 0, ext = 0, ans = 0, fl = 0;
36 |         priority_queue<pair<int,int>> q;
37 |         for (int i = 0; i < n; i++) {
38 |             a[i] -= ext;
39 | 
40 |             while (j < m and b[j].first.first <= i) {
41 |                 q.push({b[j].first.second, b[j].second});
42 |                 j++;
43 |             }
44 | 
45 |             int r, k;
46 |             while (a[i] > 0 and not q.empty()) {
47 |                 tie(r, k) = q.top(); q.pop();
48 |                 if (r < i) continue;
49 |                 
50 |                 if (k <= a[i]) {
51 |                     ans += k;
52 |                     ext += k;
53 |                     c[r] += k;
54 |                     a[i] -= k;
55 |                 }
56 |                 else {
57 |                     ans += a[i];
58 |                     ext += a[i];
59 |                     c[r] += a[i];
60 |                     q.push({r, k - a[i]});
61 |                     a[i] = 0;
62 |                 }
63 |             }
64 | 
65 |             if (a[i] > 0) {
66 |                 fl = 1;
67 |                 break;
68 |             }
69 |             ext -= c[i];
70 |         }
71 |         if (fl) cout << "NO";
72 |         else cout << "YES " << ans;
73 |         cout << '\n';
74 |     }
75 |     return 0;
76 | }


--------------------------------------------------------------------------------
/scientificFarmer.cpp:
--------------------------------------------------------------------------------
 1 | /*	
 2 | Cohesity : IITD
 3 | Scientific_Farmer:
 4 | 
 5 | Harry Stine is one of the wealthiest farmers in the world (net worth of $3.5 billion). Stine is known as a math wiz
 6 | and adopts unique practices when planting seeds and harvesting crops. For instance, his fields are always arranged
 7 | in a circular layout to promote better pollination, e.g., if there are n fields, then the 1st field and the nth field are
 8 | adjacent to each other. Also, his crop harvester machines never harvest two adjacent fields on the same day to
 9 | minimize damage to standing crops. Each field produces a certain yield (value) of crops. Given a list of non-negative
10 | integers representing the yield of each field, determine the maximum yield of crops that Harry can harvest in a day.
11 | 
12 | ==> Maximum sum in circular array such that no two elements are adjacent
13 | Solution Approach:
14 | 	recursive solution with memoization
15 | 	
16 | 	recurse(idx,prev,frst)
17 | 	we are at index = idx, we need to decice whether to take
18 | 	a[idx] or not. prev indicates a[idx - 1] is taken or not
19 | 	frst == 1 : a[1] is taken
20 | 	frst == 0 : a[1] is not taken
21 | 
22 | 	few examples: from other sources:
23 | 	
24 | 	3
25 | 	4 2 3
26 | 	=> 4
27 | 	
28 | 	4
29 | 	1 2 3 1
30 | 	=> 4
31 | 	
32 | 	6
33 | 	1 2 3 4 5 1
34 | 	=> 9
35 | 
36 | */
37 | 
38 | #include <bits/stdc++.h>
39 | using namespace std;
40 | int n;
41 | int dp[100009][2][2];
42 | int a[100009];
43 | 
44 | int recurse(int idx,bool prev,bool frst) {
45 | 	if(idx == n) {
46 | 		if(!prev and !frst) {
47 | 			return a[idx];
48 | 		}else {
49 | 			return 0;
50 | 		}
51 | 	}
52 | 	if(dp[idx][prev][frst] != -1) return dp[idx][prev][frst];	
53 | 	int res = 0;		// all numbers are non negative
54 | 	if(prev == false) {
55 | 		// take a[idx]
56 | 		res = max(res,recurse(idx+1,true,frst) + a[idx]);	
57 | 		// not take a[idx]
58 | 		res = max(res,recurse(idx+1,false,frst));
59 | 	}else {
60 | 		// not take a[idx]
61 | 		res = max(res,recurse(idx+1,false,frst));
62 | 	}
63 | 	return dp[idx][prev][frst] = res;
64 | }
65 | 
66 | int main() {
67 | 	cin >> n;
68 | 	for(int idx = 1;idx<=n;idx++) {
69 | 		cin >> a[idx];
70 | 	}
71 | 	memset(dp,-1,sizeof dp);
72 | 	// call two times
73 | 	// once not taking the first element
74 | 	// once taking the first element
75 | 	int res = max(recurse(2,false,false) , recurse(2,true,true) + a[1]);
76 | 	cout << res << endl;
77 | }


--------------------------------------------------------------------------------
/maxCoins.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Flipkart IIT Kanpur 2018
 3 | 
 4 | Given a limited number of coins of denominations 1, 5, 10, and 25
 5 | as p, q, r, and s respectively, return the maximum number of coins 
 6 | which can be used to reach a target "price", if possible.
 7 | 
 8 | Your function should return a vector of length 4 representing the
 9 | number of coins used for the denominations 1, 5, 10, 25 respectively.
10 | If no solution is possible, return a vector of 0s.
11 | 
12 | 0 <= price, p, q, r, s <= 100000
13 | */
14 | #include <bits/stdc++.h>
15 | using namespace std;
16 | #define int long long
17 | 
18 | vector<int> dummy(4);
19 | vector<int> greedy(int price, int p, int q, int r, int s) {
20 |     if (price <= p) return {price, 0, 0, 0};
21 |     price -= p;
22 | 
23 |     if (price <= 5 * q) {
24 |         if (price % 5 == 0) return {p, price / 5, 0, 0};
25 |         return dummy;
26 |     }
27 |     price -= 5 * q;
28 | 
29 |     if (price <= 10 * r) {
30 |         if (price % 10 == 0) return {p, q, price / 10, 0};
31 |         return dummy;
32 |     }
33 |     price -= 10 * r;
34 | 
35 |     if (price <= 25 * s) {
36 |         if (price % 25 == 0) return {p, q, r, price / 25};
37 |         return dummy;
38 |     }
39 | 
40 |     return dummy;
41 | }
42 | 
43 | vector<int> getMaxCoins(int price, int p, int q, int r, int s) {
44 |     // Max wastage: 1.. 25; 5.. 5; 10.. 3
45 |     map<int, set<vector<int>>> mp;
46 |     for (int i = 0; i <= 25; i++) {
47 |         for (int j = 0; j <= 5; j++) {
48 |             for (int k = 0; k <= 3; k++) {
49 |                 if (p >= i and q >= j and r >= k) {
50 |                     auto counts = greedy(price, p - i, q - j, r - k, s);
51 |                     if (counts != dummy) {
52 |                         int count = 0;
53 |                         for (int c : counts) {
54 |                             count += c;
55 |                         }
56 |                         mp[-count].insert(counts);
57 |                     }
58 |                 }
59 |             }
60 |         }
61 |     }
62 |     if (mp.empty()) return dummy;
63 |     auto feasible = mp.begin()->second;
64 |     if (feasible.empty()) return dummy;
65 |     return *feasible.begin();
66 | }
67 | 
68 | signed main() {
69 |     int denominations[] = {1, 5, 10, 25};
70 |     vector<int> counts = getMaxCoins(99, 98, 0, 0, 1);
71 |     
72 |     for (int i = 0; i < 4; i++) {
73 |         cout << "Number of coins of denomination " << denominations[i] << " = " << counts[i] << '\n';
74 |     }
75 |     return 0;
76 | }


--------------------------------------------------------------------------------
/.github/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
 1 | # Contributor Covenant Code of Conduct
 2 | 
 3 | ## Our Pledge
 4 | 
 5 | In the interest of fostering an open and welcoming environment, we as
 6 | contributors and maintainers pledge to making participation in our project and
 7 | our community a harassment-free experience for everyone, regardless of age, body
 8 | size, disability, ethnicity, sex characteristics, gender identity and expression,
 9 | level of experience, education, socio-economic status, nationality, personal
10 | appearance, race, religion, or sexual identity and orientation.
11 | 
12 | ## Our Standards
13 | 
14 | Examples of behavior that contributes to creating a positive environment
15 | include:
16 | 
17 | * Using welcoming and inclusive language
18 | * Being respectful of differing viewpoints and experiences
19 | * Gracefully accepting constructive criticism
20 | * Focusing on what is best for the community
21 | * Showing empathy towards other community members
22 | 
23 | Examples of unacceptable behavior by participants include:
24 | 
25 | * The use of sexualized language or imagery and unwelcome sexual attention or
26 |  advances
27 | * Trolling, insulting/derogatory comments, and personal or political attacks
28 | * Public or private harassment
29 | * Publishing others' private information, such as a physical or electronic
30 |  address, without explicit permission
31 | * Other conduct which could reasonably be considered inappropriate in a
32 |  professional setting
33 | 
34 | ## Our Responsibilities
35 | 
36 | Project maintainers are responsible for clarifying the standards of acceptable
37 | behavior and are expected to take appropriate and fair corrective action in
38 | response to any instances of unacceptable behavior.
39 | 
40 | Project maintainers have the right and responsibility to remove, edit, or
41 | reject comments, commits, code, wiki edits, issues, and other contributions
42 | that are not aligned to this Code of Conduct, or to ban temporarily or
43 | permanently any contributor for other behaviors that they deem inappropriate,
44 | threatening, offensive, or harmful.
45 | 
46 | ## Scope
47 | 
48 | This Code of Conduct applies both within project spaces and in public spaces
49 | when an individual is representing the project or its community. Examples of
50 | representing a project or community include using an official project e-mail
51 | address, posting via an official social media account, or acting as an appointed
52 | representative at an online or offline event. Representation of a project may be
53 | further defined and clarified by project maintainers.
54 | 
55 | ## Enforcement
56 | 
57 | Instances of abusive, harassing, or otherwise unacceptable behavior may be
58 | reported by contacting the project team at kaushal0181@gmail.com. All
59 | complaints will be reviewed and investigated and will result in a response that
60 | is deemed necessary and appropriate to the circumstances. The project team is
61 | obligated to maintain confidentiality with regard to the reporter of an incident.
62 | Further details of specific enforcement policies may be posted separately.
63 | 
64 | Project maintainers who do not follow or enforce the Code of Conduct in good
65 | faith may face temporary or permanent repercussions as determined by other
66 | members of the project's leadership.
67 | 
68 | ## Attribution
69 | 
70 | This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
71 | available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
72 | 
73 | [homepage]: https://www.contributor-covenant.org
74 | 
75 | For answers to common questions about this code of conduct, see
76 | https://www.contributor-covenant.org/faq


--------------------------------------------------------------------------------
/.github/LICENSE:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 |                             Preamble
  9 | 
 10 |   The GNU General Public License is a free, copyleft license for
 11 | software and other kinds of works.
 12 | 
 13 |   The licenses for most software and other practical works are designed
 14 | to take away your freedom to share and change the works.  By contrast,
 15 | the GNU General Public License is intended to guarantee your freedom to
 16 | share and change all versions of a program--to make sure it remains free
 17 | software for all its users.  We, the Free Software Foundation, use the
 18 | GNU General Public License for most of our software; it applies also to
 19 | any other work released this way by its authors.  You can apply it to
 20 | your programs, too.
 21 | 
 22 |   When we speak of free software, we are referring to freedom, not
 23 | price.  Our General Public Licenses are designed to make sure that you
 24 | have the freedom to distribute copies of free software (and charge for
 25 | them if you wish), that you receive source code or can get it if you
 26 | want it, that you can change the software or use pieces of it in new
 27 | free programs, and that you know you can do these things.
 28 | 
 29 |   To protect your rights, we need to prevent others from denying you
 30 | these rights or asking you to surrender the rights.  Therefore, you have
 31 | certain responsibilities if you distribute copies of the software, or if
 32 | you modify it: responsibilities to respect the freedom of others.
 33 | 
 34 |   For example, if you distribute copies of such a program, whether
 35 | gratis or for a fee, you must pass on to the recipients the same
 36 | freedoms that you received.  You must make sure that they, too, receive
 37 | or can get the source code.  And you must show them these terms so they
 38 | know their rights.
 39 | 
 40 |   Developers that use the GNU GPL protect your rights with two steps:
 41 | (1) assert copyright on the software, and (2) offer you this License
 42 | giving you legal permission to copy, distribute and/or modify it.
 43 | 
 44 |   For the developers' and authors' protection, the GPL clearly explains
 45 | that there is no warranty for this free software.  For both users' and
 46 | authors' sake, the GPL requires that modified versions be marked as
 47 | changed, so that their problems will not be attributed erroneously to
 48 | authors of previous versions.
 49 | 
 50 |   Some devices are designed to deny users access to install or run
 51 | modified versions of the software inside them, although the manufacturer
 52 | can do so.  This is fundamentally incompatible with the aim of
 53 | protecting users' freedom to change the software.  The systematic
 54 | pattern of such abuse occurs in the area of products for individuals to
 55 | use, which is precisely where it is most unacceptable.  Therefore, we
 56 | have designed this version of the GPL to prohibit the practice for those
 57 | products.  If such problems arise substantially in other domains, we
 58 | stand ready to extend this provision to those domains in future versions
 59 | of the GPL, as needed to protect the freedom of users.
 60 | 
 61 |   Finally, every program is threatened constantly by software patents.
 62 | States should not allow patents to restrict development and use of
 63 | software on general-purpose computers, but in those that do, we wish to
 64 | avoid the special danger that patents applied to a free program could
 65 | make it effectively proprietary.  To prevent this, the GPL assures that
 66 | patents cannot be used to render the program non-free.
 67 | 
 68 |   The precise terms and conditions for copying, distribution and
 69 | modification follow.
 70 | 
 71 |                        TERMS AND CONDITIONS
 72 | 
 73 |   0. Definitions.
 74 | 
 75 |   "This License" refers to version 3 of the GNU General Public License.
 76 | 
 77 |   "Copyright" also means copyright-like laws that apply to other kinds of
 78 | works, such as semiconductor masks.
 79 | 
 80 |   "The Program" refers to any copyrightable work licensed under this
 81 | License.  Each licensee is addressed as "you".  "Licensees" and
 82 | "recipients" may be individuals or organizations.
 83 | 
 84 |   To "modify" a work means to copy from or adapt all or part of the work
 85 | in a fashion requiring copyright permission, other than the making of an
 86 | exact copy.  The resulting work is called a "modified version" of the
 87 | earlier work or a work "based on" the earlier work.
 88 | 
 89 |   A "covered work" means either the unmodified Program or a work based
 90 | on the Program.
 91 | 
 92 |   To "propagate" a work means to do anything with it that, without
 93 | permission, would make you directly or secondarily liable for
 94 | infringement under applicable copyright law, except executing it on a
 95 | computer or modifying a private copy.  Propagation includes copying,
 96 | distribution (with or without modification), making available to the
 97 | public, and in some countries other activities as well.
 98 | 
 99 |   To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies.  Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 | 
103 |   An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License.  If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 | 
112 |   1. Source Code.
113 | 
114 |   The "source code" for a work means the preferred form of the work
115 | for making modifications to it.  "Object code" means any non-source
116 | form of a work.
117 | 
118 |   A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 | 
123 |   The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form.  A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 | 
134 |   The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities.  However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work.  For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 | 
147 |   The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 | 
151 |   The Corresponding Source for a work in source code form is that
152 | same work.
153 | 
154 |   2. Basic Permissions.
155 | 
156 |   All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met.  This License explicitly affirms your unlimited
159 | permission to run the unmodified Program.  The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work.  This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 | 
164 |   You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force.  You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright.  Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 | 
175 |   Conveying under any other circumstances is permitted solely under
176 | the conditions stated below.  Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 | 
179 |   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 | 
181 |   No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 | 
187 |   When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 | 
195 |   4. Conveying Verbatim Copies.
196 | 
197 |   You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 | 
205 |   You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 | 
208 |   5. Conveying Modified Source Versions.
209 | 
210 |   You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 | 
214 |     a) The work must carry prominent notices stating that you modified
215 |     it, and giving a relevant date.
216 | 
217 |     b) The work must carry prominent notices stating that it is
218 |     released under this License and any conditions added under section
219 |     7.  This requirement modifies the requirement in section 4 to
220 |     "keep intact all notices".
221 | 
222 |     c) You must license the entire work, as a whole, under this
223 |     License to anyone who comes into possession of a copy.  This
224 |     License will therefore apply, along with any applicable section 7
225 |     additional terms, to the whole of the work, and all its parts,
226 |     regardless of how they are packaged.  This License gives no
227 |     permission to license the work in any other way, but it does not
228 |     invalidate such permission if you have separately received it.
229 | 
230 |     d) If the work has interactive user interfaces, each must display
231 |     Appropriate Legal Notices; however, if the Program has interactive
232 |     interfaces that do not display Appropriate Legal Notices, your
233 |     work need not make them do so.
234 | 
235 |   A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit.  Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 | 
245 |   6. Conveying Non-Source Forms.
246 | 
247 |   You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 | 
252 |     a) Convey the object code in, or embodied in, a physical product
253 |     (including a physical distribution medium), accompanied by the
254 |     Corresponding Source fixed on a durable physical medium
255 |     customarily used for software interchange.
256 | 
257 |     b) Convey the object code in, or embodied in, a physical product
258 |     (including a physical distribution medium), accompanied by a
259 |     written offer, valid for at least three years and valid for as
260 |     long as you offer spare parts or customer support for that product
261 |     model, to give anyone who possesses the object code either (1) a
262 |     copy of the Corresponding Source for all the software in the
263 |     product that is covered by this License, on a durable physical
264 |     medium customarily used for software interchange, for a price no
265 |     more than your reasonable cost of physically performing this
266 |     conveying of source, or (2) access to copy the
267 |     Corresponding Source from a network server at no charge.
268 | 
269 |     c) Convey individual copies of the object code with a copy of the
270 |     written offer to provide the Corresponding Source.  This
271 |     alternative is allowed only occasionally and noncommercially, and
272 |     only if you received the object code with such an offer, in accord
273 |     with subsection 6b.
274 | 
275 |     d) Convey the object code by offering access from a designated
276 |     place (gratis or for a charge), and offer equivalent access to the
277 |     Corresponding Source in the same way through the same place at no
278 |     further charge.  You need not require recipients to copy the
279 |     Corresponding Source along with the object code.  If the place to
280 |     copy the object code is a network server, the Corresponding Source
281 |     may be on a different server (operated by you or a third party)
282 |     that supports equivalent copying facilities, provided you maintain
283 |     clear directions next to the object code saying where to find the
284 |     Corresponding Source.  Regardless of what server hosts the
285 |     Corresponding Source, you remain obligated to ensure that it is
286 |     available for as long as needed to satisfy these requirements.
287 | 
288 |     e) Convey the object code using peer-to-peer transmission, provided
289 |     you inform other peers where the object code and Corresponding
290 |     Source of the work are being offered to the general public at no
291 |     charge under subsection 6d.
292 | 
293 |   A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 | 
297 |   A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling.  In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage.  For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product.  A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 | 
310 |   "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source.  The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 | 
318 |   If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information.  But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 | 
329 |   The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed.  Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 | 
337 |   Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 | 
343 |   7. Additional Terms.
344 | 
345 |   "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law.  If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 | 
354 |   When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it.  (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.)  You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 | 
361 |   Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 | 
365 |     a) Disclaiming warranty or limiting liability differently from the
366 |     terms of sections 15 and 16 of this License; or
367 | 
368 |     b) Requiring preservation of specified reasonable legal notices or
369 |     author attributions in that material or in the Appropriate Legal
370 |     Notices displayed by works containing it; or
371 | 
372 |     c) Prohibiting misrepresentation of the origin of that material, or
373 |     requiring that modified versions of such material be marked in
374 |     reasonable ways as different from the original version; or
375 | 
376 |     d) Limiting the use for publicity purposes of names of licensors or
377 |     authors of the material; or
378 | 
379 |     e) Declining to grant rights under trademark law for use of some
380 |     trade names, trademarks, or service marks; or
381 | 
382 |     f) Requiring indemnification of licensors and authors of that
383 |     material by anyone who conveys the material (or modified versions of
384 |     it) with contractual assumptions of liability to the recipient, for
385 |     any liability that these contractual assumptions directly impose on
386 |     those licensors and authors.
387 | 
388 |   All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10.  If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term.  If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 | 
398 |   If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 | 
403 |   Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 | 
407 |   8. Termination.
408 | 
409 |   You may not propagate or modify a covered work except as expressly
410 | provided under this License.  Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 | 
415 |   However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 | 
422 |   Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 | 
429 |   Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License.  If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 | 
435 |   9. Acceptance Not Required for Having Copies.
436 | 
437 |   You are not required to accept this License in order to receive or
438 | run a copy of the Program.  Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance.  However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work.  These actions infringe copyright if you do
443 | not accept this License.  Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 | 
446 |   10. Automatic Licensing of Downstream Recipients.
447 | 
448 |   Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License.  You are not responsible
451 | for enforcing compliance by third parties with this License.
452 | 
453 |   An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations.  If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 | 
463 |   You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License.  For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 | 
471 |   11. Patents.
472 | 
473 |   A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based.  The
475 | work thus licensed is called the contributor's "contributor version".
476 | 
477 |   A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version.  For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 | 
487 |   Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 | 
492 |   In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement).  To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 | 
499 |   If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients.  "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 | 
513 |   If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 | 
521 |   A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License.  You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 | 
536 |   Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 | 
540 |   12. No Surrender of Others' Freedom.
541 | 
542 |   If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License.  If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all.  For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 | 
552 |   13. Use with the GNU Affero General Public License.
553 | 
554 |   Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work.  The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 | 
563 |   14. Revised Versions of this License.
564 | 
565 |   The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time.  Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 | 
570 |   Each version is given a distinguishing version number.  If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation.  If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 | 
579 |   If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 | 
584 |   Later license versions may give you additional or different
585 | permissions.  However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 | 
589 |   15. Disclaimer of Warranty.
590 | 
591 |   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 | 
600 |   16. Limitation of Liability.
601 | 
602 |   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 | 
612 |   17. Interpretation of Sections 15 and 16.
613 | 
614 |   If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 | 
621 |                      END OF TERMS AND CONDITIONS
622 | 
623 |             How to Apply These Terms to Your New Programs
624 | 
625 |   If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 | 
629 |   To do so, attach the following notices to the program.  It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 | 
634 |     <one line to give the program's name and a brief idea of what it does.>
635 |     Copyright (C) <year>  <name of author>
636 | 
637 |     This program is free software: you can redistribute it and/or modify
638 |     it under the terms of the GNU General Public License as published by
639 |     the Free Software Foundation, either version 3 of the License, or
640 |     (at your option) any later version.
641 | 
642 |     This program is distributed in the hope that it will be useful,
643 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
644 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
645 |     GNU General Public License for more details.
646 | 
647 |     You should have received a copy of the GNU General Public License
648 |     along with this program.  If not, see <https://www.gnu.org/licenses/>.
649 | 
650 | Also add information on how to contact you by electronic and paper mail.
651 | 
652 |   If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 | 
655 |     <program>  Copyright (C) <year>  <name of author>
656 |     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 |     This is free software, and you are welcome to redistribute it
658 |     under certain conditions; type `show c' for details.
659 | 
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License.  Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 | 
664 |   You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | <https://www.gnu.org/licenses/>.
668 | 
669 |   The GNU General Public License does not permit incorporating your program
670 | into proprietary programs.  If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library.  If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License.  But first, please read
674 | <https://www.gnu.org/licenses/why-not-lgpl.html>.
675 | 


--------------------------------------------------------------------------------