letcode算法

算法1：

package test;

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

class MergeCmds {
    int[] all = new int[4096];

    String mergeCmds(List<String> cmds) {
        for (int i = 0; i < cmds.size(); i++) {
            String str = cmds.get(i);
            if (str.contains("undo port truck allow-pass vlan ")) {
                String newStr = str.replace("undo port truck allow-pass vlan ", "");
                String[] arr = newStr.split(" ");
                reduce(arr);
            } else {
                String newStr = str.replace("port truck allow-pass vlan ", "");
                String[] arr = newStr.split(" ");
                add(arr);
            }
        }
        return getResult(all);
    }

    String getResult(int[] all) {
        StringBuffer sb = new StringBuffer();
        int left = -1;
        int rigt = -1;
        for (int i = 0; i < all.length; i++) {
            if (all[i] == 0) {
                continue;
            }
            if (i == all.length - 1) {
                sb.append(i);
                break;
            }
            for (int j = i + 1; j < all.length; j++) {
                if (all[j] > 0 && j - i == all[j] - all[i]) {
                    left = i;
                    rigt = j;
                    if (j == all.length - 1) {// 到头
                        if (sb.isEmpty()) {
                            sb.append(left).append(" to ").append(rigt);
                        } else {
                            sb.append(" ").append(left).append(" to ").append(rigt);
                        }
                        i = j;
                        break;
                    }
                } else if (all[j] == 0) {
                    if (left > 0 && rigt > 0) {
                        if (sb.isEmpty()) {
                            sb.append(left).append(" to ").append(rigt);
                        } else {
                            sb.append(" ").append(left).append(" to ").append(rigt);
                        }
                        left = -1;
                        rigt = -1;
                        i = j;
                        break;
                    } else {
                        if (!sb.isEmpty()) {
                            sb.append(" ").append(i);
                        } else {
                            sb.append(i);
                        }
                        i = j;
                        break;
                    }
                }
            }
        }
        return sb.toString();
    }

    private void reduce(String[] arr) {
        boolean isTo = false;
        int leftData = -1;
        for (String word : arr) {
            if (isWord(word)) {
                isTo = true;
                continue;
            }
            if (isTo) {
                int rightData = Integer.parseInt(word);
                removeData(leftData, rightData);
                isTo = false;
                leftData = -1;
                continue;
            }
            int data = Integer.parseInt(word);
            all[data] = 0;
            leftData = data;
        }
    }

    private void add(String[] arr) {
        boolean isTo = false;
        int leftData = -1;
        for (String word : arr) {
            if (isWord(word)) {
                isTo = true;
                continue;
            }
            if (isTo) {
                int rightData = Integer.parseInt(word);
                setData(leftData, rightData);
                isTo = false;
                leftData = -1;
                continue;
            }
            int data = Integer.parseInt(word);
            all[data] = data;
            leftData = data;
        }
    }

    private void removeData(int leftData, int rightData) {
        for (int i = leftData + 1; i <= rightData; i++) {
            all[i] = 0;
        }
    }

    private void setData(int leftData, int rightData) {
        for (int i = leftData + 1; i <= rightData; i++) {
            all[i] = i;
        }
    }

    private boolean isWord(String str) {
        for (int i = 0; i < str.length(); i++) {
            if (Character.isLetter(str.charAt(i))) {
                return true;
            } else {
                return false;
            }
        }
        return false;
    }

    public static void main(String[] args) {
//        String temp1 = "port truck allow-pass vlan 10 20 to 30";
//        String temp2 = "port truck allow-pass vlan 15 to 25 9";
//        String temp3 = "undo port truck allow-pass vlan 10 to 20 23";
//        List<String> cmds = new ArrayList<>();
//        cmds.add(temp1);
//        cmds.add(temp2);
//        cmds.add(temp3);
//        MergeCmds mergeCmds = new MergeCmds();
//        System.out.println(mergeCmds.mergeCmds(cmds));

        String temp = "undo port truck allow-pass vlan 10 to 20";
        String temp2 = "port truck allow-pass vlan 17 to 20 24 to 4094";
        String temp3 = "port truck allow-pass vlan 21 to 24";
        String temp4 = "port truck allow-pass vlan 1 to 15 4095 16";
        List<String> cmds = new ArrayList<>();
        cmds.add(temp);
        cmds.add(temp2);
        cmds.add(temp3);
        cmds.add(temp4);
        MergeCmds mergeCmds = new MergeCmds();
        System.out.println(mergeCmds.mergeCmds(cmds));
//        int [] aa = {0,1};
//        System.out.println(mergeCmds.getResult(aa));
    }
}

