├── README ├── c_lang ├── points_distance.c ├── print_bits.c └── varargs.c ├── data_structures ├── btree.c ├── grap_adjacency_matrix.c ├── hash_table.c ├── queue.c └── stack.c ├── math └── permutations.c ├── projecteuler ├── problem1.c ├── problem10.c ├── problem2.c ├── problem3.c ├── problem4.c ├── problem5.c ├── problem6.c ├── problem7.c └── problem8.c ├── sorting_algorithms ├── bubble_sort.c ├── merge_sort.c └── quick_sort.c └── strings_manipulation └── revese_words.c /README: -------------------------------------------------------------------------------- 1 | 2 | techinterviewprep: A repository of code I wrote to prepare for a technical interview 3 | 4 | About 5 | 6 | ================================================================================================ 7 | 8 | Most of the high-tech companies (Google, Amazon, Facebook, Yahoo) today have technical interviews 9 | in their hiring process. 10 | 11 | These interviews are used to measure the skills of the applicant and include real time coding problems. 12 | Many of these problems include basic Computer Science concepts like data structures and algorithm 13 | complexity analysis. 14 | 15 | Since I have graduate a few years ago I wrote some code to refresh the concepts. I created this repo 16 | to maintain this code I wrote. I focused in remember the concepts I learned at college given the short 17 | time I have to prepare for the interview, so the implementations are rough and are not efficient at all. 18 | I share the code only because I already wrote it and maybe someone will find it useful. 19 | 20 | For every topic I created a subdirectory, this topis are: 21 | 22 | 1- Sorting algorithms 23 | 2- Data structures 24 | 3- Strings manipulation 25 | 4- Math problems (mostly from eulerproject) 26 | 5- Unix system programming 27 | 28 | Bugs, comments or patches: martinez.javier@gmail.com 29 | -------------------------------------------------------------------------------- /c_lang/points_distance.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define POINTS_COUNT 10 6 | 7 | struct point { 8 | int x; 9 | int y; 10 | int z; 11 | double distance; 12 | }; 13 | 14 | struct point* init_point(void); 15 | void print_points(struct point *points[]); 16 | void calc_distance(struct point*, struct point*); 17 | int compare(const void *a, const void *b); 18 | 19 | int main(void) 20 | { 21 | struct point *points[POINTS_COUNT]; 22 | 23 | struct point init; 24 | 25 | int i; 26 | 27 | init.x = 0; 28 | init.y = 0; 29 | init.z = 0; 30 | 31 | for (i = 0; i < POINTS_COUNT; i++) { 32 | points[i] = init_point(); 33 | calc_distance(&init, points[i]); 34 | } 35 | 36 | qsort(points, POINTS_COUNT, sizeof(*points), &compare); 37 | 38 | print_points(points); 39 | 40 | } 41 | 42 | struct point* init_point(void) 43 | { 44 | struct point *p = (struct point*)malloc(sizeof(struct point)); 45 | 46 | p->x = rand() % 10; 47 | p->y = rand() % 10; 48 | p->z = rand() % 10; 49 | p->distance = 0.0; 50 | 51 | return p; 52 | } 53 | 54 | void print_points(struct point *points[]) 55 | { 56 | int i; 57 | 58 | for (i = 0; i < POINTS_COUNT; i++) 59 | printf("POINT X = %d Y = %d Z = %d distance = %2f\n", points[i]->x, points[i]->y, points[i]->z, points[i]->distance); 60 | } 61 | 62 | void calc_distance(struct point *init, struct point *p) 63 | { 64 | p->distance = sqrt(pow(p->x - init->x, 2) + pow(p->y - init->y, 2) + pow(p->z - init->z, 2)); 65 | } 66 | 67 | int compare(const void *a, const void *b) 68 | { 69 | struct point *point_a = *(struct point **)a; 70 | struct point *point_b = *(struct point **)b; 71 | 72 | printf("%f %f\n", point_a->distance, point_b->distance); 73 | printf("Diff = %f\n", point_a->distance - point_b->distance); 74 | return point_a->distance - point_b->distance; 75 | } 76 | -------------------------------------------------------------------------------- /c_lang/print_bits.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void print_bits(char c); 4 | void do_print_bits(char c, int idx); 5 | 6 | int main(void) 7 | { 8 | print_bits('0'); 9 | print_bits('A'); 10 | print_bits('a'); 11 | } 12 | 13 | void print_bits(char c) 14 | { 15 | int i; 16 | 17 | printf("Char %c bits = ", c); 18 | 19 | do_print_bits(c, sizeof(c)*8); 20 | 21 | printf("\n"); 22 | } 23 | 24 | void do_print_bits(char c, int idx) 25 | { 26 | int one; 27 | 28 | if (idx == 0) 29 | return; 30 | 31 | if (c & 1) 32 | one = 1; 33 | else 34 | one = 0; 35 | 36 | idx--; 37 | c >>= 1; 38 | 39 | do_print_bits(c, idx); 40 | 41 | if (one) 42 | printf("1"); 43 | else 44 | printf("0"); 45 | } 46 | -------------------------------------------------------------------------------- /c_lang/varargs.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void print_numbers(int number, ...); 5 | 6 | int main(void) 7 | { 8 | print_numbers(1); 9 | print_numbers(1, 2, 3); 10 | print_numbers(1, 2, 3, 4, 5); 11 | 12 | } 13 | 14 | void print_numbers(int number, ...) 15 | { 16 | va_list numbers; 17 | int i; 18 | 19 | va_start(numbers, number); 20 | for (i = number; i >= 0; i = va_arg(numbers, int)) 21 | printf("%d ", i); 22 | va_end(numbers); 23 | 24 | printf("\n"); 25 | } 26 | -------------------------------------------------------------------------------- /data_structures/btree.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct node { 5 | int data; 6 | struct node *left; 7 | struct node *right; 8 | }; 9 | 10 | struct node *create_node(int); 11 | struct node *insert(struct node*, int); 12 | int lookup(struct node *, int); 13 | void print_inorder(struct node *); 14 | void print_preorder(struct node *); 15 | void print_postorder(struct node *); 16 | int size(struct node *); 17 | int max_depth(struct node*); 18 | int min_value(struct node*); 19 | int max_value(struct node*); 20 | 21 | int main(void) 22 | { 23 | struct node *root = NULL; 24 | root = insert(root, 4); 25 | root = insert(root, 2); 26 | root = insert(root, 3); 27 | root = insert(root, 7); 28 | root = insert(root, 10); 29 | 30 | printf("Preorder\n"); 31 | print_preorder(root); 32 | printf("Inorder\n"); 33 | print_inorder(root); 34 | printf("Postorder\n"); 35 | print_postorder(root); 36 | 37 | printf("The tree size is %d\n", size(root)); 38 | printf("The tree max depth is %d\n", max_depth(root)); 39 | printf("The min value is %d\n", min_value(root)); 40 | printf("The max value is %d\n", max_value(root)); 41 | } 42 | 43 | struct node *create_node(int data) 44 | { 45 | struct node *node = (struct node *) malloc(sizeof(struct node)); 46 | 47 | if (node == NULL) 48 | return NULL; 49 | 50 | node->data = data; 51 | node->left = NULL; 52 | node->right = NULL; 53 | 54 | return node; 55 | } 56 | 57 | struct node *insert(struct node *node, int data) 58 | { 59 | if (node == NULL) 60 | return create_node(data); 61 | 62 | if (data <= node->data) 63 | node->left = insert(node->left, data); 64 | else 65 | node->right = insert(node->right, data); 66 | 67 | return node; 68 | } 69 | 70 | int lookup(struct node *node, int target) 71 | { 72 | if (node == NULL) 73 | return 0; 74 | 75 | if (node->data == target) 76 | return 1; 77 | 78 | if (node->data < target) 79 | lookup(node->right, target); 80 | else 81 | lookup(node->left, target); 82 | } 83 | 84 | void print_preorder(struct node *node) 85 | { 86 | if (node == NULL) 87 | return; 88 | 89 | printf("%d\n", node->data); 90 | 91 | print_preorder(node->left); 92 | 93 | print_preorder(node->right); 94 | 95 | } 96 | 97 | void print_inorder(struct node *node) 98 | { 99 | if (node == NULL) 100 | return; 101 | 102 | print_inorder(node->left); 103 | 104 | printf("%d\n", node->data); 105 | 106 | print_inorder(node->right); 107 | } 108 | 109 | void print_postorder(struct node *node) 110 | { 111 | if (node == NULL) 112 | return; 113 | 114 | print_postorder(node->left); 115 | 116 | print_postorder(node->right); 117 | 118 | printf("%d\n", node->data); 119 | } 120 | 121 | int size(struct node *node) 122 | { 123 | int count = 1; 124 | if (node == NULL) 125 | return 0; 126 | 127 | count += (size(node->left) + size(node->right)); 128 | 129 | return count; 130 | } 131 | 132 | int max_depth(struct node *node) 133 | { 134 | int ldepth; 135 | int rdepth; 136 | 137 | if (node == NULL) 138 | return 0; 139 | 140 | ldepth = max_depth(node->left); 141 | rdepth = max_depth(node->right); 142 | 143 | if (ldepth > rdepth) 144 | return ldepth + 1; 145 | else 146 | return rdepth + 1; 147 | } 148 | 149 | int min_value(struct node *node) 150 | { 151 | struct node *current = node; 152 | 153 | while(current->left) { 154 | current = current->left; 155 | } 156 | 157 | return current->data; 158 | } 159 | 160 | int max_value(struct node *node) 161 | { 162 | struct node *current = node; 163 | 164 | while(current->right) { 165 | current = current->right; 166 | } 167 | 168 | return current->data; 169 | } 170 | 171 | 172 | -------------------------------------------------------------------------------- /data_structures/grap_adjacency_matrix.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define GRAPH_SIZE 10 5 | 6 | int graph[GRAPH_SIZE][GRAPH_SIZE]; 7 | int processed[GRAPH_SIZE]; 8 | int discovered[GRAPH_SIZE]; 9 | int parent[GRAPH_SIZE]; 10 | int distance[GRAPH_SIZE]; 11 | 12 | #define NONE -1 13 | #define DISCOVERED 1 14 | #define UNDISCOVERED 0 15 | #define FULLY_EXPLORED 2 16 | #define PROCESSED 1 17 | #define UNPROCESSED 0 18 | 19 | #define INFINITY 1000000 20 | 21 | void connect(int, int); 22 | void connect_weighted(int, int, int); 23 | void disconnect(int, int); 24 | int connected(int, int); 25 | int reachable(int, int); 26 | void bfs(int); 27 | void do_bfs(int); 28 | void dfs(int); 29 | void do_dfs(int); 30 | void init_graph(void); 31 | int exists_path(int, int); 32 | int do_exists_path(int, int); 33 | void print_adjacency_matrix(void); 34 | int is_tree(void); 35 | int vertex_count(void); 36 | int edge_count(void); 37 | void dijkstra(int, int); 38 | void do_dijkstra(int, int); 39 | void print_short_path(int); 40 | 41 | int main(void) 42 | { 43 | 44 | connect_weighted(1, 2, 2); 45 | connect_weighted(1, 3, 9); 46 | connect_weighted(1, 7, 4); 47 | connect_weighted(2, 3, 4); 48 | connect_weighted(2, 4, 2); 49 | connect_weighted(2, 6, 7); 50 | connect_weighted(2, 7, 6); 51 | connect_weighted(3, 4, 3); 52 | connect_weighted(4, 5, 5); 53 | connect_weighted(4, 6, 3); 54 | connect_weighted(5, 6, 3); 55 | connect_weighted(5, 8, 4); 56 | connect_weighted(6, 7, 5); 57 | connect_weighted(6, 8, 4); 58 | connect_weighted(7, 9, 2); 59 | connect_weighted(8, 9, 3); 60 | 61 | 62 | printf("Graph characteristics\n"); 63 | printf("Adjacency matrix\n"); 64 | print_adjacency_matrix(); 65 | printf("Number of vertexs %d\n", vertex_count()); 66 | printf("Number of egdes %d\n", edge_count()); 67 | 68 | printf("Exists path between %d and %d? %s\n", 1, 5, exists_path(1, 5) ? "yes" : "no"); 69 | 70 | printf("The graph is a tree? %s\n", is_tree() ? "yes" : "no"); 71 | 72 | printf("Bread First Search\n"); 73 | bfs(1); 74 | printf("Deep First Search\n"); 75 | dfs(1); 76 | 77 | dijkstra(1, 5); 78 | } 79 | 80 | void connect(int i, int j) 81 | { 82 | connect_weighted(i, j, 1); 83 | } 84 | 85 | void connect_weighted(int i, int j, int w) 86 | { 87 | graph[i][j] = w; 88 | graph[j][i] = w; 89 | } 90 | 91 | void disconnect(int i, int j) 92 | { 93 | graph[i][j] = 0; 94 | graph[j][i] = 0; 95 | } 96 | 97 | int connected(int i, int j) 98 | { 99 | return graph[i][j]; 100 | } 101 | 102 | void bfs(int start) 103 | { 104 | init_graph(); 105 | do_bfs(start); 106 | } 107 | 108 | void do_bfs(int start) 109 | { 110 | int i; 111 | 112 | if (!discovered[start]) { 113 | printf("%d\n", start); 114 | discovered[start] = DISCOVERED; 115 | processed[start] = PROCESSED; 116 | } 117 | 118 | for (i = 0; i < GRAPH_SIZE; i++) { 119 | if (graph[start][i] && !processed[i]) { 120 | processed[i] = PROCESSED; 121 | printf("%d\n", i); 122 | } 123 | } 124 | 125 | for (i = 0; i < GRAPH_SIZE; i++) { 126 | if (graph[start][i] && !discovered[i]) { 127 | discovered[i] = DISCOVERED; 128 | do_bfs(i); 129 | } 130 | } 131 | } 132 | 133 | void dfs(int start) 134 | { 135 | init_graph(); 136 | do_dfs(start); 137 | } 138 | 139 | void do_dfs(int start) 140 | { 141 | int i; 142 | 143 | if (!discovered[start]) { 144 | printf("%d\n", start); 145 | discovered[start] = DISCOVERED; 146 | processed[start] = PROCESSED; 147 | } 148 | 149 | for (i = 0; i < GRAPH_SIZE; i++) { 150 | if (graph[start][i] && !discovered[i]) { 151 | do_bfs(i); 152 | } 153 | } 154 | } 155 | 156 | void init_graph(void) 157 | { 158 | int i; 159 | 160 | for (i = 0; i < GRAPH_SIZE; i++) { 161 | processed[i] = UNPROCESSED; 162 | discovered[i] = UNDISCOVERED; 163 | parent[i] = NONE; 164 | } 165 | } 166 | 167 | int exists_path(int src, int dest) 168 | { 169 | init_graph(); 170 | return do_exists_path(src, dest); 171 | } 172 | 173 | int do_exists_path(int src, int dest) 174 | { 175 | int i; 176 | 177 | processed[src] = PROCESSED; 178 | 179 | if (src == dest) 180 | return 1; 181 | 182 | for (i = 0; i < GRAPH_SIZE; i++) { 183 | if (graph[src][i] && !processed[i]) 184 | if (do_exists_path(i, dest)) 185 | return 1; 186 | } 187 | 188 | return 0; 189 | } 190 | 191 | void print_adjacency_matrix(void) 192 | { 193 | int i,j; 194 | 195 | for (i = 0; i < GRAPH_SIZE; i++) { 196 | for (j = 0; j < GRAPH_SIZE; j++) 197 | printf("%d ", graph[i][j]); 198 | printf("\n"); 199 | } 200 | } 201 | 202 | int is_tree(void) 203 | { 204 | int i,j; 205 | int found = 0; 206 | int processed_count = 0; 207 | 208 | for (i = 0; i < GRAPH_SIZE && !found; i++) 209 | for (j = i; j < GRAPH_SIZE && !found; j++) 210 | if (graph[i][j]) { 211 | found = 1; 212 | dfs(i); 213 | } 214 | 215 | for (i = 0; i < GRAPH_SIZE; i++) 216 | if(processed[i]) 217 | processed_count++; 218 | 219 | return processed_count == vertex_count() && edge_count() == processed_count - 1; 220 | } 221 | 222 | int vertex_count(void) 223 | { 224 | int i, j; 225 | int vertex_found[GRAPH_SIZE]; 226 | int vertex_count = 0; 227 | 228 | memset(vertex_found, 0, sizeof(int)*GRAPH_SIZE); 229 | 230 | for (i = 0; i < GRAPH_SIZE; i++) 231 | for (j = i; j < GRAPH_SIZE; j++) 232 | if (graph[i][j]) { 233 | vertex_found[i] = 1; 234 | vertex_found[j] = 1; 235 | } 236 | 237 | for (i = 0; i < GRAPH_SIZE; i++) 238 | if(vertex_found[i]) 239 | vertex_count++; 240 | 241 | return vertex_count; 242 | } 243 | 244 | int edge_count(void) 245 | { 246 | int i,j; 247 | int edge_count = 0; 248 | 249 | for (i = 0; i < GRAPH_SIZE; i++) 250 | for (j = i; j < GRAPH_SIZE; j++) 251 | if (graph[i][j]) 252 | edge_count++; 253 | 254 | return edge_count; 255 | } 256 | 257 | void dijkstra(int src, int dest) 258 | { 259 | int i; 260 | 261 | init_graph(); 262 | 263 | for (i = 0; i < GRAPH_SIZE; i++) { 264 | distance[i] = INFINITY; 265 | parent[i] = -1; 266 | } 267 | 268 | do_dijkstra(src, src); 269 | 270 | for (i = 0; i < GRAPH_SIZE; i++) { 271 | printf("node = %d parent = %d distance = %d\n", i, parent[i], distance[i]); 272 | } 273 | 274 | print_short_path(dest); 275 | } 276 | 277 | void do_dijkstra(int src, int current) 278 | { 279 | int i; 280 | 281 | if (src == current) { 282 | distance[current] = 0; 283 | } 284 | 285 | for (i = 0; i < GRAPH_SIZE; i++) { 286 | if (graph[current][i] && !processed[i]) { 287 | if (distance[i] > distance[current] + graph[current][i]) { 288 | distance[i] = distance[current] + graph[current][i]; 289 | parent[i] = current; 290 | } 291 | } 292 | } 293 | 294 | processed[current] = PROCESSED; 295 | 296 | for (i = 0; i < GRAPH_SIZE; i++) { 297 | if (graph[current][i] && !processed[i]) { 298 | do_dijkstra(src, i); 299 | } 300 | } 301 | } 302 | 303 | void print_short_path(int dest) 304 | { 305 | if (parent[dest] == -1) { 306 | printf("%d\n", dest); 307 | return; 308 | } 309 | 310 | print_short_path(parent[dest]); 311 | 312 | printf("%d\n", dest); 313 | } 314 | -------------------------------------------------------------------------------- /data_structures/hash_table.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define MAX_STRING 20 6 | #define MAX_ELEMENTS 100 7 | 8 | struct node { 9 | int value; 10 | char key[MAX_STRING]; 11 | struct node *next; 12 | }; 13 | 14 | struct node *hash_table[MAX_ELEMENTS]; 15 | 16 | int size = 0; 17 | 18 | int hash_function(char *); 19 | void put(char *, int); 20 | int get(char *); 21 | int delete(char *); 22 | struct node* create_node(char *, int); 23 | void insert_node(struct node*, int); 24 | int remove_node(char *, int); 25 | int hash_table_size(); 26 | int isempty(); 27 | void print_hash_table(); 28 | void print_hash_table_row(struct node *, int); 29 | 30 | int main(void) 31 | { 32 | char *strings[] = { "perro", "gato", "javier", "tami"}; 33 | int i, len; 34 | 35 | for (i = 0; i < 4; i++) 36 | put(strings[i], i); 37 | 38 | printf("Hash table size is %d\n", hash_table_size()); 39 | 40 | print_hash_table(); 41 | } 42 | 43 | int hash_function(char *key) 44 | { 45 | int index = 0, i; 46 | int len = strlen(key); 47 | 48 | for (i = 0; i < len; i++) 49 | index += key[i]; 50 | 51 | return index % MAX_ELEMENTS; 52 | } 53 | 54 | void put(char *key, int value) 55 | { 56 | int index; 57 | struct node *node = create_node(key, value); 58 | 59 | index = hash_function(key); 60 | 61 | insert_node(node, index); 62 | } 63 | 64 | int delete(char *key) 65 | { 66 | int index; 67 | 68 | index = hash_function(key); 69 | 70 | return remove_node(key, index); 71 | } 72 | 73 | struct node *create_node(char *key, int value) 74 | { 75 | struct node *node = (struct node*)malloc(sizeof(struct node)); 76 | 77 | if (node == NULL) 78 | return NULL; 79 | 80 | strncpy(node->key, key, MAX_STRING); 81 | node->value = value; 82 | node->next = NULL; 83 | 84 | return node; 85 | } 86 | 87 | void insert_node(struct node *node, int index) 88 | { 89 | struct node *current; 90 | 91 | if (hash_table[index] == NULL) 92 | hash_table[index] = node; 93 | else { 94 | current = hash_table[index]; 95 | 96 | while(current->next) { 97 | current = current->next; 98 | } 99 | 100 | current->next = node; 101 | } 102 | 103 | size++; 104 | } 105 | 106 | int remove_node(char *key, int index) 107 | { 108 | int retval; 109 | struct node *current = hash_table[index]; 110 | struct node *last = hash_table[index]; 111 | 112 | while(!strncmp(current->key, key, MAX_STRING) && current->next) { 113 | last = current; 114 | current = current->next; 115 | } 116 | 117 | retval = current->value; 118 | last->next = current->next; 119 | 120 | free(current); 121 | size--; 122 | return retval; 123 | } 124 | 125 | int hash_table_size() 126 | { 127 | return size; 128 | } 129 | 130 | int isempty() 131 | { 132 | return !size; 133 | } 134 | 135 | void print_hash_table() 136 | { 137 | int i; 138 | for (i = 0; i < MAX_ELEMENTS; i++) { 139 | if (hash_table[i] != NULL) 140 | print_hash_table_row(hash_table[i], i); 141 | } 142 | } 143 | 144 | void print_hash_table_row(struct node *node, int idx) 145 | { 146 | struct node *current = node; 147 | 148 | printf("idx=%d ", idx); 149 | 150 | while(current) { 151 | printf("<%s, %d> ", current->key, current->value); 152 | current = current->next; 153 | } 154 | 155 | printf("\n----------------------\n"); 156 | } 157 | -------------------------------------------------------------------------------- /data_structures/queue.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define MAX_SIZE 10 4 | 5 | int queue[MAX_SIZE]; 6 | 7 | int head = 0, tail = 0; 8 | int count = 0; 9 | 10 | int empty(); 11 | int front(); 12 | int pop(); 13 | int push(int); 14 | int size(); 15 | int isfull(); 16 | void print_queue(); 17 | 18 | int main(void) 19 | { 20 | printf("Queue empty = %d\n", empty()); 21 | 22 | push(1); 23 | push(2); 24 | push(3); 25 | push(4); 26 | push(5); 27 | push(6); 28 | push(7); 29 | push(8); 30 | push(9); 31 | push(10); 32 | push(11); 33 | 34 | printf("Queue empty = %d\n", empty()); 35 | 36 | print_queue(); 37 | 38 | printf("Removed element %d\n", pop()); 39 | printf("Removed element %d\n", pop()); 40 | 41 | print_queue(); 42 | 43 | push(22); 44 | push(33); 45 | push(44); 46 | 47 | print_queue(); 48 | } 49 | 50 | int empty() 51 | { 52 | // return head == tail; 53 | return !count; 54 | } 55 | 56 | int pop() 57 | { 58 | int value; 59 | 60 | if (empty()) { 61 | printf("An element cannot be removed from the queue, it is empty!\n"); 62 | return 0; 63 | } 64 | 65 | value = queue[head]; 66 | 67 | head++; 68 | head %= MAX_SIZE; 69 | 70 | count--; 71 | 72 | return value; 73 | } 74 | 75 | int push(int element) 76 | { 77 | if (isfull()) { 78 | printf("The element %d cannont be added - queue is full\n", element); 79 | return 1; 80 | } 81 | 82 | queue[tail] = element; 83 | 84 | tail = (tail + 1) % MAX_SIZE; 85 | 86 | count++; 87 | } 88 | 89 | int size() 90 | { 91 | return tail + MAX_SIZE - head; 92 | } 93 | 94 | int isfull() 95 | { 96 | return count == MAX_SIZE; 97 | } 98 | 99 | void print_queue() 100 | { 101 | int idx; 102 | 103 | for (idx = head; idx < head + count; idx++) 104 | printf("%d ", queue[idx % MAX_SIZE]); 105 | 106 | printf("\n"); 107 | } 108 | 109 | -------------------------------------------------------------------------------- /data_structures/stack.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define MAX_SIZE 10 4 | 5 | int stack[MAX_SIZE]; 6 | 7 | int size = 0; 8 | 9 | int push(int); 10 | int pop(); 11 | int stack_top(); 12 | void print_stack(); 13 | 14 | int main(void) 15 | { 16 | push(1); 17 | push(2); 18 | push(3); 19 | push(4); 20 | push(5); 21 | print_stack(); 22 | 23 | printf("Deleting element %d\n", pop()); 24 | printf("Deleting element %d\n", pop()); 25 | printf("Deleting element %d\n", pop()); 26 | 27 | print_stack(); 28 | 29 | printf("Deleting element %d\n", pop()); 30 | printf("Deleting element %d\n", pop()); 31 | printf("Deleting element %d\n", pop()); 32 | 33 | } 34 | 35 | int push(int element) 36 | { 37 | if (size == MAX_SIZE - 1) { 38 | printf("Cannot inset element %d stack is full\n", element); 39 | return -1; 40 | } 41 | 42 | stack[size++] = element; 43 | 44 | return 0; 45 | } 46 | 47 | int pop() 48 | { 49 | if (size == 0) { 50 | printf("Cannot delete element stack is empty\n"); 51 | return -1; 52 | } 53 | 54 | return stack[--size]; 55 | } 56 | 57 | int stack_top() 58 | { 59 | if (size == 0) { 60 | printf("Cannot obtain top stack is empty\n"); 61 | return -1; 62 | } 63 | 64 | return stack[size - 1]; 65 | } 66 | 67 | void print_stack() 68 | { 69 | int i; 70 | 71 | for (i = size; i > 0; i--) { 72 | printf("%d\n", stack[i - 1]); 73 | printf("--------\n"); 74 | } 75 | } 76 | -------------------------------------------------------------------------------- /math/permutations.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void permute(int numbers[], int start, int size); 4 | void printv(int numbers[], int size); 5 | void swap(int *x, int *y); 6 | 7 | int main(void) 8 | { 9 | int numbers[] = {1, 2, 3}; 10 | 11 | permute(numbers, 0, sizeof(numbers)/sizeof(numbers[0])); 12 | } 13 | 14 | void permute(int numbers[], int start, int size) 15 | { 16 | int i, aux; 17 | 18 | if (start == size) 19 | printv(numbers, size); 20 | else { 21 | for (i = start; i < size; i++) { 22 | swap(&numbers[start], &numbers[i]); 23 | permute(numbers, start + 1, size); 24 | swap(&numbers[start], &numbers[i]); 25 | } 26 | } 27 | } 28 | 29 | void swap(int *x, int *y) 30 | { 31 | int aux; 32 | 33 | aux = *x; 34 | *x = *y; 35 | *y = aux; 36 | } 37 | 38 | void printv(int numbers[], int size) 39 | { 40 | int i; 41 | 42 | for (i = 0; i < size; i++) 43 | printf("%d ", numbers[i]); 44 | printf("\n"); 45 | } 46 | -------------------------------------------------------------------------------- /projecteuler/problem1.c: -------------------------------------------------------------------------------- 1 | /* 2 | If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23. 3 | 4 | Find the sum of all the multiples of 3 or 5 below 1000. 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | #define MAX_NUMBERS 1000 11 | #define ARRAY_LEN(X) (sizeof(X)/sizeof(X[0])) 12 | 13 | int mult[] = {3, 5}; 14 | 15 | int main(void) 16 | { 17 | long sum = 0; 18 | int i; 19 | int j; 20 | 21 | int l = ARRAY_LEN(mult); 22 | 23 | for (i = 0; i < MAX_NUMBERS; i++) { 24 | for (j = 0; j < l; j++) { 25 | if (i % mult[j] == 0) { 26 | printf("%d is multiply of %d\n", i, mult[j]); 27 | sum += i; 28 | break; 29 | } 30 | } 31 | } 32 | 33 | printf("Total is %ld\n", sum); 34 | } 35 | 36 | -------------------------------------------------------------------------------- /projecteuler/problem10.c: -------------------------------------------------------------------------------- 1 | /* 2 | The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17. 3 | 4 | Find the sum of all the primes below two million. 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | #define MAX 2000000 11 | 12 | int is_prime(long long i); 13 | 14 | int main(void) 15 | { 16 | long long i; 17 | long long sum = 2; 18 | 19 | for (i = 3; i < MAX; i+=2) { 20 | printf("%ld\n", i); 21 | if (is_prime(i)) 22 | sum += i; 23 | } 24 | 25 | printf("The sum is %lld\n", sum); 26 | } 27 | 28 | int is_prime(long long i) 29 | { 30 | long j; 31 | int prime = 1; 32 | 33 | int sq = sqrt(i); 34 | 35 | 36 | for(j = 2; j <= sq; j++) 37 | if (i % j == 0) 38 | prime = 0; 39 | 40 | return prime; 41 | } 42 | 43 | 44 | -------------------------------------------------------------------------------- /projecteuler/problem2.c: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be: 4 | 5 | 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ... 6 | 7 | By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms. 8 | 9 | */ 10 | 11 | #include 12 | 13 | int fibonacci(int term); 14 | 15 | int main(void) 16 | { 17 | int i = 0; 18 | int term = 0; 19 | double sum; 20 | 21 | do { 22 | i++; 23 | term = fibonacci(i); 24 | if (term % 2 == 0) { 25 | sum += term; 26 | } 27 | } while (term < 4000000); 28 | printf("The sum is %f\n", sum); 29 | } 30 | 31 | int fibonacci(term) 32 | { 33 | if (term == 1) 34 | return 1; 35 | else if (term == 2) 36 | return 2; 37 | else 38 | return fibonacci(term - 1) + fibonacci(term - 2); 39 | } 40 | -------------------------------------------------------------------------------- /projecteuler/problem3.c: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | The prime factors of 13195 are 5, 7, 13 and 29. 4 | 5 | What is the largest prime factor of the number 600851475143 ? 6 | 7 | */ 8 | 9 | #include 10 | 11 | #define NUMBER 600851475143 12 | 13 | int is_prime(unsigned long long i); 14 | 15 | int main(void) 16 | { 17 | unsigned long long i; 18 | unsigned long long largest_prime = 0; 19 | 20 | for (i = 2; i < 100; i++) 21 | if (is_prime(i) && NUMBER % i == 0) 22 | largest_prime = i; 23 | 24 | printf("The largest prime is %lld\n", largest_prime); 25 | } 26 | 27 | int is_prime(unsigned long long i) 28 | { 29 | unsigned long long j; 30 | int prime = 1; 31 | 32 | for(j = 2; j < sqrt(i); j++) 33 | if (i % j == 0) 34 | prime = 0; 35 | 36 | return prime; 37 | } 38 | -------------------------------------------------------------------------------- /projecteuler/problem4.c: -------------------------------------------------------------------------------- 1 | /* 2 | A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99. 3 | 4 | Find the largest palindrome made from the product of two 3-digit numbers. 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | #define BUF_LEN 100 11 | #define MAX 999 12 | 13 | int is_palindromic(int number); 14 | 15 | int main(void) 16 | { 17 | int i, j; 18 | int max_palindromic = 0; 19 | int result; 20 | 21 | for (i = 100; i < MAX; i++) 22 | for (j = 100; j < MAX; j++) { 23 | result = i * j; 24 | if (is_palindromic(result) && result > max_palindromic) 25 | max_palindromic = result; 26 | } 27 | 28 | printf("Max palindromic = %d\n", max_palindromic); 29 | } 30 | 31 | int is_palindromic(int number) 32 | { 33 | char buffer[BUF_LEN]; 34 | int i,j; 35 | int palindromic = 1; 36 | 37 | snprintf(buffer, BUF_LEN, "%d", number); 38 | 39 | for (i = 0, j = strlen(buffer)-1; i < j; i++, j--) 40 | if (buffer[i] != buffer[j]) 41 | palindromic = 0; 42 | 43 | return palindromic; 44 | } 45 | -------------------------------------------------------------------------------- /projecteuler/problem5.c: -------------------------------------------------------------------------------- 1 | /* 2 | 2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder. 3 | 4 | What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20? 5 | */ 6 | 7 | #include 8 | 9 | #define MAX_DIVISOR 20 10 | 11 | int check_division(int); 12 | 13 | int main(void) 14 | { 15 | int number = 0; 16 | int i = 0; 17 | 18 | while(!number) { 19 | number = check_division(i); 20 | i++; 21 | } 22 | 23 | 24 | printf("The smallest number that can be divided is %d\n", number); 25 | } 26 | 27 | int check_division(int number) 28 | { 29 | int i; 30 | 31 | for (i = 1; i < MAX_DIVISOR; i++) { 32 | if (number % i != 0) 33 | number = 0; 34 | } 35 | 36 | return number; 37 | } 38 | -------------------------------------------------------------------------------- /projecteuler/problem6.c: -------------------------------------------------------------------------------- 1 | /* 2 | The sum of the squares of the first ten natural numbers is, 3 | 1^2 + 2^2 + ... + 10^2 = 385 4 | 5 | The square of the sum of the first ten natural numbers is, 6 | (1 + 2 + ... + 10)^2 = 552 = 3025 7 | 8 | Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 − 385 = 2640. 9 | 10 | Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum. 11 | */ 12 | 13 | #include 14 | #include 15 | 16 | #define MAX_NUMBER 100 17 | 18 | int main(void) 19 | { 20 | int sum_squares = 0; 21 | int square_sum = 0; 22 | int i; 23 | int diff = 0; 24 | 25 | for (i = 0; i <= MAX_NUMBER; i++) { 26 | sum_squares += i*i; 27 | square_sum += i; 28 | } 29 | 30 | square_sum *= square_sum; 31 | 32 | diff = abs(square_sum - sum_squares); 33 | 34 | printf("The difference is %d\n", diff); 35 | } 36 | -------------------------------------------------------------------------------- /projecteuler/problem7.c: -------------------------------------------------------------------------------- 1 | /* 2 | By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13. 3 | 4 | What is the 10001st prime number? 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | #define MAX 10001 11 | 12 | int is_prime(long long i); 13 | 14 | int main(void) 15 | { 16 | long long i = 3; 17 | long long prime = 0; 18 | int prime_count = 1; 19 | 20 | while (prime_count < MAX) { 21 | if (is_prime(i)) { 22 | prime_count++; 23 | } 24 | i += 2; 25 | } 26 | 27 | i -= 2; 28 | 29 | printf("The prime %d prime number is %lld\n", MAX, i); 30 | } 31 | 32 | int is_prime(long long i) 33 | { 34 | long j; 35 | int prime = 1; 36 | 37 | int sq = sqrt(i); 38 | 39 | 40 | for(j = 2; j <= sq; j++) 41 | if (i % j == 0) 42 | prime = 0; 43 | 44 | return prime; 45 | } 46 | 47 | 48 | -------------------------------------------------------------------------------- /projecteuler/problem8.c: -------------------------------------------------------------------------------- 1 | /* 2 | Find the greatest product of five consecutive digits in the 1000-digit number. 3 | */ 4 | 5 | #include 6 | #include 7 | 8 | char number[] = "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450"; 9 | 10 | int ctoi(char c); 11 | 12 | int main(void) 13 | { 14 | int i; 15 | int l; 16 | int greatest = 0; 17 | int product = 0; 18 | 19 | l = strlen(number)-1; 20 | 21 | for (i = 0; i < l - 5; i++) { 22 | product = ctoi(number[i]) * ctoi(number[i + 1]) * ctoi(number[i + 2]) * ctoi(number[i + 3]) * ctoi(number[i + 4]); 23 | 24 | if (product > greatest) 25 | greatest = product; 26 | } 27 | 28 | printf("The greatest product is %d\n", greatest); 29 | } 30 | 31 | int ctoi(char c) 32 | { 33 | return c-48; 34 | } 35 | -------------------------------------------------------------------------------- /sorting_algorithms/bubble_sort.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define ARRAY_LEN(X) (sizeof(X)/sizeof(X[0])) 4 | 5 | void bubble_sort(int [], int); 6 | void print_array(int [], int); 7 | 8 | int main(void) 9 | { 10 | int array[] = {5, 26, 10, 11, 1}; 11 | bubble_sort(array, ARRAY_LEN(array)); 12 | print_array(array, ARRAY_LEN(array)); 13 | } 14 | 15 | void print_array(int array[], int len) 16 | { 17 | int i; 18 | 19 | for (i = 0; i < len; i++) 20 | printf("%d ", array[i]); 21 | printf("\n"); 22 | } 23 | 24 | void bubble_sort(int array[], int len) 25 | { 26 | int i, band; 27 | int aux; 28 | 29 | band = 1; 30 | 31 | while (band) { 32 | for (i = 0, band = 0; i < len - 1; i++) { 33 | if (array[i] > array[i + 1]) { 34 | aux = array[i]; 35 | array[i] = array[i + 1]; 36 | array[i + 1] = aux; 37 | band = 1; 38 | } 39 | } 40 | } 41 | } 42 | 43 | -------------------------------------------------------------------------------- /sorting_algorithms/merge_sort.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define ARRAY_LEN(X) (sizeof(X)/sizeof(X[0])) 5 | 6 | #define MAX_SIZE 20 7 | 8 | void merge_sort(int [], int, int); 9 | void merge(int [], int, int, int); 10 | void print_array(int [], int); 11 | 12 | int main(void) 13 | { 14 | int array[] = {5, 26, 10, 11, 1}; 15 | merge_sort(array, 0, ARRAY_LEN(array) - 1); 16 | print_array(array, ARRAY_LEN(array)); 17 | } 18 | 19 | void print_array(int array[], int len) 20 | { 21 | int i; 22 | 23 | for (i = 0; i < len; i++) 24 | printf("%d ", array[i]); 25 | printf("\n"); 26 | } 27 | 28 | void merge_sort(int array[], int lo, int hi) 29 | { 30 | int mid; 31 | 32 | if (lo < hi) { 33 | mid = (lo + hi)/2; 34 | 35 | merge_sort(array, lo, mid); 36 | merge_sort(array, mid + 1, hi); 37 | merge(array, lo, mid, hi); 38 | } 39 | } 40 | 41 | void merge(int array[], int lo, int mid, int hi) 42 | { 43 | int aux[MAX_SIZE]; 44 | int i,j,idx, k; 45 | 46 | memset(aux, 0, sizeof(int)); 47 | 48 | i = lo; 49 | j = mid + 1; 50 | idx = lo; 51 | 52 | while (i <= mid && j <= hi) { 53 | if (array[i] <= array[j]) { 54 | aux[idx] = array[i]; 55 | i++; 56 | } else { 57 | aux[idx] = array[j]; 58 | j++; 59 | } 60 | idx++; 61 | } 62 | 63 | if (i <= mid) { 64 | for (k = i; k <= mid; k++) { 65 | aux[idx] = array[k]; 66 | idx++; 67 | } 68 | } else { 69 | for (k = j; k <= hi; k++) { 70 | aux[idx] = array[k]; 71 | idx++; 72 | } 73 | } 74 | 75 | for (k = lo; k <= hi; k++) { 76 | array[k] = aux[k]; 77 | } 78 | } 79 | 80 | -------------------------------------------------------------------------------- /sorting_algorithms/quick_sort.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define ARRAY_LEN(X) (sizeof(X)/sizeof(X[0])) 5 | 6 | #define MAX_SIZE 20 7 | 8 | void quick_sort(int [], int, int); 9 | int partition(int [], int, int); 10 | void print_array(int [], int); 11 | void swap(int *, int *); 12 | 13 | int main(void) 14 | { 15 | int array[] = {5, 26, 10, 11, 1}; 16 | quick_sort(array, 0, ARRAY_LEN(array) - 1); 17 | print_array(array, ARRAY_LEN(array)); 18 | } 19 | 20 | void print_array(int array[], int len) 21 | { 22 | int i; 23 | 24 | for (i = 0; i < len; i++) 25 | printf("%d ", array[i]); 26 | printf("\n"); 27 | } 28 | 29 | void quick_sort(int array[], int l, int h) 30 | { 31 | int p; 32 | 33 | if ( h - l > 0) { 34 | p = partition(array, l, h); 35 | 36 | quick_sort(array, l, p - 1); 37 | quick_sort(array, p + 1, h); 38 | } 39 | } 40 | 41 | int partition(int array[], int l, int h) 42 | { 43 | int i; 44 | int p; 45 | int firsthigh; 46 | 47 | p = h; 48 | firsthigh = l; 49 | 50 | for (i = l; i < h; i++) { 51 | if (array[i] < array[p]) { 52 | swap(&array[i], &array[firsthigh]); 53 | firsthigh++; 54 | } 55 | } 56 | 57 | swap(&array[p], &array[firsthigh]); 58 | 59 | return firsthigh; 60 | } 61 | 62 | void swap(int *a, int *b) 63 | { 64 | int aux; 65 | 66 | aux = *a; 67 | *a = *b; 68 | *b = aux; 69 | } 70 | 71 | 72 | 73 | -------------------------------------------------------------------------------- /strings_manipulation/revese_words.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void reverse(char *); 5 | 6 | int main(void) 7 | { 8 | char string[] = "Hello World"; 9 | 10 | reverse(string); 11 | 12 | printf("%s\n", string); 13 | } 14 | 15 | void reverse(char *string) 16 | { 17 | int i, j; 18 | int l = strlen(string)-1; 19 | 20 | for (i = 0, j = l; i < j; i++, j--) { 21 | string[l+1] = string[i]; 22 | string[i] = string[j]; 23 | string[j] = string[l+1]; 24 | } 25 | 26 | string[l+1] = '\0'; 27 | } 28 | 29 | --------------------------------------------------------------------------------