CN

 

 // Hamming code
#include <iostream>
#include <cmath>
using namespace std;

int main()
{
    int m_size, rbit = 0, msg[50], data[60], i, k, j, count = 0;
    cout << "\nEnter message size: ";
    cin >> m_size;

    // calculate value of r  2^r >= m_size +rbit +1
    while (1)
    {
        if ((m_size + rbit + 1) <= (int)pow(2, rbit))
            break;

        rbit++;
    }
    cout << "Enter message: ";
    for (i = m_size; i >= 1; i--)
    {
        cin >> msg[i];
    }
    k = 0; // for 2^k
    j = 1; // position of r bit
    for (i = 1; i <= (m_size + rbit); i++)
    {
        if (i == (int)pow(2, k))
        {
            data[i] = 8;
            k++;
        }
        else
        {
            data[i] = msg[j];
            j++;
        }
    }
    for (i = 1; i <= (m_size + rbit); i++)
    {
        if (data[i] == 8)
        {
            data[i] = 0;
            int count = 0;
            for (j = i; j <= (m_size + rbit); j++)
            {
                for (k = 0; k < i; k++)
                {
                    if (data[j] == 1)
                    {
                        count++;
                    }
                    j++;
                }
                j = j + i - 1;
            }

            if (count % 2 == 0)
                data[i] = 1;
            else
                data[i] = 0;
        }
    }
    cout << "\nSender side code: ";
    for (i = (m_size + rbit); i >= 1; i--)
        cout << data[i] << " ";
    cout << "\n\n-------------------------------------------------------\n"
         << endl;

    cout << "Enter receiver side code: ";
    for (i = (m_size + rbit); i >= 1; i--)
        cin >> data[i];

    int c = 0;

    int parities[m_size] = {0};
    for (i = 1; i <= (m_size + rbit); i++)
    {
        if (i == (int)pow(2, c))
        {
            count = 0;
            for (j = i; j <= (m_size + rbit); j++)
            {
                for (k = 0; k < i; k++)
                {
                    if (data[j] == 1)
                    {
                        count++;
                    }
                    j++;
                }
                j = j + i - 1;
            }
            if (data[i] == 1)
                count--;
            if (count % 2 == data[i])
                parities[c] = 1;
            else if (count % 2 != data[i])
                parities[c] = 0;
            c++;
        }
    }
    c = 0;
    for (int i = 0; i < rbit; i++)
    {
        c += parities[i] * ((int)pow(2, i));
    }
    if (c == 0)
    {
        cout << "NO ERROR FOUND !!!" << endl;
        exit(0);
    }
    cout << "\nError at position: " << c << endl;
    data[c] = data[c] == 0 ? 1 : 0;
    cout << "After error correction: ";
    for (i = (m_size + rbit); i >= 1; i--)
    {
        cout << data[i] << " ";
    }
    cout << endl;

    return 0;
}

 

//dijkstras

#include <limits.h>
#include <stdbool.h>
#include <stdio.h>

#define V 9

int minDistance(int dist[], bool sptSet[])
{
    int min = INT_MAX, min_index;

    for (int v = 0; v < V; v++)
        if (sptSet[v] == false && dist[v] <= min)
            min = dist[v], min_index = v;

    return min_index;
}

void printSolution(int dist[])
{
    printf("0 is the source node\n");
    printf("Enter the vertex (0-8) till which you have to find the minimum distance from the source: ");
    int v;
    scanf("%d", &v);
    for (int i = 0; i < V; i++)
    {
        if (v == i)
        {
            printf("Distance from source to entered vertex is: %d\n\n", dist[i]);
        }
    }
}

void dijkstra(int graph[V][V], int src)
{
    int dist[V];

    bool sptSet[V];

    for (int i = 0; i < V; i++)
        dist[i] = INT_MAX, sptSet[i] = false;

    dist[src] = 0;

    for (int count = 0; count < V - 1; count++)
    {
        int u = minDistance(dist, sptSet);

        sptSet[u] = true;

        for (int v = 0; v < V; v++)

            if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX && dist[u] + graph[u][v] < dist[v])
                dist[v] = dist[u] + graph[u][v];
    }

    printSolution(dist);
}

int main()
{
    int graph[V][V] = {{0, 4, 0, 0, 0, 0, 0, 8, 0},
                       {4, 0, 8, 0, 0, 0, 0, 11, 0},
                       {0, 8, 0, 7, 0, 4, 0, 0, 2},
                       {0, 0, 7, 0, 9, 14, 0, 0, 0},
                       {0, 0, 0, 9, 0, 10, 0, 0, 0},
                       {0, 0, 4, 14, 10, 0, 2, 0, 0},
                       {0, 0, 0, 0, 0, 2, 0, 1, 6},
                       {8, 11, 0, 0, 0, 0, 1, 0, 7},
                       {0, 0, 2, 0, 0, 0, 6, 7, 0}};

    dijkstra(graph, 0);

    return 0;
}