코드 한 줄

from bs4 import BeautifulSoup
from selenium import webdriver

""" 네이버 로그인 웹 크롤링 """

# 위치 지정
driver = webdriver.Chrome("(~저장경로)/chromedriver")

# 웹 자원 로드를 위해 암묵적으로 딜레이
delay_time = 3
driver.implicitly_wait(delay_time)

# URL 접근
driver.get('https://nid.naver.com/nidlogin.login')

# ID, PW 입력
id = "본인_네이버_아이디"
pw = "본인_네이버_패스워드"
driver.find_element_by_name('id').send_keys(id)
driver.find_element_by_name('pw').send_keys(pw)

# 로그인 버튼 클릭
driver.find_element_by_xpath('//*[@id="frmNIDLogin"]/fieldset/input').click()

""" 로그인 후 실시간 검색어 추출 """

driver.get("https://www.naver.com")

html = driver.page_source
soup = BeautifulSoup(html, 'html.parser')

realtime_search_word = soup.select('div.ah_roll_area > ul.ah_l > li > a > span.ah_k')
for list in realtime_search_word:
    print(list.text.strip())

# 드라이버 종료
driver.close()

이 문제는 두 개의 포인터를 쓰면 쉽게 풀린다.

첫 번째 포인터를 먼저 N만큼 보낸다.

그리고 첫 번째 포인터와 두 번째 포인터를 동시에 하나씩 움직인다.

첫 번째 포인터의 다음 노드가 null의 값을 가지게 되면, 두 번째 포인터의 다음 노드는 끝에서 N 번째 노드가 된다.

그 노드를 제거 한 뒤 머리 노드를 리턴하면 된다.

중요한 엣지 케이스는, 첫 번째 노드를 N 번째 옮긴 후 노드의 값이 null이라면 끝에서 N 번째 노드는 첫 번째 노드임으로 헤드를 업데이트 한 후 리턴해준다.

Node solution(Node head, int n) {
    if (head == null) {
        return null;
    }
    Node first = head;
    Node second = head;
    for (int i = 0; i < n; i++) {
        first = first.next;
    }
    if (first == null) {
        head = head.next;
        return head;
    }
    while (first.next != null) {
        first = first.next;
        second = second.next;
    }
    second.next = second.next.next;
    return head;
}

이 문제는 가장 긴 공통된 접두사가 첫 단어라고 가정하고, 각 문자마다 모든 단어에 비교한다.

비교하는 방식은 단어의 같은 위치에 문자가 있는지 확인한다.

만약 문자가 다르거나, 문자가 없으면 현재의 문자 위치까지만 공통된 접두사이다.

int longestPrefixLength(String[] arr) {
    if (arr.length == 0) {
        return 0;
    }
    String max_prefix = arr[0];
    for (int i = 0; i < max_prefix.length(); i++) {
        char c = max_prefix.charAt(i);
        for (int j = 1; j < arr.length; j++) {
            if (i == arr[j].length() || arr[j].charAt(i) != c) {
                return i;  
            }
        }
    }
    return max_prefix.length();
}

이 문제는 “Quick Select”의 알고리즘을 사용하는 대표적인 문제이다.

Quick select는 퀵 정렬(quick sort)를 이용하는 알고리즘이다.

퀵 정렬의 pivot을 정하고 1차 정렬을 하면 pivot의 원소 위치는 최종 정렬된 배열의 위치가 된다.

이것을 이용하여 모든 배열을 정렬 하지 않고, pivot의 값을 비교하여, 찾는 값에 따라 pivot의 왼쪽이나 오른쪽만 정렬하는 알고리즘이다.

int quickselect(int[] arr, int k) {
    return quickselect(arr, 0, arr.length - 1, k - 1);
}

int quickselect(int[] arr, int first, int last, int k) {
    if (first <= last) {
        int pivot = partition(arr, first, last);
        if (pivot == k) {
            return arr[k];
        }
        if (pivot > k) {
            return quickselect(arr, first, pivot - 1, k);
        }
        return quickselect(arr, pivot + 1, last, k);
    }
    return Integer.MIN_VALUE;
}

int partition(int[] arr, int first, int last) {
    int pivot_spot = first;
    for (int i = first; i < last; i++) {
        if (arr[i] > arr[last]) {
            swap(arr, i, pivot_spot);
            pivot_spot++;
        }
    }
    swap(arr, pivot_spot, last);
    return pivot_spot;
}

void swap(int[] arr, int x, int y) {
    int tmp = arr[x];
    arr[x] = arr[y];
    arr[y] = tmp;
}

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

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;
}