Everything

Programmers 월간 코드 챌린지 시즌1 9월 문제 삼각 달팽이 with Java and Python

활짝 웃자 — Sun, 20 Sep 2020 22:23:49 +0900

안녕하세요 !

이번 포스팅은 올려도 되는지 모르겠는데 이미 공개가 되었다고 하니까 올려봅니다! (문제 되면 지우도록 하겠습니다.)

프로그래머스 문제 찾아보다가 월간 코드 챌린지라는게 있어서 풀어봤어요.

사용 가능한 프로그래밍 언어는 굉장히 제한적입니다.

이번에도 문제는 프로그래머스에 있으니 직접 찾아보시고, 바로 풀이만 진행할게요! 해설 없어요!

* Java / Python3으로 진행 하였습니다.

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

class Solution {
    private static int num = 0;
    public int[] solution(int n) {
        int[][] triangle = triangleList(n);
        int[] answer = new int[num];
        int len = 0;
        for(int[] arrEl:triangle) {
            for(int el:arrEl) {
                answer[len] = el;
                len++;
            }
        }
        return answer;
    }
    
    private static int[][] triangleList(int n){
        int[][] triangle = new int[n][];
        for(int i=1; i<n+1; i++){
            num+=i;
            triangle[i-1] = new int[i];
        }
        int count=0, idx=1;
        int minHeight=0, maxHeight=n, minWidth=0, maxWidth=n;
        while (count<=num) {
            int i=minHeight, j=minWidth;
            for(i=minHeight; i<maxHeight; i++) {
                count++;
                if (count==num) {
                    triangle[i][j] = count;
                    return triangle;
                }
                triangle[i][j] = count;
            }
            minWidth++;
            i--;
            for(j=minWidth; j<maxWidth; j++) {
                count++;
                if(count==num) {
                    triangle[i][j] = count;
                    return triangle;
                }
                triangle[i][j] = count;
            }
            maxHeight -= 2;
            j = triangle[i-1].length - idx;
            for(i=maxHeight; i>minHeight; i--) {
                count++;
                if (count==num) {
                    triangle[i][j] = count;
                    return triangle;
                }
                triangle[i][j] = count;
                j--;
            }
            maxHeight++;
            minHeight += 2;
            maxWidth -= 2;
            idx++;
        }
        return triangle;
    }
}
Colored by Color Scripter

cs

2. Solved with Python3

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

def solution(n):
    answer = appendEl(triangleList(n))
    return answer
 
def triangleList(n):
    triangle = []
    for i in range(1, n+1):
        triangle.append([0 for _ in range(i)])
    num = sum(range(1, n+1))
    count = 0
    minHeight = 0
    maxHeight = n
    minWidth = 0
    maxWidth = n
    idx = 1
    while count <= num:
        i = minHeight
        j = minWidth
        for i in range(minHeight, maxHeight):
            count += 1
            if count == num:
                triangle[i][j] = count
                return triangle
            triangle[i][j] = count
        minWidth += 1
        for j in range(minWidth, maxWidth):
            count += 1
            if count == num:
                triangle[i][j] = count
                return triangle
            triangle[i][j] = count
        maxHeight -= 2
        j = len(triangle[i-1])-idx
        for i in range(maxHeight, minHeight, -1):
            count += 1
            if count == num:
                triangle[i][j] = count
                return triangle
            triangle[i][j] = count
            j -= 1
        maxHeight += 1
        minHeight += 2
        maxWidth -= 2
        idx += 1
    return triangle
 
def appendEl(triangleList):
    result = []
    for i in triangleList:
        result += i
    return result
Colored by Color Scripter

cs

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

Programmers Level2 소수 만들기 with Java and Python

활짝 웃자 — Sat, 12 Sep 2020 23:26:13 +0900

안녕하세요 !

9월 부터 연말까지 바빠져서

지금 시간이 조금 나서 올리게 되었습니다!

이번에도 ~ Programmers 문제 입니다.

저번에는 소수를 찾는 거였다면

이번 포스팅은 소수를 만드는 거에요.

저번 포스팅들과 마찬가지로 문제는 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

import java.util.Arrays;
import java.lang.Math;
 
class Solution {
    private static int answer = 0;
    
    public int solution(int[] nums) {
        int[] comArr = new int[3];
        combination(comArr, nums.length, 3, 0, 0, nums);
 
        return answer;
    }
    
