이클립스나 STS가 설치된 경로에서
STS.ini파일을 찾아
첫줄에 
-vm 를 넣고
jdk11설치된 폴더의 bin까지의 경로 + \javaw.exe 를 넣고 저장하면 해결된다.

프로그램이 실행될 때 ini파일을 읽는데 jdk의 버전이 1.8로 맞지않아 발생한 에러이다 11이상의 버전이 설치된 경로를 지정해주어 해결.

jdk버전을 1.8로 맞출경우 IDE를 실행시켜줄 가상머신이 없어 log파일을 확인하라는 에러가 발생한다. 위에 추가했던 내용대로 가상머신인 javaw의 경로를 추가해주어 해결해야 한다.

해당 에러를 해결하면서 pom.xml에 있던 dependencies에 빨간불이 들어오던 에러도 같이 해결되었다.

풀이

import java.util.*;
class Solution {
    public int[] solution(int l, int r) {
        List<Integer> list=new ArrayList<>();

        for(int i=l; i<=r; i++){
            String s=Integer.toString(i);
            boolean bool=true;
            for(char c:s.toCharArray()){
                if(c!='5' && c!='0'){
                    bool=false;
                    break;
                }
            }
            if(bool){
                list.add(i);
            }
        }
        if(list.isEmpty()){
            list.add(-1);
        }

        int[] answer=new int[list.size()];
        for(int i=0; i<list.size(); i++){
            answer[i]=list.get(i);
        }

        return answer;
    }
}

풀이방법

1) String으로 형변환 후 char타입 c에 한글자씩 담으면서 2) 5,0이 아니라면 bool=false로 변환 후 break 3) 5,0인 경우 bool이 true값을 가지며 list에 추가한다.

class Solution {
    public String solution(String polynomial) {
        String answer = "0";//polynomial이 빈문자라면 0반환(1차항, 상수항==0)
        String[] arr=polynomial.split(" \\+ ");
        int tmp=0;
        int con=0;

        for(int i=0; i<arr.length; i++){
            if(arr[i].contains("x")){//"x"를 포함하고 있다면
                if(arr[i].charAt(0)=='x'){//해당 문자의 0번째 글자가 x이거나
                    if(arr[i].length()==1){//1글자라면
                        tmp+=1;//1차항 1증가
                    }
                }else{
                    int idx=arr[i].indexOf('x');//1차항 계수가 2자리 이상일 경우
                    tmp+=Integer.parseInt(arr[i].substring(0, idx));//계수가 1자리 일때는 idx대신 2
                }
            }else{
                con+=Integer.parseInt(arr[i]);//x가 없다면 상수만 출력
            }
        }
        if(tmp==0){//1차항 0인 경우
            answer=con+"";
        }else if(con==0){
            if(tmp==1){//상수0이면서 1차 계수가 1인경우
                answer="x";
            }else{//상수 0이면서 1차계수가 1이 아닌경우
                answer=tmp+"x";
            }
        }else if (tmp==1 && con!=0) {
            answer = "x + "+con;
        }else{
            answer=tmp+"x + "+con;
        }
        return answer;
    }
}

풀이방법

1) polynomial을 "+"를 기준으로 split하여 배열로 만들고 2) 각 배열 인덱스에서 'x'를 포함한 경우 3) 'x'를 포함하면서 'x'만 있는 경우 1차항 계수 증가 4) 1차항 계수가 2자리 이상일 경우 5) 출력할때 상수 계수, 1차항 계수가 0 인경우 6) 1차항 계수가 1인 경우

-실행되는 것을 봤을때 4)항목에 해당하는 경우는 없었던거 같다.(없어도 실행 잘됨) -출력할 때 1차항의 계수가 1인경우를 주어진 테스트케이스에서 알아낼 수 없었다.(한참을 애먹었다)

요약: 앞으로 1칸 이동가능, 현재까지 거리*2 위치로 순간이동

풀이

