C Programs

Which language should be preferred for learning data structures considering campus placements?

noreply@blogger.com (Aditya Narayan Singh) — Sun, 26 Feb 2023 05:32:00 +0000

When it comes to preparing for campus placements, one of the most important things that you can do is to learn about data structures. This is a crucial topic that is often covered in technical interviews, and it can be the difference between getting the job of your dreams or missing out. However, with so many different programming languages available, it can be difficult to know which one you should focus on when learning about data structures. In this blog post, we'll take a closer look at some of the most popular programming languages and discuss which one is best for learning data structures.

The first programming language that comes to mind when discussing data structures is undoubtedly C. C is a powerful and efficient language that is widely used in the industry for system programming and embedded systems. It's also the language that most computer science courses use to teach data structures, so it's a good starting point for beginners. The downside of C is that it's a bit more difficult to learn than some other languages, and it can take some time to get the hang of pointers and memory allocation.

Another popular language for data structures is Java. Java is a high-level language that is often used for developing enterprise-level applications. It's also an excellent language for learning data structures because of its strong object-oriented programming paradigm. Java's syntax is relatively easy to read and write, making it an excellent choice for beginners. Moreover, Java provides a vast collection of built-in data structures like ArrayList, LinkedList, and HashSet, making it easier for learners to focus on the core concepts rather than implementing data structures from scratch.

Python is another language that has gained popularity in recent years. It's a high-level language that is easy to read and write and is widely used in the data science community. While Python may not be the fastest language, it is often used for prototyping and rapid development. Python also provides a vast collection of built-in data structures and libraries like NumPy, Pandas, and SciPy that make it easy to work with data.

In conclusion, all three languages (C, Java, and Python) are excellent choices for learning data structures. While C may be more challenging to learn, it provides an excellent foundation for understanding how data structures work at a lower level. Java, on the other hand, is an excellent choice for beginners because of its easy-to-read syntax and built-in data structures. Python is the easiest to learn among the three and offers a plethora of built-in data structures and libraries for handling data. Ultimately, the choice of programming language comes down to your personal preference and career goals.

C program to implement linked list using struct

noreply@blogger.com (Aditya Narayan Singh) — Fri, 05 Feb 2021 11:55:00 +0000

Structure in C programming language is a composite data type that can hold variables of more than one data type and keyword struct is use to declare structure in C.

Syntax to define struct in C programming language is as:

struct [structure_tag]
{
    //datatype variable 1
    //int x;
    //char s;
    ...
}[structure_variables];

I will assume that you know how to implement struct normally in C programming language because here I am going to cover how to implement struct using linked list

C Program for struct using linked list:

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

//...............................................Function Creation...........................................//

void createlinkedlist();
void display();
void insert_at_first();
void delete_from_first();
void delete_from_end();
void insert_at_selected_position();
void delete_entire_list();
void reverse_nodes();

//.........................................structure node...............................................//

struct node
{
    int roll;
    char name[30];
    struct node *next;
};
struct node *head;

//......................................................MAIN..............................................//

int main()
{

    int ch;
    do
    {

        printf("\n\n\n\n\n\n\t\t\t1.Create Linked list");
        printf("\n\t\t\t2.Display List");
        if(head!=NULL)
        {

            printf("\n\t\t\t3.Delete From First\t");
            printf("\n\t\t\t4.Delete From end\t");
            printf("\n\t\t\t5.Insert at first\t");
            printf("\n\t\t\t6.Insert at selected position");
            printf("\n\t\t\t7.Delete entire List");
            printf("\n\t\t\t8.Reverse List");
        }

        printf("\n\t\t\t9.Exit\t");


        scanf("%d",&ch);
        switch(ch)
        {
        case 1:
            createlinkedlist();
            break;
        case 2:
            display();
            break;
        case 9:
            exit (0);
            break;
        case 5:
            insert_at_first();
            break;
        case 3:
            delete_from_first();
            break;
        case 4:
            delete_from_end();
            break;
        case 6:
            insert_at_selected_position();
            break;
        case 7:
            delete_entire_list();
            break;
        case 8:
            reverse_list();
            break;
        default:
            printf("Wrong choice Try again......");
        }
    }while(ch!=3);

}

//............................................Create linked list.................................................//

void createlinkedlist()
{
    system("cls");
    struct node *newnode,*temp;
    newnode=(struct node*)malloc(sizeof(struct node));
    printf("\n\n\t\t\tRoll :  ");
    scanf("%d",&newnode->roll);
    printf("\t\t\tName :  ");
    scanf("%s",&newnode->name);
    newnode->next=NULL;
    if(head==NULL)
    {
        head=newnode;
    }
    else
    {
        temp=head;
        while(temp->next!=NULL)
        {
            temp=temp->next;
        }
        temp->next=newnode;
    }
}

// ......................................................DISPLAY............................................//

void display()
{
    system("cls");
    struct node *temp;
    printf("\n\n\t\t\tRoll\t\tName\n");
    if(head!=NULL)
    {
        for(temp=head;temp!=NULL;temp=temp->next)
            printf("\t\t\t%d\t\t%s\n",temp->roll,temp->name);


    }
    else
    {
        printf("\n\t\t\tList is empty Boss... %c %c ",2,2);
    }
}

//............................................Insert At FIrst.................................................//

void insert_at_first()
{
    system("cls");
    struct node *temp,*newnode;
    newnode=(struct student *)malloc(sizeof(struct node));
    printf("\n\n\t\t\tRoll :  ");
    scanf("%d",&newnode->roll);
    printf("\t\t\tName :  ");
    scanf("%s",&newnode->name);
    temp=head;
    head=newnode;
    newnode->next=temp;

    return 0;
}

//..............................................Delete from first.....................................................//

void delete_from_first()
{
    system("cls");
    struct node *temp;
    if(head==NULL)
    {
        printf("\n\t\t\tList is empty Boss... %c %c ",2,2);
    }
    else
    {
        temp=head;
        free(head);
        head=temp->next;
        printf("\n\n\t\t\tFirst list deleted from node...");
    }

    return 0;

}

//..............................................Delete from end................................................//

void delete_from_end()
{
    system("cls");
    struct node *temp,*newtemp;
    temp=head;

    while(temp->next!=NULL)
    {
        newtemp=temp;
        temp=temp->next;
        if(temp->next==NULL)
            newtemp->next=NULL;
    }
    free(temp);

    printf("\n\n\t\t\tLast node is deleted....");
    return 0;

}

//..................................................Insert at selected position....................................//

void insert_at_selected_position()
{
    struct node *temp;
    struct node *new_temp,*temp_copy;
    temp=head;
    int position,i;
    printf("\n\n\t\t\tEnter the roll before you want to insert\t");
    scanf("%d",&position);
    for(i=1;i<position;i++)
    {
        temp=temp->next;
    }
    temp_copy=temp->next;
    new_temp=(struct node *)malloc(sizeof(struct node));
    temp->next=new_temp;
    printf("\n\n\t\t\tRoll :  ");
    scanf("%d",&new_temp->roll);
    printf("\t\t\tName :  ");
    scanf("%s",&new_temp->name);
    new_temp->next=temp_copy;
    return 0;
}

//..................................................free entire list........................................//

void delete_entire_list()
{
    system("cls");
    struct node *temp,*had;
    temp=head;
    if(temp->next==NULL)
    {
        free(temp);
    }
    else
    {
    while(temp!=NULL)
    {
        had=temp;
        temp=temp->next;
        free(had);
    }
    }
    head=NULL;


    return 0;
}

//.......................................Reverse List....................................//

void reverse_list()
{
    system("cls");
    if(head->next==NULL)
    {
        printf("\n\n\tsorry BOSS %c reverse not possible...",1);
    }
    else
    {
    struct node *p1,*p2,*p3;
    p1=head;
    p2=p1->next;
    p3=p1->next->next;
    p1->next=NULL;


    while(p3!=NULL)
    {

        p2->next=p1;
        p1=p2;
        p2=p3;
        p3=p3->next;

    }
    p2->next=p1;
    head=p2;
    }

}

5 Tips we should follow to learn programming languages faster and better

noreply@blogger.com (Aditya Narayan Singh) — Sat, 16 Jun 2018 04:06:00 +0000

Are you assessing for a diploma in computer system technological expertise? Or are you looking for to emerge as a coding or establishing professional? Irrespective of just what your cause is, you could have to grasp your art work of coding and also this will need by no means-finishing war to your component. Given below are 5 tips to assist you examine shows as speedy as possible.

image courtesy: makeuseof

1. Study with the aid of doing

If you need to research the coding principles quicker, you need to have fun with the codes on a day by day structure. Even the handiest codes will certainly be extremely challenging to put in force for the primary time. Honestly, setting boils down to exercise. In case you do not work out sufficient, you might not be capable of get it proper. Within the start, hand-operated coding will certainly take you a lot of time, but transformeds into a great deal easier with the flow of time.

2. Draw close the principles

