nose딩

class Solution {
    static int min = Integer.MAX_VALUE;
    static int N;
    public int solution(int a, int number) {
        N=a;
        calc(number,0,0);
        return (min==Integer.MAX_VALUE) ? -1 : min;
    }
    public void calc(int number, int val, int count){
        if(count>8) return;
        if(val==number){
            min=Math.min(min,count);
            return;
        }
        int temp = 0;
        for(int i=1; i<=8-count; i++){
            temp=temp*10+N;
            calc(number,val+temp,count+i);
            calc(number,val-temp,count+i);
            calc(number,val/temp,count+i);
            calc(number,val*temp,count+i);
        }
    }
}

DFS긴 하지만 ,,,

이것도 넘 천재적이라 느낌;;;;;;;;;;;;;;;;; 하아 다시 풀어야지,.,

class Solution
{
    static int[][] dp;
    public int solution(int [][]board)
    {
        dp = new int[board.length+1][board[0].length+1];
        int max = 0;
        
        for(int i = 1; i<=board.length; i++){
            for(int j=1; j<=board[0].length; j++){
                dp[i][j]=board[i-1][j-1];
            }
        }
        
        for(int i = 1; i<=board.length; i++){
            for(int j=1; j<=board[0].length; j++){
                if(dp[i][j]==1){
                    dp[i][j]=Math.min(Math.min(dp[i][j-1],dp[i-1][j]),dp[i-1][j-1])+1;
                    max = Math.max(dp[i][j],max);
                }
            }
        }
        return max*max;
    }
}

왼쪽, 바로위, 왼쪽바로위 이렇게 세 값 중 최소값에 1을 더한걸 현재 dp에 저장하며 갱신~

,,다들 천잰가 ,, 나도 점화식 스스로 떠올리고 싶다구요 ,,

import java.util.Stack;
class Solution {
    boolean solution(String s) {
        boolean answer = true;
        Stack<Character> st = new Stack<Character>();
        for(int i = 0; i<s.length(); i++){
            if(s.charAt(i)=='('){
                st.push('(');
            }else{
                if(st.isEmpty()){
                    return false;
                }
                st.pop();
            }
        }
        if(!st.isEmpty()) answer = false;
        return answer;
    }
}

괄호하면 스택이쥬~ 이것은 국룰~

class Solution {
    public int solution(int n) {
        int countN=countOne(n);
        int nextN = n+1;
        while(countOne(n)!=countOne(nextN)){
            nextN++;
        }
        return nextN;
    }
    int countOne(int n){
        int count = 0;
        String str = Integer.toBinaryString(n);
        for(int i = 0; i<str.length(); i++){
            if(str.charAt(i)=='1') count++;
        }
        return count;
    }
}

* 2진수 : Integer.toBinaryString()

* 8진수 : Integer.toOctalString()

*16진수 : Integer.toHexString()

class Solution {
    public int solution(String s) {
        int min = Integer.MAX_VALUE; //answer;
        
        if(s.length() == 1) return 1;//1인경우 할 필요x
        
        for(int i =1; i<=s.length()/2; i++){
            String str=""; //압축한 문자열
            String prev=s.substring(0,i); //이전 문자열
            int count = 1;
            
            for(int j =i; j<=s.length()-i; j+=i){
                String now = s.substring(j,j+i);
                if(prev.equals(now)){ //이렇게 함으로써 뒤까지 다검사
                    count++;
                    continue; 
                }
                if(count>1){ //위에서 안걸렸는데 1넘은 경우는 해당 문자 반복 끝난거
                    str += count+prev;
                    count = 1;   
                }else{
                    str +=prev;
                }
                prev=now; //뒤에께 이제 현재 비교하는 값이엇삼~
            }
            
            //맨 마지막 경우 - 마지막에 못 붙인애들 처리~
            if(count>1){
                str+=count+prev;
                count=1;
            }else{
                str+=prev;
            }
            
            //비교 못한애들 붙임~
            if(s.length()%i!=0){
                str+=s.substring(s.length()-s.length()%i,s.length());
            }

            if(str.length()<min) min= str.length(); 
        }
        
        return min;
    }
}

