# Class 10 Computer Science Chapter 8 Pointers In C

Class 10 Computer Science Chapter 8 Pointers In C Question Answer, SEBA Class 10 Computer Science Solutions, to each chapter is provided in the list so that you can easily browse throughout different chapters SCERT Class 10 Computer Science Chapter 8 Pointers In C and select needs one.

## Class 10 Computer Science Chapter 8 Pointers In C

Also, you can read the SCERT book online in these sections Solutions by Expert Teachers as per SCERT (CBSE) Book guidelines. NCERT Solution of Class 10 Computer Science Chapter 8 Pointers In C is part of AHSEC All Subject Solutions. Here we have given Class 10 Computer Science Chapter 8 Pointers In C Notes for All Subjects, You can practice these here in Class 10 Computer Science.

### POINTERS IN C

Chapter – 8

COMPUTER SCIENCE

1. How is a pointer variable different from a normal?

Ans. A pointer variable (or pointer in short) is basically the same as the other variables, which can store a piece of data. Unlike normal variable which stores a value (such as an int, a double, a char), a pointer stores a memory address.

Pointers must be declared before they can be used, just like a normal variable.

2. Why is dynamic memory allocation an efficient memory management technique?

Ans. Dynamic memory allocation is memory reusability and memory can be freed when not required. It is more efficient. In this memory allocation scheme, execution is slower than static memory allocation. Here memory can be released at any time during the program. So, dynamic memory allocation is an efficient memory management technique.

3. How many bytes are needed to store an int pointer variable? Is it the same for a char pointer variable?

Ans. To store an int pointer variable, 4 bytes is required.

Yes, char pointer variable also needs 4 bytes.

4. Write the output of the following code segment.

(a)

``````int *ptr, x = 9;

ptr = &x;

printf("\n %d", (*ptr)++);``````

Output:

9

(b)

``````int *ptr, x = 9;

ptr = &x;

printf("\n %d", (*ptr)++);

printf("\n %d", *ptr);``````

Output:

9

10

(c)

``````int *ptr, x = 9;

ptr = &x;

int y = ++(*ptr);

printf("\n %d", y);``````

Output:

10

(d)

``````char *ptr, x = 'A';

ptr = &x;

char y = *ptr;

printf("\n %c", y);``````

Output:

A

(e)

``````char *ptr, x = 'A';

ptr = &x;

char y = (*ptr)++;

printf("\n %c", y);``````

Output:

A

(f)

``````char *ptr, x = 'A';

ptr = &x;

char y = ++(*ptr);

printf("\n %c", y);``````

Output:

B

(g)

``````char *ptr, x = 'A';

ptr = &x;

char *y;

y = ptr;

printf( "\n %c", ++(*y) );``````

Output:

B

5. Write a C program to dynamically allocate memory for an array to store 10 integers and display the first 5 out of them.

Solution:

``````#include <stdio.h>

#include <stdlib.h>

int main() {

int *arr;  // Declare a pointer to int

int size = 10;  // Total size of the array

int i;

// Dynamically allocate memory for the array

arr = (int *)malloc(size * sizeof(int));

if (arr == NULL) {

printf("Memory allocation failed. Exiting...\n");

return 1;

}

// Input values into the array

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

arr[i] = i + 1;  // Filling the array with some values (1 to 10)

}

// Display the first 5 elements of the array

printf("The first 5 elements of the array are: ");

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

printf("%d ", arr[i]);

}

printf("\n");

// Free the dynamically allocated memory

free(arr);

return 0;

}``````

Output:

``The first 5 elements of the array are: 1 2 3 4 5``

6. Write a C program to dynamically allocate memory for an array to store runs scored by Virat Kohli in the last ten ODI cricket matches. Write a function to find the maximum one.

Solution:

Code:

``````#include <stdio.h>

#include <stdlib.h>

// Function to find the maximum run scored

int findMaxRun(int *runs, int size) {

int max = runs[0];  // Initialize max with the first run

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

if (runs[i] > max) {

max = runs[i];  // Update max if a higher run is found

}

}

return max;

}

int main() {

int *runs;  // Declare a pointer to int

int size = 10;  // Total number of matches

int maxRun;

// Dynamically allocate memory for the array

runs = (int *)malloc(size * sizeof(int));

if (runs == NULL) {

printf("Memory allocation failed. Exiting...\n");

return 1;

}

// Input runs scored in the last 10 matches (for demonstration purposes)

printf("Enter runs scored in the last 10 matches:\n");

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

scanf("%d", &runs[i]);

}

// Find the maximum run scored using the function

maxRun = findMaxRun(runs, size);

// Display the maximum run scored

printf("Maximum run scored by Virat Kohli in the last 10 matches: %d\n", maxRun);

// Free the dynamically allocated memory

free(runs);

return 0;

}``````

Output:

``````Enter runs scored in the last 10 matches:

50

68

102

45

78

93

55

120

35

84

Maximum run scored by Virat Kohli in the last 10 matches: 120``````

