C#

// requires your project has a reference to System.Numerics, and a using statement foe it

Guid g = Guid.NewGuid();
byte[] b = g.ToByteArray();
BigInteger bigI = new BigInteger(b);

string s0 = g.ToString();
string s1 = System.Text.Encoding.Unicode.GetString(b);
string s2 = System.Text.Encoding.UTF8.GetString(b);
string s3 = System.Text.Encoding.ASCII.GetString(b);
string s4 = bigI.ToString();

Console.WriteLine($"guid to string: {s0}\r\nbyte[] to Unicode string: {s1}\r\nbyte[] to UTF8 string: {s2}\r\nbyte[] to ASCII string: {s3}\r\nbyte[] to BigInt to string: {s4}");

static ArithmeticObject AdditiveIdentity(Type type)
{
    if (type.Equals(typeof(Number)))
        return Zero;
    return new Polynomial(new List<Integer>());
}
static ArithmeticObject MultiplicativeIdentity(Type type)
{
    if (type.Equals(typeof(Number)))
        return One;
    return new Polynomial(new List<Integer> { One });
}

protected abstract ArithmeticObject Multiply(ArithmeticObject a);

T Multiply<T>(T a);

public bool IsNumber {get {return (this is Number);} }
public bool IsPolynomial {get {return (this is Polynomial);} }

using System.Collections.Generic;
using System.Linq;

namespace YourNameSpace
{
    public interface IArithmetic<T>
    {
        T TValue { set; get; }
    }

    public interface INumber : IArithmetic<int>
    {
    }

    public interface IPolynomial : IArithmetic<List<int>>
    {
    }

    public interface IOperators<T>
    {
        T TAdd(T t1, T t2);
    }

    public class Number : INumber, IOperators<Number>
    {
        public Number(int value = 0)
        {
            TValue = value;
        }

        public int TValue { get; set; }

        public static Number operator +(Number n1, Number n2)
        {
            Number newNumber = new Number();
            newNumber.TValue = n1.TValue + n2.TValue;
            return newNumber;
        }

        public Number TAdd(Number t1, Number t2)
        {
            return t1 + t2;
        }
    }

    public class Polynomial : IPolynomial, IOperators<Polynomial>
    {
        public Polynomial(params int[] ints)
        {
            TValue = ints.ToList();
        }

        public List<int> TValue { get; set; }

        // concatenation here
        public static Polynomial operator +(Polynomial p1, Polynomial p2)
        {
            Polynomial newPolynomial = new Polynomial();
            newPolynomial.TValue = p1.TValue.Concat(p2.TValue).ToList();
            return newPolynomial;
        }

        public Polynomial TAdd(Polynomial t1, Polynomial t2)
        {
            return t1 + t2;
        }
    }

    public static class ArithmeticExtensions
    {
        public static Number Add(this Number n1, Number n2)
        {
            Number n = new Number();

            n.TValue += n1.TValue + n2.TValue;

            return n;
        }

        public static Number Add(this Number n1, Polynomial p1)
        {
            Number n = new Number(n1.TValue);

            foreach (int i in p1.TValue)
            {
                n.TValue += i;
            }

            return n;
        }

        // addition performed here
        public static Polynomial Add(this Polynomial p1, Polynomial p2)
        {
            Polynomial p;

            if (p1.TValue.Count == p2.TValue.Count)
            {
                p = new Polynomial(p1.TValue.ToArray());

                for (int i = 0; i < p.TValue.Count; i++)
                {
                    p.TValue[i] += p2.TValue[i];
                }
            } else if (p1.TValue.Count < p2.TValue.Count)
            {
                // p1 has fewer values
                p = new Polynomial(p2.TValue.ToArray());

                for (int i = 0; i < p1.TValue.Count; i++)
                {
                    p.TValue[i] += p1.TValue[i];
                }
            }
            else
            {
                // p1  has more values
                p = new Polynomial(p1.TValue.ToArray());

                for (int i = 0; i < p2.TValue.Count; i++)
                {
                    p.TValue[i] += p2.TValue[i];
                }
            }

            return p;
        }

