Milan Smudja

Thursday, May 1, 2025

Wednesday, April 30, 2025

How to Generate CTCSS Tones - Python

Change frequency and duration to suit your needs.

import math
import numpy as np
import pyaudio

# Define the frequency and duration of the tone
frequency = 88.5  # Hz
duration = 360  # seconds

# Generate the audio samples
samples_per_second = 44100
num_samples = samples_per_second * duration
x = np.arange(num_samples)
samples = 0.5 * np.sin(2 * np.pi * frequency * x / samples_per_second)

# Initialize PyAudio
p = pyaudio.PyAudio()

# Open a stream and play the audio
stream = p.open(format=pyaudio.paFloat32,
                channels=1,
                rate=samples_per_second,
                output=True)
stream.write(samples.astype(np.float32).tostring())

# Close the stream and PyAudio
stream.stop_stream()
stream.close()
p.terminate()

First, the necessary modules are imported:

math for mathematical functions
numpy as np for scientific computing with Python
pyaudio for audio input/output

The frequency and duration of the audio tone to be generated are then defined with the following lines:

frequency = 88.5  # Hz
duration = 360  # seconds

The number of samples to generate is calculated based on the desired frequency and duration, along with the samples per second value:

samples_per_second = 44100
num_samples = samples_per_second * duration

A numpy array x is generated to represent the time values for the audio samples to be generated:

x = np.arange(num_samples)

The audio samples themselves are then generated as a sine wave with an amplitude of 0.5:

samples = 0.5 * np.sin(2 * np.pi * frequency * x / samples_per_second)

PyAudio is then initialized:

p = pyaudio.PyAudio()

An audio stream is opened with the desired format (32-bit floating point), number of channels (1), and sample rate (samples per second). The output parameter is set to True to indicate that audio should be played through the stream:

stream = p.open(format=pyaudio.paFloat32,
                channels=1,
                rate=samples_per_second,
                output=True)

The audio samples are then written to the stream, converted to a string of 32-bit floating point values:

stream.write(samples.astype(np.float32).tostring())

Finally, the stream is closed and PyAudio is terminated:

stream.stop_stream()
stream.close()
p.terminate()

C Program - strcmp() Function - Compares Two Strings Character by Character

This is a C program that demonstrates how to compare two strings using the strcmp() function.

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

int main()
{

    char left[] = "aaa";
    char right[] = "aaa";

    int compare_strings;

    compare_strings = strcmp(left, right);

    //printf("%d", compare_strings);

    if (compare_strings == 0)
    {
        printf("Same");
    }
    else if (compare_strings < 0)
    {
        printf("Left Positionaly Smaller");
    }
    else if (compare_strings > 0)
    {
        printf("Left Positionaly Bigger");
    }

    return 0;

}

Result:

Same
Process returned 0 (0x0)   execution time : 0.035 s
Press any key to continue.

Here's a breakdown of the code block by block:

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

These are header files that are included in the program to provide definitions for functions used later in the code. stdio.h is included for standard input/output functions, while string.h is included for string manipulation functions.

int main()
{

This is the main function of the program, where execution begins. The function returns an integer value (in this case, 0) to indicate the status of the program when it exits.

    char left[] = "aaa";
    char right[] = "aaa";

    int compare_strings;

    compare_strings = strcmp(left, right);

This declares two character arrays, left and right, and initializes them both with the same string "aaa". It also declares an integer variable compare_strings.

The strcmp() function is used to compare the two strings. The function returns an integer value that indicates the lexicographic relation between the two strings. The value 0 indicates that the strings are equal, a negative value indicates that left is lexicographically smaller than right, and a positive value indicates that left is lexicographically larger than right.

    if (compare_strings == 0)
    {
        printf("Same");
    }
    else if (compare_strings < 0)
    {
        printf("Left Positionaly Smaller");
    }
    else if (compare_strings > 0)
    {
        printf("Left Positionaly Bigger");
    }

This uses a series of if statements to check the value of compare_strings and print out a message based on the result.

If compare_strings is 0, it means that the two strings are equal, so the program prints "Same".

If compare_strings is negative, it means that left is lexicographically smaller than right, so the program prints "Left Positionaly Smaller".

If compare_strings is positive, it means that left is lexicographically larger than right, so the program prints "Left Positionaly Bigger".

    return 0;
}

