주니어 개발자의 시작

level0_배열 회전시키기

깡나용 — Tue, 10 Dec 2024 21:15:30 +0900

내가 제출한 코드

def solution(numbers, direction):
    answer = []
    if direction == "right":
        answer.append(numbers[-1])  
        answer.extend(numbers[:-1])  
    else:
        
        answer.extend(numbers[1:])  
        answer.append(numbers[0])  
    return answer

answer.extend(numbers[:-1]) # 나머지 요소들을 추가
answer.extend(numbers[1:]) # 첫 번째 요소를 제외한 나머지를 추가

나는 extend랑 append가 헷갈려서 정리차 적어보았다.

numbers = [1, 2, 3, 4]
answer = []

# extend 사용
answer.extend(numbers[1:])
print(answer)
# 출력: [2, 3, 4]  # 각 요소가 추가됨

# append 사용
answer.append(numbers[1:])
print(answer)
# 출력: [[2, 3, 4]]  # 리스트 자체가 추가됨

다른 사람이 제출한 코드1

def solution(numbers, direction):
    return [numbers[-1]] + numbers[:-1] if direction == 'right' else numbers[1:] + [numbers[0]]

두 줄로..도 가능하구낭...

그리고 리스트끼리의 덧셈 ... 까먹고 있었다..

여기서 주의사항은 리스트 덧셈은 새로운 리스트를 생성하기 때문에, 덧셈 연산이 많아지면 성능에 영향을 줄 수 있다고 한다.

다른 사람이 제출한 코드2

from collections import deque

def solution(numbers, direction):
    numbers = deque(numbers)
    if direction == 'right':
        numbers.rotate(1)
    else:
        numbers.rotate(-1)
    return list(numbers)

collections 모듈의 deque(덱)를 사용하여 리스트를 지정된 방향으로 간편하게 회전시키는 함수이다.
numbers = deque(numbers)
- 여기서는 numbers 리스트를 덱으로 변환한다.
- 덱은 회전(rotate) 기능을 제공하므로, 리스트 회전 작업을 간단히 수행할 수 있다.
numbers.rotate()
- 덱을 n칸 회전한다.
- n > 0: 오른쪽으로 n칸 이동
- n < 0: 왼쪽으로 n칸 이동.

우와 사람들 진짜... 똑똑하다. deque, rotate... 노트에 다시 기록해둬야겠다.

level0_문자열 바꿔서 찾기

깡나용 — Tue, 10 Dec 2024 20:52:13 +0900

내가 제출한 코드

def solution(myString, pat):
    my = ""
    for i in myString:
        if i == "A":
            my += "B"
        else:
            my += "A"
    if pat in my:
        return 1
    else:   
        return 0

my는 변환된 문자열을 저장하기 위한 빈 문자열을 선언한다.
현재 문자가 "A"인 경우, "B"로 변환하여 my에 추가한다.
else
- 반대로 현자 문자가 "B"인 경우," A"로 변환하여 my에 추가한다.
if pat in transformed:
- 만약 변환된 문자열 my 안에 패턴 문자열 pat이 포함되어 있는 경우는 1을, 그렇지 않을 경우에는 0을 반환한다.

다른 사람이 제출한 코드

def solution(myString, pat):
    return int(pat in myString.replace('A', 'C').replace('B', 'A').replace('C', 'B'))

myString.replace('A', 'C')
- 문자열의 모든 'A'를 'C'로 바꿔준다.
.replace('B','A')
- 모든 'B'를 'A'로 바꿔준다.
.replace('C','B')
- 모든 'C'를 'B'로 바꿔준다.
pat in 변환된 문자열:
- 변환된 문자열에 pat이 포함되어 있으면 True(1), 포함되어 있지 않으면 False(0)를 반환한다.

근데 왜 a를 그냥 b로 바로 안바꾸고 c를 만들어 준 이유가 뭘까?

-> 코드에서 문자 A를 B로 바로 바꾸지 않고 중간 단계로 C를 거치는 이유는 문자 간 변환 충돌을 방지하기 위해서이다.

myString = "AB"
# 의도한 변환
# A → C → B
# B → A
# 결과: "BA"

# A → B로 바로 바꿔본다면:
myString = "AB"
myString = myString.replace('A', 'B')  # "BB"
myString = myString.replace('B', 'A')  # "AA"
# 결과: "AA" (원래 의도한 변환 "BA"와 다름)

level0_주사위 게임1

깡나용 — Wed, 4 Dec 2024 21:52:39 +0900

내가 제출한 코드

