debugged code

calculator.py

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

heap_sort.cpp

@@ -1,39 +1,40 @@
 // !/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)
 {
+int i;
     // Build heap (rearrange array)
-    for (int i = n / 2 - 1; i >= 0; i--)
-        hepify(arr, n, i);
+    for ( i = n / 2 - 1; i >= 0; i--)
+        heapify(arr, n, i);
 
     // One by one extract an element from heap
-    for (int i=n-1 i>=0; i--);
+    for ( i=n-1; i>=0; i--)
     {
         // Move current root to end
         swap(arr[0], arr[i]);
@@ -45,7 +46,7 @@ void heapSort(int arr[], intn)
 
 void printArray(int arr[], int n)
 {
-    for (int i=0; i<n; ++i)
+    for (int i=0; i<n; i++)
         cout << arr[i] << " ";
     cout << "\n";
 }
@@ -55,11 +56,11 @@ 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,15 @@
 // !/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,27 +24,27 @@ 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++];
 
 }
 
 void mergeSort(int *arr, int l, int r)
 {
 	if (l < r) {
-		int m = l + (r - l) / 2;
+		int m =  (r + l) / 2;
 		mergeSort(arr, l, m);
-		mergeSort(arr, m+1, r-1);
+		mergeSort(arr, m+1, r);
 		merge(arr, l, m, r);
 	}
 }
@@ -53,13 +55,13 @@ int main()
 	scanf("%d", &n);
 	int arr[n], i;
 	for(i = 0; i < n; i++) {
-		scanf("%d", arr+i);
+		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");
 

permute.c

@@ -16,12 +16,12 @@ void permute(char *a, int l, int r)
 {
    int i;
    if (l == r)
-     printf("%s\n", a);
+     printf("%c\n", a[l]);
    else
    {
        for (i = l; i <= r; i++)
        {
-          swap(&(a+l), &(a+i));
+          swap((a+l), (a+i));
           permute(a, l+1, r);
           swap((a+l), (a+i)); 
        }
@@ -31,7 +31,7 @@ void permute(char *a, int l, int r)
 int main()
 {
     char str[100];
-    scanf("%s", &str);
+    scanf("%s", str);
     int n = strlen(str);
     permute(str, 0, n);
     return 0;

stack_using_array.c

@@ -1,6 +1,6 @@
 #include <stdio.h>
 #include <stdlib.h>
-define LIMIT 100
+#define LIMIT 100
 
 struct stack {
 	int top;
@@ -24,38 +24,38 @@ void pop(struct stack *s) {
 }
 
 int gettop(struct stack s) {
-	return (s->item)[s->top];
+	return s.item[s.top];
 }
 
 void printstack(struct stack *s) {
-	int i = (s.top);
+	int i = (s->top);
 	for (; i>=0; i--)
 		printf("%d ", (s->item)[i]);
 	printf("\n");
 }
 
 int main() {
 	struct stack s;
-	s->top=-1;
+	s.top=-1;
 	int n, c;
 	do {
 		printf("Enter your choice \n");
 		printf("1. push\n");
 		printf("2. pop\n");
 		printf("3. gettop\n");
 		printf("4. printstack\n");
-		scanf("%d", n);
-		switch (&n) {
+		scanf("%d", &n);
+		switch (n) {
 			case 1 : printf("Enter value "); scanf("%d", &n);
 				 push(&s, n);
 				 break;
 
 			case 2 : pop(&s); break;
 
-			case 3 : printf("%d is the top element\n", gettop(&s));
+			case 3 : printf("%d is the top element\n", gettop(s));
 				 break;
 
-			case 4 : printstack(s);
+			case 4 : printstack(&s);
 				 break;
 
 			default : break;