공부블로그

오늘의 공부 키워드

• 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를 포함한 단어들의 인덱스가 들어 있습니다.

오늘의 회고

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

오늘의 공부 키워드

• 브루트 포스의 개념
• 해시맵의 개념
• 1512 Number of Good Pairs

브루트포스

브루트 포스(Brute Force)는 컴퓨터 알고리즘 문제를 해결하는 데 사용되는 단순하고 직관적인 방법입니다. 브루트 포스 방법은 가능한 모든 경우의 수를 모두 시도해 보는 방식으로 문제를 해결합니다. 이러한 방법은 종종 가장 간단하고 명확한 접근 방식이지만, 경우의 수가 많아지면 매우 비효율적일 수 있습니다.

브루트 포스 방법의 장단점은 다음과 같습니다:

장점

1. 단순함: 구현이 매우 간단하고 직관적입니다.
2. 보편성: 어떤 문제든 적용할 수 있습니다.

단점

1. 비효율성: 경우의 수가 많아질수록 실행 시간이 급격히 증가합니다. 시간 복잡도가 매우 높아질 수 있습니다.
2. 자원 소모: 많은 연산을 필요로 하므로 메모리와 CPU 자원을 많이 소모할 수 있습니다.

해시맵

해시맵(Hash Map)은 데이터를 키-값(key-value) 쌍으로 저장하는 데이터 구조입니다. 해시맵은 해싱(Hashing)이라는 기술을 사용하여 데이터를 빠르게 검색, 삽입, 삭제할 수 있습니다. 해시맵은 파이썬에서는 dict로 구현되어 있으며, 매우 효율적인 평균 시간 복잡도 O(1)의 검색, 삽입, 삭제 연산을 제공합니다.

해시맵의 특징

1. 키-값 쌍:
   • 데이터를 고유한 키를 통해 저장하고, 해당 키를 통해 데이터를 빠르게 검색할 수 있습니다.
2. 해싱:
   • 키를 해시 함수(hash function)에 넣어 해시값(hash value)을 생성하고, 이를 이용해 데이터의 저장 위치를 결정합니다.
   • 해시 함수는 일반적으로 입력 데이터의 특성을 잘 분산시켜 충돌을 최소화하는 역할을 합니다.
3. 충돌 해결:
   • 두 개 이상의 키가 같은 해시값을 가질 때(해시 충돌), 이를 해결하기 위해 체이닝(Chaining)이나 오픈 어드레싱(Open Addressing) 등의 방법을 사용합니다.

1512 Number of Good Pairs

정수 배열 nums가 주어졌을 때, "좋은 쌍(good pairs)"의 개수를 반환하는 문제입니다.

좋은 쌍 (i, j)는 다음과 같은 조건을 만족합니다:

• nums[i] == nums[j]
• i < j

예제 1:

• 입력: nums = [1, 2, 3, 1, 1, 3]
• 출력: 4
• 설명: 좋은 쌍은 (0, 3), (0, 4), (3, 4), (2, 5) 이므로 총 4개입니다.

예제 2:

• 입력: nums = [1, 1, 1, 1]
• 출력: 6
• 설명: 배열의 모든 쌍이 좋은 쌍입니다.

예제 3:

• 입력: nums = [1, 2, 3]
• 출력: 0
• 설명: 좋은 쌍이 없습니다.

코드

from typing import List
from collections import defaultdict

class Solution:
    def numIdenticalPairs(self, nums: List[int]) -> int:
        count = 0
        freq = defaultdict(int)
        
        for num in nums:
            if num in freq:
                count += freq[num]
            freq[num] += 1
        
        return count

# 예제 입력 테스트
solution = Solution()
print(solution.numIdenticalPairs([1, 2, 3, 1, 1, 3]))  # 출력: 4
print(solution.numIdenticalPairs([1, 1, 1, 1]))        # 출력: 6
print(solution.numIdenticalPairs([1, 2, 3]))           # 출력: 0

코드 설명

1. 필요한 모듈 임포트:
   • List 타입을 사용하기 위해 typing 모듈에서 List를 임포트합니다.
   • defaultdict을 사용하기 위해 collections 모듈에서 defaultdict을 임포트합니다.
2. Solution 클래스 정의:
   • numIdenticalPairs 메서드는 List[int] 타입의 nums를 인자로 받아 int 타입의 결과를 반환합니다.
3. numIdenticalPairs 메서드:
   • count: 좋은 쌍의 개수를 저장하는 변수입니다.
   • freq: 각 숫자의 빈도를 저장하는 defaultdict(int)입니다.
   • 배열을 순회하면서 현재 숫자가 이전에 몇 번 나왔는지 확인하고, 그 빈도 수를 count에 더해줍니다.
   • 현재 숫자의 빈도를 1 증가시킵니다.
   • 배열 순회가 끝나면 count를 반환합니다.

이렇게 작성된 코드는 주어진 nums 배열에 대해 좋은 쌍의 개수를 효율적으로 계산합니다.

오늘의 회고

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

오늘의 공부 키워드

• 1470 Shuffle the Array

1470 Shuffle the Array

