This tutorial gives an introduction to different types of programming languages. It also covers the definition of Compilers, Interpretors, Assemblers etc. It also creates the very first C Program thereby showing the structure of a simple C Program. This tutorial is one of the sequence of C Programming Tutorials. Please make sure you watch the videos that come before this and also the ones that come after this one.

We hope you all have enjoyed the video tutorial . If you have any queries ask us in form of comments. Thanks for watching !

The post C programming video tutorial 2 | Introduction to Programming Languages appeared first on C codechamp.

Learning through backpropagation :

Learning occurs in the perceptron by changing connection weights after each piece of data is processed, based on the amount of error in the output compared to the expected result. This is an example of supervised learning, and is carried out through backpropagation, a generalization of the least mean squares algorithm in the linear perceptron.

We represent the error in output node in the th data point by , where is the target value and is the value produced by the perceptron. We then make corrections to the weights of the nodes based on those corrections which minimize the error in the entire output, given by

.

Using gradient descent, we find our change in each weight to be

where is the output of the previous neuron and is the learning rate, which is carefully selected to ensure that the weights converge to a response fast enough, without producing oscillations. In programming applications, this parameter typically ranges from 0.2 to 0.8.

The derivative to be calculated depends on the induced local field , which itself varies. It is easy to prove that for an output node this derivative can be simplified to

where is the derivative of the activation function described above, which itself does not vary. The analysis is more difficult for the change in weights to a hidden node, but it can be shown that the relevant derivative is

.

This depends on the change in weights of the th nodes, which represent the output layer. So to change the hidden layer weights, we must first change the output layer weights according to the derivative of the activation function, and so this algorithm represents a backpropagation of the activation function.

Now let us see how we can implement above logic using C programming skills. First of all basic information about functions that we will use in the C program of Multilayer Perceptron Net using Backpropagation.

Functions used in Multilayer Perceptron C Program  :

void createNet( int noOfLayers, int *noOfNeurons, int *noOfInputs, char *axonFamilies, double *actFuncFlatnesses, int initWeights )
->++—>>> Creates the net using given parameters where

• noOfLayers: Total no. of layers, excluding input layer.
• noOfNeurons: No. of neurons for each layer.
• noOfInputs: No. of inputs for each layer.
• axonFamilies: Transfer function. Can be ‘g’ (logistic), ‘t’ (tanh) or ‘l’ (linear) ; for each layer.
• actFuncFlatness: Flatness of the transfer functions for each layer.
• initWeights: ’1′ will initialize weights with random values, ’0′ will not. You should use ’1′ for practical use.

void feedNetInputs(double *inputs)
->++—>>>  Feeds the net with given input values

void updateNetOutput( )
->++—>>> Updates the output of the NETWORK

void trainNet ( double learningRate, double momentumRate, int batch, double *outputTargets )
->++—>>> Trains the net where

• learningRate: Should be between 0.0 and 1.0 (both excluded)
• momentumRate: Should be between 0.0 and 1.0 (both excluded)
• batch: Tells the function whether this will be a batch (1) or incremental (0) training.
• outputTargets: Output

void applyBatchCumulations( double learningRate, double momentumRate )
->++—>>>  Calculates batch cumulations and updates weights accordingly. The net must be trained more than one time in batch mode before using this function where

• learningRate: Should be between 0.0 and 1.0 (both excluded)
• momentumRate: Should be between 0.0 and 1.0 (both excluded)

double *getOutputs()
->++—>>>  The one that should be used for obtaining the net’s outputs.

int loadNet(char *path)
->++—>>> Returns 0 if the operation is successful, 1 if not.

 int main() :
You can code whatever you wish to implement using Multilayer Perceptron Net. In this you will write what you want to teach to Computer using Neural Network . We have taken a simple example  which  Create a Multilayer Perceptron net with two hidden layers. It takes two inputs, passes them through two hidden layers with 5 and 3 neurons, and an output layer with two neurons. Hidden layers use logistic activation, output layer uses tanh function, We try to train the net so that it learns how to sum two input values and output the sin() and cos() values of that sum; like   y0 = sin( x0 + x1 )    y1 = cos( x0 + x1 )  ; even though we know that it’s silly and practically useless to do so, when it’s far easier to calculate them using existing C libraries, We use batch training, with 100,000 total loops, each using random inputs between -1 and 1; applying batch changes and updating weights every 100 loops, Apply a test with 40 sets of inputs generated randomly again and show the results.
Lets see C program of Multilayer Perceptron Net using backpropagation. I used Dev C++ to Execute this code. When you use Turbo C++ you might need to include malloc.h header directive.

C program of Multilayer Perceptron using Backpropagation Neural Networks :

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

#define MAX_NO_OF_LAYERS 3
#define MAX_NO_OF_INPUTS 2
#define MAX_NO_OF_NEURONS 10
#define MAX_NO_OF_WEIGHTS 31
#define MAX_NO_OF_OUTPUTS 2

void createNet( int, int *, int *, char *, double *, int );
void feedNetInputs(double *);
void updateNetOutput(void);
double *getOutputs();
void trainNet ( double, double, int, double * );
void applyBatchCumulations( double, double );
int loadNet(char *);
int saveNet(char *);
double getRand();

struct neuron{
    double *output;
    double threshold;
    double oldThreshold;
    double batchCumulThresholdChange;
    char axonFamily;
    double *weights;
    double *oldWeights;
    double *netBatchCumulWeightChanges;
    int noOfInputs;
    double *inputs;
    double actFuncFlatness;
    double *error;
};

struct layer {
    int noOfNeurons;
    struct neuron * neurons;
};

static struct neuralNet {
    int noOfInputs;
    double *inputs;
    double *outputs;
    int noOfLayers;
    struct layer *layers;
    int noOfBatchChanges;
} theNet;

double getRand() {

    return (( (double)rand() * 2 ) / ( (double)RAND_MAX + 1 ) ) - 1;

}

static struct neuron netNeurons[MAX_NO_OF_NEURONS];
static double netInputs[MAX_NO_OF_INPUTS];
static double netNeuronOutputs[MAX_NO_OF_NEURONS];
static double netErrors[MAX_NO_OF_NEURONS];
static struct layer netLayers[MAX_NO_OF_LAYERS];
static double netWeights[MAX_NO_OF_WEIGHTS];
static double netOldWeights[MAX_NO_OF_WEIGHTS];
static double netBatchCumulWeightChanges[MAX_NO_OF_WEIGHTS];

