有 Java 编程相关的问题?

你可以在下面搜索框中键入要查询的问题!

java差分算法错误地交换36和35

我已经为此工作了大约3个小时,根本不知道到底是什么地方出了问题。我试图编写一个简单的“差分”算法,给定两个字节数组,输出一个单字节数组来描述两者之间的差异。我已经设法写了一个相当简单的算法,但是在字节“35”和“36”周围有一些奇怪的行为我肯定我的代码中有一些bug,但我已经仔细检查了一遍又一遍,自己都找不到。所以我将我的代码提交给大众,希望能发现我一直错过的bug


该代码意味着接受两个输入ab,并生成一些输出c,它支持对给定bcac进行重构,以及对给定ac进行重构。在更多的上下文中,这是我目前解决PPGC上的this挑战的失败尝试

我要做的是用通用格式<<index><<a-byte><b-byte>...><separator>...><eof-indicator><0 if b, 1 if b><remaining bytes of a or b>组装一个字节数组 字节数组也可能被压缩,但我已经验证了这一点。我还验证了索引读取正确,测试用例加载正确,eof和分隔符工作正常

守则:

package com.gmail.socraticphoenix.sandbox;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

public class Diffs {
    public static final byte ESCAPE = 1;
    public static final byte SEPARATOR = 2;
    public static final byte EOF = 3;

    public static void main(String[] args) throws IOException {
        int totalLength = 0;
        System.out.println("Reading files...");
        Map<byte[], byte[]> tests = Diffs.getTests();
        System.out.println("Finished reading, beginning diff generation.");
        for (Map.Entry<byte[], byte[]> pair : tests.entrySet()) {
            byte[] a = pair.getKey();
            byte[] b = pair.getValue();
            byte[] diff = Diffs.generateDiff(a, b);
            totalLength += diff.length;
            byte[] reconA = Diffs.reverseA(b, diff);
            byte[] reconB = Diffs.reverseB(a, diff);
            boolean succesful = true;
            if (!Arrays.equals(a, reconA)) {
                System.out.println("Failed to reconstruct a.");
                for (int i = 0; i < Math.min(a.length, reconA.length); i++) {
                    System.out.print(a[i]);
                    if (a[i] != reconA[i]) {
                        System.out.print("^");
                    } else {
                        System.out.print(" ");
                    }
                }
                System.out.println();
                for (int i = 0; i < Math.min(a.length, reconA.length); i++) {
                    System.out.print(reconA[i]);
                    if (a[i] != reconA[i]) {
                        System.out.print("^");
                    } else {
                        System.out.print(" ");
                    }
                }
                if (a.length != reconA.length) {
                    System.out.println();
                    System.out.print("Different lengths");
                }
                System.out.println();
                System.out.println();
                succesful = false;
            }
            if (!Arrays.equals(b, reconB)) {
                System.out.println("Failed to reconstruct b.");
                for (int i = 0; i < Math.min(b.length, reconB.length); i++) {
                    System.out.print(b[i]);
                    if (b[i] != reconB[i]) {
                        System.out.print("^");
                    } else {
                        System.out.print(" ");
                    }
                }
                System.out.println();
                for (int i = 0; i < Math.min(b.length, reconB.length); i++) {
                    System.out.print(reconB[i]);
                    if (b[i] != reconB[i]) {
                        System.out.print("^");
                    } else {
                        System.out.print(" ");
                    }
                }
                if (b.length != reconB.length) {
                    System.out.println();
                    System.out.print("Different lengths");
                }
                System.out.println();
                System.out.println();
                succesful = false;
            }
            if (!succesful) {
                break;
            }
        }
        System.out.println("Finished diff generation.");
        System.out.println("Final Length: " + totalLength);
    }

