More additions from practice work, pardon the mess.

Author: Grv-Singh

Codechef.c

@@ -0,0 +1,20 @@
+#include<stdio.h>
+void main(){
+    int a,b,c,d,x=0,y=0,count=0,arayA[10],arayB[10];
+    scanf("%d %d %d %d",&a,&b,&c,&d);
+    int i=a,j=c;
+    while(i<=b && j<=d){
+        arayA[x++]=i;
+        arayB[y++]=j;
+        i++;
+        j++;
+    }
+    for(i=0;i<x;i++){
+        for(j=0;j<y;j++){
+            if(arayA[j]<arayB[i]){
+                count++;
+            }
+        }
+    }
+    printf("%d",count);
+}

HashT.c

@@ -0,0 +1,126 @@
+#include<stdio.h>
+#include<malloc.h>
+#include<stdlib.h>
+#define LOAD_FACTOR 20
+
+struct ListNode{
+    int key;
+    int data;
+    struct ListNode *next;
+};
+
+struct HashTableNode{
+    int bcount;
+    struct ListNode *next;
+};
+
+struct HashTable{
+    int tsize;
+    int count;
+    struct HashTableNode **Table;
+};
+
+struct HashTable *CreateHashTable(int size){
+    int i;
+    struct HashTable *h;
+    h = (struct HashTable *)malloc(sizeof(struct HashTable));
+    if(!h){
+        return NULL;
+    }
+
+    h->tsize = size/LOAD_FACTOR;
+    h->count = 0;
+    h->Table = (struct HashTableNode **)malooc(sizeof(struct HashTableNode *) *h->tsize);
+
+    if(!h->Table){
+        printf("Memory Error");
+        return NULL;
+    }
+
+    for(i=0;i<h->tsize;i++){
+        h->Table[i]->next = NULL;
+        h->Table[i]->bcount = 0;
+    }
+    return h;
+}
+
+int HashSearch(struct HashTable *h, int data){
+    struct ListNode *temp;
+    temp = h->Table[Hash(key,h->tsize)]->next;
+    while(temp){
+        if(temp->data==data)
+            return 1;
+        temp = temp->next;
+    }
+    return 0;
+}
+
+int HashInsert(struct HashTable *h, int data){
+    int index;
+    struct ListNode *temp, *newNode;
+
+    if(HashSearch(h,data)){
+        return 0;
+    }
+
+    index = Hash(key,h->tsize);
+    temp = h->Table[index]->next;
+    newNode = (struct ListNode *)malloc(sizeof(struct ListNode));
+    if(!newNode){
+        printf("Out Of Space");
+        return -1;
+    }
+
+    newNode->key = index;
+    newNode->data = data;
+    newNode->next = h->Table[index]->next;
+    h->Table[index]->next = newNode;
+
+    h->Table[index]->bcount++;
+    h->count++;
+    if(h->count/h->tsize > LOAD_FACTOR){
+        Rehash(h);
+        return 1;
+    }
+}
+
+int HashDelete(struct HashTable *h, int data){
+    int index;
+    struct ListNode *temp;
+    index =Hash(data,h->tsize);
+
+    for(temp=h->Table[index]->next,prev=NULL;temp;prev=temp,temp=temp->next){
+        if(temp->data==data){
+            if(prev!=NULL){
+                prev->next = temp->next;
+            }
+            free(temp);
+            h->Table[index]->bcount--;
+            h->count--;
+            return 1;
+        }
+    }
+    return 0;
+}
+
+void Rehash(Struct HashTable *h){
+    int oldsize,i,index;
+    struct ListNode *p, *temp;
+    struct HashTableNode **oldTable;
+    oldsize = h->tsize;
+    oldTable = h->Table;
+    h->tsize = h->tsize*2;
+
+    h->Table= (struct HashTableNode **)malloc(h->tsize*sizeof(struct HashTableNode *));
+    if(!h->Table){
+        printf("Allocation Failed");
+        return;
+    }
+    for(i=0;i<oldsize;i++){
+        for(temp=oldTable[i]->next;temp;temp=temp->next){
+            index = Hash(temp->data,h->tsize);
+            temp->next = h->Table[index]->next;
+            h->Table[index]->next = temp;
+        }
+    }
+}

India.c

@@ -0,0 +1,30 @@
+#include <stdio.h>
+int main()
+{
+	int a = 10, b = 0, c = 10;
+	char* str = "TFy!QJu ROo TNn(ROo)SLq SLq ULo+UHs UJq "
+				"TNn*RPn/QPbEWS_JSWQAIJO^NBELPeHBFHT}TnALVlBL"
+				"OFAkHFOuFETpHCStHAUFAgcEAelclcn^r^r\\tZvYxXyT|S~Pn SPm "
+				"SOn TNn ULo0ULo#ULo-WHq!WFs XDt!";
+	while (a != 0)
+	{
+	a = str[b++];
+		while (a-- > 6
+				4)
+		{
+			if (++c == 90)
+			{
+				c = 10;
+				putchar('\n');
+			}
+			else
+			{
+				if (b % 2 == 0)
+					putchar('!');
+				else
+					putchar(' ');
+			}
+		}
+	}
+	return 0;
+}

LOD.c

