Config 폴더의 Secret.plist의 파일을 Git 추적에서 제거하는 경우

echo "Config/Secret.plist" >> .gitignore
git add .gitignore

이미 Git이 추적 중인 경우

아래 명령어로 Git 추적에서 제외한다.

git rm --cached Config/Secret.plist

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Constraints

• 2 <= nums.length <= $10^4$
• $-10^9$ <= nums[i] <= $10^9$
• $-10^9$ <= target <= $10^9$
• Only one valid answer exists.

Approach

1. 주어진 nums 배열에서 숫자를 하나씩 꺼낸다.
2. target에서 nums 배열에서 꺼낸 숫자를 빼서 얼마를 더해야 target이 될지 확인한다.
3. nums에서 꺼낸 숫자의 인덱스 값 이후에 찾아야 할 숫자가 있는지 확인한다.
4. 있다면 nums에서 꺼낸 숫자의 인덱스와 찾은 숫자의 인덱스를 반환한다.
5. 없다면 2 ~ 3을 반복한다.

Complexity

• Time complexity:
• 바깥 for 문에서 $O(n)$
• nums[index + 1] 탐색에서 $O(n)$

• 따라서, 최악의 경우 시간 복잡도는 $O(n^2)$

• Space complexity:
• $n$이 커지면 할당된 메모리도 커지는 변수는 없으므로 공간 복잡도는 $O(1)$

Code

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for index, num in enumerate(nums):
            finding_number = target - num

            if finding_number in nums[index + 1:]:
                return [index, nums.index(finding_number, index + 1)]

개선할 점

• 해시맵을 사용하면 공간복잡도는 $O(n)$으로 늘어나지만 시간복잡도를 $O(n)$으로 줄일 수 있다.

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        num_map = {}

        for index, num in enumerate(nums):
            finding_number = target - num

            if finding_number in num_map:
                return [num_map[finding_number], index]

            num_map[num] = index

프로그래머스 86491번 최소직사각형

명함 지갑을 만드는 회사에서 지갑의 크기를 정하려고 합니다. 다양한 모양과 크기의 명함들을 모두 수납할 수 있으면서, 작아서 들고 다니기 편한 지갑을 만들어야 합니다. 이러한 요건을 만족하는 지갑을 만들기 위해 디자인팀은 모든 명함의 가로 길이와 세로 길이를 조사했습니다.

아래 표는 4가지 명함의 가로 길이와 세로 길이를 나타냅니다.

가장 긴 가로 길이와 세로 길이가 각각 80, 70이기 때문에 80(가로) x 70(세로) 크기의 지갑을 만들면 모든 명함들을 수납할 수 있습니다. 하지만 2번 명함을 가로로 눕혀 수납한다면 80(가로) x 50(세로) 크기의 지갑으로 모든 명함들을 수납할 수 있습니다. 이때의 지갑 크기는 4000(=80 x 50)입니다.

모든 명함의 가로 길이와 세로 길이를 나타내는 2차원 배열 sizes가 매개변수로 주어집니다. 모든 명함을 수납할 수 있는 가장 작은 지갑을 만들 때, 지갑의 크기를 return 하도록 solution 함수를 완성해주세요.

제한 사항

• sizes의 길이는 1 이상 10,000 이하입니다.
  • sizes의 원소는 [w, h] 형식입니다.
  • w는 명함의 가로 길이를 나타냅니다.
  • h는 명함의 세로 길이를 나타냅니다.
  • w와 h는 1 이상 1,000 이하인 자연수입니다.

입출력 예시

입출력 예 설명 1

• 위의 예시와 같습니다.

입출력 예 설명 2

• 명함들을 적절히 회전시켜 겹쳤을 때, 3번째 명함(가로: 8, 세로: 15)이 다른 모든 명함보다 크기가 큽니다. 따라서 지갑의 크기는 3번째 명함의 크기와 같으며, 120(=8 x 15)을 return 합니다.

입출력 예 설명 3

• 명함들을 적절히 회전시켜 겹쳤을 때, 모든 명함을 포함하는 가장 작은 지갑의 크기는 133(=19 x 7)입니다.

코드 구현

Python

