코딩테스트를 준비하면서 헷갈리거나 계속해서 구글링하게 되는 기본 문법들을 정리했다.

기본기

• Slice
  • [start:stop:step]
    • [::-1] : 뒤집기
    • [::2] : 짝수번째 인덱스만 봄
• 함수 작성
  • def 함수이름(인자1, 인자2):
• ord, chr
  • ord(문자) : 문자에 해당하는 유니코드를 반환한다.
  • chr(정수) : 정수에 해당하는 유니코드의 문자를 반환한다.
• Swap
  • a, b = b, a
• 절대값 구하기
  • abs(-1) → 1로 리턴
• enumerate 리스트나 문자열을 for문 돌릴 때 인덱스와 내용을 같이 사용할 수 있다.

  for i, letter in enumerate(['A', 'B', 'C'], start=1):
  		print(i, letter)
  
  1 A
  2 B
  3 C

• 비트 연산자

  >>> bin(0b1101 & 0b1001)    # 비트 AND
  '0b1001'
  >>> 13 & 9                  # 비트 AND
  9
  >>> bin(0b1101 | 0b1001)    # 비트 OR
  '0b1101'
  >>> 13 | 9                  # 비트 OR
  13
  >>> bin(0b1101 ^ 0b1001)    # 비트 XOR
  '0b100'
  >>> 13 ^ 9                  # 비트 XOR
  4
  >>> bin(~0b1101)            # 비트 NOT
  '-0b1110'
  >>> ~13                     # 비트 NOT
  -14

• any, all (flag)
  • all : 반복 가능한 자료형의 모든 요소가 True이면 True를 반환하는 함수.
  • any : 반복 가능한 자료형중 한 요소가 True이면 True를 반환하는 함수.

>>> all([1,2])
True
>>> all([1,0])
False
>>> all([0,0])
False
>>> all('abc')
True

>>> any([1,2])
True
>>> any([1,0])
True
>>> any([0,0])
False
>>> any('abc')
True

문자열

• 대체하기
  • replace(’aaa’, ‘bbb’, cnt) : 앞에서부터 'aaa'를 cnt번 찾아서 'bbb'로 바꾼 문자열 return.
    • aaa가 cnt번 밑으로 존재하면 그 개수만큼 바꾼다.
  • replace('aaa', 'bbb') : 모든 'aaa'를 찾아서 'bbb'로 바꾼 문자열 return
• 문자삭제
  • replace 문법 활용
    • replace('aaa', '', cnt)
  • strip 활용
    • 사용법
      • 왼쪽 끝에서 특정 문자 한번에 제거 : str1.lstrip(’삭제할 문자들’)
      • 오른쪽 끝에서 특정 문자 한번에 제거 : str1.rstrip(’삭제할 문자들’)
      • 양쪽 끝에서 특정 문자 한번에 제거 : str1.strip(’삭제할 문자들’)
    • 주의할 점
      • 순서대로 지워주는 것이 아닌 포함되어있는 모든 문자를 삭제한다.

        
        text = "dog.jpeg"
        text.strip(".jpeg")
        
        # text => "do"

• 정수로만 이루어졌는지 확인
  • isdigit(str1) ⇒ True, False 을 리턴해준다.
• 중복된 부분 중복 제거 “abcde…ddwef……er” → “abcde.ddwef.er”

  while '..' in answer:
          answer = answer.replace('..', '.')

• 정렬
  문자열을 리스트로 변환 → 리스트 정렬 → 리스트를 문자열로 변환

  
  s = "adfe"
  s.sort()					# wrong
  s2 = sorted(s)				# ['a','d','e','f'] 
  s3 = ''.join(sorted(s))		# "adef"

• 요소의 개수 구하기
  • str.count('a') : 'a'의 개수를 return
• 특정 인덱스 제거
  • 슬라이싱을 이용하는 방법이 대표적이다.

리스트

• 요소의 개수 구하기
  • ls.count(찾고자 하는 요소)
• n번째 요소 제거
  • ls.pop(n)
  • del ls[n]
• 일치하는 요소 제거
  • ls.remove(k) : 첫번째 k만 삭제
  • ls2 = [i for i in ls if i != k] : ls에서 k가 아닌 요소들만 모아서 새로운 리스트 생성
