字节跳动2019春招研发编程题（一）

题目1 聪明的编辑

2.半错误解法

使用栈

import java.util.*;
public class Main{
    public static void slove(String str){
        /**
        整体的思路是：如果数组中的字符开始重复，那么就用栈来保存
        同时记录重复的次数，如果存在像woooow这样的字符，判断该字符是否和栈顶元素相同，
        相同就不加入，如果count>=2并且下一字符与当前字符不重复，就可以清空栈，重新开始
        该种解法，对于单个简单字符没有问题，
        但是对图片中展示方法没有处理能力。
        */
        char[] ch = str.toCharArray();
        int count = 0;
        StringBuilder sb = new StringBuilder();
        Stack<Character> queue = new Stack<>();
        sb.append(ch[0]);

        // 别出小错误
        for(int s1 = 1; s1 < ch.length; s1++){
           if(ch[s1] != ch[s1-1] && count == 0){
               sb.append(ch[s1]);
           }else{
               if(ch[s1] == ch[s1-1]){
                   ++count;
               }

               if(queue.isEmpty()){
                   queue.push(ch[s1]);

               }else if(queue.peek() != ch[s1]){
                   // 使用栈，要不队列的peek(),是队列的头部
                   queue.push(ch[s1]);
               }

               if(count >= 2 && s1 < ch.length-1 && ch[s1] != ch[s1 + 1]){
                   for(Object c : queue.toArray()){
                       sb.append(c);
                   }
                   count = 0;
                   queue.clear();
               }

               if(count >= 2 && s1 == ch.length-1){
                   for(Object c : queue.toArray()){
                       sb.append(c);
                   }
               }
           }
        }   
        System.out.println(sb.toString());
    }
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String[] strings = new String[n];
        for(int i =0; i < n; i++){
            strings[i] = sc.next();
        }
        for(String s : strings){
            slove(s);
        }
    }
}

3.正确解法（自动机）

import java.util.*;
public class Main{
    public static void slove(String str){
        int state = 0; // 初始化状态0
        char[] ch = str.toCharArray();
        char cur; // 当前字符
        // (@如果接下来要处理整一段字符，先在这里保存一个last，这个我想到了）
        char last = ch[0]; // 初始化为第一个字符

        StringBuilder sb = new StringBuilder();
        sb.append(ch[0]);

        /**
         * 中间的状态不需要保存，只需保存上一步处理过的last
         * 总共分3种情况：
         *   1、AA      、AB
         *   2、AAA、AAB
         *   3、AAAA、AABC
         */
        /**
         * 栈维持了一个中间状态，记录了很多中间值，只能边走边判断，除非移除
         * 无法像这种解法一样，根据不同的情况，进入不同的状态
         */

        for(int s1 = 1; s1 < ch.length; s1++) {
            cur = ch[s1];

            switch (state) {
                case 0: {
                    if (cur == last) { // 如果是相等的，则进入状态1 AA模式
                        state = 1;
                    } else {
                        state = 0; // 继续状态0， AB模式
                    }
                    break;
                }
                case 1: {
                    // 上一步存储了AA或者AB
                    // 只和last比，比较已有的情况
                    if (cur == last) {
                        continue;  //AAA, 忽略
                    } else {
                        state = 2; // 进入状态3：AAB模式
                    }
                    break;
                }
                case 2: {
                    if (cur == last) {
                        continue; // AABB忽略
                    } else {
                        state = 0; // AABC, 就是状态0
                    }
                    break;
                }
                default:
                    break;
            }

            sb.append(cur);
            last = cur;
        }

        System.out.println(sb.toString());
    }
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String[] strings = new String[n];
        for(int i =0; i < n; i++){
            strings[i] = sc.next();
        }
        for(String s : strings){
            slove(s);
        }
 
    }
}