2024. 11. 24. 19:46ㆍ코딩 테스트(Coding Test)/백준
2750 수 정렬하기
나의 답) 136ms
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = Integer.parseInt(br.readLine());
}
Arrays.sort(arr);
for (int i = 0; i < n; i++) {
System.out.println(arr[i]);
}
}
}
다른 사람의 답1) 120ms
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
StringBuilder sb = new StringBuilder();
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = Integer.parseInt(br.readLine());
}
Arrays.sort(arr);
for (int i = 0; i < n; i++) {
sb.append(arr[i]).append("\n");
}
System.out.print(sb);
}
}
다른 사람의 답2) 108ms
import java.io.*;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb = new StringBuilder();
int n = Integer.parseInt(br.readLine());
boolean[] arr = new boolean[2001];
for (int i = 0; i < n; i++) {
arr[Integer.parseInt(br.readLine()) + 1000] = true;
}
for (int i = 0; i < 2001; i++) {
if (arr[i]) {
sb.append(i - 1000).append('\n');
}
}
System.out.println(sb);
}
}2587 대표값2
나의 답) 100ms
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb = new StringBuilder();
int[] arr = new int[5];
int total = 0;
for (int i = 0; i < 5; i++) {
arr[i] = Integer.parseInt(br.readLine());
total += arr[i];
}
sb.append((total / 5)).append('\n');
Arrays.sort(arr);
sb.append(arr[2]);
System.out.print(sb);
}
}
다른 사람의 답1) 100ms
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int[] arr = new int[5];
int sum = 0;
int avg = 0;
for (int i = 0; i < 5; i++) {
arr[i] = Integer.parseInt(br.readLine());
sum += arr[i];
avg = sum / 5;
}
Arrays.sort(arr);
System.out.println(avg);
System.out.println(arr[arr.length / 2]);
}
}
다른 사람의 답2) 100ms
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
int[] arr = new int[5];
int sum = 0;
for (int i = 0; i < 5; i++) {
int num = Integer.parseInt(br.readLine());
arr[i] = num;
sum += arr[i];
}
Arrays.sort(arr);
System.out.println(sum / arr.length);
System.out.println(arr[arr.length / 2]);
}
}25305 커트라인
나의 답) 120ms
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken());
int k = Integer.parseInt(st.nextToken());
Integer[] arr = new Integer[n];
st = new StringTokenizer(br.readLine());
for (int i = 0; i < arr.length; i++) {
arr[i] = Integer.parseInt(st.nextToken());
}
Arrays.sort(arr, Collections.reverseOrder());
System.out.print(arr[k - 1]);
}
}
다른 사람의 답) 112ms
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int N = Integer.parseInt(st.nextToken());
int k = Integer.parseInt(st.nextToken());
st = new StringTokenizer(br.readLine());
int[] arr = new int[N];
for (int i = 0; i < arr.length; i++) {
arr[i] = Integer.parseInt(st.nextToken());
}
Arrays.sort(arr);
System.out.println(arr[arr.length - k]);
}
}
나의 답보다 시간이 짧게 나오는 이유)
1. 배열 데이터 타입의 차이
- 1번 코드는 Integer[] arr = new Integer[n];로 객체 배열을 사용하고 있습니다. Java에서 Integer[]는 객체 타입이기 때문에 배열의 각 요소가 객체로 취급됩니다. 이로 인해 배열에 값을 삽입하고 배열을 정렬하는 과정에서 추가적인 박싱(boxing)과 언박싱(unboxing) 비용이 발생합니다. 즉, int 값을 Integer 객체로 변환하고 다시 Integer 객체에서 int 값을 추출하는 과정에서 성능 저하가 발생할 수 있습니다.
- 2번 코드는 int[] arr = new int[N];로 기본 타입 배열을 사용하고 있습니다. int[]는 기본 데이터 타입인 int 배열을 사용하여 박싱 및 언박싱이 필요 없으므로, 상대적으로 메모리와 속도 측면에서 더 효율적입니다.
2. Arrays.sort()의 동작 방식
- 1번 코드에서는 Arrays.sort(arr, Collections.reverseOrder());를 사용하여 Integer[] 배열을 내림차순으로 정렬합니다. 이 방법은 내부적으로 Comparator를 사용하므로 정렬 시 비교 비용이 증가할 수 있습니다. Comparator는 객체 비교에 비효율적일 수 있습니다.
- 2번 코드에서는 Arrays.sort(arr);를 사용하여 int[] 배열을 오름차순으로 정렬합니다. int 배열에 대해서는 기본 비교 방법이 사용되며, 이 방식이 더 빠릅니다. 내림차순을 요구하지만, Arrays.sort()로 오름차순 정렬을 하고 마지막 요소를 출력하는 방법을 사용하여 성능이 더 좋습니다. 이렇게 하는 방식은 내림차순 정렬에 비해 더 효율적입니다.
2751 수 정렬하기2
나의 답) 1216ms
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb = new StringBuilder();
int n = Integer.parseInt(br.readLine());
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = Integer.parseInt(br.readLine());
}
Arrays.sort(arr);
for (int i = 0; i < n; i++) {
sb.append(arr[i]).append("\n");
}
System.out.print(sb);
}
}
ing~~
10989 수 정렬하기3
나의 답) 2344ms
import java.io.*;
import java.util.Arrays;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb = new StringBuilder();
int n = Integer.parseInt(br.readLine());
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = Integer.parseInt(br.readLine());
}
Arrays.sort(arr);
for (int i = 0; i < n; i++) {
sb.append(arr[i]).append("\n");
}
System.out.print(sb);
}
}
1427 소트인사이드
나의 답) 108ms
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb = new StringBuilder();
String str = br.readLine();
Integer[] arr = new Integer[str.length()];
for (int i = 0; i < arr.length; i++) {
arr[i] = str.charAt(i) - '0';
}
Arrays.sort(arr, Collections.reverseOrder());
for (int a : arr) {
sb.append(a);
}
System.out.print(sb.toString());
}
}
[전체 알고리즘]
1. 정렬하고자 하는 수 N 입력받기
2. 자리수를 내림차순으로 정렬
3. 출력
[자리수를 내림차순으로 정렬]
1. 입력 받은 수의 자리수 구하기
2. 빈 배열 생성 후 각 숫자를 배열에 넣기
3. 내림차순 정렬
4. StringBuilder에 붙인 후 출력
11650 좌표 정렬하기
나의 답) 616ms
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st;
StringBuilder sb = new StringBuilder();
int n = Integer.parseInt(br.readLine());
int[][] arr = new int[n][2];
for (int i = 0; i < n; i++) {
st = new StringTokenizer(br.readLine());
arr[i][0] = Integer.parseInt(st.nextToken());
arr[i][1] = Integer.parseInt(st.nextToken());
}
Arrays.sort(arr, new Comparator<int[]>() { // new Comparator 함수 Override
@Override
public int compare(int[] o1, int[] o2) {
if (o1[0] == o2[0]) { // 첫 번째 원소의 값이 같을 때 두 번째 원소의 값을 기준으로 정렬
return o1[1] - o2[1];
} else { // 같지 않을 시 첫 번째 원소를 기준으로 정렬
return o1[0] - o2[0];
}
}
});
for (int i = 0; i < n; i++) {
sb.append(arr[i][0]).append(" ").append(arr[i][1]).append("\n");
}
System.out.print(sb);
}
}
[전체 알고리즘]
1. 점의 개수 N 구하기
2. N번 돌며 x, y 입력받기
3. 좌표 정렬(x좌표가 증가하는 순으로, x좌표가 같으면 y좌표가 증가하는 순서로 정렬)
4. 좌표 출력
[새롭게 알게 된 것]
Comparator
: Comparator는 두 점을 비교하여 정렬 순서를 결정하는 역할을 한다. Arrays.sort()는 기본적으로 요소들의 순서를 비교할 수 있는 방식으로 정렬하는데, 그 비교 방식을 Comparator를 사용하여 커스터마이즈할 수 있다.
Comparator<int[]>는 int[] 배열을 비교하는 비교자를 만들겠다는 뜻이다.
Comparator를 구현할 때 compare()를 오버라이드하여 두 요소를 비교하는 방식을 정의한다.
1. new Comparator<int[]>() { ... } 부분
- 여기서 Comparator<int[]>는 2차원 배열인 int[]을 비교할 수 있는 객체를 생성한다.
- compare()를 오버라이드하여 비교 방식(정렬 기준)을 구현한다.
2. compare()의 동작
: compare()는 두 객체를 비교하는데 사용된다. 이 메서드는 두 객체를 비교한 결과에 따라 다음 값을 반환한다.
- 0: 두 객체가 동일한 것으로 간주되어 정렬 순서가 바뀌지 않는다.
- 음수: 첫 번쨰 객체가 두 번째 객체보다 앞에 와야 함을 나타낸다.
- 양수: 첫 번쨰 객체가 두 번째 객체보다 뒤에 와야 함을 나타낸다.
https://velog.io/@thsdnjst/Java-2%EC%B0%A8%EC%9B%90-%EB%B0%B0%EC%97%B4-%EC%A0%95%EB%A0%AC
다른 답) 612ms
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st;
StringBuilder sb = new StringBuilder();
int n = Integer.parseInt(br.readLine());
int[][] arr = new int[n][2];
for (int i = 0; i < n; i++) {
st = new StringTokenizer(br.readLine());
arr[i][0] = Integer.parseInt(st.nextToken());
arr[i][1] = Integer.parseInt(st.nextToken());
}
Arrays.sort(arr, new Comparator<int[]> () {
@Override
public int compare(int[] o1, int[] o2) {
return (o1[0] == o2[0]) ? o1[1] - o2[1] : o1[0] - o2[0];
}
});
for (int i = 0; i < n; i++) {
sb.append(arr[i][0]).append(" ").append(arr[i][1]).append("\n");
}
System.out.print(sb);
}
}
11651 좌표 정렬하기2
나의 답) 612ms
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st;
StringBuilder sb = new StringBuilder();
int n = Integer.parseInt(br.readLine());
int[][] arr = new int[n][2];
for (int i = 0; i < n; i++) {
st = new StringTokenizer(br.readLine());
arr[i][0] = Integer.parseInt(st.nextToken());
arr[i][1] = Integer.parseInt(st.nextToken());
}
Arrays.sort(arr, new Comparator<int[]> () {
@Override
public int compare(int[] o1, int[] o2) {
return (o1[1] == o2[1]) ? o1[0] - o2[0] : o1[1] - o2[1];
}
});
for (int i = 0; i < n; i++) {
sb.append(arr[i][0]).append(" ").append(arr[i][1]).append("\n");
}
System.out.print(sb);
}
}
[전체 알고리즘]
1. 점 N개 입력받기
2. N번 돌며 x축, y축 입력받기
3. y축에 대하여 오름차순, y좌표가 같으면 x좌표에 대하여 오름차순
1181 단어 정렬
나의 답) 336ms
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb = new StringBuilder();
int n = Integer.parseInt(br.readLine());
// HashSet을 사용하여 중복된 단어를 제거
Set<String> set = new HashSet<>();
for (int i = 0; i < n; i++) {
set.add(br.readLine()); //중복을 제거하며 입력 받음
}
// 중복 제거 후 Set을 ArrayList로 변환
ArrayList<String> words = new ArrayList<>(set);
// 길이가 짧은 것부터, 길이가 같으면 사전 순으로 정렬
Collections.sort(words, (a, b) -> {
if (a.length() == b.length()) {
return a.compareTo(b); // 길이가 같으면 사전 순으로
}
return Integer.compare(a.length(), b.length()); //길이가 짧은 것부터
});
for (String w : words) {
sb.append(w).append("\n");
}
System.out.println(sb);
}
}
[전체 알고리즘]
1. 단어의 개수 N 입력받기
2. N번 돌며 소문자로 이루어진 단어 입력받기
3. 중복된 단어 제거
4. 정렬 후 출력
[정렬 조건]
1. 길이가 짧은 것부터
2. 길이가 같으면 사전 순으로
1. Set과 HashSet 설명
- Set
: Set은 중복을 허용하지 않는 자료 구조이다. 즉, Set에 값을 넣을 때, 이미 존재하는 값이 있으면 그 값을 중복해서 추가하지 않는다.
Set은 인터페이스이기 때문에, Set 타입을 사용할 때는 이를 구현한 클래스를 지정해야 한다.
- HashSet
: HashSet은 Set 인터페이스를 구현한 클래스 중 하나이다. HashSet은 빠른 검색을 제공하는 자료 구조로, 내부적으로 해시 테이블을 사용하여 데이터를 관리한다. 즉, 중복된 값이 추가되지 않으며, 삽입 순서를 보장하지 않는다.
2. Set에서 ArrayList로 변경한 이유
- Set은 순서를 보장하지 않는다. 따라서 순서를 관리할 수 있는 ArrayList로 변환하였다.
- Set은 Collection.sort()와 같은 정렬 작업을 바로 지원하지 않기 때문에, 중복을 제거한 후에 ArrayList로 변환하여 정렬할 수 있도록 하였다.
3. Comparator 사용
- Collections.srt()는 기본적으로 오름차순으로 정렬한다. 하지만 해당 문제에서는 단어의 길이가 짧은 순으로 정렬해야 하고, 길이가 같으면 사전 순으로 정렬해야 하기 때문에 기본적인 오름차순 정렬만으로는 부족하다. 따라서 추가로 Comparator을 사용하여 정렬 기준을 정의해야 한다.
- Comparator을 사용하기 위해 Collections.sort()에서 Comparator을 두 번째 인자로 받아준다.
- compare(T o1, T 92)
: 1) 0을 반환하면 두 객체는 같다.
2) 음수를 반환하면 첫 번째 객체가 두 번째 객체보다 작다.
3) 양수를 반환하면 첫 번째 객체가 두 번째 객체보다 크다.
- 람다식 (a, b) -> { ... } 사용
4. compareTo()
: 두 객체를 비교하여 순서를 정하는 메서드이다. 음수, 0, 양수 중 하나를 반환한다.
5. Integer.compare()
: 두 int 값을 비교할 때 사용하는 메서드이다. 두 정수를 비교하고, 그들의 상대적인 순서를 결정하는 데 사용된다. 음수
음수, 0, 양수 중 하나를 반환한다.
10814 나이순 정렬
나의 답) 556ms
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st;
StringBuilder sb = new StringBuilder();
int n = Integer.parseInt(br.readLine());
ArrayList<User> user = new ArrayList<>();
for (int i = 0; i < n; i++) {
st = new StringTokenizer(br.readLine());
int age = Integer.parseInt(st.nextToken());
String name = st.nextToken();
user.add(new User(age, name));
}
user.sort((u1, u2) -> {
if (u1.age == u2.age) return 0; // 나이가 같으면 가입 순으로
return Integer.compare(u1.age, u2.age); // 나이 오름차순으로 정렬
});
for (User u : user) {
sb.append(u.age).append(" ").append(u.name).append("\n");
}
System.out.print(sb);
}
static class User {
int age;
String name;
public User(int age, String name) {
this.age = age;
this.name = name;
}
}
}
[전체 알고리즘]
1. 온라인 저지 회원의 수 N 입력받기
2. N개의 줄을 돌며 각 회원의 나이와 이름 입력받기
3. 정렬 후 출력하기
[정렬 조건]
1. 나이 오름차순
2. 나이가 같으면 가입한 순
18870 좌표 압축
좌표 압축이란?
: 주어진 수들을 범위가 좁은 값으로 변환하는 기법이다. 이 문제에서는 주어진 좌표들을 다른 좌표들과의 상대적인 순서에 맞는 값으로 바꾸는 작업을 한다.
나의 답1) 시간 초과
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st;
StringBuilder sb = new StringBuilder();
int n = Integer.parseInt(br.readLine());
int[] arr = new int[n];
st = new StringTokenizer(br.readLine());
for (int i = 0; i < n; i++) {
arr[i] = Integer.parseInt(st.nextToken());
}
for (int i = 0; i < n; i++) {
int count = 0;
for (int j = 0; j < n; j++) {
if (arr[j] < arr[i]) {
count++;
}
}
arr[i] = count;
sb.append(arr[i]).append(" ");
}
System.out.print(sb);
}
}
// N 입력받기
// 정수 N개 입력받기
[시간 초과가 발생한 이유]
=> 중첩된 반복문 때문!
현재 알고리즘은 두 개의 중첩된 for문을 사용하고 있는데, 이는 입력 크기 N이 커질수록 O(N^2) 시간이 걸린다.
주어진 문제의 제한 (N <= 1,000,000)에서는 이 알고리즘이 매우 비효율적이므로 시간 초과가 발생하는 것이다.
개선된 코드)
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st;
StringBuilder sb = new StringBuilder();
int n = Integer.parseInt(br.readLine());
int[] arr = new int[n];
st = new StringTokenizer(br.readLine());
for (int i = 0; i < n; i++) {
arr[i] = Integer.parseInt(st.nextToken());
}
// 새로운 배열 생성 후 정렬
int[] sortedArr = arr.clone();
Arrays.sort(sortedArr);
// 중복 제거한 값의 순서를 기록
Map<Integer, Integer> rankMap = new HashMap<>();
int rank = 0;
// sortedArr의 값을 순서대로 rankMap에 넣기 (중복을 처리)
for (int num : sortedArr) {
if (!rankMap.containsKey(num)) {
rankMap.put(num, rank++);
}
}
// 원래 배열에서 각 값을 순서대로 압축하여 출력
for (int i = 0; i < n; i++) {
sb.append(rankMap.get(arr[i])).append(" ");
}
System.out.println(sb.toString().trim());
}
}
1. 주어진 좌표를 정렬한다.
2. 중복을 제거한 후, 각 값에 대해 그 값이 몇 번째로 작은 값인지 순서를 부여한다.
3. 원래 배열의 값에 대해 각 값의 순서를 출력한다.
1. clone()
: 원본 객체가 가지고 있는 값만 그대로 복사한다.(얕은 복사)
2. Map
: Map은 키(key)와 값(value)의 쌍으로 데이터를 저장하는 자료구조이다.
Map은 각 키에 대해 하나의 값만을 가질 수 있기 때문에, 중복된 키를 허용하지 않는다.
즉, 같은 키에 대한 값은 오직 하나만 존재할 수 있다.
- 키: 고유한 식별자 역할을 한다. 중복될 수 없다.
- 값: 각 키에 매핑된 데이터이다. 값은 중복될 수 있다.
3. HashMap
: 가장 일반적으로 사용되는 Map의 구현체로, 키와 값을 해시 테이블을 사용하여 저장한다.
HashMap은 빠른 조회와 삽입/삭제를 제공한다.
+) TreeMap: Map을 정렬된 순서로 저장하는 구현체이다.
+) LinkedHashMap: 삽입된 순서를 유지하는 Map 구현체이다.
Map<Integer, Integer> rankMap = new HashMap<>();
int rank = 0;
rankMap의 역할:
- rankMap은 각 고유한 좌표(Integer)에 대해 그 좌표의 순위(Integer)를 저장하는 맵이다.
- rankMap에 중복된 좌표가 들어가면 자동으로 덮어씌워지기 때문에 중복이 제거된다. 즉, 중복 좌표에 대해 순위가 한 번만 기록된다.
예시:
만약 좌표가 [2, 4, -10, 4, -9]라고 할 때, rankMap은 다음과 같이 변환된다.
- 2에 대해 순위 0
- 4에 대해 순위 1 (두 번째 4는 덮어쓰여서 순위는 1로 동일)
- -10에 대해 순위 2
- -9에 대해 순위 3
4. rankMap에 순위를 부여하는 과정
for (int num : sortedArr) {
if (!rankMap.containsKey(num)) {
rankMap.put(num, rank++);
}
}
1) sortedArr 배열은 정렬된 배열이다. 이 배열의 각 값에 대해 순위를 매긴다.
2) rankMap.containsKey(num)는 해당 값 num이 rankMap에 이미 존재하는지를 확인한다. 만약 존재하지 않으면, 그 값을 새로운 순위로 추가하고, rank++로 순위를 증가시킨다.
3) 중복된 값은 덮어씌워지기 때문에 rankMap에는 중복된 좌표가 한 번만 기록된다.
예시:
주어진 배열이 [2, 4, -10, 4, -9]라고 할 때:
- 첫 번째 값 2는 rankMap에 추가되고, 순위 0을 부여한다.
- 두 번째 값 4는 아직 rankMap에 없으므로, 순위 1을 부여하고 추가한다.
- 세 번째 값 -10은 순위 2로 추가된다.
- 네 번째 값 4는 이미 rankMap에 존재하므로 순위를 덮어쓰지 않고 건너뛴다.
- 다섯 번째 값 -9는 순위 3을 부여하고 추가된다.
=> 결과적으로 rankMap에는 다음과 같은 값이 저장된다.
rankMap = {-10=2, -9=3, 2=0, 4=1}'코딩 테스트(Coding Test) > 백준' 카테고리의 다른 글
| [JAVA] 백준 10단계 (0) | 2024.11.12 |
|---|---|
| [JAVA] 백준 7단계 (0) | 2024.09.10 |
| [JAVA] 백준 6단계 (1) | 2024.09.09 |
| [JAVA] 백준 5단계 (3) | 2024.09.09 |
| [JAVA] 백준 4단계 (0) | 2024.09.05 |