leetCode

58

给定一个仅包含大小写字母和空格 ' ' 的字符串，返回其最后一个单词的长度。

如果不存在最后一个单词，请返回 0 。

说明：一个单词是指由字母组成，但不包含任何空格的字符串。

示例:

输入: "Hello World"
输出: 5

思路分析

将字符串逆转，通过遍历寻找第一个不是空格的字母下标，开始计数，知道遍历到下一个空格结束计数，返回

C++

class Solution {
public:
    int lengthOfLastWord(string s) {
        reverse(s.begin(),s.end());
        int res=0,i=0;
        while(s[i]!='\0'&&s[i]==' ')
                i++;
        while(s[i]!='\0'&&s[i]!=' '){
            i++;
            res++;
        }
        return res;
    }
};

Python3

class Solution:
    def lengthOfLastWord(self, s):
        """
        :type s: str
        :rtype: int
        """
        return len(s.strip().split(' ')[-1]) 

415

给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和。

注意：

num1 和num2 的长度都小于 5100.
num1 和num2 都只包含数字 0-9.
num1 和num2 都不包含任何前导零。
你不能使用任何內建 BigInteger 库， 也不能直接将输入的字符串转换为整数形式。

思路分析

将字符串转换成数组形式，从最后一位数字依次进行相加的和存到另一个数组中去，直到有一个数的全部位数被全部加完后，将剩下的非空数组逆转方向添加到结果数组中去，结果数组中的值分别是个位数，十位数...的值，对结果数组中的值进行乘加运算再将结果转化成字符串返回

C++

