Forem: Vidya

Strong,Perfect,Neon Number Programs

Vidya — Fri, 03 Apr 2026 15:29:33 +0000

Strong Number
A Strong Number is a number in which the sum of the factorials of its digits is equal to the number itself.

Take each digit → find factorial → add them → if result = original number, it is a Strong Number.

Example

 Digits: 1, 4, 5

1! = 1  
4! = 24  
5! = 120  

Sum = 1 + 24 + 120 = 145

java

public class Strong {

    public static void main(String[] args) {
        int no=145;
        if(num(no)) {
            System.out.println(no +"is strong number");
        }
        else {
            System.out.println(no +" is not strong number");
        }
        }
    static boolean num(int no) {
        int temp=no;
         int sum=0;
        while(no>0) {
            int digit=no%10;

        int i=1;
        int fact=1;
        while(i<=digit) {
            fact*=i;
            i++;
        }
        sum+=fact;
        no=no/10;
    }
        return sum==temp;

}}

output

Perfect Number
A Perfect Number is a number whose sum of its proper divisors (excluding the number itself) is equal to the number.

Add all divisors (except the number) → if result = original number → it's a Perfect Number.

Example

 Divisors of 6: 1, 2, 3

Sum = 1 + 2 + 3 = 6

java

public class Perfect {

    public static void main(String[] args) {
        int no=28;
        if(num(no)) {
           System.out.println(no + "is perfect");
        }else {
            System.out.println(no +" is not perfect");
        }

    }
      static boolean num(int no) {
          int div=1;
          int sum=0;
          while(div<=no/2) {
              if(no%div==0) {
                  sum+=div;

              }
              div+=1;

              }
              return sum==no;
          }

      }

output

Neon Number
A Neon Number is a number where the sum of the digits of its square is equal to the original number.

Square the number → add digits → if result = original number → it's a Neon Number.

Example

9² = 81

Digits: 8 + 1 = 9

Java

public class Neon {

    public static void main(String[] args) {
        int no=9;
        if(num(no)) {
            System.out.println(no +"is neon number");

    }
        else {
            System.out.println(no +" is not neon number");
        }
    }
    static boolean num(int no) {
        int div=no*no;
        int sum=0;
        while(div>0) {
         sum+=div%10;
         div=div/10;
    }

        return sum==no;
       }

    }

output

Twisted Reverse Number Programs

Vidya — Fri, 03 Apr 2026 04:11:08 +0000

1. Reverse (output-563412)

public class Encryp1 {
    static int rev = 0;

    public static void main(String[] args) {
              reverse(123456);
                System.out.println(rev);
            }

            static void reverse(int n) {
                if (n == 0)
                    return;

            rev = rev * 100 + (n % 100);
            reverse(n / 100);

            }
        }

output

2.Reverse (ouput-456123)

public class Encryp2 {
    static int rev = 0;

    public static void main(String[] args) {
              reverse(123456);
                System.out.println(rev);
            }

            static void reverse(int n) {
                if (n == 0)
                    return;

            rev = rev * 1000 + (n % 1000);
            reverse(n / 1000);

            }
        }

output

3.Reverse (output-135246)

public class Main {
    public static void main(String[] args) {
        int no = 123456;
        int no1 = 100000;
        String result1 = "";
        String result2 = "";

        while (no > 0 && no1 >= 1) {
            int res = no / no1;
            int res1 = res % 10;
            result1 += res1;
            no = no % no1;
            no1 = no1 / 10;

            if (no > 0 && no1 >= 1) {
                res = no / no1;
                int res2 = res % 10;
                result2 += res2;
                no = no % no1;
                no1 = no1 / 10;
            }
        }

        String result = result1 + result2;
        System.out.println(result);
    }
}

output

Number Operations (Sum, Count, Reverse) Using Loop in Java

Vidya — Wed, 01 Apr 2026 16:44:12 +0000

Sum of Digits

java

public class Main {
    public static void main(String[] args) {
        int num = 1234, sum = 0;

        while (num > 0) {
            sum += num % 10;
            num =num/ 10;
        }

        System.out.println("Sum = " + sum);
    }
}

output

2. Count of Digits

java

public class Main {
    public static void main(String[] args) {
        int num = 1234, count = 0;

        while (num > 0) {
            num =num/ 10;
            count++;
        }

        System.out.println("Count = " + count);
    }
}

output

3. Reverse a Number

 public class Main {
    public static void main(String[] args) {
        int num = 1234, rev = 0;

        while (num > 0) {
            rev = rev * 10 + num % 10;
            num =num/ 10;
        }

        System.out.println("Reverse = " + rev);
    }
}

