CareerCup

Steps:
Iterate the array recursively
at each call create node and update its key
if it is leaf node, return the newly created node
if not leaf node, call function to update left and right child nodes.
We need a pointer to keep track of location in array.

#include <stdio.h>
#include <stdlib.h>
//Definition of Node
struct node
{
	int key;
	struct node* left;
	struct node* right;
	};
typedef struct node Node;

//Recursive function
Node* preorderTree(int* array,int* nodearray,int* i, int size)
{
        int prev=*i;        
        Node* newnode=(Node*)malloc(sizeof(Node)) ;
        newnode->key=*(array+*i);
       
		*i=*i+1;
        if(*(nodearray+prev)==0)
            {             
                newnode->left=NULL;
                newnode->right=NULL;
                return newnode;
            }
        else if(*i<size)
        {            
            newnode->left=preorderTree(array,nodearray,i,size);
			newnode->right=preorderTree(array,nodearray,i,size);            
            return newnode;
        }        
              
}

//Test Code
int main()
{
	int array[5]={15,5,25,20,35};
    int nodearray[5]={1,0,1,0,0};
    int a=0;
	int arraysize=5;
    Node* result=NULL;

    result=preorderTree(array,nodearray,&a,arraysize);
    	
}

this is correct solution, I do not know why there are so many other different answers on this page.

C solution using array.

void commonCharacters(char* str1, char* str2, char* str3)
{
	int i=0;
	int array[26]={0};

	while(*str1!='\0')
	{
		if(array[*str1-97]==0)
			array[*str1-97]=1;
		str1++;
	}

	while(*str2!='\0')
	{
		if(array[*str2-97]==1)
			array[*str2-97]=2;
		str2++;
	}

	while(*str3!='\0')
	{
		if(array[*str3-97]==2)
			array[*str3-97]=3;
		str3++;
	}

	for(i=0;i<26;i++)
	{
		if(array[i]==3)
			printf("%c\n",i+97);
	}
}

Recursive solution

int rotated_binary_search(int A[], int start, int end, int key) 
{
	int middle=(start+end)/2;

	if(start==end)
	{
		if(A[start]==key)
			return start;
		else
			return -1;
	}

	if(A[start] <= A[middle] )
	{
		if(A[start]<=key && key<=A[middle])
			return	rotated_binary_search(A,start,middle,key);
		else
			return	rotated_binary_search(A,middle+1,end,key);
	}
	else
	{
		if(A[middle]<=key && key<=A[end])
			return	rotated_binary_search(A,middle,end,key);
		else
			return rotated_binary_search(A,start,middle-1,key);
	}
}