    private static void combination(int[] comArr, int n, int r,
                                   int index, int target, int[] nums){
        if (r==0){
            if(checkPrime(Arrays.stream(comArr).sum())){
                answer++;
            }
            return;
        }
        if(target==n) return;
        
        comArr[index] = nums[target];
        combination(comArr, n, r-1, index+1, target+1, nums);
        combination(comArr, n, r, index, target+1, nums);
    }
    
    private static boolean checkPrime(int check) {
        int count=0;
        double checkSqrt = Math.sqrt(check);
        double checkZero = checkSqrt - (int)checkSqrt;
        if(checkZero!=0.0) {
            for(int i=1; i<(int)checkSqrt+1; i++) {
                if(check%i==0) {
                    count++;
                }
            }
            count++;
        }
        if(count==2) {
            return true;
        } else {
            return false;
        }
    }
}
Colored by Color Scripter

cs

 

2. Solved with Python3 (Python2 버전은 Programmers에서 해당 문제에서는 풀이 언어로 선택 할 수 없어서 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

from itertools import combinations
from math import sqrt
 
def solution(nums):
    return solve(nums)
 
def solve(combLi):
    primeCount = 0
    for i in combiList(combLi):
        if primeCheck(sum(i)):
            primeCount+=1
        else:
            pass
    
    return primeCount
 
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 combiList(nums):
    return list(combinations(nums, 3))
 
def sqrtCheck(checkZero):
    if checkZero!=0.0:
        return True
    else:
        return False

cs

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

태풍이라니...

활짝 웃자 — Wed, 2 Sep 2020 17:13:29 +0900

옷 사러 가야되는데...

같은 옷이어도 가격이 틀리니

이곳 저곳 발품을 팔아야 되는데!

그것도 주말에!

주말에 비오지 말아라 ~~~

Programmers Level2 튜플 with Java and Python

활짝 웃자 — Sun, 30 Aug 2020 12:53:00 +0900

안녕하세요!

이번에도 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<String, String[]> check = new HashMap<String, String[]>();
        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<String, String[]> 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("(\\},\\{)");
    }
}
Colored by Color Scripter

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(0, len(convert)):
        convert[i] = convert[i].split(",")
    for i in convert:
        dictionary[len(i)] = convert.index(i)
    result = []
    for i in range(1, len(convert)+1):
        tmp = convert[dictionary[i]]
        for j in tmp:
            if int(j, 10) not in result:
                result.append(int(j, 10))
    return result
Colored by Color Scripter

cs

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

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

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

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

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

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

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

Programmers Level2 소수찾기 with Java and Python

활짝 웃자 — Sat, 29 Aug 2020 19:56:41 +0900

안녕하세요.

이번에는 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();
            }
        }
    }
}
Colored by Color Scripter

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

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

Project Euler(프로젝트 오일러) Factorial digit sum (Problem 20) with Python

활짝 웃자 — Tue, 25 Aug 2020 21:28:31 +0900

안녕하세요.

이번에는 문제 20번을 풀어보겠습니다.

Factorial digit sum

Problem 20

n! means n × (n − 1) × ... × 3 × 2 × 1

For example, 10! = 10 × 9 × ... × 3 × 2 × 1 = 3628800,
and the sum of the digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.

Find the sum of the digits in the number 100!

Solved

1
2
3
4
5
6
7
8
9
10
11
12
13

def fac(n):
    if(n==1):
        return 1
    else:
        return n*fac(n-1)
 
def facSum(n):
    facResult=fac(n)
    facResult=str(facResult)
    result=0
    for i in facResult:
        result+=int(i)
    return str(result)

cs

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

Project Euler(프로젝트 오일러) Self powers (Problem 48) with Python

활짝 웃자 — Tue, 25 Aug 2020 21:17:24 +0900

안녕하세요.

심심하기도 하고

스트레스 해소도 할겸해서 문제 순서나 난이도 상관 없이 해보는 Project Euler with Python 입니다.

제가 기본적인 난이도의 프로그래밍 실력이 낮다고 생각이 되서 아마 중간중간 틈틈히 가볍게 할 수 있는 프로젝트 오일러를 통해서 포스팅을 하지 않을까 싶네요.

소스 설명 없이 기록용으로 작성하도록 하겠습니다.