output

Exception Handling Keywords in Java

Vidya — Wed, 01 Apr 2026 16:22:51 +0000

What is an Exception?
An exception is an unwanted event that occurs during program execution.

Example:
Dividing a number by zero
Accessing null object
File not found

1. try Block
The try block contains code that may cause an exception.

Syntax:
      try {
// risky code
 }

Example:

try {
    int a = 10 / 0; // exception
}

Where we use:
--> Database operations
--> File handling
--> Network calls

2. catch Block
The catch block handles the exception thrown in the try.

  Syntax:
       catch(Exception e) {
// handling code
   }

Example:

try {
    int a = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero");
}

Where we use:
--> To show user-friendly messages
--> To prevent program crash

3. finally Block
The finally block always executes whether an exception occurs or not.

Syntax:
    finally {
// cleanup code
   }

Example:

try {
    int a = 10 / 2;
} catch (Exception e) {
    System.out.println("Error");
} finally {
    System.out.println("Always executed");
}

Real-time use:
--> Closing database connection
--> Closing files
--> Releasing resources

4.throw Keyword
Used to manually throw an exception.

Syntax:
     throw new Exception("message");

Example:

public class Main {
    public static void main(String[] args) {
        int num = -5;

        if (num < 0) {
            throw new ArithmeticException("Negative number not allowed");
        }

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

Where we use:
--> Custom validations
--> Business rules (e.g., age restriction)

5. throws Keyword
Used to declare exceptions in method signature.

Syntax:
   void method() throws Exception {
// code
  }

Example:

import java.io.*;

class Test {
    void readFile() throws IOException {
        FileReader file = new FileReader("test.txt");
    }
}

Where we use:
--> File handling
--> Checked exceptions
--> Passing responsibility to caller

Compile-Time vs Run-Time Exceptions in Java

Vidya — Tue, 31 Mar 2026 17:03:12 +0000

What is a Compile-Time Exception?
A compile-time exception (also called a checked exception) is an error that occurs before the program runs, during compilation.
The Java compiler checks these errors and forces the programmer to handle them using try-catch or the throws keyword. If not handled, the program will not compile.
Examples:
--> IOException
--> FileNotFoundException
--> ClassNotFoundException

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        FileReader file = new FileReader("file.txt");
    }
}

What is a Run-Time Exception?
A run-time exception (also called an unchecked exception) occurs while the program is running.
These are not checked by the compiler because they usually happen due to logical errors in the code.
Examples:
--> ArithmeticException (divide by zero)
--> NullPointerException
--> ArrayIndexOutOfBoundsException

public class Main {
    public static void main(String[] args) {
        int a = 10 / 0; // runtime exception
        System.out.println(a);
    }
}

Image Format

Basic Recursion Programs

Vidya — Tue, 31 Mar 2026 16:41:46 +0000

1.Sum of Digits

 Example:

123 → 1 + 2 + 3 = 6
--> add all digits of a number

Formula
sum(n) = (n % 10) + sum(n / 10)

java

public class Main {
    static int sumDigits(int n) {
        if (n == 0) return 0;
        return (n % 10) + sumDigits(n / 10);
    }

    public static void main(String[] args) {
        System.out.println(sumDigits(123));
    }
}

python

