공부블로그

오늘의 공부 키워드

2864  Maximim odd Binary Number

2864  Maximim odd Binary Number

문제 설명

이진 문자열 s가 주어졌을 때, 이 문자열을 재배열하여 만들 수 있는 가장 큰 홀수 이진 숫자를 구하는 것입니다. 홀수 이진 숫자는 마지막 자리가 '1'이어야 합니다. 주어진 문자열에는 최소한 하나의 '1'이 포함되어 있습니다.

예제

1. 입력: s = "010"
   • 출력: "001"
   • 설명: '1'이 하나밖에 없으므로 마지막 자리에 위치시킵니다. 따라서 답은 "001"입니다.
2. 입력: s = "0101"
   • 출력: "1001"
   • 설명: '1' 중 하나는 마지막에 배치하고, 나머지 숫자들을 앞에 배치하여 가장 큰 숫자를 만듭니다. 따라서 답은 "1001"입니다.

문제 해결 방법

이 문제를 해결하기 위한 단계는 다음과 같습니다:

1. 주어진 문자열 s에서 '1'의 개수를 셉니다.
2. 마지막 자리에 '1'을 하나 배치합니다.
3. 나머지 '1'과 '0'을 모두 앞에 배치하여 가장 큰 숫자를 만듭니다

파이썬 코드 구현

def maximumOddBinaryNumber(s: str) -> str:
    count_1 = s.count('1')
    count_0 = len(s) - count_1
    
    # '1' 하나는 마지막에 배치
    result = '1' * (count_1 - 1) + '0' * count_0 + '1'
    return result

# 예제 입력을 테스트해보세요.
print(maximumOddBinaryNumber("010"))  # 출력: "001"
print(maximumOddBinaryNumber("0101")) # 출력: "1001"

코드 설명

1. count_1 = s.count('1')는 문자열 s에서 '1'의 개수를 셉니다.
2. count_0 = len(s) - count_1는 문자열 s에서 '0'의 개수를 셉니다.
3. '1' * (count_1 - 1) + '0' * count_0 + '1'는 마지막 자리에 '1'을 배치하고, 나머지 '1'과 '0'을 앞에 배치하여 가장 큰 숫자를 만듭니다.

이와 같은 방법으로 주어진 이진 문자열을 재배열하여 가장 큰 홀수 이진 숫자를 만들 수 있습니다. 이 문제는 간단하지만, 기본적인 이진수의 특성과 문자열 처리 방법을 이해하는 데 도움이 됩니다.

마무리

이 글에서는 이진 문자열을 재배열하여 최대 홀수 이진 숫자를 만드는 문제를 해결하는 방법을 설명했습니다. 파이썬 코드를 통해 문제 해결 과정을 자세히 설명하였으니, 비슷한 문제를 해결할 때 도움이 되길 바랍니다.

여러분도 직접 코드를 작성해 보고, 다양한 입력값으로 테스트해 보세요. 이를 통해 문제 해결 능력을 키울 수 있을 것입니다. 감사합니다!

오늘의 공부 키워드

1337 The K Weakest Rows in a Matrix

1337 The K Weakest Rows in a Matrix

이 문제는 이진 행렬에서 각 행의 군인 수를 계산하고, 주어진 k 값에 따라 가장 약한 행의 인덱스를 반환하는 문제입니다. 주어진 조건에 따라 각 행의 군인 수를 계산하고, 같은 수의 군인을 가진 행은 인덱스 순서대로 정렬합니다. 이를 통해 가장 약한 k개의 행을 구할 수 있습니다.

문제를 해결하는 방법은 다음과 같습니다:

1. 각 행의 군인 수를 계산합니다.
2. 행의 인덱스와 군인 수를 튜플로 묶어 리스트를 만듭니다.
3. 이 리스트를 군인 수와 인덱스를 기준으로 정렬합니다.
4. 정렬된 리스트에서 가장 약한 k개의 행의 인덱스를 추출합니다.

파이썬코드

def kWeakestRows(mat, k):
    # 각 행의 군인 수를 계산하여 리스트 생성
    soldiers_count = [(sum(row), index) for index, row in enumerate(mat)]
    
    # 군인 수와 인덱스를 기준으로 정렬
    soldiers_count.sort()
    
    # 가장 약한 k개의 행의 인덱스를 추출하여 반환
    return [index for _, index in soldiers_count[:k]]

