Repository: dayds/aljalddakggalco
Pull request #50: [DSCT-57] GitHub PR 6주차
Author: login: NKyeong
Created: 2025-05-09T18:54:24Z | Merged: 2025-05-16T14:28:16Z

# 1181 단어 정렬
### 플로우
- 첫째 줄에 단어의 개수 N
- 길이가 짧은 것부터, 길이가 같으면 사전 순으로
- 중복은 제거
- 길이는 len 사용?
- 정렬 뭐 쓰지.. 삽입? 퀵?
- word 길이로 정렬해야 하는데 퀵으로 어떻게 쓸지 잘 모르겠음...

### 코드
```
# 입력 받기
N = int(input())
word = []

# 중복 제거하고 리스트 저장
for _ in range(N):
    w = input()
    if w not in word:
        word.append(w)

# 정렬 시작 ><
for i in range(1,len(word)):
    for j in range(i,0,-1):

        if (len(word[j]) < len(word[j-1]) # 길이로
                or (len(word[j]) == len(word[j-1]) and word[j] < word[j-1])): # 사전 순으로
            word[j], word[j - 1] = word[j - 1], word[j]

        else:
            break

for k in word:
    print(k)
```
```
N = int(input())
words = {input() for _ in range(N)}  # set으로 중복 제거
sorted_words = sorted(words, key=lambda x: (len(x), x))
print('\n'.join(sorted_words))
```

