희연's 개발 일기장

String element = word[i];
String reverse = new StringBuilder(element).reverse().toString();

char 자료형 변환

t = Character.toUpperCase(t);
t = Character.toLowerCase(t);

string 자료형 변환

str = str.toUpperCase();
str = str.toLowerCase();

대소문자 확인 

Character.isLowerCase(ch);
Character.isUpperCase(ch);

유클리드 호제법

- 두 다항식의 최대 공약수를 구하는 방법

- 두 양의 정수 a,b(a>b)에 대하여 a = bq + r (0<=r<=b)이면, a,b의 최대 공약수는 b,r의 최대 공약수와 같다.

최대 공약수 : 두 자연수의 공통된 약수 중 가장 큰 수

최대 공배수 : 두 자연수의 공통된 배수 중 가장 작은 수

최대 공약수(GCD) 최대 공배수(LCM) 코드

- while문으로 b가 0이 될때까지 a%b=c

ex. a=72, b=30

GCD(72,30) // 72%30 = 12

-> (b->a, c->b으로 변경해준다.)

-> GCD(30, 12) = 30%12 = 6

-> GCD(12,6) = 0

-> b인 6이 72와 30의 최대 공약수가 된다.

최대 공배수 = 두 수의 곱 / 두 수의 최대공약수

= a * b / GCD(a,b)

ex. GCD(72,30) 에서 최대공약수는 6 이다.

-> 72*30 / 6 = 360

72와 30의 최대 공배수는 360

class Solution {
    public int[] solution(int n, int m) {
        int[] answer = new int[2];

        answer[0] = GCD(n,m);
        answer[1] = lcm(n,m);
        return answer;
    }

    public static int GCD(int a, int b){ // 최대 공약수
        while(b!=0){
            int c = a%b;
            a=b;
            b=c;
        }
        return a;
    }

    public static int lcm(int a, int b){ // 최대 공배수
        return a*b / GCD(a,b);
    }
}

for(int i=0; i<board.length; i++){
    sum1=sum2=0;
    for(int j=0; j<board.length; j++){
        sum1 += board[i][j]; // 행의 합
        sum2 += board[j][i]; // 열의 합
    }
    answer = Math.max(answer, sum1);
    answer = Math.max(answer, sum2);
}

sum1=sum2=0;

// 대각선의 합 
for(int i=0; i<board.length; i++){
    sum1 += board[i][i];
    sum2 += board[i][board.length-i-1];
}

정수를 한자리씩 쪼개는 방법

- 10으로 나눠서 나머지를 구한다.

- answer에 10을 곱해줘서 자리를 앞으로 옮겨주고 구한 나머지를 더해준다. (첫번째 값의 경우 0 X 10 + 나머지) 

- 10으로 나눠서 몫을 구한다.

- 남은 몫이 0이 될때까지 앞의 과정을 반복한다. 

1230%10 = 0 -> 1230/10 = 123
123%10 = 3 -> 123/10 = 12
12%10 = 2 -> 12/10 = 1
1%10 = 1 -> 1/10 = 0

예시 코드

for(int i=0; i<arr.length; i++) {
    int temp = arr[i];
    int answer = 0;
    while (temp > 0) {
        int element = temp % 10;
        answer = answer * 10 + element;
        temp = temp / 10;
    }
}

에라토스테네스의 체

- 특정 범위 내의 소수를 찾을 때 사용하는 방법이다.

1. 1부터 N까지의 배열을 만든다. -> ex. int[] arr = {0,0,0,0,0,0,.....};

2. 소수가 아닌 1은 제거한다.

3. N까지 반복문을 돌려주면서 int[i] = 0인 값들에서 count++ 해준다.

- 2에서 count++; 

- 2의 배수는 모두 값을 1로 바꿔준다.

- 3에서 count++;

- 3의 배수는 모두 값을 1로 바꿔준다.

- 4의 배수는 2의 배수를 1로 바꿔주는 과정에서 바뀌었기 때문에 넘어간다.

....

- 마지막에 count를 출력해주면 그 값이 1부터 N까지의 소수 개수

에라토스테네스 체 사용

public static int solution(int n){
    int count = 0;
    int[] check = new int[n+1];

    for(int i=2; i<=n; i++){
        if(check[i]==0){
            count++;
            // i의 (j+i)배수들을 체크해준다.
            for(int j=i; j<=n; j=j+i){
                check[j] = 1;
            }
        }
    }

    return count;
}

소수 판별 코드

public static boolean isPrime(int num){
    if(num==1) return false; // 1은 소수가 아니다.
    for(int i=2; i<num; i++){
        if(num%i==0){ // i는 num의 약수가 된다.
            return false;
        }
    }
    return true;
}

Arrays.sort()

- 배열을 정렬할 때 사용한다.

- DualPivotQuicksort 사용

- 평균 O(nlogn)

- 최악 O(n^2)