# 예시 입력
mat1 = [
    [1, 1, 0, 0, 0],
    [1, 1, 1, 1, 0],
    [1, 0, 0, 0, 0],
    [1, 1, 0, 0, 0],
    [1, 1, 1, 1, 1]
]
k1 = 3

mat2 = [
    [1, 0, 0, 0],
    [1, 1, 1, 1],
    [1, 0, 0, 0],
    [1, 0, 0, 0]
]
k2 = 2

# 결과 출력
print(kWeakestRows(mat1, k1))  # Output: [2, 0, 3]
print(kWeakestRows(mat2, k2))  # Output: [0, 2]

이 코드는 각 행의 군인 수를 계산하고, 이를 이용해 행을 정렬한 후 가장 약한 k개의 행의 인덱스를 반환합니다. 행렬의 각 행은 튜플 형태로 군인 수와 인덱스를 가지고 정렬되며, 이를 통해 약한 행을 쉽게 찾을 수 있습니다.

오늘의 공부 키워드

2500 Delete Greatest Value in Each Row

2500 Delete Greatest Value in Each Row

풀이 방법:

문제의 요구사항을 따르면 각 행에서 최대값을 찾고, 이 중에서 전체의 최대값을 뽑아 더하는 과정을 반복합니다. m이 행의 수, n이 열의 수이므로, 각 단계마다 O(m) 시간이 걸리며, 최대값을 찾는 것은 O(n)이므로 전체 연산은 O(m * n)의 시간 복잡도를 갖습니다. 각 열을 한 번씩 삭제하므로 총 O(n * m * n)의 연산이 필요합니다. 그러나 이는 최악의 경우이며, 일반적인 파이썬의 내장 함수를 사용하여 최적화할 수 있습니다.

파이썬 코드

def max_value_removals(grid):
    answer = 0
    while grid[0]:  # 이 반복은 최대 n번 (열의 수 만큼)
        max_vals = []
        for row in grid:
            max_val = max(row)
            max_vals.append(max_val)
            row.remove(max_val)  # 가장 큰 값 하나를 삭제
        answer += max(max_vals)  # 각 행에서 삭제된 값 중 최대값을 더함
    return answer

# 예제 실행
print(max_value_removals([[1,2,4],[3,3,1]]))  # 출력: 8
print(max_value_removals([[10]]))  # 출력: 10

오늘의 공부 키워드

1475 Final Prices With a Special Discount in a Shop

1475 Final Prices With a Special Discount in a Shop

문제 설명

주어진 정수 배열 prices에서 각 아이템의 가격이 주어집니다. 특별 할인을 받을 수 있는 조건은 다음과 같습니다:

• i번째 아이템을 살 때, j가 i보다 크고 prices[j]가 prices[i]보다 작거나 같은 최소의 인덱스를 찾아서 prices[j] 만큼의 할인을 받습니다.
• 만약 그런 인덱스가 없다면 할인을 받지 못합니다.

주어진 배열 prices에서 각 아이템의 최종 지불 가격을 계산하여 반환하는 정수 배열 answer를 반환하는 문제입니다.

예제

1. 예제 1:
   • 입력: prices = [8, 4, 6, 2, 3]
   • 출력: [4, 2, 4, 2, 3]
   • 설명:
     • 아이템 0: 가격은 8이고, 최소 인덱스 1에서 4만큼 할인받아 최종 가격은 4입니다.
     • 아이템 1: 가격은 4이고, 최소 인덱스 3에서 2만큼 할인받아 최종 가격은 2입니다.
     • 아이템 2: 가격은 6이고, 최소 인덱스 3에서 2만큼 할인받아 최종 가격은 4입니다.
     • 아이템 3: 할인을 받지 못하여 최종 가격은 2입니다.
     • 아이템 4: 할인을 받지 못하여 최종 가격은 3입니다.
2. 예제 2:
   • 입력: prices = [1, 2, 3, 4, 5]
   • 출력: [1, 2, 3, 4, 5]
   • 설명: 모든 아이템이 할인을 받지 못합니다.
