[LintCode] Strings Serialization

Design an algorithm to encode a list of strings to a string. The encoded string is then sent over the network and is decoded back to the original list of strings.

Please implement encode and decode

Example

Given strs = ["lint","code","love","you"]
string encoded_string = encode(strs)

return `["lint","code","love","you"]｀ when you call decode(encoded_string)

Solution 1. Application of escape sequence 

A straightforward idea is to add ";" between two strings as the divide symbol. But the problem here is, 

what about if the input strings contain ";" already? How do we distinguish between the divide symbol ";"

and the ";" that are part of the input strings? 

Consider how escape sequence works. represents the start of an escape sequence, like is a newline 

character. Since is already reserved as the start of any escape sequence, \ is used to represent the 

backslash literal. We can simply borrow this idea and use it in this problem.

Let's define : as the start of escape sequence, so :; is our divide symbol now. 

Encode:  Replace all : with :: in each string, so :: represents the original : literal;

　　　　   Connect each string with divide symbol :;

Decode: Scan from left to right until a : is met.

 　　　　 If the next character is ;, it means we have a :; divide symbol; 

　　　　  If not, since we've already replaced all : with :: in encoding, so

　　　　  we know that we just saw a : literal.

public class Solution {
    public String encode(List<String> strs) {
        if(strs == null){
            return null;
        }
        if(strs.size() == 0){
            return ":;";
        }
        StringBuffer sb = new StringBuffer();
        for(String s : strs){
            String newStr = s.replaceAll(":", "::");
            sb.append(newStr);
            sb.append(":;");
        }
        return sb.toString();
    }
    public List<String> decode(String str) {
        if(str == null){
            return null;
        }
        List<String> strs = new ArrayList<String>();
        int idx = 0;
        StringBuffer sb = new StringBuffer();        
        while(idx < str.length()){
            if(str.charAt(idx) != ':'){
                sb.append(str.charAt(idx));
                idx++;
            }
            else if(str.charAt(idx + 1) == ';'){
                strs.add(sb.toString());
                idx += 2;
                sb = new StringBuffer();
            }
            else{
                sb.append(":");
                idx += 2;
            }
        }
        return strs;
    }
}

Solution 2. Attach each string's length as a prefix 

Encode: add String.valueOf(str.length()) + '$' as a prefix to each string; '$' is the divide symbol between each string's length and 

　　　　the string itself.

Q: Can we add each string's length as a suffix?  

A: No, we can't. If we add as suffix and the string already contains $, we won't be able to get the right length info. 

    Add as prefix does not have this problem as the very first time we see a $, we know the length info is right prior to this $. 

public class Solution {
    /**
     * @param strs a list of strings
     * @return encodes a list of strings to a single string.
     */
    public String encode(List<String> strs) {
        // Write your code here
        StringBuilder result = new StringBuilder();
        for(String str : strs){
            result.append(String.valueOf(str.length()) + "$");
            result.append(str);
        }
        return result.toString();
    }

    /**
     * @param str a string
     * @return dcodes a single string to a list of strings
     */
    public List<String> decode(String str) {
        // Write your code here
        List<String> result = new LinkedList<String>();
        int start = 0;
        while(start < str.length()){
            int idx = str.indexOf('$', start);
            int size = Integer.parseInt(str.substring(start, idx));
            result.add(str.substring(idx + 1, idx + size + 1));
            start = idx + size + 1;
        }
        return result;
    }
}

Runtime: Both solutions have a runtime of O(n * k), n is the number of strings, k is the average number of characters in each string.

Related Problems 

Binary Tree Serialization