def sum_digits(n):
    if n == 0:
        return 0
    return (n % 10) + sum_digits(n // 10)

print(sum_digits(123))

javascript

 function sumDigits(n) {
  if (n === 0) return 0;
  return (n % 10) + sumDigits(Math.floor(n / 10));
}

console.log(sumDigits(123));

output

2.Count Digits in a Number

 Example:
       12345 → 5 digits
     --> find how many digits are in a number

Formula
count(n) = 1 + count(n / 10)

Java

public class Main {
    static int countDigits(int n) {
        if (n == 0) return 0;
        return 1 + countDigits(n / 10);
    }

    public static void main(String[] args) {
        System.out.println(countDigits(12345));
    }
}

python

def count_digits(n):
    if n == 0:
        return 0
    return 1 + count_digits(n // 10)

print(count_digits(12345))

javascript

function countDigits(n) {
  if (n === 0) return 0;
  return 1 + countDigits(Math.floor(n / 10));
}

console.log(countDigits(12345));

output

3. Power of a Number (x^n)
Formula:
xⁿ = x × xⁿ⁻¹
the function calls itself with smaller values.

   Example:

       2⁴ = 2 × 2 × 2 × 2 = 16
       3³ = 3 × 3 × 3 = 27

java

public class Main {
    static int power(int x, int n) {
        if (n == 0) return 1;
        return x * power(x, n - 1);
    }

    public static void main(String[] args) {
        System.out.println(power(2, 4));
    }
}

python

def power(x, n):
    if n == 0:
        return 1
    return x * power(x, n - 1)

print(power(2, 4))

javascript

function power(x, n) {
  if (n === 0) return 1;
  return x * power(x, n - 1);
}

console.log(power(2, 4));

output

4. Reverse a String
This program reverses a string by breaking it into smaller parts and solving step by step.
--> Take the first character
--> Recursively reverse the remaining string
--> Add the first character at the end

How it works

 reverse("hello")
= reverse("ello") + 'h'
= reverse("llo") + 'e' + 'h'
= reverse("lo") + 'l' + 'e' + 'h'
= reverse("o") + 'l' + 'l' + 'e' + 'h'
= reverse("") + 'o' + 'l' + 'l' + 'e' + 'h'
= "" + "olleh"

java

 public class Main {
    static String reverse(String str) {
        if (str.isEmpty()) return str;
        return reverse(str.substring(1)) + str.charAt(0);
    }

    public static void main(String[] args) {
        System.out.println(reverse("hello"));
    }
}

python

 def reverse(s):
    if s == "":
        return ""
    return reverse(s[1:]) + s[0]

print(reverse("hello"))

javascript

function reverse(str) {
  if (str === "") return "";
  return reverse(str.slice(1)) + str[0];
}

console.log(reverse("hello"));

output

Debugging

Vidya — Mon, 30 Mar 2026 16:39:32 +0000

Debugging
Debugging is the process of finding, analyzing, and fixing errors (bugs) in a program so that it works correctly.

--> A bug is any mistake in the code that causes:
* Wrong output
* Program crash
* Unexpected behavior

    Debugging = Detecting + Fixing mistakes in code

Why Do We Use Debugging?

1. Fix Errors

Programs often have mistakes (syntax, runtime, logical). Debugging helps correct them.

2. Improve Program Performance

It helps optimize code and remove unnecessary parts.

3. Understand Code Behavior

Debugging lets you see how data changes step-by-step.

4. Prevent Crashes

Fixing bugs avoids application failure.

5. Ensure Correct Output

Helps verify that the program gives expected results.

Example of Debugging

int a = 10;
int b = 5;

int result = a - b;   // mistake
System.out.println("Sum is: " + result);

What’s the Issue?
We want sum, but used - (subtraction)

Output will be:
        Sum is: 5   ❌ (wrong)

Debugging Process
1. Check the output
2. Compare with expected result (10 + 5 = 15)
3.Find the mistake (- instead of +)
4.Fix the code

Advantages of Exception Handling and Runtime Exception in java

Vidya — Mon, 30 Mar 2026 15:23:26 +0000

Exception handling is a powerful mechanism in Java that allows developers to handle runtime errors in a controlled way. It ensures that the program runs smoothly even when unexpected situations occur.

1. Prevents Program Crashes
One of the biggest advantages of exception handling is that it prevents the program from terminating abruptly. When an error occurs, it can be caught and handled properly, allowing the application to continue running.

2. Maintains Normal Flow of Execution
Without exception handling, a single error can stop the entire program. With proper handling, the remaining code executes normally, improving the reliability of the application.

3. Improves Code Readability
Exception handling separates error-handling code from regular logic. This makes the program easier to read, understand, and maintain.

4. Handles Runtime Errors Gracefully

Java provides built-in exceptions to handle common runtime issues such as:

    --> Arithmetic errors (e.g., division by zero)
    --> Null pointer access
    --> Array index out of bounds

This allows developers to manage errors effectively instead of letting the program fail.

5. Provides Meaningful Error Messages
Using try and catch, developers can display user-friendly messages instead of system-generated errors. This improves the user experience.

6. Supports Debugging
Exception handling helps in identifying and debugging issues by providing detailed error information using methods like printStackTrace().

7. Ensures Resource Management
With blocks like finally, resources such as files, database connections, and streams can be closed properly, avoiding memory leaks.

8. Enhances Program Security
Exception handling prevents sensitive system information from being exposed by controlling how errors are displayed to users.

9. Allows Custom Exception Handling
Developers can create their own exceptions to handle specific business logic, making applications more flexible and robust.

10. Makes Applications Robust
Overall, exception handling improves the stability and robustness of applications by handling unexpected situations efficiently.

Parent–Child Relationship in Exceptions
Exception → Parent class
RuntimeException → Child of Exception
ArithmeticException, NullPointerException → Children of RuntimeException

Example

  try {
    int a = 10 / 0; // ArithmeticException
} catch (RuntimeException e) {
    System.out.println("Handled by RuntimeException");
}

A parent class can handle all its child exceptions.

        RuntimeException can catch:
            --> ArithmeticException
            --> NullPointerException
            --> ArrayIndexOutOfBoundsException

A parent type can refer to a child object

          RuntimeException e = new ArithmeticException();

RuntimeException is parent
ArithmeticException, NullPointerException are children
Parent can catch child exceptions
Always write:
✔ child first
✔ parent last
Use parent for general handling, child for specific handling

Recursion Programs

Vidya — Sun, 29 Mar 2026 16:41:30 +0000

Recursion
Recursion is a programming concept where a function calls itself to solve a problem step by step.

Example Programs
1) Java( Print 1 to 5)

           public class Main {
              public static void main(String[] args) {
        print(1);
    }

    static void print(int n) {
        if (n > 5) return;
        System.out.print(n + " ");
        print(n + 1);
    }
}

python

  def print_num(n):
    if n > 5:
        return
    print(n, end=" ")
    print_num(n + 1)

print_num(1)

Javascript

function printNum(n) {
  if (n > 5) return;
  console.log(n);
  printNum(n + 1);
}

printNum(1);

output

2) Java (Print 1,3,5,7,9)

 public class Main {
    public static void main(String[] args) {
        print(1);
    }

    static void print(int n) {
        if (n > 9) return;
        System.out.print(n + " ");
        print(n + 2);
    }
}