void createNet( int noOfLayers, int *noOfNeurons, int *noOfInputs, char *axonFamilies, double *actFuncFlatnesses, int initWeights ) {

    int i, j, counter, counter2, counter3, counter4;
    int totalNoOfNeurons, totalNoOfWeights;

    theNet.layers = netLayers;
    theNet.noOfLayers = noOfLayers;
    theNet.noOfInputs = noOfInputs[0];
    theNet.inputs = netInputs;

    totalNoOfNeurons = 0;
    for(i = 0; i < theNet.noOfLayers; i++) {
        totalNoOfNeurons += noOfNeurons[i];
    }
    for(i = 0; i < totalNoOfNeurons; i++) { netNeuronOutputs[i] = 0; }

    totalNoOfWeights = 0;
    for(i = 0; i < theNet.noOfLayers; i++) {
        totalNoOfWeights += noOfInputs[i] * noOfNeurons[i];
    }

    counter = counter2 = counter3 = counter4 = 0;
    for(i = 0; i < theNet.noOfLayers; i++) {
        for(j = 0; j < noOfNeurons[i]; j++) {
            if(i == theNet.noOfLayers-1 && j == 0) { // beginning of the output layer
                theNet.outputs = &netNeuronOutputs[counter];
            }
            netNeurons[counter].output = &netNeuronOutputs[counter];
            netNeurons[counter].noOfInputs = noOfInputs[i];
            netNeurons[counter].weights = &netWeights[counter2];
            netNeurons[counter].netBatchCumulWeightChanges = &netBatchCumulWeightChanges[counter2];
            netNeurons[counter].oldWeights = &netOldWeights[counter2];
            netNeurons[counter].axonFamily = axonFamilies[i];
            netNeurons[counter].actFuncFlatness = actFuncFlatnesses[i];
            if ( i == 0) {
                netNeurons[counter].inputs = netInputs;
            }
            else {
                netNeurons[counter].inputs = &netNeuronOutputs[counter3];
            }
            netNeurons[counter].error = &netErrors[counter];
            counter2 += noOfInputs[i];
            counter++;
        }
        netLayers[i].noOfNeurons = noOfNeurons[i];
        netLayers[i].neurons = &netNeurons[counter4];
        if(i > 0) {
            counter3 += noOfNeurons[i-1];
        }
        counter4 += noOfNeurons[i];
    }

    // initialize weights and thresholds
     if ( initWeights == 1 ) {
        for( i = 0; i < totalNoOfNeurons; i++) { netNeurons[i].threshold = getRand(); }
        for( i = 0; i < totalNoOfWeights; i++) { netWeights[i] = getRand(); }
        for( i = 0; i < totalNoOfWeights; i++) { netOldWeights[i] = netWeights[i]; }
        for( i = 0; i < totalNoOfNeurons; i++) { netNeurons[i].oldThreshold = netNeurons[i].threshold; }
    }

    // initialize batch values
    for( i = 0; i < totalNoOfNeurons; i++) { netNeurons[i].batchCumulThresholdChange = 0; }
    for( i = 0; i < totalNoOfWeights; i++) { netBatchCumulWeightChanges[i] = 0; }
    theNet.noOfBatchChanges = 0;

}

void feedNetInputs(double *inputs) {
     int i;
     for ( i = 0; i < theNet.noOfInputs; i++ ) {
        netInputs[i] = inputs[i];
     }
}

static void updateNeuronOutput(struct neuron * myNeuron) {

    double activation = 0;
    int i;

    for ( i = 0; i < myNeuron->noOfInputs; i++) {
        activation += myNeuron->inputs[i] * myNeuron->weights[i];
    }
    activation += -1 * myNeuron->threshold;
    double temp;
    switch (myNeuron->axonFamily) {
        case 'g': // logistic
            temp = -activation / myNeuron->actFuncFlatness;
            /* avoid overflow */
            if ( temp > 45 ) {
                *(myNeuron->output) = 0;
            }
            else if ( temp < -45 ) {
                *(myNeuron->output) = 1;
            }
            else {
                *(myNeuron->output) = 1.0 / ( 1 + exp( temp ));
            }
            break;
        case 't': // tanh
            temp = -activation / myNeuron->actFuncFlatness;
            /* avoid overflow */
            if ( temp > 45 ) {
                *(myNeuron->output) = -1;
            }
            else if ( temp < -45 ) {
                *(myNeuron->output) = 1;
            }
            else {
                *(myNeuron->output) = ( 2.0 / ( 1 + exp( temp ) ) ) - 1;
            }
            break;
        case 'l': // linear
            *(myNeuron->output) = activation;
            break;
        default:
            break;
    }

}

void updateNetOutput( ) {

    int i, j;

    for(i = 0; i < theNet.noOfLayers; i++) {
        for( j = 0; j < theNet.layers[i].noOfNeurons; j++) {
            updateNeuronOutput(&(theNet.layers[i].neurons[j]));
        }
    }

}

static double derivative (struct neuron * myNeuron) {

    double temp;
    switch (myNeuron->axonFamily) {
        case 'g': // logistic
            temp = ( *(myNeuron->output) * ( 1.0 - *(myNeuron->output) ) ) / myNeuron->actFuncFlatness; break;
        case 't': // tanh
            temp = ( 1 - pow( *(myNeuron->output) , 2 ) ) / ( 2.0 * myNeuron->actFuncFlatness ); break;
        case 'l': // linear
            temp = 1; break;
        default:
            temp = 0; break;
    }
    return temp;

}

// learningRate and momentumRate will have no effect if batch mode is 'on'
void trainNet ( double learningRate, double momentumRate, int batch, double *outputTargets ) {

    int i,j,k;
    double temp;
    struct layer *currLayer, *nextLayer;

     // calculate errors
    for(i = theNet.noOfLayers - 1; i >= 0; i--) {
        currLayer = &theNet.layers[i];
        if ( i == theNet.noOfLayers - 1 ) { // output layer
            for ( j = 0; j < currLayer->noOfNeurons; j++ ) {
                *(currLayer->neurons[j].error) = derivative(&currLayer->neurons[j]) * ( outputTargets[j] - *(currLayer->neurons[j].output));
            }
        }
        else { // other layers
            nextLayer = &theNet.layers[i+1];
            for ( j = 0; j < currLayer->noOfNeurons; j++ ) {
                temp = 0;
                for ( k = 0; k < nextLayer->noOfNeurons; k++ ) {
                    temp += *(nextLayer->neurons[k].error) * nextLayer->neurons[k].weights[j];
                }
                *(currLayer->neurons[j].error) = derivative(&currLayer->neurons[j]) * temp;
            }
        }
    }

    // update weights n thresholds
    double tempWeight;
    for(i = theNet.noOfLayers - 1; i >= 0; i--) {
        currLayer = &theNet.layers[i];
        for ( j = 0; j < currLayer->noOfNeurons; j++ ) {

            // thresholds
            if ( batch == 1 ) {
                    currLayer->neurons[j].batchCumulThresholdChange += *(currLayer->neurons[j].error) * -1;
            }
            else {
                tempWeight = currLayer->neurons[j].threshold;
                currLayer->neurons[j].threshold += ( learningRate * *(currLayer->neurons[j].error) * -1 ) + ( momentumRate * ( currLayer->neurons[j].threshold - currLayer->neurons[j].oldThreshold ) );
                currLayer->neurons[j].oldThreshold = tempWeight;
            }

            // weights
            if ( batch == 1 ) {
                for( k = 0; k < currLayer->neurons[j].noOfInputs; k++ ) {
                    currLayer->neurons[j].netBatchCumulWeightChanges[k] +=  *(currLayer->neurons[j].error) * currLayer->neurons[j].inputs[k];
                }
            }
            else {
                for( k = 0; k < currLayer->neurons[j].noOfInputs; k++ ) {
                    tempWeight = currLayer->neurons[j].weights[k];
                    currLayer->neurons[j].weights[k] += ( learningRate * *(currLayer->neurons[j].error) * currLayer->neurons[j].inputs[k] ) + ( momentumRate * ( currLayer->neurons[j].weights[k] - currLayer->neurons[j].oldWeights[k] ) );
                    currLayer->neurons[j].oldWeights[k] = tempWeight;
                }
            }

        }
    }

    if(batch == 1) {
        theNet.noOfBatchChanges++;
    }

}