3. 예제 3:
   • 입력: prices = [10, 1, 1, 6]
   • 출력: [9, 0, 1, 6]
   • 설명:
     • 아이템 0: 가격은 10이고, 최소 인덱스 1에서 1만큼 할인받아 최종 가격은 9입니다.
     • 아이템 1: 가격은 1이고, 최소 인덱스 2에서 1만큼 할인받아 최종 가격은 0입니다.
     • 아이템 2: 할인을 받지 못하여 최종 가격은 1입니다.
     • 아이템 3: 할인을 받지 못하여 최종 가격은 6입니다.

파이썬코드

def finalPrices(prices):
    n = len(prices)
    answer = [0] * n

    for i in range(n):
        discount = 0
        for j in range(i + 1, n):
            if prices[j] <= prices[i]:
                discount = prices[j]
                break
        answer[i] = prices[i] - discount

    return answer

# 예제 테스트
print(finalPrices([8, 4, 6, 2, 3]))  # 출력: [4, 2, 4, 2, 3]
print(finalPrices([1, 2, 3, 4, 5]))  # 출력: [1, 2, 3, 4, 5]
print(finalPrices([10, 1, 1, 6]))    # 출력: [9, 0, 1, 6]

풀이 방법

이 문제를 해결하기 위해 다음과 같은 단계로 접근할 수 있습니다:

1. prices 배열을 순회하면서 각 아이템의 가격을 확인합니다.
2. 각 아이템의 가격에 대해 뒤에 나오는 가격 중에서 최소 가격을 찾습니다.
3. 최소 가격을 찾아서 할인을 적용하고 최종 가격을 계산합니다.
4. 최종 가격을 answer 배열에 저장합니다.

결론

이 글에서는 파이썬을 사용하여 'Final Prices With a Special Discount in a Shop' 문제를 해결하는 방법에 대해 살펴보았습니다. 각 아이템에 대해 뒤에 나오는 최소 가격을 찾아 할인을 적용하는 방법을 사용하여 문제를 해결할 수 있었습니다. 이 문제를 통해 조건문과 반복문을 활용한 배열 탐색 방법을 익힐 수 있습니다.

오늘의 공부 키워드

933 Number of Recent Calls

933 Number of Recent Calls

문제 설명

RecentCounter 클래스는 특정 시간 프레임 내에서 최근 요청의 수를 카운트하는 클래스입니다. 이 클래스를 구현하세요:

• RecentCounter(): 초기화 시, 최근 요청의 수를 0으로 설정합니다.
• int ping(int t): 시간 t에서 새로운 요청을 추가합니다. 여기서 t는 밀리초 단위의 시간을 나타내며, 지난 3000 밀리초 동안(새로운 요청을 포함하여) 발생한 요청의 수를 반환합니다. 구체적으로, [t - 3000, t] 범위에 해당하는 요청의 수를 반환합니다.

각 ping 호출은 이전 호출보다 엄격히 더 큰 값을 사용합니다.

예제 1:

입력:

["RecentCounter", "ping", "ping", "ping", "ping"]
[[], [1], [100], [3001], [3002]]

출력:

[null, 1, 2, 3, 3]

설명:

RecentCounter recentCounter = new RecentCounter();
recentCounter.ping(1);     // 요청 = [1], 범위는 [-2999, 1], 반환 값은 1
recentCounter.ping(100);   // 요청 = [1, 100], 범위는 [-2900, 100], 반환 값은 2
recentCounter.ping(3001);  // 요청 = [1, 100, 3001], 범위는 [1, 3001], 반환 값은 3
recentCounter.ping(3002);  // 요청 = [1, 100, 3001, 3002], 범위는 [2, 3002], 반환 값은 3

제약 사항:

• 1 <= t <= 10^9
• 각 테스트 케이스는 ping을 호출할 때 엄격히 증가하는 값을 사용합니다.
• 최대 10^4번 ping을 호출할 수 있습니다.

파이썬코드

from collections import deque

class RecentCounter:
    def __init__(self):
        self.queue = deque()

    def ping(self, t: int) -> int:
        self.queue.append(t)
        # Remove elements that are out of the 3000ms range
        while self.queue[0] < t - 3000:
            self.queue.popleft()
        return len(self.queue)

