프로그래머스 링크 - https://programmers.co.kr/learn/courses/30/lessons/12953?language=java


하도 귀찮아서 최소공배수 구하는 부분은 가져왔다.

원래대로라면 유클리드 방식으로 로직을 만들어야 하지만.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.util.*;
class Solution {
  public int solution(int[] arr) {
      int answer = 1;
      for(int i: arr){
          answer = lcm(answer, i);
      }
      return answer;
  }
    
    public static int lcm(int a, int b) {
    int gcd_value = gcd((int)a, (int)b);
 
    if (gcd_value == 0return 0// 인수가 둘다 0일 때의 에러 처리
 
    return Math.abs( (a * b) / gcd_value );
  }
    
    public static int gcd(int a, int b) {
    while (b != 0) {
      int temp = a % b;
      a = b;
      b = temp;
    }
    return Math.abs(a);
  }
 
}
cs


블로그 이미지

LunaStratos

Stratosphere Stream

프로그래머스 링크 - https://programmers.co.kr/learn/courses/30/lessons/12939?language=java


최댓값과 최솟값, 요즘은 Queue에 맛이 들려서 이걸로 푼다 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.util.*;
class Solution {
  public String solution(String s) {
       String [] arr = s.split(" ");
        Queue<Integer> q = new PriorityQueue<>();
 
        for (String item: arr){
            q.offer(Integer.parseInt(item));
        }
 
        String answer = q.poll() +" ";
        while (q.size()>1) q.poll();
        answer+=q.poll();
 
      return answer;
  }
}
cs


블로그 이미지

LunaStratos

Stratosphere Stream


프로그래머스 링크 https://programmers.co.kr/learn/courses/30/lessons/12951?language=java


이런류의 문제를 풀면 split(" ") 이걸 쓰는데, 뒤에 빈공간을 훼이크로 넣어서 사람을 곤란하게 만든다. 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class Solution {
  public String solution(String s) {
     StringBuilder sb = new StringBuilder();
        String[] arr = s.split("");
        int count = 0;
        for(int j = 0 ; j< arr.length; j++){
 
            if(arr[j].equals(" ")){
                sb.append(arr[j]);
                count = 0 ;
            }else{//글자라면
 
                if(count == 0){//1번째 글자
                    sb.append(arr[j].toUpperCase());
                    count++;
 
                }else{
                    sb.append(arr[j].toLowerCase());
                    count++;
                }
 
            }
 
        }
      return sb.toString();
  }
}
 
 
cs


블로그 이미지

LunaStratos

Stratosphere Stream


PriorityQueue는 String이든 int든 특별히 compare를 하지 않으면 작은 숫자부터 poll을 해서 없에줄수 있다. 이를 응용한 방법. 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
String number = "4177252841"
        int k = 4;
 
        String answer = "";
        Queue<String> q = new PriorityQueue<>();
        ArrayList<String> alist = new ArrayList<>();
        //Queue translate
        for (int i = 0; i < number.length(); i++) {
            q.offer(number.substring(i, i + 1));
            alist.add(number.substring(i, i + 1));
        }
        System.out.println(q);
 
        //작은수 빼주기
        int count = 0;
        while (!q.isEmpty()){
            String temp = q.poll();
            for (int i = 0; i < alist.size(); i++) {
                if (count == k) break;
                System.out.println(temp +" / " + count +" / " + alist.get(i));
                if (temp.equals(alist.get(i))) {
                    alist.remove(i);
                    count++;
                }
 
            }
        }
 
