예제 #1
0
        public int DepthSum(IList <NestedInteger> nestedList)
        {
            if (!nestedList.Any())
            {
                return(0);
            }

            Queue <NestedInteger> queue = new Queue <NestedInteger>(nestedList);

            int depth = 1;
            int total = 0;

            while (queue.Count > 0)
            {
                for (int i = 0; i < queue.Count; i++)
                {
                    NestedInteger nested = queue.Dequeue();
                    if (nested.IsInteger())
                    {
                        total += nested.GetInteger() * depth;
                    }
                    else
                    {
                        foreach (var n in nested.GetList())
                        {
                            queue.Enqueue(n);
                        }
                    }
                }
                depth++;
            }
            return(total);
        }
예제 #2
0
    public bool HasNext()
    {
        if (curr.Count != curri)
        {
            NestedInteger n = curr[curri];
            if (n.IsInteger())
            {
                return(true);
            }
            // Push nested list early
            q.Push(curr);
            qi.Push(++curri); /* record next starting iteration */
            curr  = n.GetList();
            curri = 0;
            return(HasNext());
        }

        if (q.Count != 0)
        {
            curr  = q.Pop();
            curri = qi.Pop();
            return(HasNext());
        }

        return(false);
    }
        public void NestedIterator_2()
        {
            var input3 = new NestedInteger();

            input3.Add(new NestedInteger(6));
            var input2 = new NestedInteger();

            input2.Add(new NestedInteger(4));
            input2.Add(input3);
            var input1 = new NestedInteger(1);


            var solution = new _0341_FlattenNestedListIterator(new List <NestedInteger>()
            {
                input1, input2
            });

            Assert.IsTrue(solution.HasNext());
            Assert.AreEqual(1, solution.Next());
            Assert.IsTrue(solution.HasNext());
            Assert.AreEqual(4, solution.Next());
            Assert.IsTrue(solution.HasNext());
            Assert.AreEqual(6, solution.Next());
            Assert.IsFalse(solution.HasNext());
        }
예제 #4
0
    public NestedInteger Deserialize(string s)
    {
        NestedInteger ret = new NestedInteger();

        if (s == null || s.Length == 0)
        {
            return(ret);
        }
        if (s[0] != '[')
        {
            ret.SetInteger(int.Parse(s));
        }
        else if (s.Length > 2)
        {
            int start = 1, count = 0;
            for (int i = 1; i < s.Length; i++)
            {
                char c = s[i];
                if (count == 0 && (c == ',' || i == s.Length - 1))
                {
                    ret.Add(Deserialize(s.Substring(start, i - start)));
                    start = i + 1;
                }
                else if (c == '[')
                {
                    count++;
                }
                else if (c == ']')
                {
                    count--;
                }
            }
        }
        return(ret);
    }
예제 #5
0
        public void TestMethod1()
        {
            // [[1,1],2,[1,1]]
            List <NestedInteger> list = new List <NestedInteger>();
            NestedInteger        ni   = new NestedInteger();

            ni.Add(new NestedInteger(1));
            ni.Add(new NestedInteger(1));
            list.Add(ni);
            list.Add(new NestedInteger(2));
            ni = new NestedInteger();
            ni.Add(new NestedInteger(1));
            ni.Add(new NestedInteger(1));
            list.Add(ni);

            NestedIterator   nIterator = new NestedIterator(list);
            LinkedList <int> elements  = new LinkedList <int>();

            while (nIterator.HasNext())
            {
                elements.AddLast(nIterator.Next());
            }

            CollectionAssert.AreEquivalent(elements.ToArray(), new int[] { 1, 1, 2, 1, 1 });
        }
예제 #6
0
        private NestedInteger Recursive(string s, int curIndex, out int nextIndex)
        {
            nextIndex = curIndex + 1;

            var forReturn = new NestedInteger();
            var numTemp   = 0;

            for (int i = curIndex; i < s.Length; i++)
            {
                var curChar = s[i];
                switch (curChar)
                {
                case '[':
                    var r = Recursive(s, i + 1, out int ni);
                    if (r.GetList() == null)
                    {
                        forReturn.Add(r);
                    }
                    else
                    {
                        foreach (var item in r.GetList())
                        {
                            forReturn.Add(item);
                        }
                    }

                    i = ni - 1;
                    break;

                case ']':
                    nextIndex = i + 1;
                    return(forReturn);

                case ',':
                    if (numTemp != 0)
                    {
                        forReturn.Add(new NestedInteger(numTemp));
                        numTemp = 0;
                    }
                    break;

                case '-':
                    numTemp *= -1;
                    break;

                default:
                    numTemp = numTemp * 10 + int.Parse(curChar.ToString());
                    break;
                }
            }

            if (numTemp != 0)
            {
                forReturn.SetInteger(numTemp);
            }

            return(forReturn);
        }
        public void NestedIterator_3()
        {
            var input1 = new NestedInteger();

            var solution = new _0341_FlattenNestedListIterator(new List <NestedInteger>()
            {
                input1
            });

            Assert.IsFalse(solution.HasNext());
        }