def solution(a, b):
    answer = 0
    if a % 2 ==1 and b % 2 ==1:
        answer += (a**2 + b**2)
    elif a % 2 == 1 or b % 2 ==1:
        answer += 2*(a+b)
    else:
        answer += abs(a - b)
    return answer

조건1: 두 수가 모두 홀수인 경우 (a % 2 == 1 and b % 2 == 1)
- 두 수의 제곱을 더한 값(a**2 + b**2)을 answer에 더한다.
조건2: 두 수 중 하나만 홀수인 경우 (a % 2 == 1 or b % 2 == 1)
- 두 수의 합에 2를 곱한 값(2 * (a + b))을 answer에 더한다.
조건 3: 두 수 모두 짝수인 경우 (위 조건을 모두 만족하지 않을 때)
- 두 수의 차의 절댓값(abs(a - b))을 answer에 더한다.
최종적으로 계산된 answer 값을 반환한다.

다른 사람이 제출한 코드

def solution(a,b):
    return a*a+b*b if a & b & 1 else (a+b) << 1  if (a | b) & 1 else abs(a - b)

이 함수는 삼항 연산자와 비트 연산자를 사용하여 입력된 a와 b의 값을 계산한다.

첫 번째 조건: a & b & 1
- a & b & 1은 비트 연산자로, a와 b의 가장 낮은 비트(1의 자리)가 모두 1인지 확인한다.
  - 즉, a와 b가 둘 다 홀수일 때 조건이 참
- 이 조건이 참이면 a * a + b * b를 반환한다.
두 번째 조건: (a | b) & 1
- 첫 번째 조건이 거짓이면, 두 번째 조건 (a | b) & 1이 평가된다.
- a | b는 a와 b 중 하나라도 홀수라면 참
- 이 조건이 참이면 (a + b) << 1을 반환
  - (a + b) << 1은 (a + b) * 2와 동일
  - 비트 연산자 <<는 값을 왼쪽으로 1비트 이동시켜 2배로 만든다.
abs(a - b)
- 위 조건이 모두 거짓이면, 두 수의 차의 절댓값 abs(a - b)를 반환

비트 연산자 &란?
- &는 두 숫자의 이진수 표현을 비교하여, 두 숫자의 각 자리 비트가 모두 1인 경우에만 1을 결과로 반환한다.
- 나머지 경우에는 0이 반환

level0_부분 문자열 이어 붙여 문자열 만들기

깡나용 — Tue, 3 Dec 2024 21:04:34 +0900

내가 제출한 코드

def solution(my_strings, parts):
    answer = ''
    for i in range(len(my_strings)):
        answer+= my_strings[i][parts[i][0]:parts[i][1]+1]
        
    return answer

part[i][0]와 part[i][1]은 각각 시작과 끝 인덱스를 나타낸다.
my_strings[i][ part[i][0] : part[i][1]+1]
- part[i][1]+1은 종료 인덱스는 포함되지 않으므로 +1을 더해 끝 인덱스를 포함시킨다.

다른 사람이 제출한 코드1

def solution(my_strings, parts):
    answer = ""
    for i, (s, e) in enumerate(parts):
        answer += my_strings[i][s:e+1]
    return answer

for i, (s, e) in enumerate(parts):
- i는 현재 parts에서의 인덱스이다.
- (s,e)는 parts의 요소로, 각각 시작과 끝 인덱스트를 나타낸다.
  - 예를 들어 parts = [[0, 4], [1, 2], [3, 5], [7, 7]]일때
    - 첫 번째 순회: i=0, (s, e)=(0, 4)
    - 두 번째 순회: i=1, (s, e)=(1, 2)
    - 세 번째 순회: i=2, (s, e)=(3, 5)
    - 네 번째 순회: i=3, (s, e)=(7, 7)
my_strings[i][s:e+1]
- my_strings의 i번째 문자열에서 s부터 e+1까지 슬라이싱한다.

댓글에

answer += 의 문제점
- 코드에서 answer는 문자열로 초기화되고, 반복문 안에서 answer+= my_strings[i][s:e+1]을 실행한다.
- 이 코드는 내부적으로 매번 새로운 문자열 객체를 생성하고, 기존의 문자열 데이터를 복사하여 새 객체를 만들게 된다.
- 반복 횟수가 많아질수록 추가적인 메모리 사용과 복사 작업으로 인해 성능이 저하된다.

수정하라고 말씀하신 걸 코드로 적어보면