This statement ends the main() function and returns the value 0 to indicate successful program execution.

C Program - strncpy() Function - Copy Specific Number of Characters from a String to Another String

This is a C program that demonstrates how to copy a specific number of characters from one string to another using the strncpy() function.

//copy just specific number of charactes from string

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

int main()
{

    char some_string[] = "Hack The Planet, coz it's fun.";

    char target_string[20]; //ako stavis vise onda je garbage

    printf("Some String: %s \n", some_string);
    printf("Initial Target String: %s \n", target_string);

    strncpy(target_string, some_string, 10); //150, 5

    printf("Final Target String: %s \n", target_string);

    return 0;

}

Result:

Some String: Hack The Planet, coz it's fun.
Initial Target String:
Final Target String: Hack The P

Process returned 0 (0x0)   execution time : 0.031 s
Press any key to continue.

Here's a breakdown of the code block by block:

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

int main()
{

This is the main function of the program, where execution begins. The function returns an integer value (in this case, 0) to indicate the status of the program when it exits.

    char some_string[] = "Hack The Planet, coz it's fun.";

    char target_string[20];

    printf("Some String: %s \n", some_string);
    printf("Initial Target String: %s \n", target_string);

This declares two character arrays: some_string and target_string. The former is initialized with a string literal, while the latter is left uninitialized.

The program then uses printf() to display the original input string some_string and an initial value of target_string on the console.

    strncpy(target_string, some_string, 10);

    printf("Final Target String: %s \n", target_string);

The strncpy() function is used to copy the first 10 characters of some_string into target_string. The strncpy() function is similar to strcpy(), but it takes an additional argument that specifies the maximum number of characters to copy.

If the source string is shorter than the specified length, the remaining characters in the destination string are padded with null characters.

Finally, the program uses printf() to display the final value of target_string.

    return 0;
}

This statement ends the main() function and returns the value 0 to indicate successful program execution.

C Program - strcpy() Function - Copy Content of One String into Another String

This is a C program that demonstrates the use of the string manipulation functions in the C standard library. The program prompts the user to input a string using the gets() function and then copies the string into a new character array using the strcpy() function.

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

int main()
{

    //char some_string[] = "This is some string.";

    char some_string[100];

    printf("Enter Some String: \n");
    gets(some_string);

    char target_string[10];

    printf("Some String: %s \n", some_string);
    printf("Initial Target String: %s \n", target_string);

    strcpy(target_string, some_string);

    printf("Final Target String: %s \n", target_string);

    /*
    for (int x = 0; x < strlen(target_string); x++) {
        printf("%c \n", target_string[x]);
    }
    */

    return 0;

}

Result:

Enter Some String:
this is original string
Some String: this is original string
Initial Target String:
Final Target String: this is original string

Process returned 0 (0x0)   execution time : 10.649 s
Press any key to continue.

Here's an explanation of each block of code in the program:

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

int main()
{

This is the main function of the program, where execution begins. The function returns an integer value (in this case, 0) to indicate the status of the program when it exits.

    char some_string[100];

    printf("Enter Some String: \n");
    gets(some_string);

This declares a character array called some_string with a size of 100 and prompts the user to input a string using the gets() function. The gets() function reads a line of text from standard input and stores it in the some_string array. However, as mentioned earlier, using gets() is not recommended due to potential buffer overflow vulnerabilities.

    char target_string[10];

    printf("Some String: %s \n", some_string);
    printf("Initial Target String: %s \n", target_string);

    strcpy(target_string, some_string);

    printf("Final Target String: %s \n", target_string);

This declares a new character array called target_string with a size of 10 and then uses the printf() function to display the original input string some_string and an initial value of target_string on the console.

The strcpy() function is then used to copy the contents of some_string into target_string. This replaces the original contents of target_string with the input string.

Finally, the program uses printf() to display the final value of target_string.

    return 0;
}

