희연's 개발 일기장

https://www.acmicpc.net/problem/15904

문제 풀이

- 문자열을 축약해서 UCPC를 만들 수 있는지 확인하기

- 대소문자 구분

- 문자열 시작부터 U가 오는 것이 아니라 문자열 내부에 UCPC 있는지 확인하기

- .(모든문자) *(0부터 반복) 을 사용해서 문자열에 순서대로 UCPC 확인

import re

word = input()
p = re.compile('.*U.*C.*P.*C.*')
m = p.match(word)

if m:
    print("I love UCPC")
else:
    print("I hate UCPC")

https://www.acmicpc.net/problem/17413

문제 풀이

- < > 괄호 안에 단어가 있는 경우 또는 나머지 단어들을 표현하는 패턴 생성

- 괄호가 있는 단어는 그대로 결과 값에 넣어주고

- 괄호가 없는 단어들은 문자열로 만들어주고 뒤집어주기

import re

S = input()
p = re.compile('<[a-z0-9 ]+>|[a-z0-9 ]')
m = p.findall(S)

result = ''
stack = ''
idx = 1

for word in m:
    if word[0] == '<':
        result += stack[::-1]
        result += word
        stack = ''
    else:
        if word == ' ':
            result += stack[::-1] + ' '
            stack = ''
        elif idx == len(m):
            stack += word
            result += stack[::-1]
            stack = ''
        else:
            stack += word
    idx += 1

print(result)

https://www.acmicpc.net/problem/23303

백준 풀이

- 문자열 안에 D2나 d2가 있으면 D2출력, 아니면 unrated 출력

- | = or을 사용해서 D2 or d2

import re
p = re.compile('D2|d2')
word = input()
m = p.search(word)

if m:
    print('D2')
else:
    print('unrated')

https://www.acmicpc.net/problem/23627

백준 풀이

- driip 으로 끝나는 문자열 찾기

- 정규 표현식 중에 $는 마지막 문자가 앞의 문자가 와야 매치된다. 

- match와 search의 차이 : match는 첫 번째 부터 시작하고 search 는 전체에서 패턴을 찾는다.

import re
p = re.compile('driip$')
word = input()

m = p.search(word)

if m:
    print('cute')
else:
    print('not cute')

https://www.acmicpc.net/problem/1264

백준 풀이

- 정규표현식 패턴을 만드는 re 모듈을 사용

- 모음을 확인하는 컴파일 패턴 만들기

- 정규식과 매치되는 모든 문자열을 리스트로 반환해서 

- 리스트의 길이 = 모음의 개수를 구한다.

import re
p = re.compile('[aeiouAEIOU]')

while True:
    sentence = input()
    if sentence == '#':
        break

    m = p.findall(sentence)
    print(len(m))

https://www.hackerrank.com/challenges/big-sorting/problem?isFullScreen=true 

기존 풀이 방법

• String -> int 
• int -> String 하는 과정에서 시간초과로 실패 

    public static List<String> bigSorting(List<String> unsorted) {
        List<BigInteger> sorted = unsorted.stream()
                .map(BigInteger::new).sorted().collect(Collectors.toList());
        Collections.sort(sorted);
        List<String> answer = sorted.stream()
                .map(String::valueOf)
                .collect(Collectors.toList());
        return answer;
    }

새로운 풀이 방법

• compareTo를 통해서 자릿수를 비교해가면서 오름차순 정렬

    public static List<String> bigSorting(List<String> unsorted) {
        Collections.sort(unsorted, (x, y) -> {
            if(x.length() == y.length()){
                return x.compareTo(y);
            } else {
                return x.length() - y.length();
            }
        });
        return unsorted;
    }

import re
def solution(new_id):
    # 아이디 제한 - 3~15길이, 소문자 숫자 - _ . 문자 사용 가능, 마침표(.)는 처음과 끝, 연속 사용 불가능
    answer = ''

    # 1번 : 대문자 -> 소문자
    one = new_id.lower()
    
    # 2번 : 소문자, 숫자, -, _, . 제외 문자 제거
    condition = '[^a-z0-9-_.]'
    two = re.sub(condition, '', one)
    
    # 3번 : .. -> .
    three = two
    while True:
        if '..' in three:
            three = three.replace('..', '.')
        else:
            break
    
    # 4번 : 첫 번째 or 마지막에 . 제거
    four = three
    if three[0] == '.':
        four = four[1:]
    if three[-1] =='.':
        four = four[:-1]

    # 5번 : 빈 문자열은 a 입력
    five = four
    if len(four)==0:
        five = 'a'
    
    # 6번 : 문자열 길이가 16이상이면, 앞의 15개 제외 뒤에 제거
    six = five
    if len(five)>=16:
        six = five[:15]
        # 맨 뒤에 . 있으면 제거
        if six[-1] == '.':
            six = six[:-1]
    
    # 7번 : 문자열 길이가 2 이하면, 문자열의 마지막 문자를 길이가 3이 될 때까지 붙이기
    seven = six
    if len(six)<=2:
        while True:
            word = six[-1]
            seven += word
            if len(seven)==3:
                break
    
    answer = seven
    return answer

https://school.programmers.co.kr/learn/courses/30/lessons/118667

queue1 = [1,2,1,2]
queue2 = [1,10,1,2]
from collections import deque
answer = 0
p1 = deque(queue1)
p2 = deque(queue2)
sum1 = sum(p1)
sum2 = sum(p2)

while True:
    if sum1 == sum2:
        break
    else:
        answer += 1
        if sum1 > sum2:
            e1 = p1.popleft()
            p2.append(e1)
            sum1 -= e1
            sum2 += e1
        else:
            e2 = p2.popleft()
            p1.append(e2)
            sum2 -= e2
            sum1 += e2
    if len(queue1)*3 < answer:
        answer = -1
        break
print(answer)