DEV Community: vimala jeyakumar

Searching in java

vimala jeyakumar — Tue, 25 Feb 2025 04:45:33 +0000

Searching:

-->Searching Algorithms are designed to check for an element or retrieve an element from any data structure where it is stored.
-->In Java,searching refers to the process of finding an element in a data structure like an array,list,or map.
--> Based on the type of search operation, these algorithms are generally classified into two categories.

Linear Search(Sequential Search)
Binary Search(Interval Search)

Linear Search:

--> Linear search is a fundamental search algorithm that iterates through a list of elements one by one, comparing each element to the target value.
--> If the target value is found, the search stops and returns the index of the element.
--> Otherwise, the search continues until the end of the list is reached, at which point it returns -1 to indicate that the target value was not found.

When is Linear Search Useful?
Linear search is useful in several scenarios:
1. Small Data Sets
--->When the data set is relatively small (e.g., less than a few hundred elements), linear search can be efficient because the number of comparisons required is small.
2. Unsorted Data
-->Linear search is particularly useful for unsorted data, as it does not require any prior sorting of the elements.
3. Simple Implementation
-->Linear search is one of the simplest search algorithms to implement, making it suitable for beginners and educational purposes.
4. Iterative Nature
-->Linear search is an iterative algorithm, meaning it can be easily implemented using a loop. This makes it easy to understand and debug.
5. Real-Time Applications
-->In certain real-time applications where the data set is constantly changing, linear search can be more efficient than other search algorithms that require preprocessing or sorting.
6. Limited Memory
-->Linear search requires minimal memory overhead, as it only needs to store the current element being compared. This makes it suitable for systems with limited memory resources.

Example Program:(using while loop)

package Search;

public class LinearSearch {

    public static void main(String[] args)
    {
    int[] arr= {12,34,76,56,87,45,100};
    int key=87;
    int i =0;
    while(true)
    {
        if (arr[i]==key)
        {
          System.out.println("key "+key+" is presenting at:"+i );
          return;// Exits the main() method immediately
         }
    i++;
    }
System.out.println("Key " + key + " is not found in the array.");
    }

}

Output:
key 87 is presenting at:4

2.

package Search;
public class LinearSearch {
    public static void main(String[] args) {
        int[] arr = {12, 34, 76, 56, 87, 45, 100};
        int key = 87;
        int i = 0;

        while (i < arr.length) {
            if (arr[i] == key) {
                System.out.println("Key " + key + " is present at index: " + i);
                break;// Exits only the loop, but the program continues

            }
            i++;
        }
System.out.println("Search operation complete.");

    }
}

Output:
Key 87 is present at index: 4
Search operation complete.

Note:

Why Use return; Instead of break;?
-->return; exits the entire method (main() in this case).
-->break; only exits the loop, but execution would continue with any remaining statements after the loop.

Recursive Approach:

package Search;

public class RecursiveLinearSearch 
{
     public static void main(String[] args) {
            int[] arr = {12, 34, 76, 56, 87, 45, 100};
            int key = 100;

            int result = linearSearch(arr, key, 0);

            if (result != -1) {
                System.out.println("Key " + key + " is present at index: " + result);
            } else {
                System.out.println("Key " + key + " is not found in the array.");
            }
        }

            public static int linearSearch(int[] arr, int key, int index) 
            {          
                if (index >= arr.length) 
                {
                    return -1;
                }
                if (arr[index] == key) 
                {
                    return index;
                }

                return linearSearch(arr, key, index + 1);
            }

    }

Output:
Key 100 is present at index: 6

Count of digits and Palindrome

vimala jeyakumar — Tue, 25 Feb 2025 02:10:50 +0000

Count of Digits:

-->Given a number n, the task is to return the count of digits in this number.
Example:

Input: n = 1567
Output: 4
Explanation: There are 4 digits in 1567, which are 1, 5, 6 and 7

-->The idea is to count the digits by removing the digits from the input number starting from right(least significant digit) to left(most significant digit) till the number is reduced to 0.
--> We are removing digits from the right because the rightmost digit can be removed simply by performing integer division by 10. For eg: n = 1567, then 1567 / 10 = 156.7 = 156(Integer Division).

Flowchart:

Example:

package programs;

public class CountOfDigit {

    public static void main(String[] args) 
    {
        int no = 54321;
        int count = 0;
        while(no>0)
        {
            //System.out.println(no%10);
            //no = no/10;
            count = count+1;

        }
        System.out.println("count: "+count);

    }
}

Output:
1
2
3
4
5
count: 5

For loop-Numbers pattern printing

vimala jeyakumar — Fri, 14 Feb 2025 03:19:48 +0000

Example Program1:

package Forloop;

public class Pattern {

    public static void main(String[] args)
    {
        pattern();
        pattern1();
        pattern2();
        pattern3();
        pattern4();
        pattern5();
        pattern6();

    }

    private static void pattern6()
    {
        for (int line=1;line<=9;line++)
        {
            for(int col=1;col<=9;col++)
            {
                if((line==9&&col<9)||(line==5&&col<9)||(line==1&&col>1))
                    System.out.print("* ");
                else if(col==1&&line>1)
                    System.out.print("* ");
                else if((line==6||line==7||line==8)&&col==9)
                    System.out.print("* ");
                else
                    System.out.print("  ");
            }
         System.out.println();
        }   

    }

    private static void pattern5() 
    {
        for (int line=1;line<=9;line++)
        {
            for(int col=1;col<=9;col++)
            {
                if((line==9&&col<9)||(line==5&&col<9)||(line==1&&col>1))
                    System.out.print("* ");
                else if((line==2||line==3||line==4)&&col==1)
                    System.out.print("* ");
                else if((line==6||line==7||line==8)&&col==9)
                    System.out.print("* ");
                else
                    System.out.print("  ");
            }
         System.out.println();
        }   

    }

