'공부/파이썬 알고리즘'에 해당되는 글 7건

스택 : 후입선출

큐 : 선입선출

리스트는 동적할당으로 구현되어있어서 큐의 연산을 수행하기에는 효율적이지 않다.

데크를 사용하면 좋은 성능을 낼 수 있다.

스택 구현

class Node:
	def __init__(self, item, next):
		self.item = item
		self.next = next

class Stack:
	def __init__(self):
		self.last = None
	
    #맨 위에 집어넣음
	def push(self,item):
		self.last = Node(item, self.last)
	
	#맨 위값 꺼냄
	def pop(self):
		item = self.last.item
		self.last = self.last.next
		return item

20. 유효한 괄호

'''
https://leetcode.com/problems/valid-parentheses
괄호로 입력된 값이 올바른지 판별하라.

ex)
Input: s = "()[]{}"
Output: true

Input: s = "([)]"
Output: false

Input: s = "{[]}"
Output: true

방법1)
last in fisrt out. 
열린 괄호를 만날때 스택에 push하고
닫힌 괄호를 만날때 pop
pop했을때 닫힌 괄호와 일치하는지 확인

'''



class Solution:
    def isValid(self, s: str) -> bool:
        stack = []
        table = { ')':'(', 
                 '}' : '{',
                ']' : '['
                }
        for char in s:
            #괄호에 해당되지 않을 경우 stack에 추가 X
            if char not in table:
                stack.append(char)
            #stack이 비어있지 않고, pop한 결과와 다르다면
            elif not stack or table[char] != stack.pop():
                return False
            
        #스택이 비어있지 않다면 쌓이기만 했으므로 false
        return len(stack) == 0

https://leetcode.com/problems/reverse-string/

344. Reverse String

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        left, right = 0, len(s)-1
        while left < right:
            s[left], s[right] = s[right], s[left]
            left +=1
            right -=1

https://leetcode.com/problems/reorder-data-in-log-files/

937. Reorder Data in Log Files

class Solution:
    def reorderLogFiles(self, logs: List[str]) -> List[str]:
        '''
        로그의 가장 앞 부분은 식별자
        문자로 구성된 로그가 숫자 로그보다 앞에 온다.
        식별자는 순서에 영향을 끼치지 않지만, 문자가 동일할 경우 식별자 순으로 한다.
        숫자로그는 입력 순서대로 한다.
        => 1. 숫자보다 문자 로그 먼저
        => 2. 문자 동일할 경우 식별자 순(식별자는 로그 가장 앞)
        '''

        letters, digits=[], []


        for log in logs:
            #로그가 숫자라면 (log.split()는 string을 반환)
            if log.split()[1].isdigit():
                digits.append(log)

            #로그가 문자라면
            else:
                letters.append(log)
        #문자일 경우 로그기준으로 정렬, 식별자를 뒤로, 문자 동일할 경우 식별자 순으로 정렬   
        letters.sort(key=lambda x: (x.split()[1:], x.split()[0]))

        #문자+숫자
        return letters+digits

https://leetcode.com/problems/most-common-word/

\19. Most Common Word

'''
금지된 단어를 제외한 가장 흔하게 등장하는 단어를 출력하라
대소문자를 구분하지 않으며, 구두점(마침표, 쉼표) 또한 무시한다.

Input: paragraph = "Bob hit a ball, the hit BALL flew far after it was hit.", banned = ["hit"]
Output: "ball"

1. 데이터 처리 => 대소문자 없애고, 구두점 없앰
2. 빈도수 체크
'''

