project

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#define stack_max 10

//char user_id[10];
//char password[10];

typedef struct node Node;
struct node{
    int data;
    Node *next;
};

struct find_job_detail{
    char f_name[20];
    char l_name[20];
    char email_address[30];
    char phone[13];
    char institute[30];
    double cgpa;
    char job_field[20];
    char exparience[50];
};

struct Registration{
    char first_name[20];
    char last_name[20];
    char email[50];
    char user_id[20];
    char password[20];
    char confirm_pass[20];
};

void find_job()
{
    system("CLS");
    printf("\n\n\n");
    printf("\t\t\tThanks for chosing us!!!\n\t\t-------------------------------\n");
    printf("We hope, you have the enough qualifications for finding a job here. please send us your informations about you, your qualifications and your chossen field. we\n will contact with you.GOOD LUCK!\n");
    FILE *fp;
    struct find_job_detail i;
    fp = fopen("cv.txt", "w");
    if(fp == NULL){
        perror("File opening failed!");
        return;
    }
    printf("\nEnter Your first Name              : ");
    scanf(" %[^\n]", &i.f_name);
    fprintf(fp, "%s\n", i.f_name);

    printf("Enter Your last Name               : ");
    scanf(" %[^\n]", &i.l_name);
    fprintf(fp, "%s\n", i.l_name);

    printf("Enter Your Email                   : ");
    scanf(" %[^\n]", &i.email_address);
    fprintf(fp, "%s\n", i.email_address);

    printf("Enter Your Phone Number            : ");
    scanf(" %[^\n]", &i.phone);
    fprintf(fp, "%s\n", i.phone);

    printf("Enter Your Educational Institue    : ");
    scanf(" %[^\n]", &i.institute);
    fprintf(fp, "%s\n", i.institute);

    printf("Enter CGPA                         : ");
    scanf("%lf", &i.cgpa);
    fprintf(fp, "%lf\n", i.cgpa);

    printf("Enter Your Job Field               : ");
    scanf(" %[^\n]", &i.job_field);
    fprintf(fp, "%s\n", i.job_field);

    printf("Enter Your Work Expariecne         : ");
    scanf(" %[^\n]", &i.exparience);
    fprintf(fp, "%s\n", i.exparience);

    printf("\nYour Information has been saved in database wait till our response\n");
}

COORD coord = {0,0}; /// top-left corner of window

/**
    function : gotoxy
    @param input: x and y coordinates
    @param output: moves the cursor in specified position of console
*/
void gotoxy(int x,int y)
{
    coord.X = x;
    coord.Y = y;
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),coord);
}

void append(Node *head)
{
    Node *temp;
    Node *new_node = (Node *)malloc(sizeof(Node));
    printf("\nEnter Node item for last : ");
    scanf("%d", &new_node->data);
    new_node->next = NULL;

    temp = head;
    while(temp->next != NULL)
    {
        temp = temp->next;
    }
    temp->next = new_node;
}


Node *prepend(Node *head)
{
    Node *new_node = (Node *)malloc(sizeof(Node));
    printf("\nEnter Node item for beganing : ");
    scanf("%d", &new_node->data);

    new_node->next = head;
    head = new_node;

    return head;
}

void add_node(Node *head)
{
    int position, count=0, i=1;
    printf("enter the position after that place new node will be inserted : ");
    scanf("%d", &position);
    Node *temp = head;

    while(temp != NULL)
    {
        count++;
        temp = temp->next;
    }

    if(position < 1 || position > count+1) printf("Invalid selection!!!\n");

    else
    {
        temp = head;
        while(i < position)
        {
            temp = temp->next;
            i++;
        }
        Node *new_node = (Node *)malloc(sizeof(Node));
        printf("\nEnter Node item for the perticular position : ");
        scanf("%d", &new_node->data);
        if(temp == head) {
            new_node->next = head;
            head = new_node;
        }
        else{
        new_node->next = temp->next;
        temp->next=new_node;
        }
    }
}

Node *remove_node(Node *head, int total_node)
{
    Node *temp = head;
    if(total_node == 1)
    {
        free(temp);
        return NULL;
    }

    int position;
    printf("\n\nEnter the position : ");
    scanf("%d", &position);

    if(position == 1)
    {
        head = temp->next;
        free(temp);
        return head;
    }

    int i = 1;
    Node *previous_node;
    while(i<position)
    {
        previous_node = temp;
        temp = temp->next;
        i++;
    }
    previous_node->next = temp->next;
    free(temp);
    return head;
}