    private static void pattern4() 
    {
        for (int line=1;line<=9;line++)
        {
            for(int col=1;col<=9;col++)
            {
                if((line==5&&col<8)||col==5||col+line==6)
                    System.out.print("* ");
                else
                    System.out.print("  ");
            }
         System.out.println();
        }


    }

    private static void pattern3() 
    {
        for (int line=1;line<=9;line++)
        {
            for(int col=1;col<=9;col++)
            {
                if(line==9||line==1||(line==5)||col==9)
                    System.out.print("* ");

                else
                    System.out.print("  ");
            }
          System.out.println(); 
        }

    }

    private static void pattern2()
    {
        for (int line=1;line<=9;line++)
        {
            for(int col=1;col<=9;col++)
            {
                if((line==9&&col>1)||(line==5&&col>1)||(line==1&&col<9))
                    System.out.print("* ");
                else if((line==2||line==3||line==4)&&col==9)
                    System.out.print("* ");
                else if((line==6||line==7||line==8)&&col==1)
                    System.out.print("* ");
                else
                    System.out.print("  ");
            }
         System.out.println();
        }

    }

    private static void pattern1() 
    {
        for (int line=1;line<=9;line++)
        {
            for(int col=1;col<=9;col++)
            {
                if(line==9||col==5||col+line==6)
                    System.out.print("* ");
                else
                    System.out.print("  ");
            }
         System.out.println();
        }

    }

    private static void pattern() 
    {

        for (int line=1; line<=10;line++)
        {
            for(int col=1; col<=10; col++) {
              System.out.print("*  ");  
            }

            System.out.println("  "); 
        }


    }
}

output:

*  *  *  *  *  *  *  *  *  *    
*  *  *  *  *  *  *  *  *  *    
*  *  *  *  *  *  *  *  *  *    
*  *  *  *  *  *  *  *  *  *    
*  *  *  *  *  *  *  *  *  *    
*  *  *  *  *  *  *  *  *  *    
*  *  *  *  *  *  *  *  *  *    
*  *  *  *  *  *  *  *  *  *    
*  *  *  *  *  *  *  *  *  *    
*  *  *  *  *  *  *  *  *  * 

        *         
      * *         
    *   *         
  *     *         
*       *         
        *         
        *         
        *         
* * * * * * * * *

* * * * * * * *   
                * 
                * 
                * 
  * * * * * * * * 
*                 
*                 
*                 
  * * * * * * * * 

* * * * * * * * * 
                * 
                * 
                * 
* * * * * * * * * 
                * 
                * 
                * 
* * * * * * * * * 

        *         
      * *         
    *   *         
  *     *         
* * * * * * *     
        *         
        *         
        *         


  * * * * * * * * 
*                 
*                 
*                 
* * * * * * * *   
                * 
                * 
                * 
* * * * * * * * 

  * * * * * * * * 
*                 
*                 
*                 
* * * * * * * *   
*               * 
*               * 
*               * 
* * * * * * * *

Program2:

package Forloop;

public class Shape {

    public static void main(String[] args)
    {
        shape1();
        shape2();
        shape3();
        shape4();
    }
    private static void shape4()
    {
        for (int row = 5; row>=1;row--)
        {
          for(int col=1; col<=row; col++)
          {
             System.out.print(row+" ");
          }
        System.out.println();
    }   

    }
    private static void shape3()
    {
        for (int row=1; row<=5;row++)
        {
          for(int col=1; col<=row; col++)
          {
             System.out.print(col+" " );
          }
        System.out.println();
        }   

    }
    private static void shape2()
    {
        for (int row=1; row<=5;row++)
        {
          for(int col=1; col<=row; col++)
          {
             System.out.print("* ");
          }
        System.out.println();
        }

    }
    private static void shape1() 
    {   
      for (int row = 5; row>=1;row--)
        {
          for(int col=1; col<=row; col++)
          {
             System.out.print("* ");
          }
        System.out.println();
    }

    }
    }

Output:

* * * * * 
* * * * 
* * * 
* * 
* 

* 
* * 
* * * 
* * * * 
* * * * * 

1 
1 2 
1 2 3 
1 2 3 4 
1 2 3 4 5 

5 5 5 5 5 
4 4 4 4 
3 3 3 
2 2 
1

For loop - Alphabet pattern printing

vimala jeyakumar — Thu, 13 Feb 2025 03:01:43 +0000

Program 1:

package Forloop;

public class PatternV
{
        public static void main(String[] args) 
        {
            patternV();

        }

        private static void patternV() 
        {
            for (int line=1; line<=9;line++)
            {
                for(int col=1; col<=9; col++) 
                {
                    if((line==col || line+col==10) && line<=5)
                         System.out.print("* ");
                    else
                        System.out.print("  ");
                }

                System.out.println();  
            }

        }
    }


------------------------------------------------------------------
OUTPUT:

*               * 
  *           *   
    *       *     
      *   *       
        *

Program 2:

package Forloop;

public class PatternI 
{

    public static void main(String[] args) 
    {
        patterni();

    }

    private static void patterni()
    {
        for (int line=1; line<=9;line++)
        {
            for(int col=1; col<=9; col++) 
            {
                if (line==1 || col==5 || line==9)
                     System.out.print("* ");
                else 
                    System.out.print("  ");
            }

            System.out.println(); 
        }
    }

}

--------------------------------------------------------------------
OUTPUT:

* * * * * * * * * 
        *         
        *         
        *         
        *         
        *         
        *         
        *         
* * * * * * * * *

Program 3:

package Forloop;

public class PatternM 
{

