SolB

10988  팰린드롬인지 확인하기

코드

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String word = sc.next();
        if(palindrome(word)) System.out.println("1");
        else System.out.println("0");
    }

    private static boolean palindrome(String word) {
        int length = word.length();
        for (int i = 0; i < length / 2; i++) {
            if (word.charAt(i) != word.charAt(length - i - 1)) {
                return false;
            }
        }
        return true;
    }

}

코드 설명

1. word라는 string 변수를 입력받는다.
2. palindrome함수
   
   • for문으로 i가 0부터 word 길이의 절반까지 반복
     • i번째 문자인 word.charAt(i)와 대칭되는 위치의 문자인 word.charAt(length - i - 1)를 비교한다
   • 비교하는 문자가 다르면 false 반환
   • 그렇지 않으면 true 반환
3. palindrome(word)가 true면 "1" 출력, 그렇지 않으면 "0" 출력

실행 결과

버블 정렬 (Bubble sort)

• 두 인접한 데이터의 크기를 비교해 정렬하는 방법
  • 루프를 돌면서 인접한 데이터 간의 swap 연산으로 정렬한다
• 간단하게 구현이 가능하다
• 시간 복잡도 O(n^2) → 다른 정렬 알고리즘에 비해 속도가 느리다

• 루프 1번 돌 때마다 하나씩 fix(정렬)되는것
  • 루프 1번 돌 때 n번 탐색 * 루프 n번 실행 ⇒ O(n^2)

버블 정렬 과정

1. 비교 연산이 필요한 루프 범위를 설정한다
2. 인접한 데이터 값을 비교한다
3. swap 조건에 부합하면 swap 연산을 수행한다
4. 루프 범위가 끝날 때까지 (2)~(3)을 반복한다
5. 정렬 영역을 설정하고, 다음 루프를 실행할 때는 이 영역을 제외한다
6. 비교 대상이 없을 때까지 (1)~(5)를 반복한다

만약 특정한 루프의 전체 영역에서 swap이 한번도 발생하지 않았다면 그 영역 뒤에 있는 데이터가 모두 정렬됐다는 뜻이므로 프로세스를 종료해도 된다

선택 정렬 (Selection sort)

• 대상 데이터에서 최대나 최소 데이터를 데이터가 나열된 순으로 찾아가며 선택하는 방법
• 구현 방법이 복잡하다
• 시간복잡도도 O(n^2)으로 효율적이지 않아 코딩테스트에서 많이 사용하지 않는다

• min 또는 Max값을 찾고, 남은 정렬 부분의 가장 앞에 있는 데이터와 swap하는 것이 핵심

선택 정렬 과정

1. 남은 정렬 부분에서 최솟값 또는 최댓값을 찾는다
2. 남은 정렬 부분에서 가장 앞에 있는 데이터와 선택된 데이터를 swap한다
3. 가장 앞에 있는 데이터의 위치를 변경해(index++) 남은 정렬 부분의 범위를 축소한다
4. 전체 데이터 크기만큼 index가 커질 때까지, 즉 남은 정렬 부분이 없을 때까지 반복한다

선택 정렬 시간복잡도 구하기

1. 최솟값 찾기 위해 N만큼 탐색 → 1개 정렬 완료
2. 정렬된 것 제외 N-1만큼 탐색
3. 정렬된 것 제외 N-2만큼 탐색

위 과정 N번 반복

⇒ O(N^2)

삽입 정렬 (Insertion Sort)

• 이미 정렬된 데이터 범위에 정렬되지 않은 데이터를 적절한 위치에 삽입시켜 정렬하는 방식
• 시간복잡도는 O(n^2)으로 느린 편이지만 구현이 쉽다

• 선택 데이터를 현재 정렬된 데이터 범위 내에서 적절한 위치에 삽입하는 것이 핵심

삽입 정렬 과정

1. 현재 index에 있는 데이터 값을 선택한다
2. 현재 선택한 데이터가 정렬된 데이터 범위에 삽입될 위치를 탐색한다
3. 삽입 위치부터 index에 있는 위치까지 shift 연산을 수행한다
4. 삽입 위치에 현재 선택한 데이터를 삽입하고 index++연산을 수행한다
5. 전체 데이터의 크기만큼 index가 커질 때까지, 즉 선택할 데이터가 없을 때까지 반복한다