void applyBatchCumulations( double learningRate, double momentumRate ) {

    int i,j,k;
    struct layer *currLayer;
    double tempWeight;

    for(i = theNet.noOfLayers - 1; i >= 0; i--) {
        currLayer = &theNet.layers[i];
        for ( j = 0; j < currLayer->noOfNeurons; j++ ) {
            // thresholds
            tempWeight = currLayer->neurons[j].threshold;
            currLayer->neurons[j].threshold += ( learningRate * ( currLayer->neurons[j].batchCumulThresholdChange / theNet.noOfBatchChanges ) ) + ( momentumRate * ( currLayer->neurons[j].threshold - currLayer->neurons[j].oldThreshold ) );
            currLayer->neurons[j].oldThreshold = tempWeight;
            currLayer->neurons[j].batchCumulThresholdChange = 0;
            // weights
            for( k = 0; k < currLayer->neurons[j].noOfInputs; k++ ) {
                tempWeight = currLayer->neurons[j].weights[k];
                currLayer->neurons[j].weights[k] += ( learningRate * ( currLayer->neurons[j].netBatchCumulWeightChanges[k] / theNet.noOfBatchChanges ) ) + ( momentumRate * ( currLayer->neurons[j].weights[k] - currLayer->neurons[j].oldWeights[k] ) );
                currLayer->neurons[j].oldWeights[k] = tempWeight;
                currLayer->neurons[j].netBatchCumulWeightChanges[k] = 0;
            }
        }
    }

    theNet.noOfBatchChanges = 0;

}

double *getOutputs() {

    return theNet.outputs;

}

int loadNet(char *path) {

    int tempInt; double tempDouble; char tempChar;
    int i, j, k;

    int noOfLayers;
    int noOfNeurons[MAX_NO_OF_LAYERS];
    int noOfInputs[MAX_NO_OF_LAYERS];
    char axonFamilies[MAX_NO_OF_LAYERS];
    double actFuncFlatnesses[MAX_NO_OF_LAYERS];

    FILE *inFile;

    if(!(inFile = fopen(path, "rb")))
    return 1;

    fread(&tempInt,sizeof(int),1,inFile);
    noOfLayers = tempInt;

    for(i = 0; i < noOfLayers; i++) {

        fread(&tempInt,sizeof(int),1,inFile);
        noOfNeurons[i] = tempInt;

        fread(&tempInt,sizeof(int),1,inFile);
        noOfInputs[i] = tempInt;

        fread(&tempChar,sizeof(char),1,inFile);
        axonFamilies[i] = tempChar;

        fread(&tempDouble,sizeof(double),1,inFile);
        actFuncFlatnesses[i] = tempDouble;

    }

    createNet(noOfLayers, noOfNeurons, noOfInputs, axonFamilies, actFuncFlatnesses, 0);

    // now the weights
    for(i = 0; i < noOfLayers; i++) {
        for (j = 0; j < noOfNeurons[i]; j++) {
            fread(&tempDouble,sizeof(double),1,inFile);
            theNet.layers[i].neurons[j].threshold = tempDouble;
            for ( k = 0; k < noOfInputs[i]; k++ ) {
                fread(&tempDouble,sizeof(double),1,inFile);
                theNet.layers[i].neurons[j].weights[k] = tempDouble;
            }
        }
    }

    fclose(inFile);

    return 0;

}

int main() {

    double inputs[MAX_NO_OF_INPUTS];
    double outputTargets[MAX_NO_OF_OUTPUTS];

    /* determine layer paramaters */
    int noOfLayers = 3; // input layer excluded
    int noOfNeurons[] = {5,3,2};
    int noOfInputs[] = {2,5,3};
    char axonFamilies[] = {'g','g','t'};
    double actFuncFlatnesses[] = {1,1,1};

    createNet(noOfLayers, noOfNeurons, noOfInputs, axonFamilies, actFuncFlatnesses, 1);

    /* train it using batch method */
    int i;
    double tempTotal;
    int counter = 0;
    for(i = 0; i < 100000; i++) {
        inputs[0] = getRand();
        inputs[1] = getRand();
        tempTotal = inputs[0] + inputs[1];
        feedNetInputs(inputs);
        updateNetOutput();
        outputTargets[0] = (double)sin(tempTotal);
        outputTargets[1] = (double)cos(tempTotal);
        /* train using batch training ( don't update weights, just cumulate them ) */
        trainNet(0, 0, 1, outputTargets);
        counter++;
        /* apply batch changes after 1000 loops use .8 learning rate and .8 momentum */
        if(counter == 100) { applyBatchCumulations(.8,.8); counter = 0;}
    }

    /* test it */
    double *outputs;
    printf("Sin Target \t Output \t Cos Target \t Output\n");
    printf("---------- \t -------- \t ---------- \t --------\n");
    for(i = 0; i < 50; i++) {
        inputs[0] = getRand();
        inputs[1] = getRand();
        tempTotal = inputs[0] + inputs[1];
        feedNetInputs(inputs);
        updateNetOutput();
        outputs = getOutputs();
        printf( "%f \t %f \t %f \t %f \n", sin(tempTotal), outputs[0], cos(tempTotal), outputs[1]);
    }
    getch();
    return 0;

}

Output of the Program :