At first, the basics of programming will certainly appear so smooth to you. Nonetheless this is not true. What you have to do is nail the fundamentals and also you ought to do it nicely. As a rely of fact, the far better you grasp the principles, the less challenging it will likely be so about check out the superior standards. If you do not research the essentials, you might get stuck whilst obtaining understanding of the higher innovative points.

3. Code by way of hand

Nowadays, computer monitors are getting thinner and also hard drivers have ended up being lighter. Yet, guide coding remains to be just one of the top techniques in case you should discover coding. Whether you run a notebook or whiteboard, overview coding requires extra accuracy, reason and also caution. Whilst it takes more time, this limit is going to mold you right into an expert programmer.

4. Request for assistance

If you ask peer as well as advisors for help, you’ll can take a look at quicker. If you believe that you cannot find out a subject otherwise you can not stream a bug, you’re fallacious. With a pair of eyes or help from other expert, you might make it possible. What you need to do is forget about the trolls as well as flip to experts for assistance. Professionals have been additionally novices like you, to make sure that they assist you to with the issues.

5. Online possessions

Ultimately, in case you recognize a picked idea, that includes a textbook principle, you may intend to preserve your self assurance phase as well as look for on line possessions for researching the same principle. Not all people discovers the equivalent manner. If one supply doesn’t be ideal for you, does not suggest you have actually got an inconvenience internal you. At the web, you can uncover endless possessions for acquiring understanding of shows. On video sharing internet sites like youtube, you might view splendid tutorials so one can analyze at your personal speed. The movie are easy to acknowledge and assist you grade by grade during the direction.

So, when you have actually been searching for a means to evaluate the art work of programming quicker, we encourage which you try out the tips given up this post. For better assist, you might connect with a professional designer. You want to work difficult and practice on a normal foundation.

Most used UNIX commands

noreply@blogger.com (Aditya Narayan Singh) — Sat, 26 May 2018 11:21:00 +0000

ls Commands (list) :

ls : list the files
ls -a : list the hidden files
ls -al : list the hidden files with long formatting
ls -R : list the recursive directory tree
ls -t : list the files with time
ls -s : list the file size
ls -i : list the file size with index number
ls -ls : size with long format
ls -X : extension name
ls -S : sort by file size

cd Command (change directory) :

cd / : move to root directory
cd ~ : move to home directory
cd .. : go back one step
cd ~/directory : jump from one directory to another directly
cd /root/directory : absolute path of directory
cd directory : Relative path of directory
cd dir1/dir2 : moving directly to dir2 inside the dir1.
cd : move directly to the home directory
cd ~prakash : takes to other user login

pwd Commands (print working directory) :

pwd : print the working directory
/bin/pwd –version : print the version of pwd command
type -a pwd : print all the locations containing executable named pwd
PS1=’pwd>’ : change current working directory to anything
nano pwd.sh : create a shell script
chmod pwd.sh : give executive permission

mkdir commands (make directory):

mkdir dirname : create a new directory
mkdir -m a=rwx dirname : create a new directory and set permissions
mkdir -p /root/mine/a/b : create a specified intermediate directories to verify this “du mine”
mkdir –version : shows the version of the installed mkdir
mkdir -m 777 mine : create a new directory and set the permission as per numbers

rm commands(remove) :

rm file1 : delete the file1
rm -r dir1 : delete the dir1
rm -f file1 : delete the file1
rm -rf dir1 : force remove the dir1
rm file1 file2 file3 : delete the 3 files simultaneously
rmdir dir1 dir2 dir3 : delete the 3 directories simultaneously
rm -ri dir1 : delete file and sub directories interactively(-ri option in rm cmd)
rm -f *.txt : delete all the .txt file

cp commands (copy) :

cp file1 file2 : copy file1 to file2
cp -r dir1 dir2 : copy dir1 to dir2
cp *.txt dir1 : copy and move all the .txt files to dir1
cp -f file.txt dir1 : force file copy to dir1
cp -i file.txt dir1 : interactive prompt before file overwrite
cp -u * dirname : copy all the files to the directory

mv command (move) :

