LeetCode 917. 仅仅反转字母 / 1706. 球会落何处 / 537. 复数乘法

Posted 2022-03-02 Zephyr丶J

0# 917. 仅仅反转字母
2022.2.23 每日一题

题目描述

给你一个字符串 s ，根据下述规则反转字符串：

所有非英文字母保留在原有位置。
所有英文字母（小写或大写）位置反转。

返回反转后的 s 。

示例 1：

输入：s = “ab-cd”
输出：“dc-ba”

示例 2：

输入：s = “a-bC-dEf-ghIj”
输出：“j-Ih-gfE-dCba”

示例 3：

输入：s = “Test1ng-Leet=code-Q!”
输出：“Qedo1ct-eeLg=ntse-T!”

提示

1 <= s.length <= 100
s 仅由 ASCII 值在范围 [33, 122] 的字符组成
s 不含 ‘"’ 或 ‘\\’

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-only-letters
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

先反转字母，然后加上符号；或者之间变成数组，反转

class Solution 
    public String reverseOnlyLetters(String s) 
        StringBuffer sb = new StringBuffer();
        int l = s.length();

        int right = l - 1;
        while(right >= 0)
            char c = s.charAt(right);
            if(Character.isLetter(c))
                sb.append(c);
            
            right--;
        

        int idx = 0;
        for(char c : s.toCharArray())
            if(!Character.isLetter(c))
                sb.insert(idx, c);
            
            idx++;
            
        
        return sb.toString();
    

1706. 球会落何处

2022.2.24 每日一题

题目描述

用一个大小为 m x n 的二维网格 grid 表示一个箱子。你有 n 颗球。箱子的顶部和底部都是开着的。

箱子中的每个单元格都有一个对角线挡板，跨过单元格的两个角，可以将球导向左侧或者右侧。

将球导向右侧的挡板跨过左上角和右下角，在网格中用 1 表示。
将球导向左侧的挡板跨过右上角和左下角，在网格中用 -1 表示。

在箱子每一列的顶端各放一颗球。每颗球都可能卡在箱子里或从底部掉出来。如果球恰好卡在两块挡板之间的 “V” 形图案，或者被一块挡导向到箱子的任意一侧边上，就会卡住。

返回一个大小为 n 的数组 answer ，其中 answer[i] 是球放在顶部的第 i 列后从底部掉出来的那一列对应的下标，如果球卡在盒子里，则返回 -1 。

示例 1：

输入：grid = [[1,1,1,-1,-1],[1,1,1,-1,-1],[-1,-1,-1,1,1],[1,1,1,1,-1],[-1,-1,-1,-1,-1]]
输出：[1,-1,-1,-1,-1]
解释：示例如图：
b0 球开始放在第 0 列上，最终从箱子底部第 1 列掉出。
b1 球开始放在第 1 列上，会卡在第 2、3 列和第 1 行之间的 “V” 形里。
b2 球开始放在第 2 列上，会卡在第 2、3 列和第 0 行之间的 “V” 形里。
b3 球开始放在第 3 列上，会卡在第 2、3 列和第 0 行之间的 “V” 形里。
b4 球开始放在第 4 列上，会卡在第 2、3 列和第 1 行之间的 “V” 形里。

示例 2：

输入：grid = [[-1]]
输出：[-1]
解释：球被卡在箱子左侧边上。

示例 3：

输入：grid = [[1,1,1,1,1,1],[-1,-1,-1,-1,-1,-1],[1,1,1,1,1,1],[-1,-1,-1,-1,-1,-1]]
输出：[0,1,2,3,4,-1]

提示：

m == grid.length
n == grid[i].length
1 <= m, n <= 100
grid[i][j] 为 1 或 -1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/where-will-the-ball-fall
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

找到下滑的规律，然后模拟这个过程就可以了

