Merge branch 'smv1999:master' into redundant-braces

Author: ishikasinha-d

Arrays/Maximum_Difference.py

@@ -0,0 +1,50 @@
+'''
+From all the positive integers entered in a list, the aim of the program is 
+to subtract any two integers such that the result/output is the maximum 
+possible difference.
+
+'''
+
+# class to compute the difference
+class Difference:
+    def __init__(self, a):
+        # getting all elements from the entered list
+        self.__elements = a     
+    def computeDifference(self):
+        # maximum difference would be the difference between the largest and the smallest integer 
+        Difference.maximumDifference = max(self.__elements)-min(self.__elements)
+        return Difference.maximumDifference
+# end of Difference class
+
+# getting the input 
+_ = input()
+a = [int(e) for e in input().split(' ')]
+
+# creating an object of the class
+d = Difference(a)
+# calling function 'computeDifference' to compute the difference
+d.computeDifference()
+
+# printing the result
+print(d.maximumDifference)
+
+'''
+
+COMPLEXITY:
+	
+	 Time Complexity -> O(N)
+	 Space Complexity -> O(1)
+     
+Sample Input:
+3
+1 2 5
+
+Sample Output:
+4
+
+Explanation:
+Integer with max value--> 5
+Integer with min value--> 1
+Hence, maximum difference--> 5-1 = 4
+    
+'''

Arrays/Min_Max_Sum.py

@@ -0,0 +1,50 @@
+'''
+Aim: Given five positive integers, find the minimum and maximum values that can be calculated by summing exactly four of the five integers.
+
+Example:
+arr = [1,3,5,7,9]
+The minimum sum is 1+3+5+7 = 16 and the maximum sum is 3+5+7+9 = 24. So, the output will be:
+16 24
+
+'''
+
+def MMSum(a):
+    # sorting the array so that it becomes easier to find the min and max set of values
+    a.sort()    
+    minn=0
+    maxx=0
+    for i in range(0,4):
+        # summing up all minimum values
+        minn+=a[i]           
+    for i in range(1,5):
+        # summing up all maximum values
+        maxx+=a[i]           
+    print(minn,maxx)
+
+# getting the input    
+user_input = (input().strip().split()) 
+array = []
+for i in user_input:
+    array.append(int(i))
+# calling the Min-Max-Sum function     
+MMSum(array)                           
+  
+'''
+
+COMPLEXITY:
+	
+	 Time Complexity -> O(N)
+	 Space Complexity -> O(N)
+     
+Sample Input:
+2 1 3 4 5
+
+Sample Output:
+10 14
+
+Explanation:
+Sorted array: [1,2,3,4,5]
+Min Sum: 1+2+3+4 = 10
+Max Sum: 2+3+4+5 = 14
+
+'''

Arrays/integer.c

@@ -0,0 +1,94 @@
+/* Title : Enter the data elments before that mention the their total count . .
+            After entering the data you first missed positive integer missed will
+            be displayed .
+            Code is done in C language .
+*/
+#include<stdio.h>
+#include<stdlib.h>
+int main()
+{
+  int n ,j=0, i,k=1 , val;
+  int opt=1;
+  printf("\n Enter the total number of elements : \n");
+  scanf("%d",&n);
+  if(n<=0)
+  {
+    printf("\n Invalid Input , Try again later !!  \n");
+    exit(0);
+  }
+  int a[n];
+  printf("\n Enter the elements : \n");
+  for(i=0;i<n;i++)
+    {  scanf("%d",&a[i]); }
+
+    for(i=0;i<n;i++)
+{    for(j=0;j<n-1;j++)
+     if(a[j]>a[j+1])
+       { val=a[j];
+         a[j]=a[j+1];
+         a[j+1]=val; }
+}
+    printf("\n Sorted array : \n");
+    for(i=0;i<n;i++)
+    {
+      printf(" %d  ", a[i]);
+    }
+    printf("\n \n");
+    printf("\n Postive element missed from the data  is ");
+if(a[n-1]<=0)
+{
+   printf("\n1\n");
+
+
+}
+else {
+
+    for(i=0;i<n;i++)
+    {
+      if(a[i]>0)
+      {
+        for(j=0+i, k=1;j<=n && k<=n+1;k++,j++)
+         {
+             if(a[j]==k)
+             {
+               continue ;
+             }
+             else
+             {
+
+                 printf(" %d " ,k);
+                  exit(0);
+
+                  }
+
+
+
+          }
+       }
+     }
+  }
+
+}
+
+
+/*
+
+Enter the total number of elements :
+7
+
+Enter the elements :
+0
+-1
+1
+-2
+-3
+-4
+-5
+
+Sorted array :
+-5   -4   -3   -2   -1   0   1
+
+
+Postive element missed from the data  is  2
+
+*/