적절한 삽입 위치를 탐색하는 부분에서 이진 탐색 등과 같은 탐색 알고리즘을 사용하면 시간 복잡도를 줄일 수 있다

• 이진 탐색으로 O(N) -> O(logN)으로 줄일 수 있다
• 하지만 shift연산을 수행할 때 시간이 많이 소요된다

퀵 정렬 (Quick Sort)

• 기준값(pivot)을 선정해 해당 값보다 작은 데이터와 큰 데이터로 분류하는 것을 반복해 정렬하는 알고리즘
  • 기준값이 어떻게 선정되는지가 시간복잡도에 많은 영향을 미친다
    • 평균 시간복잡도 : O(nlogn)
    • 최악 시간복잡도 : O(n^2)

pivot을 45로 설정 start는 45보다 큰 값이 나올 때까지 우측으로 이동 end는 45보다 작은 값이 나올 때까지 좌측으로 이동 start와 end의 이동이 모두 멈췄을 때, 각자 가리키는 값을 swap swap의 결과 → 좌측에는 45보다 작은 애들만이, 우측에는 45보다 큰 애들만이 남겨짐 남은 15와 pivot(45)를 비교하여 45보다 작으면 pivot을 15왼쪽에, 크면 오른쪽에 위치시킴 이제 pivot(45)를 기준으로 좌측에는 45보다 작은 집단, 우측에는 45보다 큰 집단으로 나뉘었으므로 각 집단에서 다시 위와 같은 과정을 거친다 좌측 집단에서 15를 pivot으로 선정했다면, 5|32|24|42|15 → 32에서 start, end만남 → 5|15|24|42|32

• pivot을 중심으로 계속 데이터를 2개의 집합으로 나누면서 정렬하는 것이 퀵 정렬의 핵심

퀵 정렬 과정

1. 데이터를 분할하는 pivot을 설정한다
2. pivot을 기준으로 다음 a~e의 과정을 거쳐 데이터를 2개의 집합으로 분리한다
   • (a) start가 가리키는 데이터가 pivot이 가리키는 데이터보다 작으면 start를 오른쪽으로 1칸 이동한다
   • (b) end가 가리키는 데이터가 pivot이 가리키는 데이터보다 크면 end를 왼쪽으로 1칸 이동한다
   • (c) start가 가리키는 데이터가 pivot이 가리키는 데이터보다 크고, end가 가리키는 데이터가 pivot이 가리키는 데이터보다 작으면 start, end가 가리키는 데이터를 swap하고 start는 오른쪽, end는 왼쪽으로 1칸씩 이동한다
   • (d) start와 end가 만날 때까지 (a)~(c)를 반복한다
   • (e) start와 end가 만나면 만난 지점에서 가리키는 데이터와 pivot이 가리키는 데이터를 비교하여 pivot이 가리키는 데이터가 크면 만난 지점의 오른쪽에, 작으면 만난 지점의 왼쪽에 pivot이 가리키는 데이터를 삽입한다
3. 분리 집합에서 각각 다시 pivot을 선정한다
4. 분리 집합이 1개 이하가 될 때까지 과정 (1)~(3)을 반복한다

병합 정렬 (Merge Sort)

• 분할 정복(divide and conquer) 방식을 사용해 데이터를 분할하고 분할한 집합을 정렬하며 합치는 알고리즘
• 시간 복잡도 : O(nlogn)
  • n번의 data access가 있음(투 포인터로 각 그룹을 탐색하므로)& 그 과정을 ${log}_2{n}$만큼 수행(2개씩 병합하니까)
  • ex) 8개의 원소 → 8 * log(2)8 = 24

병합 정렬 과정

처음에 8개(원소의 개수)의 그룹으로나눈다 2개씩 그룹을 합치며 오름차순으로 정렬 (32, 42), (24, 60), (5, 15), (45, 90) 이어서 2개씩 그룹을 합치며 다시 오름차순으로 정렬 (24, 32, 42, 60), (5, 15, 45, 90) 마지막으로 2개씩 그룹을 합치며 다시 오름차순으로 정렬 (5, 15, 24, 32, 42, 45, 60, 90)

