From a31c27a0522a66b2097b45fa579989e6dfa75753 Mon Sep 17 00:00:00 2001 From: badaljangid Date: Fri, 10 Oct 2025 09:54:33 +0530 Subject: [PATCH] assignment 2 --- Assignment2/Main.java | 118 +++++++++++ Assignment2/mypackage/Operations.java | 273 ++++++++++++++++++++++++++ 2 files changed, 391 insertions(+) create mode 100644 Assignment2/Main.java create mode 100644 Assignment2/mypackage/Operations.java diff --git a/Assignment2/Main.java b/Assignment2/Main.java new file mode 100644 index 0000000..c80ab66 --- /dev/null +++ b/Assignment2/Main.java @@ -0,0 +1,118 @@ +import java.util.Scanner; +import mypackage.Operations; + + +public class Main { + + public static void main(String[] args) { + Scanner input = new Scanner(System.in); + Operations ops = new Operations(); // Create an instance of Operations class + + while (true) { + // Display the menu + System.out.println("\n---- MENU: STRING & NUMBER OPERATIONS ----\n"); + System.out.println("1. Count Unique Palindromic Substrings"); + System.out.println("2. Nth Fibonacci Number"); + System.out.println("3. Convert Snake Case to Camel Case"); + System.out.println("4. Count Consonants in a String"); + System.out.println("5. Binary to Decimal Conversion"); + System.out.println("6. Expand Characters Based on Digits (e.g. a1b2 → abb)"); + System.out.println("7. Character Frequency in a String"); + System.out.println("8. Prime Number Checker"); + System.out.println("9. Convert Number to Words"); + System.out.println("10. Longest Substring Without Repeating Characters"); + System.out.println("0. Exit"); + System.out.print("Enter your choice: "); + + int choice = input.nextInt(); + input.nextLine(); // consume newline character + + switch (choice) { + // Exit program + case 0: + System.out.println("Exiting program... Thank you!"); + input.close(); + return; + + // 1. Count Unique Palindromic Substrings + case 1: + System.out.print("Enter a string: "); + String palindromeInput = input.nextLine(); + int palindromeCount = ops.countUniquePalindromes(palindromeInput); + System.out.println("Unique palindromic substrings: " + palindromeCount); + break; + + // 2. Nth Fibonacci Number + case 2: + System.out.print("Enter N: "); + int n = input.nextInt(); + System.out.println("Nth Fibonacci number: " + ops.getNthFibonacci(n)); + break; + + // 3. Convert Snake Case to Camel Case + case 3: + System.out.print("Enter a snake_case string: "); + String snakeCase = input.nextLine(); + System.out.println("CamelCase: " + Operations.snakeToCamel(snakeCase)); + break; + + // 4. Count Consonants in a String + case 4: + System.out.print("Enter a string: "); + String consonantInput = input.nextLine(); + int consonantCount = Operations.countConsonants(consonantInput); + System.out.println("Number of consonants: " + consonantCount); + break; + + // 5. Binary to Decimal Conversion + case 5: + System.out.print("Enter a binary string: "); + String binary = input.nextLine(); + int decimal = Operations.binaryToDecimal(binary); + System.out.println("Decimal equivalent: " + decimal); + break; + + // 6. Expand Characters Based on Digits + case 6: + System.out.print("Enter string with characters followed by digits (e.g. a1b2c3): "); + String expandInput = input.nextLine(); + System.out.println("Expanded string: " + Operations.expandCharacters(expandInput)); + break; + + // 7. Character Frequency in a String + case 7: + System.out.print("Enter a string: "); + String freqInput = input.nextLine(); + System.out.println("Character frequency: " + Operations.charFrequency(freqInput)); + break; + + // 8. Prime Number Checker + case 8: + System.out.print("Enter a number: "); + int num = input.nextInt(); + boolean prime = Operations.isPrime(num); + System.out.println(num + (prime ? " is PRIME" : " is NOT PRIME")); + break; + + // 9. Convert Number to Words + case 9: + System.out.print("Enter a number: "); + int numWords = input.nextInt(); + System.out.println("Number in words: " + Operations.numberToWords(numWords)); + break; + + // 10. Longest Substring Without Repeating Characters + case 10: + System.out.print("Enter a string: "); + String substringInput = input.nextLine(); + int maxLength = Operations.longestUniqueSubstring(substringInput); + System.out.println("Length of longest substring without repeating characters: " + maxLength); + break; + + // Invalid choice handling + default: + System.out.println("Invalid choice! Please try again."); + } + } + } +} diff --git a/Assignment2/mypackage/Operations.java b/Assignment2/mypackage/Operations.java new file mode 100644 index 0000000..3648460 --- /dev/null +++ b/Assignment2/mypackage/Operations.java @@ -0,0 +1,273 @@ +package mypackage; + +public class Operations { + + // 1. Count unique palindromic substrings in a string + public int countUniquePalindromes(String str) { + String[] uniquePalindromes = new String[str.length() * str.length()]; + int uniqueCount = 0; + + for (int center = 0; center < str.length(); center++) { + // Odd-length palindromes + uniqueCount = expandAndStore(str, center, center, uniquePalindromes, uniqueCount); + // Even-length palindromes + uniqueCount = expandAndStore(str, center, center + 1, uniquePalindromes, uniqueCount); + } + + return uniqueCount; + } + + // Expand around center and store unique palindromes + private int expandAndStore(String str, int left, int right, String[] uniqueList, int count) { + while (left >= 0 && right < str.length() && str.charAt(left) == str.charAt(right)) { + + String current = ""; + for (int i = left; i <= right; i++) { + current += str.charAt(i); + } + + boolean alreadyExists = false; + for (int i = 0; i < count; i++) { + if (isSame(uniqueList[i], current)) { + alreadyExists = true; + break; + } + } + + if (!alreadyExists) { + uniqueList[count] = current; + count++; + } + + left--; + right++; + } + return count; + } + + // Compare two strings manually + private boolean isSame(String a, String b) { + if (a.length() != b.length()) return false; + for (int i = 0; i < a.length(); i++) { + if (a.charAt(i) != b.charAt(i)) return false; + } + return true; + } + + // 2. Find the Nth number in the Fibonacci sequence + public int getNthFibonacci(int n) { + if (n == 1) return 0; + if (n == 2) return 1; + + int first = 0, second = 1, next = 0; + + for (int i = 3; i <= n; i++) { + next = first + second; + first = second; + second = next; + } + + return next; + } + + // 3. Convert snake_case to camelCase + public static String snakeToCamel(String snakeCaseString) { + String result = ""; + boolean toUpper = false; + + for (int i = 0; i < snakeCaseString.length(); i++) { + char ch = snakeCaseString.charAt(i); + + if (ch == '_') { + toUpper = true; + } else { + if (toUpper && ch >= 'a' && ch <= 'z') { + ch = (char) (ch - 32); // convert to uppercase + } + result += ch; + toUpper = false; + } + } + + return result; + } + + // 4. Count consonants in a string + public static int countConsonants(String str) { + int consonantCount = 0; + + for (int i = 0; i < str.length(); i++) { + char ch = str.charAt(i); + + if (ch >= 'A' && ch <= 'Z') { + ch = (char) (ch - 'A' + 'a'); // convert to lowercase + } + + if (ch >= 'a' && ch <= 'z' && + ch != 'a' && ch != 'e' && ch != 'i' && ch != 'o' && ch != 'u') { + consonantCount++; + } + } + + return consonantCount; + } + + // 5. Convert binary string to decimal (manual calculation) + public static int binaryToDecimal(String binaryString) { + int decimalValue = 0; + int base = 1; + + for (int i = binaryString.length() - 1; i >= 0; i--) { + if (binaryString.charAt(i) == '1') { + decimalValue += base; + } + base *= 2; + } + + return decimalValue; + } + + // 6. Expand characters based on the digit following them + public static String expandCharacters(String str) { + String result = ""; + int i = 0; + + while (i < str.length()) { + char ch = str.charAt(i); + + if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) { + i++; + int count = 0; + + while (i < str.length() && str.charAt(i) >= '0' && str.charAt(i) <= '9') { + count = count * 10 + (str.charAt(i) - '0'); + i++; + } + + for (int j = 0; j < count; j++) { + result += ch; + } + } else { + i++; + } + } + + return result; + } + + // 7. Character frequency in a string (compressed form) + public static String charFrequency(String str) { + String result = ""; + int n = str.length(); + + for (int i = 0; i < n; i++) { + char ch = str.charAt(i); + int count = 1; + + // Skip already counted characters + boolean alreadyCounted = false; + for (int k = 0; k < i; k++) { + if (str.charAt(k) == ch) { + alreadyCounted = true; + break; + } + } + if (alreadyCounted) continue; + + // Count occurrences + for (int j = i + 1; j < n; j++) { + if (str.charAt(j) == ch) count++; + } + + result += ch + Integer.toString(count); + } + + return result; + } + + // 8. Prime number checker + public static boolean isPrime(int num) { + if (num <= 1) return false; + + for (int i = 2; i * i <= num; i++) { + if (num % i == 0) return false; + } + + return true; + } + + // Arrays for number-to-words conversion + private static final String[] units = { + "zero", "one", "two", "three", "four", + "five", "six", "seven", "eight", "nine" + }; + + private static final String[] teens = { + "ten", "eleven", "twelve", "thirteen", "fourteen", + "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" + }; + + private static final String[] tens = { + "", "", "twenty", "thirty", "forty", + "fifty", "sixty", "seventy", "eighty", "ninety" + }; + + // 9. Convert number to words + public static String numberToWords(int num) { + if (num < 0) return "minus " + numberToWords(-num); + if (num < 10) return units[num]; + if (num < 20) return teens[num - 10]; + + if (num < 100) { + int tenPart = num / 10; + int unitPart = num % 10; + return (unitPart == 0) + ? tens[tenPart] + : tens[tenPart] + " " + units[unitPart]; + } + + if (num < 1000) { + int hundredPart = num / 100; + int remainder = num % 100; + return (remainder == 0) + ? units[hundredPart] + " hundred" + : units[hundredPart] + " hundred " + numberToWords(remainder); + } + + if (num < 10000) { + int thousandPart = num / 1000; + int remainder = num % 1000; + return (remainder == 0) + ? units[thousandPart] + " thousand" + : units[thousandPart] + " thousand " + numberToWords(remainder); + } + + return "Number too large"; + } + + // 10. Length of the longest substring without repeating characters + public static int longestUniqueSubstring(String s) { + int n = s.length(); + int maxLength = 0; + + int[] lastIndex = new int[256]; + for (int i = 0; i < 256; i++) { + lastIndex[i] = -1; + } + + int start = 0; + + for (int end = 0; end < n; end++) { + char current = s.charAt(end); + + if (lastIndex[current] >= start) { + start = lastIndex[current] + 1; + } + + lastIndex[current] = end; + maxLength = Math.max(maxLength, end - start + 1); + } + + return maxLength; + } +}