class Solution {
public:
    string addStrings(string num1, string num2) {
        reverse(num1.begin(), num1.end());
        reverse(num2.begin(), num2.end());
        string ans;
        int len1 = num1.size(), len2 = num2.size(), i = 0, flag = 0;
        while(i < len1 || i < len2)
        {
            int val = 0;
            if(i < len1) val += (num1[i] - '0');
            if(i < len2) val += (num2[i] - '0');
            ans += (val+flag)%10 + '0';
            flag = (val+flag)/10;
            i++;
        }
        if(flag) ans += '1';
        reverse(ans.begin(), ans.end());
        return ans;
    }

python3

class Solution:
    def addStrings(self, num1, num2):
        """
        :type num1: str
        :type num2: str
        :rtype: str
        """
        return str(eval(num1)+eval(num2))

448

给定一个范围在  1 ≤ a[i] ≤ n ( n = 数组大小 ) 的 整型数组，数组中的元素一些出现了两次，另一些只出现一次。

找到所有在 [1, n] 范围之间没有出现在数组中的数字。

您能在不使用额外空间且时间复杂度为O(n)的情况下完成这个任务吗? 你可以假定返回的数组不算在额外空间内。

示例:

输入:
[4,3,2,7,8,2,3,1]

输出:
[5,6]

思路

先遍历一遍数组，若数字i在数组中，将以数字i为下标的元素变为负号。第二遍遍历数组时找出数组中为正值的项，其下标加1即没有出现过的数字。

C++

class Solution {
public:
    vector<int> findDisappearedNumbers(vector<int>& nums) 
    {
        vector<int> res;
        for(int i = 0; i < nums.size(); ++i)
        {
            int temp = abs(nums[i]) - 1;
            if(nums[temp] > 0)
                nums[temp] = -nums[temp];
        }

        for(int i = 0; i < nums.size(); ++i)
        {
            if(nums[i] > 0)
                res.push_back(i + 1);
        }
        return res;
    }
};

Python3

class Solution:
    def findDisappearedNumbers(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        flags=[0]*(len(nums)+1)
        res=[]
        for num in nums:
            flags[num]=1
        for i in range(1,len(nums)+1):
            if flags[i]==0:
                res.append(i)
        return res

537

给定两个表示复数的字符串。
返回表示它们乘积的字符串。注意，根据定义 i2 = -1 。

示例1

输入: "1+1i", "1+1i"
输出: "0+2i"
解释: (1 + i) * (1 + i) = 1 + i2 + 2 * i = 2i ，你需要将它转换为 0+2i 的形式。

示例2

输入: "1+-1i", "1+-1i"
输出: "0+-2i"
解释: (1 - i) * (1 - i) = 1 + i2 - 2 * i = -2i ，你需要将它转换为 0+-2i 的形式。 

思路分析

按照加号将输入进行分割，分割成实部和虚部两部分，然后根据公式进行运算

C++

class Solution {
public:
    string complexNumberMultiply(string a, string b) {
        int add_index=0;
        for(int i=0;i<a.length();i++)
            if(a[i]=='+')
                add_index=i;
        int a_real=atoi(a.substr(0,add_index).c_str());
        int a_image=atoi(a.substr(add_index+1,a.length()-add_index-1).c_str());
        for(int i=0;i<b.length();i++)
            if(b[i]=='+')
                add_index=i;
        int b_real=atoi(b.substr(0,add_index).c_str());
        int b_image=atoi(b.substr(add_index+1,b.length()-add_index-1).c_str());
        cout<<a_real<<endl<<a_image<<endl<<b_real<<endl<<b_image;
        return to_string(a_real*b_real-a_image*b_image)+'+'+to_string(a_real*b_image+a_image*b_real)+'i';
    }
};

Python3

class Solution:
    def complexNumberMultiply(self, a, b):
        """
        :type a: str
        :type b: str
        :rtype: str
        """
        a=a.split('+')
        b=b.split('+')
        real=int(a[0])*int(b[0])-int(a[1][:-1])*int(b[1][:-1])
        image=int(a[0])*int(b[1][:-1])+int(a[1][:-1])*int(b[0])
        return str(real)+'+'+str(image)+'i'

566

在MATLAB中，有一个非常有用的函数 reshape，它可以将一个矩阵重塑为另一个大小不同的新矩阵，但保留其原始数据。

给出一个由二维数组表示的矩阵，以及两个正整数r和c，分别表示想要的重构的矩阵的行数和列数。

重构后的矩阵需要将原始矩阵的所有元素以相同的行遍历顺序填充。

如果具有给定参数的reshape操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。

示例 1:

输入: 
nums = 
[[1,2],
 [3,4]]
r = 1, c = 4
输出: 
[[1,2,3,4]]
解释:
行遍历nums的结果是 [1,2,3,4]。新的矩阵是 1 * 4 矩阵, 用之前的元素值一行一行填充新矩阵。

示例 2:

输入: 
nums = 
[[1,2],
 [3,4]]
r = 2, c = 4
输出: 
[[1,2],
 [3,4]]
解释:
没有办法将 2 * 2 矩阵转化为 2 * 4 矩阵。 所以输出原矩阵。

思路分析

先判断矩阵元素总个数是否与r*c的乘积相同，若不同，则说明无法转换，接着进行矩阵之间的坐标变换，将原来的坐标值通过变换得到新的坐标值。也可将矩阵拉直成一维的，然后依次赋值给新的多维矩阵。

C++

class Solution {
public:
    vector<vector<int>> matrixReshape(vector<vector<int>>& nums, int r, int c) {
        int row = nums.size(), col = nums[0].size();
        if (row * col != r * c)
            return nums;
        vector<vector<int>> res(r, vector<int>(c));
        for (int i = 0; i < row; ++i) {
            for (int j = 0; j < col; ++j) {
                int to1dim = i * col + j,
                    newI = to1dim / c,
                    newJ = to1dim % c;
                res[newI][newJ] = nums[i][j];
            }
        }
        return res;
    }
};

Python3

class Solution:
    def matrixReshape(self, nums, r, c):
        """
        :type nums: List[List[int]]
        :type r: int
        :type c: int
        :rtype: List[List[int]]
        """
        matrix=[]
        matrix1=[]
        k=0
        for i in nums:
            matrix.extend(i)
        if len(matrix)!=r*c:
            return nums
        for i in range(r):
            matrix1.append([])
            for j in range(c):
                matrix1[i].append(matrix[k])
                k+=1
    return matrix1

682

你现在是棒球比赛记录员。
给定一个字符串列表，每个字符串可以是以下四种类型之一：
1.整数（一轮的得分）：直接表示您在本轮中获得的积分数。
2. "+"（一轮的得分）：表示本轮获得的得分是前两轮有效 回合得分的总和。
3. "D"（一轮的得分）：表示本轮获得的得分是前一轮有效 回合得分的两倍。
4. "C"（一个操作，这不是一个回合的分数）：表示您获得的最后一个有效 回合的分数是无效的，应该被移除。

每一轮的操作都是永久性的，可能会对前一轮和后一轮产生影响。
你需要返回你在所有回合中得分的总和。

示例 1:

输入: ["5","2","C","D","+"]
输出: 30
解释: 
第1轮：你可以得到5分。总和是：5。
第2轮：你可以得到2分。总和是：7。
操作1：第2轮的数据无效。总和是：5。
第3轮：你可以得到10分（第2轮的数据已被删除）。总数是：15。
第4轮：你可以得到5 + 10 = 15分。总数是：30。
示例 2:

输入: ["5","-2","4","C","D","9","+","+"]
输出: 27
解释: 
第1轮：你可以得到5分。总和是：5。
第2轮：你可以得到-2分。总数是：3。
第3轮：你可以得到4分。总和是：7。
操作1：第3轮的数据无效。总数是：3。
第4轮：你可以得到-4分（第三轮的数据已被删除）。总和是：-1。
第5轮：你可以得到9分。总数是：8。
第6轮：你可以得到-4 + 9 = 5分。总数是13。
第7轮：你可以得到9 + 5 = 14分。总数是27。
注意：

输入列表的大小将介于1和1000之间。
列表中的每个整数都将介于-30000和30000之间。

思路分析

新建一个栈或者数组，对原数组进行遍历，如果是数字就放入栈或者数组中，如果是字符就按照规则对其进行相应的操作，最后将新建的栈或数组和相加返回

C++

class Solution {
public:
    int calPoints(vector<string>& ops) {
        int sum = 0;
        vector<int> res;
        int len = res.size();
        for(int i=0;i<ops.size();i++){
            if(ops[i].compare("+")==0){
                res.push_back(res[res.size()-1]+res[res.size()-2]);
            }else if(ops[i].compare("D")==0){
                res.push_back(res[res.size()-1]*2);
            }else if(ops[i].compare("C")==0){
                res.pop_back();
            }else{
                res.push_back(stoi(ops[i]));
            }
        }
        for(int i=0;i<res.size();i++){
            sum += res[i];
        }
        return sum;
    }
};

Python3

class Solution:
    def calPoints(self, ops):
        """
        :type ops: List[str]
        :rtype: int
        """
        ops_1=[]

        for i in ops:
            if i=='+':
                ops_1.append(int(ops_1[-1])+int(ops_1[-2]))
            elif i=='D': 
                ops_1.append(2*int(ops_1[-1]))
            elif i=='C':
                ops_1.pop()
            else:
                ops_1.append(int(i))

        return sum(ops_1)

696

给定一个字符串 s，计算具有相同数量0和1的非空(连续)子字符串的数量，并且这些子字符串中的所有0和所有1都是组合在一起的。

重复出现的子串要计算它们出现的次数。

示例 1 :

输入: "00110011"
输出: 6
解释: 有6个子串具有相同数量的连续1和0：“0011”，“01”，“1100”，“10”，“0011” 和 “01”。

请注意，一些重复出现的子串要计算它们出现的次数。

另外，“00110011”不是有效的子串，因为所有的0（和1）没有组合在一起。

示例 2 :

输入: "10101"
输出: 4
解释: 有4个子串：“10”，“01”，“10”，“01”，它们具有相同数量的连续1和0。

思路分析

将字符串连续的字符的个数存成一个数组，所以总共的数量就是从数组中第二个元素起每个元素与前一个元素作比较取小的值的总和

C++

class Solution {
public:
    int countBinarySubstrings(string s) {
        int result=0,count =1;
        vector<int> num;
        for(int i = 1;i<s.length();i++)
        {
            if (s[i]==s[i-1]) count++;
                else 
                {
                    num.push_back(count);
                    count =1;
                }
        }
        num.push_back(count);
        for(int i = 1;i<num.size();i++)
        {
            result = result+min(num[i],num[i-1]);
        }
        return result;
    }
};

Python3

class Solution:
    def countBinarySubstrings(self, s):
        """
        :type s: str
        :rtype: int
        """
        output=0
        break_point_index=-1
        count=[]
        try:
            for i in range(len(s)):
                if s[i]!=s[i+1]:
                    count.append(i-break_point_index)
                    break_point_index=i
        except:
            count.append(i-break_point_index)
        for i in range(1,len(count)):
            if count[i]>count[i-1]:
                output+=count[i-1]
            else:
                output+=count[i]
        return output

739

根据每日 气温 列表，请重新生成一个列表，对应位置的输入是你需要再等待多久温度才会升高的天数。如果之后都不会升高，请输入 0 来代替。

例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。

提示：气温 列表长度的范围是 [1, 30000]。每个气温的值的都是 [30, 100] 范围内的整数。

思路分析：

我们定义一个栈，然后在遍历温度的时候分别做如下处理：

1）如果当天的温度比第二天的温度高，那么我们暂时还无法确定需要等多少天才能有更高的温度，所以就将当天的温度入栈。

2）如果当天的温度比第二天的温度低，那么它需要等待的天数就是1。但是此时我们需要更新栈顶元素对应的那天的等待时间。我们以题目中给出的例子为例来讲解：[73, 74, 75, 71, 69, 72, 76, 73]。扫描73, 74的时候，其对应结果为1；当遇到75的时候，由于75 > 71，所以我们将75入栈（此时栈内元素为75），71也同理（此时栈内元素为75,71）。当遇到69的时候，69 < 72，所以69的对应结果为1，但是由于72大于栈顶元素71，所以此时可以修改71对应的等待天数，即为72对应的天数索引与71对应的天数索引，然后71出栈（此时栈内元素为75）；当处理72的时候，结果为1，但是由于76大于栈顶元素75，所以修改75的等待天数，并出栈（此时栈内为空）。当处理76的时候，76需入栈。由于再也没有比76大的元素，并且73之后也没有元素了，所以76，73对应的等待天数就都为0了，在程序中并没有做处理。

C++

    class Solution {
    public:
        vector<int> dailyTemperatures(vector<int>& temperatures) {
            int n = temperatures.size();
            vector<int> ret(n, 0);
            stack<pair<int, int>> s;
            for (int i = 0; i < n - 1; ++i) {
                if (temperatures[i] < temperatures[i + 1]){
                    ret[i] = 1;
                    while (!s.empty() && temperatures[i + 1] > s.top().first) {
                        ret[s.top().second] = i + 1 - s.top().second;
                        s.pop();
                    } 
                } 
                else {
                    s.push(make_pair(temperatures[i], i));
                }
            }
            return ret;
        }
    };

Python3

class Solution:
    def dailyTemperatures(self, temperatures):
        """
        :type temperatures: List[int]
        :rtype: List[int]
        """
        length=len(temperatures)
        output=[]
        tmp=[]
        for i in range(length):
            output.append(0)
        for i in range(length-1):
            if temperatures[i]<temperatures[i+1]:
                output[i]=1
                while tmp!=[] and temperatures[i+1]>tmp[-1][0]:
                    output[tmp[-1][1]]=i+1-tmp[-1][1]
                    tmp.pop()
            else:
                tmp.append([temperatures[i],i])     
        return output