Self powers

Problem 48

The series, 1^1 + 2^2 + 3^3 + ... + 10^10 = 10405071317.

Find the last ten digits of the series, 1^1 + 2^2 + 3^3 + ... + 1000^1000.

Solved

1
2
3
4
5
6
def selfPowers(n):
    total=0
    for i in range(1, n+1):
        total+=pow(i,i)
    total=str(total)
    return total[len(total)-10:]
cs

결과는 직접 출력해보세요 ~!

Java List Sort (자바 리스트 정렬)

활짝 웃자 — Tue, 25 Aug 2020 10:21:37 +0900

안녕하세요.

이번에는 오랫만에 삽질한(~~맨날 삽질하면서 무슨...~~) 정렬에 대해서 포스팅을 해보려고 합니다.

기본적인건데 맨날 삽질하는 것도 있고, 까먹는 것도 있고 해서 겸사겸사 기록용으로 올릴겸 포스팅을 해봅니다.

이번 포스팅에서 다룰 주제는 다음과 같습니다.

1. List<String> 과 같은 일반적인 부분이 아닌 List<ClassName> ex) List<TestDate> 형식의 객체를 요소로 가지고 있는 List의 정렬에 대하여 알아보겠습니다.

2. Date 타입의 필드를 기준으로 정렬하는 방법에 대하여 알아보도록 하겠습니다.

3. Collections / Comparator / Collectors 로 정렬 하는 방법에 대하여 알아보도록 하겠습니다.

* 위에서 말씀드렸지만 이번에 다루게 될 정렬 Data의 타입은 Date 타입입니다.

솔직히 Date 타입은 어떻게 정렬해야되나 생각하면서 Date -> String 으로 바꿔보기도하고 별짓을 다했었는데

의미가 없더라구요. (~~그건 제가 못해서...~~)

우선 테스트를 위한 TestDate 클래스를 작성하도록 하겠습니다.

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

import java.util.Date;
 
public class TestDate {
    private String userId;
    private String userName;
    private Date register_dt;
    private String tmpField1;
    
    public TestDate(String userId, String userName) {
        this.userId = userId;
        this.userName = userName;
    }
    
    public String getUserId() {
        return this.userId;
    }
    
    public String getUserName() {
        return this.userName;
    }
    
    public Date getRegister_Dt() {
        return this.register_dt;
    }
    
    public String getTmpField1() {
        return this.tmpField1;
    }
    
    public void setUserId(String userId) {
        this.userId = userId;
    }
    
    public void setUsername(String userName) {
        this.userName = userName;
    }
    
    public void setRegister_Dt(Date register_dt) {
        this.register_dt = register_dt;
    }
    
    public void setTmpField1(String tmpField1) {
        this.tmpField1 = tmpField1;
    }
}
Colored by Color Scripter

cs

작성한 TestDate 클래스를 활용하여 정렬을 해보겠습니다.

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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import java.util.Collections;
import java.util.Comparator;
import java.util.Arrays;
import java.text.SimpleDateFormat;
import java.text.DateFormat;
 
