palindrome.c

.github/workflows/c-cpp.yml

@@ -0,0 +1,37 @@
+name: C/C++ CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build-ubuntu:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: configure
+      run: mkdir build && cd build && cmake -DCMAKE_CXX_FLAGS="-Werror" ..
+    - name: build
+      run: cmake --build build
+    - name: test
+      run: cd build && ctest
+
+  build-windows:
+
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [windows-latest, windows-2016]
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: configure
+      run: mkdir build && cd build && cmake ..
+    - name: build
+      run: cmake --build build --config Debug
+    - name: test
+      run: cd build && ctest

.gitignore

@@ -0,0 +1,5 @@
+.idea/
+Algorithms/Algorithms.iml
+DS/DS.iml
+Hackerrank/Hackerrank.iml
+HacktoberfestForBeginners.iml

.mergify.yml

@@ -0,0 +1,7 @@
+pull_request_rules:
+  - name: Automatic merge on approval
+    conditions:
+      - "#approved-reviews-by>=1"
+    actions:
+      merge:
+        method: merge

Algorithms/C#/BinaryInsertionSort.cs

@@ -0,0 +1,38 @@
+// C# Program implementing 
+// binary insertion sort 
+using System; 
+
+class GFG { 
+
+	public static void Main() 
+	{ 
+		int []arr = {37, 23, 0, 17, 12, 72, 31, 
+							46, 100, 88, 54 }; 
+
+		sort(arr); 
+
+		for(int i = 0; i < arr.Length; i++) 
+			Console.Write(arr[i] + " "); 
+	} 
+
+	public static void sort(int []array) 
+	{ 
+		for (int i = 1; i < array.Length; i++) 
+		{ 
+			int x = array[i]; 
+
+			// Find location to insert using 
+			// binary search 
+			int j = Math.Abs(Array.BinarySearch( 
+							array, 0, i, x) + 1); 
+
+			// Shifting array to one location right 
+			System.Array.Copy(array, j, array, 
+										j+1, i-j); 
+
+			// Placing element at its correct 
+			// location 
+			array[j] = x; 
+		} 
+	} 
+} 

Algorithms/C#/BubbleSort.cs

@@ -0,0 +1,34 @@
+// Bubble Sort with C#
+using System;
+
+namespace BubbleSort
+{
+    class MainClass
+    {
+        public static void Main()
+        {
+            // test numbers to sort
+            int[] toSort = { 5, 2, 6, 8, 3};
+
+            // perform bubble sort
+            for (int i = 0; i < 5; i++)
+            {
+                for (int j = 0; j < 4; j++)
+                {
+                    if (toSort[j] > toSort[j + 1])
+                    {
+                        int temp = toSort[j];
+                        toSort[j] = toSort[j + 1];
+                        toSort[j + 1] = temp;
+                    }
+                }
+            }
+
+            // print to console results
+            for (int i = 0; i < 5; i++)
+            {
+                Console.WriteLine(toSort[i]);
+            }
+        }
+    }
+}

Algorithms/C#/HeapSort.cs

@@ -0,0 +1,61 @@
+using System;
+class heapsort
+{
+    int[] r = { 2,5,1,10,6,9,3,7,4,8};
+    public void hsort()
+    {
+        int i, t;
+        for (i = 5; i >= 0; i--)
+        {
+            adjust(i, 9);
+        }
+        for (i = 8; i >= 0; i--)
+        {
+            t = r[i + 1];
+            r[i + 1] = r[0];
+            r[0] = t;
+            adjust(0, i);
+        }
+    }
+    private void adjust(int i, int n)
+    {
+        int t, j;
+        try
+        {
+            t = r[i];
+            j = 2 * i;
+            while (j <= n)
+            {
+                if (j < n && r[j] < r[j + 1])
+                    j++;
+                if (t >=r[j])
+                    break;
+                r[j / 2] = r[j];
+                j *= 2;
+            }
+            r[j / 2] = t;
+        }
+        catch (IndexOutOfRangeException e)
+        {
+            Console.WriteLine("Array Out of Bounds ", e);
+        }
+    }
+    public void print()
+    {
+        for (int i = 0; i < 10; i++)
+        {
+            Console.WriteLine("{0}", r[i]);
+        }
+
+    }
+    public static void Main()
+    {
+        heap obj = new heap();
+        Console.WriteLine("Elements Before sorting : ");
+        obj.print();
+        obj.hsort();
+        Console.WriteLine("Elements After sorting : ");
+        obj.print();
+        Console.Read();
+    }
+}

Algorithms/C#/InsertionSort.cs

