CH01 문자열

package string;

import java.util.Scanner;

public class StringMain {
    public int solution(String string, char t) {
        final String upperCaseString = string.toUpperCase();
        final char targetCharacter = Character.toUpperCase(t);
        int result = 0;
        for (char c : upperCaseString.toCharArray()) {
            if (c == targetCharacter) result++;
        }
        return result;
    }

    public static void main(String[] args) {
        StringMain T = new StringMain();
        Scanner kb = new Scanner(System.in);
        String str = kb.next();
        char c = kb.next().charAt(0);
        System.out.println(T.solution(str, c));
    }
}

package string;

import java.util.Scanner;

public class StringMain2 {
    public String solution(String string){
        StringBuilder result = new StringBuilder();
        for(char character : string.toCharArray()){
            if(Character.isLowerCase(character)){
                result.append(String.valueOf(character).toUpperCase());
            }else {
                result.append(String.valueOf(character).toLowerCase());
            }
        }
        return result.toString();
    }
    public static void main(String[] args) {
        StringMain2 T = new StringMain2();
        Scanner sc = new Scanner(System.in);
        String string = sc.next();
        System.out.println(T.solution(string));
    }
}

package string;

import java.util.Scanner;

public class StringMain3 {

    public String solution(String statement){
        String longestWord = "";
        String[] words = statement.split(" ");
        for(String word : words){
            if(word.length() > longestWord.length()){
                longestWord = word;
            }
        }

        return longestWord;
    }
    public static void main(String[] args) {
        StringMain3 T = new StringMain3();
        Scanner scanner = new Scanner(System.in);
        String statement = scanner.nextLine();
        System.out.println(T.solution(statement));
    }
}

package string;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class StringMain4 {

    public void solution2(List<String> strings) {
        for (String str : strings) {
            StringBuilder stringBuilder = new StringBuilder(str);
            System.out.println(stringBuilder.reverse());
        }

        for (String str : strings) {
            int length = str.length();
            StringBuilder result = new StringBuilder();
            for (int i = length - 1; i >= 0; i--) {
                result.append(str.charAt(i));
            }
            System.out.println(result);
        }
    }

    public void solution(List<String> strings) {
        for (String str : strings) {
            char[] chars = str.toCharArray();
            int leftIndex = 0;
            int rightIndex = chars.length - 1;
            while (leftIndex < rightIndex) {
                char tmp = chars[leftIndex];
                chars[leftIndex] = chars[rightIndex];
                chars[rightIndex] = tmp;
                leftIndex++;
                rightIndex--;
            }
            System.out.println(chars);
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int count = scanner.nextInt();
        List<String> strings = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            String temp = scanner.next();
            strings.add(temp);
        }
        StringMain4 T = new StringMain4();
        T.solution(strings);
    }
}

package string;

import java.util.Scanner;

public class StringMain5 {
    public void solution(String str) {
        char[] chars = str.toCharArray();
        int leftIndex = 0;
        int rightIndex = chars.length - 1;
        while (leftIndex < rightIndex) {
            if (!Character.isAlphabetic(chars[leftIndex])) {
                leftIndex++;
                continue;
            }

            if (!Character.isAlphabetic(chars[rightIndex])) {
                rightIndex--;
                continue;
            }

            char temp = chars[leftIndex];
            chars[leftIndex] = chars[rightIndex];
            chars[rightIndex] = temp;
            leftIndex++;
            rightIndex--;

        }
        System.out.println(chars);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String string = scanner.next();
        StringMain5 T = new StringMain5();
        T.solution(string);
    }
}

package string;

import java.util.LinkedHashSet;
import java.util.Scanner;
import java.util.Set;

public class StringMain6 {

    public void solution2(String str) {
        Set<Character> charsSet = new LinkedHashSet<>();
        char[] chars = str.toCharArray();
        for (char c : chars) {
            charsSet.add(c);
        }
        StringBuilder stringBuilder = new StringBuilder();
        charsSet.forEach(stringBuilder::append);
        System.out.println(stringBuilder);
    }

