CareerCup

BTW, I have come up with the below algorithm

int[] plusplus(int[] inArr)
{
Find length of input Array;
Define outputArraylength={length of input Array}; + 1;
declare outputArray
Declare carry variable
decrement OutputArraylength
Loop (outArraylen>=0)
{
if (inlen == (inArr.Length - 1))
carry = inArr[inlen--] + 1;
else if (inlen>=0)
carry += inArr[inlen--];
outArr[outlen--] = carry % 10;
carry /= 10;
}

return outputArray;
}

Better way to store long integer data type data is array. So that we can use this number for any arithmetic operation. eg) if the number is 123456789, keep the data in the form of (1,2,3,4,5,6,7,8,9)

Jialin code will not work all the scenarios.. Karthik code will work all the scenario with same time and space complexity

Here is the C# version for the same

public static void printParen(int pos, int open, int close, char[] str, int n)
{
if(close == n)
{
Console.WriteLine(new string(str));
return;
}
else
{
if(open > close)
{
str[pos] = '}';
printParen(pos + 1, open, close + 1, str, n);
}
if(open < n)
{
str[pos] = '{';
printParen(pos + 1, open + 1, close, str, n);
}
}
}

You should not use additional memory. With Additional memory life is simple

You can find out this one using distance.
1. You should know the orignal header in the linked list eg) 1
2. Form a Array with given linked element with distance
list=1->2->3->4->5
eg)
a(1)->0,a(2)->1,a(3)->2,a(3)->3,,,,
in this case we need to move forward 3

eg)2
for the backward cursor set the orginal header and set the distance as -{orginal position of newpointer}-{each node position}

as per the second example

a(1)->-4,a(2)->-3,a(3)->-2,a(3)->-1,a(4)->0

This will easy for us to figure it out.

While allocating a seat, we should give a space between each group.

Thank you Nani. It is simple one. I think instread of creating a new boolean 2D Array, we might play around the existing array with different values like -1 for visited 0s and -2 for 1s and count the 1 group. What you think?.

void treeToDoublyList(treeNode *rootNode, treeNode *& prevNode, treeNode *& head)
{
if (!rootNode)
return;
treeToDoublyList(rootNode->pLeft, prevNode, head);
rootNode->pLeft = prevNode;
if (prevNode)
prevNode->pRight = rootNode;
else
head = rootNode;
treeNode *rNode = rootNode->pRight;
head->pLeft = rootNode;
rootNode->pRight = head;
prevNode = rootNode;
treeToDoublyList(rNode, prevNode, head);
}

treeNode* treeToDoublyList(treeNode *rootNode)
{
treeNode *prev = NULL;
treeNode *head = NULL;
treeToDoublyList(rootNode, prev, head);
return head;
}