안녕하세요!

 

이번에도 Programmers 문제입니다.

 

이번 문제는 2019 카카오톡 개발자 겨울 인턴십에 나온 문제라고 합니다.

 

이번에도 별 다른 설명 없이 기록용으로 바로 풀이를 해볼게요!

* 효율성이 떨어져도 이해해주세요! 피드백 감사하게 받겠습니다!

 

 

1. Solved with 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
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.util.HashMap;
 
class Solution {
    public int[] solution(String s) {
        Map<StringString[]> check = new HashMap<StringString[]>();
        List<Integer> resultList = new ArrayList<Integer>();
        String[] splitStr = splitString(s);
        return test(splitStr, resultList, check);
    }
    
    private static int[] test(String[] splitString, List<Integer> resultList,
                             Map<StringString[]> check){
        for(int i=0; i<splitString.length; i++){
            String[] tmpArr = splitString[i].split(",");
            if(splitString.length==1){
                int[] resultArr = {Integer.parseInt(tmpArr[0], 10)};
                return resultArr;
            } else {
                check.put(""+tmpArr.length, tmpArr);
            }
        }
        for(int i=1; i<splitString.length+1; i++){
            for(String el:check.get(""+i)){
                if(!resultList.contains(Integer.parseInt(el))){
                    resultList.add(Integer.parseInt(el));
                }
            }
        }
        int[] resultArr = new int[resultList.size()];
        for(int i=0; i<resultList.size(); i++){
            resultArr[i] = resultList.get(i);
        }
        
        return resultArr;
    }
    
    private static String[] splitString(String s){
        s = s.replaceAll("\\{\\{""");
        s = s.replaceAll("\\}\\}""");
        return s.split("(\\},\\{)");
    }
}
cs

 

 

2. Solved with Python 2, 3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def solution(s):
    return parseString(s)
 
