Skip to content

Commit

Permalink
array
Browse files Browse the repository at this point in the history
  • Loading branch information
@KimJye
KimJye committed Jul 6, 2019
1 parent 30fc4a2 commit cb04c73
Show file tree
Hide file tree
Showing 4 changed files with 275 additions and 19 deletions.
76 changes: 76 additions & 0 deletions 2019_algorithm/backjoon/src/array/P1158.java
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,76 @@
package array;

/*
* Date: 2019. 07. 02
* Author: KimJye | https://github.com/KimJye
* Solution URL: https://github.com/KimJye/algorithm
* Problem URL : https://www.acmicpc.net/problem/1158
* Title : 조세퍼스 문제
* description : 조세퍼스 문제는 다음과 같다.
1번부터 N번까지 N명의 사람이 원을 이루면서 앉아있고, 양의 정수 K(≤ N)가 주어진다.
이제 순서대로 K번째 사람을 제거한다.
한 사람이 제거되면 남은 사람들로 이루어진 원을 따라 이 과정을 계속해 나간다.
이 과정은 N명의 사람이 모두 제거될 때까지 계속된다.
원에서 사람들이 제거되는 순서를 (N, K)-조세퍼스 순열이라고 한다.
예를 들어 (7, 3)-조세퍼스 순열은 <3, 6, 2, 7, 5, 1, 4>이다.
N과 K가 주어지면 (N, K)-조세퍼스 순열을 구하는 프로그램을 작성하시오.
입력 : 첫째 줄에 N과 K가 빈 칸을 사이에 두고 순서대로 주어진다. (1 ≤ K ≤ N ≤ 5,000)
출력 : 예제와 같이 조세퍼스 순열을 출력한다.
* solution : ArrayList
*/

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

/*
규칙
1 2 3 4 5 6 7
=> (3,2)
1 2 4 5 6 7
=> (6,2+2=4)
1 2 4 5 7
=> (2,4+2=6=>6-(5-1)4-1==1)
1,4,5,7
=> (7,1+2==3)
1,4,5
=> (5,5=>5-2(3-1)-1==2)
1,4
=> (1, 2+2=>4-1(2-1)-1=2(>last.index)=> 2-1(2-1)-1 = 0. (1,0)
4
이것은 index = (index+K-1)%list.size()
*/
public class P1158 {
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());

List<Integer> list = new ArrayList();
for(int i=1; i<=N; ++i){
list.add(i);
}

List<Integer> resultList = new ArrayList<>();
int index=0;

while(N-- >0){
index = (index + K -1) % list.size();
resultList.add(list.remove(index));
}
System.out.println(resultList.toString().replace('[','<').replace(']','>'));

br.close();
}
}
97 changes: 97 additions & 0 deletions 2019_algorithm/backjoon/src/array/P1406.java
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,97 @@
package array;

import java.io.*;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.StringTokenizer;

/*
* Date: 2019. 07. 02
* Author: KimJye | https://github.com/KimJye
* Solution URL: https://github.com/KimJye/algorithm
* Problem URL : https://www.acmicpc.net/problem/1158
* Title : 에디터
* description : 한 줄로 된 간단한 에디터를 구현하려고 한다.
* 이 편집기는 영어 소문자만을 기록할 수 있는 편집기로, 최대 600,000글자까지 입력할 수 있다.
이 편집기에는 '커서'라는 것이 있는데,
커서는 문장의 맨 앞(첫 번째 문자의 왼쪽),
문장의 맨 뒤(마지막 문자의 오른쪽),
또는 문장 중간 임의의 곳(모든 연속된 두 문자 사이)에 위치할 수 있다.
즉 길이가 L인 문자열이 현재 편집기에 입력되어 있으면, 커서가 위치할 수 있는 곳은 L+1가지 경우가 있다.
이 편집기가 지원하는 명령어는 다음과 같다.
L
커서를 왼쪽으로 한 칸 옮김 (커서가 문장의 맨 앞이면 무시됨)
D
커서를 오른쪽으로 한 칸 옮김 (커서가 문장의 맨 뒤이면 무시됨)
B
커서 왼쪽에 있는 문자를 삭제함 (커서가 문장의 맨 앞이면 무시됨)
삭제로 인해 커서는 한 칸 왼쪽으로 이동한 것처럼 나타나지만, 실제로 커서의 오른쪽에 있던 문자는 그대로임
P $
$라는 문자를 커서 왼쪽에 추가함
초기에 편집기에 입력되어 있는 문자열이 주어지고, 그 이후 입력한 명령어가 차례로 주어졌을 때, 모든 명령어를 수행하고 난 후 편집기에 입력되어 있는 문자열을 구하는 프로그램을 작성하시오. 단, 명령어가 수행되기 전에 커서는 문장의 맨 뒤에 위치하고 있다고 한다.
입력 : 첫째 줄에는 초기에 편집기에 입력되어 있는 문자열이 주어진다.
이 문자열은 영어 소문자로만 이루어져 있으며, 길이는 100,000을 넘지 않는다.
둘째 줄에는 입력할 명령어의 개수를 나타내는 정수 N(1≤N≤500,000)이 주어진다.
셋째 줄부터 N개의 줄에 걸쳐 입력할 명령어가 순서대로 주어진다.
명령어는 위의 네 가지 중 하나의 형태로만 주어진다.
출력 : 첫째 줄에 모든 명령어를 수행하고 난 후 편집기에 입력되어 있는 문자열을 출력한다.
* solution : LinkedList,ListIterator
*/
public class P1406 {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

String input = br.readLine();

LinkedList<Character> list = new LinkedList<>();
for (char c : input.toCharArray()) {
list.add(c);
}

ListIterator<Character> iterator = list.listIterator(list.size());

int N = Integer.parseInt(br.readLine());

while (N-- >0) {
StringTokenizer st = new StringTokenizer(br.readLine());
String cmd = st.nextToken();
switch (cmd) {
case "L":
if (iterator.hasPrevious()) {
iterator.previous();
}
break;
case "D":
if (iterator.hasNext()) {
iterator.next();
}
break;
case "B":
if (iterator.hasPrevious()) {
iterator.previous();
iterator.remove();
}
break;
case "P":
iterator.add(st.nextToken().charAt(0));
break;
}
}
for (char c : list) {
bw.write(String.valueOf(c));
}
br.close();
bw.flush();
bw.close();
}
}
70 changes: 70 additions & 0 deletions 2019_algorithm/backjoon/src/array/P5397.java
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,70 @@
package array;

