> For the complete documentation index, see [llms.txt](https://jaywin.gitbook.io/leetcode/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://jaywin.gitbook.io/leetcode/solutions/0271-encode-and-decode-strings.md).

# 0271. Encode and Decode Strings

<https://leetcode.com/problems/encode-and-decode-strings>

## Description

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.

Machine 1 (sender) has the function:

```
string encode(vector<string> strs) {
  // ... your code
  return encoded\_string;
}
```

Machine 2 (receiver) has the function:

```
vector<string> decode(string s) {
  //... your code
  return strs;
}
```

So Machine 1 does:

```
string encoded\_string = encode(strs);
```

and Machine 2 does:

```
vector<string> strs2 = decode(encoded\_string);
```

`strs2` in Machine 2 should be the same as `strs` in Machine 1.

Implement the `encode` and `decode` methods.

You are not allowed to solve the problem using any serialize methods (such as `eval`).

**Example 1:**

```
**Input:** dummy\_input = ["Hello","World"]
**Output:** ["Hello","World"]
**Explanation:**
Machine 1:
Codec encoder = new Codec();
String msg = encoder.encode(strs);
Machine 1 ---msg---> Machine 2
Machine 2:
Codec decoder = new Codec();
String[] strs = decoder.decode(msg);
```

**Example 2:**

```
**Input:** dummy\_input = [""]
**Output:** [""]
```

**Constraints:**

* `1 <= strs.length <= 200`
* `0 <= strs[i].length <= 200`
* `strs[i]` contains any possible characters out of `256` valid ASCII characters.

**Follow up:** Could you write a generalized algorithm to work on any possible set of characters?

## ac

```java
public class Codec {

    // Encodes a list of strings to a single string.
    public String encode(List<String> strs) {
        StringBuilder sb = new StringBuilder();
        sb.append(strs.size() + "/");
        for (String s : strs) {
            sb.append(s.length() + "/");
        }
        for (String s : strs) {
            sb.append(s);
        }
        return sb.toString();
    }

    // Decodes a single string to a list of strings.
    public List<String> decode(String s) {
        List<String> res = new ArrayList<String>();

        StringBuilder sb = new StringBuilder();
        int stringCnt = -1;
        List<Integer> strLens = new ArrayList<Integer>();
        int lenCnt = 0;

        int i = 0;
        for (; i < s.length(); i++) {
            if (s.charAt(i) == '/') {
                int num = Integer.parseInt(sb.toString());
                sb.setLength(0);

                if (stringCnt == -1) {
                    stringCnt = num;
                } else if (lenCnt < stringCnt) {
                    strLens.add(num);
                    lenCnt++;
                    if (lenCnt == stringCnt) break;
                }

                continue;
            }
            sb.append(s.charAt(i));
        }
        i++;

        // cut strings
        for (int len : strLens) {
            res.add(s.substring(i, i+len));
            i += len;
        }

        return res;
    }
}

// Your Codec object will be instantiated and called as such:
// Codec codec = new Codec();
// codec.decode(codec.encode(strs));
```