import java.util.*;

public class Solution {
    public int solution(int n) {
        int ans = 0;
        while(n!=0){
            if(n%2==0) n/=2;
            else{
                ans++;
                n--;
            }
        }
        return ans;
    }
}

풀이방법

1) 1부터 쭉 나열해서 써보면 일정한 규칙을 찾을 수 있다.(=수학적인 문제) 홀수라면 Jump 1회, 짝수는 2로 계속해서 나누었을 때 홀수가 반환되면 다시 Jump 1회를 더하면 된다.

import java.util.*;
class Solution {
    public String[] solution(String[] strings, int n) {
        String[] answer = new String[strings.length];
        List<StringBuilder> list=new ArrayList<>();

        for(int i=0; i<strings.length; i++){
            StringBuilder buf=new StringBuilder();
            buf.append(strings[i].charAt(n))
                .append(strings[i]);
            list.add(buf);
        }
        Collections.sort(list);
        for(int i=0; i<list.size(); i++){
            answer[i]=list.get(i).substring(1);
        }
        return answer;
    }
}

풀이방법

1) 값을 순서대로 담기위해 List사용 2) 문자의 임이 변형을 편리하게 하기 위해 StringBuilder사용 3) 인덱스n의 글자를 charAt()으로 추출하고 기존 strings[i]번째 단어를 append하여 더한다 4) 인덱스[n]의 글자가 가장 앞에 있으므로 sort하여 오름차순 정렬 5) answer에 인덱스[1]의 글자부터 뽑아서 넣는다.

import java.util.*;
class Solution {
    public int[] solution(int[] numbers) {
        HashSet<Integer> set=new HashSet<>();

        for(int i=0; i<numbers.length; i++){
            for(int j=i+1; j<numbers.length; j++){
                set.add(numbers[i]+numbers[j]);
            }
        }
        ArrayList<Integer> list=new ArrayList<>(set);
        Collections.sort(list);

        int[] answer=new int[list.size()];
        for(int i=0; i<list.size(); i++){
            answer[i]=list.get(i);
        }

        return answer;
    }
}


//Set<Integer> set=new TreeSet<>(): //중복값x 순서정렬o

풀이방법

1) HashSet을 사용하면 중복값을 갖지 않고 배열을 만들 수 있다. 2) 오름차순으로 정렬(sort)하기위해 HashSet을 List타입으로 변경 3) answer[]에 List를 대입하여 반환

) HashSet대신 TreeSet을 사용하면 중복값을 갖지 않으면서 오름차순 정렬된 배열을 얻을 수 있다.

import java.util.*;

class Solution {
    public int[] solution(int[] arr) {
        int[] answer = array(arr);
        if(answer.length==0) {
            return new int[]{-1};
        }
        return answer;
    }
    private static int[] array(int[] arr){
        Stack<Integer> stk=new Stack<>();
        for(int i=0; i<arr.length; i++){
            if(stk.isEmpty() || stk.peek() != arr[i]) {
                stk.push(arr[i]);
            }else{
                stk.pop();
            }
        }
        int[] tmp=new int[stk.size()];
        int idx=tmp.length-1;
        while(!stk.isEmpty()){
            tmp[idx]=stk.pop();
            idx--;
        }
        return tmp;
    }
}

풀이방법

1) stack사용으로 규칙에 맞게 값 누적하기 2) tmp배열에 임시저장 3) answer에 대입하여 반환

풀이

import java.util.*;
class Solution {
    public int[] solution(int n, String[] words) {
        ArrayList<String> list=new ArrayList<>();//나온 단어 비교용 list
        int[] answer =new int[2];

        for(int i=0; i<words.length; i++){
            int player=(i%n)+1;
            int turn=(i/n)+1;
            if(list.contains(words[i])){//words[i]가 word[]에 포함되어 있다면
                answer[0]=player;
                answer[1]=turn;
                break;
            }else{//탈락자 없을 경우
                answer[0]=0;
                answer[1]=0;
            }
            list.add(words[i]);
            //[i-1]맨 끝자 != [i]인 경우
            if(i>0 && (words[i].charAt(0)!=words[i-1].charAt(words[i-1].length()-1))){
                answer[0]=player;
                answer[1]=turn;
                break;
            }
        }
        return answer;
    }
}

