악역영애의 개발일지

Example 4 : s = "{()}" output = true;

예시를 보면 소/중/대괄호가 짝지어서 나오고 Example 4 와 같이 속에있을수도있다.

처음에는 String 의 Char.At(i) 가 ( 혹은 { 혹은 [ 일때 Char.At(i +1) 이 ) 혹은 } 혹은 ] 인것을 확인했는데

example 4 때문에 그건 불가능했다.

해당문제는 여는 괄호가 나오면 그다음엔 무조건 닫는 괄호가 나와야하기때문에 여는 괄호가 나오면 stack 에 저장해두고, 더이상 여는 괄호가 없으면 stack 에서 가장 나중에 저장된 괄호를 지우는 방식으로 진행했다.

class Solution {
    public boolean isValid(String s) {
    	Stack<Character> stack = new Stack<>();
        Map<Character, Character> map = new HashMap<>();
        map.put('(',')');
        map.put('{','}');
        map.put('[',']');
    }
}

여는괄호인지를 알기위해서 map을 만들어줬다.

class Solution {
    public boolean isValid(String s) {
    	Stack<Character> stack = new Stack<>();
        Map<Character, Character> map = new HashMap<>();
        map.put('(',')');
        map.put('{','}');
        map.put('[',']');
        
        for (int i=0; i<s.length(); i++) {
        	char c = s.charAt(i);
            
            if (map.containsKey(c)) { //여는 괄호가 나왔다면
            	stack.push(c);
            } else {
            	if (c != map.get(stack.pop()) {
                   return false;
                }
            }
        }
        
        return stack.length == 0;
    }
}

 여는 괄호가 나왔다면 stack에 넣어주고 

닫는괄호가 나왔다면, stack에 있는 여는괄호를 불러서 map.get 으로 나온 value와 비교하였다.

그리고 모든 닫는괄호가 정상적으로 짝지어나왔다면 stack.length 는 0일 것이므로 return 해줬다.

그런데 이렇게 하면 s="]" 일때 .. stack 에도 값이 없기때문에 else 로 빠지지만, 갈곳이없다..!

때문에 empty 도 같이 봐준다.

class Solution {
    public boolean isValid(String s) {
    	Stack<Character> stack = new Stack<>();
        Map<Character, Character> map = new HashMap<>();
        map.put('(',')');
        map.put('{','}');
        map.put('[',']');
        
        for (int i=0; i<s.length(); i++) {
        	char c = s.charAt(i);
            
            if (map.containsKey(c)) { //여는 괄호가 나왔다면
            	stack.push(c);
            } else {
            	if (stack.isEmpty() || c != map.get(stack.pop())) {
                   return false;
                }
            }
        }
        
        return stack.size() == 0;
    }
}

딱 봤을때 String 으로 만들어서 뒤집어야겠다는 생각을 했다.

import java.util.*;

class Solution {
    public long solution(long n) {
        
        //String 배열로 만듦
        String[] arr = String.valueOf(n).split("");
        
        //순서 뒤집음
        Arrays.sort(arr, Comparator.reverseOrder());
        
        //하나의 String으로 변환
        String str = "";
        for (String s : arr) {
            str += String.valueOf(s);
        }
        
        //long 변환
        long answer = Long.parseLong(str);
        return answer;
    }
}

그런데 String 으로 변환하는 부분이 마음에 들지않는다.

좀더 간단한 방법이 있을것같고, 내림차순으로 하기위해서 Coparator.reverseOrder() 라는 함수가 있다는것을 외워야한다.

다른 사람의 풀이를 살펴보았다.

import java.util.*;

class Solution {
    public long solution(long n) {
        
        //String 배열로 만듦
        String[] arr = String.valueOf(n).split("");
        
        //순서 뒤집음
        Arrays.sort(arr);
        
        //하나의 String으로 변환
        StringBuilder sb = new StringBuilder();
        for (String s : arr) sb.append(s);
        
        //long 변환
        long answer = Long.parseLong(sb.reverse().toString());
        return answer;
    }
}

StringBuilder 를 사용하면 Comparator.reverseOrder() 이라는 다소 긴 메소드를 기억할 필요없이

new StringBuilder 선언하고 append 로 담은다음에 sb.reverse() 만 해주면 된다.

public int solution(int n) {
    int answer = 0;

    String str = Integer.toString(n);
    char[] charArr = str.toCharArray();

    for (char c : charArr) {
        int num = Character.getNumericValue(c);
        answer += num;
    }

    return answer;
}

n 을 string으로 바꾸고 하나씩 char 로 떼서 형변환 후 더해줬다.

이렇게하면 코드가 쓸데없이 길어지므로 String.valueOf()를 사용해서 split 시켜보자.

Integer.toString() 도 있지만, 만약 변수가 null 이라면 nullPointException 발생하므로 가급적 String.valueOf() 를 쓰도록 한다.

public int solution(int n) {
    int answer = 0;

    String[] str = String.valueOf(n).split("");

    for (String s : str) {
        answer += Integer.parseInt(s);
    }

    return answer;
}

이렇게 깔끔하게 변신~

간단한 Lv.1

x만큼 배열을 늘리면된다.

class Solution {
    public long[] solution(int x, int n) {
        long[] answer = new long[n];
        
        return answer;
    }
}

우선 array 길이설정을 해주고

x를 기존 값에 더해나가고싶다.

class Solution {
    public long[] solution(int x, int n) {
        long[] answer = new long[n];
        
        for (int i=0; i<n; i++) {
           answer[i] = answer[i-1] + x;
        }
        return answer;
    }
}

그런데 이렇게하면 첫번째 루프에서는 answer[0] 의 -1 값은 없으므로  0만 따로 설정해준다.

class Solution {
    public long[] solution(int x, int n) {
        long[] answer = new long[n];
        answer[0] = x;
        for (int i=1; i<n; i++) {
           answer[i] = answer[i-1] + x;
        }
        return answer;
    }
}

start 지점까지 가서 뭔가를 저장하고있다가 뒤집어야겠다는 생각을 했었는데,

그러면 시간이 너무오래걸릴것같았다.

책의 풀이를 참고해보니 일단 start 지점까지 가는것으로 시작하였다.

class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
    