public class DateTestMain {
    public static void main(String[] args) {
        // 테스트를 위한 초기값 설정
        DateFormat df = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss.SSSS");
        
        TestDate td1 = new TestDate("td1", "td1");
        TestDate td2 = new TestDate("td2", "td2");
        TestDate td3 = new TestDate("td3", "td3");
        TestDate td4 = new TestDate("td4", "td4");
        TestDate td5 = new TestDate("td5", "td5");
        TestDate td6 = new TestDate("td6", "td6");
        TestDate td7 = new TestDate("td7", "td7");
        TestDate td8 = new TestDate("td8", "td8");
        TestDate td9 = new TestDate("td9", "td9");
        TestDate td10 = new TestDate("td10", "td10");
 
        // Date 값의 비교를 위해 for문을 100만 번 씩 반복 하였습니다.
        if(td1.getRegister_Dt()==null)    td1.setRegister_Dt(new Date());
        if(td1.getTmpField1()==null || "".equals(td1.getTmpField1())) td1.setTmpField1("080");
        for(int i=0; i<1000000; i++) {}
        if(td2.getRegister_Dt()==null)    td2.setRegister_Dt(new Date());
        if(td2.getTmpField1()==null || "".equals(td2.getTmpField1())) td2.setTmpField1("075");
        for(int i=0; i<1000000; i++) {}
        if(td3.getRegister_Dt()==null)    td3.setRegister_Dt(new Date());
        if(td3.getTmpField1()==null || "".equals(td3.getTmpField1())) td3.setTmpField1("070");
        for(int i=0; i<1000000; i++) {}
        if(td4.getRegister_Dt()==null)    td4.setRegister_Dt(new Date());
        if(td4.getTmpField1()==null || "".equals(td4.getTmpField1())) td4.setTmpField1("100");
        for(int i=0; i<1000000; i++) {}
        if(td5.getRegister_Dt()==null)    td5.setRegister_Dt(new Date());
        if(td5.getTmpField1()==null || "".equals(td5.getTmpField1())) td5.setTmpField1("005");
        for(int i=0; i<1000000; i++) {}
        if(td6.getRegister_Dt()==null)    td6.setRegister_Dt(new Date());
        if(td6.getTmpField1()==null || "".equals(td6.getTmpField1())) td6.setTmpField1("010");
        for(int i=0; i<1000000; i++) {}
        if(td7.getRegister_Dt()==null)    td7.setRegister_Dt(new Date());
        if(td7.getTmpField1()==null || "".equals(td7.getTmpField1())) td7.setTmpField1("020");
        for(int i=0; i<1000000; i++) {}
        if(td8.getRegister_Dt()==null)    td8.setRegister_Dt(new Date());
        if(td8.getTmpField1()==null || "".equals(td8.getTmpField1())) td8.setTmpField1("100");
        for(int i=0; i<1000000; i++) {}
        if(td9.getRegister_Dt()==null)    td9.setRegister_Dt(new Date());
        if(td9.getTmpField1()==null || "".equals(td9.getTmpField1())) td9.setTmpField1("005");
        for(int i=0; i<1000000; i++) {}
        if(td10.getRegister_Dt()==null)    td10.setRegister_Dt(new Date());
        if(td10.getTmpField1()==null || "".equals(td10.getTmpField1())) td10.setTmpField1("010");
 
        List<TestDate> tdList = Arrays.asList(td2, td1, td3, td10, td5, td8, td9, td4, td6, td7); // 테스트용 List
 
        for(TestDate td : tdList) // List에 값이 어떤식으로 저장되어 있는지 확인 하기 위해 출력
            System.out.println("userName : " + td.getUserName() + " / reg_dt : " + df.format(td.getRegister_Dt()));
 
        // 출력 결과
        /*
         * userName : td2 / reg_dt : 2020.08.25 09:08:35.0816 
         * userName : td1 / reg_dt : 2020.08.25 09:08:35.0809
         * userName : td3 / reg_dt : 2020.08.25 09:08:35.0818
         * userName : td10 / reg_dt : 2020.08.25 09:08:35.0830
         * userName : td5 / reg_dt : 2020.08.25 09:08:35.0821
         * userName : td8 / reg_dt : 2020.08.25 09:08:35.0826
         * userName : td9 / reg_dt : 2020.08.25 09:08:35.0828
         * userName : td4 / reg_dt : 2020.08.25 09:08:35.0820
         * userName : td6 / reg_dt : 2020.08.25 09:08:35.0823
         * userName : td7 / reg_dt : 2020.08.25 09:08:35.0825
         */
 
        //=============== 정렬 시작 ===============
        /*
         * Option 1
         * Collections.sort() with Comparator
         */
        Collections.sort(tdList, new Comparator<TestDate>() { // 익명객체 사용
            @Override
            public int compare(TestDate arg1, TestDate arg2) { // Sort Order By asc
                return arg1.getRegister_Dt().compareTo(arg2.getRegister_Dt()); // arg1 - 기준 값, arg2 - 비교 값
            }
        });
 
        Collections.sort(tdList, new Comparator<TestDate>() { // 익명객체 사용
            @Override
            public int compare(TestDate arg1, TestDate arg2) { // Sort Order By desc
                return arg2.getRegister_Dt().compareTo(arg1.getRegister_Dt()); // arg2 - 기준 값, arg1 - 비교 값
            }
        });
 
        /*
         * Option 2
         * List interface sort() [Java 8]
         */
        tdList.sort(Comparator.comparing(TestDate::getRegister_Dt)); // Sort Order By asc - Comparator의 comparing 사용, ::를 활용한 참조 방식 사용
        tdList.sort(Comparator.comparing(TestDate::getRegister_Dt).reversed()); // Sort Order By desc - Comparator의 comparing 사용, ::를 활용한 참조 방식 사용, reversed 사용시 내림차순
 
        /*
         * Option 3
         * Stream interface sorted() [Java 8]
         */
        List<TestDate> ascTD = tdList.stream() // Sort Order By asc - Comparator의 comparing 사용, ::를 활용한 참조 방식 사용, stream을 활용한 List의 sorted사용 및 collect를 활용한 Collectors.toList() 사용
                .sorted(Comparator.comparing(TestDate::getRegister_Dt))
                .collect(Collectors.toList());
 
        List<TestDate> descTD = tdList.stream() // Sort Order By desc - Comparator의 comparing 사용, ::를 활용한 참조 방식 사용, stream을 활용한 List의 sorted사용 및 collect를 활용한 Collectors.toList() 사용, reversed 사용시 내림차순
                .sorted(Comparator.comparing(TestDate::getRegister_Dt).reversed())
                .collect(Collectors.toList());
 
        //=============== 정렬 종료 ===============
 
        /*
         * 위 Option 1~3 까지의 방식 중 하나를 사용하셔서 정렬을 하신 후 출력을 해보시면 다음과 같은 결과를 확인하실 수 있습니다.
         * 여기서는 desc (내림차순) 방식으로 정렬 및 테스트를 진행 하였습니다.
         */
 
        for(TestDate td : tdList)
            System.out.println("userName : " + td.getUserName() + " / reg_dt : " + df.format(td.getRegister_Dt()));
 
        // 출력 결과
        /*
         * userName : td10 / reg_dt : 2020.08.25 09:08:35.0830
         * userName : td9 / reg_dt : 2020.08.25 09:08:35.0828
         * userName : td8 / reg_dt : 2020.08.25 09:08:35.0826
         * userName : td7 / reg_dt : 2020.08.25 09:08:35.0825
         * userName : td6 / reg_dt : 2020.08.25 09:08:35.0823
         * userName : td5 / reg_dt : 2020.08.25 09:08:35.0821
         * userName : td4 / reg_dt : 2020.08.25 09:08:35.0820
         * userName : td3 / reg_dt : 2020.08.25 09:08:35.0818
         * userName : td2 / reg_dt : 2020.08.25 09:08:35.0816
         * userName : td1 / reg_dt : 2020.08.25 09:08:35.0809
         */
 
        // 추가로 날짜 정렬 이후, 우선 순위에 따라 정렬을 해보고 결과를 확인해 보겠습니다. (desc-내림차순 정렬 사용)
 
        tdList.sort(Comparator.comparing(TestDate::getTmpField1).reversed()); // 소스코드가 짧아서 이렇게 썼습니다. (사실은 귀찮아서...)
 
        for(TestDate td : tdList)
            System.out.println("userName : " + td.getUserName() + " / tmpField : " + td.getTmpField1());
 
        // 출력 결과
        /*
         * userName : td8 / tmpField : 100
         * userName : td4 / tmpField : 100
         * userName : td1 / tmpField : 080
         * userName : td2 / tmpField : 075
         * userName : td3 / tmpField : 070
         * userName : td7 / tmpField : 020
         * userName : td10 / tmpField : 010
         * userName : td6 / tmpField : 010
         * userName : td9 / tmpField : 005
         * userName : td5 / tmpField : 005
         */
    }
}
Colored by Color Scripter

