LeetCode #2 ( #7, #9, #13)

7. Reverse Integer

Given a 32-bit signed integer, reverse digits of an integer.

Example 1:
Input: 123
Output: 321

Example 2:
Input: -123
Output: -321

Example 3:
Input: 120
Output: 21

Example 4:
Input: 1534236469
Output: 0

Note:
Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−2^31, 2^31 − 1]. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.

//Solution
//总结：%就可以得到余数，得到的余数也可为负数；注意Note中的范围判断
int reverse(int x){
    long long t = x,t1 = 0;
    while (t)
    {
        t1 = 10 * t1 + (t%10);
        t= t/10;
    }
    if(t1 <INT_MIN ||t1>INT_MAX) return 0;
    return t1;
}

9. Palindrome Number

Determine whether an integer is a palindrome. An integer is a palindrome when it reads the same backward as forward.

Example 1:
Input: 121
Output: true

Example 2:
Input: -123
Output: false
Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome.

Example 3:
Input: 10
Output: false
Explanation: Reads 01 from right to left. Therefore it is not a palindrome.

//Solution
//总结：最中间的数字不重要，所以只要求两边的数字相等即可。
bool isPalindrome(int x){
    if(x<0 || (x%10==0 && x!=0)) return false;
    int backnum = 0;
    int temp;
    while (x > backnum)
    {
        backnum = backnum *10 +x%10;
        x /=10;
    }
    return (x==backnum||x==backnum/10);
}

Follow up:
Coud you solve it without converting the integer to a string?

//Solution
//总结：将int转化为字符串，再通过两端进行比对。
class Solution {
    public boolean isPalindrome(int x) {
        String str = String.valueOf(x);
        int start = 0;
        int end = str.length()-1;
        while(start <end )
        {
            if(str.charAt(start++) != str.charAt(end--) ) return false;
        }
        return true;
    }
}

13. Roman to Integer

Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.
Symbol Value
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
For example, two is written as II in Roman numeral, just two one’s added together. Twelve is written as, XII, which is simply X + II. The number twenty seven is written as XXVII, which is XX + V + II.

Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:
I can be placed before V (5) and X (10) to make 4 and 9.
X can be placed before L (50) and C (100) to make 40 and 90.
C can be placed before D (500) and M (1000) to make 400 and 900.

Given a roman numeral, convert it to an integer. Input is guaranteed to be within the range from 1 to 3999.

Example 1:
Input: “III”
Output: 3

Example 2:
Input: “IV”
Output: 4

Example 3:
Input: “IX”
Output: 9

Example 4:
Input: “LVIII”
Output: 58
Explanation: L = 50, V= 5, III = 3.

Example 5:
Input: “MCMXCIV”
Output: 1994
Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.

//Solution
//总结：罗马数字转换成整数的规则如下：如果前一个数的值小于后一个数的值
//那么这个数为后者减去前者。如果前者大于后者，那么就是简单地相加即可。
int valueofnum(char s)
{
    int sum;

    if(s == 'I') sum =1;
    if(s == 'V') sum =5;
    if(s == 'X') sum =10;
    if(s == 'L') sum =50;
    if(s == 'C') sum =100;
    if(s == 'D') sum =500;
    if(s == 'M') sum =1000;
    
    return sum;
}
int romanToInt(char * s){
    int length = strlen(s);
    int i ;
    int sum = 0;
    int t1,t2;
    for(i = 0 ; i< length -1;i++)//判断到倒数第二个
    {
        t1 = valueofnum(s[i]);
        t2 = valueofnum(s[i+1]);
        if(t1<t2) sum = sum + t2 -t1,i++;
        else sum = sum +t1;
    
    }
    if(i==length-1)sum = sum+valueofnum(s[i]); 
    //如果此时i已经到length说明循环中t1<t2已经执行过，已经搜索完了就
    return sum;
}