C Programming Variables and Data Types Exercises

#include <stdio.h>

int main() {
    int num1 = 10;
    int num2 = 5;

    int sum = num1 + num2;
    int difference = num1 - num2;
    int product = num1 * num2;
    int quotient = num1 / num2;

    printf("Sum: %d\n", sum);
    printf("Difference: %d\n", difference);
    printf("Product: %d\n", product);
    printf("Quotient: %d\n", quotient);

    return 0;
}Code language: C++ (cpp)

Explanation:

• Inside the main function, two integer variables, num1 and num2, are declared and initialized.
• We then perform the four basic arithmetic operations and store the results in separate integer variables: sum, difference, product, and quotient.
• Finally, printf is used to print the label for each result followed by its value, using the %d format specifier to represent the integer data.

#include <stdio.h>

int main() {
    float f1 = 15.5f;
    float f2 = 7.2f;

    float sum = f1 + f2;
    float difference = f1 - f2;
    float product = f1 * f2;

    printf("Sum: %.2f\n", sum);
    printf("Difference: %.2f\n", difference);
    printf("Product: %.2f\n", product);

    return 0;
}Code language: C++ (cpp)

Explanation:

• The program uses float variables for decimal numbers. The f suffix on the values ensures they are treated as floats.
• The arithmetic operations are performed, and the results are printed using printf with the %.2f format specifier, which limits the output to two decimal places.

#include <stdio.h>

int main() {
    char ch;

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

    printf("The ASCII value of '%c' is %d\n", ch, ch);

    return 0;
}Code language: C++ (cpp)

Explanation:

• This program reads a character from the user using scanf and stores it in a char variable.
• When printf is called, the same variable is passed twice: once with %c to print the character itself, and again with %d to print its integer ASCII value. This works because C internally stores characters as their corresponding ASCII numbers.

#include <stdio.h>

int main() {
    printf("Size of int: %zu bytes\n", sizeof(int));
    printf("Size of float: %zu bytes\n", sizeof(float));
    printf("Size of double: %zu bytes\n", sizeof(double));
    printf("Size of char: %zu bytes\n", sizeof(char));
    printf("Size of long double: %zu bytes\n", sizeof(long double));

    return 0;
}Code language: C++ (cpp)

Explanation:

• The program uses the sizeof operator to check the memory footprint of different data types. This size can vary depending on the system’s architecture (e.g., 32-bit vs. 64-bit).
• The %zu format specifier is the correct way to print the size_t value returned by sizeof.

#include <stdio.h>

int main() {
    int intVar = 10;
    float floatVar = 25.75f;

    // Casting float to int
    int castedInt = (int)floatVar;
    printf("Casting float (%.2f) to int: %d\n", floatVar, castedInt);

    // Casting int to float
    float castedFloat = (float)intVar;
    printf("Casting int (%d) to float: %.2f\n", intVar, castedFloat);

    return 0;
}Code language: C++ (cpp)

Explanation:

• This program shows explicit type conversion.
• When a float is cast to an int, the decimal part is truncated. When an int is cast to a float, it’s converted to a floating-point number with a decimal and a zero. The original variables remain unchanged.

#include <stdio.h>

int main() {
    int a = 5;
    int b = 10;
    int temp;

    printf("Before swap: a = %d, b = %d\n", a, b);

    temp = a;
    a = b;
    b = temp;

    printf("After swap: a = %d, b = %d\n", a, b);

    return 0;
}Code language: C++ (cpp)

Explanation:

• A third variable, temp, is used to temporarily store the value of a.
• The value of b is then assigned to a, and finally, the value from temp (the original value of a) is assigned to b.

#include <stdio.h>

int main() {
    int a = 5;
    int b = 10;

    printf("Before swap: a = %d, b = %d\n", a, b);

    a = a + b;
    b = a - b;
    a = a - b;

    printf("After swap: a = %d, b = %d\n", a, b);

    return 0;
}Code language: C++ (cpp)

Explanation:

This technique uses a sequence of additions and subtractions to swap the values. It avoids the need for a temporary variable, but it’s important to be aware of potential integer overflow if the sum of the two variables exceeds the data type’s limit.

#include <stdio.h>

int main() {
    int age;
    char name[50];

    printf("Enter your age: ");
    scanf("%d", &age);

    printf("Enter your first name: ");
    scanf("%s", name);

    printf("You are %d years old and your name is '%s'.\n", age, name);

    return 0;
}Code language: C++ (cpp)

Explanation:

This program takes user input using scanf. The & symbol is the address-of operator; it provides scanf with the memory address of the variable so it can store the input value there.

#include <stdio.h>

#define PI 3.14159

int main() {
    float radius = 5.0f;
    float area = PI * radius * radius;

    printf("The area of a circle with radius %.2f is %.2f\n", radius, area);

    return 0;
}Code language: C++ (cpp)

Explanation:

• This program uses a #define constant for Pi.
• The preprocessor replaces all occurrences of PI with 3.14159 before the code compiles.
• The area is calculated and printed with two decimal places using the %.2f format specifier.

#include <stdio.h>

int main() {
    int num1, num2, num3;
    float average;

    printf("Enter three integers: ");
    scanf("%d %d %d", &num1, &num2, &num3);

    average = (float)(num1 + num2 + num3) / 3;

    printf("The average is: %.2f\n", average);

    return 0;
}Code language: C++ (cpp)

Explanation:

• First, we take three integer values from the user.
• To calculate a precise average with decimal places, we need to perform floating-point division. By using the type cast (float) on the sum, we force the entire expression to be evaluated as a float, ensuring the division by 3 yields a floating-point number.

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

int main() {
    int max_int = INT_MAX;
    printf("Maximum value of int: %d\n", max_int);

    int overflow_int = max_int + 1;
    printf("After incrementing: %d\n", overflow_int);

    return 0;
}Code language: C++ (cpp)

Explanation:

• This program illustrates a critical concept in C: integer overflow. The INT_MAX macro from the <limits.h> header provides the largest possible value for an int. When we add 1 to INT_MAX, the value exceeds the maximum capacity of the variable, causing it to wrap around to the lowest possible negative value.
• This unexpected behavior highlights the importance of choosing the correct data type for the range of values you expect to handle.

#include <stdio.h>

int main() {
    long long int large_number = 9876543210987654321LL;

    printf("The large number is: %lld\n", large_number);

    return 0;
}Code language: C++ (cpp)

Explanation:

This program demonstrates how to handle values that exceed the range of a standard int. The long long int data type is at least 64 bits wide, capable of storing much larger numbers.

The LL suffix on the number literal explicitly tells the compiler to treat it as a long long int. The %lld format specifier is specifically used to print long long int values.

#include <stdio.h>

int main() {
    int decimal_num = 255;

    printf("The decimal number %d in hexadecimal is: %x\n", decimal_num, decimal_num);

    return 0;
}Code language: C++ (cpp)

Explanation:

C’s printf function provides several format specifiers. The %x specifier directly interprets the integer value as a hexadecimal (base 16) number and prints its representation.

#include <stdio.h>

int main() {
    int octal_num = 015; // Represents 13 in decimal

    printf("The octal number 015 in decimal is: %d\n", octal_num);

    return 0;
}Code language: C++ (cpp)

Explanation:

This exercise highlights how C handles numbers in different bases. The leading 0 in 015 tells the compiler that the number is an octal (base 8) literal.

Internally, the computer still stores this value as its decimal equivalent (1*8^1 + 5*8^0 = 13). When we print the value using the %d format specifier, it is correctly displayed as 13.

#include <stdio.h>

int main() {
    const float PI = 3.14159f;

    // The following line will cause a compile-time error
    // PI = 3.14f;

    printf("The constant value of PI is: %f\n", PI);

    return 0;
}Code language: C++ (cpp)

Explanation:

Once a const variable is initialized, any attempt to reassign it a new value will result in a compile-time error. This prevents accidental modification of important values in your code, making it safer and more reliable.

