============================================ Reverse the String [anil --> lina]

public class Main

{
public static void main(String[] args) {
String str = "geeksforgeeks";
String revStr="";
for(char c:str.toCharArray())
{
revStr=c+revStr;
}
System.out.println(revStr);
}

============================================ Reverse the String [how to do in java

--> woh ot od ni avaj ]
Original string : how to do in java
Reversed string : woh ot od ni avaj

public class Main

{
public static void main(String[] args) {
String originalStr = "how to do in java";
String words[] = originalStr.split(" ");
for (int i = 0; i < words.length; i++)
{
String revStr="";
for(char c:words[i].toCharArray())
{
revStr=c+revStr;
}
System.out.print(revStr+" ");
}

}
}

============================================ Reverse the String [how to do in java

--> java in do to how]
public static void main(String[] args) {
String originalStr = "how to do in java";
String words[] = originalStr.split(" ");
String reversedString = "";
for (int i = words.length-1; i >= 0; i--) {
reversedString = reversedString+words[i]+ " ";
}
System.out.print(reversedString);
}

============================================ Reverse the String With Capitalization

Input: how to do in java

Output: Java In Do To How

public static void main(String[] args) {

String originalStr = "how to do in java anil";
String words[] = originalStr.split(" ");
String reversedString = "";
 for (int i = words.length - 1; i >= 0; i--) {
char firstLetter = Character.toUpperCase(words[i].charAt(0));
reversedString += firstLetter + words[i].substring(1) + " ";
}

System.out.print(reversedString.trim());
}

============================================ Fibonacci Series [0 1 1 2 3 5 8 13 21

34]

public class LetsSolveIt {

public static void main(String[] args) {
int n = 10;
printFibonacciSeries(n);
}

public static void printFibonacciSeries(int n) {

int prev = 0;
int curr = 1;

System.out.println("Fibonacci Series up to " + n + ":");

System.out.print(prev + " " + curr + " ");

for (int i = 2; i < n; i++) {

int next = prev + curr;
System.out.print(next + " ");
prev = curr;
curr = next;
}
}
}

============================================ Fibonacci Series Using recursion

public class LetsSolveIt {
public static void main(String[] args) {
int n = 10;
System.out.println("Fibonacci Series up to " + n + ":");
for (int i = 0; i < n; i++) {
System.out.print(fibonacci(i) + " ");
}
}

public static int fibonacci(int n) {

if (n <= 1) {
return n;
} else {
return fibonacci(n - 1) + fibonacci(n - 2);
}
}
}

============================================ Find Prime Number

public class LetsSolveIt {

public static void main(String[] args) {
int number = 17;
if (isPrime(number)) {
System.out.println(number + " is a prime number.");
 } else {
System.out.println(number + " is not a prime number.");
}
}

public static boolean isPrime(int number) {

if (number <= 1) {
return false;
}

for (int i = 2; i <= Math.sqrt(number); i++) {

if (number % i == 0) {
return false;
}
}
return true;
}
}

============================================ Print Prime No

public class LetsSolveIt {
public static void main(String[] args) {
int num = 30;
int count;

for (int i = 2; i <= num; i++) {

count = 0;
for (int j = 2; j <= i / 2; j++) {
if (i % j == 0) {
count++;
break;
}
}
if (count == 0) {
System.out.println(i);
}
}
}
}

============================================ Palindrome Number : 121

public class Main {

public static void main(String[] args) {

int number = 111;
int temp=number;
int sum=isPalindrome(number);
if(temp==sum)
{
System.out.println(number + " is a Palindrome.");
}
else
{
System.out.println(number + " is a Not Palindrome.");
}
}

public static int isPalindrome(int number)

{
 int rev=0;
int sum=0;
while(number>0)
{
rev=number%10;
sum=(sum*10)+rev;
number=number/10;
}
return sum;
}
}

============================================ Palindrome String: abba

public class Main {

public static void main(String[] args) {

String str = "abba";
String tempStr=isPalindrome(str);
if(tempStr.equals(str))
{
System.out.println(str + " is a Palindrome.");
}
else
{
System.out.println(str + " is a Not Palindrome.");
}
}

public static String isPalindrome(String str)

{
String revStr="";
for(char c:str.toCharArray())
{
revStr=c+revStr;
}
return revStr;
}
}

============================================ To check Armstrong

125: 1^3 + 2^3 + 5^3 = 1 + 8 + 125 = 134 (Not an Armstrong Number)
1634: 1^4 + 6^4 + 3^4 + 4^4 = 1 + 1296 + 81 + 256 = 1634 (Armstrong Number)

public class Main

{
public static void main(String[] args) {
int number = 1634;
if (isArmstrongNumber(number)) {
System.out.println(number + " is an Armstrong number.");
} else {
System.out.println(number + " is not an Armstrong number.");
}
}

static boolean isArmstrongNumber(int number) {

int originalNumber = number;
int numOfDigits = String.valueOf(number).length();
int sum = 0;
while (number > 0) {
 int digit = number % 10;
sum += Math.pow(digit, numOfDigits);
number = number/10;
}
return sum == originalNumber;
}
}

============================================ Anagram Using In-Built Methods

Two strings are said to be anagram if we can form one string by arranging the
characters of another string.
For example, Race and Care.

public class AnagramCheck {

public static void main(String[] args) {
String str1 = "listen";
String str2 = "silent";

if (areAnagrams(str1, str2)) {
System.out.println(str1 + " and " + str2 + " are anagrams.");
} else {
System.out.println(str1 + " and " + str2 + " are not anagrams.");
}
}

public static boolean areAnagrams(String str1, String str2) {

// Remove whitespace and convert strings to lowercase
str1 = str1.replaceAll("\\s", "").toLowerCase();
str2 = str2.replaceAll("\\s", "").toLowerCase();

// If lengths are not equal, they cannot be anagrams

if (str1.length() != str2.length()) {
return false;
}

// Convert strings to char arrays and sort them

char[] charArray1 = str1.toCharArray();
char[] charArray2 = str2.toCharArray();
Arrays.sort(charArray1);
Arrays.sort(charArray2);

// Compare sorted char arrays

return Arrays.equals(charArray1, charArray2);
}
}

============================================ Anagram Without Without In Built

Methods
import java.util.HashMap;

public class AnagramCheck {

public static void main(String[] args) {
String str1 = "listen";
String str2 = "silent";

if (areAnagrams(str1, str2)) {
System.out.println(str1 + " and " + str2 + " are anagrams.");
} else {
 System.out.println(str1 + " and " + str2 + " are not anagrams.");
}
}

public static boolean areAnagrams(String str1, String str2) {

str1 = str1.replaceAll("\\s", "").toLowerCase();
str2 = str2.replaceAll("\\s", "").toLowerCase();

if (str1.length() != str2.length()) {
return false;
}

HashMap<Character, Integer> charCount = new HashMap<>();

for (char c : str1.toCharArray()) {

if (charCount.containsKey(c)) {
charCount.put(c, charCount.get(c) + 1);
} else {
charCount.put(c, 1);
}
}

for (char c : str2.toCharArray()) {

if (!charCount.containsKey(c)) {
return false;
}
charCount.put(c, charCount.get(c) - 1);
if (charCount.get(c) == 0) {
charCount.remove(c);
}
}

return charCount.isEmpty();
}
}

============================================ Count the occurrence of each character

in a string.
import java.io.*;
import java.util.*;

class OccurrenceOfCharInString {
static void characterCount(String inputString)
{
HashMap<Character, Integer> charCountMap = new HashMap<Character,
Integer>();
char[] strArray = inputString.toCharArray();
for (char c : strArray) {
if (charCountMap.containsKey(c)) {
charCountMap.put(c, charCountMap.get(c) + 1);
}
else {
charCountMap.put(c, 1);
}
}
for (Map.Entry entry : charCountMap.entrySet()) {
System.out.println(entry.getKey() + " " + entry.getValue());
}
}
 public static void main(String[] args)
{
String str = "Ajit";
characterCount(str);
}
}

============================================ Remove Duplicates from Sorted

Array/Return no of unique elements in an array.
Input: nums = [1,1,2] & Output: 2, nums = [1,2,_]
Explanation: Your function should return k = 2, with the first two elements of nums
being 1 and 2 respectively.
It does not matter what you leave beyond the returned k (hence they are
underscores).
class Solution {
public int removeDuplicates(int[] nums) {
int count = 1;
for(int i=1;i<nums.length;i++){
if(nums[i] != nums[i-1]){
nums[count] = nums[i];
count++;
}
}
return count;
}
}

=========================================== Remove Duplicates from UnSorted

public class LetsSolveIt {
public static void removeDuplicates(int[] a) {
LinkedHashSet<Integer> set = new LinkedHashSet<Integer>();

// adding elements to LinkedHashSet

for (int i = 0; i < a.length; i++)
set.add(a[i]);

// Print the elements of LinkedHashSet

System.out.print(set);
}

public static void main(String[] args) {

int a[] = { 5, 2, 6, 8, 6, 7, 5, 2, 8 };

// Function call
removeDuplicates(a);
}

}
============================================ Print the array without duplicate

public class RemoveDuplicatesFromArrayWithCount {

public static void main(String[] args) {
int[] sortedArray = {1, 1, 2, 2, 3, 4, 4, 5, 6, 6};
int n = sortedArray.length;
int j = 0;
int duplicateCount = 0;

for (int i = 0; i < n - 1; i++) {

 if (sortedArray[i] != sortedArray[i + 1]) {
sortedArray[j] = sortedArray[i];
j++;
} else {
duplicateCount++;
}
}
sortedArray[j] = sortedArray[n - 1]; // Copy the last element to the end of
the modified array
int lengthWithoutDuplicates = j + 1; // Updated length of array without
duplicates

// Print the array without duplicates

System.out.println("Array without duplicates:");
for (int k = 0; k < lengthWithoutDuplicates; k++) {
System.out.print(sortedArray[k] + " ");
}

// Print the count of duplicate elements

System.out.println("\nCount of duplicate elements: " + duplicateCount);
}
}

============================================ Two Sum [return array of indices]

Input: nums = [2,7,11,15], target = 9 & Output: [0,1]
Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].

