Сформировать одномерный массив целых чисел, удалить из массива все элементы совпадающие с минимальным значением...

static void Main(string[] args)
        {
            // Заполнение массива случайными числами
            int[] a = new int[10];
            Random r = new Random();
            for (int i = 0; i < a.Length; i++)
            {
                a[i] = r.Next(100);
            }
            // Нахождение минимального элемента
            int min = a[0];
            for (int i = 0; i < 100; i++)
            {
                if (a[i] < min)
                {
                    min = a[i];
                }
            }
            // Удаление всех элементов массива равных минимальному
                for (int k = 0; k < 100; k++)
                {
                    if (a[k] == min)
                    {
                        for (int j = k; j < 100; j++)
                        {
                            a[j] = a[j + 1];
                        }
                    }
               }
           }

List<int> list = new List<int>(a);
list.RemoveAll(delegate(int element) { return min == element; });
/*Более понятный для тебя вариант
            int k = 0;
            while ( k < list.Count)
            {
                if (list[k] == min)
                {
                    list.RemoveAt(k);
                    continue;
                }
                k++;
            }
            */

int sum = 0;
            for (int i = 0; i < list.Count; i++)
            {
                sum += list[i];
            }
            sum /= list.Count;
            for (int i = 0; i < 3; i++)
            {
                list.Insert(0, sum);
            }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace ConsoleApplication3
{
    
    class Program
    {
        //Процедура вывода массива на экран
        static void Print(int[] Array)
        {
            Console.WriteLine("Массив:");
            foreach (int i in Array)
                Console.Write(i + " ");
 
            Console.WriteLine();
        }
        
        //Функция возвращает минимум в массиве
        static int FindMin(int[] Array)
        {
            int min = Array[0];
            for (int i = 0; i < Array.Length; i++)
                if (Array[i] < min)
                    min = Array[i];
 
            return min;
        }
 
        //Функция возвращает массив без минимума
        static int[] DeleteMin(int[] Array, int Min)
        {
            int[] temp = new int[Array.Length];
            int i = 0;
            int j = 0;
            int count = 0;
 
            //В локальный массив temp записываем все элементы исходного массива, кроме минимального
            for (i = 0; i < Array.Length; i++)
            {
                if (Array[i] != Min)
                {
                    temp[j] = Array[i];
                    j++;
                }
            }
            //Убираем лишние нули
            int[] temp2 = new int[Array.Length - (i - j)];
            foreach (int k in temp)
                if (k != 0)
                {
                    temp2[count] = k;
                    count++;
                }
 
            return temp2;
 
        }
 
        //Функция возвращает среднее арифметическое
        static int SredneeArifm(int[] Array)
        {
            int sum = 0;
            foreach (int i in Array)
                sum = sum + i;
 
            return sum / Array.Length;
        }
 
        //Функция возвращает массив с добавленными 3мя элементами в начале
        static int[] AddElem(int[] Array, int Srednee)
        {
            int[] temp = new int[Array.Length + 3];
            for (int i = 0; i < 3; i++)
            {
                temp[i] = Srednee;
            }
            for (int i = 3, j = 0; j < Array.Length; i++,j++)
            {
                temp[i] = Array[j];
            }
 
            return temp;
        }
 
        static void Main(string[] args)
        {
            int[] MyArray = new int[10];
            Random r1 = new Random();
            int Min = 0;
            int Srednee = 0;
 
            for (int i = 0; i < MyArray.Length; i++)
                MyArray[i] = r1.Next(1, 200);
 
            Print(MyArray);
            Min = FindMin(MyArray);
            Console.WriteLine("Min = {0}", Min);
            Print(DeleteMin(MyArray,Min));
            Srednee = SredneeArifm(MyArray);
            Console.WriteLine("Srednee = {0}", Srednee);
            MyArray = AddElem(MyArray, Srednee);
            Print(MyArray);
 
 
            Console.ReadKey(true);
        }
    }
}

var abc = (new[] {1, 2, 3, 4, 1, 5, 7}).ToList();
var min = abc.Min();
abc.RemoveAll(e => e == min);
var average = abc.Sum()/abc.Count;
abc.InsertRange(0, new int[] { average, average, average});