Sin Target       Output          Cos Target      Output
———-       ——–        ———-      ——–
-0.282596        -0.251506       0.959239        0.926403
0.987397         0.929951        0.158263        0.134966
-0.742784        -0.767919       0.669531        0.702895
0.963356         0.951930        -0.268225       -0.092782
-0.910491        -0.891614       0.413529        0.392311
-0.446427        -0.435320       0.894820        0.894715
-0.781594        -0.803610       0.623788        0.646886
0.290957         0.265966        0.956736        0.930159
-0.809212        -0.825646       0.587516        0.602877
-0.736788        -0.761619       0.676123        0.711298
-0.998244        -0.947075       -0.059235       -0.001200
0.387922         0.371767        0.921692        0.915250
0.994482         0.934887        0.104905        0.091594
0.755998         0.785001        0.654574        0.683916
-0.188741        -0.161969       0.982027        0.937597
-0.493026        -0.488288       0.870015        0.882922
-0.440519        -0.424683       0.897743        0.899018
-0.852693        -0.855158       0.522413        0.527307
-0.140706        -0.128390       0.990051        0.940160
0.189161         0.167637        0.981946        0.938250
0.996926         0.936743        0.078345        0.074192
-0.424008        -0.411728       0.905658        0.902929
0.653792         0.669850        0.756674        0.806735
0.003967         -0.012354       0.999992        0.944188
0.170850         0.132011        0.985297        0.940968
-0.417585        -0.398821       0.908638        0.903615
0.001099         0.006551        0.999999        0.943892
0.306393         0.282745        0.951905        0.928428
-0.995529        -0.938210       0.094459        0.087609
-0.299005        -0.266307       0.954252        0.925483
-0.041004        -0.027936       0.999159        0.942476
0.809427         0.827636        0.587220        0.601242
0.474114         0.471661        0.880463        0.893326
0.621403         0.638472        0.783491        0.827109
0.097623         0.087701        0.995224        0.941710
0.220047         0.196894        0.975489        0.936800
-0.520229        -0.522084       0.854027        0.870829
0.865589         0.866682        0.500755        0.487957
-0.582818        -0.594292       0.812603        0.843467
-0.996864        -0.940069       0.079136        0.070250
0.118071         0.094599        0.993005        0.942999
0.481941         0.472472        0.876204        0.893215
-0.119829        -0.107898       0.992795        0.941339
-0.682174        -0.706359       0.731189        0.770417
-0.022764        -0.028302       0.999741        0.944128
-0.977695        -0.927944       0.210029        0.174750
-0.022764        -0.026860       0.999741        0.944174
0.998870         0.938790        0.047524        0.053881
0.205854         0.179691        0.978583        0.938419
-0.660372        -0.684212       0.750939        0.788505

We hope you all have enjoyed the C program of Multilayer Perceptron using Backpropagation Neural Networks. If you have any issue with the program or logic ask us in form of comment.

References :

1. Wikipedia ( Read for more details about Multilayer Perceptron and learning technique and activation function)

2. Ncorpus

The post C Program of Multilayer Perceptron Net using Backpropagation appeared first on C codechamp.

Simple Logic of Sorting Strings in Alphabetical Order or Lexicographical order is below :

for (i=0;i<m;i++)
for (j=i+1;j<m+1;j++)
{
if (strcmp(a[i],a[j])>0)
{
strcpy(temp,a[i]);
strcpy(a[i],a[j]);
strcpy(a[j],temp);
}
}

Now let us see how to write a C Program to print strings in alphabetical order.

C program to Print Strings in Alphabetical Order :

#include <stdio.h>
#include <string.h>
#include <conio.h>
int main()
{
char a[50][50],temp[100];
int i,j,m,n;
printf("Enter the number of elements you wish to order : ");
scanf("%d",&m);
printf("\nEnter the names :\n");
for (i=0;i<m+1;i++)
gets(a[i]);
for (i=0;i<m;i++)
for (j=i+1;j<m+1;j++)
{
if (strcmp(a[i],a[j])>0)
{
strcpy(temp,a[i]);
strcpy(a[i],a[j]);
strcpy(a[j],temp);
}
}
printf("\n\nSorted strings are : ");
for (i=0;i<m+1;i++)
puts (a[i]);
getch();
}

 Output of the Program :

Enter the number of elements you wish to order : 4

Enter the names :
Lokesh Singh
Rahul Sinha
Rahul Gupta
Ajay Singh

Sorted strings are :
Ajay Singh
Lokesh Singh
Rahul Gupta
Rahul Sinha

We hope you all have enjoyed the C program of Printing Strings into Lexicographical order or Alphabetical order. If you have any doubts or issues ask us in form of comments.

The post C Program to print strings in alphabetical order appeared first on C codechamp.

Logic to concatenate two strings : Say str1[50] and str2[50] are two input string arrays and str[100] will store concatenated string. Now we will store str1[50] into str[100] until null string ‘\0′ is encountered and then from next location start storing str2[50] until null string ‘\0′ is encountered.

Now let us see how to write a C program to concatenate two strings using Arrays.

C Program to Concatenate two Strings using arrays :

#include<stdio.h>
#include<string.h>
#include<conio.h>
int main()
{
char str1[50],str2[50],str[100];
int i=0,j=0,k=0;
printf ("Enter first string : ");
gets (str1);
printf ("\n\nEnter second string : ");
gets (str2);
while (str1[i]!='\0')
{
str[k++]=str1[i++];
}
while (str2[j]!='\0')
{
str[k++]=str2[j++];
}
str[k]='\0';
printf("\n\nThe concatenated string is : ");
puts (str);
getch();
}

 Output of the program :

Enter first string : Lokesh is owner of

Enter second string : Ccodechamp

The concatenated string is : Lokesh is owner of Ccodechamp

We hope you all have enjoyed the C program to Concatenate two strings using arrays. If you have any doubt ask us in form of comments.

The post C Program to Concatenate two Strings using Arrays appeared first on C codechamp.

A     =

1      2     3

4      5     6

Now Transpose of Matrix A   will be,A^T  =

