├── Algorithms ├── Bit Manipulation │ └── Lonely Integer │ │ ├── Solutions │ │ ├── Lonely_Integer.java │ │ └── lonely_integer.py │ │ └── readme.md ├── Implementation │ ├── Kangaroo │ │ ├── Solutions │ │ │ ├── Kangaroo.java │ │ │ └── kangaroo.py │ │ └── readme.md │ └── Sherlock And Squares │ │ ├── Solutions │ │ └── Sherlock_And_Squares.java │ │ └── readme.md ├── Miscellaneous │ ├── Digit Longest Increasing Subsequence │ │ ├── Solutions │ │ │ └── DigitLongestIncreasingSubsequence.cpp │ │ └── readme.md │ └── Rectangles │ │ ├── Solutions │ │ ├── Rectangles.cpp │ │ └── Rectangles.java │ │ └── readme.md ├── Recursion │ ├── Coin Change │ │ ├── Solutions │ │ │ └── Coin_Change.java │ │ └── readme.md │ ├── Combination │ │ ├── Solutions │ │ │ └── Combination.java │ │ └── readme.md │ └── Tower Of Hanoi │ │ ├── Solutions │ │ └── Tower_Of_Hanoi.java │ │ └── readme.md ├── Sorting Algorithms │ ├── Bubble Sort │ │ ├── Bubble Sort.cpp │ │ └── Bubble_Sort.java │ ├── Count Sort │ │ └── Count Sort.cpp │ ├── Heap Sort │ │ └── Heap Sort.cpp │ ├── Insertion Sort │ │ └── Insertion Sort.cpp │ ├── Merge Sort │ │ └── Merge Sort.cpp │ ├── Quick Sort │ │ └── Quick Sort.cpp │ └── Selection Sort │ │ ├── Selection Sort.cpp │ │ └── Selection_Sort.java ├── Warmup │ └── Simple Array Sum │ │ ├── Solutions │ │ ├── Simple_Array_Sum.java │ │ └── simple_array_sum.py │ │ └── readme.md └── ad-hoc │ └── timeconversion.txt ├── CODE_OF_CONDUCT.md ├── Data Structures ├── Array │ └── Reverse │ │ ├── Solutions │ │ ├── Reverse.java │ │ ├── reverse.cpp │ │ └── reverse.py │ │ └── readme.md └── Stack │ ├── Balanced Brackets │ ├── Solutions │ │ ├── Balanced_Brackets.cpp │ │ ├── Balanced_Brackets.java │ │ └── Balanced_Brackets.py │ └── readme.md │ └── Stock and Span │ ├── Solutions │ └── Stock and Span.cpp │ └── readme.md ├── LICENSE └── README.md /Algorithms/Bit Manipulation/Lonely Integer/Solutions/Lonely_Integer.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | class Lonely_Integer{ 3 | 4 | public static void main(String args[]){ 5 | Scanner ob=new Scanner(System.in); 6 | System.out.println("\u000C"); // clears the terminal 7 | System.out.println(" Enter the value of n : "); 8 | System.out.println(); 9 | int n=ob.nextInt(); 10 | System.out.println(); 11 | System.out.println(" Enter the n elements of the array : "); 12 | System.out.println(); 13 | int i=0,r=0; 14 | int[] a=new int[n]; 15 | for(i=0;iv2)&&((x2-x1)%(v2-v1)==0))?"YES":"NO"; // ternary operator 15 | System.out.println(temp); 16 | } 17 | } -------------------------------------------------------------------------------- /Algorithms/Implementation/Kangaroo/Solutions/kangaroo.py: -------------------------------------------------------------------------------- 1 | #!/bin/python3 2 | 3 | import sys 4 | 5 | 6 | x1,v1,x2,v2 = input().strip().split(' ') 7 | x1,v1,x2,v2 = [int(x1),int(v1),int(x2),int(v2)] 8 | 9 | if x1 == x2 and v1 == v2 : print("YES") 10 | elif x1 == x2 and v2 > v1 : print("NO") 11 | elif v2 >= v1 and x2 >= x1 : print("NO") 12 | else : 13 | if (x2-x1) % (v2 -v1) == 0 : print("YES") 14 | else : print("NO") 15 | -------------------------------------------------------------------------------- /Algorithms/Implementation/Kangaroo/readme.md: -------------------------------------------------------------------------------- 1 | # Kangaroo 2 | 3 | The problem states that there are two kangaroos on a number line ready to jump in the positive direction (i.e, toward positive infinity). The first kangaroo starts at location `x1` and moves at a rate of `v1` meters per jump. The second kangaroo starts at location `x2` and moves at a rate of `v2` meters per jump. Given the starting locations and movement rates for each kangaroo, can you determine if they'll ever land at the same location at the same time? 4 | 5 | 6 | ## Input Format 7 | 8 | A single line of space seperated integers denoting the respective values of `x1`, `v1`, `x2` and `v2`. 9 | 10 | ## Output Format 11 | 12 | Print `YES` if they can land on the same location at the same time; otherwise, print `NO`. 13 | 14 | 15 | ## Analysis 16 | 17 | If `v2` is greater than or equal to `v1`, the kangaroos will never meet. 18 | 19 | Else the initial distance between them is `x2-x1`. And relative speed is `v2-v1`. Thus initial distance must be divisible by relative speed. 20 | -------------------------------------------------------------------------------- /Algorithms/Implementation/Sherlock And Squares/Solutions/Sherlock_And_Squares.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | class Sherlock_And_Squares{ 3 | 4 | public static void main(String args[]) { 5 | Scanner ob=new Scanner(System.in); 6 | System.out.println("\u000C"); // clears the terminal 7 | System.out.println(" Enter the values of A and B : "); 8 | System.out.println(); 9 | int A=ob.nextInt(); 10 | int B=ob.nextInt(); 11 | System.out.println(); 12 | int x=(int)Math.ceil(Math.sqrt(A)); 13 | int y=(int)Math.floor(Math.sqrt(B)); 14 | int c=y-x+1; 15 | System.out.println(c); 16 | } 17 | } -------------------------------------------------------------------------------- /Algorithms/Implementation/Sherlock And Squares/readme.md: -------------------------------------------------------------------------------- 1 | # Sherlock And Squares 2 | 3 | Watson gives two integers (`A` and `B`) to Sherlock and asks if he can count the number of square integers between `A` and `B` (both inclusive). 4 | 5 | Note : A square integer is an integer which is the square of any integer. For example, 1, 4, 9, and 16 are some of the square integers as they are squares of 1, 2, 3, and 4, respectively. 6 | 7 | 8 | ## Input Format 9 | 10 | The input consists of two space-separated integers denoting `A` and `B`. 11 | 12 | ## Output Format 13 | 14 | A single integer representing the required answer. 15 | 16 | 17 | ## Analysis 18 | 19 | Self explanatory. 20 | -------------------------------------------------------------------------------- /Algorithms/Miscellaneous/Digit Longest Increasing Subsequence/Solutions/DigitLongestIncreasingSubsequence.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #define For(i,a,b) for(int i=a;i=b;i--) 14 | #define lli long long int 15 | #define ld long double 16 | #define ulli unsigned long long int 17 | #define ui unsigned int 18 | #define Max(a,b) (a>b?a:b) 19 | #define Min(a,b) (a>t; 28 | while(t--) 29 | { 30 | int n; 31 | cin>>n; 32 | vectorarr(n); 33 | int max=0,pos=0; 34 | For(i,0,n) 35 | { 36 | cin>>arr[i]; 37 | 38 | } 39 | For(i,0,n) 40 | { 41 | cout< 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int n; 8 | cin>>n; 9 | int i=1,cnt=0; 10 | 11 | int ans=0; 12 | while(i<=n) 13 | { 14 | ans=ans+(n/i); 15 | if(n>=i*i) 16 | cnt++; 17 | i++; 18 | } 19 | ans=ans+(cnt); 20 | ans=ans/2; 21 | 22 | cout<=i*i) 11 | cnt++; 12 | i++; 13 | } 14 | ans+=cnt; 15 | ans/=2; 16 | System.out.println(ans); 17 | } 18 | } -------------------------------------------------------------------------------- /Algorithms/Miscellaneous/Rectangles/readme.md: -------------------------------------------------------------------------------- 1 | # Rectangles 2 | 3 | Byteman has a collection of N squares with side 1. How many different rectangles can he form using these squares? 4 | 5 | Two rectangles are considered different if none of them can be rotated and moved to obtain the second one. During rectangle construction, Byteman can neither deform the squares nor put any squares upon any other ones. 6 | 7 | 8 | ## Input Format 9 | 10 | The first and only line of the standard input contains one integer N (1 <= N <= 10000). 11 | 12 | ## Output Format 13 | 14 | The first and only line of the standard output should contain a single integer equal to the number of different rectangles that Byteman can form using his squares. 15 | -------------------------------------------------------------------------------- /Algorithms/Recursion/Coin Change/Solutions/Coin_Change.java: -------------------------------------------------------------------------------- 1 | import java.io.*; 2 | class Coin_Change{ 3 | 4 | private static int coin_change(int arr[],int n,int k){ 5 | if(k==0) 6 | return 1; 7 | else if(n<0) 8 | return 0; 9 | else if(k<0) 10 | return 0; 11 | else 12 | return (coin_change(arr,n,k-arr[n])+coin_change(arr,n-1,k)); 13 | } 14 | 15 | public static void main(String args[])throws IOException{ 16 | BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); 17 | System.out.println("\u000C"); // clears the terminal 18 | System.out.println(" Enter the number of coins (n) : "); 19 | System.out.println(); 20 | int n=Integer.parseInt(br.readLine()); 21 | System.out.println(); 22 | System.out.println(" Enter the value of K : "); 23 | System.out.println(); 24 | int K=Integer.parseInt(br.readLine()); 25 | System.out.println(); 26 | System.out.println(" Enter the worth of each coin : "); 27 | System.out.println(); 28 | int[] a=new int[n]; 29 | int i=0; 30 | for(i=0;i0){ 7 | transfer(n-1,from,temp,to); 8 | System.out.println(" Move disk "+n+" from "+from+" to "+to); 9 | transfer(n-1,temp,to,from); 10 | } 11 | } 12 | 13 | public static void main(String args[])throws IOException{ 14 | BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); 15 | System.out.println("\u000C"); // clears the terminal 16 | System.out.println(" Enter the number of disks : "); 17 | System.out.println(); 18 | int n=Integer.parseInt(br.readLine()); 19 | System.out.println(); 20 | transfer(n,'A','C','B'); 21 | } 22 | } -------------------------------------------------------------------------------- /Algorithms/Recursion/Tower Of Hanoi/readme.md: -------------------------------------------------------------------------------- 1 | # Tower Of Hanoi 2 | 3 | The problem states that there are 3 pegs A, B and C. Initially there are n disks placed on peg A in increasing order of dimension (radius) that is the disk with smallest radius is at the top and the disk with the largest radius is at the bottom. Our task is to move all the disks from peg A (source) to peg C (destination) using peg B (auxiliary peg) and the following 2 rules: 4 | 5 | 1. We can move only one disk at a time. 6 | 2. A smaller disk must always be placed over a larger disk. 7 | 8 | 9 | ## Input Format : 10 | 11 | A single integer denoting the number of disks. 12 | 13 | ## Output Format : 14 | 15 | Display movement of each disk till our goal is achieved. 16 | 17 | 18 | ## Analysis 19 | 20 | Let n be the ummber of disks. 21 | 22 | If n = 1 23 | Move single disk from peg A to peg C and stop. 24 | Else 25 | Move the top (n-1) disks from peg A to peg B using peg C as auxiliary. 26 | 27 | Move remaining disks from peg A to peg C. 28 | 29 | Move (n-1) disks from peg B to peg C using peg A as auxiliary. -------------------------------------------------------------------------------- /Algorithms/Sorting Algorithms/Bubble Sort/Bubble Sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define MAX 1000 4 | void bubble_sort(int arr[MAX], int n); 5 | void swap(int *p, int *q); 6 | int main() 7 | { 8 | int n, *arr, i, j; 9 | cout << "///Insertion Sort///\n\nEnter the number of array elements: "; 10 | cin >> n; 11 | arr = new int[n]; 12 | cout << "Enter the array elements: "; 13 | for(i=0; i> arr[i]; 16 | } 17 | bubble_sort(arr, n); 18 | cout << "The sorted array is:" << endl; 19 | for(i=0; i arr[j+1]) 36 | { 37 | swap(&arr[j], &arr[j+1]); 38 | } 39 | } 40 | } 41 | } 42 | void swap(int *p, int *q) 43 | { 44 | int temp; 45 | temp = *p; 46 | *p = *q; 47 | *q = temp; 48 | } 49 | -------------------------------------------------------------------------------- /Algorithms/Sorting Algorithms/Bubble Sort/Bubble_Sort.java: -------------------------------------------------------------------------------- 1 | import java.io.*; 2 | class Bubble_Sort{ 3 | 4 | public static void main(String args[])throws IOException{ 5 | System.out.println("\u000C"); // clears the terminal 6 | BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); 7 | System.out.println(" Enter the size of the array : "); 8 | int n=Integer.parseInt(br.readLine()); 9 | System.out.println(); 10 | System.out.println(" Enter the elemens of the array : "); 11 | System.out.println(); 12 | int i=0,j=0; 13 | int[] arr=new int[n]; 14 | for(i=0;iarr[j+1]){ 19 | int temp=arr[j]; 20 | arr[j]=arr[j+1]; 21 | arr[j+1]=temp; 22 | } 23 | } 24 | } 25 | System.out.println(); 26 | System.out.println(" The elements of the array after sorting : "); 27 | System.out.println(); 28 | for(i=0;i 2 | #include 3 | using namespace std; 4 | #define MAX 1000 5 | void print(int arr[], int n) 6 | { 7 | for(int i=0; i max) 19 | max = arr[i]; 20 | } 21 | return max; 22 | } 23 | void count_sort(int arr[], int B[], int n) 24 | { 25 | int i, k = max(arr, n); 26 | int C[k+1] = {0}; 27 | for(i=0; i=0; i--) 36 | { 37 | B[C[arr[i]]-1] = arr[i]; 38 | C[arr[i]]-=1; 39 | } 40 | } 41 | int main() 42 | { 43 | int n, *arr, *B, i, j; 44 | cout << "///Count Sort///\n\nEnter the number of array elements: "; 45 | cin >> n; 46 | arr = new int[n]; 47 | B = new int[n]; 48 | cout << "Enter the array elements: "; 49 | for(i=0; i> arr[i]; 52 | } 53 | count_sort(arr, B, n); 54 | cout << "The sorted array is:" << endl; 55 | print(B, n); 56 | delete []arr; 57 | delete []B; 58 | fflush(stdin); 59 | getchar(); 60 | return 0; 61 | } 62 | -------------------------------------------------------------------------------- /Algorithms/Sorting Algorithms/Heap Sort/Heap Sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | void print(int arr[], int n) 5 | { 6 | for(int i=0; i=0; i--) 50 | { 51 | max_heapify(arr, n, i); 52 | } 53 | } 54 | 55 | void heap_sort(int arr[], int n) 56 | { 57 | int i, heap_size = n; 58 | build_max_heap(arr, n); 59 | for(i=n-1; i>0; i--) 60 | { 61 | swap(arr[i], arr[0]); 62 | heap_size--; 63 | max_heapify(arr, heap_size, 0); 64 | } 65 | } 66 | 67 | int main() 68 | { 69 | int i, n, *arr; 70 | cout << "Enter the number of elements of the array: "; 71 | cin >> n; 72 | arr = new int[n]; 73 | cout << "Enter the array elements: " << endl; 74 | for(i=0; i> arr[i]; 78 | } 79 | heap_sort(arr, n); 80 | cout << "The sorted array is:" << endl; 81 | print(arr, n); 82 | return 0; 83 | } 84 | -------------------------------------------------------------------------------- /Algorithms/Sorting Algorithms/Insertion Sort/Insertion Sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #define MAX 1000 4 | void insertion_sort(int arr[MAX], int n); 5 | void swap(int *p, int *q); 6 | int main() 7 | { 8 | int n, *arr, i, j; 9 | cout << "///Insertion Sort///\n\nEnter the number of array elements: "; 10 | cin >> n; 11 | arr = new int[n]; 12 | cout << "Enter the array elements: "; 13 | for(i=0; i> arr[i]; 16 | } 17 | insertion_sort(arr, n); 18 | cout << "The sorted array is:" << endl; 19 | for(i=0; i=0; j--) 35 | { 36 | if(arr[j] > key) 37 | { 38 | swap(&arr[j], &arr[j+1]); 39 | } 40 | } 41 | } 42 | } 43 | void swap(int *p, int *q) 44 | { 45 | int temp; 46 | temp = *p; 47 | *p = *q; 48 | *q = temp; 49 | } 50 | -------------------------------------------------------------------------------- /Algorithms/Sorting Algorithms/Merge Sort/Merge Sort.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | #define MAX 1000 5 | void merge_sort(int arr[MAX], int l, int u); 6 | void combine(int arr[MAX], int l, int u, int m); 7 | int main() 8 | { 9 | int n, *arr, i, j; 10 | cout << "///Merge Sort///\n\nEnter the number of array elements: "; 11 | cin >> n; 12 | arr = new int[n]; 13 | cout << "Enter the array elements: "; 14 | for(i=0; i> arr[i]; 17 | } 18 | merge_sort(arr, 0, n-1); 19 | cout << "The sorted array is:" << endl; 20 | for(i=0; i 2 | using namespace std; 3 | void swap(int *x, int *y) 4 | { 5 | int t = *x; 6 | *x = *y; 7 | *y = t; 8 | } 9 | int partition(int arr[], int l, int u) 10 | { 11 | int pivot = arr[u], i = l-1; 12 | for(int j=l; j> n; 37 | arr = new int[n]; 38 | for(int i=0; i> arr[i]; 41 | } 42 | quick_sort(arr, 0, n-1); 43 | for(int i = 0; i 2 | using namespace std; 3 | #define MAX 1000 4 | void selection_sort(int arr[MAX], int n); 5 | void swap(int *p, int *q); 6 | int main() 7 | { 8 | int n, *arr, i, j; 9 | cout << "///Selection Sort///\n\nEnter the number of array elements: "; 10 | cin >> n; 11 | arr = new int[n]; 12 | cout << "Enter the array elements: "; 13 | for(i=0; i> arr[i]; 16 | } 17 | selection_sort(arr, n); 18 | cout << "The sorted array is:" << endl; 19 | for(i=0; i=0;i--) 21 | System.out.print(a[i]+" "); 22 | } 23 | } -------------------------------------------------------------------------------- /Data Structures/Array/Reverse/Solutions/reverse.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | int main(){ 5 | int n; 6 | std::cin >> n; 7 | std::vector arr(n); 8 | for(int arr_i = 0;arr_i < n;arr_i++){ 9 | std::cin >> arr[arr_i]; 10 | } 11 | 12 | // One-liner ahead! 13 | for(auto it=arr.rbegin(); it!= arr.rend(); it++) std::cout << *it << " "; 14 | 15 | return 0; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /Data Structures/Array/Reverse/Solutions/reverse.py: -------------------------------------------------------------------------------- 1 | #!/bin/python3 2 | 3 | n = int(input()) 4 | arr = input().split() 5 | 6 | print(*arr[::-1], sep=" ") 7 | 8 | -------------------------------------------------------------------------------- /Data Structures/Array/Reverse/readme.md: -------------------------------------------------------------------------------- 1 | # Reverse 2 | 3 | Given an array, `A`, of `n` integers, print each element in reverse order as a single line of space-separated integers. 4 | 5 | 6 | ## Input format 7 | 8 | The first line contains an integer, `n` (the number of integers in `A`). 9 | 10 | The second line contains `n` space separated integers describing `A`. 11 | 12 | ## Output Format 13 | 14 | Print all `n` integers in `A` in reverse order. 15 | 16 | 17 | ## Analysis 18 | 19 | The basic logic is as follows : 20 | - Write each element of input into an array. 21 | - Iterate through the array in reverse, printing each element as you go. 22 | 23 | -------------------------------------------------------------------------------- /Data Structures/Stack/Balanced Brackets/Solutions/Balanced_Brackets.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | //Balanced Bracket C++ implementation 7 | 8 | bool balanced(string s) 9 | { 10 | stack st; 11 | for(int i=0; i> t; 39 | for(int i=0; i> s; 42 | if(balanced(s)) 43 | cout << "YES" << endl; 44 | else 45 | cout << "NO" << endl; 46 | } 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /Data Structures/Stack/Balanced Brackets/Solutions/Balanced_Brackets.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | 3 | public class Balanced_Brackets { 4 | 5 | public static void main(String args[]){ 6 | Scanner ob=new Scanner(System.in); 7 | int i=0,j=0,c=0,flag=0; 8 | Stack s=new Stack(); 9 | String x=ob.next(); 10 | flag=0; 11 | for(i=0;i 2 | using namespace std; 3 | 4 | void print(vector v) 5 | { 6 | for(int i=0; i s; 17 | 18 | cin >> n; 19 | vector arr(n), ans(n); 20 | 21 | for(i=0; i> arr[i]; 24 | } 25 | 26 | ans[0] = 1; 27 | s.push(0); 28 | 29 | for(i=1; i arr[s.top()]) 32 | s.pop(); 33 | ans[i] = s.empty() ? i+1: i-s.top(); 34 | s.push(i); 35 | } 36 | 37 | print(ans); 38 | } 39 | -------------------------------------------------------------------------------- /Data Structures/Stack/Stock and Span/readme.md: -------------------------------------------------------------------------------- 1 | We are given a list of prices of a stock for N number of days. 2 | 3 | We need to find the span for each day. 4 | 5 | Span is defined as number of consecutive days before the given day 6 | where the price of stock was less than or equal to price at given day. 7 | 8 | Input format: 9 | First line contains n, the number of elements in the stock array. 10 | Second line contains the stock array elements. 11 | 12 | Output Format: 13 | A single line containing the elements of the span array. 14 | 15 | For example, 16 | Sample Input: 17 | 7 18 | 100 60 70 65 80 85 19 | 20 | Output: 21 | 1, 1, 2, 1, 4, 5 22 | 23 | Explanation: 24 | For first day span is always 1. 25 | In example we can see that for day 2 at 60, there is no day before it 26 | where price was less than 60. Hence span is 1 again. For day 3, price 27 | at day 2 (60) is less than 70, hence span is 2. Similarly, for day 4 28 | and day 5. Remember days should be consecutive, that why span for day 4 29 | is 1 even though there was a day 2 where price was less than 65. 30 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2017 CodeClub-JU 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Competitive Coding 2 | Solutions of all the problems discussed in the Code Club Sessions. 3 | 4 | 5 | ### Structure 6 | 7 | ``` 8 | CompetitiveCoding 9 | └── Topic 10 | └── Subtopic 11 | └── Problem Name 12 | ├── Problem statement 13 | ├── Solutions (JAVA, Python and C++ solutions) 14 | └── Remarks (If Any) 15 | ``` 16 | --------------------------------------------------------------------------------