void print_linked_list(Node *head)
{
    Node *temp = head;
    if(head == NULL) return 0;
    while(temp != NULL){
        printf("%d ", temp->data);
        temp = temp->next;
    }
    printf("\n");
}

void virtual_judge()
{
    printf("\nThe idea is very simple. As we are doing it by c programming, we will use file to understand the basic working process of virtual judge.\n");
    printf("\nThere will be three(3) file, suppose the name of three file is\n1. input.txt where sample input will be given.");
    printf("\n2. expected_output.txt where sample output will be stored for sameple inputs\n3. output.txt, here output will be stored for the submitted code by learner\n");
    printf("\nAfter this three process, we need to compare expected_output.txt and output.txt these two file. If they are same the code will be accepted.\n");
    printf("\nNow try to implement this idea, for better undersing you can visit to this link\n");
    printf("\nhttps://pastebin.com/qByXFRP5 and \nhttps://pastebin.com/DiCPZfEY\n");
    printf("\nFrom these link you will find a protype problem and implementation virtual judge for this perticular problem.\n");
}

void queue()
{
    printf("\n-> enqueue() - add (store) an item to the queue.\n");
    printf("\n-> dequeue()- remove (access) an item from the queue.\n");
    printf("\n-> peek() - Gets the element at the front of the queue without removing it.\n");
    printf("\n-> display() - it will display the values of stack form top to bottom serially\n");
    printf("\nFor better understand go to this link : https://pastebin.com/Qd89ArTy\n");
}

void stack()
{
    int stack[stack_max];
    int top = -1;
    int op;
    printf("\t\t1.push\n\t\t2.pop\n\t\t3.Peek\n\t\t4.Display\n\t\t0. To exit\n\nEnter your choise : ");
    scanf("%d", &op);
    while(op)
    {
    int value, item;
    if(op == 1)
    {
        if(top == stack_max){
            printf("stack is full\n");
        }
        else{
        printf("Enter item : ");
        scanf("%d", &value);
        top++;
        stack[top] = value;
        }
    }
    else if(op == 2)
    {
        if(top == -1){
            printf("Stack is empty\n");
        }
        else{
        item = stack[top];
        printf("%d\n", item);
        top--;
        }
    }
    else if(op == 3)
    {
        if(top == -1) printf("Stack is empty\n");
        printf("%d\n", stack[top]);
    }
    else if(op == 4)
    {
        for(int temp = top; temp>=0; temp--)
        {
            printf("%d\n", stack[temp]);
        }
    }
    printf("\t\t1.push\n\t\t2.pop\n\t\t3.Peek\n\t\t4.Display\n\nEnter your choise : ");
    scanf("%d", &op);
    }
}

int binary_search(int *A, int n, int x)
{
    int left = 0, right = n-1, mid;
    while(left<=right)
    {
        mid = left+(right-left)/2;
        if(A[mid] == x){
            return mid;
        }
        if(A[mid]<x) left = mid+1;
        else right = mid-1;
    }
    return -1;
}

int sort(const void * a, const void * b)
{
    return (*(int *)a - *(int *)b);
}

void linear_search()
{
    int *A, n, x;
    printf("\nEnter how many numbers you take in the array : ");
    scanf("%d", &n);
    A = (int *)calloc(n, sizeof(int));
    printf("\nEneter Numbers : ");
    for(int i=0; i<n; i++){
    scanf("%d", &A[i]);
    }
    printf("\nEnter the Number your are looking for : ");
    scanf("%d", &x);
    for(int i = 0; i < n; i++){
        if(A[i] == x){
            printf("%d is the %dth number of the array\n", x, i+1);
            return;
        }
    }
    printf("%d is not in the array\n");
}

void insersion_sort(int A[], int n)
{
    int item, j;
    for(int i=1; i<n; i++){
        item = A[i];
        j = i-1;
        while(j>=0 && A[j]>item)
        {
            A[j+1] = A[j];
            j = j-1;
        }
        A[j+1] = item;
        for(int j=0; j<n; j++){
        printf("%d ", A[j]);
        }
        printf("\n");
    }
}