#include <stdio.h>
#include <conio.h> 
int main()
{
   int m, n, c, d, matrix[10][10], transpose[10][10];

   printf("Enter number of rows and columns of matrix :- ");
   scanf("%d%d",&m,&n);
   printf("\nEnter the elements of [%d x %d] matrix :- \n",m,n);
 /*Get Elements of matrix*/
   for( c = 0 ; c < m ; c++ )
   {
      for( d = 0 ; d < n ; d++ )
      {
         scanf("%d",&matrix[c][d]);
      }
   }
 /*Printing Entered Matrix*/
  printf("\nEntered Matrix is :- \n");
  for( c = 0 ; c < m ; c++ )
   {
      for( d = 0 ; d < n ; d++ )
      {
         printf("%d\t",matrix[c][d]);
      }
      printf("\n"); 
   }
 /*Transpose Matrix */  
   for( c = 0 ; c < m ; c++ )
   {
      for( d = 0 ; d < n ; d++ )
      {
         transpose[d][c] = matrix[c][d];
      }
   }
 /* Printing Transpose Matrix*/
   printf("\n\n\nTranspose of entered matrix :-\n");

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

The post C program of Transpose of Matrix | Matrix Programs in C appeared first on C codechamp.

Basic of Huffman Coding :

Huffman coding is a lossless data compression algorithm. The idea is to assign variable-legth codes to input characters, lengths of the assigned codes are based on the frequencies of corresponding characters. The most frequent character gets the smallest code and the least frequent character gets the largest code.
The variable-length codes assigned to input characters are Prefix Codes, means the codes (bit sequences) are assigned in such a way that the code assigned to one character is not prefix of code assigned to any other character. This is how Huffman Coding makes sure that there is no ambiguity when decoding the generated bit stream.
Let us understand prefix codes with a counter example. Let there be four characters a, b, c and d, and their corresponding variable length codes be 00, 01, 0 and 1. This coding leads to ambiguity because code assigned to c is prefix of codes assigned to a and b. If the compressed bit stream is 0001, the de-compressed output may be “cccd” or “ccb” or “acd” or “ab”.

There are mainly two major parts in Huffman Coding
1) Build a Huffman Tree from input characters.
2) Traverse the Huffman Tree and assign codes to characters.

Steps to build Huffman Tree
Input is array of unique characters along with their frequency of occurrences and output is Huffman Tree.

1. Create a leaf node for each unique character and build a min heap of all leaf nodes (Min Heap is used as a priority queue. The value of frequency field is used to compare two nodes in min heap. Initially, the least frequent character is at root)

2. Extract two nodes with the minimum frequency from the min heap.

3. Create a new internal node with frequency equal to the sum of the two nodes frequencies. Make the first extracted node as its left child and the other extracted node as its right child. Add this node to the min heap.

4. Repeat steps#2 and #3 until the heap contains only one node. The remaining node is the root node and the tree is complete.

Let us understand the algorithm with an example:

character   Frequency
    a	        5
    b           9
    c           12
    d           13
    e           16
    f           45

Step 1. Build a min heap that contains 6 nodes where each node represents root of a tree with single node.

Step 2 Extract two minimum frequency nodes from min heap. Add a new internal node with frequency 5 + 9 = 14.

Now min heap contains 5 nodes where 4 nodes are roots of trees with single element each, and one heap node is root of tree with 3 elements

character           Frequency
       c               12
       d               13
 Internal Node         14
       e               16
       f                45

Step 3: Extract two minimum frequency nodes from heap. Add a new internal node with frequency 12 + 13 = 25



Now min heap contains 4 nodes where 2 nodes are roots of trees with single element each, and two heap nodes are root of tree with more than one nodes.

character           Frequency
Internal Node          14
       e               16
Internal Node          25
       f               45

Step 4: Extract two minimum frequency nodes. Add a new internal node with frequency 14 + 16 = 30


Now min heap contains 3 nodes.

character          Frequency
Internal Node         25
Internal Node         30
      f               45 

Step 5: Extract two minimum frequency nodes. Add a new internal node with frequency 25 + 30 = 55


Now min heap contains 2 nodes.

character     Frequency
       f         45
Internal Node    55

Step 6: Extract two minimum frequency nodes. Add a new internal node with frequency 45 + 55 = 100


Now min heap contains only one node.

character      Frequency
Internal Node    100

Since the heap contains only one node, the algorithm stops here.

Steps to print codes from Huffman Tree:
Traverse the tree formed starting from the root. Maintain an auxiliary array. While moving to the left child, write 0 to the array. While moving to the right child, write 1 to the array. Print the array when a leaf node is encountered.

The codes are as follows:

character   code-word
    f          0
    c          100
    d          101
    a          1100
    b          1101
    e          111

C Program of Huffman coding using Greedy Algorithm Approach :

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

// This constant can be avoided by explicitly calculating height of Huffman Tree
#define MAX_TREE_HT 100

// A Huffman tree node
struct MinHeapNode
{
    char data;  // One of the input characters
    unsigned freq;  // Frequency of the character
    struct MinHeapNode *left, *right; // Left and right child of this node
};

// A Min Heap:  Collection of min heap (or Hufmman tree) nodes
struct MinHeap
{
    unsigned size;    // Current size of min heap
    unsigned capacity;   // capacity of min heap
    struct MinHeapNode **array;  // Attay of minheap node pointers
};

// A utility function allocate a new min heap node with given character
// and frequency of the character
struct MinHeapNode* newNode(char data, unsigned freq)
{
    struct MinHeapNode* temp =
          (struct MinHeapNode*) malloc(sizeof(struct MinHeapNode));
    temp->left = temp->right = NULL;
    temp->data = data;
    temp->freq = freq;
    return temp;
}

// A utility function to create a min heap of given capacity
struct MinHeap* createMinHeap(unsigned capacity)
{
    struct MinHeap* minHeap =
         (struct MinHeap*) malloc(sizeof(struct MinHeap));
    minHeap->size = 0;  // current size is 0
    minHeap->capacity = capacity;
    minHeap->array =
     (struct MinHeapNode**)malloc(minHeap->capacity * sizeof(struct MinHeapNode*));
    return minHeap;
}

// A utility function to swap two min heap nodes
void swapMinHeapNode(struct MinHeapNode** a, struct MinHeapNode** b)
{
    struct MinHeapNode* t = *a;
    *a = *b;
    *b = t;
}

// The standard minHeapify function.
void minHeapify(struct MinHeap* minHeap, int idx)
{
    int smallest = idx;
    int left = 2 * idx + 1;
    int right = 2 * idx + 2;

    if (left < minHeap->size &&
        minHeap->array[left]->freq < minHeap->array[smallest]->freq)
      smallest = left;

    if (right < minHeap->size &&
        minHeap->array[right]->freq < minHeap->array[smallest]->freq)
      smallest = right;

    if (smallest != idx)
    {
        swapMinHeapNode(&minHeap->array[smallest], &minHeap->array[idx]);
        minHeapify(minHeap, smallest);
    }
}

// A utility function to check if size of heap is 1 or not
int isSizeOne(struct MinHeap* minHeap)
{
    return (minHeap->size == 1);
}

// A standard function to extract minimum value node from heap
struct MinHeapNode* extractMin(struct MinHeap* minHeap)
{
    struct MinHeapNode* temp = minHeap->array[0];
    minHeap->array[0] = minHeap->array[minHeap->size - 1];
    --minHeap->size;
    minHeapify(minHeap, 0);
    return temp;
}