7. Write a C program and define a function that takes the length of your name as an input parameter and then allocates memory dynamically to store your name. Write another function to display the name.

Solution:

Code:

``````#include <stdio.h>

#include <stdlib.h>

// Function to allocate memory for the name and return a pointer to it

char *allocateName(int length) {

char *name = (char *)malloc((length + 1) * sizeof(char));  // +1 for the null terminator

if (name == NULL) {

printf("Memory allocation failed. Exiting...\n");

exit(1);

}

return name;

}

// Function to display the name

void displayName(char *name) {

}

int main() {

int nameLength;

char *yourName;

// Input the length of your name

printf("Enter the length of your name: ");

scanf("%d", &nameLength);

// Allocate memory for your name

yourName = allocateName(nameLength);

scanf("%s", yourName);

displayName(yourName);

// Free the dynamically allocated memory

free(yourName);

return 0;

}``````

Output:

``````Enter the length of your name: 10

8. Write a C program to store some integer variables in an array. Then write functions to the following:

(a) To calculate the number of even numbers in the array.

(b) To dynamically allocate memory to a new array to a new array to store only the even numbers.

(c) To copy the even numbers from the first array to the second one.

Solution:

Code:

``````#include <stdio.h>

#include <stdlib.h>

// Function to calculate the number of even numbers in the array

int countEvenNumbers(int *arr, int size) {

int count = 0;

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

if (arr[i] % 2 == 0) {

count++;

}

}

return count;

}

// Function to create a new array and copy even numbers from the original array

int *copyEvenNumbers(int *arr, int size, int evenCount) {

int *evenArr = (int *)malloc(evenCount * sizeof(int));

if (evenArr == NULL) {

printf("Memory allocation failed. Exiting...\n");

exit(1);

}

int j = 0;

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

if (arr[i] % 2 == 0) {

evenArr[j] = arr[i];

j++;

}

}

return evenArr;

}

int main() {

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

int size = sizeof(originalArray) / sizeof(originalArray[0]);

// (a) Calculate the number of even numbers in the array

int evenCount = countEvenNumbers(originalArray, size);

printf("Number of even numbers in the array: %d\n", evenCount);

// (b) Dynamically allocate memory for a new array to store even numbers

int *evenArray = copyEvenNumbers(originalArray, size, evenCount);

// (c) Display the even numbers from the new array

printf("Even numbers in the new array: ");

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

printf("%d ", evenArray[i]);

}

printf("\n");

// Free the dynamically allocated memory

free(evenArray);

return 0;

}``````

Output:

``````Number of even numbers in the array: 5

Even numbers in the new array: 2 4 6 8 10``````

9. Write a C program to store some integer variables in an array. Then write functions to do the following:

(a) To calculate the number of non-zero elements that are divisible by 3.

(b) To dynamically allocate to store only those elements.

(c) To copy the selected elements from the first array to the second one.

(d) To calculate the summation of these elements.

Solution:

Code:

``````#include <stdio.h>

#include <stdlib.h>

// Function to calculate the number of non-zero elements divisible by 3

int countDivisibleBy3(int *arr, int size) {

int count = 0;

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

if (arr[i] != 0 && arr[i] % 3 == 0) {

count++;

}

}

return count;

}

// Function to create a new array and copy elements divisible by 3

int *copyDivisibleBy3(int *arr, int size, int count) {

int *newArr = (int *)malloc(count * sizeof(int));

if (newArr == NULL) {

printf("Memory allocation failed. Exiting...\n");

exit(1);

}

int j = 0;

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

if (arr[i] != 0 && arr[i] % 3 == 0) {

newArr[j] = arr[i];

j++;

}

}

return newArr;

}

// Function to calculate the summation of elements in an array

int calculateSum(int *arr, int size) {

int sum = 0;

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

sum += arr[i];

}

return sum;

}

int main() {

int originalArray[] = {1, 0, 9, 12, 6, 15, 0, 18, 3, 0};

int size = sizeof(originalArray) / sizeof(originalArray[0]);

// (a) Calculate the number of non-zero elements divisible by 3

int countDivisible = countDivisibleBy3(originalArray, size);

printf("Number of non-zero elements divisible by 3: %d\n", countDivisible);

// (b) Dynamically allocate memory for a new array to store selected elements

int *newArray = copyDivisibleBy3(originalArray, size, countDivisible);

// (c) Display the selected elements from the new array

printf("Elements divisible by 3 in the new array: ");

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

printf("%d ", newArray[i]);

}

printf("\n");

// (d) Calculate the summation of the selected elements

int sum = calculateSum(newArray, countDivisible);

printf("Summation of elements divisible by 3: %d\n", sum);

// Free the dynamically allocated memory

free(newArray);

return 0;

}``````

Output:

``````Number of non-zero elements divisible by 3: 5

Elements divisible by 3 in the new array: 9 12 6 15 18

Summation of elements divisible by 3: 60``````
Scroll to Top