#N1374. Generate a String With Characters That Have Odd Counts
problem link

#solution

class Solution {
    public String generateTheString(int n) {
        StringBuilder sb = new StringBuilder();
        
        for(int i=0; i<n-1; i++)
            sb.append('a');
        
        return (n%2==0)?sb.append('b').toString():sb.append('a').toString();
    }
}

#statistics
Till this time, 192 in total,
180 easy;
12 medium;
type of problem solutions have been posted

#N1941. Check if All Characters Have Equal Number of Occurrences
problem link

#solution

class Solution {
    public boolean areOccurrencesEqual(String s) {
        int freq[] = new int[26], count=0;
        char temp=s.charAt(0);
        
        for(char ch: s.toCharArray()){
            if(ch == temp) count++;
            freq[ch-'a']++;
        }
        
        for(int i: freq)
            if(i != 0 && i != count) return false;
        
        return true;
    }
}

#N557. Reverse Words in a String III
problem link

#solution

class Solution {
    public String reverseWords(String s) {
        StringBuilder sb = new StringBuilder();
        String[] words = s.split(" ");
        
        for(String word: words){
            sb.append(" ");
            
            sb.append(new StringBuilder(word).reverse());
        }
        
        return sb.toString().trim();
    }
}

#N657. Robot Return to Origin
problem link

#solution

class Solution {
    public boolean judgeCircle(String moves) {
        int[] count = new int[4];
        
        for(char ch: moves.toCharArray()){
            if(ch == 'R') count[0]++;
            else if(ch == 'L') count[1]++;
            else if(ch == 'U') count[2]++;
            else count[3]++;
        }
        
        return count[0] - count[1] == 0 && count[2] - count[3] == 0;
    }
}

#N1768. Merge Strings Alternately
problem link

#solution

class Solution {
    public String mergeAlternately(String word1, String word2) {
        StringBuilder sb = new StringBuilder();
        
        for(int i = 0; i<Math.max(word1.length(), word2.length()); i++){
            if(word1.length()>i)
                sb.append(word1.charAt(i));
            
            if(word2.length()>i)
                sb.append(word2.charAt(i));

        }
        
        return sb.toString();
    }
}

#N344. Reverse String
problem link

#solution

class Solution {
    public void reverseString(char[] s) {
        for(int i=0; i<s.length/2; i++){ 
            char tmp = s[i];
            s[i] = s[s.length-1-i];
            s[s.length-1-i] = tmp; 
        }
    }
}

#N1880. Check if Word Equals Summation of Two Words
problem link

#solution

class Solution {
    public boolean isSumEqual(String firstWord, String secondWord, String targetWord) {
        int num1, num2, target;
        num1 = func(firstWord);
        num2 = func(secondWord);
        target = func(targetWord);
        
        return num1 + num2 == target;
    }
    
    public int func(String str){
        int x=0;
        
        for(char ch: str.toCharArray())
            x = x*10 + (int)(ch-'a');
        
        return x;
    }
}

#N1935. Maximum Number of Words You Can Type
problem link

#solution

class Solution {
    public int canBeTypedWords(String text, String brokenLetters) {
        int broken[] = new int[26], count = 0;;
        
        for(char ch: brokenLetters.toCharArray())
            broken[ch-'a']++;
        
        for(String word: text.split(" ")){
            int countLength=0;
            
            for(char ch: word.toCharArray())
                if(broken[ch-'a'] == 0) countLength++; 
            
            if(countLength == word.length()) count++;
        }
        
        return count;
    }
}

#N1974. Minimum Time to Type Word Using Special Typewriter
problem link

#solution

class Solution {
    public int minTimeToType(String word) {
        int time = 0;
        char temp = 'a';
        
        for(char ch: word.toCharArray()){
            int time1 = Math.abs(ch-temp);
            time = time + Math.min(time1, 26-time1) + 1;
            
            temp = ch;
        }
        
        return time;
    }
}

#N1446. Consecutive Characters
problem link

#solution

class Solution {
    public int maxPower(String s) {
        if(s.length() == 1) return 1;
        int count = 0, power = 0;
        char temp = s.charAt(0);
        
        for(char ch: s.toCharArray()){
            if(temp == ch) count++;
            else{
                count = 1;
                temp = ch;
            }
            power = Math.max(power, count);
        }
        
        return power;
    }
}

#N2085. Count Common Words With One Occurrence
problem link

#solution

class Solution {
    public int countWords(String[] words1, String[] words2) {
        int count=0;
        
        Map<String, Integer> map1 = new HashMap<>();
        Map<String, Integer> map2 = new HashMap<>();
        for(String word: words1)
            map1.put(word, map1.getOrDefault(word, 0) +1);
        
        for(String word: words2)
            map2.put(word, map2.getOrDefault(word, 0) +1);
        
        for (String word: words1)
            if(map1.get(word) == 1 && map2.getOrDefault(word, 0) == 1) count++;
        
        return count;
    }
}

#N2042. Check if Numbers Are Ascending in a Sentence
problem link

#solution

class Solution {
    public boolean areNumbersAscending(String s) {
        int temp = 0;
        for(String word: s.split(" ")){
            if(Character.isDigit(word.charAt(0))){
                int num = Integer.parseInt(word);
                if(num > temp) temp = num;
                else return false;
            }
        }
        
        return true;
        
    }
}

#N824. Goat Latin
problem link

#solution

class Solution {
    public String toGoatLatin(String sentence) {
        StringBuilder sb = new StringBuilder();
        int count=1;
        Set<Character> vowels = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'));
        for(String word: sentence.split(" ")){
            if(vowels.contains(word.charAt(0)))
                sb.append(word).append("ma");
            else
                sb.append(word.substring(1)).append(word.charAt(0)).append("ma");
            
            for(int i=1; i<=count; i++)
                sb.append("a");
            
            count++;
            sb.append(" ");
        }
        
        return sb.toString().trim();
    }
}

#N1876. Substrings of Size Three with Distinct Characters
problem link

#solution

class Solution {
    public int countGoodSubstrings(String s) {
        int count = 0;
        
        for(int i=1; i<s.length()-1; i++)
        if(s.charAt(i-1) != s.charAt(i) && s.charAt(i+1) != s.charAt(i) && s.charAt(i+1) != s.charAt(i-1))
                count++;
            
        
        return count;
    }
}

#N1332. Remove Palindromic Subsequences
problem link

#solution

class Solution {
    public int removePalindromeSub(String s) {
        if (s.equals(new StringBuilder(s).reverse().toString())) return 1;
        
        return 2;
    }
}

#N2068. Check Whether Two Strings are Almost Equivalent
problem link

#solution

class Solution {
    public boolean checkAlmostEquivalent(String word1, String word2) {
        int count[] = new int[26];
        
        for(int i=0; i<word1.length(); i++){
            count[word1.charAt(i)-'a']++;
            count[word2.charAt(i)-'a']--;
        }
        
        for(int i=0; i<26; i++)
            if(Math.abs(count[i]) > 3) return false;
        
        return true;
    }
}

#N231. Power of Two
problem link

#solution

class Solution {
    public boolean isPowerOfTwo(int n) {
        if(n<1) return false;
        if(n==1) return true;
        
        if(n%2==0) return isPowerOfTwo(n/2);
        return false;
    }
}

#N2119. A Number After a Double Reversal
problem link

#solution

class Solution {
    public boolean isSameAfterReversals(int num) {
        return num==0||!(num%10==0);
    }
}