mv file1 file2 : rename the file1 to file2
mv file1 dir1 : move the file1 to the destination directory
mv file1 ../ : move the file1 to the root directory
mv *.txt dir 1 : move the all .txt files to dir1
mv dir1/* . : move all files in the subdirectory dir1 to current directory
mv dir1 dir2 : move the dir1 to dir2

ln Commands (link) :

ln -s file1 dirname : create a symbolic link “link” to file
ln -s file1 file2 : create a symbolic link to a files
ln -s -b file1.txt file2.txt : file1.txt is renamed to file2.txt , file2.txt symlink is created

touch command :

touch file1 : create a new file1
touch file1 file2 file3 : create multiple files simultaneously
touch -a test.txt : change file access and modification
touch -c test.txt : avoid creating new file
touch -m test.txt : change file modification time
touch {A..Z} : create file with names A to Z
touch {1..20 : Create files with name 1 to 10
touch {A..N}.txt : create file with extension
touch {1..10}{1..1000} : create 10k files
touch -c -t 12101730 test.txt : set the access and modification times
touch -r file leena : use time stamp of another file
touch -d ’14:24′ abc.txt ” : specify datetime as a string

cat command (concatenate) :

ct /etc/shells : display all the shell commands
cat /etc/passwd : display contents of file
cat file file1 : view contents of multiple files
cat >test1 : create a file with cat command
cat file.txt | more : use cat command with more option
cat file.txt | less : use cat command with less option
cat -n file.txt : display numbers in file
cat -e file : display $ at the EOF
cat file1; file2 file3; : diplay multiple file contents simultaneously more command :

more command :

more +3 file1.txt : display the contents of file1.txt , beginning at line 3
more +/”hope” file : display the content of the file , beginning at the first line containing the string “hope”.
ls | more : List the contents of the current directory with ls, using more to display the list one screen at a time.

head commands :

head test : print the first 10 lines from the files
head -n2 test : print the first N lines from the file
head -n -2 test : Skip the last N lines from the file
head -c 5 test : print the first N bytes from the file
head -c -7 test : to skip printing last N bytes
head -n 10 test | tail -5 : Print the lines b/w the line numbers M and N
head -n 2 /etc/passwd : print the first 2 lines of a file
head -n -27 /etc/passwd : it printed all the lines starting after the line 27

tail commands :

tail test : print the last 10 lines of the file
tail test -n 100 : Outputs the last 100 lines of the file myfile.txt
tail -n 2 /etc/passwd : print the last 2 lines of a file
tail -n-2 test : Print the last N lines from the file
tail -f test : output the contents of file as it grows, starting with the last 10 lines Process Management .
tail -c-7 test : print the last N bytes
tail -n10 test | head -5 : Print the lines b/w the line numbers M and N
tail -n -27 /etc/passwd : it printed all the lines starting before the line 27

chmod in UNIX

noreply@blogger.com (Aditya Narayan Singh) — Sat, 26 May 2018 11:19:00 +0000

Commands for changing Premission in UNIX:

chmod octal file – change the permissions of file to octal, which can be found separately for user, group, and world by adding:

4 – read (r)
2 – write (w)
1 – execute (x)

chmod commands :

> chmod 400 test : Making read only file for user
> chmod 777 dir1/ : Change file permissions and give all permissions for all user+group_other(file/directory)
> chmod u+w test : Change permissions only for user, group or others
> chmod g+w dir1/ : Change permissions only for Directories
> chmod u-w test : To remove file permission using (symbolic mode) chmod command
> chmod 555 test : To remove file permission using (octal mode) chmod command
> chmod u-rw test : To remove read and write access from file for user/group/others with symbolic(file/directory)
> chmod a-rw test : To remove read and write access from file for all with symbolic(file/directory)
> chmod a=X 8 : Setting execute permission only on directories without touching files(chmod a+X *)
> chmod –reference test perk : To copy permission from one file to another (source_file destination_file)
> chmod u+r,g+w,o+x test : Changing multiple permissions in a file/directory

C program for Doubly Linked List

noreply@blogger.com (Aditya Narayan Singh) — Sat, 31 Mar 2018 07:32:00 +0000

In computer science, a doubly linked list is a linked data structure that consists of a set of sequentially linked records called nodes. Each node contains two fields, called links, that are references to the previous and to the next node in the sequence of nodes. The beginning and ending nodes' previous and next links, respectively, point to some kind of terminator, typically a sentinel node or null, to facilitate traversal of the list. If there is only one sentinel node, then the list is circularly linked via the sentinel node. It can be conceptualized as two singly linked lists formed from the same data items, but in opposite sequential orders.
The two node links allow traversal of the list in either direction. While adding or removing a node in a doubly linked list requires changing more links than the same operations on a singly linked list, the operations are simpler and potentially more efficient (for nodes other than first nodes) because there is no need to keep track of the previous node during traversal or no need to traverse the list to find the previous node, so that its link can be modified.

****************Implementation*******************************

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
typedef struct node
{
    struct node *prev;
    int data;
    struct node *next;
};
struct node *head;
void create();
void display();
void insert_at_any_position();
void print_reverse();
void reverse_list();
main()
{
    int choice;
    do
    {
        printf("\n\t1.Create Double List");
        printf("\n\t2.Display lists");
        printf("\n\t3.Insert at any position");
        printf("\n\t4.Print reverse");
        printf("\n\t5.Reverse List");
        printf("\n\t6.Exit\t");
        scanf("%d",&choice);
        switch(choice)
        {
        case 1:
            create();
            break;
        case 2:
            display();
            break;
        case 3:
            insert_at_any_position();
            break;
        case 6:
            exit (0);
            break;
        case 4:
            print_reverse();
            break;
        case 5:
            reverse_list();
            break;
        default:
            printf("\n\t\twrong choice.......");
        }


    }while(choice!=3);
    getch();
}

create()
{
    system("cls");
    struct node *temp,*new_node;
    new_node=(struct node *)malloc(sizeof(struct node));
    printf("\n\tEnter data in form of integer\t");
    scanf("%d",&new_node->data);
    new_node->next=NULL;
    if(head==NULL)
    {
        head=new_node;
        head->prev=NULL;
    }
    else{
        temp=head;
        while(temp->next!=NULL)
        {
            temp=temp->next;
        }
        temp->next=new_node;
        new_node->prev=temp;

    }
    return 0;
}
display()
{
    system("cls");
    struct node *temp;
    int choice2;
    printf("\n\t1.From first");
    printf("\n\t2.From last\t");
    scanf("%d",&choice2);

    if(choice2==1)
    {
        temp=head;
        while(temp!=NULL)
        {
            printf("%d ==> ",temp->data);
            temp=temp->next;
        }
    }
    else if(choice2==2)
    {
        temp=head;
        while(temp->next!=NULL)
        {
            temp=temp->next;
        }
        while(temp!=NULL)
        {
            printf(" ==> %d",temp->data);
            temp=temp->prev;
        }
    }
    return 0;


}

void insert_at_any_position()
{
    system("cls");
    struct node *temp,*ptr;
    ptr=(struct node *)malloc(sizeof(struct node));
    int pos,i=1;
    printf("Insert position number\t");
    scanf("%d",&pos);
    temp=head;
    while(i<pos-1)
    {
        temp=temp->next;
    }
    ptr->prev=temp;
    temp->next->prev=ptr;
    ptr->next=temp->next;
    temp->next=ptr;

    printf("\n\tEnter data\t");
    scanf("%d",&ptr->data);
    return 1;
}

print_reverse()
{
    struct node *temp;
    temp=head;
    while(temp->next!=NULL)
    {
        temp=temp->next;
    }
    while(temp->prev!=NULL)
    {
        printf(" %d ==> ",temp->data);
        temp=temp->prev;
    }
    printf(" %d",temp->data);
}

reverse_list()
{
    system("cls");
    struct node *temp,*p;
    while(head!=NULL)
    {
        temp=head;
        head=head->next;
        p=temp->next;
        temp->next=temp->prev;
        temp->prev=p;

    }
    head=temp;

}

C program for Singly Linked list

noreply@blogger.com (Aditya Narayan Singh) — Sat, 31 Mar 2018 07:27:00 +0000

Singly Linked Lists are a type of data structure. In a singly linked list, each node in the list stores the contents and a pointer or reference to the next node in the list. It does not store any pointer or reference to the previous node. To store a single linked list, only the reference or pointer to the first node in that list must be stored. The last node in a single linked list points to nothing.

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

//............................................Function Creation...........................................//

void createlinkedlist();
void display();
void insert_at_first();
void delete_from_first();
void delete_from_end();
void insert_at_selected_position();
void delete_entire_list();
void reverse_nodes();

//.........................................structure node...............................................//

struct node
{
    int roll;
    char name[30];
    struct node *next;
};
struct node *head;

//......................................................MAIN..............................................//

int main()
{

    int ch;
    do
    {

        printf("\n\n\n\n\n\n\t\t\t1.Create Linked list");
        printf("\n\t\t\t2.Display List");
        if(head!=NULL)
        {

            printf("\n\t\t\t3.Delete From First\t");
            printf("\n\t\t\t4.Delete From end\t");
            printf("\n\t\t\t5.Insert at first\t");
            printf("\n\t\t\t6.Insert at selected position");
            printf("\n\t\t\t7.Delete entire List");
            printf("\n\t\t\t8.Reverse List");
        }

        printf("\n\t\t\t9.Exit\t");


        scanf("%d",&ch);
        switch(ch)
        {
        case 1:
            createlinkedlist();
            break;
        case 2:
            display();
            break;
        case 9:
            exit (0);
            break;
        case 5:
            insert_at_first();
            break;
        case 3:
            delete_from_first();
            break;
        case 4:
            delete_from_end();
            break;
        case 6:
            insert_at_selected_position();
            break;
        case 7:
            delete_entire_list();
            break;
        case 8:
            reverse_list();
            break;
        default:
            printf("Wrong choice Try again......");
        }
    }while(ch!=3);

}

//............................................Create linked list.................................................//

void createlinkedlist()
{
    system("cls");
    struct node *newnode,*temp;
    newnode=(struct node*)malloc(sizeof(struct node));
    printf("\n\n\t\t\tRoll :  ");
    scanf("%d",&newnode->roll);
    printf("\t\t\tName :  ");
    scanf("%s",&newnode->name);
    newnode->next=NULL;
    if(head==NULL)
    {
        head=newnode;
    }
    else
    {
        temp=head;
        while(temp->next!=NULL)
        {
            temp=temp->next;
        }
        temp->next=newnode;
    }
}

// ......................................................DISPLAY............................................//

void display()
{
    system("cls");
    struct node *temp;
    printf("\n\n\t\t\tRoll\t\tName\n");
    if(head!=NULL)
    {
        for(temp=head;temp!=NULL;temp=temp->next)
            printf("\t\t\t%d\t\t%s\n",temp->roll,temp->name);


    }
    else
    {
        printf("\n\t\t\tList is empty Boss... %c %c ",2,2);
    }
}

//............................................Insert At FIrst.................................................//

void insert_at_first()
{
    system("cls");
    struct node *temp,*newnode;
    newnode=(struct student *)malloc(sizeof(struct node));
    printf("\n\n\t\t\tRoll :  ");
    scanf("%d",&newnode->roll);
    printf("\t\t\tName :  ");
    scanf("%s",&newnode->name);
    temp=head;
    head=newnode;
    newnode->next=temp;

    return 0;
}

//..............................................Delete from first.....................................................//

void delete_from_first()
{
    system("cls");
    struct node *temp;
    if(head==NULL)
    {
        printf("\n\t\t\tList is empty Boss... %c %c ",2,2);
    }
    else
    {
        temp=head;
        free(head);
        head=temp->next;
        printf("\n\n\t\t\tFirst list deleted from node...");
    }

    return 0;

}

//..............................................Delete from end................................................//

void delete_from_end()
{
    system("cls");
    struct node *temp,*newtemp;
    temp=head;

    while(temp->next!=NULL)
    {
        newtemp=temp;
        temp=temp->next;
        if(temp->next==NULL)
            newtemp->next=NULL;
    }
    free(temp);

    printf("\n\n\t\t\tLast node is deleted....");
    return 0;

}

//..................................................Insert at selected position....................................//

void insert_at_selected_position()
{
    struct node *temp;
    struct node *new_temp,*temp_copy;
    temp=head;
    int position,i;
    printf("\n\n\t\t\tEnter the roll before you want to insert\t");
    scanf("%d",&position);
    for(i=1;i<position;i++)
    {
        temp=temp->next;
    }
    temp_copy=temp->next;
    new_temp=(struct node *)malloc(sizeof(struct node));
    temp->next=new_temp;
    printf("\n\n\t\t\tRoll :  ");
    scanf("%d",&new_temp->roll);
    printf("\t\t\tName :  ");
    scanf("%s",&new_temp->name);
    new_temp->next=temp_copy;
    return 0;
}

//..................................................free entire list........................................//

void delete_entire_list()
{
    system("cls");
    struct node *temp,*had;
    temp=head;
    if(temp->next==NULL)
    {
        free(temp);
    }
    else
    {
    while(temp!=NULL)
    {
        had=temp;
        temp=temp->next;
        free(had);
    }
    }
    head=NULL;


    return 0;
}

//.......................................Reverse List....................................//

void reverse_list()
{
    system("cls");
    if(head->next==NULL)
    {
        printf("\n\n\tsorry BOSS %c reverse not possible...",1);
    }
    else
    {
    struct node *p1,*p2,*p3;
    p1=head;
    p2=p1->next;
    p3=p1->next->next;
    p1->next=NULL;


    while(p3!=NULL)
    {

        p2->next=p1;
        p1=p2;
        p2=p3;
        p3=p3->next;

    }
    p2->next=p1;
    head=p2;
    }

}

C program for Bisection Method

noreply@blogger.com (Aditya Narayan Singh) — Thu, 29 Mar 2018 14:38:00 +0000

The bisection method in mathematics is a root-finding method that repeatedly bisects an interval and then selects a subinterval in which a root must lie for further processing. It is a very simple and robust method, but it is also relatively slow. Because of this, it is often used to obtain a rough approximation to a solution which is then used as a starting point for more rapidly converging methods. The method is also called the interval halving method, the binary search method, or the dichotomy method.

******************C program*********************

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

double f(double); // the function

int main() {
    double xa      = 0;
    double xb      = 1;
    double xm;
    double epsilon = 0.0001;
    double max_iteration = 1000;
    double counter=0;
    
    printf("Finding the Roots with the Bisection Method\n");
    printf("-------------------------------------------\n\n");
    printf("Enter Xa");
    scanf("%lf",&xa);
    printf("Enter Xb");
    scanf("%lf",&xb);
    printf("Initial x- values:\n");
    printf("f(%.2lf) = %lf\n", xa, f(xa));
    printf("f(%.2lf) = %lf\n\n", xb, f(xb));
    
    printf("epsilon = %lf\n\n", epsilon);
    
    // Make sure f(xa) and f(xb) have opposite signs
    if( f(xa)*f(xb) > 0) {
        printf("Error: f(xa) and f(xb) don't have opposite signs!\n\n");
        system("PAUSE");
        return 1;
    }
    
    xm = (xa+xb)/2; // initial value of xm
    printf("     xa         xb        f(xa)      f(xb)       xm        f(xm)\n");    

    // Loop of the bisection method
    while(counter<max_iteration && fabs(f(xm))>epsilon) {
          xm = (xa+xb)/2;
          printf("%10lf %10lf %10lf %10lf %10lf %10lf\n", xa, xb, f(xa), f(xb), xm, f(xm));
          
          if( f(xa)*f(xm) < 0)
              xb = xm;
          else xa = xm;
          
          counter++; // increment the counter
    }
    
    printf("\nNumber of iterations done: %.0lf, max_iterations=%.0lf\n", counter, max_iteration);
    printf("The root is: %lf\n", xm);
    printf("The root we found makes the function equal to: f(xm)=%lf\n", f(xm));      
    printf("\n\n");
    system("PAUSE");
    return 0;    
}
//******************
double f(double x) {
       double val;
       
       val = sin(x)-2*cos(2*x);
       return val;
}

***********************End**********************

Arduino - Robot using C program

noreply@blogger.com (Aditya Narayan Singh) — Sun, 11 Mar 2018 05:01:00 +0000

Connecting the robot to your computer

Each board on the robot has a microcontroller, which is programmed independently of the other. It is recommended that you should only program the control board (the top board) until you are familiar with the robot's functionality. The motor board (the bottom board) has a stock firmware that fulfills most general purpose applications.

Connect the control board to your computer with a USB cable.
After you have connected the board, the green LED labelled as PWR on the Control Board will be on. LED1 beneath it will flash a few times. On the Motor Board, the red LEDs labelled as LED1 to LED5 (opposite side to the power switch) should be on as well.

If the LEDs on either board do not turn on, check if the flat 10-pin communication cable next to the power switch is connected to both boards

Installing the drivers

OSX

The first time you plug a robot into a computer running OSX, the "Keyboard Setup Assistant" will launch. There's nothing to configure with the robot, so you can close this dialogue by clicking the red button in the top left of the window.

Windows

The following instructions are for Windows 7. They are valid also for Windows XP, with small differences in the dialog windows.

Plug in your board and wait for Windows to begin its driver installation process. If the installer does not launch automatically, navigate to the Windows Device Manager (Start>Control Panel>Hardware) and find the Arduino Robot listing. Right click and choose Update driver.

At the next screen, choose "Browse my computer for driver software", and click Next.
Click the Browse... button. Another dialog appears: navigate to the folder with the Arduino software that you just downloaded. Select the drivers folder an click OK, then click Next.
You will receive a notification that the board has not passed Windows Logo testing. Click on the button Continue Anyway.
After a few moments, a window will tell you the wizard has finished installing software for Arduino Robot. Press the Close button.

Uploading a test sketch

To program the robot, connect the Control Board to your computer via USB. Open the Arduino IDE, and load the sketch located in File > Examples > Robot_Control > learn > MotorTest.

You need to tell the IDE which Arduino board you are targeting with your software, so open the Tools > Board menu and choose Arduino Robot Control.

The Arduino IDE must know which of your USB ports the robot is connected to. The Tools > Serial menu lists the available ports.

if only one item is shown, click on that one.
if two or more are shown, you can disconnect the Control Board and re-open the menu; the entry that disappears should be the robot. Reconnect the board and select that serial port.

Click the "Upload" button in the top left of the IDE window. Wait a few seconds - you should see the RX and TX leds on the board flashing. If the upload is successful, the message "Done uploading." will appear in the status bar of the software. Once this appears, you can disconnect the robot from the USB cable
With batteries in the robot, turn on the power switch and put it on the ground. The robot should show you a few basic moves. Congratulations! You've gotten the robot up and running.

If the robot is not moving, turn the power switch off. Connect the motor board to the computer with a USB cable. Load the File > Examples > Robot_Motor > Robot_Motor_Core sketch in the IDE, and select Arduino Robot Motor from the Boards menu. Upload this sketch, disconnect from the computer and try turning it on again

Note: If no Serial port shows up after you plug in the robot, and restarting the IDE/unplug-replug the robot does not help, follow the steps below:

Open a very simple sketch, like Blink or BareMinimum
Press the upload button
When the status bar shows "Uploading...", double press the reset button on the Control Board
The Serial port should appear as normally.

Moving the Robot

This sketch moves the robot back and forth repeatedly.
Whenever you're writing code for the robot, make sure to include <ArduinoRobot.h> at the beginning of the sketch. This imports the necessary libraries to control the robot.
There's no need to initialize the Robot object.
To get the wheels to move, call Robot.motorsWrite(). motorsWrite() requires 2 arguments, the speed of the left motor, and the speed of the right motor. These values range from -255 to 255, where -255 is full reverse, and 255 is full speed forward. If you pass a value of 0, the motor will stop spinning the wheel.
Once you've uploaded the sketch, unplug the USB cable for the robot. Whenever the USB is connected, the robot's motors are disengaged. Turn on the power and watch it move around!

#include <ArduinoRobot.h> // import the robot library

void setup(){
  Robot.begin(); // initialize the library
}

void loop(){
  // move forward for one second
  Robot.motorsWrite(255,255);
  delay(1000);

  Robot.motorsWrite(0,0); // stop moving
  delay(1000);

  // move backwards for one second
  Robot.motorsWrite(-255,-255);
  delay(1000);

  Robot.motorsWrite(0,0); // stop moving
  delay(1000);
}

Read the buttons

You'll be writing a sketch that prints the button presses to the screen.
First, you need to include the Robot library.

#include <ArduinoRobot.h>

In setup(), start the robot and the screen.

void setup(){
  Robot.begin();
  Robot.beginTFT();
}

In loop(), every 100ms, read the state of the buttons. If one is being pressed, write the name to the screen.

void loop(){
  Robot.debugPrint(Robot.keyboardRead(), 10, 10);
  delay(100);
}

In the explore folder of the robot examples, there is a sketch called Logo, which incorporates this example with the robot movement from above.

Change the motor speed with the potentiometer

This lets you control the speed at which the robot moves in a straight line. By turning the knob and mapping the values to -255 to 255, you will set the speed and direction (forward or backwards) of the robot.
First, you need to include the Robot library.

#include <ArduinoRobot.h>

[Get Code]

In setup(), you must call Robot.begin() to initialize the robot's functions. Also call Robot.beginTFT() to initialize the screen.

void setup(){

Robot.begin();
Robot.beginTFT();
}

[Get Code]

In loop(), read the value of the potentiometer with Robot.knobRead(). Map its value (a number between 0 and 1023) to -255 to 255. Print this value to the screen, and use it to change the speed of the motors.

void loop(){
int val=map(Robot.knobRead(),0,1023,-255,255);
Robot.debugPrint(val);
Robot.motorsWrite(val,val);
delay(10);
}

[Get Code]

The robot's motor is disengaged when plugged in via USB. After programming the robot, unplug the USB cable and add batteries. Turn on the power switch and watch the robot move. Catch the robot, and change the knob to change its speed.

Making some noise

The robot has two different means of producing sounds. There's simple beeping, but the robot can also create more complex sounds by reading sequenced music off the SD card. In this example you'll start with the beeping. To learn about the more complex playback, see the Melody example in the learn folder.

 First, you need to include the Robot library.

#include <ArduinoRobot.h>

In setup(), you must call Robot.begin() to initialize the robot's functions. Also call Robot.beginSpeaker() to initialize the speaker.

void setup(){
  Robot.begin();
  Robot.beginSpeaker();
}

In loop(), you can call Robot.beep() to create a beep. There are three different kinds of beeping; a simple beep, a double beep, and a long beep.

void loop() {
  Robot.beep(BEEP_SIMPLE);
  delay(1000);
  Robot.beep(BEEP_DOUBLE);
  delay(1000);
  Robot.beep(BEEP_LONG);
  delay(1000);
}

Next steps

There are many things you can do with the robot. The few examples on this page don't do it justice. To see some more complex examples that of what the robot can do, look at the sketches found in the Explore folder of the robot examples. These are more complete examples that show you some different applications for the robot.

You'll need to calibrate the compass module of the robot so it rotates smoothly. If you're using an old model, which has Honeywell HMC 6352, you can refer to this tutorial: Calibrate Compass

To learn about more of the functionality of the specific inputs and outputs of the robot, look at the learn folder in the robot examples.
Be sure to check out the Robot's library page and the hardware page for more information about the technical aspects of the Robot.

The text of the Arduino getting started guide is licensed under a Creative Commons Attribution-ShareAlike 3.0 License. Code samples in the guide are released into the public domain.

source: www.arudino.cc

File reading & writing in C with different modes

noreply@blogger.com (Aditya Narayan Singh) — Mon, 05 Mar 2018 04:47:00 +0000

1. Opening a file

fopen() function is used for opening a file.
Syntax:

FILE pointer_name = fopen ("file_name", "Mode");

pointer_name can be anything of your choice.
file_name is the name of the file, which you want to open. Specify the full path here like “C:\\myfiles\\newfile.txt”.

While opening a file, you need to specify the mode. The mode that we use to read a file is “r” which is “read only mode”.
for example:

FILE  *fp;
fp = fopen("C:\\myfiles\\newfile.txt", "r");

The address of the first character is stored in pointer fp.

How to check whether the file has opened successfully?
If file does not open successfully then the pointer will be assigned a NULL value, so you can write the logic like this:
This code will check whether the file has opened successfully or not. If the file does not open, this will display an error message to the user.

..
FILE fpr;
fpr = fopen("C:\\myfiles\\newfile.txt", "r");
if (fpr == NULL)
{
    puts("Error while opening file");
    exit();
}

Various File Opening Modes:

The file is opened using fopen() function, while opening you can use any of the following mode as per the requirement.
Mode “r”: It is a read only mode, which means if the file is opened in r mode, it won’t allow you to write and modify content of it. When fopen() opens a file successfully then it returns the address of first character of the file, otherwise it returns NULL.

Mode “w”: It is a write only mode. The fopen() function creates a new file when the specified file doesn’t exist and if it fails to open file then it returns NULL.

Mode “a”: Using this mode Content can be appended at the end of an existing file. Like Mode “w”, fopen() creates a new file if it file doesn’t exist. On unsuccessful open it returns NULL.
File Pointer points to: last character of the file.

Mode “r+”: This mode is same as mode “r”; however you can perform various operations on the file opened in this mode. You are allowed to read, write and modify the content of file opened in “r+” mode.
File Pointer points to: First character of the file.

Mode “w+”: Same as mode “w” apart from operations, which can be performed; the file can be read, write and modified in this mode.
Mode “a+”: Same as mode “a”; you can read and append the data in the file, however content modification is not allowed in this mode.

2. Reading a File

To read the file, we must open it first using any of the mode, for example if you only want to read the file then open it in “r” mode. Based on the mode selected during file opening, we are allowed to perform certain operations on the file.

C Program to read a file

fgetc( ): This function reads the character from current pointer’s position and upon successful read moves the pointer to next character in the file. Once the pointers reaches to the end of the file, this function returns EOF (End of File). We have used EOFin our program to determine the end of the file.

#include <stdio.h>
int main()
{
     /* Pointer to the file */
     FILE *fp1;
     /* Character variable to read the content of file */
     char c;

     /* Opening a file in r mode*/
     fp1= fopen ("C:\\myfiles\\newfile.txt", "r");

     /* Infinite loop –I have used break to come out of the loop*/
     while(1)
     {
        c = fgetc(fp1);
        if(c==EOF)
            break;
        else
            printf("%c", c);
     }
     fclose(fp1);
     return 0;
}

