Leetcode 문제 풀이 문자열 의 반전 문자열

반전 문자열
1. 문제 설명
함 수 를 만 드 는 것 은 입력 한 문자열 을 반전 시 키 는 역할 을 합 니 다.입력 문자열 은 문자 배열 char [] 형식 으로 표 시 됩 니 다.
다른 배열 에 추가 공간 을 할당 하지 마 십시오. 입력 배열 을 제자리 에서 수정 하고 O (1) 의 추가 공간 으로 이 문 제 를 해결 해 야 합 니 다.
배열 의 모든 문자 가 ASCII 메타 의 인쇄 가능 한 문자 라 고 가정 할 수 있 습 니 다.
예시 1:
입력: ["h", "e", "l", "l", "o"] 출력: ["o", "l", "l", "e", "h"]
2. 문제 분석
직접 두 냥 으로 문 자 를 교환 하면 된다.두 바늘 을 사용 하거나.
3. 코드

class Solution {
    public void reverseString(char[] s) {
        char temp;
        for(int i=0;i

2. 반전 문자열 2
1. 문제 설명
문자열 과 정수 k 를 지정 합 니 다. 문자열 의 시작 부분 에서 계산 하 는 모든 2k 문자 의 앞 k 문 자 를 반전 시 켜 야 합 니 다.k 글자 보다 적 게 남 으 면 나머지 모든 것 을 반전 시 킵 니 다.2k 보다 작 지만 k 자 이상 이거 나 같은 문자 가 있 으 면 앞의 k 자 를 반전 시 키 고 나머지 문 자 를 그대로 유지 합 니 다.
예시:
입력: s = "abcdefg", k = 2 출력: "bacdfeg" 요구:
이 문자열 은 소문 자 만 포함 되 어 있 습 니 다.주어진 문자열 의 길이 와 k 는 [1, 10000] 범위 내 에 있 습 니 다.
출처: 스냅 백 (LeetCode) 링크:https://leetcode-cn.com/problems/reverse-string-ii
2. 문제 분석
반전 을 반복 합 니 다. 포인터 cur 를 설정 하면 [cur, cur + k) 부분 이 반전 되 고 [cur + k, cur + 2k) 는 변 하지 않 습 니 다. 그리고 포인터 가 2k 를 오른쪽으로 이동 하 는 동시에 나머지 문자 개 수 는 2k 개 를 줄 입 니 다. 문자열 substring (start, end) 방법 으로 문자열 [start, end) 부분 을 캡 처 하여 해당 동작 을 하고 StringBuffer 의 reverse () 방법 으로 반전 합 니 다.
3. 코드

class Solution {
    public String reverseStr(String s, int k) {
        int l = s.length();
        int cur = 0;
        StringBuffer sb = new StringBuffer();
        while(l>=2*k){
            sb.append(new StringBuffer(s.substring(cur, cur+k)).reverse().append(s.substring(cur+k, cur+2*k)));
        //substring(start,end)              start...end-1
            l = l-2*k; //l      ，     
            cur = cur+2*k; //      
        }
        if(l

3. 반전 문자열 의 모음 자모
1. 문제 설명
문자열 을 입력 하고 이 문자열 의 모음 자 모 를 반전 시 키 는 함 수 를 만 듭 니 다.
예시 1:
입력: "hello" 출력: "holle"
2. 문제 분석
헤더 포인 터 를 설정 합 니 다. String 클래스 는 변경 할 수 없 기 때문에 문자열 그룹 을 새로 만 듭 니 다. 마지막 으로 문자열 로 변환 하면 됩 니 다.
3. 코드

import java.util.*;
class Solution {
    private final static Set set = new HashSet<>(Arrays.asList('A','E','I','O','U','a','e','i','o','u'));
    public String reverseVowels(String s) {
        /*        **/ 
        int head = 0;
        int tail = s.length()-1;
        /*         ，  String      **/ 
        char[] rs = new char[tail+1];
        while(head<=tail){
            char ch = s.charAt(head);
            char ct = s.charAt(tail);
            if(!set.contains(ch)){
                rs[head] = ch;
                head++;
            }else if(!set.contains(ct)){
                rs[tail] = ct;
                tail--;
            }else{
                rs[head] = ct;
                head++;
                rs[tail] = ch;
                tail--;
            }
        }
        return new String(rs);
    }
}

4. 알파벳 만 반전
1. 문제 설명
문자열 S 를 지정 하고 '반전 후' 문자열 을 되 돌려 줍 니 다. 알파벳 이 아 닌 문자 가 제자리 에 있 고 모든 자모의 위치 가 반전 되 었 습 니 다.
예시 1:
입력: "ab - cd" 출력: "dc - ba" 예제 2:
입력: "a - bC - dEf - ghIj" 출력: "j - ih - gfE - dCba" 예제 3:
입력: "Test1ng - Reet = code - Q!" 출력: "Qedo1ct - eLg = ntse - T!"
알림:
S. length < = 100 33 < = S [i]. ASCIIcode < = 122 S 에는 \ or 가 포함 되 지 않 습 니 다. "
출처: 스냅 백 (LeetCode) 링크:https://leetcode-cn.com/problems/reverse-only-letters
2. 문제 분석
해법 1: 예 를 들 어 네 가지 방법, 두 바늘 을 옮 겨 다 닙 니 다.
3. 코드
해법 1:

class Solution {
    public String reverseOnlyLetters(String S) {
        int head = 0;
        int tail = S.length()-1;
        char[] rs = new char[tail+1]; //         
        while(head<=tail){
            char c1 = S.charAt(head);
            char c2 = S.charAt(tail);
            if(!Character.isLetter(c1)){
                rs[head] = c1;
                head++;
            }else if(!Character.isLetter(c2)){
                rs[tail] = c2;
                tail--;
            }else{
                rs[head] = c2;
                head++;
                rs[tail] = c1;
                tail--;
            }
        }
        return new String(rs);
    }
}

해법 2:

class Solution {
    public String reverseOnlyLetters(String S) {
        Stack letters = new Stack();
        for (char c: S.toCharArray())
            if (Character.isLetter(c))
                letters.push(c);

        StringBuilder ans = new StringBuilder();
        for (char c: S.toCharArray()) {
            if (Character.isLetter(c))
                ans.append(letters.pop());
            else
                ans.append(c);
        }

        return ans.toString();
    }
}

5. 반전 문자열 의 단어
1. 문제 설명
문자열 의 모든 단 어 를 하나씩 뒤 집 는 문자열 을 지정 합 니 다.
예시 1:
입력: "the sky is blue" 출력: "blue is sky the" 예제 2:
입력: "hello World!" 출력: "World! hello" 설명: 입력 문자열 은 앞 이나 뒤에 빈 칸 을 포함 할 수 있 지만 반전 후의 문 자 는 포함 할 수 없습니다. 예제 3:
입력: "a good example" 출력: "example good a" 설명: 두 단어 사이 에 빈 칸 이 있 으 면 반전 후 단어 사이 의 빈 칸 을 하나만 포함 하 는 것 으로 줄 입 니 다.
설명:
빈 칸 이 없 는 문 자 는 하나의 단 어 를 구성 합 니 다. 입력 문자열 은 앞 이나 뒤에 빈 칸 을 포함 할 수 있 지만, 반 전 된 문 자 는 포함 할 수 없습니다. 두 단어 사이 에 빈 칸 이 있 으 면 반 전 된 단어 사이 의 빈 칸 을 하나만 포함 하 는 것 으로 줄 입 니 다.
출처: 스냅 백 (LeetCode) 링크:https://leetcode-cn.com/problems/reverse-words-in-a-string
2. 문제 분석
이 문제 의 난점 은 두 단어 사이 에 빈 칸 이 남아 있 는 경우 입 니 다. 문자열 의 split 함 수 를 이용 하여 문자열 배열 을 얻 을 수 있 습 니 다. 주의 "a good example"돌아 오 는 배열 에 빈 문자열 이 포함 되 어 있 습 니 다. 이것 이 함정 입 니 다. 문자열 배열 의 끝 에서 부터 StringBuffer 에 추가 하면 반전 이 완 료 됩 니 다. 마지막 으로 StringBuffer 를 String 으로 변환 합 니 다."
3. 코드

class Solution {
    public String reverseWords(String s) {
        String[] words = s.split(" ");
        StringBuffer sb = new StringBuffer();
        for(int i=words.length-1;i>=0;i--){
            if(words[i].length()!=0){ //            
                sb.append(words[i]);
                sb.append(" ");
            }
        }
        return sb.toString().trim(); //trim          
    }
}

6. 반전 문자열 의 단어 2
1. 문제 설명
문자열 을 지정 하려 면 문자열 의 모든 단어의 문자 순 서 를 반전 시 키 고 빈 칸 과 단어의 초기 순 서 를 유지 해 야 합 니 다.
예시 1:
입력: "Let 's take LeetCode contest" 출력: "s' teL ekat edocteeL tsetnoc" 주의: 문자열 에 서 는 모든 단 어 를 하나의 빈 칸 으로 구분 하고 문자열 에 별도의 빈 칸 이 없습니다.
2. 문제 분석
문자열 의 split 함 수 를 이용 하여 문자열 배열 을 얻 을 수 있 습 니 다. 그리고 배열 의 문자열 을 반전 시 키 면 됩 니 다.
3. 코드

class Solution {
    public String reverseWords(String s) {
        String[] words = s.split(" ");
        StringBuffer sb = new StringBuffer();
        for(int i=0;i=0;j--){
                sb.append(words[i].charAt(j));
            }
            sb.append(" ");
        }
        return sb.toString().trim();
    }
}

물론 StringBuffer 의 reverse () 로 반전 할 수 있 습 니 다.

	class Solution {
	    public String reverseWords(String s) {
	        String[] words = s.split(" ");
	        StringBuffer sb = new StringBuffer();
	        for(int i=0;i

1. 문제 설명
2. 문제 분석
3. 코드