标签：index String int 解码 ret 394 字符串 ptr charAt

给定一个经过编码的字符串，返回它解码后的字符串。

编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。

你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。

此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。

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

栈

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;

class Solution {

    private int index;

    private String data;

    public String decodeString(String s) {
        if (s == null || s.length() == 0) {
            return s;
        }

        this.data = s;
        this.index = 0;

        Stack<List<Character>> stack = new Stack<>();
        Stack<Integer> numStack = new Stack<>();
        stack.push(new ArrayList<>());
        while (this.index < s.length()) {
            if (Character.isLetter(s.charAt(this.index))) {
                stack.peek().addAll(parseCharacter());
            } else if (Character.isDigit(s.charAt(this.index))) {
                int num = parseNum();
                numStack.push(num);
            } else if (this.data.charAt(this.index) == '[') {
                stack.push(new ArrayList<>());
                this.index++;
            } else if (this.data.charAt(this.index) == ']') {
                List<Character> characters = stack.pop();
                int num = numStack.isEmpty() ? 1 : numStack.pop();
                merge(stack.peek(), multiply(characters, num));
                this.index++;
            }
        }


        while (stack.size() >= 2) {
            List<Character> characters = stack.pop();
            merge(stack.peek(), characters);
        }

        List<Character> characters = stack.pop();

        StringBuilder sb = new StringBuilder();

        for (Character c : characters) {
            sb.append(c);
        }

        return sb.toString();
    }

    private void merge(List<Character> characterList1, List<Character> characterList2) {
        characterList1.addAll(characterList2);
    }

    private List<Character> multiply(List<Character> characters, int num) {
        List<Character> ret = new ArrayList<>();
        for (int i = 0; i < num; ++i) {
            ret.addAll(characters);
        }
        return ret;
    }

    private List<Character> parseCharacter() {
        List<Character> ret = new ArrayList<>();
        while (this.index < this.data.length() && Character.isLetter(this.data.charAt(this.index))) {
            ret.add(this.data.charAt(this.index++));
        }
        return ret;
    }

    private int parseNum() {
        int num = 0;
        while (this.index < this.data.length() && Character.isDigit(this.data.charAt(this.index))) {
            num = num * 10 + this.data.charAt(this.index++) - '0';
        }
        return num;
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            System.out.println(new Solution().decodeString(in.next()));
        }
    }
}

递归

class Solution {
    String src;
    int ptr;

    public String decodeString(String s) {
        src = s;
        ptr = 0;
        return getString();
    }

    public String getString() {
        if (ptr == src.length() || src.charAt(ptr) == ']') {
            // String -> EPS
            return "";
        }

        int repTime = 1;
        String ret = "";

        if (Character.isDigit(src.charAt(ptr))) {
            // String -> Digits [ String ] String
            // 解析 Digits
            repTime = getDigits();
            // 过滤左括号
            ++ptr;
            // 解析 String
            String str = getString();
            // 过滤右括号
            ++ptr;
            // 构造字符串
            while (repTime-- > 0) {
                ret += str;
            }
        } else if (Character.isLetter(src.charAt(ptr))) {
            // String -> Char String
            // 解析 Char
            ret = String.valueOf(src.charAt(ptr++));
        }

        return ret + getString();
    }

    public int getDigits() {
        int ret = 0;
        while (ptr < src.length() && Character.isDigit(src.charAt(ptr))) {
            ret = ret * 10 + src.charAt(ptr++) - '0';
        }
        return ret;
    }
}

标签：index,String,int,解码,ret,394,字符串,ptr,charAt
来源： https://www.cnblogs.com/tianyiya/p/15697317.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。