Counting the number of objects in an array with recursion - algorithm

Question

I have some problems with recursion and to understand it I'm trying to make up questions for myself and solve them. This particular question has gotten me confused:
consider this as an input in the form of a string:
[[a,b,c],[[d]],[[e,f]],[g],h,i,[[j,[k,l]]]]
the goal is to find the total number of things in the lists and the lists them self.for this example the result would be:12+10 = 22
note that the input is not an array,it is a string.Also instead of a,b,...
anything can be used,like numbers,strings etc.
[12345,0.34,["afv",24]]
This is my idea but I will mention why I cant implement it:
We write a function that starts iterating the string.It should count the total thing between [ and ].whenever the function reaches a [ it will recall itself to iterate through the remaining string.This way it can go deeper into the arrays.
These are my problems:
I don't know whether my idea is correct or not.
If my idea is correct,what is the base case.
How can I make sure that it counts all the things inside regardless of in what are they?(I mean how can I make sure it treats numbers,strings etc the same)
I think the body of the function should look like this(I'm using java here but I don't think the language is very important here):
public static int counter(String a){
int sum = 0;
//some code to iterate the string
//some code to check the conditions and if needed call the method
//some code to add the number of objects and arrays to sum
return sum;
}
If the code should like what I said then how can I fill the body?
Thank you for your time.

Answer 1

Depending how you design your recursive algorithm and size of input, you may run into the common problem of recursive stack overflow, where you have very deep recursion and run out of memory space
This is a different iterative pythonic solution if you do not have to use recursion but you should be able to transpose this to Java.
You want to increment you count for every item that is separated by commas. However, if that element has ']' characters, you know that it is a part of a embedded list. By counting the closing braces and the element, you can get the total.
Updated to handle strings with embedded commas
# Function for removing the chars between apostrophes
def remove(s,c):
while(s.find(c) != -1):
i = s.find(c) # find the first instance of c but ' or " in our case
i2 = s.find(c,i+1) # find the second instance
s = s[0:i]+s[i2+1:] # Remove the string
return s
return s
s = "[['a,b,c'],[1,2,3]]"
s = s[:-1] # remove the last list char
total = 0
s = remove(s,'\'')
s = remove(s,'"')
l = s.split(',')
for el in l:
total+=1
total+= el.count(']')
print(total)

Answer 2

Since you don't care about parsing the actual contents of the lists (for that you would implement a recursive descent parser), you can instead implement a simple state machine.
Here's a very rough, partial implementation in pseudo code just to give you some idea about how you might implement this. Ideally you would have more states to detect syntax errors:
int lists, elements = 0;
state = normal;
foreach (char c in input)
{
switch state
case normal:
if (c == '[')
lists++;
else if (c == ']')
// do nothing
else if (c == ',')
// do nothing (will only count [ and , on elements)
else if (c == '"')
elements++;
state = quoted_element
else
elements++;
state = element;
break;
case quoted_element:
if (c == '"')
state = element;
break;
case element:
if (c == '"' || c == '[')
exception("Syntax error");
else if (c == ",")
elements++;
else if (c == "]")
state = normal;
break;
}

Answer 3

Here's a recursion in JavaScript that might give you some ideas.
function f(s){
function nextIndexafterStr(i){
while (!(s[i] == "\"" && s[i-1] != "\\"))
i++;
return i + 1;
}
function nextIndexafterNum(i){
while (![",", "]"].includes(s[i]))
i++;
return i;
}
// Returns [numArrays, numElements, endIndex]
// Assumes valid input
function g(i, as, es){
// base case
if (s[i] == "]" || i == s.length)
return [as, es, i];
if (s[i] == ",")
return g(i + 1, as, es);
// a list
if (s[i] == "["){
const [aas, ees, endIndex] = g(i + 1, 0, 0);
return g(endIndex + 1, as + 1 + aas, es + ees);
}
// string element
if (s[i] == "\"")
return g(nextIndexafterStr(i + 1), as, es + 1);
// number or variable-name element
return g(nextIndexafterNum(i), as, es + 1);
}
const [as, es, _] = g(0, 0, 0);
return as + es;
}
var a = [12345,0.34,["af\"v",24]];
var b = "[[a,b,c],[[d]],[[e,f]],[g],h,i,[[j,[k,l]]]]";
a = JSON.stringify(a);
console.log(a);
console.log(f(a));
console.log(b);
console.log(f(b));