namespace Codeforces.Div2._181
{
    internal class Prog
    {
        private static void Main()
        {
            //мы создаем целочисленный массив, но кастим его к double
            //(это совсем не противоречит условию задачи)
            //т.к. avg - это точно не целое число
            double[] a = ArrayHelper.GenArray(10, -1, 10, input => (double)input);
            //Печатаем исходный массив
            ArrayHelper.PrintArray(a, Console.Out);
            Resolve(ref a);
            ArrayHelper.PrintArray(a, Console.Out);
            Console.ReadKey();
        }
 
        private static void Resolve(ref double[] a)
        {
            //находим индекс минимального элемента
            int minIdx = MinIndex(a);
            //Все удаляемые элементы просто переместим в начало массива
            //и вернем кол-во удаленных элементов
            int count = RemoveMinItems(a, minIdx);
            double avg = Avg(a, count);
            // если количество удаленных элементов равно 
            //кол-ву добавляемых элементов, то дополнительная память вообще не нужна
            if (count == 3)
            {
                a[0] = a[1] = a[2] = avg;
            }
            else
            {
                double[] t = new double[a.Length - count + 3];
                Array.Copy(a, count, t, 3, a.Length - count);
                t[0] = t[1] = t[2] = avg;
                a = t;
            }
        }
 
        public static int RemoveMinItems(double[] a, int min)
        {
            double t = a[min]; 
            //поместим сразу же минимальный элемент в первую позицию
            //это позволит использовать его как сигнальный элемент
            //и уже в дальнейшем не потребуется проверять границы массива
            //во вложенном цикле while, это улучшит примерно в два раза быстродействие 
            for (int i = min; i > 0; --i)
                a[i] = a[i - 1];
            a[0] = t;
            //один минимум у нас есть точно
            int count = 1;
            //перемещаем все удаляемые элементы в начало массива
            //вложенный цикл на самом деле очень короткий
            //и сложность этого алгоритма O(n), могу доказать формально
            for (int i = 2; i < a.Length; ++i)
            {
                if (a[i] != t) continue;
                ++count;
                int j = i;
                while (a[j - 1] > t)
                {
                    a[j] = a[j - 1];
                    --j;
                }
                a[j] = t;
            }
            return count;
        }
 
        private static double Avg(double[] a, int start)
        {
            double s = 0;
            int n = a.Length - start;
            for (int i = start; i < a.Length; ++i)
                s += a[i];
            return s/n;
        }
 
        private static int MinIndex(double[] a)
        {
            int min = 0;
            for (int i = 1; i < a.Length; ++i)
                if (a[i] < a[min]) min = i;
            return min;
        }
    }
 
    public static class ArrayHelper
    {
        public static T[] GenArray<T>(int count, int min, int max, Converter<int, T> converter) where T : struct 
        {
            Random r = new Random((int) DateTime.Now.Ticks & 0x0000FFFF);
            T[] a = new T[count];
            for (int i = 0; i < a.Length; ++i)
                a[i] = converter(r.Next(min, max));
            return a;
        }
 
        public static bool IsSorted<T>(T[] a) where T : IComparable
        {
            for (int i = 0; i < a.Length - 1; ++i)
            {
                if (a[i].CompareTo(a[i + 1]) > 0)
                    return false;
            }
            return true;
        }
 
        public static void PrintArray<T>(T[] a, TextWriter writer)
        {
            writer.WriteLine(string.Join(" ", a));
        }
    }
 
}

private static void Main()
        {
            var a = new[] {1, 2, 3, 4, 1, 5, 7}.Select(i=>(double)i); //ArrayHelper.GenArray(10, -1, 10, input => (double) input);
            Console.WriteLine(string.Join(" ", Enumerable.Repeat(((a =(from t in a let min = a.Min() where t != min select t).ToArray())).Average(), 3).Concat(a)).ToArray());
            Console.ReadKey();
        }

[__DynamicallyInvokable]
public int RemoveAll(Predicate<T> match)
{
    if (match == null)
    {
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
    }
    int index = 0;
    while ((index < this._size) && !match(this._items[index]))
    {
        index++;
    }
    if (index >= this._size)
    {
        return 0;
    }
    int num2 = index + 1;
    while (num2 < this._size)
    {
        while ((num2 < this._size) && match(this._items[num2]))
        {
            num2++;
        }
        if (num2 < this._size)
        {
            this._items[index++] = this._items[num2++];
        }
    }
    Array.Clear(this._items, index, this._size - index);
    int num3 = this._size - index;
    this._size = index;
    this._version++;
    return num3;
}