This statement ends the main() function and returns the value 0 to indicate successful program execution.

C Program - strcat() Function - How to Concatenate Strings in C

This code combines two input strings entered by the user using the strcat() function from the string.h library.

#include <stdio.h>
#include <string.h> //strcat() function

int main()
{

    char first_string[100];
    char second_string[100];

    printf("First String: ");
    gets(first_string);

    printf("Second String: ");
    gets(second_string);

    strcat(first_string, second_string);
    printf("Combination: %s \n", first_string);

    return 0;

}

Result:

First String: some
Second String:  string
Combination: some string

Process returned 0 (0x0)   execution time : 17.672 s
Press any key to continue.

Here's a line-by-line explanation:

#include <stdio.h>
#include <string.h> //strcat() function

int main()
{

    char first_string[100];
    char second_string[100];

The program includes the necessary header files, and defines two character arrays with a size of 100 each.

    printf("First String: ");
    gets(first_string);

    printf("Second String: ");
    gets(second_string);

The program prompts the user to enter two strings using printf() function and reads them using the gets() function.

Note: gets() function is considered unsafe and is deprecated in modern C. It is recommended to use fgets() instead.

    strcat(first_string, second_string);
    printf("Combination: %s \n", first_string);

    return 0;

}

The program uses the strcat() function to concatenate the two strings, storing the result in the first_string variable. The concatenated string is then printed to the console using printf() function. Finally, the program returns 0 to indicate successful completion.

C Program - strlen() Function Example - Find the Length of a String

This program prompts the user to enter a string and then calculates and displays the length of the entered string. The program continues to prompt the user for input until the program is terminated.

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

int main()
{

    char some_string[100];
    int length;

    while (1)
    {
        printf("Enter String: \n");
        gets(some_string);

        length = strlen(some_string);
        printf("String Length for %s is %d: \n", some_string, length);
        printf("-------------------------------------- \n");
    }

    return 0;
}

Result:

Enter String:
some string
String Length for some string is 11:
--------------------------------------
Enter String:
test
String Length for test is 4:
--------------------------------------
Enter String:

Here's a line-by-line explanation of the code:

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

This program includes the standard input/output library and the string library.

int main()
{
    char some_string[100];
    int length;

This declares a character array some_string of size 100 to store the user input and an integer length to store the length of the input string.

    while (1)
    {
        printf("Enter String: \n");
        gets(some_string);

This is a loop that prompts the user to enter a string and reads it from the console using gets() function. gets() reads the input as a character string, which is then stored in some_string.

Note: gets() is not safe to use, as it does not check the length of the input, so it can cause a buffer overflow if the input string is larger than the size of the array.

        length = strlen(some_string);
        printf("String Length for %s is %d: \n", some_string, length);
        printf("-------------------------------------- \n");
    }

This calculates the length of the input string using the strlen() function and stores it in the length variable. The length is then printed to the console using printf() function.

    return 0;
}

This ends the main function and returns 0, indicating successful execution of the program.

C Program - Display its Own Source Code as Output

This code opens the source code file itself using the fopen() function and reads its contents character by character using the getc() function, and then prints each character to the console using the putchar() function.

#include <stdio.h>

int main()
{

    FILE *file_pointer;
    char some_char;

    file_pointer = fopen(__FILE__, "r");

    while (some_char != EOF)
    {
        some_char = getc(file_pointer);
        putchar(some_char);
    }

    fclose(file_pointer);

    return 0;
}

Result:

#include <stdio.h>

