Added String Problems

Author: infotechprogrammer

_07_String_Problems/_01_Adding_Characters_to_String.java

@@ -0,0 +1,13 @@
+package com.String_Problems;
+
+public class _01_Adding_Characters_to_String {
+    public static void main(String[] args) {
+        String series = "";
+        for (int i = 0; i < 26; i++) { // for loop is running for all 26 alphabets here
+            char ch = (char)('a' + i); // In ASCII value of a value of i is added Eg.: 97(a) + 1 = 98(b)
+            System.out.println(ch);
+            series = series + ch;
+        }
+        System.out.println(series);
+    }
+}

_07_String_Problems/_02_String_Builder.java

@@ -0,0 +1,16 @@
+package com.String_Problems;
+
+public class _02_String_Builder {
+    public static void main(String[] args) {
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < 26; i++) { // for loop is running for all 26 alphabets here
+            char ch = (char)('a' + i); // In ASCII value of a value of i is added Eg.: 97(a) + 1 = 98(b)
+           builder.append(ch);
+        }
+        System.out.println(builder);
+        System.out.println(builder.toString());
+        builder.deleteCharAt(0); // 1st character removed
+        System.out.println(builder);
+
+    }
+}

_07_String_Problems/_03_Check_Palindrome.java

@@ -0,0 +1,28 @@
+package com.String_Problems;
+
+/*
+Check whether String is palindrome or not
+Eg1: abcdcba (true , it is palindrome)
+Eg2: abccab (false , it is not palindrome)
+ */
+public class _03_Check_Palindrome {
+    public static void main(String[] args) {
+        String str = "null";
+        System.out.println(isPalindrome(str));
+    }
+    static boolean isPalindrome(String str) {
+        if(str == null || str.length() == 0) {
+            return true;
+        }
+        str = str.toLowerCase();
+        for(int i = 0; i<= str.length() / 2; i++) {
+            char start = str.charAt(i);
+            char end = str.charAt(str.length() - 1 - i);
+
+            if(start != end) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

_07_String_Problems/_04_Defanging_an_IP_Address.java

@@ -0,0 +1,27 @@
+package com.String_Problems;
+/*
+Given a valid (IPv4) IP address, return a defanged version of that IP address.
+A defanged IP address replaces every period "." with "[.]".
+
+Example 1:
+Input: address = "1.1.1.1"
+Output: "1[.]1[.]1[.]1"
+ */
+public class _04_Defanging_an_IP_Address {
+    public static void main(String[] args) {
+        String IPAddress = "255.100.50.0";
+        System.out.println(defangIPaddr(IPAddress));
+    }
+    static String defangIPaddr(String address) {
+        StringBuilder str = new StringBuilder();
+        for(int i=0; i<address.length();i++)
+        {
+            if(address.charAt(i)=='.')
+                str.append("[.]");
+            else
+                str.append(address.charAt(i));
+        }
+
+        return str.toString();
+    }
+}

_07_String_Problems/_05_Shuffle_String.java

@@ -0,0 +1,31 @@
+package com.String_Problems;
+/*
+You are given a string s and an integer array indices of the same length.
+The string s will be shuffled such that the character at the ith position moves to indices[i] in the shuffled string.
+Return the shuffled string.
+
+Eg-1:
+Input: s = "codeleet", indices = [4,5,6,7,0,2,1,3]
+Output: "leetcode"
+Explanation: As shown, "codeleet" becomes "leetcode" after shuffling.
+ */
+public class _05_Shuffle_String {
+    public static void main(String[] args) {
+        String name = "hilSa";
+        int[] name_index = {2,3,4,0,1};
+        System.out.println(restoreString(name,name_index));
+    }
+    static String restoreString(String s, int[] indices) {
+        // Converting String s into Character Array
+        char[] ch=s.toCharArray();
+
+        for(int i=0;i<indices.length;i++){
+            ch[indices[i]]=s.charAt(i);
+        }
+
+        // Converting Array into String
+
+        s=String.valueOf(ch);
+        return s;
+    }
+}

_07_String_Problems/_06_Goal_Parser_Interpretation.java

@@ -0,0 +1,31 @@
+package com.String_Problems;
+/*
+You own a Goal Parser that can interpret a string command.
+The command consists of an alphabet of "G", "()" and/or "(al)" in some order.
+The Goal Parser will interpret "G" as the string "G", "()" as the string "o", and "(al)" as the string "al".
+The interpreted strings are then concatenated in the original order.
+Given the string command, return the Goal Parser's interpretation of command.
+
+Eg: Input: command = "G()()()()(al)"
+    Output: "Gooooal"
+ */
+public class _06_Goal_Parser_Interpretation {
+    public static void main(String[] args) {
+        String goal = "G()(al)()()";
+        System.out.println(interpret(goal));
+    }
+    static String interpret(String command) {
+        StringBuilder list = new StringBuilder();
+        for(int i = 0; i < command.length(); i++){
+            if(command.charAt(i) == 'G'){
+                list.append("G");
+            }else if(command.charAt(i) == '(' && command.charAt(i + 1) == ')'){
+                list.append("o");
+            }else if(command.charAt(i) == '(' && command.charAt(i + 1) == 'a'){
+                list.append("al");
+            }
+        }
+        String ans = list.toString();
+        return ans;
+    }
+}

_07_String_Problems/_07_Check_2_Strings_are_equal.java

@@ -0,0 +1,30 @@
+package com.String_Problems;
+/*
+Given two string arrays word1 and word2,
+return true if the two arrays represent the same string, and false otherwise.
+A string is represented by an array if the array elements concatenated in order forms the string.
+
+Example 1:
+Input: word1 = ["ab", "c"], word2 = ["a", "bc"]
+Output: true
+ */
+public class _07_Check_2_Strings_are_equal {
+    public static void main(String[] args) {
+        String[] word1 = {"ab", "c", "d", "e"};
+        String[] word2 = {"a", "bc", "de"};
+        System.out.println(arrayStringsAreEqual(word1, word2));
+    }
+    static boolean arrayStringsAreEqual(String[] word1, String[] word2) {
+        String str1 = new String();
+        String str2 = new String();
+
+        for (int i = 0; i < word1.length; i++) {
+            str1 = str1 + word1[i];
+        }
+
+        for (int j = 0; j < word2.length; j++) {
+            str2 = str2 + word2[j];
+        }
+        return str1.equals(str2);
+    }
+}

_07_String_Problems/_08_String_Halves_are_alike.java

@@ -0,0 +1,38 @@
+package com.String_Problems;
+/*
+You are given a string s of even length. Split this string into two halves of equal lengths,
+and let a be the first half and b be the second half.
+Two strings are alike if they have the same number of vowels
+('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U').
+Notice that s contains uppercase and lowercase letters.
+Return true if a and b are alike. Otherwise, return false.
+
+Example 1:
+Input: s = "book"
+Output: true
+Explanation: a = "bo" and b = "ok". a has 1 vowel and b has 1 vowel. Therefore, they are alike.
+ */
+public class _08_String_Halves_are_alike {
+    public static void main(String[] args) {
+        String text = "book";
+        System.out.println(halvesAreAlike(text));
+    }
+    static boolean halvesAreAlike(String s) {
+        String s1 = s.substring(0, s.length()/2);
+        String s2 = s.substring(s.length()/2);
+        if(checkVowel(s1) == checkVowel(s2)) {
+            return true;
+        }
+        return false;
+    }
+    static int checkVowel(String s) {
+        int count = 0;
+        for (int i = 0; i < s.length(); i++) {
+            char ch = s.charAt(i);
+            if(ch == 'a' || ch=='e'||ch=='i' || ch=='o'||ch=='u'||ch=='A'||ch=='E'||ch=='I'||ch=='O'||ch=='U') {
+                count++;
+            }
+        }
+        return count;
+    }
+}

_07_String_Problems/_09_Strings_appear_as_Substring_in_word.java

@@ -0,0 +1,25 @@
+package com.String_Problems;
+/*
+Given an array of strings patterns and a string word,
+return the number of strings in patterns that exist as a substring in word.
+A substring is a contiguous sequence of characters within a string.
+Example 1:
+Input: patterns = ["a","abc","bc","d"], word = "abc"
+Output: 3
+ */
+public class _09_Strings_appear_as_Substring_in_word {
+    public static void main(String[] args) {
+        String[] pattern = {"a","abc","bc","d","c"};
+        String word = "abc";
+        System.out.println(numOfStrings(pattern, word));
+    }
+    static int numOfStrings(String[] patterns, String word) {
+        int count = 0;
+        for (int i = 0; i < patterns.length; i++) {
+            if(word.contains(patterns[i])) {
+                count++;
+            }
+        }
+        return count;
+    }
+}

_07_String_Problems/_10_Robot_Return_to_Origin.java

@@ -0,0 +1,41 @@
+package com.String_Problems;
+/*
+There is a robot starting at the position (0, 0), the origin, on a 2D plane.
+Given a sequence of its moves, judge if this robot ends up at (0, 0) after it completes its moves.
+You are given a string moves that represents the move sequence of the robot
+where moves[i] represents its ith move. Valid moves are 'R' (right), 'L' (left), 'U' (up), and 'D' (down).
+Return true if the robot returns to the origin after it finishes all of its moves, or false otherwise.
+Note: The way that the robot is "facing" is irrelevant. 'R' will always make
+the robot move to the right once, 'L' will always make it move left, etc.
+Also, assume that the magnitude of the robot's movement is the same for each move.
+
+Example 1:
+Input: moves = "UD"
+Output: true
+
+Example 2:
+Input: moves = "LL"
+Output: false
+ */
+public class _10_Robot_Return_to_Origin {
+    public static void main(String[] args) {
+        String move = "LLRURD";
+        System.out.println(judgeCircle(move));
+    }
+    static boolean judgeCircle(String moves) {
+        int x = 0;
+        int y = 0;
+        for(char move: moves.toCharArray()) {
+            if(move == 'U') {
+                y++;
+            } else if(move == 'D') {
+                y--;
+            } else if(move == 'L') {
+                x--;
+            } else if(move == 'R') {
+                x++;
+            }
+        }
+        return (x == 0 && y == 0);
+    }
+}

_07_String_Problems/_11_Reverse_String_Words_Only.java

@@ -0,0 +1,26 @@
+package com.String_Problems;
+/*
+Given a string s, reverse the order of characters in each word within a sentence
+while still preserving whitespace and initial word order.
+
+Example 1:
+Input: s = "Let's take LeetCode contest"
+Output: "s'teL ekat edoCteeL tsetnoc"
+ */
+public class _11_Reverse_String_Words_Only {
+    public static void main(String[] args) {
+        String text = "Let's Study Today";
+        System.out.println(reverseWords(text));
+    }
+    static String reverseWords(String s) {
+        StringBuilder sb = new StringBuilder(s);
+        sb.reverse();
+        String[] result = sb.toString().split(" ");
+        for(int i=0,j=result.length-1;i<=j;i++,j--){
+            String temp = result[j];
+            result[j] = result[i];
+            result[i] = temp;
+        }
+        return String.join(" ", result);
+    }
+}

_07_String_Problems/_12_Long_Pressed_Name.java

@@ -0,0 +1,35 @@
+package com.String_Problems;
+/*
+Your friend is typing his name into a keyboard. Sometimes,when typing a character c,
+the key might get long pressed, and the character will be typed 1 or more times.
+You examine the typed characters of the keyboard.
+Return True if it is possible that it was your friends name,
+with some characters (possibly none) being long pressed.
+
+Example 1:
+Input: name = "alex", typed = "aaleex"
+Output: true
+ */
+public class _12_Long_Pressed_Name {
+    public static void main(String[] args) {
+        String name = "sahil";
+        String typed = "ssaahill";
+        System.out.println(isLongPressedName(name, typed));
+    }
+    static boolean isLongPressedName(String name, String typed) {
+        int i = 0, j = 0;
+        while (j < typed.length()) {
+            if(i != name.length() && name.charAt(i) == typed.charAt(j)) {
+                i++;
+                j++;
+            }
+            else if(i > 0 && name.charAt(i - 1) == typed.charAt(j)) {
+                j++;
+            } else {
+                return false;
+            }
+        }
+        if(i == name.length()) { return true; }
+        return false;
+    }
+}

_07_String_Problems/_13_Add_Strings.java

@@ -0,0 +1,38 @@
+package com.String_Problems;
+/*
+Given two non-negative integers, num1 and num2 represented as string,
+return the sum of num1 and num2 as a string.
+You must solve the problem without using any built-in library for handling large integers (such as BigInteger).
+You must also not convert the inputs to integers directly.
+
+Example 1:
+Input: num1 = "11", num2 = "123"
+Output: "134"
+ */
+public class _13_Add_Strings {
+    public static void main(String[] args) {
+        String num1 = "123";
+        String num2 = "346";
+        System.out.println(addStrings(num1, num2));
+    }
+    static String addStrings(String num1, String num2) {
+        int n1=num1.length()-1;
+        int n2=num2.length()-1;
+        int carry=0;
+        StringBuilder ans=new StringBuilder();
+        while(n1>=0 || n2>=0){
+            int sum =carry;
+            if(n1>=0) {
+                sum+=num1.charAt(n1--)-'0';
+            }
+            if(n2>=0) {
+                sum+=num2.charAt(n2--)-'0';
+            }
+            ans.append(sum%10);
+            carry=sum/10;
+        }
+        if(carry!=0)
+            ans.append(carry);
+        return ans.reverse().toString();
+    }
+}