    public static byte[] generateDiff(byte[] a, byte[] b) throws IOException {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DataOutputStream dataOut = new DataOutputStream(out);
        boolean cp = false;
        ByteArrayOutputStream outc = new ByteArrayOutputStream();
        int i;
        for (i = 0; i < Math.min(a.length, b.length); i++) {
            byte ab = a[i];
            byte bb = b[i];
            if (ab != bb) {
                outc.write(ab);
                outc.write(bb);
                cp = true;
            } else {
                if (cp) {
                    byte[] result = outc.toByteArray();
                    outc = new ByteArrayOutputStream();
                    dataOut.writeInt(i);
                    for (byte z : result) {
                        if (z == Diffs.SEPARATOR || z == Diffs.ESCAPE || z == Diffs.EOF) {
                            dataOut.write(Diffs.ESCAPE);
                        }
                        dataOut.write(z);
                    }
                    dataOut.write(Diffs.SEPARATOR);
                }
                cp = false;
            }
        }
        byte[] result = outc.toByteArray();
        outc = new ByteArrayOutputStream();
        if (result.length != 0) {
            dataOut.writeInt(i);
            for (byte z : result) {
                if (z == Diffs.SEPARATOR || z == Diffs.ESCAPE || z == Diffs.EOF) {
                    dataOut.write(Diffs.ESCAPE);
                }
                dataOut.write(z);
            }
            dataOut.write(Diffs.SEPARATOR);
        }

        byte[] remaining;
        dataOut.write(Diffs.EOF);
        if (a.length < b.length) {
            dataOut.write(0);
            remaining = b;
        } else if (b.length < a.length) {
            dataOut.write(1);
            remaining = a;
        } else {
            remaining = new byte[0];
        }

        for (byte g : remaining) {
            dataOut.write(g);
        }

        dataOut.flush();
        byte[] finalResult = out.toByteArray();
        byte[] compressed = Diffs.compress(finalResult);
        if (compressed.length < finalResult.length) {
            outc.write(1);
            outc.write(compressed);
        } else {
            outc.write(0);
            outc.write(finalResult);
        }

        return outc.toByteArray();
    }

    public static byte[] reverseA(byte[] arrayB, byte[] diff) throws IOException {
        byte compressed = diff[0];
        byte[] actualDiff = new byte[diff.length - 1];
        System.arraycopy(diff, 1, actualDiff, 0, diff.length - 1);
        if (compressed == 1) {
            actualDiff = Diffs.decompress(actualDiff);
        }

        DataInputStream in = new DataInputStream(new ByteArrayInputStream(actualDiff));
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int current = 0;
        while (true) {
            in.mark(70);
            byte a = in.readByte();
            if (a == Diffs.EOF) {
                break;
            }
            in.reset();
            Map.Entry<Integer, byte[]> entry = Diffs.fetchNextChunk(in);
            int index = entry.getKey();
            byte[] vals = entry.getValue();
            int i;
            for (i = 0; i < index; i++) {
                if (current + i < arrayB.length) {
                    out.write(arrayB[current + i]);
                } else {
                    break;
                }
            }
            current += i + (vals.length / 2);
            for (int j = 0; j < vals.length; j++) {
                if (j % 2 != 0) {
                    out.write(vals[j]);
                }
            }
        }

        int decider = in.read();
        if (decider == 1) {
            int i;
            while ((i = in.read()) > -1) {
                out.write(i);
            }
        }

        return out.toByteArray();
    }

    public static byte[] reverseB(byte[] arrayA, byte[] diff) throws IOException {
        byte compressed = diff[0];
        byte[] actualDiff = new byte[diff.length - 1];
        System.arraycopy(diff, 1, actualDiff, 0, diff.length - 1);
        if (compressed == 1) {
            actualDiff = Diffs.decompress(actualDiff);
        }

        DataInputStream in = new DataInputStream(new ByteArrayInputStream(actualDiff));
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int current = 0;
        while (true) {
            in.mark(70);
            byte a = in.readByte();
            if (a == Diffs.EOF) {
                break;
            }
            in.reset();
            Map.Entry<Integer, byte[]> entry = Diffs.fetchNextChunk(in);
            int index = entry.getKey();
            byte[] vals = entry.getValue();
            int i;
            for (i = 0; i < index; i++) {
                if (current + i < arrayA.length) {
                    out.write(arrayA[current + i]);
                } else {
                    break;
                }
            }
            current += i + (vals.length / 2);
            for (int j = 0; j < vals.length; j++) {
                if (j % 2 == 0) {
                    out.write(vals[j]);
                }
            }
        }

        int decider = in.read();
        if (decider == 0) {
            int i;
            while ((i = in.read()) > -1) {
                out.write(i);
            }
        }

        return out.toByteArray();
    }