int main()
{

    FILE *file_pointer;
    char some_char;

    file_pointer = fopen(__FILE__, "r");

    while (some_char != EOF)
    {
        some_char = getc(file_pointer);
        putchar(some_char);
    }

    fclose(file_pointer);

    return 0;
}
 
Process returned 0 (0x0)   execution time : 0.031 s
Press any key to continue.

Here is a line-by-line explanation:

#include <stdio.h>

This line includes the standard input/output library.

int main()
{

This line declares the main function, which is the entry point of the program.

    FILE *file_pointer;
    char some_char;

This declares a file pointer file_pointer of type FILE, and a variable some_char of type char.

    file_pointer = fopen(__FILE__, "r");

This line opens the current source code file (__FILE__) in read-only mode ("r") and assigns the resulting file pointer to file_pointer.

    while (some_char != EOF)
    {
        some_char = getc(file_pointer);
        putchar(some_char);
    }

This block of code loops through the file pointed to by file_pointer until the end of the file (EOF) is reached. Each character of the file is read and assigned to some_char using getc(), and then printed to the console using putchar().

    fclose(file_pointer);

This line closes the file pointed to by file_pointer.

    return 0;
}

This line signals the end of the main function and returns 0 to indicate successful program execution.

C Program - Rectangle Calculator - Diagonal, Area, Parimeter

This program calculates the area, perimeter, and diagonal of a rectangle based on its width and height.

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

int main()
{

    float width, height, area, parimeter, diagonal;

    printf("Rectangle Calculator:  \n\n");
    printf("--------width--------- \n");
    printf("|                    | \n");
    printf("|                    | height\n");
    printf("|                    | \n");
    printf("|                    | \n");
    printf("---------------------- \n");

    printf("Width: ");
    scanf("%f", &width);

    printf("Height: ");
    scanf("%f", &height);

    printf("--------------------- \n");

    area = width * height;
    parimeter = (2 * width) + (2 * height);
    diagonal = sqrt((width*width) + (height*height));

    printf("Area: %.2f \n", area);
    printf("Parimeter: %.2f \n", parimeter);
    printf("Diagonal: %.2f \n", diagonal);

    printf("--------------------- \n");

    return 0;
}

Result:

Rectangle Calculator:

--------width---------
|                    |
|                    | height
|                    |
|                    |
----------------------
Width: 100
Height: 50
---------------------
Area: 5000.00
Parimeter: 300.00
Diagonal: 111.80
---------------------

Process returned 0 (0x0)   execution time : 4.192 s
Press any key to continue.

Here's a line-by-line explanation of the code:

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

int main()
{

This code defines the standard library header files that will be used in the program, including stdio.h and math.h. It also defines the main function, which is the entry point of the program.

    float width, height, area, parimeter, diagonal;

This code declares five float variables, namely width, height, area, perimeter, and diagonal. These variables will be used to store the input values for the width and height of the rectangle and the calculated values of its area, perimeter, and diagonal.

    printf("Rectangle Calculator:  \n\n");
    printf("--------width--------- \n");
    printf("|                    | \n");
    printf("|                    | height\n");
    printf("|                    | \n");
    printf("|                    | \n");
    printf("---------------------- \n");

This code displays a prompt to the user asking for the width and height of the rectangle, and also shows a visual representation of the rectangle.

    printf("Width: ");
    scanf("%f", &width);

    printf("Height: ");
    scanf("%f", &height);

    printf("--------------------- \n");

This code prompts the user to input the width and height of the rectangle, and then stores these values in the width and height variables.

    area = width * height;
    perimeter = (2 * width) + (2 * height);
    diagonal = sqrt((width*width) + (height*height));

This code calculates the area, perimeter, and diagonal of the rectangle based on its width and height, and stores the results in the area, perimeter, and diagonal variables, respectively.

    printf("Area: %.2f \n", area);
    printf("Perimeter: %.2f \n", perimeter);
    printf("Diagonal: %.2f \n", diagonal);

    printf("--------------------- \n");

    return 0;
}

