Merge branch 'codemistic:main' into main

Author: pranava7

121 Leetcode/121 leetcode.py

@@ -0,0 +1,10 @@
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        maxProfit = 0
+        currentMax = 0
+
+        for i in reversed(prices):
+            currentMax = max(currentMax, i)
+            profit = currentMax - i
+            maxProfit = max(profit, maxProfit)
+        return maxProfit  

Arrays/01_static_and_dynamicArray.c

@@ -0,0 +1,25 @@
+#include <stdio.h>
+#include <stdlib.h>
+int main()
+{
+	int A[5] = { 1,2,3,4,5 }; // this is allocated inside stack memory 
+	int* p; // pointer of array
+	int i;
+	p = (int*)malloc(5 * sizeof(int)); // dynamically createing array inside heap 
+	p[0] = 1; // initializing all the terms in array
+	p[1] = 2;
+	p[2] = 3;
+	p[3] = 4;
+	p[4] = 5;
+
+	for (i = 0; i < 5; i++) // iteration for normal array 
+	{
+		printf("%d ", A[i]);
+	}
+	printf("\n");
+ 	for (i = 0; i < 5; i++) // iteration for the dynamic array 
+	{
+		printf("%d ",p[i]);
+	}
+	return 0;
+}

Arrays/01_static_and_dynamicArray.exe

@@ -0,0 +1,26 @@
+/* Normal array is created in stack 
+and stack used memory array cannot be change 
+tht is we can not incresae the size of array  */
+
+#include <stdio.h>
+#include<stdlib.h>
+int main ()
+{
+	int *p,*q; // Taking two pointers
+	int i;
+	p=(int *)malloc(5*sizeof(int)); // array is created in heap memory 
+	p[0]=9;p[1]=7;p[2]=22;p[3]=11;p[4]=12;
+	
+	q= (int *) malloc(10*sizeof(int)); // increasing size of array in heap memory
+	
+	for (i=0;i<5;i++)
+	q[i]=p[i];
+	
+	free(p);
+	p=q;
+	q=NULL;
+	
+	for (i=0;i<5;i++)
+	printf("%d \n",p[i]);
+	return 0;
+}

Arrays/02_increasing_size_of_array_using_heap.cpp

@@ -0,0 +1,30 @@
+ // Creating 2-D array 
+#include<stdio.h>
+#include<stdlib.h>
+int main ()
+{ // normal delaration and initialization 
+	int A[3][4]={{1,2,3,4},{2,4,6,8},{1,3,5,7}}; // stack memory
+	
+	// pointer decleration 
+int *B[3]; 
+int **C; // double pointer , completly in heap memory
+int i,j;
+	
+B[0]=(int *)malloc(4*sizeof(int)); // Creating memory in heap
+B[1]=(int *)malloc(4*sizeof(int));
+B[2]=(int *)malloc(4*sizeof(int));
+	
+C=(int **)malloc(3*sizeof(int *));
+C[0]=(int *)malloc(4*sizeof(int));
+C[1]=(int *)malloc(4*sizeof(int));
+C[2]=(int *)malloc(4*sizeof(int));
+	
+for (i=0;i<3;i++)
+{
+for (j=0;j<4;j++)
+printf("%d ",A[i][j]);
+printf("\n");
+}
+return 0;
+}
+ 

Arrays/02_increasing_size_of_array_using_heap.exe

@@ -0,0 +1,40 @@
+#include <stdio.h>
+#include<stdlib.h>
+struct Array
+{
+	int* A;
+	int size;
+	int length;
+};
+
+// fxn for display all the elements of the array
+
+void Display(struct Array arr)
+{
+	int i;
+	printf("Elements Are\n");
+	for (i = 0; i < arr.length; i++)
+		printf("%d ",arr.A[i]); // it will display all the elements 
+}
+int main()
+{
+	struct Array arr;
+	int n; // how many no is going to be inserted 
+	int i;
+	printf("Enter size of an array ");
+	scanf_s("%d", &arr.size);
+	arr.A = (int*)malloc(arr.size * sizeof(int)); // dynamically created array 
+	arr.length = 0;// intially no elements 
+	printf("Enter number of numbers ");
+	scanf_s("%d", &n);
+	printf("Enter All the elements ");
+	for (i = 0; i < n; i++)
+		scanf_s("%d", &arr.A[i]); // enter the elements of an array 
+	arr.length = n; // set length as n 
+
+
+	Display(arr);
+
+
+	return 0;
+}

