LeetCode题解(二)

LeetCode题解(二)

Roman to Integer

Given a roman numeral, convert it to an integer.

Input is guaranteed to be within the range from 1 to 3999.

int romanToInt(char* s) {
    int len = strlen(s);
    int prev = 0;
    int result = 0;
    int ele = 0;
    for (int i = len - 1; i > -1; --i) {
        switch (*(s + i))   {
            case 'i': case 'I': ele = 1; break;
            case 'v': case 'V': ele = 5; break;
            case 'x': case 'X': ele = 10; break;
            case 'l': case 'L': ele = 50; break;
            case 'c': case 'C': ele = 100; break;
            case 'd': case 'D': ele = 500; break;
            case 'm': case 'M': ele = 1000; break;
        }

        if (ele < prev) {
            result -= ele;
        }
        else
            result += ele;
        prev = ele;
    }

    return result;
}

Valid Parentheses

Given a string containing just the characters ‘(‘, ‘)’, ‘{‘, ‘}’, ‘[’ and ‘]’, determine if the input string is valid.

The brackets must close in the correct order, “()” and “()[]{}” are all valid but “(]” and “([)]” are not.

bool isValid(char* s) { 
    int len = (s == NULL) ? 0 : strlen(s);
    if (len < 2 || *s == ')' || *s == ']' || *s == '}')
        return false;

    char s_copy[len];
    strcpy(s_copy, s);
    char ele;
    int left_count = 0, right_count = 0;
    bool flag = false;
    for (int i = 0; i < len; ++i) {
        if (*(s + i) == ')') {
            flag = true; ele = '('; ++left_count; s_copy[i] = '\0';
        } else if (*(s + i) == ']') {
            flag = true; ele = '['; ++left_count; s_copy[i] = '\0';
        } else if (*(s + i) == '}') {
            flag = true; ele = '{'; ++left_count; s_copy[i] = '\0';
        } else {
            flag = false; ++right_count;
        }

        if (flag) {
            for (int j = i - 1; j > -1; --j) {
                if (s_copy[j] == '\0') {
                    if (j == 0)
                        return false;
                    else
                        continue;
                } else {
                    if (s_copy[j] != ele)
                        return false;
                    else
                        s_copy[j] = '\0';
                    break;
                }
            }
        }
    }

    if (left_count != right_count)
        return false;
    else
        return true;
}

Merge Two Sorted Lists

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {
    if (l1 == NULL)
        return l2;
    if (l2 == NULL)
        return l1;
    struct ListNode* result = NULL;
    if (l1->val < l2->val) {
        result = l1;
        result->next = mergeTwoLists(l1->next, l2);
    } else {
        result = l2;
        result->next = mergeTwoLists(l1, l2->next);
    }

    return result;
}

Valid Sudoku

Determine if a Sudoku is valid, according to: Sudoku Puzzles - The Rules.
1. Each row must have the numbers 1-9 occuring just once.
2. Each column must have the numbers 1-9 occuring just once.
3. And the numbers 1-9 must occur just once in each of the 9 sub-boxes of the grid.

The Sudoku board could be partially filled, where empty cells are filled with the character ‘.’.

A partially filled sudoku which is valid.

Note:
A valid Sudoku board (partially filled) is not necessarily solvable. Only the filled cells need to be validated.

bool isValidSudoku(char** board, int boardRowSize, int boardColSize) {
    if (board == NULL || boardRowSize % 3 != 0 || boardColSize % 3 != 0)
        return false;

    char row_valid[10];
    char col_valid[10];
    char subboard_valid[10];
    for (int i = 0; i < boardRowSize; ++i) {
        memset(row_valid, 0, sizeof(char) * 10);

        for (int j = 0; j < boardColSize; ++j) {
            if (*(*(board + i) + j) != '.') {
                if (row_valid[*(*(board + i) +j) - '0'])
                    return false;
                else
                    row_valid[*(*(board + i) + j) - '0'] = 1;
            }
        }
    }

    for (int j = 0; j < boardColSize; ++j) {
        memset(col_valid, 0, sizeof(char) * 10);
        for (int i = 0; i < boardRowSize; ++i) {
            if (*(*(board + i) + j) != '.') {
                if (col_valid[*(*(board + i) + j) - '0'])
                    return false;
                else
                    col_valid[*(*(board + i) + j) - '0'] = 1;
            }
        }
    }

    int n = (boardRowSize / 3) * (boardColSize / 3);
    int row = 0;
    int col = 0;
    for (int i = 0; i < n; ++i) {
        memset(subboard_valid, 0, sizeof(char) * 10);
        for (int j = 0; j < 9; ++j) {
            row = 3 * (i / 3) + j / 3;
            col = 3 * (i % 3) + j % 3;
            if (*(*(board + row) + col) != '.') {
                if (subboard_valid[*(*(board + row) + col) - '0'])
                    return false;
                else
                    subboard_valid[*(*(board + row) + col) - '0'] = 1;
            }
        }
    }

    return true;
}

Count and Say

The count-and-say sequence is the sequence of integers beginning as follows:
1, 11, 21, 1211, 111221, …

1 is read off as “one 1” or 11.
11 is read off as “two 1s” or 21.
21 is read off as “one 2, then one 1” or 1211.
Given an integer n, generate the nth sequence.

Note: The sequence of integers will be represented as a string.

/**
 * 请用户释放返回的指针指向的内存
 * */

