GATE CSE 2017 Set 1 | Question: 53

Question

Consider the following C program.

#include<stdio.h>
#include<string.h>

void printlength(char *s, char *t) {
    unsigned int c=0;
    int len = ((strlen(s) - strlen(t)) > c) ? strlen(s) : strlen(t);
    printf("%d\n", len);
}

void main() {
    char *x = "abc";
    char *y = "defgh";
    printlength(x,y);
}

Recall that $strlen$ is defined in $string.h$ as returning a value of type $size\_t$, which is an unsigned int. The output of the program is __________ .

Comments

Can we say that while comparing the value -2 with 0

first we have to make -2 as unsigned which is 6 in unsigned 3 bits

we will say it is 6>0 hence a true case?

I got you

---

My doubt is that, as x is storing address of abc string and y storing add of defgh string and we are passing address and then providing address to strlen operator would it work properly ? I mean how can strlen operator can take address as an argument ?

---

Usefull 

answer is 3

x and y are pointers and points to string "abc" and "defgh" and printlength(x,y) is called ,now x and y's values means base address of string "abc" and "defgh" is copied to s and t respectively.

1-here c is declared as unsigned int so it can't store negative values.

2-strlen() function is used  to find the actual length of string.

strlen(s)==3 and strlen(t)=5

strlen(s)-strlen(t)=3-5=-2 (signed value) >0=?

Note-we can't compare signed value and unsigned value so we need to convert -2 into unsigned value with the help of 2's complement.

if we take int as 2 bytes(16 bits) then 2's complement value of -2 =2^16-2 =65534

hence we can say 65534>0 so length=strlen(s)=3

Answer 1

$(strlen(s)- strlen(t)) = 3-5 =-2$