        System.out.println(alist);
cs


블로그 이미지

LunaStratos

Stratosphere Stream

프로그래머스 링크 - https://programmers.co.kr/learn/courses/30/lessons/12930?language=java


주의점


1. 빈칸이 앞에도 올수 있고 뒤에도 올수 있음

2. 빈칸이 하나가 아닐수도 있음. 

3.  그리고 이 빈칸이 뒤에 2개 이상 올수도 있음.


단순히 뒤에 빈칸 안올거라고 생각하고 풀다가 삑사리가 난다. 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Solution {
  public String solution(String s) {
     String[] arr = s.split("");
 
        StringBuilder sb = new StringBuilder();
        String answer = "";
        int cnt = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i].equals(" ")) {
                sb.append(arr[i]); //빈공간은 그냥 더해주기
                cnt = 0;
            } else {
                if(cnt % 2 ==0){
                    sb.append(arr[i].toUpperCase());
                    cnt++;
                }else{
                    sb.append(arr[i].toLowerCase());
                    cnt++;
                }
            }
        }
        answer = sb.toString();
      return answer;
  }
}
cs


누군 정규표현식으로 한줄로 풀던데 난 뭐하는건지..

블로그 이미지

LunaStratos

Stratosphere Stream

프로그래머스 링크 - https://programmers.co.kr/learn/courses/30/lessons/12915?language=java


이 문제의 경우 정확한 설명이 하나 빠져있다.

Array의 지정한 숫자가 같으면, 지정한 문자다음을 비교하는게 아닌, 처음 글자부터 비교해서 사전으로 정렬해야 한다. (프로그래머스 문제들은 이렇게 하나씩 설명이 엉망인게 많다. 딱 공대생 스타일로 적은 느낌.)


compare로 풀었다. 요즘은 이게 더 편한 느낌. 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.util.*;
class Solution {
  public String[] solution(String[] strings, int n) {
      String[] answer = {};
      Arrays.sort(strings, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.substring(n, o1.length()).compareTo(o2.substring(n,o2.length()));
            }
        });
        for (String item: strings
             ) {
            System.out.println(item);
        }
      return strings;
  }
}
cs







블로그 이미지

LunaStratos

Stratosphere Stream

한자리 숫자가 적힌 종이 조각이 흩어져있습니다. 흩어진 종이 조각을 붙여 소수를 몇 개 만들 수 있는지 알아내려 합니다.


각 종이 조각에 적힌 숫자가 적힌 문자열 numbers가 주어졌을 때, 종이 조각으로 만들 수 있는 소수가 몇 개인지 return 하도록 solution 함수를 완성해주세요.


프로그래머스 링크 - https://programmers.co.kr/learn/courses/30/lessons/42839?language=java


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
import java.util.*;
class Solution {
    
    static private int n; // nPr의 n
    static private int r; // nPr의 r
    static private String[] res;
    static private ArrayList<String> alist = new ArrayList<>();
    static private HashSet<Integer> map = new HashSet<>();
 
    static public void swap(String[] arr, int i, int j) {
        String temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
 
    static public void perm(String[] arr, int depth) {
 
        // depth가 0부터 시작했을 경우 depth == r에서 리턴
        if (depth == r) {
            String temp = "";
            for (String item : res) {
                temp += item;
            }
           if (Integer.parseInt(temp) <=1) {
                return;
            }
            map.add(Integer.parseInt(temp));
            return;
        }
 
        for (int i = depth; i < n; i++) {
            swap(arr, depth, i);     // 스왑
            res[depth] = arr[depth]; // 선택된 원소 저장
            perm(arr, depth + 1);     // 재귀호출
            swap(arr, depth, i);     // 복원
        }
    }
    public int solution(String numbers) {
        
        String[] arr = new String[numbers.length()];
        for (int i = 0; i < numbers.length(); i++) {
            arr[i] = numbers.substring(i, i+1);
        }
 
        for (int i = 1; i <= arr.length; i++) {
            int select = i;
            n = arr.length;
            r = select;
            res = new String[r];
            perm(arr, 0);
        }
 
        int cnt = 0;
 
 
        for (int item : map) {
               boolean flag = true;
            for (int j = 2; j * j <= item; j++) {
                if (item % j == 0) {
                    flag = false;
                    break;
                }
            }
            if (flag == true) cnt++;
 
        }
        
        return cnt;
    }
}
cs


블로그 이미지

LunaStratos

Stratosphere Stream

프로그래머스 링크  - https://programmers.co.kr/learn/courses/30/lessons/12906?language=java


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.util.*;
 
public class Solution {
    public int[] solution(int []arr) {
        //Arrays.sort(arr); 중복되는 수를 없엔다면 이걸 활성화
        ArrayList<Integer> alist = new ArrayList<>();
 
        int x = arr[0];
        alist.add(arr[0]);
        for (int i = 1; i < arr.length; i++) {
            if (x == arr[i]) { //다음 수가 같다면
                x = arr[i];
            } else { // 다음수가 같지 않다면
                alist.add(arr[i]);
                x = arr[i];
            }
        }
 
        int[] answer = new int[alist.size()];
        for (int i = 0; i < answer.length; i++) {
            answer[i] = alist.get(i);
        }
 
        return answer;
    }
}
cs


효용성 따윈 없다. Arrays.sort를 해제하면 중복된 수 빼는 것이 구해진다. 

블로그 이미지

LunaStratos

Stratosphere Stream



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.lang.reflect.Array;
import java.util.*;
 
public class Main {
 
