CareerCup

bool IsSet(int * a, int n)
{
    int t = 0;
    while (t < n)
    {
     if (a[t] <= 0)
         return false;
     if (t == 0)
         continue;
     if (a[t] <= a[t - 1])
         return false;
     t++;
    }
    return true;
}

I think the problem can be solved using a bit vector.
public static boolean isUnique(int[] a){
int prev = 0;
int res;
for(int i=0; i<a.length;i++) {
res = prev ^ (1<<a[i]);
if(res<prev) return false;
prev=res;
}
return true;
}

Let n = array size;
int i = 1;
bool ifArrayIsSet(int* arr, int n ) {
int i = 1;
while( i < n && arr[i] > 0 && arr[i] > arr[i-1] && i++);

if(i == n)
return true;
return false;
}

#include<stdio.h>



void main()
{
	int a[10],i,k=1,l;
	printf("\nenter elements");
	for(i=0;i<10;i++)
		scanf("%d",&a[i]);
	i=0;
	if(a[i]>=0)
		for(i=0;i<9;i++)
			if(a[i]>a[i+1])
			{
				k=0;
				break;
			}
			else
				k=1;
	else
		printf("Not a set");
	if(k==0)
		printf("it is not a set");
	else
		printf("SET");
}

1. sort direction is not an issue, cause if descending, just traverse the array from tail.
2. only check <= is fine, it will cover the duplicate case.
here is the c# code

public static bool IsSet(int[] array) {
    if(array == null || array.Length == 0) return false;

    if(array[0] <= 0) return false; // if ascending, only need to check once
    for(int i=0; i<array.Length-1; i++) {
        if(array[i] >= array[i+1]) return false;
    }
    return true;
}

Any solution to check if the array has duplicates will take O(n^2) time or O(n) time with O(n) space.

Sorted and positive numbers can be checked otherwise in O(N)

I think this problem can be solved by Balanced binary search tree.
Case 1:
when we scan the array simple check it is positive or not.
Case 2:
When you create the BST inorder traversal will automatically gives you element in sorted order.
Case 3:
For searching complexity will be log(n) which also for inserting the element.