풀이방법

1) 한번 사용된 단어를 list에 담는다 2) words[i]가 list에 있는 경우 %연산으로 n보다 크지 않은 반복된 숫자를 반환하게 하여 player를 반환. /연산으로 n으로 나누었을 때 몫을 turn으로 반환 3) 탈락자가 없는 경우 {0,0)반환 4) words[i]의 첫 글자와 words[i-1]의 끝 글자가 다를 때의 player와 turn반환

import java.util.*;
class Solution {
    public int solution(String s) {
        Stack<Character> stack = new Stack<>();

        for (int i=0; i<s.length(); i++) {
            char ch=s.charAt(i);

            if(!stack.isEmpty() && stack.peek()==ch){
                stack.pop();
            }else stack.push(ch);
        }

        return stack.isEmpty()?1:0;
    }
}

풀이방법

1) Stack을 활용하여 peek(가장 최근에 추가된 값)과 s의 i번째 인덱스가 같다면 pop하여 제거 2) 그렇지 않다면 push하여 남은 글자만 기록

class Solution {
    public int solution(String A, String B) {
        int answer = 0;
        String[] str=(A+A).split("");
        String tmp="";

        for(int i=A.length(); i>0; i--){
            for(int j=i; j<(i+A.length()); j++){
                tmp+=str[j];
            }
            if(tmp.equals(B)) break;
            tmp="";
            answer++;
        }
        if(answer==A.length()) answer=-1;
        return answer;
    }
}

풀이방법

1) A의 맨끝 요소가 맨 앞에서 출력되어 B와 비교한다. String A를 2번 연결하여 index를 A.length()부터 감소시키면서 A의 길이만큼 출력한다.

ex) hello + hello = h e l l o h e l l o index번호 0 1 2 3 4 5 6 7 8 9 59 = hello 48 = ohell . . . 1~4 = elloh

재미있는 방법이라고 생각하고 작성했지만, 좋은 코드라고 할 수는 없을것같다. 선언된 변수도 많고, 2중for문에 if문도 2개나 들어가서 속도도 느리고 코드도 너무 길다.

그리고 이 방법을 아주 현명하게 푼 사람이 있었다.

class Solution {
    public int solution(String A, String B) {
        return (B+B).indexOf(A);
    }
}

한번만 틀어서 생각했다면 떠올릴법도 했을텐데....아쉽다.

import java.util.*;

class Solution {
    public int[] solution(int[] arr, int k) {
        HashSet<Integer> set = new HashSet<>();
        int[] answer=new int[k];

        int count=0;
        for(int i=0; i<arr.length; i++) {
            if(!set.contains(arr[i])) {
                set.add(arr[i]);
                answer[count]=arr[i];
                count++;
            }
            if(count==k) {
                break;
            }
        }
        for(int i=count; i<k; i++) {
            answer[i]=-1;
        }
        return answer;
    }
}

풀이방법

1) 중복된 값을 제거하기 위한 HashSet 객체 set을 생성 2) 중복값이 없을경우 if수행, count가 k와 같아지면 반복문 탈출 3) 2번째 반복문을 통해 answer의 빈자리를 -1로 채운다.

배열에서 중복값을 없애기 위한 방법

1. HashSet

2. LinkedHashSet

3. 2중for문으로 제거하기

이중 HashSet과 LinkedHashSet은 중복된 값을 갖지 않는 배열을 생성하지만, HashSet의 경우 배열에 입력되는 순서가 없기 때문에 무작위로 입력된다. 반면, HashSetList의 경우 순서가 보장된 상태로 중복값을 제거한 배열을 갖는다.

