Android Glossary

obfuscate: Obfuscators replace these names with short, machine generated alternatives.This makes it more difficult to intuit the purpose of these functions without access to the original source code.
http://android-developers.blogspot.com/2010/09/securing-android-lvl-applications.html
http://android-developers.blogspot.com/2010/09/proguard-android-and-licensing-server.html

Java reflection: Enable language to inspect and dynamically classes, methods and attributes at run-time.

dynamic class-loading: Load and reload class dynamically at runtime in Java. The program doesn't know the name of the class before being executed. In Java, loading classes at runtime must be done by subclass of java.lang.ClassLoader.

root exploit:Attain privileged control (root access) of the system.  While the concept of Apple community's jailbreak is different by two additional factors of unlocking the bootloader, enable sideloading.

zero day: Malwares/Virus whose detection signature has not been obtained.

honeypot: a trap set to detect, deflect, or, in some manner, counteract attempts at unauthorized use of information systems

Repeating number problem - 3

Given a (potentially large) array of integers, all but one repeating an even number of times, how would you find the one repeating an odd number of times in an efficient way? eg [1 2 3 3 2 2 1 4 2] should return 4

Method 1: Use map data structure to track the occur times of the number in the list. Then loop through the map to find the number occurs even times.
Output:

Number occur even times: 6

Method 2: Find the unique set of the integer array and append the unique set to the original array. Then XOR the new array leaving only the number repeat even times. The trick is XOR with odd times itself remains zeros, XOR with even times itself remains itself.
Output:

Number that occurs even times: 6

Repeating number problem - 2

Given an array in which all numbers except two are repeated once. (i.e. we have 2n+2 numbers and n numbers are occurring twice and remaining two have occurred once). Find those two numbers in the most efficient way.

Method 1: Use xor operators only to find the two non duplicate numbers. Xor all (2n+2) numbers first, then the n duplicate numbers are cancelled out, leaving the two unique number being XORed. The set bits in the result indicate bits at which the two numbers differ. The bit in a specific position can be either set or clear. Correspondingly, we can divide the numbers into set group numbers and clear group numbers w.r.t the set/diff bits in the result. Since all the other numbers repeat once, it doesn't change the XORed result either in the set group or the clear group. Thus, the XOR of set group and clear group are the two numbers occurred only once.
To divide numbers into set and clear group, we need to extract the set/diff bit of all 2n+2 numbers, here is the way to extract the right most diff/set bit of the XOR result of all 2n+2 numbers.

int diffBitMask = xor & ~(xor-1);

xor-1 zero the right most set bit and keep the other set bits. The complement operator ~ mask off the other set bits and set the right most one.

The code is as follows:

public class Main {
    public static void main(String args[]) {
        int arr[] = {1, 2, 6, 1, 6, 8, 7, 8};
        findNonDuplicate(arr);
    }
    public static void findNonDuplicate(int arr[]) {
        int xor = 0, xor1 = 0, xor2 = 0;
        // Xors of the all numbers, obtaining the difference mask of two numbers
        for(int i = 0; i < arr.length; i++) {
            xor ^= arr[i];
        }
        int diffBitMask = xor & ~(xor-1);   // Right most set/diff bit
        // Grouping based on the diff bit
        for(int i = 0; i < arr.length; i++) {
            if((arr[i] & diffBitMask) > 0) {
                xor1 ^= arr[i];
            } else {
                xor2 ^= arr[i];
            }
        }
        System.out.println("The two numbers that occur once are: " + xor1 + ", " 
                + xor2);
    }
}   

Output is:

The two numbers that occur once are: 7, 2

Repeating number problem - 1

Here is the collection of problems that related to finding  the duplicate numbers in a array.

1. Given an array of numbers ranging from 1 to N, in which numbers could repeat itself any number of times, find the duplicate numbers in O(n) with constant memory space.

Method 1: Use an extra array keep track of the elements counting.

public class Duplicate {
    public static void main(String args[]) {
        int arr[] = {1, 3, 5, 8, 5, 7, 4, 2, 4};
        findDuplicate(arr);

    }
    public static void findDuplicate(int arr[]) {
        // Using the current number as the key/index to the value
        for(int i = 0; i < arr.length; i++) {
            // Positvie - never seen before
            if( arr[Math.abs(arr[i]) - 1] > 0 )  {
                arr[Math.abs(arr[i]) - 1] =  -arr[Math.abs(arr[i]) - 1];
            }
            // Negative - already seen, duplicate 
            else if(arr[Math.abs(arr[i]) - 1] < 0) {
                System.out.print(Math.abs(arr[i]) + " ");
                arr[Math.abs(arr[i]) - 1] = 0;
            }
            else {// 0 - already detected
            }
        }
        System.out.println();
    }
}

output:

5 4