rekurencja

Stwórz rekurencyjną funkcję int MinimumRek(int[] T, int i=0), która zwraca indeks najmniejszego elementu w tablicy T.
zwraca mi 0.

    {
        static int MinimumRek(int[] T, int i = 0)
        {
            int rek = 0;
            if (i == T.Length)
            {
                return 0;
            }
          MinimumRek(T, i + 1);

            
            if (T[rek] > T[i])
            {
                rek++;
            }
            

            return rek;
        }
        static void Main(string[] args)
        {
            int[] T = { 3,5,2,1,4,5 };
            Console.WriteLine(MinimumRek(T));
            Console.ReadKey();
        }
    }

int rek = 0;

Przy każdym wywołaniu funkcji zerujesz iterator

W ogóle chyba nie tędy droga, czemu zwracać 0, przy stopie rekurencji? Ale można trochę "przycheatować", :-) stworzyć funkcję pomocniczą i ona załatwi minimalny indeks:

class MainClass {
  static int  minRek(int [] a, int i, int minimum, int indMin) {
      if (i == a.Length) {
        return indMin;
      }
      else {
        if (a[i] <= minimum) {
          indMin = i;
          minimum = a[i];
        }
      return minRek(a, i + 1, minimum, indMin);
      }
  }
  static int MinimumRek(int[] T, int i = 0){
      return minRek(T, i, int.MaxValue, 0);
  }
        static void Main(string[] args)
        {
            int[] T = { 3,5,-2,1,4,0 };
            Console.WriteLine(MinimumRek(T)); // -> 2
            
        }
}

W pythonie to byłoby jakoś tak:

def min_rek(T, idx = 0):
    if idx + 1 >= len(T):
        return idx
        
    imin = min_rek(T, idx + 1)
    if T[idx] < T[imin]:
        return idx
    return imin