cs

결론부터 말씀드리면

포스팅의 목적이었던

- Date 타입의 필드만으로 정렬하기

- Date 타입으로 정렬 후, 우선 순위에 따라 정렬하기

위 2가지가 정상적으로 작동하는 것을 확인 하실 수 있습니다.

1. compare 오버라이딩

2. compareTo로 비교

3. Date 타입 -> String 타입 x / Date 타입 자체만으로 compareTo로 비교

4. 3까지의 과정 이후 우선순위에 따라 정렬하기

이렇게 하면 원하는 방식으로 정렬을 하실 수 있습니다.

위의 정렬 소스코드에서 Option 1을 제외한 Option 2, 3의 경우 Java 8 이라고 명시해 놓았는데,

Java 8 버전 이후부터 Option 2, 3 방식이 지원되기에 가능한 방식어서 명시해 놓았습니다.

* Option 2의 List.sort()는 Java 8 버전이 아니어도 지원이 됩니다.

:: 참조 방식에 대한 지원이 Java 8 버전 이후부터 지원이 되므로 주의 하시기 바랍니다.

여기서는 소스코드에 대해서 자세하게 설명하지 않겠습니다.

핵심인 Date 타입 자체만으로도 비교가 가능하다는 것을 알고, 정렬 방식의 종류와 버전에 따른 차이가 있다는 점을 마지막으로 포스팅을 마치도록 하겠습니다.