    public void solution(String str) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            int originalIndex = i;
            int firstIndex = str.indexOf(str.charAt(i));
            if (originalIndex == firstIndex) {
                stringBuilder.append(str.charAt(i));
            }
        }

        System.out.println(stringBuilder);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        StringMain6 T = new StringMain6();
        T.solution(str);
    }
}

package string;

import java.util.Scanner;

public class StringMain7 {
    public void solution2(String str) {
        char[] chars = str.toLowerCase().toCharArray();
        int leftIndex = 0;
        int rightIndex = chars.length - 1;
        boolean isSame = true;
        while (leftIndex < rightIndex) {
            if (chars[leftIndex] != chars[rightIndex]) {
                isSame = false;
                System.out.println("NO");
                break;
            }
            leftIndex++;
            rightIndex--;
        }

        if (isSame) {
            System.out.println("YES");
        }
    }

    public void solution(String str) {
        String original = str.toLowerCase();
        String reversed = new StringBuilder(str.toLowerCase()).reverse().toString();
        if (original.equals(reversed)) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        StringMain7 T = new StringMain7();
        T.solution(str);
    }
}

package string;

import java.util.Scanner;

public class StringMain8 {
    public void solution2(String str) {
        String converted = str.toUpperCase().replaceAll("[^A-Z]", "");
        String reversed = new StringBuilder(converted).reverse().toString();
        if (converted.equals(reversed)) {
            System.out.println("YES");
        } else {
            System.out.println("NO");
        }
    }

    public void solution(String str) {
        String converted = str.toUpperCase().replaceAll("[^A-Z]", "");
        char[] chars = converted.toCharArray();
        int left = 0;
        int right = chars.length - 1;
        while (left < right) {
            if (chars[left] != chars[right]) {
                System.out.println("NO");
                return;
            }
            left++;
            right--;
        }

        System.out.println("YES");
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.nextLine();
        StringMain8 T = new StringMain8();
        T.solution(str);
    }
}

package string;

import java.util.Scanner;

public class StringMain9 {
    public void solution(String str) {
        String converted = str.replaceAll("[^0-9]", "");
        int result = Integer.parseInt(converted);
        System.out.println(result);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        StringMain9 T = new StringMain9();
        T.solution(str);
    }
}

package string;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class StringMain10 {

    public void solution2(String string, String targetString) {
        char[] chars = string.toCharArray();
        char target = targetString.toCharArray()[0];

        int distance = chars.length;
        int[] distances = new int[chars.length];
        for (int i = 0; i < chars.length; i++) {
            if (chars[i] != target) {
                distances[i] = distance;
            } else {
                distance = 0;
                distances[i] = distance;
            }
            distance++;
        }

        distance = chars.length;
        for (int i = chars.length - 1; i >= 0; i--) {
            if (chars[i] != target) {
                int currentDistance = distances[i];
                int newDistance = distance;

                distances[i] = Math.min(currentDistance, newDistance);
//                if (currentDistance < newDistance) {
//                    distances[i] = currentDistance;
//                } else {
//                    distances[i] = newDistance;
//                }

            } else {
                distance = 0;
                distances[i] = distance;
            }
            distance++;
        }

        StringBuilder stringBuilder = new StringBuilder();
        for (int d : distances) {
            stringBuilder.append(d).append(" ");
        }
        System.out.println(stringBuilder.toString().trim());
    }

    public void solution(String string, String target) {
        char[] chars = string.toCharArray();
        char targetChar = target.toCharArray()[0];

        final List<Integer> targetIndex = new ArrayList<>();
        for (int i = 0; i < chars.length; i++) {
            if (chars[i] == targetChar) {
                targetIndex.add(i);
            }
        }

        final List<Integer> distances = new ArrayList<>();
        for (int i = 0; i < chars.length; i++) {
            int min = chars.length - 1;
            for (Integer index : targetIndex) {
                int temp = 0;
                if (index > i) {
                    temp = index - i;
                } else {
                    temp = i - index;
                }

                if (temp < min) {
                    min = temp;
                }
            }
            distances.add(min);
        }

        StringBuilder stringBuilder = new StringBuilder();
        distances.forEach(distance -> {
            stringBuilder.append(distance).append(" ");
        });
        String result = stringBuilder.toString().trim();
        System.out.println(result);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String string = scanner.nextLine();
        String[] strings = string.split(" ");
        StringMain10 T = new StringMain10();
        T.solution2(strings[0], strings[1]);
    }
}

