c#, tablice, pętle

Stwórz funkcję bool CzyDwieWTablicy(double[] T, double a) , która zwraca true, jeśli w tablicy T znajdują się dokładnie dwa wystąpienia liczby a (przesłanej jako argument funkcji) na nieparzystych indeksach tablicy. W przeciwnym wypadku funkcja zwraca false.
wymyśliłem coś takiego, ale oczywiście źle pokazuje:

static bool CzyDwieWTablicy(double[] T, double a)
        {
            for (int i = 0; i < T.Length; i++)
            {
                for (int j = 1; j < T.Length; j++)
                {
                    if (T[i] == a && T[i + j] == a)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

To nie jakiś skomplikowany task, zgodnie z opisem:

  static bool isTwoOnOddIndexes(double [] T, double a) {
      if (T.Length < 2) return false;
      int cnt = 0;
      for (int i = 1; i < T.Length; i += 2) {
          if (a == T[i]) {
            ++cnt;
            if (cnt > 1) return true;
          }
      }
      return false;
  }

        static bool CzyDwieWTablicy(double[] T, double a)
        {
            if (T.Length < 2) return false;
            uint count = 0;
            for (int i = 1; i < T.Length; i+=2)
            {
                if (T[i] == a) ++count;
            }
            return (count==2);
        }

Z delikatną optymalizacją (chociaż to czy to optymalizacja też zależy od przypadku, ale w generalnym rozrachunku raczej jest korzystna)

         static bool CzyDwieWTablicy(double[] T, double a)
        {
            uint count = 0;
            for (int i = 1; i < T.Length; i+=2)
            {
                if (T[i] == a)
                {
                    if (count > 1) return false;
                    ++count;
                }
            }
            return (count==2);
        }

        public bool HasExactElementCountAtOddIndexes<T>(IEnumerable<T> haystack, T needle, int desiredCount) where T : IComparable<T>
        {
            if (haystack == null)
                throw new ArgumentNullException(nameof(haystack));

            var enumerator = haystack.GetEnumerator();
            var counter = 0;
            var odd = false;

            while (enumerator.MoveNext())
            {
                if (odd = !odd) continue;

                if (enumerator.Current.CompareTo(needle) == 0)
                    counter++;
                if (counter > desiredCount)
                    return false;
            }

            return counter == desiredCount;
        }

Wersja minimalistyczna z LINQ:

        public bool HasExactElementCountAtOddIndexes<T>(IEnumerable<T> haystack, T needle, uint desiredCount) where T : IComparable<T>
            => haystack?.Where((e, i) => (i & 1) == 1).Count(e => e.CompareTo(needle) == 0) == desiredCount;