class Solution:
    def mostCommonWord(self, paragraph: str, banned: List[str]) -> str:

        #cleaning
        #\w은 단어문자를 뜻하며 ^은 not을 의미한다.
        #문자열 앞에 r이 붙으면 해당 문자열이 구성된 그대로 문자열로 반환
        #즉 문자가 아닌 모든 문자를 공백으로 치환한다.
        #re.sub('패턴', '바꿀문자열', '문자열', 바꿀횟수)
        #words에는 cleaning된 word가 순차적으로 들어가게됨
        '''
        # 리스트 안에서 for 문 사용하기 1
        list = [ num * 3 for num in list ]
        '''

        #\w, 즉 단어 문자가 아니면 공백으로 치환하고 lower, split함
        words =[word for word in re.sub(r'[^\w]',' ', paragraph).lower().split()
            if word not in banned] #금지된 단어에 당되는 경우엔 포함X


        #개수 세기
        #딕셔너리 사용하여 횟수 셈
        #int형 딕셔너리 생성
        counts = collections.defaultdict(int)
        for word in words:
            counts[word] += 1 #해당되는 word 수 셈

        #딕셔너리 변수 counts에서 값이 가장 큰 키를 가져옴
        #max함수에 key를 지정하여 argmax를 간접적으로 추출
        '''
        >>> a = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}
        >>> a.get('name')
        'pey'
        '''

        return max(counts, key=counts.get)

        #most_common(1)사용 가능 => 최빈값 1개 반환(리스트에 담긴 튜플 형태로
        '''
        counts=collections.Counter(words)
        return counts.most_common(1)[0][0] #=> [('ball', 2)]이므로
        '''

https://leetcode.com/problems/group-anagrams/submissions/

'''
애너그램 = 재배열하여 다른 뜻을 가진 단어로 바꾸는것

Input: strs = ["eat","tea","tan","ate","nat","bat"]
Output: [["bat"],["nat","tan"],["ate","eat","tea"]]

방법
1. strs의 단어들을 정렬하여 같은지 비교



'''


class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        #딕셔너리 생성
        anagrams = collections.defaultdict(list)

        for word in strs:
            #정렬하여 key, value딕셔너리에 삽입
            #list에서 문자열로 변환 -> 리스트(List)를 특정 구분자를 포함해 문자열(String)으로 변환
            anagrams[''.join(sorted(word))].append(word)

        #values() -> 모든 value들을 출력
        return list(anagrams.values())

https://leetcode.com/problems/longest-palindromic-substring/

'''
가장 긴 펠린드롬 부분 문자열을 출력

Input: s = "babad"
Output: "bab"

방법
1. 처음, 끝 비교 => 안맞으면 끝에서 2번째부터 계속 비교
(대칭되게 비교해야함 => aa, aaa, aaaa, aaaaa)
(1)b - d (x)
(2)b - a (x)
(3)b - b (O)
(4)길이가 3이므로 비교  X => 끝

(1)a - d
(2)a - a
.
.
.

2. 홀수칸, 짝수칸을 처음부터 이동 => 대칭되면 확장
더 효율적
'''



class Solution:
    def longestPalindrome(self, s: str) -> str:

        #s[left]==s[right]일 경우 범위 늘려가며 비교
        def expand(left:int, right:int)->str:
            while left >=0 and right < len(s) and s[left]==s[right]:
                left -= 1
                right += 1
            #left -= 1 했으므로 left+1, list범위는 right-1까지이므로 right
            return s[left+1:right]

        '''
        Input: s = "ac"
        Output: "a"
        '''
        #s가 짧거나 s자체가 펠린드롬일 경우 처리
        if len(s) < 2 or s==s[::-1]:
            return s


        #펠린드롬이 없는 경우
        result = ''

        for i in range(len(s) - 1):
            #max기준 len
            #홀수인 경우, 짝수인 경우
            result = max(result, expand(i, i+1), expand(i, i+2), key=len)

        return result

* 펠린드롬 연결리스트

연결리스트가 펠린드롬 구조인지 판별하여라

https://leetcode.com/problems/palindrome-linked-list/

