Longest sub-sequence of a binary string divisible by 3

using System;

namespace DivisibleByThree
{
    class Program
    {
        // Function to check if a binary string is divisible by 3
        static bool IsDivisibleBy3(string s)
        {
            int n = s.Length;
            int num = 0;
            
            // Converting binary string to integer representation
            foreach (char c in s)
            {
                num = num * 2 + (c - '0');
            }
            
            // Checking if the number is divisible by 3
            return (num % 3 == 0);
        }

        // Function to find the length of the longest substring whose binary 
        // representation is divisible by 3
        static int Longest(string s)
        {
            int n = s.Length;
            int maxLen = 0;
            
            // Generating all possible substrings and checking if they are divisible by 3
            for (int i = 0; i < (1 << n); i++)
            {
                string sub = "";
                
                // Generating substring based on the current bitmask
                for (int j = 0; j < n; j++)
                {
                    if (((i >> j) & 1) == 1)
                    {
                        sub += s[j];
                    }
                }
                
                // Checking if the generated substring is divisible by 3 and updating maxLen
                if (IsDivisibleBy3(sub))
                {
                    maxLen = Math.Max(maxLen, sub.Length);
                }
            }
            
            // Returning the length of the longest substring divisible by 3
            return maxLen;
        }

        static void Main(string[] args)
        {
            string s1 = "101";
            
            // Finding and displaying the length of the longest substring divisible by 3
            Console.WriteLine(Longest(s1));
        }
    }
}

// C# implementation of the approach 
using System;
using System.Collections.Generic;

class GFG 
{

    readonly static int N = 100 ;
    readonly static int INT_MIN = int.MinValue;
    
    static int [,]dp = new int[N, 3]; 
    static int [,]v = new int[N, 3]; 
    
    // Function to return the length of the 
    // largest sub-string divisible by 3 
    static int findLargestString(String s, int i, int r) 
    { 
        // Base-case 
        if (i == s.Length)
        { 
            if (r == 0) 
                return 0; 
            else
                return INT_MIN; 
        } 
    
        // If the state has been solved 
        // before then return its value 
        if (v[i, r] == 1) 
            return dp[i, r]; 
    
        // Marking the state as solved 
        v[i, r] = 1; 
    
        // Recurrence relation 
        dp[i, r] = Math.Max(1 + findLargestString(s, i + 1, 
                                (r * 2 + (s[i] - '0')) % 3), 
                            findLargestString(s, i + 1, r)); 
        return dp[i, r];
    }
    
    // Driver code 
    public static void Main(String[] args) 
    { 
        String s = "101"; 
    
        Console.Write(findLargestString(s, 0, 0)); 
    } 
}

// This code is contributed by 29AjayKumar