├── QN_01_Harshitha.java
├── QN_02_Harshitha.java
├── QN_03_Harshitha.java
├── QN_04_Harshitha.java
├── QN_05_Harshitha.java
├── QN_06_Harshitha.java
├── QN_11_Hariharan.java
├── QN_11_Harshitha.java
├── QN_11_Krishna.java
├── QN_12_Krishna.java
├── QN_14_Harshitha.java
├── QN_16_SOWMIYA.py
├── QN_18_Harshitha.java
├── QN_1_AMUTHAN.java
├── QN_1_Krishna.java
├── QN_1_ROHAN.py
├── QN_1_sriswasthika.java
├── QN_21_Harshitha.java
├── QN_23_Hariharan.java
├── QN_23_Harshitha.java
├── QN_23_Vicky.py
├── QN_24_Harshitha.java
├── QN_25_Harshitha.java
├── QN_2_Atchayah-S.java
├── QN_2_ROHAN.py
├── QN_30_SRIRAM.java
├── QN_3_AMUTHAN.Java
├── QN_3_Atchayah-S.java
├── QN_3_ROHAN.py
├── QN_43_Hariharan.java
├── QN_4_Atchayah-S.java
├── QN_4_ROHAN.py
├── QN_52_SRIRAM.java
├── QN_53_AMUTHAN.java
├── QN_53_Hariharan.java
├── QN_53_Krishna.java
├── QN_5_Atchayah-S.java
├── QN_5_ROHAN.py
├── QN_61_SRIRAM.java
├── QN_62_SRIRAM.java
├── QN_63_SRIRAM.java
├── QN_64_SRIRAM.java
├── QN_65_SRIRAM.java
├── QN_6_Krish.java
├── QN_6_ROHAN.py
├── QN_7_ROHAN.py
├── QN_8_Atchayah-S.java
├── QN_8_ROHAN.py
├── QN_9_ROHAN.py
├── Q_1_AMUTHAN.java
├── Q_2_AMUTHAN.java
├── Qn_1_Abhilash.java
├── Qn_1_Arularasan.java
└── README.md


/QN_01_Harshitha.java:
--------------------------------------------------------------------------------
 1 | Math-Based Problems
 2 | Find the factorial of a number using recursion.
 3 | 
 4 | 
 5 |   
 6 | 
 7 | // Online Java Compiler
 8 | // Use this editor to write, compile and run your Java code online
 9 | import java.util.*;
10 | class Main {
11 |     public static void main(String[] args) {
12 |         Scanner sc=new Scanner(System.in);
13 |         int n=sc.nextInt();
14 |         System.out.println(Fact(n));
15 |     }
16 |     
17 |     public static int Fact(int n){
18 |         if(n<=1){
19 |             return 1;
20 |         }
21 |         else{
22 |             return n * Fact(n-1);
23 |         }
24 |     }
25 | }
26 | 
27 | 
28 | 
29 | 


--------------------------------------------------------------------------------
/QN_02_Harshitha.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | class prime{
 3 |   public static void main(String[] args){
 4 |     Scanner sc=new Scanner(System.in);
 5 |     boolean flag=false;
 6 |     int num=sc.nextInt();
 7 |     if(num<=1)
 8 |       flag=true;
 9 |     else{
10 |       for(int i=2;i<num;i++)
11 |         if(num%i==0)
12 |           flag=true;
13 |     }
14 |     if(!flag)
15 |       System.out.print("True");
16 |     else
17 |       System.out.print("False");
18 |   }
19 | }
20 | 


--------------------------------------------------------------------------------
/QN_03_Harshitha.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | class Fibanocci{
 3 |   public static void main(String[] args){
 4 |     Scanner sc=new Scanner(System.in);
 5 |     int n=sc.nextInt();
 6 |     if(n<=1)
 7 |       System.out.print(n);
 8 |     else{
 9 |       int a=0,b=1;
10 |       for(int i=0;i<n;i++){
11 |         System.out.print(a+" ");
12 |         int c=a+b;
13 |         a=b;
14 |         b=c;
15 |       }
16 |     }
17 |   }
18 | }
19 | 


--------------------------------------------------------------------------------
/QN_04_Harshitha.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | class gcd{
 3 |   public static void main(String[] args){
 4 |     Scanner sc=new Scanner(System.in);
 5 |     int a=sc.nextInt();
 6 |     int b=sc.nextInt();
 7 |     int min=0;
 8 |     int gcd=0;
 9 |     if(a>b)
10 |       min=b;
11 |     else
12 |       min=a;
13 |     for(int i=min;i>=1;i--){
14 |       if(a%i==0 && b%i==0){
15 |         gcd=i;
16 |         break;
17 |       }
18 |     }
19 |     System.out.print(gcd);
20 |   }
21 | }
22 | 


--------------------------------------------------------------------------------
/QN_05_Harshitha.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | class palindrome{
 3 |   public static void main(String[] args){
 4 |     Scanner sc=new Scanner(System.in);
 5 |     int n=sc.nextInt();
 6 |     int sum=0,temp=n;
 7 |     while(n>0){
 8 |       int dig=n%10;
 9 |       sum=(sum*10)+dig;
10 |       n/=10;
11 |     }
12 |     if(temp==sum)
13 |       System.out.print("Palindrome");
14 |     else
15 |       System.out.print("Not Palindrome");
16 |   }
17 | }
18 | 


--------------------------------------------------------------------------------
/QN_06_Harshitha.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | class count{
 3 |   public static void main(String[] args){
 4 |     Scanner sc=new Scanner(System.in);
 5 |     int n=sc.nextInt();
 6 |     int sol=0;
 7 |     while(n>0){
 8 |       int dig=n%10;
 9 |       sol+=1;
10 |       n/=10;
11 |     }
12 |     System.out.print(sol);
13 |   }
14 | }
15 | 
16 | 
17 | 


