CareerCup

correct it, if i am wrong,
if the BST contains 7 nodes,
number of recursive calls called will be 7 , and the call returns value only after calling the leaf nodes

But counting number of nodes in the left subtree and right subtree itself takes O(n)

I also thought same thing.. but we need O(log n)!

Add a new node at the end of the linkedlist, while traversing count the number of nodes and make use of that count with equal probability.

number of nodes in the BST is known or unknown ?

Each Post/Comment can be liked by set of users
so a table with columns comment_id/post_id and user_id will solve the problem.

It is correlated subquery.. we can also use

select * from books order by price desc limit(0,5);

but if the 5th price is repeated , the query wont consider..
but this correlated subquery uses the condition : price >= 5th expensive price

but how the '5th expensive price' is calculated? it is done by making use of count(*) :)

For n=4.. you have to take 1,2 or 3.. So for n=1 , you have to take nothing.. so C(1) = 0.. C(2) = 1 ( {1, 1}), C(3) = 3 ({1,1,1},{2,1},{1,2})... and by your algo: C(4) = C(3) + C(2) + C(1) which gives 4(3+1+0) .. And also C(5) = 15 and by your algorithm it is 13.. a wrong answer..

public class Program15072768 {

	
	
	static int count = 0;
	
	
	static void C(int n,int tsum)
	{
		if(tsum == n)
		{
			count++;
			return;
		}
		else if(tsum > n)
		{
			return;
		}
		else{
			
			for(int i=1;i<n;i++)
			{
				
				C(n,i+tsum);
			}
		}
	}
	public static void main(String[] args) {
		 C(4,0);
		 System.out.println(count);
	}

}

Table Structure is wrong!!

table1 employee: employee_id, employee_name, salary, dept_id
table 2 department: dept_id, dept_name, reg_id
table 3 region: reg_id , reg_name

Query :
select employee_id, employee_name, salary , e.dept_id
from employee e join department d on e.dept_id = d.dept_id
join region r on r.reg_id = d.reg_id
where r.reg_name = ?

ha ha!! if you remove two edges, there will be two trees with one node each and one tree with remaining nodes :)

how it is possible??? sum of the weight of all nodes of all the three tree is constant.... if one tree have max weight and other two should not have maximum weight

From 1 to 50
Let the coin be at the initial position and the number of steps moved is zero
>>the next six step or cell(2,3,4,5,6,7) can be reached with minimum 1 dice roll
>>mark the cell with 1
>>if any of these six cell has lower point of ladder then mark upper point of ladder with 1
>>continue the above steps with MAXIMUM upper point of the ladder and mark the further cell with current weight(here it is 1) with 1

For 51 to 100
>> instead of ladder use snake!!

select name,avg(salary)
from emp e join dept d on e.deptno = d.deptno
group by name;

use HashMap<Integer,Set<Word>> where key is the length of the word..
get the Set<Word> for the given length and use a function

boolean isWord(String input)
      {
                     // which returns true if a word which differs by one character exists and also not visited before..
                   // this process repeated till we reach the target word or null... 
      }

naga-programming-concepts.blogspot.in/2012/12/bus-reseravation-httpwwwcareercupcomque.html

but it allows logging in two browsers!! one account can be logged in one time at the same time!

'1abcdefg' is not covered here!

'aabbccdd' is valid which is wrong.. atleast one number should be there..

about length which should be only 8??

Assumption: 'ab' is consecutive but not 'ba'

algo:

int previous_char = character[0];
for i=1 to n-1
{
    int current = character[i];
    if(current = previous_char + 1)
            return true;
    previous_char = current;
}
return false;

why cant we implement min-heap here:
For insertion: insert at the top and min-heapify
For popping: take the top element and min-heapify

1234/4 = ??? 1234567/7 =?? 12345678/8 = ??

search for how to create Facebook apps..

Facebook uses FQL...
Friend lists are persistent data and are stored in a database..
i dont think a particular datastructure is used for STORING FRIEND LIST

1. calculate number of space between words: here it is 2
2. calculate number of space to be distributed : here 15-11 = 4
3. each space between words will have additional space: 4/2 and either first or last space will have 4%2 (here 0, so distribution is common) additional space

finally: "DOG<space><space><space>IS<space><space><space>CUTE"

O(n) solution:
ideone.com/KeAcS

the element in the subset should be consecutive.. that is sub-array..
if it is not consecutive, then we can take only positive elements from the array which is not at all a problem to post and discuss here. ..