script tag 내부에 jsp 사용하기 (라고쓰고 에러라고 읽는다!)

활짝 웃자 — Tue, 11 Aug 2020 15:38:29 +0900

작업 중에 에러가 발생 했어요.

JSP 파일 작성 중에

script tag 내부에 jsp를 선언하여 사용하려고 했는데!

두둥!

Hello Error !!!

분명 잘 사용 했다고 생각 했는데 !!! (~~응 혼자만 ^^~~)

아무튼 문제의 소스는!

1
2
3
4
5
6
7

<script>
function formChk(form){
    <%if("write".equals(mode)){%>
    if(!form.userPhone.value){alert("연락처를 입력해 주세요."); return false;}
    <%}%>
}
</script>
Colored by Color Scripter

cs

여기까지 보면 아~무런 문제가 없는데...

하지만 다음을 보면! 두둥...

1
2
3
4
5
6
7
8
9
10

<script>
function formChk(form){
    <%if("write".equals(mode)){%>
    if(!form.userPhone.value){alert("연락처를 입력해 주세요."); return false;}
    <%}%>
    <%else if("reply".equals(mode)){%>
    if(!form.tel.value){alert("문의처를 입력해 주세요."); return false;}
    <%}%>
}
</script>
Colored by Color Scripter

cs

허헣...

너무나 기본적인 실수를 해버렸습니다.

스크립틀릿 태그를 나누지 말고, 이어서 작성 했어야 했는데 에러가 났던 것이죠! (~~응 너만 몰랐어^^~~)

- 5번째 line과 6번째 line을 나눠서 문제 발생

- 해결 : 6번째 line 5번째로 이동

해결한 코드는 다음과 같습니다.

1
2
3
4
5
6
7
8
9

<script>
function formChk(form){
    <%if("write".equals(mode)){%>
    if(!form.userPhone.value){alert("연락처를 입력해 주세요."); return false;}
    <%}else if("reply".equals(mode)){%>
    if(!form.tel.value){alert("문의처를 입력해 주세요."); return false;}
    <%}%>
}
</script>
Colored by Color Scripter

cs

이런 간단한 실수를...

실제로 수정 후, 페이지 소스보기나 F12 개발자모드로 확인을 해볼 경우 write mode 일때는 4번째 line의 소스코드만 반영되어 있고, reply mode 일때는 6번째 line의 소스코드만 반영이 되는 것을 확인 할 수 있습니다.

혹시나(그럴 일은 없으시겠지만요 쥬륵...) 저와 같은 실수를 하시는 분들이 계실까봐!

포스팅을 해봅니다.

* 여담으로 퇴근이 보이지 않아요!

이번 여름은 정말이지..

활짝 웃자 — Mon, 3 Aug 2020 15:25:03 +0900

너무 더워요

7월 달 장마가 길어지고 강수량도 역.대.급

거기에 이번년도 7, 8월은 공휴일이 (8월 17일 임시공휴일 제외) 전부 주말이거나 아예 없어서

평일이라니요!!!

7월 출근일수는! 23일...

8월 출근일수는! 21일... (임시 공휴일 제외한다면요!)

코로나에... 날씨에...

여러가지 겹치는게 많네요.

실외 근무자분들이 힘드실거 같은데...

실외 근무자분들은 뜨거운 햇볕 아래에서 일하셔야 되니 쓰러지시지 않게 조심하시고,

실내 근무자분들은 냉방병 조심하세요 !

오랫만에 왔는데 변명 따위는 안 할게요 ㅋㅋㅋㅋㅋㅋㅋㅋ

조만간 글 다시 조금씩 올려봐야죠 (~~거짓말 하지마 앙마야!~~)