// A utility function to insert a new node to Min Heap
void insertMinHeap(struct MinHeap* minHeap, struct MinHeapNode* minHeapNode)
{
    ++minHeap->size;
    int i = minHeap->size - 1;
    while (i && minHeapNode->freq < minHeap->array[(i - 1)/2]->freq)
    {
        minHeap->array[i] = minHeap->array[(i - 1)/2];
        i = (i - 1)/2;
    }
    minHeap->array[i] = minHeapNode;
}

// A standard funvtion to build min heap
void buildMinHeap(struct MinHeap* minHeap)
{
    int n = minHeap->size - 1;
    int i;
    for (i = (n - 1) / 2; i >= 0; --i)
        minHeapify(minHeap, i);
}

// A utility function to print an array of size n
void printArr(int arr[], int n)
{
    int i;
    for (i = 0; i < n; ++i)
        printf("%d", arr[i]);
    printf("\n");
}

// Utility function to check if this node is leaf
int isLeaf(struct MinHeapNode* root)
{
    return !(root->left) && !(root->right) ;
}

// Creates a min heap of capacity equal to size and inserts all character of 
// data[] in min heap. Initially size of min heap is equal to capacity
struct MinHeap* createAndBuildMinHeap(char data[], int freq[], int size)
{
    struct MinHeap* minHeap = createMinHeap(size);
    for (int i = 0; i < size; ++i)
        minHeap->array[i] = newNode(data[i], freq[i]);
    minHeap->size = size;
    buildMinHeap(minHeap);
    return minHeap;
}

// The main function that builds Huffman tree
struct MinHeapNode* buildHuffmanTree(char data[], int freq[], int size)
{
    struct MinHeapNode *left, *right, *top;

    // Step 1: Create a min heap of capacity equal to size.  Initially, there are
    // modes equal to size.
    struct MinHeap* minHeap = createAndBuildMinHeap(data, freq, size);

    // Iterate while size of heap doesn't become 1
    while (!isSizeOne(minHeap))
    {
        // Step 2: Extract the two minimum freq items from min heap
        left = extractMin(minHeap);
        right = extractMin(minHeap);

        // Step 3:  Create a new internal node with frequency equal to the
        // sum of the two nodes frequencies. Make the two extracted node as
        // left and right children of this new node. Add this node to the min heap
        // '$' is a special value for internal nodes, not used
        top = newNode('$', left->freq + right->freq);
        top->left = left;
        top->right = right;
        insertMinHeap(minHeap, top);
    }

    // Step 4: The remaining node is the root node and the tree is complete.
    return extractMin(minHeap);
}

// Prints huffman codes from the root of Huffman Tree.  It uses arr[] to
// store codes
void printCodes(struct MinHeapNode* root, int arr[], int top)
{
    // Assign 0 to left edge and recur
    if (root->left)
    {
        arr[top] = 0;
        printCodes(root->left, arr, top + 1);
    }

    // Assign 1 to right edge and recur
    if (root->right)
    {
        arr[top] = 1;
        printCodes(root->right, arr, top + 1);
    }

    // If this is a leaf node, then it contains one of the input
    // characters, print the character and its code from arr[]
    if (isLeaf(root))
    {
        printf("%c: ", root->data);
        printArr(arr, top);
    }
}

// The main function that builds a Huffman Tree and print codes by traversing
// the built Huffman Tree
void HuffmanCodes(char data[], int freq[], int size)
{
   //  Construct Huffman Tree
   struct MinHeapNode* root = buildHuffmanTree(data, freq, size);

   // Print Huffman codes using the Huffman tree built above
   int arr[MAX_TREE_HT], top = 0;
   printCodes(root, arr, top);
}

// Driver program to test above functions
int main()
{
    char arr[] = {'a', 'b', 'c', 'd', 'e', 'f'};
    int freq[] = {5, 9, 12, 13, 16, 45};
    int size = sizeof(arr)/sizeof(arr[0]);
    HuffmanCodes(arr, freq, size);
    return 0;
}

 If you have any doubts ask us in form of comments.

The post C Program of Huffman coding using Greedy Algorithm Approach appeared first on C codechamp.

1. Seperate the like terms aside say polynomial is 2xy^2 +x^2 +x. Now we have three seperate terms: xy^2, x^2 and x.

2. Add the coefficients of like terms.

3. Append the seperate terms to form an polynomial.

The same concept is implemented below with the Help of Linked List. Let us see how to write a C program of adding two poynomials using Linked Lists.

 C program to add two polynomials using Linked Lists :

#include <stdio.h>
#include <conio.h>
#include <malloc.h>
#include <stdlib.h>
typedef struct pnode
   {
	float coef;
	int exp;
	struct pnode *next;
   }p;
p *getnode();
//Main function starts here
void main()
   {
	p *p1,*p2,*p3; 
	p *getpoly(),*add(p*,p*); 
	void display(p*);
	clrscr();
	printf(“\n Enter first polynomial”);
	p1=getpoly();
	printf(“\n Enter second polynomial”);
	p2=getpoly();
	printf(“\nThe first polynomial is”);
	display(p1);
	printf(“\nThe second polynomial is”);
	display(p2);
	p3=add(p1,p2);
	printf(“\nAddition of two polynomial is :\n”);
	display(p3); 
   }