class Solution 
    int[] res;
    int m;
    int n;
    int[][] grid;
    public int[] findBall(int[][] grid) 
        //如果要往右滑，那么是当前和右侧的格子中都是1
        //如果要往左，那么当前和左侧格子中都是-1
        //如果停止，那么当前1，右侧就是-1；如果当前-1，左侧就是1
        //如果滑向右侧，那么下一个格子应该是看右下角；左滑是看左下角
        //如果到底部了，并且在还能继续往下滑，那么就输出当前列

        this.grid = grid;
        m = grid.length;
        n = grid[0].length;
        res = new int[n];
        for(int i = 0; i < n; i++)
            helper(i, 0, i);
        
        return res;
    

    public void helper(int col, int i, int j)
        int t = grid[i][j];
        if(t == 1)
            //如果在边上，或者卡在中间，那么卡住
            if(j == n - 1 || grid[i][j + 1] == -1)
                res[col] = -1;
                return;
            
            //如果已经是最后一行了，而且还能往下滑
            if(i == m - 1)
                res[col] = j + 1;
                return;
            
            helper(col, i + 1, j + 1);
        else
            //如果在边上，或者卡在中间，那么卡住
            if(j == 0 || grid[i][j - 1] == 1)
                res[col] = -1;
                return;
            
            //如果已经是最后一行了，而且还能往下滑
            if(i == m - 1)
                res[col] = j - 1;
                return;
            
            helper(col, i + 1, j - 1);
        
    

537. 复数乘法

2022.2.25 每日一题

题目描述

复数 可以用字符串表示，遵循 “实部+虚部i” 的形式，并满足下述条件：

实部 是一个整数，取值范围是 [-100, 100]
虚部 也是一个整数，取值范围是 [-100, 100]
i2 == -1

给你两个字符串表示的复数 num1 和 num2 ，请你遵循复数表示形式，返回表示它们乘积的字符串。

示例 1：

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

示例 2：

输入：num1 = “1±1i”, num2 = “1±1i”
输出：“0±2i”
解释：(1 - i) * (1 - i) = 1 + i2 - 2 * i = -2i ，你需要将它转换为 0±2i 的形式。

提示：

num1 和 num2 都是有效的复数表示。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/complex-number-multiplication
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路

把四个数取出来，然后相乘相加

class Solution 
    public String complexNumberMultiply(String num1, String num2) 
        //应该就是个简单的模拟
        String[] s1 = num1.split("\\\\+");
        boolean sym11 = s1[0].charAt(0) == '-' ? false : true; 
        int real11 = sym11 ? Integer.parseInt(s1[0]) : Integer.parseInt(s1[0].substring(1));

        s1[1] = s1[1].substring(0, s1[1].length() - 1);
        boolean sym12 = s1[1].charAt(0) == '-' ? false : true;
        int real12 = sym12 ? Integer.parseInt(s1[1]) : Integer.parseInt(s1[1].substring(1));

        String[] s2 = num2.split("\\\\+");
        boolean sym21 = s2[0].charAt(0) == '-' ? false : true; 
        int real21 = sym21 ? Integer.parseInt(s2[0]) : Integer.parseInt(s2[0].substring(1));
        
        s2[1] = s2[1].substring(0, s2[1].length() - 1);
        boolean sym22 = s2[1].charAt(0) == '-' ? false : true;
        int real22 = sym22 ? Integer.parseInt(s2[1]) : Integer.parseInt(s2[1].substring(1));

        real11 = sym11 ? real11 : -real11;
        real12 = sym12 ? real12 : -real12;
        real21 = sym21 ? real21 : -real21;
        real22 = sym22 ? real22 : -real22;

        int real = real11 * real21 - real12 * real22;
        int fake = real11 * real22 + real21 * real12;
        String res = real + "+" + fake + "i";
        return res;
    

用正则或(|)直接将两部分拆开，然后输出对应的形式

class Solution 
    public String complexNumberMultiply(String num1, String num2) 
        String[] complex1 = num1.split("\\\\+|i");
        String[] complex2 = num2.split("\\\\+|i");
        int real1 = Integer.parseInt(complex1[0]);
        int imag1 = Integer.parseInt(complex1[1]);
        int real2 = Integer.parseInt(complex2[0]);
        int imag2 = Integer.parseInt(complex2[1]);
        return String.format("%d+%di", real1 * real2 - imag1 * imag2, real1 * imag2 + imag1 * real2);
    



作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/complex-number-multiplication/solution/fu-shu-cheng-fa-by-leetcode-solution-163i/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。