Rekurencja, liczby podzielne przez n

Cześć, mam zadanko na rekurencję o treści: "Stwórz funkcję string ZwrocPodzielne(int[] tab, int n, int i=0) , która zwraca jedynie liczby podzielne przez n z tablicy, w postaci tekstowej wykorzystując rekurencję, w formacie bez spacji oraz znaku przejścia do nowej linii, zgodnie z kolejnością występowania, np.: [3,4,8,6]"
Napisałam taki kod:

static string ZwrocPodzielne(int[] tab, int n, int i = 0)
        {
            if (i == tab.Length)
            {
                if (i == 0)
                {
                    return "[]";
                }
                return "]";
            }
            if (tab.Length == 1)
            {
                if (tab[i] % n == 0)
                {
                    return "[" + tab[i] + "]";
                }
            }
            if (i == 0)
            {
                if (tab[i] % n == 0)
                {
                    return "[" + tab[i] + "," + ZwrocPodzielne(tab, n, i + 1);
                }
                return "[" + ZwrocPodzielne(tab, n, i + 1);

            }
            if (tab[i] % n == 0)
            {
                if (i == tab.Length - 1)
                {
                    return tab[i] + "]";
                }
                return tab[i] + "," + ZwrocPodzielne(tab, n, i + 1);
            }
            return ZwrocPodzielne(tab, n, i + 1);
        }

problem polega na tym, że w momencie gdy w tablicy jest tylko jedna liczba spełniająca warunek np. tablica to [3,4,5,6,7,2,3], a n=4 to wynik jest [4,] z przecinkiem na końcu zamiast [4]. Czy da się problem jakoś obejść bez tworzenia pomocniczej tablicy w której można byłoby umieścić tylko liczby spełniające warunek? Jakieś pomysły?

Da się to w ogóle zrobić? Mając jedną tablicę, wstawić czy nie przecinek, wymaga wiedzy jaka będzie następna cyfra.

Trzeba stworzyć "wewnętrzną" funkcję rekurencyjną, i "zewnętrzną" nierekurencyjną dokonującą ostatecznej kosmetyki. Inaczej to to straszna rzeźba w brązowym

Po prostu na końcu całej akcji przy i == 0 musisz usunąć przecinek, jeżeli występuje

static string ZwrocPodzielne(int[] tab, int n, int i = 0)
        {
            string val = (i == 0) ? "[" : "";
            if (tab.Count() == 0)
                return val + "]";
            if (i == tab.Count())
                return val + "]";  
            if(i == tab.Count()-1)
            {
                if(tab[i] % n == 0)
                {
                    return val + tab[i] + ZwrocPodzielne(tab, n, ++i);
                }
                else
                {
                    return val + ZwrocPodzielne(tab, n, ++i);
                }
            }
            if (i < tab.Count())
            {
                if (tab[i] % n == 0)
                {
                    return (i == 0) ? UsunOstatniPrzecinek(val + tab[i] + "," + ZwrocPodzielne(tab, n, ++i)) : (val + tab[i] + "," + ZwrocPodzielne(tab, n, ++i));
                }
                else
                {
                    return (i == 0) ? UsunOstatniPrzecinek(val + ZwrocPodzielne(tab, n, ++i)) : (val + ZwrocPodzielne(tab, n, ++i));
                }
            }
            return val;
        }
        static string UsunOstatniPrzecinek(string s)
        {
            if (s[s.Count() - 2] == ',')
                return s.Substring(0, s.Count() - 2) + "]";
            else
                return s;
        }

Tak na wstępie to poprawną odpowiedzią jest, że w sytuacji, gdy przebieg można zrobić liniowo to nie należy stosować rekurencji. Ale zakładając, że zlecający wiedział o tym i dał zadanie tylko dla ćwiczenia, to zrobiłbym to tak:

        static string ZwrocPodzielne(int[] tab, int n, int i = 0)
        {
            string result = "";
            if (i < 0)
            {
                result = ZwrocPodzielne(tab, n);
            }
            else
            {
                if (n != 0  && i < tab.Length)
                {
                    if (i < tab.Length - 1)
                    {
                        result = ZwrocPodzielne(tab, n, i + 1);
                    }
                    if (tab[i] % n == 0)
                    {
                        if (result.Length > 0)
                        {
                            result = tab[i].ToString() + "," + result;
                        }
                        else
                        {
                            result = tab[i].ToString();
                        }
                    }
                }
                if (i == 0)
                {
                    result = "[" + result + "]";
                }
            }
            return result;
        }

Ten przecinek na końcu olej . Z tego się nie strzela ;)

using System;


namespace ConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] liczby = { 2, 4, 7, 11, 27, 30, 45, 90, 125, 543, 1000 };
            Console.WriteLine(ZwrocPodzielne(liczby, 5));
        }

        static string ZwrocPodzielne(int[] tab, int n, int i = 0)
        {
            string liczbyPodzielne = string.Empty;

            if (tab.Length > i && tab[i] % n == 0)
            
                return liczbyPodzielne += tab[i] + ", " + ZwrocPodzielne(tab, n, ++i).ToString();
     
            else if (tab.Length > i)
           
                return ZwrocPodzielne(tab, n, ++i);
            else
                return liczbyPodzielne ;              
            
        }
    }
}