算法2：

package test;

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

class MemoryWithWriteBuffer {
//    String data = "1DA0820000000000000901ABCDEF00";
    String data = "";
    List<MemOp> cache = new LinkedList<>();
    String[] arr = new String[data.length() / 2];

    String memoryWithWriteBuffer(int bufferCap, List<MemOp> operations) {
        int j=0;
        for (int i = 0; i < data.length();) {
            arr[j] = data.substring(i, i+2);
            i= i+2;
            j++;
        }
//        System.out.println(Arrays.toString(arr) );
        for (int i = 0; i < operations.size(); i++) {
            MemOp memOp = operations.get(i);
            int op = memOp.op;
            switch (op) {
                case 1:
                    addCache(memOp, bufferCap);
                    break;
                case 2:
                    readMemory(memOp);
                    break;
                case 3:
                    addMemory();
                    break;
                default:
                    break;
            }

        }
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < arr.length; i++) {
            sb.append(arr[i]);
        }
        return sb.toString();
    }

    private void addCache(MemOp memOp, int bufferCap) {
        if (cache.size() >= bufferCap) {
            cache.removeLast();
        }
        cache.add(memOp);
    }

    private void readMemory(MemOp memOp) {
        int left = memOp.para1; // TODO 这里copy数据出问题，炒成 para2
        int right = memOp.para1 + memOp.para2 - 1;
        MemOp findMemOp = findMemOp(left, right);
        if (cache.contains(findMemOp)) {
            while (cache.contains(findMemOp)) {
                changeData();
            }
        } else { // 这里是否要补充?

        }
    }

    private MemOp findMemOp(int left, int right) {
        for (int i = 0; i < cache.size(); i++) {
            MemOp temp = cache.get(i);
            int l = temp.para1;
            int r = temp.para1 + temp.para2 - 1;
            if (left >= l && right <= r) {
                return temp;
            }
        }
        return null;
    }

    private void addMemory() {
        // 先进的先出
        while (cache.size() > 0) {
            changeData();
        }
    }

    private void changeData() {
        MemOp memOp = cache.removeLast();
        int data = memOp.para3;
        String hex = Integer.toHexString(data);
        int i = memOp.para1;
        int j = memOp.para1 + memOp.para2 - 1;
        for (; i <= j; i++) {
            arr[i] = hex;
        }
    }


    public static void main(String[] args) {
//        int bufferCap = 4;
//        List<MemOp> operations = new ArrayList<>();
//        MemOp memOp1 = new MemOp(1, 1, 3, 255);
//        MemOp memOp2 = new MemOp(3, 0, 0, 0);
//        MemOp memOp3 = new MemOp(1, 2, 11, 120);
//        MemOp memOp4 = new MemOp(2, 11, 1, 0);
//        operations.add(memOp1);
//        operations.add(memOp2);
//        operations.add(memOp3);
//        operations.add(memOp4);
//        MemoryWithWriteBuffer memoryWithWriteBuffer = new MemoryWithWriteBuffer();
//        String temp = "1DFF787878787878787878788EF00";
//        memoryWithWriteBuffer.data = "1DA0820000000000000901ABCDEF00";
//        System.out.println(memoryWithWriteBuffer.memoryWithWriteBuffer(bufferCap, operations));

//        int aaa = 255;
//        int bbb = 120;
//        System.out.println(Integer.toHexString(bbb));
//
        int bufferCap = 5;
        List<MemOp> operations = new ArrayList<>();
        MemOp memOp1 = new MemOp(1,35,2,100);
        MemOp memOp2 = new MemOp(1,0,40,255);
        MemOp memOp3 = new MemOp(1,11,10,81);
        MemOp memOp4 = new MemOp(1,16,12,173);
        MemOp memOp5 = new MemOp(2,16,3,0);
        MemOp memOp6 = new MemOp(2,0,3,0);
        operations.add(memOp1);
        operations.add(memOp2);
        operations.add(memOp3);
        operations.add(memOp4);
        operations.add(memOp5);
        operations.add(memOp6);
        MemoryWithWriteBuffer memoryWithWriteBuffer = new MemoryWithWriteBuffer();
        System.out.println(memoryWithWriteBuffer.memoryWithWriteBuffer(bufferCap, operations));


    }
}