    public static void main(String[] args) {
        String s = "221234";
        boolean answer = true;
        if (4 == s.length() || s.length() == 6) {
            answer = s.matches("-?\\d+(\\.\\d+)?");
            //or
            try{
                Integer.parseInt(s);
            }catch (NumberFormatException e){
                answer = false;
            }
 
        } else {
            answer = false;
        }
 
        System.out.println(answer);
 
 
    }
 
 
}
 
cs


String을 숫자인지 아닌지 확인하는 방법은 2가지가 가장 효율적일거 같다.


1. 

하나는 s.matches("-?\\d+(\\.\\d+)?"); 정규표현식. 이건 직접 짜기 힘들다.


2. 

다른 하나는 try catch. 이게 초보자가 짜기는 쉽다. 

블로그 이미지

LunaStratos

Stratosphere Stream

일반적인 알고리즘

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.lang.reflect.Array;
import java.util.*;
 
public class Main {
 
    public static void main(String[] args) {
        int n = 10;
        int answer = 0;
 
        for (int i = 2; i <= n; i++) {
            boolean flag = true;
            for (int j = 2; j < i; j++) {
 
                if (i % j == 0) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                answer++;
            }
        }
 
 
        System.out.println(answer);
 
    }
 
 
}
 
cs


이 방식은 다 찾아봐야 하기 때문에 시간이 걸린다.


좀더 진보적인 방법은 




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import java.lang.reflect.Array;
import java.util.*;
 
public class Main {
 
    public static void main(String[] args) {
        long start = System.currentTimeMillis(); //시작하는 시점 계산
 
        int n = 100000;
        int answer = 0;
 
        for (int i = 2; i <= n; i++) {
            boolean flag = true;
            for (int j = 2; j*<= i; j++) {
                if (i % 2 == 0) {
                    flag = false;
                    break;
                }else{
 
                    if (i % j == 0) {
                        flag = false;
                        break;
                    }
                }
 
            }
 
            if (flag) {
 
                answer++;
            }
        }
        System.out.println(answer);
        long end = System.currentTimeMillis(); //프로그램이 끝나는 시점 계산
        System.out.println("실행 시간 : " + (end - start) / 1000.0 + "초"); //실행 시간 계산 및 출력
 
    }
 
 
}
 
cs


기존의 방식이 10000을 넣었을때 1초 정도 걸리면, 진보된 방식은 0.016초가 걸린다.

아마 소수를 구하는 방식의 경우 소수결과보단 출력 시간이 짧은 것을 원하는 형태일 것이다. 아마도...

블로그 이미지

LunaStratos

Stratosphere Stream