@@ -0,0 +1,48 @@
+/*
+ * C# Program to Perform Insertion Sort
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+namespace ConsoleApplication1
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            int[] arr = new int[5] { 83, 12, 3, 34, 60 };
+            int i;
+            Console.WriteLine("The Array is :");
+            for (i = 0; i < 5; i++)
+            {
+                Console.WriteLine(arr[i]);
+            }
+            insertsort(arr, 5);
+            Console.WriteLine("The Sorted Array is :");
+            for (i = 0; i < 5; i++)
+                Console.WriteLine(arr[i]); 
+            Console.ReadLine();
+        }        
+        static void insertsort(int[] data, int n)
+        {
+            int i, j;
+            for (i = 1; i < n; i++)
+            {
+                int item = data[i];
+                int ins = 0;
+                for (j = i - 1; j >= 0 && ins != 1; )
+                {
+                    if (item < data[j])
+                    {
+                        data[j + 1] = data[j];
+                        j--;
+                        data[j + 1] = item;
+                    }
+                    else ins = 1;
+                }
+            }
+        }
+    }
+}

Algorithms/C#/MergeSort.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace CSharpMergeSort
+{
+    class Mergesort
+    {
+
+        static public void DoMerge(int [] numbers, int left, int mid, int right)
+        {
+            int [] temp = new int[25];
+            int i, left_end, num_elements, tmp_pos;
+
+            left_end = (mid - 1);
+            tmp_pos = left;
+            num_elements = (right - left + 1);
+
+            while ((left <= left_end) && (mid <= right))
+            {
+                if (numbers[left] <= numbers[mid])
+                    temp[tmp_pos++] = numbers[left++];
+                else
+                    temp[tmp_pos++] = numbers[mid++];
+            }
+
+            while (left <= left_end)
+                temp[tmp_pos++] = numbers[left++];
+
+            while (mid <= right)
+                temp[tmp_pos++] = numbers[mid++];
+
+            for (i = 0; i < num_elements; i++)
+            {
+                numbers[right] = temp[right];
+                right--;
+            }
+        }
+
+        static public void MergeSort_Recursive(int [] numbers, int left, int right)
+        {
+          int mid;
+
+          if (right > left)
+          {
+            mid = (right + left) / 2;
+            MergeSort_Recursive(numbers, left, mid);
+            MergeSort_Recursive(numbers, (mid + 1), right);
+
+            DoMerge(numbers, left, (mid+1), right);
+          }
+        }        
+
+        static void Main(string[] args)
+        {
+            int[] numbers = { 3, 8, 7, 5, 2, 1, 9, 6, 4 };
+            int len = 9;
+
+            Console.WriteLine("MergeSort By Recursive Method");
+            MergeSort_Recursive(numbers, 0, len - 1);
+            for (int i = 0; i < 9; i++)
+                Console.WriteLine(numbers[i]);
+
+            Console.WriteLine(numbers[i]);
+
+        }
+    }
+}

Algorithms/C#/QuickSort.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace sortQuickAlgorithm
+{
+    class quickSortAlgorithm
+    {
+
+        private int[] array = new int[20];
+        private int len;
+
+        public void QuickSortAlgorithm()
+        {
+            sort(0, len - 1);
+        }
+
+        public void sort(int left, int right)
+        {
+            int pivot, leftend, rightend;
+
+            leftend = left;
+            rightend = right;
+            pivot = array[left];
+
+            while (left < right) { while ((array[right] >= pivot) &amp;&amp; (left < right))
+                {
+                    right--;
+                }
+
+                if (left != right)
+                {
+                    array[left] = array[right];
+                    left++;
+                }
+
+                while ((array[left] >= pivot) &amp;&amp; (left < right))
+                {
+                    left++;
+                }
+
+                if (left != right)
+                {
+                    array[right] = array[left];
+                    right--;
+                }
+            }
+
+            array[left] = pivot;
+            pivot = left;
+            left = leftend;
+            right = rightend;
+
+            if (left < pivot) { sort(left, pivot - 1); } if (right > pivot)
+            {
+                sort(pivot + 1, right);
+            }
+        }
+
+        public static void Main()
+        {
+            quickSortAlgorithm q_Sort = new quickSortAlgorithm();
+
+            int[] array = { 41, 32, 15, 45, 63, 72, 57, 43, 32, 52, 183};
+            q_Sort.array = array;
+            q_Sort.len = q_Sort.array.Length;
+            q_Sort.QuickSortAlgorithm();
+
+            for (int j = 0; j &lt; q_Sort.len; j++)
+            {
+                Console.WriteLine(q_Sort.array[j]);
+            }
+            Console.ReadKey();
+        }
+    }
+}