다음에 다시 풀어봐야겠다,, 

import java.util.Arrays;
import java.util.Comparator;

class Solution {
    public String solution(int[] numbers) {
        String answer = "";
        String[] temp = new String[numbers.length];
        
        for(int i=0; i< numbers.length; i++){
            temp[i] = Integer.toString(numbers[i]);
        }
        
        //temp 내림차순으로 정렬.
        Arrays.sort(temp, new Comparator<String>(){
            @Override
            public int compare(String s1 , String s2){
                return (s2 + s1).compareTo(s1 + s2);
            }
        });
                 
        if(temp[0].equals("0")) //ex) 0000인 경우! 이런 경우 0으로 종료!
           return "0";
        
        for(int i=0; i< temp.length; i++){
            answer+=temp[i];
        }
        return answer;
    }
}

* compareTo

- 맨 첫자리부터 차례대로 비교하는 메소드이다!

- 차이의 길이를 리턴하게 되는데,

예를 들어, abc와 abcddd를 compareTo 하게 되면 -3을 리턴!

테스트 케이스에 3 이랑 30 이 input으로 있는데

330 이 되어야 하는데 303이 되어서 이걸 우쩌나 싶었다 ;-;

이런 경우 때문에

문자열 두 개를 붙여서 비교해준다. !

예를 들어 330이랑 303이랑 비교해서 더 큰 거 리턴 ~

내림차순이라서 (s2+s1).compareTo(s1+s2); 가 된다.

오름차순이라면 (s1+s2).compareTo(s2+s1) 하면 되겠쥬~? -> 이렇게 하면,, 가장 작은 수 ,, 겠지?!?

<String, Date>

- 루시와 엘라 찾기

처음에 IN을 떠올렸는데 그건 숫자만 되는거였다.

REGEXP_LIKE를 이용하여 해결했다.

첫번째 인자는 대상이 되는 컬럼이고,

두번째 인자는 찾고자하는 문자들을 넣어준다. 문자들의 구별은 '|' 로 한다.

- 이름에 el이 들어가는 동물

where LOWER(NAME) LIKE '%el&' 로 해도 되지만

조건 여러개일때도 사용할 수 있는 애를 쓰고 싶어서 REGEXP_LIKE를 이용했다.

기본적으로 LIKE는 대소문자 구분을 수행한다.

따라서 소문자 또는 대문자로 치환을 해주고 해결하면 된다.

나는 NAME을 소문자로 치환하여 el 을 가지고 했다.

대문자로 치환할 경우라면 EL 로 하면 되겟쥬 ,, ?~

- 중성화 여부 파악하기

* CASE WHEN 조건 THEN 참일때 표현할 값 ELSE 거짓일때 표현할 값 END

뒤에 END 붙이는지 ,, 몰라서 ,,, 개헤멨다 왜 안될까 하며  ,, ,,,,

CASE WHEN THEN ELSE END ,, 잊지않겠어 ,,,

- 오랜 기간 보호한 동물(2)

- DATETIME에서 DATE로 형 변환

<JOIN>

  *INNER JOIN

    -> 교집합

  *OUTER JOIN

    -> 합집합

- 없어진 기록 찾기

먼저 ANIMAL_OUTS에 ANIMAL_INS를 붙인다.

LEFT OUTER JOIN을 수행하게 되면

이런식으로 동일한 아이디 옆에 붙게된다.

이때 ANIMAL_INS에 없는 값들이 ANIMAL_OUTS에 붙을때는 NULL로 붙게된다.

따라서 유실된 값들은 이 NULL인 값들이다. 

따라서 답은 다음과 같다.

- 있었는데요 없없습니다

위의 문제 풀고 풀으니까 간단 ~_~

- 오랜 기간 보호한 동물(1)

해당 테이블을 먼저 만들어 준 후에, FROM을 통해 그걸 불러오고

ROWNUM을 이용해서 위에서 3개 출력되게 해쥰다.!

  - 보호소에서 중성화한 동물

  SEX_UPON_INTAKE와 SEX_UPON_OUTCOME이 다를 때 ! -> 이걸 NOT을 이용해서 나타냈다.