'''
펠린드롬 = 뒤집어도 같아야함

연결리스트가 펠린드롬 구조인지 판별하여라

1. 리스트를 이용하여 앞뒤 비교 = pop(0)?pop()
2. fast, slow runner활용
2.1 fast가 끝까지 가면 slow는 절반만큼 가게됨
2.2 slow는 이동하면서 역순으로 rev에 값을 저장
2.3 rev와 남은 slow가 가야하는 부분을 비교
2.4 홀수개일 경우 중앙값을 포함하면 안된다. 따라서 slow를 한칸 더 옮긴다.

'''
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        '''
        q = []
        q: Deque = collecitons.deque()

        if not head:
            return True

        node = head

        #리스트 변환
        while node is not None:
            q.append(node.val)
            node = node.next

        #펠린드롬 변환
        while len(q) > 1:
            if q.pop(0) != q.pop():
                return False
        return True
        '''

        if not head:
            return True

        fast = slow = head
        rev = None

        #절반만큼 이동/ 펠린드롬이 짝수 or 홀수 이므로 fast, fast.next값을 비교
        while fast and fast.next:
            #fast는 두칸씩 이동
            fast = fast.next.next
            #slow는 한칸씩 이동, rev에 역순으로 값 저장
            rev, slow, rev.next = slow, slow.next, rev

        #짝수일 경우 fast의 값은 None이 되고 홀수일 경우 값을 가지게 된다.
        if fast:
            slow = slow.next
        #rev와 남은 값 비교
        while rev and rev.val == slow.val:
            slow, rev = slow.next, rev.next

        #모든 값이 맞다면 rev는 none일 것이다.
        return not rev

* 정렬되어 있는 두 연결 리스트를 합쳐라

https://leetcode.com/problems/merge-two-sorted-lists/

'''
정렬되어 있는 두 연결 리스트를 합쳐라

Input: l1 = [1,2,4], l2 = [1,3,4]
Output: [1,1,2,3,4,4]

방법1)
1번째 연결리스트를 기준으로 두고 2번째 연결리스트의 값을 비교하여 삽입
1번째 연결리스트의 값과 같거나 크면 뒤로, 작으면 앞으로 => n^2만큼 비교해야..

방법2)
두 연결리스트를 합친뒤 정렬하기
정렬방법.. merge sort로 (nlogn)

'''

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeTwoLists(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:

        #l1이 l2보다 크면 swap => 재귀로 반복
        if (not l1) or (l2 and l1.val > l2.val):
            l1, l2 = l2, l1

        #l1이 none 아니면, 재귀 호출
        if l1:
            l1.next = self.mergeTwoLists(l1.next, l2)

        return l1

* 연결리스트를 뒤집어라

https://leetcode.com/problems/reverse-linked-list/

'''
연결리스트를 뒤집어라

Input: head = [1,2,3,4,5]
Output: [5,4,3,2,1]

방법1)
러너문제 활용
rev, rev.next, slow = slow, rev, slow.next

방법2)
재귀활용
rev에 저장하게..

반복문을 사용하는것이 공간복잡도가 낮고 시간도 빠르다..

'''


# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:

        result = None
        temp = head

        while temp:
            temp, result, result.next = temp.next, temp, result

        return result


        '''
        def reverse(temp: ListNode, rev: ListNode = None):

            if not temp:
                return rev

            rev, temp, rev.next = temp, temp.next, rev

            return reverse(temp, rev)

        return reverse(head)
        '''

https://leetcode.com/problems/add-two-numbers/

다시....

* 홀짝 연결 리스트

연결리스트를 홀수 노드 다음에 짝수 노드가 오도록 재구성하라. 공간 복잡도 O(1), 시간 복잡도 O(n)에 풀이하라.

https://leetcode.com/problems/odd-even-linked-list/

nput: head = [1,2,3,4,5]
Output: [1,3,5,2,4]

Input: head = [2,1,3,5,6,4,7]
Output: [2,3,6,7,1,5,4]

홀수번째 노드가 짝수번째 노드 뒤에 와야한다.

방법1) 리스트로 바꾸고 슬라이싱으로 처리...는 파이썬 내장 함수로 간단...

방법2) 홀수, 짝수 노드 따로 구분하여 붙이기
1->2->3->4->5

1. 1->3
2. 2->4
3. 3->5
4. 5->2
   odd = 1->3->5
   even = 2->4
5. 1->3->5->2->4

체크
=> a.next 가 null인가? 확인
=> 2->4노드에서 4->null이 되어야함

홀: odd.next = (even.next = odd.next.next)
짝: even.next = (odd.next = even.next.next)

시작
odd : head
even : head.next