void brute_fonce()
{
    int arr[10] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 1};
    int arr_count = 10;
    int n = arr[arr_count - 1];
    for(int i = (arr_count - 2); i>=0; i--)
    {
        if(arr[i] >= n)
        {
            int temp = arr[i];
            arr[i+1] = arr[i] = temp;
            for(int j = 0; j<arr_count; j++)
            {
                printf("%d ", arr[j]);
            }
            printf("\n");
        }
        else if(arr[i]<n)
        {
            arr[i+1] = n;
            for(int j = 0; j<arr_count; j++)
            {
                printf("%d ", arr[j]);
            }
            break;
        }
    }
    if(arr[0] > n){
        arr[0] = n;
        for(int j = 0; j<arr_count; j++)
        {
            printf("%d ", arr[j]);
        }
    }
}

void bubble_sort(int A[], int n)
{
    int temp, count=0;
    for(int i=0; i<n-1; i++){
        //if(i == n-1) break;

        for(int j=0; j<n-i-1; j++){//here n-i-1 is using because last one is not needed here
            count++;

            if(A[j]>A[j+1]){
            temp = A[j];
            A[j] = A[j+1];
            A[j+1] = temp;
            }

            for(int i=0; i<n; i++){
                printf("%d ", A[i]);
            }
            printf("\n");
        }
    }
}

void selection_sort(int A[], int n)
{
    int temp;
    for(int i=0; i<n-1; i++){// here you can use n also but the loop will perfrom extra one time which is not neccesary bcz last elemet will be the larger one autometically
        int index_min = i;

        for(int j=i+1; j<n; j++){
            if(A[j] < A[index_min]) index_min = j;
        }

        if(index_min != i){
            temp = A[i];
            A[i] = A[index_min];
            A[index_min] = temp;
        }

       for(int i=0; i<n; i++){
        printf("%d ", A[i]);
    }

    printf("\n");
    }
}

