tablica pętle

Witam, jak zpisać warunek, żeby "[" wyświetlało się przed ostatnim zwróconym wyrazem?

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

        }
        static void Main(string[] args)
        {
            int[] tab = { 1, 2, 3, 4, 5 };
            Console.WriteLine(ZwrocPodzielne(tab,2,0));
            Console.ReadKey();
        }

W drugim kodzie mam pytanie jak zwiększać ilość elementów tablicy: tabx, tak aby się równała ilości liczb ujemnych z tablicy: tab

static double[] Ujemne(double[] tab)
        {
            int x=0;
            double[] tabx = new double[x];
            for (int i = 0; i < tab.Length; i++)
            {
                if (tab[i] <0)
                {

                    x++;                    
                    
                    tabx[x] = tab[i];
                    
                }
            }

            return tabx;
        }

Dziękuje z góry za odpowiedź.

1. Warunek z i == tab.Length - 1.
2. Lepiej zaalokować z góry rozmiar, albo obliczyć ile masz elementów i na koniec dokonać kopii. Jeśli bardzo chcesz to zrobić po swojemu to Array.Resize(ref tabx, x);

chodzi mi o fragment

return (x == 1 ? "[" : ",") + tab[i] + tekst;

przy wywołaniu funkcji występuje [,7] a oczekuje [7]. Jaką wprowadzić poprawkę?

static string ZwrocNieparzyste1(int[] tab, int i = 0)
        {
            
            if (tab.Length == 0)
            {
                return "[]";
            }
            if (i == tab.Length)
            {
                return "]";
            }
            
            string tekst = ZwrocNieparzyste1(tab, i + 1);
            int x = tab.Length - i;
           
            if (tab[i] % 2 == 0)
            {
               
                  return (x == tab.Length ? "[" : "") + tekst;
            }
 
            return (x == tab.Length ? "[":  ",") + tab[i] + tekst ;
            
        }
        static void Main(string[] args)
        {
            int[] tab = {2,7,6};
            Console.WriteLine(ZwrocNieparzyste1(tab,0));
            Console.ReadKey();
        }

Po pierwsze, sprawdzanie dla ostatniego elementu nie zadziała, bo przed sprawdzeniem czy jest nieparzysta, jest return.
A po drugie możesz np. przy ostatnim sprawdzeniu czyli x == tab.length zamienić(w sensie zrobić replace, nie zamienić w kodzie) "[," na "[". Zawsze będziesz musiał uciąć przecinek, czy z przodu, czy z tyłu, bo nie wiesz które sprawdzenie będzie ostatnim.

Soul_hunter_16 napisał(a):

Zawsze będziesz musiał uciąć przecinek, czy z przodu, czy z tyłu, bo nie wiesz które sprawdzenie będzie ostatnim.

Jak nie doda na wyrost, to nie będzie musiał ucinać. I jak to nie wie, które sprawdzenie jest ostatnie, skoro ma licznik i zna rozmiar tablicy?

@Adam Mąka: napisz sobie po kolei:

1. Funkcję, która rekurencyjnie przetworzy tablicę na string, bez żadnych warunków, czyli dla wejścia int[] tab = { 2, 7, 6, 5, 3, 8, 1 } dostaniesz w wyniku 2765381.
2. Potem dodaj do niej przecinki, tak aby w wyniku było: 2,7,6,5,3,8,1.
3. Potem nawiasy klamrowe, czyli wynikiem będzie: [2,7,6,5,3,8,1].
4. Na końcu dopiero sprawdzanie parzystości, tak aby efektem było: [7,5,3,1].

Mała podpowiedź - znaków [, ] czy , nie ma sensu używać w funkcji więcej niż raz. Podobnie jak nie ma sensu więcej niż raz sprawdzać długość tablicy.

Oddzieliłbym logikę filtrowania liczb od ich formatowania do string:

public static string FormatAsString(IEnumerable<int> numbers)
{
    return $"[{string.Join(",", numbers)}]";
}

Polecam poczytać o LINQ, przydaje się bardzo do filtrowania kolekcji. To będzie na przykład dla ujemnych:

public static int[] GetNegatives(IEnumerable<int> numbers)
{
    return numbers
        .Where(i => i < 0)  // tu jest wspomniane LINQ
        .ToArray();
}

I w Main możesz użyć:

        int[] tab = { 1, 2, 3, 4, 5 };
        var negatives = GetNegatives(tab);
        var formatted = FormatAsString(negatives);
        Console.WriteLine(formatted);
        Console.ReadKey();

EDYCJA:
Działająca wersja rekurencyjna:

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

EDYCJA 2:
Wersja bez Substring

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

@somekind: W kontekście jego programu i jego sposobu, czyli doklejając przecinek czy to z przodu, czy to z tyłu "trafionej" liczby, nie będzie wiedział dodatkowo tego nie sprawdzając, czy znaleziona jest ostatnią znalezioną lub pierwszą(czyli musi przeiterować po wszystkich elementach), bo może to być ostatni indeks tablicy, pierwszy, a może ostatnia nieparzysta być w środku tablicy. Dlatego doklejając do każdej jakiś zostanie. Więc bez dodatkowego sprawdzenia nie sprawdzi, czy liczba przecinków się zgadza. O to mi chodziło.

Soul_hunter_16 napisał(a):

@somekind: W kontekście jego programu i jego sposobu, czyli doklejając przecinek czy to z przodu, czy to z tyłu "trafionej" liczby, nie będzie wiedział dodatkowo tego nie sprawdzając, czy znaleziona jest ostatnią znalezioną lub pierwszą(czyli musi przeiterować po wszystkich elementach), bo może to być ostatni indeks tablicy, pierwszy, a może ostatnia nieparzysta być w środku tablicy. Dlatego doklejając do każdej jakiś zostanie. Więc bez dodatkowego sprawdzenia nie sprawdzi, czy liczba przecinków się zgadza. O to mi chodziło.

Dlatego lepiej przecinek doklejać przed daną liczbą, a nie po.

"]" -> "4]" -> "2,4]" -> "[2,4]"

zamiast

"]" -> ",4]" -> ",2,4]" -> ??? (trzeba ciąć)

Wtedy rzeczywiście dana iteracja "nie wie", czy ma wstawić przecinek, czy nie.

Soul_hunter_16 napisał(a):

@somekind: W kontekście jego programu i jego sposobu, czyli doklejając przecinek czy to z przodu, czy to z tyłu "trafionej" liczby, nie będzie wiedział dodatkowo tego nie sprawdzając, czy znaleziona jest ostatnią znalezioną lub pierwszą(czyli musi przeiterować po wszystkich elementach), bo może to być ostatni indeks tablicy, pierwszy, a może ostatnia nieparzysta być w środku tablicy. Dlatego doklejając do każdej jakiś zostanie. Więc bez dodatkowego sprawdzenia nie sprawdzi, czy liczba przecinków się zgadza. O to mi chodziło.

A zatem lepiej nie doklejać do każdej, tylko do każdej oprócz ostatniej - a to można w miarę łatwo wykryć, i nie wymaga to żadnego iterowania. (Iterowanie w ogóle byłoby kuriozalne w zadaniu z rekurencji. ;))

maszrum napisał(a):

Dlatego lepiej przecinek doklejać przed daną liczbą, a nie po.

Kopiuj

"]" -> "4]" -> "2,4]" -> "[2,4]"

zamiast

Kopiuj

"]" -> ",4]" -> ",2,4]" -> ??? (trzeba ciąć)

Wtedy rzeczywiście dana iteracja "nie wie", czy ma wstawić przecinek, czy nie.

Wcale nie lepiej, bo wtedy trzeba pamiętać, żeby nie doklejać przed pierwszą. Ten sam problem.