力扣每日一题 1417. 重新格式化字符串

给你一个混合了数字和字母的字符串 s，其中的字母均为小写英文字母。

请你将该字符串重新格式化，使得任意两个相邻字符的类型都不同。也就是说，字母后面应该跟着数字，而数字后面应该跟着字母。

请你返回 重新格式化后 的字符串；如果无法按要求重新格式化，则返回一个 空字符串 。

 

示例 1：

输入：s = "a0b1c2"
输出："0a1b2c"
解释："0a1b2c" 中任意两个相邻字符的类型都不同。 "a0b1c2", "0a1b2c", "0c2a1b" 也是满足题目要求的答案。

示例 2：

输入：s = "leetcode"
输出：""
解释："leetcode" 中只有字母，所以无法满足重新格式化的条件。

示例 3：

输入：s = "1229857369"
输出：""
解释："1229857369" 中只有数字，所以无法满足重新格式化的条件。

示例 4：

输入：s = "covid2019"
输出："c2o0v1i9d"

示例 5：

输入：s = "ab123"
输出："1a2b3"

 

提示：

• 1 <= s.length <= 500
• s 仅由小写英文字母和/或数字组成。

Related Topics

字符串

👍 38

👎 0

个人思路和官方思路比较类似

1. 分别统计字符和数字的个数，
2. 两者个数差值绝对值不能大于1
3. 满足条件的时候，使用双指针，分别对其统计的得到字符链表和数字链表（思路不难，但自己写的时候，对齐这俩指针，老搞混，所以错了几次）。

代码

package editor.cn;

import java.util.ArrayList;
import java.util.List;

/**
 * @author ShaoYJ
 */
public class Q1417 {
    public static void main(String[] args) {
        Solution solution = new Q1417().new Solution();
//        String str = "covid2019";
        String str = "ab123";
        System.out.println(solution.reformat(str));
    }

    //leetcode submit region begin(Prohibit modification and deletion)
    class Solution {
        public String myReformat(String s) {
            List<Character> characterList = new ArrayList<>();
            List<Character> numberList = new ArrayList<>();
            int numLen = 0, charLen = 0;
            for (int i = 0; i < s.length(); i++) {
                if ((s.charAt(i) >= 'a' && s.charAt(i) <= 'z')) {
                    characterList.add(s.charAt(i));
                    charLen++;
                } else {
                    numberList.add(s.charAt(i));
                    numLen++;
                }
            }
            if (Math.abs(charLen - numLen) > 1) {
                return "";
            }
            StringBuffer sb = new StringBuffer();
            int i = 0, j = 0;
            boolean flag = true;

            if (charLen >= numLen) {
                while (j < charLen || i < numLen) {
                    if (flag) {
                        sb.append(characterList.get(j));
                        j++;
                        flag = false;
                    } else {
                        sb.append(numberList.get(i));
                        i++;
                        flag = true;
                    }
                }
            } else {
                while (i < numLen || j < charLen) {
                    if (flag) {
                        sb.append(numberList.get(i));
                        i++;
                        flag = false;
                    } else {
                        sb.append(characterList.get(j));
                        j++;
                        flag = true;
                    }
                }
            }

            return sb.toString();
        }

        public String reformat(String s) {
            int sumDigit = 0;
            for (int i = 0; i < s.length(); i++) {
                char c = s.charAt(i);
                if (Character.isDigit(c)) {
                    sumDigit++;
                }
            }
            int sumAlpha = s.length() - sumDigit;
            if (Math.abs(sumDigit - sumAlpha) > 1) {
                return "";
            }
            boolean flag = sumDigit > sumAlpha;
            char[] arr = s.toCharArray();
            for (int i = 0, j = 1; i < s.length(); i += 2) {
                if (Character.isDigit(arr[i]) != flag) {
                    while (Character.isDigit(arr[j]) != flag) {
                        j += 2;
                    }
                    swap(arr, i, j);
                }
            }
            return new String(arr);
        }

        public void swap(char[] arr, int i, int j) {
            char c = arr[i];
            arr[i] = arr[j];
            arr[j] = c;
        }

    }
//leetcode submit region end(Prohibit modification and deletion)

}

运行结果（还可调优，整体思路和官方相同，就没去深究优化）