def solution(sizes: [[int]]):
    width = []
    height = []

    for size in sizes:
        size.sort()
        width.append(size[0])
        height.append(size[1])

    return max(width) * max(height)

시간 복잡도 - Python

• 반복문을 실행하는데 시간 복잡도는 $O(n)$이다.
• 너비와 높이의 최댓값을 찾는데 시간 복잡도는 $O(n)$이다.
• 따라서, 시간 복잡도는 $O(n)$이다.

프로그래머스 12906번 같은 숫자는 싫어

배열 arr가 주어집니다. 배열 arr의 각 원소는 숫자 0부터 9까지로 이루어져 있습니다. 이때, 배열 arr에서 연속적으로 나타나는 숫자는 하나만 남기고 전부 제거하려고 합니다. 단, 제거된 후 남은 수들을 반환할 때는 배열 arr의 원소들의 순서를 유지해야 합니다. 예를 들면,

• arr = [1, 1, 3, 3, 0, 1, 1] 이면 [1, 3, 0, 1] 을 return 합니다.
• arr = [4, 4, 4, 3, 3] 이면 [4, 3] 을 return 합니다.

배열 arr에서 연속적으로 나타나는 숫자는 제거하고 남은 수들을 return 하는 solution 함수를 완성해 주세요.

제한 사항

• 배열 arr의 크기 : 1,000,000 이하의 자연수
• 배열 arr의 원소의 크기 : 0보다 크거나 같고 9보다 작거나 같은 정수

입출력 예시

입출력 예 설명 1, 2

• 문제의 예시와 같습니다.

코드 구현

Python

import math


def solution(progresses, speeds):
    need_days_collection = []
    release_num = []
    count = 0

    for index, progress in enumerate(progresses):
        need_days = math.ceil((100 - progress) / speeds[index])

        if not need_days_collection:
            need_days_collection.append(need_days)
            count += 1
        elif need_days_collection[-1] >= need_days:
            count += 1
        else:
            need_days_collection.append(need_days)
            release_num.append(count)
            count = 1

    release_num.append(count)

    return release_num

시간 복잡도 - Python

• 반복문을 실행하는데 시간 복잡도는 $O(n)$이다.
• 따라서, 시간 복잡도는 $O(n)$이다.

프로그래머스 12945번 피보나치 수

피보나치 수는 F(0) = 0, F(1) = 1일 때, 1 이상의 n에 대하여 F(n) = F(n-1) + F(n-2) 가 적용되는 수 입니다. 예를들어

• F(2) = F(0) + F(1) = 0 + 1 = 1
• F(3) = F(1) + F(2) = 1 + 1 = 2
• F(4) = F(2) + F(3) = 1 + 2 = 3
• F(5) = F(3) + F(4) = 2 + 3 = 5

와 같이 이어집니다.

2 이상의 n이 입력되었을 때, n번째 피보나치 수를 1234567으로 나눈 나머지를 리턴하는 함수, solution을 완성해 주세요.

제한 사항

• n은 2 이상 100,000 이하인 자연수입니다.

입출력 예시

입출력 예 설명 1, 2

• 피보나치수는 0번째부터 0, 1, 1, 2, 3, 5, … 와 같이 이어집니다.

코드 구현

Python

def solution(n):
    answer = [0, 1]

    for i in range(2, n + 1):
        answer.append(answer[i - 2] + answer[i - 1])

    return answer[n] % 1234567

시간 복잡도 - Python

• 반복문을 실행하는데 시간 복잡도는 $O(n)$이다.
• 따라서, 시간 복잡도는 $O(n)$이다.

개선할 점 - Python

• 배열 대신에 변수를 사용하면 시간 복잡도는 그대로 이지만 공간 복잡도를 매우 작게 할 수 있다.

def solution(n):
    a, b = 0, 1

    for i in range(2, n + 1):
        a, b = b, a + b

    return b % 1234567

프로그래머스 12973번 짝지어 제거하기