This code displays the calculated values of the area, perimeter, and diagonal of the rectangle using the printf function. The %.2f format specifier is used to display the floating-point numbers with two decimal places. Finally, the function returns 0 to indicate successful execution of the program.

C Program - Tile Calculator - The Total Number of Tiles Necessary to Cover a Surface

This program calculates the total number of small elements required to cover a specified number of walls, given the dimensions of the walls and the dimensions of the small elements.

The main() function initializes integer variables big_width, big_height, small_width, small_height, and wall_number.

The program prompts the user to input the dimensions of the big wall (big_width and big_height), the dimensions of the small element (small_width and small_height), and the number of walls (wall_number).

The program then calculates the total surface area of the big wall (big_surface) and the small element (small_surface). It uses these values to calculate the number of small elements required to cover one wall (element_per_wall) and the total number of small elements required to cover all the walls (element_total).

Finally, the program prints the number of small elements required per wall and the total number of small elements required to cover all the walls to the console, and returns 0 to indicate successful program execution.

Note that the program assumes that the small elements will be arranged in a grid and that they will completely cover each wall without any overlap. It also assumes that the dimensions provided by the user are valid and that the division operations do not result in a divide-by-zero error.

#include <stdio.h>

int main()
{

    int big_width, big_height;
    int small_width, small_height;
    int wall_number;

    printf("Big Width: ");
    scanf("%d", &big_width);

    printf("Big Height: ");
    scanf("%d", &big_height);

    printf("Small Width: ");
    scanf("%d", &small_width);

    printf("Small Height: ");
    scanf("%d", &small_height);

    printf("Number of Walls: ");
    scanf("%d", &wall_number);

    int big_surface = big_width * big_height;
    int small_surface = small_width * small_height;

    int element_per_wall = big_surface / small_surface;
    int element_total = wall_number * element_per_wall;

    printf("----------------------------- \n");
    printf("Element Number per Wall: %d   \n", element_per_wall);
    printf("Total Number of Elements: %d  \n", element_total);
    printf("----------------------------- \n");

    return 0;
}

Result:

Big Width: 100
Big Height: 50
Small Width: 10
Small Height: 5
Number of Walls: 4
-----------------------------
Element Number per Wall: 100
Total Number of Elements: 400
-----------------------------

Process returned 0 (0x0)   execution time : 24.990 s
Press any key to continue.

Here is a detailed explanation of each line and block of code in the program:

#include <stdio.h>

This line includes the standard input-output library in the program.

int main()
{

This line indicates the start of the main() function, which is the entry point of the program.

    int big_width, big_height;
    int small_width, small_height;
    int wall_number;

These lines declare integer variables for the dimensions of the big wall (big_width and big_height), the dimensions of the small element (small_width and small_height), and the number of walls (wall_number).

    printf("Big Width: ");
    scanf("%d", &big_width);

    printf("Big Height: ");
    scanf("%d", &big_height);

    printf("Small Width: ");
    scanf("%d", &small_width);

    printf("Small Height: ");
    scanf("%d", &small_height);

    printf("Number of Walls: ");
    scanf("%d", &wall_number);

These lines prompt the user to input the dimensions of the big wall (big_width and big_height), the dimensions of the small element (small_width and small_height), and the number of walls (wall_number) using printf() and scanf() functions.

    int big_surface = big_width * big_height;
    int small_surface = small_width * small_height;

These lines calculate the surface area of the big wall (big_surface) and the small element (small_surface) by multiplying their respective dimensions.

    int element_per_wall = big_surface / small_surface;
    int element_total = wall_number * element_per_wall;

These lines calculate the number of small elements required to cover one wall (element_per_wall) and the total number of small elements required to cover all the walls (element_total) using the surface area of the big wall and the small element.

    printf("----------------------------- \n");
    printf("Element Number per Wall: %d   \n", element_per_wall);
    printf("Total Number of Elements: %d  \n", element_total);
    printf("----------------------------- \n");

These lines print the number of small elements required per wall (element_per_wall) and the total number of small elements required to cover all the walls (element_total) to the console using printf().

    return 0;
}

