[250123] 프로그래머스 코딩테스트 입문 문제

컨트롤 제트 ↩️

Q. 숫자와 "Z"가 공백으로 구분되어 담긴 문자열이 주어집니다. 문자열에 있는 숫자를 차례대로 더하려고 합니다. 이 때 "Z"가 나오면 바로 전에 더했던 숫자를 뺀다는 뜻입니다. 숫자와 "Z"로 이루어진 문자열 `s`가 주어질 때, 머쓱이가 구한 값을 return 하도록 solution 함수를 완성해보세요.

 

제한사항

• 1 ≤ `s`의 길이 ≤ 200
• -1,000 < `s`의 원소 중 숫자 < 1,000
• `s`는 숫자, "Z", 공백으로 이루어져 있습니다.
• `s`에 있는 숫자와 "Z"는 서로 공백으로 구분됩니다.
• 연속된 공백은 주어지지 않습니다.
• 0을 제외하고는 0으로 시작하는 숫자는 없습니다.
• `s`는 "Z"로 시작하지 않습니다.
• `s`의 시작과 끝에는 공백이 없습니다.
• "Z"가 연속해서 나오는 경우는 없습니다.

입출력 예

s	result
"1 2 Z 3"	4
"10 20 30 40"	100
"10 Z 20 Z 1"	1
"10 Z 20 Z"	0
"-1 -2 -3 Z"	-3

 

A.

import re
def solution(s):
    answer = []
    num = []
    new_s = s.split()
    pattern = r"^-?\d+(\.\d+)?([eE][-+]?\d+)?$"
    
    for i in new_s:
        if re.match(pattern, i):
            num.append(int(i))
        else:
            if num:
                num.remove(num[-1])
                answer.extend(num)
                num = []
    if num:
        answer.extend(num)

    result = sum(answer)
    return result

# s 안에 있는 숫자를 더한 값 반환하기
# 근데 이제 Z를 만났을 땐 바로 전에 더했던 숫자값을 빼야함

---

코드 풀이 🤖

일단 나는 이 문제를 풀 때 숨어있는 숫자의 덧셈(2) 문제풀이를 그대로 활용하였음

def solution(s):
    answer = []
    num = []
    new_s = s.split()

`s`를 for 루프로 돌리기 전에 10의 자리 숫자들이 1의 자리 숫자와 같이

일일이 쪼개지는걸(?) 방지하기 위해서 공백을 기준으로 `s`를 `split()`하여

`new_s`에 저장해주었음,,

for i in new_s:
        if re.match(pattern, i):
            num.append(int(i))
        else:
            if num:
                num.remove(num[-1])
                answer.extend(num)
                num = []
    if num:
        answer.extend(num)

첨에 나는 이 부분에서 정규식 `re.match()`을 사용하지 않고

`isdigit()`을 사용함

그러나?

이 문제 풀면서 알게되었는데,,

 

`isdigit()`은 0을 포함한 양수인 정수 숫자만 True로 걸러준다는 사실을 알게됨,,

 

어쩐지,, 마지막 케이스는 음수라 그런지 `num`에 안담기더라고요,,

그래서 음수도 검열해줄 수 있는 함수가 뭐가 있을까,,

고민을 때리다가 얼마 전에 알게된 정규식이 떠올랐읍니다..

import re
def solution(s):
    answer = []
    num = []
    new_s = s.split()
    pattern = r"^-?\d+(\.\d+)?([eE][-+]?\d+)?$"
    
    for i in new_s:
        if re.match(pattern, i):
            num.append(int(i))
        else:
            if num:
                num.remove(num[-1])
                answer.extend(num)
                num = []
    if num:
        answer.extend(num)

    result = sum(answer)
    return result

정규식을 사용하기 위해 `re` 를 불러와줌

양수와 음수, 실수, 지수 등을 포함한 숫자들을 검열해주기 위한 정규식을

`pattern`에 저장해주었음

정규식으로 숫자를 검열해주기 위해 `re.match(pattern, i)` 해줍니다

여기서 잠깐,

---

re.match()란?

1. `re.match()` 정의

문자열의 시작 부분이 주어진 정규식 패턴과 일치하는지 확인하는데 사용된다.
만약 일치하면 `Match` 객체를 반환하고, 일치하지 않으면 `None`을 반환한다.

import re

# 패턴과 문자열을 비교
pattern = r"^hello"
string = "hello world"

match = re.match(pattern, string)

if match:
    print("일치합니다!")
else:
    print("일치하지 않습니다!")

2. `re.match()`의 주요 특징

1. 문자열의 시작 부분만 검사
   • `re.match()`는 문자열의 처음부터 주어진 패턴과 일치하는지 확인
   • 문자열 중간이나 끝에 패턴이 있어도 무시된다
2. 반환 값
   • 일치할 경우: `Match` 객체를 반환
   • 일치하지 않을 경우: `None`을 반환
3. `Match` 객체 활용
   • `Match` 객체는 일치하는 부분에 대한 정보(위치, 내용 등)를 제공
   • 주요 메서드:
     • `.group()`: 일치하는 문자열 반환
     • `.start()`, `.end()`: 일치하는 부분의 시작 및 끝 인덱스
     • `.span()`: 시작과 끝 인덱스를 튜플로 반환