해당 풀이에서는 HashSet을 사용하여 중복값만 제거하고, for문을 이용하여 배열 answer에 순차적으로 값을 입력하는 방식을 사용했다.

public class Solution {

    public String solution(String s, int n) {
        String answer = "";
        for(int i=0; i<s.length(); i++) {
            char ch=s.charAt(i);
            if(ch==' ') {
                answer += ch;
                continue;
            }
            if(ch>='a' && ch<='z') {
                if(ch+n>'z') {
                    answer+=(char)(ch-26+n);
                }else {
                    answer+=(char)(ch+n);
                }
            }else if(ch>='A' && ch<='Z') {
                if(ch+n>'Z') {
                    answer+=(char)(ch-26+n);
                }else {
                    answer+=(char)(ch+n);
                }
            }
        }
        return answer;
    }
}

풀이방법

1) char타입 활용 2) 아스키코드로 n만큼 더하거나 3) z를 넘어갈 경우 26(알파벳 개수)를 뺀 뒤 n만큼 더한다 4) 대 소문자 2가지로 나누어서 푼다

import java.util.*;
class Solution {
    public int solution(int[][] sizes) {
        int answer = 0;
        int mv=0;
        int mh=0;
        for(int i=0;i<sizes.length;i++){
            int v=Math.max(sizes[i][0], sizes[i][1]);
            int h=Math.min(sizes[i][0], sizes[i][1]);
            mv=Math.max(mv,v);
            mh=Math.max(mh,h);
        }
        return answer=mv*mh;
    }
}

풀이방법

1) 명함의 가장 긴 변을 v로, 가장 짧은 변을 h로 둔다 2) v중 가장 긴 값, h중 가장 긴 값을 곱하여 answer로 반환

class Solution {
    public int solution(int n) {
        int[] answer = new int[n+1];

        for(int i=0; i<=n; i++){
            if(i==0) answer[i]=0;
            else if(i==1) answer[i]=1;
            else{
                int fibo=answer[i-2]+answer[i-1];
                answer[i]=fibo%1234567;
            }
        }
        return answer[n];
    }
}

풀이방법

1) 피보나치 수는 이전수와 전전수의 합이다 2) int범위를 벗어나는것을 막기위해 1234567로 나누어 준다

class Solution {
    public int solution(int a, int b) {
        int x=Math.max(a,b);
        int y=Math.min(a,b);
        while(x%y!=0){
            int r=x%y;
            x=y;
            y=r;
        }
        b/=y;
        while(true){
            if(b%2==0){
                b/=2;
            }else if(b%5==0){
                b/=5;
            }else if(b==1) {
                return 1;
            }else{
                return 2;
            }
        }
    }
}

풀이방법

1) 유클리드 호재법으로 최대공약수 y를 구한다 2) 분모에 해당하는 b를 y로 나누어 기약분수의 형태로 만든다 3) 유한소수는 소인수를 2와5를 갖는다(2,5로 나누었을 때 0)

import java.util.*;
class Solution{
    public int solution(int []A, int []B){
        int answer = 0;

        Arrays.sort(A);
        Arrays.sort(B);

        for(int i=0; i<A.length; i++){
            answer+=A[i]*B[B.length-1-i];
        }

        return answer;
    }
}

풀이방법

1) 한쪽 배열의 최대값과, 다른쪽 배열의 최솟값을 곱하여 더하면 가장 작은 수가 나온다.

class Solution {
    public int[] solution(int n, int m) {
        int a=Math.max(n, m);
        int b=Math.min(n, m);
        while (b!=0) {
            int r=a%b;
            a=b;
            b=r;
        }

        return new int[] { a, n * m / a };
    }
}

풀이방법

1) 최대공약수: 유클리드호재법 =n<m, r=m%n일때 m=n이되고, n=r이 될때 n이 0이될때의 m값 2) 최소공배수: 최소공배수최대공약수=nm