Codechef Problems/Food_Chain.c

@@ -0,0 +1,59 @@
+/*  PROBLEM STATEMENT
+A great deal of energy is lost as metabolic heat when the organisms from one trophic level are consumed by the next level.
+Suppose in Chefland the energy reduces by a factor of K, i.e, if initially, the energy is X, then the transfer of energy to the next tropic level is ⌊XK⌋. This limits the length of foodchain which is defined to be the highest level receiving non-zero energy.
+E is the energy at the lowest tropic level. Given E and K for an ecosystem, find the maximum length of foodchain.
+Note: ⌊x⌋ denoted the floor function, and it returns the greatest integer that is less than or equal to x (i.e rounds down to the nearest integer). For example, ⌊1.4⌋=1, ⌊5⌋=5, ⌊−1.5⌋=−2, ⌊−3⌋=−3 , ⌊0⌋=0.
+Input Format
+First line will contain T, number of testcases. Then the testcases follow.
+Each testcase contains a single line of input, two integers E,K.
+Output Format
+For each testcase, output in a single line answer to the problem.
+Constraints
+1≤T≤104
+1≤E≤109
+2≤K≤109
+Sample Input 1 
+3
+5 3
+6 7
+10 2
+Sample Output 1 
+2
+1
+4
+Explanation
+TestCase 1: The energy at first level is 5 units. For the second level energy becomes ⌊53⌋=1 units. So the length of foodchain is 2 since from the next level onwards 0 units of energy will be received.
+TestCase 3: The energy at different levels is:
+Level 1- 10 units
+Level 2- ⌊102⌋=5 units
+Level 3- ⌊52⌋=2 units
+Level 4- ⌊22⌋=1 units
+Level 5- ⌊12⌋=0 units
+So the answer is 4, since it is the last level to receive non-zero energy. */
+#include <stdio.h>
+
+int main(void) {
+	
+	int t,e,k;
+	int i; int j=0;
+	scanf("%d",&t);
+	int tc=t; int arr[t];
+	 while(t--)
+	 {
+	     	scanf("%d %d",&e,&k);
+	     	int count=0;
+	     	i=e;
+	     	while(i>0)
+	     	{
+	     	        count++;
+	     	        i=i/k;
+	     	   
+	     	}
+	     	arr[j]=count;
+	     	j++;
+	 }
+	 
+	for(j=0;j<tc;j++)
+	printf("%d\n",arr[j]);
+	return 0;
+}

DSA 450 GFG/reverse_linked_list_iterative.py

@@ -0,0 +1,34 @@
+#https://leetcode.com/problems/reverse-linked-list/
+
+# Iterative method
+#Approach : 
+
+# Store the head in a temp variable called current . 
+
+#   curr = head , prev = null 
+
+# Now for a normal linked list , the current will point to the next node and so on till null 
+# For reverse linked list, the current node should point to the previous node and the first node here will point to null 
+
+# Keep iterating the linkedlist until the last node and keep changing the next of the current node to prev node and also 
+# update the prev node to current node and current node to next node
+
+
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+
+class Solution:
+    
+    def reverseList(self, head):
+        curr = head
+        prev = None
+        while(curr != None):
+          next = curr.next
+          curr.next = prev
+          prev = curr
+          curr = next
+          
+        return prev
+          

DSA 450 GFG/reverse_linked_list_rec.py

@@ -0,0 +1,23 @@
+# Approach :
+# Divide the linked list to two halved
+# First half is head and the remaining as rest 
+# The head points to the rest in a normal linked list 
+# In the reverse linked list , the next of current points to the prev node and the head node should point to NULL
+# Keep continuing this process till the last node 
+
+
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+
+
+class Solution:
+    def reverseList(self, head):
+        if head is None or head.next is None:
+          return head
+        rest = self.reverseList(head.next)
+        head.next.next = head
+        head.next = None
+        return rest