Completed

Arrays/1D Array/solution.c

@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <malloc.h>
+
+void main()
+{
+	int *arr, n, i;
+
+	scanf("%d", &n);
+	arr =(int *)malloc(n*sizeof(int));
+
+	for(i=0;i<n;i++)
+		scanf("%d", &arr[i]);
+	for(i=n-1;i>=0;i--)
+		printf("%d\n", arr[i]);
+}

Arrays/Multi-D Array/solution.c

@@ -0,0 +1,39 @@
+#include <stdio.h>
+#include <malloc.h>
+
+void main()
+{
+	int m, n, **arr, **res, *temp, i, j;
+
+	scanf("%d%d", &n, &m);
+	arr = (int **)malloc(n*sizeof(int));
+	res = (int **)malloc(m*sizeof(int));
+
+	for(i=0;i<n;i++)
+	{
+		arr[i] = (int *)malloc(m*sizeof(int));
+		for(j=0;j<m;j++)
+			scanf("%d", &arr[i][j]);
+	}
+
+	for(i=0;i<m;i++)
+	{
+		temp = (int *)malloc(n*sizeof(int));
+
+		for(j=0;j<n;j++)
+			temp[j] = arr[j][i];
+
+		res[i] = temp;
+	}
+
+	for(i=0;i<m;i++)
+	{
+		for(j=0;j<n;j++)
+		{
+			printf("%d", res[i][j]);
+			if(j!=n-1)
+				printf(" ");
+		}
+		printf("\n");
+	}
+}

Hash Tables/Hash Tables/solution.c

@@ -0,0 +1,48 @@
+#include <stdio.h>
+#include <malloc.h>
+
+void main()
+{
+	int n, q, i, offset=0;
+	long roll, **hash_table, *temp;
+
+	scanf("%d", &n);
+	hash_table = (long **)malloc(n*sizeof(long *));
+
+	for(i=0;i<n;i++)
+		hash_table[i]=0;
+
+	for(i=0;i<n;i++)
+	{
+		temp = (long *)malloc(27*sizeof(long));
+		scanf("%ld%s", &roll, temp);
+
+		if(hash_table[roll%n]!=0)
+		{
+			while(hash_table[roll%n+offset]!=0)
+				offset++;
+			hash_table[roll%n+offset]=temp;
+		}
+		else
+			hash_table[roll%n]=temp;
+
+		hash_table[roll%n+offset][26]=roll;
+		offset=0;
+	}
+
+	scanf("%d", &q);
+
+	for(i=0;i<q;i++)
+	{
+		scanf("%ld", &roll);
+
+		if(hash_table[roll%n][26]==roll)
+			printf("%s\n", hash_table[roll%n]);
+		else
+		{
+			while(hash_table[roll%n+offset][26]==roll)
+				offset++;
+			printf("%s\n", hash_table[roll%n+offset]);
+		}
+	}
+}

Queues/Queues/solution.c

@@ -0,0 +1,84 @@
+#include <stdio.h>
+#include <malloc.h>
+
+int size=0;
+
+struct node
+{
+	int cargo;
+	struct node *next;
+}*head;
+
+void enqueue(int x)
+{
+	struct node *new_node, *node;
+	size++;
+
+	node = head;
+
+	if(head==0)
+	{
+		head = (struct node *)malloc(sizeof(struct node));
+		head->cargo=x;
+		head->next=0;
+	}
+	else
+	{
+		new_node = (struct node *)malloc(sizeof(struct node));
+		while(node->next!= 0)
+			node = node->next;
+		node->next = new_node;
+		new_node->cargo = x;
+		new_node->next = 0;
+	}
+
+	printf("%d\n", size);
+}
+
+void dequeue()
+{
+	struct node *node, *parent;
+
+	if(size>0)
+		size--;
+
+	node = head;
+
+	if(node == 0)
+	{
+		printf("1 0\n");
+	}
+	else if(node->next == 0)
+	{
+		printf("%d 0\n", node->cargo);
+		free(node);
+		head = 0;
+	}
+	else
+	{
+		head = node->next;
+		printf("%d %d\n", node->cargo, size);
+		free(node);
+	}
+}
+
+void main()
+{
+	int n, i, x;
+	char choice, end;
+
+	scanf("%d", &n);
+
+	for(i=0;i<n;i++)
+	{
+		scanf("%c%c", &end, &choice);
+
+		if(choice=='E')
+		{
+			scanf("%d", &x);
+			enqueue(x);
+		}
+		else
+			dequeue();
+	}
+}