import java.util.*;
class Solution
{
public int[] twoSum(int[] nums, int target)
{
Map<Integer, Integer> maps = new HashMap();
for(int i=0;i<nums.length;i++)
{
int requiredSum=target-nums[i];
if(maps.containsKey(requiredSum))
{
return new int[] {maps.get(requiredSum),i};
}
maps.put(nums[i],i);
}
return new int[] {};
}
}

============================================ Two Sum [return array of values]

import java.util.*;
class Solution
{
public int[] twoSum(int[] nums, int target)
{
Map<Integer, Integer> maps = new HashMap();
for(int i=0;i<nums.length;i++)
{
int requiredSum=target-nums[i];
if(maps.containsKey(requiredSum))
{
return new int[] {nums[maps.get(requiredsum)],nums[i]};
 }
maps.put(nums[i],i);
}
return new int[] {};
}
}

============================================ Remove Element [Return no of unique

elements]
Input: nums = [3,2,2,3], val = 3 & Output: 2, nums = [2,2,_,_]

class Solution {
public int removeElement(int[] nums, int val) {
int count = 0;
for(int i=0;i<nums.length;i++){
if(nums[i] != val){
nums[count] = nums[i];
count++;
}
}
return count;
}
}

============================================ Merge Sorted Array

You are given two integer arrays nums1 and nums2, sorted in increasing order, and
two integers m and n, representing the number of elements in nums1 and nums2
respectively.
Example 1:
Input: nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
Output: [1,2,2,3,5,6]
Explanation: The arrays we are merging are [1,2,3] and [2,5,6].