    public static void main(String[] args) 
    {
        patternM();


    }
    private static void patternM()
    {

        int line;
        for ( line=1; line<=9;line++)
        {
            for (int col=1; col<=9;col++)
            {
                if (col==1 || col==9)
                  System.out.print("* ");   
                else if((line==col || line+col==10)&&line<=5)
                       System.out.print("* ");
                 else
                     System.out.print("  ");
                }

            System.out.println(); 
        }

    }

    }


--------------------------------------------------------------------
OUTPUT:

*               * 
* *           * * 
*   *       *   * 
*     *   *     * 
*       *       * 
*               * 
*               * 
*               * 
*               *

Program 4:

package Forloop;

public class PatternA
{

    public static void main(String[] args) 
    {
        patternA();

    }

    private static void patternA() 
    {
        for (int line=1; line<=9;line++)
        {
            for(int col=1; col<=9; col++) 
            {
                if((line==col || line+col==10) && 5<=line)
                     System.out.print("* ");
                else if( (line==7 ||col==3||col==4|| col==5)&& 7==line)
                    System.out.print("* ");
                else
                    System.out.print("  ");
            }

            System.out.println();  
        }

    }

}
--------------------------------------------------------------------
OUTPUT:

        *         
      *   *       
* * * * * * * * * 
  *           *   
*               *

Program 5:

package Forloop;

public class PatternL
{

    public static void main(String[] args) 
    {
        patternL();

    }

    private static void patternL() 
    {
        int line;
        for ( line=1; line<=9;line++)
        {
            for (int col=1; col<=9;col++)
            {
                if (col==1 || line==9)
                  System.out.print("* ");   
                 else
                     System.out.print("  ");
                }

            System.out.println(); 
        }
    }

}
--------------------------------------------------------------------
OUTPUT:

*                 
*                 
*                 
*                 
*                 
*                 
*                 
*                 
* * * * * * * * *

Program 6:

package Forloop;

public class PatternD {

    public static void main(String[] args) 
    {
        patternD();
    }

    private static void patternD()
    {   
        for (int line=1; line<=10;line++)
            {
               for(int col=1; col<=10; col++) 
                 {
                    if(col==3||col==10)
                          System.out.print("* "); 
                    else if(line==10 || line==1)
                           System.out.print("* ");
                     else
                         System.out.print("  ");
            }

                        System.out.println(" "); 
                    }

    }

}
--------------------------------------------------------------------
OUTPUT:

* * * * * * * * * *  
    *             *  
    *             *  
    *             *  
    *             *  
    *             *  
    *             *  
    *             *  
    *             *  
* * * * * * * * * *

Program 7:

package Forloop;

public class PatternE {

    public static void main(String[] args) 
    {
            patternE();
            patternV();
            patterni();

    }

    private static void patterni()
    {
        for (int line=1; line<=9;line++)
        {
            for(int col=1; col<=9; col++) 
            {
                if (line==1 || col==5 || line==9)
                     System.out.print("* ");
                else 
                    System.out.print("  ");
            }

            System.out.println(); 
        }
    }

    private static void patternV() 
    {
        for (int line=1; line<=9;line++)
        {
            for(int col=1; col<=9; col++) 
            {
                if((line==col || line+col==10) && line<=5)
                     System.out.print("* ");
                else
                    System.out.print("  ");
            }

            System.out.println();  
        }

    }

        private static void patternE() 
        {

            for (int line=1; line<=10;line++)
            {
                for(int col=1; col<=10; col++) 
                {
                    if(line==1||col==1||line==10||line==5)
                  System.out.print("* ");  
                }

                System.out.println("  "); 
            }


    }

}

--------------------------------------------------------------------
OUTPUT:

* * * * * * * * * *   
*   
*   
*   
* * * * * * * * * *   
*   
*   
*   
*   
* * * * * * * * * *


*               * 
  *           *   
    *       *     
      *   *       
        *       


* * * * * * * * * 
        *         
        *         
        *         
        *         
        *         
        *         
        *         
* * * * * * * * *

Program 8:(F)

package Forloop;

public class PatternF {

    public static void main(String[] args) 
    {
        patternF();

    }

    private static void patternF() 
    {

        for (int line=1; line<=10;line++)
        {
            for(int col=1; col<=5; col++) 
            {
                if(line==1||col==1||line==5)
              System.out.print("* ");  
            }

            System.out.println("  "); 
        }
    }
    }

--------------------------------------------------------------------
OUTPUT:

* * * * *   
*   
*   
*   
* * * * *   
*   
*   
*   
*   
*

Program 9:

package Forloop;

public class Pattern1
{

    public static void main(String[] args) 
    {
        pattern1();
        pattern2();

    }

    private static void pattern2() 
    {
        for (int line=1; line<=10;line++)
        {
           for(int col=1; col<=10; col++) 
             {
                if(col==1||col==10)
                      System.out.print("* "); 
                else if(line==col||line+col==10)
                       System.out.print("* ");
                 else
                     System.out.print("  ");
               }

           System.out.println("  ");     
}}


    private static void pattern1()
    {
        for (int line=1; line<=10;line++)
        {
           for(int col=1; col<=10; col++) 
             {
                if(col==1||col==10)
                      System.out.print("* "); 
                else if(line==10 || line==1||line==col||line+col==10)
                       System.out.print("* ");
                 else
                     System.out.print("  ");
               }

           System.out.println("  ");     
}}

}


--------------------------------------------------------------------
OUTPUT:

* * * * * * * * * *   
* *           *   *   
*   *       *     *   
*     *   *       *   
*       *         *   
*     *   *       *   
*   *       *     *   
* *           *   *   
*               * *   
* * * * * * * * * * 