짝지어 제거하기는, 알파벳 소문자로 이루어진 문자열을 가지고 시작합니다. 먼저 문자열에서 같은 알파벳이 2개 붙어 있는 짝을 찾습니다. 그다음, 그 둘을 제거한 뒤, 앞뒤로 문자열을 이어 붙입니다. 이 과정을 반복해서 문자열을 모두 제거한다면 짝지어 제거하기가 종료됩니다. 문자열 S가 주어졌을 때, 짝지어 제거하기를 성공적으로 수행할 수 있는지 반환하는 함수를 완성해 주세요. 성공적으로 수행할 수 있으면 1을, 아닐 경우 0을 리턴해주면 됩니다.

예를 들어, 문자열 S = baabaa 라면

b aa baa → bb aa → aa →

의 순서로 문자열을 모두 제거할 수 있으므로 1을 반환합니다.

제한 사항

• 문자열의 길이 : 1,000,000이하의 자연수
• 문자열은 모두 소문자로 이루어져 있습니다.

입출력 예시

입출력 예 설명 1

• 위의 예시와 같습니다.

입출력 예 설명 2

• 문자열이 남아있지만 짝지어 제거할 수 있는 문자열이 더 이상 존재하지 않기 때문에 0을 반환합니다.

코드 구현

Python

def solution(s):
    stack = []

    for char in s:
        if stack and stack[-1] == char:
            stack.pop()
        else:
            stack.append(char)

    return 1 if not stack else 0

시간 복잡도 - Python

• 반복문을 실행하는데 시간 복잡도는 $O(n)$이다.
• 따라서, 시간 복잡도는 $O(n)$이다.

프로그래머스 12909번 올바른 괄호

괄호가 바르게 짝지어졌다는 것은 ‘(‘ 문자로 열렸으면 반드시 짝지어서 ‘)’ 문자로 닫혀야 한다는 뜻입니다. 예를 들어