def parseString(s):
    dictionary = {}
    convert = s.split("},{")
    if len(convert) == 1:
        convert[0= convert[0].split("{{")[1]
        convert[0= convert[0].split("}}")[0]
        convert[0= int(convert[0], 10)
        return convert
    convert[0= convert[0].split("{")[-1]
    convert[len(convert)-1= convert[len(convert)-1].split("}")[0]
    for i in range(0len(convert)):
        convert[i] = convert[i].split(",")
    for i in convert:
        dictionary[len(i)] = convert.index(i)
    result = []
    for i in range(1len(convert)+1):
        tmp = convert[dictionary[i]]
        for j in tmp:
            if int(j, 10not in result:
                result.append(int(j, 10))
    return result
cs

 

※ 여담이지만 솔직히 이번에 문제에서는 split("},{") 으로 나눠주면서 Java보다는 Python이 확실히 편하더군요. (개인적인 생각입니다!)

    Python 에서는 "},{" 로만 해줘도 하나의 문자열로 인식을 하는데,

    Java 에서는 중괄호를 각각 인식해주기 위해서 "\\"를 사용해야하지, ','를 넣어주고 따로 지정해주지 않으면

    모든 ','를 split 대상으로 인식해서 다 split 되어 버리지... 그거 인식해주려고 소괄호로 묶어서 하나의 문자열로 인식을

    해줘야 하는게 번거롭더군요. (제가 못해서 그래요 헿)

    아무튼 각각의 어떤 언어가 좋고 나쁘다는 말할 수 없다고 생각하고, 각각의 장단점이 있는 것 같습니다.

 

 

 

 

 

 

위 코드의 결과는 직접 확인해 보세요 ~!

 

 

 

 

 

 

 

안녕하세요.

 

이번에는 Project Euler에 이어서 Programmers 문제를 가져왔습니다 !

 

이번에도 마찬가지로 기본적인 알고리즘 코딩이 많이 부족하다고 생각하여 효율이 떨어지더라도 우선 문제를 풀어보는거에 중점을 두고,

필요 API등만 검색해보고 직접 풀어보는 형식으로 진행 하였습니다.

* 아마 문제를 검색해보시면 풀이 방법들이 많이 잘 나와 있을거에요. (위에서 언급한대로 문제 자체를 검색하지 않았다는 점 말씀드립니다.)

 

이번에도 소스코드에 대한 설명은 없이 기록용이므로 바로 풀이를 하도록 하겠습니다.

* 문제 풀이는 Java, Python 2버전, Python 3 버전을 사용하여 진행 하였습니다.

 

Programmers의 문제는 한글로 되어있고, 금방 찾아 보실 수 있으니 문제 내용은 생략 하도록 하겠습니다.

 

1. Solved with 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
71
72
73
74
75
76
77
import java.lang.Math;
import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;
import java.util.LinkedList;
 
class Solution {
    public int solution(String numbers) {
        int num=numbers.length();
        List<String> checkDuplicate = new ArrayList<String>();
        LinkedList<Integer> perArr = new LinkedList<Integer>();
        List<String> initList = Arrays.asList(numbers.split(""));
        int[] perCheck = new int[num];
        
        for(int i=1; i<num+1; i++){
            permutation(num, i, perArr, perCheck, initList, checkDuplicate);
        }
        return checkPrimeNum(checkDuplicate);
    }
    
    private static int checkPrimeNum(List<String> checkList){
        List<Integer> convertList = new ArrayList<Integer>();
        List<Integer> primeNum = new ArrayList<Integer>();
        
        for(String el:checkList){
            int convertVal = Integer.parseInt(el, 10);
            if(!convertList.contains(convertVal) 
              && convertVal!=0 && convertVal!=1){
                convertList.add(convertVal);
            }
        }
        
        for(int el: convertList){
            int count=0;
            double elSqrt = Math.sqrt(el);
            double checkZero = elSqrt - (int)elSqrt;
            if(checkZero!=0.0){
                //for(int i=1; i<el+1; i++){
                for(int i=1; i<(int)elSqrt+1; i++){
                    if(el%i==0){
                        count++;
                    }
                }
                count++;
                if(count==2){
                    primeNum.add(el);
                }
            }
        }
        return primeNum.size();
    }
    
    private static void permutation(int n, int r, LinkedList<Integer> perArr,
                                   int[] perCheck, List<String> initList,
                                   List<String> checkDuplicate){
        String checkStr = "";
        if(perArr.size()==r){
            for(int el: perArr){
                checkStr+=el;
                if(!checkDuplicate.contains(checkStr)){
                    checkDuplicate.add(checkStr);
                }
            }
            return;
        }
        
        for(int i=0; i<n; i++){
            if(perCheck[i]==0){
                perArr.add(Integer.parseInt(initList.get(i), 10));
                perCheck[i]=1;
                permutation(n, r, perArr, perCheck, initList, checkDuplicate);
                perCheck[i]=0;
                perArr.removeLast();
            }
        }
    }
}
cs

 

 

2. Solved with Python 2, Python 3

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
from itertools import permutations
from math import sqrt
 
def solution(numbers):
    return primeNum(numbers)
 
def primeNum(number):
    items = list(number)
    itemLen = len(items)+1
    setDuplicate = []
    
    for i in range(1, itemLen):
        check = set(permutations(items, i))
        for j in check:
            strs = ""
            for k in j:
                strs += k
            num = int(strs, 10)
            if num==0 or num==1:
                pass
            else:
                if num not in setDuplicate:
                    if primeCheck(num):
                        setDuplicate.append(num)
                    else:
                        pass
                else:
                    pass
    
    return len(setDuplicate)
 
def primeCheck(num):
    numSqrt = sqrt(num)
    checkSqrt = int(numSqrt)+1
    checkZero = numSqrt - int(numSqrt)
    count = 0
    if sqrtCheck(checkZero):
        for i in range(1, checkSqrt):
            if(num%i==0):
                count+=1
            else:
                pass
        count+=1
        if count==2:
            return True
        else:
            return False
    else:
        return False
 
def sqrtCheck(checkZero):
    if checkZero!=0.0:
        return True
    else:
        return False
cs

 

결과는 직접 확인해 보세요 ~!

 

 

 

+ Recent posts