CareerCup

in C

int sum = 0;
int old_sum;

void inRevOrder(struct Node* node)
{
	if(!node) return;
	if(node->right) inRevOrder(node->right);
	old_sum = sum;
	sum += node->val;
	node->val = old_sum;
	if(node->left) inRevOrder(node->left);
}

I added comments to the code. Hope they help.

// Keeps a count of the depth (number of rucursive calls)
int count;

// Stores the visited elements' INDEX
int* done;

// Returns the number of calls possible without going
// beyond bounds and makes sure it does not visit
// already visited elements
void get_depth_for(int *i, int m, int size)
{
	// We continue only if the index is within bounds
	if(m < size)
	{
		// To know if the node has been visited aleady
		int found = 0;
		for(int x=0; x<count; x++)
		{
			if(done[x] == m)
			{
				found = 1;
				break;
			}
		}

		if(0 == found)
		{
			// If we are here, that means
			// 		the index has not been visited
			// 		AND
			// 		the index is within bounds
			done[count++] = m;

			// MOST IMPORTANT PART!
			// Call the function recursively with
			// the element at index m as the index
			// of the next element
			get_depth_for(i, i[m], size);
		}
	}
}

int main()
{
	int i[4] = {3, 1, 2, 0};
	int m;
	int highest = 0;
	done = malloc(sizeof(i));
	for(m=0; m<4; m++)
	{
		count = 0;
		get_depth_for(i, m, sizeof(i));
		if ( highest < count )
		{
			highest = count;
		}
	}
	printf("%d\n", highest);
	return 0;
}

int sum_pair_n(const int *i, const int size, const int sum)
{
	int tail = size - 1;
	int head = 0;
	int iSum;

	while(head < tail)
	{
		iSum = i[head] + i[tail];
		if(iSum == sum)
		{
			return 1;
		}
		else if(iSum < sum)
		{
			head++;
		}
		else if(iSum > sum)
		{
			tail--;
		}
	}
	return 0;
}

int sum_pair_logn(const int *i, const int size, const int sum)
{
	int head = 0;
	int look_for;

	while(head < size)
	{
		look_for = sum - i[head];
		int h=head+1, t=size;
		while(h<=t)
		{
			if(i[(h+t)/2] == look_for)
			{
				return 1;
			}
			else if(i[(h+t)/2] > look_for) t = (h+t)/2 - 1;
			else if(i[(h+t)/2] < look_for) h = (h+t)/2 + 1;
		}
		head++;
	}
	return 0;
}

int main()
{
	int i[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
	printf("%d\n", sum_pair_n(i, 10, 5));
	printf("%d\n", sum_pair_logn(i, 10, 4));
	return 0;
}

int main()
{
	char *str = "a1b10c4";
	char ch;
	long count=0;
	int m;
	while(*str != '\0')
	{
		ch = *str;
		sscanf(str + 1, "%ld", &count);
		for(m=0; m<count; m++)
			printf("%c", ch);
		str++;
		while(*str >= '0' && *str <= '9')
			str++;
	}
	return 0;
}

int main()
{
	int i[10] = {1, 5, 3, 4, 2, 6, 9, 8, 7, 0};
	int k = 2;
	int m;

	mergesort_s(i, 10);

	int *s, *f;
	s=f=i;

	while( *s < (*f + k ) )
	{
		s++;
	}

	int count = 0;

	while(s < (i + 10))
	{
		if((*s - *f) == k)
		{
			count++;
		}
		f++;
		while( *s < (*f + k ) )
		{
			s++;
		}
	}

	printf("%d\n", count);

	return 0;
}

This should time complexity : O(nlogn) + O(n) -> O(n)