Описать класс "Многочлен" и перегрузку операций для этого класса — сложения, умножения, вычитания

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ArbitraryPolynom
{
    public class Poly
    {
        public double[] Coeff { get; set; }
 
        public Poly(double[] coeff)
        {
            Coeff = coeff;
        }
 
        public Poly(Poly p1)
        {
            Coeff = new double[p1.Coeff.Length];
            for (int i = 0; i < Coeff.Length; i++)
                Coeff[i] = p1.Coeff[i];
        }
 
        public override string ToString()
        {
            string ans = "y = ";
            for (int i = Coeff.Length-1; i > 0; i--)
            {
                ans += String.Format("{0} (x{1})^{1} + ", Coeff[i], i);
            }
            ans += String.Format("{0};", Coeff[0]);
            return ans;
        }
 
        public static Poly operator +(Poly p1, Poly p2)
        {
            bool condition = p1.Coeff.Length <= p2.Coeff.Length;
            int loopCount = condition? p1.Coeff.Length : p2.Coeff.Length;
            Poly ans = new Poly(condition ? p2 : p1);
            if (condition)
            {
                for (int i = 0; i < loopCount; i++)
                    ans.Coeff[i] += p1.Coeff[i];
            }
            else
            {
                for (int i = 0; i < loopCount; i++)
                    ans.Coeff[i] += p2.Coeff[i];
            }
            return ans;
        }
 
        public static Poly operator -(Poly p1, Poly p2)
        {
            bool condition = p1.Coeff.Length <= p2.Coeff.Length;
            int loopCount = condition ? p1.Coeff.Length : p2.Coeff.Length;
            Poly ans = new Poly(condition ? p2 : p1);
            if (condition)
            {
                for (int i = 0; i < loopCount; i++)
                    ans.Coeff[i] -= p1.Coeff[i];
            }
            else
            {
                for (int i = 0; i < loopCount; i++)
                    ans.Coeff[i] -= p2.Coeff[i];
            }
            return ans;
        }
    }
 
    public class Program
    {
        static void Main(string[] args)
        {
            Random rand = new Random();
            double [] k = new double[5];
            double[] k1 = new double[4];
            for (int i = 0; i < k.Length; i++)
                k[i] = rand.Next(20);
            for (int i = 0; i < k1.Length; i++)
                k1[i] = rand.Next(20);
 
            Poly p1 = new Poly(k);
            Console.WriteLine(p1.ToString());
            Poly p2 = new Poly(k1);
            Console.WriteLine(p2.ToString());
 
            Poly p3 = p2 + p1;
            Console.WriteLine(p3.ToString());
                
            
            Console.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
 
namespace ArbitraryPolynom
{
    public struct Component
    {
        public double Val { get; set; }
        public int Power { get; set; }
    }
 
    public class Poly
    {
        private List<Component> coeff;
       
        public Poly()
        {
            coeff = new List<Component>();
        }
 
        public Poly(double[] _coeff)
        {
            coeff = new List<Component>();
            for (int i = 0; i < _coeff.Length; i++)
            {
                coeff.Add(new Component(){Val = _coeff[i], Power = i});
            }
        }
 
        public Poly(Poly p1)
        {
            coeff = new List<Component>();
            foreach (var comp in coeff)
            {
                coeff.Add(comp);
            }
        }
 
        public override string ToString()
        {
            coeff.OrderBy(x => x.Power);
            string ans = "y = ";
            for (int i = coeff.Count - 1; i > 0; i--)
            {
                ans += String.Format("{0} x^{1}", coeff[i].Val, coeff[i].Power);
                if (coeff[i - 1].Val >= 0) ans += " + ";
            }
            ans += String.Format("{0};", coeff[0].Val);
            return ans;
        }
        
        public static Poly operator +(Poly p1, Poly p2)
        {
            Poly ans = new Poly();
            int maxP1 = p1.coeff.Max(x => x.Power);
            int maxP2 = p2.coeff.Max(x => x.Power);
            int count = maxP1 <= maxP2 ? maxP2 : maxP1;
            for (int i = 0; i < count+1; i++)
            {
                double c1 = p1.coeff.Where(x => x.Power == i).Sum(x => x.Val);
                double c2 = p2.coeff.Where(x => x.Power == i).Sum(x => x.Val);
                ans.coeff.Add(new Component() {Power = i, Val = c1 + c2});
            }
            ans.coeff.OrderBy(x => x.Power);
            return ans;
        }
 
        public static Poly operator -(Poly p1, Poly p2)
        {
            Poly ans = new Poly();
            int maxP1 = p1.coeff.Max(x => x.Power);
            int maxP2 = p2.coeff.Max(x => x.Power);
            int count = maxP1 <= maxP2 ? maxP2 : maxP1;
            for (int i = 0; i < count + 1; i++)
            {
                double c1 = p1.coeff.Where(x => x.Power == i).Sum(x => x.Val);
                double c2 = p2.coeff.Where(x => x.Power == i).Sum(x => x.Val);
                ans.coeff.Add(new Component() { Power = i, Val = c1 - c2 });
            }
            ans.coeff.OrderBy(x => x.Power);
            return ans;
        }
 
        public static Poly operator *(Poly p1, Poly p2)
        {
            Poly temp = new Poly();
            foreach (Component c1 in p1.coeff)
            {
                foreach (Component c2 in p2.coeff)
                {
                    temp.coeff.Add(new Component(){Val = c1.Val*c2.Val, 
                                                  Power = c1.Power+c2.Power});
                }
            }
            Poly ans = new Poly();
            int count = temp.coeff.Max(x => x.Power);
            for (int i = 0; i < count+1; i++)
            {
                double c3 = temp.coeff.Where(x => x.Power == i).Sum(x => x.Val);
                ans.coeff.Add(new Component(){Val = c3,Power = i});
            }
            ans.coeff.OrderBy(x => x.Power);
            return ans;
        }
    }
 
 
 
    public class Program
    {
        static void Main(string[] args)
        {
            Random rand = new Random();
            double [] k = new double[5];
            double[] k1 = new double[4];
            for (int i = 0; i < k.Length; i++)
                k[i] = rand.Next(-10,10);
            for (int i = 0; i < k1.Length; i++)
                k1[i] = rand.Next(-10, 10);
 
            Poly p1 = new Poly(k);
            Console.WriteLine(p1.ToString());
            Poly p2 = new Poly(k1);
            Console.WriteLine(p2.ToString());
 
            Poly p3 = p2 - p1;
            Console.WriteLine(p3.ToString());
 
            p3 = p2 * p1;
            Console.WriteLine(p3.ToString());
                
            
            Console.ReadLine();
        }
    }
}