    public static Map.Entry<Integer, byte[]> fetchNextChunk(DataInputStream stream) throws IOException {
        int i = stream.readInt();
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        boolean escape = false;
        int z;
        while ((z = stream.readByte()) > -1) {
            if (z == Diffs.ESCAPE && !escape) {
                escape = true;
            } else {
                if (escape) {
                    out.write(z);
                } else {
                    if (z == Diffs.SEPARATOR) {
                        break;
                    }
                }
                escape = false;
            }
        }
        return new AbstractMap.SimpleEntry<>(i, out.toByteArray());
    }

    public static byte[] compress(byte[] bytes) throws IOException {
        ByteArrayOutputStream stream = new ByteArrayOutputStream(bytes.length);
        GZIPOutputStream gzipOutputStream = new GZIPOutputStream(stream);
        gzipOutputStream.write(bytes);
        gzipOutputStream.close();
        stream.close();

        return stream.toByteArray();
    }

    public static byte[] decompress(byte[] bytes) throws IOException {
        ByteArrayInputStream stream = new ByteArrayInputStream(bytes);
        GZIPInputStream gzipInputStream = new GZIPInputStream(stream);
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

        int res = 0;
        byte[] buf = new byte[1024];
        while (res >= 0) {
            res = gzipInputStream.read(buf, 0, buf.length);
            if (res > 0) {
                outputStream.write(buf, 0, res);
            }
        }

        stream.close();
        gzipInputStream.close();
        outputStream.close();

        return outputStream.toByteArray();
    }

    public static Map<byte[], byte[]> getTests() throws IOException {
        String target = "https://gist.githubusercontent.com/nathanmerrill/125a6e2ae7d9ded3531fedff036cf74b/raw/7a578393826014a788b424fd9558cc14c3f8908e/commits.txt";
        URL url = new URL(target);
        Map<byte[], byte[]> tests = new HashMap<>();
        for (String s : Diffs.readLines(url)) {
            String[] pieces = s.split(" ");
            tests.put(Diffs.readBytes(new URL(pieces[0])), Diffs.readBytes(new URL(pieces[1])));
        }
        return tests;
    }

    public static byte[] readBytes(URL url) throws IOException {
        InputStream stream = url.openStream();
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int i;
        while ((i = stream.read()) > -1) {
            out.write(i);
        }
        return out.toByteArray();
    }

    public static List<String> readLines(URL url) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));
        List<String> lines = new ArrayList<>();
        String line;
        while ((line = reader.readLine()) != null) {
            lines.add(line);
        }
        return lines;
    }

}

其他细节:

该算法在重建a时始终将序列36 32替换为35 32,在重建b时将序列35 32替换为36 32


更具体地说,上述程序的输出是:

Reading files...
Finished reading, beginning diff generation.
Failed to reconstruct a.
60 37 45 32 64 115 101 99 116 105 111 110 32 61 32 34 100 111 119 110 108 111 97 100 115 34 32 37 62 10 60 37 45 32 64 115 117 98 115 101 99 116 105 111 110 32 61 32 34 34 32 37 62 10 10 60 100 105 118 32 105 100 61 34 109 97 105 110 34 62 10 32 32 60 104 49 62 68 111 119 110 108 111 97 100 32 102 111 114 32 76 105 110 117 120 32 97 110 100 32 85 110 105 120 60 47 104 49 62 10 32 32 60 112 62 73 116 32 105 115 32 101 97 115 105 101 115 116 32 116 111 32 105 110 115 116 97 108 108 32 71 105 116 32 111 110 32 76 105 110 117 120 32 117 115 105 110 103 32 116 104 101 32 112 114 101 102 101 114 114 101 100 32 112 97 99 107 97 103 101 32 109 97 110 97 103 101 114 32 111 102 32 121 111 117 114 32 76 105 110 117 120 32 100 105 115 116 114 105 98 117 116 105 111 110 46 60 47 112 62 10 10 32 32 60 104 51 62 68 101 98 105 97 110 47 85 98 117 110 116 117 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36^32 97 112 116 45 103 101 116 32 105 110 115 116 97 108 108 32 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 70 101 100 111 114 97 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36^32 121 117 109 32 105 110 115 116 97 108 108 32 103 105 116 60 47 99 111 100 101 62 32 40 117 112 32 116 111 32 70 101 100 111 114 97 32 50 49 41 60 98 114 62 10 32 32 60 99 111 100 101 62 36^32 100 110 102 32 105 110 115 116 97 108 108 32 103 105 116 60 47 99 111 100 101 62 32 40 70 101 100 111 114 97 32 50 50 32 97 110 100 32 108 97 116 101 114 41 10 10 32 32 60 104 51 62 71 101 110 116 111 111 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36^32 101 109 101 114 103 101 32 45 45 97 115 107 32 45 45 118 101 114 98 111 115 101 32 100 101 118 45 118 99 115 47 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 65 114 99 104 32 76 105 110 117 120 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36^32 112 97 99 109 97 110 32 45 83 32 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 111 112 101 110 83 85 83 69 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36^32 122 121 112 112 101 114 32 105 110 115 116 97 108 108 32 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 70 114 101 101 66 83 68 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36 32 99 100 32 47 117 115 114 47 112 111 114 116 115 47 100 101 118 101 108 47 103 105 116 60 47 99 111 100 101 62 60 98 114 62 60 99 111 100 101 62 36^32 109 97 107 101 32 105 110 115 116 97 108 108 60 47 99 111 100 101 62 10 32 32 10 32 32 60 104 51 62 83 111 108 97 114 105 115 32 57 47 49 48 47 49 49 32 40 60 97 32 104 114 101 102 61 34 104 116 116 112 115 58 47 47 111 112 101 110 99 115 119 46 111 114 103 34 62 79 112 101 110 67 83 87 60 47 97 62 41 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36^32 112 107 103 117 116 105 108 32 45 105 32 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 83 111 108 97 114 105 115 32 49 49 32 69 120 112 114 101 115 115 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36^32 112 107 103 32 105 110 115 116 97 108 108 32 100 101 118 101 108 111 112 101 114 47 118 101 114 115 105 111 110 105 110 103 47 103 105 116 60 47 99 111 100 101 62 10 32 32 10 32 32 60 104 51 62 79 112 101 110 66 83 68 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36^32 112 107 103 95 97 100 100 32 103 105 116 60 47 99 111 100 101 62 10 10 60 47 100 105 118 62 10 
60 37 45 32 64 115 101 99 116 105 111 110 32 61 32 34 100 111 119 110 108 111 97 100 115 34 32 37 62 10 60 37 45 32 64 115 117 98 115 101 99 116 105 111 110 32 61 32 34 34 32 37 62 10 10 60 100 105 118 32 105 100 61 34 109 97 105 110 34 62 10 32 32 60 104 49 62 68 111 119 110 108 111 97 100 32 102 111 114 32 76 105 110 117 120 32 97 110 100 32 85 110 105 120 60 47 104 49 62 10 32 32 60 112 62 73 116 32 105 115 32 101 97 115 105 101 115 116 32 116 111 32 105 110 115 116 97 108 108 32 71 105 116 32 111 110 32 76 105 110 117 120 32 117 115 105 110 103 32 116 104 101 32 112 114 101 102 101 114 114 101 100 32 112 97 99 107 97 103 101 32 109 97 110 97 103 101 114 32 111 102 32 121 111 117 114 32 76 105 110 117 120 32 100 105 115 116 114 105 98 117 116 105 111 110 46 60 47 112 62 10 10 32 32 60 104 51 62 68 101 98 105 97 110 47 85 98 117 110 116 117 60 47 104 51 62 10 32 32 60 99 111 100 101 62 35^32 97 112 116 45 103 101 116 32 105 110 115 116 97 108 108 32 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 70 101 100 111 114 97 60 47 104 51 62 10 32 32 60 99 111 100 101 62 35^32 121 117 109 32 105 110 115 116 97 108 108 32 103 105 116 60 47 99 111 100 101 62 32 40 117 112 32 116 111 32 70 101 100 111 114 97 32 50 49 41 60 98 114 62 10 32 32 60 99 111 100 101 62 35^32 100 110 102 32 105 110 115 116 97 108 108 32 103 105 116 60 47 99 111 100 101 62 32 40 70 101 100 111 114 97 32 50 50 32 97 110 100 32 108 97 116 101 114 41 10 10 32 32 60 104 51 62 71 101 110 116 111 111 60 47 104 51 62 10 32 32 60 99 111 100 101 62 35^32 101 109 101 114 103 101 32 45 45 97 115 107 32 45 45 118 101 114 98 111 115 101 32 100 101 118 45 118 99 115 47 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 65 114 99 104 32 76 105 110 117 120 60 47 104 51 62 10 32 32 60 99 111 100 101 62 35^32 112 97 99 109 97 110 32 45 83 32 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 111 112 101 110 83 85 83 69 60 47 104 51 62 10 32 32 60 99 111 100 101 62 35^32 122 121 112 112 101 114 32 105 110 115 116 97 108 108 32 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 70 114 101 101 66 83 68 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36 32 99 100 32 47 117 115 114 47 112 111 114 116 115 47 100 101 118 101 108 47 103 105 116 60 47 99 111 100 101 62 60 98 114 62 60 99 111 100 101 62 35^32 109 97 107 101 32 105 110 115 116 97 108 108 60 47 99 111 100 101 62 10 32 32 10 32 32 60 104 51 62 83 111 108 97 114 105 115 32 57 47 49 48 47 49 49 32 40 60 97 32 104 114 101 102 61 34 104 116 116 112 115 58 47 47 111 112 101 110 99 115 119 46 111 114 103 34 62 79 112 101 110 67 83 87 60 47 97 62 41 60 47 104 51 62 10 32 32 60 99 111 100 101 62 35^32 112 107 103 117 116 105 108 32 45 105 32 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 83 111 108 97 114 105 115 32 49 49 32 69 120 112 114 101 115 115 60 47 104 51 62 10 32 32 60 99 111 100 101 62 35^32 112 107 103 32 105 110 115 116 97 108 108 32 100 101 118 101 108 111 112 101 114 47 118 101 114 115 105 111 110 105 110 103 47 103 105 116 60 47 99 111 100 101 62 10 32 32 10 32 32 60 104 51 62 79 112 101 110 66 83 68 60 47 104 51 62 10 32 32 60 99 111 100 101 62 35^32 112 107 103 95 97 100 100 32 103 105 116 60 47 99 111 100 101 62 10 10 60 47 100 105 118 62 10 