--------------------------------------------------------------------------------
/QN_11_Hariharan.java:
--------------------------------------------------------------------------------
 1 | public class main {
 2 |     public static String reverseString(String s) {
 3 |         char[] chars = s.toCharArray();
 4 |         int l = 0;
 5 |         int r = chars.length - 1;
 6 |         
 7 |         while (l < r) {
 8 |             char temp = chars[l];
 9 |             chars[l] = chars[r];
10 |             chars[r] = temp;
11 |             
12 |             l++;
13 |             r--;
14 |         }
15 |         return new String(chars);
16 |     }
17 | 


--------------------------------------------------------------------------------
/QN_11_Harshitha.java:
--------------------------------------------------------------------------------
 1 | 11. REVERSE STRING
 2 | 
 3 | import java.util.*;
 4 | class reverse{
 5 |   public static void main(String[] args){
 6 |     Scanner sc=new Scanner(System.in);
 7 |     String str=sc.nextLine();
 8 |     char a[]=str.toCharArray();
 9 | 
10 |     int left=0;
11 |     int right=a.length-1;
12 |     while(left<right){
13 |       char temp=a[left];
14 |       a[left]=a[right];
15 |       a[right]=temp;
16 |       left++;
17 |       right--;
18 |     }
19 |     System.out.println(a);
20 |   }
21 | }
22 | 


--------------------------------------------------------------------------------
/QN_11_Krishna.java:
--------------------------------------------------------------------------------
 1 | class main{
 2 |   public static void main(String[] args){
 3 |      System.out.println(reverseString("Krishna"));//anhsirK;
 4 |      System.out.println(reverseString("Github")); //buhtiG;
 5 |   }
 6 |   public static String reverseString(String st){
 7 |     if(st.length()==1) return st.charAt(0)+"";
 8 |     return reverseString(st.substring(1))+st.charAt(0);
 9 |   }
10 | }
11 | 


--------------------------------------------------------------------------------
/QN_12_Krishna.java:
--------------------------------------------------------------------------------
 1 | class main{
 2 |   public static void main(String[] args){
 3 |     
 4 |     //Check if a string is a palindrome. //same word when we read in both sides..
 5 |     String str1="MalayalaM";
 6 |     String str2="Krsi";
 7 |      System.out.println(str1.equals(reverseString(str1)));//true;
 8 |      System.out.println(str2.equals(reverseString(str2))); //false;
 9 |   }
10 |   public static String reverseString(String st){
11 |     if(st.length()==1) return st.charAt(0)+"";
12 |     return reverseString(st.substring(1))+st.charAt(0);
13 |   }
14 | }
15 | 


--------------------------------------------------------------------------------
/QN_14_Harshitha.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | class vowels {
 3 |   public static void main(String[] args){
 4 |     Scanner sc=new Scanner(System.in);
 5 |     String str=sc.next();
 6 |     char a[]=str.tocharArray();
 7 |     for(int i=0;i<a.length;i++){
 8 |       if(a[i]=='a'||a[i]=='e'||a[i]=='i'||a[i]=='o'||a[i]=='u'){
 9 |         a[i]="";
10 |       }
11 |       else{
12 |         continue;
13 |       }
14 |     }
15 |   }
16 | }
17 | 


--------------------------------------------------------------------------------
/QN_16_SOWMIYA.py:
--------------------------------------------------------------------------------
1 | Code  to count the number of words in a string:
2 | 
3 | 
4 | text = input("Enter a string: ")
5 | word_count = len(text.split())
6 | print("Word count:", word_count)
7 | 


--------------------------------------------------------------------------------
/QN_18_Harshitha.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | class a{
 3 |   public static void main(String []args){
 4 |     Scanner sc=new Scanner(System.in);
 5 |     String str1=sc.next();
 6 |     String str2=sc.next();
 7 |     int count=0;
 8 |     char arr1[]=str1.toCharArray();
 9 |     char arr2[]=str2.toCharArray();
10 |     Arrays.sort(arr1);
11 |     Arrays.sort(arr2);
12 |     for(int i=0;i<arr1.length;i++){
13 |       if(arr1[i]==arr2[i]){
14 |         count++;
15 |       }
16 |     }
17 |     if(count==arr1.length)
18 |       System.out.println("anagram");
19 |     else
20 |       System.out.println("Not Anagram");
21 |   }
22 | }
23 | 


--------------------------------------------------------------------------------
/QN_1_AMUTHAN.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class FactorialUsingRecursion {
 3 |     public static int recursion(int n) {
 4 |         if(n-1 == 0) {
 5 |           return 1;
 6 |         }
 7 |         return n * recursion(n-1);
 8 |     }
 9 |     public static void main (String args[]) {
10 |         Scanner sc = new Scanner(System.in);
11 |         int n = sc.nextInt();
12 |         int answer = recursion(n);
13 |         System.out.print("The factorial of "+n+" is "+answer);
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/QN_1_Krishna.java:
--------------------------------------------------------------------------------
 1 | class main{
 2 |   public static void main(String[] args){
 3 |      System.out.println(fact(0));//1;
 4 |      System.out.println(fact(5));//120;
 5 |   }
 6 |   public static int fact(int a){
 7 |     if(a==0) return 1;
 8 |     return a*fact(a-1);
 9 |   }
10 | }
11 | 


--------------------------------------------------------------------------------
/QN_1_ROHAN.py:
--------------------------------------------------------------------------------
 1 | # Recursive solution : TC - O(n) , SC - O(n)
 2 | def factorial_1(n):
 3 |     if n < 2:
 4 |         return 1
 5 |     return n * factorial_1(n - 1)
 6 | print(factorial_1(5))
 7 |     
 8 | # Memoized solution : TC - O(n) , SC - O(n)    
 9 | def factorial_2(n):
10 |     if n in memo:
11 |         return memo[n]
12 |     memo[n] = n * factorial_2(n - 1)
13 |     return memo[n]
14 | memo = {0 : 1, 1 : 1}
15 | print(factorial_2(5))
16 | 
17 | # Dynamic Programming solution : TC - O(n) , SC - O(n)    
18 | def factorial_3(n):
19 |     fact = [1] * (n + 1)
20 |     for i in range(1, n + 1):
21 |         fact[i] = i * fact[i - 1]
22 |     return fact[n]
23 | print(factorial_3(5))
24 | 
25 | # Dynamic Programming space optimized solution : TC - O(n) , SC - O(1)    
26 | def factorial_4(n):
27 |     prev = 1
28 |     for i in range(1, n + 1):
29 |         curr = i * prev
30 |         prev = curr
31 |     return curr
32 | print(factorial_4(5))
33 | 


--------------------------------------------------------------------------------
/QN_1_sriswasthika.java:
--------------------------------------------------------------------------------
 1 | // Factorial of given number 
 2 | import java.util.*;
 3 | class Main { 
 4 | 	static int fact(int n) 
 5 | 	{ 
 6 | 		if (n == 0) 
 7 | 			return 1; 
 8 | 
 9 | 		return n * fact(n - 1); 
10 | 	} 
11 | 
12 | 	public static void main(String[] args) 
13 | 	{ 
14 |     Scanner sc=new Scanner(System.in);
15 | 		int num = sc.nextInt(); 
16 | 		System.out.println("Factorial of " + num + " is " + fact(num)); 
17 | 	} 
18 | }
19 | 


--------------------------------------------------------------------------------
/QN_21_Harshitha.java:
--------------------------------------------------------------------------------
 1 | import util.java.*;
 2 | class main{
 3 |   public static void main(String[] args){
 4 |     Scanner sc=new Scanner();
 5 |     int n=sc.nextInt();
 6 |     int a[]=new int[n];
 7 |     for(int i=0;i<n;i++){
 8 |       a[i]=sc.nextInt();
 9 |     }
10 |     int min=a[0];
11 |     int max=a[n-1];
12 |     for(int i=0;i<n;i++){
13 |       if(a[i]<min){
14 |         min=a[i];
15 |       }
16 |       if(a[i]>max){
17 |         max=a[i];
18 |       }
19 |     }
20 |     System.out.println("min: "+min);
21 |     System.out.println("max: "+max);
22 |   }
23 | }
24 | 


--------------------------------------------------------------------------------
/QN_23_Hariharan.java:
--------------------------------------------------------------------------------
 1 | class main
 2 | {
 3 | 	public static void main (String[] args) 
 4 | 	{
 5 | 		Scanner sc=new Scanner(System.in);
 6 | 		int n=sc.nextInt();
 7 | 		int[] a=new int[n];
 8 | 		for(int i=0;i<n;i++){
 9 | 		    a[i]=sc.nextInt();
10 | 		}
11 | 		int max= Integer.MIN_VALUE;
12 | 		for(int i=0;i<n;i++){
13 | 		    if(a[i]>max){
14 | 		        max=a[i];
15 | 		    }
16 | 		}
17 | 		int secmax= Integer.MIN_VALUE;
18 | 		for(int i=0;i<n;i++){
19 | 		    if(secmax<a[i] && a[i]<max){
20 | 		        secmax=a[i];
21 | 		    }
22 | 		}
23 | 		System.out.println(secmax);
24 | 	}
25 | }
26 | 


--------------------------------------------------------------------------------
/QN_23_Harshitha.java:
--------------------------------------------------------------------------------
 1 | // Online Java Compiler
 2 | // Use this editor to write, compile and run your Java code online
 3 | import java.util.*;
 4 | class Main {
 5 |     public static void main(String[] args) {
 6 |         Scanner sc=new Scanner(System.in);
 7 |         int n=sc.nextInt();
 8 |         int arr[]=new int[n];
 9 |         for(int i=0;i<n;i++){
10 |             arr[i]=sc.nextInt();
11 |         }
12 |         int max=arr[0];
13 |         int index=0;
14 |         for(int i=1;i<n;i++){
15 |             if(max<arr[i]){
16 |                 max=arr[i];
17 |                 index=i;
18 |             }
19 |         }
20 |         for(int i=0;i<n;i++){
21 |             if(index==i){
22 |             int temp=arr[i];
23 |             arr[i]=arr[n-1];
24 |             arr[n-1]=temp;
25 |         }
26 |         }
27 |         int max1=arr[0];
28 |         for(int i=1;i<n-1;i++){
29 |             if(max1<arr[i]){
30 |                 max1=arr[i];
31 |             }
32 |         }
33 |         System.out.println(max1);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/QN_23_Vicky.py:
--------------------------------------------------------------------------------
 1 | class Solution:
 2 |     def getSecondLargest(self,lst):
 3 |         
 4 |         if (len(lst)<2):
 5 |             return none
 6 |         
 7 |         one = max(lst[0] , lst[1])
 8 |         second = min(lst[0] , lst[1])
 9 |         
10 |         for i in range(2,len(lst)):
11 |             if (lst[i] > one):
12 |                 second = one
13 |                 one = lst[i]
14 |             elif(second < lst[i] < one):
15 |                 second = lst[i]
16 |         
17 |         if (one == second):
18 |             return -1
19 |             
20 |         return second


--------------------------------------------------------------------------------
/QN_24_Harshitha.java:
--------------------------------------------------------------------------------
 1 | // Online Java Compiler
 2 | // Use this editor to write, compile and run your Java code online
 3 | import java.util.*;
 4 | class Main {
 5 |     public static void main(String[] args) {
 6 |         Scanner sc=new Scanner(System.in);
 7 |         int count=0;
 8 |         int n=sc.nextInt();
 9 |         int a[]=new int[n];
10 |         for(int i=0;i<n;i++){
11 |             a[i]=sc.nextInt();
12 |         }
13 |         Arrays.sort(a);
14 |         for(int i=0;i<n-1;i++){
15 |             if(a[i]==a[i+1]){
16 |                 count+=1;
17 |             }
18 |         }
19 |         if(count>0)
20 |         System.out.println("Array contains duplicate values");
21 |         else
22 |         System.out.println("Array doesn't contain any duplicate values");
23 |         
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/QN_25_Harshitha.java:
--------------------------------------------------------------------------------
 1 | /******************************************************************************
 2 | 
 3 |                             Online Java Compiler.
 4 |                 Code, Compile, Run and Debug java program online.
 5 | Write your code in this editor and press "Run" button to execute it.
 6 | 
 7 | *******************************************************************************/
 8 | import java.util.*;
 9 | public class Main
10 | {
11 | 	public static void main(String[] args) {
12 | 	    Scanner sc=new Scanner(System.in);
13 | 	    int n=sc.nextInt();
14 | 	    int a[]=new int[n];
15 | 	    for(int i=0;i<n;i++){
16 | 	        a[i]=sc.nextInt();
17 | 	    }
18 | 	    int rev[]=new int[n];
19 | 	    for(int i=0;i<n;i++){
20 | 	        rev[n-i-1]=a[i];
21 | 	    }
22 | 	    System.out.print("enter k:");
23 | 	    int k=sc.nextInt();
24 | 	    int start=0;
25 | 	    int end=k-1;
26 | 	    while(start<end){
27 | 	        int temp=rev[start];
28 | 	        rev[start]=rev[end];
29 | 	        rev[end]=temp;
30 | 	        start++;
31 | 	        end--;
32 | 	    }
33 | 	    start=k;
34 | 	    end=n-1;
35 | 	    while(start<end){
36 | 	        int temp=rev[start];
37 | 	        rev[start]=rev[end];
38 | 	        rev[end]=temp;
39 | 	        start++;
40 | 	        end--;
41 | 	    }
42 | 	    for(int i=0;i<n;i++){
43 | 	        System.out.print(rev[i]);
44 | 	    }
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/QN_2_Atchayah-S.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class PrimeNumber{
 3 |     public static void main(String args[]){
 4 |         int number;
 5 |         boolean flag=true;
 6 |         Scanner sc=new Scanner(System.in);
 7 |         System.out.println("Enter a number to check prime or not: ");
 8 |         number=sc.nextInt();
 9 |         if((number==0)||(number==1))
10 |         flag=false;
11 |         for(int i=2;i<=Math.sqrt(number);i++){
12 |             if(number%i==0){
13 |             flag=false;
14 |             break;
15 |             }
16 |         }
17 |         if(flag)
18 |         System.out.println(number+" is a prime number");
19 |         else
20 |         System.out.println(number+" is not a prime number");
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/QN_2_ROHAN.py:
--------------------------------------------------------------------------------
 1 | # Default Prime check everyone follow - TC - O(n), SC - O(n)
 2 | def isPrime(n):
 3 |     if n < 2:
 4 |         return False
 5 |     if n == 2:
 6 |         return True
 7 |     for i in range(2, int(n ** 0.5) + 1):
 8 |         if n % i == 0:
 9 |             return False
10 |     return True
11 |     
12 | #Best and quickest Prime check - TC - O(n), SC - O(n)
13 | def isPrimeQuick(n):
14 |     if n < 2:
15 |         return False
16 |     if n < 4: return True
17 |     if n % 2 == 0 or n % 3 == 0:
18 |         return False
19 |     for i in range(5, int(n ** 0.5) + 1, 6):
20 |         if n % i == 0 or n % (i + 2) == 0:
21 |             return False
22 |     return True
23 | 
24 | #Printing Primes between 0 to 100
25 | primes_from_default = [i for i in range(100) if isPrime(i)]
26 | primes_from_quick = [i for i in range(100) if isPrimeQuick(i)]
27 | print(primes_from_default)
28 | print(primes_from_quick)
29 | 


--------------------------------------------------------------------------------
/QN_30_SRIRAM.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | class Main{
 3 |     public static void main(String args[])
 4 |     {
 5 |         Solution obj = new Solution();
 6 |         int[] nums = {0,1,0,3,12};
 7 |         obj.moveZeroes(nums);
 8 |     }
 9 | }
10 | 
11 | class Solution {
12 |     public void moveZeroes(int[] nums)
13 |     {
14 |         int c=0;
15 |         int n=nums.length;
16 |         for(int i=0;i<n;i++){
17 |             if(nums[i]!=0)  nums[c++]=nums[i]; 
18 |         }
19 |         for(int i=c;i<n;i++)  nums[i]=0;
20 |         System.out.println(Arrays.toString(nums));
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/QN_3_AMUTHAN.Java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class FibonacciNumbers {
 3 |     public static void nSeries(int n) {
 4 |         int n1 = 0;
 5 |         int n2 = 1;
 6 |         int temp = 0;
 7 |         System.out.print(n1+" ");
 8 |         for(int i=1; i<=n; i++) {
 9 |             System.out.print(n2+" ");
10 |             temp = n1 + n2;
11 |             n1 = n2;
12 |             n2 = temp;
13 |         }
14 |     }
15 |     public static void main (String args[]) {
16 |         Scanner sc = new Scanner(System.in);
17 |         System.out.print("Enter n: ");
18 |         int n = sc.nextInt();
19 |         nSeries(n);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/QN_3_Atchayah-S.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class FibonacciNumbers{
 3 | public static void main(String args[]){
 4 | int a=-1,b=1,c=0,N;
 5 | Scanner sc=new Scanner(System.in);
 6 | System.out.println("Enter the number of Fibonacci numbers to generate (N):");
 7 | N=sc.nextInt();
 8 | System.out.println("First "+N+" Fibonacci numbers");
 9 | for(int i=0;i<N;i++){
10 | c=a+b;
11 | System.out.println(c);
12 | a=b;
13 | b=c;
14 | }
15 | }}
16 | 


--------------------------------------------------------------------------------
/QN_3_ROHAN.py:
--------------------------------------------------------------------------------
 1 | n = 10
 2 | 
 3 | 
 4 | # Recursive solution : TC - O(n) , SC - O(n)
 5 | def fibonacci_1(n):
 6 |     if n == 1 or n == 2:
 7 |         return 1
 8 |     return fibonacci_1(n - 1) + fibonacci_1(n - 2)
 9 |     
10 | sequence_1 = [fibonacci_1(i) for i in range(1, n + 1)]
11 | print(sequence_1)
12 | 
13 | 
14 | # Memoized solution : TC - O(n) , SC - O(n)
15 | def fibonacci_2(n):
16 |     if n in memo:
17 |         return memo[n]
18 |     memo[n] = fibonacci_1(n - 1) + fibonacci_1(n - 2)
19 |     return memo[n]
20 |     
21 | memo = {1 : 1, 2 : 1}
22 | sequence_2 = [fibonacci_2(i) for i in range(1, n + 1)]
23 | print(sequence_2)
24 | 
25 | 
26 | # Dynamic Programming solution : TC - O(n) , SC - O(n) 
27 | def fibonacci_3(n):
28 |     series = [1, 1]
29 |     for i in range(n - 2):
30 |         series.append(series[-1] + series[-2])
31 |     return series[-1]
32 |     
33 | sequence_3 = [fibonacci_3(i) for i in range(1, n + 1)] 
34 | print(sequence_3)
35 | 
36 | 
37 | # Dynamic Programming space optimized solution : TC - O(n) , SC - O(1)  
38 | def fibonacci_4(n):
39 |     curr = prev = prev_prev = 1
40 |     for i in range(n - 2):
41 |         curr = prev + prev_prev
42 |         prev_prev = prev
43 |         prev = curr
44 |     return curr
45 |     
46 | sequence_4 = [fibonacci_4(i) for i in range(1, n + 1)] 
47 | print(sequence_4)
48 | 
49 | 
50 | 


--------------------------------------------------------------------------------
/QN_43_Hariharan.java:
--------------------------------------------------------------------------------
 1 | class main
 2 | {
 3 | 	public static void main (String[] abcd)
 4 | 	{
 5 | 		Scanner sc=new Scanner(System.in);
 6 | 		int year=sc.nextInt();
 7 | 		if((year%4==0&&year%100!=0)||(year%400==0)){
 8 | 		    System.out.print("Leap Year");
 9 | 		}
10 | 		else{
11 | 		    System.out.print("Not a Leap Year");
12 | 		}
13 | 	}
14 | }
15 | 


--------------------------------------------------------------------------------
/QN_4_Atchayah-S.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Gcd{
 3 | public static int gcd(int num1, int num2){
 4 | int result= num1<num2? num1: num2;
 5 | while(result>0){
 6 |  if(num1%result==0 && num2%result==0)
 7 | 	break;
 8 | result--;
 9 | }
10 | return result;
11 | }
12 | public static void main(String args[]){
13 | int num1, num2;
14 | Scanner sc=new Scanner(System.in);
15 | num1=sc.nextInt();
16 | num2=sc.nextInt();
17 | System.out.println("GCD of "+num1+" and "+num2+" is "+gcd(num1,num2));
18 | }
19 | }


--------------------------------------------------------------------------------
/QN_4_ROHAN.py:
--------------------------------------------------------------------------------
 1 | a = 24
 2 | b = 56
 3 | 
 4 | # Recursive solution : TC - O(log(min(a, b))) , SC - O(log(min(a, b)))
 5 | def recursive_gcd(a, b):
 6 |     if b == 0:
 7 |         return a
 8 |     return recursive_gcd(b, a % b)
 9 |     
10 | print(recursive_gcd(a, b))
11 | 
12 | 
13 | # Iterative solution : TC - O(log(min(a, b))) , SC - O(1)
14 | def euclid_gcd(a,b):
15 |     while b != 0:
16 |         a, b = b, a % b
17 |     return a
18 |     
19 | print(euclid_gcd(a, b))
20 | 


--------------------------------------------------------------------------------
/QN_52_SRIRAM.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |   public static void main(String args[])
 3 |   {
 4 |       int n=125;
 5 |       int count = hammingWeight(n);
 6 |       System.out.println(count);
 7 |   }
 8 |   
 9 |   public static int hammingWeight(int n) {
10 |         int a=0;
11 |         while(n>0)
12 |         {
13 |             if(n%2==1) a+=1;
14 |             n/=2;
15 |         }
16 |         return a;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/QN_53_AMUTHAN.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Solution {
 3 |   public static boolean isPowerOfTwo(int n) {
 4 |     return (n>0) && ((n & (n-1)) == 0);
 5 |   }
 6 |   public static void main(String args[]) {
 7 |     Scanner sc = new Scanner(System.in);
 8 |     int n = sc.nextInt();
 9 |     System.out.println(isPowerOfTwo(n));
10 |   }
11 | }
12 | 


--------------------------------------------------------------------------------
/QN_53_Hariharan.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 |     public boolean isPowerOfTwo(int n) {
3 |         if(n==0 || n==Integer.MIN_VALUE){
4 |             return false;
5 |         }
6 |         return (n & (n-1))==0;
7 |     }
8 | }
9 | 


--------------------------------------------------------------------------------
/QN_53_Krishna.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public boolean isPowerOfTwo(int n) {
 3 |         if(n<=0) return false; // edge case for negative numbers
 4 | 
 5 |         //by consecutive dividing by 2;
 6 |         // while(n%2==0){
 7 |         //     n/=2;
 8 |         // }
 9 |         // return n==1;
10 | 
11 |         // using right shift 
12 |         // while(n%2==0){
13 |         //     n>>=1;
14 |         // }
15 |         // return n==1;
16 |         
17 |         //8&(8-1) ... 8&7==0 ... 1000&0111==0... it will be power of two..
18 |         return (n&(n-1))==0;
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/QN_5_Atchayah-S.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class PalindromeNumber{
 3 | public static void main(String[] args){
 4 | int num,temp,rem,rev=0;
 5 | Scanner sc=new Scanner(System.in);
 6 | num=sc.nextInt();
 7 | temp=num;
 8 | while(num>0){
 9 | rem=num%10;
10 | rev=rev*10+rem;
11 | num/=10;
12 | }
13 | if(temp==rev){
14 | System.out.println(temp+" is a palindrome number.");
15 | }
16 | else{
17 | System.out.println(temp+" is not a palindrome number.");
18 | }
19 | }
20 | }
21 | 


--------------------------------------------------------------------------------
/QN_5_ROHAN.py:
--------------------------------------------------------------------------------
 1 | n = 12321
 2 | 
 3 | # Standard method - stores every digits in an list and checks the list
 4 | def isPalindrome(n):
 5 |     stk = []
 6 |     while n:
 7 |         stk.append(n % 10)
 8 |         n //= 10
 9 |     low = 0
10 |     high = len(stk) - 1
11 |     while low < high:
12 |         if stk[low] != stk[high]:
13 |             return False
14 |         low += 1
15 |         high -= 1
16 |     return True
17 |     
18 | print(isPalindrome(n))
19 | 
20 | # One Liner
21 | print(str(n) == str(n)[::-1])
22 | 


--------------------------------------------------------------------------------
/QN_61_SRIRAM.java:
--------------------------------------------------------------------------------
 1 | public class BinarySearch {
 2 |     public static int binarySearch(int[] arr, int target) {
 3 |         int left = 0, right = arr.length - 1;
 4 | 
 5 |         while (left <= right) {
 6 |             int mid = left + (right - left) / 2;
 7 | 
 8 |             if (arr[mid] == target)
 9 |                 return mid;
10 |             else if (arr[mid] < target)
11 |                 left = mid + 1;
12 |             else
13 |                 right = mid - 1;
14 |         }
15 |         return -1; // not found
16 |     }
17 | 
18 |     public static void main(String[] args) {
19 |         int[] arr = {2, 4, 6, 8, 10, 12};
20 |         int target = 10;
21 |         int result = binarySearch(arr, target);
22 |         System.out.println(result != -1 ? "Found at index " + result : "Not found");
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/QN_62_SRIRAM.java:
--------------------------------------------------------------------------------
 1 | public class SelectionSort {
 2 |     public static void selectionSort(int[] arr) {
 3 |         for (int i = 0; i < arr.length - 1; i++) {
 4 |             int minIdx = i;
 5 |             for (int j = i + 1; j < arr.length; j++) {
 6 |                 if (arr[j] < arr[minIdx]) {
 7 |                     minIdx = j;
 8 |                 }
 9 |             }
10 |             // swap
11 |             int temp = arr[i];
12 |             arr[i] = arr[minIdx];
13 |             arr[minIdx] = temp;
14 |         }
15 |     }
16 | 
17 |     public static void main(String[] args) {
18 |         int[] arr = {64, 25, 12, 22, 11};
19 |         selectionSort(arr);
20 |         for (int num : arr) System.out.print(num + " ");
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/QN_63_SRIRAM.java:
--------------------------------------------------------------------------------
 1 | public class BubbleSort {
 2 |     public static void bubbleSort(int[] arr) {
 3 |         for (int i = 0; i < arr.length - 1; i++) {
 4 |             boolean swapped = false;
 5 |             for (int j = 0; j < arr.length - 1 - i; j++) {
 6 |                 if (arr[j] > arr[j + 1]) {
 7 |                     // swap
 8 |                     int temp = arr[j];
 9 |                     arr[j] = arr[j + 1];
10 |                     arr[j + 1] = temp;
11 |                     swapped = true;
12 |                 }
13 |             }
14 |             if (!swapped) break; // optimization
15 |         }
16 |     }
17 | 
18 |     public static void main(String[] args) {
19 |         int[] arr = {5, 1, 4, 2, 8};
20 |         bubbleSort(arr);
21 |         for (int num : arr) System.out.print(num + " ");
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/QN_64_SRIRAM.java:
--------------------------------------------------------------------------------
 1 | public class MergeSort {
 2 |     public static void mergeSort(int[] arr, int left, int right) {
 3 |         if (left < right) {
 4 |             int mid = (left + right) / 2;
 5 | 
 6 |             mergeSort(arr, left, mid);
 7 |             mergeSort(arr, mid + 1, right);
 8 | 
 9 |             merge(arr, left, mid, right);
10 |         }
11 |     }
12 | 
13 |     private static void merge(int[] arr, int left, int mid, int right) {
14 |         int n1 = mid - left + 1;
15 |         int n2 = right - mid;
16 | 
17 |         int[] L = new int[n1];
18 |         int[] R = new int[n2];
19 | 
20 |         for (int i = 0; i < n1; i++) L[i] = arr[left + i];
21 |         for (int j = 0; j < n2; j++) R[j] = arr[mid + 1 + j];
22 | 
23 |         int i = 0, j = 0, k = left;
24 | 
25 |         while (i < n1 && j < n2) {
26 |             if (L[i] <= R[j]) arr[k++] = L[i++];
27 |             else arr[k++] = R[j++];
28 |         }
29 | 
30 |         while (i < n1) arr[k++] = L[i++];
31 |         while (j < n2) arr[k++] = R[j++];
32 |     }
33 | 
34 |     public static void main(String[] args) {
35 |         int[] arr = {38, 27, 43, 3, 9, 82, 10};
36 |         mergeSort(arr, 0, arr.length - 1);
37 |         for (int num : arr) System.out.print(num + " ");
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/QN_65_SRIRAM.java:
--------------------------------------------------------------------------------
 1 | public class QuickSort {
 2 |     public static void quickSort(int[] arr, int low, int high) {
 3 |         if (low < high) {
 4 |             int pi = partition(arr, low, high);
 5 | 
 6 |             quickSort(arr, low, pi - 1);
 7 |             quickSort(arr, pi + 1, high);
 8 |         }
 9 |     }
10 | 
11 |     private static int partition(int[] arr, int low, int high) {
12 |         int pivot = arr[high];
13 |         int i = low - 1;
14 | 
15 |         for (int j = low; j < high; j++) {
16 |             if (arr[j] <= pivot) {
17 |                 i++;
18 |                 // swap
19 |                 int temp = arr[i];
20 |                 arr[i] = arr[j];
21 |                 arr[j] = temp;
22 |             }
23 |         }
24 | 
25 |         // swap pivot
26 |         int temp = arr[i + 1];
27 |         arr[i + 1] = arr[high];
28 |         arr[high] = temp;
29 | 
30 |         return i + 1;
31 |     }
32 | 
33 |     public static void main(String[] args) {
34 |         int[] arr = {10, 7, 8, 9, 1, 5};
35 |         quickSort(arr, 0, arr.length - 1);
36 |         for (int num : arr) System.out.print(num + " ");
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/QN_6_Krish.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | 
 3 | public class Main {
 4 |     public static void main(String[] args) {
 5 |       //Count no of digits in a Number 
 6 |       //Using Math 
 7 |       int num=1009;
 8 |       System.out.println((int)Math.log10(num)+1);//op 4
 9 |       //while loop 
10 |       int count =0;
11 |       while(num>0){
12 |         num/=10;
13 |         count++;
14 |       }
15 |       System.out.println(count);
16 |       num=1009;
17 |       //Inbuild Function Using String length
18 |       System.out.println((num+"").length());
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/QN_6_ROHAN.py:
--------------------------------------------------------------------------------
 1 | n = 12345
 2 | 
 3 | # Standard method - counts digit by digit
 4 | def numberLength(n):
 5 |     cnt = 0
 6 |     while n:
 7 |         cnt += 1
 8 |         n //= 10
 9 |     return cnt
10 |     
11 | print(numberLength(n))
12 | 
13 | # One Liner
14 | print(len(str(n)))
15 | 


--------------------------------------------------------------------------------
/QN_7_ROHAN.py:
--------------------------------------------------------------------------------
 1 | num = 12340
 2 | 
 3 | # Standard method - iterates digit by digit
 4 | def reverseNumber(num):
 5 |     new_num = 0
 6 |     while num:
 7 |         new_num = new_num * 10 + (num % 10)
 8 |         num //= 10
 9 |     return new_num
10 |     
11 | print(reverseNumber(num))
12 | 
13 | # One Liner
14 | print(int(str(num)[::-1]))
15 | 


--------------------------------------------------------------------------------
/QN_8_Atchayah-S.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class AmstrongNumber{
 3 | public static boolean isAmstrong(int num){
 4 |     int temp=num,len=0,result=0;
 5 |     while(temp>0){
 6 |         temp/=10;
 7 |         len++;
 8 |     }
 9 |     temp=num;
10 |     while(temp>0){
11 |         result+=Math.pow(temp%10,len);
12 |         temp/=10;
13 |     }
14 | return (result==num);
15 | }
16 | public static void main(String args[]){
17 |     int num;
18 |     Scanner sc=new Scanner(System.in);
19 |     num=sc.nextInt();
20 |     System.out.println(isAmstrong(num)?num+" is an Armstrong Number": num+" is not an Armstrong Number");
21 |     }
22 | }


--------------------------------------------------------------------------------
/QN_8_ROHAN.py:
--------------------------------------------------------------------------------
 1 | num = 153
 2 | 
 3 | # Standard method - iterates digit by digit
 4 | def armstrongNumber(num):
 5 |     sum_of_cubes = 0
 6 |     n = num
 7 |     while num:
 8 |         digit = num % 10
 9 |         sum_of_cubes += digit ** 3
10 |         num //= 10
11 |     return sum_of_cubes == n
12 |     
13 | print(armstrongNumber(num))
14 | 
15 | # One Liner
16 | print(sum(int(digit) ** 3 for digit in str(num)) == num)
17 | 


--------------------------------------------------------------------------------
/QN_9_ROHAN.py:
--------------------------------------------------------------------------------
 1 | #Best and quickest Prime check - TC - O(n), SC - O(n)
 2 | def isPrime(n):
 3 |     if n < 2:
 4 |         return False
 5 |     if n < 4: return True
 6 |     if n % 2 == 0 or n % 3 == 0:
 7 |         return False
 8 |     for i in range(5, int(n ** 0.5) + 1, 6):
 9 |         if n % i == 0 or n % (i + 2) == 0:
10 |             return False
11 |     return True
12 |     
13 | n = 100
14 | for i in range(n + 1):
15 |     if isPrime(i):
16 |         print(i, end = ' ')
17 | 


--------------------------------------------------------------------------------
/Q_1_AMUTHAN.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class FactorialUsingRecursion {
 3 |     public static int recursion(int n) {
 4 |         if(n-1 == 0) {
 5 |           return 1;
 6 |         }
 7 |         return n * recursion(n-1);
 8 |     }
 9 |     public static void main (String args[]) {
10 |         Scanner sc = new Scanner(System.in);
11 |         int n = sc.nextInt();
12 |         int answer = recursion(n);
13 |         System.out.print("The factorial of "+n+" is "+answer);
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/Q_2_AMUTHAN.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class PrimeNumberChecker {
 3 |     public static boolean isPrime(int n) {
 4 |         if(n == 1 || n == 0) {
 5 |             return false;
 6 |         }else if(n == 2) {
 7 |             return true;
 8 |         }
 9 |         int c = 1;
10 |         for(int i=2; i<=n/2; i++) {
11 |             if(n %% i == 0) {
12 |                 c = 0;
13 |             }
14 |         }
15 |         if(c == 1) {
16 |             return true;
17 |         }else {
18 |             return false;
19 |         }
20 |     }
21 |     public static void main (String args[]) {
22 |         Scanner sc = new Scanner(System.in);
23 |         int n = sc.nextInt();
24 |         if(isPrime(n)) {
25 |             System.out.println(n+" is prime number");
26 |         }else {
27 |             System.out.println(n+" is not prime number");
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/Qn_1_Abhilash.java:
--------------------------------------------------------------------------------
 1 | class Fact_rec{
 2 |     static int factorial(int n) {
 3 |         if (n == 0)
 4 |             return 1;
 5 |         else
 6 |             return (n * factorial(n - 1));
 7 |     }
 8 |     public static void main(String args[]){
 9 |         int num=4;
10 |         int fact=factorial(num);
11 |             System.out.println("factorial of "+num+" is "+fact);
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/Qn_1_Arularasan.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Main{
 3 | public static void main(String[] args){
 4 |   int a=3;
 5 |   System.out.print(factorial(a));//3*2*1 = 6
 6 | }
 7 |   public static int factorial(int a){
 8 |     if(a==0) return 1;
 9 |     return a*factorial(a-1);
10 |   }
11 | }
12 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # 75 Logic Building Problems
  2 | 
  3 | This repository contains a curated list of **75 logic-building problems** designed to enhance your problem-solving skills. Each problem is categorized into different topics such as math, strings, arrays, recursion, puzzles, and more. Feel free to attempt the problems and explore the solutions.
  4 | 
  5 | ---
  6 | 
  7 | ## Math-Based Problems
  8 | 
  9 | 1. Find the factorial of a number using recursion.
 10 | 2. Check if a number is prime.
 11 | 3. Generate the first N Fibonacci numbers.
 12 | 4. Find the greatest common divisor (GCD) of two numbers.
 13 | 5. Check if a number is a palindrome.
 14 | 6. Count the number of digits in a number.
 15 | 7. Reverse the digits of a number.
 16 | 8. Check if a number is an Armstrong number.
 17 | 9. Print all prime numbers up to N.
 18 | 10. Find the sum of digits of a number until it becomes a single digit.
 19 | 
 20 | ---
 21 | 
 22 | ## String Manipulation
 23 | 
 24 | 11. Reverse a string.
 25 | 12. Check if a string is a palindrome.
 26 | 13. Find the frequency of characters in a string.
 27 | 14. Remove all vowels from a string.
 28 | 15. Replace spaces with underscores in a string.
 29 | 16. Count the number of words in a string.
 30 | 17. Find the longest word in a string.
 31 | 18. Check if two strings are anagrams.
 32 | 19. Remove duplicate characters from a string.
 33 | 20. Find the first non-repeating character in a string.
 34 | 
 35 | ---
 36 | 
 37 | ## Array Problems
 38 | 
 39 | 21. Find the largest and smallest element in an array.
 40 | 22. Sort an array without using in-built functions.
 41 | 23. Find the second largest number in an array.
 42 | 24. Remove duplicate elements from an array.
 43 | 25. Rotate an array to the right by K steps.
 44 | 26. Merge two sorted arrays.
 45 | 27. Find the missing number in an array of size N containing numbers from 1 to N+1.
 46 | 28. Find the intersection of two arrays.
 47 | 29. Find the subarray with the maximum sum (Kadane’s algorithm).
 48 | 30. Move all zeros in an array to the end.
 49 | 
 50 | ---
 51 | 
 52 | ## Recursion Problems
 53 | 
 54 | 31. Find the Nth Fibonacci number using recursion.
 55 | 32. Solve the Tower of Hanoi problem.
 56 | 33. Print all subsets of a given set.
 57 | 34. Calculate the power of a number using recursion.
 58 | 35. Generate all permutations of a string.
 59 | 36. Solve the N-Queens problem.
 60 | 37. Find the sum of the first N natural numbers using recursion.
 61 | 38. Count the number of ways to climb stairs (1 or 2 steps at a time).
 62 | 39. Find the greatest common divisor (GCD) using recursion.
 63 | 40. Print all possible combinations of balanced parentheses.
 64 | 
 65 | ---
 66 | 
 67 | ## Logical Puzzles
 68 | 
 69 | 41. Solve the classic FizzBuzz problem.
 70 | 42. Check if a number is a perfect square.
 71 | 43. Determine if a year is a leap year.
 72 | 44. Simulate the Josephus problem.
 73 | 45. Check if a Sudoku board is valid.
 74 | 46. Calculate the digital root of a number.
 75 | 47. Find the day of the week for a given date.
 76 | 48. Solve the classic “Rat in a Maze” problem.
 77 | 49. Find the longest common prefix among a list of strings.
 78 | 50. Generate Pascal’s Triangle.
 79 | 
 80 | ---
 81 | 
 82 | ## Bit Manipulation
 83 | 
 84 | 51. Find the only non-repeating element in an array where every other element repeats twice.
 85 | 52. Count the number of 1s in the binary representation of a number.
 86 | 53. Check if a number is a power of 2.
 87 | 54. Swap two numbers without using a temporary variable.
 88 | 55. Find the two non-repeating elements in an array where every other element repeats twice.
 89 | 56. Reverse the bits of a number.
 90 | 57. Check if two numbers differ by exactly one bit.
 91 | 58. Determine the XOR of all elements in an array.
 92 | 59. Find the position of the rightmost set bit in a number.
 93 | 60. Toggle the Kth bit of a number.
 94 | 
 95 | ---
 96 | 
 97 | ## Searching and Sorting
 98 | 
 99 | 61. Implement binary search.
100 | 62. Implement selection sort.
101 | 63. Implement bubble sort.
102 | 64. Implement merge sort.
103 | 65. Implement quick sort.
104 | 66. Find the Kth smallest element in an array.
105 | 67. Find the peak element in a mountain array.
106 | 68. Count the number of occurrences of an element in a sorted array.
107 | 69. Find the first and last positions of an element in a sorted array.
108 | 70. Search for a number in a 2D matrix.
109 | 
110 | ---
111 | 
112 | ## Dynamic Programming
113 | 
114 | 71. Solve the Knapsack problem.
115 | 72. Find the minimum number of coins needed to make a given sum.
116 | 73. Find the longest increasing subsequence.
117 | 74. Solve the Matrix Chain Multiplication problem.
118 | 75. Solve the Longest Common Subsequence problem.
119 | 
120 | ---
121 | 
122 | ## Contribution
123 | Feel free to contribute additional solutions or optimize the existing ones. Pull requests are welcome!
124 | 
125 | **FILE NAME FORMATS : QN_NUMBER_URNAME
126 | EG: QN_1_KRISHNA.JAVA**
127 | 
128 | ---
129 | 
130 | 


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