Collections.sort()

- 리스트를 정렬할 때 사용한다.

- Timesort 사용 : 삽입 정렬 + 합병 정렬

- 평균 O(nlogn)

- 최악 O(nlogn)

1차원 배열 정렬

문자열 배열

- 오름차순 정렬

Arrays.sort(arr);
Collections.sort(list);

- 내림차순 정렬 : 정렬 후에 반대로 뒤집어 준다.

Arrays.sort(arr, Comparator.reverseOrder());
Collections.sort(list, Collections.reverseOrder());

정수형 배열

- Object이 아닌 primitive타입 자료형 이기 때문에 Comparator를 사용해 정렬 불가능
- 오름차순 정렬 -> 뒤집기

// 오름차순 정렬
Arrays.sort(arr); 

// 내림차순 정렬
Arrays.sort(arr); // 오름차순 정렬 후
for(int i=0; i<arr.length/2; i++){ // 순서를 뒤집어준다.
    int temp = arr[i];
    arr[i] = arr[arr.length-i-1];
    arr[arr.length-i-1] = temp;
}

- 리스트 : Collections.sort() 사용

Collections.sort(list);
Collections.sort(list, Collections.reverseOrder());

2차원 배열

// 첫번째 원소 오름차순
Arrays.sort(arr, (o1, o2)->{
    return o1[0]-o2[0];
});

// 첫번째 원소 내림차순
Arrays.sort(arr, (o2, o1)->{
    return o1[0]-o2[0];
});

// 두번째 원소 오름차순
Arrays.sort(arr, (o1, o2)->{
    return o1[1]-o2[1];
});

// 두번째 원소 내림차순
Arrays.sort(arr, (o2, o1)->{
    return o1[1]-o2[1];
});

CompareTo - 정렬에 조건 넣기

class Point implements Comparable<Point>{
    public int x, y;
    Point(int x, int y){
        this.x=x;
        this.y=y;
    }
    @Override
    public int compareTo(Point o){
        if(this.x==o.x){ // x 값이 같을 경우
            return this.y-o.y;
        } else {
            return this.x - o.x;
        }
    }
}

CompareTo - 씨름선수

키와 몸무게 모두 높은 지원자가 존재하면 해당 지원자는 탈락

키를 먼저 내림차순으로 정렬해주고 몸무게를 비교한다.

class Body implements Comparable<Body>{
    public int h, w;
    Body(int h, int w){
        this.h = h;
        this.w = w;
    }
    @Override
    public int compareTo(Body o){ // h 내림차순
        return o.h-this.h;
    }
}
public class Solution {
    public static int solution(ArrayList<Body> arr, int n){
        int answer = 0;

        Collections.sort(arr); // 내림차순
        int max = Integer.MIN_VALUE;
        for(Body ob : arr){
            if(ob.w>max){
                max = ob.w;
                answer++;
            }
        }

        return answer;
    }
    public static void main(String[] args) {
        Solution T = new Solution();
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        ArrayList<Body> arr = new ArrayList<>();
        for(int i=0; i<n; i++){
            int height = sc.nextInt();
            int weight = sc.nextInt();
            arr.add(new Body(height, weight));
        }
        System.out.println(T.solution(arr, n));
    }
}

- 1개의 회의실에서 n개의 회의를 할 때

- 시간이 겹치지 않게 최대 수의 회의 찾기

- 시작 시간과 끝나는 시간이 주어진다.

- 끝나는 시간을 오름차순 해준다.

- 끝나는 시간이 같으면 시간순으로 오름차순한다.

class Time implements Comparable<Time> {
    public int s, e; // 시작시간, 끝나는시간
    Time(int s, int e){
        this.s = s;
        this.e = e;
    }
    @Override
    public int compareTo(Time o){
        if(this.e==o.e){ // 끝나는시간이 같으면 시간순으로 오름차순
            return this.s-o.s; // 오름차순
        } else {
            return this.e-o.e;
        }
    }
}
public class Solution {
    public int solution(ArrayList<Time> arr, int n){
        int count=0;

        Collections.sort(arr);
        int et = 0;
        for(Time ob : arr){
            if(ob.s>=et){
                count++;
                et = ob.e;
            }
        }
        return count;
    }

    public static void main(String[] args) {
        Solution T = new Solution();
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        ArrayList<Time> arr = new ArrayList<>();
        for(int i=0; i<n; i++){
            int meet = sc.nextInt();
            int room = sc.nextInt();
            arr.add(new Time(meet, room));
        }
        System.out.println(T.solution(arr, n));
    }
}

- next(), nextLine()은 둘 다 Scanner 클래스의 method

공통점

- 둘 다 문자열로 반환 시켜준다.

차이점

- next() : 공백(space) 전까지 입력받은 문자열을 반환한다.

- nextLine() : Enter를 치기 전까지의 모든 문자열을 반환한다.