/*Funtion to get polynomial*/
p *getpoly()
  {
	p *temp,*New,*last;
	int flag,exp;
	char ans;
	float coef;
	temp=NULL;
	flag=1;
	printf(“\nenter the polynomial in descending order of exponent”);
	do
	  {
		printf(“\nenter the coef & exponent of a term”);
		scanf(“%f%d”,&coef,&exp);
		New=getnode();
		if(New==NULL)
		printf(“\nmemory cannot be allocated”);
		New->coef=coef;
		New->exp=exp;
		if(flag==1)
		  {
			temp=New;
			last=temp;
			flag=0;
		   }
		else
		  {
			last->next=New;
			last=New;
		   }
		printf(“\ndou want to more terms”);
		ans=getch();
	    }
      while(ans==’y');
      return(temp);
   }
/*Function to get the Nodes of Polynomial*/
p *getnode()
  {
	p *temp;
	temp=(p*) malloc (sizeof(p));
	temp->next=NULL;
	return(temp);
  }
/*Function to display Polynomial*/
void display(p*head)
  {
	p*temp;
	temp=head;
	if(temp==NULL)
	printf(“\npolynomial empty”);
	while(temp->next!=NULL)
	  {
		printf(“%0.1fx^%d+”,temp->coef,temp->exp);
		temp=temp->next;
	   }
	printf(“\n%0.1fx^%d”,temp->coef,temp->exp);
	getch();
   }
/*Function to add Polynomials*/
p*add(p*first,p*second)
  {
	p *p1,*p2,*temp,*dummy;
	char ch;
	float coef;
	p *append(int,float,p*);
	p1=first;
	p2=second;
	temp=(p*)malloc(sizeof(p));
	if(temp==NULL)
	printf(“\nmemory cannot be allocated”);
	dummy=temp;
	while(p1!=NULL&&p2!=NULL)
	  {
		if(p1->exp==p2->exp)
    		  {
			coef=p1->coef+p2->coef;
			temp=append(p1->exp,coef,temp);
			p1=p1->next;
			p2=p2->next;
	           }
		else
		if(p1->expexp)
		  {
			coef=p2->coef;
			temp=append(p2->exp,coef,temp);
			p2=p2->next;
		   }
		else
		if(p1->exp>p2->exp)
		  {
			coef=p1->coef;
			temp=append(p1->exp,coef,temp);
			p1=p1->next;
		   }
	   }
	while(p1!=NULL)
	  {
		temp=append(p1->exp,p1->coef,temp);
		p1=p1->next;
		}
	while(p2!=NULL)
	  {
		temp=append(p2->exp,p2->coef,temp);
		p2=p2->next;
		}
	temp->next=NULL;
	temp=dummy->next;
	free(dummy);
	return(temp);
   }
/*Function to append the coefficients with Polynomial*/
p*append(int Exp,float Coef,p*temp)
  {
	p*New,*dum;
	New=(p*)malloc(sizeof(p));
	if(New==NULL)
	printf(“\ncannot be allocated”);
	New->exp=Exp;
	New->coef=Coef;
	New->next=NULL;
	dum=temp;
	dum->next=New;
	dum=New;
	return(dum);
  }

 We hope you all have enjoyed the C program to add two polynomials using Linked Lists. If you have any doubts or queries ask me in form of comments.

The post C program to add two polynomials using Linked Lists appeared first on C codechamp.

Generalized approach to find Minimum Spanning tree of weighted graphs using KRUSKAL’s Algorithm :

• create a forest F (a set of trees), where each vertex in the graph is a separate tree

• create a set S containing all the edges in the graph

• while S is nonempty and F is not yet spanning

  • remove an edge with minimum weight from S

  • if that edge connects two different trees, then add it to the forest, combining two trees into a single tree

  • otherwise discard that edge.

At the termination of the algorithm, the forest forms a minimum spanning forest of the graph. If the graph is connected, the forest has a single component and forms a minimum spanning tree.

Lets see how to write a C code to implement KRUSKAL’s Algorithm to find Minimum Spanning tree of weighted graphs.

C program to Find Minimum Spanning tree using KRUSKAL’s Algorithm  :

#include<stdio.h>
#define INF 1000
char vertex[10];
int wght[10][10];
int span_wght[10][10];
int source;
struct Sort
{
int v1,v2;
int weight;
}que[20];
int n,ed,f,r;
int cycle(int s,int d)
{
int j,k;
if(source==d)
return 1;
for(j=0;j<n;j++)
if(span_wght[d][j]!=INF && s!=j)
{
if(cycle(d,j))
return 1;
}
return 0;
}
void build_tree()
{
int i,j,w,k,count=0;
for(count=0;count<n;f++)
{
i=que[f].v1;
j=que[f].v2;
w=que[f].weight;
span_wght[i][j]=span_wght[j][i]=w;
source=i;
k=cycle(i,j);
if(k)
span_wght[i][j]=span_wght[j][i]=INF;
else
count++;
}
}
void swap(int *i,int *j)
{
int t;
t=*i;
*i=*j;
*j=t;
}
void main()
{
int i,j,k=0,temp;
int sum=0;
clrscr();
printf("\n\n\tKRUSKAL'S ALGORITHM TO FIND SPANNING TREE\n\n");
printf("\n\tEnter the No. of Nodes : ");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("\n\tEnter %d value : ",i+1);
fflush(stdin);
scanf("%c",&vertex[i]);
for(j=0;j<n;j++)
{
wght[i][j]=INF;
span_wght[i][j]=INF;
}
}
printf("\n\nGetting Weight\n");
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
{
printf("\nEnter 0 if path Doesn't exist between %c to %c : ",vertex[i],vertex[j]);
scanf("%d",&ed);
if(ed>=1)
{
wght[i][j]=wght[j][i]=ed;
que[r].v1=i;
que[r].v2=j;
que[r].weight=wght[i][j];
if(r)
{
for(k=0;k<r;k++)
if(que[k].weight>que[r].weight)
{
swap(&que[k].weight,&que[r].weight);
swap(&que[k].v1,&que[r].v1);
swap(&que[k].v2,&que[r].v2);
}
}
r++;
}
}
clrscr();
printf("\n\tORIGINAL GRAPH WEIGHT MATRIX\n\n");
printf("\n\tweight matrix\n\n\t");
for(i=0;i<n;i++,printf("\n\t"))
for(j=0;j<n;j++,printf("\t"))
printf("%d",wght[i][j]);
build_tree();
printf("\n\n\t\tMINIMUM SPANNING TREE\n\n");
printf("\n\t\tLIST OF EDGES\n\n");
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
if(span_wght[i][j]!=INF)
{
printf("\n\t\t%c ------ %c = %d ",vertex[i],vertex[j],span_wght[i][j]);
sum+=span_wght[i][j];
}
printf("\n\n\t\tTotal Weight : %d ",sum);
getch();
}

We hope you all have enjoyed the C program of Kruskal’s Algorithm to find minimum spanning tree. If you have any doubts or queries ask us in form of comments.

The post C program to Find Minimum Spanning tree KRUSKAL’s Algorithm appeared first on C codechamp.

General apporach for writing a C Code to Find Minimum Spanning tree using PRIM’s Algorithm :

• create a tree containing a single vertex, chosen arbitrarily from the graph

• create a set containing all the edges in the graph

• loop until every edge in the set connects two vertices in the tree

  • remove from the set an edge with minimum weight that connects a vertex in the tree with a vertex not in the tree

  • add that edge to the tree

Let’s see how to write a C program of PRIM’s Algorithm to find Minimum Spanning tree.

C program to find Minimum Spanning tree using PRIM’s Algorithm :