# Example usage
recentCounter = RecentCounter()
print(recentCounter.ping(1))     # Output: 1
print(recentCounter.ping(100))   # Output: 2
print(recentCounter.ping(3001))  # Output: 3
print(recentCounter.ping(3002))  # Output: 3

풀이 방법

이 문제를 해결하기 위해서 RecentCounter 클래스를 큐를 사용하여 구현할 수 있습니다. 큐를 사용하면 가장 오래된 요청을 효율적으로 제거하면서 새로운 요청을 추가할 수 있습니다. 다음은 구체적인 풀이 단계입니다:

1. 초기화:
   • __init__ 메서드에서 큐를 초기화합니다.
2. ping 메서드:
   • 새로운 요청이 들어오면 큐에 추가합니다.
   • 큐에서 t - 3000보다 작은 모든 요청을 제거합니다.
   • 큐의 크기를 반환합니다.

오늘의 공부 키워드

1700. Number of Students Unable to Eat Lunch

1700. Number of Students Unable to Eat Lunch

문제 설명

학교 급식실에서는 점심시간에 원형과 사각형 샌드위치를 제공합니다. 각각 0과 1로 표현됩니다. 모든 학생들은 줄을 서서 각자 원형 또는 사각형 샌드위치를 선호합니다.

샌드위치의 수는 학생들의 수와 같습니다. 샌드위치는 스택에 쌓여 있습니다. 각 단계에서 다음이 이루어집니다:

• 줄의 맨 앞 학생이 스택 맨 위의 샌드위치를 선호하면 샌드위치를 가져가고 줄에서 나갑니다.
• 그렇지 않으면, 샌드위치를 두고 줄의 끝으로 갑니다.

이 과정은 더 이상 줄의 학생들이 스택 맨 위의 샌드위치를 원하지 않아 먹지 못하는 상황이 될 때까지 계속됩니다.

두 개의 정수 배열 students와 sandwiches가 주어집니다. sandwiches[i]는 스택의 i번째 샌드위치의 타입(0이 맨 위)이고, students[j]는 줄의 j번째 학생의 선호도(0이 맨 앞)입니다. 먹지 못하는 학생의 수를 반환하세요.

예제

예제 1

• 입력: students = [1,1,0,0], sandwiches = [0,1,0,1]
• 출력: 0
• 설명:
  1. 맨 앞 학생이 맨 위의 샌드위치를 두고 줄 끝으로 가서 students = [1,0,0,1]이 됩니다.
  2. 맨 앞 학생이 맨 위의 샌드위치를 두고 줄 끝으로 가서 students = [0,0,1,1]이 됩니다.
  3. 맨 앞 학생이 맨 위의 샌드위치를 가져가서 students = [0,1,1]이 되고 sandwiches = [1,0,1]이 됩니다.
  4. 맨 앞 학생이 맨 위의 샌드위치를 두고 줄 끝으로 가서 students = [1,1,0]이 됩니다.
  5. 맨 앞 학생이 맨 위의 샌드위치를 가져가서 students = [1,0]이 되고 sandwiches = [0,1]이 됩니다.
  6. 맨 앞 학생이 맨 위의 샌드위치를 두고 줄 끝으로 가서 students = [0,1]이 됩니다.
  7. 맨 앞 학생이 맨 위의 샌드위치를 가져가서 students = [1]이 되고 sandwiches = [1]이 됩니다.
  8. 맨 앞 학생이 맨 위의 샌드위치를 가져가서 students = []이 되고 sandwiches = []이 됩니다.
  9. 따라서 모든 학생들이 샌드위치를 먹을 수 있습니다.

예제 2

• 입력: students = [1,1,1,0,0,1], sandwiches = [1,0,0,0,1,1]
• 출력: 3

해결책

이 문제를 해결하기 위해서 다음 단계를 따라갈 수 있습니다:

1. 각 샌드위치 타입의 수와 학생들의 선호도를 셉니다.
2. 학생들이 줄을 돌면서 샌드위치를 가져가거나 줄 끝으로 가는 과정을 시뮬레이션합니다.
3. 만약 더 이상 어떤 학생도 맨 위의 샌드위치를 원하지 않으면, 남은 학생 수를 반환합니다.

코드

