From 3ab57622b195cdad004e7ccabe8d500a232b3276 Mon Sep 17 00:00:00 2001 From: sparsh77 Date: Fri, 1 Oct 2021 13:00:40 +0530 Subject: [PATCH 01/33] add selection sort --- .gitignore | 1 + selection_sort.cpp | 40 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 40 insertions(+), 1 deletion(-) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..485dee6 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.idea diff --git a/selection_sort.cpp b/selection_sort.cpp index 8b13789..b6ef618 100644 --- a/selection_sort.cpp +++ b/selection_sort.cpp @@ -1 +1,39 @@ - +#include +using namespace std; +void swapping(int &a, int &b) { //swap the content of a and b + int temp; + temp = a; + a = b; + b = temp; +} +void display(int *array, int size) { + for(int i = 0; i> n; + int arr[n]; //create an array with given number of elements + cout << "Enter elements:" << endl; + for(int i = 0; i> arr[i]; + } + cout << "Array before Sorting: "; + display(arr, n); + selectionSort(arr, n); + cout << "Array after Sorting: "; + display(arr, n); +} From c2370e6e58c1778a4e5e6aa2110761b920617be1 Mon Sep 17 00:00:00 2001 From: vishal0535 <91584533+vishal0535@users.noreply.github.com> Date: Fri, 1 Oct 2021 14:14:52 +0530 Subject: [PATCH 02/33] Create Swap Numbers.cpp --- Swap Numbers.cpp | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 Swap Numbers.cpp diff --git a/Swap Numbers.cpp b/Swap Numbers.cpp new file mode 100644 index 0000000..a956a99 --- /dev/null +++ b/Swap Numbers.cpp @@ -0,0 +1,19 @@ +#include +using namespace std; + +int main() +{ + int a = 5, b = 10, temp; + + cout << "Before swapping." << endl; + cout << "a = " << a << ", b = " << b << endl; + + temp = a; + a = b; + b = temp; + + cout << "\nAfter swapping." << endl; + cout << "a = " << a << ", b = " << b << endl; + + return 0; +} From 836380fe541bbc1e09fa2e94f97ab0ebc23ef4dc Mon Sep 17 00:00:00 2001 From: Sandip Date: Sat, 2 Oct 2021 14:41:07 +0530 Subject: [PATCH 03/33] Add rotate_matrix.cpp --- rotate_matrix.cpp | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 rotate_matrix.cpp diff --git a/rotate_matrix.cpp b/rotate_matrix.cpp new file mode 100644 index 0000000..ae56773 --- /dev/null +++ b/rotate_matrix.cpp @@ -0,0 +1,37 @@ +// You are given n x n 2D matrix representing an image. +// Rotate the image by 90 degrees (clockwise). + +// Input: +// [ +// [1, 2, 3] +// [4, 5, 6] +// [7, 8, 9] +// ] + +// Output: +// [ +// [7, 4, 1] +// [8, 5, 2] +// [9, 6, 3] +// ] + +#include +#include +#include +using namespace std; + +class RotateMatrix +{ +public: + void rotateMatrix(vector> &matrix) + { + int n = matrix.size(); + + for (int i = 0; i < n; i++) + for (int j = 0; j <= i; j++) + swap(matrix[i][j], matrix[j][i]); + + for (int i = 0; i < n; i++) + reverse(matrix[i].begin(), matrix[i].end()); + } +}; \ No newline at end of file From 36b55921d363d89b41a5dda97fa8f323b9154062 Mon Sep 17 00:00:00 2001 From: mr_rdm Date: Sat, 2 Oct 2021 19:36:56 +0530 Subject: [PATCH 04/33] =?UTF-8?q?feat:=20=F0=9F=9A=80Add=20binary=20search?= =?UTF-8?q?=20algorithm?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- binary_search.cpp | 66 ++++++++++++++++++++++++++++++++++++++++++++++ binary_search.exe | Bin 0 -> 99648 bytes 2 files changed, 66 insertions(+) create mode 100644 binary_search.cpp create mode 100644 binary_search.exe diff --git a/binary_search.cpp b/binary_search.cpp new file mode 100644 index 0000000..1d8ab11 --- /dev/null +++ b/binary_search.cpp @@ -0,0 +1,66 @@ +#include +using namespace std; +#define ll long long int +#define endl '\n' +#define MOD 1000000007 +#define fastio() \ + ios_base::sync_with_stdio(false); \ + cin.tie(NULL); \ + cout.tie(NULL); + +int binarySearch(vector &nums, int target) +{ + int start = 0, end = nums.size() - 1; + + while (start <= end) + { + int mid = start + (end - start) / 2; + + if (nums[mid] == target) + { + return mid; + } + else if (nums[mid] < target) + { + start = mid + 1; + } + else + { + end = mid - 1; + } + } + + return -1; +} +int main() +{ + int noOfElements; + cout << "Please enter number of elements : "; + cin >> noOfElements; + vector elements; + + cout << "Please enter the elements one by one" << endl; + for (int i = 0; i < noOfElements; i++) + { + int a; + cin >> a; + elements.push_back(a); + } + sort(elements.begin(), elements.end()); + + int noToFind; + cout << "Please enter the number to search : "; + cin >> noToFind; + + int index = binarySearch(elements, noToFind); + if (index != -1) + { + cout << noToFind << " found in the array" << endl; + } + else + { + cout << noToFind << " is not present" << endl; + } + + return 0; +} \ No newline at end of file diff --git a/binary_search.exe b/binary_search.exe new file mode 100644 index 0000000000000000000000000000000000000000..46c40f58c04e039cbacd116d3b0fd12dbf88452d GIT binary patch literal 99648 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 Date: Sat, 2 Oct 2021 20:12:08 +0530 Subject: [PATCH 05/33] add sliding window maximum --- sliding_window_maximum.cpp | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 sliding_window_maximum.cpp diff --git a/sliding_window_maximum.cpp b/sliding_window_maximum.cpp new file mode 100644 index 0000000..33cf798 --- /dev/null +++ b/sliding_window_maximum.cpp @@ -0,0 +1,25 @@ +class Solution { +public: + vector maxSlidingWindow(vector& nums, int k) { + int n = nums.size(); + if (n == 0 || k == 0) return {}; + + vector v(n-k+1); + deque d; + + for (int i = 0; i < n; ++i) { + while (!d.empty() && d.front() <= i-k) + d.pop_front(); + + while (!d.empty() && nums[d.back()] < nums[i]) + d.pop_back(); + + d.push_back(i); + + if (i >= k-1) + v[i+1-k] = nums[d.front()]; + } + return v; + } + +}; From eef5ca733598acd84b3b7aeec80836a618637404 Mon Sep 17 00:00:00 2001 From: Dhritiman Roy <37190888+droy312@users.noreply.github.com> Date: Mon, 4 Oct 2021 14:25:40 +0530 Subject: [PATCH 06/33] Create README.md --- README.md | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 README.md diff --git a/README.md b/README.md new file mode 100644 index 0000000..b2a6bc6 --- /dev/null +++ b/README.md @@ -0,0 +1,4 @@ +# cpp_code +A repo for hacktoberfest 2021 + +Hacktober participants, please create an issue before submitting a PR. From e9a7e93be9cf7f2aba018cdacb340459a6402a73 Mon Sep 17 00:00:00 2001 From: Supratick2001 <72028007+Supratick2001@users.noreply.github.com> Date: Mon, 4 Oct 2021 14:33:40 +0530 Subject: [PATCH 07/33] Create Merge sort in cpp merge sort code added --- Merge sort in cpp | 69 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 Merge sort in cpp diff --git a/Merge sort in cpp b/Merge sort in cpp new file mode 100644 index 0000000..b806565 --- /dev/null +++ b/Merge sort in cpp @@ -0,0 +1,69 @@ +#include +using namespace std; +void swapping(int &a, int &b) { //swap the content of a and b + int temp; + temp = a; + a = b; + b = temp; +} +void display(int *array, int size) { + for(int i = 0; i> n; + int arr[n]; //create an array with given number of elements + cout << "Enter elements:" << endl; + for(int i = 0; i> arr[i]; + } + cout << "Array before Sorting: "; + display(arr, n); + mergeSort(arr, 0, n-1); //(n-1) for last index + cout << "Array after Sorting: "; + display(arr, n); +} From 02ba18d53fc5765dd3f93b54d3047a64d4a7e46a Mon Sep 17 00:00:00 2001 From: PawanJaiswal08 <82941430+PawanJaiswal08@users.noreply.github.com> Date: Wed, 6 Oct 2021 11:55:45 +0530 Subject: [PATCH 08/33] Added Quick Sort in C++ --- Quick_Sort.cpp | 65 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 Quick_Sort.cpp diff --git a/Quick_Sort.cpp b/Quick_Sort.cpp new file mode 100644 index 0000000..d49e04f --- /dev/null +++ b/Quick_Sort.cpp @@ -0,0 +1,65 @@ +#include +using namespace std; + +int partition(int *a, int start, int end){ + + int pivot=a[end]; + //P-index indicates the pivot value index + + int P_index=start; + int i,t; //t is temporary variable + + //Here We will check if array value is less than pivot + //Then we will place it at left side by swapping + + for(i=start;i>n; + + int a[n]; + cout<<"Enter the array elements :\n"; + for(int i=0;i>a[i]; + } + + Quicksort(a,0,n-1); + + cout<<"After Quick Sort the array is :\n"; + for(int i=0;i Date: Wed, 6 Oct 2021 20:34:29 +0530 Subject: [PATCH 09/33] Added Insertion Sort in C++ --- Insertion_Sort.cpp | 61 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 Insertion_Sort.cpp diff --git a/Insertion_Sort.cpp b/Insertion_Sort.cpp new file mode 100644 index 0000000..bf8c6ed --- /dev/null +++ b/Insertion_Sort.cpp @@ -0,0 +1,61 @@ + +// This is a program on the insertion sort. It's a sorting algorithm. +// -----------Time complexity of the insertion sort algorithm---------- +// 1. Best complexity: n +// 2. Average complexity: n^2 +// 3. Worst complexity: n^2 +// -----------Space complexity of the insertion sort algorithm--------- +// 1.Space complexity: 1 + + +#include +using namespace std; + +// function to print the elements of the array +void display(int arr[], int n) { + + for(int i=0;i= 0) { + arr[j + 1] = arr[j]; + --j; + } + arr[j + 1] = temp; + } +} + +int main() { + + int n; + cout<<"Enter number of elements : "; + cin>>n; + + int arr[n]; + cout<<"Enter the array elements :\n"; + for(int i=0;i>arr[i]; + } + + cout<<"\nBefore Sort the array is :\n"; + display(arr,n); + + insertionSort(arr, n); + + cout<<"\nAfter Insertion Sort the array is :\n"; + display(arr,n); + + return 0; + +} From be31e545c7ba3e40a087f51f4a9e79c67618432d Mon Sep 17 00:00:00 2001 From: Ben C Date: Wed, 6 Oct 2021 19:52:34 -0700 Subject: [PATCH 10/33] Implement Fizz Buzz in C++ --- fizz_buzz.cpp | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 fizz_buzz.cpp diff --git a/fizz_buzz.cpp b/fizz_buzz.cpp new file mode 100644 index 0000000..6c5fbde --- /dev/null +++ b/fizz_buzz.cpp @@ -0,0 +1,21 @@ +#include + +using namespace std; + +int main() { + + // Begin our main loop of 1-50 + for (int i = 1; i <= 50; i++) { + + string output = ""; + + if (i % 3 == 0) output += "Fizz"; // If our current number is a multiple of 3, add "Fizz to the output" + if (i % 5 == 0) output += "Buzz"; // If our current number is a multiple of 5, add "Buzz to the output" + + if (output == "") output = to_string(i); // If the output is empty (our number isn't a multiple of 3 or 5), we simply set it to our number + + cout << output << endl; // Show the user the output + + } + +} From a3cd49513a1efd3eeaf4ede4affe32667d3f8f1d Mon Sep 17 00:00:00 2001 From: Siddhant Date: Thu, 7 Oct 2021 09:29:34 +0530 Subject: [PATCH 11/33] Doubly Linked List Traversal.cpp --- Doubly Linked List Traversal.cpp | 70 ++++++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 Doubly Linked List Traversal.cpp diff --git a/Doubly Linked List Traversal.cpp b/Doubly Linked List Traversal.cpp new file mode 100644 index 0000000..2376808 --- /dev/null +++ b/Doubly Linked List Traversal.cpp @@ -0,0 +1,70 @@ +#include +#include + +struct Node{ + int data; + struct Node *prev; + struct Node *next; +}; + +void DoublylinkedListTraversal(struct Node *ptr){ + while(ptr != NULL){ + printf("Elements: %d\n",ptr->data); + ptr=ptr->next; +} +}/* +void DoublylinkedListTraversal(struct Node *head) +{ + struct Node * ptr = head; + while (ptr->next != NULL) + { + printf("Elements: %d\n",ptr->data); + ptr = ptr->next; + } + printf("Elements: %d\n",ptr->data); + printf("\n"); + while (ptr != NULL) + { + printf("Elements: %d\n",ptr->data); + ptr = ptr->prev; + } +} +*/ +int main(){ + struct Node *head; + struct Node *second; + struct Node *third; + struct Node *fourth; + + //Allocate memory to Nodes in heap + head=(struct Node*)malloc(sizeof(struct Node)); + second=(struct Node*)malloc(sizeof(struct Node)); + third=(struct Node*)malloc(sizeof(struct Node)); + fourth=(struct Node*)malloc(sizeof(struct Node)); + + //Link first to second as well prev to NULL + head->data=23; + head->prev=NULL; + head->next=second; + + //Link second to third as well prev to first + second->data=34; + second->prev=head; + second->next=third; + + //Link third to fourth as well prev to second + third->data=56; + third->prev=second; + third->next=fourth; + + //Link fourth to NULL as well prev to third + fourth->data=52; + fourth->prev=third; + fourth->next=NULL; + + DoublylinkedListTraversal(head); + //printf("\n"); + //DoublylinkedListTraversal(fourth); + + return 0; +} From eaeca2516f2d0c7bd4e8d7609560f51fa0ee4391 Mon Sep 17 00:00:00 2001 From: kamalrt11 <54072216+kamalrt11@users.noreply.github.com> Date: Thu, 7 Oct 2021 10:32:14 +0530 Subject: [PATCH 12/33] Create Insertion Sort --- insertion_sort.cpp | 80 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 80 insertions(+) create mode 100644 insertion_sort.cpp diff --git a/insertion_sort.cpp b/insertion_sort.cpp new file mode 100644 index 0000000..37a691a --- /dev/null +++ b/insertion_sort.cpp @@ -0,0 +1,80 @@ +#include +#include +using namespace std; +#define int long long + +// bool compareQ(pair a, pair b) +// { +// if (a.first < b.first) +// return (a.second > b.second); + + +// return false; +// // } +// int N = 1e9 + 2; +void insertion_sort(int a[], int n) +{ + for (int i = 0; i < n; i++) + { + int key = a[i]; + int j = i - 1; + while (j >= 0 && a[j] > key) + { + a[j + 1] = a[j]; + j--; + } + a[j + 1] = key; + + } +} + +void solve() +{ + + int n; + cin >> n; + int a[n]; + for (int i = 0; i < n; i++) + { + cin >> a[i]; + } + insertion_sort(a, n); + + for (int i = 0; i < n; i++) + { + cout << a[i] << " "; + } +} + + + + +int32_t main() +{ + ios_base::sync_with_stdio(false); + cin.tie(NULL); + +#ifndef ONLINE_JUDGE + freopen("input.txt", "r", stdin); + freopen("error.txt", "w", stderr); + freopen("output.txt", "w", stdout); +#endif + + long long t = 1; + + // cin >> t; + while (t--) + { + + solve(); + } + + + +} + + + + + + From 392da9bcfbaac098f4cf11e8aa0960e6fd76b94b Mon Sep 17 00:00:00 2001 From: Kshitiz Raj Date: Thu, 7 Oct 2021 23:39:25 +0530 Subject: [PATCH 13/33] Added DNF Sort Algorithm --- waveSortArrays.cpp | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 waveSortArrays.cpp diff --git a/waveSortArrays.cpp b/waveSortArrays.cpp new file mode 100644 index 0000000..c8567c1 --- /dev/null +++ b/waveSortArrays.cpp @@ -0,0 +1,29 @@ +#include +using namespace std; + +void swap(int arr[],int i,int j){ + int temp=arr[i]; + arr[i]=arr[j]; + arr[j]=temp; +} + +void waveSort(int arr[],int n){ + for(int i=1;iarr[i-1]){ + swap(arr,i,i-1); + } + if(arr[i]>arr[i+1] && i Date: Thu, 7 Oct 2021 23:42:02 +0530 Subject: [PATCH 14/33] Removed the last commited file --- waveSortArrays.cpp | 29 ----------------------------- 1 file changed, 29 deletions(-) delete mode 100644 waveSortArrays.cpp diff --git a/waveSortArrays.cpp b/waveSortArrays.cpp deleted file mode 100644 index c8567c1..0000000 --- a/waveSortArrays.cpp +++ /dev/null @@ -1,29 +0,0 @@ -#include -using namespace std; - -void swap(int arr[],int i,int j){ - int temp=arr[i]; - arr[i]=arr[j]; - arr[j]=temp; -} - -void waveSort(int arr[],int n){ - for(int i=1;iarr[i-1]){ - swap(arr,i,i-1); - } - if(arr[i]>arr[i+1] && i Date: Thu, 7 Oct 2021 23:43:19 +0530 Subject: [PATCH 15/33] Added Wave Sort Algorithm --- waveSortArrays.cpp | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 waveSortArrays.cpp diff --git a/waveSortArrays.cpp b/waveSortArrays.cpp new file mode 100644 index 0000000..c8567c1 --- /dev/null +++ b/waveSortArrays.cpp @@ -0,0 +1,29 @@ +#include +using namespace std; + +void swap(int arr[],int i,int j){ + int temp=arr[i]; + arr[i]=arr[j]; + arr[j]=temp; +} + +void waveSort(int arr[],int n){ + for(int i=1;iarr[i-1]){ + swap(arr,i,i-1); + } + if(arr[i]>arr[i+1] && i Date: Thu, 7 Oct 2021 23:45:46 +0530 Subject: [PATCH 16/33] Added DNF Sort Algorithm --- dnfSortArrays.cpp | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 dnfSortArrays.cpp diff --git a/dnfSortArrays.cpp b/dnfSortArrays.cpp new file mode 100644 index 0000000..d496a0c --- /dev/null +++ b/dnfSortArrays.cpp @@ -0,0 +1,39 @@ +#include +using namespace std; + +void swap(int arr[], int i, int j){ + int temp=arr[i]; + arr[i]=arr[j]; + arr[j]=temp; +} + +void dnfSort(int arr[], int n){ + int low=0; + int mid=0; + int high=n-1; + + while(mid<=high){ + if(arr[mid]==0){ + swap(arr,low,mid); + low++; + mid++; + } + else if(arr[mid]==1){ + mid++; + } + else{ + swap(arr,mid,high); + high--; + } + } +} + +int main(){ + int arr[]={1,0,2,1,0,1,2,1,2}; + dnfSort(arr,9); + + for(int i=0;i<9;i++){ + cout< Date: Fri, 8 Oct 2021 09:16:16 +0530 Subject: [PATCH 17/33] Added Sum of Subarray Program --- sumOfSubArray.cpp | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 sumOfSubArray.cpp diff --git a/sumOfSubArray.cpp b/sumOfSubArray.cpp new file mode 100644 index 0000000..6d4b990 --- /dev/null +++ b/sumOfSubArray.cpp @@ -0,0 +1,23 @@ +#include +using namespace std; + +int main(){ + int n; + cin>>n; + + int arr[n]; + for(int i=0;i>arr[i]; + } + + int sumfinal=0; + for(int i=0;i Date: Fri, 8 Oct 2021 15:14:53 +0530 Subject: [PATCH 18/33] Added Insertion Sort using Recursion --- Recursive_Insertion_Sort.cpp | 61 ++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+) create mode 100644 Recursive_Insertion_Sort.cpp diff --git a/Recursive_Insertion_Sort.cpp b/Recursive_Insertion_Sort.cpp new file mode 100644 index 0000000..ff5fe7f --- /dev/null +++ b/Recursive_Insertion_Sort.cpp @@ -0,0 +1,61 @@ +// Recursive C++ program for insertion sort + +// TIME COMPLEXITY +// 1. Best complexity: n +// 2. Average complexity: n^2 +// 3. Worst complexity: n^2 + +#include +using namespace std; + +// Recursive function to sort an array using +// insertion sort +void insertionSortRecursive(int arr[], int n) +{ + // Base case + if (n <= 1) + return; + + // Sort first n-1 elements + insertionSortRecursive( arr, n-1 ); + + int last = arr[n-1]; + int j = n-2; + + while (j >= 0 && arr[j] > last) + { + arr[j+1] = arr[j]; + j--; + } + arr[j+1] = last; +} + +void display(int arr[], int n) +{ + for (int i=0; i < n; i++) + cout << arr[i] <<" "; +} + +int main() +{ + int n; + cout<<"Enter number of elements : "; + cin>>n; + + int arr[n]; + cout<<"Enter the array elements :\n"; + for(int i=0;i>arr[i]; + } + + cout<<"\nBefore Sort the array is :\n"; + display(arr,n); + + insertionSortRecursive(arr, n); + + cout<<"\nAfter Insertion Sort the array is :\n"; + display(arr, n); + + return 0; +} From 3c5c0796e79df2587fb95f16d392591c86f488ce Mon Sep 17 00:00:00 2001 From: Jayesh Kumar Shaw <75195156+i-jayesh@users.noreply.github.com> Date: Sat, 9 Oct 2021 13:29:31 +0530 Subject: [PATCH 19/33] Floyd's Algorithm --- ...oval_of_Loop_in_LL_(Floyd's_Algorithm).cpp | 115 ++++++++++++++++++ 1 file changed, 115 insertions(+) create mode 100644 Detection&Removal_of_Loop_in_LL_(Floyd's_Algorithm).cpp diff --git a/Detection&Removal_of_Loop_in_LL_(Floyd's_Algorithm).cpp b/Detection&Removal_of_Loop_in_LL_(Floyd's_Algorithm).cpp new file mode 100644 index 0000000..d57487b --- /dev/null +++ b/Detection&Removal_of_Loop_in_LL_(Floyd's_Algorithm).cpp @@ -0,0 +1,115 @@ +#include +using namespace std; + +/* Link list node */ +struct Node { + int data; + struct Node* next; +}; + +/* Function to remove loop. */ +void removeLoop(struct Node*, struct Node*); + +/* This function detects and removes loop in the list +If loop was there in the list then it returns 1, +otherwise returns 0 */ +int detectAndRemoveLoop(struct Node* list) +{ + struct Node *slow_p = list, *fast_p = list; + + // Iterate and find if loop exists or not + while (slow_p && fast_p && fast_p->next) { + slow_p = slow_p->next; + fast_p = fast_p->next->next; + + /* If slow_p and fast_p meet at some point then there + is a loop */ + if (slow_p == fast_p) { + removeLoop(slow_p, list); + + /* Return 1 to indicate that loop is found */ + return 1; + } + } + + /* Return 0 to indicate that there is no loop*/ + return 0; +} + + +/* Function to remove loop. +loop_node --> Pointer to one of the loop nodes +head --> Pointer to the start node of the linked list */ +void removeLoop(struct Node* loop_node, struct Node* head) +{ + struct Node* ptr1 = loop_node; + struct Node* ptr2 = loop_node; + + // Count the number of nodes in loop + unsigned int k = 1, i; + while (ptr1->next != ptr2) { + ptr1 = ptr1->next; + k++; + } + + // Fix one pointer to head + ptr1 = head; + + // And the other pointer to k nodes after head + ptr2 = head; + for (i = 0; i < k; i++) + ptr2 = ptr2->next; + + /* Move both pointers at the same pace, + they will meet at loop starting node */ + while (ptr2 != ptr1) { + ptr1 = ptr1->next; + ptr2 = ptr2->next; + } + + // Get pointer to the last node + while (ptr2->next != ptr1) + ptr2 = ptr2->next; + + /* Set the next node of the loop ending node + to fix the loop */ + ptr2->next = NULL; +} + +/* Function to print linked list */ +void printList(struct Node* node) +{ + // Print the list after loop removal + while (node != NULL) { + cout << node->data << " "; + node = node->next; + } +} + +struct Node* newNode(int key) +{ + struct Node* temp = new Node(); + temp->data = key; + temp->next = NULL; + return temp; +} + +// Driver Code +int main() +{ + struct Node* head = newNode(50); + head->next = newNode(20); + head->next->next = newNode(15); + head->next->next->next = newNode(4); + head->next->next->next->next = newNode(10); + + /* Create a loop for testing */ + head->next->next->next->next->next = head->next->next; + + detectAndRemoveLoop(head); + + cout << "Linked List after removing loop \n"; + printList(head); + return 0; +} + From 1648fb096bc4df8b0fcd9a580c7886e57b419ddd Mon Sep 17 00:00:00 2001 From: Sandeshjain13 <91777977+Sandeshjain13@users.noreply.github.com> Date: Sat, 9 Oct 2021 16:37:19 +0530 Subject: [PATCH 20/33] Create valid_sudoku.cpp --- valid_sudoku.cpp | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 valid_sudoku.cpp diff --git a/valid_sudoku.cpp b/valid_sudoku.cpp new file mode 100644 index 0000000..031e1e7 --- /dev/null +++ b/valid_sudoku.cpp @@ -0,0 +1,23 @@ +class Solution { +public: + bool isValidSudoku(vector>& b) { + vector> row(9); + vector> col(9); + vector> box(9); + + for(int i=0 ; i<9 ; i ++){ + for(int j=0 ; j<9 ; j++){ + char val=b[i][j]; + if(val=='.')continue; + if(row[i].find(val)!=row[i].end())return false; + row[i].insert(val); + if(col[j].find(val)!=col[j].end())return false; + col[j].insert(val); + int id=(i/3)*3+j/3; + if(box[id].find(val)!=box[id].end())return false; + box[id].insert(val); + } + } + return true; + } +}; From c6c42a25769078018672479d053d667df403d47a Mon Sep 17 00:00:00 2001 From: Bhojraj Bharambe <66865003+Bhojraj9022@users.noreply.github.com> Date: Sun, 10 Oct 2021 14:32:54 +0530 Subject: [PATCH 21/33] Added Solution for Tug Of War Problem in C++ --- tog of war | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 tog of war diff --git a/tog of war b/tog of war new file mode 100644 index 0000000..e8ec02f --- /dev/null +++ b/tog of war @@ -0,0 +1,2 @@ + +/*# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["style.css"],"names":[],"mappings":"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","file":"style.css","sourcesContent":["html{line-height:1.15;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%}body{margin:0}article,aside,footer,header,nav,section{display:block}h1{font-size:2em;margin:0.67em 0}figcaption,figure,main{display:block}figure{margin:1em 40px}hr{box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace, monospace;font-size:1em}a{background-color:transparent;-webkit-text-decoration-skip:objects}abbr[title]{border-bottom:none;text-decoration:underline;text-decoration:underline dotted}b,strong{font-weight:inherit}b,strong{font-weight:bolder}code,kbd,samp{font-family:monospace, monospace;font-size:1em}dfn{font-style:italic}mark{background-color:#ff0;color:#000}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-0.25em}sup{top:-0.5em}audio,video{display:inline-block}audio:not([controls]){display:none;height:0}img{border-style:none}svg:not(:root){overflow:hidden}button,input,optgroup,select,textarea{font-family:sans-serif;font-size:100%;line-height:1.15;margin:0}button,input{overflow:visible}button,select{text-transform:none}button,html [type=\"button\"],[type=\"reset\"],[type=\"submit\"]{-webkit-appearance:button}button::-moz-focus-inner,[type=\"button\"]::-moz-focus-inner,[type=\"reset\"]::-moz-focus-inner,[type=\"submit\"]::-moz-focus-inner{border-style:none;padding:0}button:-moz-focusring,[type=\"button\"]:-moz-focusring,[type=\"reset\"]:-moz-focusring,[type=\"submit\"]:-moz-focusring{outline:1px dotted ButtonText}fieldset{padding:0.35em 0.75em 0.625em}legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}progress{display:inline-block;vertical-align:baseline}textarea{overflow:auto}[type=\"checkbox\"],[type=\"radio\"]{box-sizing:border-box;padding:0}[type=\"number\"]::-webkit-inner-spin-button,[type=\"number\"]::-webkit-outer-spin-button{height:auto}[type=\"search\"]{-webkit-appearance:textfield;outline-offset:-2px}[type=\"search\"]::-webkit-search-cancel-button,[type=\"search\"]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}details,menu{display:block}summary{display:list-item}canvas{display:inline-block}template{display:none}[hidden]{display:none}html{box-sizing:border-box}*,*:before,*:after{box-sizing:inherit}body{background:#fff;-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased}hr{border:0;display:block;height:1px;background:#E4E8EE;margin-top:24px;margin-bottom:24px}ul,ol{margin-top:0;margin-bottom:24px;padding-left:24px}ul{list-style:disc}ol{list-style:decimal}li>ul,li>ol{margin-bottom:0}dl{margin-top:0;margin-bottom:24px}dt{font-weight:600}dd{margin-left:24px;margin-bottom:24px}img{height:auto;max-width:100%;vertical-align:middle}figure{margin:24px 0}figcaption{font-size:16px;line-height:24px;padding:8px 0}img,svg{display:block}table{border-collapse:collapse;margin-bottom:24px;width:100%}tr{border-bottom:1px solid #E4E8EE}th{text-align:left}th,td{padding:10px 16px}th:first-child,td:first-child{padding-left:0}th:last-child,td:last-child{padding-right:0}html{font-size:20px;line-height:30px}body{color:#6B7A90;font-size:1rem}body,button,input,select,textarea{font-family:\"Heebo\", sans-serif}a{color:#4234F8;text-decoration:none}a:hover,a:active{outline:0;text-decoration:underline}h1,h2,h3,h4,h5,h6,.h1,.h2,.h3,.h4,.h5,.h6{clear:both;color:#161E2A;font-family:\"Oxygen\", sans-serif;font-weight:600}h1,.h1{font-size:38px;line-height:48px;letter-spacing:0px}@media (min-width: 641px){h1,.h1{font-size:44px;line-height:54px;letter-spacing:0px}}h2,.h2{font-size:32px;line-height:42px;letter-spacing:0px}@media (min-width: 641px){h2,.h2{font-size:38px;line-height:48px;letter-spacing:0px}}h3,.h3,blockquote{font-size:28px;line-height:34px;letter-spacing:0px}@media (min-width: 641px){h3,.h3,blockquote{font-size:32px;line-height:42px;letter-spacing:0px}}h4,.h4{font-size:28px;line-height:34px;letter-spacing:0px}h5,.h5,h6,.h6{font-size:20px;line-height:30px;letter-spacing:-0.1px}@media (max-width: 640px){.h1-mobile{font-size:38px;line-height:48px;letter-spacing:0px}.h2-mobile{font-size:32px;line-height:42px;letter-spacing:0px}.h3-mobile{font-size:28px;line-height:34px;letter-spacing:0px}.h4-mobile{font-size:28px;line-height:34px;letter-spacing:0px}.h5-mobile,.h6-mobile{font-size:20px;line-height:30px;letter-spacing:-0.1px}}.text-light{color:#606483}.text-light a{color:#606483}.text-light h1,.text-light h2,.text-light h3,.text-light h4,.text-light h5,.text-light h6,.text-light .h1,.text-light .h2,.text-light .h3,.text-light .h4,.text-light .h5,.text-light .h6{color:#fff !important}.text-sm{font-size:18px;line-height:27px;letter-spacing:-0.1px}.text-xs{font-size:16px;line-height:24px;letter-spacing:-0.1px}h1,h2,.h1,.h2{margin-top:48px;margin-bottom:16px}h3,.h3{margin-top:36px;margin-bottom:12px}h4,h5,h6,.h4,.h5,.h6{margin-top:24px;margin-bottom:4px}p{margin-top:0;margin-bottom:24px}dfn,cite,em,i{font-style:italic}blockquote{color:#6B7A90;font-style:italic;margin-top:24px;margin-bottom:24px;margin-left:24px}blockquote::before{content:\"\\201C\"}blockquote::after{content:\"\\201D\"}blockquote p{display:inline}address{color:#6B7A90;border-width:1px 0;border-style:solid;border-color:#E4E8EE;padding:24px 0;margin:0 0 24px}pre,pre h1,pre h2,pre h3,pre h4,pre h5,pre h6,pre .h1,pre .h2,pre .h3,pre .h4,pre .h5,pre .h6{font-family:\"Courier 10 Pitch\", Courier, monospace}pre,code,kbd,tt,var{background:#F3F4FF}pre{font-size:16px;line-height:24px;margin-bottom:1.6em;max-width:100%;overflow:auto;padding:24px;margin-top:24px;margin-bottom:24px}code,kbd,tt,var{font-family:Monaco, Consolas, \"Andale Mono\", \"DejaVu Sans Mono\", monospace;font-size:16px;padding:2px 4px}abbr,acronym{cursor:help}mark,ins{text-decoration:none}small{font-size:18px;line-height:27px;letter-spacing:-0.1px}b,strong{font-weight:600}button,input,select,textarea,label{font-size:20px;line-height:30px}.container,.container-sm{width:100%;margin:0 auto;padding-left:16px;padding-right:16px}@media (min-width: 481px){.container,.container-sm{padding-left:24px;padding-right:24px}}.container{max-width:1128px}.container-sm{max-width:848px}.container .container-sm{max-width:800px;padding-left:0;padding-right:0}.screen-reader-text{clip:rect(1px, 1px, 1px, 1px);position:absolute !important;height:1px;width:1px;overflow:hidden;word-wrap:normal !important}.screen-reader-text:focus{border-radius:2px;box-shadow:0 0 2px 2px rgba(0,0,0,0.6);clip:auto !important;display:block;font-size:14px;letter-spacing:0px;font-weight:600;line-height:16px;text-decoration:none;text-transform:uppercase;background-color:#fff;color:#4234F8 !important;border:none;height:auto;left:8px;padding:16px 40px;top:8px;width:auto;z-index:100000}.list-reset{list-style:none;padding:0}.text-left{text-align:left}.text-center{text-align:center}.text-right{text-align:right}.text-primary{color:#4234F8}.text-secondary{color:#FF6C50}.has-top-divider{position:relative}.has-top-divider::before{content:'';position:absolute;top:0;left:0;width:100%;display:block;height:1px;background:#E4E8EE}.has-bottom-divider{position:relative}.has-bottom-divider::after{content:'';position:absolute;bottom:0;left:0;width:100%;display:block;height:1px;background:#E4E8EE}.m-0{margin:0}.mt-0{margin-top:0}.mr-0{margin-right:0}.mb-0{margin-bottom:0}.ml-0{margin-left:0}.m-8{margin:8px}.mt-8{margin-top:8px}.mr-8{margin-right:8px}.mb-8{margin-bottom:8px}.ml-8{margin-left:8px}.m-16{margin:16px}.mt-16{margin-top:16px}.mr-16{margin-right:16px}.mb-16{margin-bottom:16px}.ml-16{margin-left:16px}.m-24{margin:24px}.mt-24{margin-top:24px}.mr-24{margin-right:24px}.mb-24{margin-bottom:24px}.ml-24{margin-left:24px}.m-32{margin:32px}.mt-32{margin-top:32px}.mr-32{margin-right:32px}.mb-32{margin-bottom:32px}.ml-32{margin-left:32px}.m-40{margin:40px}.mt-40{margin-top:40px}.mr-40{margin-right:40px}.mb-40{margin-bottom:40px}.ml-40{margin-left:40px}.m-48{margin:48px}.mt-48{margin-top:48px}.mr-48{margin-right:48px}.mb-48{margin-bottom:48px}.ml-48{margin-left:48px}.m-56{margin:56px}.mt-56{margin-top:56px}.mr-56{margin-right:56px}.mb-56{margin-bottom:56px}.ml-56{margin-left:56px}.m-64{margin:64px}.mt-64{margin-top:64px}.mr-64{margin-right:64px}.mb-64{margin-bottom:64px}.ml-64{margin-left:64px}.p-0{padding:0}.pt-0{padding-top:0}.pr-0{padding-right:0}.pb-0{padding-bottom:0}.pl-0{padding-left:0}.p-8{padding:8px}.pt-8{padding-top:8px}.pr-8{padding-right:8px}.pb-8{padding-bottom:8px}.pl-8{padding-left:8px}.p-16{padding:16px}.pt-16{padding-top:16px}.pr-16{padding-right:16px}.pb-16{padding-bottom:16px}.pl-16{padding-left:16px}.p-24{padding:24px}.pt-24{padding-top:24px}.pr-24{padding-right:24px}.pb-24{padding-bottom:24px}.pl-24{padding-left:24px}.p-32{padding:32px}.pt-32{padding-top:32px}.pr-32{padding-right:32px}.pb-32{padding-bottom:32px}.pl-32{padding-left:32px}.p-40{padding:40px}.pt-40{padding-top:40px}.pr-40{padding-right:40px}.pb-40{padding-bottom:40px}.pl-40{padding-left:40px}.p-48{padding:48px}.pt-48{padding-top:48px}.pr-48{padding-right:48px}.pb-48{padding-bottom:48px}.pl-48{padding-left:48px}.p-56{padding:56px}.pt-56{padding-top:56px}.pr-56{padding-right:56px}.pb-56{padding-bottom:56px}.pl-56{padding-left:56px}.p-64{padding:64px}.pt-64{padding-top:64px}.pr-64{padding-right:64px}.pb-64{padding-bottom:64px}.pl-64{padding-left:64px}.sr .has-animations .is-revealing{visibility:hidden}.button{display:inline-flex;font-size:14px;letter-spacing:0px;font-weight:700;line-height:16px;text-decoration:none !important;text-transform:uppercase;background-color:#fff;background:#fff;color:#4234F8 !important;border:none;border-radius:2px;cursor:pointer;justify-content:center;padding:16px 40px;height:48px;text-align:center;white-space:nowrap}.button:active{outline:0}.button::before{border-radius:2px}.button-shadow{position:relative}.button-shadow::before{content:'';position:absolute;top:0;right:0;bottom:0;left:0;box-shadow:0 8px 16px rgba(22,30,42,0.12);mix-blend-mode:multiply;transition:box-shadow .15s ease}.button-shadow:hover::before{box-shadow:0 8px 16px rgba(22,30,42,0.16)}.button-sm{padding:8px 24px;height:32px}.button-sm.button-shadow::before{box-shadow:0 4px 16px rgba(22,30,42,0.12)}.button-sm.button-shadow:hover::before{box-shadow:0 4px 16px rgba(22,30,42,0.16)}.button-primary,.button-secondary{color:#fff !important;transition:background .15s ease}.button-primary{background:#4234F8}.button-primary:hover{background:#4b3ef8}.button-primary.button-shadow::before{box-shadow:0 8px 16px rgba(66,52,248,0.24)}.button-primary.button-shadow:hover::before{box-shadow:0 8px 16px rgba(66,52,248,0.32)}.button-primary .button-sm.button-shadow::before{box-shadow:0 4px 16px rgba(66,52,248,0.24)}.button-primary .button-sm.button-shadow:hover::before{box-shadow:0 4px 16px rgba(66,52,248,0.32)}.button-secondary{background:#FF6C50}.button-secondary:hover{background:#ff795f}.button-secondary.button-shadow::before{box-shadow:0 8px 16px rgba(255,108,80,0.24)}.button-secondary.button-shadow:hover::before{box-shadow:0 8px 16px rgba(255,108,80,0.32)}.button-secondary .button-sm.button-shadow::before{box-shadow:0 4px 16px rgba(255,108,80,0.24)}.button-secondary .button-sm.button-shadow:hover::before{box-shadow:0 4px 16px rgba(255,108,80,0.32)}.button-block{display:flex;width:100%}@media (max-width: 640px){.button-wide-mobile{width:100%;max-width:280px}}.site-header{padding:24px 0;position:absolute;top:0;left:0;width:100%;z-index:1}.site-header-inner{position:relative;display:flex;justify-content:space-between;align-items:center}.header-links{display:inline-flex}.header-links li{display:inline-flex}.header-links a:not(.button){font-size:16px;line-height:24px;letter-spacing:-0.1px;font-weight:600;color:#606483;text-transform:uppercase;text-decoration:none;line-height:16px;padding:8px 24px}.header-links a:not(.button):hover,.header-links a:not(.button):active{color:#fff}.hero{position:relative;padding-top:128px;padding-bottom:88px;z-index:0}.hero .hero-bg{position:absolute;top:0;bottom:42%;left:0;right:0;background:#0B0D19;z-index:-2}.hero .hero-particles-container{position:absolute;top:0;bottom:42%;left:0;right:0}.hero::before,.hero::after{content:'';position:absolute;left:calc(50% - 360px);width:720px;background-repeat:no-repeat}.hero::before{top:0;height:159px;background-image:url(\"../images/hero-bg-top.svg\");background-size:720px 159px}.hero::after{bottom:42%;height:173px;background-image:url(\"../images/hero-bg-bottom.svg\");background-size:720px 173px}.hero-inner{position:relative;z-index:1}.hero-copy{position:relative;margin-bottom:48px}@media (min-width: 641px){.hero{padding-top:160px;padding-bottom:128px}.hero::before,.hero::after{left:calc(50% - 720px);width:1440px}.hero::before{height:318px;background-size:1440px 318px}.hero::after{height:347px;background-size:1440px 347px}.hero-copy{margin-bottom:88px}.hero-paragraph{padding-left:72px;padding-right:72px}}.has-animations .hero .hero-bg,.has-animations .hero::before,.has-animations .hero::after,.has-animations .hero-particles-container,.has-animations .site-header,.has-animations .hero-title,.has-animations .hero-paragraph,.has-animations .hero-cta,.has-animations .hero .mockup-bg,.has-animations .hero .device-mockup{opacity:0}.has-animations.is-loaded .hero .hero-bg{animation:heroBg 0.6s cubic-bezier(0.215, 0.61, 0.355, 1) forwards}.has-animations.is-loaded .hero::before,.has-animations.is-loaded .hero::after{animation:heroFadeIn .6s ease forwards .45s}.has-animations.is-loaded .site-header,.has-animations.is-loaded .hero-particles-container,.has-animations.is-loaded .hero .mockup-bg{animation:heroFadeIn .6s ease forwards .45s}.has-animations.is-loaded .hero-title{animation:heroContent 0.6s cubic-bezier(0.215, 0.61, 0.355, 1) forwards 0.15s}.has-animations.is-loaded .hero-paragraph{animation:heroContent 0.6s cubic-bezier(0.215, 0.61, 0.355, 1) forwards 0.3s}.has-animations.is-loaded .hero-cta{animation:heroContent 0.6s cubic-bezier(0.215, 0.61, 0.355, 1) forwards 0.45s}.has-animations.is-loaded .hero .device-mockup{animation:heroMockup .6s ease forwards .6s}@keyframes heroBg{from{transform:scaleY(0) scaleX(1.2) skewY(30deg);opacity:1}to{transform:scaleY(1) scaleX(1) skewY(0);opacity:1}}@keyframes heroContent{from{transform:translateY(40px) skewY(2deg);opacity:0}to{transform:translateY(0) skewY(0);opacity:1}}@keyframes heroMockup{from{transform:translateY(80px);opacity:0}to{transform:translateY(0);opacity:1}}@keyframes heroFadeIn{from{opacity:0}to{opacity:1}}.mockup-container{position:relative}.mockup-bg{pointer-events:none}.mockup-bg img,.mockup-bg svg{position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);width:auto !important;height:auto;max-width:300% !important}.device-mockup{position:relative;width:350px;height:auto;margin:0 auto;z-index:1}.has-animations .features-extended{opacity:0}.has-animations.is-loaded .features-extended{opacity:1}.features-extended-header{margin-bottom:32px}.features-extended-wrap{display:flex;flex-wrap:wrap;margin-top:-24px}.features-extended-wrap:last-of-type{margin-bottom:-24px}.features-extended-wrap:not(:last-of-type){margin-bottom:24px}.feature-extended{padding:24px 0}.feature-extended-image{position:relative;margin-bottom:32px}.feature-extended-image img,.feature-extended-image svg{width:100%;max-width:296px;height:auto;margin-left:auto;margin-right:auto;overflow:visible}.feature-extended-body{text-align:center}@media (min-width: 641px){.features-extended .container{max-width:912px}.features-extended .section-inner{padding-bottom:128px}.features-extended .section-paragraph{padding-left:72px;padding-right:72px;margin-bottom:0}.features-extended-header{margin-bottom:80px}.features-extended-wrap{margin-top:-64px}.features-extended-wrap:last-of-type{margin-bottom:-64px}.features-extended-wrap:not(:last-of-type){margin-bottom:64px}.feature-extended{display:flex;flex-wrap:nowrap;align-items:stretch;justify-content:flex-end;padding:64px 0}.feature-extended .feature-extended-image{width:440px;margin-right:96px;margin-bottom:0}.feature-extended .feature-extended-image img,.feature-extended .feature-extended-image svg{width:auto}.feature-extended .feature-extended-image img.device-mockup,.feature-extended .feature-extended-image svg.device-mockup{max-width:296px}.feature-extended:nth-child(even){justify-content:flex-start}.feature-extended:nth-child(even) .feature-extended-image{order:1;margin-left:96px;margin-right:0}.feature-extended-body{display:flex;flex-direction:column;justify-content:center;flex-shrink:0;width:360px;text-align:left}}@media (min-width: 1025px){.features-extended .container{max-width:944px}.feature-extended .feature-extended-image{margin-right:64px}.feature-extended:nth-child(even) .feature-extended-image{margin-left:64px}.feature-extended-body{width:392px}}.cta .section-paragraph{margin-bottom:32px}@media (min-width: 641px){.cta .section-paragraph{margin-bottom:32px;padding-left:72px;padding-right:72px}}.is-boxed{background:#fff}.body-wrap{background:#fff;overflow:hidden;display:flex;flex-direction:column;min-height:100vh}.boxed-container{max-width:1440px;margin:0 auto;box-shadow:0 20px 48px rgba(22,30,42,0.16)}main{flex:1 0 auto}.section-inner{position:relative;padding-top:48px;padding-bottom:48px}@media (min-width: 641px){.section-inner{padding-top:88px;padding-bottom:88px}}.site-footer{position:relative;background:#0B0D19}.site-footer::before{content:'';position:absolute;top:-76px;left:calc(50% - 360px);width:720px;height:291px;background-image:url(\"../images/footer-bg.svg\");background-size:720px 291px;background-repeat:no-repeat}.site-footer .footer-particles-container{position:absolute;top:0;bottom:0;left:0;right:0}.site-footer-bottom{font-size:14px;line-height:22px;letter-spacing:0px;z-index:1}.site-footer-bottom a{color:#606483;text-decoration:none}.site-footer-bottom a:hover,.site-footer-bottom a:active{text-decoration:underline}.site-footer-inner{position:relative;display:flex;flex-wrap:wrap;padding-top:48px;padding-bottom:48px;position:relative}.site-footer-inner::before{content:'';position:absolute;top:0;left:0;width:100%;display:block;height:1px;background:#1E233D}.footer-brand,.footer-links,.footer-social-links,.footer-copyright{flex:none;width:100%;display:inline-flex;justify-content:center}.footer-brand,.footer-links,.footer-social-links{margin-bottom:24px}.footer-links li+li,.footer-social-links li+li{margin-left:16px}.footer-social-links li{display:inline-flex}.footer-social-links li a{padding:8px}@media (min-width: 641px){.site-footer::before{top:-152px;left:calc(50% - 720px);width:1440px;height:582px;background-size:1440px 582px}.site-footer-inner{justify-content:space-between;padding-top:64px;padding-bottom:64px}.footer-brand,.footer-links,.footer-social-links,.footer-copyright{flex:50%}.footer-brand,.footer-copyright{justify-content:flex-start}.footer-links,.footer-social-links{justify-content:flex-end}.footer-links{order:1;margin-bottom:0}}\n"]} */ \ No newline at end of file From d5394be339b9e818a80c5d51ff69d5c48e97d820 Mon Sep 17 00:00:00 2001 From: Bhojraj Bharambe <66865003+Bhojraj9022@users.noreply.github.com> Date: Sun, 10 Oct 2021 14:40:12 +0530 Subject: [PATCH 22/33] Delete tog of war --- tog of war | 2 -- 1 file changed, 2 deletions(-) delete mode 100644 tog of war diff --git a/tog of war b/tog of war deleted file mode 100644 index e8ec02f..0000000 --- a/tog of war +++ /dev/null @@ -1,2 +0,0 @@ - -/*# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["style.css"],"names":[],"mappings":"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","file":"style.css","sourcesContent":["html{line-height:1.15;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%}body{margin:0}article,aside,footer,header,nav,section{display:block}h1{font-size:2em;margin:0.67em 0}figcaption,figure,main{display:block}figure{margin:1em 40px}hr{box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace, monospace;font-size:1em}a{background-color:transparent;-webkit-text-decoration-skip:objects}abbr[title]{border-bottom:none;text-decoration:underline;text-decoration:underline dotted}b,strong{font-weight:inherit}b,strong{font-weight:bolder}code,kbd,samp{font-family:monospace, monospace;font-size:1em}dfn{font-style:italic}mark{background-color:#ff0;color:#000}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-0.25em}sup{top:-0.5em}audio,video{display:inline-block}audio:not([controls]){display:none;height:0}img{border-style:none}svg:not(:root){overflow:hidden}button,input,optgroup,select,textarea{font-family:sans-serif;font-size:100%;line-height:1.15;margin:0}button,input{overflow:visible}button,select{text-transform:none}button,html [type=\"button\"],[type=\"reset\"],[type=\"submit\"]{-webkit-appearance:button}button::-moz-focus-inner,[type=\"button\"]::-moz-focus-inner,[type=\"reset\"]::-moz-focus-inner,[type=\"submit\"]::-moz-focus-inner{border-style:none;padding:0}button:-moz-focusring,[type=\"button\"]:-moz-focusring,[type=\"reset\"]:-moz-focusring,[type=\"submit\"]:-moz-focusring{outline:1px dotted ButtonText}fieldset{padding:0.35em 0.75em 0.625em}legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}progress{display:inline-block;vertical-align:baseline}textarea{overflow:auto}[type=\"checkbox\"],[type=\"radio\"]{box-sizing:border-box;padding:0}[type=\"number\"]::-webkit-inner-spin-button,[type=\"number\"]::-webkit-outer-spin-button{height:auto}[type=\"search\"]{-webkit-appearance:textfield;outline-offset:-2px}[type=\"search\"]::-webkit-search-cancel-button,[type=\"search\"]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}details,menu{display:block}summary{display:list-item}canvas{display:inline-block}template{display:none}[hidden]{display:none}html{box-sizing:border-box}*,*:before,*:after{box-sizing:inherit}body{background:#fff;-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased}hr{border:0;display:block;height:1px;background:#E4E8EE;margin-top:24px;margin-bottom:24px}ul,ol{margin-top:0;margin-bottom:24px;padding-left:24px}ul{list-style:disc}ol{list-style:decimal}li>ul,li>ol{margin-bottom:0}dl{margin-top:0;margin-bottom:24px}dt{font-weight:600}dd{margin-left:24px;margin-bottom:24px}img{height:auto;max-width:100%;vertical-align:middle}figure{margin:24px 0}figcaption{font-size:16px;line-height:24px;padding:8px 0}img,svg{display:block}table{border-collapse:collapse;margin-bottom:24px;width:100%}tr{border-bottom:1px solid #E4E8EE}th{text-align:left}th,td{padding:10px 16px}th:first-child,td:first-child{padding-left:0}th:last-child,td:last-child{padding-right:0}html{font-size:20px;line-height:30px}body{color:#6B7A90;font-size:1rem}body,button,input,select,textarea{font-family:\"Heebo\", sans-serif}a{color:#4234F8;text-decoration:none}a:hover,a:active{outline:0;text-decoration:underline}h1,h2,h3,h4,h5,h6,.h1,.h2,.h3,.h4,.h5,.h6{clear:both;color:#161E2A;font-family:\"Oxygen\", sans-serif;font-weight:600}h1,.h1{font-size:38px;line-height:48px;letter-spacing:0px}@media (min-width: 641px){h1,.h1{font-size:44px;line-height:54px;letter-spacing:0px}}h2,.h2{font-size:32px;line-height:42px;letter-spacing:0px}@media (min-width: 641px){h2,.h2{font-size:38px;line-height:48px;letter-spacing:0px}}h3,.h3,blockquote{font-size:28px;line-height:34px;letter-spacing:0px}@media (min-width: 641px){h3,.h3,blockquote{font-size:32px;line-height:42px;letter-spacing:0px}}h4,.h4{font-size:28px;line-height:34px;letter-spacing:0px}h5,.h5,h6,.h6{font-size:20px;line-height:30px;letter-spacing:-0.1px}@media (max-width: 640px){.h1-mobile{font-size:38px;line-height:48px;letter-spacing:0px}.h2-mobile{font-size:32px;line-height:42px;letter-spacing:0px}.h3-mobile{font-size:28px;line-height:34px;letter-spacing:0px}.h4-mobile{font-size:28px;line-height:34px;letter-spacing:0px}.h5-mobile,.h6-mobile{font-size:20px;line-height:30px;letter-spacing:-0.1px}}.text-light{color:#606483}.text-light a{color:#606483}.text-light h1,.text-light h2,.text-light h3,.text-light h4,.text-light h5,.text-light h6,.text-light .h1,.text-light .h2,.text-light .h3,.text-light .h4,.text-light .h5,.text-light .h6{color:#fff !important}.text-sm{font-size:18px;line-height:27px;letter-spacing:-0.1px}.text-xs{font-size:16px;line-height:24px;letter-spacing:-0.1px}h1,h2,.h1,.h2{margin-top:48px;margin-bottom:16px}h3,.h3{margin-top:36px;margin-bottom:12px}h4,h5,h6,.h4,.h5,.h6{margin-top:24px;margin-bottom:4px}p{margin-top:0;margin-bottom:24px}dfn,cite,em,i{font-style:italic}blockquote{color:#6B7A90;font-style:italic;margin-top:24px;margin-bottom:24px;margin-left:24px}blockquote::before{content:\"\\201C\"}blockquote::after{content:\"\\201D\"}blockquote p{display:inline}address{color:#6B7A90;border-width:1px 0;border-style:solid;border-color:#E4E8EE;padding:24px 0;margin:0 0 24px}pre,pre h1,pre h2,pre h3,pre h4,pre h5,pre h6,pre .h1,pre .h2,pre .h3,pre .h4,pre .h5,pre .h6{font-family:\"Courier 10 Pitch\", Courier, monospace}pre,code,kbd,tt,var{background:#F3F4FF}pre{font-size:16px;line-height:24px;margin-bottom:1.6em;max-width:100%;overflow:auto;padding:24px;margin-top:24px;margin-bottom:24px}code,kbd,tt,var{font-family:Monaco, Consolas, \"Andale Mono\", \"DejaVu Sans Mono\", monospace;font-size:16px;padding:2px 4px}abbr,acronym{cursor:help}mark,ins{text-decoration:none}small{font-size:18px;line-height:27px;letter-spacing:-0.1px}b,strong{font-weight:600}button,input,select,textarea,label{font-size:20px;line-height:30px}.container,.container-sm{width:100%;margin:0 auto;padding-left:16px;padding-right:16px}@media (min-width: 481px){.container,.container-sm{padding-left:24px;padding-right:24px}}.container{max-width:1128px}.container-sm{max-width:848px}.container .container-sm{max-width:800px;padding-left:0;padding-right:0}.screen-reader-text{clip:rect(1px, 1px, 1px, 1px);position:absolute !important;height:1px;width:1px;overflow:hidden;word-wrap:normal !important}.screen-reader-text:focus{border-radius:2px;box-shadow:0 0 2px 2px rgba(0,0,0,0.6);clip:auto !important;display:block;font-size:14px;letter-spacing:0px;font-weight:600;line-height:16px;text-decoration:none;text-transform:uppercase;background-color:#fff;color:#4234F8 !important;border:none;height:auto;left:8px;padding:16px 40px;top:8px;width:auto;z-index:100000}.list-reset{list-style:none;padding:0}.text-left{text-align:left}.text-center{text-align:center}.text-right{text-align:right}.text-primary{color:#4234F8}.text-secondary{color:#FF6C50}.has-top-divider{position:relative}.has-top-divider::before{content:'';position:absolute;top:0;left:0;width:100%;display:block;height:1px;background:#E4E8EE}.has-bottom-divider{position:relative}.has-bottom-divider::after{content:'';position:absolute;bottom:0;left:0;width:100%;display:block;height:1px;background:#E4E8EE}.m-0{margin:0}.mt-0{margin-top:0}.mr-0{margin-right:0}.mb-0{margin-bottom:0}.ml-0{margin-left:0}.m-8{margin:8px}.mt-8{margin-top:8px}.mr-8{margin-right:8px}.mb-8{margin-bottom:8px}.ml-8{margin-left:8px}.m-16{margin:16px}.mt-16{margin-top:16px}.mr-16{margin-right:16px}.mb-16{margin-bottom:16px}.ml-16{margin-left:16px}.m-24{margin:24px}.mt-24{margin-top:24px}.mr-24{margin-right:24px}.mb-24{margin-bottom:24px}.ml-24{margin-left:24px}.m-32{margin:32px}.mt-32{margin-top:32px}.mr-32{margin-right:32px}.mb-32{margin-bottom:32px}.ml-32{margin-left:32px}.m-40{margin:40px}.mt-40{margin-top:40px}.mr-40{margin-right:40px}.mb-40{margin-bottom:40px}.ml-40{margin-left:40px}.m-48{margin:48px}.mt-48{margin-top:48px}.mr-48{margin-right:48px}.mb-48{margin-bottom:48px}.ml-48{margin-left:48px}.m-56{margin:56px}.mt-56{margin-top:56px}.mr-56{margin-right:56px}.mb-56{margin-bottom:56px}.ml-56{margin-left:56px}.m-64{margin:64px}.mt-64{margin-top:64px}.mr-64{margin-right:64px}.mb-64{margin-bottom:64px}.ml-64{margin-left:64px}.p-0{padding:0}.pt-0{padding-top:0}.pr-0{padding-right:0}.pb-0{padding-bottom:0}.pl-0{padding-left:0}.p-8{padding:8px}.pt-8{padding-top:8px}.pr-8{padding-right:8px}.pb-8{padding-bottom:8px}.pl-8{padding-left:8px}.p-16{padding:16px}.pt-16{padding-top:16px}.pr-16{padding-right:16px}.pb-16{padding-bottom:16px}.pl-16{padding-left:16px}.p-24{padding:24px}.pt-24{padding-top:24px}.pr-24{padding-right:24px}.pb-24{padding-bottom:24px}.pl-24{padding-left:24px}.p-32{padding:32px}.pt-32{padding-top:32px}.pr-32{padding-right:32px}.pb-32{padding-bottom:32px}.pl-32{padding-left:32px}.p-40{padding:40px}.pt-40{padding-top:40px}.pr-40{padding-right:40px}.pb-40{padding-bottom:40px}.pl-40{padding-left:40px}.p-48{padding:48px}.pt-48{padding-top:48px}.pr-48{padding-right:48px}.pb-48{padding-bottom:48px}.pl-48{padding-left:48px}.p-56{padding:56px}.pt-56{padding-top:56px}.pr-56{padding-right:56px}.pb-56{padding-bottom:56px}.pl-56{padding-left:56px}.p-64{padding:64px}.pt-64{padding-top:64px}.pr-64{padding-right:64px}.pb-64{padding-bottom:64px}.pl-64{padding-left:64px}.sr .has-animations .is-revealing{visibility:hidden}.button{display:inline-flex;font-size:14px;letter-spacing:0px;font-weight:700;line-height:16px;text-decoration:none !important;text-transform:uppercase;background-color:#fff;background:#fff;color:#4234F8 !important;border:none;border-radius:2px;cursor:pointer;justify-content:center;padding:16px 40px;height:48px;text-align:center;white-space:nowrap}.button:active{outline:0}.button::before{border-radius:2px}.button-shadow{position:relative}.button-shadow::before{content:'';position:absolute;top:0;right:0;bottom:0;left:0;box-shadow:0 8px 16px rgba(22,30,42,0.12);mix-blend-mode:multiply;transition:box-shadow .15s ease}.button-shadow:hover::before{box-shadow:0 8px 16px rgba(22,30,42,0.16)}.button-sm{padding:8px 24px;height:32px}.button-sm.button-shadow::before{box-shadow:0 4px 16px rgba(22,30,42,0.12)}.button-sm.button-shadow:hover::before{box-shadow:0 4px 16px rgba(22,30,42,0.16)}.button-primary,.button-secondary{color:#fff !important;transition:background .15s ease}.button-primary{background:#4234F8}.button-primary:hover{background:#4b3ef8}.button-primary.button-shadow::before{box-shadow:0 8px 16px rgba(66,52,248,0.24)}.button-primary.button-shadow:hover::before{box-shadow:0 8px 16px rgba(66,52,248,0.32)}.button-primary .button-sm.button-shadow::before{box-shadow:0 4px 16px rgba(66,52,248,0.24)}.button-primary .button-sm.button-shadow:hover::before{box-shadow:0 4px 16px rgba(66,52,248,0.32)}.button-secondary{background:#FF6C50}.button-secondary:hover{background:#ff795f}.button-secondary.button-shadow::before{box-shadow:0 8px 16px rgba(255,108,80,0.24)}.button-secondary.button-shadow:hover::before{box-shadow:0 8px 16px rgba(255,108,80,0.32)}.button-secondary .button-sm.button-shadow::before{box-shadow:0 4px 16px rgba(255,108,80,0.24)}.button-secondary .button-sm.button-shadow:hover::before{box-shadow:0 4px 16px rgba(255,108,80,0.32)}.button-block{display:flex;width:100%}@media (max-width: 640px){.button-wide-mobile{width:100%;max-width:280px}}.site-header{padding:24px 0;position:absolute;top:0;left:0;width:100%;z-index:1}.site-header-inner{position:relative;display:flex;justify-content:space-between;align-items:center}.header-links{display:inline-flex}.header-links li{display:inline-flex}.header-links a:not(.button){font-size:16px;line-height:24px;letter-spacing:-0.1px;font-weight:600;color:#606483;text-transform:uppercase;text-decoration:none;line-height:16px;padding:8px 24px}.header-links a:not(.button):hover,.header-links a:not(.button):active{color:#fff}.hero{position:relative;padding-top:128px;padding-bottom:88px;z-index:0}.hero .hero-bg{position:absolute;top:0;bottom:42%;left:0;right:0;background:#0B0D19;z-index:-2}.hero .hero-particles-container{position:absolute;top:0;bottom:42%;left:0;right:0}.hero::before,.hero::after{content:'';position:absolute;left:calc(50% - 360px);width:720px;background-repeat:no-repeat}.hero::before{top:0;height:159px;background-image:url(\"../images/hero-bg-top.svg\");background-size:720px 159px}.hero::after{bottom:42%;height:173px;background-image:url(\"../images/hero-bg-bottom.svg\");background-size:720px 173px}.hero-inner{position:relative;z-index:1}.hero-copy{position:relative;margin-bottom:48px}@media (min-width: 641px){.hero{padding-top:160px;padding-bottom:128px}.hero::before,.hero::after{left:calc(50% - 720px);width:1440px}.hero::before{height:318px;background-size:1440px 318px}.hero::after{height:347px;background-size:1440px 347px}.hero-copy{margin-bottom:88px}.hero-paragraph{padding-left:72px;padding-right:72px}}.has-animations .hero .hero-bg,.has-animations .hero::before,.has-animations .hero::after,.has-animations .hero-particles-container,.has-animations .site-header,.has-animations .hero-title,.has-animations .hero-paragraph,.has-animations .hero-cta,.has-animations .hero .mockup-bg,.has-animations .hero .device-mockup{opacity:0}.has-animations.is-loaded .hero .hero-bg{animation:heroBg 0.6s cubic-bezier(0.215, 0.61, 0.355, 1) forwards}.has-animations.is-loaded .hero::before,.has-animations.is-loaded .hero::after{animation:heroFadeIn .6s ease forwards .45s}.has-animations.is-loaded .site-header,.has-animations.is-loaded .hero-particles-container,.has-animations.is-loaded .hero .mockup-bg{animation:heroFadeIn .6s ease forwards .45s}.has-animations.is-loaded .hero-title{animation:heroContent 0.6s cubic-bezier(0.215, 0.61, 0.355, 1) forwards 0.15s}.has-animations.is-loaded .hero-paragraph{animation:heroContent 0.6s cubic-bezier(0.215, 0.61, 0.355, 1) forwards 0.3s}.has-animations.is-loaded .hero-cta{animation:heroContent 0.6s cubic-bezier(0.215, 0.61, 0.355, 1) forwards 0.45s}.has-animations.is-loaded .hero .device-mockup{animation:heroMockup .6s ease forwards .6s}@keyframes heroBg{from{transform:scaleY(0) scaleX(1.2) skewY(30deg);opacity:1}to{transform:scaleY(1) scaleX(1) skewY(0);opacity:1}}@keyframes heroContent{from{transform:translateY(40px) skewY(2deg);opacity:0}to{transform:translateY(0) skewY(0);opacity:1}}@keyframes heroMockup{from{transform:translateY(80px);opacity:0}to{transform:translateY(0);opacity:1}}@keyframes heroFadeIn{from{opacity:0}to{opacity:1}}.mockup-container{position:relative}.mockup-bg{pointer-events:none}.mockup-bg img,.mockup-bg svg{position:absolute;top:50%;left:50%;transform:translate(-50%, -50%);width:auto !important;height:auto;max-width:300% !important}.device-mockup{position:relative;width:350px;height:auto;margin:0 auto;z-index:1}.has-animations .features-extended{opacity:0}.has-animations.is-loaded .features-extended{opacity:1}.features-extended-header{margin-bottom:32px}.features-extended-wrap{display:flex;flex-wrap:wrap;margin-top:-24px}.features-extended-wrap:last-of-type{margin-bottom:-24px}.features-extended-wrap:not(:last-of-type){margin-bottom:24px}.feature-extended{padding:24px 0}.feature-extended-image{position:relative;margin-bottom:32px}.feature-extended-image img,.feature-extended-image svg{width:100%;max-width:296px;height:auto;margin-left:auto;margin-right:auto;overflow:visible}.feature-extended-body{text-align:center}@media (min-width: 641px){.features-extended .container{max-width:912px}.features-extended .section-inner{padding-bottom:128px}.features-extended .section-paragraph{padding-left:72px;padding-right:72px;margin-bottom:0}.features-extended-header{margin-bottom:80px}.features-extended-wrap{margin-top:-64px}.features-extended-wrap:last-of-type{margin-bottom:-64px}.features-extended-wrap:not(:last-of-type){margin-bottom:64px}.feature-extended{display:flex;flex-wrap:nowrap;align-items:stretch;justify-content:flex-end;padding:64px 0}.feature-extended .feature-extended-image{width:440px;margin-right:96px;margin-bottom:0}.feature-extended .feature-extended-image img,.feature-extended .feature-extended-image svg{width:auto}.feature-extended .feature-extended-image img.device-mockup,.feature-extended .feature-extended-image svg.device-mockup{max-width:296px}.feature-extended:nth-child(even){justify-content:flex-start}.feature-extended:nth-child(even) .feature-extended-image{order:1;margin-left:96px;margin-right:0}.feature-extended-body{display:flex;flex-direction:column;justify-content:center;flex-shrink:0;width:360px;text-align:left}}@media (min-width: 1025px){.features-extended .container{max-width:944px}.feature-extended .feature-extended-image{margin-right:64px}.feature-extended:nth-child(even) .feature-extended-image{margin-left:64px}.feature-extended-body{width:392px}}.cta .section-paragraph{margin-bottom:32px}@media (min-width: 641px){.cta .section-paragraph{margin-bottom:32px;padding-left:72px;padding-right:72px}}.is-boxed{background:#fff}.body-wrap{background:#fff;overflow:hidden;display:flex;flex-direction:column;min-height:100vh}.boxed-container{max-width:1440px;margin:0 auto;box-shadow:0 20px 48px rgba(22,30,42,0.16)}main{flex:1 0 auto}.section-inner{position:relative;padding-top:48px;padding-bottom:48px}@media (min-width: 641px){.section-inner{padding-top:88px;padding-bottom:88px}}.site-footer{position:relative;background:#0B0D19}.site-footer::before{content:'';position:absolute;top:-76px;left:calc(50% - 360px);width:720px;height:291px;background-image:url(\"../images/footer-bg.svg\");background-size:720px 291px;background-repeat:no-repeat}.site-footer .footer-particles-container{position:absolute;top:0;bottom:0;left:0;right:0}.site-footer-bottom{font-size:14px;line-height:22px;letter-spacing:0px;z-index:1}.site-footer-bottom a{color:#606483;text-decoration:none}.site-footer-bottom a:hover,.site-footer-bottom a:active{text-decoration:underline}.site-footer-inner{position:relative;display:flex;flex-wrap:wrap;padding-top:48px;padding-bottom:48px;position:relative}.site-footer-inner::before{content:'';position:absolute;top:0;left:0;width:100%;display:block;height:1px;background:#1E233D}.footer-brand,.footer-links,.footer-social-links,.footer-copyright{flex:none;width:100%;display:inline-flex;justify-content:center}.footer-brand,.footer-links,.footer-social-links{margin-bottom:24px}.footer-links li+li,.footer-social-links li+li{margin-left:16px}.footer-social-links li{display:inline-flex}.footer-social-links li a{padding:8px}@media (min-width: 641px){.site-footer::before{top:-152px;left:calc(50% - 720px);width:1440px;height:582px;background-size:1440px 582px}.site-footer-inner{justify-content:space-between;padding-top:64px;padding-bottom:64px}.footer-brand,.footer-links,.footer-social-links,.footer-copyright{flex:50%}.footer-brand,.footer-copyright{justify-content:flex-start}.footer-links,.footer-social-links{justify-content:flex-end}.footer-links{order:1;margin-bottom:0}}\n"]} */ \ No newline at end of file From 1dabaac29653716e50cf075d71275dd25fde6783 Mon Sep 17 00:00:00 2001 From: Bhojraj Bharambe <66865003+Bhojraj9022@users.noreply.github.com> Date: Sun, 10 Oct 2021 14:41:25 +0530 Subject: [PATCH 23/33] Add files via upload --- tog_of_war_Problem.cpp | 163 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 163 insertions(+) create mode 100644 tog_of_war_Problem.cpp diff --git a/tog_of_war_Problem.cpp b/tog_of_war_Problem.cpp new file mode 100644 index 0000000..f14d1f7 --- /dev/null +++ b/tog_of_war_Problem.cpp @@ -0,0 +1,163 @@ +#include + +#define ll long long int +#define ld long double + +using namespace std; + +void file_io() +{ + ios_base::sync_with_stdio(false); + cin.tie(NULL); +#ifndef ONLINE_JUDGE + freopen("input.txt", "r", stdin); + freopen("output.txt", "w", stdout); +#endif +} + +class ThreeVal +{ +public: + bool True, False, None; + + ThreeVal() + { + True = false; + False = false; + None = false; + } + + void setTrue() + { + True = true; + False = false; + None = false; + } + + void setFalse() + { + False = true; + True = false; + None = false; + } + + void setNone() + { + None = true; + True = false; + False = false; + } +}; + +void addPerson(vector *arr, ll n, vector *currentElements, ll noOfSelectedElements, vector *solution, ll *minimumDifference, ll sum, ll currentSum, ll currentPosition) +{ + if (currentPosition == n) + { + return; + } + + if (((n / 2) - noOfSelectedElements) > (n - currentPosition)) + { + return; + } + addPerson(arr, n, currentElements, noOfSelectedElements, solution, minimumDifference, sum, currentSum, currentPosition + 1); + noOfSelectedElements++; + currentSum += (*arr)[currentPosition]; + (*currentElements)[currentPosition].setTrue(); + + if (noOfSelectedElements == n / 2) + { + if ((abs(sum / 2) - currentSum) < *minimumDifference) + { + *minimumDifference = abs(sum / 2 - currentSum); + for (ll i = 0; i < n; i++) + { + (*solution)[i] = (*currentElements)[i]; + } + } + } + else + { + addPerson(arr, n, currentElements, noOfSelectedElements, solution, minimumDifference, sum, currentSum, currentPosition + 1); + } + + (*currentElements)[currentPosition].setFalse(); +} + +void tugOfWar(vector *arr, ll n) +{ + vector *currentElements = new vector(); + for (ll i = 0; i < n; i++) + { + ThreeVal tv; + tv.setNone(); + currentElements->push_back(tv); + } + + vector *solution = new vector(); + for (ll i = 0; i < n; i++) + { + ThreeVal tv; + tv.setNone(); + solution->push_back(tv); + } + + ll minimumDifference = INT_MAX; + + ll sum = 0; + for (ll i = 0; i < n; i++) + { + sum += (*arr)[i]; + (*currentElements)[i].setFalse(); + (*solution)[i].setFalse(); + } + + addPerson(arr, n, currentElements, 0, solution, &minimumDifference, sum, 0, 0); + + ll sum1 = 0, sum2 = 0; + + for (ll i = 0; i < n; i++) + { + // cout << (*solution)[i].True << " " << (*solution)[i].False << " " << (*solution)[i].None << endl; + if ((*solution)[i].True) + { + sum1 += (*arr)[i]; + } + + if ((*solution)[i].False) + { + sum2 += (*arr)[i]; + } + } + + if (sum1 < sum2) + { + cout << sum1 << " " << sum2 << endl; + } + else + { + cout << sum2 << " " << sum1 << endl; + } +} + +int main() +{ + file_io(); + ll testCases; + cin >> testCases; + ll n, no; + vector arr; + while (testCases--) + { + arr.clear(); + cin >> n; + for (ll i = 0; i < n; i++) + { + cin >> no; + arr.push_back(no); + } + tugOfWar(&arr, n); + } + + return 0; +} \ No newline at end of file From 1ce60fd63061699ac2665b2bfeceb1ab811102a7 Mon Sep 17 00:00:00 2001 From: Bhojraj Bharambe <66865003+Bhojraj9022@users.noreply.github.com> Date: Sun, 10 Oct 2021 14:41:59 +0530 Subject: [PATCH 24/33] Deleted Tug_of_war_problem file --- tog_of_war_Problem.cpp | 163 ----------------------------------------- 1 file changed, 163 deletions(-) delete mode 100644 tog_of_war_Problem.cpp diff --git a/tog_of_war_Problem.cpp b/tog_of_war_Problem.cpp deleted file mode 100644 index f14d1f7..0000000 --- a/tog_of_war_Problem.cpp +++ /dev/null @@ -1,163 +0,0 @@ -#include - -#define ll long long int -#define ld long double - -using namespace std; - -void file_io() -{ - ios_base::sync_with_stdio(false); - cin.tie(NULL); -#ifndef ONLINE_JUDGE - freopen("input.txt", "r", stdin); - freopen("output.txt", "w", stdout); -#endif -} - -class ThreeVal -{ -public: - bool True, False, None; - - ThreeVal() - { - True = false; - False = false; - None = false; - } - - void setTrue() - { - True = true; - False = false; - None = false; - } - - void setFalse() - { - False = true; - True = false; - None = false; - } - - void setNone() - { - None = true; - True = false; - False = false; - } -}; - -void addPerson(vector *arr, ll n, vector *currentElements, ll noOfSelectedElements, vector *solution, ll *minimumDifference, ll sum, ll currentSum, ll currentPosition) -{ - if (currentPosition == n) - { - return; - } - - if (((n / 2) - noOfSelectedElements) > (n - currentPosition)) - { - return; - } - addPerson(arr, n, currentElements, noOfSelectedElements, solution, minimumDifference, sum, currentSum, currentPosition + 1); - noOfSelectedElements++; - currentSum += (*arr)[currentPosition]; - (*currentElements)[currentPosition].setTrue(); - - if (noOfSelectedElements == n / 2) - { - if ((abs(sum / 2) - currentSum) < *minimumDifference) - { - *minimumDifference = abs(sum / 2 - currentSum); - for (ll i = 0; i < n; i++) - { - (*solution)[i] = (*currentElements)[i]; - } - } - } - else - { - addPerson(arr, n, currentElements, noOfSelectedElements, solution, minimumDifference, sum, currentSum, currentPosition + 1); - } - - (*currentElements)[currentPosition].setFalse(); -} - -void tugOfWar(vector *arr, ll n) -{ - vector *currentElements = new vector(); - for (ll i = 0; i < n; i++) - { - ThreeVal tv; - tv.setNone(); - currentElements->push_back(tv); - } - - vector *solution = new vector(); - for (ll i = 0; i < n; i++) - { - ThreeVal tv; - tv.setNone(); - solution->push_back(tv); - } - - ll minimumDifference = INT_MAX; - - ll sum = 0; - for (ll i = 0; i < n; i++) - { - sum += (*arr)[i]; - (*currentElements)[i].setFalse(); - (*solution)[i].setFalse(); - } - - addPerson(arr, n, currentElements, 0, solution, &minimumDifference, sum, 0, 0); - - ll sum1 = 0, sum2 = 0; - - for (ll i = 0; i < n; i++) - { - // cout << (*solution)[i].True << " " << (*solution)[i].False << " " << (*solution)[i].None << endl; - if ((*solution)[i].True) - { - sum1 += (*arr)[i]; - } - - if ((*solution)[i].False) - { - sum2 += (*arr)[i]; - } - } - - if (sum1 < sum2) - { - cout << sum1 << " " << sum2 << endl; - } - else - { - cout << sum2 << " " << sum1 << endl; - } -} - -int main() -{ - file_io(); - ll testCases; - cin >> testCases; - ll n, no; - vector arr; - while (testCases--) - { - arr.clear(); - cin >> n; - for (ll i = 0; i < n; i++) - { - cin >> no; - arr.push_back(no); - } - tugOfWar(&arr, n); - } - - return 0; -} \ No newline at end of file From 75d55d657c8d5eb92fe5cbe4692c8c6695c14bba Mon Sep 17 00:00:00 2001 From: Bhojraj Bharambe <66865003+Bhojraj9022@users.noreply.github.com> Date: Sun, 10 Oct 2021 14:42:29 +0530 Subject: [PATCH 25/33] Added Solution for Tug of War Problem in C++ --- tog_of_war_Problem.cpp | 163 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 163 insertions(+) create mode 100644 tog_of_war_Problem.cpp diff --git a/tog_of_war_Problem.cpp b/tog_of_war_Problem.cpp new file mode 100644 index 0000000..f14d1f7 --- /dev/null +++ b/tog_of_war_Problem.cpp @@ -0,0 +1,163 @@ +#include + +#define ll long long int +#define ld long double + +using namespace std; + +void file_io() +{ + ios_base::sync_with_stdio(false); + cin.tie(NULL); +#ifndef ONLINE_JUDGE + freopen("input.txt", "r", stdin); + freopen("output.txt", "w", stdout); +#endif +} + +class ThreeVal +{ +public: + bool True, False, None; + + ThreeVal() + { + True = false; + False = false; + None = false; + } + + void setTrue() + { + True = true; + False = false; + None = false; + } + + void setFalse() + { + False = true; + True = false; + None = false; + } + + void setNone() + { + None = true; + True = false; + False = false; + } +}; + +void addPerson(vector *arr, ll n, vector *currentElements, ll noOfSelectedElements, vector *solution, ll *minimumDifference, ll sum, ll currentSum, ll currentPosition) +{ + if (currentPosition == n) + { + return; + } + + if (((n / 2) - noOfSelectedElements) > (n - currentPosition)) + { + return; + } + addPerson(arr, n, currentElements, noOfSelectedElements, solution, minimumDifference, sum, currentSum, currentPosition + 1); + noOfSelectedElements++; + currentSum += (*arr)[currentPosition]; + (*currentElements)[currentPosition].setTrue(); + + if (noOfSelectedElements == n / 2) + { + if ((abs(sum / 2) - currentSum) < *minimumDifference) + { + *minimumDifference = abs(sum / 2 - currentSum); + for (ll i = 0; i < n; i++) + { + (*solution)[i] = (*currentElements)[i]; + } + } + } + else + { + addPerson(arr, n, currentElements, noOfSelectedElements, solution, minimumDifference, sum, currentSum, currentPosition + 1); + } + + (*currentElements)[currentPosition].setFalse(); +} + +void tugOfWar(vector *arr, ll n) +{ + vector *currentElements = new vector(); + for (ll i = 0; i < n; i++) + { + ThreeVal tv; + tv.setNone(); + currentElements->push_back(tv); + } + + vector *solution = new vector(); + for (ll i = 0; i < n; i++) + { + ThreeVal tv; + tv.setNone(); + solution->push_back(tv); + } + + ll minimumDifference = INT_MAX; + + ll sum = 0; + for (ll i = 0; i < n; i++) + { + sum += (*arr)[i]; + (*currentElements)[i].setFalse(); + (*solution)[i].setFalse(); + } + + addPerson(arr, n, currentElements, 0, solution, &minimumDifference, sum, 0, 0); + + ll sum1 = 0, sum2 = 0; + + for (ll i = 0; i < n; i++) + { + // cout << (*solution)[i].True << " " << (*solution)[i].False << " " << (*solution)[i].None << endl; + if ((*solution)[i].True) + { + sum1 += (*arr)[i]; + } + + if ((*solution)[i].False) + { + sum2 += (*arr)[i]; + } + } + + if (sum1 < sum2) + { + cout << sum1 << " " << sum2 << endl; + } + else + { + cout << sum2 << " " << sum1 << endl; + } +} + +int main() +{ + file_io(); + ll testCases; + cin >> testCases; + ll n, no; + vector arr; + while (testCases--) + { + arr.clear(); + cin >> n; + for (ll i = 0; i < n; i++) + { + cin >> no; + arr.push_back(no); + } + tugOfWar(&arr, n); + } + + return 0; +} \ No newline at end of file From 89398c30a184b526e42ecf1d679a8837aec64c28 Mon Sep 17 00:00:00 2001 From: vedic-kalra <85125045+vedic-kalra@users.noreply.github.com> Date: Thu, 14 Oct 2021 01:57:12 +0530 Subject: [PATCH 26/33] Longest Common Subsequence CPP Implementation here i am providing two solutions to the following problems using dynamic programming one is Top-Down DP and another is Bottom-Up DP this paticular questions corresponds to the folloing question on leetcode leetcode-1143 https://leetcode.com/problems/longest-common-subsequence/ here i have explained the question in a gradual optimal manner --- longest_common_subsequence_using_dp.cpp | 73 +++++++++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 longest_common_subsequence_using_dp.cpp diff --git a/longest_common_subsequence_using_dp.cpp b/longest_common_subsequence_using_dp.cpp new file mode 100644 index 0000000..cf862e8 --- /dev/null +++ b/longest_common_subsequence_using_dp.cpp @@ -0,0 +1,73 @@ +//here i am providing two solutions to the following problems using dynamic programming +//one is Top-Down DP and another is Bottom-Up DP +// this paticular questions corresponds to the folloing question on leetcode +//leetcode-1143 https://leetcode.com/problems/longest-common-subsequence/ +//here i have explained the question in a gradual optimal manner +//------------------------------------------------------------------------------------------------------------------ +//brute force approach +class Solution { + public int longestCommonSubsequence(String text1, String text2) { + return longestCommonSubsequence(text1, text2, 0, 0); + } + + private int longestCommonSubsequence(String text1, String text2, int i, int j) { + if (i == text1.length() || j == text2.length()) + return 0; + if (text1.charAt(i) == text2.charAt(j)) + return 1 + longestCommonSubsequence(text1, text2, i + 1, j + 1); + else + return Math.max( + longestCommonSubsequence(text1, text2, i + 1, j), + longestCommonSubsequence(text1, text2, i, j + 1) + ); + } +} +//------------------------------------------------------------------------------------------------------------------ +/* Top-down DP +We might use memoization to overcome overlapping subproblems. +Since there are two changing values, i.e. i and j in the recursive +function longestCommonSubsequence, we might apply a two-dimensional array.*/ +class Solution { + private Integer[][] dp; + public int longestCommonSubsequence(String text1, String text2) { + dp = new Integer[text1.length()][text2.length()]; + return longestCommonSubsequence(text1, text2, 0, 0); + } + + private int longestCommonSubsequence(String text1, String text2, int i, int j) { + if (i == text1.length() || j == text2.length()) + return 0; + + if (dp[i][j] != null) + return dp[i][j]; + + if (text1.charAt(i) == text2.charAt(j)) + return dp[i][j] = 1 + longestCommonSubsequence(text1, text2, i + 1, j + 1); + else + return dp[i][j] = Math.max( + longestCommonSubsequence(text1, text2, i + 1, j), + longestCommonSubsequence(text1, text2, i, j + 1) + ); + } +} +//------------------------------------------------------------------------------------------------------------------ +/*Bottom-up DP +For every i in text1, j in text2, we will choose one of the following two options: + +if two characters match, length of the common subsequence would be 1 plus the +length of the common subsequence till the i-1 andj-1 indexes +if two characters doesn't match, we will take the longer by either skipping i or j indexes*/ +class Solution { + public int longestCommonSubsequence(String text1, String text2) { + int[][] dp = new int[text1.length() + 1][text2.length() + 1]; + for (int i = 1; i <= text1.length(); i++) { + for (int j = 1; j <= text2.length(); j++) { + if (text1.charAt(i - 1) == text2.charAt(j - 1)) + dp[i][j] = 1 + dp[i - 1][j - 1]; + else + dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]); + } + } + return dp[text1.length()][text2.length()]; + } +} \ No newline at end of file From 2a2fa78d3b147a0c3a287d25996b14e48d037c36 Mon Sep 17 00:00:00 2001 From: Kshitiz Raj Date: Thu, 14 Oct 2021 12:11:17 +0530 Subject: [PATCH 27/33] Add Zig Zag Pattern Program --- ZigZagPattern.cpp | 67 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 ZigZagPattern.cpp diff --git a/ZigZagPattern.cpp b/ZigZagPattern.cpp new file mode 100644 index 0000000..e345f7f --- /dev/null +++ b/ZigZagPattern.cpp @@ -0,0 +1,67 @@ +#include +using namespace std; + +int main() +{ + + int n; + cin >> n; + + for (int i = 1; i <= 3; i++) + { + if (i == 1) + { + int c = 0; + for (int j = 1; j <= n; j++) + { + if (j == 1 || j == 2) + { + cout << " "; + } + else + { + if (c % 4 == 0) + { + cout << "* "; + } + else + { + cout << " "; + } + c++; + } + } + } + else if (i == 2) + { + for (int j = 1; j <= n; j++) + { + if (j % 2 == 0) + { + cout << "* "; + } + else + { + cout << " "; + } + } + } + else + { + for (int j = 1; j <= n; j++) + { + if (j % 4 == 1) + { + cout << "* "; + } + else + { + cout << " "; + } + } + } + cout << endl; + } + + return 0; +} \ No newline at end of file From dbdcf3dbc9fd469cda393f404f39c2ac2e9bcda1 Mon Sep 17 00:00:00 2001 From: Aryan Date: Thu, 14 Oct 2021 17:11:07 +0530 Subject: [PATCH 28/33] Added All The File Of Longest Common Subsequence --- LongestCommonSubsequence.cpp | 38 ++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 LongestCommonSubsequence.cpp diff --git a/LongestCommonSubsequence.cpp b/LongestCommonSubsequence.cpp new file mode 100644 index 0000000..6b6a574 --- /dev/null +++ b/LongestCommonSubsequence.cpp @@ -0,0 +1,38 @@ +#include +#include +#include +using namespace std; + +//finding max value +int max(int a, int b) +{ + return (a > b) ? a : b; +} + +//finding LCS +int LongestCommonSubsequence(char *str1, char *str2, int x, int y) +{ + if (x == 0 || y == 0) + { + return 0; + } + if (str1[x - 1] == str2[y - 1]) + { + return (1 + LongestCommonSubsequence(str1, str2, x - 1, y - 1)); + } + else + { + return max(LongestCommonSubsequence(str1, str2, x, y - 1), LongestCommonSubsequence(str1, str2, x - 1, y)); + } +} + +//main function +int main() +{ + char str1[] = "cantonment"; + char str2[] = "longatone"; + int x = strlen(str1); + int y = strlen(str2); + cout << "\nLength of Longest Common Subsequence From Both The Strings Is " << LongestCommonSubsequence(str1, str2, x, y) << endl; + return 0; +} \ No newline at end of file From 4d00773ee10c01defb4f4eb23dfe43535c89a548 Mon Sep 17 00:00:00 2001 From: SAGAR SATAPATHY Date: Fri, 15 Oct 2021 03:40:09 +0530 Subject: [PATCH 29/33] added stack linklist added stack linklist for hacktoberfest in cpp --- stack_linkedlist.cpp | 82 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 stack_linkedlist.cpp diff --git a/stack_linkedlist.cpp b/stack_linkedlist.cpp new file mode 100644 index 0000000..5022a8b --- /dev/null +++ b/stack_linkedlist.cpp @@ -0,0 +1,82 @@ +/* C++ program to implement basic stack +operations */ +#include + +using namespace std; + +#define MAX 1000 + +class Stack { + int top; + +public: + int a[MAX]; // Maximum size of Stack + + Stack() { top = -1; } + bool push(int x); + int pop(); + int peek(); + bool isEmpty(); +}; + +bool Stack::push(int x) +{ + if (top >= (MAX - 1)) { + cout << "Stack Overflow"; + return false; + } + else { + a[++top] = x; + cout << x << " pushed into stack\n"; + return true; + } +} + +int Stack::pop() +{ + if (top < 0) { + cout << "Stack Underflow"; + return 0; + } + else { + int x = a[top--]; + return x; + } +} +int Stack::peek() +{ + if (top < 0) { + cout << "Stack is Empty"; + return 0; + } + else { + int x = a[top]; + return x; + } +} + +bool Stack::isEmpty() +{ + return (top < 0); +} + +// Driver program to test above functions +int main() +{ + class Stack s; + s.push(10); + s.push(20); + s.push(30); + cout << s.pop() << " Popped from stack\n"; + //print all elements in stack : + cout<<"Elements present in stack : "; + while(!s.isEmpty()) + { + // print top element in stack + cout< Date: Mon, 18 Oct 2021 18:05:52 +0530 Subject: [PATCH 30/33] Insertion_Sort.cpp Added "the" in front of number in line 41 --- Insertion_Sort.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Insertion_Sort.cpp b/Insertion_Sort.cpp index bf8c6ed..769a5f7 100644 --- a/Insertion_Sort.cpp +++ b/Insertion_Sort.cpp @@ -38,7 +38,7 @@ void insertionSort(int arr[], int n) { int main() { int n; - cout<<"Enter number of elements : "; + cout<<"Enter the number of elements : "; cin>>n; int arr[n]; From 9cecedcc084b01c81126d5d3dd6767cc5c8bdfc6 Mon Sep 17 00:00:00 2001 From: PratikPrakhar <84954224+PratikPrakhar@users.noreply.github.com> Date: Tue, 19 Oct 2021 19:06:29 +0530 Subject: [PATCH 31/33] Added program of Stack using linked list --- Stack using linked list.c | 106 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 106 insertions(+) create mode 100644 Stack using linked list.c diff --git a/Stack using linked list.c b/Stack using linked list.c new file mode 100644 index 0000000..c3f9864 --- /dev/null +++ b/Stack using linked list.c @@ -0,0 +1,106 @@ +#include +#include + +struct Node +{ + int data; + struct Node *next; +}; + +struct Node *head = NULL; + +void push(int value) +{ + struct Node *n = (struct Node *)malloc(sizeof(struct Node *)); + if (head == NULL) + { + head = n; + n->data = value; + n->next = NULL; + return; + } + + n->next = head; + n->data = value; + head = n; +} + +void pop() +{ + struct Node *temp = head; + if (head == NULL) + { + printf("\nStack is empty.\n"); + return; + } + + head = head->next; + temp->next = NULL; +} + +void peek() +{ + if (head == NULL) + { + printf("\nStack is empty.\n"); + return; + } + + printf("The top element is: %d\n", head->data); +} + +void display() +{ + struct Node *temp = head; + if (head == NULL) + { + printf("\nStack is empty.\n"); + return; + } + printf("\nElements of stack are:\n"); + while (temp != NULL) + { + printf("%d\n", temp->data); + temp = temp->next; + } +} + +int main() +{ + while (1) + { + printf("\n=======Menu=======\n"); + printf("1. Push\n"); + printf("2. Pop\n"); + printf("3. Peek\n"); + printf("4. Display\n"); + printf("5. Exit\n\n"); + int c, n; + scanf("%d", &c); + switch (c) + { + case 1: + printf("Enter the element to be inserted: "); + scanf("%d", &n); + push(n); + break; + case 2: + pop(); + break; + case 3: + peek(); + break; + case 4: + display(); + break; + case 5: + exit(0); + break; + + default: + printf("Please select a valid option."); + } + } + + return 0; +} \ No newline at end of file From 5d70b380e3b37522b4fbe31fffcf76307afa1c86 Mon Sep 17 00:00:00 2001 From: VikasArsul <92970538+VikasArsul@users.noreply.github.com> Date: Fri, 22 Oct 2021 11:28:25 +0530 Subject: [PATCH 32/33] Solution for Rat-In-Maze problem in C++ --- rat_in_maze.cpp | 75 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 rat_in_maze.cpp diff --git a/rat_in_maze.cpp b/rat_in_maze.cpp new file mode 100644 index 0000000..808a791 --- /dev/null +++ b/rat_in_maze.cpp @@ -0,0 +1,75 @@ +#include +using namespace std; + +bool isSafe(int** arr, int x, int y, int n){ + + if( x>n; + + int** arr = new int*[n]; + for(int i=0; i>arr[i][j]; + } + } + + int** solArr = new int*[n]; + for(int i=0; i Date: Sat, 23 Oct 2021 09:48:38 +0530 Subject: [PATCH 33/33] Create Kadanes_Algo --- Kadanes_Algo | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 Kadanes_Algo diff --git a/Kadanes_Algo b/Kadanes_Algo new file mode 100644 index 0000000..d788079 --- /dev/null +++ b/Kadanes_Algo @@ -0,0 +1,20 @@ +#include +using namespace std; +int main() +{ + int n; + cin >> n; + int ms = 0, cs = 0; + int arr[n]; + for (int i = 0; i < n; i++) + { + cin >> arr[i]; + cs += arr[i]; + if (cs < 0) + cs = 0; + else if (cs >= ms) + ms = cs; + } + cout << ms << endl; + return 0; +}