├── Arrays ├── AlgorithmsToDo.md ├── Array_Delete.c ├── Array_Insert.c ├── Array_Reverse.c ├── MedianofArray.cpp └── meanofArray.c ├── DataStructures ├── AlgorithmsToDo.md ├── CircularLinkedList.c ├── CircularQueue.c ├── Doubly-Linked-List.c └── Link-List.C ├── Graphs ├── AlgorithmsToDo.md └── BFS.c ├── Hashing ├── AlgorithmsToDo.md ├── double_hashing.c ├── linear_probe.c ├── open_hashing.c └── quadratic_probing..c ├── LeetCodeSolutions ├── 1108-DefanginganIPAddress.c ├── 2-AddTwoNumbers.c ├── 20-ValidParanthesis.c ├── 35-search-insert-position.c ├── 628-MaximumProductOfThreeNumbers.c ├── 7-reverse-integer.c ├── 9-palindrome-number.c └── AlgorithmsToDo.md ├── Maths ├── AlgorithmsToDo.md ├── Factorial.c ├── Find_Min.c ├── Median.c ├── Prime_Factors.c ├── TwoMax.c ├── TwoMin.c ├── isPrime.c ├── max.c ├── mean.c ├── min.c ├── power.c ├── power.exe ├── power.o ├── problema1.c ├── problema2.c ├── problema3.c ├── problema4.c ├── problema5.c ├── problema6.c ├── problema7.c ├── problema8.c └── problema9.c ├── OtherAlgorithms ├── AlgorithmsToDo.md ├── Check-Palindrome.c └── Fibonacci-Series.c ├── ProjectEulerSolutions ├── 1-multiples-of-3-and-5.c ├── 10-summation_of_primes.c ├── 11-largest_product_in_a_grid.c ├── 12-highly_divisible_triangular_number.c ├── 13-large_sum.c ├── 14-longest_collatz_sequence.c ├── 15-lattice_paths.c ├── 2-even -fibonacci-numbers.c ├── 3-largest-prime-factor.c ├── 4-largest_palindrome _product.c ├── 5-smallest-multiple.c ├── 6-sum-square-difference.c ├── 7-10001-prime.c └── AlgorithmsToDo.md ├── README.md ├── Recursion ├── AlgorithmsToDo.md └── Factorial_Of_A_Number.c ├── Searching ├── AlgorithmsToDo.md ├── ExponentialSearch.c ├── InterpolationSearch.c ├── Interpolation_Search.c ├── JumpSearch.c ├── LinearSearch.c ├── binarySearch.c └── fibonacchisearch.c ├── Sorting ├── AlgorithmsToDo.md ├── Bubble_Sort.c ├── Counting_Sort.c ├── Countingsort.c ├── Heap_Sort.c ├── Insertion_Sort.c ├── Merge_Sort.c ├── Quick_Sort.c ├── Radix_Sort.c ├── Selection_Sort.c └── Shell_Sort.c ├── Trees ├── AVL-tree.c ├── AlgorithmsToDo.md ├── Binary-Search-tree.c └── DFS.c ├── p018-maximum-path-sum-i ├── maximumpath ├── maximumpath.cpp └── path.in ├── p022-names-scores ├── namesscores ├── namesscores.cpp └── p022_names.txt ├── p031-coin-sums ├── coinsums └── coinsums.cpp └── p081-path-sum-two-ways ├── p081_matrix.txt ├── pathsumtwo └── pathsumtwo.cpp /Arrays/AlgorithmsToDo.md: -------------------------------------------------------------------------------- 1 | # Arrays - TO DO 2 | - Reverse array 3 | - Sum of elements in array 4 | - Largest element 5 | - Two largest elements 6 | - Smallest element 7 | - Two smallest elements 8 | - Median of elements 9 | - Mean of elements 10 | -------------------------------------------------------------------------------- /Arrays/Array_Delete.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define MAX 100 3 | 4 | void delete(int arr[], int n, int index); 5 | void display(int arr[], int n); 6 | 7 | main(){ 8 | int arr[MAX], i, n, item, pos; 9 | 10 | // Input 11 | printf("Enter size of array: "); 12 | scanf("%d", &n); 13 | for(i = 0; i < n; i++){ 14 | printf("Enter element %d: ", i+1); 15 | scanf("%d", &arr[i]); 16 | } 17 | 18 | printf("\nEnter position at which to insert: "); 19 | scanf("%d", &pos); 20 | if(pos <= n){ 21 | delete(arr, n, pos-1); 22 | n--; 23 | printf("\nNew Array: "); 24 | display(arr, n); 25 | } 26 | else{ 27 | printf("\nINVALID INPUT! Position more than size of array."); 28 | } 29 | } 30 | 31 | void delete(int arr[], int n, int index){ 32 | int i; 33 | for(i = index; i < n; i++){ 34 | arr[i] = arr[i+1]; 35 | } 36 | } 37 | 38 | void display(int arr[], int n){ 39 | int i; 40 | for(i = 0; i < n; i++){ 41 | printf("%d ", arr[i]); 42 | } 43 | } -------------------------------------------------------------------------------- /Arrays/Array_Insert.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define MAX 100 3 | 4 | void insert(int arr[], int n, int item, int index); 5 | void display(int arr[], int n); 6 | 7 | main(){ 8 | int arr[MAX], i, n, item, pos; 9 | 10 | // Input 11 | printf("Enter size of array: "); 12 | scanf("%d", &n); 13 | for(i = 0; i < n; i++){ 14 | printf("Enter element %d: ", i+1); 15 | scanf("%d", &arr[i]); 16 | } 17 | 18 | printf("\nEnter number to insert: "); 19 | scanf("%d", &item); 20 | printf("\nEnter position at which to insert: "); 21 | scanf("%d", &pos); 22 | if(pos <= n){ 23 | insert(arr, n, item, pos-1); 24 | n++; 25 | printf("\nNew Array: "); 26 | display(arr, n); 27 | } 28 | else{ 29 | printf("\nINVALID INPUT! Position more than size of array."); 30 | } 31 | } 32 | 33 | void insert(int arr[], int n, int item, int index){ 34 | int i; 35 | for(i = n; i > index; i--){ 36 | arr[i] = arr[i-1]; 37 | } 38 | arr[index] = item; 39 | } 40 | 41 | void display(int arr[], int n){ 42 | int i; 43 | for(i = 0; i < n; i++){ 44 | printf("%d ", arr[i]); 45 | } 46 | } -------------------------------------------------------------------------------- /Arrays/Array_Reverse.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int n; 6 | 7 | printf("Enter the number of elements in array\n"); 8 | scanf("%d", &n); 9 | 10 | int a[n]; 11 | printf("Enter array elements\n"); 12 | 13 | for(int i=0; i a = 5 21 | a[c] = a[i] - a[c]; // b = a - b -> b = 2 22 | a[i] -= a[c]; // a = a - b -> a = 3 23 | } 24 | 25 | printf("Reverse array is\n"); 26 | 27 | for(int i=0; i 2 | #include 3 | 4 | int comparator(const void *p, const void *q){ 5 | int l = *(const int *)p; 6 | int r = *(const int *)q; 7 | 8 | return l>r; 9 | } 10 | 11 | int main() 12 | { 13 | int N; 14 | printf("Enter the size of the array: "); 15 | scanf("%d",&N); 16 | 17 | int arr[N]; 18 | int i; 19 | for(i=0;i 2 | 3 | int main() 4 | { 5 | int N; 6 | printf("enter the size of the array: "); 7 | scanf("%d",&N); 8 | int i; 9 | long int sum = 0; 10 | for(i=0;i 2 | #include 3 | 4 | typedef struct Node 5 | 6 | { 7 | int info; 8 | struct Node *next; 9 | }node; 10 | 11 | node *front=NULL,*rear=NULL,*temp; 12 | 13 | void create(); 14 | void del(); 15 | void display(); 16 | 17 | int main() 18 | { 19 | int chc; 20 | do 21 | { 22 | printf("\nMenu\n\t 1 to create the element : "); 23 | printf("\n\t 2 to delete the element : "); 24 | printf("\n\t 3 to display the queue : "); 25 | printf("\n\t 4 to exit from main : "); 26 | printf("\nEnter your choice : "); 27 | scanf("%d",&chc); 28 | 29 | switch(chc) 30 | { 31 | case 1: 32 | create(); 33 | break; 34 | 35 | case 2: 36 | del(); 37 | break; 38 | 39 | case 3: 40 | display(); 41 | break; 42 | 43 | case 4: 44 | return 1; 45 | 46 | default: 47 | printf("\nInvalid choice :"); 48 | } 49 | }while(1); 50 | 51 | return 0; 52 | } 53 | 54 | void create() 55 | { 56 | node *newnode; 57 | newnode=(node*)malloc(sizeof(node)); 58 | printf("\nEnter the node value : "); 59 | scanf("%d",&newnode->info); 60 | newnode->next=NULL; 61 | if(rear==NULL) 62 | front=rear=newnode; 63 | else 64 | { 65 | rear->next=newnode; 66 | rear=newnode; 67 | } 68 | 69 | rear->next=front; 70 | } 71 | 72 | void del() 73 | { 74 | temp=front; 75 | if(front==NULL) 76 | printf("\nUnderflow :"); 77 | else 78 | { 79 | if(front==rear) 80 | { 81 | printf("\n%d",front->info); 82 | front=rear=NULL; 83 | } 84 | else 85 | { 86 | printf("\n%d",front->info); 87 | front=front->next; 88 | rear->next=front; 89 | } 90 | 91 | temp->next=NULL; 92 | free(temp); 93 | } 94 | } 95 | 96 | void display() 97 | { 98 | temp=front; 99 | if(front==NULL) 100 | printf("\nEmpty"); 101 | else 102 | { 103 | printf("\n"); 104 | for(;temp!=rear;temp=temp->next) 105 | printf("\n%d address=%u next=%u\t",temp->info,temp,temp->next); 106 | printf("\n%d address=%u next=%u\t",temp->info,temp,temp->next); 107 | } 108 | } -------------------------------------------------------------------------------- /DataStructures/CircularQueue.c: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | 5 | int queue[20]; 6 | int rear = -1; 7 | int front = -1; 8 | int size; 9 | 10 | void enqueue(){ 11 | 12 | int x; 13 | 14 | printf("Enter data: "); 15 | scanf(" %d", &x); 16 | 17 | if( (rear >= size-1 && front == 0) || front == rear + 1) 18 | printf("Node can't be added!"); 19 | 20 | 21 | else if(rear == size - 1 && front != 0){ 22 | rear = 0; 23 | queue[rear] = x; 24 | } 25 | 26 | else{ 27 | if(front == -1) 28 | front++; 29 | 30 | queue[++rear] = x; 31 | 32 | printf("\nElement queued!"); 33 | } 34 | 35 | 36 | } 37 | 38 | void dqueue(){ 39 | if(front == -1 ) 40 | printf("\nQueue Underflow!"); 41 | 42 | else if(front == size - 1) 43 | { 44 | printf("\nDeleted element %d", queue[front]); 45 | front = 0; 46 | } 47 | 48 | else if(front == rear){ 49 | printf("\nDeleted element %d", queue[front]); 50 | front = rear = -1; 51 | } 52 | 53 | else 54 | printf("\nDeleted element %d", queue[front++]); 55 | } 56 | 57 | void display(){ 58 | 59 | if(front == -1 ) 60 | printf("\nQueue Underflow!"); 61 | 62 | 63 | printf("\nData in a queue: "); 64 | if ( rear > front){ 65 | 66 | 67 | for(int i = front; i <= rear; i++) 68 | printf(" %d", queue[i]); 69 | } 70 | 71 | else{ 72 | for(int i = front; i <= size-1 ; i++) 73 | printf(" %d", queue[i]); 74 | 75 | for(int j = 0; j <= rear ; j++) 76 | printf(" %d", queue[j]); 77 | 78 | } 79 | } 80 | int main() 81 | { 82 | 83 | printf("< - Circular Queue - Creation - Deletion - Traversal - >\n"); 84 | int ch; 85 | 86 | printf("Size of the Queue: "); 87 | scanf(" %d", &size); 88 | 89 | while(1){ 90 | printf("\n1. Enqueue() \n2. Dqueue()\n3. Traversal()\n4.exit()\n Choice: "); 91 | scanf(" %d", &ch); 92 | 93 | switch(ch){ 94 | 95 | case 1: enqueue(); break; 96 | case 2: dqueue(); break; 97 | case 3: display(); break; 98 | case 4: exit(1); break; 99 | default: printf("\nwrong input!");break; 100 | } 101 | } 102 | 103 | return 0; 104 | } 105 | -------------------------------------------------------------------------------- /DataStructures/Doubly-Linked-List.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct node{ 5 | int data; 6 | struct node* prev; 7 | struct node* next; 8 | }; 9 | 10 | struct node *head, *tail; 11 | 12 | void insertBefore(struct node *n){ 13 | int x; 14 | printf("\nEnter (x): "); 15 | scanf("%d", &x); 16 | 17 | if(head->data == x){ 18 | head->prev = n; 19 | n->next = head; 20 | head = n; 21 | return; 22 | } 23 | 24 | struct node *p = head; 25 | while(p != NULL){ 26 | if(p->data == x){ 27 | struct node *tmp = p->prev; 28 | p->prev = n; 29 | n->next = p; 30 | n->prev = tmp; 31 | tmp->next = n; 32 | printf("\nInserted data (%d)\n", n->data); 33 | return; 34 | } 35 | p = p->next; 36 | } 37 | 38 | printf("\nNo data (%d)\nInserted to last\n", x); 39 | tail->next = n; 40 | n->prev = tail; 41 | tail = n; 42 | } 43 | 44 | void insertAfter(struct node *n){ 45 | int x; 46 | printf("\nEnter (x): "); 47 | scanf("%d", &x); 48 | 49 | struct node *p = head; 50 | while(p != tail){ 51 | if(p->data == x){ 52 | struct node *tmp = p->next; 53 | p->next = n; 54 | n->prev = p; 55 | n->next = tmp; 56 | tmp->prev = n; 57 | printf("\nInserted data (%d)\n", n->data); 58 | return; 59 | } 60 | p = p->next; 61 | } 62 | 63 | printf("\nNo data (%d)\nInserted to last\n", x); 64 | tail->next = n; 65 | n->prev = tail; 66 | tail = n; 67 | } 68 | 69 | void insert(){ 70 | int d; 71 | printf("\nEnter data: "); 72 | scanf("%d", &d); 73 | 74 | struct node *newn = (struct node*)malloc(sizeof(struct node)); 75 | newn->data = d; 76 | newn->prev = NULL; 77 | newn->next = NULL; 78 | 79 | if(head == NULL){ 80 | head = tail = newn; 81 | printf("\nCreated List.\n"); 82 | }else{ 83 | int c; 84 | printf("\n1. First\n2. Before (x)\n3. After (x)\n4. Last\n"); 85 | scanf("%d", &c); 86 | switch(c){ 87 | case 1: 88 | head->prev = newn; 89 | newn->next = head; 90 | head = newn; 91 | break; 92 | case 2: insertBefore(newn); break; 93 | case 3: insertAfter(newn); break; 94 | case 4: 95 | tail->next = newn; 96 | newn->prev = tail; 97 | tail = newn; 98 | break; 99 | default: printf("\nWrong input!"); break; 100 | } 101 | } 102 | } 103 | 104 | void displayForward(){ 105 | struct node *p = head; 106 | if(head == NULL){ 107 | printf("\nNo data to display!"); 108 | return; 109 | } 110 | 111 | printf("\nList data: "); 112 | while(p != NULL){ 113 | printf(" %d", p->data); 114 | p = p->next; 115 | } 116 | } 117 | 118 | void displayBackward(){ 119 | struct node *p = tail; 120 | if(tail == NULL){ 121 | printf("\nNo data to display!"); 122 | return; 123 | } 124 | 125 | printf("\nList data(Backward): "); 126 | while(p != NULL){ 127 | printf(" %d", p->data); 128 | p = p->prev; 129 | } 130 | } 131 | 132 | void display(){ 133 | int c; 134 | printf("\n1. Forward(head -> tail)\n2. Backward(tail -> head)\n Choice: "); 135 | scanf("%d", &c); 136 | switch(c){ 137 | case 1: displayForward(); break; 138 | case 2: displayBackward(); break; 139 | default: printf("\nWrong input!"); break; 140 | } 141 | } 142 | 143 | void delete(){ 144 | int x; 145 | printf("\nEnter (x): "); 146 | scanf("%d", &x); 147 | 148 | if(head->data == x){ 149 | head->next->prev = NULL; 150 | head = head->next; 151 | free(head); 152 | printf("\nDeleted data (%d)\n", x); 153 | return; 154 | } 155 | 156 | if(tail->data == x){ 157 | tail->prev->next = NULL; 158 | tail = tail->prev; 159 | free(tail); 160 | printf("\nDeleted data (%d)\n", x); 161 | return; 162 | } 163 | 164 | struct node *p = head; 165 | while(p != NULL){ 166 | if(p->data == x){ 167 | p->prev->next = p->next; 168 | p->next->prev = p->prev; 169 | free(p); 170 | printf("\nDeleted data (%d)\n", x); 171 | return; 172 | } 173 | p = p->next; 174 | } 175 | } 176 | 177 | void main() 178 | { 179 | int c; 180 | while(1){ 181 | printf("\n1. Create/Insert\n2. Display\n3. Delete\n4. Exit\n Choice: "); 182 | scanf("%d", &c); 183 | switch(c){ 184 | case 1: insert(); break; 185 | case 2: display(); break; 186 | case 3: delete(); break; 187 | case 4: exit(0); 188 | default: printf("\nWrong input!"); break; 189 | } 190 | } 191 | } 192 | -------------------------------------------------------------------------------- /DataStructures/Link-List.C: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | struct node{ 6 | int data; 7 | struct node* link; 8 | }*root; 9 | 10 | void create(){ 11 | 12 | int x; 13 | 14 | struct node* newn; 15 | newn = (struct node*)malloc(sizeof(struct node)); 16 | 17 | printf("\nEnter Data: "); 18 | scanf(" %d", &x); 19 | newn -> data = x; 20 | newn -> link = NULL; 21 | 22 | if(root == NULL){ 23 | root = newn; 24 | printf("\nRoot Node created!"); 25 | } 26 | 27 | else{ 28 | struct node *p; 29 | p = root; 30 | 31 | while(p -> link != NULL) 32 | p = p -> link; 33 | 34 | 35 | p -> link = newn; 36 | newn -> link = NULL; 37 | 38 | printf("\nNode inserted!"); 39 | } 40 | } 41 | 42 | void delt(){ 43 | struct node *p, *c; 44 | p = root; 45 | c = root; 46 | 47 | if (p == NULL) 48 | printf("\nNo Data to delete!"); 49 | 50 | else{ 51 | 52 | while(p -> link != NULL){ 53 | c = p ; 54 | p = p -> link; 55 | 56 | } 57 | printf("\n%d node deleted!", p -> data); 58 | c -> link = NULL; 59 | free(p); 60 | } 61 | 62 | } 63 | 64 | void display(){ 65 | 66 | struct node* tmp; 67 | tmp = root; 68 | 69 | if(root == NULL) 70 | printf("\nNo data to display!"); 71 | 72 | printf("\nLink list data: "); 73 | 74 | while(tmp != NULL){ 75 | printf(" %d", tmp -> data); 76 | tmp = tmp -> link; 77 | } 78 | 79 | } 80 | void main() 81 | { 82 | printf("< - Link List - Creation - Deletion - Traversal - >\n"); 83 | int ch; 84 | while(1){ 85 | printf("\n1. create/insert() \n2. display()\n3. delete()\n4.exit()\n Choice: "); 86 | scanf(" %d", &ch); 87 | 88 | switch(ch){ 89 | 90 | case 1: create(); break; 91 | case 2: display(); break; 92 | case 3: delt(); break; 93 | case 4: exit(1); break; 94 | default: printf("\nwrong input!");break; 95 | } 96 | } 97 | } -------------------------------------------------------------------------------- /Graphs/AlgorithmsToDo.md: -------------------------------------------------------------------------------- 1 | # Graphs - TO DO 2 | - 3 | -------------------------------------------------------------------------------- /Graphs/BFS.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define SIZE 40 4 | struct queue { 5 | int items[SIZE]; 6 | int front; 7 | int rear; 8 | }; 9 | struct queue* createQueue(); 10 | void enqueue(struct queue* q, int); 11 | int dequeue(struct queue* q); 12 | void display(struct queue* q); 13 | int isEmpty(struct queue* q); 14 | void printQueue(struct queue* q); 15 | struct node 16 | { 17 | int vertex; 18 | struct node* next; 19 | }; 20 | struct node* createNode(int); 21 | struct Graph 22 | { 23 | int numVertices; 24 | struct node** adjLists; 25 | int* visited; 26 | }; 27 | struct Graph* createGraph(int vertices); 28 | void addEdge(struct Graph* graph, int src, int dest); 29 | void printGraph(struct Graph* graph); 30 | void bfs(struct Graph* graph, int startVertex); 31 | int main() 32 | { 33 | struct Graph* graph = createGraph(6); 34 | addEdge(graph, 0, 1); 35 | addEdge(graph, 0, 2); 36 | addEdge(graph, 1, 2); 37 | addEdge(graph, 1, 4); 38 | addEdge(graph, 1, 3); 39 | addEdge(graph, 2, 4); 40 | addEdge(graph, 3, 4); 41 | 42 | bfs(graph, 0); 43 | 44 | return 0; 45 | } 46 | void bfs(struct Graph* graph, int startVertex) { 47 | struct queue* q = createQueue(); 48 | 49 | graph->visited[startVertex] = 1; 50 | enqueue(q, startVertex); 51 | 52 | while(!isEmpty(q)){ 53 | printQueue(q); 54 | int currentVertex = dequeue(q); 55 | printf("Visited %d\n", currentVertex); 56 | 57 | struct node* temp = graph->adjLists[currentVertex]; 58 | 59 | while(temp) { 60 | int adjVertex = temp->vertex; 61 | if(graph->visited[adjVertex] == 0){ 62 | graph->visited[adjVertex] = 1; 63 | enqueue(q, adjVertex); 64 | } 65 | temp = temp->next; 66 | } 67 | } 68 | } 69 | 70 | struct node* createNode(int v) 71 | { 72 | struct node* newNode = malloc(sizeof(struct node)); 73 | newNode->vertex = v; 74 | newNode->next = NULL; 75 | return newNode; 76 | } 77 | 78 | struct Graph* createGraph(int vertices) 79 | { 80 | struct Graph* graph = malloc(sizeof(struct Graph)); 81 | graph->numVertices = vertices; 82 | 83 | graph->adjLists = malloc(vertices * sizeof(struct node*)); 84 | graph->visited = malloc(vertices * sizeof(int)); 85 | 86 | 87 | int i; 88 | for (i = 0; i < vertices; i++) { 89 | graph->adjLists[i] = NULL; 90 | graph->visited[i] = 0; 91 | } 92 | 93 | return graph; 94 | } 95 | 96 | void addEdge(struct Graph* graph, int src, int dest) 97 | { 98 | // Add edge from src to dest 99 | struct node* newNode = createNode(dest); 100 | newNode->next = graph->adjLists[src]; 101 | graph->adjLists[src] = newNode; 102 | 103 | // Add edge from dest to src 104 | newNode = createNode(src); 105 | newNode->next = graph->adjLists[dest]; 106 | graph->adjLists[dest] = newNode; 107 | } 108 | struct queue* createQueue() { 109 | struct queue* q = malloc(sizeof(struct queue)); 110 | q->front = -1; 111 | q->rear = -1; 112 | return q; 113 | } 114 | int isEmpty(struct queue* q) { 115 | if(q->rear == -1) 116 | return 1; 117 | else 118 | return 0; 119 | } 120 | void enqueue(struct queue* q, int value){ 121 | if(q->rear == SIZE-1) 122 | printf("\nQueue is Full!!"); 123 | else { 124 | if(q->front == -1) 125 | q->front = 0; 126 | q->rear++; 127 | q->items[q->rear] = value; 128 | } 129 | } 130 | int dequeue(struct queue* q){ 131 | int item; 132 | if(isEmpty(q)){ 133 | printf("Queue is empty"); 134 | item = -1; 135 | } 136 | else{ 137 | item = q->items[q->front]; 138 | q->front++; 139 | if(q->front > q->rear){ 140 | printf("Resetting queue"); 141 | q->front = q->rear = -1; 142 | } 143 | } 144 | return item; 145 | } 146 | void printQueue(struct queue *q) { 147 | int i = q->front; 148 | if(isEmpty(q)) { 149 | printf("Queue is empty"); 150 | } else { 151 | printf("\nQueue contains \n"); 152 | for(i = q->front; i < q->rear + 1; i++) { 153 | printf("%d ", q->items[i]); 154 | } 155 | } 156 | } 157 | -------------------------------------------------------------------------------- /Hashing/AlgorithmsToDo.md: -------------------------------------------------------------------------------- 1 | # Hashing - TO DO 2 | - Separate Chaining ( Open Hashing ) 3 | - Linear Probing 4 | - Quadratic Probing 5 | - Double Hashing 6 | -------------------------------------------------------------------------------- /Hashing/double_hashing.c: -------------------------------------------------------------------------------- 1 | //double hashing 2 | 3 | #include 4 | #include 5 | #define M 20 6 | 7 | struct DataItem 8 | { 9 | int key; 10 | int value; 11 | } HT[M]; 12 | 13 | void initialize() 14 | { 15 | for(int i = 0 ; i< M ; i++) 16 | { 17 | HT[i].key = 0; 18 | } 19 | } 20 | 21 | float loadFactor() 22 | { 23 | int count = 0; 24 | for(int i = 0 ; i< M ; i++) 25 | { 26 | if(HT[i].key!=0) 27 | count++; 28 | } 29 | float d = (float)count/M; 30 | return d; 31 | 32 | } 33 | 34 | int hf1( int key ) 35 | { 36 | return key % M; 37 | } 38 | 39 | int hf2 ( int key ) 40 | { 41 | int k = 6 ; 42 | return (key % k) + 1; 43 | } 44 | 45 | void insertValue( int key ) 46 | { 47 | if(loadFactor()==1) 48 | { 49 | printf("HASHTABLE FULL"); 50 | return; 51 | } 52 | 53 | int ha = hf1(key); 54 | int ha2 = hf2(key); 55 | 56 | if(HT[ha].key==0) 57 | { 58 | HT[ha].key = key; 59 | return; 60 | } 61 | 62 | int j = 1; 63 | int nha = ha + j*ha2 ; 64 | int k = nha % M ; 65 | 66 | while(j<90) 67 | { 68 | if(HT[k].key==0) 69 | { 70 | HT[k].key = key; 71 | return; 72 | } 73 | else 74 | { 75 | j++; 76 | } 77 | } 78 | 79 | } 80 | 81 | bool search( int key ) 82 | { 83 | int flag = 0; 84 | if(!loadFactor()) 85 | { 86 | printf("NO ITEMS"); 87 | return false; 88 | } 89 | 90 | int ha = hf1( key ); 91 | int ha2 = hf2(key); 92 | 93 | if( HT[ha].key == key) 94 | { 95 | printf("FOUND"); 96 | flag++; 97 | return true; 98 | } 99 | else 100 | { 101 | int j = 1; 102 | int nha = ha + j* ha2; 103 | int k = nha%M; 104 | 105 | while(j<90) 106 | { 107 | if(HT[k].key == key) 108 | { 109 | printf("FOUND"); 110 | flag++; 111 | return true; 112 | } 113 | else 114 | { 115 | j++; 116 | } 117 | } 118 | if(!flag) 119 | { 120 | printf("NOT FOUND"); 121 | return false; 122 | } 123 | 124 | 125 | } 126 | } 127 | 128 | void print() 129 | { 130 | for(int i = 0 ; i< M ; i++) 131 | { 132 | printf("%5d" , HT[i].key); 133 | } 134 | printf("\n"); 135 | } 136 | 137 | int main() 138 | { 139 | insertValue(34); 140 | insertValue(55); 141 | insertValue(12); 142 | insertValue(8); 143 | insertValue(45); 144 | insertValue(37); 145 | insertValue(88); 146 | insertValue(98); 147 | insertValue(54); 148 | insertValue(32); 149 | print(); 150 | search( 34); 151 | 152 | 153 | } 154 | 155 | 156 | 157 | -------------------------------------------------------------------------------- /Hashing/linear_probe.c: -------------------------------------------------------------------------------- 1 | //open addressing 2 | 3 | #include 4 | #include 5 | 6 | #define M 14 7 | 8 | struct Dataitem 9 | { 10 | int key; 11 | int value; 12 | } HT[M]; 13 | 14 | 15 | void initialize() 16 | { 17 | for( int i = 0 ; i=0); 80 | } 81 | 82 | 83 | bool search(int item) 84 | { 85 | if(loadFactor()==0) 86 | { 87 | printf(" \nNO ELEMENT IN HASHTABLE "); 88 | return false; 89 | } 90 | int ha = item % M ; 91 | 92 | if(HT[ha].key == item) 93 | { 94 | printf("TRUE"); 95 | return true; 96 | } 97 | 98 | int nha = ha+1; 99 | do 100 | { 101 | int k = nha % M; ///////////////// 102 | if(HT[k].key == item) 103 | { 104 | printf("TRUE"); 105 | return true; 106 | } 107 | nha++; ////////////////////// 108 | 109 | }while(nha=0); 123 | 124 | printf("FAIL"); 125 | return false; 126 | } 127 | 128 | bool deleted(int item) 129 | { 130 | if(!loadFactor()) 131 | { 132 | printf("NO ITEM"); 133 | return false; 134 | } 135 | 136 | int ha = item % M; 137 | 138 | if( HT[ha].key == item) 139 | { 140 | HT[ha].key = 0; 141 | return true; 142 | } 143 | 144 | int nha = ha+1; 145 | do 146 | { 147 | int k = nha % M; ///////////// 148 | if( HT[k].key == item) 149 | { 150 | HT[k].key = 0; 151 | return true; 152 | } 153 | nha++; 154 | }while(nha < M); 155 | 156 | nha = ha-1; 157 | do 158 | { 159 | int k = nha % M; //////////////// 160 | if( HT[k].key == item ) 161 | { 162 | HT[k].key = 0; 163 | return true; 164 | } 165 | nha--; 166 | }while(nha >= 0); 167 | 168 | printf("NOT FOUND"); 169 | return false; 170 | } 171 | 172 | void print() 173 | { 174 | for(int i = 0 ; i< M ; i++) 175 | { 176 | printf("%5d" , HT[i].key); 177 | } 178 | printf("\n"); 179 | } 180 | 181 | int main() 182 | { 183 | insert(11); 184 | insert(7); 185 | insert(21); 186 | print(); 187 | // search(7); 188 | deleted(21); 189 | print(); 190 | } 191 | 192 | -------------------------------------------------------------------------------- /Hashing/open_hashing.c: -------------------------------------------------------------------------------- 1 | //open hashing 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | #define M 5 8 | 9 | struct Node 10 | { 11 | int key; 12 | struct Node* next; 13 | }; 14 | 15 | struct Hash 16 | { 17 | struct Node* head; 18 | int count; 19 | } *HT; 20 | 21 | struct Node* createNode( int key ) 22 | { 23 | struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); 24 | newNode->key = key; 25 | newNode->next = NULL; 26 | return newNode; 27 | }; 28 | 29 | void initialize() 30 | { 31 | for ( int i = 0 ; i < M ; i++) 32 | { 33 | HT[i].head = NULL; 34 | } 35 | } 36 | 37 | void insertValue( int key ) 38 | { 39 | int ha = key % M; 40 | struct Node* newNode = createNode( key ); 41 | 42 | if(!HT[ha].head) 43 | { 44 | HT[ha].head = newNode; 45 | HT[ha].count = 1; 46 | } 47 | else 48 | { 49 | newNode->next = HT[ha].head; 50 | HT[ha].head = newNode; 51 | HT[ha].count++; 52 | } 53 | } 54 | 55 | bool search( int key ) 56 | { 57 | int ha = key % M; 58 | int flag = 0; 59 | 60 | if(!HT[ha].head) 61 | { 62 | printf("NOT FOUND"); 63 | return false; 64 | } 65 | 66 | for( struct Node* temp = HT[ha].head ; temp!=NULL ; temp = temp->next) 67 | { 68 | if( temp->key == key) 69 | { 70 | printf("FOUND"); 71 | return true; 72 | } 73 | } 74 | printf("NOT FOUND"); 75 | return false; 76 | 77 | } 78 | 79 | 80 | void print() 81 | { 82 | for( int i=0; i < M ; i++ ) 83 | { 84 | printf("\nentries at index %d\n",i); 85 | if(!HT[i].head) 86 | { 87 | printf("NULL"); 88 | return; 89 | } 90 | else 91 | { 92 | for(struct Node* temp = HT[i].head ; temp!=NULL ; temp = temp->next) 93 | printf("%2d->",temp->key); 94 | } 95 | } 96 | 97 | } 98 | 99 | int main() 100 | { 101 | HT = (struct Hash*) calloc( M , sizeof(struct Hash)); 102 | insertValue(5); 103 | insertValue(10); 104 | insertValue(6); 105 | insertValue(7); 106 | insertValue(8); 107 | insertValue(9); 108 | insertValue(11); 109 | insertValue(12); 110 | insertValue(13); 111 | insertValue(14); 112 | print(); 113 | printf("\n"); 114 | int s = 8; 115 | printf("%d ->> " , s); 116 | search(s); 117 | } 118 | 119 | 120 | 121 | -------------------------------------------------------------------------------- /Hashing/quadratic_probing..c: -------------------------------------------------------------------------------- 1 | //quadratic probing 2 | 3 | #include 4 | #include 5 | 6 | #define M 15 7 | 8 | struct DataItem 9 | { 10 | int key; 11 | int value; 12 | } HT[M]; 13 | 14 | 15 | void initialize() 16 | { 17 | for(int i = 0 ; i < M ; i++) 18 | { 19 | HT[i].key = 0; 20 | } 21 | } 22 | 23 | float loadFactor() 24 | { 25 | int count = 0; 26 | for(int i = 0 ; i< M ; i++) 27 | { 28 | if( HT[i].key != 0) 29 | { 30 | count++; 31 | } 32 | } 33 | float d = (float)count/M; 34 | return (float)d; 35 | } 36 | 37 | 38 | void insert(int item) 39 | { 40 | int j = 1; 41 | if(loadFactor() == 1) 42 | { 43 | printf("HASH TABLE FULL\n"); 44 | return; 45 | } 46 | 47 | int ha = item % M; 48 | if( HT[ha].key == 0 ) 49 | { 50 | HT[ha].key = item; 51 | return; 52 | } 53 | 54 | while(true) 55 | { 56 | int nha = ha + (j*j); 57 | int k = nha % M; 58 | if (HT[k].key == 0) 59 | { 60 | HT[k].key = item; 61 | return; 62 | } 63 | else 64 | { 65 | j++; 66 | } 67 | } 68 | 69 | } 70 | 71 | 72 | bool search(int item) 73 | { 74 | int flag = 0; 75 | int j = 1; 76 | if(!loadFactor()) 77 | { 78 | printf("NO ITEMS"); 79 | return false; 80 | } 81 | int ha = item % M; 82 | if(HT[ha].key == item) 83 | { 84 | printf("FOUND"); 85 | return true; 86 | } 87 | 88 | while(j < 10) 89 | { 90 | int nha = ha + (j*j); 91 | int k = nha % M; 92 | if(HT[k].key == item) 93 | { 94 | printf("FOUND"); 95 | flag = 1; 96 | return true; 97 | } 98 | else 99 | { 100 | j++; 101 | } 102 | } 103 | if(!flag) 104 | { 105 | printf("NOT FOUND"); 106 | return false; 107 | } 108 | } 109 | 110 | 111 | bool deleted(int item) 112 | { 113 | int j = 1; 114 | if(!loadFactor()) 115 | { 116 | printf("NO ITEMS"); 117 | return false; 118 | } 119 | 120 | int ha = item % M; 121 | if( HT[ha].key == item) 122 | { 123 | HT[ha].key = 0; 124 | return true; 125 | } 126 | 127 | while(j<10) ///////////////////// 128 | { 129 | int nha = ha + (j*j); 130 | int k = nha % M; 131 | 132 | if( HT[k].key == item) 133 | { 134 | HT[k].key = 0; 135 | return true; 136 | } 137 | else 138 | { 139 | j++; 140 | } 141 | } 142 | printf("NOT FOUND\n"); 143 | return false; 144 | 145 | } 146 | 147 | void print() 148 | { 149 | for(int i = 0 ; i< M ; i++) 150 | { 151 | printf("%5d" , HT[i].key); 152 | } 153 | printf("\n"); 154 | } 155 | 156 | 157 | 158 | 159 | int main() 160 | { 161 | int choice; 162 | int key; 163 | printf("*************QUADRATIC PROBING***************\n"); 164 | printf("1. Insert\n2. Search\n3. Delete\n4. Print\n0. Exit\n"); 165 | do 166 | { 167 | scanf("%d", &choice); 168 | switch(choice) 169 | { 170 | case 1: 171 | printf("\nEnter the Number To be Inserted: "); 172 | scanf("%d" , &key); 173 | insert(key); 174 | break; 175 | case 2: 176 | printf("\nEnter the Number To be Searched: "); 177 | scanf("%d" , &key); 178 | search(key); 179 | break; 180 | case 3: 181 | printf("\nEnter the Number To be Deleted: "); 182 | scanf("%d" , &key); 183 | deleted(key); 184 | break; 185 | case 4: 186 | printf("\n"); 187 | print(); 188 | break; 189 | default: 190 | printf("WRONG INPUT"); 191 | } 192 | }while(choice!= 0); 193 | } 194 | -------------------------------------------------------------------------------- /LeetCodeSolutions/1108-DefanginganIPAddress.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | char * defangIPaddr(char * address){ 6 | char *temp = malloc((strlen(address) + 7) * sizeof(address[0])); 7 | int i = 0, j = 0; 8 | for(; i < strlen(address); i++){ 9 | if(address[i] == '.'){ 10 | temp[j++] = '['; 11 | temp[j++] = '.'; 12 | temp[j++] = ']'; 13 | }else{ 14 | temp[j++] = address[i]; 15 | } 16 | } 17 | temp[j] = '\0'; 18 | return temp; 19 | } 20 | 21 | -------------------------------------------------------------------------------- /LeetCodeSolutions/2-AddTwoNumbers.c: -------------------------------------------------------------------------------- 1 | void append(int new_val, struct ListNode ** tail) { 2 | 3 | ( * tail) - > next = malloc(sizeof(struct ListNode)); 4 | 5 | ( * tail) = ( * tail) - > next; 6 | ( * tail) - > val = new_val; 7 | ( * tail) - > next = NULL; 8 | } 9 | 10 | struct ListNode * addTwoNumbers(struct ListNode * l1, struct ListNode * l2) { 11 | int carry = 0; 12 | int new_val = 0; 13 | struct ListNode * l3 = malloc(sizeof(struct ListNode)); 14 | struct ListNode * head = NULL; 15 | struct ListNode * tail = NULL; 16 | 17 | while (l1 != NULL || l2 != NULL) { 18 | if (l1 == NULL) { 19 | new_val = l2 - > val + carry; 20 | l2 = l2 - > next; 21 | if (new_val - 10 >= 0) { 22 | carry = 1; 23 | new_val = new_val - 10; 24 | } else carry = 0; 25 | } else if (l2 == NULL) { 26 | new_val = l1 - > val + carry; 27 | l1 = l1 - > next; 28 | if (new_val - 10 >= 0) { 29 | carry = 1; 30 | new_val = new_val - 10; 31 | } else carry = 0; 32 | } else { 33 | new_val = l1 - > val + l2 - > val + carry; 34 | 35 | if (new_val - 10 >= 0) { 36 | carry = 1; 37 | new_val = new_val - 10; 38 | } else carry = 0; 39 | l1 = l1 - > next; 40 | l2 = l2 - > next; 41 | } 42 | if (head == NULL) { 43 | l3 - > val = new_val; 44 | l3 - > next = NULL; 45 | head = l3; 46 | tail = head; 47 | } else { 48 | append(new_val, & tail); 49 | } 50 | } 51 | if (carry) { 52 | append(carry, & tail); 53 | 54 | } 55 | 56 | return head; 57 | } 58 | -------------------------------------------------------------------------------- /LeetCodeSolutions/20-ValidParanthesis.c: -------------------------------------------------------------------------------- 1 | struct sNode 2 | { 3 | char data; 4 | struct sNode *next; 5 | }; 6 | 7 | void push(struct sNode** topref,int newdata) 8 | { 9 | struct sNode* newnode = (struct sNode*) malloc(sizeof(struct sNode)); 10 | newnode->data=newdata; 11 | newnode->next=(*topref); 12 | (*topref)=newnode; 13 | } 14 | int pop(struct sNode** topref) 15 | { 16 | char res; 17 | struct sNode *top; 18 | 19 | /*If stack is empty then error */ 20 | if (*topref == NULL) 21 | { 22 | exit(0); 23 | } 24 | else 25 | { 26 | top = *topref; 27 | res = top->data; 28 | *topref = top->next; 29 | free(top); 30 | return res; 31 | } 32 | } 33 | bool isMatching(char character1, char character2) 34 | { 35 | if (character1 == '(' && character2 == ')') 36 | return 1; 37 | else if (character1 == '{' && character2 == '}') 38 | return 1; 39 | else if (character1 == '[' && character2 == ']') 40 | return 1; 41 | else 42 | return 0; 43 | } 44 | 45 | bool isValid(char s[]){ 46 | int i; 47 | struct sNode *stack=NULL; 48 | while(s[i]) 49 | { 50 | if(s[i] == '(' ||s[i] == '{' || s[i] =='[') 51 | push(&stack,s[i]); 52 | if(s[i] ==')'||s[i]=='}'||s[i]==']') 53 | { 54 | if(stack == NULL) 55 | return false; 56 | 57 | else if(!isMatching(pop(&stack),s[i])) 58 | return false; 59 | } 60 | i++; 61 | } 62 | if(stack ==NULL) 63 | return true; 64 | else 65 | return false; 66 | 67 | 68 | } 69 | 70 | -------------------------------------------------------------------------------- /LeetCodeSolutions/35-search-insert-position.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int searchInsert(int* nums, int numsSize, int target){ 4 | int i,index=numsSize; 5 | for(i=0;i=target){ 7 | index = i; 8 | break; 9 | } 10 | } 11 | return index; 12 | } 13 | int main(){ 14 | int nums[50],target,numsSize,i; 15 | printf("Enter the size of the nums integer array: "); 16 | scanf("%d",&numsSize ); 17 | 18 | printf("Enter the numbers:\n"); 19 | for ( i = 0; i < numsSize; i++) { 20 | scanf("%d",&nums[i] ); 21 | } 22 | printf("Enter the number to be searched: "); 23 | scanf("%d",&target ); 24 | 25 | printf("Output : the index is : %d\n",searchInsert(nums,numsSize,target) ); 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /LeetCodeSolutions/628-MaximumProductOfThreeNumbers.c: -------------------------------------------------------------------------------- 1 | #include 2 | //Solution function 3 | //A dp based approach , done in O(n) time complexity 4 | int maximumProduct(int* nums, int numsSize){ 5 | int p1,p2; 6 | int max1,max2,max3,small1,small2; 7 | max1=max2=max3=-1001; 8 | small1=small2=1001; 9 | for(int i=0;i=max3){ 11 | max1=max2; 12 | max2=max3; 13 | max3=nums[i]; 14 | }else if(nums[i]>=max2){ 15 | max1=max2; 16 | max2=nums[i]; 17 | }else if(nums[i]>=max1){ 18 | max1=nums[i]; 19 | } 20 | 21 | if(nums[i]<=small1){ 22 | small2=small1; 23 | small1=nums[i]; 24 | }else if(nums[i]<=small2){ 25 | small2=nums[i]; 26 | } 27 | } 28 | p1=max1*max2*max3; 29 | p2 = small1*small2*max3; 30 | if(p1>p2) 31 | return p1; 32 | else 33 | return p2; 34 | } 35 | //Driver code 36 | int main(){ 37 | int nums[3] = {1,2,3}; 38 | int ans = maximumProduct(nums,3); 39 | printf("%d",ans); 40 | return 0; 41 | } -------------------------------------------------------------------------------- /LeetCodeSolutions/7-reverse-integer.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int reverse(int x){ 5 | 6 | int ReversedInteger=0,remainder; 7 | long num; 8 | 9 | while(x != 0){ 10 | 11 | remainder = x%10; 12 | 13 | //check for integer overflow 14 | if(num*10 + remainder>INT_MAX||num*10 + remainder 2 | #include 3 | 4 | int isPalindrome(int x){ 5 | int ReversedInteger=0,remainder,OriginalInteger; 6 | long num; 7 | 8 | OriginalInteger = x; 9 | 10 | while(x != 0){ 11 | 12 | remainder = x%10; 13 | 14 | //check for integer overflow 15 | if(num*10 + remainder>INT_MAX||num*10 + remainder= 0 ) 26 | return 1; 27 | else 28 | return 0; 29 | } 30 | 31 | int main(){ 32 | 33 | int inputNum; 34 | printf("Input: "); 35 | scanf("%d",&inputNum); 36 | 37 | if(isPalindrome(inputNum)==1) 38 | printf("Output: %d is a Palindrome Number",inputNum); 39 | else 40 | printf("Output: %d is not a Palindrome Number",inputNum); 41 | 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /LeetCodeSolutions/AlgorithmsToDo.md: -------------------------------------------------------------------------------- 1 | # LeetCode Solutions - TO DO 2 | - Solve any LeetCode problem -------------------------------------------------------------------------------- /Maths/AlgorithmsToDo.md: -------------------------------------------------------------------------------- 1 | # Maths - TO DO 2 | - Power programmed by JLHC 3 | - Check if Prime Number 4 | -------------------------------------------------------------------------------- /Maths/Factorial.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | int n, i; 5 | unsigned long long factorial = 1; 6 | printf("Enter an integer: "); 7 | scanf("%d",&n); 8 | if (n < 0) 9 | printf("Error! Factorial of a negative number doesn't exist."); 10 | else 11 | { 12 | for(i=1; i<=n; ++i) 13 | { 14 | factorial *= i; 15 | } 16 | printf("Factorial of %d = %llu", n, factorial); 17 | } 18 | return 0; 19 | } -------------------------------------------------------------------------------- /Maths/Find_Min.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main(){ 3 | int n; //size of array 4 | scanf("%d", &n); 5 | int a[n]; 6 | for(int i=0; i 2 | #include 3 | 4 | void mergesort(int a[],int i,int j); 5 | void merge(int a[],int i1,int j1,int i2,int j2); 6 | 7 | int main(){ 8 | 9 | printf("Enter the size of the array: "); 10 | 11 | int n; 12 | scanf("%d", &n); 13 | 14 | printf("Enter %d numbers:\n", n); 15 | 16 | int *arr = (int*)malloc(sizeof(int)*n); 17 | for(int i = 0;i < n;i++){ 18 | scanf("%d", &arr[i]); 19 | } 20 | 21 | // Sorting 22 | mergesort(arr, 0, n-1); 23 | 24 | float median; 25 | if (n%2 == 0) median = (arr[n/2]+arr[n/2-1])/2.; 26 | else median = arr[n/2]; 27 | 28 | printf("The median of array is: %.2f\n", median); 29 | 30 | return 0; 31 | } 32 | 33 | void mergesort(int a[],int i,int j) 34 | { 35 | int mid; 36 | 37 | if(i 2 | #include 3 | void primeFactors(int n){ 4 | while(n%2==0){ 5 | printf("%d ", 2); 6 | n = n/2; 7 | } 8 | for(int i=3; i<=sqrt(n); i=i+2){ 9 | while( n%i==0){ 10 | printf("%d ", i); 11 | n = n/i; 12 | } 13 | } 14 | if(n>2){ 15 | printf("%d ", n); 16 | } 17 | } 18 | 19 | int main() { 20 | int n; 21 | scanf("%d", &n); 22 | primeFactors(n); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /Maths/TwoMax.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int max(int a, int b){ 5 | return (a>b)?a:b; 6 | } 7 | 8 | int main(){ 9 | 10 | printf("Enter the array size: "); 11 | 12 | int n; 13 | scanf("%d", &n); 14 | 15 | printf("Enter %d numbers:\n", n); 16 | 17 | int *arr = (int*)malloc(sizeof(int)*n); 18 | for(int i = 0;i < n;i++){ 19 | scanf("%d", &arr[i]); 20 | } 21 | 22 | int a = arr[0]; 23 | int b = arr[1]; 24 | int first = max(a, b); 25 | int second = a+b-first; 26 | 27 | for(int i = 2;i < n;i++){ 28 | if (arr[i] > first){ 29 | second = first; 30 | first = arr[i]; 31 | } 32 | else second = max(second, arr[i]); 33 | } 34 | 35 | printf("First max: %d\nSecond max: %d\n", first, second); 36 | 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /Maths/TwoMin.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int min(int a, int b){ 5 | return (a 3 | 4 | int main() 5 | { 6 | int j, num, isP; 7 | isP = 1; 8 | 9 | printf("Enter any number to check prime: "); 10 | scanf("%d", &num); 11 | 12 | for(j=2; j<=num/2; j++) 13 | { 14 | if(num%j==0) 15 | { 16 | isP = 0; 17 | break; 18 | } 19 | } 20 | 21 | if(isP == 1) 22 | { 23 | printf("%d is prime number", num); 24 | } 25 | else 26 | { 27 | printf("%d is composite number", num); 28 | } 29 | 30 | return 0; 31 | } -------------------------------------------------------------------------------- /Maths/max.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int arr[100], max, size, i, loc; 6 | 7 | printf("Enter the size of array\n"); 8 | scanf("%d", &size); 9 | printf("Enter %d integers\n", size); 10 | for (i = 0; i < size; i++) 11 | scanf("%d", &arr[i]); 12 | max = arr[0]; 13 | loc = 1; 14 | for (i = 1; i < size; i++) 15 | { 16 | if (arr[i] > max) 17 | { 18 | max = arr[i]; 19 | loc = i+1; 20 | } 21 | } 22 | printf("Maximum element is %d and it is at position %d\n", max, loc); 23 | return 0; 24 | } -------------------------------------------------------------------------------- /Maths/mean.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(){ 5 | 6 | int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 7 | int n = sizeof(arr)/sizeof(arr[0]); 8 | 9 | int sum = 0; 10 | for(int i = 0;i < n;i++){ 11 | sum += arr[i]; 12 | } 13 | 14 | float mean = (float)sum/n; 15 | 16 | printf("mean: %.2f\n", mean); 17 | 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /Maths/min.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int arr[100], min, size, i, loc; 6 | 7 | printf("Enter the size of array\n"); 8 | scanf("%d", &size); 9 | printf("Enter %d integers\n", size); 10 | for (i = 0; i < size; i++) 11 | scanf("%d", &arr[i]); 12 | min = arr[0]; 13 | loc = 1; 14 | for (i = 1; i < size; i++) 15 | { 16 | if (arr[i] < min) 17 | { 18 | min = arr[i]; 19 | loc = i+1; 20 | } 21 | } 22 | printf("minimum element is %d and it is at position %d\n", min, loc); 23 | return 0; 24 | } -------------------------------------------------------------------------------- /Maths/power.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | float funPow(float a, float b); 4 | int main(int argc, char*argv[]){ 5 | 6 | float a,b, res=0; 7 | printf("Enter the number\n"); 8 | scanf("%f",&a); 9 | printf("Enter the power\n"); 10 | scanf("%f",&b); 11 | res = funPow(a,b); 12 | printf("The number %f at pow %f is %f: ",a,b,res); 13 | 14 | } 15 | 16 | float funPow(float a, float b){ 17 | return pow(a,b); 18 | } 19 | -------------------------------------------------------------------------------- /Maths/power.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PawanKolhe/C-Algorithms/dd005e16fde4c2423f7afa1d125209e07a7a8e8e/Maths/power.exe -------------------------------------------------------------------------------- /Maths/power.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PawanKolhe/C-Algorithms/dd005e16fde4c2423f7afa1d125209e07a7a8e8e/Maths/power.o -------------------------------------------------------------------------------- /Maths/problema1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(int argc, char *argv[]){ 4 | long int A,B; 5 | scanf("%ld %ld",&A,&B); 6 | A+=B; 7 | printf("%ld",A); 8 | return 0; 9 | } 10 | -------------------------------------------------------------------------------- /Maths/problema2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(int argc, char *argv[]){ 4 | long int c; 5 | scanf("%ld", &c); 6 | c=1.8*c+32; 7 | printf("%ld", c); 8 | return 0; 9 | } -------------------------------------------------------------------------------- /Maths/problema3.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main(int argc, char *argv[]){ 4 | int a,b,res; 5 | scanf("%d %d", &a, &b); 6 | b=(int)sqrt(b); 7 | a=(int)sqrt(a-1); 8 | res=b-a; 9 | printf("%d",res); 10 | 11 | } 12 | -------------------------------------------------------------------------------- /Maths/problema4.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(int argc, char *argv[]) 5 | { 6 | float x,y,res; 7 | scanf("%f %f", &x , &y); 8 | res=pow(x,y); 9 | printf("%f", res); 10 | return 0; 11 | 12 | 13 | } -------------------------------------------------------------------------------- /Maths/problema5.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main(int argc, char *argv[]) 5 | { 6 | unsigned long int r,n,m,x,y; 7 | scanf("%ld %ld %ld %ld", &n, &m, &x, &y); 8 | r = m/x>=n?n:((y*n+m)/(x+y)); 9 | printf("%ld", r); 10 | 11 | return 0; 12 | } -------------------------------------------------------------------------------- /Maths/problema6.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(int argc, char *argv[]) { 4 | long int a,b,s,n,r; 5 | scanf("%ld %ld %ld %ld", &a, &b, &s, &n); 6 | 7 | (n*b<=s || n*a<=s)?(r=(s-n*b)/(a-b)):(r=-1); 8 | printf("%ld", r); 9 | return 0; 10 | } -------------------------------------------------------------------------------- /Maths/problema7.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(int argc, char *argv[]) { 4 | long int a,s,k,x,y,r; 5 | scanf("%ld %ld %ld %ld %ld", &a, &s, &k, &x, &y); 6 | r=(s+k*y-a)/(x+y); 7 | ((a+r*x)==(s+(k-r)*y))?r:(r=-1); 8 | 9 | printf("%ld", r); 10 | return 0; 11 | } -------------------------------------------------------------------------------- /Maths/problema8.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(int argc, char *argv[]) { 4 | long int n,r,k,min,max; 5 | scanf("%ld %ld %ld ",&n , &r, &k); 6 | (k<=r)?(min=r-k):(min=k-r); 7 | 8 | 9 | //((k<=r))?(max=(n-k)+1):(max=r+k); 10 | 11 | ((n-r)>k)?(max=r+k):(max=n-(k-(n-r))); 12 | 13 | printf("%ld %ld",min, max); 14 | 15 | return 0; 16 | } -------------------------------------------------------------------------------- /Maths/problema9.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(int argc, char *argv[]) { 4 | long int a1,l1,a2,l2; 5 | long int c,x,y; 6 | long int w; 7 | long int tv,td,g,mitadVida,mitadAtaque,otroVida,otroAtack; 8 | 9 | scanf("%ld %ld %ld %ld",&a1,&l1,&a2,&l2); 10 | scanf("%ld %ld %ld",&c,&x,&y); 11 | tv=l1+c*y; 12 | td=a1+c*x; 13 | //probamos a repartir las moenedas en mitad si el residuo es cero y si no la repartimos 14 | ((c%2)==0)?(mitadVida=(c*(0.5))*y+l1 , mitadAtaque=(c*(0.5))*x+a1):((c%3)==0?(mitadVida=(int)((c*0.33333333333)*y)+l1, mitadAtaque=(int)((c*0.666666667)*x)+a1):(mitadVida=l1,mitadAtaque=a1)); 15 | //(mitadVida==l1)?(mitadVida):mitadVida 16 | 17 | (x 2 | #include 3 | #include 4 | 5 | #define STRING_MAX_LENGTH 256 6 | 7 | char* strrev(char *str); 8 | 9 | int main() 10 | { 11 | char *string, *string_reversed; 12 | string = malloc(STRING_MAX_LENGTH * sizeof(int)); 13 | string_reversed = malloc(STRING_MAX_LENGTH * sizeof(int)); 14 | 15 | puts("Enter a string to check if it is a palindrome."); 16 | scanf("%s", string); 17 | 18 | // Make a copy in order to compare normal and reversed string. 19 | strcpy(string_reversed, string); 20 | // Reverse it! 21 | strrev(string_reversed); 22 | 23 | // Now, compare both strings. 24 | if (strcmp(string, string_reversed) == 0) { 25 | puts("String is a palindrome!"); 26 | } else { 27 | puts("String is not a palindrome."); 28 | } 29 | 30 | free(string); 31 | free(string_reversed); 32 | 33 | return 0; 34 | } 35 | 36 | char* strrev(char *str) 37 | { 38 | char c, *start, *end; 39 | 40 | if (!str || !*str) return str; 41 | 42 | for (start = str, end = str + strlen(str) - 1; start < end; start++, end--) { 43 | c = *start; 44 | *start = *end; 45 | *end = c; 46 | } 47 | 48 | return str; 49 | } -------------------------------------------------------------------------------- /OtherAlgorithms/Fibonacci-Series.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int n, first = 0, second = 1, next, c; 6 | 7 | printf("Enter the number of terms\n"); 8 | scanf("%d", &n); 9 | 10 | printf("First %d terms of Fibonacci series are:\n", n); 11 | 12 | for (c = 0; c < n; c++) 13 | { 14 | if (c <= 1) 15 | next = c; 16 | else 17 | { 18 | next = first + second; 19 | first = second; 20 | second = next; 21 | } 22 | printf("%d\n", next); 23 | } 24 | 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /ProjectEulerSolutions/1-multiples-of-3-and-5.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(){ 4 | 5 | int sum = 0; 6 | for(int i = 1;i < 1000;i++){ 7 | if (i%3 == 0 || i%5 == 0) sum += i; 8 | } 9 | printf("%d\n", sum); 10 | 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /ProjectEulerSolutions/10-summation_of_primes.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | /** 4 | * Project Euler Problem 10 5 | * 6 | * The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17. 7 | * Find the sum of all the primes below two million. 8 | * 9 | * This implementation takes an input value and returns the correct value 10 | * for values over 5. 11 | */ 12 | int main() 13 | { 14 | double sum = 5; 15 | int count, count2, prime, limit; 16 | printf("\n\nEnter upper limit : "); 17 | scanf("%d",&limit); 18 | getchar(); 19 | 20 | for(count = 5; count < limit; count += 2) 21 | { 22 | prime = 0; 23 | for(count2 = 3 ;count2 < (count / count2 + 1); count2 += 2) 24 | { 25 | if(count % count2 == 0) 26 | { 27 | prime = 1; 28 | break; 29 | } 30 | } 31 | if(prime == 0) { 32 | sum += count; 33 | } 34 | } 35 | 36 | printf("\nThe sum of all prime numbers below %d is %.0f\n", limit, sum); 37 | return 0; 38 | } -------------------------------------------------------------------------------- /ProjectEulerSolutions/11-largest_product_in_a_grid.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | /** 4 | * Project Euler Problem 11 5 | * 6 | * In the 20×20 grid below, four numbers along a diagonal line have been marked in red. 7 | * 8 | * (Assume starting at row 06, column 08 in provided grid array in source code) 9 | * 10 | * The product of these numbers is 26 × 63 × 78 × 14 = 1788696. 11 | * 12 | * What is the greatest product of four adjacent numbers in the same direction 13 | * (up, down, left, right, or diagonally) in the 20×20 grid? 14 | */ 15 | int main() { 16 | int grid[20][20] = 17 | { 18 | { 8, 2, 22, 97, 38, 15, 0, 40, 0, 75, 4, 5, 7, 78, 52, 12, 50, 77, 91, 8}, 19 | {49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 4, 56, 62, 0}, 20 | {81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 3, 49, 13, 36, 65}, 21 | {52, 70, 95, 23, 4, 60, 11, 42, 69, 24, 68, 56, 1, 32, 56, 71, 37, 2, 36, 91}, 22 | {22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80}, 23 | {24, 47, 32, 60, 99, 3, 45, 2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50}, 24 | {32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70}, 25 | {67, 26, 20, 68, 2, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21}, 26 | {24, 55, 58, 5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72}, 27 | {21, 36, 23, 9, 75, 0, 76, 44, 20, 45, 35, 14, 0, 61, 33, 97, 34, 31, 33, 95}, 28 | {78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 3, 80, 4, 62, 16, 14, 9, 53, 56, 92}, 29 | {16, 39, 5, 42, 96, 35, 31, 47, 55, 58, 88, 24, 0, 17, 54, 24, 36, 29, 85, 57}, 30 | {86, 56, 0, 48, 35, 71, 89, 7, 5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58}, 31 | {19, 80, 81, 68, 5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 4, 89, 55, 40}, 32 | { 4, 52, 8, 83, 97, 35, 99, 16, 7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66}, 33 | {88, 36, 68, 87, 57, 62, 20, 72, 3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69}, 34 | { 4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36}, 35 | {20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 4, 36, 16}, 36 | {20, 73, 35, 29, 78, 31, 90, 1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 5, 54}, 37 | { 1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 1, 89, 19, 67, 48} 38 | }; 39 | 40 | int prod = 0; 41 | for (int i = 0; i < 20; i++) { 42 | for (int j = 0; j < 20; j++) { 43 | int vertical = 0, horizontal = 0, diagonal_left = 0, diagonal_right = 0; 44 | if (j < 17) { 45 | horizontal = grid[i][j] * 46 | grid[i][j + 1] * 47 | grid[i][j + 2] * 48 | grid[i][j + 3]; 49 | } 50 | if (i < 17) { 51 | vertical = grid[i][j] * 52 | grid[i + 1][j] * 53 | grid[i + 2][j] * 54 | grid[i + 3][j]; 55 | } 56 | if (i < 17 && j < 17) { 57 | diagonal_right = grid[i][j] * 58 | grid[i + 1][j + 1] * 59 | grid[i + 2][j + 2] * 60 | grid[i + 3][j + 3]; 61 | } 62 | if (i > 3 && i < 17 && j > 3) { 63 | diagonal_left = grid[i][j] * 64 | grid[i + 1][j - 1] * 65 | grid[i + 2][j - 2] * 66 | grid[i + 3][j - 3]; 67 | } 68 | 69 | if(horizontal > prod){ prod = horizontal;} 70 | if(vertical > prod){prod = vertical;} 71 | if(diagonal_left>prod){prod = diagonal_left;} 72 | if(diagonal_right>prod){prod = diagonal_right;} 73 | } 74 | } 75 | 76 | printf("The highest product of 4 contiguous numbers in the grid is %d\n", prod); 77 | return 0; 78 | } -------------------------------------------------------------------------------- /ProjectEulerSolutions/12-highly_divisible_triangular_number.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | /** 5 | * Project Euler Problem 12 6 | * 7 | * The sequence of triangle numbers is generated by adding the natural numbers. 8 | * So the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. 9 | * The first ten terms would be: 10 | * 11 | * 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ... 12 | * 13 | * Let us list the factors of the first seven triangle numbers: 14 | * 15 | * 1: 1 16 | * 3: 1,3 17 | * 6: 1,2,3,6 18 | * 10: 1,2,5,10 19 | * 15: 1,3,5,15 20 | * 21: 1,3,7,21 21 | * 28: 1,2,4,7,14,28 22 | * 23 | * We can see that 28 is the first triangle number to have over five divisors. 24 | * 25 | * What is the value of the first triangle number to have over five hundred divisors? 26 | */ 27 | 28 | int divisors(int triangle){ 29 | int count=0; 30 | for (int i = (int)sqrt(triangle); i > 0; i--) 31 | { 32 | if (triangle % i == 0) 33 | { 34 | count++; 35 | } 36 | } 37 | return 2*count; 38 | } 39 | 40 | int main() { 41 | int row = 0, triangle = 0, count = 0, max = 500; 42 | 43 | while(count < max){ 44 | triangle += row++; 45 | count = divisors(triangle); 46 | } 47 | 48 | printf("%d has the required divisors greater than %d with %d total divisors\n", triangle, max, count); 49 | return 0; 50 | } -------------------------------------------------------------------------------- /ProjectEulerSolutions/13-large_sum.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | /** 4 | * Project Euler Problem 13 5 | * 6 | * Work out the first ten digits of the sum of the following one-hundred 50-digit numbers. 7 | */ 8 | 9 | int main() { 10 | char numbers[100][51] = 11 | { 12 | "37107287533902102798797998220837590246510135740250", 13 | "46376937677490009712648124896970078050417018260538", 14 | "74324986199524741059474233309513058123726617309629", 15 | "91942213363574161572522430563301811072406154908250", 16 | "23067588207539346171171980310421047513778063246676", 17 | "89261670696623633820136378418383684178734361726757", 18 | "28112879812849979408065481931592621691275889832738", 19 | "44274228917432520321923589422876796487670272189318", 20 | "47451445736001306439091167216856844588711603153276", 21 | "70386486105843025439939619828917593665686757934951", 22 | "62176457141856560629502157223196586755079324193331", 23 | "64906352462741904929101432445813822663347944758178", 24 | "92575867718337217661963751590579239728245598838407", 25 | "58203565325359399008402633568948830189458628227828", 26 | "80181199384826282014278194139940567587151170094390", 27 | "35398664372827112653829987240784473053190104293586", 28 | "86515506006295864861532075273371959191420517255829", 29 | "71693888707715466499115593487603532921714970056938", 30 | "54370070576826684624621495650076471787294438377604", 31 | "53282654108756828443191190634694037855217779295145", 32 | "36123272525000296071075082563815656710885258350721", 33 | "45876576172410976447339110607218265236877223636045", 34 | "17423706905851860660448207621209813287860733969412", 35 | "81142660418086830619328460811191061556940512689692", 36 | "51934325451728388641918047049293215058642563049483", 37 | "62467221648435076201727918039944693004732956340691", 38 | "15732444386908125794514089057706229429197107928209", 39 | "55037687525678773091862540744969844508330393682126", 40 | "18336384825330154686196124348767681297534375946515", 41 | "80386287592878490201521685554828717201219257766954", 42 | "78182833757993103614740356856449095527097864797581", 43 | "16726320100436897842553539920931837441497806860984", 44 | "48403098129077791799088218795327364475675590848030", 45 | "87086987551392711854517078544161852424320693150332", 46 | "59959406895756536782107074926966537676326235447210", 47 | "69793950679652694742597709739166693763042633987085", 48 | "41052684708299085211399427365734116182760315001271", 49 | "65378607361501080857009149939512557028198746004375", 50 | "35829035317434717326932123578154982629742552737307", 51 | "94953759765105305946966067683156574377167401875275", 52 | "88902802571733229619176668713819931811048770190271", 53 | "25267680276078003013678680992525463401061632866526", 54 | "36270218540497705585629946580636237993140746255962", 55 | "24074486908231174977792365466257246923322810917141", 56 | "91430288197103288597806669760892938638285025333403", 57 | "34413065578016127815921815005561868836468420090470", 58 | "23053081172816430487623791969842487255036638784583", 59 | "11487696932154902810424020138335124462181441773470", 60 | "63783299490636259666498587618221225225512486764533", 61 | "67720186971698544312419572409913959008952310058822", 62 | "95548255300263520781532296796249481641953868218774", 63 | "76085327132285723110424803456124867697064507995236", 64 | "37774242535411291684276865538926205024910326572967", 65 | "23701913275725675285653248258265463092207058596522", 66 | "29798860272258331913126375147341994889534765745501", 67 | "18495701454879288984856827726077713721403798879715", 68 | "38298203783031473527721580348144513491373226651381", 69 | "34829543829199918180278916522431027392251122869539", 70 | "40957953066405232632538044100059654939159879593635", 71 | "29746152185502371307642255121183693803580388584903", 72 | "41698116222072977186158236678424689157993532961922", 73 | "62467957194401269043877107275048102390895523597457", 74 | "23189706772547915061505504953922979530901129967519", 75 | "86188088225875314529584099251203829009407770775672", 76 | "11306739708304724483816533873502340845647058077308", 77 | "82959174767140363198008187129011875491310547126581", 78 | "97623331044818386269515456334926366572897563400500", 79 | "42846280183517070527831839425882145521227251250327", 80 | "55121603546981200581762165212827652751691296897789", 81 | "32238195734329339946437501907836945765883352399886", 82 | "75506164965184775180738168837861091527357929701337", 83 | "62177842752192623401942399639168044983993173312731", 84 | "32924185707147349566916674687634660915035914677504", 85 | "99518671430235219628894890102423325116913619626622", 86 | "73267460800591547471830798392868535206946944540724", 87 | "76841822524674417161514036427982273348055556214818", 88 | "97142617910342598647204516893989422179826088076852", 89 | "87783646182799346313767754307809363333018982642090", 90 | "10848802521674670883215120185883543223812876952786", 91 | "71329612474782464538636993009049310363619763878039", 92 | "62184073572399794223406235393808339651327408011116", 93 | "66627891981488087797941876876144230030984490851411", 94 | "60661826293682836764744779239180335110989069790714", 95 | "85786944089552990653640447425576083659976645795096", 96 | "66024396409905389607120198219976047599490197230297", 97 | "64913982680032973156037120041377903785566085089252", 98 | "16730939319872750275468906903707539413042652315011", 99 | "94809377245048795150954100921645863754710598436791", 100 | "78639167021187492431995700641917969777599028300699", 101 | "15368713711936614952811305876380278410754449733078", 102 | "40789923115535562561142322423255033685442488917353", 103 | "44889911501440648020369068063960672322193204149535", 104 | "41503128880339536053299340368006977710650566631954", 105 | "81234880673210146739058568557934581403627822703280", 106 | "82616570773948327592232845941706525094512325230608", 107 | "22918802058777319719839450180888072429661980811197", 108 | "77158542502016545090413245809786882778948721859617", 109 | "72107838435069186155435662884062257473692284509516", 110 | "20849603980134001723930671666823555245252804609722", 111 | "53503534226472524250874054075591789781264330331690" 112 | }; 113 | 114 | int sums[100]; 115 | int offset = 50; 116 | for(int i = 0; i < 100; i++) 117 | { 118 | sums[i] = 0; 119 | } 120 | 121 | for(int row = 0; row < 100; row++) 122 | { 123 | for(int column = 0; column < 50; column++) 124 | { 125 | sums[column + offset] += numbers[row][column] - '0'; 126 | } 127 | } 128 | 129 | for(int i = 99; i > 0; i--) 130 | { 131 | sums[i - 1] += sums[i]/10; 132 | sums[i] %= 10; 133 | } 134 | 135 | for(int i = 0; i <100; i++) 136 | { 137 | if(sums[i] > 0) 138 | { 139 | offset = i; 140 | break; 141 | } 142 | } 143 | 144 | for(int i = offset; i < offset + 10; i++) 145 | { 146 | printf("%d", sums[i]); 147 | } 148 | printf("\n"); 149 | 150 | return 0; 151 | } -------------------------------------------------------------------------------- /ProjectEulerSolutions/14-longest_collatz_sequence.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | /** 4 | * The following iterative sequence is defined for the set of positive integers: 5 | * 6 | * n => n/2 (n is even) 7 | * n => 3n + 1 (n is odd) 8 | * 9 | * Using the rule above and starting with 13, we generate the following sequence: 10 | * 13 => 40 => 20 => 10 => 5 => 16 => 8 => 4 => 2 => 1 11 | * 12 | * It can be seen that this sequence (starting at 13 and finishing at 1) contains 13 | * 10 terms. Although it has not been proved yet (Collatz Problem), it is thought 14 | * that all starting numbers finish at 1. 15 | * 16 | * Which starting number, under one million, produces the longest chain? 17 | * 18 | * NOTE: Once the chain starts the terms are allowed to go above one million. 19 | */ 20 | int main() 21 | { 22 | int longest = 0; 23 | int terms = 0; 24 | int i; 25 | unsigned long j; 26 | 27 | for (i = 1; i <= 1000000; i++) 28 | { 29 | j = (unsigned long)i; 30 | int this_terms = 1; 31 | 32 | while (j != 1) 33 | { 34 | this_terms++; 35 | 36 | if (this_terms > terms) 37 | { 38 | terms = this_terms; 39 | longest = i; 40 | } 41 | 42 | j = (j % 2 == 0) 43 | ? j / 2 44 | : 3 * j + 1; 45 | } 46 | } 47 | 48 | printf("number under 1,000,000 producing the longest chain: %d (%d terms)\n", longest, terms); 49 | return 0; 50 | } -------------------------------------------------------------------------------- /ProjectEulerSolutions/15-lattice_paths.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define MATRIX_SIZE 21 3 | 4 | /** 5 | * Starting in the top left corner of a 2×2 grid, and only being able to move to the 6 | * right and down, there are exactly 6 routes to the bottom right corner. 7 | * 8 | * How many such routes are there through a 20×20 grid? 9 | */ 10 | int main() { 11 | long long int matrix[MATRIX_SIZE][MATRIX_SIZE]; 12 | 13 | for(int i=0; i<=MATRIX_SIZE-1; i++) 14 | { 15 | matrix[MATRIX_SIZE-1][i]=1; 16 | matrix[i][MATRIX_SIZE-1]=1; 17 | } 18 | 19 | for(int i=MATRIX_SIZE-2; i>=0; i--) { 20 | for (int j = MATRIX_SIZE - 2; j >= 0; j--) { 21 | matrix[i][j] = matrix[i + 1][j] + matrix[i][j + 1]; 22 | } 23 | } 24 | 25 | printf("Number of routes is: %lld\n", matrix[0][0]); 26 | } -------------------------------------------------------------------------------- /ProjectEulerSolutions/2-even -fibonacci-numbers.c: -------------------------------------------------------------------------------- 1 | #include 2 | /* 3 | 4 | Task:Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, 5 | the first 10 terms will be: 6 | 7 | 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ... 8 | 9 | By considering the terms in the Fibonacci sequence whose values do not exceed four million, 10 | find the sum of the even-valued terms. 11 | 12 | */ 13 | 14 | long long even_fibonacci_sum(){ 15 | int first_f = 1; 16 | int second_f = 2; 17 | 18 | int next_f; 19 | long long sum = second_f; 20 | while(1){ 21 | next_f = first_f + second_f; 22 | if(next_f > 4000000) 23 | break; 24 | first_f = second_f; 25 | second_f = next_f; 26 | //equivalent to if (next_f % 2 == 0) sum += next_f 27 | sum += (next_f % 2 == 0) * next_f; 28 | } 29 | return sum; 30 | //4613732 31 | } 32 | 33 | int main(){ 34 | printf("%ld\n", even_fibonacci_sum()); 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /ProjectEulerSolutions/3-largest-prime-factor.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | /* 5 | 6 | Find maximum prime factor of number num 7 | 8 | */ 9 | int isPrime(int x){ 10 | 11 | int i,prime = 1; 12 | for (i = 2; i < x && prime; i++){ 13 | if (!(x%i)) prime = 0; 14 | } 15 | return prime; 16 | } 17 | 18 | int main() 19 | { 20 | long num = 600851475143; 21 | int max_prime = 0; 22 | 23 | int i = 3; 24 | while (num != 1){ 25 | if (!(num % i) && isPrime(i)){ 26 | num /= i; 27 | if (i > max_prime) max_prime = i; 28 | } 29 | i++; 30 | 31 | } 32 | printf("%d\n",max_prime); 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /ProjectEulerSolutions/4-largest_palindrome _product.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define Ndigits 8 5 | 6 | int CheckPalindrome(int num) 7 | { 8 | int i=0,n1=0,n2=num; 9 | while(num!=0) 10 | { 11 | n1=n1*10+num%10; 12 | num=num/10; 13 | } 14 | if(n1==n2) 15 | return 1; 16 | return 0; 17 | 18 | } 19 | 20 | void main() 21 | { 22 | int mn=900,i,j,num; 23 | for(mn=900;mn>=0;mn=mn-100) 24 | { 25 | for(i=99;i>=0;i--) 26 | { 27 | for(j=i;j>=0;j--) 28 | { 29 | num=mn*mn+mn*(i+j)+i*j; 30 | if(CheckPalindrome(num)) 31 | { 32 | printf("The Largest Possible Palindrome is %d \n",num); 33 | printf("The two multiples are %d and %d.\n",mn+i,mn+j); 34 | exit(0); 35 | } 36 | } 37 | } 38 | } 39 | } 40 | 41 | 42 | 43 | -------------------------------------------------------------------------------- /ProjectEulerSolutions/5-smallest-multiple.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | /* 5 | Find minimum number evenly divisible with every number from [1..20] 6 | */ 7 | int main() 8 | { 9 | long num = 20; int found = 0,i,divisible = 1; 10 | while (!found){ 11 | 12 | for(i = 1; i <= 20 && divisible; i++){ 13 | if (num % i != 0) divisible = 0; 14 | } 15 | if (divisible){ 16 | found = divisible; 17 | } else{ 18 | 19 | num++; 20 | divisible = 1; 21 | 22 | } 23 | } 24 | printf("%ld\n",num); 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /ProjectEulerSolutions/6-sum-square-difference.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | /* 5 | Target value = (sum(1...100))^2 - sum(1^2..100^2) 6 | 7 | */ 8 | int main() 9 | { 10 | int suma_squared = 0,squared_suma = 0,i; 11 | for (i = 1; i <= 100; i++){ 12 | 13 | suma_squared += i; 14 | squared_suma += i*i; 15 | 16 | } 17 | 18 | printf("%d\n",abs(suma_squared*suma_squared-squared_suma)); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /ProjectEulerSolutions/7-10001-prime.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | /* 4 | 5 | Find 10001. prime number ---> regard 2 as first prime 6 | 7 | */ 8 | 9 | int isPrime(int x){ 10 | 11 | int i,prime = 1; 12 | for (i = 2; i < x && prime; i++) 13 | if (!(x%i)) prime = 0; 14 | return prime; 15 | 16 | 17 | 18 | } 19 | int findPrime(){ 20 | int num = 2, primeNum = 0; 21 | while (primeNum < 10001){ 22 | 23 | if (isPrime(num)) primeNum++; 24 | num++; 25 | 26 | } 27 | return --num; 28 | } 29 | 30 | int main() 31 | { 32 | printf("Result = %d\n",findPrime()); 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /ProjectEulerSolutions/AlgorithmsToDo.md: -------------------------------------------------------------------------------- 1 | # Project Euler Solutions - TO DO 2 | - Solve any Project Euler problem -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # C Algorithms 2 | ### All algorithms implemented in C (for learning) 3 | Contribute algorithms written in C language. It's beginner friendly! Feel free to add new algorithms or open an issue and commit if you have a more efficient way of implementing an algorithm. You can 4 | 5 | ## Getting Started 6 | - **Fork** this repository (Click the 'Fork' button, top right of this page) 7 | - **Clone** your forked copy of this repo down to your local machine: 8 | ``` 9 | git clone https://github.com//C-Algorithms.git 10 | ``` 11 | - **Change directory** to get inside repository: 12 | ``` 13 | cd C-Algorithms 14 | ``` 15 | - **Create a branch** for a new algorithm contribution: 16 | ``` 17 | git checkout -b feature/ 18 | ``` 19 | - *Or* if its a bugfix to a file: 20 | ``` 21 | git checkout -b bugfix/ 22 | ``` 23 | - Make your changes locally 24 | - **Stage** and **commit** changes: 25 | ``` 26 | git add . 27 | git commit -m 'commit message' 28 | ``` 29 | - **Push** changes to GitHub: 30 | ``` 31 | git push origin 32 | ``` 33 | - Create a **New Pull Request** (PR) from your forked repository on GitHub (Click the 'New Pull Request' Button located at the top of your repo) 34 | - Wait for your PR review and merge approval! 35 | - ***Star this repository*** if you had fun! :) 36 | 37 | ### Syncing Forked repo with Original repo: 38 | ``` 39 | git remote add upstream https://github.com/PawanKolhe/C-Algorithms.git 40 | git pull upstream master 41 | ``` 42 | 43 | ## New to Open Source? 44 | Check out the following resources: 45 | - [How to Create a Pull Request](https://www.digitalocean.com/community/tutorials/how-to-create-a-pull-request-on-github) 46 | - [An Introduction to Open Source](https://www.digitalocean.com/community/tutorial_series/an-introduction-to-open-source) 47 | 48 | ## What to contribute? 49 | - You can check the [Issues](https://github.com/PawanKolhe/C-Algorithms/issues) tab on the top and comment on the one you want to work on. 50 | - You can also suggest addition of new algorithms. Just create an 'Issue' [here](https://github.com/PawanKolhe/C-Algorithms/issues). 51 | - You can also contribute your solutions to problems from LeetCode: [LeetCode](https://leetcode.com/problemset/algorithms/) 52 | - Place your code in '/LeetCodeSolutions' folder with *number* and *name* of the problem as the file name. 53 | - You can also contribute your solutions to problems from Project Euler: [Project Euler](https://projecteuler.net/archives) 54 | - Place your code in '/ProjectEulerSolutions' folder with *number* and *name* of the problem as the file name. 55 | -------------------------------------------------------------------------------- /Recursion/AlgorithmsToDo.md: -------------------------------------------------------------------------------- 1 | # Recursion - TO DO 2 | - Make any C program using recursion -------------------------------------------------------------------------------- /Recursion/Factorial_Of_A_Number.c: -------------------------------------------------------------------------------- 1 | #include 2 | long int multiplyNumbers(int n); 3 | int main() 4 | { 5 | int n; 6 | printf("Enter a positive integer: "); 7 | scanf("%d", &n); 8 | printf("Factorial of %d = %ld", n, multiplyNumbers(n)); 9 | return 0; 10 | } 11 | long int multiplyNumbers(int n) 12 | { 13 | if (n >= 1) 14 | return n*multiplyNumbers(n-1); 15 | else 16 | return 1; 17 | } 18 | -------------------------------------------------------------------------------- /Searching/AlgorithmsToDo.md: -------------------------------------------------------------------------------- 1 | # Searching - TO DO 2 | - Binary search 3 | -------------------------------------------------------------------------------- /Searching/ExponentialSearch.c: -------------------------------------------------------------------------------- 1 | #include 2 | int binarySearch(int arr[], int, int, int); 3 | int exponentialSearch(int arr[], int n, int x) 4 | { 5 | // If x is present at firt location itself 6 | if (arr[0] == x) 7 | return 0; 8 | 9 | // Find range for binary search by 10 | // repeated doubling 11 | int i = 1; 12 | while (i < n && arr[i] <= x) 13 | i = i*2; 14 | 15 | // Call binary search for the found range. 16 | return binarySearch(arr, i/2, min(i, n), x); 17 | } 18 | 19 | // A recursive binary search function. It returns 20 | // location of x in given array arr[l..r] is 21 | // present, otherwise -1 22 | int binarySearch(int arr[], int l, int r, int x) 23 | { 24 | if (r >= l) 25 | { 26 | int mid = l + (r - l)/2; 27 | 28 | // If the element is present at the middle 29 | // itself 30 | if (arr[mid] == x) 31 | return mid; 32 | 33 | // If element is smaller than mid, then it 34 | // can only be present n left subarray 35 | if (arr[mid] > x) 36 | return binarySearch(arr, l, mid-1, x); 37 | 38 | // Else the element can only be present 39 | // in right subarray 40 | return binarySearch(arr, mid+1, r, x); 41 | } 42 | 43 | // We reach here when element is not present 44 | // in array 45 | return -1; 46 | } 47 | 48 | // Driver code 49 | int main(void) 50 | { 51 | int arr[] = {2, 3, 4, 10, 40}; 52 | int n = sizeof(arr)/ sizeof(arr[0]); 53 | int x = 10; 54 | int result = exponentialSearch(arr, n, x); 55 | (result == -1)? printf("Element is not present in array") 56 | : printf("Element is present at index %d", 57 | result); 58 | return 0; 59 | } -------------------------------------------------------------------------------- /Searching/InterpolationSearch.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int interpolationSearch(int arr[], int n, int x){ 4 | int low = 0, high = n-1; 5 | //For sorted array 6 | 7 | while (low <= high && x >= arr[low] && x <= arr[high]){ 8 | if (low == high){ 9 | if (x == arr[low]){ 10 | return low; 11 | } 12 | return -1; 13 | } 14 | 15 | int pos = low + (((double)(high-low)/(arr[high]-arr[low]))*(x-arr[low])); 16 | if (x == arr[pos]){ 17 | return pos; 18 | } 19 | if (x > arr[pos]){ 20 | low = pos+1; 21 | } 22 | else { 23 | high = pos-1; 24 | } 25 | 26 | } 27 | 28 | return -1; 29 | 30 | } 31 | 32 | int main(){ 33 | int arr[] = {10, 12, 13, 16, 18, 19, 20, 21, 22, 23, 34 | 24, 33, 35, 42, 47}; 35 | int n = sizeof(arr)/sizeof(arr[0]); 36 | 37 | int x = 18; // Element to be searched 38 | int index = interpolationSearch(arr, n, x); 39 | 40 | // If element was found 41 | if (-1 != index) printf("Element found at index %d", index); 42 | else printf("Element not found."); 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /Searching/Interpolation_Search.c: -------------------------------------------------------------------------------- 1 | #include 2 | int interpolationSearch(int arr[], int n, int x) 3 | { 4 | 5 | int lo = 0, hi = (n - 1); 6 | 7 | while (lo <= hi && x >= arr[lo] && x <= arr[hi]) 8 | { 9 | if (lo == hi){ 10 | if (arr[lo] == x) return lo; 11 | return -1; 12 | } 13 | int pos = lo + (((double)(hi-lo) / (arr[hi]-arr[lo]))*(x - arr[lo])); 14 | 15 | 16 | if (arr[pos] == x) 17 | return pos; 18 | 19 | if (arr[pos] < x) 20 | lo = pos + 1; 21 | 22 | else 23 | hi = pos - 1; 24 | } 25 | return -1; 26 | } 27 | int main(){ 28 | int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 29 | int n = 10; 30 | int key = 7; 31 | int idx = interpolationSearch(arr,n,key); 32 | if(idx !=-1) 33 | printf("Key is Found at index %d\n", idx); 34 | else 35 | printf("Key is Not Found\n"); 36 | } -------------------------------------------------------------------------------- /Searching/JumpSearch.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int jumpSearch(int arr[], int x, int n) 5 | { 6 | // Finding block size to be jumped 7 | int step = sqrt(n); 8 | 9 | // Finding the block where element is 10 | // present (if it is present) 11 | int prev = 0; 12 | while (arr[((step> n)?n:step)-1] < x) 13 | { 14 | prev = step; 15 | step += sqrt(n); 16 | if (prev >= n) 17 | return -1; 18 | } 19 | 20 | // Doing a linear search for x in block 21 | // beginning with prev. 22 | while (arr[prev] < x) 23 | { 24 | prev++; 25 | 26 | // If we reached next block or end of 27 | // array, element is not present. 28 | if (prev == ((step> n)?n:step)) 29 | return -1; 30 | } 31 | // If element is found 32 | if (arr[prev] == x) 33 | return prev; 34 | 35 | return -1; 36 | } 37 | 38 | int main() 39 | { 40 | int arr[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 41 | 34, 55, 89, 144, 233, 377, 610 }; 42 | int key = 55; 43 | int n = sizeof(arr) / sizeof(arr[0]); 44 | 45 | int idx = jumpSearch(arr, key, n); 46 | 47 | printf("Key %d is at index %d\n",key,idx); 48 | return 0; 49 | } -------------------------------------------------------------------------------- /Searching/LinearSearch.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int linearSearch(int arr[], int x, int n){ 4 | int i; 5 | for (i=0;i 2 | #include 3 | 4 | #define ARRAY_SIZE 10 5 | 6 | int binarySearch(int value, int values[], int n); 7 | 8 | int main (int argc, char* argv[]) 9 | { 10 | if(argc != 2) 11 | { 12 | printf("Usage: ./binarySearch value\n"); 13 | return 1; 14 | } 15 | 16 | int value = atoi(argv[1]); 17 | 18 | int array[ARRAY_SIZE] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 19 | 20 | if (binarySearch(value, array, ARRAY_SIZE)) 21 | { 22 | printf("Found!\n"); 23 | return 0; 24 | } 25 | else 26 | { 27 | printf("Not found!\n"); 28 | return 2; 29 | } 30 | 31 | return 0; 32 | } 33 | 34 | int binarySearch(int needle, int values[], int size) 35 | { 36 | int begin = 0; 37 | int end = size - 1; 38 | 39 | while(begin <= end) 40 | { 41 | int midpoint = (end + begin) / 2; 42 | 43 | if(needle == values[midpoint]) 44 | { 45 | return 1; 46 | } 47 | 48 | if(needle < values[midpoint]) 49 | { 50 | end = midpoint - 1; 51 | } 52 | if(needle > values[midpoint]) 53 | { 54 | begin = midpoint + 1; 55 | } 56 | } 57 | return 0; 58 | } 59 | -------------------------------------------------------------------------------- /Searching/fibonacchisearch.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | static int binsrch_geq(const int *arr, int n, int val) 6 | { 7 | register int low, high, mid; 8 | int geq; 9 | 10 | low=0; 11 | high=n-1; 12 | geq=-1; 13 | 14 | while(low<=high) 15 | { 16 | mid=(low+high)>>1; 17 | if(val arr[mid]) 23 | low=mid+1; 24 | else 25 | return mid; 26 | } 27 | 28 | return geq; 29 | } 30 | int fibsrch(const int *arr, int n, int val) 31 | { 32 | register int k, idx, offs; 33 | static int prevn=-1, prevk=-1; 34 | 35 | 36 | 37 | const static int Fib[47+1]= {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 38 | 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 39 | 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 40 | 433494437, 701408733, 1134903170, 1836311903, INT_MAX 41 | }; 42 | 43 | 44 | if(n!=prevn) 45 | { 46 | #if 1 47 | k=(n>1)? binsrch_geq(Fib, sizeof(Fib)/sizeof(int), n) : 1; 48 | #else 49 | #endif 50 | prevk=k; 51 | prevn=n; 52 | } 53 | else k=prevk; 54 | 55 | 56 | for(offs=0; k>0; ) 57 | { 58 | idx=offs+Fib[--k]; 59 | 60 | if(idx>=n || valarr[idx]) 63 | { 64 | offs=idx; 65 | --k; 66 | } 67 | else 68 | return idx; 69 | } 70 | 71 | return -1; 72 | } 73 | 74 | int main() 75 | { 76 | int data[]= {1, 4, 5, 7, 9, 11, 13, 16, 18, 20, 25, 27, 30, 32, 33, 36, 39, 41, 44, 47, 51, 53, 55}; 77 | int i, x, n; 78 | 79 | x = 30; 80 | n = sizeof(data)/sizeof(int); 81 | i = fibsrch(data, n, x); 82 | if(i>=0) 83 | printf("%d found at index %d\n", x, i); 84 | else 85 | printf("%d was not found\n", x); 86 | 87 | return 0; 88 | } -------------------------------------------------------------------------------- /Sorting/AlgorithmsToDo.md: -------------------------------------------------------------------------------- 1 | # Sorting - TO DO 2 | - Selection sort 3 | - Bubble sort 4 | - Insertion sort 5 | - Merge sort 6 | - Quick sort 7 | - Binary tree sort 8 | - Heap sort 9 | - Shell sort 10 | - Radix sort 11 | -------------------------------------------------------------------------------- /Sorting/Bubble_Sort.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | int a[50],n,i,j,temp; 6 | printf("Enter the size of array: "); 7 | scanf("%d",&n); 8 | printf("Enter the array elements: "); 9 | 10 | for(i=0;ia[j+1]) 16 | { 17 | temp=a[j]; 18 | a[j]=a[j+1]; 19 | a[j+1]=temp; 20 | } 21 | 22 | printf("\nArray after sorting: "); 23 | for(i=0;i 2 | 3 | #define MAXLEN 50 4 | 5 | void counting_sort(int[], int, int); 6 | 7 | int main() 8 | { 9 | int input_array[MAXLEN], n, i, max = 0; 10 | printf("How many elements? "); 11 | scanf("%d",&n); 12 | printf("\nEnter input_arrayay elements: "); 13 | 14 | /* read all elements */ 15 | for(i=0; i max) 18 | max = input_array[i]; 19 | } 20 | 21 | counting_sort(input_array, n, max); 22 | 23 | printf("\nArray after counting sort: "); 24 | 25 | for(i=0; i 2 | 3 | void counting_sort(int a[],int n,int max) 4 | { 5 | int count[50]={0},i,j; 6 | 7 | for(i=0;imax) 28 | max=a[i]; 29 | } 30 | 31 | counting_sort(a,n,max); 32 | return 0; 33 | } -------------------------------------------------------------------------------- /Sorting/Heap_Sort.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void heapSort(int *unsorted, int n); 4 | 5 | void heapify(int *unsorted, int index, int heap_size) { 6 | int temp; 7 | int largest = index; 8 | int left_index = 2 * index; 9 | int right_index = 2 * index + 1; 10 | 11 | if (left_index < heap_size && *(unsorted + left_index) > *(unsorted + largest)) { 12 | largest = left_index; 13 | } 14 | 15 | if (right_index < heap_size && *(unsorted + right_index) > *(unsorted + largest)) { 16 | largest = right_index; 17 | } 18 | 19 | if (largest != index) { 20 | temp = *(unsorted + largest); 21 | *(unsorted + largest) = *(unsorted + index); 22 | *(unsorted + index) = temp; 23 | heapify(unsorted, largest, heap_size); 24 | } 25 | } 26 | 27 | void heapSort(int *unsorted, int n) { 28 | int temp; 29 | for (int i = n / 2 - 1; i > -1; i--) { 30 | heapify(unsorted, i, n); 31 | } 32 | for (int i = n - 1; i > 0; i--) { 33 | temp = *(unsorted); 34 | *(unsorted) = *(unsorted + i); 35 | *(unsorted + i) = temp; 36 | heapify(unsorted, 0, i); 37 | } 38 | } 39 | 40 | int main() { 41 | int a[30],n,i; 42 | printf("Enter no of elements:"); 43 | scanf("%d",&n); 44 | printf("Enter array elements:"); 45 | 46 | for(i=0;i 2 | #include 3 | 4 | void insertionSort(int arr[], int n) 5 | { 6 | int i, key, j; 7 | for (i = 1; i < n; i++) { 8 | key = arr[i]; 9 | j = i - 1; 10 | 11 | while (j >= 0 && arr[j] > key) { 12 | arr[j + 1] = arr[j]; 13 | j = j - 1; 14 | } 15 | arr[j + 1] = key; 16 | } 17 | } 18 | 19 | void printArray(int arr[], int n) 20 | { 21 | int i; 22 | for (i = 0; i < n; i++) 23 | printf("%d ", arr[i]); 24 | printf("\n"); 25 | } 26 | 27 | int main() 28 | { 29 | int arr[] = { 12, 11, 13, 5, 6 }; 30 | int n = sizeof(arr) / sizeof(arr[0]); 31 | 32 | insertionSort(arr, n); 33 | printArray(arr, n); 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /Sorting/Merge_Sort.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void mergesort(int a[],int i,int j); 4 | void merge(int a[],int i1,int j1,int i2,int j2); 5 | 6 | int main() 7 | { 8 | int a[30],n,i; 9 | printf("Enter no of elements:"); 10 | scanf("%d",&n); 11 | printf("Enter array elements:"); 12 | 13 | for(i=0;i 2 | 3 | void quick_sort(int[],int,int); 4 | int partition(int[],int,int); 5 | 6 | int main() 7 | { 8 | int a[50],n,i; 9 | printf("How many elements?"); 10 | scanf("%d",&n); 11 | printf("\nEnter array elements:"); 12 | 13 | for(i=0;i 2 | 3 | void radixSort(int *array, int size); 4 | 5 | 6 | int findLargestNum(int *array, int size){ 7 | 8 | int i; 9 | int largestNum = -1; 10 | 11 | for(i = 0; i < size; i++){ 12 | if(array[i] > largestNum) 13 | largestNum = array[i]; 14 | } 15 | 16 | return largestNum; 17 | } 18 | 19 | void radixSort(int *array, int size) { 20 | 21 | // Base 10 is used 22 | int i; 23 | int semiSorted[size]; 24 | int significantDigit = 1; 25 | int largestNum = findLargestNum(array, size); 26 | 27 | // Loop until we reach the largest significant digit 28 | while (largestNum / significantDigit > 0){ 29 | 30 | int bucket[10] = { 0 }; 31 | 32 | // Counts the number of "keys" or digits that will go into each bucket 33 | for (i = 0; i < size; i++) 34 | bucket[(array[i] / significantDigit) % 10]++; 35 | 36 | /** 37 | * Add the count of the previous buckets, 38 | * Acquires the indexes after the end of each bucket location in the array 39 | * Works similar to the count sort algorithm 40 | **/ 41 | for (i = 1; i < 10; i++) 42 | bucket[i] += bucket[i - 1]; 43 | 44 | // Use the bucket to fill a "semiSorted" array 45 | for (i = size - 1; i >= 0; i--) 46 | semiSorted[--bucket[(array[i] / significantDigit) % 10]] = array[i]; 47 | 48 | 49 | for (i = 0; i < size; i++) 50 | array[i] = semiSorted[i]; 51 | 52 | // Move to next significant digit 53 | significantDigit *= 10; 54 | } 55 | } 56 | 57 | int main() { 58 | int a[30],n,i; 59 | printf("Enter no of elements:"); 60 | scanf("%d",&n); 61 | printf("Enter array elements:"); 62 | 63 | for(i=0;i 2 | 3 | void swap(int *xp, int *yp) 4 | { 5 | int temp = *xp; 6 | *xp = *yp; 7 | *yp = temp; 8 | } 9 | 10 | void selectionSort(int arr[], int n) 11 | { 12 | int i, j, min_idx; 13 | 14 | for (i = 0; i < n-1; i++) 15 | { 16 | min_idx = i; 17 | for (j = i+1; j < n; j++) 18 | if (arr[j] < arr[min_idx]) 19 | min_idx = j; 20 | swap(&arr[min_idx], &arr[i]); 21 | } 22 | } 23 | 24 | void printArray(int arr[], int size) 25 | { 26 | int i; 27 | for (i=0; i < size; i++) 28 | printf("%d ", arr[i]); 29 | printf("\n"); 30 | } 31 | 32 | int main() 33 | { 34 | int arr[] = {64, 25, 12, 22, 11}; 35 | int n = sizeof(arr)/sizeof(arr[0]); 36 | selectionSort(arr, n); 37 | printf("Sorted array: \n"); 38 | printArray(arr, n); 39 | return 0; 40 | } -------------------------------------------------------------------------------- /Sorting/Shell_Sort.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void shellsort(int arr[], int num) 4 | { 5 | int i, j, k, tmp; 6 | for (i = num / 2; i > 0; i = i / 2) 7 | { 8 | for (j = i; j < num; j++) 9 | { 10 | for(k = j - i; k >= 0; k = k - i) 11 | { 12 | if (arr[k+i] >= arr[k]) 13 | break; 14 | else 15 | { 16 | tmp = arr[k]; 17 | arr[k] = arr[k+i]; 18 | arr[k+i] = tmp; 19 | } 20 | } 21 | } 22 | } 23 | } 24 | 25 | int main() { 26 | int a[30],n,i; 27 | printf("Enter no of elements:"); 28 | scanf("%d",&n); 29 | printf("Enter array elements:"); 30 | 31 | for(i=0;i 2 | #include 3 | 4 | #define FALSE 0 5 | #define TRUE 1 6 | 7 | struct node 8 | { 9 | struct node *lchild; 10 | int info; 11 | struct node *rchild; 12 | int balance; 13 | }; 14 | 15 | void inorder(struct node *ptr); 16 | struct node *RotateLeft(struct node *pptr); 17 | struct node *RotateRight(struct node *pptr); 18 | 19 | struct node *insert(struct node *pptr, int ikey); 20 | struct node *insert_left_check(struct node *pptr, int *ptaller); 21 | struct node *insert_right_check(struct node *pptr, int *ptaller); 22 | struct node *insert_LeftBalance(struct node *pptr); 23 | struct node *insert_RightBalance(struct node *pptr); 24 | 25 | void display(struct node *ptr,int level); 26 | 27 | int main() 28 | { 29 | int choice,key; 30 | struct node *root = NULL; 31 | 32 | while(1) 33 | { 34 | printf("\n"); 35 | printf("1.Insert\n"); 36 | printf("2.Display\n"); 37 | printf("3.Quit\n"); 38 | 39 | printf("\nEnter your choice : "); 40 | scanf("%d",&choice); 41 | 42 | switch(choice) 43 | { 44 | case 1: 45 | printf("\nEnter the key to be inserted : "); 46 | scanf("%d",&key); 47 | root = insert(root,key); 48 | break; 49 | 50 | case 2: 51 | printf("\n"); 52 | display(root,0); 53 | printf("\n"); 54 | break; 55 | 56 | case 3: 57 | exit(1); 58 | 59 | default: 60 | printf("Wrong choice\n"); 61 | 62 | }/*End of switch */ 63 | }/*End of while */ 64 | 65 | return 0; 66 | 67 | }/*End of main()*/ 68 | 69 | 70 | struct node *insert(struct node *pptr, int ikey) 71 | { 72 | static int taller; 73 | if(pptr==NULL) /*Base case*/ 74 | { 75 | pptr = (struct node *) malloc(sizeof(struct node)); 76 | pptr->info = ikey; 77 | pptr->lchild = NULL; 78 | pptr->rchild = NULL; 79 | pptr->balance = 0; 80 | taller = TRUE; 81 | } 82 | else if(ikey < pptr->info) /*Insertion in left subtree*/ 83 | { 84 | pptr->lchild = insert(pptr->lchild, ikey); 85 | if(taller==TRUE) 86 | pptr = insert_left_check( pptr, &taller ); 87 | } 88 | else if(ikey > pptr->info) /*Insertion in right subtree */ 89 | { 90 | pptr->rchild = insert(pptr->rchild, ikey); 91 | if(taller==TRUE) 92 | pptr = insert_right_check(pptr, &taller); 93 | } 94 | else /*Base Case*/ 95 | { 96 | printf("Duplicate key\n"); 97 | taller = FALSE; 98 | } 99 | return pptr; 100 | }/*End of insert( )*/ 101 | 102 | struct node *insert_left_check(struct node *pptr, int *ptaller ) 103 | { 104 | switch(pptr->balance) 105 | { 106 | case 0: /* Case L_A : was balanced */ 107 | pptr->balance = 1; /* now left heavy */ 108 | break; 109 | case -1: /* Case L_B: was right heavy */ 110 | pptr->balance = 0; /* now balanced */ 111 | *ptaller = FALSE; 112 | break; 113 | case 1: /* Case L_C: was left heavy */ 114 | pptr = insert_LeftBalance(pptr); /* Left Balancing */ 115 | *ptaller = FALSE; 116 | } 117 | return pptr; 118 | }/*End of insert_left_check( )*/ 119 | 120 | struct node *insert_right_check(struct node *pptr, int *ptaller ) 121 | { 122 | switch(pptr->balance) 123 | { 124 | case 0: /* Case R_A : was balanced */ 125 | pptr->balance = -1; /* now right heavy */ 126 | break; 127 | case 1: /* Case R_B : was left heavy */ 128 | pptr->balance = 0; /* now balanced */ 129 | *ptaller = FALSE; 130 | break; 131 | case -1: /* Case R_C: Right heavy */ 132 | pptr = insert_RightBalance(pptr); /* Right Balancing */ 133 | *ptaller = FALSE; 134 | } 135 | return pptr; 136 | }/*End of insert_right_check( )*/ 137 | 138 | struct node *insert_LeftBalance(struct node *pptr) 139 | { 140 | struct node *aptr, *bptr; 141 | 142 | aptr = pptr->lchild; 143 | if(aptr->balance == 1) /* Case L_C1 : Insertion in AL */ 144 | { 145 | pptr->balance = 0; 146 | aptr->balance = 0; 147 | pptr = RotateRight(pptr); 148 | } 149 | else /* Case L_C2 : Insertion in AR */ 150 | { 151 | bptr = aptr->rchild; 152 | switch(bptr->balance) 153 | { 154 | case -1: /* Case L_C2a : Insertion in BR */ 155 | pptr->balance = 0; 156 | aptr->balance = 1; 157 | break; 158 | case 1: /* Case L_C2b : Insertion in BL */ 159 | pptr->balance = -1; 160 | aptr->balance = 0; 161 | break; 162 | case 0: /* Case L_C2c : B is the newly inserted node */ 163 | pptr->balance = 0; 164 | aptr->balance = 0; 165 | } 166 | bptr->balance = 0; 167 | pptr->lchild = RotateLeft(aptr); 168 | pptr = RotateRight(pptr); 169 | } 170 | return pptr; 171 | }/*End of insert_LeftBalance( )*/ 172 | 173 | struct node *insert_RightBalance(struct node *pptr) 174 | { 175 | struct node *aptr, *bptr; 176 | 177 | aptr = pptr->rchild; 178 | if(aptr->balance == -1) /* Case R_C1 : Insertion in AR */ 179 | { 180 | pptr->balance = 0; 181 | aptr->balance = 0; 182 | pptr = RotateLeft(pptr); 183 | } 184 | else /* Case R_C2 : Insertion in AL */ 185 | { 186 | bptr = aptr->lchild; 187 | switch(bptr->balance) 188 | { 189 | case -1: /* Case R_C2a : Insertion in BR */ 190 | pptr->balance = 1; 191 | aptr->balance = 0; 192 | break; 193 | case 1: /* Case R_C2b : Insertion in BL */ 194 | pptr->balance = 0; 195 | aptr->balance = -1; 196 | break; 197 | case 0: /* Case R_C2c : B is the newly inserted node */ 198 | pptr->balance = 0; 199 | aptr->balance = 0; 200 | } 201 | bptr->balance = 0; 202 | pptr->rchild = RotateRight(aptr); 203 | pptr = RotateLeft(pptr); 204 | } 205 | return pptr; 206 | }/*End of insert_RightBalance( )*/ 207 | 208 | struct node *RotateLeft(struct node *pptr) 209 | { 210 | struct node *aptr; 211 | aptr = pptr->rchild; /*A is right child of P*/ 212 | pptr->rchild = aptr->lchild; /*Left child of A becomes right child of P */ 213 | aptr->lchild = pptr; /*P becomes left child of A*/ 214 | return aptr; /*A is the new root of the subtree initially rooted at P*/ 215 | }/*End of RotateLeft( )*/ 216 | 217 | struct node *RotateRight(struct node *pptr) 218 | { 219 | struct node *aptr; 220 | aptr = pptr->lchild; /*A is left child of P */ 221 | pptr->lchild = aptr->rchild; /*Right child of A becomes left child of P*/ 222 | aptr->rchild = pptr; /*P becomes right child of A*/ 223 | return aptr; /*A is the new root of the subtree initially rooted at P*/ 224 | }/*End of RotateRight( )*/ 225 | 226 | 227 | void display(struct node *ptr,int level) 228 | { 229 | int i; 230 | if(ptr == NULL )/*Base Case*/ 231 | return; 232 | else 233 | { 234 | display(ptr->rchild, level+1); 235 | printf("\n"); 236 | for (i=0; iinfo); 239 | display(ptr->lchild, level+1); 240 | } 241 | }/*End of display()*/ 242 | -------------------------------------------------------------------------------- /Trees/AlgorithmsToDo.md: -------------------------------------------------------------------------------- 1 | # Trees - TO DO 2 | - Binary Search Tree -------------------------------------------------------------------------------- /Trees/Binary-Search-tree.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef struct BST 5 | { 6 | int data; 7 | struct BST *left; 8 | struct BST *right; 9 | }node; 10 | 11 | node *create(); 12 | void insert(node *,node *); 13 | void preorder(node *); 14 | 15 | int main() 16 | { 17 | char ch; 18 | node *root=NULL,*temp; 19 | 20 | do 21 | { 22 | temp=create(); 23 | if(root==NULL) 24 | root=temp; 25 | else 26 | insert(root,temp); 27 | 28 | printf("nDo you want to enter more(y/n)?"); 29 | getchar(); 30 | scanf("%c",&ch); 31 | }while(ch=='y'|ch=='Y'); 32 | 33 | printf("nPreorder Traversal: "); 34 | preorder(root); 35 | return 0; 36 | } 37 | 38 | node *create() 39 | { 40 | node *temp; 41 | printf("nEnter data:"); 42 | temp=(node*)malloc(sizeof(node)); 43 | scanf("%d",&temp->data); 44 | temp->left=temp->right=NULL; 45 | return temp; 46 | } 47 | 48 | void insert(node *root,node *temp) 49 | { 50 | if(temp->datadata) 51 | { 52 | if(root->left!=NULL) 53 | insert(root->left,temp); 54 | else 55 | root->left=temp; 56 | } 57 | 58 | if(temp->data>root->data) 59 | { 60 | if(root->right!=NULL) 61 | insert(root->right,temp); 62 | else 63 | root->right=temp; 64 | } 65 | } 66 | 67 | void preorder(node *root) 68 | { 69 | if(root!=NULL) 70 | { 71 | printf("%d ",root->data); 72 | preorder(root->left); 73 | preorder(root->right); 74 | } 75 | } 76 | -------------------------------------------------------------------------------- /Trees/DFS.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int a[20][20],reach[20],n; 4 | void dfs(int v) { 5 | int i; 6 | reach[v]=1; 7 | for (i=1;i<=n;i++) 8 | if(a[v][i] && !reach[i]) { 9 | printf("\n %d->%d",v,i); 10 | dfs(i); 11 | } 12 | } 13 | void main() { 14 | int i,j,count=0; 15 | clrscr(); 16 | printf("\n Enter number of vertices:"); 17 | scanf("%d",&n); 18 | for (i=1;i<=n;i++) { 19 | reach[i]=0; 20 | for (j=1;j<=n;j++) 21 | a[i][j]=0; 22 | } 23 | printf("\n Enter the adjacency matrix:\n"); 24 | for (i=1;i<=n;i++) 25 | for (j=1;j<=n;j++) 26 | scanf("%d",&a[i][j]); 27 | dfs(1); 28 | printf("\n"); 29 | for (i=1;i<=n;i++) { 30 | if(reach[i]) 31 | count++; 32 | } 33 | if(count==n) 34 | printf("\n Graph is connected"); 35 | else 36 | printf("\n Graph is not connected"); 37 | 38 | } 39 | -------------------------------------------------------------------------------- /p018-maximum-path-sum-i/maximumpath: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PawanKolhe/C-Algorithms/dd005e16fde4c2423f7afa1d125209e07a7a8e8e/p018-maximum-path-sum-i/maximumpath -------------------------------------------------------------------------------- /p018-maximum-path-sum-i/maximumpath.cpp: -------------------------------------------------------------------------------- 1 | // Project Euler 2019 2 | // Vinicius Rodrigues 17.10.2019 3 | // Maximum Path Sum I : Problem 18 4 | // R: 1074 5 | 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | using namespace std; 15 | 16 | const int size = 15; 17 | 18 | int main() 19 | { 20 | vector> matrix; 21 | string cmd; 22 | 23 | // input 24 | for(int i = 0; i < 15; i++) 25 | { 26 | matrix.push_back(vector()); 27 | for(int j = 0; j <= i; j++) 28 | { 29 | cin >> cmd; 30 | (--matrix.end()) -> push_back(atoi(cmd.c_str())); 31 | } 32 | } 33 | 34 | // varredura somando o maximo das duas celulas anteriores 35 | for(int i = 1; i < matrix.size(); i++) 36 | { 37 | for(int j = 0; j < matrix[i].size(); j++) 38 | { 39 | if(j != i and j > 0) 40 | matrix[i][j] += max(matrix[i-1][j], matrix[i-1][j-1]); 41 | else 42 | matrix[i][j] += j == i ? matrix[i-1][j-1] : matrix[i-1][j]; 43 | } 44 | } 45 | 46 | auto triBase = *(--matrix.end()); 47 | printf("%d\n", *max_element(triBase.begin(), triBase.end())); 48 | } 49 | -------------------------------------------------------------------------------- /p018-maximum-path-sum-i/path.in: -------------------------------------------------------------------------------- 1 | 75 2 | 95 64 3 | 17 47 82 4 | 18 35 87 10 5 | 20 04 82 47 65 6 | 19 01 23 75 03 34 7 | 88 02 77 73 07 63 67 8 | 99 65 04 28 06 16 70 92 9 | 41 41 26 56 83 40 80 70 33 10 | 41 48 72 33 47 32 37 16 94 29 11 | 53 71 44 65 25 43 91 52 97 51 14 12 | 70 11 33 28 77 73 17 78 39 68 17 57 13 | 91 71 52 38 17 14 91 43 58 50 27 29 48 14 | 63 66 04 68 89 53 67 30 73 16 69 87 40 31 15 | 04 62 98 27 23 09 70 98 73 93 38 53 60 04 23 16 | -------------------------------------------------------------------------------- /p022-names-scores/namesscores: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PawanKolhe/C-Algorithms/dd005e16fde4c2423f7afa1d125209e07a7a8e8e/p022-names-scores/namesscores -------------------------------------------------------------------------------- /p022-names-scores/namesscores.cpp: -------------------------------------------------------------------------------- 1 | // Project Euler 2019 2 | // Vinicius Rodrigues 20.10.2019 3 | // Names Scores : Problem 22 4 | 5 | 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | using namespace std; 14 | map charMap; 15 | 16 | vector split(const string& s, const char& c) 17 | { 18 | vector result; 19 | string aux = ""; 20 | for(int i = 0; i < s.length(); i++) 21 | { 22 | if(s[i] == c) 23 | { 24 | result.push_back(aux); 25 | aux = ""; 26 | } 27 | else 28 | aux += s[i]; 29 | } 30 | if(aux != "") 31 | result.push_back(aux); 32 | return result; 33 | } 34 | 35 | string strip(const string& s, const char& c) 36 | { 37 | string new_str = ""; 38 | auto i = s.begin(); 39 | while(*i == c and i != s.end()) 40 | i++; 41 | 42 | while(*i != c and i != s.end()) 43 | { 44 | new_str += *i; 45 | i++; 46 | } 47 | return new_str; 48 | } 49 | 50 | int calcPoints(const string& s) 51 | { 52 | int score = 0; 53 | for(auto i = s.begin(); i != s.end(); i++) 54 | score += charMap[*i]; 55 | return score; 56 | } 57 | 58 | int main() 59 | { 60 | ifstream file("p022_names.txt"); 61 | istream_iterator ii(file); 62 | string text = *ii; 63 | 64 | vector words = split(text, ','); 65 | for(int i = 0; i < words.size(); i++) 66 | words[i] = strip(words[i], '\"'); 67 | 68 | sort(words.begin(), words.end()); 69 | 70 | for(int i = 0; i < 'Z'-'A'+1; i++) 71 | charMap['A'+i] = i+1; 72 | 73 | int summation = 0; 74 | for(int i = 0; i < words.size(); i++) 75 | summation += calcPoints(words[i]) * (i+1); 76 | 77 | cout << summation << endl; 78 | } 79 | -------------------------------------------------------------------------------- /p022-names-scores/p022_names.txt: -------------------------------------------------------------------------------- 1 | "MARY","PATRICIA","LINDA","BARBARA","ELIZABETH","JENNIFER","MARIA","SUSAN","MARGARET","DOROTHY","LISA","NANCY","KAREN","BETTY","HELEN","SANDRA","DONNA","CAROL","RUTH","SHARON","MICHELLE","LAURA","SARAH","KIMBERLY","DEBORAH","JESSICA","SHIRLEY","CYNTHIA","ANGELA","MELISSA","BRENDA","AMY","ANNA","REBECCA","VIRGINIA","KATHLEEN","PAMELA","MARTHA","DEBRA","AMANDA","STEPHANIE","CAROLYN","CHRISTINE","MARIE","JANET","CATHERINE","FRANCES","ANN","JOYCE","DIANE","ALICE","JULIE","HEATHER","TERESA","DORIS","GLORIA","EVELYN","JEAN","CHERYL","MILDRED","KATHERINE","JOAN","ASHLEY","JUDITH","ROSE","JANICE","KELLY","NICOLE","JUDY","CHRISTINA","KATHY","THERESA","BEVERLY","DENISE","TAMMY","IRENE","JANE","LORI","RACHEL","MARILYN","ANDREA","KATHRYN","LOUISE","SARA","ANNE","JACQUELINE","WANDA","BONNIE","JULIA","RUBY","LOIS","TINA","PHYLLIS","NORMA","PAULA","DIANA","ANNIE","LILLIAN","EMILY","ROBIN","PEGGY","CRYSTAL","GLADYS","RITA","DAWN","CONNIE","FLORENCE","TRACY","EDNA","TIFFANY","CARMEN","ROSA","CINDY","GRACE","WENDY","VICTORIA","EDITH","KIM","SHERRY","SYLVIA","JOSEPHINE","THELMA","SHANNON","SHEILA","ETHEL","ELLEN","ELAINE","MARJORIE","CARRIE","CHARLOTTE","MONICA","ESTHER","PAULINE","EMMA","JUANITA","ANITA","RHONDA","HAZEL","AMBER","EVA","DEBBIE","APRIL","LESLIE","CLARA","LUCILLE","JAMIE","JOANNE","ELEANOR","VALERIE","DANIELLE","MEGAN","ALICIA","SUZANNE","MICHELE","GAIL","BERTHA","DARLENE","VERONICA","JILL","ERIN","GERALDINE","LAUREN","CATHY","JOANN","LORRAINE","LYNN","SALLY","REGINA","ERICA","BEATRICE","DOLORES","BERNICE","AUDREY","YVONNE","ANNETTE","JUNE","SAMANTHA","MARION","DANA","STACY","ANA","RENEE","IDA","VIVIAN","ROBERTA","HOLLY","BRITTANY","MELANIE","LORETTA","YOLANDA","JEANETTE","LAURIE","KATIE","KRISTEN","VANESSA","ALMA","SUE","ELSIE","BETH","JEANNE","VICKI","CARLA","TARA","ROSEMARY","EILEEN","TERRI","GERTRUDE","LUCY","TONYA","ELLA","STACEY","WILMA","GINA","KRISTIN","JESSIE","NATALIE","AGNES","VERA","WILLIE","CHARLENE","BESSIE","DELORES","MELINDA","PEARL","ARLENE","MAUREEN","COLLEEN","ALLISON","TAMARA","JOY","GEORGIA","CONSTANCE","LILLIE","CLAUDIA","JACKIE","MARCIA","TANYA","NELLIE","MINNIE","MARLENE","HEIDI","GLENDA","LYDIA","VIOLA","COURTNEY","MARIAN","STELLA","CAROLINE","DORA","JO","VICKIE","MATTIE","TERRY","MAXINE","IRMA","MABEL","MARSHA","MYRTLE","LENA","CHRISTY","DEANNA","PATSY","HILDA","GWENDOLYN","JENNIE","NORA","MARGIE","NINA","CASSANDRA","LEAH","PENNY","KAY","PRISCILLA","NAOMI","CAROLE","BRANDY","OLGA","BILLIE","DIANNE","TRACEY","LEONA","JENNY","FELICIA","SONIA","MIRIAM","VELMA","BECKY","BOBBIE","VIOLET","KRISTINA","TONI","MISTY","MAE","SHELLY","DAISY","RAMONA","SHERRI","ERIKA","KATRINA","CLAIRE","LINDSEY","LINDSAY","GENEVA","GUADALUPE","BELINDA","MARGARITA","SHERYL","CORA","FAYE","ADA","NATASHA","SABRINA","ISABEL","MARGUERITE","HATTIE","HARRIET","MOLLY","CECILIA","KRISTI","BRANDI","BLANCHE","SANDY","ROSIE","JOANNA","IRIS","EUNICE","ANGIE","INEZ","LYNDA","MADELINE","AMELIA","ALBERTA","GENEVIEVE","MONIQUE","JODI","JANIE","MAGGIE","KAYLA","SONYA","JAN","LEE","KRISTINE","CANDACE","FANNIE","MARYANN","OPAL","ALISON","YVETTE","MELODY","LUZ","SUSIE","OLIVIA","FLORA","SHELLEY","KRISTY","MAMIE","LULA","LOLA","VERNA","BEULAH","ANTOINETTE","CANDICE","JUANA","JEANNETTE","PAM","KELLI","HANNAH","WHITNEY","BRIDGET","KARLA","CELIA","LATOYA","PATTY","SHELIA","GAYLE","DELLA","VICKY","LYNNE","SHERI","MARIANNE","KARA","JACQUELYN","ERMA","BLANCA","MYRA","LETICIA","PAT","KRISTA","ROXANNE","ANGELICA","JOHNNIE","ROBYN","FRANCIS","ADRIENNE","ROSALIE","ALEXANDRA","BROOKE","BETHANY","SADIE","BERNADETTE","TRACI","JODY","KENDRA","JASMINE","NICHOLE","RACHAEL","CHELSEA","MABLE","ERNESTINE","MURIEL","MARCELLA","ELENA","KRYSTAL","ANGELINA","NADINE","KARI","ESTELLE","DIANNA","PAULETTE","LORA","MONA","DOREEN","ROSEMARIE","ANGEL","DESIREE","ANTONIA","HOPE","GINGER","JANIS","BETSY","CHRISTIE","FREDA","MERCEDES","MEREDITH","LYNETTE","TERI","CRISTINA","EULA","LEIGH","MEGHAN","SOPHIA","ELOISE","ROCHELLE","GRETCHEN","CECELIA","RAQUEL","HENRIETTA","ALYSSA","JANA","KELLEY","GWEN","KERRY","JENNA","TRICIA","LAVERNE","OLIVE","ALEXIS","TASHA","SILVIA","ELVIRA","CASEY","DELIA","SOPHIE","KATE","PATTI","LORENA","KELLIE","SONJA","LILA","LANA","DARLA","MAY","MINDY","ESSIE","MANDY","LORENE","ELSA","JOSEFINA","JEANNIE","MIRANDA","DIXIE","LUCIA","MARTA","FAITH","LELA","JOHANNA","SHARI","CAMILLE","TAMI","SHAWNA","ELISA","EBONY","MELBA","ORA","NETTIE","TABITHA","OLLIE","JAIME","WINIFRED","KRISTIE","MARINA","ALISHA","AIMEE","RENA","MYRNA","MARLA","TAMMIE","LATASHA","BONITA","PATRICE","RONDA","SHERRIE","ADDIE","FRANCINE","DELORIS","STACIE","ADRIANA","CHERI","SHELBY","ABIGAIL","CELESTE","JEWEL","CARA","ADELE","REBEKAH","LUCINDA","DORTHY","CHRIS","EFFIE","TRINA","REBA","SHAWN","SALLIE","AURORA","LENORA","ETTA","LOTTIE","KERRI","TRISHA","NIKKI","ESTELLA","FRANCISCA","JOSIE","TRACIE","MARISSA","KARIN","BRITTNEY","JANELLE","LOURDES","LAUREL","HELENE","FERN","ELVA","CORINNE","KELSEY","INA","BETTIE","ELISABETH","AIDA","CAITLIN","INGRID","IVA","EUGENIA","CHRISTA","GOLDIE","CASSIE","MAUDE","JENIFER","THERESE","FRANKIE","DENA","LORNA","JANETTE","LATONYA","CANDY","MORGAN","CONSUELO","TAMIKA","ROSETTA","DEBORA","CHERIE","POLLY","DINA","JEWELL","FAY","JILLIAN","DOROTHEA","NELL","TRUDY","ESPERANZA","PATRICA","KIMBERLEY","SHANNA","HELENA","CAROLINA","CLEO","STEFANIE","ROSARIO","OLA","JANINE","MOLLIE","LUPE","ALISA","LOU","MARIBEL","SUSANNE","BETTE","SUSANA","ELISE","CECILE","ISABELLE","LESLEY","JOCELYN","PAIGE","JONI","RACHELLE","LEOLA","DAPHNE","ALTA","ESTER","PETRA","GRACIELA","IMOGENE","JOLENE","KEISHA","LACEY","GLENNA","GABRIELA","KERI","URSULA","LIZZIE","KIRSTEN","SHANA","ADELINE","MAYRA","JAYNE","JACLYN","GRACIE","SONDRA","CARMELA","MARISA","ROSALIND","CHARITY","TONIA","BEATRIZ","MARISOL","CLARICE","JEANINE","SHEENA","ANGELINE","FRIEDA","LILY","ROBBIE","SHAUNA","MILLIE","CLAUDETTE","CATHLEEN","ANGELIA","GABRIELLE","AUTUMN","KATHARINE","SUMMER","JODIE","STACI","LEA","CHRISTI","JIMMIE","JUSTINE","ELMA","LUELLA","MARGRET","DOMINIQUE","SOCORRO","RENE","MARTINA","MARGO","MAVIS","CALLIE","BOBBI","MARITZA","LUCILE","LEANNE","JEANNINE","DEANA","AILEEN","LORIE","LADONNA","WILLA","MANUELA","GALE","SELMA","DOLLY","SYBIL","ABBY","LARA","DALE","IVY","DEE","WINNIE","MARCY","LUISA","JERI","MAGDALENA","OFELIA","MEAGAN","AUDRA","MATILDA","LEILA","CORNELIA","BIANCA","SIMONE","BETTYE","RANDI","VIRGIE","LATISHA","BARBRA","GEORGINA","ELIZA","LEANN","BRIDGETTE","RHODA","HALEY","ADELA","NOLA","BERNADINE","FLOSSIE","ILA","GRETA","RUTHIE","NELDA","MINERVA","LILLY","TERRIE","LETHA","HILARY","ESTELA","VALARIE","BRIANNA","ROSALYN","EARLINE","CATALINA","AVA","MIA","CLARISSA","LIDIA","CORRINE","ALEXANDRIA","CONCEPCION","TIA","SHARRON","RAE","DONA","ERICKA","JAMI","ELNORA","CHANDRA","LENORE","NEVA","MARYLOU","MELISA","TABATHA","SERENA","AVIS","ALLIE","SOFIA","JEANIE","ODESSA","NANNIE","HARRIETT","LORAINE","PENELOPE","MILAGROS","EMILIA","BENITA","ALLYSON","ASHLEE","TANIA","TOMMIE","ESMERALDA","KARINA","EVE","PEARLIE","ZELMA","MALINDA","NOREEN","TAMEKA","SAUNDRA","HILLARY","AMIE","ALTHEA","ROSALINDA","JORDAN","LILIA","ALANA","GAY","CLARE","ALEJANDRA","ELINOR","MICHAEL","LORRIE","JERRI","DARCY","EARNESTINE","CARMELLA","TAYLOR","NOEMI","MARCIE","LIZA","ANNABELLE","LOUISA","EARLENE","MALLORY","CARLENE","NITA","SELENA","TANISHA","KATY","JULIANNE","JOHN","LAKISHA","EDWINA","MARICELA","MARGERY","KENYA","DOLLIE","ROXIE","ROSLYN","KATHRINE","NANETTE","CHARMAINE","LAVONNE","ILENE","KRIS","TAMMI","SUZETTE","CORINE","KAYE","JERRY","MERLE","CHRYSTAL","LINA","DEANNE","LILIAN","JULIANA","ALINE","LUANN","KASEY","MARYANNE","EVANGELINE","COLETTE","MELVA","LAWANDA","YESENIA","NADIA","MADGE","KATHIE","EDDIE","OPHELIA","VALERIA","NONA","MITZI","MARI","GEORGETTE","CLAUDINE","FRAN","ALISSA","ROSEANN","LAKEISHA","SUSANNA","REVA","DEIDRE","CHASITY","SHEREE","CARLY","JAMES","ELVIA","ALYCE","DEIRDRE","GENA","BRIANA","ARACELI","KATELYN","ROSANNE","WENDI","TESSA","BERTA","MARVA","IMELDA","MARIETTA","MARCI","LEONOR","ARLINE","SASHA","MADELYN","JANNA","JULIETTE","DEENA","AURELIA","JOSEFA","AUGUSTA","LILIANA","YOUNG","CHRISTIAN","LESSIE","AMALIA","SAVANNAH","ANASTASIA","VILMA","NATALIA","ROSELLA","LYNNETTE","CORINA","ALFREDA","LEANNA","CAREY","AMPARO","COLEEN","TAMRA","AISHA","WILDA","KARYN","CHERRY","QUEEN","MAURA","MAI","EVANGELINA","ROSANNA","HALLIE","ERNA","ENID","MARIANA","LACY","JULIET","JACKLYN","FREIDA","MADELEINE","MARA","HESTER","CATHRYN","LELIA","CASANDRA","BRIDGETT","ANGELITA","JANNIE","DIONNE","ANNMARIE","KATINA","BERYL","PHOEBE","MILLICENT","KATHERYN","DIANN","CARISSA","MARYELLEN","LIZ","LAURI","HELGA","GILDA","ADRIAN","RHEA","MARQUITA","HOLLIE","TISHA","TAMERA","ANGELIQUE","FRANCESCA","BRITNEY","KAITLIN","LOLITA","FLORINE","ROWENA","REYNA","TWILA","FANNY","JANELL","INES","CONCETTA","BERTIE","ALBA","BRIGITTE","ALYSON","VONDA","PANSY","ELBA","NOELLE","LETITIA","KITTY","DEANN","BRANDIE","LOUELLA","LETA","FELECIA","SHARLENE","LESA","BEVERLEY","ROBERT","ISABELLA","HERMINIA","TERRA","CELINA","TORI","OCTAVIA","JADE","DENICE","GERMAINE","SIERRA","MICHELL","CORTNEY","NELLY","DORETHA","SYDNEY","DEIDRA","MONIKA","LASHONDA","JUDI","CHELSEY","ANTIONETTE","MARGOT","BOBBY","ADELAIDE","NAN","LEEANN","ELISHA","DESSIE","LIBBY","KATHI","GAYLA","LATANYA","MINA","MELLISA","KIMBERLEE","JASMIN","RENAE","ZELDA","ELDA","MA","JUSTINA","GUSSIE","EMILIE","CAMILLA","ABBIE","ROCIO","KAITLYN","JESSE","EDYTHE","ASHLEIGH","SELINA","LAKESHA","GERI","ALLENE","PAMALA","MICHAELA","DAYNA","CARYN","ROSALIA","SUN","JACQULINE","REBECA","MARYBETH","KRYSTLE","IOLA","DOTTIE","BENNIE","BELLE","AUBREY","GRISELDA","ERNESTINA","ELIDA","ADRIANNE","DEMETRIA","DELMA","CHONG","JAQUELINE","DESTINY","ARLEEN","VIRGINA","RETHA","FATIMA","TILLIE","ELEANORE","CARI","TREVA","BIRDIE","WILHELMINA","ROSALEE","MAURINE","LATRICE","YONG","JENA","TARYN","ELIA","DEBBY","MAUDIE","JEANNA","DELILAH","CATRINA","SHONDA","HORTENCIA","THEODORA","TERESITA","ROBBIN","DANETTE","MARYJANE","FREDDIE","DELPHINE","BRIANNE","NILDA","DANNA","CINDI","BESS","IONA","HANNA","ARIEL","WINONA","VIDA","ROSITA","MARIANNA","WILLIAM","RACHEAL","GUILLERMINA","ELOISA","CELESTINE","CAREN","MALISSA","LONA","CHANTEL","SHELLIE","MARISELA","LEORA","AGATHA","SOLEDAD","MIGDALIA","IVETTE","CHRISTEN","ATHENA","JANEL","CHLOE","VEDA","PATTIE","TESSIE","TERA","MARILYNN","LUCRETIA","KARRIE","DINAH","DANIELA","ALECIA","ADELINA","VERNICE","SHIELA","PORTIA","MERRY","LASHAWN","DEVON","DARA","TAWANA","OMA","VERDA","CHRISTIN","ALENE","ZELLA","SANDI","RAFAELA","MAYA","KIRA","CANDIDA","ALVINA","SUZAN","SHAYLA","LYN","LETTIE","ALVA","SAMATHA","ORALIA","MATILDE","MADONNA","LARISSA","VESTA","RENITA","INDIA","DELOIS","SHANDA","PHILLIS","LORRI","ERLINDA","CRUZ","CATHRINE","BARB","ZOE","ISABELL","IONE","GISELA","CHARLIE","VALENCIA","ROXANNA","MAYME","KISHA","ELLIE","MELLISSA","DORRIS","DALIA","BELLA","ANNETTA","ZOILA","RETA","REINA","LAURETTA","KYLIE","CHRISTAL","PILAR","CHARLA","ELISSA","TIFFANI","TANA","PAULINA","LEOTA","BREANNA","JAYME","CARMEL","VERNELL","TOMASA","MANDI","DOMINGA","SANTA","MELODIE","LURA","ALEXA","TAMELA","RYAN","MIRNA","KERRIE","VENUS","NOEL","FELICITA","CRISTY","CARMELITA","BERNIECE","ANNEMARIE","TIARA","ROSEANNE","MISSY","CORI","ROXANA","PRICILLA","KRISTAL","JUNG","ELYSE","HAYDEE","ALETHA","BETTINA","MARGE","GILLIAN","FILOMENA","CHARLES","ZENAIDA","HARRIETTE","CARIDAD","VADA","UNA","ARETHA","PEARLINE","MARJORY","MARCELA","FLOR","EVETTE","ELOUISE","ALINA","TRINIDAD","DAVID","DAMARIS","CATHARINE","CARROLL","BELVA","NAKIA","MARLENA","LUANNE","LORINE","KARON","DORENE","DANITA","BRENNA","TATIANA","SAMMIE","LOUANN","LOREN","JULIANNA","ANDRIA","PHILOMENA","LUCILA","LEONORA","DOVIE","ROMONA","MIMI","JACQUELIN","GAYE","TONJA","MISTI","JOE","GENE","CHASTITY","STACIA","ROXANN","MICAELA","NIKITA","MEI","VELDA","MARLYS","JOHNNA","AURA","LAVERN","IVONNE","HAYLEY","NICKI","MAJORIE","HERLINDA","GEORGE","ALPHA","YADIRA","PERLA","GREGORIA","DANIEL","ANTONETTE","SHELLI","MOZELLE","MARIAH","JOELLE","CORDELIA","JOSETTE","CHIQUITA","TRISTA","LOUIS","LAQUITA","GEORGIANA","CANDI","SHANON","LONNIE","HILDEGARD","CECIL","VALENTINA","STEPHANY","MAGDA","KAROL","GERRY","GABRIELLA","TIANA","ROMA","RICHELLE","RAY","PRINCESS","OLETA","JACQUE","IDELLA","ALAINA","SUZANNA","JOVITA","BLAIR","TOSHA","RAVEN","NEREIDA","MARLYN","KYLA","JOSEPH","DELFINA","TENA","STEPHENIE","SABINA","NATHALIE","MARCELLE","GERTIE","DARLEEN","THEA","SHARONDA","SHANTEL","BELEN","VENESSA","ROSALINA","ONA","GENOVEVA","COREY","CLEMENTINE","ROSALBA","RENATE","RENATA","MI","IVORY","GEORGIANNA","FLOY","DORCAS","ARIANA","TYRA","THEDA","MARIAM","JULI","JESICA","DONNIE","VIKKI","VERLA","ROSELYN","MELVINA","JANNETTE","GINNY","DEBRAH","CORRIE","ASIA","VIOLETA","MYRTIS","LATRICIA","COLLETTE","CHARLEEN","ANISSA","VIVIANA","TWYLA","PRECIOUS","NEDRA","LATONIA","LAN","HELLEN","FABIOLA","ANNAMARIE","ADELL","SHARYN","CHANTAL","NIKI","MAUD","LIZETTE","LINDY","KIA","KESHA","JEANA","DANELLE","CHARLINE","CHANEL","CARROL","VALORIE","LIA","DORTHA","CRISTAL","SUNNY","LEONE","LEILANI","GERRI","DEBI","ANDRA","KESHIA","IMA","EULALIA","EASTER","DULCE","NATIVIDAD","LINNIE","KAMI","GEORGIE","CATINA","BROOK","ALDA","WINNIFRED","SHARLA","RUTHANN","MEAGHAN","MAGDALENE","LISSETTE","ADELAIDA","VENITA","TRENA","SHIRLENE","SHAMEKA","ELIZEBETH","DIAN","SHANTA","MICKEY","LATOSHA","CARLOTTA","WINDY","SOON","ROSINA","MARIANN","LEISA","JONNIE","DAWNA","CATHIE","BILLY","ASTRID","SIDNEY","LAUREEN","JANEEN","HOLLI","FAWN","VICKEY","TERESSA","SHANTE","RUBYE","MARCELINA","CHANDA","CARY","TERESE","SCARLETT","MARTY","MARNIE","LULU","LISETTE","JENIFFER","ELENOR","DORINDA","DONITA","CARMAN","BERNITA","ALTAGRACIA","ALETA","ADRIANNA","ZORAIDA","RONNIE","NICOLA","LYNDSEY","KENDALL","JANINA","CHRISSY","AMI","STARLA","PHYLIS","PHUONG","KYRA","CHARISSE","BLANCH","SANJUANITA","RONA","NANCI","MARILEE","MARANDA","CORY","BRIGETTE","SANJUANA","MARITA","KASSANDRA","JOYCELYN","IRA","FELIPA","CHELSIE","BONNY","MIREYA","LORENZA","KYONG","ILEANA","CANDELARIA","TONY","TOBY","SHERIE","OK","MARK","LUCIE","LEATRICE","LAKESHIA","GERDA","EDIE","BAMBI","MARYLIN","LAVON","HORTENSE","GARNET","EVIE","TRESSA","SHAYNA","LAVINA","KYUNG","JEANETTA","SHERRILL","SHARA","PHYLISS","MITTIE","ANABEL","ALESIA","THUY","TAWANDA","RICHARD","JOANIE","TIFFANIE","LASHANDA","KARISSA","ENRIQUETA","DARIA","DANIELLA","CORINNA","ALANNA","ABBEY","ROXANE","ROSEANNA","MAGNOLIA","LIDA","KYLE","JOELLEN","ERA","CORAL","CARLEEN","TRESA","PEGGIE","NOVELLA","NILA","MAYBELLE","JENELLE","CARINA","NOVA","MELINA","MARQUERITE","MARGARETTE","JOSEPHINA","EVONNE","DEVIN","CINTHIA","ALBINA","TOYA","TAWNYA","SHERITA","SANTOS","MYRIAM","LIZABETH","LISE","KEELY","JENNI","GISELLE","CHERYLE","ARDITH","ARDIS","ALESHA","ADRIANE","SHAINA","LINNEA","KAROLYN","HONG","FLORIDA","FELISHA","DORI","DARCI","ARTIE","ARMIDA","ZOLA","XIOMARA","VERGIE","SHAMIKA","NENA","NANNETTE","MAXIE","LOVIE","JEANE","JAIMIE","INGE","FARRAH","ELAINA","CAITLYN","STARR","FELICITAS","CHERLY","CARYL","YOLONDA","YASMIN","TEENA","PRUDENCE","PENNIE","NYDIA","MACKENZIE","ORPHA","MARVEL","LIZBETH","LAURETTE","JERRIE","HERMELINDA","CAROLEE","TIERRA","MIRIAN","META","MELONY","KORI","JENNETTE","JAMILA","ENA","ANH","YOSHIKO","SUSANNAH","SALINA","RHIANNON","JOLEEN","CRISTINE","ASHTON","ARACELY","TOMEKA","SHALONDA","MARTI","LACIE","KALA","JADA","ILSE","HAILEY","BRITTANI","ZONA","SYBLE","SHERRYL","RANDY","NIDIA","MARLO","KANDICE","KANDI","DEB","DEAN","AMERICA","ALYCIA","TOMMY","RONNA","NORENE","MERCY","JOSE","INGEBORG","GIOVANNA","GEMMA","CHRISTEL","AUDRY","ZORA","VITA","VAN","TRISH","STEPHAINE","SHIRLEE","SHANIKA","MELONIE","MAZIE","JAZMIN","INGA","HOA","HETTIE","GERALYN","FONDA","ESTRELLA","ADELLA","SU","SARITA","RINA","MILISSA","MARIBETH","GOLDA","EVON","ETHELYN","ENEDINA","CHERISE","CHANA","VELVA","TAWANNA","SADE","MIRTA","LI","KARIE","JACINTA","ELNA","DAVINA","CIERRA","ASHLIE","ALBERTHA","TANESHA","STEPHANI","NELLE","MINDI","LU","LORINDA","LARUE","FLORENE","DEMETRA","DEDRA","CIARA","CHANTELLE","ASHLY","SUZY","ROSALVA","NOELIA","LYDA","LEATHA","KRYSTYNA","KRISTAN","KARRI","DARLINE","DARCIE","CINDA","CHEYENNE","CHERRIE","AWILDA","ALMEDA","ROLANDA","LANETTE","JERILYN","GISELE","EVALYN","CYNDI","CLETA","CARIN","ZINA","ZENA","VELIA","TANIKA","PAUL","CHARISSA","THOMAS","TALIA","MARGARETE","LAVONDA","KAYLEE","KATHLENE","JONNA","IRENA","ILONA","IDALIA","CANDIS","CANDANCE","BRANDEE","ANITRA","ALIDA","SIGRID","NICOLETTE","MARYJO","LINETTE","HEDWIG","CHRISTIANA","CASSIDY","ALEXIA","TRESSIE","MODESTA","LUPITA","LITA","GLADIS","EVELIA","DAVIDA","CHERRI","CECILY","ASHELY","ANNABEL","AGUSTINA","WANITA","SHIRLY","ROSAURA","HULDA","EUN","BAILEY","YETTA","VERONA","THOMASINA","SIBYL","SHANNAN","MECHELLE","LUE","LEANDRA","LANI","KYLEE","KANDY","JOLYNN","FERNE","EBONI","CORENE","ALYSIA","ZULA","NADA","MOIRA","LYNDSAY","LORRETTA","JUAN","JAMMIE","HORTENSIA","GAYNELL","CAMERON","ADRIA","VINA","VICENTA","TANGELA","STEPHINE","NORINE","NELLA","LIANA","LESLEE","KIMBERELY","ILIANA","GLORY","FELICA","EMOGENE","ELFRIEDE","EDEN","EARTHA","CARMA","BEA","OCIE","MARRY","LENNIE","KIARA","JACALYN","CARLOTA","ARIELLE","YU","STAR","OTILIA","KIRSTIN","KACEY","JOHNETTA","JOEY","JOETTA","JERALDINE","JAUNITA","ELANA","DORTHEA","CAMI","AMADA","ADELIA","VERNITA","TAMAR","SIOBHAN","RENEA","RASHIDA","OUIDA","ODELL","NILSA","MERYL","KRISTYN","JULIETA","DANICA","BREANNE","AUREA","ANGLEA","SHERRON","ODETTE","MALIA","LORELEI","LIN","LEESA","KENNA","KATHLYN","FIONA","CHARLETTE","SUZIE","SHANTELL","SABRA","RACQUEL","MYONG","MIRA","MARTINE","LUCIENNE","LAVADA","JULIANN","JOHNIE","ELVERA","DELPHIA","CLAIR","CHRISTIANE","CHAROLETTE","CARRI","AUGUSTINE","ASHA","ANGELLA","PAOLA","NINFA","LEDA","LAI","EDA","SUNSHINE","STEFANI","SHANELL","PALMA","MACHELLE","LISSA","KECIA","KATHRYNE","KARLENE","JULISSA","JETTIE","JENNIFFER","HUI","CORRINA","CHRISTOPHER","CAROLANN","ALENA","TESS","ROSARIA","MYRTICE","MARYLEE","LIANE","KENYATTA","JUDIE","JANEY","IN","ELMIRA","ELDORA","DENNA","CRISTI","CATHI","ZAIDA","VONNIE","VIVA","VERNIE","ROSALINE","MARIELA","LUCIANA","LESLI","KARAN","FELICE","DENEEN","ADINA","WYNONA","TARSHA","SHERON","SHASTA","SHANITA","SHANI","SHANDRA","RANDA","PINKIE","PARIS","NELIDA","MARILOU","LYLA","LAURENE","LACI","JOI","JANENE","DOROTHA","DANIELE","DANI","CAROLYNN","CARLYN","BERENICE","AYESHA","ANNELIESE","ALETHEA","THERSA","TAMIKO","RUFINA","OLIVA","MOZELL","MARYLYN","MADISON","KRISTIAN","KATHYRN","KASANDRA","KANDACE","JANAE","GABRIEL","DOMENICA","DEBBRA","DANNIELLE","CHUN","BUFFY","BARBIE","ARCELIA","AJA","ZENOBIA","SHAREN","SHAREE","PATRICK","PAGE","MY","LAVINIA","KUM","KACIE","JACKELINE","HUONG","FELISA","EMELIA","ELEANORA","CYTHIA","CRISTIN","CLYDE","CLARIBEL","CARON","ANASTACIA","ZULMA","ZANDRA","YOKO","TENISHA","SUSANN","SHERILYN","SHAY","SHAWANDA","SABINE","ROMANA","MATHILDA","LINSEY","KEIKO","JOANA","ISELA","GRETTA","GEORGETTA","EUGENIE","DUSTY","DESIRAE","DELORA","CORAZON","ANTONINA","ANIKA","WILLENE","TRACEE","TAMATHA","REGAN","NICHELLE","MICKIE","MAEGAN","LUANA","LANITA","KELSIE","EDELMIRA","BREE","AFTON","TEODORA","TAMIE","SHENA","MEG","LINH","KELI","KACI","DANYELLE","BRITT","ARLETTE","ALBERTINE","ADELLE","TIFFINY","STORMY","SIMONA","NUMBERS","NICOLASA","NICHOL","NIA","NAKISHA","MEE","MAIRA","LOREEN","KIZZY","JOHNNY","JAY","FALLON","CHRISTENE","BOBBYE","ANTHONY","YING","VINCENZA","TANJA","RUBIE","RONI","QUEENIE","MARGARETT","KIMBERLI","IRMGARD","IDELL","HILMA","EVELINA","ESTA","EMILEE","DENNISE","DANIA","CARL","CARIE","ANTONIO","WAI","SANG","RISA","RIKKI","PARTICIA","MUI","MASAKO","MARIO","LUVENIA","LOREE","LONI","LIEN","KEVIN","GIGI","FLORENCIA","DORIAN","DENITA","DALLAS","CHI","BILLYE","ALEXANDER","TOMIKA","SHARITA","RANA","NIKOLE","NEOMA","MARGARITE","MADALYN","LUCINA","LAILA","KALI","JENETTE","GABRIELE","EVELYNE","ELENORA","CLEMENTINA","ALEJANDRINA","ZULEMA","VIOLETTE","VANNESSA","THRESA","RETTA","PIA","PATIENCE","NOELLA","NICKIE","JONELL","DELTA","CHUNG","CHAYA","CAMELIA","BETHEL","ANYA","ANDREW","THANH","SUZANN","SPRING","SHU","MILA","LILLA","LAVERNA","KEESHA","KATTIE","GIA","GEORGENE","EVELINE","ESTELL","ELIZBETH","VIVIENNE","VALLIE","TRUDIE","STEPHANE","MICHEL","MAGALY","MADIE","KENYETTA","KARREN","JANETTA","HERMINE","HARMONY","DRUCILLA","DEBBI","CELESTINA","CANDIE","BRITNI","BECKIE","AMINA","ZITA","YUN","YOLANDE","VIVIEN","VERNETTA","TRUDI","SOMMER","PEARLE","PATRINA","OSSIE","NICOLLE","LOYCE","LETTY","LARISA","KATHARINA","JOSELYN","JONELLE","JENELL","IESHA","HEIDE","FLORINDA","FLORENTINA","FLO","ELODIA","DORINE","BRUNILDA","BRIGID","ASHLI","ARDELLA","TWANA","THU","TARAH","SUNG","SHEA","SHAVON","SHANE","SERINA","RAYNA","RAMONITA","NGA","MARGURITE","LUCRECIA","KOURTNEY","KATI","JESUS","JESENIA","DIAMOND","CRISTA","AYANA","ALICA","ALIA","VINNIE","SUELLEN","ROMELIA","RACHELL","PIPER","OLYMPIA","MICHIKO","KATHALEEN","JOLIE","JESSI","JANESSA","HANA","HA","ELEASE","CARLETTA","BRITANY","SHONA","SALOME","ROSAMOND","REGENA","RAINA","NGOC","NELIA","LOUVENIA","LESIA","LATRINA","LATICIA","LARHONDA","JINA","JACKI","HOLLIS","HOLLEY","EMMY","DEEANN","CORETTA","ARNETTA","VELVET","THALIA","SHANICE","NETA","MIKKI","MICKI","LONNA","LEANA","LASHUNDA","KILEY","JOYE","JACQULYN","IGNACIA","HYUN","HIROKO","HENRY","HENRIETTE","ELAYNE","DELINDA","DARNELL","DAHLIA","COREEN","CONSUELA","CONCHITA","CELINE","BABETTE","AYANNA","ANETTE","ALBERTINA","SKYE","SHAWNEE","SHANEKA","QUIANA","PAMELIA","MIN","MERRI","MERLENE","MARGIT","KIESHA","KIERA","KAYLENE","JODEE","JENISE","ERLENE","EMMIE","ELSE","DARYL","DALILA","DAISEY","CODY","CASIE","BELIA","BABARA","VERSIE","VANESA","SHELBA","SHAWNDA","SAM","NORMAN","NIKIA","NAOMA","MARNA","MARGERET","MADALINE","LAWANA","KINDRA","JUTTA","JAZMINE","JANETT","HANNELORE","GLENDORA","GERTRUD","GARNETT","FREEDA","FREDERICA","FLORANCE","FLAVIA","DENNIS","CARLINE","BEVERLEE","ANJANETTE","VALDA","TRINITY","TAMALA","STEVIE","SHONNA","SHA","SARINA","ONEIDA","MICAH","MERILYN","MARLEEN","LURLINE","LENNA","KATHERIN","JIN","JENI","HAE","GRACIA","GLADY","FARAH","ERIC","ENOLA","EMA","DOMINQUE","DEVONA","DELANA","CECILA","CAPRICE","ALYSHA","ALI","ALETHIA","VENA","THERESIA","TAWNY","SONG","SHAKIRA","SAMARA","SACHIKO","RACHELE","PAMELLA","NICKY","MARNI","MARIEL","MAREN","MALISA","LIGIA","LERA","LATORIA","LARAE","KIMBER","KATHERN","KAREY","JENNEFER","JANETH","HALINA","FREDIA","DELISA","DEBROAH","CIERA","CHIN","ANGELIKA","ANDREE","ALTHA","YEN","VIVAN","TERRESA","TANNA","SUK","SUDIE","SOO","SIGNE","SALENA","RONNI","REBBECCA","MYRTIE","MCKENZIE","MALIKA","MAIDA","LOAN","LEONARDA","KAYLEIGH","FRANCE","ETHYL","ELLYN","DAYLE","CAMMIE","BRITTNI","BIRGIT","AVELINA","ASUNCION","ARIANNA","AKIKO","VENICE","TYESHA","TONIE","TIESHA","TAKISHA","STEFFANIE","SINDY","SANTANA","MEGHANN","MANDA","MACIE","LADY","KELLYE","KELLEE","JOSLYN","JASON","INGER","INDIRA","GLINDA","GLENNIS","FERNANDA","FAUSTINA","ENEIDA","ELICIA","DOT","DIGNA","DELL","ARLETTA","ANDRE","WILLIA","TAMMARA","TABETHA","SHERRELL","SARI","REFUGIO","REBBECA","PAULETTA","NIEVES","NATOSHA","NAKITA","MAMMIE","KENISHA","KAZUKO","KASSIE","GARY","EARLEAN","DAPHINE","CORLISS","CLOTILDE","CAROLYNE","BERNETTA","AUGUSTINA","AUDREA","ANNIS","ANNABELL","YAN","TENNILLE","TAMICA","SELENE","SEAN","ROSANA","REGENIA","QIANA","MARKITA","MACY","LEEANNE","LAURINE","KYM","JESSENIA","JANITA","GEORGINE","GENIE","EMIKO","ELVIE","DEANDRA","DAGMAR","CORIE","COLLEN","CHERISH","ROMAINE","PORSHA","PEARLENE","MICHELINE","MERNA","MARGORIE","MARGARETTA","LORE","KENNETH","JENINE","HERMINA","FREDERICKA","ELKE","DRUSILLA","DORATHY","DIONE","DESIRE","CELENA","BRIGIDA","ANGELES","ALLEGRA","THEO","TAMEKIA","SYNTHIA","STEPHEN","SOOK","SLYVIA","ROSANN","REATHA","RAYE","MARQUETTA","MARGART","LING","LAYLA","KYMBERLY","KIANA","KAYLEEN","KATLYN","KARMEN","JOELLA","IRINA","EMELDA","ELENI","DETRA","CLEMMIE","CHERYLL","CHANTELL","CATHEY","ARNITA","ARLA","ANGLE","ANGELIC","ALYSE","ZOFIA","THOMASINE","TENNIE","SON","SHERLY","SHERLEY","SHARYL","REMEDIOS","PETRINA","NICKOLE","MYUNG","MYRLE","MOZELLA","LOUANNE","LISHA","LATIA","LANE","KRYSTA","JULIENNE","JOEL","JEANENE","JACQUALINE","ISAURA","GWENDA","EARLEEN","DONALD","CLEOPATRA","CARLIE","AUDIE","ANTONIETTA","ALISE","ALEX","VERDELL","VAL","TYLER","TOMOKO","THAO","TALISHA","STEVEN","SO","SHEMIKA","SHAUN","SCARLET","SAVANNA","SANTINA","ROSIA","RAEANN","ODILIA","NANA","MINNA","MAGAN","LYNELLE","LE","KARMA","JOEANN","IVANA","INELL","ILANA","HYE","HONEY","HEE","GUDRUN","FRANK","DREAMA","CRISSY","CHANTE","CARMELINA","ARVILLA","ARTHUR","ANNAMAE","ALVERA","ALEIDA","AARON","YEE","YANIRA","VANDA","TIANNA","TAM","STEFANIA","SHIRA","PERRY","NICOL","NANCIE","MONSERRATE","MINH","MELYNDA","MELANY","MATTHEW","LOVELLA","LAURE","KIRBY","KACY","JACQUELYNN","HYON","GERTHA","FRANCISCO","ELIANA","CHRISTENA","CHRISTEEN","CHARISE","CATERINA","CARLEY","CANDYCE","ARLENA","AMMIE","YANG","WILLETTE","VANITA","TUYET","TINY","SYREETA","SILVA","SCOTT","RONALD","PENNEY","NYLA","MICHAL","MAURICE","MARYAM","MARYA","MAGEN","LUDIE","LOMA","LIVIA","LANELL","KIMBERLIE","JULEE","DONETTA","DIEDRA","DENISHA","DEANE","DAWNE","CLARINE","CHERRYL","BRONWYN","BRANDON","ALLA","VALERY","TONDA","SUEANN","SORAYA","SHOSHANA","SHELA","SHARLEEN","SHANELLE","NERISSA","MICHEAL","MERIDITH","MELLIE","MAYE","MAPLE","MAGARET","LUIS","LILI","LEONILA","LEONIE","LEEANNA","LAVONIA","LAVERA","KRISTEL","KATHEY","KATHE","JUSTIN","JULIAN","JIMMY","JANN","ILDA","HILDRED","HILDEGARDE","GENIA","FUMIKO","EVELIN","ERMELINDA","ELLY","DUNG","DOLORIS","DIONNA","DANAE","BERNEICE","ANNICE","ALIX","VERENA","VERDIE","TRISTAN","SHAWNNA","SHAWANA","SHAUNNA","ROZELLA","RANDEE","RANAE","MILAGRO","LYNELL","LUISE","LOUIE","LOIDA","LISBETH","KARLEEN","JUNITA","JONA","ISIS","HYACINTH","HEDY","GWENN","ETHELENE","ERLINE","EDWARD","DONYA","DOMONIQUE","DELICIA","DANNETTE","CICELY","BRANDA","BLYTHE","BETHANN","ASHLYN","ANNALEE","ALLINE","YUKO","VELLA","TRANG","TOWANDA","TESHA","SHERLYN","NARCISA","MIGUELINA","MERI","MAYBELL","MARLANA","MARGUERITA","MADLYN","LUNA","LORY","LORIANN","LIBERTY","LEONORE","LEIGHANN","LAURICE","LATESHA","LARONDA","KATRICE","KASIE","KARL","KALEY","JADWIGA","GLENNIE","GEARLDINE","FRANCINA","EPIFANIA","DYAN","DORIE","DIEDRE","DENESE","DEMETRICE","DELENA","DARBY","CRISTIE","CLEORA","CATARINA","CARISA","BERNIE","BARBERA","ALMETA","TRULA","TEREASA","SOLANGE","SHEILAH","SHAVONNE","SANORA","ROCHELL","MATHILDE","MARGARETA","MAIA","LYNSEY","LAWANNA","LAUNA","KENA","KEENA","KATIA","JAMEY","GLYNDA","GAYLENE","ELVINA","ELANOR","DANUTA","DANIKA","CRISTEN","CORDIE","COLETTA","CLARITA","CARMON","BRYNN","AZUCENA","AUNDREA","ANGELE","YI","WALTER","VERLIE","VERLENE","TAMESHA","SILVANA","SEBRINA","SAMIRA","REDA","RAYLENE","PENNI","PANDORA","NORAH","NOMA","MIREILLE","MELISSIA","MARYALICE","LARAINE","KIMBERY","KARYL","KARINE","KAM","JOLANDA","JOHANA","JESUSA","JALEESA","JAE","JACQUELYNE","IRISH","ILUMINADA","HILARIA","HANH","GENNIE","FRANCIE","FLORETTA","EXIE","EDDA","DREMA","DELPHA","BEV","BARBAR","ASSUNTA","ARDELL","ANNALISA","ALISIA","YUKIKO","YOLANDO","WONDA","WEI","WALTRAUD","VETA","TEQUILA","TEMEKA","TAMEIKA","SHIRLEEN","SHENITA","PIEDAD","OZELLA","MIRTHA","MARILU","KIMIKO","JULIANE","JENICE","JEN","JANAY","JACQUILINE","HILDE","FE","FAE","EVAN","EUGENE","ELOIS","ECHO","DEVORAH","CHAU","BRINDA","BETSEY","ARMINDA","ARACELIS","APRYL","ANNETT","ALISHIA","VEOLA","USHA","TOSHIKO","THEOLA","TASHIA","TALITHA","SHERY","RUDY","RENETTA","REIKO","RASHEEDA","OMEGA","OBDULIA","MIKA","MELAINE","MEGGAN","MARTIN","MARLEN","MARGET","MARCELINE","MANA","MAGDALEN","LIBRADA","LEZLIE","LEXIE","LATASHIA","LASANDRA","KELLE","ISIDRA","ISA","INOCENCIA","GWYN","FRANCOISE","ERMINIA","ERINN","DIMPLE","DEVORA","CRISELDA","ARMANDA","ARIE","ARIANE","ANGELO","ANGELENA","ALLEN","ALIZA","ADRIENE","ADALINE","XOCHITL","TWANNA","TRAN","TOMIKO","TAMISHA","TAISHA","SUSY","SIU","RUTHA","ROXY","RHONA","RAYMOND","OTHA","NORIKO","NATASHIA","MERRIE","MELVIN","MARINDA","MARIKO","MARGERT","LORIS","LIZZETTE","LEISHA","KAILA","KA","JOANNIE","JERRICA","JENE","JANNET","JANEE","JACINDA","HERTA","ELENORE","DORETTA","DELAINE","DANIELL","CLAUDIE","CHINA","BRITTA","APOLONIA","AMBERLY","ALEASE","YURI","YUK","WEN","WANETA","UTE","TOMI","SHARRI","SANDIE","ROSELLE","REYNALDA","RAGUEL","PHYLICIA","PATRIA","OLIMPIA","ODELIA","MITZIE","MITCHELL","MISS","MINDA","MIGNON","MICA","MENDY","MARIVEL","MAILE","LYNETTA","LAVETTE","LAURYN","LATRISHA","LAKIESHA","KIERSTEN","KARY","JOSPHINE","JOLYN","JETTA","JANISE","JACQUIE","IVELISSE","GLYNIS","GIANNA","GAYNELLE","EMERALD","DEMETRIUS","DANYELL","DANILLE","DACIA","CORALEE","CHER","CEOLA","BRETT","BELL","ARIANNE","ALESHIA","YUNG","WILLIEMAE","TROY","TRINH","THORA","TAI","SVETLANA","SHERIKA","SHEMEKA","SHAUNDA","ROSELINE","RICKI","MELDA","MALLIE","LAVONNA","LATINA","LARRY","LAQUANDA","LALA","LACHELLE","KLARA","KANDIS","JOHNA","JEANMARIE","JAYE","HANG","GRAYCE","GERTUDE","EMERITA","EBONIE","CLORINDA","CHING","CHERY","CAROLA","BREANN","BLOSSOM","BERNARDINE","BECKI","ARLETHA","ARGELIA","ARA","ALITA","YULANDA","YON","YESSENIA","TOBI","TASIA","SYLVIE","SHIRL","SHIRELY","SHERIDAN","SHELLA","SHANTELLE","SACHA","ROYCE","REBECKA","REAGAN","PROVIDENCIA","PAULENE","MISHA","MIKI","MARLINE","MARICA","LORITA","LATOYIA","LASONYA","KERSTIN","KENDA","KEITHA","KATHRIN","JAYMIE","JACK","GRICELDA","GINETTE","ERYN","ELINA","ELFRIEDA","DANYEL","CHEREE","CHANELLE","BARRIE","AVERY","AURORE","ANNAMARIA","ALLEEN","AILENE","AIDE","YASMINE","VASHTI","VALENTINE","TREASA","TORY","TIFFANEY","SHERYLL","SHARIE","SHANAE","SAU","RAISA","PA","NEDA","MITSUKO","MIRELLA","MILDA","MARYANNA","MARAGRET","MABELLE","LUETTA","LORINA","LETISHA","LATARSHA","LANELLE","LAJUANA","KRISSY","KARLY","KARENA","JON","JESSIKA","JERICA","JEANELLE","JANUARY","JALISA","JACELYN","IZOLA","IVEY","GREGORY","EUNA","ETHA","DREW","DOMITILA","DOMINICA","DAINA","CREOLA","CARLI","CAMIE","BUNNY","BRITTNY","ASHANTI","ANISHA","ALEEN","ADAH","YASUKO","WINTER","VIKI","VALRIE","TONA","TINISHA","THI","TERISA","TATUM","TANEKA","SIMONNE","SHALANDA","SERITA","RESSIE","REFUGIA","PAZ","OLENE","NA","MERRILL","MARGHERITA","MANDIE","MAN","MAIRE","LYNDIA","LUCI","LORRIANE","LORETA","LEONIA","LAVONA","LASHAWNDA","LAKIA","KYOKO","KRYSTINA","KRYSTEN","KENIA","KELSI","JUDE","JEANICE","ISOBEL","GEORGIANN","GENNY","FELICIDAD","EILENE","DEON","DELOISE","DEEDEE","DANNIE","CONCEPTION","CLORA","CHERILYN","CHANG","CALANDRA","BERRY","ARMANDINA","ANISA","ULA","TIMOTHY","TIERA","THERESSA","STEPHANIA","SIMA","SHYLA","SHONTA","SHERA","SHAQUITA","SHALA","SAMMY","ROSSANA","NOHEMI","NERY","MORIAH","MELITA","MELIDA","MELANI","MARYLYNN","MARISHA","MARIETTE","MALORIE","MADELENE","LUDIVINA","LORIA","LORETTE","LORALEE","LIANNE","LEON","LAVENIA","LAURINDA","LASHON","KIT","KIMI","KEILA","KATELYNN","KAI","JONE","JOANE","JI","JAYNA","JANELLA","JA","HUE","HERTHA","FRANCENE","ELINORE","DESPINA","DELSIE","DEEDRA","CLEMENCIA","CARRY","CAROLIN","CARLOS","BULAH","BRITTANIE","BOK","BLONDELL","BIBI","BEAULAH","BEATA","ANNITA","AGRIPINA","VIRGEN","VALENE","UN","TWANDA","TOMMYE","TOI","TARRA","TARI","TAMMERA","SHAKIA","SADYE","RUTHANNE","ROCHEL","RIVKA","PURA","NENITA","NATISHA","MING","MERRILEE","MELODEE","MARVIS","LUCILLA","LEENA","LAVETA","LARITA","LANIE","KEREN","ILEEN","GEORGEANN","GENNA","GENESIS","FRIDA","EWA","EUFEMIA","EMELY","ELA","EDYTH","DEONNA","DEADRA","DARLENA","CHANELL","CHAN","CATHERN","CASSONDRA","CASSAUNDRA","BERNARDA","BERNA","ARLINDA","ANAMARIA","ALBERT","WESLEY","VERTIE","VALERI","TORRI","TATYANA","STASIA","SHERISE","SHERILL","SEASON","SCOTTIE","SANDA","RUTHE","ROSY","ROBERTO","ROBBI","RANEE","QUYEN","PEARLY","PALMIRA","ONITA","NISHA","NIESHA","NIDA","NEVADA","NAM","MERLYN","MAYOLA","MARYLOUISE","MARYLAND","MARX","MARTH","MARGENE","MADELAINE","LONDA","LEONTINE","LEOMA","LEIA","LAWRENCE","LAURALEE","LANORA","LAKITA","KIYOKO","KETURAH","KATELIN","KAREEN","JONIE","JOHNETTE","JENEE","JEANETT","IZETTA","HIEDI","HEIKE","HASSIE","HAROLD","GIUSEPPINA","GEORGANN","FIDELA","FERNANDE","ELWANDA","ELLAMAE","ELIZ","DUSTI","DOTTY","CYNDY","CORALIE","CELESTA","ARGENTINA","ALVERTA","XENIA","WAVA","VANETTA","TORRIE","TASHINA","TANDY","TAMBRA","TAMA","STEPANIE","SHILA","SHAUNTA","SHARAN","SHANIQUA","SHAE","SETSUKO","SERAFINA","SANDEE","ROSAMARIA","PRISCILA","OLINDA","NADENE","MUOI","MICHELINA","MERCEDEZ","MARYROSE","MARIN","MARCENE","MAO","MAGALI","MAFALDA","LOGAN","LINN","LANNIE","KAYCE","KAROLINE","KAMILAH","KAMALA","JUSTA","JOLINE","JENNINE","JACQUETTA","IRAIDA","GERALD","GEORGEANNA","FRANCHESCA","FAIRY","EMELINE","ELANE","EHTEL","EARLIE","DULCIE","DALENE","CRIS","CLASSIE","CHERE","CHARIS","CAROYLN","CARMINA","CARITA","BRIAN","BETHANIE","AYAKO","ARICA","AN","ALYSA","ALESSANDRA","AKILAH","ADRIEN","ZETTA","YOULANDA","YELENA","YAHAIRA","XUAN","WENDOLYN","VICTOR","TIJUANA","TERRELL","TERINA","TERESIA","SUZI","SUNDAY","SHERELL","SHAVONDA","SHAUNTE","SHARDA","SHAKITA","SENA","RYANN","RUBI","RIVA","REGINIA","REA","RACHAL","PARTHENIA","PAMULA","MONNIE","MONET","MICHAELE","MELIA","MARINE","MALKA","MAISHA","LISANDRA","LEO","LEKISHA","LEAN","LAURENCE","LAKENDRA","KRYSTIN","KORTNEY","KIZZIE","KITTIE","KERA","KENDAL","KEMBERLY","KANISHA","JULENE","JULE","JOSHUA","JOHANNE","JEFFREY","JAMEE","HAN","HALLEY","GIDGET","GALINA","FREDRICKA","FLETA","FATIMAH","EUSEBIA","ELZA","ELEONORE","DORTHEY","DORIA","DONELLA","DINORAH","DELORSE","CLARETHA","CHRISTINIA","CHARLYN","BONG","BELKIS","AZZIE","ANDERA","AIKO","ADENA","YER","YAJAIRA","WAN","VANIA","ULRIKE","TOSHIA","TIFANY","STEFANY","SHIZUE","SHENIKA","SHAWANNA","SHAROLYN","SHARILYN","SHAQUANA","SHANTAY","SEE","ROZANNE","ROSELEE","RICKIE","REMONA","REANNA","RAELENE","QUINN","PHUNG","PETRONILA","NATACHA","NANCEY","MYRL","MIYOKO","MIESHA","MERIDETH","MARVELLA","MARQUITTA","MARHTA","MARCHELLE","LIZETH","LIBBIE","LAHOMA","LADAWN","KINA","KATHELEEN","KATHARYN","KARISA","KALEIGH","JUNIE","JULIEANN","JOHNSIE","JANEAN","JAIMEE","JACKQUELINE","HISAKO","HERMA","HELAINE","GWYNETH","GLENN","GITA","EUSTOLIA","EMELINA","ELIN","EDRIS","DONNETTE","DONNETTA","DIERDRE","DENAE","DARCEL","CLAUDE","CLARISA","CINDERELLA","CHIA","CHARLESETTA","CHARITA","CELSA","CASSY","CASSI","CARLEE","BRUNA","BRITTANEY","BRANDE","BILLI","BAO","ANTONETTA","ANGLA","ANGELYN","ANALISA","ALANE","WENONA","WENDIE","VERONIQUE","VANNESA","TOBIE","TEMPIE","SUMIKO","SULEMA","SPARKLE","SOMER","SHEBA","SHAYNE","SHARICE","SHANEL","SHALON","SAGE","ROY","ROSIO","ROSELIA","RENAY","REMA","REENA","PORSCHE","PING","PEG","OZIE","ORETHA","ORALEE","ODA","NU","NGAN","NAKESHA","MILLY","MARYBELLE","MARLIN","MARIS","MARGRETT","MARAGARET","MANIE","LURLENE","LILLIA","LIESELOTTE","LAVELLE","LASHAUNDA","LAKEESHA","KEITH","KAYCEE","KALYN","JOYA","JOETTE","JENAE","JANIECE","ILLA","GRISEL","GLAYDS","GENEVIE","GALA","FREDDA","FRED","ELMER","ELEONOR","DEBERA","DEANDREA","DAN","CORRINNE","CORDIA","CONTESSA","COLENE","CLEOTILDE","CHARLOTT","CHANTAY","CECILLE","BEATRIS","AZALEE","ARLEAN","ARDATH","ANJELICA","ANJA","ALFREDIA","ALEISHA","ADAM","ZADA","YUONNE","XIAO","WILLODEAN","WHITLEY","VENNIE","VANNA","TYISHA","TOVA","TORIE","TONISHA","TILDA","TIEN","TEMPLE","SIRENA","SHERRIL","SHANTI","SHAN","SENAIDA","SAMELLA","ROBBYN","RENDA","REITA","PHEBE","PAULITA","NOBUKO","NGUYET","NEOMI","MOON","MIKAELA","MELANIA","MAXIMINA","MARG","MAISIE","LYNNA","LILLI","LAYNE","LASHAUN","LAKENYA","LAEL","KIRSTIE","KATHLINE","KASHA","KARLYN","KARIMA","JOVAN","JOSEFINE","JENNELL","JACQUI","JACKELYN","HYO","HIEN","GRAZYNA","FLORRIE","FLORIA","ELEONORA","DWANA","DORLA","DONG","DELMY","DEJA","DEDE","DANN","CRYSTA","CLELIA","CLARIS","CLARENCE","CHIEKO","CHERLYN","CHERELLE","CHARMAIN","CHARA","CAMMY","BEE","ARNETTE","ARDELLE","ANNIKA","AMIEE","AMEE","ALLENA","YVONE","YUKI","YOSHIE","YEVETTE","YAEL","WILLETTA","VONCILE","VENETTA","TULA","TONETTE","TIMIKA","TEMIKA","TELMA","TEISHA","TAREN","TA","STACEE","SHIN","SHAWNTA","SATURNINA","RICARDA","POK","PASTY","ONIE","NUBIA","MORA","MIKE","MARIELLE","MARIELLA","MARIANELA","MARDELL","MANY","LUANNA","LOISE","LISABETH","LINDSY","LILLIANA","LILLIAM","LELAH","LEIGHA","LEANORA","LANG","KRISTEEN","KHALILAH","KEELEY","KANDRA","JUNKO","JOAQUINA","JERLENE","JANI","JAMIKA","JAME","HSIU","HERMILA","GOLDEN","GENEVIVE","EVIA","EUGENA","EMMALINE","ELFREDA","ELENE","DONETTE","DELCIE","DEEANNA","DARCEY","CUC","CLARINDA","CIRA","CHAE","CELINDA","CATHERYN","CATHERIN","CASIMIRA","CARMELIA","CAMELLIA","BREANA","BOBETTE","BERNARDINA","BEBE","BASILIA","ARLYNE","AMAL","ALAYNA","ZONIA","ZENIA","YURIKO","YAEKO","WYNELL","WILLOW","WILLENA","VERNIA","TU","TRAVIS","TORA","TERRILYN","TERICA","TENESHA","TAWNA","TAJUANA","TAINA","STEPHNIE","SONA","SOL","SINA","SHONDRA","SHIZUKO","SHERLENE","SHERICE","SHARIKA","ROSSIE","ROSENA","RORY","RIMA","RIA","RHEBA","RENNA","PETER","NATALYA","NANCEE","MELODI","MEDA","MAXIMA","MATHA","MARKETTA","MARICRUZ","MARCELENE","MALVINA","LUBA","LOUETTA","LEIDA","LECIA","LAURAN","LASHAWNA","LAINE","KHADIJAH","KATERINE","KASI","KALLIE","JULIETTA","JESUSITA","JESTINE","JESSIA","JEREMY","JEFFIE","JANYCE","ISADORA","GEORGIANNE","FIDELIA","EVITA","EURA","EULAH","ESTEFANA","ELSY","ELIZABET","ELADIA","DODIE","DION","DIA","DENISSE","DELORAS","DELILA","DAYSI","DAKOTA","CURTIS","CRYSTLE","CONCHA","COLBY","CLARETTA","CHU","CHRISTIA","CHARLSIE","CHARLENA","CARYLON","BETTYANN","ASLEY","ASHLEA","AMIRA","AI","AGUEDA","AGNUS","YUETTE","VINITA","VICTORINA","TYNISHA","TREENA","TOCCARA","TISH","THOMASENA","TEGAN","SOILA","SHILOH","SHENNA","SHARMAINE","SHANTAE","SHANDI","SEPTEMBER","SARAN","SARAI","SANA","SAMUEL","SALLEY","ROSETTE","ROLANDE","REGINE","OTELIA","OSCAR","OLEVIA","NICHOLLE","NECOLE","NAIDA","MYRTA","MYESHA","MITSUE","MINTA","MERTIE","MARGY","MAHALIA","MADALENE","LOVE","LOURA","LOREAN","LEWIS","LESHA","LEONIDA","LENITA","LAVONE","LASHELL","LASHANDRA","LAMONICA","KIMBRA","KATHERINA","KARRY","KANESHA","JULIO","JONG","JENEVA","JAQUELYN","HWA","GILMA","GHISLAINE","GERTRUDIS","FRANSISCA","FERMINA","ETTIE","ETSUKO","ELLIS","ELLAN","ELIDIA","EDRA","DORETHEA","DOREATHA","DENYSE","DENNY","DEETTA","DAINE","CYRSTAL","CORRIN","CAYLA","CARLITA","CAMILA","BURMA","BULA","BUENA","BLAKE","BARABARA","AVRIL","AUSTIN","ALAINE","ZANA","WILHEMINA","WANETTA","VIRGIL","VI","VERONIKA","VERNON","VERLINE","VASILIKI","TONITA","TISA","TEOFILA","TAYNA","TAUNYA","TANDRA","TAKAKO","SUNNI","SUANNE","SIXTA","SHARELL","SEEMA","RUSSELL","ROSENDA","ROBENA","RAYMONDE","PEI","PAMILA","OZELL","NEIDA","NEELY","MISTIE","MICHA","MERISSA","MAURITA","MARYLN","MARYETTA","MARSHALL","MARCELL","MALENA","MAKEDA","MADDIE","LOVETTA","LOURIE","LORRINE","LORILEE","LESTER","LAURENA","LASHAY","LARRAINE","LAREE","LACRESHA","KRISTLE","KRISHNA","KEVA","KEIRA","KAROLE","JOIE","JINNY","JEANNETTA","JAMA","HEIDY","GILBERTE","GEMA","FAVIOLA","EVELYNN","ENDA","ELLI","ELLENA","DIVINA","DAGNY","COLLENE","CODI","CINDIE","CHASSIDY","CHASIDY","CATRICE","CATHERINA","CASSEY","CAROLL","CARLENA","CANDRA","CALISTA","BRYANNA","BRITTENY","BEULA","BARI","AUDRIE","AUDRIA","ARDELIA","ANNELLE","ANGILA","ALONA","ALLYN","DOUGLAS","ROGER","JONATHAN","RALPH","NICHOLAS","BENJAMIN","BRUCE","HARRY","WAYNE","STEVE","HOWARD","ERNEST","PHILLIP","TODD","CRAIG","ALAN","PHILIP","EARL","DANNY","BRYAN","STANLEY","LEONARD","NATHAN","MANUEL","RODNEY","MARVIN","VINCENT","JEFFERY","JEFF","CHAD","JACOB","ALFRED","BRADLEY","HERBERT","FREDERICK","EDWIN","DON","RICKY","RANDALL","BARRY","BERNARD","LEROY","MARCUS","THEODORE","CLIFFORD","MIGUEL","JIM","TOM","CALVIN","BILL","LLOYD","DEREK","WARREN","DARRELL","JEROME","FLOYD","ALVIN","TIM","GORDON","GREG","JORGE","DUSTIN","PEDRO","DERRICK","ZACHARY","HERMAN","GLEN","HECTOR","RICARDO","RICK","BRENT","RAMON","GILBERT","MARC","REGINALD","RUBEN","NATHANIEL","RAFAEL","EDGAR","MILTON","RAUL","BEN","CHESTER","DUANE","FRANKLIN","BRAD","RON","ROLAND","ARNOLD","HARVEY","JARED","ERIK","DARRYL","NEIL","JAVIER","FERNANDO","CLINTON","TED","MATHEW","TYRONE","DARREN","LANCE","KURT","ALLAN","NELSON","GUY","CLAYTON","HUGH","MAX","DWAYNE","DWIGHT","ARMANDO","FELIX","EVERETT","IAN","WALLACE","KEN","BOB","ALFREDO","ALBERTO","DAVE","IVAN","BYRON","ISAAC","MORRIS","CLIFTON","WILLARD","ROSS","ANDY","SALVADOR","KIRK","SERGIO","SETH","KENT","TERRANCE","EDUARDO","TERRENCE","ENRIQUE","WADE","STUART","FREDRICK","ARTURO","ALEJANDRO","NICK","LUTHER","WENDELL","JEREMIAH","JULIUS","OTIS","TREVOR","OLIVER","LUKE","HOMER","GERARD","DOUG","KENNY","HUBERT","LYLE","MATT","ALFONSO","ORLANDO","REX","CARLTON","ERNESTO","NEAL","PABLO","LORENZO","OMAR","WILBUR","GRANT","HORACE","RODERICK","ABRAHAM","WILLIS","RICKEY","ANDRES","CESAR","JOHNATHAN","MALCOLM","RUDOLPH","DAMON","KELVIN","PRESTON","ALTON","ARCHIE","MARCO","WM","PETE","RANDOLPH","GARRY","GEOFFREY","JONATHON","FELIPE","GERARDO","ED","DOMINIC","DELBERT","COLIN","GUILLERMO","EARNEST","LUCAS","BENNY","SPENCER","RODOLFO","MYRON","EDMUND","GARRETT","SALVATORE","CEDRIC","LOWELL","GREGG","SHERMAN","WILSON","SYLVESTER","ROOSEVELT","ISRAEL","JERMAINE","FORREST","WILBERT","LELAND","SIMON","CLARK","IRVING","BRYANT","OWEN","RUFUS","WOODROW","KRISTOPHER","MACK","LEVI","MARCOS","GUSTAVO","JAKE","LIONEL","GILBERTO","CLINT","NICOLAS","ISMAEL","ORVILLE","ERVIN","DEWEY","AL","WILFRED","JOSH","HUGO","IGNACIO","CALEB","TOMAS","SHELDON","ERICK","STEWART","DOYLE","DARREL","ROGELIO","TERENCE","SANTIAGO","ALONZO","ELIAS","BERT","ELBERT","RAMIRO","CONRAD","NOAH","GRADY","PHIL","CORNELIUS","LAMAR","ROLANDO","CLAY","PERCY","DEXTER","BRADFORD","DARIN","AMOS","MOSES","IRVIN","SAUL","ROMAN","RANDAL","TIMMY","DARRIN","WINSTON","BRENDAN","ABEL","DOMINICK","BOYD","EMILIO","ELIJAH","DOMINGO","EMMETT","MARLON","EMANUEL","JERALD","EDMOND","EMIL","DEWAYNE","WILL","OTTO","TEDDY","REYNALDO","BRET","JESS","TRENT","HUMBERTO","EMMANUEL","STEPHAN","VICENTE","LAMONT","GARLAND","MILES","EFRAIN","HEATH","RODGER","HARLEY","ETHAN","ELDON","ROCKY","PIERRE","JUNIOR","FREDDY","ELI","BRYCE","ANTOINE","STERLING","CHASE","GROVER","ELTON","CLEVELAND","DYLAN","CHUCK","DAMIAN","REUBEN","STAN","AUGUST","LEONARDO","JASPER","RUSSEL","ERWIN","BENITO","HANS","MONTE","BLAINE","ERNIE","CURT","QUENTIN","AGUSTIN","MURRAY","JAMAL","ADOLFO","HARRISON","TYSON","BURTON","BRADY","ELLIOTT","WILFREDO","BART","JARROD","VANCE","DENIS","DAMIEN","JOAQUIN","HARLAN","DESMOND","ELLIOT","DARWIN","GREGORIO","BUDDY","XAVIER","KERMIT","ROSCOE","ESTEBAN","ANTON","SOLOMON","SCOTTY","NORBERT","ELVIN","WILLIAMS","NOLAN","ROD","QUINTON","HAL","BRAIN","ROB","ELWOOD","KENDRICK","DARIUS","MOISES","FIDEL","THADDEUS","CLIFF","MARCEL","JACKSON","RAPHAEL","BRYON","ARMAND","ALVARO","JEFFRY","DANE","JOESPH","THURMAN","NED","RUSTY","MONTY","FABIAN","REGGIE","MASON","GRAHAM","ISAIAH","VAUGHN","GUS","LOYD","DIEGO","ADOLPH","NORRIS","MILLARD","ROCCO","GONZALO","DERICK","RODRIGO","WILEY","RIGOBERTO","ALPHONSO","TY","NOE","VERN","REED","JEFFERSON","ELVIS","BERNARDO","MAURICIO","HIRAM","DONOVAN","BASIL","RILEY","NICKOLAS","MAYNARD","SCOT","VINCE","QUINCY","EDDY","SEBASTIAN","FEDERICO","ULYSSES","HERIBERTO","DONNELL","COLE","DAVIS","GAVIN","EMERY","WARD","ROMEO","JAYSON","DANTE","CLEMENT","COY","MAXWELL","JARVIS","BRUNO","ISSAC","DUDLEY","BROCK","SANFORD","CARMELO","BARNEY","NESTOR","STEFAN","DONNY","ART","LINWOOD","BEAU","WELDON","GALEN","ISIDRO","TRUMAN","DELMAR","JOHNATHON","SILAS","FREDERIC","DICK","IRWIN","MERLIN","CHARLEY","MARCELINO","HARRIS","CARLO","TRENTON","KURTIS","HUNTER","AURELIO","WINFRED","VITO","COLLIN","DENVER","CARTER","LEONEL","EMORY","PASQUALE","MOHAMMAD","MARIANO","DANIAL","LANDON","DIRK","BRANDEN","ADAN","BUFORD","GERMAN","WILMER","EMERSON","ZACHERY","FLETCHER","JACQUES","ERROL","DALTON","MONROE","JOSUE","EDWARDO","BOOKER","WILFORD","SONNY","SHELTON","CARSON","THERON","RAYMUNDO","DAREN","HOUSTON","ROBBY","LINCOLN","GENARO","BENNETT","OCTAVIO","CORNELL","HUNG","ARRON","ANTONY","HERSCHEL","GIOVANNI","GARTH","CYRUS","CYRIL","RONNY","LON","FREEMAN","DUNCAN","KENNITH","CARMINE","ERICH","CHADWICK","WILBURN","RUSS","REID","MYLES","ANDERSON","MORTON","JONAS","FOREST","MITCHEL","MERVIN","ZANE","RICH","JAMEL","LAZARO","ALPHONSE","RANDELL","MAJOR","JARRETT","BROOKS","ABDUL","LUCIANO","SEYMOUR","EUGENIO","MOHAMMED","VALENTIN","CHANCE","ARNULFO","LUCIEN","FERDINAND","THAD","EZRA","ALDO","RUBIN","ROYAL","MITCH","EARLE","ABE","WYATT","MARQUIS","LANNY","KAREEM","JAMAR","BORIS","ISIAH","EMILE","ELMO","ARON","LEOPOLDO","EVERETTE","JOSEF","ELOY","RODRICK","REINALDO","LUCIO","JERROD","WESTON","HERSHEL","BARTON","PARKER","LEMUEL","BURT","JULES","GIL","ELISEO","AHMAD","NIGEL","EFREN","ANTWAN","ALDEN","MARGARITO","COLEMAN","DINO","OSVALDO","LES","DEANDRE","NORMAND","KIETH","TREY","NORBERTO","NAPOLEON","JEROLD","FRITZ","ROSENDO","MILFORD","CHRISTOPER","ALFONZO","LYMAN","JOSIAH","BRANT","WILTON","RICO","JAMAAL","DEWITT","BRENTON","OLIN","FOSTER","FAUSTINO","CLAUDIO","JUDSON","GINO","EDGARDO","ALEC","TANNER","JARRED","DONN","TAD","PRINCE","PORFIRIO","ODIS","LENARD","CHAUNCEY","TOD","MEL","MARCELO","KORY","AUGUSTUS","KEVEN","HILARIO","BUD","SAL","ORVAL","MAURO","ZACHARIAH","OLEN","ANIBAL","MILO","JED","DILLON","AMADO","NEWTON","LENNY","RICHIE","HORACIO","BRICE","MOHAMED","DELMER","DARIO","REYES","MAC","JONAH","JERROLD","ROBT","HANK","RUPERT","ROLLAND","KENTON","DAMION","ANTONE","WALDO","FREDRIC","BRADLY","KIP","BURL","WALKER","TYREE","JEFFEREY","AHMED","WILLY","STANFORD","OREN","NOBLE","MOSHE","MIKEL","ENOCH","BRENDON","QUINTIN","JAMISON","FLORENCIO","DARRICK","TOBIAS","HASSAN","GIUSEPPE","DEMARCUS","CLETUS","TYRELL","LYNDON","KEENAN","WERNER","GERALDO","COLUMBUS","CHET","BERTRAM","MARKUS","HUEY","HILTON","DWAIN","DONTE","TYRON","OMER","ISAIAS","HIPOLITO","FERMIN","ADALBERTO","BO","BARRETT","TEODORO","MCKINLEY","MAXIMO","GARFIELD","RALEIGH","LAWERENCE","ABRAM","RASHAD","KING","EMMITT","DARON","SAMUAL","MIQUEL","EUSEBIO","DOMENIC","DARRON","BUSTER","WILBER","RENATO","JC","HOYT","HAYWOOD","EZEKIEL","CHAS","FLORENTINO","ELROY","CLEMENTE","ARDEN","NEVILLE","EDISON","DESHAWN","NATHANIAL","JORDON","DANILO","CLAUD","SHERWOOD","RAYMON","RAYFORD","CRISTOBAL","AMBROSE","TITUS","HYMAN","FELTON","EZEQUIEL","ERASMO","STANTON","LONNY","LEN","IKE","MILAN","LINO","JAROD","HERB","ANDREAS","WALTON","RHETT","PALMER","DOUGLASS","CORDELL","OSWALDO","ELLSWORTH","VIRGILIO","TONEY","NATHANAEL","DEL","BENEDICT","MOSE","JOHNSON","ISREAL","GARRET","FAUSTO","ASA","ARLEN","ZACK","WARNER","MODESTO","FRANCESCO","MANUAL","GAYLORD","GASTON","FILIBERTO","DEANGELO","MICHALE","GRANVILLE","WES","MALIK","ZACKARY","TUAN","ELDRIDGE","CRISTOPHER","CORTEZ","ANTIONE","MALCOM","LONG","KOREY","JOSPEH","COLTON","WAYLON","VON","HOSEA","SHAD","SANTO","RUDOLF","ROLF","REY","RENALDO","MARCELLUS","LUCIUS","KRISTOFER","BOYCE","BENTON","HAYDEN","HARLAND","ARNOLDO","RUEBEN","LEANDRO","KRAIG","JERRELL","JEROMY","HOBERT","CEDRICK","ARLIE","WINFORD","WALLY","LUIGI","KENETH","JACINTO","GRAIG","FRANKLYN","EDMUNDO","SID","PORTER","LEIF","JERAMY","BUCK","WILLIAN","VINCENZO","SHON","LYNWOOD","JERE","HAI","ELDEN","DORSEY","DARELL","BRODERICK","ALONSO" -------------------------------------------------------------------------------- /p031-coin-sums/coinsums: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PawanKolhe/C-Algorithms/dd005e16fde4c2423f7afa1d125209e07a7a8e8e/p031-coin-sums/coinsums -------------------------------------------------------------------------------- /p031-coin-sums/coinsums.cpp: -------------------------------------------------------------------------------- 1 | // Project Euler 2019 2 | // Vinicius Rodrigues 21.10.2019 3 | // Coin Sums : Problem 31 4 | 5 | #include 6 | 7 | using namespace std; 8 | 9 | int range = 8; 10 | int coins[] = {1, 2, 5, 10, 20, 50, 100, 200}; 11 | 12 | int countCoins(int num, int coin) 13 | { 14 | int count = 0; 15 | if(coin == -1) 16 | for(int i = 0; i < range; i++) 17 | count += countCoins(num, i); 18 | else 19 | { 20 | num -= coins[coin]; 21 | if(num == 0) return 1; 22 | else if(num < 0) return 0; 23 | 24 | for(int i = coin; i < range; i++) 25 | count += countCoins(num, i); 26 | } 27 | 28 | return count; 29 | } 30 | 31 | int main() 32 | { 33 | int count = countCoins(200, -1); 34 | cout << count << endl; 35 | } 36 | -------------------------------------------------------------------------------- /p081-path-sum-two-ways/p081_matrix.txt: -------------------------------------------------------------------------------- 1 | 4445,2697,5115,718,2209,2212,654,4348,3079,6821,7668,3276,8874,4190,3785,2752,9473,7817,9137,496,7338,3434,7152,4355,4552,7917,7827,2460,2350,691,3514,5880,3145,7633,7199,3783,5066,7487,3285,1084,8985,760,872,8609,8051,1134,9536,5750,9716,9371,7619,5617,275,9721,2997,2698,1887,8825,6372,3014,2113,7122,7050,6775,5948,2758,1219,3539,348,7989,2735,9862,1263,8089,6401,9462,3168,2758,3748,5870 2 | 1096,20,1318,7586,5167,2642,1443,5741,7621,7030,5526,4244,2348,4641,9827,2448,6918,5883,3737,300,7116,6531,567,5997,3971,6623,820,6148,3287,1874,7981,8424,7672,7575,6797,6717,1078,5008,4051,8795,5820,346,1851,6463,2117,6058,3407,8211,117,4822,1317,4377,4434,5925,8341,4800,1175,4173,690,8978,7470,1295,3799,8724,3509,9849,618,3320,7068,9633,2384,7175,544,6583,1908,9983,481,4187,9353,9377 3 | 9607,7385,521,6084,1364,8983,7623,1585,6935,8551,2574,8267,4781,3834,2764,2084,2669,4656,9343,7709,2203,9328,8004,6192,5856,3555,2260,5118,6504,1839,9227,1259,9451,1388,7909,5733,6968,8519,9973,1663,5315,7571,3035,4325,4283,2304,6438,3815,9213,9806,9536,196,5542,6907,2475,1159,5820,9075,9470,2179,9248,1828,4592,9167,3713,4640,47,3637,309,7344,6955,346,378,9044,8635,7466,5036,9515,6385,9230 4 | 7206,3114,7760,1094,6150,5182,7358,7387,4497,955,101,1478,7777,6966,7010,8417,6453,4955,3496,107,449,8271,131,2948,6185,784,5937,8001,6104,8282,4165,3642,710,2390,575,715,3089,6964,4217,192,5949,7006,715,3328,1152,66,8044,4319,1735,146,4818,5456,6451,4113,1063,4781,6799,602,1504,6245,6550,1417,1343,2363,3785,5448,4545,9371,5420,5068,4613,4882,4241,5043,7873,8042,8434,3939,9256,2187 5 | 3620,8024,577,9997,7377,7682,1314,1158,6282,6310,1896,2509,5436,1732,9480,706,496,101,6232,7375,2207,2306,110,6772,3433,2878,8140,5933,8688,1399,2210,7332,6172,6403,7333,4044,2291,1790,2446,7390,8698,5723,3678,7104,1825,2040,140,3982,4905,4160,2200,5041,2512,1488,2268,1175,7588,8321,8078,7312,977,5257,8465,5068,3453,3096,1651,7906,253,9250,6021,8791,8109,6651,3412,345,4778,5152,4883,7505 6 | 1074,5438,9008,2679,5397,5429,2652,3403,770,9188,4248,2493,4361,8327,9587,707,9525,5913,93,1899,328,2876,3604,673,8576,6908,7659,2544,3359,3883,5273,6587,3065,1749,3223,604,9925,6941,2823,8767,7039,3290,3214,1787,7904,3421,7137,9560,8451,2669,9219,6332,1576,5477,6755,8348,4164,4307,2984,4012,6629,1044,2874,6541,4942,903,1404,9125,5160,8836,4345,2581,460,8438,1538,5507,668,3352,2678,6942 7 | 4295,1176,5596,1521,3061,9868,7037,7129,8933,6659,5947,5063,3653,9447,9245,2679,767,714,116,8558,163,3927,8779,158,5093,2447,5782,3967,1716,931,7772,8164,1117,9244,5783,7776,3846,8862,6014,2330,6947,1777,3112,6008,3491,1906,5952,314,4602,8994,5919,9214,3995,5026,7688,6809,5003,3128,2509,7477,110,8971,3982,8539,2980,4689,6343,5411,2992,5270,5247,9260,2269,7474,1042,7162,5206,1232,4556,4757 8 | 510,3556,5377,1406,5721,4946,2635,7847,4251,8293,8281,6351,4912,287,2870,3380,3948,5322,3840,4738,9563,1906,6298,3234,8959,1562,6297,8835,7861,239,6618,1322,2553,2213,5053,5446,4402,6500,5182,8585,6900,5756,9661,903,5186,7687,5998,7997,8081,8955,4835,6069,2621,1581,732,9564,1082,1853,5442,1342,520,1737,3703,5321,4793,2776,1508,1647,9101,2499,6891,4336,7012,3329,3212,1442,9993,3988,4930,7706 9 | 9444,3401,5891,9716,1228,7107,109,3563,2700,6161,5039,4992,2242,8541,7372,2067,1294,3058,1306,320,8881,5756,9326,411,8650,8824,5495,8282,8397,2000,1228,7817,2099,6473,3571,5994,4447,1299,5991,543,7874,2297,1651,101,2093,3463,9189,6872,6118,872,1008,1779,2805,9084,4048,2123,5877,55,3075,1737,9459,4535,6453,3644,108,5982,4437,5213,1340,6967,9943,5815,669,8074,1838,6979,9132,9315,715,5048 10 | 3327,4030,7177,6336,9933,5296,2621,4785,2755,4832,2512,2118,2244,4407,2170,499,7532,9742,5051,7687,970,6924,3527,4694,5145,1306,2165,5940,2425,8910,3513,1909,6983,346,6377,4304,9330,7203,6605,3709,3346,970,369,9737,5811,4427,9939,3693,8436,5566,1977,3728,2399,3985,8303,2492,5366,9802,9193,7296,1033,5060,9144,2766,1151,7629,5169,5995,58,7619,7565,4208,1713,6279,3209,4908,9224,7409,1325,8540 11 | 6882,1265,1775,3648,4690,959,5837,4520,5394,1378,9485,1360,4018,578,9174,2932,9890,3696,116,1723,1178,9355,7063,1594,1918,8574,7594,7942,1547,6166,7888,354,6932,4651,1010,7759,6905,661,7689,6092,9292,3845,9605,8443,443,8275,5163,7720,7265,6356,7779,1798,1754,5225,6661,1180,8024,5666,88,9153,1840,3508,1193,4445,2648,3538,6243,6375,8107,5902,5423,2520,1122,5015,6113,8859,9370,966,8673,2442 12 | 7338,3423,4723,6533,848,8041,7921,8277,4094,5368,7252,8852,9166,2250,2801,6125,8093,5738,4038,9808,7359,9494,601,9116,4946,2702,5573,2921,9862,1462,1269,2410,4171,2709,7508,6241,7522,615,2407,8200,4189,5492,5649,7353,2590,5203,4274,710,7329,9063,956,8371,3722,4253,4785,1194,4828,4717,4548,940,983,2575,4511,2938,1827,2027,2700,1236,841,5760,1680,6260,2373,3851,1841,4968,1172,5179,7175,3509 13 | 4420,1327,3560,2376,6260,2988,9537,4064,4829,8872,9598,3228,1792,7118,9962,9336,4368,9189,6857,1829,9863,6287,7303,7769,2707,8257,2391,2009,3975,4993,3068,9835,3427,341,8412,2134,4034,8511,6421,3041,9012,2983,7289,100,1355,7904,9186,6920,5856,2008,6545,8331,3655,5011,839,8041,9255,6524,3862,8788,62,7455,3513,5003,8413,3918,2076,7960,6108,3638,6999,3436,1441,4858,4181,1866,8731,7745,3744,1000 14 | 356,8296,8325,1058,1277,4743,3850,2388,6079,6462,2815,5620,8495,5378,75,4324,3441,9870,1113,165,1544,1179,2834,562,6176,2313,6836,8839,2986,9454,5199,6888,1927,5866,8760,320,1792,8296,7898,6121,7241,5886,5814,2815,8336,1576,4314,3109,2572,6011,2086,9061,9403,3947,5487,9731,7281,3159,1819,1334,3181,5844,5114,9898,4634,2531,4412,6430,4262,8482,4546,4555,6804,2607,9421,686,8649,8860,7794,6672 15 | 9870,152,1558,4963,8750,4754,6521,6256,8818,5208,5691,9659,8377,9725,5050,5343,2539,6101,1844,9700,7750,8114,5357,3001,8830,4438,199,9545,8496,43,2078,327,9397,106,6090,8181,8646,6414,7499,5450,4850,6273,5014,4131,7639,3913,6571,8534,9703,4391,7618,445,1320,5,1894,6771,7383,9191,4708,9706,6939,7937,8726,9382,5216,3685,2247,9029,8154,1738,9984,2626,9438,4167,6351,5060,29,1218,1239,4785 16 | 192,5213,8297,8974,4032,6966,5717,1179,6523,4679,9513,1481,3041,5355,9303,9154,1389,8702,6589,7818,6336,3539,5538,3094,6646,6702,6266,2759,4608,4452,617,9406,8064,6379,444,5602,4950,1810,8391,1536,316,8714,1178,5182,5863,5110,5372,4954,1978,2971,5680,4863,2255,4630,5723,2168,538,1692,1319,7540,440,6430,6266,7712,7385,5702,620,641,3136,7350,1478,3155,2820,9109,6261,1122,4470,14,8493,2095 17 | 1046,4301,6082,474,4974,7822,2102,5161,5172,6946,8074,9716,6586,9962,9749,5015,2217,995,5388,4402,7652,6399,6539,1349,8101,3677,1328,9612,7922,2879,231,5887,2655,508,4357,4964,3554,5930,6236,7384,4614,280,3093,9600,2110,7863,2631,6626,6620,68,1311,7198,7561,1768,5139,1431,221,230,2940,968,5283,6517,2146,1646,869,9402,7068,8645,7058,1765,9690,4152,2926,9504,2939,7504,6074,2944,6470,7859 18 | 4659,736,4951,9344,1927,6271,8837,8711,3241,6579,7660,5499,5616,3743,5801,4682,9748,8796,779,1833,4549,8138,4026,775,4170,2432,4174,3741,7540,8017,2833,4027,396,811,2871,1150,9809,2719,9199,8504,1224,540,2051,3519,7982,7367,2761,308,3358,6505,2050,4836,5090,7864,805,2566,2409,6876,3361,8622,5572,5895,3280,441,7893,8105,1634,2929,274,3926,7786,6123,8233,9921,2674,5340,1445,203,4585,3837 19 | 5759,338,7444,7968,7742,3755,1591,4839,1705,650,7061,2461,9230,9391,9373,2413,1213,431,7801,4994,2380,2703,6161,6878,8331,2538,6093,1275,5065,5062,2839,582,1014,8109,3525,1544,1569,8622,7944,2905,6120,1564,1839,5570,7579,1318,2677,5257,4418,5601,7935,7656,5192,1864,5886,6083,5580,6202,8869,1636,7907,4759,9082,5854,3185,7631,6854,5872,5632,5280,1431,2077,9717,7431,4256,8261,9680,4487,4752,4286 20 | 1571,1428,8599,1230,7772,4221,8523,9049,4042,8726,7567,6736,9033,2104,4879,4967,6334,6716,3994,1269,8995,6539,3610,7667,6560,6065,874,848,4597,1711,7161,4811,6734,5723,6356,6026,9183,2586,5636,1092,7779,7923,8747,6887,7505,9909,1792,3233,4526,3176,1508,8043,720,5212,6046,4988,709,5277,8256,3642,1391,5803,1468,2145,3970,6301,7767,2359,8487,9771,8785,7520,856,1605,8972,2402,2386,991,1383,5963 21 | 1822,4824,5957,6511,9868,4113,301,9353,6228,2881,2966,6956,9124,9574,9233,1601,7340,973,9396,540,4747,8590,9535,3650,7333,7583,4806,3593,2738,8157,5215,8472,2284,9473,3906,6982,5505,6053,7936,6074,7179,6688,1564,1103,6860,5839,2022,8490,910,7551,7805,881,7024,1855,9448,4790,1274,3672,2810,774,7623,4223,4850,6071,9975,4935,1915,9771,6690,3846,517,463,7624,4511,614,6394,3661,7409,1395,8127 22 | 8738,3850,9555,3695,4383,2378,87,6256,6740,7682,9546,4255,6105,2000,1851,4073,8957,9022,6547,5189,2487,303,9602,7833,1628,4163,6678,3144,8589,7096,8913,5823,4890,7679,1212,9294,5884,2972,3012,3359,7794,7428,1579,4350,7246,4301,7779,7790,3294,9547,4367,3549,1958,8237,6758,3497,3250,3456,6318,1663,708,7714,6143,6890,3428,6853,9334,7992,591,6449,9786,1412,8500,722,5468,1371,108,3939,4199,2535 23 | 7047,4323,1934,5163,4166,461,3544,2767,6554,203,6098,2265,9078,2075,4644,6641,8412,9183,487,101,7566,5622,1975,5726,2920,5374,7779,5631,3753,3725,2672,3621,4280,1162,5812,345,8173,9785,1525,955,5603,2215,2580,5261,2765,2990,5979,389,3907,2484,1232,5933,5871,3304,1138,1616,5114,9199,5072,7442,7245,6472,4760,6359,9053,7876,2564,9404,3043,9026,2261,3374,4460,7306,2326,966,828,3274,1712,3446 24 | 3975,4565,8131,5800,4570,2306,8838,4392,9147,11,3911,7118,9645,4994,2028,6062,5431,2279,8752,2658,7836,994,7316,5336,7185,3289,1898,9689,2331,5737,3403,1124,2679,3241,7748,16,2724,5441,6640,9368,9081,5618,858,4969,17,2103,6035,8043,7475,2181,939,415,1617,8500,8253,2155,7843,7974,7859,1746,6336,3193,2617,8736,4079,6324,6645,8891,9396,5522,6103,1857,8979,3835,2475,1310,7422,610,8345,7615 25 | 9248,5397,5686,2988,3446,4359,6634,9141,497,9176,6773,7448,1907,8454,916,1596,2241,1626,1384,2741,3649,5362,8791,7170,2903,2475,5325,6451,924,3328,522,90,4813,9737,9557,691,2388,1383,4021,1609,9206,4707,5200,7107,8104,4333,9860,5013,1224,6959,8527,1877,4545,7772,6268,621,4915,9349,5970,706,9583,3071,4127,780,8231,3017,9114,3836,7503,2383,1977,4870,8035,2379,9704,1037,3992,3642,1016,4303 26 | 5093,138,4639,6609,1146,5565,95,7521,9077,2272,974,4388,2465,2650,722,4998,3567,3047,921,2736,7855,173,2065,4238,1048,5,6847,9548,8632,9194,5942,4777,7910,8971,6279,7253,2516,1555,1833,3184,9453,9053,6897,7808,8629,4877,1871,8055,4881,7639,1537,7701,2508,7564,5845,5023,2304,5396,3193,2955,1088,3801,6203,1748,3737,1276,13,4120,7715,8552,3047,2921,106,7508,304,1280,7140,2567,9135,5266 27 | 6237,4607,7527,9047,522,7371,4883,2540,5867,6366,5301,1570,421,276,3361,527,6637,4861,2401,7522,5808,9371,5298,2045,5096,5447,7755,5115,7060,8529,4078,1943,1697,1764,5453,7085,960,2405,739,2100,5800,728,9737,5704,5693,1431,8979,6428,673,7540,6,7773,5857,6823,150,5869,8486,684,5816,9626,7451,5579,8260,3397,5322,6920,1879,2127,2884,5478,4977,9016,6165,6292,3062,5671,5968,78,4619,4763 28 | 9905,7127,9390,5185,6923,3721,9164,9705,4341,1031,1046,5127,7376,6528,3248,4941,1178,7889,3364,4486,5358,9402,9158,8600,1025,874,1839,1783,309,9030,1843,845,8398,1433,7118,70,8071,2877,3904,8866,6722,4299,10,1929,5897,4188,600,1889,3325,2485,6473,4474,7444,6992,4846,6166,4441,2283,2629,4352,7775,1101,2214,9985,215,8270,9750,2740,8361,7103,5930,8664,9690,8302,9267,344,2077,1372,1880,9550 29 | 5825,8517,7769,2405,8204,1060,3603,7025,478,8334,1997,3692,7433,9101,7294,7498,9415,5452,3850,3508,6857,9213,6807,4412,7310,854,5384,686,4978,892,8651,3241,2743,3801,3813,8588,6701,4416,6990,6490,3197,6838,6503,114,8343,5844,8646,8694,65,791,5979,2687,2621,2019,8097,1423,3644,9764,4921,3266,3662,5561,2476,8271,8138,6147,1168,3340,1998,9874,6572,9873,6659,5609,2711,3931,9567,4143,7833,8887 30 | 6223,2099,2700,589,4716,8333,1362,5007,2753,2848,4441,8397,7192,8191,4916,9955,6076,3370,6396,6971,3156,248,3911,2488,4930,2458,7183,5455,170,6809,6417,3390,1956,7188,577,7526,2203,968,8164,479,8699,7915,507,6393,4632,1597,7534,3604,618,3280,6061,9793,9238,8347,568,9645,2070,5198,6482,5000,9212,6655,5961,7513,1323,3872,6170,3812,4146,2736,67,3151,5548,2781,9679,7564,5043,8587,1893,4531 31 | 5826,3690,6724,2121,9308,6986,8106,6659,2142,1642,7170,2877,5757,6494,8026,6571,8387,9961,6043,9758,9607,6450,8631,8334,7359,5256,8523,2225,7487,1977,9555,8048,5763,2414,4948,4265,2427,8978,8088,8841,9208,9601,5810,9398,8866,9138,4176,5875,7212,3272,6759,5678,7649,4922,5422,1343,8197,3154,3600,687,1028,4579,2084,9467,4492,7262,7296,6538,7657,7134,2077,1505,7332,6890,8964,4879,7603,7400,5973,739 32 | 1861,1613,4879,1884,7334,966,2000,7489,2123,4287,1472,3263,4726,9203,1040,4103,6075,6049,330,9253,4062,4268,1635,9960,577,1320,3195,9628,1030,4092,4979,6474,6393,2799,6967,8687,7724,7392,9927,2085,3200,6466,8702,265,7646,8665,7986,7266,4574,6587,612,2724,704,3191,8323,9523,3002,704,5064,3960,8209,2027,2758,8393,4875,4641,9584,6401,7883,7014,768,443,5490,7506,1852,2005,8850,5776,4487,4269 33 | 4052,6687,4705,7260,6645,6715,3706,5504,8672,2853,1136,8187,8203,4016,871,1809,1366,4952,9294,5339,6872,2645,6083,7874,3056,5218,7485,8796,7401,3348,2103,426,8572,4163,9171,3176,948,7654,9344,3217,1650,5580,7971,2622,76,2874,880,2034,9929,1546,2659,5811,3754,7096,7436,9694,9960,7415,2164,953,2360,4194,2397,1047,2196,6827,575,784,2675,8821,6802,7972,5996,6699,2134,7577,2887,1412,4349,4380 34 | 4629,2234,6240,8132,7592,3181,6389,1214,266,1910,2451,8784,2790,1127,6932,1447,8986,2492,5476,397,889,3027,7641,5083,5776,4022,185,3364,5701,2442,2840,4160,9525,4828,6602,2614,7447,3711,4505,7745,8034,6514,4907,2605,7753,6958,7270,6936,3006,8968,439,2326,4652,3085,3425,9863,5049,5361,8688,297,7580,8777,7916,6687,8683,7141,306,9569,2384,1500,3346,4601,7329,9040,6097,2727,6314,4501,4974,2829 35 | 8316,4072,2025,6884,3027,1808,5714,7624,7880,8528,4205,8686,7587,3230,1139,7273,6163,6986,3914,9309,1464,9359,4474,7095,2212,7302,2583,9462,7532,6567,1606,4436,8981,5612,6796,4385,5076,2007,6072,3678,8331,1338,3299,8845,4783,8613,4071,1232,6028,2176,3990,2148,3748,103,9453,538,6745,9110,926,3125,473,5970,8728,7072,9062,1404,1317,5139,9862,6496,6062,3338,464,1600,2532,1088,8232,7739,8274,3873 36 | 2341,523,7096,8397,8301,6541,9844,244,4993,2280,7689,4025,4196,5522,7904,6048,2623,9258,2149,9461,6448,8087,7245,1917,8340,7127,8466,5725,6996,3421,5313,512,9164,9837,9794,8369,4185,1488,7210,1524,1016,4620,9435,2478,7765,8035,697,6677,3724,6988,5853,7662,3895,9593,1185,4727,6025,5734,7665,3070,138,8469,6748,6459,561,7935,8646,2378,462,7755,3115,9690,8877,3946,2728,8793,244,6323,8666,4271 37 | 6430,2406,8994,56,1267,3826,9443,7079,7579,5232,6691,3435,6718,5698,4144,7028,592,2627,217,734,6194,8156,9118,58,2640,8069,4127,3285,694,3197,3377,4143,4802,3324,8134,6953,7625,3598,3584,4289,7065,3434,2106,7132,5802,7920,9060,7531,3321,1725,1067,3751,444,5503,6785,7937,6365,4803,198,6266,8177,1470,6390,1606,2904,7555,9834,8667,2033,1723,5167,1666,8546,8152,473,4475,6451,7947,3062,3281 38 | 2810,3042,7759,1741,2275,2609,7676,8640,4117,1958,7500,8048,1757,3954,9270,1971,4796,2912,660,5511,3553,1012,5757,4525,6084,7198,8352,5775,7726,8591,7710,9589,3122,4392,6856,5016,749,2285,3356,7482,9956,7348,2599,8944,495,3462,3578,551,4543,7207,7169,7796,1247,4278,6916,8176,3742,8385,2310,1345,8692,2667,4568,1770,8319,3585,4920,3890,4928,7343,5385,9772,7947,8786,2056,9266,3454,2807,877,2660 39 | 6206,8252,5928,5837,4177,4333,207,7934,5581,9526,8906,1498,8411,2984,5198,5134,2464,8435,8514,8674,3876,599,5327,826,2152,4084,2433,9327,9697,4800,2728,3608,3849,3861,3498,9943,1407,3991,7191,9110,5666,8434,4704,6545,5944,2357,1163,4995,9619,6754,4200,9682,6654,4862,4744,5953,6632,1054,293,9439,8286,2255,696,8709,1533,1844,6441,430,1999,6063,9431,7018,8057,2920,6266,6799,356,3597,4024,6665 40 | 3847,6356,8541,7225,2325,2946,5199,469,5450,7508,2197,9915,8284,7983,6341,3276,3321,16,1321,7608,5015,3362,8491,6968,6818,797,156,2575,706,9516,5344,5457,9210,5051,8099,1617,9951,7663,8253,9683,2670,1261,4710,1068,8753,4799,1228,2621,3275,6188,4699,1791,9518,8701,5932,4275,6011,9877,2933,4182,6059,2930,6687,6682,9771,654,9437,3169,8596,1827,5471,8909,2352,123,4394,3208,8756,5513,6917,2056 41 | 5458,8173,3138,3290,4570,4892,3317,4251,9699,7973,1163,1935,5477,6648,9614,5655,9592,975,9118,2194,7322,8248,8413,3462,8560,1907,7810,6650,7355,2939,4973,6894,3933,3784,3200,2419,9234,4747,2208,2207,1945,2899,1407,6145,8023,3484,5688,7686,2737,3828,3704,9004,5190,9740,8643,8650,5358,4426,1522,1707,3613,9887,6956,2447,2762,833,1449,9489,2573,1080,4167,3456,6809,2466,227,7125,2759,6250,6472,8089 42 | 3266,7025,9756,3914,1265,9116,7723,9788,6805,5493,2092,8688,6592,9173,4431,4028,6007,7131,4446,4815,3648,6701,759,3312,8355,4485,4187,5188,8746,7759,3528,2177,5243,8379,3838,7233,4607,9187,7216,2190,6967,2920,6082,7910,5354,3609,8958,6949,7731,494,8753,8707,1523,4426,3543,7085,647,6771,9847,646,5049,824,8417,5260,2730,5702,2513,9275,4279,2767,8684,1165,9903,4518,55,9682,8963,6005,2102,6523 43 | 1998,8731,936,1479,5259,7064,4085,91,7745,7136,3773,3810,730,8255,2705,2653,9790,6807,2342,355,9344,2668,3690,2028,9679,8102,574,4318,6481,9175,5423,8062,2867,9657,7553,3442,3920,7430,3945,7639,3714,3392,2525,4995,4850,2867,7951,9667,486,9506,9888,781,8866,1702,3795,90,356,1483,4200,2131,6969,5931,486,6880,4404,1084,5169,4910,6567,8335,4686,5043,2614,3352,2667,4513,6472,7471,5720,1616 44 | 8878,1613,1716,868,1906,2681,564,665,5995,2474,7496,3432,9491,9087,8850,8287,669,823,347,6194,2264,2592,7871,7616,8508,4827,760,2676,4660,4881,7572,3811,9032,939,4384,929,7525,8419,5556,9063,662,8887,7026,8534,3111,1454,2082,7598,5726,6687,9647,7608,73,3014,5063,670,5461,5631,3367,9796,8475,7908,5073,1565,5008,5295,4457,1274,4788,1728,338,600,8415,8535,9351,7750,6887,5845,1741,125 45 | 3637,6489,9634,9464,9055,2413,7824,9517,7532,3577,7050,6186,6980,9365,9782,191,870,2497,8498,2218,2757,5420,6468,586,3320,9230,1034,1393,9886,5072,9391,1178,8464,8042,6869,2075,8275,3601,7715,9470,8786,6475,8373,2159,9237,2066,3264,5000,679,355,3069,4073,494,2308,5512,4334,9438,8786,8637,9774,1169,1949,6594,6072,4270,9158,7916,5752,6794,9391,6301,5842,3285,2141,3898,8027,4310,8821,7079,1307 46 | 8497,6681,4732,7151,7060,5204,9030,7157,833,5014,8723,3207,9796,9286,4913,119,5118,7650,9335,809,3675,2597,5144,3945,5090,8384,187,4102,1260,2445,2792,4422,8389,9290,50,1765,1521,6921,8586,4368,1565,5727,7855,2003,4834,9897,5911,8630,5070,1330,7692,7557,7980,6028,5805,9090,8265,3019,3802,698,9149,5748,1965,9658,4417,5994,5584,8226,2937,272,5743,1278,5698,8736,2595,6475,5342,6596,1149,6920 47 | 8188,8009,9546,6310,8772,2500,9846,6592,6872,3857,1307,8125,7042,1544,6159,2330,643,4604,7899,6848,371,8067,2062,3200,7295,1857,9505,6936,384,2193,2190,301,8535,5503,1462,7380,5114,4824,8833,1763,4974,8711,9262,6698,3999,2645,6937,7747,1128,2933,3556,7943,2885,3122,9105,5447,418,2899,5148,3699,9021,9501,597,4084,175,1621,1,1079,6067,5812,4326,9914,6633,5394,4233,6728,9084,1864,5863,1225 48 | 9935,8793,9117,1825,9542,8246,8437,3331,9128,9675,6086,7075,319,1334,7932,3583,7167,4178,1726,7720,695,8277,7887,6359,5912,1719,2780,8529,1359,2013,4498,8072,1129,9998,1147,8804,9405,6255,1619,2165,7491,1,8882,7378,3337,503,5758,4109,3577,985,3200,7615,8058,5032,1080,6410,6873,5496,1466,2412,9885,5904,4406,3605,8770,4361,6205,9193,1537,9959,214,7260,9566,1685,100,4920,7138,9819,5637,976 49 | 3466,9854,985,1078,7222,8888,5466,5379,3578,4540,6853,8690,3728,6351,7147,3134,6921,9692,857,3307,4998,2172,5783,3931,9417,2541,6299,13,787,2099,9131,9494,896,8600,1643,8419,7248,2660,2609,8579,91,6663,5506,7675,1947,6165,4286,1972,9645,3805,1663,1456,8853,5705,9889,7489,1107,383,4044,2969,3343,152,7805,4980,9929,5033,1737,9953,7197,9158,4071,1324,473,9676,3984,9680,3606,8160,7384,5432 50 | 1005,4512,5186,3953,2164,3372,4097,3247,8697,3022,9896,4101,3871,6791,3219,2742,4630,6967,7829,5991,6134,1197,1414,8923,8787,1394,8852,5019,7768,5147,8004,8825,5062,9625,7988,1110,3992,7984,9966,6516,6251,8270,421,3723,1432,4830,6935,8095,9059,2214,6483,6846,3120,1587,6201,6691,9096,9627,6671,4002,3495,9939,7708,7465,5879,6959,6634,3241,3401,2355,9061,2611,7830,3941,2177,2146,5089,7079,519,6351 51 | 7280,8586,4261,2831,7217,3141,9994,9940,5462,2189,4005,6942,9848,5350,8060,6665,7519,4324,7684,657,9453,9296,2944,6843,7499,7847,1728,9681,3906,6353,5529,2822,3355,3897,7724,4257,7489,8672,4356,3983,1948,6892,7415,4153,5893,4190,621,1736,4045,9532,7701,3671,1211,1622,3176,4524,9317,7800,5638,6644,6943,5463,3531,2821,1347,5958,3436,1438,2999,994,850,4131,2616,1549,3465,5946,690,9273,6954,7991 52 | 9517,399,3249,2596,7736,2142,1322,968,7350,1614,468,3346,3265,7222,6086,1661,5317,2582,7959,4685,2807,2917,1037,5698,1529,3972,8716,2634,3301,3412,8621,743,8001,4734,888,7744,8092,3671,8941,1487,5658,7099,2781,99,1932,4443,4756,4652,9328,1581,7855,4312,5976,7255,6480,3996,2748,1973,9731,4530,2790,9417,7186,5303,3557,351,7182,9428,1342,9020,7599,1392,8304,2070,9138,7215,2008,9937,1106,7110 53 | 7444,769,9688,632,1571,6820,8743,4338,337,3366,3073,1946,8219,104,4210,6986,249,5061,8693,7960,6546,1004,8857,5997,9352,4338,6105,5008,2556,6518,6694,4345,3727,7956,20,3954,8652,4424,9387,2035,8358,5962,5304,5194,8650,8282,1256,1103,2138,6679,1985,3653,2770,2433,4278,615,2863,1715,242,3790,2636,6998,3088,1671,2239,957,5411,4595,6282,2881,9974,2401,875,7574,2987,4587,3147,6766,9885,2965 54 | 3287,3016,3619,6818,9073,6120,5423,557,2900,2015,8111,3873,1314,4189,1846,4399,7041,7583,2427,2864,3525,5002,2069,748,1948,6015,2684,438,770,8367,1663,7887,7759,1885,157,7770,4520,4878,3857,1137,3525,3050,6276,5569,7649,904,4533,7843,2199,5648,7628,9075,9441,3600,7231,2388,5640,9096,958,3058,584,5899,8150,1181,9616,1098,8162,6819,8171,1519,1140,7665,8801,2632,1299,9192,707,9955,2710,7314 55 | 1772,2963,7578,3541,3095,1488,7026,2634,6015,4633,4370,2762,1650,2174,909,8158,2922,8467,4198,4280,9092,8856,8835,5457,2790,8574,9742,5054,9547,4156,7940,8126,9824,7340,8840,6574,3547,1477,3014,6798,7134,435,9484,9859,3031,4,1502,4133,1738,1807,4825,463,6343,9701,8506,9822,9555,8688,8168,3467,3234,6318,1787,5591,419,6593,7974,8486,9861,6381,6758,194,3061,4315,2863,4665,3789,2201,1492,4416 56 | 126,8927,6608,5682,8986,6867,1715,6076,3159,788,3140,4744,830,9253,5812,5021,7616,8534,1546,9590,1101,9012,9821,8132,7857,4086,1069,7491,2988,1579,2442,4321,2149,7642,6108,250,6086,3167,24,9528,7663,2685,1220,9196,1397,5776,1577,1730,5481,977,6115,199,6326,2183,3767,5928,5586,7561,663,8649,9688,949,5913,9160,1870,5764,9887,4477,6703,1413,4995,5494,7131,2192,8969,7138,3997,8697,646,1028 57 | 8074,1731,8245,624,4601,8706,155,8891,309,2552,8208,8452,2954,3124,3469,4246,3352,1105,4509,8677,9901,4416,8191,9283,5625,7120,2952,8881,7693,830,4580,8228,9459,8611,4499,1179,4988,1394,550,2336,6089,6872,269,7213,1848,917,6672,4890,656,1478,6536,3165,4743,4990,1176,6211,7207,5284,9730,4738,1549,4986,4942,8645,3698,9429,1439,2175,6549,3058,6513,1574,6988,8333,3406,5245,5431,7140,7085,6407 58 | 7845,4694,2530,8249,290,5948,5509,1588,5940,4495,5866,5021,4626,3979,3296,7589,4854,1998,5627,3926,8346,6512,9608,1918,7070,4747,4182,2858,2766,4606,6269,4107,8982,8568,9053,4244,5604,102,2756,727,5887,2566,7922,44,5986,621,1202,374,6988,4130,3627,6744,9443,4568,1398,8679,397,3928,9159,367,2917,6127,5788,3304,8129,911,2669,1463,9749,264,4478,8940,1109,7309,2462,117,4692,7724,225,2312 59 | 4164,3637,2000,941,8903,39,3443,7172,1031,3687,4901,8082,4945,4515,7204,9310,9349,9535,9940,218,1788,9245,2237,1541,5670,6538,6047,5553,9807,8101,1925,8714,445,8332,7309,6830,5786,5736,7306,2710,3034,1838,7969,6318,7912,2584,2080,7437,6705,2254,7428,820,782,9861,7596,3842,3631,8063,5240,6666,394,4565,7865,4895,9890,6028,6117,4724,9156,4473,4552,602,470,6191,4927,5387,884,3146,1978,3000 60 | 4258,6880,1696,3582,5793,4923,2119,1155,9056,9698,6603,3768,5514,9927,9609,6166,6566,4536,4985,4934,8076,9062,6741,6163,7399,4562,2337,5600,2919,9012,8459,1308,6072,1225,9306,8818,5886,7243,7365,8792,6007,9256,6699,7171,4230,7002,8720,7839,4533,1671,478,7774,1607,2317,5437,4705,7886,4760,6760,7271,3081,2997,3088,7675,6208,3101,6821,6840,122,9633,4900,2067,8546,4549,2091,7188,5605,8599,6758,5229 61 | 7854,5243,9155,3556,8812,7047,2202,1541,5993,4600,4760,713,434,7911,7426,7414,8729,322,803,7960,7563,4908,6285,6291,736,3389,9339,4132,8701,7534,5287,3646,592,3065,7582,2592,8755,6068,8597,1982,5782,1894,2900,6236,4039,6569,3037,5837,7698,700,7815,2491,7272,5878,3083,6778,6639,3589,5010,8313,2581,6617,5869,8402,6808,2951,2321,5195,497,2190,6187,1342,1316,4453,7740,4154,2959,1781,1482,8256 62 | 7178,2046,4419,744,8312,5356,6855,8839,319,2962,5662,47,6307,8662,68,4813,567,2712,9931,1678,3101,8227,6533,4933,6656,92,5846,4780,6256,6361,4323,9985,1231,2175,7178,3034,9744,6155,9165,7787,5836,9318,7860,9644,8941,6480,9443,8188,5928,161,6979,2352,5628,6991,1198,8067,5867,6620,3778,8426,2994,3122,3124,6335,3918,8897,2655,9670,634,1088,1576,8935,7255,474,8166,7417,9547,2886,5560,3842 63 | 6957,3111,26,7530,7143,1295,1744,6057,3009,1854,8098,5405,2234,4874,9447,2620,9303,27,7410,969,40,2966,5648,7596,8637,4238,3143,3679,7187,690,9980,7085,7714,9373,5632,7526,6707,3951,9734,4216,2146,3602,5371,6029,3039,4433,4855,4151,1449,3376,8009,7240,7027,4602,2947,9081,4045,8424,9352,8742,923,2705,4266,3232,2264,6761,363,2651,3383,7770,6730,7856,7340,9679,2158,610,4471,4608,910,6241 64 | 4417,6756,1013,8797,658,8809,5032,8703,7541,846,3357,2920,9817,1745,9980,7593,4667,3087,779,3218,6233,5568,4296,2289,2654,7898,5021,9461,5593,8214,9173,4203,2271,7980,2983,5952,9992,8399,3468,1776,3188,9314,1720,6523,2933,621,8685,5483,8986,6163,3444,9539,4320,155,3992,2828,2150,6071,524,2895,5468,8063,1210,3348,9071,4862,483,9017,4097,6186,9815,3610,5048,1644,1003,9865,9332,2145,1944,2213 65 | 9284,3803,4920,1927,6706,4344,7383,4786,9890,2010,5228,1224,3158,6967,8580,8990,8883,5213,76,8306,2031,4980,5639,9519,7184,5645,7769,3259,8077,9130,1317,3096,9624,3818,1770,695,2454,947,6029,3474,9938,3527,5696,4760,7724,7738,2848,6442,5767,6845,8323,4131,2859,7595,2500,4815,3660,9130,8580,7016,8231,4391,8369,3444,4069,4021,556,6154,627,2778,1496,4206,6356,8434,8491,3816,8231,3190,5575,1015 66 | 3787,7572,1788,6803,5641,6844,1961,4811,8535,9914,9999,1450,8857,738,4662,8569,6679,2225,7839,8618,286,2648,5342,2294,3205,4546,176,8705,3741,6134,8324,8021,7004,5205,7032,6637,9442,5539,5584,4819,5874,5807,8589,6871,9016,983,1758,3786,1519,6241,185,8398,495,3370,9133,3051,4549,9674,7311,9738,3316,9383,2658,2776,9481,7558,619,3943,3324,6491,4933,153,9738,4623,912,3595,7771,7939,1219,4405 67 | 2650,3883,4154,5809,315,7756,4430,1788,4451,1631,6461,7230,6017,5751,138,588,5282,2442,9110,9035,6349,2515,1570,6122,4192,4174,3530,1933,4186,4420,4609,5739,4135,2963,6308,1161,8809,8619,2796,3819,6971,8228,4188,1492,909,8048,2328,6772,8467,7671,9068,2226,7579,6422,7056,8042,3296,2272,3006,2196,7320,3238,3490,3102,37,1293,3212,4767,5041,8773,5794,4456,6174,7279,7054,2835,7053,9088,790,6640 68 | 3101,1057,7057,3826,6077,1025,2955,1224,1114,6729,5902,4698,6239,7203,9423,1804,4417,6686,1426,6941,8071,1029,4985,9010,6122,6597,1622,1574,3513,1684,7086,5505,3244,411,9638,4150,907,9135,829,981,1707,5359,8781,9751,5,9131,3973,7159,1340,6955,7514,7993,6964,8198,1933,2797,877,3993,4453,8020,9349,8646,2779,8679,2961,3547,3374,3510,1129,3568,2241,2625,9138,5974,8206,7669,7678,1833,8700,4480 69 | 4865,9912,8038,8238,782,3095,8199,1127,4501,7280,2112,2487,3626,2790,9432,1475,6312,8277,4827,2218,5806,7132,8752,1468,7471,6386,739,8762,8323,8120,5169,9078,9058,3370,9560,7987,8585,8531,5347,9312,1058,4271,1159,5286,5404,6925,8606,9204,7361,2415,560,586,4002,2644,1927,2824,768,4409,2942,3345,1002,808,4941,6267,7979,5140,8643,7553,9438,7320,4938,2666,4609,2778,8158,6730,3748,3867,1866,7181 70 | 171,3771,7134,8927,4778,2913,3326,2004,3089,7853,1378,1729,4777,2706,9578,1360,5693,3036,1851,7248,2403,2273,8536,6501,9216,613,9671,7131,7719,6425,773,717,8803,160,1114,7554,7197,753,4513,4322,8499,4533,2609,4226,8710,6627,644,9666,6260,4870,5744,7385,6542,6203,7703,6130,8944,5589,2262,6803,6381,7414,6888,5123,7320,9392,9061,6780,322,8975,7050,5089,1061,2260,3199,1150,1865,5386,9699,6501 71 | 3744,8454,6885,8277,919,1923,4001,6864,7854,5519,2491,6057,8794,9645,1776,5714,9786,9281,7538,6916,3215,395,2501,9618,4835,8846,9708,2813,3303,1794,8309,7176,2206,1602,1838,236,4593,2245,8993,4017,10,8215,6921,5206,4023,5932,6997,7801,262,7640,3107,8275,4938,7822,2425,3223,3886,2105,8700,9526,2088,8662,8034,7004,5710,2124,7164,3574,6630,9980,4242,2901,9471,1491,2117,4562,1130,9086,4117,6698 72 | 2810,2280,2331,1170,4554,4071,8387,1215,2274,9848,6738,1604,7281,8805,439,1298,8318,7834,9426,8603,6092,7944,1309,8828,303,3157,4638,4439,9175,1921,4695,7716,1494,1015,1772,5913,1127,1952,1950,8905,4064,9890,385,9357,7945,5035,7082,5369,4093,6546,5187,5637,2041,8946,1758,7111,6566,1027,1049,5148,7224,7248,296,6169,375,1656,7993,2816,3717,4279,4675,1609,3317,42,6201,3100,3144,163,9530,4531 73 | 7096,6070,1009,4988,3538,5801,7149,3063,2324,2912,7911,7002,4338,7880,2481,7368,3516,2016,7556,2193,1388,3865,8125,4637,4096,8114,750,3144,1938,7002,9343,4095,1392,4220,3455,6969,9647,1321,9048,1996,1640,6626,1788,314,9578,6630,2813,6626,4981,9908,7024,4355,3201,3521,3864,3303,464,1923,595,9801,3391,8366,8084,9374,1041,8807,9085,1892,9431,8317,9016,9221,8574,9981,9240,5395,2009,6310,2854,9255 74 | 8830,3145,2960,9615,8220,6061,3452,2918,6481,9278,2297,3385,6565,7066,7316,5682,107,7646,4466,68,1952,9603,8615,54,7191,791,6833,2560,693,9733,4168,570,9127,9537,1925,8287,5508,4297,8452,8795,6213,7994,2420,4208,524,5915,8602,8330,2651,8547,6156,1812,6271,7991,9407,9804,1553,6866,1128,2119,4691,9711,8315,5879,9935,6900,482,682,4126,1041,428,6247,3720,5882,7526,2582,4327,7725,3503,2631 75 | 2738,9323,721,7434,1453,6294,2957,3786,5722,6019,8685,4386,3066,9057,6860,499,5315,3045,5194,7111,3137,9104,941,586,3066,755,4177,8819,7040,5309,3583,3897,4428,7788,4721,7249,6559,7324,825,7311,3760,6064,6070,9672,4882,584,1365,9739,9331,5783,2624,7889,1604,1303,1555,7125,8312,425,8936,3233,7724,1480,403,7440,1784,1754,4721,1569,652,3893,4574,5692,9730,4813,9844,8291,9199,7101,3391,8914 76 | 6044,2928,9332,3328,8588,447,3830,1176,3523,2705,8365,6136,5442,9049,5526,8575,8869,9031,7280,706,2794,8814,5767,4241,7696,78,6570,556,5083,1426,4502,3336,9518,2292,1885,3740,3153,9348,9331,8051,2759,5407,9028,7840,9255,831,515,2612,9747,7435,8964,4971,2048,4900,5967,8271,1719,9670,2810,6777,1594,6367,6259,8316,3815,1689,6840,9437,4361,822,9619,3065,83,6344,7486,8657,8228,9635,6932,4864 77 | 8478,4777,6334,4678,7476,4963,6735,3096,5860,1405,5127,7269,7793,4738,227,9168,2996,8928,765,733,1276,7677,6258,1528,9558,3329,302,8901,1422,8277,6340,645,9125,8869,5952,141,8141,1816,9635,4025,4184,3093,83,2344,2747,9352,7966,1206,1126,1826,218,7939,2957,2729,810,8752,5247,4174,4038,8884,7899,9567,301,5265,5752,7524,4381,1669,3106,8270,6228,6373,754,2547,4240,2313,5514,3022,1040,9738 78 | 2265,8192,1763,1369,8469,8789,4836,52,1212,6690,5257,8918,6723,6319,378,4039,2421,8555,8184,9577,1432,7139,8078,5452,9628,7579,4161,7490,5159,8559,1011,81,478,5840,1964,1334,6875,8670,9900,739,1514,8692,522,9316,6955,1345,8132,2277,3193,9773,3923,4177,2183,1236,6747,6575,4874,6003,6409,8187,745,8776,9440,7543,9825,2582,7381,8147,7236,5185,7564,6125,218,7991,6394,391,7659,7456,5128,5294 79 | 2132,8992,8160,5782,4420,3371,3798,5054,552,5631,7546,4716,1332,6486,7892,7441,4370,6231,4579,2121,8615,1145,9391,1524,1385,2400,9437,2454,7896,7467,2928,8400,3299,4025,7458,4703,7206,6358,792,6200,725,4275,4136,7390,5984,4502,7929,5085,8176,4600,119,3568,76,9363,6943,2248,9077,9731,6213,5817,6729,4190,3092,6910,759,2682,8380,1254,9604,3011,9291,5329,9453,9746,2739,6522,3765,5634,1113,5789 80 | 5304,5499,564,2801,679,2653,1783,3608,7359,7797,3284,796,3222,437,7185,6135,8571,2778,7488,5746,678,6140,861,7750,803,9859,9918,2425,3734,2698,9005,4864,9818,6743,2475,132,9486,3825,5472,919,292,4411,7213,7699,6435,9019,6769,1388,802,2124,1345,8493,9487,8558,7061,8777,8833,2427,2238,5409,4957,8503,3171,7622,5779,6145,2417,5873,5563,5693,9574,9491,1937,7384,4563,6842,5432,2751,3406,7981 81 | -------------------------------------------------------------------------------- /p081-path-sum-two-ways/pathsumtwo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PawanKolhe/C-Algorithms/dd005e16fde4c2423f7afa1d125209e07a7a8e8e/p081-path-sum-two-ways/pathsumtwo -------------------------------------------------------------------------------- /p081-path-sum-two-ways/pathsumtwo.cpp: -------------------------------------------------------------------------------- 1 | // Project Euler 2019 2 | // Vinicius Rodrigues 23.10.2019 3 | // Path sum: Two Ways : Problem 81 4 | 5 | #include 6 | #include 7 | 8 | using namespace std; 9 | 10 | int matrix[80][80]; 11 | 12 | void makeMatrix(int m[80][80], string s) 13 | { 14 | int l = 0, c = 0; 15 | string num = ""; 16 | for(int i = 0; i < s.length(); i++) 17 | { 18 | if(s[i] == '\n' or s[i] == ',') 19 | { 20 | if(num.length() > 0) 21 | { 22 | m[l][c] = atoi(num.c_str()); 23 | num = ""; 24 | } 25 | if(s[i] == '\n') {l++; c=0;} 26 | else c++; 27 | } 28 | else 29 | { 30 | num += s[i]; 31 | } 32 | } 33 | } 34 | 35 | void scanMatrix(int m[80][80]) 36 | { 37 | for(int i = 0; i < 80; i++) 38 | { 39 | for(int j = 0; j < 80; j++) 40 | { 41 | if(i != 0 and j != 0) 42 | m[i][j] += min(m[i-1][j], m[i][j-1]); 43 | else if(i == 0 and j != 0) 44 | m[i][j] += m[i][j-1]; 45 | else if(i != 0 and j == 0) 46 | m[i][j] += m[i-1][j]; 47 | } 48 | } 49 | } 50 | 51 | int main() 52 | { 53 | ifstream file("p081_matrix.txt"); 54 | string text = "", line = ""; 55 | while(!file.eof()) 56 | { 57 | getline(file, line); 58 | text += line + '\n'; 59 | } 60 | 61 | makeMatrix(matrix, text); 62 | 63 | scanMatrix(matrix); 64 | 65 | cout << matrix[79][79] << endl; 66 | } 67 | --------------------------------------------------------------------------------