Get current timestamp in milliseconds (UTC)

    struct timeval tp;
    gettimeofday(&tp, NULL);
    long long ms = (long long) tp.tv_sec * 1000L + tp.tv_usec / 1000; //get current timestamp in milliseconds

[FFMPEG] RGB <-> YUV

    int imgWidth = 320, imgHeight = 240;
    AVPicture rgbPic, yuvPic;

    int dataSize = imgWidth * imgHeight;
    
    avpicture_fill(&rgbPic, NULL, PIX_FMT_RGB24, imgWidth, imgHeight);
    rgbPic.data[0] = (uint8_t *) malloc(dataSize * 3);
    
    avpicture_fill(&yuvPic, NULL, PIX_FMT_YUV420P, imgWidth, imgHeight);
    yuvPic.data[0] = (uint8_t *) malloc(dataSize * 3 / 2);
    yuvPic.data[1] = yuvPic.data[0] + dataSize;
    yuvPic.data[2] = yuvPic.data[1] + dataSize / 4;
    
    // RGB888 to YUV420
    {
        SwsContext *rgb_to_yuv_ctx = sws_getContext(
                imgWidth, imgHeight, PIX_FMT_RGB24
                , imgWidth, imgHeight, PIX_FMT_YUV420P
                , SWS_BICUBIC, NULL, NULL, NULL);
        sws_scale(rgb_to_yuv_ctx
                , rgbPic.data, rgbPic.linesize, 0, imgHeight
                , yuvPic.data, yuvPic.linesize);
        sws_freeContext(rgb_to_yuv_ctx);
    }

    // YUV420 to RGB888
    {
        SwsContext *yuv_to_rgb_ctx = sws_getContext(
                imgWidth, imgHeight, PIX_FMT_YUV420P
                , imgWidth, imgHeight, PIX_FMT_RGB24
                , SWS_BICUBIC, NULL, NULL, NULL);
        sws_scale(yuv_to_rgb_ctx
                , yuvPic.data, yuvPic.linesize, 0, imgHeight
                , rgbPic.data, rgbPic.linesize);
        sws_freeContext(yuv_to_rgb_ctx);
    }

4Sum

	public ArrayList<ArrayList<Integer>> fourSum(int[] num, int target) {
		if (num == null || num.length < 4)
			return new ArrayList<ArrayList<Integer>>();
		Arrays.sort(num);

		return genericSumSorted(num, target, 0, num.length, 4);
	}

	public ArrayList<ArrayList<Integer>> genericSumSorted(int[] num,
			int target, int offSet, int len, int numToSum) {
		int loopMax = len - numToSum + 1;
		ArrayList<ArrayList<Integer>> rv = new ArrayList<ArrayList<Integer>>();

		if (numToSum == 1) {
			for (int i = offSet; i < loopMax; i++) {
				if (num[i] == target) {
					ArrayList<Integer> newSet = new ArrayList<Integer>();
					newSet.add(num[i]);
					rv.add(newSet);
					break;
				}
			}
		} else {
			int lastValue = num[offSet] - 1;
			for (int i = offSet; i < loopMax; i++) {
				if (num[i] == lastValue)
					continue;
				lastValue = num[i];
				int newTarget = target - num[i];

				ArrayList<ArrayList<Integer>> sub = genericSumSorted(num,
						newTarget, i + 1, len, numToSum - 1);
				for (ArrayList<Integer> subDetail : sub) {
					subDetail.add(0, lastValue);
					rv.add(subDetail);
				}
			}
		}
		return rv;
	}

3Sum Closest

	public int threeSumClosest(int[] num, int target) {
		if (num == null)
			return target;

		int len = num.length;
		if (len < 3) {
			int sum = 0;
			for (int i = 0; i < len; i++)
				sum += num[i];
			return sum;
		}

		Arrays.sort(num);
		return findClosestSumSorted(num, target, 0, len, 3);
	}

	public int findClosestSumSorted(int[] num, int target, int offSet, int len,
			int numToSum) {
		int loopMax = len - numToSum + 1;
		if (numToSum == 1) {
			int prevBestValue = num[offSet];
			int prevDiff = Math.abs(target - num[offSet]);
			for (int i = offSet + 1; i < loopMax; i++) {
				int currentDiff = Math.abs(target - num[i]);
				if (currentDiff < prevDiff) {
					prevBestValue = num[i];
					prevDiff = currentDiff;
				} else if (currentDiff > prevDiff)
					break;
			}
			return prevBestValue;
		} else {
			int prevBestValue = 0, prevDiff = Integer.MAX_VALUE;
			int lastValue = num[offSet] - 1;
			for (int i = offSet; i < loopMax; i++) {
				if (lastValue == num[i])
					continue;

				lastValue = num[i];
				int newTarget = target - num[i];
				int findValue = findClosestSumSorted(num, newTarget, i + 1,
						len, numToSum - 1);
				int currentDiff = Math.abs(newTarget - findValue);
				if (currentDiff < prevDiff) {
					prevBestValue = num[i] + findValue;
					prevDiff = currentDiff;
				} else if (currentDiff > prevDiff)
					break;
			}
			return prevBestValue;
		}
	}

