CareerCup

As it is most obvious, the data structure to be used in this scenario is the STACK.
Here's the pseudocode:

check the first bit in the current position.
          if 1, top=top-2(delete current byte and subsequent byte)
          else top=top-1(delete only current byte)

Looking at the start of current index you can't be sure if the last char is a kanji char or ascii char, For that you need to be sure about the first char of the array.

so if the first char is Kanji (1@ MSB)or ascii, u need to increment the index accordingly.

A small mistake in my above algorithm..
the first bit of the previous index should be checked.
The rest works out well

All you need to do is check the msb at index-2. Assuming valid input, if MSB@index-2 is 1,then the prev character is kanji.. otherwise its ascii

int backspacePos(int index, char*arr)
{
if(index==0 ||index==1) return 0;
if(arr[index-2]&0x10000000==0x10000000)
return index-2;
return index-1;
}

char* shiftArr(int index1, int index2, char *arr)
{
int t1=index1,t2=index2;
while(arr[t2]!='\0')
{
arr[t1]=arr[t2];
t1++;
t2++;
}
arr[t1]='\0';
return arr
}

//usage
//k=backspacePos(index,array)
//array=shiftArr(k,index,array);

Does doing backspace simply imply shifting characters that begin from the index in the array one position earlier? Isnt it too much of overhead? I am not sure what exactly is expected here.

Why we have such algorithm problem? Is it appear in on-site interview?

Can anyone plz bring out the correct solution for this, so that we don't get confused?

first a few things to note-
--- i am assuming the data is stored as big endian. if it were stored as little endian, it would actually be easier for us to decode. little endian means if the data in hex is - 0xABCD, in the memory it is stored as CD AB. so for Kanji I would check if 0xCD & 0x80 == 1. since I am assuming big endian just for fun, by byte ordering is like AB CD.
--- how do I get the CD byte from the given index.
strncpy(a,&array[index-1],2); //so this will copy 2 bytes from the required position, which is one less than the given position.

if(a[1]&0x80==0x80) we know it was a kanji character, else fro ASCII we need to make sure a[0]& 0x80 == 0, because the MSB for that byte needs to be 0 for it to be an ASCII .

once we have figured out which character it was, it is easy to delete either one byte (ascii) or 2 bytes(kanji) from the original array.
now the original index numbers will be affected and I do not know whether they want us to fix that too.

---

Assuming BigEndian

void backSpace (char* text, int index)
{
	if (index <= 0 || index > strlen(text)-1)
	{
		return;
	}

	int shift = (text[index-2] & 0x80) ? 2 : 1;
	
	while (text[index] != '\0')
	{
		text[index-shift] = text[index];
		index++;
	}
	text[index-shift] = '\0';
}

Hey Andy can you explain:
int shift = (text[index-2] & 0x80) ? 2 : 1;

If say text[index-2] = 0xCD, then you are checking:
if (11001101 & 10000000) == true, i.e. 11111111
then shift = 2
else shift = 1

But if condition will always be false then ?

What is the question here? Can anyone post please!

I Hope this was the original question..

First some definitions for this problem: a) An ASCII character is one byte long and the most significant bit in the byte is always ‘0′. b) A Kanji character is two bytes long. The only characteristic of a Kanji character is that in its first byte the most significant bit is ‘1′.

Now you are given an array of a characters (both ASCII and Kanji) and, an index into the array. The index points to the start of some character. Now you need to write a function to do a backspace (i.e. delete the character before the given index).

hi cunomad,

you are such a lose.fuck you man.fuck off from Careercup.Why are you writing random questions and waste people time.Dont play with our lifes and careers.You loser.Go to hell dude..Please die