Leetcode每日一题 —— 2553. 分割数组中数字的数位

2553. 分割数组中数字的数位 - 力扣（LeetCode）

2553. 分割数组中数字的数位 - 给你一个正整数数组 nums ，请你返回一个数组 answer ，你需要将 nums 中每个整数进行数位分割后，按照 nums 中出现的 相同顺序 放入答案数组中。 对一个整数进行数位分割，指的是将整数各个数位按原本出现的顺序排列成数组。 * 比方说，整数 10921 ，分割它的各个数位得到 [1,0,9,2,1] 。   示例 1： 输入：nums = [13,25,83,77] 输出：[1,3,2,5,8,3,7,7] 解释： - 分割 13...

思路
倒序拆分后反转即可。

代码

class Solution {
    public int[] separateDigits(int[] nums) {
        // 倒序将 nums 中的数字拆分成单个数字
        List<Integer> list = new ArrayList<>();
        for (int i = nums.length - 1; i>=0; i--) {
            while (nums[i] > 0) {
                list.add(nums[i] % 10);
                nums[i] /= 10;
            }
        }
        // 反转 list 并写入结果数组
        int len = list.size();
        int[] ans = new int[len];
        for (int i = 0; i < len; i++) {
            ans[i] = list.get(len - i - 1);
        }
        return ans;
    }
}

PS
最近沉迷于写一个小游戏的脚本，怠惰了
补一下近两天的简单题目，，再往前的有点复杂，晚些再补。

0510-2770

    public int maximumJumps(int[] nums, int target) {
        int n = nums.length;
        // 跳到第 i 位置的最大次数
        int[] dp = new int[n];
        // 初始化 dp[0] 便于边界计算
        dp[0] = 1;
        for (int i = 0; i < n - 1; i++) {
            // 如果到达不了直接跳过
            if (dp[i] == 0) {
                continue;
            }
            // 遍历所有可能到达的下标 尝试更新
            for (int j = i + 1; j < n; j++) {
                if (Math.abs(nums[i] - nums[j]) <= target) {
                    dp[j] = Math.max(dp[j], dp[i] + 1);
                }
            }
        }
        return dp[n - 1] == 0 ? -1 : dp[n - 1] - 1;
    }

0509-1914

    private int m, n;
    public int[][] rotateGrid(int[][] grid, int k) {
        m = grid.length;
        n = grid[0].length;
        int[][] ans = new int[m][n];
        // 层
        int f = Math.min(m / 2, n / 2);
        for (int i = 0; i < f; i++) {
            // 周长
            int s = (m + n - 4 * i) * 2 - 4;
            // 旋转次数
            int c = k % s;
            // 遍历一周
            for (int t = 0; t < s; t++) {
//                System.out.println(i + "-" + t + " nx:" + calcRow(t, i, s) + " ny:" + calcCol(t, i, s));
                ans[calcRow(t, i, s)][calcCol(t, i, s)] = grid[calcRow((t + c) % s, i, s)][calcCol((t + c) % s, i, s)];
            }
        }
        return ans;
    }

    // 计算行
    private int calcRow(int t, int f, int s) {
        // 在顶部
        int tmp = n - 2 * f;
        if (tmp > t) {
            return f;
        }
        // 在右侧
        if (s / 2 >= t) {
            return t - tmp + f + 1;
        }
        // 在底部
        tmp = s / 2 + tmp;
        if (tmp > t) {
            return m - 1 - f;
        }
        // 在左侧
        return s - t + f;
    }

    // 计算列
    private int calcCol(int t, int f, int s) {
        // 在顶部
        int tmp = n - 2 * f;
        if (tmp > t) {
            return t + f;
        }
        // 在右侧
        if (s / 2 >= t) {
            return n - 1 - f;
        }
        // 在底部
        tmp = s / 2 + tmp;
        if (tmp > t) {
            return tmp - t + f - 1;
        }
        // 在左侧
        return f;
    }

2 个帖子 - 2 位参与者

阅读完整话题