#include<stdio.h>
#define INF 1000
int vertex[10];
int wght[10][10];
int new_wght[10][10];
int closed[10];
int n;
int inclose(int i,int n1)
{
/*chk for the ith vertex presence in closed*/
int j;
for(j=0;j<=n1;j++)
if(closed[j]==i)
return 1;
return 0;
}
void buildtree()
{
int i=0,j,count=0;
int min,k,v1=0,v2=0;
closed[0]=0;
while(count<n-1)
{
min=INF;
for(i=0;i<=count;i++)
for(j=0;j<n;j++)
if(wght[closed[i]][j]<min && !inclose(j,count))
{
min=wght[closed[i]][j];
v1=closed[i];
v2=j;
}
new_wght[v1][v2]=new_wght[v2][v1]=min;
count++;
closed[count]=v2;
printf("\nScan : %d %d---------%d wght = %d \n",count,v1+1,v2+1,min);
getch();
}
}
void main()
{
int i,j,ed,sum=0;
clrscr();
printf("\n\n\tPRIM'S ALGORITHM TO FIND SPANNING TREE\n\n");
printf("\n\tEnter the No. of Nodes : ");
scanf("%d",&n);
for(i=0;i<n;i++)
{
vertex[i]=i+1;
for(j=0;j<n;j++)
{
wght[i][j]=INF;
new_wght[i][j]=INF;
}
}
printf("\n\nGetting Weight.\n");
printf("\n\tEnter 0 if path doesn't exist between {v1,v2} else enter the wght\n");
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
{
printf("\n\t%d -------- %d : ",vertex[i],vertex[j]);
scanf("%d",&ed);
if(ed>=1)
wght[i][j]=wght[j][i]=ed;
}
getch();
clrscr();
printf("\n\n\t\tNODES CURRENTLY ADDED TO SPANNING TREE\n\n");
buildtree();
printf("\n\tNEW GRAPH WEIGHT MATRIX\n\n");
printf("\n\tweight matrix\n\n\t");
for(i=0;i<n;i++,printf("\n\t"))
for(j=0;j<n;j++,printf("\t"))
printf("%d",new_wght[i][j]);
printf("\n\n\t\tMINIMUM SPANNING TREE\n\n");
printf("\n\t\tLIST OF EDGES\n\n");
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
if(new_wght[i][j]!=INF)
{
printf("\n\t\t%d ------ %d = %d ",vertex[i],vertex[j],new_wght[i][j]);
sum+=new_wght[i][j];
}
printf("\n\n\t Total Weight : %d ",sum);
getch();
}

We hope you all have enjoyed the C program of PRIM’s Algorithm to find minimum spanning tree. If you have any doubts or queries ask us in form of comments.

The post C program to find Minimum Spanning tree PRIM’s Algorithm appeared first on C codechamp.

How to Compute CRC Cyclic Redundancy Check ?

To compute an n-bit binary CRC, line the bits representing the input in a row, and position the (n+1)-bit pattern representing the CRC’s divisor (called a “polynomial”) underneath the left-hand end of the row.

Start with the message to be encoded:

11010011101100

This is first padded with zeroes corresponding to the bit length n of the CRC. Here is the first calculation for computing a 3-bit CRC:

11010011101100 000 <--- input right padded by 3 bits
1011               <--- divisor (4 bits) = x³+x+1
------------------
01100011101100 000 <--- result

If the input bit above the leftmost divisor bit is 0, do nothing. If the input bit above the leftmost divisor bit is 1, the divisor is XORed into the input (in other words, the input bit above each 1-bit in the divisor is toggled). The divisor is then shifted one bit to the right, and the process is repeated until the divisor reaches the right-hand end of the input row. Here is the entire calculation:

11010011101100 000 <--- input right padded by 3 bits
1011               <--- divisor
01100011101100 000 <--- result
 1011              <--- divisor ...
00111011101100 000
  1011
00010111101100 000
   1011
00000001101100 000
       1011
00000000110100 000
        1011
00000000011000 000
         1011
00000000001110 000
          1011
00000000000101 000 
           101 1
-----------------
00000000000000 100 <---remainder (3 bits)

Since the leftmost divisor bit zeroed every input bit it touched, when this process ends the only bits in the input row that can be nonzero are the n bits at the right-hand end of the row. These n bits are the remainder of the division step, and will also be the value of the CRC function (unless the chosen CRC specification calls for some postprocessing).

The validity of a received message can easily be verified by performing the above calculation again, this time with the check value added instead of zeroes. The remainder should equal zero if there are no detectable errors.

11010011101100 100 <--- input with check value
1011               <--- divisor
01100011101100 100 <--- result
 1011              <--- divisor ...
00111011101100 100

......

00000000001110 100
          1011
00000000000101 100 
           101 1
------------------
                 0 <--- remainder

Let see how to write a C program to implement Cyclic Redundancy Check CRC.

C program to implement Cyclic Redundancy Check CRC :

#include<stdio.h>
#include<string.h>
#define N strlen(g)

char t[28],cs[28],g[]="10001000000100001";
int a,e,c;

void xor(){
    for(c = 1;c < N; c++)
    cs[c] = (( cs[c] == g[c])?'0':'1');
}

void crc(){
    for(e=0;e<N;e++)
        cs[e]=t[e];
    do{
        if(cs[0]=='1')
            xor();
        for(c=0;c<N-1;c++)
            cs[c]=cs[c+1];
        cs[c]=t[e++];
    }while(e<=a+N-1);
}

int main()
{
    printf("\nEnter data : ");
    scanf("%s",t);
    printf("\n----------------------------------------");
    printf("\nGeneratng polynomial : %s",g);
    a=strlen(t);
    for(e=a;e<a+N-1;e++)
        t[e]='0';
    printf("\n----------------------------------------");
    printf("\nModified data is : %s",t);
    printf("\n----------------------------------------");
    crc();
    printf("\nChecksum is : %s",cs);
    for(e=a;e<a+N-1;e++)
        t[e]=cs[e-a];
    printf("\n----------------------------------------");
    printf("\nFinal codeword is : %s",t);
    printf("\n----------------------------------------");
    printf("\nTest error detection 0(yes) 1(no)? : ");
    scanf("%d",&e);
    if(e==0)
    {
        do{
            printf("\nEnter the position where error is to be inserted : ");
            scanf("%d",&e);
        }while(e==0 || e>a+N-1);
        t[e-1]=(t[e-1]=='0')?'1':'0';
        printf("\n----------------------------------------");
        printf("\nErroneous data : %s\n",t);
    }
    crc();
    for(e=0;(e<N-1) && (cs[e]!='1');e++);
        if(e<N-1)
            printf("\nError detected\n\n");
        else
            printf("\nNo error detected\n\n");
            printf("\n----------------------------------------\n");
        return 0;
}

Sample Output:

Enter data : 1101

—————————————-
Generatng polynomial : 10001000000100001
—————————————-
Modified data is : 11010000000000000000
—————————————-
Checksum is : 1101000110101101
—————————————-
Final codeword is : 11011101000110101101
—————————————-
Test error detection 0(yes) 1(no)? : 0

Enter the position where error is to be inserted : 2

—————————————-
Erroneous data : 10011101000110101101

Error detected

We hope you all have enjoyed the C program of Cyclic Redundancy check CRC. If you have any doubts ask us in form of comments.

The post C program to implement Cyclic Redundancy Check CRC appeared first on C codechamp.