Merge branch 'smv1999:master' into Keerthana

Author: KeerthanaPravallika

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;
+}

Codechef Problems/MaximumArrayXOR.java

@@ -0,0 +1,76 @@
+/*
+ * Implementation of Maximum Array XOR problem from CodeChef
+ * 
+ * Problem name: Maximum Array XOR problem
+ * Problem code: MAXARXOR
+ * Problem link: https://www.codechef.com/START7C/problems/MAXARXOR
+ * 
+ * Solution:
+ * 
+ * Value of an array A  is defined as the sum of (A(i)⊕i) for all 0≤i<L, where ⊕ denotes bitwise xor operation.
+ * You are given an integer N and an array A consisting of 2^N integers where A(i)=i for all 0≤i<2^N.
+ * Example :
+ *     - For N=1, you have an array A of length 2^1=2 and A=[0,1].
+ *     - For N=2, you have an array A of length 2^2=4 and A=[0,1,2,3].
+ * 
+ * You can do at most K operations on this array. In one operation, you can choose 
+ * two indices i and j (0≤i,j<2^N) and swap A(i) and A(j) (i.e. A(i) becomes A(j) and vice versa).
+ *  
+ * In this problem, we need to find the maximum value of array A after at most K operations.
+ * Maximum value is only possible when the value (A(i)⊕i) is 2^N - 1 for each index. So to get maximum value for each index
+ * we have to swap values according to the condition. But to get the solution of this problem we don't really need to swap.
+ * We can find the maximum value of array without actually swapping them.
+ * 
+ * For every single swap we will maximize the value of two indexes in the array, so for K operations we can
+ * maximize 2*K cells. But it is also possible that 2*K cells can be greater than 2^N so that's why
+ * we will reduce it. It's given in the question that atmost K operations are allowed. So now we need
+ * to multiply 2*K to 2^N - 1, to get the maximum value.
+ * 
+ */
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+class MaximumArrayXOR
+{
+    public static void main (String[] args) throws java.lang.Exception
+    {
+        Scanner sc=new Scanner(System.in);
+        int t=sc.nextInt();
+        
+        while(t-->0)
+        {
+            long count=0;
+            long N=sc.nextInt();
+            long K=sc.nextInt();
+            
+            //maximum value each cell of the array should have
+            count=(long)Math.pow(2,N);
+            
+            //reducing value of K if it is greater than count/2
+            //count/2 is the maximum number of swaps that can be performed to get the maximum value of Array
+            if(K>=count/2)
+            K=count/2;
+            
+            //finding out the maximum value of Array
+            count=(count-1)*K*2;
+        
+            System.out.println(count);
+            
+        }
+    }
+}
+/*
+ * Sample Input 1 
+ * 3
+ * 2 0
+ * 2 1
+ * 10 100
+ * 
+ * Sample Output 1 
+ * 0
+ * 6
+ * 204600
+ * 
+ * Time complexity: O(n)
+ */