마지막

  # Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def oddEvenList(self, head: Optional[ListNode]) -> Optional[ListNode]:

        if head is None:
            return head

        #odd, even으로 구분
        odd = odd_start = head
        even = even_start = head.next


        #while odd and odd.next:이 아니라 even을 비교하여야한다... odd일 경우 None.next에 값을 넣게 되버림(한번에 두개씩 바꾸므로)

        while even and even.next:
            odd.next, even.next = even.next, even.next.next
            #odd를 다음 odd로, even을 다음 even으로
            odd = odd.next
            even = even.next

        #odd->even 연결
        odd.next = even_start

        return odd_start   

https://leetcode.com/problems/trapping-rain-water/

'''
    높이를 입력받아 비 온 후 얼마나 많은 물이 쌓일 수 있는지 계산
    Input: height = [0,1,0,2,1,0,1,3,2,1,2,1]
    Output: 6

    방법1)
        최대 높이 - 현재 높이 = 물이 고인 양

    방법2)
        현재 높이가 이전 높이 보다 높을 때 

'''
class Solution:
    def trap(self, height: List[int]) -> int:
        if not height:
            return 0

        #양쪽에서 시작하여 최대높이 까지
        volume = 0
        left, right = 0, len(height) - 1
        left_max, right_max = height[left], height[right]


        #좌우가 만날때 종료
        while left < right:
            #좌우 최대값 입력
            left_max, right_max = max(height[left], left_max), max(height[right], right_max)

            #좌우 높은 쪽으로 이동하므로,오른쪽이 크면 왼쪽이 이동, 왼쪽이 크면 오른쪽이 이동 
            #따라서 최대 지점에서 만나게됨
            if left_max <= right_max:
                volume += left_max - height[left]
                left += 1
            else:
                volume += right_max - height[right]
                right -= 1
        return volume

https://leetcode.com/problems/3sum

'''
배열을 입력받아 합으로 0을 만들 수 있는 3개의 요소를 출력하라
Input: nums = [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]

방법1)
두요소의 합*(-1) 에 해당되는 값이 있는지 확인한다.
-1 => [0, 1, 2, -1, -4]
=> 모든 요소를 다 더해봐야함 = n^3

방법2)
정렬을 한 뒤 비교(투포인터 방식으로 비교) => nlog(n) + n^2
1. 정렬
2. 기준점을 둠, 나머진 투포인터 방식으로 비교(left, right지정)
3. 중복값이 있을경우 넘어감(계산낭비)

'''

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        result=[]
        #1.정렬
        nums.sort()

        #2.기준값 두고 비교(마지막 값 2개는 사용하지 않음)
        for i in range(len(nums)-2):
            #중복값일 경우 제외
            if i > 0 and nums[i] == nums[i-1]:
                continue    

            left, right = i + 1, len(nums)-1

            while left < right:
                sum = nums[i] + nums[left] + nums[right]
                if sum < 0:
                    left += 1
                elif sum > 0:
                    right -= 1
                else:
                    result.append([nums[i], nums[left], nums[right]])

                    #현재 값과 같은 값을 가질 경우 중복 제거
                    #왼쪽확인
                    while left < right and nums[left] == nums[left + 1]:
                        left += 1
                    #오른쪽 확인
                    while left < right and nums[right] == nums[right - 1]:
                        right -= 1
                    #확인이 끝난 후 각 값을 다음번째 값으로 옮김
                    left += 1
                    right -= 1


        return result

https://leetcode.com/problems/array-partition-i/