python

def print_num(n):
    if n > 9:
        return
    print(n, end=" ")
    print_num(n + 2)

print_num(1)

Javascript

 function printNum(n) {
  if (n > 9) return;
  console.log(n);
  printNum(n + 2);
}

printNum(1);

output

3) Java (Print 5,10,15,20,25)

 public class Main {
    public static void main(String[] args) {
        print(5);
    }

    static void print(int n) {
        if (n > 25) return;
        System.out.print(n + " ");
        print(n + 5);
    }
}

python

def print_num(n):
    if n > 25:
        return
    print(n, end=" ")
    print_num(n + 5)

print_num(5)

javascript

 function printNum(n) {
  if (n > 25) return;
  console.log(n);
  printNum(n + 5);
}

printNum(5);

output

4) java (Factorial)

public class Main {
    public static void main(String[] args) {
        int result = fact(5);
        System.out.println(result);
    }

    static int fact(int n) {
        if (n == 1) return 1;   
        return n * fact(n - 1); 
    }
}

python

def fact(n):
    if n == 1:
        return 1
    return n * fact(n - 1)

print(fact(5))

javascript

 function fact(n) {
  if (n === 1) return 1;
  return n * fact(n - 1);
}

console.log(fact(5));

output

Exception, Exception Handling

Vidya — Sun, 29 Mar 2026 09:56:22 +0000

Exception
An exception in Java is an unwanted or unexpected event that occurs during the execution of a program, which disrupts the normal flow of instructions.An exception is a runtime error that occurs while the program is running.

Example

          int a = 10; 
          int b = 0;
          System.out.println(a / b);
          --> This code will cause an exception:
              ArithmeticException (division by zero)

Why Do Exceptions Occur?
-> Dividing a number by zero
-> Accessing an invalid array index
-> Trying to open a file that does not exist
-> Invalid user input
-> Network or database issues

Exception Handling
Exception handling in Java is a mechanism used to handle runtime errors (exceptions) so that the program does not crash and continues execution smoothly.

Why Exception Handling?

      --> Without exception handling 
           * Program stops suddenly (crash)

      --> With exception handling
           *Program handles error and continues

Case 1: No Error

      TRY → No Error → Skip CATCH → FINALLY runs

Case 2: Error Occurs

     TRY → Error → CATCH runs → FINALLY runs

String Methods

Vidya — Fri, 27 Mar 2026 16:38:05 +0000

1. trim()
Removes extra spaces only at the beginning and end.

Example


         String s=" Admin123 ";
         System.out.println(s.trim()); // output:"Admin123"

2.equalsIgnoreCase()
Compares two strings ignoring uppercase/lowercase.

Example

"Vijay".equalsIgnoreCase("vijay"); // true

3.equals() vs ==
== checks memory reference(same object or not).
equals() checks actual content/value.

Example

          String s1="java";
          String s2=new String("java");

          s1==s2  // output:false
          s1.equals(s2) // output:true

4.contains
checks if a substring exists inside a string.Returns true or false.

Example

        String email="test@gmail.com";
        email.contains("@"); // output:true

5.Integer.parseInt()
converts String to integer.

Example

         int num=Integer.parseInt("1234");
         System.out.println(num + 10); // output:1244

6.split() + loop(count word)
split sentences into words and count occurrences.