• ”()()” 또는 “(())()” 는 올바른 괄호입니다.
• ”)()(“ 또는 “(()(“ 는 올바르지 않은 괄호입니다.

’(‘ 또는 ‘)’ 로만 이루어진 문자열 s가 주어졌을 때, 문자열 s가 올바른 괄호이면 true를 return 하고, 올바르지 않은 괄호이면 false를 return 하는 solution 함수를 완성해 주세요.

제한 사항

• 문자열 s의 길이 : 100,000 이하의 자연수
• 문자열 s는 ‘(‘ 또는 ‘)’ 로만 이루어져 있습니다.

입출력 예시

입출력 예 설명 1, 2, 3, 4

문제의 예시와 같습니다.

코드 구현

Python

def solution(s: str):
    stack = []

    for char in s:
        if char == '(':
            stack.append(char)
        else:
            if stack:
                stack.pop()
            else:
                return False

    return len(stack) == 0

시간 복잡도 - Python

• 문자열을 순회하는데에 필요한 시간 복잡도는 O(n)이다.
• .append(), .pop() 연산에 필요한 시간 복잡도는 O(1)이다.
• 따라서, 시간 복잡도는 O(n)이다.

프로그래머스 12911번 숫자의 표현

자연수 n이 주어졌을 때, n의 다음 큰 숫자는 다음과 같이 정의 합니다.

• 조건 1. n의 다음 큰 숫자는 n보다 큰 자연수 입니다.
• 조건 2. n의 다음 큰 숫자와 n은 2진수로 변환했을 때 1의 갯수가 같습니다.
• 조건 3. n의 다음 큰 숫자는 조건 1, 2를 만족하는 수 중 가장 작은 수 입니다.

예를 들어서 78(1001110)의 다음 큰 숫자는 83(1010011)입니다.

자연수 n이 매개변수로 주어질 때, n의 다음 큰 숫자를 return 하는 solution 함수를 완성해주세요.

제한 사항

• n은 1,000,000 이하의 자연수 입니다.

입출력 예시

입출력 예 설명 1

문제의 예시와 같습니다.

입출력 예 설명 2

15(1111)의 다음 큰 숫자는 23(10111)입니다.

코드 구현

Python

def solution(n: int):
    answer = n + 1

    while bin(n)[2:].count("1") != bin(answer)[2:].count("1"):
        answer += 1

    return answer

시간 복잡도 - Python

• 2진수 변환에서 시간 복잡도는 $O(\log n)$이다.
• while 문에서 시간 복잡도는 $O(n)$이다.
• 따라서, 시간 복잡도는 최악의 경우 $O(n \log n)$이다.

프로그래머스 12924번 숫자의 표현

Finn은 요즘 수학공부에 빠져 있습니다. 수학 공부를 하던 Finn은 자연수 n을 연속한 자연수들로 표현 하는 방법이 여러개라는 사실을 알게 되었습니다. 예를들어 15는 다음과 같이 4가지로 표현 할 수 있습니다.

• 1 + 2 + 3 + 4 + 5 = 15
• 4 + 5 + 6 = 15
• 7 + 8 = 15
• 15 = 15

자연수 n이 매개변수로 주어질 때, 연속된 자연수들로 n을 표현하는 방법의 수를 return하는 solution를 완성해주세요.

제한 사항

• n은 10,000 이하의 자연수 입니다.

입출력 예시

입출력 예 설명 1

문제의 예시와 같습니다.

코드 구현

Python

def solution(n):
    answer = 0

    for i in range(1, n + 1):
        add_num = i
        sum = 0
        
        while sum < n:
            sum += add_num
            add_num += 1
        
        if sum == n:
            answer += 1

    return answer

시간 복잡도 - Python

• 바깥 for 문에서 시간 복잡도는 $O(n)$이다.
• 내부 while 문에서 시간 복잡도는 $O(n)$이다.
• 따라서, 시간 복잡도는 최악의 경우 $O(n^2)$이다.

프로그래머스 70129번 이진 변환 반복하기

0과 1로 이루어진 어떤 문자열 x에 대한 이진 변환을 다음과 같이 정의합니다.

1. x의 모든 0을 제거합니다.
2. x의 길이를 c라고 하면, x를 “c를 2진법으로 표현한 문자열”로 바꿉니다.

예를 들어, x = "0111010"이라면, x에 이진 변환을 가하면 x = "0111010" -> "1111" -> "100" 이 됩니다.

0과 1로 이루어진 문자열 s가 매개변수로 주어집니다. s가 “1”이 될 때까지 계속해서 s에 이진 변환을 가했을 때, 이진 변환의 횟수와 변환 과정에서 제거된 모든 0의 개수를 각각 배열에 담아 return 하도록 solution 함수를 완성해주세요.

제한 사항

• s의 길이는 1 이상 150,000 이하입니다.
• s에는 ‘1’이 최소 하나 이상 포함되어 있습니다.

입출력 예시

입출력 예 설명 1

• “110010101001”이 “1”이 될 때까지 이진 변환을 가하는 과정은 다음과 같습니다.

• 3번의 이진 변환을 하는 동안 8개의 0을 제거했으므로, [3,8]을 return 해야 합니다.

입출력 예 설명 2

• “01110”이 “1”이 될 때까지 이진 변환을 가하는 과정은 다음과 같습니다.

• 3번의 이진 변환을 하는 동안 8개의 0을 제거했으므로, [3,8]을 return 해야 합니다.

입출력 예 설명 3

• “1111111”이 “1”이 될 때까지 이진 변환을 가하는 과정은 다음과 같습니다.

• 4번의 이진 변환을 하는 동안 8개의 0을 제거했으므로, [3,8]을 return 해야 합니다.

코드 구현

Python

def solution(s: str):
    count_time = 0
    count_zero = 0

    while s != "1":
        count_time += 1
        before = len(s)
        temp = []

        for num in list(s):
            if num == "1":
                temp.append(num)

        after = len(temp)
        count_zero += before - after

        s = bin(after)[2:]

    return [count_time, count_zero]

시간 복잡도 - Python

• 0을 제거하는데 시간 복잡도는 $O(n)$이다.
• 2진수로 변환하는데 시간 복잡도는 $O(\log n)$이다.
• 이진 변환 과정에서 전체 반복하는데 시간 복잡도는 $O(\log n)$이다.
• 따라서, 시간 복잡도는 $O(n \log n)$이다.

개선할 점 - Python

• 문자열을 리스트로 변환하지 않고 직접 처리하면 더 좋은 성능을 얻을 수 있다.

def solution(s: str):
    count_time = 0
    count_zero = 0

    while s != "1":
        count_time += 1

        count_one = s.count("1")
        count_zero += len(s) - count_one

        s = bin(count_one)[2:]

    return [count_time, count_zero]