예제 #8
0
 static void DFS(NestedInteger integer, int depth, ref int res)
 {
     if (integer.IsInteger())
     {
         res += integer.GetInteger() * depth;
         return;
     }
     foreach (var nestedInteger in integer.GetList())
     {
         DFS(nestedInteger, depth + 1, ref res);
     }
 }
예제 #9
0
 static void DFS(NestedInteger integer, int height, List <int[]> record, ref int maxHeight)
 {
     if (integer.IsInteger())
     {
         maxHeight = Math.Max(maxHeight, height);
         record.Add(new[] { integer.GetInteger(), height });
     }
     foreach (var nestedInteger in integer.GetList())
     {
         DFS(nestedInteger, height + 1, record, ref maxHeight);
     }
 }
예제 #10
0
            private void Dfs(NestedInteger ni)
            {
                if (ni.IsInteger())
                {
                    m_res.Add(ni.GetInteger());
                    return;
                }

                foreach (var item in ni.GetList())
                {
                    Dfs(item);
                }
            }
예제 #11
0
 private NestedInteger Dfs(object item, NestedInteger current)
 {
     if (item is int)
     {
         current.SetInteger((int)item);
         return(current);
     }
     foreach (var obj in (object[])item)
     {
         current.Add(Dfs(obj, new NestedInteger()));
     }
     return(current);
 }
예제 #12
0
 void AddNum(NestedInteger node)
 {
     if (node.IsInteger())
     {
         arr.Add(node.GetInteger());
     }
     else
     {
         foreach (var item in node.GetList())
         {
             AddNum(item);
         }
     }
 }
예제 #13
0
    public int Next()
    {
        if (curr.Count == curri)
        {
            throw new Exception("Invalid Next");
        }
        NestedInteger n = curr[curri++];

        if (!n.IsInteger())
        {
            throw new Exception("Invalid Next");
        }
        return(n.GetInteger());
    }
 private void DFS(NestedInteger nestedInteger)
 {
     if (nestedInteger.IsInteger())
     {
         nums.Add(nestedInteger.GetInteger());
     }
     else
     {
         foreach (var item in nestedInteger.GetList())
         {
             DFS(item);
         }
     }
 }
 public void dfs(NestedInteger node)
 {
     if (node.IsInteger())
     {
         queue.Enqueue(node.GetInteger());
     }
     else
     {
         foreach (var child in node.GetList())
         {
             dfs(child);
         }
     }
 }
예제 #16
0
 private void DFS(NestedInteger cur)
 {
     if (cur.IsInteger())
     {
         q.Enqueue(cur.GetInteger());
     }
     else
     {
         foreach (var item in cur.GetList())
         {
             DFS(item);
         }
     }
 }
예제 #17
0
 private void Helper(NestedInteger integer, Queue <int> previous)
 {
     if (integer.IsInteger())
     {
         previous.Enqueue(integer.GetInteger());
     }
     else
     {
         foreach (var item in integer.GetList())
         {
             Helper(item, previous);
         }
     }
 }
예제 #18
0
 private void Add(NestedInteger nestedInteger)
 {
     if (nestedInteger.IsInteger())
     {
         list.Add(nestedInteger.GetInteger());
     }
     else
     {
         foreach (var i in nestedInteger.GetList())
         {
             Add(i);
         }
     }
 }
            private void PopulateNext(NestedInteger nest)
            {
                if (nest.IsInteger())
                {
                    //_queue.Enqueue(nest.GetInteger());
                    return;
                }

                var list = nest.GetList();

                foreach (var n in list)
                {
                    PopulateNext(n);
                }
            }