void learner()
{
    system("CLS");
    printf("\n\n\n");
    printf("\t\t\tThanks for chosing us!!!\n\t\t----------------------------------------------\n");
    char x = 'y';
    while(x == 'y')
    {
    printf("\n\t\t\tWhat You Want to learn?\n\t\t----------------------------------------------\n\n1.Sorting Algorithms\n2.Searching Algorithms\n3.Stack\n4.Queue\n5.Observe working of singly Linked List\n6.Working process of virtual judge\n");
    int select;
    printf("\nYour selection : ");
    scanf("%d", &select);
    if(select == 1)
    {
        system("CLS");
        printf("\n1.Selection sort\n2.Insertion sort\n3.buble sort\n4.Brute fonce method\n");
        printf("\nYour selection : ");
        scanf("%d", &select);
        system("CLS");
        if(select == 1)
        {
            printf("Selection sort is a simple sorting algorithm. This sorting algorithm is an in-place comparison-based algorithm in which the list is divided into two parts, the sorted part at the left end and the unsorted part at the right end. Initially, the sorted part is empty and the unsorted part is the entire list.");
            printf("The smallest element is selected from the unsorted array and swapped with the leftmost element, and that element becomes a part of the sorted array. This process continues moving unsorted array boundary by one element to the right.");
            printf("This algorithm is not suitable for large data sets as its average and worst case complexities are of Ο(n^2), where n is the number of items.");
            printf("\n\t\tHow selection sort works\n\t----------------------------------------\n");
            printf("Consider the following depicted array as an example. 5 4 3 2 1. we need to sort this array using selection sort process\n");
            printf("\nStep 1 : For the first position in the sorted list, the whole list is scanned sequentially. The first position where 5 is stored presently, we search the whole list and find that 1 is the lowest value. Now we need to swap these two. If we swap these two or after first iterration it is garunteed the lowest value will be in first place. So Number one is sorted.\n");
            printf("\nStep 2 : For the second position in the sorted list, the the whole list is scanned sequentially without first position because its already sorted, we will find the lowest which is 2 and it will go to second place\n.");
            printf("\nStep 3 : This lowest finding process will continue for all these value in the array and swap process will continue and after the all iterration the array will be sorted\n");
            printf("\nfor the avobe mentioned array after every iterration the array will look like\n\n1 4 3 2 5\n\n1 2 3 4 5\n\n1 2 3 4 5\n\n1 2 3 4 5\n");
            printf("Now its your job to write some simple code to implement this algorithm\n\n for better understanding take input and see the every iterration output\n");
            int *C, n2;
            printf("\nEnter how many numbers you take in the array : ");
            scanf("%d", &n2);
            C = (int *)calloc(n2, sizeof(int));
            printf("\nEneter Numbers : ");
            for(int i=0; i<n2; i++){
                scanf("%d", &C[i]);
            }
            selection_sort(C,n2);
        }
        else if(select == 2)
        {
            printf("Insertion sort is a simple sorting algorithm that builds the final sorted array (or list) one item at a time. It is much less efficient on large lists than more advanced algorithms such as quicksort, heapsort, or merge sort.\n");
            printf("\nThe array is searched sequentially and unsorted items are moved and inserted into the sorted sub-list (in the same array). This algorithm is not suitable for large data sets as its average and worst case complexity are of Ο(n2), where n is the number of items.\n");
            printf("We take an unsorted array for our example. 5 4 3 2 1\n");
            printf("\nStep 1 : Insertion sort compares the first two elements. smaller one will go to first place. it will look like 4 5 3 2 1\n");
            printf("\nStep 2 : Then we will find the right place for 3. which is before 4. it will look like 3 4 5 2 1\n");
            printf("\nStep 3 : Now we will find out the right place for 2 which is before 3. it will look like 2 3 4 5 1\n");
            printf("\nStep 4 : Now we will find the right place for 1 which is before 2. it will look like 1 2 3 4 5. after this iterraation we will find our sorted array\n");
            printf("\nNow write a simple code for this algorithm first, for better understing take a input array and look at the every iterration\n");
            int *A, n;
            printf("\nEnter how many numbers you take in the array : ");
            scanf("%d", &n);
            A = (int *)calloc(n, sizeof(int));
            printf("\nEneter Numbers : ");
            for(int i=0; i<n; i++){
            scanf("%d", &A[i]);
            }
            insersion_sort(A, n);
        }
        else if(select == 3)
        {
            printf("Bubble sort is a simple sorting algorithm.\n");
            printf("\nThis sorting algorithm is comparison-based algorithm in which each pair of adjacent elements is compared and the elements are swapped if they are not in order.\n");
            printf("\nThis algorithm is not suitable for large data sets as its average and worst case complexity are of Ο(n2) where n is the number of items.\n");
            printf("\nStep 1 : We take an unsorted array for our example. 8 2 4 1 5\n");
            printf("\nStep 2 : Buble sort start working by comparing first two number and smaller one will come to first. 2 8 4 1 5\n");
            printf("\nStep 2 : Then it will compare 2nd and 3rd number and smaller one will come first. 2 4 8 1 5\n");
            printf("\nStep 2 : Then it will compare 3rd and 4th number and smaller one will come first. 2 4 1 8 5\n");
            printf("\nStep 2 : Then it will compare 4th and 5th number and smaller one will come first. 2 4 1 5 8. this is the end of step 2 and first iterration of first loop. And largest value will come up into last place\n");
            printf("\nStep 3 : Same process will go on for every iterration and after every iterration the largest will go into the last place.\n");
            printf("\nNow visualise the algorithm and try to write the code. for better understanding take a input and see the every iterration output\n");
            int *B, n1;
            printf("\nEnter how many numbers you take in the array : ");
            scanf("%d", &n1);
            B = (int *)calloc(n1, sizeof(int));
            printf("\nEneter Numbers : ");
            for(int i=0; i<n1; i++){
                scanf("%d", &B[i]);
            }
            bubble_sort(B, n1);
        }
        else if(select == 4)
        {
            printf("One common task for computers is to sort data. For example, people might want to see all their files on a computer sorted by size. Since sorting is a simple problem with many different possible solutions, it is often used to introduce the study of algorithms.\n");
            printf("\nGiven a sorted list with an unsorted number  in the rightmost cell, can you write some simple code to insert  into the array so that it remains sorted?\n");
            printf("\nSince this is a learning exercise, it won't be the most efficient way of performing the insertion. It will instead demonstrate the brute-force method in detail.\n");
            printf("\nAssume you are given the array arr = [1, 2, 4, 5, 3]  indexed 0 to 4. Store the value of arr[4].\n");
            printf("\nNow test lower index values successively from 3 to 0 until you reach a value that is lower than arr[4],arr[1] in this case.\n");
            printf("\nEach time your test fails, copy the value at the lower index to the current index and print your array.\n");
            printf("\nWhen the next lower indexed value is smaller than arr[4], insert the stored value at the current index and print the entire array.\n");
            printf("\nThe results of operations on the example array is: \n");
            printf("\nStarting array: [1, 2, 4, 5, 3]\n");
            printf("\nStore the value of arr[4] = 3 Do the tests and print interim results: \n");
            printf("\n1 2 4 5 5\n1 2 4 4 5\n1 2 3 4 5\n");
            printf("for better understanding look at another example given\n");
            brute_fonce();
        }
    }
    else if(select == 2)
    {
        system("CLS");
        printf("1.Linear Search\n2.Binary Search\n");
        printf("\nYour selection : ");
        scanf("%d", &select);
        system("CLS");
        if(select == 1)
        {
            printf("\nLinear search is a very simple search algorithm. In this type of search, a sequential search is made over all items one by one.\n");
            printf("\nEvery item is checked and if a match is found then that particular item is returned, otherwise the search continues till the end of the data collection.\n");
            printf("\nLinear Search ( Array A, Value x)\nStep 1: Set i to 1\nStep 2: if i > n then go to step 7\nStep 3: if A[i] = x then go to step 6\nStep 4: Set i to i + 1.");
            printf("\nStep 5: Go to Step 2\nStep 6: Print Element x Found at index i and go to step 8\nStep 7: Print element not found\nStep 8: Exit\n");
            printf("\nNow try to understand the algorithm and write down the simple code for it. for better understanding take a input array and search that\n");
            linear_search();
        }
        else if(select == 2)
        {
            printf("\nBinary search is a fast search algorithm with run-time complexity of Ο(log n).\n");
            printf("\nThis search algorithm works on the principle of divide and conquer. For this algorithm to work properly, the data collection should be in the sorted form.\n");
            printf("\nBinary search looks for a particular item by comparing the middle most item of the collection. If a match occurs, then the index of item is returned.\n");
            printf("\n If the middle item is greater than the item, then the item is searched in the sub-array to the left of the middle item. Otherwise, the item is searched for in the sub-array to the right of the middle item.\n");
            printf("\nThis process continues on the sub-array as well until the size of the subarray reduces to zero.\n");
            printf("\nGiven an array A of n elements with values or records  A_{0},A_{1},A_{2},......,A_{n-1} sorted such that A_{0} <= A_{1} <= {2} <= ........<= A_{n-1} and target value T, the following subroutine uses binary search to find the index of T in A\n");
            printf("\nSetp 1 : Set L to 0 and R to n-1.\n");
            printf("\nSetp 2 : If  L>R, the search terminates as unsuccessful.\n");
            printf("\nSetp 3 : Set m (the position of the middle element) to the floor of (L+R)/2, which is the greatest integer less than or equal to  (L+R)/2.\n");
            printf("\nSetp 4 : If  A_m < T, set L to  m+1 and go to step 2.\n");
            printf("\nSetp 5 : If  A_m > T, set R to  m-1 and go to step 2.\n");
            printf("\nSetp 6 : Now A_m = T, the search is done; return m\n");
            printf("\nNow try to write some code by own and for better understanding take a input array and see the output. try to make a code which gives the same kind of output\n");
            int *A, n, x;
            printf("\nEnter how many numbers you take in the array : ");
            scanf("%d", &n);
            A = (int *)calloc(n, sizeof(int));
            printf("\nEneter Numbers : ");
            for(int i=0; i<n; i++){
                scanf("%d", &A[i]);
            }
            qsort(A, n, sizeof(int), sort);
            for(int i=0; i<n; i++){
                printf("%d ", A[i]);
            }
            printf("\nEneter the Number you are searching in the array : ");
            scanf("%d", &x);
            int z = binary_search(A, n, x);
            if(z == -1) printf("\nThere is no number like %d\n", x);
            else printf("\n%d is the %dth number of the array\n", x, z+1);
        }
    }
    else if(select == 3)
    {
        system("CLS");
        int choise;
        printf("\nA stack is an Abstract Data Type (ADT), commonly used in most programming languages. It is named stack as it behaves like a real-world stack, for example – a deck of cards or a pile of plates, etc.\n");
        printf("\nA real-world stack allows operations at one end only. For example, we can place or remove a card or plate from the top of the stack only. Likewise, Stack ADT allows all data operations at one end only. At any given time, we can only access the top element of a stack.\n");
        printf("\nThis feature makes it LIFO data structure. LIFO stands for Last-in-first-out.\n");
        printf("\nHere, the element which is placed (inserted or added) last, is accessed first.\n");
        printf("\nIn stack terminology, insertion operation is called PUSH operation and removal operation is called POP operation.\n");
        printf("\nA stack can be implemented by means of Array, Structure, Pointer, and Linked List. Stack can either be a fixed size one or it may have a sense of dynamic resizing. Here, we are going to implement stack using arrays, which makes it a fixed size stack implementation.\n");
        printf("\n\t\tBasic Operations\n\t------------------------------------------\n");
        printf("\nStack operations may involve initializing the stack, using it and then de-initializing it. Apart from these basic stuffs, a stack is used for the following two primary operations −\n");
        printf("\n-> push() − Pushing (storing) an element on the stack. New item will added at top position\n");
        printf("\n-> pop() − Removing (accessing) an element from the stack. item will be removed from top position\n");
        printf("\n-> peek() − get the top data element of the stack, without removing it. this will print us the top position value of stack\n");
        printf("\n-> display() - it will display the values of stack form top to bottom serially\n");
        printf("\nNow try to implement the algorithm decribed above.\n");
        printf("\nFor better understanding you can go to stack function to observe the working process\n");
        printf("\n\t1.Yes\n\t2.No\nDo you want to observe the process : ");
        scanf("%d", &choise);
        if(choise == 1)stack();
    }
    else if(select == 4)
    {
        system("CLS");
        printf("\nQueue is an abstract data structure, somewhat similar to Stacks. Unlike stacks, a queue is open at both its ends.\n");
        printf("\nOne end is always used to insert data (enqueue) and the other is used to remove data (dequeue). Queue follows First-In-First-Out methodology, i.e., the data item stored first will be accessed first.\n");
        printf("\nA real-world example of queue can be a single-lane one-way road, where the vehicle enters first, exits first. More real-world examples can be seen as queues at the ticket windows and bus-stops.\n");
        printf("\nAs we now understand that in queue, we access both ends for different reasons. The following diagram given below tries to explain queue representation as data structure −\n");
        printf("\nAs in stacks, a queue can also be implemented using Arrays, Linked-lists, Pointers and Structures. For the sake of simplicity, we shall implement queues using one-dimensional array.\n");
        printf("\nQueue operations may involve initializing or defining the queue, utilizing it, and then completely erasing it from the memory. Here we shall try to understand the basic operations associated with queues −\n");
        queue();
    }
    else if(select == 5)
    {
    system("CLS");
    Node *head=0, *temp;
    int choise;
    printf("Enter How many node you want to Insert : ");
    scanf("%d", &choise);
    printf("\n");
    for(int i = 0; i < choise; i++){
    Node *new_node = (Node *)malloc(sizeof(Node));
    printf("Enter Node item for %d : ", i+1);
    scanf("%d", &new_node->data);
    new_node->next = NULL;

    if(head == NULL){
        head = temp = new_node;
    }
    else{
        temp->next = new_node;
        temp = new_node;
    }
    }

    printf("\nThis is Your created linked list : ");
    print_linked_list(head);

    gotoxy(30,10); /// move the cursor to postion 30, 10 from top-left corner
    printf("1. Insert at Nth position"); /// option for add record
    gotoxy(30,12);
    printf("2. Delete at Nth position"); /// option for showing existing record
    gotoxy(30,14);
    printf("3. Print List");

    int op;
    printf("Enter Your Choise(0 to exit) : ");
    scanf("%d", &op);
    while(op)
    {
        if(op == 1){
            choise++;
            int option;
            printf("Enter the place where you want to insert\n\n\t1.First position\n\t2.Last position\n\t3.After Nth position\n\n : ");
            scanf("%d", &option);
            if(option == 1) head = prepend(head);
            else if(option == 2) append(head);
            else if(option == 3) add_node(head);
        }
        else if(op == 2){
            head = remove_node(head, choise);
        }
        else if(op == 3){
            print_linked_list(head);
        }
        printf("\n1. Insert at Nth position"); /// option for add record
        printf("\n2. Delete at Nth position"); /// option for showing existing record
        printf("\n3. Print List");
        printf("Enter Your Choise(0 to exit) : ");
        scanf("%d", &op);
    }
    }
    else if(select == 6)
    {
        system("CLS");
        virtual_judge();
    }
    printf("\nDo you want to learn more(y/n) : ");
    x = getche();
    system("CLS");
    }
}

