Skip to content

Commit cb04c73

Browse files
KimJyeKimJye
committed
array
1 parent 30fc4a2 commit cb04c73

4 files changed

Lines changed: 275 additions & 19 deletions

File tree

‎2019_algorithm/backjoon/src/array/P1158.java‎

Lines changed: 76 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,76 @@
1+
package array;
2+
3+
/*
4+
* Date: 2019. 07. 02
5+
* Author: KimJye | https://github.com/KimJye
6+
* Solution URL: https://github.com/KimJye/algorithm
7+
* Problem URL : https://www.acmicpc.net/problem/1158
8+
* Title : 조세퍼스 문제
9+
* description : 조세퍼스 문제는 다음과 같다.
10+
1번부터 N번까지 N명의 사람이 원을 이루면서 앉아있고, 양의 정수 K(≤ N)가 주어진다.
11+
이제 순서대로 K번째 사람을 제거한다.
12+
한 사람이 제거되면 남은 사람들로 이루어진 원을 따라 이 과정을 계속해 나간다.
13+
이 과정은 N명의 사람이 모두 제거될 때까지 계속된다.
14+
원에서 사람들이 제거되는 순서를 (N, K)-조세퍼스 순열이라고 한다.
15+
예를 들어 (7, 3)-조세퍼스 순열은 <3, 6, 2, 7, 5, 1, 4>이다.
16+
17+
N과 K가 주어지면 (N, K)-조세퍼스 순열을 구하는 프로그램을 작성하시오.
18+
19+
입력 : 첫째 줄에 N과 K가 빈 칸을 사이에 두고 순서대로 주어진다. (1 ≤ K ≤ N ≤ 5,000)
20+
21+
출력 : 예제와 같이 조세퍼스 순열을 출력한다.
22+
23+
24+
* solution : ArrayList
25+
*/
26+
27+
import java.io.BufferedReader;
28+
import java.io.IOException;
29+
import java.io.InputStreamReader;
30+
import java.util.ArrayList;
31+
import java.util.List;
32+
import java.util.StringTokenizer;
33+
34+
/*
35+
규칙
36+
1 2 3 4 5 6 7
37+
=> (3,2)
38+
1 2 4 5 6 7
39+
=> (6,2+2=4)
40+
1 2 4 5 7
41+
=> (2,4+2=6=>6-(5-1)4-1==1)
42+
1,4,5,7
43+
=> (7,1+2==3)
44+
1,4,5
45+
=> (5,5=>5-2(3-1)-1==2)
46+
1,4
47+
=> (1, 2+2=>4-1(2-1)-1=2(>last.index)=> 2-1(2-1)-1 = 0. (1,0)
48+
4
49+
50+
이것은 index = (index+K-1)%list.size()
51+
*/
52+
public class P1158 {
53+
public static void main(String[] args) throws IOException {
54+
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
55+
StringTokenizer st = new StringTokenizer(br.readLine());
56+
57+
int N = Integer.parseInt(st.nextToken());
58+
int K = Integer.parseInt(st.nextToken());
59+
60+
List<Integer> list = new ArrayList();
61+
for(int i=1; i<=N; ++i){
62+
list.add(i);
63+
}
64+
65+
List<Integer> resultList = new ArrayList<>();
66+
int index=0;
67+
68+
while(N-- >0){
69+
index = (index + K -1) % list.size();
70+
resultList.add(list.remove(index));
71+
}
72+
System.out.println(resultList.toString().replace('[','<').replace(']','>'));
73+
74+
br.close();
75+
}
76+
}

‎2019_algorithm/backjoon/src/array/P1406.java‎

