Comments for GeeksforGeeks

Comment on Maximum Length Bitonic Subarray by vijay_kansal

vijay_kansal — Wed, 22 Feb 2012 04:59:34 +0000

I think the given simple solution of O(n) time and O(1) space must work.
Please indicate errors in the code, if any...

int longest_bitonic(int *a,int n)
{
 if(n<=0)
  return 0;
 int i,max,lastdistincti=0,starti;
 i=0;
 while(i=a[i-1];i++)
   ;

  for(;imax)
   max=i-starti;
 }
 return max;
}

Comment on Trie | (Insert and Search) by Tarun

Tarun — Tue, 21 Feb 2012 23:10:13 +0000

[sourcecode language="C"] /* Paste your code here (You may delete these lines if not writing code) */ ///===========================node.h========================================== #ifndef __NODE__H #define __NODE__H //node.h #include #include #define ARRAY_SIZE(a) sizeof(a)/sizeof(a[0]) #define ALPHABET_SIZE 26 #define index(c) ((int)c - (int)'a') class Node { private: int m_count; std::string m_data; Node* child[ALPHABET_SIZE]; public: Node(); friend std::ostream& operator<<(std::ostream& _out, const Node& _node); friend class Tries; }; #endif //node.h ///===========================end of node.h========================================== ///===========================node.cpp========================================== #include "node.h" Node::Node() { for(int i = 0; i < ALPHABET_SIZE; ++i) { child[i] = 0; } } std::ostream& operator<<(std::ostream& _out, const Node& _node) { if(!_node.m_data.empty()) { _out<<_node.m_data<<","; } for(int i = 0; i < ALPHABET_SIZE; i++) { if(_node.child[i] == NULL) { continue; } _out<<*(_node.child[i]); } _out< #include "node.h" #include "tries.h" void Tries::init() { if(NULL == m_head) { m_head = new Node(); } m_head->m_count = 0; } Tries::Tries() { init(); } void Tries::insert(char _key[]) { if (NULL == _key) { return; } Node* temp = m_head; int len = strlen(_key); for(int i = 0; i < len; ++i) { int indx = index(_key[i]); if(NULL == temp->child[indx]) { temp->child[indx] = new Node(); temp = temp->child[indx]; } else { temp = temp->child[indx]; } temp->m_count++; } temp->m_data = _key; } void Tries::search(char _key[]) { if(NULL == m_head) { return; } int len = strlen(_key); int i = 0; Node* temp = m_head; for(i = 0; i < len-1; i++) for(i = 0; i < len-1; i++) { temp = temp->child[index(_key[i])]; if(NULL == temp) { return; } if(!temp->m_data.empty()) { std::cout<<"data: <"<m_data<<">"<child[index(_key[i])]; if(temp) { std::cout<<*temp; } } ///===========================end of tries.cpp========================================== /* * ===================================================================================== * * Filename: tries_test.cpp * * Description: main calls for testing of tries * * Version: 1.0 * Created: Tue Feb 21 2012 05:52:50 * Revision: none * Compiler: gcc * * Author: Tarun Kumar (1.1), tarun_kumar1@symantec.com * Company: Symantec, Chennai * * ===================================================================================== */ #include "tries.h" int main() { char value[][8] = {"she", "sells", "sea", "shore", "the", "by", "sheer"}; Tries Tree; for(int i = 0; i < 7; ++i) { Tree.insert(value[i]); } Tree.search("s"); return 0; } ///===========================Makefile========================================== ##Makefile GCC = g++ -g all: tries.exe OBJ = node.o \ tries.o \ tries_test.o \ tries.exe: $(OBJ) $(GCC) $(OBJ) -o tries.exe rm -f $(OBJ) tries.o: tries.cpp tries.h node.h node.cpp $(GCC) -c tries.cpp node.o: node.cpp node.h $(GCC) -c node.cpp tries_test.o: tries.o $(GCC) -c tries_test.cpp # -- remove binary and executable clean: rm -f $(OBJ) tries.exe ///===========================end of Makefile========================================== [/sourcecode]

Comment on Find the largest BST subtree in a given Binary Tree by Neeraj