*               * *   
* *           *   *   
*   *       *     *   
*     *   *       *   
*       *         *   
*     *   *       *   
*   *       *     *   
* *           *   *   
*               * *   
*                 *

Program 10:

package Forloop;

public class Pattern2 {

    public static void main(String[] args) 
    {
        pattern2();

    }

    private static void pattern2() 
    {
            for (int line=1; line<=10;line++)
            {
               for(int col=1; col<=10; col++) 
                 {
                    if(col==5||line==5)
                          System.out.print("* "); 
                    else if(line==col||line+col==10)
                           System.out.print("* ");
                     else
                         System.out.print("  ");
                   }

               System.out.println("  ");     
    }}

    }


--------------------------------------------------------------------
OUTPUT:

*       *       *     
  *     *     *       
    *   *   *         
      * * *           
* * * * * * * * * *   
      * * *           
    *   *   *         
  *     *     *       
*       *       *     
        *         *

Modulo or Remainder in java

vimala jeyakumar — Wed, 12 Feb 2025 14:43:50 +0000

Remainder:

-->Modulo or Remainder Operator returns the remainder of the two numbers after division.
-->If you are provided with two numbers, say A and B, A is the dividend and B is the divisor, A mod B is there a remainder of the division of A and B.
-->Modulo operator is an arithmetical operator which is denoted by %.
NOTE:
If numerator is less than denominator then % will give output as the numerator only.

Syntax:

A % B
Where A is the dividend and B is divisor

quotient = dividend / divisor;
remainder = dividend % divisor;

Quotient:

The quotient is the quantity produced by the division of two numbers. For example,
-->(7/2) = 3 In the above expression 7 is divided by 2, so the quotient is 3 and the remainder is 1.

Example Program:

package programs;

public class Reminder {

    public static void main(String[] args) 
    {
        int no = 6547;

        while(no>0)
        {
            System.out.println(no%10);// 5 4 3 2

            no=no/10;//123 12 1
        }

    }

}

Output:
7
4
5
6
example program:

package programs;

public class Reminder {

    public static void main(String[] args) 
    {
        int no = 6547;
        int reminder;
        int quotient;
        while(no>0){

            reminder=no%10;// 5 4 3 2
            System.out.println("Reminder: "+reminder);
            quotient=no/10;//123 12 1
            System.out.println("Quotient: "+quotient);
            no=quotient;
        }


    }
}

Output:
Reminder: 7
Quotient: 654
Reminder: 4
Quotient: 65
Reminder: 5
Quotient: 6
Reminder: 6
Quotient: 0

Reference:

https://www.geeksforgeeks.org/program-to-find-quotient-and-remainder-in-java/
https://www.geeksforgeeks.org/modulo-or-remainder-operator-in-java/
https://www.tpointtech.com/write-a-program-to-find-the-quotient-and-remainder

Reverse in java

vimala jeyakumar — Tue, 11 Feb 2025 17:32:46 +0000

Definition:

->In Java, "reverse" refers to the process of changing the order of elements in a data structure so that they appear in the opposite sequence.

1.Strings – Changing the order of characters (e.g., "hello" → "olleh").
2.Arrays – Changing the order of elements in an array
(e.g., {1, 2, 3} → {3, 2, 1}).
3.Lists – Reversing the order of elements in an ArrayList, LinkedList, etc.
4.Numbers – Reversing the digits of an integer (e.g., 123 → 321).

Reverse Number:

->In Java, reversing a number means that the digit at the first position should be swapped with the last digit, the second digit will be swapped with the second last digit, and so on till the middle element.

Algorithm for Reversing a Number in Java
->Take the number’s modulo by 10.
->Multiply the reverse number by 10 and add modulo value into the reverse number.
->Divide the number by 10.
->Repeat above steps until number becomes zero.
Example Program:

package programs;

public class Reverse 
{

    public static void main(String[] args) 
    {
                int num = 2910;
                int reversed = 0;

                while (num != 0) 
                {
                    int digit = num % 10;
                    reversed = reversed * 10 + digit;
                    num /= 10;
                    System.out.println("Reversed: " + reversed);
                }
//              System.out.println("Reversed: " + reversed);
            }       
    }

output:
Reversed: 0
Reversed: 1
Reversed: 19
Reversed: 192

Reverse String:

package programs;

public class ReverseString {

    public static void main(String[] args) 
    {
        String str = "Hello";
        String reversed = "";
        for (int i = str.length() - 1; i >= 0; i--) {
            reversed += str.charAt(i);
        }
        System.out.println("Reversed: " + reversed);

    }

}

output:
Reversed: olleH

Reference:
--> https://www.geeksforgeeks.org/java-reverse-number-program/
--> https://www.tpointtech.com/how-to-reverse-string-in-java
--> https://chatgpt.com/c/67ab758b-6c98-800f-8b8f-b39e0d01b060

Number Series

vimala jeyakumar — Mon, 03 Feb 2025 13:54:19 +0000

Task:

1 . Look at this series: 58, 52, 46, 40, 34, ... What number should come next?
26

32
Ans:
The series is decreasing by 6 each time:

58 - 6 = 52
52 - 6 = 46
46 - 6 = 40
40 - 6 = 34

So, continuing the pattern, 34 - 6 = 28.

The next number in the series is 28.

Program:

package day1if;

public class Numberseries1 
{
public static void main (String args[])
{
    int no = 58;
    int count = 1;
    while( count<=5)
    {
        System.out.println(no);
        no = no-6;
        count = count+ 1;

    }
}
}

output:
58
52
46
40
34
28

2.Look at this series: 3, 4, 7, 8, 11, 12, ... What number should come next?
7

15
Ans:
Let’s look at the pattern:

3 → 4 (add 1)
4 → 7 (add 3)
7 → 8 (add 1)
8 → 11 (add 3)
11 → 12 (add 1)

