A string is a valid parentheses string (denoted VPS) if it meets one of the following:


	It is an empty string "", or a single character not equal to "(" or ")",
	It can be written as AB (A concatenated with B), where A and B are VPS's, or
	It can be written as (A), where A is a VPS.


We can similarly define the nesting depth depth(S) of any VPS S as follows:


	depth("") = 0
	depth(C) = 0, where C is a string with a single character not equal to "(" or ")".
	depth(A + B) = max(depth(A), depth(B)), where A and B are VPS's.
	depth("(" + A + ")") = 1 + depth(A), where A is a VPS.


For example, "", "()()", and "()(()())" are VPS's (with nesting depths 0, 1, and 2), and ")(" and "(()" are not VPS's.

Given a VPS represented as string s, return the nesting depth of s.

&nbsp;
Example 1:

Input: s = "(1+(2*3)+((8)/4))+1"
Output: 3
Explanation: Digit 8 is inside of 3 nested parentheses in the string.


Example 2:

Input: s = "(1)+((2))+(((3)))"
Output: 3


&nbsp;
Constraints:


	1 &lt;= s.length &lt;= 100
	s consists of digits 0-9 and characters '+', '-', '*', '/', '(', and ')'.
	It is guaranteed that parentheses expression s is a VPS.


class Solution:
    def maxDepth(self, s: str) -> int:
        ans = cur = 0
        for c in s:
            if c == '(':
                cur += 1
                ans = max(ans, cur)
            elif c == ')':
                cur -= 1
        return ans 
class Solution {
    public int maxDepth(String s) {
        int count = 0;   //count current dept of "()"
        int max = 0;     //count max dept of "()"

        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                count++;
            } else if (s.charAt(i) == ')') {
                count--;
            }
            max = Math.max(count, max);
        }
        return max;
    }
}
class Solution {
public:
    int maxDepth(string s) {
        int maxi=0,curr=0;
        for(int i=0;i<s.size();i++){
            if(s[i]=='('){
                maxi=max(maxi,++curr);
            }else if(s[i]==')'){
                curr--;
            }
        }
        return maxi;
    }
};
var maxDepth = function(s) {
    let maxCount = 0, count = 0;
    for (let i = 0; i < s.length; i++) {
        if (s[i] === '(') {
            maxCount = Math.max(maxCount, ++count);
        } else if (s[i] === ')') {
            count--;
        }
    }
    return maxCount;
};
Maximum Nesting Depth of the Parentheses