3. Writing to a file

To write the file, we must open the file in a mode that supports writing. For example, if you open a file in “r” mode, you won’t be able to write the file as “r” is read only mode that only allows reading.

Example: C Program to write the file

This program asks the user to enter a character and writes that character at the end of the file. If the file doesn’t exist then this program will create a file with the specified name and writes the input character into the file.

#include <stdio.h>
int main()
{
   char ch;
   FILE *fpw;
   fpw = fopen("C:\\newfile.txt","w");

   if(fpw == NULL)
   {
      printf("Error");   
      exit(1);             
   }

   printf("Enter any character: ");
   scanf("%c",&ch);

   /* You can also use fputc(ch, fpw);*/
   fprintf(fpw,"%c",ch);
   fclose(fpw);

   return 0;
}

4. Closing a file

fclose(fp);

The fclose( ) function is used for closing an opened file. As an argument you must provide a pointer to the file that you want to close.

An example to show Open, read, write and close operation in C

#include <stdio.h>
int main()
{
    char ch;

    /* Pointer for both the file*/
    FILE *fpr, *fpw;
    /* Opening file FILE1.C in “r” mode for reading */
    fpr = fopen("C:\\file1.txt", "r");

    /* Ensure FILE1.C opened successfully*/
    if (fpr == NULL)
    {
         puts("Input file cannot be opened");
    }

    /* Opening file FILE2.C in “w” mode for writing*/
    fpw= fopen("C:\\file2.txt", "w");

    /* Ensure FILE2.C opened successfully*/


    if (fpw == NULL)
    {
       puts("Output file cannot be opened");
    }

    /*Read & Write Logic*/
    while(1)
    {
        ch = fgetc(fpr);
        if (ch==EOF)
            break;
        else
            fputc(ch, fpw);
    }



    /* Closing both the files */
    fclose(fpr);
    fclose(fpw);

    return 0;
}