package string;

import java.util.Scanner;

public class StringMain11 {

    public void solution2(String originalString) {
        String appendedEmptyString = originalString + " ";
        char[] chars = appendedEmptyString.toCharArray();
        int count = 1;

        StringBuilder result = new StringBuilder();
        for (int i = 0; i < chars.length - 1; i++) {
            char currentChar = chars[i];
            char nextChar = chars[i + 1];
            if (currentChar == nextChar) {
                count++;
            } else {
                if (count != 1) {
                    result.append(currentChar).append(count);
//                    count = 1;
                } else {
                    result.append(currentChar);
                }
                count = 1;
            }
        }

        System.out.println(result);
    }

    public void solution(String str) {
        char[] chars = str.toCharArray();
        StringBuilder stringBuilder = new StringBuilder();

        stringBuilder.append(chars[0]);
        int count = 1;

        char lastChar = chars[0];
        for (int i = 1; i < chars.length; i++) {
            char currentChar = chars[i];
            if (lastChar == currentChar) {
                count++;
            } else {
                if (count != 1) {
                    stringBuilder.append(count);
                    count = 1;
                }

                stringBuilder.append(currentChar);
                lastChar = currentChar;
            }

            if (i == chars.length - 1) {
                if (count != 1) {
                    stringBuilder.append(count);
                }
            }
        }

        System.out.println(stringBuilder);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        StringMain11 T = new StringMain11();
        T.solution2(str);
    }

}

package string;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class StringMain12 {

    public void solution(String str) {
        char[] chars = str.toCharArray();
        List<String> strings = new ArrayList<>();
        StringBuilder stringBuilder = new StringBuilder();

        for (int i = 0; i < chars.length; i++) {
            if (stringBuilder.length() != 0 && stringBuilder.length() % 7 == 0) {
                strings.add(stringBuilder.toString());
                stringBuilder = new StringBuilder();
            }
            stringBuilder.append(chars[i]);

            if (i == chars.length - 1) {
                strings.add(stringBuilder.toString());
            }
        }

        StringBuilder result = new StringBuilder();
        strings.stream()
                .map(tmpStr -> {
                    tmpStr = tmpStr.replace("#", "1");
                    tmpStr = tmpStr.replace("*", "0");
                    return tmpStr;
                })
                .map(binary -> {
                    char[] binaries = binary.toCharArray();
                    int resultInt = 0;
                    for (int i = binaries.length - 1; i >= 0; i--) {
                        int target = Integer.parseInt(String.valueOf(binaries[i]));
                        double multiple = Math.pow(2, binaries.length - (i + 1));
                        resultInt += target * multiple;
                    }
                    return (char) resultInt;
                })
                .forEach(result::append);
        System.out.println(result);
    }

    private static char convertToString(String binary) {
        char[] chars = binary.toCharArray();
        int result = 0;
        for (int i = chars.length - 1; i >= 0; i--) {
            int target = Integer.parseInt(String.valueOf(chars[i]));
            double multiple = Math.pow(2, chars.length - (i + 1));
            result += target * multiple;
        }
        return (char) result;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str1 = scanner.next();
        String str = scanner.next();
        StringMain12 T = new StringMain12();
        T.solution(str);
    }
}

package string;

import java.util.Scanner;

public class StringMain12New {

    public void solution(int count, String str) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < count; i++) {
            String binary = str.substring(0, 7).replace("#", "1").replace("*", "0");
            int code = Integer.parseInt(binary, 2);
            String targetChar = String.valueOf((char) code);
            stringBuilder.append(targetChar);
            str = str.substring(7);
        }
        System.out.println(stringBuilder);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int count = scanner.nextInt();
        String string = scanner.next();
        StringMain12New T = new StringMain12New();
        T.solution(count, string);
    }
}