def count_students_unable_to_eat(students, sandwiches):
    count0 = students.count(0)
    count1 = students.count(1)
    
    for sandwich in sandwiches:
        if sandwich == 0 and count0 > 0:
            count0 -= 1
        elif sandwich == 1 and count1 > 0:
            count1 -= 1
        else:
            break
            
    return count0 + count1

# 예제 입력
students1 = [1, 1, 0, 0]
sandwiches1 = [0, 1, 0, 1]

students2 = [1, 1, 1, 0, 0, 1]
sandwiches2 = [1, 0, 0, 0, 1, 1]

# 출력
print(count_students_unable_to_eat(students1, sandwiches1))  # 출력: 0
print(count_students_unable_to_eat(students2, sandwiches2))  # 출력: 3

오늘의 공부 키워드

2733 Neither Minimum nor Maximum

2733 Neither Minimum nor Maximum

문제 해석

주어진 정수 배열 nums에는 서로 다른 양의 정수가 포함되어 있습니다. 이 배열에서 최소값도 최대값도 아닌 수를 찾아 반환하는 문제입니다. 만약 그런 수가 없다면 -1을 반환해야 합니다.

예제 1:

• 입력: nums = [3,2,1,4]
• 출력: 2
• 설명: 이 예제에서 최소값은 1이고 최대값은 4입니다. 따라서 2나 3 중 하나가 유효한 답이 될 수 있습니다.

예제 2:

• 입력: nums = [1,2]
• 출력: -1
• 설명: 이 배열에서는 최소값도 최대값도 아닌 수가 없기 때문에 답이 없습니다.

예제 3:

• 입력: nums = [2,1,3]
• 출력: 2
• 설명: 2는 최소값도 최대값도 아니므로 유효한 답입니다.

코드

def find_number(nums):
    if len(nums) <= 2:
        return -1

    min_value = min(nums)
    max_value = max(nums)

    for num in nums:
        if num != min_value and num != max_value:
            return num
    
    return -1

풀이 방법

이 문제를 해결하기 위한 단계는 다음과 같습니다:

1. nums 배열에서 최소값과 최대값을 찾습니다.
2. 배열을 순회하면서 최소값도 최대값도 아닌 값을 찾습니다.
3. 만약 그런 값이 있다면 해당 값을 반환하고, 없다면 -1을 반환합니다.

예제 실행

예제 1:

nums = [3,2,1,4]
print(find_number(nums))  # 출력: 2

예제 2

nums = [1,2]
print(find_number(nums))  # 출력: -1

예제3

nums = [2,1,3]
print(find_number(nums))  # 출력: 2

이 방법은 배열을 순회하면서 최소값과 최대값을 제외한 값을 찾는 간단한 논리로 문제를 해결합니다.

오늘의 회고

• 부족함을 느끼지만 실력을 늘리는것이 제일 빠른길임을 명심하자
• 새로운 개념을 배울수 있어서 좋았다.
• 생각보다 긴 코드라서 배우고 있는 입장에서 정말 어려웠다

오늘의 공부 키워드

• 1528 Suffle String

1528 Shuffle String

주어진 문자열 s와 정수 배열 indices가 있습니다. 문자열 s의 각 문자는 indices 배열의 값에 따라 재배열됩니다.
즉, s의 i번째 위치에 있는 문자는 indices[i] 위치로 이동합니다. 재배열된 문자열을 반환해야한다.

예시

1. 예시 1:
   • 입력: s = "codeleet", indices = [4,5,6,7,0,2,1,3]
   • 출력: "leetcode"
   • 설명: "codeleet"의 각 문자는 인덱스 배열에 따라 "leetcode"로 재배열됩니다.
2. 예시 2:
   • 입력: s = "abc", indices = [0,1,2]
   • 출력: "abc"
   • 설명: 각 문자가 제자리에서 움직이지 않으므로 결과는 "abc"입니다.

제약 조건

• s.length == indices.length == n
• 1 <= n <= 100
• s는 소문자 영어 문자로만 구성됩니다.
• 0 <= indices[i] < n
• indices의 모든 값은 고유합니다.

해결 방법

이 문제를 해결하기 위해서는 다음 단계를 따릅니다:

1. indices 배열의 각 위치에 맞게 문자를 재배열할 빈 문자열을 만듭니다.
2. indices 배열을 순회하며 각 인덱스 위치에 s의 문자를 배치합니다.
3. 재배열된 문자열을 반환합니다.

