코드 한 줄

먼저, 본인은 다음과 같은 변수를 선언했다.

private int N;
private boolean tf;
private int cnt;

    while(collatz.tf) {
        collatz.cnt++;

        if(collatz.N % 2 == 0) {
            collatz.N = collatz.N / 2;
            System.out.println("[" + collatz.cnt + "] : " + collatz.N);
        } else {
            collatz.N = (collatz.N * 3) + 1;
            System.out.println("[" + collatz.cnt + "] : " + collatz.N);
        }

        if(collatz.N == 1) {
            collatz.tf = false;
        }
    }

반복문이 돌아갈 때마다 카운트를 증가하며, N에 대하여 짝수일 때, 홀수일 때마다 해당 작업을 하고 과정을 출력한다.

N이 1이 되면 while문을 빠져나오기 위해 tf에 false 값을 넣는다.

import java.util.Scanner;

public class Collatz {

    private int N;
    private boolean tf;
    private int cnt;

    public static void main(String[] args) {
        Collatz collatz = new Collatz();
        Scanner sc = new Scanner(System.in);
        collatz.tf = true;
        collatz.cnt = 0;

        System.out.print("콜라츠 추측 : ");
        collatz.N = sc.nextInt();

        while(collatz.tf) {
            collatz.cnt++;

            if(collatz.N % 2 == 0) {
                collatz.N = collatz.N / 2;
                System.out.println("[" + collatz.cnt + "] : " + collatz.N);
            } else {
                collatz.N = (collatz.N * 3) + 1;
                System.out.println("[" + collatz.cnt + "] : " + collatz.N);
            }

            if(collatz.N == 1) {
                collatz.tf = false;
                System.out.println("");
            }
        }
    }
}

여기서 중요한 것은 나누기 사용이 안된다는 것과 O(n) 시간 복잡도여야 한다는 것이다.

여기 input 예제를 보면

Input a = [a[0], a[1], a[2], a[3], a[4]]
output =
[
a[1]*a[2]*a[3]*a[4],
a[0]*a[2]*a[3]*a[4],
a[0]*a[1]*a[3]*a[4],
a[0]*a[1]*a[2]*a[4],
a[0]*a[1]*a[2]*a[3]
]

int one[N]; int product = 1;
for(int i = 0; i < N; i++) {
    one[i] = product;
    product *= input[i]; 
}
int two[N]; int product = 1;
for(int i = N-1; i >= 0; i--) {
    two[i] = product;
    product *= input[i];
}

int[] one = [ 
1, 
a[0], 
a[0]*a[1], 
a[0]*a[1]*a[2], 
a[0]*a[1]*a[2]*a[3]
]
int[] two = [
a[1]*a[2]*a[3]*a[4], 
a[2]*a[3]*a[4], 
a[3]*a[4],
a[4],
1
]
int[] output = [
a[1]*a[2]*a[3]*a[4], 
a[0]*a[2]*a[3]*a[4], 
a[0]*a[1]*a[3]*a[4],
a[0]*a[1]*a[2]*a[4],
a[0]*a[1]*a[2]*a[3]
]

int output[N]
for(int i = 0; i < N; i++) {
    output[i] = one[i]*two[i];
}

public class CoinChange {

    private int ten;
    private int fifty;
    private int hundred;
    private int fiveHundred;
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        CoinChange cc = new CoinChange();

        System.out.print("거스름돈을 입력하세요 : ");
        int change = sc.nextInt();

        while(change >= 500) {
            change -= 500;
            cc.fiveHundred++;
        }
        while(change >= 100) {
            change -= 100;
            cc.hundred++;
        }
        while(change >= 50) {
            change -= 50;
            cc.fifty++;
        }
        while(change >= 10) {
            change -= 10;
            cc.ten++;
        }

        System.out.println("10원짜리 " + cc.ten + "개");
        System.out.println("50원짜리 " + cc.fifty + "개");
        System.out.println("100원짜리 " + cc.hundred + "개");
        System.out.println("500원짜리 " + cc.fiveHundred + "개");
        System.out.println("총 동전 개수는 " + (cc.ten + cc.fifty + cc.hundred + cc.fiveHundred) + "개 입니다.");
    }
}

(간단한 문제라서 따로 메소드를 사용하진 않았습니다.)

이 문제는 해쉬맵(hashmap)을 써서 A의 문자를 B의 문자 매칭을 저장하면 된다.

A의 문자가 해쉬맵의 키로 있다면, B의 문자와 해쉬맵의 있는 값과 비교한다.

A의 문자가 해쉬맵의 키로 없다면, B의 문자가 해쉬맵의 값으로 있는지 확인하고 없으면 해쉬맵에 더해준다.

bool solve(String a, String b) {
    HashMap<char, char> map = new HashMap<>();
    for (int i = 0; i < a.length(); i++) {
        char c1 = a.charAt(i);
        char c2 = b.charAt(i);
        if (map.containsKey(c1)) {
            if (map.get(c1) != c2) {
                return false;
            }
        }
        else {
            if (map.containsValue(c2)) {
                return false;
            }
            map.put(c1, c2);
        }
    }
    return true;
}

이 문제는 해쉬맵을 사용하여 char와 char의 인덱스를 저장하여 풀면 된다.

string의 각 char를 보면서 해쉬맵에 있다면 substring 시작점을 char의 인덱스+1 로 두면 된다.

그리고 현재 char의 인덱스와 시작점의 거리를 계속 계산하여 가장 큰 값을 리턴하면 된다.

int longestSubstringLength(String s) {
	int ret = 0;
	int start = 0;
	Map<char, int> map = new HashMap<>();
	for (int j = 0; j < s.length(); j++) {
		if (map.containsKey(s[j])) {
			start = Math.max(map.get(s[j]), start);
		}
		ret = Math.max(ret, j - start + 1);
		map.put(s[j], j + 1); // 캐릭터 인덱스 저장
	} 
	return ret;
}

이 문제는 0을 오른쪽으로 옮기는 것보다 0이 아닌 정수를 왼쪽으로 옮긴다고 생각하면 쉽게 풀 수 있다.

void solve(int[] input) {
    int position = 0; // 0이 아닌 정수가 들어갈 곳

    for (int i = 0; i < input.length; i++) {
        if (input[i] != 0) {
            swap(input, i, position);
            position++;
        }
    }
}

void swap(int[] arr, int a, int b) {
    if (a == b) return;
    int temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}