├── A Real Opportunity.cpp
├── README.md
└── Save Me From Assignments.cpp


/A Real Opportunity.cpp:
--------------------------------------------------------------------------------
  1 | #include<bits/stdc++.h>
  2 | using namespace std;
  3 | typedef long long ll;
  4 | typedef long double ld;
  5 | const ll INF = 9223372036854775807;
  6 | const ll MOD = 1000000007;
  7 | const long double PI = acos(-1);
  8 | #define pb push_back
  9 | #define mp make_pair
 10 | #define all(v) v.begin(), v.end()
 11 | #define o0(a) cout<<a<<" "
 12 | #define o1(a) cout<<a<<"\n"
 13 | #define o2(a, b) cout<<a<<" "<<b<<"\n"
 14 | #define o3(a, b, c) cout<<a<<" "<<b<<" "<<c<<"\n"
 15 | #define o4(a, b, c, d) cout<<a<<" "<<b<<" "<<c<<" "<<d<<"\n"
 16 | #define i1(a) cin>>a
 17 | #define i2(a, b) cin>>a>>b
 18 | #define i3(a, b, c) cin>>a>>b>>c
 19 | #define i4(a, b, c, d) cin>>a>>b>>c>>d
 20 | #define fi first
 21 | #define se second
 22 | 
 23 | inline ll power(ll a, ll b, ll z = MOD)
 24 | {
 25 | 	ll res = 1;
 26 | 	a = (a%z);
 27 | 	while(b)
 28 | 	{
 29 | 		if(b&1)
 30 | 			res = (res*a)%z;
 31 | 		a = (a*a)%z;
 32 | 		b = b>>1;
 33 | 	}
 34 | 	return res;
 35 | }
 36 | 
 37 | inline ll inverse(ll a, ll z = MOD)
 38 | {
 39 | 	return power(a, z-2, z);
 40 | }
 41 | 
 42 | ll extend(ll a, ll b, ll &x, ll &y)
 43 | {
 44 | 	if(b == 0)
 45 | 	{
 46 | 		x = 1;
 47 | 		y = 0;
 48 | 		return a;
 49 | 	}
 50 | 	ll x1, y1;
 51 | 	ll g = extend(b, a%b, x1, y1);
 52 | 	x = y1;
 53 | 	y = x1- (a/b)*y1;
 54 | 	return g;
 55 | }
 56 | 
 57 | class matrix
 58 | {
 59 | 	public:
 60 | 	ll n, aray[5][5], z = MOD;
 61 | 	matrix(ll n)
 62 | 	{
 63 | 		this->n = n;
 64 | 		for(ll i=0;i<n;i++)
 65 | 		{
 66 | 			for(ll j=0;j<n;j++)
 67 | 				aray[i][j] = (i == j);
 68 | 		}
 69 | 	}
 70 | 	matrix operator+(const matrix& a)
 71 | 	{
 72 | 		matrix ans = matrix(n);
 73 | 		for(ll i=0;i<n;i++)
 74 | 		{
 75 | 			for(ll j=0;j<n;j++)
 76 | 				ans.aray[i][j] = (a.aray[i][j] + aray[i][j])%z;
 77 | 		}
 78 | 		return ans;
 79 | 	}
 80 | 	matrix operator*(const matrix& a)
 81 | 	{
 82 | 		matrix ans = matrix(n);
 83 | 		for(ll i=0;i<n;i++)
 84 | 		{
 85 | 			for(ll j=0;j<n;j++)
 86 | 			{
 87 | 				ans.aray[i][j] = 0;
 88 | 				for(ll k=0;k<n;k++)
 89 | 					ans.aray[i][j] = (ans.aray[i][j] + aray[i][k]*a.aray[k][j])%z;
 90 | 			}
 91 | 		}
 92 | 		return ans;
 93 | 	}
 94 | };
 95 | 
 96 | inline matrix mat_power(matrix x, ll b, ll z = MOD)
 97 | {
 98 | 	matrix ans = matrix(x.n);
 99 | 	while(b)
100 | 	{
101 | 		if(b&1)
102 | 			ans = ans*x;
103 | 		x = x*x;
104 | 		b = b>>1;
105 | 	}
106 | 	return ans;
107 | }
108 | 
109 | // void build(ll node, ll l, ll r)
110 | // {
111 | //     lazy[node] = 0;
112 | //     if(l == r)
113 | //     {
114 | //         tree[node] = aray[l];
115 | //         return ;
116 | //     }
117 | //     ll mid = (l+r)>>1;
118 | //     build(node<<1, l, mid);
119 | //     build((node<<1)+1, mid+1, r);
120 | //     tree[node] = tree[node<<1] + tree[(node<<1)+1];
121 | //     return ;
122 | // }
123 | 
124 | // void update(ll node, ll l, ll r, ll left, ll right, ll val)
125 | // {
126 | //     if(lazy[node] != 0)
127 | //     {
128 | //         tree[node] += (r-l+1)*lazy[node];
129 | //         if(l != r)
130 | //         {
131 | //             lazy[node<<1] += lazy[node];
132 | //             lazy[(node<<1)+1] += lazy[node];
133 | //         }
134 | //         lazy[node] = 0;
135 | //     }
136 | //     if(left > r || l > right)
137 | //         return ;
138 | //     if(left <= l && right >= r)
139 | //     {
140 | //         tree[node] += val*(r-l+1);
141 | //         if(l != r)
142 | //         {
143 | //             lazy[node<<1] += val;
144 | //             lazy[(node<<1)+1] += val;
145 | //         }
146 | //         return ;
147 | //     }
148 | //     ll mid = (l+r)>>1;
149 | //     update(node<<1, l, mid, left, right, val);
150 | //     update((node<<1)+1, mid+1, r, left, right, val);
151 | //     tree[node] = tree[node<<1] + tree[(node<<1)+1];
152 | //     return ;
153 | // }
154 | 
155 | // ll query(ll node, ll l, ll r, ll left, ll right)
156 | // {
157 | //     if(left > r || l > right)
158 | //         return 0;
159 | //     if(lazy[node] != 0)
160 | //     {
161 | //         tree[node] += (r-l+1)*lazy[node];
162 | //         if(l != r)
163 | //         {
164 | //             lazy[node<<1] += lazy[node];
165 | //             lazy[(node<<1)+1] += lazy[node];
166 | //         }
167 | //         lazy[node] = 0;
168 | //     }
169 | //     if(left <= l && right >= r)
170 | //         return tree[node];
171 | //     ll mid = (l+r)>>1;
172 | //     return query(node<<1, l, mid, left, right) + query((node<<1)+1, mid+1, r, left, right);
173 | // }
174 | 
175 | int main()
176 | {
177 |     ios_base::sync_with_stdio(false);
178 |     cin.tie(NULL);
179 |     ll n, m;
180 |     cin>>n>>m;
181 |     n = n%m;
182 |     ll x = 1, low = n%m, y = 1, high = n%m, curr = 1;
183 |     for(int i=1;i<=m;i++)
184 |     {
185 |         curr = (curr*n)%m;
186 |         if(curr > high)
187 |         {
188 |             high = curr;
189 |             y = i;
190 |         }
191 |         if(curr < low)
192 |         {
193 |             low = curr;
194 |             x = i;
195 |         }
196 |     }
197 |     cout<<x<<" "<<y<<"\n";
198 |     return 0;
199 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Competitive Programming for Beginners
 2 | 
 3 | Competitive Programming attracts one of the best minds across the world. It is all about solving problems pertaining to a multitude of data structures and algorithms. Ranging from ACM-ICPC and Goolge Code Jam to several daily contests across various platforms, there are hundreds of competitions where one can participate to showcase their skills and get better at them. Refer to our [WnCC Wiki Article](https://www.wncc-iitb.org/wiki/index.php/Competitive_Programming) to get started. You can also have a look at [this](https://www.quora.com/What-is-competitive-programming-2) blog to get to know more about what competitive programming is.
 4 | 
 5 | ## How to Start?
 6 | 
 7 | Okay great! It is an amazing thing to do. But how to start with competitive programming. Firstly, learn a programming langauge (preferrably C++). Learn about the various standard libraries that the language offers and that are generally used in Competitive Programming. You can refer to [this](https://www.geeksforgeeks.org/c-plus-plus/) article for beginning with C++ and [this](https://www.geeksforgeeks.org/the-c-standard-template-library-stl/) article for learning STL.
 8 | 
 9 | ## Hone your Problem Solving Skills
10 | 
11 | Once, you are familiar with the syntax and all, you can start with practicing problems online on several platforms like [Codechef](https://www.codechef.com/), [Codeforces](https://codeforces.com/), [Hackerearth](https://www.hackerearth.com/challenges/), [Hackerrank](https://www.hackerrank.com/), [SPOJ](https://www.spoj.com/), [A2OJ](https://a2oj.com/), [Atcoder](https://atcoder.jp/), [TopCoder](https://www.topcoder.com/). Start with the basic adhoc problems. These require just logical thinking and no complicated algorithms or data structures. The [CSES Problem Set](https://cses.fi/problemset/) available online and [A2OJ ladder](https://a2oj.com/) is a great way to start with practising basic problems.
12 | 
13 | ## Data Structures and Algorithms
14 | 
15 | Having done a fair amount of practice with problems that require you to think logically and basic programming skills, it's time to learn about simple data structures and algorithms. 
16 | 
17 | * Refer to [this](https://cp-algorithms.com/) website. This website contains all the data structures and algorithms that any competitive programmer would need in general. It will be a one stop for any thing that you might need. It contains detailed description of algorithms, implemented code, proofs and problems for practice for that concept.
18 | 
19 | * Refer to the [Edu](https://codeforces.com/edu/courses) section of codeforces for learning new data structures and algorithms. 
20 | 
21 | * [Codemonk](https://www.hackerearth.com/practice/codemonk/) on Hackerearth is extremely useful for beginners to get acquainted with various data structures and algorithms. 
22 | 
23 | * For diving deep into DSA, you can refer the CLRS book.
24 | 
25 | * For getting into the field of Competitive Programming, refer to the book Competitive Programming 3.
26 | 
27 | It must be kept in mind, that solving the problems is key to accomplishment in thsi field. Simply knowing the algorithms won't help. Unless you practice problems and try to come up with your own algorithms for solving problems, you won't see a growth in your performance
28 | 
29 | ## Time for Contests
30 | 
31 | While you learn new concepts and practice problems, it is important for you to appear in timed contests to test your skills and see where you stand. You don't need to compare yourself with others but contests really help you grow. Also, keep this in mind, do competitive programming only if you enojoy it. It makes no sense to do CP for the sake of rating on websites. You can give contests on Codeforces, Codechef, Atcoder and TopCoder. There are other websites where they hold regular contests, but these platforms are the most popular. 
32 | 
33 | Do remember to "upsolve", i.e. try to solve the problems that appeared in the contests that you couldn't solve during the contest. Another advantage of practicing problems on these wesbites is that they provide editorials that is the solutions to the problems are available which you can have a look at to learn new concepts and new techniques to solve the problems.
34 | 
35 | ## Practice
36 | 
37 | * You can refer to [this](https://github.com/wncc/CodeInQuarantine/tree/master/Week_2_CC) WnCC repository to practice a few handpicked problems that are good to hone your skills in various algorithms and data structures. 
38 | 
39 | * [This](https://codeforces.com/blog/entry/55274) is an extremely useful set of problems for to help you get familiar with new concepts.
40 | 
41 | * You can sort the problems based on difficulty of the problems on Codeforces and keep praticing problems which are slightly challenging for you to solve based on that.
42 | 
43 | ## Competition
44 | 
45 | So, we have planned a competition for you next week. The structure for the contest is that you will be given two days i.e. 24 hours for solving a set of 10 problems on a platform hosted on HackerRank. These problems would be arranged in order of difficulty. The problems would be simple programming exercises with a few tougher ones for the people who are interested. 
46 | 
47 | The tentative structure would be -
48 | 
49 | * 5 problems that will be ad-hoc, that is just to test your implementational skills.
50 | 
51 | * 2 problems on simple algorithms like sorting and searching.
52 | 
53 | * 1 problem based on recursion.
54 | 
55 | * 1 problem based on stack and queue data structure.
56 | 
57 | * 1 relatively advanced problem based on logical thinking and application of multiple ideas in one problem.
58 | 
59 | Specifically for the competition,
60 | 
61 | * It is important for you to understand [arrays](https://www.geeksforgeeks.org/arrays-in-c-cpp/) and a bit of STL especially [sorting](https://www.geeksforgeeks.org/sort-c-stl/). 
62 | 
63 | * Also read about simple standard algoithms like [Modular Exponentiation](https://www.geeksforgeeks.org/modular-exponentiation-power-in-modular-arithmetic/) and [Binary Search](https://www.topcoder.com/community/competitive-programming/tutorials/binary-search).  
64 | 
65 | The problems wil be more focussed on logic rather than algorithms and data structures. Practice basic coding via adhoc problems using the resources above. Since each problem is based on logical thinking, it is advised to read each problem because it might be the case that you can solve the toughest problem in the contest but not the easiest one. 
66 | 
67 | The contest is aimed at the beginners and hence we have kept easier problems. In the follow-up competitions soon, the level of problems will increase geradually to cater to intermediate students too. 
68 | 
69 | Don't forget to join us on telegram [here](https://t.me/joinchat/QqpKj1h3zk3XwoNgPpDiZA) for all further communications about the competition.
70 | 


--------------------------------------------------------------------------------
/Save Me From Assignments.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | #define ld long double
 4 |  
 5 | const ld a = 0.0000001;
 6 | ld aray[10000];
 7 | int n, k;
 8 |  
 9 | bool poss(double val)
10 | {
11 |     int c = 0;
12 |     for(auto x : aray)
13 |     {
14 |         c += floor(x/val);
15 |         if(c >= k)
16 |             return true;
17 |     }
18 |     if(c >= k)
19 |         return true;
20 |     return false;
21 | }
22 | int main()
23 | {
24 |     ios_base::sync_with_stdio(false);
25 |     cin.tie(NULL);
26 |     cin>>n>>k;
27 |     for(int i=0;i<n;i++)
28 |         cin>>aray[i];
29 |     ld left = 0, right = 1e9, mid;
30 |     while(left+a < right)
31 |     {
32 |         mid = (left+right)/2;
33 |         if(poss(mid))
34 |             left = mid;
35 |         else 
36 |             right = mid;
37 |     }
38 |     cout<<fixed<<setprecision(6)<<left<<"\n";
39 |     return 0;
40 | }


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