char* countAndSay(int n) {
    int N = n > 1 ? expl(n / 4) * 10 : 2;
    char* result = (char*)malloc(sizeof(char) * N); 
    memset(result, 0, sizeof(char) * N);
    if (n < 1)
        return result;

    char* cache = (char*)malloc(sizeof(char) * N);
    result[0] = '1';
    if (n == 1)
        return result;
    int count;
    char ele;
    for (int i = 2; i < n + 1; ++i) {
        memset(cache, 0, sizeof(char) * N);
        count = 0;
        ele = result[0];
        for (int j = 0; j < strlen(result); ++j) {
            if (result[j] == ele) {
                ++count;
            } else {
                cache[strlen(cache)] = '0' + count;
                cache[strlen(cache)] = ele;
                ele = result[j];
                count = 1;
            }
            if (j == strlen(result) - 1) {
                cache[strlen(cache)] = '0' + count;
                cache[strlen(cache)] = ele;
            }
        }
        memcpy(result, cache, sizeof(char) * N);
    }

    free(cache);
    return result;
}

Length of Last Word

Given a string s consists of upper/lower-case alphabets and empty space characters ’ ‘, return the length of last word in the string.

If the last word does not exist, return 0.

Note: A word is defined as a character sequence consists of non-space characters only.

For example,
Given s = “Hello World”,
return 5.

int lengthOfLastWord(char* s) {
    if (s == NULL || *s == '\0')
        return 0;
    int len = strlen(s);
    char copy[len + 1];
    strcpy(copy, s);
    s = &copy[0];
    char* last_space = strrchr(s, ' ');
    // 去首尾空格
    while (*s == ' ') {
        s += 1;
    }
    while (last_space == s + strlen(s) - 1) {
        *last_space = '\0';
        last_space = strrchr(s, ' ');
    }

    len = strlen(s);
    if (len == 0) {
        return 0;
    }
    else {
        if (!last_space)
            return len;
        else
            return s + len - 1 - last_space;
    }
}

Plus One

Given a non-negative number represented as an array of digits, plus one to the number.

The digits are stored such that the most significant digit is at the head of the list.

/**
 * Return an array of size *returnSize.
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* plusOne(int* digits, int digitsSize, int* returnSize) {
    int* result = NULL;
    bool is_carry = false;
    if (digitsSize < 1) {
        *returnSize = 0;
        return NULL;
    }

    for (int idx = 0; idx < digitsSize; ++idx) {
        if (*(digits + idx) != 9) {
            is_carry = false;
            break;
        } else {
            is_carry = true;
        }
    }

    if (is_carry) {
        result = (int*)malloc(sizeof(int) * (digitsSize + 1));
        *returnSize = digitsSize + 1;
        result += 1;
    } else {
        result = (int*)malloc(sizeof(int) * digitsSize);
        *returnSize = digitsSize;
    }

    int carry_bit = 0;
    *(result + digitsSize - 1) = (*(digits + digitsSize - 1) + 1) % 10;
    carry_bit = (*(digits + digitsSize - 1) + 1) / 10;
    for (int index = digitsSize - 2; index > -1; --index) {
        *(result + index) = (*(digits + index) + carry_bit) % 10;
        carry_bit = (*(digits + index) + carry_bit) / 10;
    }

    if (is_carry) {
        result -= 1;
        *result = carry_bit;
    }

    return result;
}

Add Binary

Given two binary strings, return their sum (also a binary string).

For example,
a = “11”
b = “1”
Return “100”.

char* addBinary(char* a, char* b) {
    if (a == NULL)
        return b;
    if (b == NULL)
        return a;

    int len_a = strlen(a);
    int len_b = strlen(b);
    if (len_a < len_b)
        return addBinary(b, a);

    int diff = len_a - len_b;
    b -= diff;
    int carry_bit = 0;
    char tmp[len_a + 2];
    char* result;
    memset(tmp, 0, sizeof(char)* (len_a + 2));
    result = tmp;
    int sum = 0;
    for (int idx = len_a - 1; idx > diff - 1; --idx) {
        sum = (a[idx] - '0') + (b[idx] - '0') + carry_bit;
        if (sum == 0) {
            *result = '0'; carry_bit = 0;
        } else if (sum == 1) {
            *result = '1'; carry_bit = 0;
        } else if (sum == 2) {
            *result = '0'; carry_bit = 1;
        } else if (sum == 3) {
            *result = '1'; carry_bit = 1;
        }
        ++result;
    }

    for (int idx = diff - 1; idx > -1; --idx) {
        sum = (a[idx] - '0') + carry_bit;
        if (sum == 0) {
            *result = '0'; carry_bit = 0;
        } else if (sum == 1) {
            *result = '1'; carry_bit = 0;
        } else if (sum == 2) {
            *result = '0'; carry_bit = 1;
        }
        ++result;
    }

    if (carry_bit)
        *result = '1';
    diff = strlen(tmp);
    result = (char*)calloc(diff + 1, sizeof(char));
    for (int idx = diff - 1; idx > -1; --idx)
        *(result + idx) = tmp[diff - idx - 1];
    return result;
}

Climbing Stairs

You are climbing a stair case. It takes n steps to reach to the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

int climbStairs(int n) {
    if (n < 3)
        return n;

    int fibo[n];
    fibo[0] = 1;
    fibo[1] = 2;
    for (int i = 2; i < n; ++i) {
        fibo[i] = fibo[i - 1] + fibo[i - 2];
    }

    return fibo[n - 1];
}

Remove Duplicates from Sorted List

Given a sorted linked list, delete all duplicates such that each element appear only once.

For example,
Given 1->1->2, return 1->2.
Given 1->1->2->3->3, return 1->2->3.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* deleteDuplicates(struct ListNode* head) {
    if (head == NULL || head->next == NULL)
        return head;

    struct ListNode* result = head;
    while (head && head->next) {
        if (head->val == head->next->val) {
            head->next = head->next->next;
        } else {
            head = head->next;
        }
    }

    return result;
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值