using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    internal class BaseSimpleNumbersCalculator
    {
        public static int[] GetSimpleNumbers(int n)
        {
            int[] numbers = Enumerable.Range(2, (int)Math.Sqrt(n)-1).ToArray();

            Array.ForEach(numbers.Select((value, i) => (value, i)).ToArray(), p => {
                if (p.value != 0)
                {
                    Array.ForEach(numbers.Skip(p.i + 1).Select((value, i) => (value, i)).ToArray(), x =>
                    {
                        if (x.value % p.value == 0)
                        {
                            numbers[x.i + p.i + 1] = 0;
                        }
                    });
                }
            }) ;

            return numbers.Where(value => value != 0).ToArray();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    internal class SimpleNumbersCalculatorBaseParallel
    {
        static Stopwatch sw = new Stopwatch();
        public static float Calculate(int n, int m)
        {
            int[] baseNumbers = BaseSimpleNumbersCalculator.GetSimpleNumbers(n);
            int[] numbers = Enumerable.Range((int)Math.Sqrt(n), n - (int)Math.Sqrt(n)).ToArray();

            int numbersCount = baseNumbers.Length;

            List<Task> tasks = new List<Task>();

            sw.Reset();

            sw.Start();

            for (int i = 0; i < m; i++)
            {
                int start = i * (numbersCount / m);
                int end = (i + 1) * (numbersCount / m);
                if (i == m - 1)
                {
                    end += numbersCount % m;
                }
                tasks.Add(ProcessAsync(start, end, baseNumbers, numbers));
            }

            Task.WhenAll(tasks).Wait();

            sw.Stop();

            return (float)sw.Elapsed.TotalMilliseconds;
        }
        static async Task ProcessAsync(int start, int end, int[] baseNumbers, int[] numbers)
        {
            await Task.Run(() =>
            {
                Array.ForEach(baseNumbers.Select((value, i) => (value, i)).Where(x => x.i >= start && x.i < end).ToArray(), p => {
                    Array.ForEach(numbers.Select((value, i) => (value, i)).ToArray(),
                        x => { if (x.value != 0 && x.value % p.value == 0) numbers[x.i] = 0; });
                });

            });
        }
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    internal class SimpleNumbersCalculatorDataParallel
    {
        static Stopwatch sw = new Stopwatch();
        public static float Calculate(int n, int m)
        {
            int[] baseNumbers = BaseSimpleNumbersCalculator.GetSimpleNumbers(n);
            int[] numbers = Enumerable.Range((int)Math.Sqrt(n), n - (int)Math.Sqrt(n)).ToArray();

            int numbersCount = numbers.Length;

            List<Task> tasks = new List<Task>();

            sw.Reset();

            sw.Start();

            for (int i = 0; i < m; i++)
            {
                int start = i * (numbersCount / m);
                int end = (i + 1) * (numbersCount / m);
                if (i == m - 1)
                {
                    end += numbersCount % m;
                }
                tasks.Add(ProcessAsync(start, end, baseNumbers, numbers));
            }

            Task.WhenAll(tasks).Wait();

            sw.Stop();

            return (float)sw.Elapsed.TotalMilliseconds;
        }
        static async Task ProcessAsync(int start, int end, int[] baseNumbers, int[] numbers)
        {
            await Task.Run(() =>
            {
                Array.ForEach(baseNumbers, p => {
                    Array.ForEach(numbers.Select((value, i) => (value, i)).Where(x => x.i >= start && x.i < end).ToArray(),
                        x => { if (x.value != 0 && x.value % p == 0) numbers[x.i] = 0; });
                });

            });
        }
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    internal class SimpleNumbersCalculatorPluckParallel
    {
        static Stopwatch sw = new Stopwatch();

        static int currentIndex;
        public static float Calculate(int n, int m)
        {
            int[] baseNumbers = BaseSimpleNumbersCalculator.GetSimpleNumbers(n);
            int[] numbers = Enumerable.Range((int)Math.Sqrt(n), n - (int)Math.Sqrt(n)).ToArray();

            int numbersCount = numbers.Length;

            List<Task> tasks = new List<Task>();

            currentIndex = 0;

            sw.Reset();

            sw.Start();

            for (int i = 0; i < m; i++)
            {
                tasks.Add(ProcessAsync(baseNumbers, numbers));
            }

            Task.WhenAll(tasks).Wait();

            sw.Stop();

            return (float)sw.Elapsed.TotalMilliseconds;
        }
        static async Task ProcessAsync(int[] baseNumbers, int[] numbers)
        {
            await Task.Run(() =>
            {
                int b;

                while (true)
                {
                    lock (baseNumbers)
                    {
                        if (currentIndex < baseNumbers.Length)
                        {
                            b = baseNumbers[currentIndex];
                            currentIndex++;
                        }
                        else
                        {
                            return;
                        }

                    }

                    Array.ForEach(numbers.Select((value, i) => (value, i)).ToArray(), x => { if (x.value != 0 && x.value % b == 0) numbers[x.i] = 0; });
                }
            });
        }
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    internal class SimpleNumbersCalculatorPoolParallel
    {
        static Stopwatch sw = new Stopwatch();
        public static float Calculate(int n)
        {
            int[] baseNumbers = BaseSimpleNumbersCalculator.GetSimpleNumbers(n);
            int[] numbers = Enumerable.Range((int)Math.Sqrt(n), n - (int)Math.Sqrt(n)).ToArray();

            ManualResetEvent[] events = new ManualResetEvent[baseNumbers.Length];

            sw.Reset();

            sw.Start();

            for(int i = 0; i < baseNumbers.Length; i++)
            {
                events[i] = new ManualResetEvent(false);
                ThreadPool.QueueUserWorkItem(Run, (baseNumbers[i], numbers, events[i]));
            }

            WaitHandle.WaitAll(events);

            sw.Stop();

            return (float)sw.Elapsed.TotalMilliseconds;
        }
        static void Run(object o)
        {
            var parametrs = ((int, int[], ManualResetEvent))o;

            int b = parametrs.Item1;
            int[] numbers = parametrs.Item2;
            ManualResetEvent ev = parametrs.Item3;

            Array.ForEach(numbers.Select((value, i) => (value, i)).ToArray(),x => { if (x.value != 0 && x.value % b == 0) numbers[x.i] = 0; });

            ev.Set();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    internal static class SimpleNumbersСalculatorSeq
    {
        static Stopwatch sw = new Stopwatch();
        public static float Calculate(int n)
        {
            int[] baseNumbers = BaseSimpleNumbersCalculator.GetSimpleNumbers(n);
            int[] numbers = Enumerable.Range((int)Math.Sqrt(n), n - (int)Math.Sqrt(n)).ToArray();

            sw.Reset();

            sw.Start();

            Array.ForEach(baseNumbers, p => {
                Array.ForEach(numbers.Select((value, i) => (value, i)).ToArray(), x => { if (x.value != 0 && x.value % p == 0) numbers[x.i] = 0; });
            });

            sw.Stop();

            return (float)sw.Elapsed.TotalMilliseconds;
        }
    }
}