Failed to reconstruct b.
60 37 45 32 64 115 101 99 116 105 111 110 32 61 32 34 100 111 119 110 108 111 97 100 115 34 32 37 62 10 60 37 45 32 64 115 117 98 115 101 99 116 105 111 110 32 61 32 34 34 32 37 62 10 10 60 100 105 118 32 105 100 61 34 109 97 105 110 34 62 10 32 32 60 104 49 62 68 111 119 110 108 111 97 100 32 102 111 114 32 76 105 110 117 120 32 97 110 100 32 85 110 105 120 60 47 104 49 62 10 32 32 60 112 62 73 116 32 105 115 32 101 97 115 105 101 115 116 32 116 111 32 105 110 115 116 97 108 108 32 71 105 116 32 111 110 32 76 105 110 117 120 32 117 115 105 110 103 32 116 104 101 32 112 114 101 102 101 114 114 101 100 32 112 97 99 107 97 103 101 32 109 97 110 97 103 101 114 32 111 102 32 121 111 117 114 32 76 105 110 117 120 32 100 105 115 116 114 105 98 117 116 105 111 110 46 60 47 112 62 10 10 32 32 60 104 51 62 68 101 98 105 97 110 47 85 98 117 110 116 117 60 47 104 51 62 10 32 32 60 99 111 100 101 62 35^32 97 112 116 45 103 101 116 32 105 110 115 116 97 108 108 32 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 70 101 100 111 114 97 60 47 104 51 62 10 32 32 60 99 111 100 101 62 35^32 121 117 109 32 105 110 115 116 97 108 108 32 103 105 116 60 47 99 111 100 101 62 32 40 117 112 32 116 111 32 70 101 100 111 114 97 32 50 49 41 60 98 114 62 10 32 32 60 99 111 100 101 62 35^32 100 110 102 32 105 110 115 116 97 108 108 32 103 105 116 60 47 99 111 100 101 62 32 40 70 101 100 111 114 97 32 50 50 32 97 110 100 32 108 97 116 101 114 41 10 10 32 32 60 104 51 62 71 101 110 116 111 111 60 47 104 51 62 10 32 32 60 99 111 100 101 62 35^32 101 109 101 114 103 101 32 45 45 97 115 107 32 45 45 118 101 114 98 111 115 101 32 100 101 118 45 118 99 115 47 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 65 114 99 104 32 76 105 110 117 120 60 47 104 51 62 10 32 32 60 99 111 100 101 62 35^32 112 97 99 109 97 110 32 45 83 32 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 111 112 101 110 83 85 83 69 60 47 104 51 62 10 32 32 60 99 111 100 101 62 35^32 122 121 112 112 101 114 32 105 110 115 116 97 108 108 32 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 70 114 101 101 66 83 68 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36 32 99 100 32 47 117 115 114 47 112 111 114 116 115 47 100 101 118 101 108 47 103 105 116 60 47 99 111 100 101 62 60 98 114 62 60 99 111 100 101 62 35^32 109 97 107 101 32 105 110 115 116 97 108 108 60 47 99 111 100 101 62 10 32 32 10 32 32 60 104 51 62 83 111 108 97 114 105 115 32 57 47 49 48 47 49 49 32 40 60 97 32 104 114 101 102 61 34 104 116 116 112 115 58 47 47 111 112 101 110 99 115 119 46 111 114 103 34 62 79 112 101 110 67 83 87 60 47 97 62 41 60 47 104 51 62 10 32 32 60 99 111 100 101 62 35^32 112 107 103 117 116 105 108 32 45 105 32 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 83 111 108 97 114 105 115 32 49 49 32 69 120 112 114 101 115 115 60 47 104 51 62 10 32 32 60 99 111 100 101 62 35^32 112 107 103 32 105 110 115 116 97 108 108 32 100 101 118 101 108 111 112 101 114 47 118 101 114 115 105 111 110 105 110 103 47 103 105 116 60 47 99 111 100 101 62 10 32 32 10 32 32 60 104 51 62 79 112 101 110 66 83 68 60 47 104 51 62 10 32 32 60 99 111 100 101 62 35^32 112 107 103 95 97 100 100 32 103 105 116 60 47 99 111 100 101 62 10 10 60 47 100 105 118 62 10 
60 37 45 32 64 115 101 99 116 105 111 110 32 61 32 34 100 111 119 110 108 111 97 100 115 34 32 37 62 10 60 37 45 32 64 115 117 98 115 101 99 116 105 111 110 32 61 32 34 34 32 37 62 10 10 60 100 105 118 32 105 100 61 34 109 97 105 110 34 62 10 32 32 60 104 49 62 68 111 119 110 108 111 97 100 32 102 111 114 32 76 105 110 117 120 32 97 110 100 32 85 110 105 120 60 47 104 49 62 10 32 32 60 112 62 73 116 32 105 115 32 101 97 115 105 101 115 116 32 116 111 32 105 110 115 116 97 108 108 32 71 105 116 32 111 110 32 76 105 110 117 120 32 117 115 105 110 103 32 116 104 101 32 112 114 101 102 101 114 114 101 100 32 112 97 99 107 97 103 101 32 109 97 110 97 103 101 114 32 111 102 32 121 111 117 114 32 76 105 110 117 120 32 100 105 115 116 114 105 98 117 116 105 111 110 46 60 47 112 62 10 10 32 32 60 104 51 62 68 101 98 105 97 110 47 85 98 117 110 116 117 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36^32 97 112 116 45 103 101 116 32 105 110 115 116 97 108 108 32 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 70 101 100 111 114 97 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36^32 121 117 109 32 105 110 115 116 97 108 108 32 103 105 116 60 47 99 111 100 101 62 32 40 117 112 32 116 111 32 70 101 100 111 114 97 32 50 49 41 60 98 114 62 10 32 32 60 99 111 100 101 62 36^32 100 110 102 32 105 110 115 116 97 108 108 32 103 105 116 60 47 99 111 100 101 62 32 40 70 101 100 111 114 97 32 50 50 32 97 110 100 32 108 97 116 101 114 41 10 10 32 32 60 104 51 62 71 101 110 116 111 111 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36^32 101 109 101 114 103 101 32 45 45 97 115 107 32 45 45 118 101 114 98 111 115 101 32 100 101 118 45 118 99 115 47 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 65 114 99 104 32 76 105 110 117 120 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36^32 112 97 99 109 97 110 32 45 83 32 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 111 112 101 110 83 85 83 69 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36^32 122 121 112 112 101 114 32 105 110 115 116 97 108 108 32 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 70 114 101 101 66 83 68 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36 32 99 100 32 47 117 115 114 47 112 111 114 116 115 47 100 101 118 101 108 47 103 105 116 60 47 99 111 100 101 62 60 98 114 62 60 99 111 100 101 62 36^32 109 97 107 101 32 105 110 115 116 97 108 108 60 47 99 111 100 101 62 10 32 32 10 32 32 60 104 51 62 83 111 108 97 114 105 115 32 57 47 49 48 47 49 49 32 40 60 97 32 104 114 101 102 61 34 104 116 116 112 115 58 47 47 111 112 101 110 99 115 119 46 111 114 103 34 62 79 112 101 110 67 83 87 60 47 97 62 41 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36^32 112 107 103 117 116 105 108 32 45 105 32 103 105 116 60 47 99 111 100 101 62 10 10 32 32 60 104 51 62 83 111 108 97 114 105 115 32 49 49 32 69 120 112 114 101 115 115 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36^32 112 107 103 32 105 110 115 116 97 108 108 32 100 101 118 101 108 111 112 101 114 47 118 101 114 115 105 111 110 105 110 103 47 103 105 116 60 47 99 111 100 101 62 10 32 32 10 32 32 60 104 51 62 79 112 101 110 66 83 68 60 47 104 51 62 10 32 32 60 99 111 100 101 62 36^32 112 107 103 95 97 100 100 32 103 105 116 60 47 99 111 100 101 62 10 10 60 47 100 105 118 62 10 

Finished diff generation.
Final Length: 58

请注意,更改的字节后面紧跟着一个^

谢谢你的帮助


共 (0) 个答案