def solution(my_strings, parts):
    answer = []  # 리스트로 초기화
    for i, (s, e) in enumerate(parts):
        answer.append(my_strings[i][s:e+1])  # 리스트에 부분 문자열 추가
    return ''.join(answer)  # 리스트의 문자열을 결합하여 반환

다른 사람이 제출한 코드2

def solution(my_strings, parts):
    return ''.join([x[y[0]:y[1]+1] for x,y in zip(my_strings, parts)])

zip(my_strings, parts)
- zip() 함수는 두 리스트(my_strings와 parts)를 동시에 순회하기 위해 사용
- zip()은 두 리스트의 요소를 튜플로 묶어준다.

my_strings = ["progressive", "hamburger", "hammer", "ahocorasick"]
parts = [[0, 4], [1, 2], [3, 5], [7, 7]]
list(zip(my_strings, parts)) 
# 결과: [("progressive", [0, 4]), ("hamburger", [1, 2]), ("hammer", [3, 5]), ("ahocorasick", [7, 7])]

예시다.

[x[y[0]:y[1]+1] for x, y in zip(my_strings, parts)]
- 여기서 x는 my_strings의 개별 문자열, y는 parts의 [start, end] 범위이다.
- x[y[0]:y[1]+1]는 x 문자열에서 y[0](시작)부터 y[1]+1(끝 포함)까지의 부분 문자열을 추출한다.

level0_배열의 원소 삭제하기

깡나용 — Thu, 28 Nov 2024 20:50:27 +0900

내가 제출한 코드

def solution(arr, delete_list):
    return list(filter(lambda x: x not in delete_list,arr))

아까 푼 문제와 비슷한거 같다.

다만 다른 점이 비교해야할 대상이 리스트라는 것이다.

arr 리스트에서 delete_list에 포함되지 않은 요소들만 추출하여 새로운 리스트로 반환한다.

https://pydole.tistory.com/84

[Python] 포함(Containment) 연산자 in, not in

파이썬에는 포함(Containment) 연산자를 ( in, not in ) 제공하며, 객체 in (not in) 시퀀스의 형태로 사용 가능하다. 1. 문자열(strings) ########### in ########### if 'p' in 'python': print(True) else: print(False) ---------------

pydole.tistory.com

level0_꼬리 문자열

깡나용 — Thu, 28 Nov 2024 20:33:59 +0900

내가 제출한 코드

def solution(str_list, ex):
    answer = ''
    for i in range(len(str_list)):
        if ex not in str_list[i]:
            answer+=str_list[i]
    return answer

str_list의 길이만큼 반복문을 실행한다.
if ex in not in str_list[i]
- 만약 str_list[i]에 ex가 포한되지 않을 경우
- answer에 str_list[i]fmf 추가한다.
- 여기서, += 연산자는 문자열을 이어 붙이는 역할을 한다.

다른 사람이 제출한 코드

def solution(str_list, ex): 
    return ''.join(filter(lambda x: ex not in x, str_list))

filter 함수는 특정 조건을 만족하는 요소들만 걸러내는 함수이다.
filter 함수 사용법
- filter(함수, 반복 가능한 데이터)
- 여기서 lambda x : ex not in x 가 조건 함수로 사용된다.
- 요소 x가 ex를 포함하지 않을 때, True를 반환한다.
''.join
- join은 문자열 리스트의 요소들을 하나의 문자열로 이어붙이는 메서드이다.

https://www.youtube.com/watch?v=ge9J92wy0nE&list=PLa9dKeCAyr7iWPMclcDxbnlTjQ2vjdIDD

filter랑 lamba를 찾다보니 좋은 유튜브를 발견했다.

더 자세히 공부해보는것도 좋은거 같다!

참고하다보니 reduce도 알게되었다..ㅎㅎ

level0_배열의 길이에 따라 다른 연산하기

깡나용 — Tue, 26 Nov 2024 21:16:12 +0900

내가 제출한 코드

def solution(arr, n):
    if len(arr) % 2 == 1:
        arr = [x+ n if i % 2 == 0 else x for i,x  in enumerate(arr)]
    else:
        arr=[x+ n if i % 2 == 1 else x for i,x  in enumerate(arr)]
    return arr

if len(arr) % 2 == 1
- 만약에 arr의 길이가 홀수라면
arr = [x+ n if i % 2 == 0 else x for i,x in enumerate(arr)]
- enumerate(arr)는 arr 배열의 요소( x)와 해당 요소의 인덱스(i)를 동시에 제공한다.
- if i % 2 == 0
  - arr배열 요소의 인덱스가 짝수라면
