Merge branch 'master' of https://github.com/smv1999/CompetitiveProgrammingQuestionBank

Author: smv1999

2D Arrays/rotate_by_90.cpp

@@ -0,0 +1,55 @@
+// Given a square matrix of size N x N. The task is to rotate it by 90 degrees in anti-clockwise direction without using any extra space.
+
+#include<bits/stdc++.h>
+#include <stdio.h>
+using namespace std;
+
+int main()
+{
+    int t; cin>>t;
+    
+    while(t--)
+    {
+        int n;
+        cin>>n;
+        int matrix[n][n];
+     
+        for(int i = 0; i < n; i++)
+        {
+            for(int j = 0; j < n; j++)
+            {
+                cin>>matrix[i][j];
+            }
+        }
+        
+    //rotating the matrix by 90 , anticlockwise        
+    // the matrix will have floor(n/2) cycles 
+    for(int i=0; i<n/2; i++)
+    {
+        //parsing through each cycle and rotating
+        for(int j=i; j< n-i-1; j++)
+        {
+            //stored current element in temporary variable temp
+            int temp= matrix[i][j];
+            
+            //shifted right element to top
+            matrix[i][j]= matrix[j][n-i-1];
+            
+            //shifted bottom element to right
+            matrix[j][n-i-1]= matrix[n-1-i][n-1-j];
+            
+            //shifted left element to bottom
+            matrix[n-1-i][n-1-j] = matrix[n-1-j][i];
+            
+            //assign temp to left
+            matrix[n-1-j][i]= temp;
+        }
+    }
+    
+    for(int i = 0; i < n; i++)
+        for(int j=0; j<n; j++)
+                cout<< matrix[i][j];
+        cout<<endl;
+    }
+    return 0;
+}  

2D Arrays/transpose.java

@@ -0,0 +1,150 @@
+/*
+   Title : Find the transpose of the matrix .
+           User needs to provide the number of rows and columns .
+           And the user needs to provide the elements of the matrix .
+           User will get the transpose of the matrix .
+           i.e Row elements become the column elements and vice- versa .
+           **** Maximum 10 number of rows and columns can be only entered .
+   */
+import java.util.Scanner;
+import java.lang.*;
+class transpose
+{
+    final static int MAXLIMIT=10 ;
+    private int row;
+    private int col;
+    int i ,j ;
+    private double a[][];
+
+    transpose(int rows , int cols)      //Constructor
+    {
+        row=rows ;
+        col=cols ;
+        a=new double[row][col] ;
+
+    }
+
+    Scanner in=new Scanner(System.in);
+
+    public void get ()
+    {
+       System.out.println("\n Enter the elements : \n");
+        for(i=0;i<row;i++)
+        {
+            for(j=0;j<col;j++)
+            {
+                a[i][j]=in.nextDouble();
+            }
+        }
+
+    }
+
+    public void display ()
+    {
+        System.out.println( "\n Matrix A  " + row + " * " + col + " : \n") ;
+
+        for(i=0;i<row;i++)
+        {
+            for(j=0;j<col;j++)
+            {
+                System.out.print(a[i][j]+ "\t") ;
+            }
+            System.out.println("\n") ;
+        }
+    }
+
+     public void trans()
+    {
+        System.out.println( "\n\n The transpose of the given matrix : \n");
+        System.out.println( "\n Matrix AT " + col + " * " + row+ " : \n") ;
+
+        for(i=0;i<col;i++)
+        {
+            for(j=0;j<row;j++)
+            {
+                System.out.print(a[j][i]+ "\t") ;
+            }
+            System.out.println("\n") ;
+        }
+    }
+
+    public static void main (String [] args  )
+    {
+      int rows , cols ;
+      int opt;
+      Scanner in=new Scanner(System.in);
+      do
+      { opt=0;
+      System.out.println("\n Enter the total number of rows and columns respectively : \n");
+       rows=in.nextInt();
+       cols=in.nextInt();
+       if(rows>MAXLIMIT|| cols>MAXLIMIT|| rows<1||cols<1)
+       {
+           System.out.println("\n  Invalid enteries ! \n  Remember ,  Maximum limit of rows and columns is 10 .\n");
+           System.out.println("  Do you wish to continue ? \n  Press 1  if yes otherwise any to stop . \n");
+           opt=in.nextInt();
+       }
+
+       else
+       {
+
+       transpose A = new transpose(rows , cols);
+       A.get();
+       A.display();
+       A.trans();
+
+
+       }
+      } while(opt==1);
+
+    }
+
+}
+
+/*
+
+Enter the total number of rows and columns respectively :
+
+13
+1
+
+  Invalid enteries !
+  Remember ,  Maximum limit of rows and columns is 10 .
+
+  Do you wish to continue ?
+  Press 1  if yes otherwise any to stop .
+
+1
+
+ Enter the total number of rows and columns respectively :
+
+3
+2
+
+ Enter the elements :
+
+1
+2
+3
+5
+5
+5
+
+ Matrix A  3 * 2 :
+
+1.0     2.0
+
+3.0     5.0
+
+5.0     5.0
+
+
+ The transpose of the given matrix : \n");
+
+ Matrix AT 2 * 3 :
+
+1.0     3.0     5.0
+
+2.0     5.0     5.0
+
+*/