구체적인 알고리즘은 다음과 같습니다:

1. 결과를 저장할 동일한 길이의 빈 리스트 shuffled를 만듭니다.
2. indices 배열을 순회하면서, 각 indices[i] 위치에 s[i] 문자를 배치합니다.
3. 리스트를 문자열로 변환하여 반환합니다

코드

from typing import List

class Solution:
    def restoreString(self, s: str, indices: List[int]) -> str:
        shuffled = [''] * len(s)
        for i, index in enumerate(indices):
            shuffled[index] = s[i]
        return ''.join(shuffled)

# 예제 테스트
sol = Solution()
s1 = "codeleet"
indices1 = [4, 5, 6, 7, 0, 2, 1, 3]
print(sol.restoreString(s1, indices1))  # "leetcode"

s2 = "abc"
indices2 = [0, 1, 2]
print(sol.restoreString(s2, indices2))  # "abc"

s3 = "aiohn"
indices3 = [3, 1, 4, 2, 0]
print(sol.restoreString(s3, indices3))  # "nihao"

코드 설명

• shuffled 리스트를 s와 동일한 길이로 초기화합니다.
• indices 배열을 순회하면서 각 인덱스 위치에 s의 문자를 배치합니다.
• 최종적으로 리스트를 문자열로 변환하여 반환합니다.

오늘의 공부 키워드

• 1773 Count Items Matching a Rule

1773 Count Items Matching a Rule

문제 설명

당신은 items라는 배열을 받았습니다. 여기서 각 items[i] = [typei, colori, namei]는 i번째 아이템의 타입, 색상, 이름을 나타냅니다. 또한 두 개의 문자열 ruleKey와 ruleValue로 표현된 규칙이 주어집니다.

i번째 아이템은 다음 중 하나가 참일 경우 주어진 규칙과 일치한다고 말합니다:

• ruleKey == "type"이고 ruleValue == typei
• ruleKey == "color"이고 ruleValue == colori
• ruleKey == "name"이고 ruleValue == namei

주어진 규칙과 일치하는 아이템의 개수를 반환하세요.

예제

예제 1:

• 입력: items = [["phone","blue","pixel"],["computer","silver","lenovo"],["phone","gold","iphone"]], ruleKey = "color", ruleValue = "silver"
• 출력: 1
• 설명: 주어진 규칙과 일치하는 아이템은 ["computer","silver","lenovo"] 하나입니다.

예제 2:

• 입력: items = [["phone","blue","pixel"],["computer","silver","phone"],["phone","gold","iphone"]], ruleKey = "type", ruleValue = "phone"
• 출력: 2
• 설명: 주어진 규칙과 일치하는 아이템은 ["phone","blue","pixel"]와 ["phone","gold","iphone"] 두 개입니다. ["computer","silver","phone"]은 일치하지 않습니다.

코드

def countMatches(items, ruleKey, ruleValue):
    # ruleKey에 따른 인덱스를 설정합니다.
    index = {"type": 0, "color": 1, "name": 2}[ruleKey]
    
    # 일치하는 아이템의 개수를 셉니다.
    count = 0
    for item in items:
        if item[index] == ruleValue:
            count += 1
    
    return count

# 예제 실행
items1 = [["phone","blue","pixel"],["computer","silver","lenovo"],["phone","gold","iphone"]]
ruleKey1 = "color"
ruleValue1 = "silver"
print(countMatches(items1, ruleKey1, ruleValue1))  # 출력: 1

items2 = [["phone","blue","pixel"],["computer","silver","phone"],["phone","gold","iphone"]]
ruleKey2 = "type"
ruleValue2 = "phone"
print(countMatches(items2, ruleKey2, ruleValue2))  # 출력: 2

풀이법

1. ruleKey에 따라 인덱스를 설정합니다:
   • ruleKey가 "type"이면 인덱스는 0입니다.
   • ruleKey가 "color"이면 인덱스는 1입니다.
   • ruleKey가 "name"이면 인덱스는 2입니다.
2. 각 아이템에 대해 주어진 ruleValue와 일치하는지 확인합니다.
3. 일치하는 아이템의 개수를 셉니다.

주요 포인트