'''
n개의 페어를 이용한 min(a,b)의 합으로 만들 수 있는 가장 큰 수를 출력하라.
Input: nums = [1,4,3,2]
Output: 4

Explanation: All possible pairings (ignoring the ordering of elements) are:
1. (1, 4), (2, 3) -> min(1, 4) + min(2, 3) = 1 + 2 = 3
2. (1, 3), (2, 4) -> min(1, 3) + min(2, 4) = 1 + 2 = 3
3. (1, 2), (3, 4) -> min(1, 2) + min(3, 4) = 1 + 3 = 4
So the maximum possible sum is 4.

방법1) 
정렬한 뒤, 뒤에서부터 2개씩 묶어 계산 = nlogn

방법2)
짝수번째 값이 항상 min값이 됨

방법3)
슬라이싱 사용

'''
class Solution:
    def arrayPairSum(self, nums: List[int]) -> int:
        '''
        nums.sort()
        result = 0
        pair = []
        '''

        '''
        =====================================================
        방법 1)
        =====================================================
        '''
        '''
        387ms = 속도 더 나음
        for i in range(len(nums)-1, 0, -2):
            #배열의 개수가 홀수인 경우
            if i != 0:
                result += min(nums[i], nums[i-1])
        '''


        '''
        514ms = 가독성 좋음
        for n in nums:
            pair.append(n)
            if len(pair) == 2:
                result += min(pair)
                pair = []
        '''

        '''
        =====================================================
        방법2) 276ms
        =====================================================
        '''
        '''
        if len(nums)%2 == 0:
            for i, n in enumerate(nums):
                if i%2 == 0:
                    result += n
        else:
            for i, n in enumerate(nums):
                if i%2 != 0:
                    result += n

        return result
        '''

        '''
        =====================================================
        방법3) 314ms
        =====================================================
        return sum(sorted(nums)[::2])
        '''

https://leetcode.com/problems/product-of-array-except-self/

'''
배열을 입력받아 output[i]가 자신을 제외한 나머지 모든 요소의 곱셈 결과가 되도록 출력하라.
단 나눗셈을 하지 않고 O(n) 에 풀어라

Input: nums = [1,2,3,4]
Output: [24,12,8,6]

방법1)
자기자신 제외하고 나머지 값들 곱함
자기 자신 제외하고 왼쪽 오른쪽 구분하여 서로 곱함

1 2 3 4

1. 1*(2*3*4)
2. (1)*(3*4)
3. (1*2)*(4)
4. (1*2*3)*1

왼쪽 1, 1, 2, 6
오른쪽 24, 12, 4, 1


'''

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        result = []
        tmp = 1

        #왼쪽
        for i in range(len(nums)):
            result.append(tmp)
            tmp = tmp * nums[i]

        tmp = 1
        #오른쪽 => 반대로
        for i in range(len(nums)-1, -1, -1):
            result[i] = result[i] * tmp
            tmp = tmp * nums[i]

        return result

https://leetcode.com/problems/best-time-to-buy-and-sell-stock/

'''
주식을 사고팔기 가장 좋은 시점

한번의 거래로 낼 수 있는 최대 이익을 산출하라.
Input: prices = [7,1,5,3,6,4]
Output: 5
2일날 1에 사서 5일날 6에 팔면 최대의 이익이다.

방법1)
현재 값보다 다음값이 크면, 현재 이후의 값중 최대값을 구하여 이익을 계산 => 예시의 경우 
1->5, 3->6 두가지의 경우를 계산해야한다.

방법2) 방법1 복잡도 줄여야
최소값과 최대 이익값을 갱신하면서 마지막에 차이를 구함


'''


class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        '''
        방법1) 시간 초과남
        max_profit = -1
        profit = 0

        leng = len(prices)

        for i in range(leng):
            if i < leng-1 and prices[i] < prices[i+1]:
                profit = max(prices[i:]) - prices[i]

            if max_profit < profit:
                max_profit = profit
        '''

        profit = -sys.maxsize-1
        min_price =  sys.maxsize

        #갱신
        for i in range(len(prices)):
            min_price = min(min_price, prices[i])
            profit = max(profit, prices[i]-min_price)

        return profit

isdigit(), isnumeric() => 글자가 숫자모양이면 true (3²같은 제곱과 같은 형태 가능)

isdecimal() => 주어진 무나졍리 int형으로 변환 가능한지 (3²같은 제곱과 같은 형태 불가능)

for _ in range(10):

_뜻은 변수가 없다는 뜻

input().split()시

split의 기본값이 ' ' 공백이다.

list생성시

a = []

a = list(range(10)) 과같이 가능

SWAP 시 temp 불필요

a = 3

b = 'abc'

temp = a

a = b

b = temp

파이썬에서는 다음과 같이 한 줄로 두 값을 바꿔치기할 수 있다.

a = 3 b = 'abc'

a, b = b, a 

is => ID비교

== => 값 비교

def fn(a) :

a의 타입이 무엇인지 몰라 버그 유발 가능

def fn(a: int) -> bool:

a가 정수형임을 알리고 리턴값이 true or false임을 알림