    if (head == null) return head;
    
    ListNode root = new ListNode(0);
    root.next = head;
    
    ListNode start = head;
    
    if (int i=0; i<left-1; i++ {
    	start=start.next;
    }
    
    }
}

우선 null 예외처리를 해주고

이리저리 손질보고나서 리턴을 예쁘게 하기위해 root 라는 새로운 ListNode 를 만들어주고 head 를 연결했다.

나중에 리턴할때는 root.next로 리턴할것이다.

앞으로 보낼 ListNode start 를 하나 만들고 left 파라미터 만큼 이동하기로했다.

주어진숫자는 자릿수이기때문에 index에 맞추려고 -1 해줌.

그리고 어떤식으로 살펴갈까 생각을 했는데

앞에 있는걸 뒤로 옮기자니 도루묵이 되어버렸고

start 지점을 기억하고 뒤에서 ++ 한 자릿수만큼 이동한뒤 끌어와야겠다고 생각했다.

class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
    
    if (head == null) return head;
    
    ListNode root = new ListNode(0);
    root.next = head;
    
    ListNode start = root;
    
    for (int i=0; i<left-1; i++) {
    	start=start.next;
    }
    
    ListNode end = start.next;
    
    for (int i=0; i<right-left; i++) {
    	ListNode tmp = start.next; //start의 next 따로저장
        start.next = end.next; //start next.next를 next로 땡겨옴
        end.next = end.next.next; //end의 자릿수를 뒤로 이동 
        start.next.next = tmp; //다시 원래의 next를 저장
    }
    return root.next;
    
    }
}

end 를 만들어주고 loof를 돌렸다.

첫번째 loop

head = 1 2 3 4 5 6

start =  1 2 3 4 5 6

end = 2 3 4 5 6

ListNode tmp = start.next;
start.next = end.next;

tmp = 2 3 4 5 6

start = 1  + 3 4 5 6

start 의 next 가 end 의 next로 당겨졌다.

start 는 head 이므로, head 도 변하였다.

head = 1 3 4 5 6

end.next = end.next.next;
start.next.next = tmp;

end = 2 4 5 6 

end 의 next가 next.next로 당겨지고 이때 tmp 도 3이 빠진 2 4 5 6 으로 변하는 것으로..이해했다..

start.next.next = tmp 를 통해서 start = 1 3 2 4 5 6

두번째 loop

루프돌기전에

start = 1 3 2 4 5 6

end = 2 4 5 6

ListNode tmp = start.next;
start.next = end.next;

tmp = 3 2 4 5 6

start = 1 + 4 5 6

end.next = end.next.next;
start.next.next = tmp;

end = 2 5 6

이때tmp도 3 2 5 6

start = 1 4 3 2 5 6

..

이런식으로 바꿔나가면 된다!