Neeraj — Tue, 21 Feb 2012 19:38:39 +0000

Need new glasses

/* Paste your code here (You may delete these lines if not writing code) */

Comment on Average of a stream of numbers by Progod

Progod — Tue, 21 Feb 2012 17:47:43 +0000

Yes it should be float balance = x - oldAvg; That was a typo

/* Paste your code here (You may delete these lines if not writing code) */

Comment on Average of a stream of numbers by Progod

Progod — Tue, 21 Feb 2012 17:36:23 +0000

Sorry for typo It should be float balance = x - oldAvg;

/* Paste your code here (You may delete these lines if not writing code) */

Comment on Average of a stream of numbers by Progod

Progod — Tue, 21 Feb 2012 17:22:05 +0000

Sorry for the typo.

float getAvg (int x)
{
static int sum, n;

sum += x;
return (((float)sum)/++n);
}
here sum can give you overflow problem.
to solve this problem you can use following approach.

float getAvg (int x)
{
    static float oldAvg, n;

    fload balance = x - oldAvg;
    oldAvg += (balance/++n);

    return oldAvg;
}

Comment on Given an array arr[], find the maximum j – i such that arr[j] > arr[i] by kartikaditya

kartikaditya — Tue, 21 Feb 2012 16:27:25 +0000

Time - O(N)
Space - O(1)

#include 
#include 

using namespace std;

int findMaxJMinusI(int a[], int n) {
    int start = 0, end = n - 1;
    while (start < end) {
        if (a[start] < a[end]) {
            return end - start;
        } else if (a[start] < a[end - 1] || a[start + 1] < end) {
            return end - 1 - start;
        }
        ++start;
        --end;
    }
    return -1;
}

int main() {
    int a1[] = {34, 8, 10, 3, 2, 80, 30, 33, 1};
    cout << findMaxJMinusI(a1, 9) << endl;
    int a2[] = {9, 2, 3, 4, 5, 6, 7, 8, 18, 0};
    cout << findMaxJMinusI(a2, 10) << endl;
    int a3[] = {1, 2, 3, 4, 5, 6};
    cout << findMaxJMinusI(a3, 6) << endl;
    int a4[] = {6, 5, 4, 3, 2, 1};
    cout << findMaxJMinusI(a4, 6) << endl;
    int a5[] = {4, 8, 1, 5};
    cout << findMaxJMinusI(a5, 4) << endl;
    return 0;
}

Comment on Given an array arr[], find the maximum j – i such that arr[j] > arr[i] by kartikaditya

kartikaditya — Tue, 21 Feb 2012 16:17:33 +0000

Time - O(N)
Space - O(1)

#include
#include

using namespace std;

int findMaxJMinusI(int a[], int n) {
int start = 0, end = n - 1;
while (start < end) {
if (a[start] < a[end]) {
return end - start;
} else if (a[start] < a[end - 1] || a[start + 1] < end) {
return end - 1 - start;
}
++start;
--end;
}
return -1;
}

int main() {
int a1[] = {34, 8, 10, 3, 2, 80, 30, 33, 1};
cout << findMaxJMinusI(a1, 9) << endl;
int a2[] = {9, 2, 3, 4, 5, 6, 7, 8, 18, 0};
cout << findMaxJMinusI(a2, 10) << endl;
int a3[] = {1, 2, 3, 4, 5, 6};
cout << findMaxJMinusI(a3, 6) << endl;
int a4[] = {6, 5, 4, 3, 2, 1};
cout << findMaxJMinusI(a4, 6) << endl;
int a5[] = {4, 8, 1, 5};
cout << findMaxJMinusI(a5, 4) << endl;
return 0;
}

Comment on Dynamic Programming | Set 3 (Longest Increasing Subsequence) by kartikaditya

kartikaditya — Tue, 21 Feb 2012 15:21:46 +0000

public class LongestIncreasingSubsequence {
    private static int binarySearch(int a[], int x, int start, int end) {
        int limit = end;
        int mid = 0;
        while (start < end) {
            mid = (start + end) >> 1;
            if (a[mid] <= x) {
                start = mid + 1;
            } else {
                end = mid - 1;
            }
        }
        if (a[start] <= x) {
            return start;
        }
        return start - 1;
    }