3Sum

	public ArrayList<ArrayList<Integer>> threeSum(int[] num) {
		if (num == null || num.length < 3)
			return new ArrayList<ArrayList<Integer>>();
		Arrays.sort(num);
		return genericSumSorted(num, 0, 0, num.length, 3);
	}

	public ArrayList<ArrayList<Integer>> genericSumSorted(int[] num,
			int target, int offSet, int len, int numToSum) {
		int loopMax = len - numToSum + 1;
		ArrayList<ArrayList<Integer>> rv = new ArrayList<ArrayList<Integer>>();

		if (numToSum == 1) {
			for (int i = offSet; i < loopMax; i++) {
				if (num[i] == target) {
					ArrayList<Integer> newSet = new ArrayList<Integer>();
					newSet.add(num[i]);
					rv.add(newSet);
					break;
				}
			}
		} else {
			int lastValue = num[offSet] - 1;
			for (int i = offSet; i < loopMax; i++) {
				if (num[i] == lastValue)
					continue;
				lastValue = num[i];
				int newTarget = target - num[i];

				ArrayList<ArrayList<Integer>> sub = genericSumSorted(num,
						newTarget, i + 1, len, numToSum - 1);
				for (ArrayList<Integer> subDetail : sub) {
					subDetail.add(0, lastValue);
					rv.add(subDetail);
				}
			}
		}
		return rv;
	}

Longest Common Prefix

 public String longestCommonPrefix(String[] strs) {
  if (strs == null)
   return null;

  int len = strs.length;
  if (len == 0)
   return "";

  int shortStrIdx = 0;
  int shortStrLen = strs[0].length();
  for (int i = 1; i < len; i++) {
   int strLen = strs[i].length();
   if (strLen < shortStrLen) {
    shortStrIdx = i;
    shortStrLen = strLen;
   } else if (strLen == shortStrLen) {
    for (int j = 0; j < strLen; j++) {
     if (strs[shortStrIdx].charAt(j) != strs[i].charAt(j)) {
      shortStrLen = j;
      break;
     }
    }
    if (shortStrLen == 0)
     return "";
   }
  }

  for (int i = 0; i < len; i++) {
   if (i == shortStrIdx)
    continue;

   for (int j = 0; j < shortStrLen; j++) {
    if (strs[shortStrIdx].charAt(j) != strs[i].charAt(j)) {
     shortStrLen = j;
     break;
    }
    if (shortStrLen == 0)
     return "";
   }
  }

  return strs[shortStrIdx].substring(0, shortStrLen);
 }

Roman to Integer

 public int romanToInt(String s) {
  int rv = 0;
  int len = s.length();

  int currentDigit = 0;
  int prevValue = 0;
  for (int i = 0; i < len; i++) {
   char c = s.charAt(i);

   int currentValue = 0;
   switch (c) {
   case 'M':
    currentValue = 1000;
    break;
   case 'D':
    currentValue = 500;
    break;
   case 'C':
    currentValue = 100;
    break;
   case 'L':
    currentValue = 50;
    break;
   case 'X':
    currentValue = 10;
    break;
   case 'V':
    currentValue = 5;
    break;
   case 'I':
    currentValue = 1;
    break;
   }

   if (prevValue == 0) {
    currentDigit += currentValue;
    prevValue = currentValue;
   } else if (currentValue == prevValue) {
    currentDigit += currentValue;
   } else if (currentValue > prevValue) {
    rv += currentValue - currentDigit;
    prevValue = 0;
    currentDigit = 0;
   } else {
    rv += currentDigit;
    prevValue = currentValue;
    currentDigit = currentValue;
   }
  }

  rv += currentDigit;
  return rv;
 }