알아둘 것
#현재 사용중인 버전 확인
$nvm current
#nvm으로 설치된 node.js 목록 확인
$nvm ls
#특정 버전의 노드를 사용하는 명령어 입력
nvm use <version>
#특정 버전의 노드가 설치되어 있지 않은 경우, 설치
npm install <version>
Detached Head: head가 branch로 부터 떨어져있는 상태를 말함.
branch 를 통해서가 아닌 직접 다이렉트로 commit을 참조하고 있는 상태를 말함.
git 에서 head는 단 하나만 존재하며, 시작점 같은 개념이라고 한다.
head는 특정 branch를 가리키고 그 branch는 해당 branch의 마지막 commit을 가리킨다.
보통의 경우엔 head-> branch -> commit 의 참조순서를 가진다.
하지만 이 때, check out 명령어로 특정 커밋으로 check out할 경우, 깃은 참조하던 branch를 잃어버리고, 직접 특정 commit을 참조하는 detached head 상태가 된다.
git checkout <revision number>명령어를 사용해, 특정 커밋으로 check out할 경우 detached head상태가 된다.
출처: https://devcamus.tistory.com/6
고 한다. 근데 난 revision number 명령어를 사용해서 커밋하지 않았는데?;
아 내가 checkout 할 때 -b 옵션(브랜치 이름을 변경해서 가져올 수 있는 옵션, 로컬 저장소를 만들 수 있는 옵션) 혹은 -t(원격 브랜치를 이름 변경없이 로컬 저장소를 만들 수 있는 옵션)을 추가하여 명령어를 실행하지 않아서 임시로 해당 브랜치로 이동하게 되었고, 따라서 로컬 브랜치가 만들어지지 않았음. 그래서 HEAD detached at 상태였다.
git checkout -b 브랜치명 혹은 git checkout -t 브랜치명
명령어를 주면 로컬 브랜치를 만들 수 있다.
| [Git] 원격브랜치를 로컬환경에 가져오기 (0) | 2024.08.15 |
|---|---|
| [Git] 원본 저장소 원격 추가하기 (0) | 2024.07.29 |
| [Git]브랜치 관리 (1) | 2024.01.31 |
https://school.programmers.co.kr/learn/courses/30/lessons/87946
프로그래머스
코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.
programmers.co.kr
XX게임에는 피로도 시스템(0 이상의 정수로 표현합니다)이 있으며, 일정 피로도를 사용해서 던전을 탐험할 수 있습니다. 이때, 각 던전마다 탐험을 시작하기 위해 필요한 "최소 필요 피로도"와 던전 탐험을 마쳤을 때 소모되는 "소모 피로도"가 있습니다. "최소 필요 피로도"는 해당 던전을 탐험하기 위해 가지고 있어야 하는 최소한의 피로도를 나타내며, "소모 피로도"는 던전을 탐험한 후 소모되는 피로도를 나타냅니다. 예를 들어 "최소 필요 피로도"가 80, "소모 피로도"가 20인 던전을 탐험하기 위해서는 유저의 현재 남은 피로도는 80 이상 이어야 하며, 던전을 탐험한 후에는 피로도 20이 소모됩니다.
이 게임에는 하루에 한 번씩 탐험할 수 있는 던전이 여러개 있는데, 한 유저가 오늘 이 던전들을 최대한 많이 탐험하려 합니다. 유저의 현재 피로도 k와 각 던전별 "최소 필요 피로도", "소모 피로도"가 담긴 2차원 배열 dungeons 가 매개변수로 주어질 때, 유저가 탐험할수 있는 최대 던전 수를 return 하도록 solution 함수를 완성해주세요.
k는 1 이상 5,000 이하인 자연수입니다.
dungeons의 세로(행) 길이(즉, 던전의 개수)는 1 이상 8 이하입니다.
dungeons의 가로(열) 길이는 2 입니다.
dungeons의 각 행은 각 던전의 ["최소 필요 피로도", "소모 피로도"] 입니다.
"최소 필요 피로도"는 항상 "소모 피로도"보다 크거나 같습니다.
"최소 필요 피로도"와 "소모 피로도"는 1 이상 1,000 이하인 자연수입니다.
서로 다른 던전의 ["최소 필요 피로도", "소모 피로도"]가 서로 같을 수 있습니다.
k dungeons result
80 [[80,20],[50,40],[30,10]] 3
현재 피로도는 80입니다.
만약, 첫 번째 → 두 번째 → 세 번째 던전 순서로 탐험한다면
현재 피로도는 80이며, 첫 번째 던전을 돌기위해 필요한 "최소 필요 피로도" 또한 80이므로, 첫 번째 던전을 탐험할 수 있습니다. 첫 번째 던전의 "소모 피로도"는 20이므로, 던전을 탐험한 후 남은 피로도는 60입니다.
남은 피로도는 60이며, 두 번째 던전을 돌기위해 필요한 "최소 필요 피로도"는 50이므로, 두 번째 던전을 탐험할 수 있습니다. 두 번째 던전의 "소모 피로도"는 40이므로, 던전을 탐험한 후 남은 피로도는 20입니다.
남은 피로도는 20이며, 세 번째 던전을 돌기위해 필요한 "최소 필요 피로도"는 30입니다. 따라서 세 번째 던전은 탐험할 수 없습니다.
만약, 첫 번째 → 세 번째 → 두 번째 던전 순서로 탐험한다면
현재 피로도는 80이며, 첫 번째 던전을 돌기위해 필요한 "최소 필요 피로도" 또한 80이므로, 첫 번째 던전을 탐험할 수 있습니다. 첫 번째 던전의 "소모 피로도"는 20이므로, 던전을 탐험한 후 남은 피로도는 60입니다.
남은 피로도는 60이며, 세 번째 던전을 돌기위해 필요한 "최소 필요 피로도"는 30이므로, 세 번째 던전을 탐험할 수 있습니다. 세 번째 던전의 "소모 피로도"는 10이므로, 던전을 탐험한 후 남은 피로도는 50입니다.
남은 피로도는 50이며, 두 번째 던전을 돌기위해 필요한 "최소 필요 피로도"는 50이므로, 두 번째 던전을 탐험할 수 있습니다. 두 번째 던전의 "소모 피로도"는 40이므로, 던전을 탐험한 후 남은 피로도는 10입니다.
따라서 이 경우 세 던전을 모두 탐험할 수 있으며, 유저가 탐험할 수 있는 최대 던전 수는 3입니다.
1. dungeons에서 모두 나올 수 있는 순서에 대해 경우의 수를 순열로 뽑는다.
2. 리스트를 하나 만들고, 순열로 뽑은 모든 경우의 수에 대해서 조건을 따져가면서 던전에 방문한 횟수를 카운트 하여 최종적으로 카운트 한 수를 해당 리스트에 추가한다.
2-1. 위에서 말한 조건으로 각 던전의 최소 필요 피로도가 k와 같거나 커야지 던전에 방문할 수 있으니 해당하는 조건을 체크한다.
2-2. 만약 k가 특정 던전에 방문할 수 있다면 k에서 소모 피로도를 빼준다.
3. 2번에서 만든 리스트에서 max값을 구하여 출력한다.
from itertools import permutations
def solution(k, dungeons):
answer = -1
cpk=k
cases = list(permutations(dungeons, len(dungeons)))
checkList=[]
for i in range(len(cases)):
cpK=k
checkcheck = 0
for j in range(len(cases[i])):
if cpK >= cases[i][j][0]:
cpK = cpK - cases[i][j][1]
checkcheck += 1
else:
pass
if j == len(cases[i])-1:
checkList.append(checkcheck)
answer = max(checkList)
return answer
주석 포함 코드
from itertools import permutations
def solution(k, dungeons):
answer = -1
#print('k', k, 'dungeons', dungeons)
# 던전마다 탐험을 시작하기 위해 필요한 "최소 필요 피로도"
# 던전 탐험을 마쳤을 때 소모되는 "소모 피로도"
#최소 필요 피로도"가 80, "소모 피로도"가 20인 던전을 탐험하기 위해서는 유저의 현재 남은 피로도는 80 이상 이어야 하며, 던전을 탐험한 후에는 피로도 20이 소모됨
#하루에 한 번씩 탐험할 수 있는 던전이 여러개
# 1. dungeons는 [0]기준 MAX를 뽑는다.
# 2. dungeons의 순열을 뽑는다.
cpk=k
cases = list(permutations(dungeons, len(dungeons)))
#print(cases)
checkList=[]
#print("")
for i in range(len(cases)):
#maxx = cases[i][0][0]
cpK=k
#print("1 cpK", cpK)
checkcheck = 0
#print('i', i, cases[i])
for j in range(len(cases[i])):
#print('j', j, cases[i][j])
if cpK >= cases[i][j][0]:
cpK = cpK - cases[i][j][1]
#print('cpK', cpK)
checkcheck += 1
else:
pass
if j == len(cases[i])-1:
checkList.append(checkcheck)
#print("")
#print("")
#print(checkList)
answer= max(checkList)
return answer
최악의 경우 O(N^2)
하지않았다.
안풀어본 문제유형(완전탐색)이라 완전 쫄았다. 완전탐색 문제를 풀기위해서 대략 어떤 알고리즘이 필요한지 찾아보고 일단은 대충이라도 공부했다. (요즘 좀 바쁨) 암튼 대충 이런저런 방법으로 생각해보다가 문제를 풀었다 .
진짜 내가 이 문제를 푼거에 대해서 아주 놀랍다 하하 박수 ~~~ 짝짝~~
생각보다 진짜 별거아니네 !!! 쫄지마 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
| [프로그래머스 lv2]방문 길이 (1) | 2024.01.30 |
|---|---|
| [프로그래머스 lv1]실패율 (0) | 2024.01.29 |
| [프로그래머스 lv1]같은 숫자는 싫어 (0) | 2023.11.30 |
| [프로그래머스 lv2]소수 찾기 (0) | 2023.11.29 |
| [프로그래머스 lv1]모의고사 (1) | 2023.11.28 |
https://school.programmers.co.kr/learn/courses/30/lessons/12906
프로그래머스
코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.
programmers.co.kr
배열 arr가 주어집니다. 배열 arr의 각 원소는 숫자 0부터 9까지로 이루어져 있습니다. 이때, 배열 arr에서 연속적으로 나타나는 숫자는 하나만 남기고 전부 제거하려고 합니다. 단, 제거된 후 남은 수들을 반환할 때는 배열 arr의 원소들의 순서를 유지해야 합니다. 예를 들면,
배열 arr에서 연속적으로 나타나는 숫자는 제거하고 남은 수들을 return 하는 solution 함수를 완성해 주세요.
배열 arr의 크기 : 1,000,000 이하의 자연수
배열 arr의 원소의 크기 : 0보다 크거나 같고 9보다 작거나 같은 정수
arr answer
[1,1,3,3,0,1,1] [1,3,0,1]
[4,4,4,3,3] [4,3]
입출력 예 #1,2
문제의 예시와 같습니다.
stack을 이용하여 문제를 푼다.
1. stack 구실을 할 임의의 리스트를 하나 만든다.
2. arr의 원소를 순회하면서 임의의 리스트에 첫번째 원소를 push한다.
2-1. 첫번째 이후의 원소들은 임의의 리스트의 마지막에 push한 값을 pop을 통해 꺼낸다.
2-2. 2-1번을 통해 꺼낸 값과 현재 넣고자 하는 arr의 원소를 비교하여 값이 같으면 pass하고 같지 않으면 push 한다.
1. 효율성 통과하지 못한 코드
def solution(arr):
answer = []
# pivot 변수 = p
# 이전 pivot을 기억하는 변수 = pre_p
check = 0
pre_p = arr[0]
l=len(arr)
for i in range(1, len(arr)):
p = arr[i]
#print('p', p, 'pre_p', pre_p)
if pre_p == p:
pre_p = p
arr[i] = 10
# '-'를 세는 변수 = check
check+=1
else:
pre_p=p
for i in range(check):
arr.remove(10)
answer = arr
return answer
2. 효율성 통과한 코드
def solution(arr):
stack = []
for i in range(len(arr)):
if i == 0:
stack.append((arr[i]))
else:
top = stack.pop()
stack.append(top)
if arr[i]==top:
pass
else:
stack.append(arr[i])
return stack
1. 효율성을 통과하지 못한 코드: O(N^2)
2. 효율성을 통과한 코드: O(N)
처음에 효율성을 통과하지 못한 코드에 대해서 중첩 되지 않는 for문을 썼는데 왜 시간복잡도 효율성이 통과되지 않는지 이해가 안갔다. 혹시 내가 stack자료구조를 고려하지 않고 코드를 작성해서 그 부분에서 오류가 나는건가? 싶었다. 그래서 코드를 stack자료구조를 고려해서 리스트를 stack화 해서 코드를 짰다. 확실히 pop함수를 사용해서 그런가 편리하고 뒷처리를 해주지 않아도 되는 점이 깔끔하고 좋았다. 그리고 효율성에도 통과했다.
그렇다면 1번 코드는 어디에서 효율성을 많이 잡아먹는가?
바로 for문에 있는 remove함수 때문이다.
remove함수는 시간복잡도 O(N)을 잡아먹는다. 그런데 이걸 for문으로 처리하고있으니 시간복잡도가 O(N^2)이 되었던 것이였다.
파이썬 각각의 함수들의 특성에 대해서는 잘 몰랐는데, 이렇게 문제를 풀면서 기억에 각인도 시키고 하니 좋다.
어쩜 코딩테스트 문제들은 하나같이 문제 푸는 사람이 그 문제를 풀기위해서 알아야 하는것을 모른다면, 그것에 대해서 스스로 알게되지 않고서야 절대 문제를 못풀게끔 되어있는게 너무 신기하다. 이제야 드는 생각인데, 코딩테스트나 알고리즘 공부 어쩌면 좋은 제도일지도 모르겠다는 생각이 든다.
| [프로그래머스 lv1]실패율 (0) | 2024.01.29 |
|---|---|
| [프로그래머스 lv2]피로도 (1) | 2023.12.01 |
| [프로그래머스 lv2]소수 찾기 (0) | 2023.11.29 |
| [프로그래머스 lv1]모의고사 (1) | 2023.11.28 |
| [프로그래머스 lv1]최소직사각형 (1) | 2023.11.23 |
https://school.programmers.co.kr/learn/courses/30/lessons/42839
프로그래머스
코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.
programmers.co.kr
한자리 숫자가 적힌 종이 조각이 흩어져있습니다. 흩어진 종이 조각을 붙여 소수를 몇 개 만들 수 있는지 알아내려 합니다.
각 종이 조각에 적힌 숫자가 적힌 문자열 numbers가 주어졌을 때, 종이 조각으로 만들 수 있는 소수가 몇 개인지 return 하도록 solution 함수를 완성해주세요.
numbers는 길이 1 이상 7 이하인 문자열입니다.
numbers는 0~9까지 숫자만으로 이루어져 있습니다.
"013"은 0, 1, 3 숫자가 적힌 종이 조각이 흩어져있다는 의미입니다.
numbers return
"17" 3
"011" 2
예제 #1
[1, 7]으로는 소수 [7, 17, 71]를 만들 수 있습니다.
예제 #2
[0, 1, 1]으로는 소수 [11, 101]를 만들 수 있습니다.
11과 011은 같은 숫자로 취급합니다.
1. numbers 문자열을 문자로 떼내어 리스트에 정리한다.
2. 정리한 리스트를 permutations함수를 통해 각 원소들을 통해 만들 수 있는 조합 모든 경우(한자리, 두자리, 세자리 ,, numbers의 길이만큼의 자리)를 리스트에 정리한다.
3. 소수판별 함수를 만들어서 위의 리스트 원소들을 대상으로 소수 판별을 한다.
4. 결과 출력
from itertools import permutations
def solution(numbers):
answer = 0
numbers= str(numbers)
Nlist=[]
for i in range(len(numbers)):
Nlist.append(str(numbers[i]))
totalList = []
for i in range(len(numbers)):
if i == len(numbers):
break
totalList += list(map(''.join, (permutations(Nlist, i+1))))
totalList=list(map(int, totalList))
totalList=set(totalList)
totalList=list(totalList)
if 0 in totalList:
totalList.remove(0)
if 1 in totalList:
totalList.remove(1)
def primenumber(x):
# 2부터 x-1까지 순회
for i in range(2, x):
if x % i == 0:
# 하나라도 나눠 떨어지면 False 반환
return False
# 아무것도 나눠 떨어지는게 없으면 True 반환
return True
for i in range(len(totalList)):
if primenumber(totalList[i])== True:
answer+=1
# 어둠의 잔해 소수 판별기
# topic=2
# check=0
# for i in range(len(totalList)):
# while 1:
# if totalList[i] == 0:
# # 원소 0은 pass
# pass
# if totalList[i] % topic == 0:
# check+=1
# if check ==1:
# break
# topic+=1
# else:
# topic+=1
# if topic == totalList[i]:
# topic = 2
# break
# if check == 1:
# answer+=1
# check=0
# else:
# check=0
# pass
return answerO(N)
하지않음
문제를 어떻게 풀어야하겠다는 것은 알겠지만서도, 자잘한 문법, 함수 사용법을 정확하게 몰라서 좀 시간이 걸렸다.
생각하는데로 출력하고 활용하는것이 좀 어려웠다.
특히 튜플 자료형, join함수, map함수, map객체, set함수 등에 대해서 잘 몰라서 새로 찾아봤다.
소수를 찾는 로직도 예전에 문제를 한번 풀어봤었는 경험으로 코드를 짜봤는데(어둠의 잔해 소수 판별기), 시간초과가 나왔다. 왜그럴까??? 빈틈없이 짰다고 생각했는데, 시간날때 다시 한번 봐야겠다.
| [프로그래머스 lv2]피로도 (1) | 2023.12.01 |
|---|---|
| [프로그래머스 lv1]같은 숫자는 싫어 (0) | 2023.11.30 |
| [프로그래머스 lv1]모의고사 (1) | 2023.11.28 |
| [프로그래머스 lv1]최소직사각형 (1) | 2023.11.23 |
| [프로그래머스 lv2]카펫 (2) | 2023.11.22 |
https://school.programmers.co.kr/learn/courses/30/lessons/42840#
프로그래머스
코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.
programmers.co.kr
수포자는 수학을 포기한 사람의 준말입니다. 수포자 삼인방은 모의고사에 수학 문제를 전부 찍으려 합니다. 수포자는 1번 문제부터 마지막 문제까지 다음과 같이 찍습니다.
1번 수포자가 찍는 방식: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...
2번 수포자가 찍는 방식: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5, ...
3번 수포자가 찍는 방식: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...
1번 문제부터 마지막 문제까지의 정답이 순서대로 들은 배열 answers가 주어졌을 때, 가장 많은 문제를 맞힌 사람이 누구인지 배열에 담아 return 하도록 solution 함수를 작성해주세요.
시험은 최대 10,000 문제로 구성되어있습니다.
문제의 정답은 1, 2, 3, 4, 5중 하나입니다.
가장 높은 점수를 받은 사람이 여럿일 경우, return하는 값을 오름차순 정렬해주세요.
answers return
[1,2,3,4,5] [1]
[1,3,2,4,2] [1,2,3]
입출력 예 #1
수포자 1은 모든 문제를 맞혔습니다.
수포자 2는 모든 문제를 틀렸습니다.
수포자 3은 모든 문제를 틀렸습니다.
따라서 가장 문제를 많이 맞힌 사람은 수포자 1입니다.
입출력 예 #2
모든 사람이 2문제씩을 맞췄습니다.
1. 수포자 1, 2, 3의 정답 패턴이 들어있는 리스트 생성
2. 각각의 정답을 answers와 대조하여 각각의 score을 매김
3. score중에서 max가 있으면 해당 값을 answer리스트에 삽입, 만약 max값을 가지는 사람이 여러명이거나 셋다 값이 같다면 해당 케이스에 대해서 처리해줘야함
def solution(answers):
answer = []
l1=[1,2,3,4,5]
l2=[2,1,2,3,2,4,2,5]
l3=[3,3,1,1,2,2,4,4,5,5]
len_a = len(answers)
cnt = 0
score1 = score2 = score3 = 0
for i in range(len(answers)):
cnt = i
if cnt >= len(l1):
cnt = cnt % len(l1)
if l1[cnt] == answers[i]:
score1+=1
cnt = 0
for i in range(len(answers)):
cnt = i
if cnt >= len(l2):
cnt = cnt % len(l2)
if l2[cnt] == answers[i]:
score2+=1
cnt = 0
for i in range(len(answers)):
cnt = i
if cnt >= len(l3):
cnt = cnt % len(l3)
if l3[cnt] == answers[i]:
score3+=1
total_list=[]
total_list.append(score1)
total_list.append(score2)
total_list.append(score3)
if score1==score2==score3:
answer.extend([1,2,3])
else:
maxx=(max(total_list))
answer.append(total_list.index(max(total_list)) + 1)
total_list[total_list.index(max(total_list))] = 0
if maxx in total_list:
answer.append(total_list.index(maxx)+1)
return answerO(N)
하지않음
문제 이해를 잘 못했어서 하루를 날렸다.
세세한 조건 따질줄 아직 잘 모르는것 같다.
그리고 조건을 따질 줄 안다 하더라도 이걸 이렇게까지 해야한다고? 싶은 생각에 자꾸 막히는듯 함
| [프로그래머스 lv1]같은 숫자는 싫어 (0) | 2023.11.30 |
|---|---|
| [프로그래머스 lv2]소수 찾기 (0) | 2023.11.29 |
| [프로그래머스 lv1]최소직사각형 (1) | 2023.11.23 |
| [프로그래머스 lv2]카펫 (2) | 2023.11.22 |
| [프로그래머스 lv2]H-Index (0) | 2023.11.21 |
명함 지갑을 만드는 회사에서 지갑의 크기를 정하려고 합니다. 다양한 모양과 크기의 명함들을 모두 수납할 수 있으면서, 작아서 들고 다니기 편한 지갑을 만들어야 합니다. 이러한 요건을 만족하는 지갑을 만들기 위해 디자인팀은 모든 명함의 가로 길이와 세로 길이를 조사했습니다.
아래 표는 4가지 명함의 가로 길이와 세로 길이를 나타냅니다.
명함 번호 가로 길이 세로 길이
1 60 50
2 30 70
3 60 30
4 80 40
가장 긴 가로 길이와 세로 길이가 각각 80, 70이기 때문에 80(가로) x 70(세로) 크기의 지갑을 만들면 모든 명함들을 수납할 수 있습니다. 하지만 2번 명함을 가로로 눕혀 수납한다면 80(가로) x 50(세로) 크기의 지갑으로 모든 명함들을 수납할 수 있습니다. 이때의 지갑 크기는 4000(=80 x 50)입니다.
모든 명함의 가로 길이와 세로 길이를 나타내는 2차원 배열 sizes가 매개변수로 주어집니다. 모든 명함을 수납할 수 있는 가장 작은 지갑을 만들 때, 지갑의크기를 return 하도록 solution 함수를 완성해주세요.
1. sizes 리스트에서 가로가 세로보다 작으면 위치를 바꿔준다.
2. sizes리스트의 모든 가로길이중에서 가장 큰 값, 해당 리스트의 모든 세로 길이 중에서 가장 큰 값
3. 두 값의 곱을 출력한다.
def solution(sizes):
answer = 0
tmp=0
for i in range(len(sizes)):
if sizes[i][0] < sizes[i][1]:
tmp=sizes[i][0]
sizes[i][0]=sizes[i][1]
sizes[i][1]=tmp
wMax=0
lMax=sizes[0][1]
for i in range(len(sizes)):
if sizes[i][0] > wMax:
wMax=sizes[i][0]
if sizes[i][1] > lMax:
lMax = sizes[i][1]
answer = wMax * lMax
return answer
O(N)
하지않음
없음
| [프로그래머스 lv2]소수 찾기 (0) | 2023.11.29 |
|---|---|
| [프로그래머스 lv1]모의고사 (1) | 2023.11.28 |
| [프로그래머스 lv2]카펫 (2) | 2023.11.22 |
| [프로그래머스 lv2]H-Index (0) | 2023.11.21 |
| [프로그래머스 lv2]가장 큰 수 (1) | 2023.11.21 |
https://school.programmers.co.kr/learn/courses/30/lessons/42842#
Leo는 카펫을 사러 갔다가 아래 그림과 같이 중앙에는 노란색으로 칠해져 있고 테두리 1줄은 갈색으로 칠해져 있는 격자 모양 카펫을 봤습니다.
Leo는 집으로 돌아와서 아까 본 카펫의 노란색과 갈색으로 색칠된 격자의 개수는 기억했지만, 전체 카펫의 크기는 기억하지 못했습니다.
Leo가 본 카펫에서 갈색 격자의 수 brown, 노란색 격자의 수 yellow가 매개변수로 주어질 때 카펫의 가로, 세로 크기를 순서대로 배열에 담아 return 하도록 solution 함수를 작성해주세요.
갈색 격자의 수 brown은 8 이상 5,000 이하인 자연수입니다.
노란색 격자의 수 yellow는 1 이상 2,000,000 이하인 자연수입니다.
카펫의 가로 길이는 세로 길이와 같거나, 세로 길이보다 깁니다.
brown yellow return
10 2 [4, 3]
8 1 [3, 3]
24 24 [8, 6]
1. 가로>=세로 라는 조건에 유의한다.
2. 노란 박스는 1층일 수도 있고, 2층일 수도 있고, ... N층일 수도 있다.
3. 2번에 의해 노란박스가 1층이면 노란박스의 가로길이는 yellow값이 된다.
4. 노란박스의 층수가 정해지면 그에 따라 brown을 가늠해볼 수 있게된다.
brown은 노란박스 층수+2가 세로가 되고, 노란박스+2가 가로가 된다. 이게 노란박스를 품은 brown이다.
즉, brown+yellow의 값인 total 격자 수가 된다.
5. 4번을 충족하는 노란박스의 층수를 찾으면 문제가 풀린다.
def solution(brown, yellow):
answer = []
total = int(brown) + int(yellow)
x = 1
while 1:
if yellow%x==0:
y = yellow//x
if (x+2)*(y+2) == total and y+2 >= x+2:
answer.append(y+2) # 가로
answer.append(x+2) # 세로
break
else:
x+=1
return answer
O(N)
처음에 답이 안나왔는데, 다음 값의 정확도를 개선하였음
yellow를 x로 나누면 y값이 나온다. 이때 yellow가 x로 나누어떨어져서 나머지가 없는 x의 값에 의한 y를 찾게끔하였음.
없음. 항상 괜히 쫄지마 !
| [프로그래머스 lv1]모의고사 (1) | 2023.11.28 |
|---|---|
| [프로그래머스 lv1]최소직사각형 (1) | 2023.11.23 |
| [프로그래머스 lv2]H-Index (0) | 2023.11.21 |
| [프로그래머스 lv2]가장 큰 수 (1) | 2023.11.21 |
| [프로그래머스 lv2]의상 (0) | 2023.11.20 |
H-Index는 과학자의 생산성과 영향력을 나타내는 지표입니다. 어느 과학자의 H-Index를 나타내는 값인 h를 구하려고 합니다. 위키백과1에 따르면, H-Index는 다음과 같이 구합니다.
어떤 과학자가 발표한 논문 n편 중, h번 이상 인용된 논문이 h편 이상이고 나머지 논문이 h번 이하 인용되었다면 h의 최댓값이 이 과학자의 H-Index입니다.
어떤 과학자가 발표한 논문의 인용 횟수를 담은 배열 citations가 매개변수로 주어질 때, 이 과학자의 H-Index를 return 하도록 solution 함수를 작성해주세요.
과학자가 발표한 논문의 수는 1편 이상 1,000편 이하입니다.
논문별 인용 횟수는 0회 이상 10,000회 이하입니다.
citations return
[3, 0, 6, 1, 5] 3
이 과학자가 발표한 논문의 수는 5편이고, 그중 3편의 논문은 3회 이상 인용되었습니다. 그리고 나머지 2편의 논문은 3회 이하 인용되었기 때문에 이 과학자의 H-Index는 3입니다.
문제의 조건에 집중하여 반복문으로 문제를 풀었다.
1. h번 이상 인용된 논문을 찾을 때, h를 0번부터 h번까지 기준으로 한다. 이때 이 값은 hTimes변수에 기록한다.
2. citations를 h이상인지 아닌지 조회하여 h이상인 논문을 세아려서 그게 몇개인지 high라는 변수에 담는다.
3. 당시 몇번 이상 인용된 논문을 찾을때 그 개수(hTimes)가 high를 넘거나 같을 때, high값을 정답으로 반환한다.
def solution(citations):
answer = 0
# citations는 발표한 논문의 인용 횟수를 담은 배열임
hTimes=0
while 1:
high = 0
for i in citations:
if i >= hTimes:
high+=1
if hTimes >= high:
break
else:
hTimes+=1
answer = high
return answer
O(N^2)
하지않음
처음에 n편중 모든 논문이 0번 인용되는 경우를 생각하지 못했다.
이 문제가 왜 정렬 문제인지 이해가 잘 안간다~
| [프로그래머스 lv1]최소직사각형 (1) | 2023.11.23 |
|---|---|
| [프로그래머스 lv2]카펫 (2) | 2023.11.22 |
| [프로그래머스 lv2]가장 큰 수 (1) | 2023.11.21 |
| [프로그래머스 lv2]의상 (0) | 2023.11.20 |
| [프로그래머스 lv2]전화번호 목록 (0) | 2023.11.10 |
몇일간 못풀던 문제를 풀었다. 속이 후련해야 하는데 이 문제는 속이 시원하면서도 어딘가 찝찝하다;;
0 또는 양의 정수가 주어졌을 때, 정수를 이어 붙여 만들 수 있는 가장 큰 수를 알아내 주세요.
예를 들어, 주어진 정수가 [6, 10, 2]라면 [6102, 6210, 1062, 1026, 2610, 2106]를 만들 수 있고, 이중 가장 큰 수는 6210입니다.
0 또는 양의 정수가 담긴 배열 numbers가 매개변수로 주어질 때, 순서를 재배치하여 만들 수 있는 가장 큰 수를 문자열로 바꾸어 return 하도록 solution 함수를 작성해주세요.
numbers의 길이는 1 이상 100,000 이하입니다.
numbers의 원소는 0 이상 1,000 이하입니다.
정답이 너무 클 수 있으니 문자열로 바꾸어 return 합니다.
numbers return
[6, 10, 2] "6210"
[3, 30, 34, 5, 9] "9534330"
1. numbers 요소들을 map함수를 통해 문자열로 변경
2. 0번째 요소부터 바로 다음의 요소를 이용해서
'다음의 요소+현재 보는 요소' , '현재 보는 요소+ 다음의 요소'를 int형으로 변환하여 대소 비교를 한 후
리스트 index 정렬을 해주었다.
이때 한자리수에 대한 처리가 어려웠다.
구체적으로 말하자면
1. 입력값 [979, 97, 978, 81, 818, 817] 일 때 기댓값 "9799797881881817"인 경우,
2. 입력값 [1000, 111, 110, 101, 100, 11, 10, 1, 0] 일 때 기댓값 "1111111101011010010000"인 경우가 해결이 안되었다.
문자열을 단순히 복사하여 문자열을 부풀린 후 대소비교는 안하려했으나 이 방법 밖에 풀이가 없는듯 하다. ;;
입력값 81, 818, 817이 있다고 쳤을 때, 문자열로 변환후 정렬을 하면
-> 818, 817, 81으로 나올것이다.
우선 818, 817의 경우
818817
817818 두가지 경우가 나올 수 있는데, 818817이 더 크다. 따라서 818, 817의 순서는 자연스럽다.
817과 81의 경우
81817
81781 두가지 경우가 나올 수 있는데, 중에서 81817이 더 크다. 따라서 현재 817, 81의 순서는 자연스럽지 않다.
이를 전체적으로 종합해보면 818, 81, 817의 순서가 자연스럽다는 결론을 내릴 수 있다.
그러나 처음에 818, 81, 817을 문자열로 변환한뒤 정렬한게 818, 817, 81인데,
818, 817, 81 이것을 어떻게 818, 81, 817순으로 정렬할 수 있을까?
두자리 수 인 81을 세자리 수로 만들면서 동시에 817보다는 크고 818보다는 작아야 한다.
81 뒤에 0부터 시작해서 9까지 어느 수를 붙이든간에 부자연스럽다는 것을 알 수 있다.
0~7을 붙일경우 817보다 같거나 작게되고, 8을 붙일 경우 818과 같게 되고, 9를 붙이면 818보다 크게 된다.
또한 81이 두자리 수라고해서 다른 숫자를 붙일 경우 다른 숫자들에도 해당 숫자를 붙여주는게 바람직 하다.
그런데 이렇게 다른 규칙이 없는 임의의 숫자를 정하여 붙이게 되면 숫자의 크기가 어긋나게된다.
따라서 최선의 방법은 자기 자신을 한번더 자신에게 붙이는 방법이 있다.
818, 81, 817을
818818, 8181, 817817 로 한 다음,
제한 사항에 numbers의 원소는 0이상 1,000 이하라는 사항을 반영하여,
위 원소들을 길이 4로 끊는다. (3으로 끊어버리면 대소 비교가 어려움--> 818, 818, 817)
8188, 8181, 8178 이때 대소 비교를 하면,
8188 > 8181 > 8178 순으로
818, 81, 817의 순서를 유지할 수 있게된다.
이때, 몇가지 고려해야 할 것들이 있는데, 아래의 테스트케이스를 통해 설명하겠다.
위와같은 논리를 아래에 테스트케이스에 적용한다.
입력값 〉 [3, 30, 34, 5, 9]
기댓값 〉 "9534330" 에 적용하면
문자열로 변환하여 정렬한다. [9, 5, 34, 30, 3]
9534까지 잘 가다가 330과 303에 걸리게 된다.
303보다 330이 더 크다.
하지만 이때 3은 한자리수로써, 자기 자신을 한번 더 자신에게 붙여봤자 33이 된다.
이를 모든 원소에 적용하면
99 55 3434 3030 33이 된다.
이 경우일 때는 결과적으로 정렬에 문제가 없다.
그러나 다음과 같은 경우에서 문제가 된다.
입력값 〉 [111, 110, 11, 1]
기댓값 〉 "111111110"
입력값을 문자열로 변환후 2배 해보면
111111
110110
1111
11
대소 비교를 해보면, 111111>1111>110110>11
즉, 111, 11, 110, 1이 된다.
입력값을 문자열로 변환후 3배 해보면
111111111
110110110
111111
111
대소 비교를 해보면, 111111111>111111>111>110110110
즉, 111, 11, 1, 110이 된다.
제한사항에 numbers의 원소는 0이상 1,000이하라고 되어있다.
해당 조건을 고려하여 한자리수 문자열을 위해서 입력값 요소들에 대해 3배로 불리기를 해주고 비교해야 한다.
def solution(numbers):
answer = ''
str_list = list(map(str, numbers))
str_list.sort(key = lambda x: x*3, reverse=True)
for i in str_list:
answer+=i
if int(answer)==0:
answer = '0'
return answer
# 예전 코드
# tmp=0
# i=0
# while 1:
# tmp=0
# if i >= len(str_list)-1:
# break
# if int(str_list[i]+str_list[i+1]) > int(str_list[i+1]+str_list[i]):
# pass
# elif int(str_list[i]+str_list[i+1]) < int(str_list[i+1]+str_list[i]):
# tmp=str_list[i+1]
# str_list[i+1]= str_list[i]
# str_list[i]=tmp
# i+=1
# 참회 코드
#for i in str_list:
# answer+=str_list[i]
# 완전 잊어먹지 않을 정도로 충격먹음ㅋ
#print(answer)
#print(str_list)O(NlogN)
람다를 쓰면서 코드 최적화를 한 것 같다.
뭐랄까.. 이 문제는 문자열로써의 숫자가 갖는 성질에 대한 이해같다.
문자를 불려서 해당 값을 비교한다는게 숫자로써의 비교가 아니라 대상으로써의 비교의 연속같다.
30, 34라는 문자와 3이라는 문자의 비교 같다.
문자열에는 맨 앞자리[0]가 언제나 큰 우선순위를 갖기때문에
34가 3434가 되는것이 3이 33밖에 안되는 것 30이 3030이 되는것이 전혀 문제가 되지 않는다.
즉 숫자 크기로 보면 안되고 오로지 인덱스가 주는 가중치를 생각해야한다. 3은 30보다 커야 하고 그만큼의 가중치를 받아야 한다.
아 쓰면서도 뭔말인지 좀 살짝 이해하기 어려운데 아무튼 문자열을 하나의 덩이라고 생각하고 덩이끼리 비교한다고 생각한다.
람다 사용법을 몰라서 생소하고 쓸줄 몰랐다.
람다는 간략하게 코드 짜고싶을때 사용하기 좋은 것 같다.
위 코드에서 str_list의 key(원소)들은 lambda 익명 함수의 매개변수 x로써의 역할을 하게된다.
| [프로그래머스 lv2]카펫 (2) | 2023.11.22 |
|---|---|
| [프로그래머스 lv2]H-Index (0) | 2023.11.21 |
| [프로그래머스 lv2]의상 (0) | 2023.11.20 |
| [프로그래머스 lv2]전화번호 목록 (0) | 2023.11.10 |
| [프로그래머스 lv1]폰켓몬 (0) | 2023.11.10 |