Solution

Solution

In C, pointer multiplication and pointer division are not allowed.

Here,

j = j * 2;

and

k = k / 2;

are invalid operations.

Solution

Given loop invariant is

$m \times x^k=p^n$

At the end of the while loop, condition becomes false.

So,

$k=0$

Putting $k=0$ in invariant,

$m \times x^0=p^n$

Since,

$x^0=1$

Therefore,

$m=p^n$

Solution

Given that structure $S$ takes $32$ bits.

So,

$32\text{ bits}=4\text{ bytes}$

Now,

$p$ points to $B[4]$

$q$ points to $B[5]$

Since $p$ and $q$ are pointers of type $S$, pointer subtraction gives the difference in number of structures.

So,

$q-p=1$

Therefore,

$M=1$

Now, union $U$ contains $unsigned\ char\ a$ and $unsigned\ short\ b$.

Size of union $U$ is $2$ bytes.

After union $U$, variable $c$ is stored.

So, offset of $c$ from the beginning of structure is $2$ bytes.

Therefore,

$N=2$

Hence,

$(M,N)=(1,2)$

Solution

Solution

Solution

The expression $n$ bitwise AND $1$ checks the last bit of $n$.

If the last bit is $1$, then $b$ increases by $1$.

After that, $n$ is shifted right by one bit.

So, the loop checks each bit of $n$ one by one.

Therefore, $b$ counts the total number of $1$'s in the binary representation of $n$.

Solution

p is a pointer variable and must store the address of x, written as:

p = &x;

But the program assigns:

p = x;

which means an integer is assigned to a pointer, causing a compilation error (type mismatch).

Solution

Solution

Outer loop runs for:

$i=0,1,2,3,4$

Inner loop runs only when $j<i$.

But inside inner loop, there is a $break$ statement, so inner loop executes only one time for each valid value of $i$.

For $i=0$:

$j<0$ is false, so inner loop does not execute.

For $i=1$:

$x=x+(1+0-1)=0+0=0$

For $i=2$:

$x=x+(2+0-1)=0+1=1$

For $i=3$:

$x=x+(3+0-1)=1+2=3$

For $i=4$:

$x=x+(4+0-1)=3+3=6$

So, final value of $x$ is:

$x=6$

Solution

Solution

Solution

Solution

Solution

Correct file handling sequence in C:

Open file

Check for error

Read / Write

Close file

Thus order:

(C) → (D) → (B) → (A)

Solution

Solution

Function pointer syntax:

return_type (*pointer_name)(arguments);

Example:

int (*func)(int,int);

Meaning:

func is a pointer

pointing to a function

returning int

taking two int parameters

Thus correct declaration:

int (*func)(int,int);

Solution

Recursive calls divide $y$ by $3$ each time.

Call sequence:

$fun(4,81)$
$fun(4,27)$
$fun(4,9)$
$fun(4,3)$

Total calls = 4

Each call increments temp.

So

$temp = 4$

Solution

Statement (a) is not legal because we cannot take the address of a constant value like $44$.

Statement (b) is legal because if $r$ is an integer variable, then &r gives its address and it can be stored in an integer pointer.

Statement (c) is not legal because &a gives address, but $P$ is declared as normal integer, not pointer.

Statement (d) is legal because if $a$ is an integer variable, then its value can be assigned to integer variable $P$.

So, legal statements are:

(b) and (d)

Solution

Solution

Solution

Initial:

arr = {1,2,3,4,5}

p → arr[0]

First statement:

*p++

Post-increment

Value printed = *p = 1

Then pointer moves to next element.

Now:

p → arr[1]

Second statement:

*(p+1)

p+1 → arr[2]

Value = 3

Output:

1 3

Solution

Observe recursion:

Each call prints * while dividing a by 2.

Sequence:

10 → 5 → 2 → 1

For each b value, stars printed = 3.

b decreases from 10 to 1.

Thus:

$9 \times 3 = 27$

Total stars printed = 27.

Solution

Solution

Given code returns $false$ when:

$((x>25) \land (y>100))$

or

$((x>25) \land (y \le 100))$

So,

$false = (x>25)$

Therefore, the code returns $true$ when:

$x \le 25$

Hence, the required Boolean expression is:

$x \le 25$

Solution

Solution

For $n$ bits:

Unsigned range is:

$0$ to $2^n-1$

Signed range is:

$-2^{n-1}$ to $2^{n-1}-1$

So, signed data type does not have more range than unsigned data type.

Solution

Solution

Solution

Consider ar as a 3-dimensional array declared as:

data_type ar[a][b][c];

Here, the array element ar[m][n][o] can be represented in pointer form as:

*(*(*(ar + m) + n) + o)

Step-by-step understanding:

• ar is a pointer to the first 2D array ar[0].
• ar + m moves the pointer to the m^th 2D array → ar[m].
• *(ar + m) gives the address of the first 1D array inside ar[m].
• *(ar + m) + n moves to the n^th 1D array → ar[m][n].
• *(*(ar + m) + n) gives the address of the first element of that 1D array.
• *(*(*(ar + m) + n) + o) finally gives the element ar[m][n][o].

✅ Final Answer: *(*(*(ar + m) + n) + o)

Solution

Solution

The correct execution flow in a programming environment is:

Programming statement (A) – Program is written.

Compilation (B) – Code is compiled to machine/intermediate code.

Type of variable (D) – Variables are recognized with their types.

Memory allocation (C) – Memory is allocated during execution.

Memory deallocation (E) – Memory is released after execution.

Thus the correct order is:

Solution

Solution

Solution

Solution

Solution

Memory allocated using malloc() is released using free().

Here, memory is allocated to pointer p, so it should be freed as: free(p);

Solution

In a do-while loop, initialization is done first.

Then the loop body executes at least once.

After executing the body, the condition is tested.

So, correct order is:

Initialisation → Execution of the body → Testing the condition

That is:

III, II, IV