그리운 사람을 그리워하는 것은 아직 몸의 감각이 생생히 살아 있다는 증거다. 길가에 핀 가을꽃 한 송이에 잠시 눈길이 머무른다. 알알이 달려 있는 열매와 그 나무를 들여다볼 여유도 갖는다. 가을의 들머리에 서본다. 몸속에 숨어 있던 예민한 감각들이 뾰족뾰족 고개를 들기 시작한다. 순간순간 숨이 멎었다가 날숨에 실려 나오며 울컥거린다. 바람은 내 곁을 스치며 잘 살아보라고 어깨를 툭툭 치고 간다.
- 김삼환의 《사랑은 내가 주어가 아니라는 것을 알려주었다》 중에서 -
* 30년 넘게 함께 살던 아내를 불의의 사고로 떠나보낸 이가 쓴 글입니다. 떠난 아내가 사무치게 그리운 것은 그와 함께 했던 공간에서 함께 했던 시간을 떠올릴 때이고, 다시는 그와 함께 할 수 없음을 알 때입니다. 모든 것은 그대로인데 휑하니 가슴을 스쳐가는 바람은 숨죽인 감각을 건드리며 속삭입니다. 그러니 사는 동안 더 열심히 더 잘 살아가라고...
사람은 생후 9개월쯤이면, 그러니까 걸음마나 말을 떼기도 전에 이미 손짓을 시작한다. 물론 태어난 직후에도 손짓을 하지만 이 동작이 의미를 띠기 시작하는 것은 9개월이 지나서다. 손짓은 신기한 몸짓이다. 어떤 다른 동물도 손짓을 하지 않는다. 손이 있는 동물이라도 마찬가지다.
- 브라이언 헤어, 버네사 우즈의 《다정한 것이 살아남는다》 중에서 -
* 대화를 할 때 사람들은 무의식적으로 손짓을 합니다. 손짓을 보노라면 그 사람의 의중이 더 잘 읽힙니다. 때로 우리는 말없이 아이의 머리를 쓰다듬거나 사랑하는 이의 몸을 만집니다. 손짓은 말보다 더 많은 뜻을 전달하기도 합니다. 손짓 하나로 더 가까워지고 손짓 하나로 멀어집니다.
버블 정렬은 바로 옆에 있는 것과 비교해서 정렬하는 것입니다. 구현은 쉽지만 효율성이 매우 낮다고 알려져 있습니다.
선택 정렬(Selection Sort)
데이터를 선택 정렬은 배열에서 작은 데이터를 선별하여서 데이터를 앞으로 보내는 정렬의 일종입니다. 이 정렬도 효율은 낮습니다.
삽입 정렬(Insertion Sort)
삽입 정렬은 자료 배열의 모든 요소를 앞에서부터 차례대로 이미 정렬된 배열 부분과 비교하여, 자신의 위치를 찾아 삽입함으로써 정렬을 완성하는 알고리즘입니다.
퀵 정렬(Quick Sort)
퀵 정렬은 찰스 앤터니 리처드 호어가 개발한 정렬 알고리즘이다. 다른 원소와의 비교만으로 정렬을 수행하는 비교 정렬에 속한다. 퀵 정렬은 n개의 데이터를 정렬할 때, 최악의 경우에는 O(n²)번의 비교를 수행하고, 평균적으로 O(n log n)번의 비교를 수행합니다.
병합 정렬(Merge Sort)
합병 정렬 또는 병합 정렬은 O(n log n) 비교 기반 정렬 알고리즘이다. 일반적인 방법으로 구현했을 때 이 정렬은 안정 정렬에 속하며, 분할 정복 알고리즘의 하나 입니다.
힙 정렬(Heap Sort)
힙 정렬이란 최대 힙 트리나 최소 힙 트리를 구성해 정렬을 하는 방법으로서, 내림차순 정렬을 위해서는 최소 힙을 구성하고 오름차순 정렬을 위해서는 최대 힙을 구성하면 됩니다.
기수 정렬(Radix Sort)
기수 정렬은 기수 별로 비교 없이 수행하는 정렬 알고리즘이다. 기수로는 정수, 낱말, 천공카드 등 다양한 자료를 사용할 수 있으나 크기가 유한하고 사전순으로 정렬할 수 있어야 한다. 버킷 정렬의 일종으로 취급되기도 합니다.
계수 정렬(Count Sort)
계수 정렬 또는 카운팅 소트는 컴퓨터 과학에서 정렬 알고리즘의 하나로서, 작은 양의 정수들인 키에 따라 객체를 수집하는 것, 즉 정수 정렬 알고리즘의 하나 입니다.
# 정렬 알고리즘 : https://modulabs.co.kr/blog/algorithm-python/
import random
class Sort :
def bubble_sort(arr):
for i in range(len(arr)):
for j in range(len(arr) - i - 1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]
return arr
def selection_sort(arr):
for i in range(len(arr)):
min_index = i
for j in range(i+1, len(arr)):
if arr[min_index] > arr[j]:
min_index = j
arr[i], arr[min_index] = arr[min_index], arr[i]
return arr
def quick_sort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left, right, equal = [], [], []
for i in arr:
if i < pivot:
left.append(i)
elif i > pivot:
right.append(i)
else:
equal.append(i)
return Sort.quick_sort(left) + equal + Sort.quick_sort(right)
def merge_sort(arr):
if len(arr) < 2:
return arr
mid = len(arr) // 2
left = Sort.merge_sort(arr[:mid])
right = Sort.merge_sort(arr[mid:])
merged_arr = []
l = r = 0
while l < len(left) and r < len(right):
if left[l] < right[r]:
merged_arr.append(left[l])
l += 1
else:
merged_arr.append(right[r])
r += 1
merged_arr += left[l:]
merged_arr += right[r:]
return merged_arr
def heap_sort(arr):
def heapify(arr, n, i):
largest = i
l = 2 * i + 1
r = 2 * i + 2
if l < n and arr[i] < arr[l]:
largest = l
if r < n and arr[largest] < arr[r]:
largest = r
if largest != i:
arr[i], arr[largest] = arr[largest], arr[i]
heapify(arr, n, largest)
n = len(arr)
for i in range(n, -1, -1):
heapify(arr, n, i)
for i in range(n-1, 0, -1):
arr[i], arr[0] = arr[0], arr[i]
heapify(arr, i, 0)
return arr
def radix_sort(arr):
RADIX = 10
placement = 1
max_digit = max(arr)
while placement < max_digit:
buckets = [list() for _ in range(RADIX)]
for i in arr:
tmp = int((i / placement) % RADIX)
buckets[tmp].append(i)
a = 0
for b in range(RADIX):
buck = buckets[b]
for i in buck:
arr[a] = i
a += 1
placement *= RADIX
return arr
def counting_sort(arr):
max_value = max(arr)
m = max_value + 1
count = [0] * m
for a in arr:
count[a] += 1
i = 0
for a in range(m):
for c in range(count[a]):
arr[i] = a
i += 1
return arr
arr = [i for i in random.sample(range(10), 10)]
print("Original array: ", arr)
print("Bubble sort: ", Sort.bubble_sort(arr))
print("Selection sort: ", Sort.selection_sort(arr))
print("Quick sort: ", Sort.quick_sort(arr))
print("Merge sort: ", Sort.merge_sort(arr))
print("Heap sort: ", Sort.heap_sort(arr))
print("Radix sort: ", Sort.radix_sort(arr))
print("Counting sort: ", Sort.counting_sort(arr))
#sudoku puzzle create using python chatGPT
import random
def generate_solved_sudoku():
base = 3
side = base*base
# pattern for a baseline valid solution
def pattern(r,c): return (base*(r%base)+r//base+c)%side
# randomize rows, columns and numbers (of valid base pattern)
def shuffle(s): return random.sample(s,len(s))
rBase = range(base)
rows = [ g*base + r for g in shuffle(rBase) for r in shuffle(rBase) ]
cols = [ g*base + c for g in shuffle(rBase) for c in shuffle(rBase) ]
nums = shuffle(range(1,base*base+1))
# produce board using randomized baseline pattern
board = [ [nums[pattern(r,c)] for c in cols] for r in rows ]
return board
def print_sudoku(board):
for i in range(9):
if i % 3 == 0 and i != 0:
print("- - - - - - - - - - - -")
for j in range(9):
if j % 3 == 0 and j != 0:
print("|", end=" ")
print(board[i][j], end=" ")
print()
def remove_numbers(board, difficulty_level):
"""
Remove numbers from the solved Sudoku grid based on the difficulty level.
"""
if difficulty_level == 'easy':
num_to_remove = 30 # Easy: 30 numbers removed
elif difficulty_level == 'medium':
num_to_remove = 40 # Medium: 40 numbers removed
else:
num_to_remove = 50 # Hard: 50 numbers removed
for _ in range(num_to_remove):
row = random.randint(0, 8)
col = random.randint(0, 8)
if board[row][col] != 0:
board[row][col] = 0
# Generate a solved Sudoku puzzle
solved_sudoku = generate_solved_sudoku()
# Print the solved Sudoku puzzle
print("Solved Sudoku Puzzle:")
print_sudoku(solved_sudoku)
# Create a copy of the solved puzzle
unsolved_sudoku = [row[:] for row in solved_sudoku]
# Remove numbers to create a puzzle
difficulty_level = 'medium' # Change difficulty level as needed ('easy', 'medium', 'hard')
remove_numbers(unsolved_sudoku, difficulty_level)
# Print the unsolved Sudoku puzzle (the generated puzzle)
print("\nUnsolved Sudoku Puzzle:")
print_sudoku(unsolved_sudoku)