### 느낀점
위 코드는 시간 초과가 발생했는데 수정해도 시간 초과가 발생했다. 정렬 코드를 직접 작성하고 싶었는데 이것 때문에 시간 초과가 발생한 것 같다.
그래서 아래 코드는 지피티가 수정해준 코드인데 역시나 파이썬 내장함수를 쓰는게 현명하고 빠른 길이었다.
추가로 다른 사람들 코드도 찾아봤다. 나는 순서대로 길이 정렬 후 알파벳 정렬 순서로 생각하고 코드를 작성했는데 다른 코드는 그 반대로 했다. 왜 나는 이런 생각을 못하는 걸까...
- 알파벳으로 정렬(sort)하고 길이로 정렬(sort(key=len)


# 1517 버블소트
### 플로우
- N개의 수로 이루어진 수열
- 병합정렬
- swap의 count

### 코드
```
# 입력 받기
N = int(input())
arr = list(map(int,input().split()))

# swap count
k = 0

def merge(left, right):
    sorted_list = []
    i, j = 0, 0

    global k

    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            sorted_list.append(left[i])
            i += 1
        else:
            sorted_list.append(right[j])
            j += 1
            k += len(left)-i

    # 남은 값들을 삽입한다.
    while i < len(left):
        sorted_list.append(left[i])
        i += 1
    while j < len(right):
        sorted_list.append(right[j])
        j += 1

    return sorted_list


def merge_sort(array):
    if len(array) <= 1:
        return array

    mid = len(array) // 2
    left = merge_sort(array[:mid])
    right = merge_sort(array[mid:])

    return merge(left, right)

merge_sort(arr)
print(k)
```

### 느낀점
좀 더 간략하게 쓸 수 있었는데 너무 길게 작성된 느낌이다. 그래도 나름 잘 작성된 것 같아 기분이 좋다. 


Diff:
diff --git a/NaK/NaK_week12/BOJ_1181.py b/NaK/NaK_week12/BOJ_1181.py
new file mode 100644
index 0000000..c3e64a2
--- /dev/null
+++ b/NaK/NaK_week12/BOJ_1181.py
@@ -0,0 +1,45 @@
+# 첫째 줄에 단어의 개수 N
+# 길이가 짧은 것부터, 길이가 같으면 사전 순으로
+# 중복은 제거
+# 길이는 len 사용?
+# 정렬 뭐 쓰지.. 삽입? 퀵?
+## word 길이로 정렬해야 하는데 퀵으로 어떻게 쓸지 잘 모르겠음...
+
+# 입력 받기
+N = int(input())
+word = []
+
+# 중복 제거하고 리스트 저장
+for _ in range(N):
+    w = input()
+    if w not in word:
+        word.append(w)
+
+# 정렬 시작 ><
+for i in range(1,len(word)):
+    for j in range(i,0,-1):
+
+        if (len(word[j]) < len(word[j-1]) # 길이로
+                or (len(word[j]) == len(word[j-1]) and word[j] < word[j-1])): # 사전 순으로
+            word[j], word[j - 1] = word[j - 1], word[j]
+
+        else:
+            break
+
+for k in word:
+    print(k)
+
+
+# 시간초과 발생
+# 수정해도 시간초과 발생
+
+# 지피티가 알려준 코드
+N = int(input())
+words = {input() for _ in range(N)}  # set으로 중복 제거
+sorted_words = sorted(words, key=lambda x: (len(x), x))
+print('\n'.join(sorted_words))
+
+# 파이썬 내장 함수가 좋긴하구나...
+# 나는야 빡대가뤼
+
+# 다른 사람은 알파벳으로 정렬(sort)하고 길이로 정렬(sort(key=len)했는데 왜 난 반대로할 생각을 못했을까...
\ No newline at end of file
diff --git a/NaK/NaK_week12/BOJ_1517.py b/NaK/NaK_week12/BOJ_1517.py
new file mode 100644
index 0000000..4e1d7b1
--- /dev/null
+++ b/NaK/NaK_week12/BOJ_1517.py
@@ -0,0 +1,49 @@
+# N개의 수로 이루어진 수열
+# 병합정렬
+# swap의 count
+
+# 입력 받기
+N = int(input())
+arr = list(map(int,input().split()))
+
+# swap count
+k = 0
+
+def merge(left, right):
+    sorted_list = []
+    i, j = 0, 0
+
+    global k
+
+    while i < len(left) and j < len(right):
+        if left[i] <= right[j]:
+            sorted_list.append(left[i])
+            i += 1
+        else:
+            sorted_list.append(right[j])
+            j += 1
+            k += len(left)-i
+
+    # 남은 값들을 삽입한다.
+    while i < len(left):
+        sorted_list.append(left[i])
+        i += 1
+    while j < len(right):
+        sorted_list.append(right[j])
+        j += 1
+
+    return sorted_list
+
+
+def merge_sort(array):
+    if len(array) <= 1:
+        return array
+
+    mid = len(array) // 2
+    left = merge_sort(array[:mid])
+    right = merge_sort(array[mid:])
+
+    return merge(left, right)
+
+merge_sort(arr)
+print(k)
\ No newline at end of file
diff --git "a/NaK/NaK_week12/PGS_7\354\235\230\352\260\234\354\210\230.py" "b/NaK/NaK_week12/PGS_7\354\235\230\352\260\234\354\210\230.py"
new file mode 100644
index 0000000..8e9819b
--- /dev/null
+++ "b/NaK/NaK_week12/PGS_7\354\235\230\352\260\234\354\210\230.py"
@@ -0,0 +1,17 @@
+# 머쓱이는 행운의 숫자 7을 가장 좋아합니다.
+# 정수 배열 array가 매개변수로 주어질 때, 7이 총 몇 개 있는지 return 하도록 solution 함수를 완성해보세요.
+
+def solution(array):
+    answer = ""
+
+    for i in array:
+        answer += str(i)
+
+    return answer.count("7")
+
+
+# 다른 사람의 풀이
+def solution(array):
+    return str(array).count('7')
+
+## 와...
\ No newline at end of file
diff --git "a/NaK/NaK_week12/PGS_\353\250\270\354\223\261\354\235\264\353\263\264\353\213\244\355\202\244\355\201\260\354\202\254\353\236\214.py" "b/NaK/NaK_week12/PGS_\353\250\270\354\223\261\354\235\264\353\263\264\353\213\244\355\202\244\355\201\260\354\202\254\353\236\214.py"
new file mode 100644
index 0000000..a2f3fad
--- /dev/null
+++ "b/NaK/NaK_week12/PGS_\353\250\270\354\223\261\354\235\264\353\263\264\353\213\244\355\202\244\355\201\260\354\202\254\353\236\214.py"
@@ -0,0 +1,19 @@
+# 머쓱이는 학교에서 키 순으로 줄을 설 때 몇 번째로 서야 하는지 궁금해졌습니다.
+# 머쓱이네 반 친구들의 키가 담긴 정수 배열 array와 머쓱이의 키 height가 매개변수로 주어질 때,
+# 머쓱이보다 키 큰 사람 수를 return 하도록 solution 함수를 완성해보세요.
+
+def solution(array, height):
+    k = 0
+
+    for i in array:
+        if height < i:
+            k += 1
+
+    return k
+
+
+# 다른 사람의 풀이
+def solution(array, height):
+    array.append(height)
+    array.sort(reverse=True)
+    return array.index(height)
\ No newline at end of file
diff --git "a/NaK/NaK_week12/PGS_\354\236\230\353\235\274\354\204\234\353\260\260\354\227\264\353\241\234\354\240\200\354\236\245\355\225\230\352\270\260.py" "b/NaK/NaK_week12/PGS_\354\236\230\353\235\274\354\204\234\353\260\260\354\227\264\353\241\234\354\240\200\354\236\245\355\225\230\352\270\260.py"
new file mode 100644
index 0000000..d4462d3
--- /dev/null
+++ "b/NaK/NaK_week12/PGS_\354\236\230\353\235\274\354\204\234\353\260\260\354\227\264\353\241\234\354\240\200\354\236\245\355\225\230\352\270\260.py"
@@ -0,0 +1,4 @@
+# 문자열 my_str과 n이 매개변수로 주어질 때, my_str을 길이 n씩 잘라서 저장한 배열을 return하도록 solution 함수를 완성해주세요.
+
+def solution(my_str, n):
+    return [my_str[i:i+n] for i in range(0,len(my_str),n)]
\ No newline at end of file
diff --git "a/NaK/NaK_week12/PGS_\354\244\221\353\263\265\353\220\234\354\210\253\354\236\220\352\260\234\354\210\230.py" "b/NaK/NaK_week12/PGS_\354\244\221\353\263\265\353\220\234\354\210\253\354\236\220\352\260\234\354\210\230.py"
new file mode 100644
index 0000000..de3c582
--- /dev/null
+++ "b/NaK/NaK_week12/PGS_\354\244\221\353\263\265\353\220\234\354\210\253\354\236\220\352\260\234\354\210\230.py"
@@ -0,0 +1,5 @@
+# 정수가 담긴 배열 array와 정수 n이 매개변수로 주어질 때,
+# array에 n이 몇 개 있는 지를 return 하도록 solution 함수를 완성해보세요.
+
+def solution(array, n):
+    return array.count(n)
\ No newline at end of file


Reviews:
user: login: sohds
body: 전반적으로 열심히 고생하셔서 푼 흔적이 보이네요. 고생하셨습니다!
state: APPROVED
author_association: CONTRIBUTOR
submitted_at: 2025-05-11T14:29:12Z
user: login: NKyeong
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-05-11T14:42:49Z

Review comments:
diff_hunk: @@ -0,0 +1,45 @@
+# 첫째 줄에 단어의 개수 N
+# 길이가 짧은 것부터, 길이가 같으면 사전 순으로
+# 중복은 제거
+# 길이는 len 사용?
+# 정렬 뭐 쓰지.. 삽입? 퀵?
+## word 길이로 정렬해야 하는데 퀵으로 어떻게 쓸지 잘 모르겠음...
+
+# 입력 받기
+N = int(input())
+word = []
+
+# 중복 제거하고 리스트 저장
+for _ in range(N):
+    w = input()
+    if w not in word:
+        word.append(w)
+
+# 정렬 시작 ><
+for i in range(1,len(word)):
+    for j in range(i,0,-1):
+
+        if (len(word[j]) < len(word[j-1]) # 길이로
+                or (len(word[j]) == len(word[j-1]) and word[j] < word[j-1])): # 사전 순으로
+            word[j], word[j - 1] = word[j - 1], word[j]
+
+        else:
+            break
+
+for k in word:
+    print(k)
+
+
+# 시간초과 발생
+# 수정해도 시간초과 발생
+
+# 지피티가 알려준 코드
+N = int(input())
+words = {input() for _ in range(N)}  # set으로 중복 제거
+sorted_words = sorted(words, key=lambda x: (len(x), x))
+print('\n'.join(sorted_words))
+
+# 파이썬 내장 함수가 좋긴하구나...
+# 나는야 빡대가뤼
path: NaK/NaK_week12/BOJ_1181.py
user: login: sohds
body: ㅋㅋㅋㅋㅋㅋ 깨알 주석 처리 귀엽네요 ㅎ 다른 누군가의 코드를 보고 깨달은 지점까지 좋습니다!
created_at: 2025-05-11T14:24:15Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,45 @@
+# 첫째 줄에 단어의 개수 N
+# 길이가 짧은 것부터, 길이가 같으면 사전 순으로
+# 중복은 제거
+# 길이는 len 사용?
+# 정렬 뭐 쓰지.. 삽입? 퀵?
+## word 길이로 정렬해야 하는데 퀵으로 어떻게 쓸지 잘 모르겠음...
+
+# 입력 받기
+N = int(input())
+word = []
+
+# 중복 제거하고 리스트 저장
+for _ in range(N):
+    w = input()
+    if w not in word:
+        word.append(w)
+
+# 정렬 시작 ><
+for i in range(1,len(word)):
+    for j in range(i,0,-1):
+
+        if (len(word[j]) < len(word[j-1]) # 길이로
+                or (len(word[j]) == len(word[j-1]) and word[j] < word[j-1])): # 사전 순으로
+            word[j], word[j - 1] = word[j - 1], word[j]
+
+        else:
+            break
+
+for k in word:
+    print(k)
+
+
+# 시간초과 발생
+# 수정해도 시간초과 발생
+
+# 지피티가 알려준 코드
+N = int(input())
+words = {input() for _ in range(N)}  # set으로 중복 제거
+sorted_words = sorted(words, key=lambda x: (len(x), x))
+print('\n'.join(sorted_words))
+
+# 파이썬 내장 함수가 좋긴하구나...
+# 나는야 빡대가뤼
path: NaK/NaK_week12/BOJ_1181.py
user: login: sohds
body: 파이썬 내장함수인 `sorted()` 는 병합 정렬을 기반으로 만들어졌는데, 병합 정렬은 일반적으로 퀵 정렬보다 느리지만 최악의 경우에도 시간 복잡도 O(NlogN)을 보장한다는 특징이 있다고 합니다.

나경님이 기존에 작성하신 코드는 for문을 일단 2번 돌기 때문에, O(n^2)이 되어 아마 시간초과가 뜨지 않을까 싶네요!
created_at: 2025-05-11T14:26:56Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,49 @@
+# N개의 수로 이루어진 수열
path: NaK/NaK_week12/BOJ_1517.py
user: login: sohds
body: 오... 처음부터 병합정렬로 풀이하셨나요? 1번보단 2번이 훨씬 어려웠을 것 같은데!

저는 함수 안에 함수를 또 지정해서 진행했는데, 확실히 이렇게 따로따로 있는게 더 직관적으로 이해가 잘되는 것 같긴 하네요,
created_at: 2025-05-11T14:28:45Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,49 @@
+# N개의 수로 이루어진 수열
path: NaK/NaK_week12/BOJ_1517.py
user: login: NKyeong
body: 예린님 코멘트 참고해서 아예 병합정렬로 시작했어요. 코드는 노션에 있는 코드 참고했습니다.
created_at: 2025-05-11T14:42:49Z
author_association: COLLABORATOR

PR comments:
user: login: notion-workspace[bot]
created_at: 2025-05-10T07:36:33Z
body: <a href="https://www.notion.so/w6-1ef5a691af8a8039ad66d84ca0ed7c2d?pvs=8&n=github_linkback">[w6] 이나경 코드 제출</a>
author_association: NONE
user: login: N4YE
created_at: 2025-05-11T14:56:59Z
body: ### 1. 단어 정렬
저는 사실 정렬의 종류를 깊게 생각하고 문제를 푼 것은 아니고 기존에 알선 sorted()를 사용해서 풀어야겠다고만 생각했는데, 그래도 퀵인지 병합인지 버블인지 등등 고민하신 부분이 좋은 것 같습니다. 코드 부분은 서연님이 첨삭해주신 것 같아서 넘어갈게요!
   
---
### 2. 버블 소트
함수를 2개로 나누어 두는 풀이는 또 처음 보는 것 같아요! 서연님과 저는 start와 end로 나누어 <= 기호를 통해 if문을 사용하였는데, 아예 나눠두니까 코드가 간결하게 보이는 것 같네요. 병합 정렬에 대해 여러모로 공부를 할 수 있었던 것 같아 유익합니다.
   
수고하셨습니다! 😍
author_association: COLLABORATOR