리스트 컴프리헨션 : 기존 리스트를 기반으로 새로운 리스트를 만들어내는 구문

[n*2 for n in range(1, 10+1) if n&2==1]
# [2,6,10,14,18]

#리스트 컴프리헨션을 사용하지 않는 경우
a=[]
for n in range(1, 10+1):
    if n % 2 == 1:
        a.append(n*2)

print(a)
# [2,6,10,14,18]

리스트외에도 딕셔너리등이 가능함

a={}
for key, value in original.items():
    a[key]=value


 #한줄로 표현 가능
 a = {key: value for key, value in original.items()}

제너레이터 : 루프의 반복 동작을 제어할 수 있는 루틴

ex) 숫자 1억개를 만들어내 계산하는 프로그램

! 제너레이터가 없으면 메모리 어딘가에 1억개의 숫자를 보관해야함

제너레이터를 생성해두고 필요할때 언제든 숫자를 만들 수 있음

1억개 숫자중 100개만 사용하는 경우, 제너레이터를 사용하는 것이 나음

#함수의 리턴값은 제너레이터가 됨
def get_natural_number():
    n = 0
    #while true이므로 계속해서 값을 내보냄
    while True:
        n+=1
        yield n

yield구문을 사용하면 제너레이터를 리턴할 수 있다.

(기존함수는 return 구문을 만나면 값을 리턴하고 함수의 동작을 종료함)

yield는 제너레이터가 여기까지 실행중이던 값을 내보낸다는 뜻

중간값을 리턴한 다음 함수는 종료되지 않고 끝까지 실행됨

g = get_natural_number()
for _ in range(0. 100):
    print(next(g)) #next로 값을 추출 할 수 있다.

 #1
 #2
 #.
 #.
 #.
 #99
 #100

여러 타입의 값을 하나의 함수에서 생성하는 것도 가능

def generator():
    yield 1
    yield 'string'
    yield True


g = generator()

next(g) #1
next(g) #'string'
next(g) #True

range : 제너레이터의 방식을 활용하는 대표적인 함수

list(range(5))
#[0,1,2,3,4]

range(5)
#range(0, 5)


type(range(5))
#<class 'range'>

for i in range(5):
    print(i, end=" ")
 #0 1 2 3 4

range()는 range클래스를 리턴

for문에서는 내부적으로 제너레이터의 next를 호출하듯 숫자 생성

만약) 숫자가 100만개라면?

# 1번
a = [n for n in range(1000000)]

#2번
b = range(10000000)


len(a) #1000000
len(b) #1000000

len(a) == len(b) #True

a #range(0, 1000000) => 생성된 값이 담겨있음
b #<class 'range'> => 생성해야한다는 조건만 있음


#따라서 크기를 비교해보면
sys.getsizeof(a) #8697464
sys.getsizeof(b) #48 => 1억개라도 메모리 점유율은 동일함, 생성조건만 보관하고 있기 때문이다.
#인덱스로 접근 시에는 바로 생성하도록 구현되어 있음
b[999] #999

enumerate : "열거하다" 여러가지 자료형을 인덱스를 포함한 enumerate객체로 리턴함

a = [1,2,3,2,45,2,5]
a #[1,2,3,2,45,2,5]

enumerate(a)
#<enumerate object at ~~~>


#list로 결과를 추출할 경우, 인덱스를 자동으로 부여해줌
list(enumerate(a))
#[(0,1), (1,2), (2,3), (3,2), (4,45), (5,2), (6,5)]


#인덱스와 값을 함께 출력??
a = ['a1', 'b2', 'c3']

#1번 => range사용
for i in range(len(a)):
    print(i, a[i])


#2번 => 인덱스 위한 변수 따로 선언
i = 0
for v in a:
    print(i, v)
    i += 1

#3번 => 인덱스와 값 함께 처리
for i, v in enumerate(a):
    i += 1

나눗셈

// => 정수형으로 유지

5/3
#1.66666666666666667

5//3
#1

5//3 = int(5/3)

#몫과 나머지 한번에 구함
divmod(5, 3)
#(1, 2)

print

콤마로 구분

print('A1', 'B2')
#>>A1 B2

