[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 \n 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