Code commits from Hacktoberfest 2018

Algorithms/Binary Search/Binary search.cpp

@@ -0,0 +1,39 @@
+#include <stdio.h>
+
+#include<stdio.h>
+int main()
+{
+   int c, first, last, middle, n, search, array[100];
+
+   printf("Enter number of elements\n");
+   scanf("%d",&n);
+
+   printf("Enter %d integers\n", n);
+
+   for (c = 0; c < n; c++)
+      scanf("%d",&array[c]);
+
+   printf("Enter value to find\n");
+   scanf("%d", &search);
+
+   first = 0;
+   last = n - 1;
+   middle = (first+last)/2;
+
+   while (first <= last) {
+      if (array[middle] < search)
+         first = middle + 1;    
+      else if (array[middle] == search) {
+         printf("%d found at location %d.\n", search, middle+1);
+         break;
+      }
+      else
+         last = middle - 1;
+
+      middle = (first + last)/2;
+   }
+   if (first > last)
+      printf("Not found! %d isn't present in the list.\n", search);
+
+   return 0;  
+}

Algorithms/Binary Search/Task.md

@@ -1,3 +1,4 @@
 # Task
 
-Implement Binary Search through your favourable language.
+Implement Binary Search through your favourable language.
+

Algorithms/Binary Search/binary_search.cpp

@@ -0,0 +1,44 @@
+
+// C program to implement recursive Binary Search 
+#include <stdio.h> 
+
+// A recursive binary search function. It returns  
+// location of x in given array arr[l..r] is present,  
+// otherwise -1 
+int binarySearch(int arr[], int l, int r, int x) 
+{ 
+   if (r >= l) 
+   { 
+        int mid = l + (r - l)/2; 
+
+        // If the element is present at the middle  
+        // itself 
+        if (arr[mid] == x)   
+            return mid; 
+
+        // If element is smaller than mid, then  
+        // it can only be present in left subarray 
+        if (arr[mid] > x)  
+            return binarySearch(arr, l, mid-1, x); 
+
+        // Else the element can only be present 
+        // in right subarray 
+        return binarySearch(arr, mid+1, r, x); 
+   } 
+
+   // We reach here when element is not  
+   // present in array 
+   return -1; 
+} 
+
+int main(void) 
+{ 
+   int arr[] = {2, 3, 4, 10, 40}; 
+   int n = sizeof(arr)/ sizeof(arr[0]); 
+   int x = 10; 
+   int result = binarySearch(arr, 0, n-1, x); 
+   (result == -1)? printf("Element is not present in array") 
+                 : printf("Element is present at index %d", 
+                                                   result); 
+   return 0; 
+}

Algorithms/Bubble Sort/bubble sort.cpp

@@ -0,0 +1,34 @@
+#include <stdio.h>
+
+int main()
+{
+  int array[100], n, c, d, swap;
+
+  printf("Enter number of elements\n");
+  scanf("%d", &n);
+
+  printf("Enter %d integers\n", n);
+
+  for (c = 0; c < n; c++)
+    scanf("%d", &array[c]);
+
+  for (c = 0 ; c < n - 1; c++)
+  {
+    for (d = 0 ; d < n - c - 1; d++)
+    {
+      if (array[d] > array[d+1]) /* For decreasing order use < */
+      {
+        swap       = array[d];
+        array[d]   = array[d+1];
+        array[d+1] = swap;
+      }
+    }
+  }
+
+  printf("Sorted list in ascending order:\n");
+
+  for (c = 0; c < n; c++)
+     printf("%d\n", array[c]);
+
+  return 0;
+}

Algorithms/Bubble Sort/bubble.cpp

@@ -0,0 +1,42 @@
+
+// C program for implementation of Bubble sort 
+#include <stdio.h> 
+
+void swap(int *xp, int *yp) 
+{ 
+    int temp = *xp; 
+    *xp = *yp; 
+    *yp = temp; 
+} 
+
+// A function to implement bubble sort 
+void bubbleSort(int arr[], int n) 
+{ 
+   int i, j; 
+   for (i = 0; i < n-1; i++)       
+
+       // Last i elements are already in place    
+       for (j = 0; j < n-i-1; j++)  
+           if (arr[j] > arr[j+1]) 
+              swap(&arr[j], &arr[j+1]); 
+} 
+
+/* Function to print an array */
+void printArray(int arr[], int size) 
+{ 
+    int i; 
+    for (i=0; i < size; i++) 
+        printf("%d ", arr[i]); 
+    printf("n"); 
+} 
+
+// Driver program to test above functions 
+int main() 
+{ 
+    int arr[] = {64, 34, 25, 12, 22, 11, 90}; 
+    int n = sizeof(arr)/sizeof(arr[0]); 
+    bubbleSort(arr, n); 
+    printf("Sorted array: \n"); 
+    printArray(arr, n); 
+    return 0; 
+}

Algorithms/Bubble Sort/bubbleSort_Palaash.c

@@ -0,0 +1,34 @@
+#include<stdio.h>
+//Descending Bubble Sort using C
+int main()
+{
+	int a[20],i,j,size,temp,swap;
+	printf("\n Enter Array Size : ");
+	scanf("%d",&size);
+	printf("\n Enter Array Elements : ");
+	for(i=0;i<size;i++)
+        scanf("%d",&a[i]);
+
+	//BUBBLE SORT : Descending
+	for(i=0;i<size-1;i++){
+        swap=0;
+        //COMPARE ELEMENTS AND SWAP:
+        for(j=0;j<(size-1)-1;j++){
+            if(a[j]<a[j+1]){
+                temp=a[j];
+                a[j]=a[j+1];
+                a[j+1]=temp;
+                swap=1;
+            }
+        }
+        if(swap==0){
+            break;
+        }
+	}
+
+	printf("\nArray after sort: ");
+	for(i=0;i<size;i++)
+        printf("%d",a[i]);
+
+    return 0;
+}

Algorithms/Bubble Sort/bubblesort.java

@@ -0,0 +1,33 @@
+public class array {
+	static Scanner scn = new Scanner(System.in);
+
+	public static void main(String[] args) {
+        int[] arr2 = takeinput();
+        bubblesort(arr2);
+        display(arr2);
+    }
+    public static int[] takeinput() {
+		int n = scn.nextInt();
+		int[] arr = new int[n];
+		for (int i = 0; i <= arr.length - 1; i++) {
+			arr[i] = scn.nextInt();
+		}
+		return arr;
+	}
+
+	public static void display(int[] arr) {
+		for (int i = 0; i <= arr.length - 1; i++) {
+			System.out.println(arr[i]);
+		}
+	}
+public static void bubblesort(int[] arr) {
+    for (int c = 0; c < arr.length - 1; c++) {
+        for (int j = 0; j < arr.length - 1 - c; j++) {
+            if (arr[j] > arr[j + 1]) {
+                int temp = arr[j];
+                arr[j] = arr[j + 1];
+                arr[j + 1] = temp;
+            }
+        }
+    }
+}