1. 인덱스 설정: ruleKey에 따라 아이템의 어느 부분을 비교할지 결정하기 위해 인덱스를 설정합니다. 이를 위해 사전(dictionary)을 사용하여 "type", "color", "name"에 대응하는 인덱스를 매핑합니다.
2. 아이템 필터링: 각 아이템을 순회하면서 지정된 인덱스의 값이 ruleValue와 일치하는지 확인합니다.
3. 카운팅: 일치하는 경우 카운트를 증가시키고, 최종적으로 일치하는 아이템의 개수를 반환합니다.

이 코드 구조는 매우 효율적이고 명확하며, 각 단계에서 무엇을 하는지 쉽게 이해할 수 있습니다.

오늘의 회고

• 부족함을 느끼지만 실력을 늘리는것이 제일 빠른길임을 명심하자
• 새로운 개념을 배울수 있어서 좋았다
• 잘은 못하지만 꾸준히 뭔가를 한다는건 좋았다.
• 계속적으로 습관을 가지자

오늘의 공부 키워드

• 2942 Find Words Containing Character

2942 Find Words Containing Character

문제 설명

0부터 시작하는 문자열 배열 words와 문자 x가 주어집니다.

문자 x를 포함하는 단어의 인덱스를 나타내는 배열을 반환하세요.

반환된 배열은 임의의 순서일 수 있습니다.

예제

예제 1:

• 입력: words = ["leet","code"], x = "e"
• 출력: [0, 1]
• 설명: "e"는 "leet"와 "code"에 모두 포함되어 있으므로, 인덱스 0과 1을 반환합니다.

예제 2:

• 입력: words = ["abc","bcd","aaaa","cbc"], x = "a"
• 출력: [0, 2]
• 설명: "a"는 "abc"와 "aaaa"에 포함되어 있으므로, 인덱스 0과 2를 반환합니다.

예제 3:

• 입력: words = ["abc","bcd","aaaa","cbc"], x = "z"
• 출력: []
• 설명: "z"는 어떤 단어에도 포함되지 않으므로, 빈 배열을 반환합니다.

제약 사항

• words.length는 1 이상 50 이하입니다.
• words[i].length는 1 이상 50 이하입니다.
• x는 소문자 영어 문자입니다.
• words[i]는 소문자 영어 문자로만 이루어져 있습니다.

풀이 방법

1. 빈 리스트 만들기: 결과를 저장할 빈 리스트 result를 만듭니다.
2. 각 단어 확인하기: 각 단어와 인덱스를 하나씩 확인합니다.
3. 문자 포함 여부 확인: 만약 단어에 문자 x가 포함되어 있다면, 그 단어의 인덱스를 result에 추가합니다.
4. 결과 반환: 최종적으로 result 리스트를 반환합니다.

코드

def findWordsContainingCharacter(words, x):
    # 결과를 저장할 빈 리스트를 만듭니다.
    result = []
    
    # 각 단어와 그 단어의 인덱스를 하나씩 확인합니다.
    for index, word in enumerate(words):
        # 만약 단어에 문자 x가 포함되어 있다면
        if x in word:
            # 그 단어의 인덱스를 result 리스트에 추가합니다.
            result.append(index)
    
    # 최종적으로 result 리스트를 반환합니다.
    return result

코드 설명

result = []

 2. 각 단어 확인하기:

for index, word in enumerate(words):

• for 반복문을 사용해서 words 리스트의 각 단어와 그 단어의 인덱스를 하나씩 가져옵니다.
• enumerate 함수를 사용하면 index에는 인덱스가, word에는 단어가 들어갑니다.

3. 문자 포함 여부 확인:

if x in word:
    result.append(index)

• if 문을 사용해서 현재 단어(word)에 문자 x가 포함되어 있는지 확인합니다.
• 만약 포함되어 있다면, 그 단어의 인덱스를 result 리스트에 추가합니다.

4. 결과 반환:

return result

• 모든 단어를 확인한 후, result 리스트를 반환합니다. 이 리스트에는 문자 x를 포함한 단어들의 인덱스가 들어 있습니다.

오늘의 회고

• 부족함을 느끼지만 실력을 늘리는것이 제일 빠른길임을 명심하자
• 새로운 개념을 배울수 있어서 좋았다.