๋ฌธ์
์ผ๋ง ์ GPT์ ์ค์ ๋น๊ต ๋ฐฉ์์ด ํ์ ๊ฐ ๋ ์ ์ด ์์๋ค.
์ง๋ฌธ) "3.9์ 3.11 ์ค์ ๋ญ๊ฐ ๋ ์ปค?" / ๋ต๋ณ) "3.11์ด ๋ ํฝ๋๋ค."
์ํ ์๊ฐ์ ์กธ์ง ์์ ์ฌ๋๋ค์ ๊ฐ ๋ณด๋ค ํฌ๋ค๊ณ ์๊ฐํ์ง๋ง, GPT์ ๋์ผ๋ก ๋ณด๋ฉด Python 3.9์ Python 3.11 ์ค ํ์๋ฅผ ๋ ํฌ๊ฒ ๋ณด๋ ํ์ต ๋ฐ์ดํฐ๊ฐ ๋ง์ ์ ๋ ๊ฒ ์๊ฐํ ์ ์๋ค. GPT์ ์ธ์์์ 3.1์ 3๋ณด๋ค ํฌ๊ณ , ๋ง์ฐฌ๊ฐ์ง๋ก 3.9๋ 3.2๋ณด๋ค ํฌ์ง๋ง, 3.10์ 3.2๋ณด๋ค ํฐ ๊ฐ์ผ๋ก ์ฒ๋ฆฌ๋๋ค.
๊ตฌ์ฒด์ ์ผ๋ก, ์์์ ์ ๊ธฐ์ค์ผ๋ก ์ผ์ชฝ์ ์๋ก ์ฝ์ ๊ฐ์ , ์ค๋ฅธ์ชฝ์ ์๋ก ์ฝ์ ๊ฐ์ ๋ผ๊ณ ํ ๋ ๋ ์์ ๋น๊ต๊ฐ ๋ค์๊ณผ ๊ฐ์ด ์ด๋ฃจ์ด์ง๋ค:
- ๊ฐ์ด ๋ ์์ผ๋ฉด ๋ ์์ ์์ด๋ค.
- ๊ฐ์ด ๊ฐ์ ๊ฒฝ์ฐ ๊ฐ์ด ๋ ์์ผ๋ฉด ๋ ์์ ์์ด๋ค.
- ์์์ ์ด ์๋ ๊ฒฝ์ฐ๋ ๊ฐ์ ์์ ์์์ ์ด ์๋ ๊ฒฝ์ฐ๋ณด๋ค ํญ์ ์๊ฒ ์ทจ๊ธ๋๋ค. (๋ค์ ๋งํด, GPT์๊ฒ 3์ 3.0๋ณด๋ค ์๋ค.)
๊ฐ์ ์๋ค์ด ์ฃผ์ด์ก์ ๋, ์ด๋ฅผ GPT์ ๊ธฐ์ค์ ๋ฐ๋ผ ๋น๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํด๋ณด์.
์ ์ฝ์กฐ๊ฑด
[๋ฌธ์ ์ ์ฝ ์กฐ๊ฑด]
[์กฐ๊ฑด 1] ์ ์ด์ ์ดํ์ด๋ค.
[์กฐ๊ฑด 2] ๊ฐ ์๋ ์ค์ ํน์ ์ ์๋ก ํํ๋๊ณ , ์ด์ ์ดํ์ด๋ฉฐ, ์์์ ์ด ์๊ฑฐ๋ ์์์ ์๋ ์ต๋ 3์๋ฆฌ๊น์ง ์ฃผ์ด์ง๋ค.
[์๋ธ ํ์คํฌ๋ณ ์ ์ฝ ์กฐ๊ฑด]
๋ณ๋์ ์๋ธ ํ์คํฌ๊ฐ ์กด์ฌํ์ง ์์ต๋๋ค.
์ ๋ ฅํ์
์ฒซ ๋ฒ์งธ ์ค์ ์ด ์ฃผ์ด์ง๋ค.
๋ ๋ฒ์งธ ์ค๋ถํฐ ๊ฐ์ ์ค์ ๊ฑธ์ณ, ๊ฐ ์๊ฐ ํ ์ค์ ํ๋์ฉ ์ฃผ์ด์ง๋ค.
01.23, 3.001๊ณผ ๊ฐ์ด ์์์ ์ ๊ธฐ์ค์ผ๋ก ๊ฐ ํํธ์ ์ด ์๋ ์ ์ด์ ์ leading zero๊ฐ ๋์ค๋ ๊ฒฝ์ฐ๋ ์ฃผ์ด์ง์ง ์๋๋ค.
์ถ๊ฐ๋ก, 3.00, 3.000, ๋๋ 00.1๊ณผ ๊ฐ์ด ์์์ ์ ๊ธฐ์ค์ผ๋ก ํ ํํธ์ ๋ ๊ฐ ์ด์์ 0๋ง ์ฃผ์ด์ง๋ ์ ๋ ฅ์ ์๋ค.
์ถ๋ ฅํ์
์ฒซ ๋ฒ์งธ ์ค๋ถํฐ ๊ฐ์ ์ค์ ๊ฑธ์ณ, ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ์๋ค์ GPT์ ๊ธฐ์ค์ผ๋ก ๋น๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ ์์๋๋ก ํ ์ค์ ํ๋์ฉ ์ถ๋ ฅํ๋ค.
์์
5 1.2 1.11 2.9 4.2 3
1.2 1.11 2.9 3 4.2
1.2์ 1.11์ ์์์ ์ ์ํด ์ถ๋ ฅํ๋ฉด ๋๋ค.
8 1 1.0 2.0 2.10 2.1 2.100 1.11 1.3
1 1.0 1.3 1.11 2.0 2.1 2.10 2.100
ํ์ด
์ ์ ํ ๊ณ์ฐ์ ์ด์ฉํ ๋ฐฐ์ด์ ์ ๋ ฌ ๋ฌธ์
์์ซ์ ์ ๊ธฐ์ค์ผ๋ก ์์๋ฆฌ ์ ์์ ๋ท์๋ฆฌ ์ ์๋ฅผ ๋น๊ตํ๋ค.
์๋ฐ์ ๋ฐฐ์ด์์์ sortํจ์์ ์๊ฐ๋ณต์ก๋๋ O(nlogn)์ผ๋ก ์ ๋ ฅ๊ฐ N์ ์ต๋๊ฐ์ธ 1,000์ด ๋ค์ด์๋ 1์ด ์์ ์ ๋ ฌ ๊ฐ๋ฅ
์ฝ๋
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb = new StringBuilder();
ArrayList<String> arr = new ArrayList<>();
// ์
๋ ฅ๊ฐ ๋ฐ๊ธฐ
int N = Integer.parseInt(br.readLine());
for(int i=0; i < N; i++){
arr.add(br.readLine());
}
// ๋๋คํจ์๋ก ์ ๋ ฌ ์ ์
Collections.sort(arr, (first, second) -> {
String[] a1 = first.split("\\.");
String[] a2 = second.split("\\.");
// ์์๋ฆฌ ์ ์๋น๊ต
int r1 = Integer.parseInt(a1[0]) - Integer.parseInt(a2[0]);
// ์์๋ฆฌ ์ ์๊ฐ ๊ฐ์ง ์๋ค๋ฉด, ๊ฒฐ๊ณผ ๋ฆฌํดํ์ฌ ์ ๋ ฌ
if(r1 != 0){
return r1;
}
// ๋ท์๋ฆฌ ์ ์๋น๊ต
// ์์ซ์ ์ด ์๋ ๊ฐ๊ณผ ์์ซ์ ์ดํ ๊ฐ์ด 0์ธ ๊ฐ์ ๋น๊ตํ๊ธฐ ์ํด์ ์๋ค๋ฉด, -1์ฒ๋ฆฌ
int n1 = a1.length < 2 ? -1 : Integer.parseInt(a1[1]);
int n2 = a2.length < 2 ? -1 : Integer.parseInt(a2[1]);
return n1 - n2;
});
// ์ถ๋ ฅ๊ฐ ์ธํ
for(String item : arr) {
sb.append(item).append("\n");
}
System.out.println(sb.toString());
br.close();
}
}
'Programming > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ๋ชจ๋๋ฌ ์ ๊ณฑ๊ทผ (0) | 2025.05.01 |
---|---|
[Java] ์๋ฐ์ ์ด์ง ์ฐ์ฐ(๋นํธ ์ฐ์ฐ) (0) | 2025.04.06 |
[Kotlin] ๋ฐฑ์ค 2504 ๊ดํธ์ ๊ฐ ์ฝํ๋ฆฐ ํ์ด - stack (0) | 2025.03.31 |
[Kotlin] ๋ฐฑ์ค 14888 - ์ฐ์ฐ์ ๋ผ์๋ฃ๊ธฐ(์ฌ๊ท์์ ํ์ DFS, ๋ฐฑํธ๋ํน) (1) | 2025.03.09 |
[Kotlin] ๋ฐฑ์ค 1978 ์์ ์ฐพ๊ธฐ (1) | 2025.03.08 |