병합 정렬은 코딩테스트의 정렬 관련 문제에서 자주 등장한다. 특히 2개의 그룹을 병합하는 원리를 꼭 숙지해야 한다!

2개의 그룹을 병합하는 과정

• 투 포인터 개념을 사용하여 왼쪽, 오른쪽 그룹을 병합한다
• 왼쪽 포인터와 오른쪽 포인터의 값을 비교하여 작은 값을 결과 배열에 추가하고 포인터를 오른쪽으로 1칸 이동시킨다
  • 한쪽 그룹의 모든 숫자가 결과 배열에 추가되었을 경우, 다른 배열의 남은 숫자를 그대로 결과 배열 뒤쪽에 넣어준다
• 이 예제를 버블소트로 해결하려면 swap이 무려 9번이나 일어나게 된다

기수 정렬 (Radix Sort)

• 값을 비교하지 않는 특이한 정렬
• 값을 놓고 비교할 자릿수를 정한 다음 해당 자릿수만 비교한다
• 시간 복잡도 : O(kn)
  • k : 데이터의 자릿수

기수 정렬 과정

• 기수 정렬은 10개의 큐를 이용하며, 각 큐는 값의 자릿수를 대표한다

• 원본 배열 : 16 80 18 77 03 24 88 23

1. 일의 자릿수 기준으로 배열 원소를 큐에 집어넣는다
2. 이후 0번째 큐부터 9번째 큐까지 pop을 진행한다
   • 그 결과 80 03 23 24 16 77 18 88이 만들어진다
3. 이어서 십의 자릿수를 기준으로 같은 과정을 진행한다
4. 마지막 자릿수를 기준으로 정렬할 때까지 앞의 과정을 반복한다

기수 정렬은 시간 복잡도가 가장 짧은 정렬이다. 만약 코딩테스트에서 정렬해야 하는 데이터의 개수가 너무 많으면 기수 정렬을 활용하자.

배열과 리스트

배열

• 배열의 특징
  1. 인덱스를 사용하여 값에 바로 접근할 수 있다
  2. 새로운 값을 삽입하거나 특정 인덱스에 있는 값을 삭제하기 어렵다
     • 값을 삽입하거나 삭제하려면 해당 인덱스 주변에 있는 값을 이동시키는 과정이 필요하다
  3. 배열의 크기는 선언할 때 지정할 수 있으며, 한 번 선언하면 크기를 늘리거나 줄일 수 없다
  4. 구조가 간단하므로 코딩테스트에서 많이 사용한다

값에 바로 접근해야 하거나, 크기를 늘리거나 줄여야하는 상황이 있다면 배열을 사용하자

리스트

리스트는 값과 포인터를 묶은 노드라는 것을 포인터로 연결한 자료구조이다 (JAVA는 ArrayList, LinkedList를 제공)

• 리스트의 특징
  1. 인덱스가 없으므로 값에 접근하려면 Head 포인터로부터 순서대로 접근해야 한다
     • 다시 말해 값에 접근하는 속도가 느리다
  2. 포인터로 연결되어 있으므로 데이터를 삽입하거나 삭제하는 연산 속도가 빠르다
  3. 선언할 때 크기를 별도로 지정하지 않아도 된다
     
     • 다시 말해 리스트의 크기는 정해져 있지 않으며, 크기가 변하기 쉬운 데이터를 다룰 때 적절하다
  4. 포인터를 저장할 공간이 필요하므로 배열보다 구조가 복잡하다

데이터를 삽입하거나 삭제해야 하는 경우, 크기가 변하기 쉬운 데이터를 다루는 경우에는 리스트를 사용하자

구간 합

합 배열을 이용하여 시간복잡도를 더 줄이기 위해 사용하는 특수한 목적의 알고리즘

구간 합의 핵심 이론

합 배열 S 정의

배열 A가 있을 때 합 배열 S는 다음과 같이 정의한다

S[i] = A[0] + A[1] + … + A[i-1] + A[i] // A[0]부터 A[i]까지의 합

