Question

Generate an array of random numbers in C++

1)The size of the array is defined by the user

2) The application is to take every odd number and find the mean.

Program has to use structured programing and pointers

Answer 1

`Hey,

Note: Brother if you have any queries related the answer please do comment. I would be very happy to resolve all your queries.

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

Online C++ Compiler.
Code, Compile, Run and Debug C++ program online.
Write your code in this editor and press "Run" button to compile and execute it.

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

#include <iostream>
#include<cstdlib>
#include<ctime>
using namespace std;

int main()
{
srand(time(NULL));
int n;
cout<<"Enter size: ";
cin>>n;
int* arr=new int[n];
for(int i=0;i<n;i++)
{
*(arr+i)=rand()%100+1;
}
double avg=0;
for(int i=0;i<n;i++)
{
if(*(arr+i)%2==1)
avg+=*(arr+i);
}
avg=avg/(double)n;
cout<<"Mean of odd numbers in array are: "<<avg<<endl;
return 0;
}

Kindly revert for any queries

Thanks.

Answer 2

#include <iostream>

#include <vector>

#include <cstdlib> // For rand(), srand()

#include <ctime>   // For time()

// Function to generate an array of random numbers

int* generateRandomArray(int size) {

    int* arr = new int[size]; // Allocate memory for the array

    // Seed the random number generator

    srand(static_cast<unsigned int>(time(0))); 

    for (int i = 0; i < size; ++i) {

        arr[i] = rand() % 100; // Generate random numbers between 0 and 99

    }

    return arr;

}

// Function to calculate the mean of odd numbers in an array

double calculateMeanOfOddNumbers(int* arr, int size) {

    std::vector<int> oddNumbers; // Store odd numbers found

    for (int i = 0; i < size; ++i) {

        if (*(arr + i) % 2 != 0) { // Check if the number is odd using pointer arithmetic

            oddNumbers.push_back(*(arr + i)); 

        }

    }

    if (oddNumbers.empty()) {

        return 0.0; // Return 0 if no odd numbers are found

    }

    double sum = 0.0;

    for (int num : oddNumbers) {

        sum += num;

    }

    return sum / oddNumbers.size();

}

int main() {

    int size;

    // Get the size of the array from the user

    std::cout << "Enter the size of the array: ";

    std::cin >> size;

    // Generate the random array

    int* randomArray = generateRandomArray(size);

    // Display the generated array

    std::cout << "Generated Array: ";

    for (int i = 0; i < size; ++i) {

        std::cout << *(randomArray + i) << " "; // Display using pointer arithmetic

    }

    std::cout << std::endl;

    // Calculate and display the mean of odd numbers

    double meanOfOdd = calculateMeanOfOddNumbers(randomArray, size);

    std::cout << "Mean of Odd Numbers: " << meanOfOdd << std::endl;

    // Deallocate the dynamically allocated memory

    delete[] randomArray;

    return 0;

}

C++

#include <iostream>#include <vector>#include <cstdlib> // For rand(), srand()#include <ctime>   // For time()// Function to generate an array of random numbersint* generateRandomArray(int size) {    int* arr = new int[size]; // Allocate memory for the array
    // Seed the random number generator
    srand(static_cast<unsigned int>(time(0))); 
    for (int i = 0; i < size; ++i) {
        arr[i] = rand() % 100; // Generate random numbers between 0 and 99
    }    return arr;
}// Function to calculate the mean of odd numbers in an arraydouble calculateMeanOfOddNumbers(int* arr, int size) {    std::vector<int> oddNumbers; // Store odd numbers found
    for (int i = 0; i < size; ++i) {        if (*(arr + i) % 2 != 0) { // Check if the number is odd using pointer arithmetic
            oddNumbers.push_back(*(arr + i)); 
        }
    }    if (oddNumbers.empty()) {        return 0.0; // Return 0 if no odd numbers are found
    }    double sum = 0.0;    for (int num : oddNumbers) {
        sum += num;
    }    return sum / oddNumbers.size();
}int main() {    int size;    // Get the size of the array from the user
    std::cout << "Enter the size of the array: ";    std::cin >> size;    // Generate the random array
    int* randomArray = generateRandomArray(size);    // Display the generated array
    std::cout << "Generated Array: ";    for (int i = 0; i < size; ++i) {        std::cout << *(randomArray + i) << " "; // Display using pointer arithmetic
    }    std::cout << std::endl;    // Calculate and display the mean of odd numbers
    double meanOfOdd = calculateMeanOfOddNumbers(randomArray, size);    std::cout << "Mean of Odd Numbers: " << meanOfOdd << std::endl;    // Deallocate the dynamically allocated memory
    delete[] randomArray;    return 0;
}

Explanation:

1. generateRandomArray(int size):

• Takes the desired array size as input.

• Dynamically allocates memory for the array using new int[size].

• Seeds the random number generator using srand(time(0)) to ensure different random numbers each time the program runs.

• Generates random numbers between 0 and 99 (you can change the range by modifying rand() % 100) and stores them in the array.

• Returns a pointer to the generated array.

2. calculateMeanOfOddNumbers(int* arr, int size):

• Takes the array pointer and size as input.

• Creates a std::vector<int> to store the odd numbers found in the array.

• Iterates through the array using pointer arithmetic (*(arr + i)) to access elements.

• Checks if each element is odd using the modulo operator (% 2 != 0).

• If an element is odd, it's added to the oddNumbers vector.

• Calculates the sum of the odd numbers and divides by the count to find the mean.

• Returns the mean (or 0.0 if no odd numbers are found).

3. main():

• Gets the array size from the user.

• Calls generateRandomArray() to create the array.

• Displays the generated array using pointer arithmetic.

• Calls calculateMeanOfOddNumbers() to get the mean of odd numbers.

• Displays the calculated mean.

• Crucially, deallocates the memory allocated for the array using delete[] randomArray to prevent memory leaks.

Key Concepts:

• Pointers: The code uses pointers (int*) to work with arrays and access elements using pointer arithmetic.

• Dynamic Memory Allocation: new and delete[] are used to allocate and deallocate memory dynamically, allowing the array size to be determined at runtime.

• Structured Programming: The code is organized into functions (generateRandomArray, calculateMeanOfOddNumbers) for better readability and maintainability.

• Vectors (Optional but Recommended): Using std::vector to store the odd numbers makes the code more flexible and easier to manage, as you don't need to know the exact number of odd numbers in advance.

• Random Number Generation: srand() and rand() are used to generate random numbers.