Arrays/03_Creating_2D_array_Accessing.c

@@ -0,0 +1,54 @@
+#include <iostream>
+using namespace std;
+struct Array
+{
+	int A[10];
+	int size;
+	int length;
+};
+void Display(struct Array arr)
+{
+	int i;
+	cout<<"printing all the elements "<<endl;
+	for (i = 0; i < arr.length; i++)
+		cout << arr.A[i] << " ";
+}
+void Add(struct Array *arr , int x) // element to be inserted 
+{
+	if (arr->length < arr->size)
+		arr->A[arr->length++] = x; // increment the size of array and fit the elements // it will take the constant time 
+}
+void Insert(struct Array* arr, int index, int x) // the index at which we want to enter // and the value we want tpo enter 
+{
+	int i;
+	for (i = arr->length; i > index; i--) // we will strat from last of the array and shift the elements upto the given index 
+	{
+		arr->A[i] = arr->A[i - 1]; // shifting the elements to next  // i is on some index and copy the value from previous index 
+	}
+	arr->A[index] = x; // set the value at the particular index 
+	arr->length++; // increment the size of length 
+	// work done shifting of elelmets and copying elements 
+	// best case : --------------- min : O(1) // there may be zero shifting 
+	// worst case : --------------- max : O(n)// there may be n shifing 
+
+}
+
+int main() {
+	int no;
+	struct Array arr;
+	cout << "Enter the size of the array " << endl;
+	cin >> arr.size;
+	arr.A = new int[arr.size];
+	arr.length = 0;
+	cout << "Enter the length of array" << endl;
+	cin >> no;
+	cout << "Enter all the elements of array" << endl;
+	for (int i = 0; i < no; i++)
+		cin >> arr.A[i];
+	arr.length = no;
+	Add(&arr, 10);
+	Insert(&arr,3,25);
+	Display(arr);
+
+	return 0;
+}

Arrays/03_Creating_2D_array_Accessing.exe

@@ -0,0 +1,45 @@
+#include <stdio.h>
+
+struct Array 
+{
+	int A[10];
+	int length;
+	int size;
+};
+
+int Display(struct Array arr)
+{
+	int i;
+	printf("Elements Are\n");
+	for (i=0;i<arr.length;i++)
+	printf("%d ",arr.A[i]);
+	return 0;
+}
+int Delete (struct Array *arr, int index)
+
+/* Difference between Dot(.) and Arrow(->) operator:
+
+The Dot(.) operator is used to normally access members of a structure or union.
+The Arrow(->) operator exists to access the members of the structure or the unions using pointers. */
+{
+	int x=0;
+	int i;
+	if (index>=0 && index <arr->length)
+	{
+		x=arr->A[index]; // first of all take out the element from the particular index you want to del---------------------> taking 1 unit of time 
+		for (i=index;i<arr->length-1;i++) // shift the element in forward direnction and stop at length -1 so that array can not have any vacant space 
+		arr->A[i]=arr->A[i+1]; // at the place of a[i] copy the next element i.e a[i+1]
+		arr->length--;//at last the length will be decreatmented ----------------> 1 unit of time -------> so best time is 1+1 =2 
+		
+		// min shifting is 0 and max shifting is n ----> Best case time is O(1) -> Worst Case time is ----> O(n)
+		return x;
+	}
+	return 0;
+}
+int main ()
+{
+	struct Array arr1={{1,2,3,4,56,5,2},10,5};
+	printf("%d\n",Delete(&arr1,0));
+	Display(arr1);
+	return 0;
+}

Arrays/04_Array_ADT.c