3. 매개변수

`re.match(pattern, string, flags=0)`

• `pattern`: 정규식 패턴 문자열
• `string`: 검사할 문자열
• `flags`: 정규식 플래그 (대소문자 구분, 여러 줄 매칭 등), 기본값은 0

플래그 예시:

• `re.IGNORECASE` 또는 `re.I`: 대소문자 구분 없음
• `re.MULTILINE` 또는 `re.M`: 여러 줄에서 시작/끝 검사를 활성화
• `re.DOTALL` 또는 `re.S`: 줄바꿈 문자도 `.`에 포함

예제 코드:

1. 기본 동작

import re

# 패턴과 문자열 정의
pattern = r"hello"
string1 = "hello world"
string2 = "world hello"

# 문자열의 시작 부분 검사
print(re.match(pattern, string1))  # <re.Match object; span=(0, 5), match='hello'>
print(re.match(pattern, string2))  # None

2. `Match` 객체 사용

import re

pattern = r"hello"
string = "hello world"

match = re.match(pattern, string)

if match:
    print("일치한 부분:", match.group())    # 'hello'
    print("일치 시작 위치:", match.start()) # 0
    print("일치 끝 위치:", match.end())    # 5
    print("일치 범위:", match.span())      # (0, 5)

3. 플래그 사용 (IGNORECASE)

import re

pattern = r"hello"
string = "Hello world"

# 대소문자 무시
match = re.match(pattern, string, re.IGNORECASE)

if match:
    print("대소문자 구분 없이 일치:", match.group())  # 'Hello'

4. 주의할 점

문자열 시작 부분만 검사

• 예를 들어, 문자열 중간에 패턴이 있어도 `re.match()`는 이를 무시한다

import re
pattern = r"world"
string = "hello world"
print(re.match(pattern, string))  # None

문자열의 임의 위치 검사 필요 시 `re.search()` 사용

• `re.search()`는 문자열 전체에서 패턴을 검색

import re
pattern = r"world"
string = "hello world"
print(re.search(pattern, string))  # <re.Match object; span=(6, 11), match='world'>

 

5. `re.match()` vs `re.search()` 비교

특성	`re.match()`	`re.search()`
검사 범위	문자열의 시작 부분만 검사	문자열 전체 검사
반환 값	첫 번째 일치하는 `Match` 객체 또는 `None`	첫 번째 일치하는 `Match` 객체 또는 `None`
주요 용도	문자열이 특정 패턴으로 시작하는지 확인	문자열 안에 특정 패턴이 있는지 확인

6. 실생활 예제

이메일 주소 확인

import re

# 이메일 주소의 시작이 유효한지 확인
pattern = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
email = "example@email.com"

if re.match(pattern, email):
    print("유효한 이메일입니다!")
else:
    print("유효하지 않은 이메일입니다.")

 

결론:
`re.match()`는 문자열의 시작 부분만 확인할 때 적합하고, 더 유연한 검색이 필요할 경우
`re.search()` 또는 `re.findall()`을 사용하는 것이 좋다~

---

운좋게 `re.match()` 사용했는데도 이번 문제는 통과했지만

다음번에 또 정규식을 사용하게 된다면 그냥 `re.findall()`을 사용하는 것이 안전빵이지 않으려나,,?

for i in new_s:
        if re.match(pattern, i):
            num.append(int(i))
        else:
            if num:
                num.remove(num[-1])
                answer.extend(num)
                num = []
    if num:
        answer.extend(num)

    result = sum(answer)
    return result

다시 코드로 돌아와서,,

`re.match(pattern, i)`가 `True`일 경우:

`num`에 `i`를 추가해줍니다

 

`False`일 경우(숫자가 아닐 경우):

인데 이제 `num`에 숫자가 채워져있을 경우,,

`num`의 맨마지막에 채워진 데이터[-1]를 삭제해주고

`answer`에 옮겨담아줌

그리고 `num` 초기화~!

 

그 이후에 문자열의 맨 마지막에도 숫자가 존재해서

`num`에 숫자가 채워져있을 경우:

똑같이 `answer`에 옮겨담아줌

그리고 `answer`의 합계를 return해줍니다

---

다른사람 문제 풀이 참조해보기

# 혜연님 코드
def solution(s):
    s_list = s.split()
    c = 0
    
    while c < len(s_list):
        try:
            if s_list[c] == 'Z':
                del s_list[c-1:c+1]
                c -= 1
        except IndexError:
            pass
        c += 1
    
    answer = sum(map(int, s_list))
    
    return answer

혜연님 신박한 방식으로 푸셔서 허락맡고 퍼왔읍니다,,,

동작원리는 대충

 

인덱스를 순회하면서 검열을 하는데

문자열이 숫자일 경우 패스하고 인덱스 포인터를 +1 올려줍니다

그러다 'Z'를 만나면 그전 숫자와 'Z'까지 슬라이싱으로 같이 삭제한 후,

인덱스 포인터를 다시 -1로 조정하면서 문자열 끝까지 재순회한다~

 

우와 이사람 개발자다~!~!