예제 #20
0
 // Set this NestedInteger to hold a nested list and adds a nested integer to it.
 public void Add(NestedInteger ni)
 {
     number = null;
     if (list == null)
     {
         list = new List <NestedInteger>()
         {
             ni
         }
     }
     ;
     else
     {
         list.Add(ni);
     }
 }
예제 #21
0
    public NestedInteger Deserialize(string s)
    {
        var    stack    = new Stack <NestedInteger>();
        string tokenNum = "";

        foreach (char c in s)
        {
            if (c == '[')
            {
                stack.Push(new NestedInteger());
            }
            else if (c == ']')
            {
                if (tokenNum.Length > 0)
                {
                    stack.Peek().Add(new NestedInteger(Int32.Parse(tokenNum)));
                }
                NestedInteger ni = stack.Pop(); //本层list结束
                tokenNum = "";
                if (stack.Count > 0)            //栈内有更高层次的list
                {
                    stack.Peek().Add(ni);
                }
                else  //栈为空,遍历到字符串结尾
                {
                    return(ni);
                }
            }
            else if (c == ',')
            {
                if (tokenNum.Length > 0) //将数字加入到本层list中
                {
                    stack.Peek().Add(new NestedInteger(Int32.Parse(tokenNum)));
                }
                tokenNum = "";
            }
            else //number
            {
                tokenNum += c;
            }
        }
        if (tokenNum.Length > 0)//特殊case: 如果字符串只包含数字的情况
        {
            return(new NestedInteger(Int32.Parse(tokenNum)));
        }
        return(null);
    }
예제 #22
0
        public NestedInteger Deserialize(string s)
        {
            var parent = new NestedInteger();
            var stack  = new Stack <NestedInteger>();
            int?num    = null;
            int sign   = 1;

            foreach (char c in s)
            {
                if (c == '[')
                {
                    var list = new NestedInteger();
                    parent.Add(list);
                    stack.Push(parent);
                    parent = list;
                }
                else if (c == ']' || c == ',')
                {
                    if (num.HasValue)
                    {
                        parent.Add(new NestedInteger(num.Value * sign));
                        num  = null;
                        sign = 1;
                    }
                    if (c == ']')
                    {
                        parent = stack.Pop();
                    }
                }
                else if (c == '-')
                {
                    sign = -1;
                }
                else
                {
                    num ??= 0;
                    num = num * 10 + (c - '0');
                }
            }

            if (num.HasValue)
            {
                parent.Add(new NestedInteger(num.Value * sign));
            }
            return(parent.GetList()[0]);
        }
예제 #23
0
        //static void Main(string[] args)
        //{
        //    NestedInteger first = new NestedInteger()
        //    {
        //        List = new List<NestedInteger>()
        //        {
        //            new NestedInteger() { Number = 1 },
        //            new NestedInteger() { Number = 1 }
        //        }
        //    };

        //    NestedInteger second = new NestedInteger()
        //    {
        //        Number = 2
        //    };

        //    NestedInteger third = new NestedInteger()
        //    {
        //        List = new List<NestedInteger>()
        //        {
        //            new NestedInteger() { Number = 1 },
        //            new NestedInteger() { Number = 1 }
        //        }
        //    };

        //    List<NestedInteger> firstList = new List<NestedInteger>
        //    {
        //        first,
        //        second,
        //        third
        //    };

        //    Console.WriteLine($"sum:{ComputeNestedListSum(firstList)}\t expected:10");
        //    Console.WriteLine($"using recursion: sum:{ComputeNestedListSumRecursive(firstList)}\t expected:10");

        //    first = new NestedInteger() { Number = 1 };

        //    second = new NestedInteger()
        //    {
        //        List = new List<NestedInteger>()
        //        {
        //           new NestedInteger()
        //           {
        //                Number = 4
        //           },
        //           new NestedInteger()
        //           {
        //                List = new List<NestedInteger>()
        //                {
        //                    new NestedInteger()
        //                    {
        //                        Number = 6
        //                    }
        //                }
        //           }
        //        }
        //    };

        //    List<NestedInteger> secondList = new List<NestedInteger>
        //    {
        //        first,
        //        second
        //    };

        //    Console.WriteLine($"sum:{ComputeNestedListSum(secondList)}\t expected:27");
        //    Console.WriteLine($"using recursion: sum:{ComputeNestedListSumRecursive(secondList)}\t expected:27");

        //    Console.ReadKey();
        //}

        // Tx = O(n) {n: number of nested integers}
        // Sx = O(2n)
        // [[1,1],2,[1,1]] = 10
        // [1,[4,[6]]] = 27
        public static int ComputeNestedListSum(List <NestedInteger> list)
        {
            if (list == null)
            {
                throw new ArgumentNullException(nameof(list));
            }
            else if (list.Count == 0)
            {
                return(0);
            }

            int depth = 1, sum = 0;

            Queue <NestedInteger> nestedIntegers = new Queue <NestedInteger>();

            foreach (var ni in list)
            {
                nestedIntegers.Enqueue(ni);
            }

            while (nestedIntegers.Count > 0)
            {
                int size = nestedIntegers.Count;

                for (int index = 0; index < size; index++)
                {
                    NestedInteger nestedInteger = nestedIntegers.Dequeue();

                    if (nestedInteger.List != null)
                    {
                        foreach (var ni in nestedInteger.List)
                        {
                            nestedIntegers.Enqueue(ni);
                        }
                    }
                    else
                    {
                        sum += nestedInteger.Number * depth;
                    }
                }

                depth++;
            }

            return(sum);
        }