• 합 배열은 기존의 배열을 전처리한 배열이라고 생각하면 된다
  • 미리 합 배열을 구해놓으면 기존 배열의 일정 범위의 합을 구하는 시간 복잡도가 O(N) → O(1)로 감소\

• • A[i]부터 A[j]까지의 배열 합을 합 배열 없이 구하는 경우
    • 최악의 경우 ( i가 0이고 j가 N인 경우) ⇒ O(N)
    • 이를 O(1)로 감소시킬 수 있다

합 배열 S를 만드는 공식

S[i] = S[i-1] + A[i]

구간 합을 구하는 공식

S[j] - S[i-1] // i에서 j까지 구간 합

• 다음 그림은 배열 A의 A[2]부터 A[5]까지의 구간 합을 합 배열을 통해 구하는 과정을 보여준다
  • S[5] = A[0] + A[1] + A[2] + A[3] + A[4] + A[5]
  • S[1] = A[0] + A[1]
  • S[5] - S[1] = A[2] + A[3] + A[4] + A[5]

투 포인터

배열이나 리스트와 같은 선형 자료구조에서 두 개의 포인터를 사용하여 원하는 결과를 얻는 알고리즘 기법

투 포인터 이동 원칙

• sum > N : sum = sum - start_index; start_index++;
• sum < N : end_index++; sum = sum + end_index;
• sum == N : end_index++; sum = sum + end_index; count++;

슬라이딩 윈도우

• 2개의 포인터로 범위를 지정한 다음 범위(window)를 유지한 채로 이동(sliding)하며 문제를 해결하는 알고리즘
  
  • 이로 인해 중복 연산을 피하고, 새로운 구간에서 추가적인 계산을 최소화하여 연산량을 줄일 수 있다

스택과 큐

스택

스택은 삽입과 삭제 연산이 후입선출(LIFO; Last In First Out)로 이뤄지는 자료구조이다

• 후입선출은 삽입과 삭제가 한 쪽에서만 일어나는 특징이 있다

• 스택 용어
  
  • top : 삽입과 삭제가 일어나는 위치를 뜻한다
  • push : top 위치에 새로운 데이터를 삽입하는 연산이다
  • pop : top 위치에 현재 있는 데이터를 삭제하고 확인하는 연산이다
  • peek : top 위치에 현재 있는 데이터를 단순 확인하는 연산이다

스택은 깊이우선탐색(DFS), 백트래킹 종류의 코딩테스트에 효과적으로 사용된다

큐

큐는 삽입과 삭제 연산이 선입선출(FIFO; First In First Out)로 이뤄지는 자료구조이다

• 선입선출은 삽입과 삭제가 양쪽에서 일어나는 특징이 있다

• 큐 용어
  • rear : 큐에서 가장 끝 데이터를 가리키는 영역이다
  • front : 큐에서 가장 앞의 데이터를 가리키는 영역이다
  • add : rear 부분에 새로운 데이터를 삽입하는 연산이다
  • poll : front 부분에 있는 데이터를 삭제하고 확인하는 연산이다
  • peek : 큐의 맨 앞(front)에 있는 데이터를 확인할 때 사용하는 연산이다

큐는 너비우선탐색(BFS) 종류의 코딩테스트에 효과적으로 사용된다

import re
arr = []
arr2=[]
while True:
    arr.extend(input().split())
    if arr[-1] == 'E-N-D':
        break
for i in arr:
    arr2.append(re.sub('[^a-z-]','',i.lower()))
print(sorted(arr2, key=lambda x : len(x), reverse=True)[0])

<코드 설명>

문자열들을 split하여 input해주고 이를 arr에 extend해주었다. 

arr의 마지막 원소가 'E-N-D'이면 while문을 break한다.

arr의 원소 중 알파벳(a-z, A-Z)과 하이픈(-) 빼고 제외해주었으며, 결과를 소문자로 출력해주어야 하므로 lower()해주었다. 그리고 이 를 arr2 리스트에 append해주었다.

arr2를 길이를 기준으로 sort해주고, 그 중 가장 첫번 째 원소를 출력해주었다.

<실행 결과>