Stacks/Stacks/solution.c

@@ -0,0 +1,78 @@
+#include <stdio.h>
+#include <malloc.h>
+
+struct stack
+{
+	int cost;
+	struct stack *next;
+}*head;
+
+void customer()
+{
+	struct stack *node, *parent;
+
+	node = head;
+
+	if(node == 0)
+	{
+		printf("No food\n");
+	}
+	else
+	{
+		while(node->next)
+		{
+			parent = node;
+			node = node->next;
+		}
+
+		printf("%d\n", node->cost);
+		parent->next = 0;
+		free(node);
+	}
+
+}
+
+void chef(int expense)
+{
+	struct stack *node, *new_node;
+
+	node = head;
+	new_node = (struct stack *)malloc(sizeof(struct stack));
+
+	if(node == 0)
+	{
+		new_node->next = 0;
+		new_node->cost = expense;
+		head = new_node;
+	}
+	else
+	{
+		while(node->next)
+			node = node->next;
+
+		node->next = new_node;
+		new_node->cost = expense;
+		new_node->next = 0;
+	}
+}
+
+void main()
+{
+	int r, i, choice, expense;
+	char temp;
+
+	scanf("%d", &r);
+
+	for(i=0;i<r;i++)
+	{
+		scanf("%c%d", &temp, &choice);
+
+		if(choice==1)
+			customer();
+		else
+		{
+			scanf("%d", &expense);
+			chef(expense);
+		}
+	}
+}

Trees/Binary Search Tree/solution.c

@@ -0,0 +1,105 @@
+#include <stdio.h>
+#include <malloc.h>
+
+struct bin_search
+{
+	int cargo;
+	int allocated;
+};
+
+void main()
+{
+	int n, i, curr=1, temp, flag, q, last=1;
+	struct bin_search *tree;
+
+	scanf("%d", &n);
+	tree = (struct bin_search *)malloc(n*n*sizeof(struct bin_search));
+
+	for(i=0;i<n;i++)
+		tree[i].allocated = 0;
+
+	for(i=0;i<n;i++)
+	{
+		curr = 1;
+		scanf("%d", &temp);
+
+		if(tree[curr].allocated == 0)
+		{
+			tree[curr].cargo = temp;
+			tree[curr].allocated = 1;
+		}
+		else
+		{
+			flag=1;
+			while(flag)
+			{
+				if(temp>tree[curr].cargo)
+				{
+					curr = curr*2+1;
+					if(tree[curr].allocated == 0)
+					{
+						tree[curr].cargo = temp;
+						tree[curr].allocated = 1;
+						flag = 0;
+					}
+				}
+				else if(temp<=tree[curr].cargo)
+				{
+					curr = curr*2;
+					if(tree[curr].allocated == 0)
+					{
+						tree[curr].cargo = temp;
+						tree[curr].allocated = 1;
+						flag = 0;
+					}
+				}
+			}
+		}
+	}
+
+	curr = 1;
+	flag = 1;
+
+	scanf("%d", &q);
+
+	while(tree[curr].cargo == q);
+	{
+		if(q > tree[curr].cargo)
+			curr = curr*2+1;
+		else
+			curr = curr*2;
+	}
+
+	last = curr;
+
+	while(tree[last].allocated != 0)
+		last = last*2+1;
+	last = last/2;
+
+	while(flag)
+	{
+		printf("%d\n", tree[curr].cargo);
+
+		if(tree[curr*2].allocated != 0)
+			curr = curr*2;
+		else if(tree[curr*2+1].allocated != 0)
+			curr = curr*2+1;
+		else if(curr != last)
+		{
+			if(curr%2 == 0)
+				curr++;
+			else
+				curr = curr/2+1;
+
+			while(tree[curr].allocated == 0)
+			{
+				if(curr%2 == 0)
+					curr++;
+				else
+					curr = curr/2+1;
+			}
+		}
+		else
+			flag = 0;
+	}
+}