예제 #24
0
            private List <int> Parse(NestedInteger nested)
            {
                var values = new List <int>();

                if (nested.IsInteger())
                {
                    values.Add(nested.GetInteger());
                }

                if (nested.GetList() != null)
                {
                    var listItems = nested.GetList().SelectMany(Parse);
                    values.AddRange(listItems);
                }

                return(values);
            }
예제 #25
0
        private int SumNestedInteger(NestedInteger ni, int depth)
        {
            if (ni.IsInteger())
            {
                return(ni.GetInteger().Value *depth);
            }
            else
            {
                var sum = 0;
                foreach (var item in ni.GetList())
                {
                    sum += SumNestedInteger(item, depth + 1);
                }

                return(sum);
            }
        }
예제 #26
0
        public NestedInteger DeserializeImpl()
        {
            var  ni         = new NestedInteger();
            int  num        = 0;
            bool isNegative = false;

            while (index < charArray.Length - 1)
            {
                index++;
                var c = charArray[index];
                if (c == '[')
                {
                    ni.Add(DeserializeImpl());
                }
                else if (c == ']')
                {
                    return(ni);
                }
                else if (c == ',')
                {
                    continue;
                }
                else if (c == '-')
                {
                    isNegative = true;
                }
                else
                {
                    num = 10 * num + (c - '0');
                    if (!char.IsDigit(charArray[index + 1]))
                    {
                        if (isNegative)
                        {
                            num = -num;
                        }

                        ni.Add(new NestedInteger(num));
                        num        = 0;
                        isNegative = false;
                    }
                }
            }

            return(null);
        }
예제 #27
0
        private int GetSum(NestedInteger nestedInteger, int level)
        {
            int result = 0;

            if (nestedInteger.IsInteger())
            {
                return(nestedInteger.GetInteger() * level);
            }
            else
            {
                foreach (var item in nestedInteger.GetList())
                {
                    result += GetSum(item, level + 1);
                }
            }

            return(result);
        }
예제 #28
0
 public bool HasNext()
 {
     while (stack.Count > 0)
     {
         NestedInteger t = stack.Peek();
         if (t.IsInteger())
         {
             return(true);
         }
         stack.Pop();
         list = t.GetList();
         for (int i = list.Count - 1; i >= 0; --i)
         {
             stack.Push(list[i]);
         }
     }
     return(false);
 }
예제 #29
0
        public void TestMethod2()
        {
            List <NestedInteger> list = new List <NestedInteger>();
            NestedInteger        ni   = new NestedInteger(1);

            list.Add(ni);
            ni = new NestedInteger();
            ni.Add(new NestedInteger(4));
            var ni2 = new NestedInteger();

            ni2.Add(new NestedInteger(6));
            ni.Add(ni2);
            list.Add(ni);
            Solution s      = new Solution();
            var      result = s.DepthSumInverse(list);

            Assert.AreEqual(result, 17);
        }
예제 #30
0
        private int GetSum(NestedInteger nestedList, int weight)
        {
            int sum = 0;

            if (nestedList.IsInteger())
            {
                sum += nestedList.GetInteger() * weight;
            }
            else
            {
                foreach (var item in nestedList.GetList())
                {
                    sum += GetSum(item, weight + 1);
                }
            }

            return(sum);
        }