2025.01.07 ord에서 파생된 의문(ASCII 코드, 알고리즘)

 

ord() 함수는 파이썬의 내장 함수로 문자의 유니코드 코드 포인트(Unicode code point)를 반환한다.

즉 특정 문자의 ASCII 값이나 유니코드 값을 숫자로 반환.

 

ASCII 코드의 주요 범위

 

1. 대문자 알파벳 (A-Z)

ord('A') = 65
ord('Z') = 90

 

2. 소문자 알파벳 (a-z)

ord('a') = 97
ord('z') = 122

 

3. 숫자 (0-9)

ord('0') = 48
ord('9') = 57

 

4. 자주 사용되는 특수문자 예시

ord(' ') = 32  # 스페이스
ord('!') = 33  # 느낌표
ord('.') = 46  # 마침표
ord(',') = 44  # 쉼표

 

5. 제어 문자

 

• 0-31: 제어 문자들 (예: 개행문자 '\n' = 10)
• 127: DEL

 

 

 

 

파이썬에서 해결 못해?

 

 

ASCII 코드 대신 사용할만한 Python이 제공하는 문자 관련 메서드들

char = 'A'

# 대문자/소문자 확인
char.isupper()  # True
char.islower()  # False

# 알파벳 확인
char.isalpha()  # True

# 숫자 확인
char.isdigit()  # False

# 대소문자 변환
char.lower()  # 'a'
char.upper()  # 'A'

 

 

 

암호문제 처럼 문자열은?

 

 

알고리즘 문제나 암호화 문제에서는 ASCII 코드 값을 직접 다루는 경우가 많기 때문에 아래 내용은 외워두면 좋음

외워야할 ASCII 코드 값

1. 무조건 외우셈

ord('A') = 65  # 대문자 시작
ord('a') = 97  # 소문자 시작

 

2. 알고리즘에서 자주 쓰는 패턴

# 1. 알파벳을 0-25 인덱스로 변환
index = ord(char) - ord('A')  # 대문자의 경우
index = ord(char) - ord('a')  # 소문자의 경우

# 2. 0-25 인덱스를 다시 알파벳으로 변환
char = chr(index + ord('A'))  # 대문자로 변환
char = chr(index + ord('a'))  # 소문자로 변환

 

3. 자주 나오는 문제 유형

# 1. 알파벳 순환(rotation) - 카이사르 암호 등
def rotate(char, n):
    if char.isupper():
        return chr((ord(char) - ord('A') + n) % 26 + ord('A'))
    return chr((ord(char) - ord('a') + n) % 26 + ord('a'))

# 2. 알파벳 거리 계산
def distance(char1, char2):
    return abs(ord(char1) - ord(char2))

 

 

 

알고리즘에서 꼭 알아야 하는 핵심개념

일단 장고 강의 들어야해서 이런게 있다 정도만 보고 내일 하나씩 정리해보자...!

 

1. 시간복잡도와 공간복잡도

# O(1): 상수 시간
hash_map = {'key': 'value'}
value = hash_map['key']

# O(n): 선형 시간
for i in list:
    print(i)

# O(n²): 이중 반복문
for i in range(n):
    for j in range(n):
        print(i, j)

# O(log n): 이진 탐색
def binary_search(arr, target):
    left, right = 0, len(arr)-1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid

 

 

2. 자료구조의 특징과 시간복잡도

# List (배열)
array = [1, 2, 3]
array.append(4)      # O(1)
array.pop()         # O(1)
array.insert(0, 0)  # O(n)

# Dictionary (해시맵)
dict = {}
dict['key'] = 'value'  # O(1)
value = dict['key']    # O(1)

# Set (집합)
set_a = {1, 2, 3}
set_a.add(4)          # O(1)
2 in set_a            # O(1)

 

 

3. 주요 알고리즘 패턴

# 투 포인터
def two_pointer(arr, target):
    left, right = 0, len(arr)-1
    while left < right:
        current_sum = arr[left] + arr[right]
        if current_sum == target:
            return True
        elif current_sum < target:
            left += 1
        else:
            right -= 1

# 슬라이딩 윈도우
def sliding_window(arr, k):
    window_sum = sum(arr[:k])
    max_sum = window_sum
    
    for i in range(len(arr)-k):
        window_sum = window_sum - arr[i] + arr[i+k]
        max_sum = max(max_sum, window_sum)

 

 

4. 재귀와 DFS/BFS

# DFS (깊이 우선 탐색)
def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    
    for next in graph[start]:
        if next not in visited:
            dfs(graph, next, visited)

# BFS (너비 우선 탐색)
from collections import deque
def bfs(graph, start):
    visited = {start}
    queue = deque([start])
    
    while queue:
        vertex = queue.popleft()
        for neighbor in graph[vertex]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)

 

 

5. Python 특정 문법/함수

# 자주 쓰이는 내장 함수
max(), min(), sum(), len()
sorted()  # 정렬
reversed()  # 역순

# Collections 모듈
from collections import Counter, defaultdict, deque
counter = Counter(['a', 'b', 'a'])  # 요소 개수 세기
d = defaultdict(int)  # 기본값이 있는 딕셔너리
queue = deque()  # 양방향 큐

# List Comprehension
squares = [x**2 for x in range(10)]

 

 

6. 자주 나오는 테크닉

# 무한대 표현
INF = float('inf')

# 2차원 배열 생성
n, m = 3, 4
array_2d = [[0] * m for _ in range(n)]

# 방향 배열 (상하좌우)
dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]

 

 

 

 

공부할게 너뮤많타 🤯