Question

I got this as an interview question …

infinite array which is sorted and from some position (we dont know the position) only special symbol ‘$’ will be there we need to find an element in that array …

i gave a solution like get the first occurrance of $ and then do binary search on the previous part from $

to find the first occurance of $ i gave solution like increment in window size if (i,2i)

the code i gave is

#include<stdio.h>

int first(int *arr,int start,int end,int index)
{
    int mid=(start+end)/2;
    if((mid==start||arr[mid-1] != '$') && arr[mid]=='$')
        return mid;
    if(arr[mid]=='$')
        return first(arr,start,mid-1,index);
    else
    {
        if(arr[end] =='$')
            return first(arr,mid+1,end,index);
        else
            return first(arr,end+1,(1<<index),index+1);
    }
}

int binsearch(int *arr,int end ,int n)
{
    int low,high,mid;
    high=end-1;
    low=0;
    while(low<= high)
    {
        mid=(low+high)/2;
        if(n<arr[mid])
            high=mid-1;
        else if (n >arr[mid])
            low=mid+1;
        else
            return mid;
    }
    return -1;
}

int main()
{
    int arr[20]={1,2,3,4,5,6,7,8,9,10,'$','$','$','$','$','$','$','$','$','$'};
    int i =first(arr,0,2,2);
    printf("first occurance of $ is  %d\n",i);
    int n=20;//n is required element to be found
    if(i==0||arr[i-1]<n)
        printf(" element %d not  found",n);
    else{
        int p=binsearch(arr,i,n);
        if(p  != -1)
            printf("element %d is found at index %d",n,p);
        else
            printf(" element %d not found",n);
    }
    return 0;
}

Is there any better way to do the above problem ??

And also i wanted to know to find the first occurance of $ why should we move the window only in powers of 2 why not 3 like (i,3i)

Can someone pls through some light on the recurrance relation ..pls help..

Answer 1

Seems like a fine way to do it to me. As a small optimization, you can stop your first routine when you reach any number bigger than the one you’re searching for (not just $).

Growing the window by powers of 2 means you’ll find the end in log_2(n) iterations. Growing by factors of 3 means you’ll find it in log_3(n) iterations, which is smaller. But not asymptotically smaller, as O(log_2(n)) == O(log_3(n)). And your binary search is going to take log_2(n) steps anyway, so making the first part faster is not going to help your big-O running time.