This line indicates the end of the main() function, and the program returns 0 to indicate successful program execution.

C Program - Bubble Sort In C using Nested While Loops

This code sorts an array of integers using the Bubble Sort algorithm and prints the sorted array to the console.

The array to be sorted is initialized at the beginning of the program, and the main() function contains a nested while loop that implements the Bubble Sort algorithm.

The algorithm works by repeatedly swapping adjacent elements if they are in the wrong order, and it continues doing this until the array is fully sorted.

Once the array is sorted, the program uses a for loop to iterate through the sorted array and print each element to the console. The program then returns 0 to indicate successful program execution.

#include <stdio.h>

int main()
{

    int arr[] = {2, 4, 3, 1, 6, 5, 8, 10, 7, 9};
    int num = 10;
    int x = 0;
    int temp;

    while (x < num - 1)
    {
        int y = 0;
        while (y < num - 1 - x)
        {
            if (arr[y] > arr[y + 1])
            {
                temp = arr[y]; //helper variable
                arr[y] = arr[y + 1];
                arr[y + 1] = temp;
            }
            y++;
        }
        x++;
    }

    printf("Sorted Array: \n");

    for (int x = 0; x < num; x++)
    {
        printf("%d ", arr[x]);
    }

    return 0;
}

Result:

Sorted Array:
1 2 3 4 5 6 7 8 9 10
Process returned 0 (0x0)   execution time : 0.035 s
Press any key to continue.

Here's a line-by-line explanation of the program:

#include <stdio.h>

int main()
{

The program starts with the standard main() function and includes the standard library header stdio.h.

    int arr[] = {2, 4, 3, 1, 6, 5, 8, 10, 7, 9};
    int num = 10;
    int x = 0;
    int temp;

The program initializes an integer array arr with 10 integers and initializes integer variables num, x, and temp.

    while (x < num - 1)
    {
        int y = 0;
        while (y < num - 1 - x)
        {
            if (arr[y] > arr[y + 1])
            {
                temp = arr[y];
                arr[y] = arr[y + 1];
                arr[y + 1] = temp;
            }
            y++;
        }
        x++;
    }

The program uses a nested while loop to implement the Bubble Sort algorithm. The outer loop executes num - 1 times and the inner loop executes num - 1 - x times. The variable y is used to iterate through the array. Inside the inner loop, the algorithm compares the current element with the next element of the array. If the current element is greater than the next element, they are swapped using a helper variable temp.

    printf("Sorted Array: \n");

    for (int x = 0; x < num; x++)
    {
        printf("%d ", arr[x]);
    }

    return 0;
}

Finally, the program prints the sorted array using a for loop and returns 0 to indicate successful program execution.

C Program - Bubble Sort Algorithm using Function in C

This is a C program that sorts an array of integers in ascending order using the Bubble Sort algorithm.

#include <stdio.h>

int main()
{

    int arr[] = {2, 4, 3, 1, 6, 5, 8, 10, 7, 9};
    int num = 10;
    int x, y;
    int temp;

    for (x = 0; x < num - 1; x++)
    {
        for (y = 0; y < num - x - 1; y++)
        {
            if (arr[y] > arr[y + 1])
            {
                temp = arr[y];
                arr[y] = arr[y + 1];
                arr[y + 1] = temp;
            }
        }
    }

    printf("Sorted Array: \n");
    for (x = 0; x < num; x++)
    {
        printf("%d ", arr[x]);
    }

    return 0;
}

Result:

Sorted Array:
1 2 3 4 5 6 7 8 9 10
Process returned 0 (0x0)   execution time : 0.031 s
Press any key to continue.