Tic Tac Toe game using C program

noreply@blogger.com (Unknown) — Fri, 02 Mar 2018 12:16:00 +0000

Tic-tac-toe is a paper-and-pencil game for two players, X and O, who take turns marking the spaces in a 3×3 grid. The player who succeeds in placing three of their marks in a horizontal, vertical, or diagonal row wins the game.

wikipedia

**Source Code*

#include <stdio.h>
#include <conio.h>

char square[10] = { 'o', '1', '2', '3', '4', '5', '6', '7', '8', '9' };

int checkwin();
void board();

int main()
{
    int player = 1, i, choice;

    char mark;
    do
    {
        board();
        player = (player % 2) ? 1 : 2;

        printf("Player %d, enter a number:  ", player);
        scanf("%d", &choice);

        mark = (player == 1) ? 'X' : 'O';

        if (choice == 1 && square[1] == '1')
            square[1] = mark;
            
        else if (choice == 2 && square[2] == '2')
            square[2] = mark;
            
        else if (choice == 3 && square[3] == '3')
            square[3] = mark;
            
        else if (choice == 4 && square[4] == '4')
            square[4] = mark;
            
        else if (choice == 5 && square[5] == '5')
            square[5] = mark;
            
        else if (choice == 6 && square[6] == '6')
            square[6] = mark;
            
        else if (choice == 7 && square[7] == '7')
            square[7] = mark;
            
        else if (choice == 8 && square[8] == '8')
            square[8] = mark;
            
        else if (choice == 9 && square[9] == '9')
            square[9] = mark;
            
        else
        {
            printf("Invalid move ");

            player--;
            getch();
        }
        i = checkwin();

        player++;
    }while (i ==  - 1);
    
    board();
    
    if (i == 1)
        printf("==>\aPlayer %d win ", --player);
    else
        printf("==>\aGame draw");

    getch();

    return 0;
}

/*********************************************

FUNCTION TO RETURN GAME STATUS
1 FOR GAME IS OVER WITH RESULT
-1 FOR GAME IS IN PROGRESS
O GAME IS OVER AND NO RESULT
 **********************************************/

int checkwin()
{
    if (square[1] == square[2] && square[2] == square[3])
        return 1;
        
    else if (square[4] == square[5] && square[5] == square[6])
        return 1;
        
    else if (square[7] == square[8] && square[8] == square[9])
        return 1;
        
    else if (square[1] == square[4] && square[4] == square[7])
        return 1;
        
    else if (square[2] == square[5] && square[5] == square[8])
        return 1;
        
    else if (square[3] == square[6] && square[6] == square[9])
        return 1;
        
    else if (square[1] == square[5] && square[5] == square[9])
        return 1;
        
    else if (square[3] == square[5] && square[5] == square[7])
        return 1;
        
    else if (square[1] != '1' && square[2] != '2' && square[3] != '3' &&
        square[4] != '4' && square[5] != '5' && square[6] != '6' && square[7] 
        != '7' && square[8] != '8' && square[9] != '9')

        return 0;
    else
        return  - 1;
}


