sherxon / algods Goto Github PK

It will be almost twice as fast, using half as much space, if you only sieve over odd numbers.

Hello.
I'm not fluent in Java so I won't implement it by myself, however there is an O(log n) solution for finding nth Fibonacci number which is based on matrix exponentiation -

[[1 1] [1 0]]^n = [[F_{n+1} F_n] [F_n F_{n-1}]]

This can be done with exponentiation by squaring which is O(log n).

Whether or not there is a cycle, this program always returns true after running
` for (Integer neighbor : graph.getNeighbors(start)) {

        if(visited.contains(neighbor) && !exited.contains(neighbor)) return true;

        if(!visited.contains(neighbor) && dfs(neighbor)) return true;
    }`

hi I like your code for ReverseInteger. Why do you use the Math.abs()? Here is another approach with less code:

public int reverse(int x) {
    int rev = 0;
    while(x != 0){
        rev = rev*10 + x%10;
        x = x/10;
    }
 
    return rev;
}

In your solution you have used priority queue to fetch second minimum node. Wouldn't it be much more efficient if you simply returned leftmost element in the right subtree of the root ?

It would be really cool to have Bloom Filter.

can i see your solution for dealing with duplicates?

https://github.com/sherxon/AlgoDS/blob/master/src/interviewquestions/easy/ContainsDuplicate.java#L17:

    for (int i : nums) {
        if (!set.add(-2 * i)) return true;
    }

Why multiply by -2?

See https://repl.it/HBRv/0: new int[] {2147483646, -2} contains duplicates.

if array is {8,7,6,7,4},result is wrong

Looks like CycleDetection will fail if Graph has multiple component.

hope provide unit test for these solutions
thanks :)