2D Arrays/transpose_of_matrix.cpp

@@ -0,0 +1,50 @@
+//Write a program to find the transpose of a square matrix of size N*N. The transpose of a matrix is obtained by changing rows to columns and columns to rows.
+
+#include <bits/stdc++.h> 
+using namespace std; 
+
+//Function to find transpose of a matrix.
+void transpose(vector<vector<int> > &matrix, int n)
+{ 
+    for(int i=0; i< n; i++)
+    {
+            
+    for(int j=i; j< n; j++)
+        {
+           swap(matrix[i][j], matrix[j][i]);
+        }  
+    }
+}
+    
+int main() 
+{
+
+int t;
+cin>>t;
+    
+while(t--) 
+{
+    int n;
+    cin>>n;
+    vector<vector<int> > matrix(n); 
+
+    for(int i=0; i<n; i++)
+    {
+        matrix[i].assign(n, 0);
+        for( int j=0; j<n; j++)
+        {
+            cin>>matrix[i][j];
+        }
+    }
+
+    transpose(matrix,n);
+    for (int i = 0; i < n; ++i)
+       { 
+           for (int j = 0; j < n; ++j)
+                cout<<matrix[i][j]<<" ";
+        cout<<endl;
+        }
+}
+return 0;
+
+}  

Arrays/Hourglass_Sum.py

@@ -0,0 +1,65 @@
+'''
+Given a 6X6 2D Array, A:
+1 1 1 0 0 0
+0 1 0 0 0 0
+1 1 1 0 0 0
+0 0 0 0 0 0
+0 0 0 0 0 0
+0 0 0 0 0 0
+
+An hourglass in A is a subset of values with indices falling in this pattern 
+in A's graphical representation:
+a b c
+  d
+e f g
+
+There are 16 hourglasses in A, and an hourglass sum is the sum of an hourglass' 
+values. Like here, the maximum hourglass sum is 7 for the hourglass in the top 
+left corner.
+
+Aim: Check all such hourglasses and print the maximum hourglass sum for the 
+2D array entered by user.
+
+'''
+
+# getting the 2D array as input
+arr = []
+for _ in range(6):
+    arr.append(list(map(int, input().rstrip().split())))
+
+res = []
+# looping through the 2D array
+for x in range(0, 4):
+    for y in range(0, 4):
+        # selecting combinations that make an hourglass
+        s = sum(arr[x][y:y+3]) + arr[x+1][y+1] + sum(arr[x+2][y:y+3])
+        res.append(s)
+# printing out the maximum hourglass sum        
+print(max(res))
+
+'''
+
+COMPLEXITY:
+	
+	 Time Complexity -> O(N^2)
+	 Space Complexity -> O(N)
+     
+Sample Input:
+0 0 1 2 3 0
+0 0 0 5 0 0
+1 0 0 7 1 0
+0 0 0 0 0 0
+0 1 1 1 0 1
+0 0 4 0 0 4
+
+Sample Output:
+19
+
+Explanation:
+The hourglass with the maximum sum is,
+1 2 3
+  5 
+0 7 1
+with the sum being 1 + 2 + 3 + 5 + 0 + 7 + 1 = 19
+    
+'''

Arrays/Leap_Year.py

@@ -0,0 +1,34 @@
+'''
+Aim: To check if the entered year is a leap year or not.
+
+'''
+
+def is_leap(year):
+    # a year is a leap one if it's divisible by 4 and if it's not 
+    # divisible by 100 or is divisible by 400
+    print((year%4==0 and (year%100!=0 or year%400==0))) 
+
+# getting the input
+year = int(input().strip())
+# displaying the result
+is_leap(year) 
+
+'''
+
+COMPLEXITY:
+	
+	 Time Complexity -> O(1)
+	 Space Complexity -> O(1)
+     
+Sample Input:
+2000
+
+Sample Output:
+True
+
+Explanation:
+2000 % 400 = 0 
+2000 % 4 = 0
+Hence, 2000 was a leap year.
+
+'''