/*******************************************************************
FUNCTION TO DRAW BOARD OF TIC TAC TOE WITH PLAYERS MARK
 ********************************************************************/


void board()
{
    system("cls");
    printf("\n\n\tTic Tac Toe\n\n");

    printf("Player 1 (X)  -  Player 2 (O)\n\n\n");


    printf("     |     |     \n");
    printf("  %c  |  %c  |  %c \n", square[1], square[2], square[3]);

    printf("_____|_____|_____\n");
    printf("     |     |     \n");

    printf("  %c  |  %c  |  %c \n", square[4], square[5], square[6]);

    printf("_____|_____|_____\n");
    printf("     |     |     \n");

    printf("  %c  |  %c  |  %c \n", square[7], square[8], square[9]);

    printf("     |     |     \n\n");
}

/*******************************************************************
END OF PROJECT
 ********************************************************************/

Output:

Prim’s Algorithm in C

noreply@blogger.com (Aditya Narayan Singh) — Sun, 25 Feb 2018 12:41:00 +0000

Prim’s Algorithm is an approach to determine minimum cost spanning tree. In this case, we start with single edge of graph and we add edges to it and finally we get minimum cost tree. In this case, as well, we have n-1 edges when number of nodes in graph are n.We again and again add edges to tree and tree is extended to create spanning tree, while in case of Kruskal’s algorithm there may be more than one tree, which is finally connected through edge to create spanning tree.

Algorithm

This algorithm creates spanning tree with minimum weight from a given weighted graph.

Begin
Create edge list of given graph, with their weights.
Draw all nodes to create skeleton for spanning tree.
Select an edge with lowest weight and add it to skeleton and delete edge from edge list.
Add other edges. While adding an edge take care that the one end of the edge should always be in the skeleton tree and its cost should be minimum.
Repeat step 5 until n-1 edges are added.
Return.

C program for constructing a minimum cost spanning tree of a graph using Prim’s algorithm

#include<stdio.h>
#include<stdlib.h>
 
#define infinity 9999
#define MAX 20
 
int G[MAX][MAX],spanning[MAX][MAX],n;
 
int prims();
 
int main()
{
    int i,j,total_cost;
    printf("Enter no. of vertices:");
    scanf("%d",&n);
    
    printf("\nEnter the adjacency matrix:\n");
    
    for(i=0;i<n;i++)
        for(j=0;j<n;j++)
            scanf("%d",&G[i][j]);
    
    total_cost=prims();
    printf("\nspanning tree matrix:\n");
    
    for(i=0;i<n;i++)
    {
        printf("\n");
        for(j=0;j<n;j++)
            printf("%d\t",spanning[i][j]);
    }
    
    printf("\n\nTotal cost of spanning tree=%d",total_cost);
    return 0;
}
 
int prims()
{
    int cost[MAX][MAX];
    int u,v,min_distance,distance[MAX],from[MAX];
    int visited[MAX],no_of_edges,i,min_cost,j;
    
    //create cost[][] matrix,spanning[][]
    for(i=0;i<n;i++)
        for(j=0;j<n;j++)
        {
            if(G[i][j]==0)
                cost[i][j]=infinity;
            else
                cost[i][j]=G[i][j];
                spanning[i][j]=0;
        }
        
    //initialise visited[],distance[] and from[]
    distance[0]=0;
    visited[0]=1;
    
    for(i=1;i<n;i++)
    {
        distance[i]=cost[0][i];
        from[i]=0;
        visited[i]=0;
    }
    
    min_cost=0;        //cost of spanning tree
    no_of_edges=n-1;        //no. of edges to be added
    
    while(no_of_edges>0)
    {
        //find the vertex at minimum distance from the tree
        min_distance=infinity;
        for(i=1;i<n;i++)
            if(visited[i]==0&&distance[i]<min_distance)
            {
                v=i;
                min_distance=distance[i];
            }
            
        u=from[v];
        
        //insert the edge in spanning tree
        spanning[u][v]=distance[v];
        spanning[v][u]=distance[v];
        no_of_edges--;
        visited[v]=1;
        
        //updated the distance[] array
        for(i=1;i<n;i++)
            if(visited[i]==0&&cost[i][v]<distance[i])
            {
                distance[i]=cost[i][v];
                from[i]=v;
            }
        
        min_cost=min_cost+cost[u][v];
    }
    
    return(min_cost);
}

Output

Enter no. of vertices:6

Enter the adjacency matrix:
0 3 1 6 0 0
3 0 5 0 3 0
1 5 0 5 6 4
6 0 5 0 0 2
0 3 6 0 0 6
0 0 4 2 6 0

spanning tree matrix:
0 3 1 0 0 0
3 0 0 0 3 0
1 0 0 0 0 4
0 0 0 0 0 2
0 3 0 0 0 0
0 0 4 2 0 0

Total cost of spanning tree=13

C program for kruskal’s algorithm

noreply@blogger.com (Aditya Narayan Singh) — Sat, 24 Feb 2018 09:09:00 +0000

It is an algorithm for finding the minimum cost spanning tree of the given graph. In kruskal’s algorithm, edges are added to the spanning tree in increasing order of cost. If the edge E forms a cycle in the spanning, it is discarded.

Kruskal’s Algorithm

This algorithm will create spanning tree with minimum weight, from a given weighted graph.

Begin
Create the edge list of given graph, with their weights.
Sort the edge list according to their weights in ascending order.
Draw all the nodes to create skeleton for spanning tree.
Pick up the edge at the top of the edge list (i.e. edge with minimum weight).
Remove this edge from the edge list.
Connect the vertices in the skeleton with given edge. If by connecting the vertices, a cycle is created in the skeleton, then discard this edge.
Repeat steps 5 to 7, until n-1 edges are added or list of edges is over.
Return

C program for constructing a minimum cost spanning tree of a graph using Kruskal’s algorithm:

#include<stdio.h>
#define MAX 30
 
typedef struct edge
{
    int u,v,w;
}edge;
 
typedef struct edgelist
{
    edge data[MAX];
    int n;
}edgelist;
 
edgelist elist;
 
int G[MAX][MAX],n;
edgelist spanlist;
 
void kruskal();
int find(int belongs[],int vertexno);
void union1(int belongs[],int c1,int c2);
void sort();
void print();
 
void main()
{
    int i,j,total_cost;
    
    printf("\nEnter number of vertices:");
    
    scanf("%d",&n);
    
    printf("\nEnter the adjacency matrix:\n");
    
    for(i=0;i<n;i++)
        for(j=0;j<n;j++)
            scanf("%d",&G[i][j]);
            
    kruskal();
    print();
}
 
void kruskal()
{
    int belongs[MAX],i,j,cno1,cno2;
    elist.n=0;
 
    for(i=1;i<n;i++)
        for(j=0;j<i;j++)
        {
            if(G[i][j]!=0)
            {
                elist.data[elist.n].u=i;
                elist.data[elist.n].v=j;
                elist.data[elist.n].w=G[i][j];
                elist.n++;
            }
        }
 
    sort();
    
    for(i=0;i<n;i++)
        belongs[i]=i;
    
    spanlist.n=0;
    
    for(i=0;i<elist.n;i++)
    {
        cno1=find(belongs,elist.data[i].u);
        cno2=find(belongs,elist.data[i].v);
        
        if(cno1!=cno2)
        {
            spanlist.data[spanlist.n]=elist.data[i];
            spanlist.n=spanlist.n+1;
            union1(belongs,cno1,cno2);
        }
    }
}
 
int find(int belongs[],int vertexno)
{
    return(belongs[vertexno]);
}
 
void union1(int belongs[],int c1,int c2)
{
    int i;
    
    for(i=0;i<n;i++)
        if(belongs[i]==c2)
            belongs[i]=c1;
}
 
void sort()
{
    int i,j;
    edge temp;
    
    for(i=1;i<elist.n;i++)
        for(j=0;j<elist.n-1;j++)
            if(elist.data[j].w>elist.data[j+1].w)
            {
                temp=elist.data[j];
                elist.data[j]=elist.data[j+1];
                elist.data[j+1]=temp;
            }
}
 
void print()
{
    int i,cost=0;
    
    for(i=0;i<spanlist.n;i++)
    {
        printf("\n%d\t%d\t%d",spanlist.data[i].u,spanlist.data[i].v,spanlist.data[i].w);
        cost=cost+spanlist.data[i].w;
    }
 
    printf("\n\nCost of the spanning tree=%d",cost);
}

Output Screenshot

How to change post author name in blogger

noreply@blogger.com (Aditya Narayan Singh) — Sat, 17 Feb 2018 05:02:00 +0000

Publishing new post will display the Author's Name and some of the templates will display the Author's Name and can click it to redirect to the author profile page.In this tutorial I will teach you how to change your Author's Name whenever you are posting or viewing your post and change or remove the redirect.

Follow the step by step instruction below to change the author name in your blog.

First: How to change the Author's Name.

Step 1: Go to your blogger dashboard.

Step 2: Click on Template.

Step 3: Click on Edit HTML and click inside the box.

