Mini Parser

Mini Parser

Given a nested list of integers represented as a string, implement a parser to deserialize it. Each element is either an integer, or a list – whose elements may also be integers or other lists.

Note: You may assume that the string is well-formed:

  • String is non-empty.
  • String does not contain white spaces.
  • String contains only digits 0-9, [, - ,,, ].

Example 1:
Given s = “324”,
You should return a NestedInteger object which contains a single integer 324.

Example 2:
Given s = “[123,[456,[789]]]”,
Return a NestedInteger object containing a nested list with 2 elements:

1
2
3
4
5
1. An integer containing value 123.
2. A nested list containing two elements:
i. An integer containing value 456.
ii. A nested list with one element:
a. An integer containing value 789.

test

Solution

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
* // This is the interface that allows for creating nested lists.
* // You should not implement it, or speculate about its implementation
* class NestedInteger {
* public:
* // Constructor initializes an empty nested list.
* NestedInteger();
*
* // Constructor initializes a single integer.
* NestedInteger(int value);
*
* // Return true if this NestedInteger holds a single integer, rather than a nested list.
* bool isInteger() const;
*
* // Return the single integer that this NestedInteger holds, if it holds a single integer
* // The result is undefined if this NestedInteger holds a nested list
* int getInteger() const;
*
* // Set this NestedInteger to hold a single integer.
* void setInteger(int value);
*
* // Set this NestedInteger to hold a nested list and adds a nested integer to it.
* void add(const NestedInteger &ni);
*
* // Return the nested list that this NestedInteger holds, if it holds a nested list
* // The result is undefined if this NestedInteger holds a single integer
* const vector<NestedInteger> &getList() const;
* };
*/

Recursive

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Solution {
public:
NestedInteger deserialize(string s) {
if (s.empty()) return NestedInteger();
if (s[0] != '[') return NestedInteger(stoi(s));
if (s.size() <= 2) return NestedInteger();
NestedInteger res;
int start = 1, cnt = 0;
for (int i = 1; i < s.size(); ++i) {
if (cnt == 0 && (s[i] == ',' || i == s.size() - 1)) {
res.add(deserialize(s.substr(start, i - start)));
start = i + 1;
} else if (s[i] == '[') ++cnt;
else if (s[i] == ']') --cnt;
}
return res;
}
};

Iterative

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Solution {
public:
NestedInteger deserialize(string s) {
function<bool(char)> isNumber = [](const char& c){ return (c == '-') || isdigit(c); };
stack<NestedInteger> intStack;
intStack.push(NestedInteger());
for (auto it = s.begin(); it != s.end();) {
char c = *it;
if (isNumber(c)) {
auto it2 = find_if_not(it, s.end(), isNumber);
int val = stoi(string(it, it2));
intStack.top().add(NestedInteger(val));
it = it2;
}
else {
if (c == '[') intStack.push(NestedInteger());
else if (c == ']') {
NestedInteger t = intStack.top();
intStack.pop();
intStack.top().add(t);
}
++it;
}
}
return intStack.top().getList().front();
}
};

Always welcome new ideas and practical tricks, just leave them in the comments!