Lines changed: 97 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,97 @@
1+
package array;
2+
3+
import java.io.*;
4+
import java.util.LinkedList;
5+
import java.util.ListIterator;
6+
import java.util.StringTokenizer;
7+
8+
/*
9+
* Date: 2019. 07. 02
10+
* Author: KimJye | https://github.com/KimJye
11+
* Solution URL: https://github.com/KimJye/algorithm
12+
* Problem URL : https://www.acmicpc.net/problem/1158
13+
* Title : 에디터
14+
* description : 한 줄로 된 간단한 에디터를 구현하려고 한다.
15+
* 이 편집기는 영어 소문자만을 기록할 수 있는 편집기로, 최대 600,000글자까지 입력할 수 있다.
16+
이 편집기에는 '커서'라는 것이 있는데,
17+
커서는 문장의 맨 앞(첫 번째 문자의 왼쪽),
18+
문장의 맨 뒤(마지막 문자의 오른쪽),
19+
또는 문장 중간 임의의 곳(모든 연속된 두 문자 사이)에 위치할 수 있다.
20+
즉 길이가 L인 문자열이 현재 편집기에 입력되어 있으면, 커서가 위치할 수 있는 곳은 L+1가지 경우가 있다.
21+
이 편집기가 지원하는 명령어는 다음과 같다.
22+
L
23+
커서를 왼쪽으로 한 칸 옮김 (커서가 문장의 맨 앞이면 무시됨)
24+
25+
D
26+
커서를 오른쪽으로 한 칸 옮김 (커서가 문장의 맨 뒤이면 무시됨)
27+
28+
B
29+
커서 왼쪽에 있는 문자를 삭제함 (커서가 문장의 맨 앞이면 무시됨)
30+
삭제로 인해 커서는 한 칸 왼쪽으로 이동한 것처럼 나타나지만, 실제로 커서의 오른쪽에 있던 문자는 그대로임
31+
32+
P $
33+
$라는 문자를 커서 왼쪽에 추가함
34+
35+
초기에 편집기에 입력되어 있는 문자열이 주어지고, 그 이후 입력한 명령어가 차례로 주어졌을 때, 모든 명령어를 수행하고 난 후 편집기에 입력되어 있는 문자열을 구하는 프로그램을 작성하시오. 단, 명령어가 수행되기 전에 커서는 문장의 맨 뒤에 위치하고 있다고 한다.
36+
37+
입력 : 첫째 줄에는 초기에 편집기에 입력되어 있는 문자열이 주어진다.
38+
이 문자열은 영어 소문자로만 이루어져 있으며, 길이는 100,000을 넘지 않는다.
39+
둘째 줄에는 입력할 명령어의 개수를 나타내는 정수 N(1≤N≤500,000)이 주어진다.
40+
셋째 줄부터 N개의 줄에 걸쳐 입력할 명령어가 순서대로 주어진다.
41+
명령어는 위의 네 가지 중 하나의 형태로만 주어진다.
42+
43+
출력 : 첫째 줄에 모든 명령어를 수행하고 난 후 편집기에 입력되어 있는 문자열을 출력한다.
44+
45+
46+
* solution : LinkedList,ListIterator
47+
48+
*/
49+
public class P1406 {
50+
public static void main(String[] args) throws IOException {
51+
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
52+
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
53+
54+
String input = br.readLine();
55+
56+
LinkedList<Character> list = new LinkedList<>();
57+
for (char c : input.toCharArray()) {
58+
list.add(c);
59+
}
60+
61+
ListIterator<Character> iterator = list.listIterator(list.size());
62+
63+
int N = Integer.parseInt(br.readLine());
64+
65+
while (N-- >0) {
66+
StringTokenizer st = new StringTokenizer(br.readLine());
67+
String cmd = st.nextToken();
68+
switch (cmd) {
69+
case "L":
70+
if (iterator.hasPrevious()) {
71+
iterator.previous();
72+
}
73+
break;
74+
case "D":
75+
if (iterator.hasNext()) {
76+
iterator.next();
77+
}
78+
break;
79+
case "B":
80+
if (iterator.hasPrevious()) {
81+
iterator.previous();
82+
iterator.remove();
83+
}
84+
break;
85+
case "P":
86+
iterator.add(st.nextToken().charAt(0));
87+
break;
88+
}
89+
}
90+
for (char c : list) {
91+
bw.write(String.valueOf(c));
92+
}
93+
br.close();
94+
bw.flush();
95+
bw.close();
96+
}
97+
}

‎2019_algorithm/backjoon/src/array/P5397.java‎

