CareerCup

private int maxInt()
{
int a=-1;
a=a>>>1;
return a;
}

int i = -1;
i = i >>> 1;

//This will shift the singed bit to right by 1 and hence making the value 2147483647

The best way to get the max value of int on 32 or 64 bit processors is by negating the 0(so that we get all 1's) and then doing an unsigned right shift (>>> in java).

int c = (~0) >>> 1;

In C, if we do normal shift (~0 >> 1), the compiler will perform arithmetic shift and will append the sign bit into the shifted bit. Instead, we would have to force a logical shift by explicitly declaring the value as unsigned, i.e. by doing something like this:

~0u >> 1;

int int_max = (unsigned int)-1 >> 1;

int i=0;
int int_max = ~i & (~i-1) //all ones and-ed with sign bit 0 rest all ones.

int m = ~(1<<(sizeof(int)*8-1))

int m = (~0u)>>1;

1 #include<stdio.h>                                                               
  2                                                                                 
  3 int main()                                                                      
  4 {                                                                               
  5   unsigned int i=0;                                                             
  6   printf("%u\n" ,((unsigned int)~i/2));                                         
  7   return 0;                                                                     
  8 }

def max_int():
import struct
max_int_list = [1] * (struct.calcsize("i")*8)
max_int_list[0] = 0 # highest priorty bit is reserved for negative flag
max_int_str = "".join(str(x) for x in max_int_list)
print(max_int_str)
return int(max_int_str,2)

def max_int():
    import struct
    max_int_list = [1] * (struct.calcsize("i")*8)
    max_int_list[0] = 0 # highest priorty bit is reserved for negative flag
    max_int_str = "".join(str(x) for x in max_int_list)
    print(max_int_str)
    return int(max_int_str,2)

How about this?

cout << "MY_INT_MAX = " << ((-1U) >> 1) << endl;
    cout << "MY_LONG_MAX = " << ((-1UL) >> 1)  << endl;

int MAX_INT = ~0 & ~(1 << 31);

#include<stdio.h>

int main(){
printf("%u\n",((unsigned int)~0));
}

AD's answer is perfect. Here is a bit of explanation:

Imagine you have a signed 4 bit system. In that system

-1

would be this:

1111
||_ from here bits are inverted
|_ sign bit (negative)

Shift to right add a zero to beggining of sequence:

0111
||_ regular bits. all 1 from here (max value)
|_ sign bit (positive)

career cup app for android

int int_max = -1 >> 1

public class GenMaxInt {
    public static void main(String[] args) {
        int i = 0;
        int j =0;
        int ans =0;
        while(true) {
            int y = ~i& 1 << j;
            if( y < 0) {
               System.out.println(ans);
               break;
            }
            ans += y;
            j++;
        }
    }

}

printf("MAX_INT=%d\n", ~(1<<31));

//C++
int int_max=~(1<<31);
int int_min=1<<31;

// Generate INT_MAX
void int_max_generate()
{
	int num = 1;
	num = static_cast<unsigned int>(-1) >> 1; // instead of -1 use ~0
	cout << num << endl;
}

#define MY_MAX_INT(x) ((~(x & 0)) & ~(((x & 0)|1) << (sizeof(x)*8-1)))

int x = MY_MAX_INT(x);
long long y = MY_MAX_INT(y)

#define int_max(TYPE) ( (1<< ((sizeof(TYPE)*8)-1)) -1)

This is how I would do:

int max = (unsigned int) -1 >> 1;

You could also replace -1 by ~0

#include <limits.h>
#include <stdio.h>

int main()
{
  /* find the position of the most significant bit */
   int msb_pos = (sizeof(int) * CHAR_BIT) - 1;

  /* Move number 1 to the MSB pos and then take xor with -1 */
   int result = (1 << msb_pos) ^ -1;

   printf("Result = %d\n", result);
   printf("Builtin = %d\n", INT_MAX);

   return result;
}

I read in a book that the effect of >> on a signed int is undefined. That is, different compilers generated different types of code. Thus, I can up with this code.

#include <limits.h>
#include <stdio.h>

int main()
{
  /* find the most significant bit (MSB) pos */
   int msb_pos = (sizeof(int) * CHAR_BIT) - 1;

  /* mov number 1 to the MSB pos and then xor with -1 */
   int result = (1 << msb_pos) ^ -1;

   printf("Result = %d\n", result);
   printf("Builtin = %d\n", INT_MAX);

   return result;
}

C'mon guys 32 bit processor does not mean necessarily mean that size of int is 4 bytes.

Java: -(1<<31)-1

int max_int = ~0;
  size_t size = sizeof(int);  
  max_int = max_int & ~(1 << ((size * 8) - 1));

int  i = -1;
i = (unsigned int) i >> 1;
cout << i << endl;

#include<stdio.h>

int main(){
printf("%u\n",((unsigned int)~0));
}

#include <stdio.h>

int add(int i, int j)
{
  int sum = i ^ j;
  int carry = i & j;
  while(carry != 0){
    carry = carry << 1;
    i = sum;
    j = carry;
    sum = i ^ j;
    carry = i & j;
  }
  return sum;
}

int multiply(int i, int j){
  int result = 0;
  while(j != 0)
  {
    if(j & 01)
    {
      result = add(result, i);
    }
    i <<= 1;
    j >>= 1;
  }
  return result;
}

int get()
{
  int size = sizeof(int);
  unsigned int ret = 1;
  int i = 1;

  while(true){
    if(i == 31)
      return (int)(ret | (1 << size));
    i = add(i, 1);
    ret <<= 1;
    ret |= 1;
  }
}

int main()
{
  printf("%d\n", get());
}

int int_max = -1 >> 1