├── day_61.java
├── day_70.java
├── day_77.java
├── day_74.java
├── day_68.java
├── day_64.java
├── day_66.java
├── day_79.java
├── day_67.java
├── day_72.java
├── day_78.java
├── day_62.java
├── day_75.java
├── day_69.java
├── README.md
├── day_63.java
├── day_71.java
├── day_65.java
├── day_76.java
├── day_80.java
└── day_73.java


/day_61.java:
--------------------------------------------------------------------------------
 1 | class Solution {//sort the people based on height
 2 |     public String[] sortPeople(String[] names, int[] heights) {
 3 |         for(int i=0;i<heights.length;i++){
 4 |             for(int j=i+1;j<heights.length;j++){
 5 |                 if(heights[i]<heights[j]){
 6 |                     int temp=heights[i];
 7 |                     heights[i]=heights[j];
 8 |                     heights[j]=temp;
 9 |                     String te=names[i];
10 |                     names[i]=names[j];
11 |                     names[j]=te;
12 |                 }
13 | 
14 |             }
15 |             
16 |         }return names;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/day_70.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Hello {
 3 | 
 4 |     public static void main(String[] args) {
 5 | 		//Nth-Character Binary String;
 6 | 		Scanner sc=new Scanner(System.in);
 7 | 		String str=sc.next();
 8 | 		sc.nextLine();
 9 | 		int a=sc.nextInt();
10 | 		int b=sc.nextInt();
11 |         String ans="";
12 |         int c=-1;
13 |         for(char i:str.toCharArray()){
14 |             c++;
15 |             if(c<=a-1){
16 |                 if(i=='0'){
17 |                     
18 |                     ans+="01";
19 |                    
20 |                 }
21 |                 else{
22 |                     ans+="10";
23 |                 }
24 |                 
25 |             }
26 |             else{
27 |                 ans+=i;
28 |             }
29 |         }
30 |         System.out.print(ans.charAt(b-1));
31 | 	}
32 | }
33 | 


--------------------------------------------------------------------------------
/day_77.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Hello {
 3 | 
 4 |     public static void main(String[] args) {
 5 | 		//Difference-Two Time Periods
 6 | 		Scanner sc=new Scanner(System.in);
 7 | 		String[] a=sc.nextLine().split(":");
 8 | 		String[] b=sc.nextLine().split(":");
 9 | 		int f=0;
10 | 		int s=0;
11 | 		for(int i=0;i<3;i++){
12 | 		    f+=(Integer.parseInt(a[i])*(Math.pow(60,2-i)));
13 | 		    s+=(Integer.parseInt(b[i])*(Math.pow(60,(2-i))));
14 | 		    
15 | 		}
16 | 		int ans=Math.abs(s-f)/3600;
17 | 		int ans2=Math.abs(s-f)%3600;
18 | 		int min=ans2/60;
19 | 		int sec=ans2%60;
20 | 	
21 | 		System.out.print(format(ans,min,sec));
22 | 
23 | 	}
24 | 	static String format(int a,int b,int c){
25 | 	    String ans="";
26 | 	    if(a<10) ans+='0';
27 | 	    ans+=a+":";
28 | 	    if(b<10) ans+='0';
29 | 	    ans+=b+":";
30 | 	    if(c<10) ans+='0';
31 | 	    ans+=c;
32 | 	    return ans;
33 | 	    
34 | 	}
35 | }
36 | 


--------------------------------------------------------------------------------
/day_74.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Hello {
 3 | 
 4 |     public static void main(String[] args) {
 5 | 		//Pairs-Unit Digit Sum
 6 | 		String[] str=new Scanner(System.in).next().split("");
 7 | 		int und=Integer.parseInt(str[str.length-1]);
 8 | 		List<Integer> ip=new ArrayList<>();
 9 | 		for(String i : str){
10 | 		    ip.add(Integer.parseInt(i));
11 | 		}
12 | 		int c=0;
13 | 		Set<Integer> set=new HashSet<>();
14 | 		for(int i=0;i<ip.size()-1;i++){int id=0;
15 | 		    for(int j=i+1;j<ip.size()-1;j++){
16 | 		        if((int)((int)ip.get(i)+(int)ip.get(j))==und&&(!set.contains(ip.get(i))&&!set.contains(ip.get(j)))){
17 | 		            id=j;
18 | 		            set.add(ip.get(i));
19 | 		            set.add(ip.get(j));
20 | 		           c++;
21 | 		          //  System.out.println(ip.get(i)+" "+ip.get(j));
22 | 		         
23 | 		           
24 | 		        }}}
25 | 		    
26 | 		
27 | 		System.out.print((c==0)?-1:c);
28 | 
29 | 	}
30 | }
31 | 
32 | 
33 | 
34 | 


--------------------------------------------------------------------------------
/day_68.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Hello {
 3 | 
 4 |     public static void main(String[] args) {
 5 | 		//largest Square Submatrix
 6 | 		Scanner sc=new Scanner(System.in);
 7 | 		int r=sc.nextInt();
 8 | 		int c=sc.nextInt();
 9 | 		int[][] ar=new int[r][c];
10 | 		for(int i=0;i<r;i++) for(int j=0;j<c;j++) ar[i][j]=sc.nextInt();
11 | 		int key=sc.nextInt();
12 | 		boolean f=true;
13 | 		int id1=0,id2=0;
14 | 		for(int i=0;i<r&&f;i++) for(int j=0;j<c;j++){
15 | 		    if(ar[i][j]==key){
16 | 		        id1=i;
17 | 		        id2=j;
18 | 		        f=false;
19 | 		        break;
20 | 		    }
21 | 		}
22 | 	
23 | 	if(id1==0||id2==0||id1==r-1||id2==c-1||(id1==r-1&&id2==c-1)){
24 | 	    System.out.print(key);return;
25 | 	}
26 | 		int st=Math.min(Math.min(r-id1,c),Math.min(c-id2,r));
27 | 		
28 | 		int end=id2+st;
29 | 		for(int i=id1-st+1;i<id1+st;i++){
30 | 		    for(int j=id2-st+1;j<end;j++){
31 | 		        System.out.print(ar[i][j]+" ");
32 | 		    }System.out.print("\n");
33 | 		}
34 | 		
35 | 		
36 | 
37 | 	}
38 | }
39 | 


--------------------------------------------------------------------------------
/day_64.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Hello {
 3 | 
 4 |     public static void main(String[] args) {
 5 | 		//L-Shaped Palindromic Matrix {
 6 | 		   
 7 | 		Scanner sc=new Scanner(System.in);
 8 | 		int n=sc.nextInt();
 9 | 		String[] st=new String[n];
10 | 		char[][] ip=new char[n][n];
11 | 		for(int i=0;i<n;i++){
12 | 		    for(int j=0;j<n;j++){
13 | 		        ip[i][j]=sc.next().charAt(0);
14 | 		    }
15 | 		}
16 | 		for(int i=0;i<n;i++) st[i]="";
17 | 		for(int i=0;i<n;i++){
18 | 		    for(int j=0;j<n-i;j++){
19 | 		        
20 | 		        st[i]+=ip[j][i];
21 | 		    
22 | 		}
23 | 		    for(int k=i+1;k<n;k++){
24 | 		        st[i]+=ip[n-i-1][k];
25 | 		    }
26 | 		}
27 | 		for(int i=0;i<n;i++){
28 | 		    if(palin(st[i]))
29 | 		    System.out.print(st[i]+" ");
30 | 		}
31 | 	}
32 | 	static boolean palin(String a){
33 | 	    int i=0;
34 | 	    int j=a.length()-1;
35 | 	    while(i<=j){
36 | 	        if(a.charAt(i)!=a.charAt(j)) return false;
37 | 	        i++;
38 | 	        j--;
39 | 	    }
40 | 	    return true;
41 | 	}
42 | }
43 | 


--------------------------------------------------------------------------------
/day_66.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Hello {
 3 | 
 4 |     public static void main(String[] args) {
 5 | 		//Replace vowels With 1
 6 | 		String sc=new Scanner(System.in).next();
 7 | 		int C=0;//vowel count
 8 | 		String ans="";
 9 | 		String Vowel="AEIOUaeiou";
10 | 		for(char i : sc.toCharArray()){
11 | 		    if(!(i>='a'&&i<='z'||i>='A'&&i<='Z')) {System.out.print("Invalid");return;}
12 | 		    if(Vowel.contains(""+i)){
13 | 		        ans+='1';C++;
14 | 		    }else ans+=i;
15 | 		}
16 | 		System.out.print(ans+" "+C);
17 | 
18 | 	}
19 | }
20 | // #include<stdio.h>
21 | // #include<stdlib.h>
22 | 
23 | // int main()
24 | // {
25 | //     int a;
26 | //     scanf("%d",&a);
27 | //     int ar[a];
28 | //     for(int i=0;i<a;i++) scanf("%d",&ar[i]);
29 | //     for(int i=a-1;i>=0;i--){
30 | //         int r=ar[i]%10;
31 | //         if(r==0){
32 | //         if(ar[i]!=0)
33 | //         printf("%d ",ar[i]);
34 | //         }
35 | //         else if(ar[i]%r==0) 
36 | //         printf("%d ",ar[i]);
37 | //     }
38 | // }-->divisible by its unit digit
39 | 


--------------------------------------------------------------------------------
/day_79.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Hello {
 3 | 
 4 |     public static void main(String[] args) {
 5 | 		//N terms Double Series;
 6 | 		Scanner sc=new Scanner(System.in);
 7 | 		int n=sc.nextInt();
 8 | 		int x=sc.nextInt();
 9 | 		int y=sc.nextInt();
10 | 		int i=1;
11 | 		while(i<=n/2){
12 | 		    if(i%2==1)
13 | 		    System.out.print(i*x+1+" "+(i*y+1)+" ");
14 | 		    else
15 | 		    System.out.print(i*x-1+" "+(i*y-1)+" ");
16 | 		    i++;
17 | 		}
18 | 		if(n%2==1) System.out.print((i%2==0)?i*x-1:i*x+1);
19 | 
20 | 	}
21 | }
22 | import java.util.*;
23 | public class Hello {
24 | 
25 |     public static void main(String[] args) {
26 | 		//Probablitity N Balls
27 | 		Scanner sc=new Scanner(System.in);
28 | 		int a=sc.nextInt();
29 | 		int b=sc.nextInt();
30 | 		int c=sc.nextInt();
31 | 		int d=Math.min(a,c);
32 | 		int i=d;
33 | 		int j=0;
34 | 		while(i>=0&&j<=b){
35 | 		    if(i+j==c){
36 | 		        System.out.println(i+" "+j);
37 | 		        i--;
38 | 		        j=0;
39 | 		    }
40 | 		    
41 | 		    
42 | 		    if(j==b){
43 | 		        i=d;
44 | 		    }j++;
45 | 		}
46 | 
47 | 	}
48 | }
49 | 


--------------------------------------------------------------------------------
/day_67.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Hello {
 3 | 
 4 |     public static void main(String[] args) {
 5 | 		//Integer Atleast One Zero
 6 | 		Scanner sc=new Scanner(System.in);
 7 | 		int x=sc.nextInt();
 8 | 		int y=sc.nextInt();
 9 | 		boolean p=true;
10 | 		for(int i=x;i<=y;i++){
11 | 		    String r=Integer.toString(i);
12 | 		    if(r.contains("0")){
13 | 		        p=false;
14 | 		        System.out.print(i+" ");
15 | 		    }
16 | 		}
17 | 		if(p) System.out.print(-1);
18 | 
19 | 	}
20 | }
21 | import java.util.*;
22 | public class Hello {
23 | 
24 |     public static void main(String[] args) {
25 | 		//Matrix -Row&Column Pattern
26 | 		Scanner sc=new Scanner(System.in);
27 | 		int r=sc.nextInt();
28 | 		int c=sc.nextInt();
29 | 		int[][] ar=new int[r][c];
30 | 		for(int i=0;i<r;i++) for(int j=0;j<c;j++) ar[i][j]=sc.nextInt();
31 | 		for(int i=0;i<Math.min(r,c);i++){
32 | 		    for(int j=i;j<r;j++){
33 | 		        System.out.print(ar[i][j]+" ");
34 | 		    }
35 | 		    System.out.println();
36 | 		    for(int k=i+1;k<Math.min(r,c);k++){
37 | 		        System.out.print(ar[k][i]+" ");
38 | 		    }
39 | 		    if(i!=r-1)
40 | 		    System.out.println();
41 | 		}
42 | 		
43 | 
44 | 	}
45 | }
46 | 


--------------------------------------------------------------------------------
/day_72.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Hello {
 3 | 
 4 |     public static void main(String[] args) {
 5 | 		//Interlace Vowels and Consonants
 6 | 		String str=new String(new Scanner(System.in).next());
 7 | 		StringBuilder v=new StringBuilder();
 8 | 		StringBuilder c=new StringBuilder();
 9 | 		String vow="AEIOUaeiou";
10 | 		for(char i:str.toCharArray()){
11 | 		    if(vow.contains(""+i)){
12 | 		        v.append(i);
13 | 		    }
14 | 		    else{
15 | 		        c.append(i);
16 | 		    }
17 | 		}
18 | 		c.reverse();
19 | 		int vi,ci;
20 | 		vi=ci=0;
21 | 		int vl=v.length();
22 | 		int cl=c.length();
23 | 		while(vi<vl||ci<cl){
24 | 		    if(vi<vl)
25 | 		    System.out.print(v.charAt(vi));
26 | 		    if(ci<cl)
27 | 		    System.out.print(c.charAt(ci));
28 | 		    vi++;
29 | 		    ci++;
30 | 		}
31 | 
32 | 	}
33 | }
34 | import java.util.*;
35 | public class Hello {
36 | 
37 |     public static void main(String[] args) {
38 | 		//Shift Digits & Double
39 | 		String s=new Scanner(System.in).next();
40 | 		
41 | 		StringBuilder ev=new StringBuilder();
42 | 		int le=s.length();
43 | 		
44 | 		
45 | 		
46 | 		for(int i=1;i<le;i+=2){
47 | 		    ev.append(s.charAt(i));
48 | 		}
49 | 		String even=ev.charAt(ev.length()-1)+ev.substring(0,ev.length()-1);
50 | 		
51 | 		long ans=0;
52 | 		int pi=0;
53 | 		for(int i=0;i<le;i+=2){
54 | 		    ans=ans*10+(s.charAt(i)-'0');
55 | 		    if(pi<even.length())
56 | 		    ans=ans*10+(even.charAt(pi)-'0');
57 | 		    pi++;
58 | 		}
59 | 		System.out.print(ans*2);
60 | 
61 | 	}
62 | }
63 | 


--------------------------------------------------------------------------------
/day_78.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Hello {
 3 | 
 4 |     public static void main(String[] args) {
 5 | 		//Primorial Number
 6 | 		int a=new Scanner(System.in).nextInt();
 7 | 		long p=1;
 8 | 		int n=2;
 9 | 		while(a>0){
10 | 		    if(prime(n)){
11 | 		        a--;
12 | 		        p*=n;
13 | 		    }
14 | 		    n++;
15 | 		}
16 |          System.out.print(p);
17 | 	}
18 | 	static boolean prime(int a){
19 | 	    if(a<=3) return true;
20 | 	    if(a%2==0||a%3==0) return false;
21 | 	    for(int i=4;i*i<=a;i++){
22 | 	        if(a%i==0) return false;
23 | 	    }return true;
24 | 	}
25 | 	
26 | }
27 | import java.util.*;
28 | public class Hello {
29 | 
30 |     public static void main(String[] args) {
31 | 		//Words Alternate Min&Max
32 | 		String[] str=new Scanner(System.in).nextLine().split(" ");
33 | 		int i=0;
34 | 		String rs="";
35 | 		int j=str.length-1;
36 | 		while(i<j){
37 | 		    String ans="";
38 | 		    if(str[i].length()==str[j].length()){
39 | 		        rs+=(str[i]+" "+str[j]+" ");
40 | 		        i++;j--;
41 | 		        continue;
42 | 		    }
43 | 		    else if(str[i].length()<str[j].length()){
44 | 		        if(i%2==0){
45 | 		            ans=str[i];
46 | 		        }
47 | 		        else ans=str[j];
48 | 		    }
49 | 		    else if(str[i].length()>str[j].length()){
50 | 		        if(i%2==0){
51 | 		            ans=str[j];
52 | 		        }
53 | 		        else ans=str[i];
54 | 		    }
55 | 		    rs+=(ans+" ");
56 | 		    j--;
57 | 		    i++;
58 | 		}
59 | 		System.out.print(rs.trim());
60 | 
61 | 	}
62 | }
63 | 


--------------------------------------------------------------------------------
/day_62.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Hello {
 3 | 
 4 |     public static void main(String[] args) {
 5 | 		//Tooggle Exactly One Bit
 6 | 		Scanner sc=new Scanner(System.in);
 7 | 		int a=sc.nextInt();
 8 | 		String bi=Integer.toBinaryString(a);
 9 | 		int max=0;
10 | 		int n=bi.length();
11 | 		for(int i=0;i<n;i++){
12 | 		    char c=(bi.charAt(i)=='1')?'0':'1';
13 | 		    if(i!=0&&i!=n-1){
14 | 		    String maxFind=bi.substring(0,i)+c+bi.substring(i+1);
15 | 		        max=Math.max(max,Integer.valueOf(maxFind,2));
16 | 		    }
17 | 		    else if(i==0) {
18 | 		        String maxF=c+bi.substring(1);
19 | 		        max=Math.max(max,Integer.valueOf(maxF,2));
20 | 		    }
21 | 		    else{
22 | 		        String maxFi=bi.substring(0,n-1)+c;
23 | 		        max=Math.max(max,Integer.valueOf(maxFi,2));
24 | 		    }
25 | 		}
26 | 		System.out.print(max+"");
27 | 
28 | 	}
29 | }
30 | import java.util.*;
31 | public class Hello {
32 | 
33 |     public static void main(String[] args) {
34 | 		//Employee Break Timing:
35 | 		Scanner sc=new Scanner(System.in);
36 | 		int n=sc.nextInt();
37 | 		int[] st=new int[n];
38 | 		int[] en=new int[n];
39 | 		int id=0;
40 | 		int in=0;
41 | 		for(int i=0;i<n+n;i++){
42 | 		    String[] ip=sc.next().split(":");
43 | 		    int tm=Integer.parseInt(ip[0])*60+Integer.parseInt(ip[1]);
44 | 		    if(i%2==0) st[id++]=tm;
45 | 		    else en[in++]=tm;
46 | 		}
47 | 		int s=0;
48 | 		for(int i=1;i<n;i++){
49 | 		    s+=(st[i]-en[i-1]);
50 | 		}
51 | 		if(s/60!=1)
52 | 		System.out.print(s/60+" Hours "+s%60+" Minutes");
53 | 		else{
54 | 		    System.out.print("1 Hour "+s%60+" Minutes");
55 | 		}
56 |  
57 | 	}
58 | }
59 | 


--------------------------------------------------------------------------------
/day_75.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int passThePillow(int n, int time) {
 3 |         int max=1;
 4 |         int c=0;
 5 |         boolean right,left;
 6 |         right=left=false;
 7 |         while(c<time){
 8 |             c++;
 9 |             if(max==n){
10 |                 right=false;
11 |                 left=true;
12 |             }
13 |             if(max==1){
14 |                 right=true;
15 |                 left=false;
16 |             }
17 |             if(left){
18 |                 max--;
19 |             }
20 |             if(right){
21 |                 max++;
22 |             }
23 | 
24 |         }
25 |         return max;
26 |     }
27 | }
28 | import java.util.*;
29 | public class Hello {
30 | 
31 |     public static void main(String[] args) {
32 | 		//Average of Largest Integers;
33 | 		Scanner sc=new Scanner(System.in);
34 | 		int r=sc.nextInt();
35 | 		int c=sc.nextInt();
36 | 		int[][] matr=new int[r][c];
37 | 		int[] rowMax=new int[r];
38 | 		int[] columnMax=new int[c];
39 | 		for(int i=0;i<r;i++){
40 | 		    int max=0;
41 | 		    for(int j=0;j<c;j++){
42 | 		        matr[i][j]=sc.nextInt();
43 | 		        max=Math.max(max,matr[i][j]);
44 | 		    }
45 | 		    rowMax[i]=max;
46 | 		}
47 | 		for(int i=0;i<c;i++){
48 | 		    int max=0;
49 | 		    for(int j=0;j<r;j++){
50 | 		        max=Math.max(max,matr[j][i]);
51 | 		    }
52 | 		    columnMax[i]=max;
53 | 		}
54 | 		
55 | 		int s=0;
56 | 		for(int i:rowMax) s+=i;
57 | 		double rowAvg=(double)s/r;
58 | 		System.out.printf("%.2f\n",rowAvg);
59 | 		s=0;
60 | 		for(int i:columnMax) s+=i;
61 | 		double colAvg=(double)s/c;
62 | 		System.out.printf("%.2f",colAvg);
63 | 
64 | 	}
65 | }
66 | 


--------------------------------------------------------------------------------
/day_69.java:
--------------------------------------------------------------------------------
 1 | 
 2 | import java.util.*;
 3 | public class Hello {
 4 | 
 5 |     public static void main(String[] args) {
 6 | 		//Matrix -String Border;
 7 | 		Scanner sc=new Scanner(System.in);
 8 | 		String[] ip=sc.nextLine().split(" ");
 9 | 		int len=ip[0].length();
10 | 		char[][] ma=new char[len][len];
11 | 		for(int i=0;i<len;i++) for(int j=0;j<len;j++) ma[i][j]=sc.next().charAt(0);
12 | 		StringBuilder[] str=new StringBuilder[4];
13 | 		for(int i=0;i<4;i++) str[i]=new StringBuilder("");
14 | 		for(int i=0;i<len;i++) {
15 | 		   
16 | 		        str[0].append(ma[0][i]);
17 | 		    
18 | 		        str[1].append(ma[i][0]);
19 | 		    
20 | 		        str[2].append(ma[len-1][i]);
21 | 		        
22 | 		        str[3].append(ma[i][len-1]);
23 | 		}
24 | 		System.out.print(check(ip,str));
25 | 
26 | 	}
27 | 	static String check(String[] a,StringBuilder[] b){
28 | 	    for(int i=0;i<a.length;i++){
29 | 	        int j=-1;
30 | 	        for(j=0;j<4;j++){
31 | 	            if(b[j].toString().equals(a[i])||b[j].reverse().toString().equals(a[i])){
32 | 	                b[j]=new StringBuilder("");
33 | 	                break;
34 | 	            }
35 | 	            
36 | 	        }
37 | 	        if(j==4) return "No";
38 | 	    }
39 | 	    return "Yes";
40 | 	}
41 | }
42 | import java.util.*;
43 | public class Hello {
44 | 
45 |     public static void main(String[] args) {
46 | 		//Pairs-Divisible by 5
47 | 		Scanner sc=new Scanner(System.in);
48 | 		int a=sc.nextInt();
49 | 		int b=sc.nextInt();
50 | 		ArrayList<Integer> se=new ArrayList<>();
51 | 		for(int i=1;i<=b;i++) se.add(i);
52 | 		int c=0;
53 | 		for(int i=1;i<=a;i++){
54 | 		    for(int j=0;j<se.size();j++){
55 | 		        if((i+se.get(j))%5==0){
56 | 		        c++;
57 | 		        se.remove(j);
58 | 				break;
59 | 		    }}
60 | 		}
61 | 		System.out.print(c);
62 | 
63 | 	}
64 | }
65 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | 
 2 | ---
 3 | 
 4 | # Problem-Solving-Day-61-80
 5 | 
 6 | This repository contains solutions to various problem-solving exercises completed over a span of 20 days, from Day 41 to Day 60. Each day focuses on different challenges implemented in Java.
 7 | 
 8 | ## Repository Structure
 9 | 
10 | The repository is organized with each file corresponding to a specific day's challenge:
11 | 
12 | - **Java Solutions**: Files named `day_XX.java` (e.g., `day_61.java`)
13 | 
14 | ## Getting Started
15 | 
16 | To explore and run the solutions:
17 | 
18 | 1. **Clone the Repository**:
19 |    ```bash
20 |    git clone https://github.com/Krishna18062005/Problem-Solving-Day-61-80.git
21 |    ```
22 | 
23 | 2. **Navigate to the Directory**:
24 |    ```bash
25 |    cd Problem-Solving-Day-61-80
26 |    ```
27 | 
28 | 3. **Compile and Run Java Solutions**:
29 |    - Ensure you have Java installed.
30 |    - Compile the Java file:
31 |      ```bash
32 |      javac day_61.java
33 |      ```
34 |    - Run the compiled program:
35 |      ```bash
36 |      java day_61
37 |      ```
38 | 
39 | ## Prerequisites
40 | 
41 | - **Java**: Make sure Java Development Kit (JDK) is installed.
42 | 
43 | ## Contributing
44 | 
45 | Contributions are welcome! If you have alternative solutions or improvements:
46 | 
47 | 1. Fork the repository.
48 | 2. Create a new branch:
49 |    ```bash
50 |    git checkout -b feature-branch
51 |    ```
52 | 3. Commit your changes:
53 |    ```bash
54 |    git commit -m 'Add feature'
55 |    ```
56 | 4. Push to the branch:
57 |    ```bash
58 |    git push origin feature-branch
59 |    ```
60 | 5. Open a Pull Request.
61 | 
62 | ## License
63 | 
64 | This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
65 | 
66 | ## Acknowledgments
67 | 
68 | - Inspired by daily coding challenges and problem-solving practice.
69 | 
70 | ---
71 | 


--------------------------------------------------------------------------------
/day_63.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Hello {
 3 | 
 4 |     public static void main(String[] args) {
 5 | 		//Replace Rows or Columns:
 6 | 		Scanner sc=new Scanner(System.in);
 7 | 		int r=sc.nextInt();
 8 | 		int c=sc.nextInt();
 9 | 		int[][] ma=new int[r][c];
10 | 		for(int i=0;i<r;i++){
11 | 		    for(int j=0;j<c;j++){
12 | 		        ma[i][j]=sc.nextInt();
13 | 		    }
14 | 		}
15 | 		char ip=sc.next().charAt(0);
16 | 		if(ip=='D'||ip=='d'){
17 | 		    for(int i=0;i<r;i++){
18 | 		        for(int j=0;j<c;j++){
19 | 		            System.out.print(ma[r-1][j]+" ");
20 | 		        }
21 | 		        System.out.println();
22 | 		    }
23 | 		}
24 | 		else if(ip=='U'||ip=='u'){
25 | 		    for(int i=0;i<r;i++){
26 | 		        for(int j=0;j<c;j++){
27 | 		            System.out.print(ma[0][j]+" ");
28 | 		        }
29 | 		        System.out.println();
30 | 		    }
31 | 		    
32 | 		}
33 | 		else if(ip=='R'||ip=='r'){
34 | 		    for(int i=0;i<r;i++){
35 | 		        for(int j=0;j<c;j++){
36 | 		            System.out.print(ma[i][c-1]+" ");
37 | 		        }
38 | 		        System.out.println();
39 | 		    }
40 | 		    
41 | 		}
42 | 		else if(ip=='L'||ip=='l'){
43 | 		    for(int i=0;i<r;i++){
44 | 		        for(int j=0;j<c;j++){
45 | 		            System.out.print(ma[i][0]+" ");
46 | 		        }
47 | 		        System.out.println();
48 | 		    }
49 | 		    
50 | 		}
51 | 		else{
52 | 		for(int i=0;i<r;i++){
53 | 		    for(int j=0;j<c;j++){
54 | 		        System.out.print(ma[i][j]+" ");
55 | 		    }
56 | 		    System.out.println();
57 | 		}}
58 | 
59 | 	}
60 | }
61 | import java.util.*;
62 | public class Hello {
63 | 
64 |     public static void main(String[] args) {
65 | 		//Binary Pattern
66 | 		Scanner sc=new Scanner(System.in);
67 | 		int a=sc.nextInt();
68 | 		for(int i=1;i<=a;i++){
69 | 		    int po=(int)Math.pow(2,i);
70 | 		    for(int j=0;j<po;j++){
71 | 		        System.out.println(form(Integer.toBinaryString(j),i));
72 | 		    }
73 | 		}
74 | 
75 | 	}
76 | 	public static String form(String a,int i){
77 | 	    String ans="";
78 | 	    int n=i-a.length();
79 | 	    for(int j=0;j<n;j++){
80 | 	        ans+='0';
81 | 	    }
82 | 	    ans+=a;
83 | 	    return ans.replace(""," ");
84 | 	}
85 | }
86 | 


--------------------------------------------------------------------------------
/day_71.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Hello {
 3 | 
 4 |     public static void main(String[] args) {
 5 | 		//Count -First Bit !
 6 | 		int a=new Scanner(System.in).nextInt();
 7 | 		int c=0;
 8 | 		int si=Integer.toBinaryString(a).length();
 9 | 		
10 |  		for(int i=0;i<=a;i++) 
11 |  		  if(bitstartwith1(i,si)) c++;
12 |  		 System.out.print(c);
13 | 
14 | 	}
15 | 	static boolean bitstartwith1(int a,int len){
16 | 	    String st=Integer.toBinaryString(a);
17 | 	    if(st.length()!=len) return false;
18 | 	    return st.charAt(0)=='1';
19 | 	}
20 | }
21 | import java.util.*;
22 | public class Hello {
23 | 
24 |     public static void main(String[] args) {
25 | 		//String -Common Words
26 | 		Scanner sc=new Scanner(System.in);
27 | 		String[] fs=sc.nextLine().split(" ");
28 | 		String[] ls=sc.nextLine().split(" ");
29 | 		int k=sc.nextInt();
30 | 		LinkedHashSet<String> set=new LinkedHashSet<>();
31 | 	    for(String i:fs){
32 | 	        if(i.length()!=k) continue;
33 | 	        for(String j:ls){
34 | 	            if(j.length()!=k) continue;
35 | 	            if(i.equals(j)) {
36 | 	                set.add(i);
37 | 	                break;
38 | 	            }
39 | 	        }
40 | 	    }
41 | 	    if(set.isEmpty()){ System.out.print(-1);return;}
42 | 	    for(String i:set)System.out.print(i+" ");
43 | 	}
44 | }
45 | import java.util.*;
46 | public class Hello {
47 | 
48 |     public static void main(String[] args) {
49 | 		//Count N integers in M integers
50 | 		Scanner sc=new Scanner(System.in);
51 | 		int f=sc.nextInt();
52 | 		int s=sc.nextInt();
53 | 		int[] fa=new int[f];
54 | 		int[] sa=new int[s];
55 | 		for(int i=0;i<f;i++) fa[i]=sc.nextInt();
56 | 		for(int i=0;i<s;i++) sa[i]=sc.nextInt();
57 | 		
58 | 		Arrays.sort(sa);
59 | 		int i=0;
60 | 		int j=0;
61 | 		int c=0;
62 | 		while(j<s&&i<f){
63 | 		    if(fa[i]==sa[j]){
64 | 		        c++;
65 | 		        j++;
66 | 		    }
67 | 		    else if(fa[i]<sa[j]) i++;
68 | 		    else j++;
69 | 		}
70 | 		System.out.print(c);
71 | 
72 | 	}
73 | }
74 | import java.util.*;
75 | public class Hello {
76 | 
77 |     public static void main(String[] args) {
78 | 		//Insert Word In Lexicographical order
79 | 		Scanner sc=new Scanner(System.in);
80 | 		ArrayList<String> ip=new ArrayList<>();
81 | 		while(sc.hasNext()){
82 | 		    ip.add(sc.next());
83 | 		}
84 | 		Collections.sort(ip);
85 | 		for(String i: ip){
86 | 		    System.out.print(i+" ");
87 | 		}
88 | 		
89 | 
90 | 	}
91 | }
92 | 


--------------------------------------------------------------------------------
/day_65.java:
--------------------------------------------------------------------------------
  1 | import java.util.*;
  2 | public class Hello {
  3 | 
  4 |     public static void main(String[] args) {
  5 | 		//Reverse Equal Vowels and Consonants;
  6 | 		Scanner sc=new Scanner(System.in);
  7 | 		String ip=sc.nextLine();
  8 | 		String[] k=ip.split("\\s");
  9 | 		for(String i:k){
 10 | 		    if(count(i)){
 11 | 		        System.out.print(rv(i)+" ");
 12 | 		    }
 13 | 		    else{
 14 | 		        System.out.print(i+" ");
 15 | 		    }
 16 | 		}
 17 |  
 18 | 	}
 19 | 	static boolean count(String a){
 20 | 	    int c=0;
 21 | 	    String v="aeiouAEIOU";
 22 | 	    for(char j:a.toCharArray()){
 23 | 	       
 24 | 	        if(v.contains(""+j)) c++;
 25 | 	    }
 26 | 	    return c==a.length()-c;
 27 | 	}
 28 | 	static String rv(String a){
 29 | 	    String ans="";
 30 | 	    for(char i:a.toCharArray()){
 31 | 	        ans=i+ans;
 32 | 	    }
 33 | 	    return ans;
 34 | 	    
 35 | 	}
 36 | }
 37 | //this code tells about the equalsIgnoreCase: it is in C programming
 38 | // #include<stdio.h>
 39 | // #include<stdlib.h>
 40 | // #include<string.h>
 41 | // int cmp(char* a,char* b){
 42 | //     if(strlen(a)!=strlen(b)) return 1;
 43 | //     else{
 44 | //         for(int i=0;i<strlen(a);i++){
 45 | //             if(a[i]!=b[i]) return 1;
 46 | //         }
 47 | //     }
 48 | //     return 0;
 49 | // }
 50 | // int main()
 51 | // {
 52 | 
 53 | // char a[1001],b[1001];
 54 | // scanf("%s %s",a,b);
 55 | // for(int i=0;i<strlen(a);i++){
 56 | //     if(a[i]>=97){
 57 | //         a[i]-=32;
 58 | //     }
 59 | // }
 60 | // for(int i=0;i<strlen(b);i++){
 61 | //     if(b[i]>=97){
 62 | //         b[i]-=32;
 63 | //     }
 64 | // }
 65 | // if(cmp(a,b)==0)
 66 | // printf("YES");
 67 | // else
 68 | // printf("NO");
 69 | // }
 70 | 
 71 | import java.util.*;
 72 | public class Hello {
 73 | 
 74 |     public static void main(String[] args) {
 75 | 		//U -Shaped Layers Matrix
 76 | 		Scanner sc=new Scanner(System.in);
 77 | 		int r=sc.nextInt();
 78 | 		int c=sc.nextInt();
 79 | 		int ar[][]=new int[r][c];
 80 | 		for(int i=0;i<r;i++){
 81 | 		    for(int j=0;j<c;j++){
 82 | 		        ar[i][j]=sc.nextInt();
 83 | 		    }
 84 | 		}
 85 | 		for(int i=0;i<Math.min(c/2,r);i++){
 86 | 		    for(int j=0;j<r-i-1;j++){
 87 | 		        System.out.print(ar[j][i]+" ");
 88 | 		    }
 89 | 		    
 90 | 		    for(int k=i;k<c-i;k++){
 91 | 		        System.out.print(ar[r-i-1][k]+" ");
 92 | 		    }
 93 | 		    for(int l=r-i-2;l>=0;l--){
 94 | 		        System.out.print(ar[l][c-i-1]+" ");
 95 | 		    }
 96 | 		    
 97 | 		    System.out.println();
 98 | 		}
 99 | 		
100 |     
101 | 	}
102 | }
103 | import java.util.*;
104 | public class Hello {
105 | 
106 |     public static void main(String[] args) {
107 |         //longest prefix divisible by D;
108 | 		Scanner sc=new Scanner(System.in);
109 | 		String ip=sc.next();
110 | 		int d=sc.nextInt();
111 | 		for(int i=ip.length()-1;i>=0;i--){
112 | 		    int num=Integer.parseInt(ip.substring(0,i+1));
113 | 		    if(num%d==0){
114 | 		        System.out.print(num);
115 | 		        return;
116 | 		    }
117 | 		}
118 | 		System.out.print(-1);
119 | 
120 | 	}
121 | }
122 | import java.util.*;
123 | public class Hello {
124 | 
125 |     public static void main(String[] args) {
126 | 		//Order by Integers;
127 | 		Scanner sc=new Scanner(System.in);
128 | 		int as=sc.nextInt();
129 | 		int is=sc.nextInt();
130 | 		ArrayList<Integer> a=new ArrayList<>();
131 | 		ArrayList<Integer> I =new ArrayList<>();
132 | 		
133 | 		for(int i=0;i<as;i++) a.add(sc.nextInt());
134 | 		for(int i=0;i<is;i++) I.add(sc.nextInt());
135 | 	//	System.out.print(I);
136 | 		int ans[]=new int[as];
137 | 		int j=0;
138 | 		int id=0;
139 | 		while(j<is){
140 | 		    for(int i=0;i<a.size();i++){
141 | 		        if((int)a.get(i)==(int)I.get(j)){
142 | 		        ans[id++]=I.get(j);
143 | 		       
144 | 		        }
145 | 		    }
146 | 		    while(a.contains(I.get(j)))
147 | 		    a.remove(I.get(j));
148 | 		    j++;
149 | 		}
150 |         Collections.sort(a);
151 | 		for(int i=0;i<a.size();i++)
152 | 		ans[id++]=a.get(i);
153 | 		for(int i:ans)
154 | 		System.out.print(i+" ");
155 | 
156 | 	}
157 | }
158 | 


--------------------------------------------------------------------------------
/day_76.java:
--------------------------------------------------------------------------------
  1 | // 100339. Find the Encrypted String
  2 | // Solved
  3 | // Easy
  4 | // You are given a string s and an integer k. Encrypt the string using the following algorithm:
  5 | 
  6 | // For each character c in s, replace c with the kth character after c in the string (in a cyclic manner).
  7 | // Return the encrypted string.
  8 | 
  9 |  
 10 | 
 11 | // Example 1:
 12 | 
 13 | // Input: s = "dart", k = 3
 14 | 
 15 | // Output: "tdar"
 16 | 
 17 | // Explanation:
 18 | 
 19 | // For i = 0, the 3rd character after 'd' is 't'.
 20 | // For i = 1, the 3rd character after 'a' is 'd'.
 21 | // For i = 2, the 3rd character after 'r' is 'a'.
 22 | // For i = 3, the 3rd character after 't' is 'r'.
 23 | // Example 2:
 24 | 
 25 | // Input: s = "aaa", k = 1
 26 | 
 27 | // Output: "aaa"
 28 | 
 29 | // Explanation:
 30 | 
 31 | // As all the characters are the same, the encrypted string will also be the same.
 32 | 
 33 |  
 34 | 
 35 | // Constraints:
 36 | 
 37 | // 1 <= s.length <= 100
 38 | // 1 <= k <= 104
 39 | // s consists only of lowercase English letters.
 40 | class Solution {
 41 |     public String getEncryptedString(String s, int k) {
 42 |         char[] ans=s.toCharArray();
 43 |         String an="";
 44 |         for(int i=0;i<ans.length;i++){
 45 |             int l;
 46 |             if(i+k<ans.length)
 47 |             l=i+k;
 48 |             else{
 49 |                 int c=k;
 50 |                 l=i;
 51 |                 while(c>0){
 52 |                     l++;
 53 |                     if(l==ans.length){
 54 |                         l=0;
 55 |                     }
 56 |                   c--;               }
 57 |             }
 58 |             an+=ans[l];           
 59 |         }
 60 |        // System.out.print(ans);
 61 |         return an;
 62 |     }
 63 | }
 64 | 
 65 | // 100328. Generate Binary Strings Without Adjacent Zeros
 66 | // Solved
 67 | // Medium
 68 | // You are given a positive integer n.
 69 | 
 70 | // A binary string x is valid if all 
 71 | // substrings
 72 | //  of x of length 2 contain at least one "1".
 73 | 
 74 | // Return all valid strings with length n, in any order.
 75 | 
 76 |  
 77 | 
 78 | // Example 1:
 79 | 
 80 | // Input: n = 3
 81 | 
 82 | // Output: ["010","011","101","110","111"]
 83 | 
 84 | // Explanation:
 85 | 
 86 | // The valid strings of length 3 are: "010", "011", "101", "110", and "111".
 87 | 
 88 | // Example 2:
 89 | 
 90 | // Input: n = 1
 91 | 
 92 | // Output: ["0","1"]
 93 | 
 94 | // Explanation:
 95 | 
 96 | // The valid strings of length 1 are: "0" and "1".
 97 | 
 98 |  
 99 | 
100 | // Constraints:
101 | 
102 | // 1 <= n <= 18
103 | 
104 | class Solution {
105 |     public List<String> validStrings(int n) {
106 |         List<String> ans=new ArrayList<>();
107 |         int max=(int)Math.pow(2,n)-1;
108 |         System.out.print(max);
109 |         for(int i=0;i<=max;i++){
110 |             if(adjaZero(bin(Integer.toBinaryString(i),n))){
111 |                 ans.add(bin(Integer.toBinaryString(i),n));
112 |             }
113 |         }
114 |         return ans;
115 |     }
116 |     static String bin(String a,int n){
117 |         
118 |         String as="";
119 |         int c=n-a.length();
120 |         
121 |         for(int i=0;i<c;i++){
122 |             as+='0';
123 |         }
124 |         return as+a;
125 |         
126 |     }
127 |     static boolean adjaZero(String st){
128 |         for(int i=0;i<st.length()-1;i++){
129 |             if(st.charAt(i)=='0'&&st.charAt(i+1)=='0') return false;
130 |         }
131 |         return true;
132 |     }
133 | 
134 | 
135 | 
136 |  import java.util.*;
137 | public class Hello {
138 | 
139 |     public static void main(String[] args) {
140 | 		//Super Market -Available Products
141 | 		Scanner sc=new Scanner(System.in);
142 | 		int f=sc.nextInt();
143 | 		int s=sc.nextInt();
144 | 		int[] ar=new int[f];
145 | 		int[] ar2=new int[s];
146 | 		for(int i=0;i<f;i++){
147 | 		    ar[i]=sc.nextInt();
148 | 		}
149 | 		for(int i=0;i<s;i++){
150 | 		    ar2[i]=sc.nextInt();
151 | 		}
152 | 		for(int i=0;i<f;i++){
153 | 		    for(int j=0;j<s;j++){
154 | 		        if(ar[i]==ar2[j]){
155 | 		            System.out.print(ar[i]+" ");break;
156 | 		        }
157 | 		    }
158 | 		}
159 | 
160 | 	}
161 | }
162 | }
163 | 


--------------------------------------------------------------------------------
/day_80.java:
--------------------------------------------------------------------------------
  1 | class Solution {
  2 |     public String reverseParentheses(String s) {
  3 |        Stack<Character> ans=new Stack<>();
  4 |        for(int i=0;i<s.length();i++){
  5 |         if(s.charAt(i)==')'){
  6 |             String tmp="";
  7 |             while(ans.peek()!='('){
  8 |                 tmp+=ans.pop();
  9 | 
 10 |  
 11 |             }
 12 |             ans.pop();
 13 |             for(int j=0;j<tmp.length();j++){
 14 |                 ans.push(tmp.charAt(j));
 15 |             }
 16 | 
 17 |         }
 18 |         else{
 19 |             ans.push(s.charAt(i));
 20 |         }
 21 |        }
 22 |        String an="";
 23 |        while(!ans.isEmpty()){
 24 |         an=ans.pop()+an;
 25 |        }
 26 |        return an;
 27 |     }
 28 | }
 29 | /**
 30 |  * Definition for a binary tree node.
 31 |  * public class TreeNode {
 32 |  *     int val;
 33 |  *     TreeNode left;
 34 |  *     TreeNode right;
 35 |  *     TreeNode() {}
 36 |  *     TreeNode(int val) { this.val = val; }
 37 |  *     TreeNode(int val, TreeNode left, TreeNode right) {
 38 |  *         this.val = val;
 39 |  *         this.left = left;
 40 |  *         this.right = right;
 41 |  *     }
 42 |  * }
 43 |  */
 44 | class Solution {
 45 |     public TreeNode searchBST(TreeNode root, int val) {
 46 |         while(root!=null){
 47 |             if(root.val==val){
 48 |                 return root;
 49 |             }
 50 |             else if(root.val>val){
 51 |                 if(root.left!=null)
 52 |                 root=root.left;
 53 |                 else{
 54 |                     return null;
 55 |                 }
 56 | 
 57 |             }
 58 |             else{
 59 |                 if(root.right!=null)
 60 |                 root=root.right;
 61 |                 else{
 62 |                     return null;
 63 |                 }
 64 |             }
 65 |         }
 66 |         return null;
 67 |     }
 68 | }
 69 | class Solution {
 70 |     public List<Boolean> kidsWithCandies(int[] candies, int ec) {
 71 |         List<Boolean> ans=new ArrayList<>();
 72 |         int max=candies[0];
 73 |         for(int i=1;i<candies.length;i++) max=(max<candies[i])?candies[i]:max;
 74 |         for(int i=0;i<candies.length;i++){
 75 |             ans.add((candies[i]+ec)>=max);
 76 |         }
 77 |         return ans;
 78 |     }
 79 | }
 80 | 
 81 | class Solution {
 82 |     public String removeStars(String s) {
 83 |         Stack<Character> ans=new Stack<>();
 84 |         for(int i=0;i<s.length();i++){
 85 |             if(s.charAt(i)=='*') ans.pop();
 86 |             else ans.push(s.charAt(i));
 87 |         }
 88 |         String an="";
 89 |         while(!ans.isEmpty()){
 90 |             an=ans.pop()+an;
 91 | 
 92 |         }
 93 |         return an;
 94 |     }
 95 | }
 96 | class Solution {
 97 |     public String maximumOddBinaryNumber(String s) {
 98 |         int oc=0;
 99 |         int zc=0;
100 |         for(char i:s.toCharArray()){
101 |             if(i=='1') oc++;
102 |             else zc++;
103 | 
104 |         }
105 |         StringBuilder str=new StringBuilder();
106 |         for(int i=0;i<s.length()-1;i++){
107 |             if(oc-1>0){oc--;
108 |            str.append('1');}
109 |            else
110 |            str.append('0');
111 |         }
112 |         str.append('1');
113 |         return str.toString();
114 |     }
115 | }
116 | import java.util.*;
117 | public class Hello {
118 | 
119 |     public static void main(String[] args) {
120 | 		//Replace - Four Directions
121 | 		Scanner sc=new Scanner(System.in);
122 | 		int a=sc.nextInt();
123 | 		int b=sc.nextInt();
124 | 		String mat[][]=new String[a][b];
125 | 		for(int i=0;i<a;i++) for(int j=0;j<b;j++) mat[i][j]=sc.next();
126 | 		String c=sc.next();
127 | 		int iind=0;
128 | 		int jind=0;
129 | 		for(int i=0;i<a;i++) for(int j=0;j<b;j++) if(c.equals(mat[i][j])){ iind=i;jind=j;
130 | 		}
131 | 		int ii=iind;
132 | 		int ji=jind;
133 | 		while(ii>=0&&ji>=0){
134 | 		    mat[ii--][ji--]="*";
135 | 		    
136 | 		}
137 | 		ii=iind;
138 | 		ji=jind;
139 | 		while(ii>=0&&ji<b){
140 | 		    mat[ii--][ji++]="*";
141 | 		}
142 | 		ii=iind;
143 | 		ji=jind;
144 | 		while(ii<a&&ji>=0){
145 | 		    mat[ii++][ji--]="*";
146 | 		}
147 | 		ii=iind;
148 | 		ji=jind;
149 | 		while(ii<a&&ji<b){
150 | 		    mat[ii++][ji++]="*";
151 | 		}
152 | 		for(int i=0;i<a;i++){
153 | 		    for(int j=0;j<b;j++){
154 | 		      
155 | 		        System.out.print(mat[i][j]+" ");
156 | 		    }
157 | 		    System.out.println("");
158 | 		}
159 | 	}
160 | }
161 | 


--------------------------------------------------------------------------------
/day_73.java:
--------------------------------------------------------------------------------
  1 | import java.util.*;
  2 | 
  3 | public class passstrengthcheck {
  4 |     public static void main(String args[]) {
  5 |         Scanner sc = new Scanner(System.in);
  6 |         System.out.printf("ENTER PASSWORD TO CHECK\n");
  7 |         String aq = sc.nextLine();
  8 |         char[] a = aq.toCharArray();
  9 |         int sy = 0, up = 0, le = 0, nu = 0, lo = 0;
 10 |         for (int i = 0; i < aq.length(); i++) {
 11 |             // for check lowercase letters
 12 |             if (a[i] > 96 && a[i] <= 123) {
 13 |                 lo += 1;
 14 |             }
 15 |             if (a[i] > 64 && a[i] <= 90) {
 16 |                 // for check uppercase letters
 17 |                 up += 1;
 18 |             }
 19 |             if (a[i] >= 33 && a[i] <= 47 || a[i] >= 58 && a[i] <= 64) {
 20 |                 // for checking symbols
 21 |                 sy += 1;
 22 |             }
 23 |             if (a[i] != ' ') {
 24 |                 // for checking length
 25 |                 le += 1;
 26 |             }
 27 |             if (a[i] >= 48 && a[i] <= 57) {
 28 |                 // for checking numbers
 29 |                 nu += 1;
 30 |             }
 31 |         }
 32 |         if (sy >= 1 && le >= 8 && up >= 1 && nu >= 1 && lo >= 1) {
 33 |             System.out.printf("----STRONG PASSWORD----");
 34 |         } else if (le < 8) {
 35 |             System.out.printf("----NOT ENOUGH LENGTH----");
 36 |         } else if (lo == 0) {
 37 |             System.out.printf("---DOESNOT CONTAINS LOWERCASE");
 38 |         } else if (up == 0) {
 39 |             System.out.printf("---DOESNOT CONTAINS UPPERCASE");
 40 |         } else if (nu == 0) {
 41 |             System.out.printf("---DOESNOT CONTAINS NUMERICVAL");
 42 |         } else if (sy == 0) {
 43 |             System.out.printf("---DOESNOT CONTAINS SYMBOLS");
 44 |         } else
 45 |             System.out.printf("----INVALID PASSWORD----");
 46 | 
 47 |     }
 48 | }
 49 | 
 50 | import java.util.*;
 51 | public class Hello {
 52 | 
 53 |     public static void main(String[] args) {
 54 | 		//N columns Pattern
 55 | 		Scanner sc=new Scanner(System.in);
 56 | 		int a=sc.nextInt();
 57 | 		int[] ar=new int[a];
 58 | 		for(int i=0;i<a;i++){
 59 | 		    ar[i]=sc.nextInt();
 60 | 		}
 61 | 		int cp=0;
 62 | 		for(int i=0;i<a;i++){
 63 | 		    int c=0;
 64 | 		    while(c<ar[i]){
 65 | 		        System.out.print(ar[i]+" ");
 66 | 		        c++;
 67 | 		        cp++;
 68 | 		        if(cp==a){
 69 | 		            cp=0;
 70 | 		            System.out.println();
 71 | 		        }
 72 | 		    }
 73 | 		}
 74 | 
 75 | 	}
 76 | }
 77 | import java.util.*;
 78 | public class Hello {
 79 | 
 80 |     public static void main(String[] args) {
 81 | 		//Sort Factors;
 82 | 		Scanner sc=new Scanner(System.in);
 83 | 		int num=sc.nextInt();
 84 | 		ArrayList<Integer> fa=new ArrayList<>();
 85 | 		ArrayList<Integer> fc=new ArrayList<>();
 86 | 		Hello ello=new Hello();
 87 | 		for(int i=1;i<=num;i++){
 88 | 		    if(num%i==0){
 89 | 		        fa.add(i);
 90 | 		        fc.add(ello.co(i));
 91 | 		    }
 92 | 		}
 93 | 		ello.sort(fa,fc);
 94 | 		for(int i=0;i<fa.size();i++)
 95 | 		System.out.print(fa.get(i)+" ");
 96 | 
 97 | 	}
 98 |   int co(int a){
 99 |       int c=2;
100 |       for(int i=2;i<a;i++) if(a%i==0) c++;
101 |       return c;
102 |   } 
103 |   void sort(ArrayList<Integer> a,ArrayList<Integer> b){
104 |       for(int i=0;i<a.size();i++){
105 |           for(int j=i+1;j<a.size();j++){
106 |               if(b.get(i)<=b.get(j)){
107 |                   int tm=a.get(i);
108 |                   a.set(i,a.get(j));
109 |                   a.set((j),tm);
110 |                   int tp=b.get(i);
111 |                   b.set(i,b.get(j));
112 |                   b.set(j,tp);
113 |               }
114 |           }
115 |       }
116 |   } 
117 | }
118 | import java.util.*;
119 | public class Hello {
120 | 
121 |     public static void main(String[] args) {
122 | 		//Matrix Palindrome
123 | 		Scanner sc=new Scanner(System.in);
124 | 		int r=sc.nextInt();
125 | 		int c=sc.nextInt();
126 | 		int[][] ar=new int[r][c];
127 | 		for(int i=0;i<r;i++){
128 | 		    for(int j=0;j<c;j++){
129 | 		        ar[i][j]=sc.nextInt();
130 | 		    }
131 | 		}
132 | 		System.out.print((check(ar,r,c))?"YES":"NO");
133 | 
134 | 	}
135 | 	static boolean check(int[][] arr,int r,int c){
136 | 	    for(int i=0;i<r;i++) for(int j=0;j<c/2;j++)	
137 | 	    if(arr[i][j]!=arr[i][c-j-1]) return false;
138 | 	    
139 | 	    for(int i=0;i<c;i++) for(int j=0;j<r/2;j++)
140 | 	    if(arr[j][i]!=arr[r-j-1][i]) return false;
141 | 	    
142 | 	    return true;
143 | 	}
144 | }
145 | import java.util.*;
146 | public class Hello {
147 | 
148 |     public static void main(String[] args) {
149 | 		//Subarrays-Mininum and Maximum Sum
150 | 		Scanner sc=new Scanner(System.in);
151 | 		int a=sc.nextInt();
152 | 		int[] arr=new int[a];
153 | 		for(int i=0;i<a;i++) arr[i]=sc.nextInt();
154 | 		int k=sc.nextInt();
155 | 		int mid=-1;
156 | 		int max=0;
157 | 		int s=0;
158 | 		int minIndex=0;
159 | 		int maxIndex=0;
160 | 		for(int i=0;i<k;i++){
161 | 		    s+=arr[i];
162 | 		}
163 | 	        mid=max=s;
164 | 		minIndex=maxIndex=k-1;
165 | 		for(int i=k;i<a;i++){
166 | 		    
167 | 		    s+=arr[i]-arr[i-k];
168 | 		    if(s>max){
169 | 		        max=s;
170 | 		        maxIndex=i;
171 | 		    }
172 | 		    if(s<mid){
173 | 		        mid=s;
174 | 		        minIndex=i;
175 | 		    }
176 | 		}
177 | 	//	System.out.println(minIndex+" "+maxIndex);
178 | 		for(int i=minIndex-k+1;i<minIndex+1;i++){
179 | 		    System.out.print(arr[i]+" ");
180 | 		}
181 | 		System.out.println();
182 | 		for(int i=maxIndex-k+1;i<maxIndex+1;i++)
183 | 		System.out.print(arr[i]+" ");
184 | 
185 | 	}
186 | }
187 | 


--------------------------------------------------------------------------------