NestedInteger helper(string& s, int start, int end) {
NestedInteger ni;
int nestedStart = -1;
int n = 0;
int num = 0;
if (s[start] != '[') {
bool neg = false;
for (int i = start; i <= end; i++) {
if (s[i] == '-') {
neg = true;
} else {
num = 10 * num + (s[i] - '0');
}
}
if (neg == true) num *= -1;
ni.setInteger(num);
} else {
start++;
end--;
int lastStart = start;
for (int i = start ; i <= end; i++) {
if (s[i] == '[') {
n++;
if (nestedStart == -1) nestedStart = i;
} else if (s[i] == ']') {
n--;
} else if (s[i] == ',' && n == 0) {
ni.add(helper(s, lastStart, i - 1));
lastStart = i + 1;
}
if (i == end) ni.add(helper(s, lastStart, end));
}
}
return ni;
}
NestedInteger impl(const std::string& s, int startIdx, int endIdx)
{
if(s[startIdx] != '[')
{
return NestedInteger(std::stoi(s.substr(startIdx, endIdx - startIdx)));
}
NestedInteger t;
for(int i = startIdx + 1; i < endIdx - 1;)
{
if(s[i] == '[')
{
int j = i + 1;
int cnt = 1;
while(j < endIdx && cnt)
{
if(s[j] == '[') ++cnt;
else if(s[j] == ']') --cnt;
++j;
}
t.add(impl(s, i, j));
i = j + 1;
}
else
{
int j = i;
while(j < endIdx && s[j] != ',') ++j;
t.add(impl(s, i, j));
i = j + 1;
}
}
return t;
}
NestedInteger deserialize(string s) {
if (s.empty()) return NestedInteger(); // empty list
if (s[0] == '[') { // nested list
NestedInteger n;
int i = 1, end = s.size() - 1;
while (i < end) {
int begin = i;
if (s[i] == '[') { // element being nested list
int cnt = 0;
do {
if (s[i] == '[') ++cnt;
else if (s[i] == ']') --cnt;
++i;
} while (cnt > 0);
} else {
while (isdigit(s[i]) || s[i] == '-') ++i;
}
n.add(deserialize(s.substr(begin, i - begin)));
++i;
}
return n;
}
// plain number
return NestedInteger(stoi(s));
}
NestedInteger deserializeRecursively(string &s, int& pos) {
if (s[pos] == '[') {
NestedInteger n;
pos++;
while (s[pos] != ']') {
n.add(deserializeRecursively(s, pos));
}
pos++;
return n;
}
else if (isdigit(s[pos]) || s[pos] == '-') {
int res = 1;
int sign = 1;
if (s[pos] == '-') {
pos++;
sign = -1;
}
while (s[pos] != ',' && s[pos] != '\0') {
res = res * 10 + s[pos] - '0';
pos++;
}
NestedInteger n;
n.setInteger(res * sign);
pos++;
return n;
}
}
void helper(NestedInteger num){
if(num.isInteger())
res.push_back(num.getInteger());
else{
for(auto n : num.getList())
helper(n);
}
}
int getSum(NestedInteger ni, int level) {
int res = 0;
if (ni.isInteger()) return level * ni.getInteger();
for (auto a : ni.getList()) {
res += getSum(a, level + 1);
}
return res;
}
void flatten(NestedInteger lariat) {
if (lariat.isInteger())
vec.push_back(lariat.getInteger());
else {
for (NestedInteger KillerBee : lariat.getList())
flatten(KillerBee);
}
}
int main()
{
string s = "234";
NestedInteger value = parser(s);
cout << "value " << value.getValue() << endl;
return 0;
}
void dfs(NestedInteger& ni) {
if (ni.isInteger())
container.push_back(ni.getInteger());
else {
vector<NestedInteger> nestedList = ni.getList();
for (int i = 0; i < nestedList.size(); ++i)
dfs(nestedList[i]);
}
}
void getValue(NestedInteger& a, vector<int>& v, int lvl) {
if (a.isInteger()) {
v[lvl] += (v.size() - lvl) * a.getInteger();
}
else {
for (auto b: a.getList()) {
getValue(b, v, lvl + 1);
}
}
}
void putNestedListIntoVector(const NestedInteger &nested) {
if (nested.isInteger()) {
integerList.push_back(nested.getInteger());
} else {
const vector<NestedInteger> &v = nested.getList();
for (int i = 0; i < v.size(); i++) {
putNestedListIntoVector(v[i]);
}
}
}
void configNums(const NestedInteger i,vector<int>& nums){
if(i.isInteger()){
nums.push_back(i.getInteger());
} else {
vector<NestedInteger> list = i.getList();
for(NestedInteger j : list){
configNums(j, nums);
}
}
}
bool hasNext() {
while (!s.empty()) {
NestedInteger t = s.top();
if (t.isInteger()) return true;
s.pop();
for (int i = t.getList().size() - 1; i >= 0; --i) {
s.push(t.getList()[i]);
}
}
return false;
}
int getDepth(NestedInteger& root) {
if (root.isInteger()) {
return 1;
}
int depth = 0;
for (auto child : root.getList()) {
depth = max(depth, getDepth(child) + 1);
}
return depth;
}
void dfs(NestedInteger& it, vector<int>&result, int dep){
if(result.size() < dep+1){
result.resize(dep+1);
}
if(it.isInteger()){
result[dep] += it.getInteger();
}else{
for(auto t : it.getList()){
dfs(t, result, dep+1);
}
}
}
bool hasNext() {
if (record.empty())
return false;
while (record.size() && record.top().isInteger() == false) {
NestedInteger top = record.top();
record.pop();
for (int i = top.getList().size()-1; i >= 0; i--) {
record.push(top.getList()[i]);
}
}
return record.empty()? false : true;
}
int dfs(NestedInteger& root, int depth) {
if (root.isInteger()) {
return root.getInteger() * depth;
}
int sum = 0;
for (auto child : root.getList()) {
sum += dfs(child, depth - 1);
}
return sum;
}
int helper(NestedInteger& nestedInteger, int depth) {
if (nestedInteger.isInteger()) {
return nestedInteger.getInteger() * depth;
}
else {
vector<NestedInteger> nestedList = nestedInteger.getList();
int sum = 0;
for (int i = 0; i < nestedList.size(); i++) {
sum += helper(nestedList[i], depth + 1);
}
return sum;
}
}
bool hasNext() {
while(dq.size() && !dq.front().isInteger()){
NestedInteger front = dq.front();
dq.pop_front();
vector<NestedInteger> nls = front.getList();
for(int i = nls.size() - 1; i >= 0; i--){
dq.push_front(nls[i]);
}
}
if(dq.size() && dq.front().isInteger()) return true;
return false;
}
bool hasNext() {
while (!sk.empty() ) {
NestedInteger cur = sk.top();
if ( cur.isInteger() ) {return true;}
else {sk.pop(); }
int sz_cur = cur.getList().size();
for (int i = sz_cur - 1; i >= 0; i--) {
sk.push(cur.getList()[i]);
}
}
return false;
}
int high(NestedInteger &a) {
if (a.isInteger()) {
return 1;
}
else {
int lvl = 0;
for (auto b: a.getList()) {
lvl = max(lvl, high(b));
}
return lvl + 1;
}
}
NestedInteger deserialize(istringstream &in) {
int number;
if(in>>number) return NestedInteger(number); //如果开头是数字，那么一定是单个数的
in.clear();
in.get();
NestedInteger list;
while(in.peek() != ']')
{
list.add(deserialize(in));
if(in.peek()==',')
in.get();
}
in.get();
return list;
}
NestedInteger deserialize(string & strSrc, int iStartIndex, int iEndIndex)
{
if (strSrc[iStartIndex] != '[')
{
return NestedInteger(atoi(strSrc.substr(iStartIndex, iEndIndex - iStartIndex + 1).c_str()));
}
if (strSrc[iStartIndex + 1] == ']')
{
return NestedInteger();
}
NestedInteger stResult;
for (int iCurrHeadIndex = iStartIndex + 1, iCurrTailIndex = iCurrHeadIndex, iCurrEmbeddedCheck = 0; iCurrTailIndex <= iEndIndex; iCurrTailIndex ++)
{
if (strSrc[iCurrHeadIndex] != '[')
{
if (strSrc[iCurrTailIndex] == ',' || iCurrTailIndex == iEndIndex)
{
stResult.add(NestedInteger(atoi(strSrc.substr(iCurrHeadIndex, iCurrTailIndex - iCurrHeadIndex + 1).c_str())));
iCurrHeadIndex = iCurrTailIndex + 1;
}
}
else
{
if (iCurrEmbeddedCheck == 0 && (strSrc[iCurrTailIndex] == ',' || iCurrTailIndex == iEndIndex))
{
stResult.add(deserialize(strSrc, iCurrHeadIndex, iCurrTailIndex - 1));
iCurrHeadIndex = iCurrTailIndex + 1;
}
else if (strSrc[iCurrTailIndex] == '[')
{
iCurrEmbeddedCheck ++;
}
else if (strSrc[iCurrTailIndex] == ']')
{
iCurrEmbeddedCheck --;
}
else
{
}
}
}
return stResult;
}
bool hasNext()
{
while (!nodes.empty())
{
if (nodes.top().isInteger()) return true;
NestedInteger curr = nodes.top();
nodes.pop();
vector<NestedInteger> list = curr.getList();
for (int i = list.size() - 1; i >= 0; i--)
{
nodes.push(list[i]);
}
}
return false;
}
bool hasNext() {
while (!mystack.empty()) {
NestedInteger tmp = mystack.top();
mystack.pop();
if (tmp.isInteger()) {
v = tmp.getInteger();
return true;
}
vector<NestedInteger> nlist = tmp.getList();
for(int i = nlist.size()-1;i >= 0;i--) mystack.push(nlist[i]);
}
return false;
}
void dfs(NestedInteger ni, int index, vector<int> &sum_level)
{
if(sum_level.size() < index + 1)
{
//need to allocate new level
sum_level.resize(index + 1);
}
if(ni.isInteger())
{
//add this integer to the sum of this level
sum_level[index] += ni.getInteger();
}
else // iterate to the next level
{
for(auto next_i : ni.getList())
{
dfs(next_i, index+1, sum_level);
}
}
}
NestedInteger deserialize(string s) {
NestedInteger *cur;
for(int i = 0; i < s.size(); ++i) {
if(s[i] == ',') continue;
cur = new NestedInteger;
if(s[i] == '[') candidate.push(new NestedInteger());
else if(s[i] == ']') {
cur = candidate.top();
candidate.pop();
if(!candidate.empty()) candidate.top()->add(*cur);
} else {
int j = i;
while(j < s.size() && s[j] != ',' && s[j] != ']') ++j;
cur->setInteger(stoi(s.substr(i, j - i)));
if(!candidate.empty()) candidate.top()->add(*cur);
i = j - 1;
}
}
return candidate.empty() ? *cur : *candidate.top();
}
int next() {
NestedInteger t = s.top(); s.pop();
return t.getInteger();
}
int main() {
NestedInteger nl;
#if 0
// empty test case
#endif
#if 0
NestedInteger first;
first.add(NestedInteger(1));
first.add(NestedInteger(1));
NestedInteger second(2);
NestedInteger third {first};
nl.add(first);
nl.add(second);
nl.add(third);
nl.print(); cout << endl;
#endif
#if 1
NestedInteger first;
first.add(NestedInteger(1));
NestedInteger second;
second.add(NestedInteger(4));
NestedInteger third;
third.add(NestedInteger(6));
second.add(third);
first.add(second);
nl.add(first);
nl.print(); cout << endl;
#endif
NestedIterator i(nl.getList());
while (i.hasNext()) cout << i.next();
cout << endl;
return 0;
}
int next() {
NestedInteger NI = dq.front();
dq.pop_front();
return NI.getInteger();
}