주어진 배열 nums는 2n개의 요소로 구성되어 있으며, [x1, x2, ..., xn, y1, y2, ..., yn] 형태입니다.

배열을 [x1, y1, x2, y2, ..., xn, yn] 형태로 변환하여 반환하세요.

예제 1:

입력: nums = [2, 5, 1, 3, 4, 7], n = 3

출력: [2, 3, 5, 4, 1, 7]

설명: x1=2, x2=5, x3=1, y1=3, y2=4, y3=7이므로 결과는 [2, 3, 5, 4, 1, 7]입니다.

예제 2:

입력: nums = [1, 2, 3, 4, 4, 3, 2, 1], n = 4

출력: [1, 4, 2, 3, 3, 2, 4, 1]

예제 3: 입력: nums = [1, 1, 2, 2], n = 2

출력: [1, 2, 1, 2]

제약사항:

• 1 <= n <= 500
• nums.length == 2n
• 1 <= nums[i] <= 10^3

풀이 방법:

1. 결과를 저장할 빈 배열 result를 초기화합니다.
2. 인덱스 i를 0부터 n-1까지 반복합니다.
3. 각 반복에서 nums의 앞쪽 절반에서 x 값을, 뒷쪽 절반에서 y 값을 번갈아가며 result 배열에 추가합니다.
4. 결과 배열을 반환합니다.

코드

def shuffle(nums, n):
    result = []
    for i in range(n):
        result.append(nums[i])       # x 값을 추가
        result.append(nums[i + n])   # y 값을 추가
    return result

# 예제 실행
print(shuffle([2, 5, 1, 3, 4, 7], 3))  # [2, 3, 5, 4, 1, 7]
print(shuffle([1, 2, 3, 4, 4, 3, 2, 1], 4))  # [1, 4, 2, 3, 3, 2, 4, 1]
print(shuffle([1, 1, 2, 2], 2))  # [1, 2, 1, 2]

오늘의 회고

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

오늘의 공부 키워드

• 2037 Minimum Number of Moves to seat EveryOne

2037  Minimum Number of Moves to Seat Everyone

• 문제 상황:
  • 학교에 학생들이 있고, 자리가 있어요.
  • 각 학생은 특정 위치에 있고, 각 자리는 특정 위치에 있어요.
  • 학생들은 한 번에 한 칸씩 앞이나 뒤로 움직일 수 있어요.
  • 모든 학생들이 각기 다른 자리에 앉도록 해야 해요.
• 목표:
  • 모든 학생들이 자리에 앉을 때, 학생들이 움직이는 횟수를 최소화하는 것이 목표예요.

해결 방법

이 문제를 해결하는 방법을 단계별로 설명할게요:

Step 1: 문제 이해하기

학생들을 자리에 앉힐 때 움직이는 횟수를 최소화하려면 어떻게 해야 할까요? 가장 좋은 방법은 자리에 가까운 학생을 그 자리에 앉히는게 제일 좋다.

Step 2: 정렬하기

먼저, 학생들과 자리를 각각 정렬한다. 이렇게 하면 각 자리와 가장 가까운 학생을 쉽게 찾을 수 있다.

Step 3: 매칭하기

정렬한 후, 각 자리에 가장 가까운 학생을 하나씩 매칭한다. 이 때, 각 학생이 자리에 앉기 위해 움직여야 하는 칸 수를 계산한다.

Step 4: 결과 계산하기

모든 학생들이 자리에 앉기 위해 움직인 칸 수를 모두 더한다. 이 값이 우리가 찾는 최소 움직임의 횟수이다.

코드

def min_moves_to_seats(seats, students):
    seats.sort()
    students.sort()
    
    total_moves = 0
    for seat, student in zip(seats, students):
        total_moves += abs(seat - student)
    
    return total_moves

# 예제 테스트
print(min_moves_to_seats([3, 1, 5], [2, 7, 4]))  # 출력: 4
print(min_moves_to_seats([4, 1, 5, 9], [1, 3, 2, 6]))  # 출력: 7
print(min_moves_to_seats([2, 2, 6, 6], [1, 3, 2, 6]))  # 출력: 4

코드 설명

1. 함수 정의: min_moves_to_seats(seats, students)는 자리와 학생들의 위치를 입력으로 받아요.
2. 정렬: seats.sort()와 students.sort()를 사용해 자리와 학생들의 위치를 오름차순으로 정렬해요.
3. 이동 횟수 계산:
   • total_moves를 0으로 초기화해요.
   • for seat, student in zip(seats, students):로 자리와 학생들의 위치를 동시에 순회하며 이동 횟수를 계산해요.
   • abs(seat - student)로 각 자리와 학생 간의 이동 횟수를 계산하고, total_moves에 더해요.
4. 결과 반환: 모든 이동 횟수를 더한 total_moves를 반환해요.

예제

• 입력: 자리 [3, 1, 5], 학생 [2, 7, 4]
• 정렬 후: 자리 [1, 3, 5], 학생 [2, 4, 7]
• 계산: 1 + 1 + 2 = 4
• 출력: 4

이 코드는 학생들이 자리에 앉기 위해 최소한으로 움직여야 하는 횟수를 계산해요.

오늘의 회고

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