class MemOp {
    int op;
    int para1;
    int para2;
    int para3;

    public MemOp() {
    }

    public MemOp(int op, int para1, int para2, int para3) {
        this.op = op;
        this.para1 = para1;
        this.para2 = para2;
        this.para3 = para3;
    }
}

算法3：

package test;

import java.util.Arrays;

class MatchLogTrait {
    int[] matchLogTrait(int[] events, int[] traits) {
        int left = 0;
        int right = 0;
        int minLen = Integer.MAX_VALUE;
        for (int i = left; i < events.length; i++) {
            for (int j = i + traits.length-1; j < events.length; j++) {
                boolean equal = equal(i, j, events, traits);
                if (equal) {
                    if (minLen > j - i + 1) {
                        left = i;
                        right = j;
                        minLen = j - i + 1;
                    }
                }
            }
        }
        int[] result = new int[minLen];
        int j = 0;
        for (int i = left; i <= right; i++) {
            result[j] = events[i];
            j++;
        }
        return result;
    }

    private boolean equal(int left, int right, int[] events, int[] traits) {
        int[] visit = new int[traits.length];
        StringBuffer sb = new StringBuffer();
        StringBuffer sbb = new StringBuffer();
        for (int i : traits) {
            sbb.append(i);
        }
        for (int i = left; i <= right; i++) {
            int data = events[i];
            for (int j = 0; j < traits.length; j++) {
                if (data == traits[j] && visit[j] == 0) {
                    visit[j] = 1;
                    sb.append(data);
                    break;
                }
            }
        }
        if (sb.toString().equals(sbb.toString())) {
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
//        int[] events = {4, 8, 4, 3, 6, 6, 8};
//        int[] traits = {4, 6, 8};
//        MatchLogTrait matchLogTrait = new MatchLogTrait();
//        System.out.println(Arrays.toString(matchLogTrait.matchLogTrait(events, traits)));

        int[] events = {2, 30, 4, 4, 6, 2, 2, 3, 4, 6, 6, 2, 4, 4, 6};
        int[] traits = {2, 4, 6};
        MatchLogTrait matchLogTrait = new MatchLogTrait();
        System.out.println(Arrays.toString(matchLogTrait.matchLogTrait(events, traits)));
    }
}

算法4：

package test;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

class GetBatchCmds {

    List<Cmd> getBatchCmds(List<Config> config, List<Cmd> batchReqs) {
        List<Config> configOld = new ArrayList<>(config);
        List<Config> configNew = new ArrayList<>(config);
        for (int i = 0; i < batchReqs.size(); i++) {
            Cmd cmd = batchReqs.get(i);
            char opType = cmd.opType;
            int cmdId1 = cmd.id1;
            int cmdId2 = cmd.id2;
            if (opType == 'a') {
                if (macthPos(configNew, cmd)) {
                    continue;
                }
                Config newConfig = new Config(cmdId1, cmdId2);
                configNew.add(newConfig);

            } else {
                Config con = findConfig(configNew, cmd);
                if (con != null) {
                    configNew.remove(con);
                }
            }
        }
        List<Cmd> result = new ArrayList<>();
        for (int i = 0; i < configNew.size(); i++) {
            Config configOne = configNew.get(i);
            Cmd cmd = new Cmd('a', configOne.id1, configOne.id2);
            result.add(cmd);
        }
        for (int i = 0; i < configOld.size(); i++) {
            Config configOne = configOld.get(i);
            boolean isFind = false;
            for (int j = 0; j < result.size(); j++) {
                Cmd cmd = result.get(j);
                if (configOne.id1 == cmd.id1 && configOne.id2 == cmd.id2) {
                    result.remove(cmd);
                    isFind = true;
                    continue;
                }
            }
            if (!isFind) {
                Cmd cmd = new Cmd('d', configOne.id1, configOne.id2);
                result.add(cmd);
            }
        }

        // 排序
        List<Cmd> sort = result.stream().sorted((o1, o2) -> {
            int gap = o2.opType - o1.opType;
            if (gap != 0) {
                return gap;
            } else {
                return Integer.compare(o1.id1, o2.id1);
            }
        }).collect(Collectors.toList());
        return sort;
    }

