Category: leetcode solutions

Orignal question can be found here.

My solution is as follows:

int integerBreak(int n)
{
        int result=0;
        int new_result=0;
        for(int cnt=2; cnt<=n; ++cnt)
        {
                new_result=pow((n/cnt+1), n%cnt) * pow(n/cnt,(cnt-n%cnt));
                if( new_result > result)
                        result=new_result;
                else
                        break;
        }
        return result;
}

Orignal question can be found here.

My solution is as follows:

int titleToNumber(char* s)
{
        int result=0;
        for(int i=0; i<strlen(s); ++i)
        {
                result=result*26+s[i]-'A'+1;
        }
        return result;
}

Orignal question can be found here.

My solution is as follows:

bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
        if(p==NULL && q==NULL)
                return true;
        if(p==NULL || q==NULL)
                return false;
        if(p->val==q->val)
        {
                return (isSameTree(p->left,q->left) && isSameTree(p->right, q->right));
        }

        return false;
}

Orignal question can be found here.

My solution is as follows:

void moveZeroes(int* nums, int numsSize)
{
        int zero_cnt = 0;
        for(int i=0; i<numsSize; ++i)
        {
                if(nums[i] == 0)
                        ++zero_cnt;
                else
                        nums[i-zero_cnt] = nums[i];
        }

        for(int i=numsSize-1; i>numsSize-1-zero_cnt; --i)
                nums[i] = 0;
}

Orignal question can be found here.

My solution is as follows:

struct TreeNode* invertTree(struct TreeNode* root)
{
        if(root==NULL)
                return root;
        else
        {
                struct TreeNode* left_child=root->left;
                struct TreeNode* right_child=root->right;
                root->left=right_child;
                root->right=left_child;
                invertTree(root->left);
                invertTree(root->right);
        }
        return root;
}

Orignal question can be found here.

My solution is as follows:

char findTheDifference(char* s, char* t)
{
        int hash[26];
        for(int i=0; i<26; ++i)
                hash[i]=0;
        for(int i=0; i<strlen(s); ++i)
                ++hash[s[i]-'a'];
        for(int i=0; i<strlen(t); ++i)
        {
                if(hash[t[i]-'a']==0)
                        return t[i];
                else
                        --hash[t[i]-'a'];
        }
        return NULL;
}

Orignal question can be found here.

My solution is as follows:

int* twoSum(int* numbers, int numbersSize, int target, int* returnSize)
{
        *returnSize=2;
        int i=0;
        int j=numbersSize-1;
        int* result=(int*) malloc(sizeof(int)*(*returnSize));
        while(i<j)
        {
                if(numbers[i]+numbers[j]==target)
                {
                        result[0]=i+1;
                        result[1]=j+1;
                        break;
                }
                else if(numbers[i]+numbers[j]>target)
                        --j;
                else
                        ++i;
        }
        return result;
}

Orignal question can be found here.

My solution is as follows:

int maxDepth(struct TreeNode* root)
{
        if(root == NULL)
                return 0;
        int left_child_depth = maxDepth(root->left);
        int right_child_depth = maxDepth(root->right);
        return left_child_depth>=right_child_depth ? (left_child_depth+1):(right_child_depth+1);
}

Orignal question can be found here.

My solution is as follows:

int* countBits(int num, int* returnSize)
{
        *returnSize = num+1;
        int *result = (int*) malloc(sizeof(int)*(*returnSize));
        result[0] = 0;

        for(int i=1; i<=num; ++i)
                if(i%2 == 0)
                        result[i] = result[i/2];
                else
                        result[i] = result[i-1]+1;

        return result;

}

Orignal question can be found here.

My solution is as follows:

int firstUniqChar(char* s)
{
        unsigned int hash[26];

        for(int i=0; i<26; ++i)
                hash[i]=0;

        for(int i=0; i<strlen(s); ++i)
        {
                ++hash[(s[i] - 'a')];
        }

        for(int i=0; i<strlen(s); ++i)
                if(hash[(s[i] - 'a')] == 1)
                        return i;
        return -1;
}