void learn_or_findjob()
{
    printf("\t\t\tWhy You Are Here\n\t\t------------------------------\n\t\t\t1.Learner\n\t\t\t2.Find Job\n");
    int option;
    printf("\n\t\tEnter Your Option : ");
    scanf("%d", &option);
    if(option == 1)
    {
        learner();
    }
    else{
        find_job();
    }
}

int Login()
{
    FILE *LOG;
    LOG = fopen("login.txt", "r");
    if(LOG == NULL){
        perror("File opening failed!");
        return 0;
    }
    printf("\n\t\t\tWelcome to login section\n\t\t--------------------------------------------------\n");
    char check_userid_pass[20];
    char userId[20];
    char pass2[20];
    int count = 0;
    printf("\tEnter User id  : ");
    scanf(" %[^\n]", &userId);
    printf("\tEnter Password : ");
    scanf(" %[^\n]", &pass2);

    while(fscanf(LOG, "%s", &check_userid_pass) != EOF)
    {
        if(strcmp(userId, check_userid_pass) == 0) count++;
        if(strcmp(pass2, check_userid_pass) == 0) count++;
    }
    if(count <= 1)return 0;
    else return 1;

}

void registration()
{
    printf("\t\tWelcome to the registration section\n\t----------------------------------------------------\n");
    FILE *LOG;
    LOG = fopen("login.txt", "a");

    if(LOG == NULL){
        perror("File opening failed!");
        return;
    }
    struct Registration p;

    printf("\t\tEnter your first name     : ");
    scanf("%s", &p.first_name);
    //fprintf(LOG, "%s\n", p.first_name);

    printf("\t\tEnter your last name      : ");
    scanf("%s", &p.last_name);
    //fprintf(LOG, "%s\n", p.last_name);

    printf("\t\tEnter your Email          : ");
    scanf(" %[^\n]", &p.email);
    //fprintf(LOG, "%s\n", p.email);

    printf("\t\tEnter your User Id        : ");
    scanf(" %[^\n]", &p.user_id);
    fprintf(LOG, "%s\n", p.user_id);

    printf("\t\tEnter your password       : ");
    scanf(" %[^\n]", &p.password);
    fprintf(LOG, "%s\n", p.password);

    printf("\t\tEnter your password Again : ");
    scanf(" %[^\n]", &p.confirm_pass);
    //fprintf(LOG, "%s\n", p.confirm_pass);

    if(strcmp(p.password, p.confirm_pass) == 0)
    {
        printf("\n\t\tYour registration is successful!!\n\t------------------------------------------------------\n");
        //getch();
        system("CLS");
        fclose(LOG);
        //fflush(stdin);
        if(Login())
        {
           system("CLS");
           printf("\nLogin successsful\n");
           printf("\n\n\n\n");
           learn_or_findjob();
        }
        else{
             printf("INVALID!!!!!!!!!\n");
        }
    }
    else{
        printf("Your password doesn't match!!!!! your registration is not successful!\n");
    }
}

void Starting_of_software()
{
    printf("\t\tWelcome to the Leanning Platform and Find Job Software\n\t---------------------------------------------------------------------\n\n");
    printf("\t\t1. Are You a New User?\n\t\t2. Already Have An Account?\n\n");
    int choise;
    printf("Enter Your choise : ");
    scanf("%d", &choise);
    if(choise == 1)
    {
        system("CLS");
        printf("\n");
        registration();
    }
    else if(choise == 2)
    {
        printf("\n");
        system("CLS");
        if(Login())
        {
           system("CLS");
           printf("\nLogin successsful\n");
           printf("\n\n\n\n");
           learn_or_findjob();
        }
        else{
             printf("INVALID!!!!!!!!!\n");
        }
    }
}

int main()
{
    Starting_of_software();
    return 0;
}