    private Config findConfig(List<Config> configNew, Cmd cmd) {
        for (int i = 0; i < configNew.size(); i++) {
            Config config = configNew.get(i);
            if (config.id1 == cmd.id1 && config.id2 == cmd.id2) {
                return config; // 存在
            }
        }
        return null;
    }

    private boolean macthPos(List<Config> configNew, Cmd cmd) {
        for (int i = 0; i < configNew.size(); i++) {
            Config config = configNew.get(i);
            if (config.id1 == cmd.id1 || config.id2 == cmd.id2 ||
                    config.id2 == cmd.id1 || config.id1 == cmd.id2) {
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        List<Config> config = new ArrayList<>();
        Config config1 = new Config(2, 3);
        Config config2 = new Config(4, 5);
        config.add(config1);
        config.add(config2);
        List<Cmd> batchReqs = new ArrayList<>();
        Cmd cmd1 = new Cmd('a', 0, 1);
        Cmd cmd2 = new Cmd('a', 5, 6);
        Cmd cmd3 = new Cmd('d', 0, 1);
        Cmd cmd4 = new Cmd('d', 1, 2);
        Cmd cmd5 = new Cmd('a', 0, 6);
        Cmd cmd6 = new Cmd('d', 4, 5);
        Cmd cmd7 = new Cmd('a', 1, 4);
        batchReqs.add(cmd1);
        batchReqs.add(cmd2);
        batchReqs.add(cmd3);
        batchReqs.add(cmd4);
        batchReqs.add(cmd5);
        batchReqs.add(cmd6);
        batchReqs.add(cmd7);
        GetBatchCmds getBatchCmds = new GetBatchCmds();
        List<Cmd> result = getBatchCmds.getBatchCmds(config, batchReqs);
        for (int i = 0; i < result.size(); i++) {
            Cmd one = result.get(i);
            System.out.println(one.opType + "--" + one.id1 + "-" + one.id2);
        }


        List<Config> configList = new ArrayList<>();
        List<Cmd> batchReqss = new ArrayList<>();
        Cmd cmd8 = new Cmd('a', 10, 20);
        Cmd cmd9 = new Cmd('a', 50, 60);
        Cmd cmd10 = new Cmd('d', 50, 60);
        Cmd cmd11 = new Cmd('d', 10, 20);
        batchReqss.add(cmd8);
        batchReqss.add(cmd9);
        batchReqss.add(cmd10);
        batchReqss.add(cmd11);
        GetBatchCmds getBatchCmdss = new GetBatchCmds();
        List<Cmd> result2 = getBatchCmdss.getBatchCmds(configList, batchReqss);
        for (int i = 0; i < result2.size(); i++) {
            Cmd one = result2.get(i);
            System.out.println(one.opType + "--" + one.id1 + "-" + one.id2);
        }
    }
}

class Cmd {
    char opType;
    int id1;
    int id2;

    public Cmd() {

    }

    public Cmd(char opType, int id1, int id2) {
        this.opType = opType;
        this.id1 = id1;
        this.id2 = id2;
    }


}

class Config {
    int id1;
    int id2;

    public Config() {

    }

    public Config(int id1, int id2) {
        this.id1 = id1;
        this.id2 = id2;
    }
}

算法5：

package test;

import java.util.*;

public class FileSystem {
    private String pathName = "/"; // 唯一
    private String oldPathName = "/";
    private List<String> dirNames = new LinkedList<>();
    private List<String> fileNames = new LinkedList<>();
    private Map<String, FileSystem> map;

    FileSystem() {
        map = new LinkedHashMap<>();
        FileSystem fileSystem = new FileSystem(dirNames, fileNames);
        map.put(pathName, fileSystem);
    }

    FileSystem(List<String> dirNames, List<String> fileName) {
        this.dirNames = dirNames;
        this.fileNames = fileName;
    }

    boolean makeDir(String dirName) {
        FileSystem fileSystem = map.get(this.pathName);
        List<String> dirNames = fileSystem.dirNames;
        if (dirNames.contains(dirName)) {
            return false;
        }
        List<String> filedNames = fileSystem.fileNames;
        if (filedNames.contains(dirName)) {
            return false;
        }
        dirNames.add(dirName);
        return true;
    }

    boolean createFile(String fileName) {
        FileSystem fileSystem = map.get(this.pathName);
        List<String> filedNames = fileSystem.fileNames;
        if (filedNames.contains(fileName)) {
            return false;
        }
        List<String> dirNames = fileSystem.dirNames;
        if (dirNames.contains(fileName)) {
            return false;
        }
        filedNames.add(fileName);
        return true;
    }

    boolean changeDir(String pathName) {
        if (pathName.equals("'") || pathName.equals("/")) { // TODO 用例2发现
            return true;
        }
        FileSystem fileSystem = map.get(this.pathName);
        List<String> dirNames = fileSystem.dirNames;
        String newPathName = pathName;
        if (newPathName.contains("/")) {
            if (newPathName.endsWith("/")) {
                newPathName = newPathName.substring(0, newPathName.length() - 1);
            }
            if (newPathName.startsWith("/")) { // TODO 用例2的补充
                newPathName = newPathName.substring(1, newPathName.length());
            }
        } else {
            return false;// TOOD 用例2的补充
        }
        if (this.pathName.equals(newPathName)) { // TODO  debug发现的，用例2
            return true;
        }
        if (dirNames.contains(newPathName)) {
            this.oldPathName = this.pathName;
            this.pathName = newPathName;
            List<String> dirNameNew = new LinkedList<>();
             List<String> fileNameNew = new LinkedList<>();
            map.put(this.pathName, new FileSystem(dirNameNew, fileNameNew));
            return true;
        }
        return false;
    }

    boolean remove(String name) {
        if (this.pathName.equals(name)) { // TODO 用例2发现的
            map.remove(name);
            this.pathName = this.oldPathName;
        }
        FileSystem fileSystem = map.get(this.pathName);
        List<String> dirNames = fileSystem.dirNames;
        List<String> fileNames = fileSystem.fileNames;
        boolean isFind = false;
        for (String dirName : dirNames) {
            if (dirName.equals(name)) {
                isFind = true;
                dirNames.remove(dirName);
            }
        }
        for (String fileName : fileNames) {
            if (fileName.equals(name)) {
                isFind = true;
                fileNames.remove(fileName);
            }
        }
        return isFind;

    }

    List<String> listDir() {
        FileSystem fileSystem = map.get(this.pathName);
        List<String> dirNames = fileSystem.dirNames;
        List<String> dirNamesSort = dirNames.stream().sorted().toList();
        List<String> fileNames = fileSystem.fileNames;
        List<String> fileNameSort = fileNames.stream().sorted().toList();
        List<String> result = new LinkedList<>();
        result.addAll(dirNamesSort);
        result.addAll(fileNameSort);
        return result;
    }

    public static void main(String[] args) {
//        FileSystem fileSystem = new FileSystem();
//        System.out.println(fileSystem.makeDir("dirc"));
//        System.out.println(fileSystem.makeDir("dirb"));
//        System.out.println(fileSystem.makeDir("dirc"));
//        List<String> aa = fileSystem.listDir();
//        String[] arr = aa.toArray(new String[aa.size()]);
//        System.out.println(Arrays.toString(arr));
//        System.out.println(fileSystem.changeDir("dirc/"));
//        System.out.println(fileSystem.createFile("fileb"));
//        System.out.println(fileSystem.makeDir("dirb"));
//        System.out.println(fileSystem.createFile("dirb"));
//        List<String> bb = fileSystem.listDir();
//        String[] arrb = bb.toArray(new String[bb.size()]);
//        System.out.println(Arrays.toString(arrb));
//        System.out.println(fileSystem.changeDir("/dirb/dirc"));


        FileSystem fileSystem = new FileSystem();
        List<String> bb = fileSystem.listDir();
        String[] arrb = bb.toArray(new String[bb.size()]);
        System.out.println(Arrays.toString(arrb));
        System.out.println(fileSystem.changeDir("'"));
        System.out.println(fileSystem.createFile("gateway"));
        System.out.println(fileSystem.makeDir("home"));
        System.out.println(fileSystem.changeDir("gateway"));
        System.out.println(fileSystem.makeDir("etc"));
        List<String> aa = fileSystem.listDir();
        String[] arr = aa.toArray(new String[aa.size()]);
        System.out.println(Arrays.toString(arr));
        System.out.println(fileSystem.remove("gateway"));
        System.out.println(fileSystem.changeDir("etc/"));
        System.out.println(fileSystem.createFile("pip"));
        System.out.println(fileSystem.changeDir("/etc/"));
        List<String> bbb = fileSystem.listDir();
        String[] arrbb = bbb.toArray(new String[bbb.size()]);
        System.out.println(Arrays.toString(arrbb));
        System.out.println(fileSystem.changeDir("/")); // TODO 用例2发现的
        System.out.println(fileSystem.remove("etc"));
        List<String> bbbb = fileSystem.listDir();
        String[] arrbbb = bbbb.toArray(new String[bbbb.size()]);
        System.out.println(Arrays.toString(arrbbb));

    }
}

算法6：

package test;

public class BinaryEditor {
    private int col = 0;
    StringBuffer sb;

    String binaryEditor(String inputStr, String cmds) {
        col = inputStr.length();
        sb = new StringBuffer(inputStr);
        char[] arrChar = cmds.toCharArray();
        for (char cmd : arrChar) {
            switch (cmd) {
                case '0':
                    insertZero();
                    break;
                case '1':
                    insertOne();
                    break;
                case 'B':
                    delLeft();
                    break;
                case 'L':
                    removeLeft();
                    break;
                case 'R':
                    removeRight();
                    break;
            }

        }
        return sb.toString();
    }

    /**
     * 1 001101-》1101
     * 010 -》0
     */
    /**
     * 1、10M + 0 = 100
     * 2、0M  + 0 = 0
     * 3、M10 + 0 = 10
     *
     * @param
     */
    private void delLeft() { // 1101
        if (col >= 1) {// 1001101
            StringBuffer sbb = new StringBuffer();
            sbb.append(sb.subSequence(0, col - 1)).append(sb.subSequence(col, sb.length()));
            if (sbb.length() == 0) { // TODO debug时发现
                sb.setLength(0);
                col = 0;
                return;
            }
            int data = Integer.parseInt(sbb.toString());
            if (data == 0) {//10
                sb.setLength(0);
                sb.append(0);
                col = 0;
                return;
            }
            sb.deleteCharAt(col-1);
            col--;
        }
    }

    private void removeLeft() {//10
        if (col == 0) {
            return;
        }
        col--;
    }

    /**
     * 1、10M + 0 = 100
     * 2、0M  + 0 = 0
     * 3、M10 + 0 = 10
     *
     */
    private void removeRight() {
        if (sb.length() == col) {
            return;
        }
        col++;
    }

    /**
     * 1、10M + 0 = 100
     * 2、0M  + 0 = 0
     * 3、M10 + 0 = 10
     *
     * @param
     */
    private void insertZero() {
        if (col >= 1) {
            // 100
            // 0
            int data = Integer.parseInt(sb.subSequence(0, col).toString());
            if (data >= 1) {
                sb.append(0);
                col++;
            }
        }
    }

    /**
     * 1、10M + 1 = 101
     * 2、0M  + 1 = 1
     * 3、M10 + 1 = 110
     *
     * @param
     */
    private void insertOne() {
        if (col >= 1) { // 101
            int data = Integer.parseInt(sb.subSequence(0, col).toString());
            if (data >= 1) {
                sb.append(1);
                col++;
            } else {// 01
                sb.setCharAt(col - 1, '1');
            }
        } else {// 110
            if (sb.length() > 0) {
//                StringBuffer sbb = new StringBuffer();
//                sbb.append(1).append(sb);
//                sb = sbb; // 0
                sb.insert(0, 1);
                col++;
            }//10

        }
    }

    private StringBuffer insert(StringBuffer sb) {
        StringBuffer sbb = new StringBuffer();
        sbb.append(1).append(sb);
        sb = sbb;
        System.out.println("sbb: " + sbb.toString());
        System.out.println("sb: " + sb.toString());
        return sb;
    }
    public static void main(String[] args) {
        String inputStr = "abcdefg";
        StringBuffer sb = new StringBuffer(inputStr);
//        sb.insert(0, '#'); // #abcdefg
//        sb.delete(1,5); // afg [1,5)
//        sb.replace(1, 5, "888");
//        sb.deleteCharAt(1);
        sb.setLength(2);
        sb.append('3');
        System.out.println(sb.toString());

//
        String inputStr2 = "10";
        String cmds = "0LLB0R1";
        BinaryEditor binaryEditor = new BinaryEditor();
        System.out.println(binaryEditor.binaryEditor(inputStr2, cmds));


//        String inputStr2 = "10";
//        String cmds = "0LLBB1RRRBB";
//        BinaryEditor binaryEditor = new BinaryEditor();
//        System.out.println(binaryEditor.binaryEditor(inputStr2, cmds));
    }
}

算法7：

package test;

import java.util.*;

class ArpSys {
    int arpCap;
    int cachedPktCap;
    int preIpCap;

    ArpSys(int arpCap, int cachedPktCap, int preIpCap) {
        this.arpCap = arpCap;
        this.cachedPktCap = cachedPktCap;
        this.preIpCap = preIpCap;

    }

    class Mac {
        String macAddr;
        List<Integer> ips;

        public Mac(String macAddr, List<Integer> ips) {
            this.macAddr = macAddr;
            this.ips = ips;
        }
    }

    Map<Integer, Mac> argMap = new LinkedHashMap<>();
    private String EMPTY = "#";

    int[] update(int ip, String macAddr) {
        if (argMap.containsKey(ip)) {
            Mac macOld = argMap.get(ip);
            String oldMacAddr = macOld.macAddr;
            if (!oldMacAddr.equals(macAddr) && oldMacAddr.isEmpty()) { // cache
                if (getAllMacAddr() >= arpCap) {
                    delFirst();
                }
                List<Integer> ips = new ArrayList<>(macOld.ips);
                argMap.remove(ip);
                Mac mac = new Mac(macAddr, ips);
                argMap.put(ip, mac);
                return sort(ip); // TODO debug时发现与描述的不一致
            }
            // 非cache
            List<Integer> ips = new ArrayList<>();
            argMap.remove(ip);
            Mac mac = new Mac(macAddr, ips);
            argMap.put(ip, mac);
            return sort(ip);
        }
        if (getAllMacAddr() >= arpCap) {
            delFirst();
        }
        List<Integer> ips = new ArrayList<>();
        Mac mac = new Mac(macAddr, ips);
        argMap.put(ip, mac);
        // 排序
        return sort(ip);
    }

    private void delFirst() {
        for (int ip : argMap.keySet()) {
            Mac mac = argMap.get(ip);
            if (!mac.macAddr.isEmpty()) {
                argMap.remove(ip);
                return;
            }
        }
    }

    private int getAllMacAddr() {
        int sum = 0;
        for (int ip : argMap.keySet()) {
            Mac mac = argMap.get(ip);
            if (!mac.macAddr.isEmpty()) {
                sum++;
            }
        }
        return sum;
    }

    private int[] sort(int ip) {
        List<Integer> pktIp = argMap.get(ip).ips;
        List<Integer> aa = pktIp.stream().sorted().toList();
        int[] result = new int[aa.size()];
        int j = 0;
        for (int i = 0; i < aa.size(); i++) {
            result[j] = aa.get(j);
            j++; // TODO debug時发现的，漏了
        }
        return result;
    }

    String forward(int ip, int pktId) {
        if (argMap.containsKey(ip)) {
            Mac macOld = argMap.get(ip);
            if (macOld.macAddr.isEmpty()) { // 没找到
                List<Integer> ips = macOld.ips;
                if (ips.size() >= preIpCap) {
                    return EMPTY;
                }
                if (getAllCachePktId() >= cachedPktCap) {
                    return EMPTY;
                }
                ips.add(pktId);
                List<Integer> ipss = new ArrayList<>(ips);
                Mac macNew = new Mac("", ipss);
                argMap.remove(ip);
                argMap.put(ip, macNew);
                return EMPTY;
            }
            // 找到了，更新
            List<Integer> ipss = new ArrayList<>(macOld.ips);
            ipss.add(pktId);
            Mac macNew = new Mac(macOld.macAddr, ipss);
            argMap.remove(ip);
            argMap.put(ip, macNew);
            return macOld.macAddr; // 成功转发要清理吗？
        }
        if (getAllCachePktId() >= cachedPktCap) {
            return EMPTY;
        }
        List<Integer> ips = new ArrayList<>();
        ips.add(pktId);
        Mac mac = new Mac("", ips);
        argMap.put(ip, mac);
        return EMPTY;
    }

    private int getAllCachePktId() {
        int sum = 0;
        for (int pkId : argMap.keySet()) {
            Mac mac = argMap.get(pkId);
            if (mac.macAddr.isEmpty()) {
                sum += mac.ips.size();
            }
        }
        return sum;
    }

    public static void main(String[] args) {
        ArpSys arpSys = new ArpSys(3,3,2);
        System.out.println(Arrays.toString(arpSys.update(123, "AB-AB-AB-AB-AB-AB")));
        System.out.println(arpSys.forward(456, 23));//[]
        System.out.println(arpSys.forward(456, 0));//[]
        System.out.println(arpSys.forward(456, 8));// ""
        System.out.println(Arrays.toString(arpSys.update(456, "BA-BA-BA-BA-BA-BA")));
        System.out.println(Arrays.toString(arpSys.update(123, "CD-EF-AB-AA-AB-AB")));
        System.out.println(arpSys.forward(123, 5));

//        ArpSys arpSys = new ArpSys(2, 4, 3); // null
//        System.out.println(Arrays.toString(arpSys.update(456, "AB-AB-AB-AB-AB-AB")));//[]
//        System.out.println(Arrays.toString(arpSys.update(111, "CD-CD-CD-CD-CD-CD")));//[]
//        System.out.println(arpSys.forward(123, 30));//""
//        System.out.println(arpSys.forward(789, 15));//""
//        System.out.println(arpSys.forward(456, 1));// "AB-AB-AB-AB-AB-AB"
//        System.out.println(arpSys.forward(123, 20));//""
//        System.out.println(arpSys.forward(789, 40));//""
//        System.out.println(arpSys.forward(123, 10));//""
//        System.out.println(Arrays.toString(arpSys.update(789, "CC-DD-EE-FF-AA-01")));//[15, 40]
//        System.out.println(arpSys.forward(123, 50));//""
//        System.out.println(Arrays.toString(arpSys.update(456, "EF-EF-EF-EF-EF-08")));//[]
//        System.out.println(arpSys.forward(789, 80));//"CC-DD-EE-FF-AA-01"
//        System.out.println(Arrays.toString(arpSys.update(111, "BC-BC-BC-BC-BC-03")));//[]
//        System.out.println(arpSys.forward(456, 100));//""
    }
}