• 리스트 끼리의 뺄셈

  
  listA = ['사과', '딸기', '오렌지', '바나나']
  listB = ['귤', '감', '포도', '사과', '바나나']
  
  listE = [x for x in listA if x not in listB]
  
  ['딸기', '오렌지']

• 리스트 중간에 삽입
  • ls.insert(3, [1,4]) → 3번째 인덱스 자리에 [1,4] 배열을 넣는다
• 리스트에서 열 추출하기

  • 예시

    a = [
        [0, 1],
        [2, 3],
        [4, 5],
        [6, 7],
        [8, 9],
    ]
    
    b = [i[0] for i in a]
    # b = [0, 2, 4, 6, 8]

딕셔너리

• 딕셔너리 정리
  • 설명
    • 대응관계를 나타낼 수 있는 자료형. Key : Value 형태로 저장된다.
  • 값 추가 & 수정

    d1 = {'one' : 3, 'two' : 2, 'three' : 3}#선언
    d1['one'] = 1 #값 수정
    d1['four'] = 4 #값 추가
    print(d1)
    # {'one' : 1, 'two" : 2, 'three' : 3, 'four' : 4}

  • 접근
    • key를 이용해 value 찾기

      print(d1['two'])       => 2출력
      print(d1.get('two'))   => 2출력

    • value를 이용해 key 찾기

      • items와 list 활용

        [key for key, value in d1.items() if value == 3]
        => ['three']

      • 반복적으로 찾아야 할 경우에는 key와 value를 바꾼 딕셔너리를 하나 더 생성한다.

        d2 = {value : key for key, value in d1.items()}

  • 삭제

    #방법 1
    d1.pop('two')
    
    #방법 2
    del(d1['two'])

  • 딕셔너리 두개 결합

    d1 = {1:10, 2:20}
    d2 = {1:100, 3:300}
    
    dic1.update(dic2)
    print(dic1)
    
    # {1: 100, 2: 20, 3: 300}

  • 정렬
    • Key값을 기준으로 정렬하기

      • dic → list

        # key 값을 기준으로 오름차순 정렬하여 리스트 출력
        print(sorted(dic))
        # key 값을 기준으로 내림차순 정렬한 리스트 출력 
        print(sorted(dic, reverse=True))

      • dic → dic

        # key 값을 기준으로 정렬된 (key,value) 원소쌍을 가진 리스트 출력 
        print(sorted(dic.items()))
        
        # key 값을 기준을 정렬된 딕셔너리 생성 
        dic = dict(sorted(dic.items()))
        print(dic)

    • Value값을 기준으로 정렬하기

      # value 값을 기준으로 오름차순 정렬하여 (k, v) 리스트 반환
      print(sorted(dic.items(), key=lambda x:x[1]))
      # 위 값을 딕셔너리로 변환
      print(dict(sorted(dic.items(), key=lambda x:x[1])))
      # value 값을 기준으로 오름차순 정렬
      print(sorted(dic,key=lambda x:dic[x]))

알고리즘

• 최대공약수, 최소공배수 알고리즘

  • 최대공약수(GCD) : n과 m의 최대 공약수는 m과 n%m 의 최대공약수와 같다.
    n%m 이 0이 될 때 까지 재귀로 구한다.

    def gcd(n, m):
        if n % m == 0:
            return m
        else:
            return gcd(m, n % m)

  • 최소공배수(LCM) : 최대공약수를 구한 후 n과 m을 같이 곱해준다.

• 순열과 조합 : itertools를 사용하지 않으려면 DFS 사용하는 것이 일반적이다.

  • 순열

    import itertools
    
    arr = ['A', 'B', 'C']
    nPr = itertools.permutations(arr, 2)
    print(list(nPr))
    
    결과 : [('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]

  • 조합

    import itertools
    
    arr = ['A', 'B', 'C']
    nCr = itertools.combinations(arr, 2)
    print(list(nCr))
    
    결과 : [('A', 'B'), ('A', 'C'), ('B', 'C')]

메모

계속해서 추가할 예정이며 추후에 보기좋게 정리할 예정이다.