- x+n
  - arr배열의 요소에 n을 더한다.
- else x
  - arr배열 요소의 인덱스가 홀수라면 x

else문도 위와 동일하다.

다른 사람이 제출한 코드1

내가 한줄...코드를 보았다...

def solution(arr, n):
	return [x + n*((len(arr)+i) % 2) for i,x in enumerate(arr)]

감탄....

만만세..

x + n *((len(arr)+i)%2)
- arr의 리스트의 길이와 인덱스를 더한 값을 2로 나눈 나머지
- 0 또는 1의 값을 가진다.

다른 사람이 제출한 코드2

사실... 나도 range 범위를 쓰려고 했는데.. 머리는 아는데 손이 움직여지지 않았던 코드였다.

def solution(arr, n):
    N=len(arr)
    if N % 2 : # 홀수라면(TRUE는 1)
    	for i in range(0,N,2):
        	arr[i] += n # 난.. 여기서 막혀버렸다..
    else:
    	for i in range(1,N,2):
        	arr[i] += n
    return arr

level0_배열의 원소만큼 추가하기

깡나용 — Mon, 25 Nov 2024 22:18:27 +0900

내가 제출한 코드

def solution(arr):
    answer = []
    for i in arr:
        answer+=[i] * i
    return answer

[i] * i 는 리스트 [i]를 i번 반복한 새로운 리스트를 생성한다.
여기서 나는 사실 append랑 += 연산자랑... 매우 헷깔렸다..
- 만약 append를 사용했더라면
  - answer.append([5] * 5)
    - 결과는 [[5,5,5,5,5]] 로 출력됐을 것이다.
- answer += [i] * i를 사용하면 리스트의 각 숫자를 원하는 만큼 병합하여 평평한(flat)리스트를 만들 수 있다.

다른 사람이 제출한 코드

def solution(arr):
    return [i for i in arr for j in range(i)]

나는 바보같이 왜 j가 필요한거지? 계속 혼자 고민하다... ㅜㅜ 단순히 반복 횟수를 제어하는 역할을 한다는 걸 발견하고.. 눈물을 흘렸다..

result = []
for i in arr: # arr에서 각 요소를 하나씩 가져옴
    for j in range(i): # 해당 요소의 값만큼 반복 (0부터 i-1까지)
    	result.append(i) # i를 result에 추가

이 코드는 위 코드와 동일하다.

level0_배열에서 문자열 대소문자 변환하기

깡나용 — Mon, 18 Nov 2024 21:44:55 +0900

내가 제출한 코드

def solution(strArr):
    answer = []
    for i in range(len(strArr)):
        if i % 2 == 0:
            answer.append(strArr[i].lower())
        else:
            answer.append(strArr[i].upper())
    return answer

i % 2 == 0:
- strArr[i].lower ()
  - 짝수 인덱스는 모두 소문자로 변환한다.
strArr[i].upper()
- 홀수 인덱스는 모두 대문자로 변환한다.

다른 사람이 제출한 코드

def solution(strArr):
    return [s.lower() if i % 2 ==0 else s.upper() for i,s in enumerate(strArr)]

리스트 컴프리헨션을 사용하였다.
enumerate(strArr)를 통해 인덱스(i)와 요소(s)를 동시에 가져온다.
s.lower() if i % 2 == 0 else s.upper()
- 인덱스 i가 짝수인경우 s.lower()로 변환한다.(소문자로)
- 인덱스 i가 홀수인 경우 s.upper()로 변환한다.(대문자로)
각 요소 s가 변환된 결과를 모아 새로운 리스트로 반환한다.

level0_짝수 홀수 개수

깡나용 — Mon, 18 Nov 2024 21:23:18 +0900

내가 제출한 코드

def solution(num_list):
    answer = [0,0]
    for i in num_list:
        answer[i % 2] += 1
    return answer

i가 짝수일 경우 i % 2 == 0 , i가 홀수일 경우 1이 나온다.
answer[0]-> 짝수, answer[1]-> 홀수 에 1씩 더해진다.

다른 사람이 제출한 코드

def solution(num_list):
    odd = sum(1 for n in num_list if n % 2)
    return [len(num_list) - odd, odd]

리스트 num_list의 각 요소 n을 순회하며 n % 2의 결과가 True(즉, n이 홀수)인 경우 1을 더한다.
- 1은 True 값을, 0은 False값을 반환한다.
- odd 변수는 리스트의 홀수 개수를 나타낸다.
len(num_list) - odd
- 짝수의 개수이다.