main()
{
     int i;
     i = abc();
     printf("%d",i);
}
abc()
{
     _AX = 1000;
}

Answer:
     1000
Explanation:
     Normally the return value from the function is through the information from the accumulator. Here _AH is the pseudo global variable denoting the accumulator. Hence, the value of the accumulator is set 1000 so the function returns value 1000.

int i;
main()
{
     int t;
     for ( t=4;scanf("%d",&i)-t;printf("%d\n",i))
          printf("%d--",t--);
}
// If the inputs are 0,1,2,3 find the o/p

Answer:
     4--0
     3--1
     2--2
Explanation:
     Let us assume some x= scanf("%d",&i)-t the values during execution will be,
               t   i     x
               4  0   -4
               3  1   -2
               2  2    0

main(){
     int a= 0;int b = 20;char x =1;char y =10;
     if(a,b,x,y)
          printf("hello");
}

Answer:
     hello
Explanation:
     The comma operator has associativity from left to right. Only the rightmost value is returned and the other values are evaluated and ignored. Thus the value of last variable y is returned to check in if. Since it is a non zero value if becomes true so, "hello" will be printed.

main(){
unsigned int i;
for(i=1;i>-2;i--)
printf("c aptitude");
}

Explanation:
     i is an unsigned integer. It is compared with a signed value. Since the both types doesn't match, signed is promoted to unsigned value. The unsigned equivalent of -2 is a huge value so condition becomes false and control comes out of the loop.

In the following pgm add a stmt in the function fun such that the address of 'a' gets stored in 'j'.
main(){
      int * j;
      void fun(int **);
      fun(&j);
}
void fun(int **k) {
      int a =0;
      /* add a stmt here*/
}

Answer:
     *k = &a
Explanation:
     The argument of the function is a pointer to a pointer.

What are the following notations of defining functions known as?
i. int abc(int a,float b)
{
      /* some code */
}
ii. int abc(a,b)
int a; float b;
{
      /* some code*/
}

Answer:
     i. ANSI C notation
     ii. Kernighan & Ritche notation

main()
{
     char *p;
     p="%d\n";
     p++;
     p++;
     printf(p-2,300);
}

Answer:
     300
Explanation:
     The pointer points to % since it is incremented twice and again decremented by 2, it points to '%d\n' and 300 is printed.

main(){
     char a[100];
     a[0]='a';a[1]]='b';a[2]='c';a[4]='d';
     abc(a);
}
abc(char a[]){
     a++;
     printf("%c",*a);
     a++;
     printf("%c",*a);
}

Explanation:
     The base address is modified only in function and as a result a points to 'b' then after incrementing to 'c' so bc will be printed.

func(a,b)
int a,b;
{
     return( a= (a==b) );
}
main()
{
     int process(),func();
     printf("The value of process is %d !\n ",process(func,3,6));
}
process(pf,val1,val2)
int (*pf) ();
int val1,val2;
{
     return((*pf) (val1,val2));
}

Answer:
     The value if process is 0 !
Explanation:
     The function 'process' has 3 parameters - 1, a pointer to another function 2 and 3, integers. When this function is invoked from main, the following substitutions for formal parameters take place: func for pf, 3 for val1 and 6 for val2. This function returns the result of the operation performed by the function 'func'. The function func has two integer parameters. The formal parameters are substituted as 3 for a and 6 for b. since 3 is not equal to 6, a==b returns 0. therefore the function returns 0 which in turn is returned by the function 'process'.

void main()
{
     static int i=5;
     if(--i){
          main();
          printf("%d ",i);
     }
}

Answer:
     0 0 0 0
Explanation:
     The variable "I" is declared as static, hence memory for I will be allocated for only once, as it encounters the statement. The function main() will be called recursively unless I becomes equal to 0, and since main() is recursively called, so the value of static I ie., 0 will be printed every time the control is returned.