Here's a detailed explanation of each line of the code:

#include <stdio.h>

This line includes the standard input-output header file in the program.

int main()
{

This is the main function of the program.

    int arr[] = {2, 4, 3, 1, 6, 5, 8, 10, 7, 9};

This declares an array of integers with 10 elements and initializes it with some values.

    int num = 10;

This sets the value of num to 10, which is the number of elements in the array.

    int x, y;

These are integer variables used as loop counters.

    int temp;

This is a temporary integer variable used for swapping the values of array elements during the sorting process.

    for (x = 0; x < num - 1; x++)

This is the outer loop that iterates through the array elements from the first element to the second last element.

        for (y = 0; y < num - x - 1; y++)
        {
            if (arr[y] > arr[y + 1])
            {
                temp = arr[y];
                arr[y] = arr[y + 1];
                arr[y + 1] = temp;
            }
        }

This is the inner loop that iterates through the array elements from the first element to the second last element of the unsorted portion of the array. It compares each adjacent pair of elements and swaps them if they are not in the correct order (i.e., the first element is greater than the second element).

    printf("Sorted Array: \n");
    for (x = 0; x < num; x++)
    {
        printf("%d ", arr[x]);
    }

This prints the sorted array elements in ascending order.

    return 0;
}

This statement ends the program and returns 0 to the operating system to indicate successful execution of the program.

Bubble Sort using Functions:

#include <stdio.h> //include standard input-output library

void bubble_sort(int arr[], int num) //declare a function named bubble_sort with parameters: array of integers and size of the array
{
    int x, y; //declare two integer variables to be used in loops
    int temp; //declare a temporary variable to be used for swapping elements in the array

    for (x = 0; x < num - 1; x++) //outer loop for iterating over all elements in the array except the last one
    {
        for (y = 0; y < num - x - 1; y++) //inner loop for comparing adjacent elements in the array
        {
            if (arr[y] > arr[y + 1]) //check if the current element is greater than the next element
            {
                temp = arr[y]; //swap elements if the condition is true using a temporary variable
                arr[y] = arr[y + 1];
                arr[y + 1] = temp;
            }
        }
    }

    printf("Sorted Array: \n"); //print a message indicating that the array is sorted
    for (x = 0; x < num; x++) //iterate over all elements in the sorted array
    {
        printf("%d ", arr[x]); //print each element of the sorted array
    }
}

int main() //start of the main function
{

    int arr[] = {2, 4, 3, 1, 6, 5, 8, 10, 7, 9}; //initialize an array of integers
    int num = sizeof(arr)/sizeof(arr[0]); //get the number of elements in the array

    bubble_sort(arr, num); //call the bubble_sort function with the array and its size as arguments

    return 0; //return 0 to indicate successful program execution
}

Result:

Sorted Array:
1 2 3 4 5 6 7 8 9 10
Process returned 0 (0x0)   execution time : 0.031 s
Press any key to continue.

INDEX

C Program - How to Implement Bubble Sort in C Programming Language

Bubble sort is a simple sorting algorithm that repeatedly steps through the list of elements to be sorted, compares each adjacent pair of elements and swaps them if they are in the wrong order. This process is repeated multiple times until the entire list is sorted.

The algorithm works by starting at the beginning of the list and comparing the first two elements.

If the first element is greater than the second element, they are swapped. Then the algorithm compares the second and third elements, and so on, until the end of the list is reached. This is considered one pass through the list. After the first pass, the largest element in the list will be in its correct place.

The algorithm then starts again with the first element and performs the same process for the remaining elements until the list is fully sorted.

Bubble sort has a time complexity of O(n^2), which makes it less efficient than other sorting algorithms for larger lists. However, it is easy to understand and implement and can be useful for smaller datasets or as a learning exercise.

//buble sort

#include <stdio.h>