        public static Polynomial Add(this Polynomial p1, Number n1)
        {
            Polynomial p = new Polynomial(p1.TValue.ToArray());

            for (int i = 0; i < p.TValue.Count; i++)
            {
                p.TValue[i] += n1.TValue;
            }

            return p;
        }
    }
}

public void Teat()
{
    Number n1, n2;
    Polynomial p1, p2;
    
    n1 = new Number(100);
    n2 = new Number(200);
    p1 = new Polynomial(1,2,3, 4, 5, 6);
    p2 = new Polynomial(7,8,9);
    
    var n3 = n1 + n2;  // use of operator overloading
    var p3 = p1 + p2;  // => {1,2,3,4,5,6,7,8,9}
    
    var p4 = p1.Add(p2); // use of Extension Methods
    var p5 = p2.Add(p1); // both => {8,10,12,4,5,6}
    
    var p6 = p1.Add(n1); // add Number to Polynomial => {101 ~ 106}
    var n4 = n2.Add(p2); // add Polynomial to Number => 224
}

interface IArithmetic<T>
{
    T GetAdditiveIdentity();
    T GetMultiplicativeIdentity();
    T Minus(T n);
    T Times(T n);
}
struct Division<T>
{
    public T Quotient;
    public T Remainder;
}
interface IDivisible<T> : IArithmetic<T> 
{            
    Division<T> EuclideanDivideBy(T divisor);
}
abstract class Number : IArithmetic<Number>
{
    ...
}
class Integer : Number, IDivisible<Integer>
{
    ...
}
class Polynomial : IDivisible<Polynomial>
{
    ...
}
static T Exponentiate<T>(T expBase, Integer exponent) where T : IArithmetic<T>
{
    T output = expBase.GetMultiplicativeIdentity();
    T baseToAPowerOfTwo = expBase;
    Integer two = new Integer(2);
    while (exponent.Sign > 0)
    {
        Division<Integer> division = exponent.EuclideanDivideBy(two);
        if (division.Remainder == One)
            output = output.Times(baseToAPowerOfTwo);
        baseToAPowerOfTwo = baseToAPowerOfTwo.Times(baseToAPowerOfTwo);
        exponent = division.Quotient;
    }
    return output;
}
struct ExtendedGCDInfo<T>
{
    public T GCD;
    public T ACoefficient;
    public T BCoefficient;
    public T AOverGCD;
    public T BOverGCD;
}
static ExtendedGCDInfo<T> ExtendedGCD<T>(T a, T b) where T : IDivisible<T>
{
    ExtendedGCDInfo<T> output = new ExtendedGCDInfo<T>();
    output.ACoefficient = a.GetAdditiveIdentity();
    output.BCoefficient = a.GetMultiplicativeIdentity();                       
    output.BOverGCD = a.GetMultiplicativeIdentity();
    output.AOverGCD = a.GetAdditiveIdentity();
    while (!a.Equals(a.GetAdditiveIdentity())) 
    {
        Division<T> division = b.EuclideanDivideBy(a);
        T m = output.ACoefficient.Minus(output.BOverGCD.Times(division.Quotient));
        T n = output.BCoefficient.Minus(output.AOverGCD.Times(division.Quotient));
        b = a;
        a = division.Remainder;
        output.ACoefficient = output.BOverGCD;
        output.BCoefficient = output.AOverGCD;
        output.BOverGCD = m;
        output.AOverGCD = n;
    }
    output.GCD = b;
    output.BOverGCD = a.GetAdditiveIdentity().Minus(output.BOverGCD);
    return output;
}

Quote:

help with the loop function,
I have written my code but it doesnt run exactly as I need it to. Please help me!!
Florence needs help with C Sharp Programming as soon as possible. Florence wrote:
I am stuck on a basic c# calculator using the loop function, my loop function wont correctly loop.. please help!!

if (option != "1" || option != "2")
    {
    incorrect = true;

if (option != "1" && option != "2") // if it is any number other than 1 or 2
    {
    incorrect = true;