But in C, when we do operation with two unsigned integers, result is also unsigned. ($strlen$ returns $size\_t$ which is unsigned in most systems). So, this result "$-2$" is treated as unsigned and its value is $\textsf{INT_MAX}-2$ (not sure about all systems, but at least on systems using $2$'s complement representation). Now, the comparison is between this large number and another unsigned number $c$ which is $0$. So, the comparison return TRUE here.

Even if '$c$' is declared as "$int$", while doing an operation with an unsigned int, it gets promoted to unsigned int and we get the same result.

Hence $(strlen(s)- strlen(t)) >0$ will return $1$ on execution thus the conditional operator will return the true statement which is $strlen(abc) =3$.

Ans should be $3$.

Comments

Unsigned int..... Therefore -ve value will be wrapped around and will be greater than zero...... Therefore...answer is 3....But didn think like this in exam.... :(

---

Try to print -2 as unsigned integer.

---

@Arnabi Due to representation. Even though number is "-2" we are telling compiler and eventually hardware to treat it as an unsigned number which would be MAX_INT - 2.

---

arjun sir pls check the 1-43 question

---

okk got it now.Thanks arjun sir and all..:)

---

#include<stdio.h>
int main(){
    if(-2>0){
        printf("true");
    }
    else{
        printf("flase\n");
    }
return 0;
}

Output:

niraj@niraj-Lenovo-B460:~/socket_programming$ gcc compare.c
niraj@niraj-Lenovo-B460:~/socket_programming$ ./a.out
flase

 

so -2>0 is flase not true

---

Try (-2 > (unsigned int) 0) . You will get True

---

-2 in unsigned int is the same as 2³²-2 =  4294967294

Hence -2 > 0 is true for unsigned int.

---

but why -2 should be converted in unsigned int?

It is not told that s, t are in unsigned int.

And it stores in len which is 'int' only. It can be signed int.rt?

---

Well if you have a variable of type int, and it contains a negative value such as -9 then how do you convert this to an unsigned data type and what exactly happens if you perform a cast as shown above? Well the basic answer is – nothing. No bits are changed, the compiler just treats the bit representation as unsigned. For example, let us assume that the compiler represents signed integers using 2’s complement notation (this is the norm – but is *not* mandated by the C language). If our signed integer is a 16 bit value, and has the value -9, then its binary representation will be 1111111111110111. If you now cast this to an unsigned integer, then the unsigned integer will have the value 0xFFF7 or 65527₁₀. Note however that you cannot rely upon the fact that casting -9 to an unsigned type will result in the value 0xFFF7. Whether it does or not depends entirely on how the compiler chooses to represent negative numbers.

---

@sushmita

len is int, not an unsigned int. rt?

and as u said it is compiler dependent, then how could u sure the answer?

---

Sretha because in c if we are having unsigned int operands first by typecasting other operands are also promoted to unsigned int and hence -2 will no longer be -2. It will be a positive number only.

---

ok means len here promoted to unsigned int.

---

The Answer is 3 but I found somewhat a different explanation.
Even if 'unsigned int c' is not given, ((strlen (s) - strlen (t)) > c) would return true(and print 3 as output) since strlen() function always returns unsigned value. So, strlen(s) - strlen(t) will yield unsigned-unsigned= unsigned value which, upon being compared with c( even if it is signed), would return TRUE( and print 3 ) since c will be converted to unsigned.

So, having unsigned/siged int c doesn't make much of a dfference.

---

You are correct.

---

the definition of strlen function is given in string.h header file and the output of the strlen function retrun a value of type size_t form and size_t is a unsigned integer . so in each case  ((strlen(s) - strlen(t)) > c) return a unsigned value, it is not matter that whether c is given unsigned or not.

if c is not given unsgined then answer also will be same .

---

Binary operations between different integral types are performed within a "common" type defined by so called usual arithmetic conversions (see the language specification, 6.3.1.8)

Reference : https://stackoverflow.com/questions/2084949/comparison-operation-on-unsigned-and-signed-integers

C Language Specification URL : www.open-std.org/jtc1/sc22/wg14/www/docs/n1124.pdf

So here (strlen(s)-strlen(t)) which is coming as -2 is converted to first unsigned int (which evaluates to INT_MAX-2) and then it is compared with c(c being unsigned int) which is 0.

The result of the boolean expression in program goes true and strlen(s) is selected for output which prints output as 3.

---

IIn above case it returns -2 .I think it should return 2 .Do not understand why this is happening .We discussed that arithmetic calcuation between unsigned is always positive.

---

size_t strlen( const char *s );

Thanx that was an eye opener

---

Here, we compare length of pointer because s and t are char type pointer. But all type of pointer have same size then why we get length of string and when i try to print strlen(*y) i got error . why?

could you explain ?

---

@gaurav456

You should try this code. You were printing with %d which converts c to signed integer. So pick %ld which is big enough to take the large unsigned value that c has.

#include<stdio.h>
void main()
{
    
    unsigned int a=3, b=5,c;
    c=a-b;
    long d=c;
    printf("%ld",d);
    
}

---

ToBONGBIRDIE .. i appreciate your information regarding strlen() but I have a doubt ..

you said "strlen(s) - strlen(t) will yield unsigned-unsigned= unsigned".

Now  strlen(s) & strlen(t) produces separately positive values 3 and 5 respectively. Now as both 3 & 5 are unsigned... so (3-5) is not resulting (-2) ?

If it resulting (-2) then how that "unsigned int c" does not matter in the question?

if you can please reply..

---

@Arjun sir

Shouldn't it be

-2 mod (INT_MAX +1) = INT_MAX - 1 and   NOT INT_MA X - 2 , Considering 2's complement representation.

---

why after removing unsigned it is still  showing output as 3 .?

---

@VS

Yes i also agree that it should be INT_MAX-1 and not INT_MAX-2

---

@gaurav456 lets go to DELD/CO to understand output of your code

unsigned int a =3 , b=5,c;

c=a-b;

print(c);

first of all as sushmita said , there is no difference between representation of unsigned int and signed. it is just way cpu interpret this 

suppose cpu using 8 bit for representation and used 2's compliment system

then -3 in signed representation is 

0000 0011 (3) 

1111 1100 (1s compliment)

1111 1101 (2s compliment)

now coming to your question 

a =3 will be represented as 0000 0011

b=5 will be represented as 0000  0101

a-b will be done by taking b's 2's compliment and adding it to a.

 0000  0101 (b)

  1111  1010 (b's 1s compliment)

  1111 1011 (b's 2s compliment) 

 a-b =  0000 0011 

         +1111 1011

gives  1111 1110 (no carry generated)

Now rule says if carry generated ignore it (means answer is positive), but if no carry generated take 2's compliment(means answer is -ve , note that computer don't do take compliment , we take for our understanding purpose ) ( I wrote in just one simple sentence but there whole new concept behind it)

so here as no carry generated answer is -ve and to get t magnitude take compliment(2's )

       0000 0010 (2)

hence output is -2

---

@once_2019  read comment of  @Bongbirdie

---

@gaurav456 you can print using "%u" instead of "%d" for this code which gives 4294967294 as difference between the strings and c.This makes it clear that the output will be 3.

---

Yes, it would be UINT_MAX-1.I mean -2 in unsigned integer would correspond to exactly this.

Code: https://ideone.com/hPSJXn

And also it is very logical.

Suppose I take  unsigned int as 1 Byte data.

So, Minimum value would be 0000 0000.

Now suppose I do -1 on this, this would wrap to the highest value=1111 1111

Now to this again I do -1, then it would become 1111 1110, Which is exactly 1 less than the maximum value.

---

long is a signed integer in C and will display the same result as for int, '%u' should be used to display all unsigned int values.

---

@Arjun Sir if we are considering int of 2 bytes than -2 will be stored as 11111111 1111 1110 ,

which will be taken as positive value in the case of unsigned..

am i correct?

---

https://overiq.com/c-programming-101/the-strlen-function-in-c/

---

Will be helpful:- Difference between strlen() and sizeof() for string in C - GeeksforGeeks

Answer 2

Suppose  numbes are represented in 2's complement.

Then ,(strlen(s)- strlen(t)) gives -2.

Because it is unsigned ,its binary format will be in 2's complement 

+2^n-1-2 on n bit machine.

Just care here about that it will be positive and  condition become true,and length of first string gets printed which is 3.

Answer 3

Since the question stresses that the function returns an UNSIGNED number. There has to be a thing around that. Which is

An unsigned number can never be negative and hence even the difference between two unsigned number also can't be negative. So when you subtract an unsigned number from another unsigned it would result in a positive wrapped around number.

Since positive number is greater than 0.

And hence we choose strlen('abc') which is 3.

Hence output is 3.

Comments

You are printing unsigned integer as signed one

Use %u

---

with  %u you are making it unsigned....

int t=-2;

printf("%d....%u",t,t);

then t is unsigned? NO

 

come to the question,

   int len = ((strlen(s) - strlen(t)) > c) ? strlen(s) : strlen(t);

when you comparing with c, at that moment it is converted as unsigned...

---

when you comparing with c, at that moment it is converted as unsigned..

i know this.

i was answering your question why it is printing -2.

Answer 4

here it is taking two list of two legth

code like:

is the length of first list > lenght of 2nd list

then-> return the First list length

else

return 2nd list length

it is simply returning the length of larger string 

here it is 5

so 5 should be the answer

Comments

 Aboveallplayer answer should be 3, because when you subtract an unsigned number from another unsigned it would result in a positive wrapped around number,

explanation:

When you work with unsigned types, modular arithmetic (also known as "wrap around" behavior) is taking place. To understand this modular arithmetic, just have a look at these clocks:

9 + 4 = 1 (13 mod 12), so to the other direction it is: 1 - 4 = 9 (-3 mod 12). The same principle is applied while working with unsigned types. If the result type is unsigned, then modular arithmetic takes place.

---

If remove unsigned still answer 3

https://rextester.com/OOO61331

---

@Ram Swaroop​​​​​​​

That's because strlen() is an inbuilt function that always returns an unsigned int as the value.

So, (unsigned int - unsigned it > 0?) is the case, which is always true.

Unsigned int - unsigned int can't be signed. So answer is unsigned => positive => greater than 0.