bit manipulation & math

Author: Hearen

LuoSonglei/week-97/342-PowerOfFour.c

@@ -0,0 +1,48 @@
+/*******************************************
+Author      : LHearen
+E-mail      : [email protected]
+Time        : Tue, 24 May 2016 19:24 CST
+Description : Given an integer (signed 32 bits), write a function to check whether it is a power of 4.
+Example:
+Given num = 16, return true. Given num = 5, return false.
+Follow up: Could you solve it without loops/recursion?
+Source      : https://leetcode.com/problems/power-of-four/
+*******************************************/
+#include <cstdbool.h>
+//AC - 4ms - using loop to check;
+bool isPowerOfFour0(int n)
+{
+    int arr[] = {1, 4,16,64,256,1024,4096,16384,65536,262144,1048576,4194304,
+        16777216,67108864,268435456,1073741824}; //using the OJ to get the array;
+    for(int i = 0; i < sizeof(arr)/sizeof(int); i++) //check whether it's one of them;
+        if(num == arr[i]) return true;
+    return false;
+}
+
+//AC - 4ms - recursive;
+bool isPowerOfFour1(int n)
+{
+    if(n < 1) return false;
+    if(n == 1) return true;
+    return (n&3)==0 && isPowerOfFour(n>>2); //n&3 -> n%4;
+}
+
+//AC - 4ms - using loop;
+bool isPowerOfFour2(int n)
+{
+    if(n < 1) return false;
+    if(n == 1) return true;
+    while(n > 1)
+    {
+        if(n%4) return false;
+        n /= 4;
+    }
+    return true;
+}
+
+//AC - 4ms - adopting bit manipulation;
+bool isPowerOfFour(int n)
+{
+    return n==1 || (n>1 && (n&-n)==n && (n&0x2aaaaaab)==0); //n&-n used to get the last bit of n -> used here to check whether it only has one 1-bit; 
+    //n&0x2aaaaaab used to make sure the 1-bit lies in the right position - power of four;
+}

LuoSonglei/week-97/343-IntegerBreak.c

@@ -0,0 +1,44 @@
+/*******************************************
+Author      : LHearen
+E-mail      : [email protected]
+Time        : Tue, 24 May 2016 20:21 CST
+Description : Given a positive integer n, break it into the sum of at least two positive integers and maximize the product of those integers. Return the maximum product you can get.
+For example, given n = 2, return 1 (2 = 1 + 1); given n = 10, return 36 (10 = 3 + 3 + 4).
+Note: you may assume that n is not less than 2.
+Source      : https://leetcode.com/problems/integer-break/
+*******************************************/
+//AC - 0ms - DP;
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+int integerBreak0(int n) 
+{
+    int *arr = (int*)malloc(sizeof(int)*(n+1)); //used to store the max product of the index;
+    arr[2]=1, arr[3]=2, arr[4]=4; //corner cases;
+    for(int i = 5; i <= n; i++) 
+    {
+        int max = 0;
+        for(int j = 2; j < i-1; j++)
+        {
+            int t = MAX(j, arr[j])*MAX(i-j, arr[i-j]); //select the value itself or the its product value;
+            if(t > max) max = t;
+        }
+        arr[i] = max;
+    }
+    return arr[n];
+}
+
+//AC - 0ms - mathematical solution;
+//only 2 or 3 will be used to make the product bigger;
+//elements bigger than them can be splitted further to make bigger;
+//meantime 3*3 > 2*2*2 so we should get as many 3 as possible;
+int integerBreak(int n) 
+{
+    if(n == 2) return 1;
+    if(n == 3) return 2;
+    int ret = 1;
+    while(n > 4)
+    {
+        ret *= 3;
+        n -= 3;
+    }
+    return ret*n;
+}

LuoSonglei/week-97/345-ReverseVowelsOfAString.c

@@ -0,0 +1,33 @@
+/*******************************************
+Author      : LHearen
+E-mail      : [email protected]
+Time        : Tue, 24 May 2016 19:58 CST
+Description : Write a function that takes a string as input and reverse only the vowels of a string.
+Example 1:
+Given s = "hello", return "holle".
+Example 2:
+Given s = "leetcode", return "leotcede".
+Source      : https://leetcode.com/problems/reverse-vowels-of-a-string/
+*******************************************/
+#include <cstdbool.h>
+//AC - 4ms;
+bool isVowel(char a)
+{
+    char c = tolower(a);
+    return c=='a' || c=='e' || c=='i' || c=='o' || c=='u';
+}
+char* reverseVowels(char* s) {
+    int len = strlen(s);
+    int l=0, r=len-1;
+    while(l < r)
+    {
+        while(l<len && !isVowel(s[l])) l++;
+        while(r>-1 && !isVowel(s[r])) r--;
+        if(l<len && r>-1 && l < r)
+        {
+            char t=s[l]; s[l]=s[r]; s[r]=t;
+            l++, r--;
+        }
+    }
+    return s;
+}