반응형
ㅇ주요문법들
1. 정렬
// int[] -> Integer[] -> int[]
Integer[] arr3 = Arrays.stream(test).boxed().toArray(Integer[]::new);
int[] z = Arrays.stream(i).mapToInt(Integer::intValue).toArray();
Arrays.sort(jobs, (o1, o2) -> o1[0] - o2[0]); // Int 배열 오름차순
Arrays.sort(jobs, (o1, o2) -> o1[1].compareTo(o2[1])); // String 배열 오름차순
Collections.sort(arr, new Comparator<String>() {
public int compare(String o1, String o2) {
return (o2+o1).compareTo(o1+o2) ; // 3, 30인 경우 303/330 비교를 위해 문자를 붙여서 비교를 한다.
}
});
static class Node implements Comparable<Node> {
public int compareTo(Node o) {
return this.dist - o.dist; // 오름차순 (내림차순은 o.dist - this.dist
}
}
2. Map
HashMap<Integer, Integer> xSet = new HashMap<>();
xSet.put(1, 2);
xSet.get(1);
xSet.getOrDefault(key, defaultValue); // 없으면 기본값을 리턴
// Map 출력
for(Map.Entry<Integer, Integer> entry : xSet.entrySet()) {
System.out.println(entry + " " + entry.getKey() + " " + entry.getValue());
}
HashSet<Integer>[] dp = new HashSet[9];
Iterator<Integer> listA = dp[a].iterator();
while(listA.hasNext()) {
int numA = listA.next();
}
3. Stack, Queue
Stack<Character> stack = new Stack<>();
stack.push(1); // 끝에 넣기
stack.push(2); // 끝에 넣기
stack.add(0, 3); // 앞에 넣기
int a = stack.firstElement(); // 앞에조회
int b = stack.peek(); // 끝에 조회
int c = stack.remove(0); // 앞에 꺼내기
int d = stack.pop(); // 끝에 꺼내기
System.out.println(stack.contains(2)); // 존재여부
// Queue는 끝에꺼를 꺼낼 수 없다!!
PriorityQueue<Node> pq = new PriorityQueue<>();
pq.offer(value);
Node node = pq.poll();
// PQ는 기본적으로 정수형은 오름차순으로 정렬해 준다.
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
System.out.println(pq.poll()); // 앞에 꺼내기
System.out.println(pq.contains(1)); // 존재여부
System.out.println(pq.peek()); // 앞에 조회
System.out.println(pq.remove(20)); // 제거 및 boolean 결과(값으로 처리)
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(Collections.reverseOrder());
=======================================================================================================
ㅇArray, List 정렬
// Integer[] -> int[]
Integer[] i = {3,2,1};
int[] z = Arrays.stream(i).mapToInt(Integer::intValue).toArray();
// int[] -> Integer[] (int 타입 배열을 Arrays.sort 리버스 하려면 변환해야 한다)
int[] test = {1,5,2,3};
Integer[] arr3 = Arrays.stream(test).boxed().toArray(Integer[]::new);
System.out.println(Arrays.toString(i));
System.out.println(Arrays.toString(z));
Arrays.sort(arr);
// 내림차순은 문자열 밖에 안 된다.
Arrays.sort(arr, Collections.reverseOrder());
// 숫자 int 배열을 내림차순 정렬해서 int 배열로 반환하기
int[] test = {1,5,2,3};
Integer[] arr3 = Arrays.stream(test).boxed().toArray(Integer[]::new);
Arrays.sort(arr3, Collections.reverseOrder());
test = Arrays.stream(arr3).mapToInt(Integer::intValue).toArray();
System.out.println(Arrays.toString(arr3));
// 2차원 배열 정렬
int[][] jobs = {{2,3}, {4,5}};
Arrays.sort(jobs, (o1, o2) -> o1[0] - o2[0]);
for(int i = 0 ; i < jobs.length ; i++) {
for(int x = 0 ; x < jobs.length ; x++) {
System.out.println(jobs[i][x]);
}
}
int[] numbers = {0, 0, 0};
ArrayList<String> arr = new ArrayList<>();
for(int i : numbers) {
arr.add(String.valueOf(i));
}
Collections.sort(arr, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return (o2+o1).compareTo(o1+o2) ; // 3, 30인 경우 303/330 비교를 위해 문자를 붙여서 비교를 한다.
}
});
---------------------------------------------------------------------------------------------------------
// 이차원 배열은 comparator 로 처리가 안 된다. 람다식으로 가야 한다.
// 숫자 처리(타입에 따라서 다르게 써야 한다.)
int[][] jobs = {{0,3}, {1,9}, {2,6}};
Arrays.sort(jobs, (o1, o2) -> o1[0] - o2[0]); // 오름차순
// 문자 처리(타입에 따라서 다르게 써야 한다. int 안 되고 Integer 만 된다)
String[][] jobs = {{"0","3"}, {"1","9"}, {"2","6"}};
Arrays.sort(jobs, (o1, o2) -> o1[1].compareTo(o2[1]));
for(int[] i : jobs) {
System.out.println(Arrays.toString(i));
}
String[] phone_book = {"119", "89798", "1195522"};
Arrays.sort(phone_book);
---------------------------------------------------------------------------------------------------------
ArrayList<Mnode> mList = new ArrayList<>();
HashMap<String, Integer> genMap = new HashMap<>();
Collections.sort(mList, new Comparator<Mnode>() {
@Override
public int compare(Mnode o1, Mnode o2) {
if(o1.gen.equals(o2.gen)) {
return o2.playCnt - o1.playCnt; // 같은 장르는 플레이횟수로 내림차순
} else {
return genMap.get(o2.gen) - genMap.get(o1.gen); // 다른 장르는 플레이 횟수로 내림차순
}
}
});
---------------------------------------------------------------------------------------------------------
문자열 정렬
String[] list = {"1","100", "111", "2", "202"};
// Array 도 Comparator 를 쓸 수가 있다.
Arrays.sort(list, new Comparator<String>() {
public int compare(String s1, String s2) {
if(s1.length() == s2.length()) {
return (s1+s2).compareTo(s2+s1);
} else {
return s1.length() - s2.length();
}
}
});
System.out.println(Arrays.toString(list));
// Array to List
ArrayList<String> listArr = new ArrayList<>(Arrays.asList(list));
Collections.sort(listArr, new Comparator<String>() {
public int compare(String s1, String s2) {
if(s1.length() == s2.length()) {
return (s1+s2).compareTo(s2+s1);
} else {
return s1.length() - s2.length();
}
}
});
System.out.println(listArr);
// List to Array (Ineger 는 이렇게 처리가 안 된다. JAVA8은 되지만..
list = listArr.toArray(new String[listArr.size()]);
System.out.println(Arrays.toString(list));
ㅇ순열
String numbers = "011";
int answer = 0 ;
HashSet<Integer> set = new HashSet<>();
permutation("", numbers, set);
private static void permutation(String prefix, String num, HashSet<Integer> set) {
int n = num.length();
if(prefix.equals("") == false) {
set.add(Integer.valueOf(prefix));
}
for(int i = 0 ; i < n ; i++) {
// 타겟숫자와 나머지 숫자를 넘겨서 중복되지 않는다.
permutation(prefix + num.charAt(i), num.substring(0, i) + num.substring(i + 1, n), set);
}
}
ㅇMap
HashMap<Integer, Integer> xSet = new HashMap<>();
xSet.put(getX, 2);
xSet.get(getX)
xSet.getOrDefault(key, defaultValue); // 없으면 기본값을 리턴한다.
// Map 출력
for(Map.Entry<Integer, Integer> entry : xSet.entrySet()) {
System.out.println(entry);
}
// 입력하면 키값으로 정렬이 되는 맵
TreeMap<Integer, Integer> trMap = new TreeMap<>();
// 맵에 기존에 값이 없으면 기본값 넣기
hs.getOrDefault(key, defaultValue)
ㅇStack, Queue
Stack<Integer> stack = new Stack<>();
if (stack.isEmpty()) System.out.println("empty");
stack.push(1); // 끝에 넣기
stack.push(2); // 끝에 넣기
stack.add(0, 3); // 앞에 넣기
System.out.println(stack);
int a = stack.firstElement(); // 앞에조회
System.out.println(a);
int b = stack.peek(); // 끝에 조회
System.out.println(b);
int c = stack.remove(0); // 앞에 꺼내기
System.out.println(c);
int d = stack.pop(); // 끝에 꺼내기
System.out.println(d);
System.out.println(stack.contains(2)); // 존재여부
PriorityQueue<Node> canGo = new PriorityQueue<>();
canGo.offer(tickets[i][1]);
// PQ는 기본적으로 정수형은 오름차순으로 정렬해 준다.
PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.offer(3);pq.offer(1);pq.offer(2);pq.offer(5);pq.offer(20);
System.out.println(pq);
System.out.println(pq.poll()); // 앞에 꺼내기
System.out.println(pq.contains(1)); // 존재여부
System.out.println(pq.peek()); // 앞에 조회
System.out.println(pq.remove(20)); // 제거 결과(값으로 처리)
System.out.println(pq);
// PQ를 역순으로 정렬할 경우
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(Collections.reverseOrder());
static class Node implements Comparable<Node> {
int idx;
int dist;
Node(int i, int d){
this.idx = i;
this.dist = d;
}
// comparator 의 compare 는 처음 넣을 때 큐가 비어 있을 대 오류가 발생한다.
// comparable 의 compareTo는 상관 없더라.
public int compareTo(Node o) {
return this.dist - o.dist; // 오름차순
}
}
ㅇDFS, BFS
ㅇDP
static HashSet<Integer>[] dp = new HashSet[9];
public static int solution(int N, int number) {
if(N==number) {
return 1;
}
String n_ = String.valueOf(N);
for(int i=0;i<=8;i++) {
dp[i] = new HashSet<Integer>();
if(i==1) dp[1].add(Integer.parseInt(n_));
if(i<2 ) continue;
//ex ) dp[3]에 NNN이 들어갈 수 있도록 지정
n_+=String.valueOf(N);
dp[i].add(Integer.parseInt(n_));
for(int j=1;j<i;j++) {
calc(j,i);
//찾으려는 number가 만들어졌을 경우 바로 리턴
if(dp[i].contains(number)) {
return i;
}
}
}
return -1;
}
//각각 N의 개수마다 사칙연산을 해서 배열에 담아줌
static void calc(int a,int b) {
Iterator<Integer> listA = dp[a].iterator();
Iterator<Integer> listB = dp[b-a].iterator();
while(listA.hasNext()) {
int numA = listA.next();
while(listB.hasNext()) {
int numB = listB.next();
dp[b].add(numA+numB);
dp[b].add(numA-numB);
dp[b].add(numA*numB);
if(numB!=0)
dp[b].add(numA/numB);
}
listB = dp[b-a].iterator();
}
}
ㅇ최단경로 다익스트라
static class Node implements Comparable<Node>{
int index;
int dist;
Node(int i, int d) {
this.index = i;
this.dist = d;
}
public int compareTo(Node o) {
return this.dist - o.dist;
}
}
public static void main(String[] args) {
int nodeCnt;
int start = 1;
int[][] paths = {{1, 2, 8}, {1, 3, 2}, {3, 2, 1}, {3, 5, 3}, {6, 7, 3}};
ArrayList<ArrayList<Node>> ways = new ArrayList<ArrayList<Node>>();
// 동적으로 경로배열 만들기. 복잡하다.. (양방향은 의미 없음)
// 쉽게 가려면 그냥 노드 갯수만큼 미리 다 만들면 된다.
// for(int i = 0 ; i <= nodeCnt ; i++) {
// ways.add(new ArrayList<Node>());
// }
for(int i = 0 ; i < paths.length ; i++) {
int s = paths[i][0];
int e = paths[i][1];
int d = paths[i][2];
if(ways.size() < e) {
for(int x = 0 ; x <= e - ways.size() + 1; x++) {
ways.add(new ArrayList<Node>());
}
}
ways.get(s).add(new Node(e, d));
}
nodeCnt = ways.size();
// 시작지점에서 각 노드까지의 최단거리를 저장하는 배열
int[] distArr = new int[nodeCnt + 1];
Arrays.fill(distArr, Integer.MAX_VALUE);
// 최단거리 순서로 처리하는 큐
PriorityQueue<Node> pq = new PriorityQueue<Node>();
pq.offer(new Node(start, 0));
distArr[start] = 0;
HashSet<Integer> visitCity = new HashSet<Integer>();
while(pq.isEmpty() == false) {
Node curNode = pq.poll();
int curIdx = curNode.index;
int curDist = curNode.dist;
visitCity.add(curIdx);
if(distArr[curIdx] < curDist) continue;
for(int i = 0 ; i < ways.get(curIdx).size() ; i++) {
Node nextNode = ways.get(curIdx).get(i);
int nextIndex = nextNode.index;
int cost = distArr[curIdx] + nextNode.dist;
if(cost < distArr[nextNode.index]) {
pq.offer(new Node(nextIndex, cost));
distArr[nextIndex] = cost;
}
}
Iterator<Node> itr = pq.iterator();
while(itr.hasNext()) {
Node nd = itr.next();
System.out.print(nd.index + "(" + nd.dist + "), ");
}
System.out.println();
}
int maxTime = 0;
for(int i : distArr) {
if(i != Integer.MAX_VALUE) {
maxTime = Math.max(maxTime, i);
}
}
System.out.println(Arrays.toString(distArr));
System.out.println((visitCity.size() - 1) + " " + maxTime);
}
ㅇ연결된것들 그룹으로 분류하기(최상위 부모 찾기)
// 부모-자식 관계 배열
int[] astr = new int[n];
Arrays.fill(astr, -1);
// 부모-자식관계 만들기(연결된건 그룹으로 묶는다)
for(int i = 0 ; i < astronaut.length ; i++) {
int pa = astronaut[i][0];
int ch = astronaut[i][1];
if (astr[pa] == -1) {
astr[pa] = pa; // 최초면 자기자신을 부모로 선정
}
if (astr[ch] == -1) {
astr[ch] = ch; // 최초면 자기자신을 부모로 선정
}
int updP = astr[ch]; // 이전 자식의 부모값(자기가 부모인 경우 갱신위해 보관)
astr[ch] = astr[pa]; // 현재 자식의 부모값 갱신
for(int x = 0 ; x < n ; x++) {
if(astr[x] == updP) {
astr[x] = astr[pa]; // 이전 자식의 부모값을 현재 자식의 부모값으로 갱신
}
}
}
System.out.println(Arrays.toString(astr));
HashMap<Integer, Integer> gm = new HashMap<>();
for(int i = 0 ; i < astr.length ; i++)
if(astr[i] == -1) { // 연결 안 되고 독립된 것들
gm.put(i, 1);
} else { // 하나의 부모로 연결된 것들
int cnt = gm.getOrDefault(astr[i], 0);
cnt++;
gm.put(astr[i], cnt);
}
}
ㅇ대용량 자리수
BigInteger bi = BigInteger.ONE;
BigInteger bi = BigInteger.ZERO;
for(int i = 0 ; i < 25 ; i++) {
bi = bi.multiply(BigInteger.valueOf(i + 1));
}
bi.add(BigInteger.valueOf(3));
bi.subtract(BigInteger.valueOf(4));
bi.multiply(BigInteger.valueOf(5));
System.out.println(bi);
ㅇ피보나치
public static void main(String[] args) {
// 1 1 2 3 5 8 13 21 34
int target = 8;
int[] piboArr = new int[2];
for(int i = 1 ; i <= target ; i++) {
if(i < 2) {
piboArr[piboArr.length - i] = i;
System.out.print(piboArr[piboArr.length - i] + " ");
continue;
}
int sum = piboArr[0] + piboArr[1];
piboArr[0] = piboArr[1];
piboArr[1] = sum;
System.out.print(piboArr[1] + " ");
}
System.out.println();
for(int i = 1 ; i <= target ; i++) {
System.out.print(fibo(i) + " ");
}
}
static int fibo(int get) {
if(get < 2) return get;
return fibo(get - 2) + fibo(get - 1);
}package com.kei;
public class StringFormats {
public static void main(String[] args) {
double a = 0.1234567;
System.out.printf("%.4f\n", a); // 소수점 4자리까지 출력
String b = "#";
System.out.printf("%5s\n", b); // 앞에 공백 5개 추가
System.out.printf("%-5s\n", b); // 뒤에 공백 5개 추가
System.out.printf("%10d\n", 3); // 총 10자리, 숫자외에는 공백으로 좌측 채우기
System.out.printf("%05d\n", 3); // 총 5자리, 숫자외에는 0으로 좌측 채우기
}
}
반응형
댓글