#include <stdio.h>

int main() {
    int ascii_val;

    printf("Enter an ASCII value (0-127): ");
    scanf("%d", &ascii_val);

    printf("The character for ASCII %d is: %c\n", ascii_val, ascii_val);

    return 0;
}Code language: C++ (cpp)

Explanation:

The program reads an integer value into ascii_val. This exercise showcases the relationship between integers and characters in C.

When the int variable is printed using the %c format specifier, the compiler treats the integer value as an ASCII code and outputs the corresponding character.

#include <stdio.h>

int main() {
    int x = 10; // Outer scope variable

    printf("Outer x: %d\n", x);

    { // Start of Inner Block/Scope
        int x = 50; // Inner scope variable (Shadows outer x)
        int y = 5;

        printf("Inner x: %d\n", x);
        printf("Inner y: %d\n", y);
    } // End of Inner Block/Scope

    printf("Outer x (after inner block): %d\n", x);
    // printf("%d", y); // This would cause a compile-time error!

    return 0;
}Code language: C++ (cpp)

Explanation:

• This program demonstrates variable scope. The first x is declared in the main function’s scope.
• Inside the inner block, a new variable named x is declared and initialized to 50; this shadows the outer x.
• The inner printf sees the value 50. After the inner block ends, the inner x is destroyed, and the outer x (value 10) is visible again. Variables like y are only accessible within their declared block.

#include <stdio.h>

int main() {
    int count = 7;
    float price = 3.50f;

    // Result of count * price is automatically a float (24.50)
    float total_float = count * price;

    // Explicitly cast the floating-point result to an integer
    int total_int = (int)(count * price);

    printf("Floating-point result: %.2f\n", total_float);
    printf("Casted integer result (truncation): %d\n", total_int);

    return 0;
}Code language: C++ (cpp)

Explanation:

• When mixing an int and a float in an expression (count * price), C performs implicit type promotion, converting the int to a float before multiplication.
• The result (24.5) is a float. The line with total_int uses an explicit type cast (int) to convert the floating-point result back to an integer, which truncates the fractional part (.5), yielding 24.

#include <stdio.h>

int main() {
    char char1, char2;
    int sum_ascii;

    printf("Enter two characters: ");
    // Note: space before %c to consume whitespace
    scanf(" %c %c", &char1, &char2); 

    sum_ascii = char1 + char2;

    printf("The ASCII value of '%c' is %d\n", char1, char1);
    printf("The ASCII value of '%c' is %d\n", char2, char2);
    printf("Sum of ASCII values: %d\n", sum_ascii);

    return 0;
}Code language: C++ (cpp)

Explanation:

• In C, when arithmetic operations are performed on char variables, they are automatically promoted to ints to perform the calculation.
• Therefore, adding char1 and char2 effectively adds their corresponding ASCII values. The result is stored in the int variable sum_ascii and printed as an integer.

#include <stdio.h>

int main() {
    int quantity = 3;
    float unit_price = 15.75f;
    char code = 'A';

    printf("Item Code: %c, Quantity: %d, Total Price: $%.2f\n", 
           code, quantity, quantity * unit_price);

    return 0;
}Code language: C++ (cpp)

Explanation:

This exercise focuses on using the full capability of the printf function. A single statement is used to combine different data types (char, int, and the result of a float calculation) into one descriptive output sentence.

The use of specific format specifiers (like %.2f for currency) ensures the output is properly formatted.

#include <stdio.h>

int main() {
    double large_num = 1234567890.12345;
    double small_num = 0.00000000123;

    printf("Large number in standard format: %f\n", large_num);
    printf("Large number in exponential format: %e\n", large_num);
    
    printf("Small number in exponential format: %e\n", small_num);

    return 0;
}Code language: C++ (cpp)

Explanation:

The %e format specifier tells printf to display the double value in the form of mantissa and exponent (e.g., 1.234568e+09), a concise way to handle vast numerical ranges.