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 01/26] 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 02/26] 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 03/26] 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 04/26] 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 05/26] 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 06/26] 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 07/26] 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 08/26] 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 09/26] 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 10/26] 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 11/26] 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 12/26] 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 13/26] 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 14/26] 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 15/26] 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 16/26] 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 17/26] 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 18/26] 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 19/26] 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 20/26] 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 21/26] 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 22/26] 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 23/26] 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 24/26] 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 25/26] 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 26/26] 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; +}