int main()          //temp = generic variable, container
{
    //pairs       1   2  3  4  5  6  7  8  9
    int arr[] = {2, 4, 3, 1, 6, 5, 8, 10, 7, 9};
    int num = 10; //we must know this in advance or calculate it
    int x, y; //for for loops, x, y are just positions where elements exists
    int temp; //used only for swaping, helper container

    for (x = 0; x < num - 1 ; x++)
    {
        for (y = 0; y < num - x - 1  ; y++)
        {
            if(arr[y] > arr[y + 1])
            {
                temp = arr[y];
                arr[y] = arr[y + 1];
                arr[y + 1] = temp;
            }
        }
    }

    //this is just normal printing
    printf("Sorted Array: \n");

    for(x = 0; x < num; x++)
    {
        printf("%d  ", arr[x]);
    }

    return 0;

}

Result:

Sorted Array:
1  2  3  4  5  6  7  8  9  10
Process returned 0 (0x0)   execution time : 0.035 s
Press any key to continue.

Here's a line-by-line explanation of the Bubble Sort code:

#include <stdio.h>

This line includes the standard input/output library.

int main()

This line defines the main function, which is the entry point of the program.

int arr[] = {2, 4, 3, 1, 6, 5, 8, 10, 7, 9};

This line creates an integer array of size 10 and initializes it with unsorted values.

int num = 10;

This line defines a variable to store the size of the array.

int x, y, temp;

These lines define variables to be used as counters and a temporary variable to store values during swapping.

for (x = 0; x < num - 1 ; x++)
{
    for (y = 0; y < num - x - 1  ; y++)
    {
        if(arr[y] > arr[y + 1])
        {
            temp = arr[y];
            arr[y] = arr[y + 1];
            arr[y + 1] = temp;
        }
    }
}

These lines of code implement the bubble sort algorithm.

The algorithm compares adjacent elements in an array and swaps them if they are in the wrong order. It repeats this process for each pair of adjacent elements until no more swaps are required.

The outer loop in this code iterates through the array from the first element (index 0) to the second to last element (index num-2). The inner loop iterates through the array from the first element (index 0) to the second to last element minus the number of iterations performed in the outer loop (index num-x-2).

The reason for this is that, after each iteration of the outer loop, the largest element is guaranteed to be in its correct position at the end of the array, so there is no need to compare it with any elements after that position.

Within the inner loop, the code compares the current element at index y with the next element at index y+1.

If the current element is greater than the next element, it means they are in the wrong order, and the code swaps them by assigning the value of the current element to a temporary variable, assigning the value of the next element to the current element, and assigning the value of the temporary variable to the next element.

After both loops complete, the array is sorted in ascending order.

printf("Sorted Array: \n");
for(x = 0; x < num; x++)
{
    printf("%d  ", arr[x]);
}

These lines print out the sorted array.

return 0;

This line indicates the end of the main function and returns a value of zero to the operating system to indicate that the program executed successfully.

Milan Smudja

Thursday, May 1, 2025

C++ Tutorial

HTML Tutorial

Python Tutorial

Wednesday, April 30, 2025

How to Generate CTCSS Tones - Python

C Program - strcmp() Function - Compares Two Strings Character by Character

C Program - strncpy() Function - Copy Specific Number of Characters from a String to Another String

C Program - strcpy() Function - Copy Content of One String into Another String

C Program - strcat() Function - How to Concatenate Strings in C

C Program - strlen() Function Example - Find the Length of a String

C Program - Display its Own Source Code as Output

C Program - Rectangle Calculator - Diagonal, Area, Parimeter

C Program - Tile Calculator - The Total Number of Tiles Necessary to Cover a Surface

C Program - Bubble Sort In C using Nested While Loops

C Program - Bubble Sort Algorithm using Function in C

Bubble Sort using Functions:

C Program - How to Implement Bubble Sort in C Programming Language

Tkinter Introduction - Top Widget, Method, Button