It looks like the pattern alternates between adding 1 and adding 3.

Following this pattern, the next step is to add 3 to 12, so:

12 + 3 = 15

The next number in the series is 15.

Program:

package day1if;

public class Numberseries2 {

    public static void main(String[] args) {
        int no = 3;
        int count =1;
        while( count<=7)
        {
            System.out.println(no);
            no = no+1;
            System.out.println(no);
            no = no+3;
            count = count+2;
        }
    }
}

output:
3
4
7
8
11
12
15
16

3.Look at this series: 31, 29, 24, 22, 17, ... What number should come next?
15

12
Ans:
Let’s examine the pattern:

31 → 29 (subtract 2)
29 → 24 (subtract 5)
24 → 22 (subtract 2)
22 → 17 (subtract 5)

The pattern alternates between subtracting 2 and subtracting 5.

So, following this pattern, the next step is to subtract 2 from 17:

17 - 2 = 15

The next number in the series is 15.

Program:

package day1if;

public class Numberseries3 {

    public static void main(String[] args) 
    {

        int no = 31;
        int count =0;
        while( count<=5)
        {
            System.out.println(no);
            no = no-2;
            System.out.println(no);
            no = no-5;
            count = count+2;
        }


    }

}

output:
31
29
24
22
17
15

4.Look at this series: 1.5, 2.3, 3.1, 3.9, ... What number should come next?
4.2

4.4

4.7

5.1
Ans:
Let’s examine the differences between the numbers in the series:

2.3 - 1.5 = 0.8
3.1 - 2.3 = 0.8
3.9 - 3.1 = 0.8

It looks like the series increases by 0.8 each time. So, to find the next number:

3.9 + 0.8 = 4.7

The next number in the series is 4.7.

Program:

package day1if;

public class Numberseries4 {

    public static void main(String[] args)
    {
        float no = 1.5f;
        int count  = 1;
        while (count<6)
        {
            System.out.println(no);
             no = no + 0.8f; 
             count = count+1;
        }
    }

}

Output:
1.5
2.3
3.1
3.8999999
4.7

5.Look at this series: 201, 202, 204, 207, ... What number should come next?
205

208

210

211
Ans:
Let’s look at the differences between the numbers:

202 - 201 = 1
204 - 202 = 2
207 - 204 = 3

It seems the series is increasing by 1, 2, 3, and so on.

Following this pattern, the next difference should be 4. So:

207 + 4 = 211

The next number in the series is 211.

Program:

package day1if;

public class Numberseries5 
{
    public static void main(String[] args)
    {
        int no = 201;
        int count = 1;
        while( count<6)
        {
            System.out.println(no);
            no = no+1;
            System.out.println(no);
            no = no+2;
            System.out.println(no);
            no=no+3;
            System.out.println(no);
            no=no+4;
            count = count+4;
        }
    }

}

Output:
204
207
211
212
214
217

6.Look at this series: 2, 6, 18, 54, ... What number should come next?
108

148

162

216
Ans:
The pattern in the series appears to be multiplying each term by 3:

2 × 3 = 6
6 × 3 = 18
18 × 3 = 54

So, to find the next number, we multiply 54 by 3:

54 × 3 = 162

Thus, the next number in the series is 162.

Program:

package day1if;

public class Numberseries6 
{
    public static void main(String[] args)
    {
        int no =2;
        int count = 1;
        while( count<6)
        {
            System.out.println(no);
            no = no*3;
            count = count+1;
        }

}
    }

Output:
2
6
18
54
162

7.Look at this series: 5.2, 4.8, 4.4, 4, ... What number should come next?
3

3.3

3.5

3.6
Ans:
The pattern in this series appears to be decreasing by 0.4 each time:

5.2 - 0.4 = 4.8
4.8 - 0.4 = 4.4
4.4 - 0.4 = 4

So, to find the next number, we subtract 0.4 from 4:

4 - 0.4 = 3.6

Thus, the next number in the series is 3.6.

Program:

package day1if;

public class Numberseries7
{
    public static void main(String[] args)
    {
        float no =5.2f;
        int count = 1;
        while( count<6)
        {
            System.out.println(no);
            no = no-0.4f;
            count = count+1;
        }

}
}

Output:
5.2
4.7999997
4.3999996
3.9999995
3.5999994

8.Look at this series: 2, 4, 6, 8, 10, ... What number should come next?
11

14
Ans:
The pattern in this series is increasing by 2 each time:

2 + 2 = 4
4 + 2 = 6
6 + 2 = 8
8 + 2 = 10

So, to find the next number, we add 2 to 10:

10 + 2 = 12

Thus, the next number in the series is 12.

Program:

package day1if;

public class Numberseries8 {

    public static void main(String[] args) 
    {
        int no =2;
        int count = 0;
        while( count<6)
        {
            System.out.println(no);
            no = no+2;
            count = count+1;
        }

    }

}

Output:
2
4
6
8
10
12

9.Look at this series: 36, 34, 30, 28, 24, ... What number should come next?
20

26
Ans:
The pattern in this series alternates between subtracting 2 and subtracting 4:

36 - 2 = 34
34 - 4 = 30

30 - 2 = 28
28 - 4 = 24

To find the next number, we subtract 2 from 24:

24 - 2 = 22

Thus, the next number in the series is 22.

Program:

package day1if;

public class Numberseries9 {

    public static void main(String[] args)
    {
        int no =36;
        int count = 0;
        while( count<6)
        {
            System.out.println(no);
            no = no-2;
            System.out.println(no);
            no = no-4;
            count = count+2;
        }



    }

}

Output:
36
34
30
28
24
22

10.Look at this series: 22, 21, 23, 22, 24, 23, ... What number should come next?
22