public class MergeSortedArray {

public static void main(String[] args) {
int[] nums1 = {1, 2, 3, 0, 0, 0};
int m = 3;
int[] nums2 = {2, 5, 6};
int n = 3;

merge(nums1, m, nums2, n);

System.out.print("Merged Array: ");

for (int num : nums1) {
System.out.print(num + " ");
}
}

public static void merge(int[] nums1, int m, int[] nums2, int n) {

int i = m - 1;
int j = n - 1;
int k = m + n - 1;

while (j >= 0) {
if (i >= 0 && nums1[i] > nums2[j]) {
nums1[k] = nums1[i];
i--;
} else {
 nums1[k] = nums2[j];
j--;
}
k--;
}
}
}

============================================ Valid Paranthesis

class Solution {
public boolean isValid(String s) {
// Create an empty stack to keep track of opening brackets
Stack<Character> stack = new Stack<Character>();

// Loop through every character in the string

for (char c : s.toCharArray()) {
// If the character is an opening bracket, push it onto the stack
if (c == '(' || c == '[' || c == '{') {
stack.push(c);
} else { // If current character is not opening bracket, then it must
be closing. So stack cannot be empty at this point.
if (stack.isEmpty()) {
return false;
}
// Otherwise, get the top of the stack and check if it's the
matching opening bracket
char top = stack.peek();
if ((c == ')' && top == '(') || (c == ']' && top == '[') || (c ==
'}' && top == '{')) {
// If it is, pop the opening bracket from the stack
stack.pop();
} else { // Otherwise, the brackets don't match, so return false
return false;
}
}
}
// If the stack is empty, all opening brackets have been closed, so return
true
// Otherwise, there are unmatched opening brackets, so return false
return stack.isEmpty();
}
}