import java.io.*;
import java.util.LinkedList;
import java.util.ListIterator;

/*
* Date: 2019. 07. 06
* Author: KimJye | https://github.com/KimJye
* Solution URL: https://github.com/KimJye/algorithm
* Problem URL : https://www.acmicpc.net/problem/5397
* Title : 키로거
* description : 창영이는 강산이의 비밀번호를 훔치기 위해서 강산이가 사용하는 컴퓨터에 키로거를 설치했다.
* 며칠을 기다린 끝에 창영이는 강산이가 비밀번호 창에 입력하는 글자를 얻어냈다.
키로거는 사용자가 키보드를 누른 명령을 모두 기록한다.
따라서, 강산이가 비밀번호를 입력할 때, 화살표나 백스페이스를 입력해도 정확한 비밀번호를 알아낼 수 있다.
강산이가 비밀번호 창에서 입력한 키가 주어졌을 때, 강산이의 비밀번호를 알아내는 프로그램을 작성하시오.
입력 : 첫째 줄에 테스트 케이스의 개수가 주어진다.
각 테스트 케이스는 한줄로 이루어져 있고, 강산이가 입력한 순서대로 길이가 L인 문자열이 주어진다.
(1 ≤ L의 길이 ≤ 1,000,000) 강산이가 백스페이스를 입력했다면, '-'가 주어진다.
이때 커서의 바로 앞에 글자가 존재한다면, 그 글자를 지운다.
화살표의 입력은 '<'와 '>'로 주어진다.
이때는 커서의 위치를 움직일 수 있다면, 왼쪽 또는 오른쪽으로 1만큼 움직인다.
나머지 문자는 비밀번호의 일부이다. 물론, 나중에 백스페이스를 통해서 지울 수는 있다.
만약 커서의 위치가 줄의 마지막이 아니라면, 그 문자를 입력하고, 커서는 오른쪽으로 한 칸 이동한다.
출력 : 각 테스트 케이스에 대해서, 강산이의 비밀번호를 출력한다. 비밀번호의 길이는 항상 0보다 크다.
* solution : LinkedList, ListIterator
*/
public class P5397 {
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 N = Integer.parseInt(br.readLine());

while(N-- >0){
String input = br.readLine();
LinkedList<Character> list = new LinkedList<>();

ListIterator<Character> iterator = list.listIterator();

for(char c : input.toCharArray()){
switch (c){
case '<' : if(iterator.hasPrevious()) iterator.previous(); break;
case '>' : if(iterator.hasNext()) iterator.next(); break;
case '-' : if(iterator.hasPrevious()){
iterator.previous();
iterator.remove();;
break;
}
default: iterator.add(c);
}
}
for (char c : list) {
bw.write(String.valueOf(c));
}
bw.newLine();
bw.flush();
}
br.close();
bw.flush();
bw.close();
}
}
51 changes: 32 additions & 19 deletions 2019_algorithm/backjoon/src/sort/P2108.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -39,12 +39,12 @@ static int average(int[] a) {
sum += i;
}

double result = (double)sum / a.length;
double result = (double) sum / a.length;

// 음수
if(result<0){
result *=-1;
return (int) (Math.round(result))*-1;
if (result < 0) {
result *= -1;
return (int) (Math.round(result)) * -1;
}

return (int) Math.round(result);
Expand Down Expand Up @@ -77,22 +77,35 @@ static int frequent(int[] a) {
}
// 최빈값 중 두번째로 작은 값 찾기
List<Integer> list = sortByValue(hashMap);
int maxValue = hashMap.get(list.get(0));
int min = list.get(0);
int result=min;

for(int i=1; i<list.size(); ++i){
if((hashMap.get(list.get(i)) == maxValue)){
if(list.get(i)<min){
result = min;
min = list.get(i);
}
else if((list.get(i)> min && list.get(i)<result) || min == result)
result = list.get(i);
for(int i : list){
System.out.print(i +" ");
}
if ((hashMap.get(list.get(0))) == (hashMap.get(list.get(1)))) {
if(list.get(0)>list.get(1)){
return list.get(0);
}else{
return list.get(1);
}
}

return result;
return list.get(0);

////
//// int maxValue = hashMap.get(list.get(0));
//// int min = list.get(0);
//// int result=min;
////
//// for(int i=1; i<list.size(); ++i){
//// if((hashMap.get(list.get(i)) == maxValue)){
//// if(list.get(i)<min){
//// result = min;
//// min = list.get(i);
//// }
//// else if((list.get(i)> min && list.get(i)<result) || min == result)
//// result = list.get(i);
//// }
//// }
//
// return result;
}

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

Expand Down

0 comments on commit cb04c73

Please sign in to comment.