    public static void getLongestIncreasingSubsequence(int a[]) {
        int dp[] = new int[a.length + 1];
        int memo[] = new int[a.length + 1];

        dp[0] = 1;
        memo[1] = a[0];
        int maxSize = 1;
        for (int i = 1; i < a.length; ++i) {
            if (a[i] < memo[1]) {
                memo[1] = a[i];
                dp[i] = 1;
            } else if (a[i] >= memo[maxSize]) {
                ++maxSize;
                memo[maxSize] = a[i];
                dp[i] = maxSize;
            } else {
                int k = binarySearch(memo, a[i], 1, maxSize);
                memo[k + 1] = a[i];
                dp[i] = k + 1;
            }
        }
        System.out.print(maxSize + " :: ");
        for (int i = 1; i <= maxSize; ++i) {
            System.out.print(memo[i] + " ");
        }
        System.out.println();
    }

    public static void main(String args[]) {
        getLongestIncreasingSubsequence(new int[]{10, 22, 9, 33, 21, 50, 41, 60});
        getLongestIncreasingSubsequence(new int[]{10, 22, 9, 33, 21, 50, 41, 60, 80});
        getLongestIncreasingSubsequence(new int[]{1, 1, 1, 1, 0, 0, 0, 0, 0});
        getLongestIncreasingSubsequence(new int[]{0, 0, 0, 0, 0, 1, 1, 1, 1});
    }
}

Comment on Find the largest BST subtree in a given Binary Tree by kartikaditya

kartikaditya — Tue, 21 Feb 2012 15:12:01 +0000

Dude 45 is to the left of 40

Comment on Find the largest BST subtree in a given Binary Tree by Neeraj

Neeraj — Tue, 21 Feb 2012 14:56:52 +0000

I don't follow. Why is the largest BST of size 3? The entire tree seems like a BST to me?

/* Paste your code here (You may delete these lines if not writing code) */

Comment on Lucky Numbers by aravind

aravind — Tue, 21 Feb 2012 05:59:52 +0000

Thanks a lot for good code...

Comment on Dynamic Programming | Set 4 (Longest Common Subsequence) by kartikaditya

kartikaditya — Tue, 21 Feb 2012 05:17:02 +0000

public class LongestCommonSubsequence {
    public static String getLongestCommonSubsequence(String s1, String s2) {
		int dp[][] = new int[s1.length()][s2.length()];
		dp[0][0] = (s1.charAt(0) == s2.charAt(0)) ? 1 : 0;
		for (int i = 1; i < s1.length(); ++i) {
			if (s1.charAt(i) == s2.charAt(0)) {
				dp[i][0] = 1;
			} else {
				dp[i][0] = dp[i - 1][0];
			}
		}
		for (int i = 1; i < s2.length(); ++i) {
			if (s1.charAt(0) == s2.charAt(i)) {
				dp[0][i] = 1;
			} else {
				dp[0][i] = dp[0][i - 1];
			}
		}
		for (int i = 1; i < s1.length(); ++i) {
			for (int j = 1; j < s2.length(); ++j) {
				if (s1.charAt(i) == s2.charAt(j)) {
					dp[i][j] = 1 + dp[i - 1][j - 1];
				} else {
					dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j]);
				}
			}
		}
		StringBuffer sb = new StringBuffer();
		int x = s1.length() - 1, y = s2.length() - 1;
		while (x >= 0 && y >= 0) {
			if (s1.charAt(x) == s2.charAt(y)) {
				sb.append(s1.charAt(x));
				--x;
				--y;
			} else {
				if (x > 0 && dp[x - 1][y] == dp[x][y]) {
					--x;
				} else {
					--y;
				}
			}
		}
		return sb.reverse().toString();
	}

	public static void main(String[] args) {
		System.out.println(getLongestCommonSubsequence("ABCDGH", "AEDFHR"));
		System.out.println(getLongestCommonSubsequence("AGGTAB", "GXTXAYB"));
	}
}