Step 4: Press Ctrl+F to search for <data:post.author/>.

<data:post.author/> - This is the author name.

Step 5: Change <data:post.author/> into something else like Admin.

Search for all the <data:post.author/> you can find and change all of them into the name you want to display in your blog. Congratulations! well done! do not forget to save your work by clicking the Save Template button on the upper left of the box.

Second: Change or Remove the redirect link when clicking the Author's Name.

After searching for <data:post.author/>.

if you can see <a href="Redirect Site"> <data:post.author/> </a> something like this.

then let us continue.

Remove Redirect Link:

Step 1: Remove or Delete <a href="Redirect Site"> </a> and remain the <data:post.author/> or the Author Name.

Step 2: Save Template! and check it. you can't click the Author Name.

Change Redirect Link:

Step 1: Change the Redirect Site into the site where you want to Redirect whenever clicking the Author's Name.

Step 2: Save Template! and check it. When clicking the Author's Name will Redirect into the Page you put.

Thanks For Reading! Have a Nice Day!

C program to Print Smiley on Screen

noreply@blogger.com (Aditya Narayan Singh) — Fri, 09 Feb 2018 04:04:00 +0000

To print smiling face on the screen in C programming, use the ASCII value of smiling face which is 1.

Following C program ask to the user that how many smiling face he or she want to print on the screen to print the required number of smiling face on the screen:

************Source*Code**************

#include<stdio.h>
#include<conio.h>
void main()
  {
    int sml=1, i, limit;
    printf("How many smiley face you want to print ? ");
    scanf("%d",&limit);
    for(i=0; i<limit; i++)
       {
            printf("%c ",sml);
        }
        getch();
   }

****************Output*****************

screenshot

Best IDE for C/C++ programming

noreply@blogger.com (Aditya Narayan Singh) — Sun, 21 Jan 2018 09:10:00 +0000

Here is a list of some very good C/C++ IDEs. You should select the one which fits your needs. If you are a beginner then try your hands at TurboC++, otherwise take a look at these.

1) CLion

Platforms: Linux, Mac OS X, Windows
JetBrains, a well-known company has created this IDE for C/C++ developers.

Smart editor
Embedded terminal
Various languages and standards: C++11, libc++, boost, JavaScript, XML, HTML and CSS
Keyboard Shortcuts to help you with fast project creating
CMake support
Code analysis

Why it's a number one? Well, because it has a multi-platform support first of all and a has a lot of functions which will help us in developing.

2) Visual Studio

Platforms: Windows

IDE from Microsoft. The only minus about this IDE that it only works with Windows. This IDE is not only for C/C++ developers, but it also includes many popular languages in its list. If you are working with a team then you probably do need a Pro version minimum which is not free. But if you are working alone then you can use Express edition of IDE which is free.

3) Xcode

Platforms: Mac OS X

This IDE is the best choice for Mac users. Probably there are so many programmers who prefer to use a Mac. And again this IDE like the previous one (Visual Studio) is not only for C/C++ developers, there are many other popular languages supported. It is completely free to use. So you get pretty cool features to develop your program with C/C++.

4) Eclipse

Platforms: Linux, Mac OS X, Windows

The second good IDE which has a multi-platform support. It is also open source which is a big plus and completely free.

C/C++ Development Tools
Eclipse Git Team Provider
Mylyn Task List
Remote System Explorer

5) NetBeans IDE

Platforms: Linux, Mac OS X, Windows

Multi-platform, free IDE. Has a lot good feature which can help you in development.

C++11 Support
Qt Toolkit Support
Remote Development
File Navigation
Compiler Configurations

Spiral matrix in C

noreply@blogger.com (Aditya Narayan Singh) — Mon, 15 Jan 2018 13:11:00 +0000

A spiral matrix is a matrix of the type which puts numbers in a circular fashion rather than in row-major or column-major fashion.

This is the spiral matrix in which one has stored value in clockwise and other one in anticlockwise:

******************************Source code**********************************

#include <stdio.h>
 
#define UP 1
#define DOWN 2
#define LEFT 3
#define RIGHT 4
#define MAX 6
 
void main()
{
 
    int initial_direction = UP , n = MAX , p = 1 ;    
    // intial_direction is set to UP because we need to start moving right

    int r ,c , a[MAX][MAX];
    int row_right  = 0 , column_down = n-1 , row_left = n-1 , column_up = 0 ;
 
    //Set all elements of the matrix to 0
    for(r = 0 ; r < MAX ; r++)
    {
        for(c = 0 ; c < MAX ; c++)
        a[r][c] = 0 ;
    }
    //Generate elements of the spiral matrix
    while(p != n*n+1)
    {
          if(initial_direction == UP)
          {
            //Move RIGHT
            r = row_right++ ;
            for(c = 0 ; c < n ; c++)
            {
                if(a[r][c] == 0)
                a[r][c] = p++;
            }
 
            initial_direction = RIGHT ;
          }
          else if(initial_direction == RIGHT)
          {
            //Move down
            c = column_down-- ;
            for(r = 0 ; r < n ; r++)
            {
                if(a[r][c] == 0)
                a[r][c] = p++;
            }
            initial_direction = DOWN ;
 
          }
          else if(initial_direction == DOWN)
          {
            //Move left
            r = row_left-- ;
            for(c = n-1 ; c >= 0 ; c--)
            {
                if(a[r][c] == 0)
                a[r][c] = p++;
 
            }
            initial_direction = LEFT ;
          }
          else if(initial_direction == LEFT)
          {
            //Move up
            c = column_up++;
            for(r = n-1 ; r >= 0 ; r--)
            {
                if(a[r][c] == 0)
                a[r][c] = p++;
            }
            initial_direction = UP ;
          }
 
    }
 
 
    //Print the matrix
    printf("\n\n");
    for(r = 0 ; r < MAX ; r++)
    {
          for(c = 0 ; c < MAX ; c++)
          printf("%4d ",a[r][c]);
          printf("\n");
    }
}
 

********************************Output**********************************

C program to Capitalize the String

noreply@blogger.com (Aditya Narayan Singh) — Fri, 22 Dec 2017 15:50:00 +0000

Capitalize a String or a sentence means to make the first letter of each word upper case.

We try to achieve the same using the C program here

*************************PROGRAM************

#include <stdio.h>
#define MAX 100

int main()
{
 char str[MAX]={0}; 
 int i;
 
 //input string
 printf("Enter a string: ");
 scanf("%[^\n]s",str); //read string with spaces
 
 //capitalize first character of words
 for(i=0; str[i]!='\0'; i++)
 {
  //check first character is lowercase alphabet
  if(i==0)
  {
   if((str[i]>='a' && str[i]<='z'))
    str[i]=str[i]-32; //subtract 32 to make it capital
   continue; //continue to the loop
  }
  if(str[i]==' ')//check space
  {
   //if space is found, check next character
   ++i;
   //check next character is lowercase alphabet
   if(str[i]>='a' && str[i]<='z')
   {
    str[i]=str[i]-32; //subtract 32 to make it capital
    continue; //continue to the loop
   }
  }
  else
  {
   //all other uppercase characters should be in lowercase
   if(str[i]>='A' && str[i]<='Z')
    str[i]=str[i]+32; //subtract 32 to make it small/lowercase
  }
 }
 
 printf("Capitalize string is: %s\n",str);
 
 return 0;
}

*************************OUTPUT*******************************

First run:
Enter a string: HELLO FRIENDS HOW ARE YOU?
Capitalize string is: Hello Friends How Are You?

Second run:
Enter a string: hello friends how are you?
Capitalize string is: Hello Friends How Are You?

Third run:
Enter a string: 10 ways to learn programming.
Capitalize string is: 10 Ways To Learn Programming.

Sum of Two numbers using recursion function in C

noreply@blogger.com (Aditya Narayan Singh) — Sat, 16 Dec 2017 14:35:00 +0000

How to add two number using recursion function in C?

Solution:

#include <stdio.h>

int main(int argc, char *argv[]){

int a,b;

scanf("%d%d",&a,&b);

printf("%d",sum(a,b));

return 0;

}

int sum(int a,int b){

static int s=0;

if(b > 0){

s++;

sum(a,b-1);

}

else if(a>0){

s++;

sum(a-1,b);

}

return s;

}

Reverse string in C without using strrev() function

noreply@blogger.com (Aditya Narayan Singh) — Wed, 04 Oct 2017 14:23:00 +0000

It's a C program that explains how to reverse a given string without using the inbuilt function 'strrev()' which is a part of the #include<string.h> header file.

It is very simple to reverse a string by using strrev() function in c:

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

int main(){
  char *str,*str2;
  str = malloc(sizeof(char*));
  str2 = malloc(sizeof(char*));
  scanf("%s",str);
  str2 = strrev(str);
  printf("Reverse of %s is %s",str,str2);
  return 0;
}

Else you can do it as below without using strrev() function:

#include<stdio.h>