@@ -0,0 +1,31 @@
+#include<stdio.h>
+struct Array {
+	int A[20];
+	int length;
+	int size;
+	
+};
+void Display (struct Array arr)
+{
+	int i;
+	printf("\nEnter elements\n");
+	for (i=0;i<arr.length;i++)
+	printf("%d ",arr.A[i]);
+}
+int LinearSearch (struct Array arr, int key)
+{
+	int i;
+	for (i=0;i<arr.length;i++)
+	{
+		if (key==arr.A[i]) // formula 
+		return i;
+	}
+	return -1;
+}
+int main ()
+{
+	struct Array arr1= {{2,3,4,2,3,4,5,88,9	},20,5	};
+	printf("The element is at %dth index",LinearSearch(arr1,88));
+	Display(arr1);
+	return 0;
+}

Arrays/05_inserting_an_element.cpp

@@ -0,0 +1,41 @@
+#include<stdio.h>
+struct Array {
+	int A[20];
+	int length;
+	int size;
+	
+};
+void Display (struct Array arr)
+{
+	int i;
+	printf("\nEnter elements\n");
+	for (i=0;i<arr.length;i++)
+	printf("%d ",arr.A[i]);
+}
+void swap(int *x,int *y)
+ {
+ int temp=*x;
+ *x=*y;
+ *y=temp;
+ }
+int LinearSearch(struct Array *arr,int key)
+{
+ int i;
+ for(i=0;i<arr->length;i++) // iterating through the list 
+ {
+ if(key==arr->A[i]) // checking whether elements is equal to the key elements or not 
+ {
+ swap(&arr->A[i],&arr->A[0]); // this is move to 1st method // from this we can reduce time to O(1) // when we will search the same element again 
+ return i;
+ }
+ }
+ return -1;
+}
+
+int main ()
+{
+	struct Array arr1= {{2,3,4,2,3,4,5,88,9	},20,5	};
+	printf("The element is at %dth index",LinearSearch(&arr1,9));
+	Display(arr1);
+	return 0;
+}

Arrays/06_Deleting_element_from_array.c

@@ -0,0 +1,39 @@
+#include<stdio.h>
+struct Array 
+{
+	int A[10];
+	int size;
+	int length;
+};
+ void Display(struct Array arr)
+ {
+ int i;
+ printf("\nElements are\n");
+ for(i=0;i<arr.length;i++)
+ printf("%d ",arr.A[i]);
+ }
+int BinarySearch(struct Array arr,int key)
+{
+ int l,mid,h;
+ l=0;
+ h=arr.length-1;
+ while(l<=h)
+ {
+ mid=(l+h)/2;
+ if(key==arr.A[mid])
+ return mid;
+ else if(key<arr.A[mid])
+ h=mid-1;
+ else
+ l=mid+1;
+ }
+return -1;
+}
+int main ()
+{
+	struct Array arr1= {{1,2,43,55,57,87,98,444,999},10,9};
+	printf("The element is present at %d position",BinarySearch(arr1,98));
+	Display(arr1);
+	return 0;
+	
+}

Arrays/07_Linearsearch.c

@@ -0,0 +1,40 @@
+#include<stdio.h>
+struct Array {
+	int A[10];
+	int length;
+	int size;
+	
+};
+void Display (struct Array arr)
+{
+	int i;
+	printf("Enter all the elements ");
+	for (i=0;i<arr.length;i++)
+	printf("%d ",arr.A[i]);
+
+}
+int RBinSearch(int a[],int l,int h,int key)
+{
+
+ int mid=0;
+ if(l<=h)
+ {
+ mid=(l+h)/2;
+ if(key==a[mid])
+ return mid;
+ else if(key<a[mid])
+ return RBinSearch(a,l,mid-1,key);
+ }
+ else
+ return RBinSearch(a,mid+1,h,key);
+return -1;
+}
+
+int main ()
+{
+	
+	struct Array arr1={{1,3,5,6,7,8,77,777,888},10,8};
+	printf("The element is at index %d\n",RBinSearch(arr1.A,0,arr1.length,5));
+	Display(arr1);
+	return 0;
+}