Example

       String s="java is easy java is powerful";
       String[] arr=s.split(" ");
       int count=0;
       for(String word :arr){
          if(word.equals("java"))
          count++;
        }
        System.out.println(count); // output: 2

7.Reverse String(without StringBuilder)
Traverse from end to start.

Example

           String s="java";
           String rev="";
           for(int i=s.length()-1;i>=0;i--){
              rev+=s.charAt(i);
           }
           System.out.println(rev); // output:avaj

8.palindrome check
check if string equals its reverse.

**Example**

        public class PalindromeString {
             public static void main(String[] args) {
        String str = "madam";
        String rev = "";
        for (int i = str.length() - 1; i >= 0; i--) {
            rev = rev + str.charAt(i);
        }

        if (str.equals(rev))
            System.out.println("Palindrome");
        else
            System.out.println("Not Palindrome");
    }
}                            // output:palindrome

9.Remove duplicates
Remove repeated characters.maintains unique characters only.

** Example**

        public class Duplicate1 {
          public static void main(String[] args) {
           String name="aabbccdd";
           String copy="";
           for(int i=0;i<name.length();i++) {
               if(copy.indexOf(name.charAt(i))==-1) {
                   copy+=name.charAt(i);
               }
           }
           System.out.println(copy);
       }
}                         // output:abcd

10.substring()

       Extract part of a string.

Example

      String log="Error:File not Found";
      System.out.println(log.substring(7)); // output:file not found

11.replace()

     Replaces old word with new word.

Example

     String s="I love java";
     System.out.println(s.replace("java", "Spring Boot"));        
      //output:I love Spring Boot

12.matches()
used for pattern checking(like mobile number).**

Example

  String mobile="9876543210";
  mobile.matches("\\d{10}"); // output:true

LCM,Factorial,Sum of Numbers Program in three languages

Vidya — Fri, 27 Mar 2026 15:31:34 +0000

LCM(Least Common Multiple)
The Least Common Multiple (LCM) of two or more numbers is the smallest number that is exactly divisible by all the given numbers.

Example:

  Find LCM of 4 and 6:
      Multiples of 4 → 4, 8, 12, 16, 20...
      Multiples of 6 → 6, 12, 18, 24...
    --> The smallest common multiple is 12
    --> So, LCM(4, 6) = 12

Flowchart

Java

public class Lcm {

    public static void main(String[] args) {
        int no1=3;
        int no2=10;
        int big=(no1<no2)?no1:no2;
        int big2=big;
        while(true) {
            if(big%no1==0 && big%no2==0) {
                System.out.println("LCM is " + big);
                break;
            }
            big+=big2;
        }

    }

}

Python

                no1=3
            no2=10
            big=no1 if no1>no2 else no2
            big2=big
        while True:
            if big%no1==0 and  big%no2==0:
              print("LCM is " , big)
              break
            big+=big2

javascript

                let no1=3;
        let no2=10;
        let big=(no1<no2)?no1:no2;
        let big2=big;
        while(true) {
            if(big%no1==0 && big%no2==0) {
                   console.log("LCM is " + big);
               break;
            }
            big+=big2;
               }

output

Sum of Numbers
The sum of numbers means the result obtained when two or more numbers are added together.

Example:

        2 + 3 = 5 → Here, 5 is the sum
        10 + 20 + 30 = 60 → Here, 60 is the sum

Flowchart

java

public class Sum {

    public static void main(String[] args) {
         int sum=0;
         int no=1;
         while(no<=10) {
             sum=sum+no;
             no++;
         }
          System.out.println("Sum is " + sum);
    }

}

python

              sum=0
          no=1
         while no<=10:
             sum=sum+no
             no+=1
        print("Sum is " , sum)

javascript

             let sum=0;
         let no=1;
         while(no<=10) {
             sum=sum+no;
             no++;
         }
             console.log("Sum is " + sum);

output

Factorial
The factorial of a number is the product of all positive integers from 1 up to that number.

Example:

      5! = 5 × 4 × 3 × 2 × 1 = 120
      4! = 4 × 3 × 2 × 1 = 24

Flowchart

Java

public class Factorial {

    public static void main(String[] args) {
         int fact=1;
         int no=1;
         while(no<=10) {
             fact=fact*no;
             no++;
         }
         System.out.println("Factorial is " + fact);
    }

}

python

                 fact=1;
         no=1;
         while no<=10):
             fact=fact*no
             no+=1
         print("Factorial is " , fact)

javascript

                 let fact=1;
         let no=1;
         while(no<=10) {
             fact=fact*no;
             no++;
         }
                 console.log("Factorial is " + fact);

output