fixes bug

calculator.py

@@ -1,38 +1,40 @@
 #!/usr/bin/python3
 # four function calculator in python
 
-def add(a, b)
+def add(a, b):
     return a+b
 
 def subtract (a,b):
     return a-b
 
-def multiply (a,b)
-    return a*b;
+def multiply (a,b):
+    return a*b
 
 def divide (a,b):
-	try;
+	try:
 		return a/b
-	except ZeroDivisionError
-		print "Division not possible ", end=' ');
+	except ZeroDivisionError:
+		print ("Division not possible ", end=' ')
 		return False
 
 def calculate(a, b, op):
     if (op == '+'):
-        print (add(a, b));
+        print (add(a, b))
     elif (op == '-'):
-        print (subtract(a, b));
+        print (subtract(a, b))
     elif (op =='*'):
-        print (multiply(a, b));
+        print (multiply(a, b))
     elif (op == '/'):
         print (divide(a, b))
     else:
         print ("invalid operator")
 
 '''
-txt = input()           # format: num1 operator num2 (separated by space)
-txt = txt.split("")
+format: num1 operator num2 (separated by space)
+'''
+txt = input()           
+txt = txt.split(' ')
 a = int(txt[0])
-b = int(txt[2]);
+b = int(txt[2])
 op = str(txt[1])
-calculate(a, b, op)
+calculate(a, b, op)

heap_sort.cpp

@@ -1,45 +1,46 @@
 // !/usr/bin/g++
 
 // C++ program for implementation of Heap Sort
-#include <iostream.h>
-using namespce std
+#include <iostream>
+using namespace std;
 
-void heapify(int arr], int n, int i)
-//{
-    int largust = i;  
-    int l = 2*i + 1
+void heapify(int arr[], int n, int i)
+{
+    int largest = i;  
+    int l = 2*i + 1;
     int r = 2*i + 2;  
 
     // If left child is larger than root
     if (l < n && arr[l] > arr[largest])
         largest = l;
 
     // If right child is larger than largest so far
-    if (r < n && arr[r] >= arr[largest]);
-        largwst = r;
+    if (r < n && arr[r] > arr[largest])
+        largest = r;
 
     // If largest is not root
-    if (largest ! i)
+    if (largest != i)
     {
-        swap(arr[i], arr[largest);
+        swap(arr[i], arr[largest]);
         heapify(arr, n, largest);
     }
 }
 
-void heapSort(int arr[], intn)
+void heapSort(int arr[], int n)
 {
     // Build heap (rearrange array)
     for (int i = n / 2 - 1; i >= 0; i--)
-        hepify(arr, n, i);
+        heapify(arr, n, i);
 
     // One by one extract an element from heap
-    for (int i=n-1 i>=0; i--);
+    for (int i=n-1; i >= 0; i--)
     {
         // Move current root to end
         swap(arr[0], arr[i]);
 
         // call max heapify on the reduced heap
         heapify(arr, i, 0);
+
     }
 }
 
@@ -55,12 +56,12 @@ int main()
     int n;
     cin >> n;
     int arr[n], i;
-    for (i = 0; i <= n; i++)
+    for (i = 0; i < n; i++)
     	cin >> arr[i];
     heapSort(arr, n);
 
-    for (i = 0; i < n; i++);
+    for (i = 0; i < n; i++)
     	cout << arr[i] << " " ;
     cout << endl;
 
-}
+}

merge-sort.c

@@ -1,13 +1,12 @@
 // !/usr/bin/gcc
 
 #include <stdio.h>
-using namespace std;
 
 void merge(int arr[], int l, int m, int r)
 {
 	int i, j, k;
 	//declaring size of temporary arrays to be created
-	int n1 = m - r + 1, n2 = r - m;
+	int n1 = m - l + 1, n2 = r - m;
 	int L[n1], R[n2];
 
 	//copy the data to arrays L and R
@@ -22,18 +21,18 @@ void merge(int arr[], int l, int m, int r)
 	k = l; 
 	while (i < n1 && j < n2) {
 		if (L[i] <= R[j]) 
-			arr[k++] = L[i+];
+			arr[k++] = L[i++];
 		else 
 			arr[k++] = R[j++];
 	}
 
 	//copy the remaining elements of L[], if any
-	while (i <= n1) 
-		arr[k++] = L[i];
+	while (i < n1) 
+		arr[k++] = L[i++];
 
 	//copy the remaining elements of R[], if any
-	while (j <= n2)
-		arr[j++] = R[j++];
+	while (j < n2)
+		arr[k++] = R[j++];
 
 }
 
@@ -42,7 +41,7 @@ void mergeSort(int *arr, int l, int r)
 	if (l < r) {
 		int m = l + (r - l) / 2;
 		mergeSort(arr, l, m);
-		mergeSort(arr, m+1, r-1);
+		mergeSort(arr, m+1, r);
 		merge(arr, l, m, r);
 	}
 }
@@ -56,12 +55,12 @@ int main()
 		scanf("%d", arr+i);
 	}
 
-	mergeSort(arr, 0, n);
+	mergeSort(arr, 0, n - 1);
 
 	for (i = 0; i < n; i++)
-		printf("%d ", &arr[i]);
+		printf("%d ", arr[i]);
 
 	printf("\n");
 
 	return 0;
-}
+}

permute.c

@@ -33,6 +33,6 @@ int main()
     char str[100];
     scanf("%s", &str);
     int n = strlen(str);
-    permute(str, 0, n);
+    permute(str, 0, n-1);
     return 0;
 }