============================================ Print all subsequences/substrings of a

string

import java.util.*;

public class Main

{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Enter String: ");
String str = sc.nextLine();
System.out.println("All substrings are:" );
for(int i=0;i<str.length();i++){
for(int j=i+1;j<=str.length();j++){
StringBuilder strBuilder = new StringBuilder();
for(int k=i;k<j;k++){
 strBuilder.append(str.charAt(k));
}
System.out.println(strBuilder.toString());
}
}

}
}

============================================ Find the Index of the First Occurrence

Of 2nd String in 1st String

class Solution {
public int strStr(String haystack, String needle) {
int hl=haystack.length();
int nl=needle.length();
if(hl<nl)
return -1;
for(int i=0;i<=hl-nl;i++){
int j=0;
while(j<nl && haystack.charAt(i+j)==needle.charAt(j)){
j++;
}
if(j==needle.length()){
return i;
}
}
return -1;
}
}

============================================ Rotates an array to the right by k

steps
Input: {1, 2, 3, 4, 5, 6, 7} and k = 3
Output: [5, 6, 7, 1, 2, 3, 4]
import java.util.Arrays;

public class Main {

public static void main(String[] args) {

int[] nums1 = {1, 2, 3, 4, 5, 6, 7};
int k1 = 3;
rotate(nums1, k1);
System.out.println("Rotated array: " + Arrays.toString(nums1));
}

public static void rotate(int[] nums, int k) {

int n = nums.length;
k %= n; // Calculate the effective number of rotations

// Reverse the entire array

reverse(nums, 0, n - 1);
// Reverse the first k elements
reverse(nums, 0, k - 1);
// Reverse the remaining elements after the first k elements
reverse(nums, k, n - 1);
}
// Helper function to reverse an array or a portion of an array
private static void reverse(int[] nums, int start, int end) {
while (start < end) {
int temp = nums[start];
nums[start] = nums[end];
nums[end] = temp;
start++;
end--;
}
}

============================================ Rotates an array to the left by k

steps
public class LeftRotation {
public static void main(String[] args) {
int[] nums = {1, 2, 3, 4, 5, 6, 7};
int k = 3;
rotateLeft(nums, k);
System.out.print("Left rotated array: ");

// To Print
for (int num : arr) {
System.out.print(num + " ");
}
System.out.println();
}

public static void rotateLeft(int[] nums, int k) {

int n = nums.length;
k %= n; // Calculate the effective number of rotations

// Reverse the first n - k elements

reverse(nums, 0, n - k - 1);
// Reverse the last k elements
reverse(nums, n - k, n - 1);
// Reverse the entire array
reverse(nums, 0, n - 1);
}

// Helper function to reverse an array or a portion of an array

private static void reverse(int[] nums, int start, int end) {
while (start < end) {
int temp = nums[start];
nums[start] = nums[end];
nums[end] = temp;
start++;
end--;
}
}
}

============================================ Max Min

public class LetsSolveIt {
public static int[] findMaxMin(int[] myList) {
int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;

int[] newArr = new int[2];

 for (int i = 0; i < myList.length; i++) {
if (myList[i] > max) {
max = myList[i];
}
if (myList[i] < min) {
min = myList[i];
}
newArr[0] = max;
newArr[1] = min;
}

return newArr;

public static void main(String[] args) {

int[] myList1 = { 5, 3, 8, 1, 6, 9 };
int[] result1 = findMaxMin(myList1);
System.out.println("Test case 1: MaxMin: " + Arrays.toString(result1)); //
prints "[9, 1]"
}

=========================================== Max Profit

public class LetsSolveIt {
public static int maxProfit(int[] prices) {
if (prices == null || prices.length <= 1) {
return 0;
}

int minPrice = prices[0];

int maxProfit = 0;

for (int i = 0; i < prices.length; i++) {

if (prices[i] < minPrice)
minPrice = prices[i];
else if (prices[i] - minPrice > maxProfit)
maxProfit = prices[i] - minPrice;
}
return maxProfit;
}

public static void main(String[] args) {

int[] prices = { 7, 1, 5, 3, 6, 4 };
int profit = maxProfit(prices);
System.out.println("Test case 1: Maximum profit: " + profit); // prints
"Maximum profit: 5"
}
}

============================================ Longest String

public class LetsSolveIt {
public static String findLongestString(String[] array) {
String longest = "";
for (String str : array) {
if (str.length() > longest.length()) {
 longest = str;
}
}
return longest;
}

public static void main(String[] args) {

String[] stringList1 = { "apple", "banana", "kiwi", "pear" };

String longest1 = findLongestString(stringList1);
System.out.println("Test case 1: Longest string: " + longest1);
}
}
============================================ Longest Happy String
public class LongestHappyString {
public static void main(String[] args) {
int a = 1, b = 1, c = 7;
System.out.println(longestHappyString(a, b, c));
}

public static String longestHappyString(int a, int b, int c) {

StringBuilder result = new StringBuilder();
int totalLength = a + b + c;

char prevChar = '-';

while (totalLength > 0) {
char nextChar = findNextChar(a, b, c, prevChar);
if (nextChar == '-') break; // No valid character found

result.append(nextChar);
totalLength--;

// Update counts
if (nextChar == 'a') a--;
else if (nextChar == 'b') b--;
else if (nextChar == 'c') c--;

prevChar = nextChar;
}

return result.toString();
}

private static char findNextChar(int a, int b, int c, char prevChar) {

if (prevChar == 'a') {
if (b >= c && b > 0) return 'b';
else if (c > 0) return 'c';
else if (b > 0) return 'b';
} else if (prevChar == 'b') {
if (a >= c && a > 0) return 'a';
else if (c > 0) return 'c';
else if (a > 0) return 'a';
} else if (prevChar == 'c') {
if (a >= b && a > 0) return 'a';
else if (b > 0) return 'b';
else if (a > 0) return 'a';
} else {
if (a >= b && a >= c && a > 0) return 'a';
else if (b >= c && b > 0) return 'b';
 else if (c > 0) return 'c';
else if (b > 0) return 'b';
else if (a > 0) return 'a';
}

return '-'; // No valid character found

}
}

============================================ Longest Palindromic String

public class LongestPalindromicSubstring {
public static void main(String[] args) {
String str = "babad";
System.out.println(longestPalindrome(str)); // Output: "bab" or "aba"
}

public static String longestPalindrome(String s) {

if (s == null || s.length() < 1) return "";

int start = 0, end = 0;

for (int i = 0; i < s.length(); i++) {
int len1 = expandAroundCenter(s, i, i); // For odd length palindromes
int len2 = expandAroundCenter(s, i, i + 1); // For even length
palindromes
int len = Math.max(len1, len2);
if (len > end - start) {
start = i - (len - 1) / 2;
end = i + len / 2;
}
}
return s.substring(start, end + 1);
}

private static int expandAroundCenter(String s, int left, int right) {

while (left >= 0 && right < s.length() && s.charAt(left) ==
s.charAt(right)) {
left--;
right++;
}
return right - left - 1;
}
}

============================================ Max Sub Array

import java.util.Arrays;

public class Main {

public static int maxSubarray(int[] nums) {

if (nums == null || nums.length == 0) {
return 0; // Return 0 for empty array
}

int maxSum = nums[0]; // Initialize maxSum with the first element

int currentSum = nums[0]; // Initialize currentSum with the first element

// Iterate through the array starting from the second element

for (int i = 1; i < nums.length; i++) {
// Update currentSum to include the current element if it improves the
sum
currentSum = Math.max(nums[i], currentSum + nums[i]);
// Update maxSum if the currentSum is greater
maxSum = Math.max(maxSum, currentSum);
}

return maxSum;
}

public static void main(String[] args) {

// Example 1: Simple case with positive and negative numbers
int[] inputCase1 = {-2, 1, -3, 4, -1, 2, 1, -5, 4};
int result1 = maxSubarray(inputCase1);
System.out.println("Example 1: Input: " + Arrays.toString(inputCase1) + "\
nResult: " + result1);
}