@@ -0,0 +1,31 @@
+#include<stdio.h>
+
+void main(){
+
+    struct Queue *Q;
+    struct Stack *s = CreateStack();
+    struct BinaryTree *temp;
+    if(!root){
+        return;
+    }
+    Q = CreateQueue();
+    EnQueue(Q,root);
+
+    while(!IsEmptyQueue(Q)){
+        temp = Q->front;
+
+        if(temp->right){
+            EnQueue(Q,temp->right);
+        }
+        if(temp->left){
+            EnQueue(Q,temp->left);
+        }
+
+        temp=DeQueue(Q);
+        Push(s,temp);
+    }
+
+    while(!IsEmptyStack(s)){
+        printf("%d",Pop(s)->data);
+    }
+}

NimGame.c

@@ -0,0 +1,141 @@
+#include<stdio.h>
+#include<string.h>
+
+void main(){
+
+//Game Starts Here!!
+printf("Welcome to NimGame\n\n");
+
+//Intialising useful Variables
+int C=0,Sticks,u,TBlanks,Blanks,Counter,i,x,p,j,NoBlank,Start,End;
+
+//Initialising and Declaring useful Variables
+char Input[5],Array[15]={1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+
+//This Piece of code(Z) Displays the Moves
+Z:
+
+//Declaring useful Variables
+Sticks=3,Blanks=0,Counter=0,NoBlank=00;
+
+//Start of Pattern
+printf("\t + + + + + + + + +\n");
+
+while(Sticks<=7){
+
+    printf("\t + ");
+
+    for(i=1;i<=Sticks;i++){
+        if(Array[Counter]==1)
+        {
+            printf("| ");
+        }else{
+                printf("  ");
+             }
+    ++Counter;
+                          }
+
+    for(j=1;j<=(7-Sticks);j++){
+        printf("  ");
+                              }
+    printf("+");
+
+    printf("\n");
+
+    Sticks+=2;
+                }
+
+printf("\t + + + + + + + + +\n");
+//End of Pattern
+
+//=========+=======+=======+=======+=======+=========+=============+===============++==============+============+=========+
+printf("%d",C);
+//Asking Apt. User for Input
+if((C%2)!=0){
+    printf("Player 1 Enter The Range to be Deleted <Start-End><Start=End, for Single Deletion> : ");
+            }else{
+        printf("Player 2 Enter The Range to be Deleted <Start-End><Start=End, for Single Deletion> : ");
+                }
+
+//Input from User
+
+scanf("%s",&Input);
+
+printf("\n");
+
+//Extracting Start of Range
+Start=(((Input[0]-48)*10)+(Input[1]-48));
+
+//Extracting End of Range
+End=(((Input[3]-48)*10)+(Input[4]-48));
+//printf("%d%d",Start,End);
+//Loop to count No. Of Blanks b/w User's Start and End Position(s)
+for(x=Start;x<=End;x++)
+{
+    if(Array[(x-1)]==0){Blanks++;}
+
+}//printf("%d",Blanks);
+
+//Validating the Move
+if(Blanks==0){
+    NoBlank=11;
+    }
+    else{
+    NoBlank=00;
+    }
+
+//Counting No. Of Blanks in Nimgame
+for(u=0;u<15;u++)
+{
+    if(Array[u]==0){TBlanks++;}
+}
+
+//Checks for Valid Move i.e without Blanks
+if(NoBlank==11){
+
+    //Checks for Valid Move i.e Same Row is Valid else not
+    if(((Start<=3)&&(End>=4))||((Start<=8)&&(End>=9)))
+    {
+    printf("Invalid Move!! Choose From Single Row...\n\n");
+    goto Z;
+
+    }else{
+
+
+if(TBlanks<15){
+        if((C%2)!=0){
+            printf("\n\tPlayer 1's Move:%s\n",Input);
+
+        //Makes Blanks in ARRAY as per Valid Input
+        for(p=Start;p<=End;p++){
+            Array[(p-1)]=0;
+                               }
+
+                         }else{
+            printf("\n\tPlayer 2's Move:%s\n",Input);
+                                //Makes Blanks in ARRAY as per Valid Input
+        for(p=Start;p<=End;p++){
+            Array[(p-1)]=0;
+                               }
+}
+//Counter of Chance
+        ++C;
+        goto Z;
+
+                 }else{
+        if((C%2)!=0){
+            printf("\n\tPlayer 2 Won!! :)\n");
+                                      }else{
+                                        printf("\n\tPlayer 1 Won!! :)\n");
+                                           }
+                        }
+
+         }
+
+               }else{
+                        printf("Blanks Cannot be Deleted\n\n");
+                        goto Z;
+                    }
+
+//End Of Game
+}

Permutation.cpp

@@ -0,0 +1,28 @@
+#include<stdio.h>
+#include<iostream>
+#include<stdlib.h>
+using namespace std;
+
+void Perm(int a[], int k, int n){
+    if(k==n){
+        for(int i=1; i<=n; i++){
+            cout<<a[i]<<" ";
+            cout<<endl;
+        }
+    }else{
+        for(int i=k; i<=n; i++){
+            int t=a[k];
+            a[k]=a[i];
+            a[i]=t;
+            Perm(a,k+1,n);
+            t=a[k];
+            a[k]=a[i];
+            a[i]=t;
+        }
+    }
+}
+
+int main(){
+    int a[10]={1,2,3,4,5,6,7,8,9,10};
+    Perm(a,5,7);
+}