Summing special object array of ints and objects

user_19272101 0
Viewed 32

I have a List<object> which can contain either an integer value or another List<object>.

What I need to do, is to sum the values in the array, depending on its depth(If depth is 0, multiply by 0, if 1 then by 1 ... etc.)

Example array: [5, 2, [7, -1], 3, [6, [-13, 8], 4]] How it should be calculated: 5 + 2 + 2 * (7 - 1) + 3 + 2 * (6 + 3 * (-13 + 8) + 4) = 12

What I managed to get:

public class Program
{
    public static List<object> TestCase1()
    {
        List<object> test = new List<object>(){
            5,
            2,
            new List<object>(){
                7, -1
            },
            3,
            new List<object>(){
                6,
                new List<object>(){
                    -13, 8
                },
                4,
            },
        };
        return test;
    }

    public static int ProductSum(List<object> array)
    {
        int depthCounter = 1;
        int totalSum = 0;
        int tempSum = 0;
        for (int i = 0; i < array.Count; i++)
        {
            if (array[i] is IList<object>)
            {
                totalSum += tempSum * depthCounter;
                tempSum = 0;
                depthCounter++;
            }
            else
            {
                tempSum += (int)array[i];
            }
        }
        return totalSum;
    }
    static void Main(string[] args)
    {
        Console.WriteLine("Result = " + ProductSum(TestCase1()));
    }
}

The result from my code is

The problem that I have, is I don't see a way, that I could iterate through an array to calculate it ... Maybe there is a way to sort an array of objects in some way to simplify it?

c#
2 Answers

The method should call itself ("recursive"), when it encounters a nested list. It should also take a depth parameter, keeping track of the depth. Every time you call the function recursively, you pass depth + 1 as the new depth. Whenever you count something, you multiply by depth.

public static int ProductSum(List<object> list) => ProductSum(list, 1);

public static int ProductSum(List<object> list, int depth)
{
    var sum = 0;
    foreach (var thing in list) {
        if (thing is List<object> innerList) {
            sum += ProductSum(innerList, depth + 1) * depth;
        } else if (thing is int x) {
            sum += x * depth;
        }
    }
    return sum;
}
user_51335850

You should do it recusively:

    public static int ProductSum(List<object> array, int depthCounter)
    {
        int totalSum = 0;
        
        for (int i = 0; i < array.Count; i++)
        {
            if (array[i] is List<object>)
            {
                totalSum += ProductSum(array[i] as List<Object>, depthCounter + 1);
                
            }
            else
            {
                totalSum += (int)array[i] * depthCounter;
            }
        }
        return totalSum;
    }

You call it this way:

ProductSum(TestCase1(), 0);

But I don't get the number you calculated, though: If all depth 0 candidates are multiplied by 0, these are... 0! ;) Maybe there are some rules for your application that I don't know, and that's the reason why the calculations differ, but in the code you see how recursions work.

user_194773690
Related