int main(){
  char str[100];
  int i=0,n=0;
  scanf("%s",str);

  while(str[i++]!='\0'){
    n++;
  }

  printf("Reverse of %s is ",str);
  for(i=n-1;i>=0;i--){
     printf("%c",str[i]);
  }
  return 0;
}

In both program you get the same output:
dotcprograms.blogspot.in
Reverse of dotcprograms.blogspot.in is ni.topsgolb.smargorpctod

Dangling Pointer

noreply@blogger.com (Aditya Narayan Singh) — Mon, 18 Sep 2017 14:13:00 +0000

Dangling Pointer

Dangling pointer are the pointer which contain address of no "memory blocks."
In other words dangling pointer arises when the variable are address it is pointing to is freed.
or,
A pointer pointing to non-existing memory location is called dangling pointer.
Dangling pointer points to which is not valid anymore in the program.

How to prevent dangling pointer generation:--

Allocate the pointer another object before deleting the object it is pointing currently.
Don't delete the objects(not a good practice lead to memory blockage though)

Example

main(){

int *p = malloc(sizeof(int));

free (p); /* now the p becomes dangling pointer */

}

Magic square in C

noreply@blogger.com (Aditya Narayan Singh) — Thu, 09 Apr 2015 08:36:00 +0000

A magic square is a

n\times n

square grid (where

n

is the number of cells on each side) filled with distinct positive integers in the range

1,2,...,n^{2}

such that each cell contains a different integer and the sum of the integers in each row, column and diagonal is equal. The sum is called the magic constant or magic sum of the magic square. A square grid with

n

cells on each side is said to have order n.

The mathematical study of magic squares typically deals with its construction, classification, and enumeration. Although completely general methods for producing all the magic squares of all orders do not exist, historically three general techniques have been discovered: by bordering method, by making composite magic squares, and by adding two preliminary squares. There are also more specific strategies like the continuous enumeration method that reproduces specific patterns. The magic squares are generally classified according to their order n as: odd if n is odd, evenly even (also referred to as doubly even) if n = 4k (e.g. 4, 8, 12, and so on), oddly even (also known as singly even) if n = 4k + 2 (e.g. 6, 10, 14, and so on). This classification is based on different techniques required to construct odd, evenly even, and oddly even squares. Beside this, depending on further properties, magic squares are also classified as pan-diagonal magic squares and most-perfect magic square. More challengingly, attempts have also been made to classify all the magic squares of a given order as transformations of a smaller set of squares. Except for n ≤ 5, the enumeration of higher order magic squares is still an open challenge. The enumeration of pan-diagonal magic squares of any order was only accomplished in the late 20th century.

************************************Program**************************************

#include<stdio.h>
#include<conio.h>
main()
{
    int i,c,n,r;

    /* We get the range of matrix in variable n and use
       to set the range for magic square box  */

    printf("Enter the range of magic square\n");
    scanf("%d",&n);
    int arr[n][n];

    /*   In first for loop we use to arrange the elements
         on the equations of magic square box     */


    for(i=1;i<=n*n;i++)
    {
        r=(n-i%n+1+2*((i-1)/n))%n;    // for row  //
        c=((n-1)/2+i-1-(i-1)/n)%n;   // for column //
        arr[r][c]=i;
    }

    /*    Here we print the generated magic square box using nested for loops   */


    for(r=0;r<n;r++)
    {
        for(c=0;c<n;c++)
        {
            printf("%d\t",arr[r][c]);
        }
        printf("\n");
    }
    getch();
}

************************************Output***************************************

How to Merge Two matrix in C

noreply@blogger.com (Aditya Narayan Singh) — Wed, 01 Apr 2015 03:18:00 +0000

By merging property in C we are able to merge(mix) two are more matrix in a single matrix one after one in a known sequence, for this we have to declare a array variable of size equal to the size of arrays variable that are to be merged
example: –int a[5]={1,2,3,4,5},b[5]={6,7,8,9,1};

int c[10];
that means if we want to merge matrix of array a[5] and matrix of array b[5] then we have to declare a matrix i.e. of size equal to 5+5 means a array of size 10, so here c[10]. Now come to the example:-

******************************Program*********************************

#include<stdio.h>
#include<conio.h>
main()
{
    int arr1[5]={1,2,3,4,5},arr2[5]={6,7,8,9,10};
    int arr3[10],i,k=0;

    printf("1st matrix:\n");
    for(i=0;i<5;i++)
    {
        printf("%d ",arr1[i]);
    }
    printf("\n2nd matrix:\n");
    for(i=0;i<5;i++)
    {
        printf("%d ",arr2[i]);
    }

    for(i=0;i<10;i++)
    {
        if(i>4)
        {
            arr3[i]=arr2[k];
            k=k+1;
        }
        else
        {
            arr3[i]=arr1[i];
        }

    }
    i=0;
    printf("\nMatrix after merging:\n");
    while(i<10)
    {
        printf("%d ",arr3[i]);
        i++;
    }
    getch();
}

*************************************Output*****************************

Output of matrix merging

Technorati Tags: C questions,array in c

C program for calculating Geometric Progression (GP)

noreply@blogger.com (Aditya Narayan Singh) — Thu, 19 Mar 2015 15:08:00 +0000

In mathematics, a geometric progression, also known as a geometric sequence, is a sequence of numbers where each term after the first is found by multiplying the previous one by a fixed, non-zero number called the common ratio. For example, the sequence 2, 6, 18, 54, ... is a geometric progression with common ratio 3. Similarly 10, 5, 2.5, 1.25, ... is a geometric sequence with common ratio 1/2.

Examples of a geometric sequence are powers r^k of a fixed number r, such as 2^k and 3^k. The general form of a geometric sequence is

where r ≠ 0 is the common ratio and a is a scale factor, equal to the sequence's start value.

************************************************************Program***********************************************************

#include<stdio.h>
#include<conio.h>
main()
{
    int a,n,r,t;
    printf("Enter the first term of your GP : ");
    scanf("%d",&a);
    printf("Enter the ratio(r) : ");
    scanf("%d",&r);
    printf("Enter the number of terms you want to get in your GP : ");
    scanf("%d",&n);
    printf("GP of your given data is :\n%d ",a);
    while(n>=0)
    {
        t=a*r;
        printf("%d ",t);
        a=t;
        n--;
    }
    getch();
}

************************************************************Output**************************************************************

Output for GP in C

C program for Arithmetic Progression calculation

noreply@blogger.com (Aditya Narayan Singh) — Wed, 18 Mar 2015 16:38:00 +0000

An arithmetic progression is a sequence of numbers such that the difference of any two successive members of the sequence is a constant. For example, the sequence 1, 2, 3, 4, ... is is an arithmetic progression with common difference 1.

***************************************Program***********************************

#include<stdio.h>
#include<conio.h>
main()
{
    int a,n,d,t;
    printf("Enter the first term of your AP : ");
    scanf("%d",&a);
    printf("Enter the difference b/w terms : ");
    scanf("%d",&d);
    printf("Enter the number of terms you want to get in your AP : ");
    scanf("%d",&n);
    printf("AP of your given data is :\n%d ",a);
    while(n>=0)
    {
        t=a+d;
        printf("%d ",t);
        a=t;
        n--;
    }
    getch();
}

***************************************Output************************************

Output of AP program in C

C Programs

Which language should be preferred for learning data structures considering campus placements?

C program to implement linked list using struct

5 Tips we should follow to learn programming languages faster and better

1. Study with the aid of doing

2. Draw close the principles

3. Code by way of hand

4. Request for assistance

5. Online possessions

Most used UNIX commands

chmod in UNIX

Commands for changing Premission in UNIX:

chmod commands :

C program for Doubly Linked List

C program for Singly Linked list

C program for Bisection Method

Arduino - Robot using C program

Connecting the robot to your computer

Installing the drivers

OSX

Windows

Uploading a test sketch

Moving the Robot

Read the buttons

Change the motor speed with the potentiometer

Making some noise

Next steps

File reading & writing in C with different modes

1. Opening a file

Various File Opening Modes:

2. Reading a File

C Program to read a file

3. Writing to a file

Example: C Program to write the file

4. Closing a file

An example to show Open, read, write and close operation in C

Tic Tac Toe game using C program

************Source Code***********

Output:

Prim’s Algorithm in C

Algorithm

C program for kruskal’s algorithm

Kruskal’s Algorithm

How to change post author name in blogger

First: How to change the Author's Name.

Second: Change or Remove the redirect link when clicking the Author's Name.

C program to Print Smiley on Screen

Best IDE for C/C++ programming

Spiral matrix in C

A spiral matrix is a matrix of the type which puts numbers in a circular fashion rather than in row-major or column-major fashion.

This is the spiral matrix in which one has stored value in clockwise and other one in anticlockwise:

C program to Capitalize the String

Sum of Two numbers using recursion function in C

Reverse string in C without using strrev() function

Dangling Pointer

Magic square in C

How to Merge Two matrix in C

C program for calculating Geometric Progression (GP)

C program for Arithmetic Progression calculation

**Source Code*