Lines changed: 70 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,70 @@
1+
package array;
2+
3+
import java.io.*;
4+
import java.util.LinkedList;
5+
import java.util.ListIterator;
6+
7+
/*
8+
* Date: 2019. 07. 06
9+
* Author: KimJye | https://github.com/KimJye
10+
* Solution URL: https://github.com/KimJye/algorithm
11+
* Problem URL : https://www.acmicpc.net/problem/5397
12+
* Title : 키로거
13+
* description : 창영이는 강산이의 비밀번호를 훔치기 위해서 강산이가 사용하는 컴퓨터에 키로거를 설치했다.
14+
* 며칠을 기다린 끝에 창영이는 강산이가 비밀번호 창에 입력하는 글자를 얻어냈다.
15+
키로거는 사용자가 키보드를 누른 명령을 모두 기록한다.
16+
따라서, 강산이가 비밀번호를 입력할 때, 화살표나 백스페이스를 입력해도 정확한 비밀번호를 알아낼 수 있다.
17+
18+
강산이가 비밀번호 창에서 입력한 키가 주어졌을 때, 강산이의 비밀번호를 알아내는 프로그램을 작성하시오.
19+
20+
입력 : 첫째 줄에 테스트 케이스의 개수가 주어진다.
21+
각 테스트 케이스는 한줄로 이루어져 있고, 강산이가 입력한 순서대로 길이가 L인 문자열이 주어진다.
22+
(1 ≤ L의 길이 ≤ 1,000,000) 강산이가 백스페이스를 입력했다면, '-'가 주어진다.
23+
이때 커서의 바로 앞에 글자가 존재한다면, 그 글자를 지운다.
24+
화살표의 입력은 '<'와 '>'로 주어진다.
25+
이때는 커서의 위치를 움직일 수 있다면, 왼쪽 또는 오른쪽으로 1만큼 움직인다.
26+
나머지 문자는 비밀번호의 일부이다. 물론, 나중에 백스페이스를 통해서 지울 수는 있다.
27+
만약 커서의 위치가 줄의 마지막이 아니라면, 그 문자를 입력하고, 커서는 오른쪽으로 한 칸 이동한다.
28+
29+
출력 : 각 테스트 케이스에 대해서, 강산이의 비밀번호를 출력한다. 비밀번호의 길이는 항상 0보다 크다.
30+
31+
32+
* solution : LinkedList, ListIterator
33+
34+
*/
35+
public class P5397 {
36+
public static void main(String[] args) throws IOException {
37+
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
38+
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
39+
40+
int N = Integer.parseInt(br.readLine());
41+
42+
while(N-- >0){
43+
String input = br.readLine();
44+
LinkedList<Character> list = new LinkedList<>();
45+
46+
ListIterator<Character> iterator = list.listIterator();
47+
48+
for(char c : input.toCharArray()){
49+
switch (c){
50+
case '<' : if(iterator.hasPrevious()) iterator.previous(); break;
51+
case '>' : if(iterator.hasNext()) iterator.next(); break;
52+
case '-' : if(iterator.hasPrevious()){
53+
iterator.previous();
54+
iterator.remove();;
55+
break;
56+
}
57+
default: iterator.add(c);
58+
}
59+
}
60+
for (char c : list) {
61+
bw.write(String.valueOf(c));
62+
}
63+
bw.newLine();
64+
bw.flush();
65+
}
66+
br.close();
67+
bw.flush();
68+
bw.close();
69+
}
70+
}

‎2019_algorithm/backjoon/src/sort/P2108.java‎

Lines changed: 32 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -39,12 +39,12 @@ static int average(int[] a) {
3939
sum += i;
4040
}
4141

42-
double result = (double)sum / a.length;
42+
double result = (double) sum / a.length;
4343

4444
// 음수
45-
if(result<0){
46-
result *=-1;
47-
return (int) (Math.round(result))*-1;
45+
if (result < 0) {
46+
result *= -1;
47+
return (int) (Math.round(result)) * -1;
4848
}
4949

5050
return (int) Math.round(result);
@@ -77,22 +77,35 @@ static int frequent(int[] a) {
7777
}
7878
// 최빈값 중 두번째로 작은 값 찾기
7979
List<Integer> list = sortByValue(hashMap);
80-
int maxValue = hashMap.get(list.get(0));
81-
int min = list.get(0);
82-
int result=min;
83-
84-
for(int i=1; i<list.size(); ++i){
85-
if((hashMap.get(list.get(i)) == maxValue)){
86-
if(list.get(i)<min){
87-
result = min;
88-
min = list.get(i);
89-
}
90-
else if((list.get(i)> min && list.get(i)<result) || min == result)
91-
result = list.get(i);
80+
for(int i : list){
81+
System.out.print(i +" ");
82+
}
83+
if ((hashMap.get(list.get(0))) == (hashMap.get(list.get(1)))) {
84+
if(list.get(0)>list.get(1)){
85+
return list.get(0);
86+
}else{
87+
return list.get(1);
9288
}
9389
}
94-
95-
return result;
90+
return list.get(0);
91+
92+
////
93+
//// int maxValue = hashMap.get(list.get(0));
94+
//// int min = list.get(0);
95+
//// int result=min;
96+
////
97+
//// for(int i=1; i<list.size(); ++i){
98+
//// if((hashMap.get(list.get(i)) == maxValue)){
99+
//// if(list.get(i)<min){
100+
//// result = min;
101+
//// min = list.get(i);
102+
//// }
103+
//// else if((list.get(i)> min && list.get(i)<result) || min == result)
104+
//// result = list.get(i);
105+
//// }
106+
//// }
107+
//
108+
// return result;
96109
}
97110

98111
// Value 기준 내림차순 정렬
@@ -104,7 +117,7 @@ static List<Integer> sortByValue(final Map<Integer, Integer> map) {
104117
public int compare(Object o1, Object o2) {
105118
Integer v1 = map.get(o1);
106119
Integer v2 = map.get(o2);
107-
return (v1>v2) ? -1 : ((v1==v2)? 0 : 1 );
120+
return (v1 > v2) ? -1 : ((v1 == v2) ? 0 : 1);
108121
}
109122
});
110123

0 commit comments

Comments
 (0)