파라미터로 구분자 지정

print('A1', 'B2', sep=',')
#구분자를 ,로 지정
#>>A1, B2

print 함수는 항상 줄바꿈을 한다. 따라서 루프의 값을 반복적으로 출력하려면 end 파라미터를 공백처리한다.

print('aa', end =' ')
print('bb')
#>> aa bb

리스트 출력시 join으로 묶어서 처리

a = ['A', 'B']
print(' '.join(a))
#>>A B

문자열 함께 출력

idx = 1
fruit = "Apple"
print('{0}: {1}'.format(idx + 1, fruit))
#>>2: Apple

#인덱스 생략도 가능
idx = 1
fruit = "Apple"
print('{}: {}'.format(idx + 1, fruit))
#>>2: Apple

f-string(formated string literal)

print(f'{idx+1}: {fruit}')
#>>2: Apple

pass

class MyClass(object):
    def method_a(self):

    def method_b(self):
        print("Method B")

c = MyClass()

위 코드는 실행되지 않는다.

method_a()가 아무런 처리를 하지 않았기 때문에 method_b()에서 오류가 발생한다.

pass는 이런 오류를 막는다.

class MyClass(object):
    def method_a(self):
        #pass 삽입
        pass


    def method_b(self):
        print("Method B")

c = MyClass()

pass는 null연산으로 아무 작업도 하지 않는다. 따라서 인덴트 오류같은 불필요한 오류를 방지한다.

pass를 사용하여 mockup 인터페이스부터 구현한 다음 추후 구현을 할 수 있게 된다.

locals

locals()는 로컬 심볼 테이블 딕셔너리를 가져오는 메소드이다.

로컬에 선언된 모든 변수를 조회할 수 있다.

...
import pprint
pprint.pprint(locals())
...

pprint로 출력하게 되면 클래스 메소드 내부의 모든 로컬변수를 출력해준다.

{'num':[2,7,11,15].
'pprint': >module 'pprint' from '/user/lib/python3.8/pprint.py'>,
'self':<__main__.Solution object at 0x~~~~>,
'target; : 9'}

int

숫자 정수형 int만 제공

int가 충분하지 않으면 자동으로 long 타입으로 변환됨

bool은 논리 자료형이지만 내부적으로 int로 처리된다.

Ture == 1
>>True
False == 0
>>True

매핑

키와 자료형으로 구성된 복합 자료형

유일한 매핑 자료형은 딕셔너리이다.

집합

set은 중복된 값을 갖지 않는 자료형이다.

입력순서가 유지되지 않으며 중복된 값이 있을 경우 하나의 값만 유지한다.

a=set()
a
>>set()

type(a)
>><class 'set'>

{} 중괄호를 사용하여 선언함

a={'a','b','c'}

시퀀스

특정 대상의 순서있는 나열

str은 문자의 순서 있는 나열로 문자열을 이루는 자료형이고, list는 다양한 값들을 배열 형태의 순서있는 나열로 구성하는 자료형이다.

시퀀스는 불변(immutable)과 가변(mutable)로 구분한다.

불변 : 값을 변경할 수 없다. => str, tuple, bytes

a='abc' #abc할당
a='def' #def할당
type(a)
>><class 'str'>

a 변수에 처음 abc가 할당되고, 이후 다른 str타입인 def를 다시 참조했다.

a='abc'
id('abc')
>>4317530408
id(a)
>>4317530408

a='def'
id('def')
>>4318831648
id(a)
>>4318831648

각 메모리 주소를 보면 참조하는 주소가 바뀐 것을 알 수 있다.

변경되려면 다음과 같은 할당자가 처리되어야한다.

a[1]='d'
>> 오류 발생

하지만 오류가 발생한다.

가변 : 값을 변경할 수 있다. => list

list는 값을 추가/삭제할 수 있는 동적 배열이다.

