Algorithms I

Finding Minimum Value Of Array

 public int MinElement(int[] arr)
 {
        int min = int.MaxValue;

        foreach (int a in arr)
        {
          if (min >= a)
          {
            min = a;
          }
        }

     return min;
 }

Finding Maximum Value Of Array

 public int MaxElement(int[] arr)
 {
   int max = 0;
            
   foreach(int a in arr)
   {
      if(max<=a)
      {
          max = a;
      }
   }

   return max;
}        

Definite Integral Between X0 to Xn

public double Integral(double divisionCount,double x0 , double xn)
{
    double total = 0;

    double h = Math.Abs((xn - x0) / divisionCount);

    for(double x=x0;x<=xn; x=x+h)
    {
        total += h*IntegralFunctionFx(x);
    }

    return total;
}

public double IntegralFunctionFx(double x)
{
  //Sample Integral Function f(x)
  return Math.Cos(x);
}

Matrix Sum

public int[,] MatrixSum(int[,] A, int[,] B)
{    
   int M = A.GetLength(0);
   int N = A.GetLength(1);

   int[,] C = new int[M, N];

   for (int i = 0; i < M; i++)
   {
      for (int j = 0; j < N; j++)
      {
        C[i,j] = A[i,j] + B[i,j];
      }
   }

  return C;
}

Matrix Multiply

public int[,] MatrixMultiply(int[,] A, int[,] B)
{
       int M = A.GetLength(0);
       int N = B.GetLength(1);

       int[,] C = new int[M, N];

       int subTotal = 0;

       for (int i = 0; i < M; i++)
       {
            for (int k = 0; k < N; k++)
            {
                subTotal = 0;
                for (int j = 0; j < N; k++)
                {
                   subTotal += A[i, j] * B[j, k];
                }

                C[i, k] = subTotal;
             }
       }

  return C;
}

Infinite SUM

 public double fxInfiniteSum(double epsilon)
 {
     double result = 0;

     for (int i = 1; i <= int.MaxValue; i++)
     {
         if ((i - 1) == 0)
         {
             result += gx(1);
             continue;
         }
         else
         {
             if (gx(i - 1) - gx(i) <= epsilon)
                 return result;
         }

         result += gx(i);
     }

     return result;
  }

public double gx(double x)
{
    //Sample Function 1/x^2
    return 1.0 / (x * x);
}

Geometric Average

 public double GeometricAverage(int[] array)
 {
     double result = 1;
     for (int i = 0; i < array.Length; i++)
     {
         result *= array[i];
     }

     return Math.Sqrt(result);
 }

Arithmetic Average

public double ArithmeticAverage(int[] array)
{
   double result = 0;
   for(int i=0;i< array.Length;i++)
   {
       result += array[i];
   }

    return result / array.Length;
}

Factorial

public int Factorial(int n)
{
   if (n >= 1)
   {
      return n * Factorial(n - 1);
   }
   else
   {
      return 1;
   }
}

GCD (OBEB) Greatest Common Divisor

public int gcd(int a,int b)
{
    int result = 0;

    if (b == 0)
       return a;
    else
       return gcd(b, a % b);
}

LCM (OKEK) Least Common Multiple

public static int lcm(int a, int b)
{
    int result = 0;

    result = (a * b) / gcd(a, b);
    return result;
}

Sorting

public int[] Sort(int[] A)
{
    int[] B = new int[A.Length];
    int min = 0;
    List<int> ANew = new List<int>(A);

    for (int i = ANew.Count-1; i >= 0; i--)
    {
         min = FindMin(ANew.ToArray());
         B[i] = min;
         ANew.Remove(min);
    }

    return B.Reverse().ToArray();

}

public int FindMin(int[] X)
{
     int min = int.MaxValue;

     for(int i=0;i<X.Length;i++)
     {
         if (min >= X[i])
             min = X[i];
     }

     return min;
}

Bubble Sort

public int[] BubleSort(int[] arr)
{
   for(int i=0;i<arr.Length;i++)
   {
       for (int j = 0; j < arr.Length; j++)
       {
           if (j < (arr.Length - 1) && arr[j] >= arr[j + 1])
           {
               int temp = arr[j+1];
               arr[j + 1] = arr[j];
               arr[j] = temp;          
           }
        }
    }

    return arr;
}

Selection Sort

public int[] SelectionSort(int[] arr)
{   
   for (int i=0; i<arr.Length;i++)
   {
       int min_index = i;

       for(int j=i+1;j<arr.Length;j++)
       {
           if(arr[j]<=arr[min_index])
           {
              min_index = j;
           }
       }
       int temp = arr[i];
       arr[i] = arr[min_index];
       arr[min_index] = temp;
   }
   return arr;
}

Insertion Sort

public int[] IntersionSoft(int[] arr)
{
   for (int i = 1; i < arr.Length; i++)
   {
       int current = arr[i];

       int j = i - 1;

       while(j>= 0 && arr[j]>current)
       {
           arr[j + 1] = arr[j];
           j--;
       }
                 

       arr[j+1] = current;
    }
    
    return arr;
}

Guessing Game

• Random secret number with 4 digits.
• All digits in the secret number are different.

guessValue   = "5218; //Sample Guess Value

 public bool CalculateGameResult(string guessValue)
    {
        string secretNumber = "7208"; //Sample Secret Number

        int M = 0;
        int P = 0;

        for (int j = 0; j < secretNumber.Length; j++)
        {
            if (secretNumber.Contains(guessValue.ToString()[j]))
            {
                if (secretNumber[j] == guessValue.ToString()[j])
                {
                    P++;
                }
                else
                {
                    M++;
                }
            }
        }

        bool resultSuccess = false;

        if (P == secretNumber.Length)
        {
            resultSuccess = true;
        }
        else
        {
            resultSuccess = false;
        }

        return resultSuccess;
    }
}