Ans:
The pattern in this series alternates between subtracting 1 and adding 2:

22 - 1 = 21
21 + 2 = 23
23 - 1 = 22
22 + 2 = 24
24 - 1 = 23

So, the next step should be adding 2 to 23:

23 + 2 = 25

Thus, the next number in the series is 25.

Program:

package day1if;

public class Numberseries10 
{

    public static void main(String[] args) 
    {
        int no =22;
        int count = 0;
        while( count<7)
        {
            System.out.println(no);
            no = no-1;
            System.out.println(no);
            no = no+2;
            count = count+2;
        }


    }

}

Output:
22
21
23
22
24
23
25
24

Control flow statement

vimala jeyakumar — Thu, 30 Jan 2025 18:25:00 +0000

Control flow Statement:

-->Java compiler executes the code from top to bottom. The statements in the code are executed according to the order in which they appear.
-->However, Java provides statements that can be used to control the flow of Java code. Such statements are called control flow statements.
--> It is one of the fundamental features of Java, which provides a smooth flow of program.
Loop statement
-->In programming, sometimes we need to execute the block of code repeatedly while some condition evaluates to true.
-->However, loop statements are used to execute the set of instructions in a repeated order.
-->The execution of the set of instructions depends upon a particular condition.
1.do while loop
2.while loop
3.for loop

While loop:
-->The while loop is also used to iterate over the number of statements multiple times. However, if we don't know the number of iterations in advance, it is recommended to use a while loop.
-->Unlike for loop, the initialization and increment/decrement doesn't take place inside the loop statement in while loop.
-->Java while loop is a control flow statement used to execute the block of statements repeatedly until the given condition evaluates to false.
-->Once the condition becomes false, the line immediately after the loop in the program is executed.

Note: If we do not provide the curly braces ‘{‘ and ‘}’ after while( condition ), then by default while statement will consider the immediate one statement to be inside its block.

Syntax:

    while (test_expression) {   

     // statements        

    update_expression; 


    }

Flowchart:

Example program:

package day1if;
public class WhileLoop {
    public static void main(String[] args) 
    {
      int c = 1; 
     while (c <= 5) 
     {   
       System.out.println(c); 
         c++;  
        }
    }
}

Output:
1
2
3
4
5
2.

package day1if;
class whileLoop {
    public static void main(String args[])
    {
        int i = 1;
      while (i < 6) {
            System.out.println("Welcome to java");  
           i++;

        }
    }
}

Output:
Welcome to java
Welcome to java
Welcome to java
Welcome to java
Welcome to java

Task1:

program:
public class Count
{
public static void main (String args[])
{
int count = 1;
while(count<=5){
count=count+1;
System.out.println("count: "+ count);
}}}

Output:
count: 2
count: 3
count: 4
count: 5
count: 6

Task 2:

Program:
public class Count1
{
public static void main (String args[])
{
int count = 5;
while(count>=1)
{
count=count-1;
System.out.println("count: "+ count);
}
}}
Output:
count: 4
count: 3
count: 2
count: 1
count: 0

Task 3:

program:
public class Count2
{
public static void main (String args[])
{
int count = 1;
while(count<=10){
count=count+2;
System.out.println("count: "+ count);
}}}

Output:
count: 3
count: 5
count: 7
count: 9
count: 11

Task 4:

Program:
public class Count3
{
public static void main (String args[])
{
int count = 0;
while(count<10)
{
count=count+2;
System.out.println("count: "+ count);
}
}}
Output:
count: 2
count: 4
count: 6
count: 8
count: 10

Refernce:
https://www.w3schools.com/java/java_while_loop.asp

https://www.codingem.com/flowchart-loop/

https://www.geeksforgeeks.org/java-while-loop-with-examples/

https://www.geeksforgeeks.org/control-flow-statements-in-programming/

Switch statement & Ternary operator

vimala jeyakumar — Thu, 30 Jan 2025 10:41:10 +0000

Switch Statement:

-->The switch statement in Java is a multi-way branch statement. In simple words, the Java switch statement executes one statement from multiple conditions.
-->It is an alternative to an if-else-if ladder statement. It provides an easy way to dispatch execution to different parts of code based on the value of the expression.
-->The expression can be of type byte, short, char, int, long, (enums, String, or wrapper classes(TBD).

Note: Java switch expression must be of byte, short, int, long(with its Wrapper type), enums and string. Beginning with JDK7, it also works with enumerated types (Enums in java), the String class, and Wrapper classes.

Syntax:

switch(expression)
{
  case value1 :
     // Statements
     break; // break is optional

  case value2 :
     // Statements
     break; // break is optional
     ....
     ....
     ....
   default : 
     // default Statement
}

Flowchart:

Example program:

1.package day1if;
public class SizePrinter {

    public static void main(String[] args) {
        int sizeNumber = 15;

        switch (sizeNumber) {
            case 1:
                System.out.println("Extra Small");
                break;
            case 2:
                System.out.println("Small");
                break;
            case 3:
                System.out.println("Medium");
                break;
            case 4:
                System.out.println("Large");
                break;
            case 5:
                System.out.println("Extra Large");
                break;
            default:
                System.out.println("Invalid size number");
        }
    }
}

Output:
Invalid size number

2.package day1if;

public class Days{

    public static void main(String[] args)
    {
        int day =4;
        String dayString;

        switch (day) 
        { 
         case 1:
            dayString = "Monday";
            break;      
        case 2:
            dayString = "Tuesday";
            break;
        case 3:
            dayString = "Wednesday";
            break;
        case 4:
            dayString = "Thursday";
            break;
        case 5:
            dayString = "Friday";
            break;
        case 6:
            dayString = "Saturday";
            break;
        case 7:
            dayString = "Sunday";
            break;
        default:
            dayString = "Invalid day";
        }
        System.out.println(dayString);
    }
}

Output:
Thursday

Ternary Operator:

-->The ternary operator is a shorthand way of writing an if-else statement. It takes three operands: a condition, a result for when the condition is true, and a result for when the condition is false.

Note: Every code using an if-else statement cannot be replaced with a ternary operator.

Syntax:

condition ? result_if_true : result_if_false

Flowchart:

Example program:

package day1if;
public class TernaryOperator
{  
public static void main(String args[])   
{  
int x, y;  
x = 20;  
y = (x == 1) ? 61: 90;  
System.out.println("Value of y is: " + y);  
y = (x == 20) ? 61: 90;  
System.out.println("Value of y is: " + y);  
}  
}

Output:
Value of y is: 90
Value of y is: 61

Reference:

->https://www.geeksforgeeks.org/switch-statement-in-java/

->https://www.geeksforgeeks.org/conditional-statements-in-programming/

->https://www.javatpoint.com/ternary-operator-in-java

Data Structure Basics

vimala jeyakumar — Thu, 30 Jan 2025 07:28:42 +0000

Data Structure Basics :

1.Normal Statement
2.Conditional Statement
3.Control flow Statement
Normal Statement:
-->we declare variables and constants by specifying their data type and name. A variable holds a value that is going to use in the Java program.
For example:
int quantity = 20;
boolean flag = false;
String message = "Hello;

Conditional Statement:

==>Conditional statements in programming are used to control the flow of a program based on certain conditions.
==>These statements allow the execution of different code blocks depending on whether a specified condition evaluates to true or false, providing a fundamental mechanism for decision-making in algorithms.

If Statement:

-->The if statement is the most basic form of conditional statement. It checks if a condition is true. If it is, the program executes a block of code.
-->if condition is true, the if code block executes. If false, the execution moves to the next block to check.

Syntax:

if (condition) {
    // code to execute if condition is true
}

Flowchart:

Example Program:
package day1if;

public class Players
{
public static void main(String[] args)
{
// TODO Auto-generated method stub
int Cricket = 11;
int basketball = 12;
if(Cricket<basketball)
{
System.out.println("it is true");
}
}
}
Output:
it is true

If-Else Statement:

--> The if-else statement in Java is a powerful decision-making tool used to control the program’s flow based on conditions.
-->It executes one block of code if a condition is true and another block if the condition is false.
Syntax:

if (condition)
{
//Statements to be executed if condition satisfies
}
else
{
//Statements to be executed if the condition is not satisfied
}

Flowchart:

Example Program:
package day1if;

public class UserAge
{
public static void main (String args[])
{
int user = 17;
if(user>=18)
{
System.out.println(" user is 18 or younger");
}
else
{
System.out.println(" user is older than 18");
}
}
}
Output:
user is older than 18

If-Else if Statement:

-->The if-else if statement allows for multiple conditions to be checked in sequence. If the if condition is false, the program checks the next else if condition, and so on.
-->In else if statements, the conditions are checked from the top-down, if the first block returns true, the second and the third blocks will not be checked, but if the first if block returns false, the second block will be checked.
-->This checking continues until a block returns a true outcome.

Syntax:

if (condition)
{
//Statements set 1
}
else if (condition 2)
{
//Statements set 2
}
. . .
else
{
//Statements to be executed if no condition is satisfied.
}

Flowchart:

Example program:
package day1if;

public class ExamResult
{
public static void main (String args[])
{
int mark = 65 ;
if (mark<50)
{
System.out.println("arear");
}
else if (mark<=60)
{
System.out.println(" D grade");
}
else if (mark<=85)
{
System.out.println(" b grade");
}
else
{
System.out.println("pass A grade");
}
}
}

Output:
b grade

Nested if Statement:

-->Nested if in Java refers to having one if statement inside another if statement.
-->If the outer condition is true the inner conditions are checked and executed accordingly.
-->Nested if condition comes under decision-making statement in Java, enabling multiple branches of execution.

Note:
1.Normal if condition checks condition independently which means each condition works on its own.
2.Whereas nested if checks conditions that depend on each other, which means one condition is only checked if another condition is true.

Syntax:

    if(condition){    
         //code to be executed    
              if(condition){  
                 //code to be executed    
        }    
    }

Flowchart:

Example program:

package day1if;
public class Nestedif
{
  public static void main(String args[]) {
      int x = 30;
      int y = 10;

      if( x == 30 ) 
      {
           System.out.println("X = 30");
         if( y >10 ) 
           {
             System.out.print("Y = 10"); 
           }
         else if(y<10)
           {
             System.out.println("Y = 0");
           }
         else
         {
             System.out.println("it's false");
              if(y==20) 
                {
                  System.out.println("Y = 10");
                }
              else
              {
                  System.out.println("it's False");
              }
         }
      }
   }
}

Output:
X = 30
it's false
it's False

Reference:

->https://www.javatpoint.com/types-of-statements-in-java

->https://www.geeksforgeeks.org/conditional-statements-in-programming/

->https://www.scholarhat.com/tutorial/java/java-conditional-statements-if-else-switch

Task

vimala jeyakumar — Fri, 24 Jan 2025 02:56:21 +0000

Task 1:

Task 1:
Assignment - 0: static, non-static

Create a class Called Theatre.
Declare below global variables in it. 2.1. String movieName 2.2. int movie_time
Add main method
Inside main method, create two instances (objects), 4.1 movie1 4.2 movie2
For instance movie1, add 'Jailer' as movieName and 630 as movie_time
For instance movie2, add 'Leo' as movieName and 7 as movie_time
Create and define a method as below. public void watch_movie() { System.out.println("Watching " + movieName); System.out.println("Show Time is " +movie_time); }
Call above method using both the instances - movie1, movie2.
Go through and record your observations.

Source Code :

public class Theatre1
{
String movieName;
int movieTime;

public static void main (String args[])
{
Theatre1 movie1 = new Theatre1();
Theatre1 movie2 = new Theatre1();
movie1.movieName = "jailer";
movie1.movieTime = 630;
movie2.movieName = "leo";
movie2.movieTime = 720;
movie1.watch_movie();
movie2.watch_movie();
}
public void watch_movie()
{
System.out.println("watched: " + movieName + " showtime: " + movieTime);
}
}

Output:

watched: jailer showtime: 630
watched: leo showtime: 720

Task 2:

return statement

Create a class called EB_Reading
Have main method in it.
Create an object called assessor.
Using assessor instance, call a method named 'reading'.
'reading' method should return consumed units in int.
Store the returned value as 'consumed_units'.
Using the same 'assessor' instance, call a method named as 'calculate'.
Pass 'consumed_units' as argument to calculate.
Based on the consumed_units value, find out How much Customer should pay.
Print Payment value.

Source Code:

public class EbReading
{
public static void main (String args[]){
EbReading assessor = new EbReading();
int Consumed units = assessor.reading();
System.out.println("CU"+ Consumed units);
assessor.calculate(Consumed units);
}
public int reading()
{
int unit1 = 100;
return unit1;
}
public void calculate(int Consumed units)
{
int payment = Consumed units*10;
System.out.println("Pay: " + payment);
}
}

Output:

CU: 100
Pay: 1000

Task 3:

Add Methods in Calculator

public class Calculator
{

public static void main(String[] args)
{
Calculator calc = new Calculator();
calc.add();

}
public void add()
{
System.out.println(10+20);
}

}

//subtract()

//multiply()

//divide()

Source code:

public class Calculator1
{
int a = 10;
float b = 20.5f;
public static void main (String args[])
{
Calculator1 calc = new Calculator1();
calc.add();
calc.sub();
calc.mult();
calc.div();
}
public void add()
{
float c = a+b;
System.out.println("Addition: "+ c);
}
public void sub()
{
float c = a-b;
System.out.println("subtraction: "+ c);
}
public void mult()
{
float c = a*b;
System.out.println("multiply: "+ c);
}
public void div()
{
float c = a/b;
System.out.println("divition: "+ c);
}
}

Output:

Addition: 30.5
subtraction: -10.5
multiply: 205.0
divition: 0.4878049

Day 8 - Datatype

vimala jeyakumar — Wed, 08 Jan 2025 09:42:27 +0000

What is Datatype?
--> Data types specify the different sizes and values that can be stored in the variable.
--> Java is a statically-typed programming language. It means, all variables must be declared before its use. That is why we need to declare variable's type and name.
--> Data types in Java are of different sizes and values that can be stored in the variable that is made as per convenience and circumstances to cover up all test cases.

There are two types of data types in Java:
1. Primitive data types: The primitive data types include boolean, char, byte, short, int, long, float and double.
2. Non-primitive data types: The non-primitive data types include Strings ,Classes, Interfaces, and Arrays.

Java Primitive Data Types:
--> In Java language, primitive data types are the building blocks of data manipulation.
--> The primitive data types include boolean, char, byte, short, int, long, float and double.
--> Primitive data are only single values and have no special capabilities.

Non-Primitive Data Types in Java:
-->The Non-Primitive (Reference) Data Types will contain a memory address of variable values because the reference types won’t store the variable value directly in memory.
-->In Java, non-primitive data types, also known as reference data types, are used to store complex objects rather than simple values.
-->The non-primitive data types include Strings ,Classes, Interfaces, and Arrays.

Class:
One common non-primitive data type in Java is the class. Classes are used to create objects, which are instances of the class. A class defines the properties and behaviors of objects, including variables (fields) and methods. For example, you might create a Person class to represent a person, with variables for the person's name, age, and address, and methods to set and get these values.

Strings:(TBD)
Strings are defined as an array of characters. The difference between a character array and a string in Java is, that the string is designed to hold a sequence of characters in a single variable whereas, a character array is a collection of separate char-type entities. Unlike C/C++, Java strings are not terminated with a null character.

Arrays:(TBD)
Arrays are a fundamental non-primitive data type in Java that allow you to store multiple values of the same type in a single variable. Arrays have a fixed size, which is specified when the array is created, and can be accessed using an index. Arrays are commonly used to store lists of values or to represent matrices and other multi-dimensional data structures.

Interface:(TBD)
Interfaces are another important non-primitive data type in Java. An interface defines a contract for what a class implementing the interface must provide, without specifying how it should be implemented. Interfaces are used to achieve abstraction and multiple inheritance in Java, allowing classes to be more flexible and reusable.

Example program:
source code:
public class Players
{
int score;
float strike_rate;
public static void main(String[] args)
{
Players player1 = new Players();
Players player2 = new Players();
player1.score = 100;
player2.score = 80;
player1.strike_rate = 78.4f;
player2.strike_rate = 65.0f;
System.out.println(player1.score);
System.out.println(player2.strike_rate);
}
}
Output:
100
65.0

Task:
source code:
public class Hotel
{
int amount;
float quantity;
public static void main(String args[])
{
Hotel food1 = new Hotel();
Hotel food2 = new Hotel();
food1.amount =100;
food1.quantity = 50.5f;
food2.amount = 200;
System.out.println( food1.amount);
System.out.println( food2.quantity);
}
}
Output:
100
0.0

Reference:
https://www.javatpoint.com/java-data-types
https://www.geeksforgeeks.org/data-types-in-java/
https://monad.edu.in/img/media/uploads/data%20types%20in%20java.pdf