# -*- coding: utf-8 -*-
"""
Created on Mon Feb 22 14:47:47 2021

@author: changmin
"""
'''
msg = "It is Time"
print(msg.upper()) #대문자로 결과물만, msg는 그대로 
print(msg.lower()) # 결과물만 소문자로
print(msg)

tmp = msg.upper()
print(tmp)
print(tmp.find('T')) # 문자열에서 해당 문자 인덱스 번호 반환(처음 발견한)
print(tmp.count('T')) # 문자열에서 해당 문자 개수 반환
print(msg[:2]) # 슬라이싱 => 처음부터 2개만
print(msg[3:5]) # 3번 인덱스부터 4번 인덱스 까지
print(len(msg)) # 문자열 길이 반환

for i in range(len(msg)):
    print(msg[i], end =" ") #  옆으로 출력
    
print()

for x in msg:
    print(x, end = " ")
print()

for x in msg:
    if x.isupper():
        print(x, end =' ')
    elif x.islower():
        print(x, end = ' ')
        
print('\n\n')
for x in msg:
    if x.isalpha():
        print(x, end=' ')

print()        
tmp = 'AZ'
for x in tmp:
    print(ord(x)) # 아스키 넘버 출력
    

tmp =65
print(chr(tmp))
'''

'''
리스트와 내장함수(1)
'''
'''
import random as r
a=[]
print(a)
b = list()

a=[1, 2, 3, 4, 5]
print(a)
print(a[0])

b = list(range(1, 11))
print(b)

c=a+b
print(c)

print('\n\n\n')

print(a)
a.append(6)
print(a)

a.insert(3, 7) # 3번 인덱스에 7넣음
print(a)

a.pop() # 맨 뒤 인덱스 없앰
print(a)

a.pop(3) # 3번 인덱스 없앰
print(a)

a.remove(4) # 4라는 값 제거
print(a)

print(a.index(5)) # 5라는 값이 있는 인덱스 번호를 반환

d=list(range(1, 11))
print(d)

print(sum(d)) # 리스트 안의 합을 반환

print(max(d)) # 리스트중 가장 큰값 찾아줌

print(min(d)) # 작은값 반환

print(min(7, 5)) # 인자값들 중 최소값을 찾아줌

print(min(7, 3, 5))

print(d)
r.shuffle(d) # 값 섞음
print(d)

d.sort() # 오름차순
print(d)

d.sort(reverse = True) # 내림차순
print(d)

d.clear() # 리스트 값들 다 삭제
print(d)
'''



'''

'''
#리스트와 내장함수 2
'''

a =[23, 12, 36, 53, 19]
print(a[:3]) # 슬라이싱
print(a[1:4]) 
print(len(a)) # 길이 출력

for i in range(len(a)):
    print(a[i], end=' ')    
print()

for x in a:
    print(x, end = ' ')
print()

for x in a:
    if x%2 == 1:
        print(x, end = ' ')
print()
    
# 튜플로 출력
# enumerate => (0,23) (1,36) ..... (4,19) 
for x in enumerate(a):
    print(x[0], x[1])
    
for index, value in enumerate(a):
    print(index, value)
print()

# all => 모두 참이면 참을 리턴
if all(50>x for x in a):
    print('Yes')
else:
    print('No')
    
# any => 한번이라도 참이면 참
if any(15>x for x in a):
    print('Yes')
else:
    print('No')

'''
#튜플
'''

b=(1, 2, 3, 4, 5)
print(b[0])
#b[0]=7 # 에러 튜플의 값은 변경 불가, 리스트의 값은 변경가능
#print(b[0])


'''

"""
'''
2차원 리스트 생성과 접근
'''

a= [0]*3
print(a)

a = [[0]*3 for _ in range(3)] # 크기가 3인 일차원 리스트 언더바는 변수없이 반복문만 돔 => 일차원 리스트 3번 만듦

a[0][1] = 2
print(a)
print()
#표처럼 출력
for x in a:
    print(x)

for x in a:
    for y in x:
        print(y, end =' ')

"""

'''
람다 함수 => 함수 이름이 없음
'''
'''

def plus_one(x):
    return x+1

print(plus_one(1))
'''

plust_two = lambda x: x+2

print(plust_two(1))


a = [1, 2, 3]
# map => 함수명, 자료 => 
def plus_one(x):
    return x+1

print(plus_one(1))

print(list(map(plus_one, a))) # a에 대해 plus one을 함

print(list(map(lambda x:x+1, a))) # a에 대해 plus one을 함