what 127775 / 50000 should give??
2.(5)
or 2.5555 ??

@Sanjay:
if you seen the decimal value should not repeat, then 225/1000 give only 0.(2)

the task is the decimal PATTERN should not be repeated.. not decimal VALUE..

you are seeing for the first decimal quotient not to repeat..
but i seen first remainder not to repeat..

because 10/7 and 11/7 both give quotient 1..

my answer for 1/97 is

0.01(030927835051546391752577319587628865979381443298969072164948453608247422680412371134020618556701)

as there are 97 possible remainders.. these number of decimal points.. when you try to go further.. the pattern in the bracket will be repeated..

used kadane's algorithm

haha.. the answer should be {40,-10,-10,100,1}
see: ideone.com/mttTG

can you explain your question ??

Use Graph:
1) each node is a user
2) each edge has weight 1
3) using dijikstra algorithm to find the shortest path between two nodes
4) degree of connection = number of edges

again modified the code.. check the link again..
thank you for giving the counter test case :)

understand the program first, then you will know that it is not much complicated as you are thinking..

if you use a variable, how will you say it is a nth element from tail??
are u going to use n variables to find nth element from tail?

check for 10/3 ..

a single pass means , a node can be visited only once.. whether it is single pointer or two pointer..

you are done two pass... first pointer traverse n elements and the second pointer traverse n-5 elements

Use One pointer to the list and a queue of size 5:
1) traverse to the 5th node
2) insert the element at the queue
3) if the queue is full, take rear element out and insert the new element at the front
4) repeat it till the pointer reaches null
5) the rear pointer of the queue contains the 5th element from the tail of the list..

Thank you for the finding the mistake.. now changed the code. check the same link

ideone.com/btABe

public static int isCommonArea(Rectangle rectOne,Rectangle rectTwo)
        {
                int x1 = rectOne.top_left_x;
                int y1 = rectOne.top_left_y;
                int x2 = rectOne.right_bottom_x;
                int y2 = rectOne.right_bottom_y;
                
 
                int x3 = rectTwo.top_left_x;
                int y3 = rectTwo.top_left_y;
                int x4 = rectTwo.right_bottom_x;
                int y4 = rectTwo.right_bottom_y;
                
                if(x1<x3 && x3<x2 && y1>y3 && y3>y2)
                        return 1;
                if(x1<x3 && x3<x2 && y1>y4 && y4>y2)
                        return 1;
                if(x1<x4 && x4<x2 && y1>y3 && y3>y2)
                        return 1;
                if(x1<x4 && x4<x2 && y1>y4 && y4>y2)
                        return 1;
                return -1;
        }

For Full Code: ideone.com/yyE68

@VRAM: ya man.. it wont work.. u have to use KMP string matching algorithm.. for the solution.. see my comment at the top

for simplicity : i am explaining for sorting 10 numbers with memory size 2
a) find the minimum element and its index in one full traverse from i to (total_numbers -1) [here it is 8]for (i+1)th iteration
for ex: {5,8,1,3,9,10,6,4,2,7} , store {2,1} where 2 is the index and 1 is the element for 1st iteration
b) swap(input[min_index],input[i]) where (i+1)th iteration
here,
swap (input[2],input[0]) for the 1st iteration
c) repeat a) and b) for 8 times .. as for 9th iteration no swaping will be there and elements are sorted..

use KMP string Matching.. for solution: ideone.com/t2nPA

@neel: LOL... inorder array of a BST always in ascending order.. else it wont be a BST..

take {1,2,3,1,4,2,3,7,5,6}
range : only one range.. 1...7
now..
first consecutive: 1,2,3 as the next 1 repeated and cannot be taken into account and length = 3
next..
1,4,2,3,7,5,6.. and length = 7 greater than previous one.. so update it..

if there is any out of range value eg: 10.. counting is stopped and checked for consecutiveness(whether '1' in array[] is continuous) and previous count..

Note: you have to update the count only the array[] is of the form {1,1,1,0,0,0..} not {1,0,1,0,1,1} because numbers should be consecutive

ya.. i too say the same.. :)

consider the array[] = {1,1000,2,999,998}
here longest sorted sequence is {998,999,1000} which can only be taken for count..
if 1,2 are continuous then 998,999,1000 are also continuous with long length..
in either case {1,2} doesnt affect the answer.. so we can leave {1,2} while traversing..