프로그래머스 링크 - 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

댓글을 달아 주세요