CareerCup

If 'x' in an int input and 'm' & 'n' are indices with 0-base as LSB, then the output can be written in one instruction as
y = (x & ((1 << m) - (1 << (n+1)))) >> (n+1);

Explanation:
1) (1<<m) returns 2 to the power m
2) (1<<(n+1)) returns 2 to the power (n+1)
3) Difference of above 2 returns the mask with all bits set between m and n (both exclusive)
4) Now AND the above mask with original input 'x' to extract bit values for only the bits between m and n (both excluded)
5) I assumed that the expected result needs to be returned considering the (n+1)th bit as LSB, and hence the last right shift operation for (n+1) times.

Let's take an example:
int m = 6; //1st index
int n = 1; // 2nd index
int x = 173; //input = 10101101

int y = (x & ((1 << m) - (1 << (n+1)))) >> (n+1);

//(1<<6) - (1<<(1+1)) = 01000000 - 00000100 = 00111100
//x & 00111100 = 10101101 & 00111100 = 00101100 (144 in base 10)
//finally, y = 00101100 >> (1+1)= 00001011 (11 in base 10)

(x&(~(~0<<m))) >> (n-1)

((unsigned char)(c << (n - 1))) >> (8 - (m - n + 1))

((i << (8-m-1)) & 0xff) >> (n+8-m-1)

if indices start from 1

ans = ((i & (-1 << (8 - n)) >> (8 - n)) & ((1 << (n - m + 1)) - 1)

Define "single instruction". If it means 1 assembly instruction, that's only possible if value's already in a register and either we know m and n at compile time so we can prepare the appropriate bitmask, or if a special "bit range extraction" instruction exists.

if i is the byte given, we can extract bits between n and m where m>=n with the following single instruction.

[i & [(0xFF << m) ^ (0xFF<< n)]] >> n

how this works:
we create 2 maska (Assuming m=5 and n=2)

11100000 0xFF << m
11111100 0xFF << n

Now we take xor of the above which gives us below mask

00011100 [(0xFF << m) ^ (0xFF<< n)]

Now if the apply the & gate with the given byte i (Assuming its 01010101) it gives us below byte.

00010100 [i & [(0xFF << m) ^ (0xFF<< n)]]

Now we can shift the byte n times to the right to get the extracted byte

00000101

-------------------------------------------

Please let me know if you see any improvement or if you have any comment.

We need to construct a mask having all the bits between m and n set to 1.

which is = 2^m + 2^m-1 + 2^m-2 .... + 2^n
= 2^n (1 + 2 + 2^2 ..... 2^m-n)
= 2^n(2^(m-n+1)-1)
= 2^m+1 - 2^n
That's how you'd get the mask in a single instruction.

void function(int i, int j, int orig_number){
int mask = 0xFFFFFFFF;
return ((((mask<<j)&&(~(mask<<i)))&&orig_number)>>j);
}

Apologies for a small mistake in the above code.
The '&&' should be '&'.

char y = ((x << 8 - m) >> (8 - m + n));

indices start from 1

((x >> (n-1)) & (0xff >>> ((8-m) + (n-1))))

(x&( ((1<<m) -1) & ~ ( (1<<(n+1)) -1)) >> (n+1)

(x>>m-1)&((1<<m-n+1)-1)

main problem is of extraction and u have not given extraction.
you have given answer in last bainary indice.

bits=((~(0xFFFF<<(n-m+1))<<m)&x)>>m;

where
x is the given number

#include<stdio.h>
int main()
{
int a = 214;
int m=6,n=3;
int c;
c = a & ((1<<(m+1)) - (1<<(n)));
c = c >> n;
printf("%0x",c);
return 0;
}