Common Bit Manipulation

bool getBit(int num, int shift)
{
 return ( (num & (1 << shift)) != 0);
}
int setBit(int num, int shift)
{
 return ( num | (1 << shift));
}
int clearBit(int num, int shift)
{
 int mask = ~ (1 << shift);
 return num & mask;
}
int clearBitMSBthroughShiftBit(int num, int shift)
{
 int mask = (1 << (shift )) -1;
 return num & mask;
}
int clearBitMSBthroughShift0(int num, int shift)
{
 int mask = ~ ((1 << (shift +1 )) -1);
 return num & mask;
}
int updateBit(int num, int shift, int v) //set i-th bit = v
{
 int mask = ~ (1 << shift);
 return (num & mask) | (v << shift);
}

 

CTCI: Ch. 5-1

You are given two 32-bit numbers, N and M, and two bit positions, i and j. Write a method to insert M into N such that M starts at bit j and ends at bit i.
You can assume that the bits j through I have enough space to fit all of M. That is, if M = 10011, you can assume that there are at least 5 bits between j and i.
You would not, for example, have j = 3 and i = 2, because M could not fully fit between bit 3 and bit 2.

 

Continue reading

Chapter 5. Bit Manipulation

  1. You are given two 32-bit numbers, N and M, and two bit positions, i and j. Write a method to insert M into N such that M starts at bit j and ends at bit i. You can assume that the bits j through I have enough space to fit all of M. That is, if M = 10011, you can assume that there are at least 5 bits between j and i. You would not, for example, have j = 3 and i = 2, because M could not fully fit between bit 3 and bit 2.
    EXAMPLE
    Input:    N = 10000000000, M = 10011, i = 2, j = 6
    Output: N = 10001001100
    Continue reading

Google I/O 2013

Google Developers Live

YouTube: https://developers.google.com/youtube/

Google I/O 2013: Keynote

Google I/O 2013: Day 1 Keynote and Android Sessions

Google I/O 2013: Day 1 Technical Sessions

Google I/O 2013: Day 1 Chrome Sessions

Google I/O 2013: Day 2 Android Sessions

Google I/O 2013: Day 2 Technical Sessions

Google I/O 2013: Day 2 Technical Sessions 2

 

Android Studio v0.1

Getting Started with Android Studio

Amortized Analysis

In computer science, amortized analysis is a method of analyzing algorithms that considers the entire sequence of operations of the program. It allows for the establishment of a worst-case bound for the performance of an algorithm irrespective of the inputs by looking at all of the operations. At the heart of the method is the idea that while certain operations may be extremely costly in resources, they cannot occur at a high-enough frequency to weigh down the entire program because the number of less costly operations will far outnumber the costly ones in the long run, "paying back" the program over a number of iterations. It is particularly useful because it guarantees worst-case performance rather than making assumptions about the state of the program. [wikipedia]

Continue reading