class Solution {
    public int solution(String my_string, String target) {
        int answer = 0;

        //answer=(my_string.contains(target))?1:0;
        answer=(my_string.indexOf(target)>-1)?1:0;
        return answer;
    }
}

풀이방법

1) contain()함수 사용 :contain()함수는 문자열에 특정문자를 포함하고 있는지 확인한다.(대소문자 구분)

2) indexOf()함수 사용 :indexOf()함수는 문자열에 특정문자의 위치를 반환한다.(특정문자열을 포함하고 있으면 인덱스를 반환, 찾지못한 경우 -1을 반환한다.)

처리속도는 indexOf()가 조금 더 빨랐다. ->contains()함수는 특정 문자열을 indexOf()>-1인 경우를 boolean타입으로 true, false를 반환하기 때문이다. 즉, contains()함수는 indexOf()함수를 사용하여 boolean값을 반환하는 함수이다.

class Solution {
    public boolean solution(String s) {
        boolean answer = false;
        int k=0;
        if(s.length()==4 || s.length()==6){
            for(int i=0; i<s.length(); i++){
                if(s.charAt(i)>57){
                    k-=1;
                }
            }answer=(k<0)?false:true;
        }


        return answer;
    }
}

풀이방법 0) 문제를 잘 읽어보자. 문자열s의 길이가 4 또는 6 일때의 true조건이 있다.

1) charAt()메서드로 문자열s를 for반복하여 아스키코드57(숫자9)보다 큰 값(알파벳은 64이상)을 음수(-)로 만들어 음수일 때 false를 출력하도록 했다.

다른 사람 풀이 [1]

class Solution {
  public boolean solution(String s) {
      if(s.length() == 4 || s.length() == 6){
          try{
              int x = Integer.parseInt(s);
              return true;
          } catch(NumberFormatException e){
              return false;
          }
      }
      else return false;
  }
}

위의 풀이법은 try catch문으로 예외를 발생시켜 T/F를 판별하는 참신한?방법을 사용했는데 댓글에 "Effective Java"라는 이야기가 있어서 찾아보니 책에서 말하는 '예외'는

1. 예외는 진짜 예외 상황에만 적용하라
2. 복구가능한 상황에는 검사예외를 프로그래밍 오류에는 런타임 예외를 사용하라
3. 메서드가 던지는 모든 예외를 문서화하라
4. 예외의 상세 메세지에 실패 관련 정보를 담아라
5. 가능한 실패원자적으로 만들어라 라는 내용이 있었고, 해당 풀이는 1번 사항에 위배됨을 알 수 있었다. (하지만 정말 참신한 접근이었다. 마치 절대 열어선 안되는 상자를 연 판도라처럼...) 결론은 흐름제어에 예외처리 사용은 '금기'시 된다.

   다른 사람 풀이[2]
   

class Solution { public boolean solution(String s) { return (s.length() != 4 && s.length() != 6) || (s.split("[0-9]").length > 0) ? false:true; } }

``` 위 풀이 방법은 split()에 대한 지식이 얄팍했음을 깨우치게했다. 프로그래머스에서 특히 애용하던? split()을 단일 문자로 자를줄만 알았지 "[0-9]"와 같은 정규식을 사용해서 문자와 정수를 분리해낼 수 있다는 생각을 못했다. 처리 속도면에서는 내 풀이가 더 빠르지만, 간결함과 더불어 정규표현식까지 배울점이 많은 풀이임은 틀림없다.

Integer : int(data type)를 객체로 다루기 위해 사용하는 클래스

이때 자료형에는 primitive type(기본형)과 reference type(참조형)이 있는데 int는 primitive type에 포함되고 Integer는 reference type에 포함된다.

차이점 int는 산술연산이 가능하지만 Integer의 경우 valueOf() 또는 Integer() 와 같은 메서드를 통해 산술연산이 가능하다.(Unboxing)