Python

이번 문제는 단순한 구현으로 해결할 수 있는 문제였다n과 k를 입력받는다.학생의 정보를 입력받는다.m,w 배열을 만들고, 배열의 인덱스를 학년으로 정한다. (0 2 => m2)전체 학생 수 만큼 반복문을 돌며 m,w 배열을 증가시킨다.반복문을 range(1,7)만큼 돌

이번 문제는 이미 C++로 구현한 문제이다. 파이썬 연습을 위해 파이썬으로 다시 작성해보았다. 이분탐색을 이용한 문제이다.

앞서 C++로 풀어봤던 문제를 파이썬으로도 풀어보았다. 확실히 파이썬이 코드 길이는 짧게 나오는 것 같다.\[ BOJ / C++ ] 1477번 휴게소 세우기휴게소 위치 배열을 오름차순으로 정렬한다.휴게소 거리 배열 dis를 구한다.이분탐색 안에서 mid와 dis를 비교

\[ BOJ / C++ ] 15658번 연산자 끼워넣기 (2)파이썬으로도 해결해보았다. C++ 코드와 조금은 다르게 풀어보았다.DFS의 인자를 줄이는 대신에 DFS 재귀호출 이후 갯수를 줄였던 연산자의 갯수를 다시 늘린다.maxi, mini의 값은 python 내장함수

\[ BOJ / C++ ] 1038번 감소하는 수C++로 풀어봤던 문제를 python으로 다시 풀어보았다. 확실히 python은 내장함수가 많아서 코드가 짧게 나오는 것 같다. append와 len, sorted 등을 사용하였다.

이번 문제는 패턴을 찾아 해결하였다. 처음에는 1개나 3개를 가져가는 모든 경우를 구해야하나 고민하였다. 그러다가 아이디어가 생각났다.돌을 1개 혹은 3개만 가져갈 수 있다는 것은 첫번째 시도에서는 홀수가 되고, 두번째 시도에서는 짝수가 된다는 의미이다.1,3 모두 홀

이번 문제는 피보나치수열의 변형 문제였다. 패턴을 찾기 위해 미지수 a와 b를 대입해보았다.d가 6이라면,\-> k0=a\-> k1=b\-> k2=a+b\-> k3=a+2b\-> k4=2a+3b\-> k5=3a+5b이러한 형태가 나타난다.미지수가 2개이기 때문에 고민을

C++로 풀어본 문제를 파이썬으로도 풀어보았다. \[ BOJ / C++ ] 2012번 등수 매기기풀이 방법 또한 똑같이 하였다. 백준의 python3로 제출하면 시간 초과가 발생했지만 PyPy3으로 제출하면 정답으로 처리되었다.

바로 이전에 C++로 풀어보았던 문제를 Python으로 다시 풀어보았다. 앞서 풀었던 로직 그대로 해결하였기 때문에 설명은 생략하겠다. \[ BOJ / C++ ] 2448번 별 찍기

C++로 풀어본 문제를 파이썬으로도 풀어보았다. C++로 해결한 방법과 조금 다르게 하였다.중복 확인 없이 모두 입력받는다.입력받은 배열을 정렬한다.정렬한 배열을 빈 배열 result에 대한 result.count() 내장함수를 통하여 result.count()가 0일

오픈채팅방카카오톡 오픈채팅방에서는 친구가 아닌 사람들과 대화를 할 수 있는데, 본래 닉네임이 아닌 가상의 닉네임을 사용하여 채팅방에 들어갈 수 있다.신입사원인 김크루는 카카오톡 오픈 채팅방을 개설한 사람을 위해, 다양한 사람들이 들어오고, 나가는 것을 지켜볼 수 있는

데이터 처리 전문가가 되고 싶은 "어피치"는 문자열을 압축하는 방법에 대해 공부를 하고 있습니다. 최근에 대량의 데이터 처리를 위한 간단한 비손실 압축 방법에 대해 공부를 하고 있는데, 문자열에서 같은 값이 연속해서 나타나는 것을 그 문자의 개수와 반복되는 값으로 표현

로또 6/45(이하 '로또'로 표기)는 1부터 45까지의 숫자 중 6개를 찍어서 맞히는 대표적인 복권입니다. 아래는 로또의 순위를 정하는 방식입니다.로또를 구매한 민우는 당첨 번호 발표일을 학수고대하고 있었습니다. 하지만, 민우의 동생이 로또에 낙서를 하여, 일부 번호

카카오에 입사한 신입 개발자 네오는 "카카오계정개발팀"에 배치되어, 카카오 서비스에 가입하는 유저들의 아이디를 생성하는 업무를 담당하게 되었습니다. "네오"에게 주어진 첫 업무는 새로 가입하는 유저들이 카카오 아이디 규칙에 맞지 않는 아이디를 입력했을 때, 입력된 아이

배열 array의 i번째 숫자부터 j번째 숫자까지 자르고 정렬했을 때, k번째에 있는 수를 구하려 합니다.예를 들어 array가 1, 5, 2, 6, 3, 7, 4, i = 2, j = 5, k = 3이라면array의 2번째부터 5번째까지 자르면 5, 2, 6, 3입니

수많은 마라톤 선수들이 마라톤에 참여하였습니다. 단 한 명의 선수를 제외하고는 모든 선수가 마라톤을 완주하였습니다.마라톤에 참여한 선수들의 이름이 담긴 배열 participant와 완주한 선수들의 이름이 담긴 배열 completion이 주어질 때, 완주하지 못한 선수의

가로 길이가 Wcm, 세로 길이가 Hcm인 직사각형 종이가 있습니다. 종이에는 가로, 세로 방향과 평행하게 격자 형태로 선이 그어져 있으며, 모든 격자칸은 1cm x 1cm 크기입니다. 이 종이를 격자 선을 따라 1cm × 1cm의 정사각형으로 잘라 사용할 예정이었는데

네오와 프로도가 숫자놀이를 하고 있습니다. 네오가 프로도에게 숫자를 건넬 때 일부 자릿수를 영단어로 바꾼 카드를 건네주면 프로도는 원래 숫자를 찾는 게임입니다.다음은 숫자의 일부 자릿수를 영단어로 바꾸는 예시입니다.1478 → "one4seveneight"234567

124 나라가 있습니다. 124 나라에서는 10진법이 아닌 다음과 같은 자신들만의 규칙으로 수를 표현합니다.124 나라에는 자연수만 존재합니다.124 나라에는 모든 수를 표현할 때 1, 2, 4만 사용합니다.예를 들어서 124 나라에서 사용하는 숫자는 다음과 같이 변환

프로그래머스 팀에서는 기능 개선 작업을 수행 중입니다. 각 기능은 진도가 100%일 때 서비스에 반영할 수 있습니다.또, 각 기능의 개발속도는 모두 다르기 때문에 뒤에 있는 기능이 앞에 있는 기능보다 먼저 개발될 수 있고, 이때 뒤에 있는 기능은 앞에 있는 기능이 배포

게임개발자인 "죠르디"는 크레인 인형뽑기 기계를 모바일 게임으로 만들려고 합니다."죠르디"는 게임의 재미를 높이기 위해 화면 구성과 규칙을 다음과 같이 게임 로직에 반영하려고 합니다.게임 화면은 "1 x 1" 크기의 칸들로 이루어진 "N x N" 크기의 정사각 격자이며

매운 것을 좋아하는 Leo는 모든 음식의 스코빌 지수를 K 이상으로 만들고 싶습니다. 모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 Leo는 스코빌 지수가 가장 낮은 두 개의 음식을 아래와 같이 특별한 방법으로 섞어 새로운 음식을 만듭니다.섞은 음식의 스코빌 지수

주어진 숫자 중 3개의 수를 더했을 때 소수가 되는 경우의 개수를 구하려고 합니다. 숫자들이 들어있는 배열 nums가 매개변수로 주어질 때, nums에 있는 숫자들 중 서로 다른 3개를 골라 더했을 때 소수가 되는 경우의 개수를 return 하도록 solution 함수

실패율슈퍼 게임 개발자 오렐리는 큰 고민에 빠졌다. 그녀가 만든 프랜즈 오천성이 대성공을 거뒀지만, 요즘 신규 사용자의 수가 급감한 것이다. 원인은 신규 사용자와 기존 사용자 사이에 스테이지 차이가 너무 큰 것이 문제였다.이 문제를 어떻게 할까 고민 한 그녀는 동적으로

배열 arr가 주어집니다. 배열 arr의 각 원소는 숫자 0부터 9까지로 이루어져 있습니다. 이때, 배열 arr에서 연속적으로 나타나는 숫자는 하나만 남기고 전부 제거하려고 합니다. 단, 제거된 후 남은 수들을 반환할 때는 배열 arr의 원소들의 순서를 유지해야 합니다

이번 문제는 문제를 이해하는데에 시간이 조금 걸렸던 문제였다. 간단하게 해석하면 주어진 수열에서 사이사이에 원하는 수를 뺄 수 있고 원하는대로 뺀 뒤에 남은 증가 부분 수열 중에서 합이 가장 큰 것을 출력하는 문제이다.n과 수열 arr을 입력받는다.arr의 각 자리에서

이번 문제는 다이나믹 프로그래밍으로 해결하는 문제였다. 반복되는 연산을 저장하여 연산 횟수를 줄이는 다이나믹 프로그래밍의 장점을 이용했다.n, k 를 입력받는다.동전의 금액을 입력받는 coin 배열을 선언하고 입력받는다.동전의 합의 경우 수를 저장하는 answer 배열

이번 문제는 다이나믹 프로그래밍을 통해 해결할 수 있는 문제이다. 점화식을 구한 뒤에 각 계산의 결과를 담아두는 배열에 저장하여 이를 반환한다.k를 입력받는다.계산 결과를 담아 둘 배열 ansA, ansB를 선언한다.초기의 상태는 'A'이므로 ansA0=1, ansB0

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 처음에는 주어진 2차원 배열을 만든 뒤에 내려가며 최대와 최소에 해당하는 수들을 각각 저장하여 해결해야겠다고 생각을 했다. 하지만 그렇게 되면 입력값이 너무 많아져 메모리 제한을 초과한다는 사실을 알게 되었다. 그래서

이번 문제는 다이나믹 프로그래밍을 응용하여 해결하였다. 처음에는 하나의 수를 제거할 수 있다는 점에서 단순하게 cnt라는 변수를 0으로 두고, dpi>dpi+arri+1일 때 cnt를 1 증가시켜 하나의 수를 제거한 것으로 처리를 하였다. 의도한 내용은 잘 작동하였지만

문자열 s는 한 개 이상의 단어로 구성되어 있습니다. 각 단어는 하나 이상의 공백문자로 구분되어 있습니다. 각 단어의 짝수번째 알파벳은 대문자로, 홀수번째 알파벳은 소문자로 바꾼 문자열을 리턴하는 함수, solution을 완성하세요.문자열 전체의 짝/홀수 인덱스가 아니

짝지어 제거하기는, 알파벳 소문자로 이루어진 문자열을 가지고 시작합니다. 먼저 문자열에서 같은 알파벳이 2개 붙어 있는 짝을 찾습니다. 그다음, 그 둘을 제거한 뒤, 앞뒤로 문자열을 이어 붙입니다. 이 과정을 반복해서 문자열을 모두 제거한다면 짝지어 제거하기가 종료됩니

이번 문제는 가운데에 작은 수가 몰리도록 정렬하여 해결하였다.테스트 케이스 갯수 t를 입력받는다.테스트 케이스의 원소 갯수 n을 입력받는다.배열 l을 입력받는다.빈 배열 arr을 선언한다.result를 0으로 정의한다.l을 오름차순 정렬한다.l의 길이가 0이 될때까지

보통 에라토스테네스의 체 문제는 소수를 찾는 문제로 자주 등장한다. 에라토스테네스의 체의 원리는 다음과 같다.1~100 범위의 수 안에서의 소수를 구한다고 가정한다.가장 작은 수인 2는 소수 배열에 넣고 2의 배수를 모두 False로 체크해준다.그 다음 작은 수인 3을

이번 문제는 주어진 조건을 통해 구현하여 해결하였다.a와 p를 입력받는다.반복 수열 전까지의 수를 저장하기 위한 cnt변수를 선언한다.각 자리의 숫자를 p번 곱한 수들의 합을 저장할 arr 배열을 선언한다.arr 배열에 a를 넣어준다.while문에서 이전의 수를 가지고

이번 문제는 문자열을 자르고 뒤집는 구현을 통하여 해결하였다.문자열 s를 입력받는다.문자열을 자르고 뒤집어 합친 문자열을 보관할 answer 배열을 정의한다.3중 for문을 돌린다.\-> 가장 바깥 for문을 0부터 s의 길이-2까지 i에 대해 돌린다.\-> 가운데 f

이번 문제는 배열의 모든 인덱스에서의 합을 비교하며 역전패의 여부를 확인하는 문제이다.두 팀의 각 회에서의 획득한 점수를 받을 배열 j,s를 입력받는다.각 팀의 점수의 누적합을 담을 jsum, ssum을 0으로 정의한다.역전 당한 여부를 확인하기 위한 chk 변수를 F

이번 문제는 카드의 합의 모든 경우를 비교하여 일의자리가 가장 큰 경우를 찾아 해결하였다. 입력받는 경우와 3개의 카드를 선택하는 경우를 모두 구하기 위해서 4중 for문을 사용해야해서 시간 제한을 벗어날까 걱정했지만 수의 범위가 크지 않아 시간 초과는 발생하지 않았다

이번 문제는 2중 for문을 통해 모든 수들을 비교하며 현재 위치의 수 ~ 현재 위치의 수+5 범위 내 수의 갯수를 구하고 현재 위치의 수-5 ~ 현재 위치의 수 범위 내의 수의 갯수를 구하여 더 작은 것을 취하는 방식으로 해결했다.배열의 크기 n을 입력받는다.입력받은

이번 문제는 n까지의 for문을 돌리며 i에 d가 포함될 경우 그 수만큼 cnt에 더하여 cnt를 출력하는 방법으로 해결했다.n과 d를 입력받는다.d의 수를 더하는 cnt변수를 0으로 정의한다.1부터 n+1까지의 i에 대한 for문을 돌린다.\-> 만약 d가 i에 포함

이번 문제는 케이스의 수만큼 반복하며 입력된 횟수가 가장 많은 수를 찾아 이를 출력하는 문제이다. 여기서 주의할 점은 가장 많은 수가 복수개일 경우 그 중 가장 작은 수를 찾아야 하는 것이다. 이 방법에 대해 고민하다가 내림차순으로 정렬하고 가장 많이 나온 수를 갱신할

이번 문제는 입력받은 수가 10의 x제곱보다 작아질때까지 계속해서 반올림을 하여 해결하였다.n을 입력받는다.0부터 n까지의 i에 대한 for문을 돌린다.num을 입력받는다.num의 반올림 자리를 나타낼 cal을 10으로 정의한다.num이 cal보다 작을 때까지 whil

이번 문제는 입력받은 숫자들을 문자열로 처리하여 해결하였다. N, 2N, 3N, ... 순으로 수가 증가하는 것은 반복 전에 tmp변수에 해당 수를 저장하고 매 반복 사이클마다 cnt변수를 증가시키며 곱하도록 하여 구현하였다.케이스의 개수 t를 입력받는다.수들을 저장할

이번 문제는 문제에서 주어진 공식을 이용하여 절사평균과 보정평균을 소수점 셋째자리에서 반올림하여 출력하는 문제였다. 오답처리되어 찾아본 결과 절사평균과 보정평균을 프로그램으로 구하는 과정에서 0.00000001의 오차가 발생하기 때문에 이를 더해야 정답을 구할 수 있다

이번 문제는 그리디 알고리즘을 이용하여 해결하였다. 우선 전구의 상태 문자열을 입력 받은 뒤에 문자열을 배열로 변환해주고, 배열의 길이만큼 for문을 돌며 현재 인덱스의 문자가 Y일 경우 인덱스의 배수에 위치하는 모든 전구의 상태를 반대로 바꿔주었고 이 과정에서 수를

이번 문제는 각 플레이어들이 가지는 카드를 오름차순으로 정렬한 뒤에 카드의 수 m만큼 반복하며 해당 순서의 카드 중 가장 큰 수와 비교하여 이와 같은 수의 카드를 가질 경우 결과를 저장하는 배열에서 해당 플레이어의 인덱스의 수를 증가시켜 결과 배열에서 가장 큰 수와 같

이번 문제는 입력되는 이름, 일, 월, 연도를 2차원 배열로 저장하고 우선순위를 연도, 월, 일로 한 정렬을 통하여 해결하였다.학생의 수인 n을 입력받는다.학생의 생년월일과 이름이 저장되는 배열 bd를 선언한다.0부터 n까지의 i에 대한 for문을 돌린다.\-> 공백을

이번 문제는 소요시간을 누적시키고, 현재 기다린 시간에서 해당 구간의 A+B를 나눴을 때의 나머지가 B와 같아질 때 다음 구간으로 넘겨가며 누적된 소요시간을 구해 해결하였다.처음에는 기다린 시간 누적을 1씩 더했고 정답은 나왔지만 성능이 좋지는 않았다.n을 입력받는다.

이번 문제는 모든 알파벳을 포함하는 배열과 알파벳의 수를 세기 위한 배열을 먼저 만들고, 문자열에 존재하는 알파벳에 해당하는 인덱스 값을 증가시킨 후 알파벳의 수를 세기 위한 배열에서 가장 작은 수에 따라 알맞은 출력값을 출력하여 해결하였다. 입력되는 문자열에 대소문자

이번 문제는 정답 배열에 담을 임시 배열을 -1로 채운 뒤에 모든 문자열을 검사하며 c가 나올 경우 해당 원소를 0으로 갱신시키고 c다음의 모든 원소를 이전 원소+1의 값으로 갱신시킨다. 하나의 문자열을 검사하고 나면 임시 배열을 정답 배열에 담아 해결하였다.남북에 해

이번 문제는 주어진 s, t문자열의 무한 문자열을 만들 fs와 ft에 계속해서 s와 t를 각각 더해가며 fs와 ft의 길이가 같아졌을 때에 fs와 ft를 비교하여 결과를 출력하는 방식으로 해결하였다.s를 입력받는다.t를 입력받는다.s의 무한 문자열을 담을 fs문자열을

이번 문제는 입력받은 문자열에서 <가 등장하면 >가 등장할 때까지 문자열을 가만히 냅두고, 숫자나 알파벳이 등장하면 시작 위치를 저장하고, 숫자나 알파벳의 끝까지를 뒤집어서 저장하여 해결하였다. 알파벳 뒤집기를 수월하게 하기 위해 입력받은 문자열은 배열로 변경하여

이번 문제는 k의 범위가 매우 크기 때문에 k를 최대한 줄인 뒤에 이진수로 표현하는 방식으로 수를 표현하고 이를 4와 7로 변환시켜 해결하였다. 전체적인 풀이의 이해를 위한 설명은 다음과 같다.자리수가 1인 경우는 2가지, 2인 경우는 4가지, 3인 경우는 8가지, .

이번 문제는 보자마자 분할 정복을 통해 해결해야겠다고 생각했다. 배열의 크기가 고정적이라면 하드코딩도 가능하겠지만 크기가 유동적이기 때문에 재귀함수를 통한 분할 정복 기법으로 해결하였다.함수의 인자는 배열의 크기, x좌표, y좌표로 지정하였고 좌측 상단, 우측 상단,

이번 문제는 입력된 문자열의 모든 접미사를 구하고 이를 알파벳의 오름차순으로 정렬하여 출력해 해결하였다.문자열 s를 입력받고 이를 바로 배열로 변경해준다.접미사를 저장할 배열 tail을 선언한다.s의 길이만큼 반복하는 i에 대한 for문을 돌린다.\-> 접미사를 만들

이번 문제는 팔린 책의 제목을 입력 받을 때에 팔린 책의 제목들을 중복을 제거하여 따로 저장하고, 전체 판매 목록에서 각 책들의 판매 수를 세어 가장 많이 팔린 수의 책을 구하여 해결하였다. 가장 많이 팔린 책이 여러 개일 경우 사전 순으로 가장 앞서는 제목을 출력해야

이번 문제는 집합 s를 먼저 받고, m개의 문자열을 입력받아 m개의 문자열에서 집합 s에 포함되는 문자열이 몇개나 포함되어 있는지 출력하여 해결했다. 첫 제출 시에 시간초과가 발생하여서 이중for문을 단일for문으로 줄여 해결했다.s의 길이인 n과 입력으로 주어지는 문

이번 문제는 주어진 패턴에서 앞의 문자열과 뒤의 문자열을 따로 저장하여 입력되는 문자열에 다음 앞의 문자열과 뒤의 문자열이 모두 포함되어 있을 때에 DA를 출력하고 아닐 경우 NE를 출력하도록 하여 해결하였다. 계속해서 오답처리가 되어서 테스트 케이스를 찾아보던 중

이번 문제는 입력받은 문자열을 검사하며 UCPC 중에 포함되는 문자가 있을 경우 answer를 True로 두고 문자열을 그 다음 문자부터 시작하도록 슬라이싱하여 중복 체크를 하지 않도록 해주고, 만약 포함되지 않았을 경우 answer를 False로 갱신하여 해결하였다.

d이번 문제는 :를 기준으로 두 수를 입력 받아 이 두 수의 최대 공약수를 구하고 두 수에 최대 공약수를 나눈 값을 출력하여 해결하였다. 처음에는 최대 공약수를 비효율적인 방법으로 구하여 시간 초과가 발생했다. 파이썬 내장함수에 최대공약수를 구하는 gcd() 함수를 알

이번 문제는 말을 뒤집거나 말끼리의 위치를 바꿔서 원하는 순서로 정렬시키는데에 필요한 작업 횟수를 출력하는 문제였다. 말을 원하고자 하는 형태로 바꾸는데에 두가지 작업이 존재해서 처음에는 방향을 잡기 어려웠지만 어느정도 패턴을 파악하였고 그 패턴을 발전시켜서 해결하였다

이번 문제는 입력되는 문자열을 배열로 변경하고, 같은 구성으로 이뤄진 문자열을 나누기 위해 배열을 정렬을 하고 배열이 담긴 배열의 중복을 제거하여 해결하였다.n을 입력받는다.입력받는 문자열을 담을 배열 word를 선언한다.0부터 n까지 반복하는 i에 대한 for문을 돌

이번 문제는 입력된 문자열을 2중 for문을 사용하여 부분 문자열의 길이를 1씩 늘려가며 모든 가능한 부분 문자열을 생성한 뒤에 이를 모아둔 배열의 중복을 제거하여 해결하였다.문자열 s를 입력받는다.부분 문자열을 담아둘 part 배열을 선언한다.1부터 s의 길이까지 반

이번 문제는 입력 받은 이름들을 배열로 저장한 뒤에 이를 오름차순 정렬, 내림차순 정렬한 결과와 비교하여 해당하는 문자열을 출력하여 해결하였다.n을 입력받는다.이름을 입력받아 저장할 배열 name을 선언한다.n번 반복하는 i에 대한 for문을 돌린다.\-> name에

이번 문제는 입력받은 문자열에서 pi, ka, chu가 존재하면 문자열에서 해당 부분을 없애는 방식으로 해결하였다.문자열 s를 입력받는다.pi, ka, chu를 담은 배열 pikachu를 선언한다.while문에 사용할 i를 0으로 선언한다.i가 s의 길이보다 작거나 같

이번 문제는 제 1 공개키의 단어들이 제 2 공개키에 배열되는 순서를 저장하여 암호문을 평문으로 바꾸는 방식으로 해결하였다.테스트의 수 t를 입력받는다.t만큼 반복하는 i에 대한 for문을 돌린다.n을 입력받는다.제 1 공개키에 해당하는 배열 key1을 입력받는다.제

이번 문제는 그리디 알고리즘을 이용하여 보드판을 검사하며 .이 나왔을 때에 이전의 X의 갯수를 확인하여 X의 갯수가 홀수일 경우 폴리오미노로 채울 수 없다고 판단하여 -1을 출력하고 짝수일 경우 cnt를 0으로 갱신하여 . 이후의 X의 갯수를 새로 카운팅하도록 하였다.

이번 문제는 레벨별 점수를 받은 뒤 가장 높은 레벨에서 가장 낮은 레벨 방향으로 순회하며 더 높은 레벨의 점수가 더 낮은 레벨의 점수보다 낮을 경우 낮은 레벨의 점수를 높은 레벨의 점수-1로 지정해주고 감소한 만큼을 따로 누적시키고 더 높은 레벨의 점수가 더 낮은 레벨

이번 문제는 입력받은 문자열을 순회하며 H와 P가 K 거리 안에 붙어 있을 경우 먹힌 햄버거와 햄버거를 먹은 사람의 인덱스를 체크하기 위한 chk 배열에 이를 체크해주고 마지막에 chk배열과 s문자열을 동시에 순회하며 chk가 True이고 s가 P일 경우 cnt를 증가

이번 문제는 과일의 높이를 모두 입력 받고 이를 오름차순으로 정렬한 뒤에 과일 배열을 순회하며 스네이크버드의 길이보다 작거나 같을 경우 스네이크버드의 길이를 1 증가시키는 방법으로 해결하였다.n, l을 입력받는다.과일의 높이를 저장할 배열 fruits를 선언하고 입력받

이번 문제는 입력 받은 센서의 위치를 오름차순으로 정렬한 뒤에 가장 왼쪽에 있는 센서와 가장 오른쪽에 있는 센서 간의 거리를 구하고, 각 센서 간의 거리를 모두 담아둔 배열을 따로 만들고 이를 오름차순으로 정렬하여 가장 왼쪽과 오른쪽 간의 거리에 센서 간의 거리 배열을

이번 문제는 수열의 수들을 양수, 음수, 0으로 구분하여 저장한 뒤에 규칙을 찾아 더하여 가장 큰 결과를 구하여 해결하였다.처음에는 브루트포스 방식으로 모든 경우를 다 구한 뒤에 그 중 가장 큰 수를 채택해야겠다는 생각을 했지만 매우 비효율적일 것 같다는 생각이 들어서

처음에는 모든 경우를 구하는 방식으로 풀어보려고 하였다. 그러나 아무리 생각해보아도 연산 사이클이 너무 커질 것 같아서 다른 방법을 생각해보다가 결국 구글링을 통해 힌트를 얻을 수 있었다. 추의 무게를 담은 배열을 오름차순으로 정렬한 뒤에 이전 추들의 누적합+1이 현재

이번 문제는 접근을 초기에 잘못하는 바람에 코드를 새로 짜야했다. 처음에 접근한 방식은 입력된 문자열의 길이를 가장 긴 문자열과 같게 맞추기 위해 앞에 공백을 붙여 모든 문자열의 길이를 같게 만든 뒤에 모든 문자열의 첫번째 인덱스를 확인, 두번째 인덱스를 확인, ...

처음에는 만들 수 있는 문자열과 만들 수 없는 문자열을 분류하여 규칙을 찾아보려고 하였다. 그러나 가짓수가 너무 많았고 특별한 규칙을 찾기도 힘들었다. 그러던 도중 반대로 구해보는 방법을 생각해보았고 반대로 문자열의 문자를 하나씩 지우는 연산을 통해 문제를 해결하였다.

이번 문제는 크레인의 무게 제한과 상자의 무게를 내림차순 정렬한 뒤에 크레인과 상자를 가장 앞에서부터 검사하며 무거운 상자부터 무거운 크레인으로 옮기도록 배정해주고 크레인에 상자를 올릴 때마다 시간을 증가시키는 방식으로 해결하였다.n을 입력받는다.크레인의 제한 무게를

이번 문제는 원생들의 키를 모두 입력 받은 뒤에 각 원생들 간의 키 차이를 따로 저장하여 이를 내림차순 정렬하고 k-1번째 키 차이부터 가장 마지막의 키 차이까지의 합을 출력하여 해결하였다. 첫 시도에는 k번 반복하는 반복문으로 키 차이 배열에서 원소를 삭제하는 방식으

이번 문제는 초기의 문자열 s를 B로 채운 뒤에 s의 각 문자들을 편하게 변경하기 위해 리스트로 변경하고 s를 순회하며 현재 위치의 문자를 A로 수정한 뒤 s를 순회하며 현재 위치의 문자가 A일 때 뒤에 존재하는 B의 갯수를 더하여 이 누적된 합과 k를 비교하는 방식으

이번 문제는 우선순위큐를 사용하여 우선순위큐의 크기가 1보다 클 동안 가장 작은 두 수를 더한 값을 결과값에 계속해서 더해주어 해결하였다. 가장 작은 두 카드덱을 합치는 것이 가장 작은 결과를 도출한다는 패턴을 쉽게 알 수 있었다. 초기에는 우선순위큐를 사용하지 않고

우선 세준이의 위치는 0이고 책들 또한 0에 위치하기 때문에 음수 좌표에 갔다가 양수 좌표로 가는 것은 동선의 낭비이다. 그렇기 때문에 책들의 제자리를 입력 받은 뒤에 이를 음수 좌표와 양수 좌표의 배열로 나눠서 따로 저장하고, 음수 좌표와 양수 좌표를 절대값이 큰 순

이번 문제는 그리디 알고리즘을 이용하여 주식 가격 배열을 뒤에서부터 비교하며 반복마다 가장 큰 가격보다 작을 경우 이익에 현재 가장 큰 가격에서 현재 가격을 뺀 금액을 더해주고, 만약 가장 큰 가격보다 현재 가격이 더 크다면 가장 큰 가격을 갱신해주는 방식으로 해결하였

이번 문제는 현재 가지고 있는 연료의 양으로 갈 수 있는 주유소 중에서 가장 많은 연료를 채울 수 있는 주유소에 방문하는 것을 기본으로 하여 해결하였다. 주유수의 정보를 모두 입력 받은 뒤에 이를 내림차순으로 정렬한 후 목적지에 갈 수 있는 기름이 모일 때까지 현재 기

이번 문제는 입력 받은 카드를 오름차순으로 정렬하고 가장 앞의 2개의 수의 합을 덮어 씌우는 과정을 m번 반복하는 방식으로 해결하였다.처음으로 heapq를 써야겠다고 먼저 생각하게 된 문제였다. 그 이유는 우선 시간 제한이 1초이고, 매 반복마다 문자열을 오름차순 정렬

처음에 이 문제에 접근할때에는 풍선이 없어질 때까지 반복하는 while문 안에서 풍선을 뒤에서부터 확인하며 자신의 앞의 풍선이 더 클 경우에는 계속해서 풍선을 지우고 더 작다면 cnt변수를 증가시켜 cnt변수를 출력하는 방식으로 작성하였다. 그러나 시간 복잡도가 O(n

처음에는 현재 위치의 수가 바로 다음 위치의 수보다 작을 경우 교체하는 연산을 s번 진행하는 방식으로 코드를 작성하였다. 테스트 케이스는 모두 통과했지만 오답 처리를 당했다. 우선 처음에 작성한 코드이다.문제를 조금 잘못 이해하고 푼 것 같았다. 그래서 다시 한번 읽어

다이나믹 프로그래밍 공부를 시작하는 문제이다. 규칙을 찾아 점화식을 만드는 것이 중요했다. 우선 메모라이제이션을 위한 배열 dp를 만들고 dp의 인덱스는 구매하는 카드의 수로 두고 문제를 접근하였다. dp에 몇장의 카드를 살 때의 최대 금액을 저장하여 dpn을 결과값으

이번 문제는 다이나믹 프로그래밍을 활용하여 해결하였다. 우선 메모라이제이션을 위한 dp배열을 만들고 0으로 채워주고 dp2=1을 미리 지정해준다. dpn이 0인 경우는 업데이트가 안된 경우이므로 이때는 -1을 출력한다. 이번 문제에서 도출한 점화식은 n이 5의 배수일

다음 규칙을 지키는 문자열을 올바른 괄호 문자열이라고 정의합니다.(), \[], {} 는 모두 올바른 괄호 문자열입니다.만약 A가 올바른 괄호 문자열이라면, (A), \[A], {A} 도 올바른 괄호 문자열입니다. 예를 들어, \[] 가 올바른 괄호 문자열이므로, (\

n행 m열의 격자가 있습니다. 격자의 각 행은 0, 1, ..., n-1번의 번호, 그리고 각 열은 0, 1, ..., m-1번의 번호가 순서대로 매겨져 있습니다. 당신은 이 격자에 공을 하나 두고, 그 공에 다음과 같은 쿼리들을 날리고자 합니다.열 번호가 감소하는 방

IT 벤처 회사를 운영하고 있는 라이언은 매년 사내 해커톤 대회를 개최하여 우승자에게 상금을 지급하고 있습니다.이번 대회에서는 우승자에게 지급되는 상금을 이전 대회와는 다르게 다음과 같은 방식으로 결정하려고 합니다.해커톤 대회에 참가하는 모든 참가자들에게는 숫자들과 3

점심시간에 도둑이 들어, 일부 학생이 체육복을 도난당했습니다. 다행히 여벌 체육복이 있는 학생이 이들에게 체육복을 빌려주려 합니다. 학생들의 번호는 체격 순으로 매겨져 있어, 바로 앞번호의 학생이나 바로 뒷번호의 학생에게만 체육복을 빌려줄 수 있습니다. 예를 들어, 4

n개의 음이 아닌 정수가 있습니다. 이 수를 적절히 더하거나 빼서 타겟 넘버를 만들려고 합니다. 예를 들어 1, 1, 1, 1, 1로 숫자 3을 만들려면 다음 다섯 방법을 쓸 수 있습니다.사용할 수 있는 숫자가 담긴 배열 numbers, 타겟 넘버 target이 매개변

문자열 s에는 공백으로 구분된 숫자들이 저장되어 있습니다. str에 나타나는 숫자 중 최소값과 최대값을 찾아 이를 "(최소값) (최대값)"형태의 문자열을 반환하는 함수, solution을 완성하세요.예를들어 s가 "1 2 3 4"라면 "1 4"를 리턴하고, "-1 -2

괄호가 바르게 짝지어졌다는 것은 '(' 문자로 열렸으면 반드시 짝지어서 ')' 문자로 닫혀야 한다는 뜻입니다. 예를 들어"()()" 또는 "(())()" 는 올바른 괄호입니다.")()(" 또는 "(()(" 는 올바르지 않은 괄호입니다.'(' 또는 ')' 로만 이루어진

선행 스킬이란 어떤 스킬을 배우기 전에 먼저 배워야 하는 스킬을 뜻합니다.예를 들어 선행 스킬 순서가 스파크 → 라이트닝 볼트 → 썬더일때, 썬더를 배우려면 먼저 라이트닝 볼트를 배워야 하고, 라이트닝 볼트를 배우려면 먼저 스파크를 배워야 합니다.위 순서에 없는 다른

문자열로 구성된 리스트 strings와, 정수 n이 주어졌을 때, 각 문자열의 인덱스 n번째 글자를 기준으로 오름차순 정렬하려 합니다. 예를 들어 strings가 "sun", "bed", "car"이고 n이 1이면 각 단어의 인덱스 1의 문자 "u", "e", "a"로

0 또는 양의 정수가 주어졌을 때, 정수를 이어 붙여 만들 수 있는 가장 큰 수를 알아내 주세요.예를 들어, 주어진 정수가 6, 10, 2라면 6102, 6210, 1062, 1026, 2610, 2106를 만들 수 있고, 이중 가장 큰 수는 6210입니다.0 또는 양

일반적인 프린터는 인쇄 요청이 들어온 순서대로 인쇄합니다. 그렇기 때문에 중요한 문서가 나중에 인쇄될 수 있습니다. 이런 문제를 보완하기 위해 중요도가 높은 문서를 먼저 인쇄하는 프린터를 개발했습니다. 이 새롭게 개발한 프린터는 아래와 같은 방식으로 인쇄 작업을 수행합

무인도에 갇힌 사람들을 구명보트를 이용하여 구출하려고 합니다. 구명보트는 작아서 한 번에 최대 2명씩 밖에 탈 수 없고, 무게 제한도 있습니다.예를 들어, 사람들의 몸무게가 70kg, 50kg, 80kg, 50kg이고 구명보트의 무게 제한이 100kg이라면 2번째 사람

어떤 숫자에서 k개의 수를 제거했을 때 얻을 수 있는 가장 큰 숫자를 구하려 합니다.예를 들어, 숫자 1924에서 수 두 개를 제거하면 19, 12, 14, 92, 94, 24 를 만들 수 있습니다. 이 중 가장 큰 숫자는 94 입니다.문자열 형식으로 숫자 number

문자열 s에 나타나는 문자를 큰것부터 작은 순으로 정렬해 새로운 문자열을 리턴하는 함수, solution을 완성해주세요.s는 영문 대소문자로만 구성되어 있으며, 대문자는 소문자보다 작은 것으로 간주합니다.str은 길이 1 이상인 문자열입니다.문자열은 불변하다. 순서를

임의의 양의 정수 n에 대해, n이 어떤 양의 정수 x의 제곱인지 아닌지 판단하려 합니다.n이 양의 정수 x의 제곱이라면 x+1의 제곱을 리턴하고, n이 양의 정수 x의 제곱이 아니라면 -1을 리턴하는 함수를 완성하세요.n은 1이상, 50000000000000 이하인

자연수 n이 매개변수로 주어집니다. n을 3진법 상에서 앞뒤로 뒤집은 후, 이를 다시 10진법으로 표현한 수를 return 하도록 solution 함수를 완성해주세요.n은 1 이상 100,000,000 이하인 자연수입니다.입출력 예 설명입출력 예 답을 도출하는 과정은

스마트폰 전화 키패드의 각 칸에 다음과 같이 숫자들이 적혀 있습니다.이 전화 키패드에서 왼손과 오른손의 엄지손가락만을 이용해서 숫자만을 입력하려고 합니다.맨 처음 왼손 엄지손가락은 \* 키패드에 오른손 엄지손가락은 1\. 엄지손가락은 상하좌우 4가지 방향으로만 이동할

H-Index는 과학자의 생산성과 영향력을 나타내는 지표입니다. 어느 과학자의 H-Index를 나타내는 값인 h를 구하려고 합니다. 위키백과1에 따르면, H-Index는 다음과 같이 구합니다.어떤 과학자가 발표한 논문 n편 중, h번 이상 인용된 논문이 h편 이상이고

전화번호부에 적힌 전화번호 중, 한 번호가 다른 번호의 접두어인 경우가 있는지 확인하려 합니다.전화번호가 다음과 같을 경우, 구조대 전화번호는 영석이의 전화번호의 접두사입니다.구조대 : 119박준영 : 97 674 223지영석 : 11 9552 4421전화번호부에 적힌

스파이들은 매일 다른 옷을 조합하여 입어 자신을 위장합니다.예를 들어 스파이가 가진 옷이 아래와 같고 오늘 스파이가 동그란 안경, 긴 코트, 파란색 티셔츠를 입었다면 다음날은 청바지를 추가로 입거나 동그란 안경 대신 검정 선글라스를 착용하거나 해야 합니다.스파이가 가진

초 단위로 기록된 주식가격이 담긴 배열 prices가 매개변수로 주어질 때, 가격이 떨어지지 않은 기간은 몇 초인지를 return 하도록 solution 함수를 완성하세요.prices의 각 가격은 1 이상 10,000 이하인 자연수입니다.prices의 길이는 2 이상

두 수의 최소공배수(Least Common Multiple)란 입력된 두 수의 배수 중 공통이 되는 가장 작은 숫자를 의미합니다. 예를 들어 2와 7의 최소공배수는 14가 됩니다. 정의를 확장해서, n개의 수의 최소공배수는 n 개의 수들의 배수 중 공통이 되는 가장 작

한자리 숫자가 적힌 종이 조각이 흩어져있습니다. 흩어진 종이 조각을 붙여 소수를 몇 개 만들 수 있는지 알아내려 합니다.각 종이 조각에 적힌 숫자가 적힌 문자열 numbers가 주어졌을 때, 종이 조각으로 만들 수 있는 소수가 몇 개인지 return 하도록 soluti

XX게임에는 피로도 시스템(0 이상의 정수로 표현합니다)이 있으며, 일정 피로도를 사용해서 던전을 탐험할 수 있습니다. 이때, 각 던전마다 탐험을 시작하기 위해 필요한 "최소 필요 피로도"와 던전 탐험을 마쳤을 때 소모되는 "소모 피로도"가 있습니다. "최소 필요 피로

△△ 게임대회가 개최되었습니다. 이 대회는 N명이 참가하고, 토너먼트 형식으로 진행됩니다. N명의 참가자는 각각 1부터 N번을 차례대로 배정받습니다. 그리고, 1번↔2번, 3번↔4번, ... , N-1번↔N번의 참가자끼리 게임을 진행합니다. 각 게임에서 이긴 사람은 다

정수 n, left, right가 주어집니다. 다음 과정을 거쳐서 1차원 배열을 만들고자 합니다.n행 n열 크기의 비어있는 2차원 배열을 만듭니다.i = 1, 2, 3, ..., n에 대해서, 다음 과정을 반복합니다.1행 1열부터 i행 i열까지의 영역 내의 모든 빈 칸

1부터 입력받은 숫자 n 사이에 있는 소수의 개수를 반환하는 함수, solution을 만들어 보세요.소수는 1과 자기 자신으로만 나누어지는 수를 의미합니다.(1은 소수가 아닙니다.)n은 2이상 1000000이하의 자연수입니다.입출력 예 1부터 10 사이의 소수는 2,3

0과 1로 이루어진 어떤 문자열 x에 대한 이진 변환을 다음과 같이 정의합니다.x의 모든 0을 제거합니다.x의 길이를 c라고 하면, x를 "c를 2진법으로 표현한 문자열"로 바꿉니다.예를 들어, x = "0111010"이라면, x에 이진 변환을 가하면 x = "0111

JadenCase란 모든 단어의 첫 문자가 대문자이고, 그 외의 알파벳은 소문자인 문자열입니다. 문자열 s가 주어졌을 때, s를 JadenCase로 바꾼 문자열을 리턴하는 함수, solution을 완성해주세요.s는 길이 1 이상 200 이하인 문자열입니다.s는 알파벳과

1부터 n까지 번호가 붙어있는 n명의 사람이 영어 끝말잇기를 하고 있습니다. 영어 끝말잇기는 다음과 같은 규칙으로 진행됩니다.1번부터 번호 순서대로 한 사람씩 차례대로 단어를 말합니다.마지막 사람이 단어를 말한 다음에는 다시 1번부터 시작합니다.앞사람이 말한 단어의 마

두 수를 입력받아 두 수의 최대공약수와 최소공배수를 반환하는 함수, solution을 완성해 보세요. 배열의 맨 앞에 최대공약수, 그다음 최소공배수를 넣어 반환하면 됩니다. 예를 들어 두 수 3, 12의 최대공약수는 3, 최소공배수는 12이므로 solution(3, 1

이번 문제는 다이나믹 프로그래밍으로 해결하였다. 우선 카드 i개를 구매하는 최소 비용을 구해보면 cards1+dpi-1, cards2+dpi-2, cards3+dpi-3, ... , cardsi+dp0이 된다. 그러므로 점화식은 dpi=cardsj+dpi-j가 된다.

이번 문제는 다이나믹 프로그래밍으로 해결하였다. 접근 방법은 수열을 순회하며 현재 수보다 이전에 있는 수 중에 더 큰 수가 있을 경우 dp배열의 현재 위치를 갱신하는 방식이다. 점화식은 dpi=max(dpi, dpj+1)가 된다.n을 입력받는다.a를 입력받는다.dp를

다이나믹 프로그래밍 연습을 위해서 다이나믹 프로그래밍 문제를 더 풀어보았다. 이번에는 이전 수들 중에서 자신보다 작은 수에 대한 dp값을 비교하여 더 큰 값으로 갱신하는 방식으로 해결하였다. 1, 5, 2, 3, 7로 예를 들어보면 다음과 같다.dp배열을 1로 초기화한

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 메모라이제이션을 위한 dp배열을 만들고 점화식을 구하였다. 점화식을 구해보면 dp\[i+t\[i]]=dp\[i]+p\[i], dp\[i]=dp\[i-1] 이렇게 두가지로 나타난다. 이 두가지 방법을 통해 더 큰 값을

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 점화식을 찾는 과정이 정말 오래 걸렸다. 결국은 구글링을 통해 점화식을 찾아 겨우 해결할 수 있었다. 이 문제 점화식의 핵심은 맨 위에 두 칸중 사자가 어디에 있는지에 따라서 따로따로 메모라이제이션을 해야한다는 점이었

이번 문제는 다이나믹 프로그래밍을 활용하여 해결하였다. 피보나치 수 문제는 워낙 많이 접해봐서 바로 풀 수 있었다. 메모라이제이션을 이용하여 연산의 크기를 줄였다.n을 입력받는다.dp 배열을 0, 1, 1 뒤에 0 n개로 채운다.3부터 n까지 반복하는 i에 대한 for

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 문자열을 순회하며 현재 이전의 문자들 중 바로 이전에 올 수 있는 문자의 인덱스를 찾아 문제에서 주어진 연산을 통해 도출되는 값 중 가장 작은 것을 dp현재로 갱신하는 방식으로 접근하였다. 이를 위해 dp배열은 sys

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 이전의 값과 비교하여 dp를 갱신하며 그 중 최대값을 찾아 출력하였다. 처음에 문제를 제대로 읽지 않아서 앞<=뒤, 앞>=뒤 의 경우에 대한 dp를 모두 구현하지 않고 앞<=뒤에 대한 dp만 구현해서 오답

이번 문제는 다이나믹 프로그래밍을 활용하여 해결하였다. 여태 풀었던 다이나믹 프로그래밍과 조금 다르게 메모라이제이션을 하였다. (n+1)\*(m+1)의 리스트를 만들고 n을 순회하면서 리스트를 한줄씩 거치게 된다. 순회 전에 dp0를 1로 바꿔준다. 그리고 반복을 통해

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 메모라이제이션을 2\*1, 1\*2, 2\*2를 가장 왼쪽이 붙이는 경우로 나눠서 진행하였다. 2\*1로 시작하는 타일링의 경우 이전의 모든 경우를 더한 수가 된다1\*2로 시작하는 타일링의 경우 이전의 1\*2의 경

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 점화식을 구하기 위해 그림을 그려보았다.x축은 끝자리 수를 나타내고 y축은 n을 나타내고 있다. 그림을 통해 찾아낸 패턴은 끝자리가 k인 n자리 수의 경우의 수는 n-1자리 수의 끝자리 0~k인 수의 합이 된다.n=2

이번 문제는 다이나믹 프로그래밍을 활용하여 해결하였다. 이동하면서 얻을 수 있는 모든 경우의 수를 저장해야 하고 그때 그때 가장 최선의 값을 저장해야 한다. 이 과정을 도식화하면 다음과 같다.미로를 maze에 저장하였고 dp를 통해 메모라이제이션을 하였다. dp\[0]

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 우선 점화식을 구하기 위해 도식화해보았다.y축은 가장 왼쪽 타일의 경우를 5가지로 나눈 것이고, x축은 N을 의미한다. dp리스트에 저장했다고 가정한다. 우선 N이 홀수일 경우에는 주어진 타일들로 완전히 채울 수 없기

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 점화식을 구하기 위해 도식화 하였다.board에 게임판을 입력하고 dp에 메모라이제이션을 진행하였다. dp0을 1로 갱신한다.dp0에서 갈 수 있는 칸에 해당하는 dp에 dp0을 더한다.\-> dp0에서는 board0

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 전에 자릿수로 만들 수 있는 수를 만드는 문제를 풀어본 기억이 나서 점화식을 쉽게 구할 수 있었다. 점화식을 구하기 위해 도식화 해보았다.전에 구했던 점화식과 조금 다른 점화식을 도출할 수 있었다. 전에 구했던 점화식

자연수 n이 주어졌을 때, n의 다음 큰 숫자는 다음과 같이 정의 합니다.조건 1. n의 다음 큰 숫자는 n보다 큰 자연수 입니다.조건 2. n의 다음 큰 숫자와 n은 2진수로 변환했을 때 1의 갯수가 같습니다.조건 3. n의 다음 큰 숫자는 조건 1, 2를 만족하는

튜브가 활동하는 코딩 동아리에서는 전통적으로 해오는 게임이 있다. 이 게임은 여러 사람이 둥글게 앉아서 숫자를 하나씩 차례대로 말하는 게임인데, 규칙은 다음과 같다.숫자를 0부터 시작해서 차례대로 말한다. 첫 번째 사람은 0, 두 번째 사람은 1, … 열 번째 사람은

어떤 문장의 각 알파벳을 일정한 거리만큼 밀어서 다른 알파벳으로 바꾸는 암호화 방식을 시저 암호라고 합니다. 예를 들어 "AB"는 1만큼 밀면 "BC"가 되고, 3만큼 밀면 "DE"가 됩니다. "z"는 1만큼 밀면 "a"가 됩니다. 문자열 s와 거리 n을 입력받아 s를

행렬의 덧셈은 행과 열의 크기가 같은 두 행렬의 같은 행, 같은 열의 값을 서로 더한 결과가 됩니다. 2개의 행렬 arr1과 arr2를 입력받아, 행렬 덧셈의 결과를 반환하는 함수, solution을 완성해주세요.행렬 arr1, arr2의 행과 열의 길이는 500을 넘

이번 문제는 깊이우선탐색을 통해 해결하였다. 섬의 분포를 확인하기 위해 총 8개의 방향으로 나아갈 수 있기 때문에 dw, dh 리스트를 만들어 8가지의 방향을 저장한 후 이 방향을 이용해서 연결될 수 있는 섬을 모두 방문처리한다. 현재 섬이 이미 방문처리 되어있을 경우

이번 문제는 깊이우선탐색으로 해결하였다. 우선 그래프에서 4개의 방향으로 나아가며 검사할 수 있으므로 4개의 방향에 대한 리스트를 따로 정의해주고, 일반인의 경우 재귀호출 조건을 현재와 같은 색이고 방문처리 되어있지 않을 경우로 지정해주고, 적록색약의 경우 재귀호출 조

이번 문제는 깊이우선탐색을 통해 해결하였다. 거쳤던 곳을 다시 방문해도 상관없기 때문에 방문 처리를 따로 하지 않았고, 4방향으로 모두 재귀호출하여 문자열의 길이가 6이 되었을 때 정답 리스트에서의 중복 검사를 거쳐 삽입하는 방식으로 접근하였다. 재귀 제한을 늘려준다.

이번 문제는 깊이우선탐색을 통해 해결하였다. 현재의 위치에서 갈 수 있는 왼쪽과 오른쪽의 인덱스를 저장하고 왼쪽, 오른쪽 인덱스가 돌다리 범위 내에 존재하고 아직 방문하지 않은 경우에 방문하도록 재귀함수를 호출하는 방식으로 접근하였다. 그리고 마지막에 방문처리 리스트를

이번 문제는 깊이우선탐색으로 해결하였다. 우선 모눈종이를 나타내는 리스트 field를 0으로 채운 후, 직사각형의 영역을 1로 갱신한 뒤에 검사하려는 다음 눈금이 범위 내에 있고 직사각형의 범위가 아니라면 카운팅 변수를 1씩 증가시키며 재귀함수를 호출하는 방식으로 접근

이번 문제는 깊이우선탐색을 통해 해결하였다. 구하고자 하는 두 사람의 번호를 입력 받고 한 사람의 번호부터 연결이 되어있는 모든 경우를 재귀 호출을 통해 검사하며 각각의 촌수를 구해주고 마지막에 반대편 사람의 촌수가 초기값 그대로라면 관계가 없는 것이므로 -1을 출력하

이번 문제는 깊이우선탐색을 통해 해결하였다. 처음에 이 문제에 접근할 때에는 dfs 재귀함수를 통해 각 노드의 레벨을 저장하고 2중 for문을 통해 현재 노드와 연결된 노드의 레벨이 현재 노드의 레벨보다 1 낮을 경우 출력하는 방법으로 접근하였다. 이 방법으로 문제는

이번 문제는 처음 시도에는 깊이우선탐색으로 접근하였다. 방문처리 리스트 대신에 paper리스트 자체에서 확인한 인덱스를 0으로 바꿔주면서 그 영역의 넓이까지 카운팅하는 방식으로 재귀함수를 호출하였다. 이 방식으로 빠르게 해결할 수 있었다.그러나 이 과정에서 메모리 초과

이번 문제는 깊이우선탐색으로 해결하려 하였지만 시간초과가 발생하여서 너비우선탐색으로 해결하게 되었다. 우선 깊이우선탐색으로 풀이는 다음과 같다.파이참에서는 원하는 값을 잘 출력해주었지만 시간초과가 발생하였고, 다른 사람들의 풀이를 찾아보니 모두 BFS로 접근하여 해결한

이번 문제는 깊이우선탐색을 통해 해결하였다. 4가지 이동 방향을 따로 관리하여 모든 방향으로의 경우에 대해서 재귀호출을 통해 그리드에 재귀 제한을 늘린다.dfs 함수를 y, x를 인자로 갖도록 선언한다.\-> grid\[y]\[x]를 '.'으로 갱신한다.\-> 4가지

이번 문제는 깊이우선탐색을 통해 쉽게 해결하였다. 통로에 1이 있을 경우 1을 0으로 바꿔주고 4가지 방향으로 탐색을 진행하며 각 탐색마다 카운팅 변수를 1 증가시키고 결과적으로 카운팅 변수를 반환하는 재귀함수를 작성하여 해결하였다. 재귀 제한을 늘려준다.dfs함수를

이번 문제는 깊이우선탐색을 통해 해결하였다. 일반적인 깊이우선탐색 문제와 비슷하게 풀이하였지만 조금은 달랐다. 그때 그때 좌표의 값에 따라서 영역 안의 늑대와 양의 수를 카운팅하고 깊이우선탐색이 한번 끝날 때마다 늑대와 양의 수를 비교하여 더 큰 수를 해당 카운팅 변수

이번 문제는 깊이우선탐색을 통해 해결하였다. 이번 문제는 인접 리스트 방식으로 그래프를 구성하였다. 이 문제의 패턴을 살펴보면 리프 노드에서 루트 노드까지의 거리들의 합이 짝수일 경우에는 No가 출력되고 합이 홀수일 경우에는 Yes가 출력된다. 그러므로 루트 노드인 1

이번 문제는 깊이우선탐색을 통해 해결하였다. 처음에는 공간 복잡도를 최대한 줄이기 위해서 방문처리 리스트를 사용하지 않고 구현해보려고 했다. 이 방법을 위해 매 반복마다 높이의 최솟값을 구한 뒤에 dfs함수에서 거쳐가는 위치의 높이에서 최솟값을 빼주는 방식으로 해보기로

이번 문제는 깊이우선탐색과 다이나믹 프로그래밍을 이용해서 해결하였다. 처음에는 깊이우선탐색으로만 접근하였다. 단순하게 dfs() 함수에서 현재 위치보다 다음 위치가 작을 경우에 재귀호출 시키고 만약 m-1에 도달하면 전역변수를 1 증가시키는 방법으로 구현하였다. 테스트

이번 문제는 깊이우선탐색을 통해 해결하였다. 인접 리스트 형태로 트리를 저장하였다. 이때 각 노드의 리스트에 저장되는 내용은 자신의 자식 노드들이 된다. 그리고 dfs()함수를 루트부터 시작하여 현재 노드가 제거할 노드라면 함수를 종료하고, 현재 노드의 자식이 없을 경

이번 문제는 깊이우선탐색을 통해 해결하였다. 기존의 깊이우선탐색 문제와 매우 유사하였기 때문에 쉽게 해결할 수 있었다. 문자열로 입력된 섬유 물질의 정보를 가변 객체인 리스트로 변환하여 저장하고, dfs() 재귀 함수에서 방문한 인덱스의 값을 1로 변경시키며 깊이 우선

이번 문제는 깊이우선탐색으로 해결하였다. 이전에 풀어본 양과 늑대 문제와 매우 유사했기 때문에 따로 설명은 생략해도 될 것 같다.재귀 제한을 늘린다.dfs함수를 x, y를 인자로 갖도록 선언한다.\-> k_cnt, v_cnt를 global로 선언한다.\-> field\

이번 문제는 깊이우선탐색을 통해 해결하였다. 깊이우선탐색을 하는 과정에서 사이클의 조건을 생각하는데에 시간이 조금 걸렸다. 사이클의 조건은 다음과 같이 도출되었다.길이가 4 이상이다.다음 탐색하고자 하는 위치가 시작 위치와 같다.탐색 도중에 위의 조건에 만족할 경우 Y

이번 문제는 깊이우선탐색을 통해 해결하였다. 처음에는 치즈인 좌표에서 공기와 접촉한 면이 몇개인지 판단하고 지우는 방식으로 접근하였다. 그러나 이 경우, 하나의 좌표가 지워지면 다른 좌표에 영향을 줘서 결국 다른 방식으로 처리되었다. 그러던 중에 반대로 생각해보기로 하

이번 문제는 깊이우선탐색을 통해 해결하였다. 처음에는 5000\*5000의 그래프를 생성하여 범위에 해당하는 위치를 모두 체크하여 연결되는 범위의 수를 세는 방식으로 해결하려고 하였다. 그러나 인덱스 에러와 시간초과에 시달리는 결과가 도출됐다...그래서 다른 방향으로

이번 문제는 깊이우선탐색을 통해 해결하였다. 2가지 방향을 리스트로 관리하고 현재 위치의 값을 방향값에 곱하여 범위 내에 들어갈 수 있다면 재귀 호출을 하는 방식으로 접근하였고 쉽게 해결하였다.dfs함수를 y, x를 인자로 갖도록 선언한다.\-> answer를 glob

다익스트라 알고리즘을 연습하기 위해 이 문제를 풀어보았다. 처음으로 다익스트라 알고리즘을 활용해봤기 때문에 많이 미숙하여 코드를 찾아보며 풀이하였다.우선 그래프를 인접 리스트 형식으로 저장하였다. 이때 지름길의 종료 위치가 도착지보다 멀리 있을 경우에는 그래프에 저장하

이번 문제는 다익스트라 알고리즘을 통해 해결하였다. 그래프를 인접 리스트 방식으로 저장하였다. 이때 치환이 양방향으로 가능하기 때문에 양방향으로 모두 저장해줘야 한다. 그리고 BFS를 처리하기 위해 사용할 큐 q는 최소힙으로 선언하고, 초기에 0, a를 넣어준다. 이때

이번 문제는 다익스트라 알고리즘을 통해 해결하였다. 그래프를 양방향 인접 리스트로 저장하였고, 방문한 곳을 다시 방문하지 않도록 방문 처리도 적용하였다. BFS에 사용할 큐 q는 최소힙으로 구현하였고 q에는 현재까지 만난 소, 현재 위치를 저장하도록 하였다. 그리고 현

이번 문제는 다익스트라 알고리즘을 통해 해결하였다. 그래프는 양방향 인접 리스트로 구현하였다. 이 문제에서는 친구들의 위치를 시작으로 하는 모든 방까지의 최소 거리를 저장하고, 전체 친구들의 위치에서 해당 방까지의 거리의 합을 따로 관리해야 한다. 전체 친구들의 위치로

이번 문제는 다익스트라 알고리즘을 통해 해결하였다. 다익스트라 알고리즘으로 접근하여 제출하였지만 시간 초과가 발생하여 input을 sys.stdin.readline으로 변경하고, sys.maxsize를 dist 리스트에 매번 넣는것이 아닌, INF 변수에 sys.max

이번 문제는 다익스트라 알고리즘을 통해 해결하였다. 그래프는 인접 행렬 방식으로 저장하였고 4가지 방향으로 너비우선탐색을 진행하며 방문 처리를 진행하였고 다익스트라 알고리즘을 통해 최소 비용을 구하였다. 출력 시 숫자를 표시하기 위한 변수 time을 0으로 선언한다.무

이번 문제는 다익스트라 알고리즘을 통해 해결하였다. 그래프는 양방향 인접 리스트로 구현하였고, 보통의 다익스트라 알고리즘과 같이 각 노드까지의 거리를 저장하는 리스트를 최대값으로 채워둔 뒤에 각 노드들에 가는데 필요한 비용을 비교하여 더 작은 비용을 취하도록 하는 방식

이번 문제는 다익스트라 알고리즘을 통해 해결하였다. 그래프는 양방향 인접 리스트로 구현하였고, 1부터 v1까지의 최단거리+v1부터 v2까지의 최단거리+v2부터 n까지의 최단거리와 1부터 v2까지의 최단거리+v2부터 v1까지의 최단거리+v1부터 n까지의 최단거리 중 더

이번 문제는 다익스트라 알고리즘을 통해 해결하였다. 그래프는 인접 리스트로 구현하였다. 기존의 다익스트라 알고리즘 문제와 조금 다른 점이 있다면 방문한 노드들을 같이 출력해야 한다는 것이었다. 방문한 노드를 담는 리스트를 전역 변수로 선언하게 되면 방문하여 탐색만 했던

n개의 노드가 있는 그래프가 있습니다. 각 노드는 1부터 n까지 번호가 적혀있습니다. 1번 노드에서 가장 멀리 떨어진 노드의 갯수를 구하려고 합니다. 가장 멀리 떨어진 노드란 최단경로로 이동했을 때 간선의 개수가 가장 많은 노드들을 의미합니다.노드의 개수 n, 간선에

네트워크란 컴퓨터 상호 간에 정보를 교환할 수 있도록 연결된 형태를 의미합니다. 예를 들어, 컴퓨터 A와 컴퓨터 B가 직접적으로 연결되어있고, 컴퓨터 B와 컴퓨터 C가 직접적으로 연결되어 있을 때 컴퓨터 A와 컴퓨터 C도 간접적으로 연결되어 정보를 교환할 수 있습니다.

ROR 게임은 두 팀으로 나누어서 진행하며, 상대 팀 진영을 먼저 파괴하면 이기는 게임입니다. 따라서, 각 팀은 상대 팀 진영에 최대한 빨리 도착하는 것이 유리합니다.지금부터 당신은 한 팀의 팀원이 되어 게임을 진행하려고 합니다. 다음은 5 x 5 크기의 맵에, 당신의

가로 길이가 2이고 세로의 길이가 1인 직사각형모양의 타일이 있습니다. 이 직사각형 타일을 이용하여 세로의 길이가 2이고 가로의 길이가 n인 바닥을 가득 채우려고 합니다. 타일을 채울 때는 다음과 같이 2가지 방법이 있습니다.타일을 가로로 배치 하는 경우타일을 세로로

본 문제는 정확성과 효율성 테스트 각각 점수가 있는 문제입니다.밤늦게 귀가할 때 안전을 위해 항상 택시를 이용하던 무지는 최근 야근이 잦아져 택시를 더 많이 이용하게 되어 택시비를 아낄 수 있는 방법을 고민하고 있습니다. "무지"는 자신이 택시를 이용할 때 동료인 어피

위와 같은 삼각형의 꼭대기에서 바닥까지 이어지는 경로 중, 거쳐간 숫자의 합이 가장 큰 경우를 찾아보려고 합니다. 아래 칸으로 이동할 때는 대각선 방향으로 한 칸 오른쪽 또는 왼쪽으로만 이동 가능합니다. 예를 들어 3에서는 그 아래칸의 8 또는 1로만 이동이 가능합니다

처음에는 a, b를 이진수로 바꿔서 일일히 비교하며 값을 변경하는 방식으로 구현하였다. 시간 제한이 매우 적어서 시간 초과가 발생하였고, ^=를 사용하면 바로 XOR 연산이 적용된다는 사실을 알게 되었다. 이를 통해서 매우 간단하게 해결할 수 있었다.a, b, c를 입

이번 문제는 a가 k와 다를 동안 반복하는 while문 안에서 d가 0보다 작을 경우에는 a가 k보다 작아진 경우 k가 될 수 없는 것이므로 반복문을 종료하고, d가 0보다 큰 경우에는 a가 k보다 커진 경우 k가 될 수 없는 것이므로 반복문을 종료하도록 하였다. 반복

이번 문제는 그래프를 탐색하여 해결하는 문제이다. 그래프는 인접 리스트 형태로 저장하였다. 그리고 방문처리 리스트를 사용하여 한 사람이 두 번 이상 말하지 않도록 하였다. 데크를 사용하여 while문의 반복 횟수를 조절하였다.n, m을 입력받는다.그래프 리스트 fing

이번 문제는 다익스트라 알고리즘을 통해 해결하였다. 처음에 접근할 때에는 방문할 수 없는 노드에 대한 그래프를 생성하지 않는 과정을 거치고 난 후에 다익스트라 알고리즘으로 최단 거리를 구하는 방식으로 작성하였다. 그러나 이 방식으로 작성하였을 때 시간 초과가 발생하였다

이번 문제는 시간이 정말 오래 걸렸다. 전에 풀어보았던 문제와 비슷하여 딕셔너리를 이용하여 해당 key에 대한 value에 자릿수를 더하고 자릿수 내림차순으로 정렬하여 9부터 1씩 감소시키며 곱한 값을 더하는 방식으로 접근하였다. 그러나 이 문제에서는 첫자리 숫자가 0

이번 문제는 다익스트라 알고리즘으로 풀 수 있는 문제이다. 우선 그래프를 인접 행렬 형태로 저장하고, 4가지 방향에 대한 탐색을 통하여 그때 그때의 최솟값으로 갱신하는 방식으로 최단거리를 구하였다. 우선 해당 좌표가 -1일 경우에는 접근할 수 없으므로 다음으로 탐색할

민호는 다단계 조직을 이용하여 칫솔을 판매하고 있습니다. 판매원이 칫솔을 판매하면 그 이익이 피라미드 조직을 타고 조금씩 분배되는 형태의 판매망입니다. 어느정도 판매가 이루어진 후, 조직을 운영하던 민호는 조직 내 누가 얼마만큼의 이득을 가져갔는지가 궁금해졌습니다. 예

주어진 항공권을 모두 이용하여 여행경로를 짜려고 합니다. 항상 "ICN" 공항에서 출발합니다.항공권 정보가 담긴 2차원 배열 tickets가 매개변수로 주어질 때, 방문하는 공항 경로를 배열에 담아 return 하도록 solution 함수를 작성해주세요.모든 공항은 알

셀수있는 수량의 순서있는 열거 또는 어떤 순서를 따르는 요소들의 모음을 튜플(tuple)이라고 합니다. n개의 요소를 가진 튜플을 n-튜플(n-tuple)이라고 하며, 다음과 같이 표현할 수 있습니다.(a1, a2, a3, ..., an)튜플은 다음과 같은 성질을 가지

N개의 마을로 이루어진 나라가 있습니다. 이 나라의 각 마을에는 1부터 N까지의 번호가 각각 하나씩 부여되어 있습니다. 각 마을은 양방향으로 통행할 수 있는 도로로 연결되어 있는데, 서로 다른 마을 간에 이동할 때는 이 도로를 지나야 합니다. 도로를 지날 때 걸리는 시

계속되는 폭우로 일부 지역이 물에 잠겼습니다. 물에 잠기지 않은 지역을 통해 학교를 가려고 합니다. 집에서 학교까지 가는 길은 m x n 크기의 격자모양으로 나타낼 수 있습니다.아래 그림은 m = 4, n = 3 인 경우입니다.가장 왼쪽 위, 즉 집이 있는 곳의 좌표는

이번 문제는 BFS를 통해 해결하였다. BFS 안에서 나이트의 이동을 구현하기 위해 나이트의 이동 정보를 리스트에 짝지어 담아 모든 경우를 순회하도록 하였다. 그리고 BFS 안에서 목적지에 도달하면 현재까지의 누적 이동 횟수를 출력하고 반복문을 탈출하도록 하였다.t를

이번 문제는 너비우선탐색과 비트마스킹을 함께 사용하여 풀이하였다. 혼자의 힘으로는 접근하기에 어려웠기 때문에 구글링의 힘을 빌려서 해결하였다. 이 문제에서의 핵심은 (시도한 비밀번호) XOR (1이 k개 들어간 임의의 bit) = 비밀번호 후보를 통해 얻은 비밀번호 후

이번 문제는 itertools의 permutations를 이용하여 정말 쉽게 풀 수 있었다. itertools의 permutations를 리스트로 저장한 뒤에 이를 오름차순으로 정렬하고 주어진 형식대로 출력하였다.n, m을 입력받는다.arr을 입력받는다.결과를 저장할

신입사원 무지는 게시판 불량 이용자를 신고하고 처리 결과를 메일로 발송하는 시스템을 개발하려 합니다. 무지가 개발하려는 시스템은 다음과 같습니다.각 유저는 한 번에 한 명의 유저를 신고할 수 있습니다. \- 신고 횟수에 제한은 없습니다. 서로 다른 유저를 계속해서 신

땅따먹기 게임을 하려고 합니다. 땅따먹기 게임의 땅(land)은 총 N행 4열로 이루어져 있고, 모든 칸에는 점수가 쓰여 있습니다. 1행부터 땅을 밟으며 한 행씩 내려올 때, 각 행의 4칸 중 한 칸만 밟으면서 내려와야 합니다. 단, 땅따먹기 게임에는 한 행씩 내려올

이번 문제는 분할정복을 통해 해결할 수 있는 문제였다. 우선 문제를 보자마자 재귀 함수를 사용해야겠다는 생각을 했다. 왼쪽과 오른쪽에 대한 재귀 호출이 계속 이뤄져야 하는 것으로 보였다. 분할정복은 이렇게 일정한 부분으로 나눠서 따로 따로 처리하는 방식이다. 전체 길이

개발팀 내에서 이벤트 개발을 담당하고 있는 "무지"는 최근 진행된 카카오이모티콘 이벤트에 비정상적인 방법으로 당첨을 시도한 응모자들을 발견하였습니다. 이런 응모자들을 따로 모아 불량 사용자라는 이름으로 목록을 만들어서 당첨 처리 시 제외하도록 이벤트 당첨자 담당자인 "

이 문제의 경우 투에-모스 문자열의 점화식을 찾아보고 점화식을 이용하여 쉽게 구현하였다. 투에-모스 문자열의 점화식은 다음과 같다.이를 코드로 작성하면 다음과 같이 작성할 수 있다.recursion함수를 n을 인자로 갖도록 하여 선언한다.\-> 만약 n이 0일 경우 0

이번 문제는 분할정복을 통해 해결하였다. 규칙을 찾는데에 시간을 많이 썼지만 실패하였고 다른 사람들의 풀이를 조금 참고하였다. 우선 이 문제에서 중요한 것은 사분면으로 계속해서 나누는 것이다. 사분면으로 나눈 후에 구하고자 하는 좌표가 속하는 사분면으로 재귀 호출을 하

양의 정수 x에 대한 함수 f(x)를 다음과 같이 정의합니다.x보다 크고 x와 비트가 1~2개 다른 수들 중에서 제일 작은 수예를 들어,f(2) = 3 입니다. 다음 표와 같이 2보다 큰 수들 중에서 비트가 다른 지점이 2개 이하이면서 제일 작은 수가 3이기 때문입니다

건설회사의 설계사인 죠르디는 고객사로부터 자동차 경주로 건설에 필요한 견적을 의뢰받았습니다.제공된 경주로 설계 도면에 따르면 경주로 부지는 N x N 크기의 정사각형 격자 형태이며 각 격자는 1 x 1 크기입니다.설계 도면에는 각 격자의 칸은 0 또는 1 로 채워져 있

이번 문제는 다익스트라 알고리즘을 사용하여 해결하였다. 탐색의 범위를 n과 k 중 더 큰 수의 2배까지로 설정하였고, 이동 방향을 dx는 \[0, -1, 1]로, tp는 \[2, 1, 1]로 설정하였다. 다음 탐색 인덱스는 (cur+dx\[i])\*tp\[i]가 된다.

이번 문제는 자신의 뒤에 서는 학생을 리스트로 가지는 그래프를 인접 리스트 형식으로 구현하고, 자신의 앞에 있는 학생의 수를 세는 리스트를 따로 만든 뒤, 이 두 개의 리스트를 사용하여 BFS 방식으로 탐색하여 해결하였다. 우선 자신의 앞에 있는 학생의 수가 0인 학생

이번 문제는 단순한 완전 탐색을 통해 해결할 수 있었다. 이동하고자 하는 채널의 최대 크기가 500,000이므로 9밖에 사용할 수 없는 경우, 즉 999,999부터 시작해야 되는 경우가 있으므로 1,000,000에 대하여 순회해야 한다. 순회해가며 그때마다 해당 숫자를

이번 문제는 깊이 우선 탐색을 통해 해결할 수 있었다. 이 문제에서의 키 포인트는 우선 가장 앞의 열에서 가장 끝의 열로 이동한다는 점 (행에서 행이 아님)과 가장 위의 행부터 아래방향을 먼저 탐색해야 한다는 점이다. 우선 처음에 행과 열을 헷갈리는 바람에 삽질을 조금

이번 문제는 정말 많은 시간을 고민하였다. BFS를 사용했는데, 처음에는 이해를 잘못해서 벽에 닿기 전에 방향을 틀 수 있다고 생각하고 구현하였고, 문제를 제대로 이해하고 코드를 계속해서 수정해보았지만 6%를 넘어가지 못하고 오답처리 되었다. 결국은 구글에서 코드를 찾

지도개발팀에서 근무하는 제이지는 지도에서 도시 이름을 검색하면 해당 도시와 관련된 맛집 게시물들을 데이터베이스에서 읽어 보여주는 서비스를 개발하고 있다.이 프로그램의 테스팅 업무를 담당하고 있는 어피치는 서비스를 오픈하기 전 각 로직에 대한 성능 측정을 수행하였는데,

OO 연구소는 한 번에 K 칸을 앞으로 점프하거나, (현재까지 온 거리) x 2 에 해당하는 위치로 순간이동을 할 수 있는 특수한 기능을 가진 아이언 슈트를 개발하여 판매하고 있습니다. 이 아이언 슈트는 건전지로 작동되는데, 순간이동을 하면 건전지 사용량이 줄지 않지만

파일명 정렬세 차례의 코딩 테스트와 두 차례의 면접이라는 기나긴 블라인드 공채를 무사히 통과해 카카오에 입사한 무지는 파일 저장소 서버 관리를 맡게 되었다.저장소 서버에는 프로그램의 과거 버전을 모두 담고 있어, 이름 순으로 정렬된 파일 목록은 보기가 불편했다. 파일을

이번 문제는 보자마자 itertools의 permutations를 사용해야겠다고 생각했다. 그러나 더 좋은 방법이 있을 것 같아 고민하였고 백트래킹 방식으로 풀어보기로 하였다. 우선 사전 순으로 출력해야되기 때문에 입력받은 문자들을 사전 순으로 정렬시키고, 함수 내에서

라디오를 자주 듣는 네오는 라디오에서 방금 나왔던 음악이 무슨 음악인지 궁금해질 때가 많다. 그럴 때 네오는 다음 포털의 '방금그곡' 서비스를 이용하곤 한다. 방금그곡에서는 TV, 라디오 등에서 나온 음악에 관해 제목 등의 정보를 제공하는 서비스이다.네오는 자신이 기억

양의 정수 n이 주어집니다. 이 숫자를 k진수로 바꿨을 때, 변환된 수 안에 아래 조건에 맞는 소수(Prime number)가 몇 개인지 알아보려 합니다.0P0처럼 소수 양쪽에 0이 있는 경우P0처럼 소수 오른쪽에만 0이 있고 왼쪽에는 아무것도 없는 경우0P처럼 소수

주차장의 요금표와 차량이 들어오고(입차) 나간(출차) 기록이 주어졌을 때, 차량별로 주차 요금을 계산하려고 합니다. 아래는 하나의 예시를 나타냅니다.요금표입/출차 기록자동차별 주차 요금어떤 차량이 입차된 후에 출차된 내역이 없다면, 23:59에 출차된 것으로 간주합니다

게임 캐릭터를 4가지 명령어를 통해 움직이려 합니다. 명령어는 다음과 같습니다.U: 위쪽으로 한 칸 가기D: 아래쪽으로 한 칸 가기R: 오른쪽으로 한 칸 가기L: 왼쪽으로 한 칸 가기캐릭터는 좌표평면의 (0, 0) 위치에서 시작합니다. 좌표평면의 경계는 왼쪽 위(-5,

개발자를 희망하는 죠르디가 카카오에 면접을 보러 왔습니다.코로나 바이러스 감염 예방을 위해 응시자들은 거리를 둬서 대기를 해야하는데 개발 직군 면접인 만큼아래와 같은 규칙으로 대기실에 거리를 두고 앉도록 안내하고 있습니다.대기실은 5개이며, 각 대기실은 5x5 크기입니

트럭 여러 대가 강을 가로지르는 일차선 다리를 정해진 순으로 건너려 합니다. 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 알아내야 합니다. 다리에는 트럭이 최대 bridge_length대 올라갈 수 있으며, 다리는 weight 이하까지의 무게를 견딜 수 있습니다

이번 문제는 시간 초과 발생으로 인해 많은 시도를 했던 문제이다. 처음에는 단순하게 이중 for문으로 작성하였고 N의 범위로 인해 당연하게 시간 초과가 발생하였다. 성능 개선을 고민하던 중 while문 안에서 포인터 2개로 서로를 비교하도록 작성하였지만 또 다시 시간

이번 문제는 문제에서 주어진 내용대로 구현을 하는 문제이다. 미세먼지가 퍼지는 함수를 작성하고, 공기청정기가 한바퀴 도는 함수를 작성하였다. 혼자 힘으로 코드를 작성하다가 막히는 부분들이 조금 존재하여 다른 사람의 코드를 참고하였다. 미세먼지가 퍼지는 함수는 동서남북

이번 문제는 다익스트라 알고리즘을 활용하여 해결하였다. 이 문제에서는 다익스트라 알고리즘을 함수로 따로 구현해야 한다. 여러번 사용해야 하기 때문이다. 결과적으로 모든 마을에서의 다익스트라 함수를 호출해야 한다. x마을을 출발점으로 호출한 경우에는 모든 마을의 비용에

이번 문제는 바로 이전에 풀었던 문제와 거의 풀이가 유사하다. 다익스트라 알고리즘을 함수로 구현하고, 모든 노드에서부터의 다익스트라 함수를 모두 호출한 후, 반환되는 거리 리스트의 원소들의 총합을 한 리스트에 모은 후 가장 작은 값의 인덱스를 출력하도록 접근하였다. n

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 우선 점화식을 구하기 위해 도식화해보았다.k가 1일 때의 dp는 모두 1로 채워지고, n이 1일 때의 dp는 모두 k로 채워진다. 그리고 dpi는 dpi+dpi-1의 값으로 갱신되는 것을 볼 수 있다. 따라서 점화식은

이 문제는 파이썬의 집합 자료형을 이용하면 쉽게 풀 수 있는 문제이다. 처음에는 간단하게 생각하여 진실을 아는 사람이 포함되지 않은 파티의 개수를 반환하면 된다고 생각했다. 다시 생각해보니, 진실을 아는 사람이 포함된 파티에 있는 사람들도 진실을 알게 되므로, 진실을

이번 문제는 너비 우선 탐색을 통해 해결하였다. 로직은 맞게 작성했지만 시간 초과 이슈가 계속 발생하여서 여러번 접근 방식을 변경하였다. 우선 처음으로 접근했을 때는 빙산이 녹는 함수는 BFS로, 빙산의 개수를 세는 함수는 DFS로 작성하였다. 매 while문마다 0으

이번 문제는 도시 전체를 순회하며 각 집의 인덱스와 치킨집의 인덱스를 따로 저장한 후, 치킨집들을 itertools의 combinations를 이용하여 m개씩으로 조합한 리스트를 순회하며 각 집들과의 거리 중 가장 짧은 거리를 누적시켜 그 값을 비교하여 가장 작은 값을

문제들이 잘 풀리지 않아 준비 운동으로 쉬운 문제를 한번 풀어보았다. 이 문제는 단순하게 조합의 공식을 대입하여 해결하였다.n, m을 입력받는다.분자에 해당하는 top을 1로 선언한다.분모에 해당하는 bottom을 1로 선언한다.m번 반복하는 i에 대한 for문을 돌린

이번 문제는 다익스트라 알고리즘을 통해 쉽게 해결하였다. 기존의 다익스트라 알고리즘 문제와 똑같이 작성을 하고, 힙에 넣을 다음 탐색 구역이 1일 경우에는 비용을 1 증가시켜주고, 그 외에는 비용을 그대로 유지한 상태로 진행시킨다. 이렇게 하면 목적지의 최소 비용을 구

이번 문제는 BFS 알고리즘을 통해 해결하였다. 문제를 보자마자 BFS 알고리즘을 통해 해결해야겠다는 생각을 했지만 공기 중과 구멍을 분간하는 법에 대한 방법이 떠오르지 않았다. 이 부분에 대해서 오랫동안 고민하다가 다른 사람의 풀이법을 보았고, 0에서 1로 가는 부분

이번 문제는 이분 탐색을 통해 해결하였다. 여기서의 left는 가장 작을 수 있는 차이인 1로, right는 가장 클 수 있는 차이인 home-1-home0으로 선언하였다. 그리고 mid를 잡으며 이분 탐색을 통해 가장 인접한 두 공유기 사이의 최대 거리를 구한다. 여

이번 문제는 이분 탐색을 통해 해결하였다. 우선 A와 B를 입력받음과 동시에 오름차순으로 정렬시켜놓고, A를 순회하며 B에 대한 Ai의 이분 탐색을 통해 Ai보다 작은 수의 갯수를 도출해낸다. 이때, 무의미한 탐색을 줄이기 위해 Ai가 B의 첫번째 원소보다 작거나 같을

이번 문제는 이분 탐색을 통해 해결하였다. 처음에 문제를 접했을 때에는 다이나믹 프로그래밍을 통해 풀어야겠다고 생각하였다. 현재 위치의 수 앞을 순회하며 자신보다 작은 수가 있을 경우 dp를 업데이트 시키는 방식으로 작성하였다.그러나 DP는 O(N^2)의 시간 복잡도가

이번 문제는 두개의 힙을 사용하여 해결하였다. 처음에는 입력을 받을 때에 이분 탐색을 통해 입력값이 들어갈 자리를 찾아 들어가도록 하고, 가운데 값을 인덱스로 접근하여 매 입력마다 출력되도록 하였다. 그러나 시간초과가 발생하였고, 다른 방법이 생각나지 않아 고민하던 중

이번 문제는 union-find 알고리즘을 통해 해결하였다. 처음에는 문제에서 주어진 그대로 집합 자료형을 사용하여 합집합을 만들어 관리하도록 하였지만 시간 초과가 발생하였다.0부터 n까지의 집합을 만들어 result에 담아두고, 0이 입력되면 a, b가 포함된 집합을

여러 언론사에서 쏟아지는 뉴스, 특히 속보성 뉴스를 보면 비슷비슷한 제목의 기사가 많아 정작 필요한 기사를 찾기가 어렵다. Daum 뉴스의 개발 업무를 맡게 된 신입사원 튜브는 사용자들이 편리하게 다양한 뉴스를 찾아볼 수 있도록 문제점을 개선하는 업무를 맡게 되었다.개

이번 문제에서는 주사위의 전개도가 매우 중요했다. 주사위에 새겨지는 수를 리스트로 관리하고, 각 방향으로 주사위가 돌아갈 때에 인덱스 1은 항상 위, 인덱스 6은 항상 아래로 향하도록 하고 방향에 따라서 값들을 회전시켜주었다. 이 과정은 당연히 주사위의 다음 위치가 그

이번 문제는 피보나치 수 문제 중에서 입력값이 정말 크게 주어진 경우이다. 우선 내가 할 수 있는 최선의 피보나치 수 코드는 다이나믹 프로그래밍 알고리즘을 통한 작성이기 때문에 다이나믹 프로그래밍을 작성하였고 메모리 초과라는 결과를 얻었다.그래서 찾아본 결과 피보나치

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. dp 리스트를 n\*21의 크기로 잡은 후, n을 순회하며 연산 후 나오는 수에 해당하는 인덱스의 값에 dp에 저장된 값을 더하는 방식으로 풀이하였다. 예제 1을 예로 들면 다음과 같다.8 3 2 4 8 7 2 4 0

이번 문제는 딕셔너리를 사용하여 해결하였다. 우선 터널에 들어가는 차들을 딕셔너리에 {이름: 순번}으로 저장한다. 그리고 터널을 나오는 차들을 리스트로 저장한다. 이제 2중 for문을 사용하여 터널을 나오는 차들의 리스트에서 현재 차보다 뒤에 있는 차 중, 현재 차보다

이번 문제는 문자열 처리가 관건이었다. 학생의 번호를 입력받고, 1부터 번호의 길이까지 1씩 늘려가며 학생들의 번호-1:의 중복 여부를 확인하고, 만약 중복이 없는 경우가 발생하면 바로 해당 번호의 길이를 출력하고 종료되도록 작성하였다.n을 입력받는다.학생 번호를 입력

이번 문제는 수많은 조건들을 정의해 해결해야 하는 문제였다. 처음에는 단순하게 인접 행렬 형식의 그래프를 만든 후, 두 박스의 영역을 1로 갱신한 후, DFS를 통해 그래프를 순회하며 전체 넓이를 구하고, 두 박스의 좌표로 넓이를 구한 후, 두 넓이를 비교하여 1차이

이번 문제는 플로이드-와샬 알고리즘을 통해 해결하였다. 이전 같았다면 모든 정점에서의 다익스트라 알고리즘을 돌렸겠지만 이는 분명히 시간 초과가 발생했을 것이다. 플로이드-와샬은 모든 정점에서 모든 정점으로의 최단 거리를 구하는 알고리즘으로 다이나믹 프로그래밍을 기초로

이번 문제는 BFS 알고리즘을 활용하여 해결하였다. 여기서는 지훈이와 불이 동시에 움직이는 것을 표현해야 했기 때문에 이 부분에서 고민을 많이 했다. 처음에는 불의 모든 좌표를 리스트에 계속해서 모으고, 반복하며 지훈이를 한칸씩, 모든 불들을 상하좌우로 한칸씩 이동하도

이번 문제는 풀이보다는 간단한 생각으로 바로 해결하였다. 처음에는 시작하는 시작점도 주지 않아서 어떻게 접근해야 할지 난감했지만, 문제에서 비행 스케줄이 항상 연결 그래프라는 부분을 보고 생각을 해냈다. 연결 그래프에서 모든 지역을 최소한의 비행으로 방문하기 위해서는

이번 문제는 플로이드-와샬 알고리즘을 통해 해결하였다. 기존의 플로이드-와샬 문제와 다른 점이 있다면 최단 거리를 저장하는 것이 아닌, 최단 거리로 가기 위해 다음에 방문해야할 정점의 번호를 저장해야 한다는 점이었다. 그래서 최단 거리를 저장할 리스트와 다음에 방문해야

이번 문제는 플로이드-와샬을 통해 해결하였다. 기존의 플로이드-와샬 문제와 조금 다르게 초기의 최소 비용 리스트를 최댓값이 아닌 0으로 모두 채워줘야 한다. 그리고 a가 b보다 작다고 할 때에, 최소 비용 리스트a를 1로 갱신해준다. 이렇게 초기화가 되면, 플로이드-와

이번 문제는 정렬을 이용하여 해결하였다. tips를 입력받고, tipsi-i가 0보다 클 경우에만 결과 변수에 더하는 방식으로 계산했을 때에 최대값을 만들기 위해서는 tips가 내림차순으로 정렬되어야 한다. 이 접근법으로 쉽게 해결할 수 있었다.n을 입력받는다.tips

이번 문제는 플로이드-와샬 알고리즘을 사용하여 쉽게 해결하였다. 우선 각 정점에서 다른 정점까지 도착할 수 있을 경우에 1로 표시되고, 아닐 경우 0으로 표시되므로, 해당 정점까지 바로 가는 경로가 있거나 중간 정점이 존재할 경우에는 도착할 수 있는 경우가 되므로 1로

이번 문제는 플로이드-와샬 알고리즘과 다익스트라 알고리즘을 사용하여 두번 풀어보았다. 우선 플로이드-와샬 알고리즘 풀이는 모든 정점에서 모든 정점으로의 최단 거리를 구하여 저장한 후에, 결과값들을 순회하며 최단 거리가 m 이하인 정점에 대한 아이템 수를 더하여 그 중

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 점화식을 찾는 과정이 어려웠는데 다른 사람의 풀이를 어느정도 참고하여 2가지의 점화식을 도출해냈다. 점화식을 도출하기 위해 다음과 같이 도식화하였다.첫번째 점화식은 dp\[i-3], dp\[i-2], dp\[i-1]을

이번 문제는 DP와 permutations를 사용하여 풀이하였다. 처음에는 패턴을 찾아보려고 했지만 공격의 최대 횟수가 3이기 때문에 permutations를 사용해도 크게 성능에 지장이 없을 것 같아 permutations으로 공격 순서의 모든 경우를 비교하며 dpa

이번 문제는 백트레킹을 통해 해결하였다. 가능한 결과값을 백트레킹을 통하여 모두 구한 후에 그 중에서 가장 큰 값을 출력하도록 하였다. 방문 처리는 해당 포지션이 선발된 것과 같은 의미로 사용되었기 때문에 1차원 리스트로 구현하였다. 모든 포지션이 선발되게 되면 idx

이번 문제는 파이썬의 itertools 모듈을 사용하여 해결하였다. 2부터 n까지 반복하는 i에 대한 for문을 돌려 i개로 이루어진 combinations를 모두 생성하고, 생성된 combinations들을 순회하며 전체 합, 최댓값과 최솟값의 차를 l, r, x와

이번 문제는 DP를 통해 해결하였다. 수열은 1 -> 01 -> 1001 -> 01101001 -> 1001011001101001 -> ... 으로 구성된다. 이때 만들어진 문자열들을 반으로 잘라 보면 다음과 같은 규칙을 찾을 수 있다.앞쪽과 뒷쪽이 XOR연산을 했을

이번 문제는 DP를 통해 해결하였다. 처음에는 다익스트라를 통해 힙에 점수에 해당하는 값을 음수로 넣어 최대힙으로 구현하여 해결하려고 했으나 오답이라는 결과를 얻었다. 그래서 DP로 다시 구현하였다. 비행에 해당하는 그래프를 인접 행렬로 구현하고, dp 리스트를 2차원

이번 문제는 BFS를 통한 그래프 탐색으로 해결하였다. 초반에 뼈대는 바로 작성하였지만 예외처리를 하는 부분에서 시간이 오래 걸렸다. n이 k보다 큰 경우와 n이 0이고, k가 1인 경우에만 bfs함수에서 None이 반환되었다. 그래서 이 경우에 대한 예외처리를 진행하

이번 문제는 우선순위 큐, 즉 파이썬에서의 heapq 모듈을 이용하여 해결하였다. 처음 접근은 그래프를 저장할 때에 현재 문제보다 먼저 풀어야 되는 문제를 인접 리스트로 저장하고, 1부터 n까지 순회하며 현재 문제 번호보다 먼저 풀어야 하는 문제를 재귀 함수를 통해 찾

이번 문제는 로봇 청소기의 구동 순서를 구현하고 이를 전체 탐색을 통해 결과 값을 도출하는 문제였다. 그래서 DFS를 이용하여 탐색하기로 하였다. 이 문제에서 어려웠던 점은 방향이 계속 바뀐다는 점이었다. 그래서 우선 dy, dx리스트에 북, 동, 남, 서 순서로 방향

이번 문제는 deque의 rotate 함수를 사용하여 해결하였다. rotate(1)의 경우 해당 문자열은 1:+0과 같은 형태가 되고, rotate(-1)의 경우 해당 문자열은 -1+:-1과 같은 형태가 된다. 돌아간 톱니바퀴의 오른쪽에 위치하는 모든 톱니바퀴를 회전시

이번 문제는 deque를 이용하여 해결하였다. 우선 조건대로 deque의 rotate()함수를 이용하여 벨트와 로봇을 한칸씩 이동시키고, n-1인덱스에 위치하는 로봇을 없애준다. 그리고 로봇 리스트를 뒤에서부터 순회하며 다음 칸에 로봇이 없고 다음 칸의 내구도가 0보다

이번 문제는 반복문 하나로 간단하게 해결할 수 있었다. 반복문 안에서 현재 시험장에서 b를 빼주고, 만약 현재 시험장의 학생 수가 0보다 클 경우에만 시험장의 학생 수가 c로 나눠 떨어진다면 몫을 결과 변수에 더하고, 나눠떨어지지 않으면 몫+1을 결과 변수에 더했다.

카카오에 신입 개발자로 입사한 "콘"은 선배 개발자로부터 개발역량 강화를 위해 다른 개발자가 작성한 소스 코드를 분석하여 문제점을 발견하고 수정하라는 업무 과제를 받았습니다. 소스를 컴파일하여 로그를 보니 대부분 소스 코드 내 작성된 괄호가 개수는 맞지만 짝이 맞지 않

rows x columns 크기인 행렬이 있습니다. 행렬에는 1부터 rows x columns까지의 숫자가 한 줄씩 순서대로 적혀있습니다. 이 행렬에서 직사각형 모양의 범위를 여러 번 선택해, 테두리 부분에 있는 숫자들을 시계방향으로 회전시키려 합니다. 각 회전은 (x

레스토랑을 운영하던 스카피는 코로나19로 인한 불경기를 극복하고자 메뉴를 새로 구성하려고 고민하고 있습니다.기존에는 단품으로만 제공하던 메뉴를 조합해서 코스요리 형태로 재구성해서 새로운 메뉴를 제공하기로 결정했습니다. 어떤 단품메뉴들을 조합해서 코스요리 메뉴로 구성하면

이번 문제는 BFS를 이용하여 갈 수 있는 공간 중 조건에 부합하는 위치로 이동하는 과정을 더이상 움직일 수 없을 때까지 반복하는 방식으로 접근하였다. 답을 찾아보지 않고 풀이하여 시간이 오래 걸렸지만 그만큼 얻은게 많은 문제이다.n을 입력받는다.공간을 grid에 입력

이번 문제는 삼성 기출로 구현, 시뮬레이션으로 분류된 문제이다. 우선 구현 문제의 경우에는 함수로 각각의 과정을 정의하는 것이 가장 깔끔하다고 생각하기 때문에 모든 과정을 함수로 구현하였다. 우선 비구름의 위치를 나타낼 리스트 clouds를 False로 채워 2차원으로

이번 문제는 삼성 기출 문제로 BFS를 이용한 구현으로 해결하였다. 우선 Combinations를 사용해야 한다는 생각을 하였고, itertools를 이용하여 Combinations를 사용하여 해결해본 후에, Combinations를 재귀함수로 직접 구하여 다시 해결해

이번 문제는 백트레킹을 이용하여 풀이하였다. 처음에는 수열에 중복된 수가 없을 것이라 생각하고 풀이하여 값에 대한 중복 처리를 하여 틀렸다. 중복된 수가 존재할 가능성을 생각하여, 선택된 수들의 인덱스를 따로 저장하고, 이에 대한 중복 처리를 하여 해결할 수 있었다.n

이번 문제는 주어진 조건대로 백트레킹을 진행하며 모든 경우를 구하고, 그 중 가장 큰 경우를 구하는 방식으로 해결하였다. x-1, x+1 인덱스의 원소의 곱을 에너지로 더하기 위해서 구슬 리스트를 지우기 전에 해당 값들을 미리 저장하고, x위치의 원소를 지운 후, 재귀

이번 문제는 백트레킹과 BFS를 고민하다가 BFS로 풀이하였다. 동전이 2개로 고정되어 있으므로 2개의 동전의 좌표와 카운팅 변수를 deque에 넣어주고, 4개의 방향 리스트를 이용하여 모든 경우를 탐색한다. 이때 동전의 다음 위치에 대한 조건 처리를 해주어야 한다.두

이번 문제는 브루트포스를 통해 모든 경우에 대하여 접근하며, 범위 내에 존재할 수 있는 경우에 조건에 맞게 5개의 구간으로 나누는 함수를 구현하여 구간별 인구수의 합을 리스트로 저장하고, 이 리스트에서의 최댓값과 최솟값의 차를 최종 결과 변수와 비교하여 더 작은 값으로

이번 문제는 삼성 기출 문제로, 큐를 사용하여 쉽게 해결하였다. 문제에서 주어진대로 다음 위치 인덱스를 범위에 들어갈 경우에 구하고, 해당 인덱스가 뱀의 인덱스를 나타내는 tail 큐에 들어있을 경우 result+1을 반환하고, 그렇지 않다면 다음 위치를 tail에 넣

n명의 사람이 일렬로 줄을 서고 있습니다. n명의 사람들에게는 각각 1번부터 n번까지 번호가 매겨져 있습니다. n명이 사람을 줄을 서는 방법은 여러가지 방법이 있습니다. 예를 들어서 3명의 사람이 있다면 다음과 같이 6개의 방법이 있습니다.1, 2, 31, 3, 22,

이번 문제는 그때 그때의 행과 열의 길이를 계산하여 R 연산과 C 연산을 주어진대로 구현하는 문제였다. 우선 defaultdict를 이용하여 행이나 열의 수들의 등장을 카운팅하고, defaultdict를 순회하며 key와 value를 튜플로 임시 리스트에 저장하고, 이

이번 문제는 삼성 기출 문제로 BFS를 통해 개방할 수 있는 국경선들을 모두 체크하고, 현재 위치의 나라와 연결된 모든 나라들을 구하여 그 나라들의 인구수를 평균값으로 갱신해준다. 이 과정을 거치기 전의 전체 나라들의 인구 상황을 저장하고, 이 과정을 거친 후의 인구

이번 문제는 삼성 기출 문제로, 재귀를 통해 활성화 바이러스의 combinations를 구하고, combinations를 순회하며 해당 위치에서 바이러스가 퍼지는 과정을 BFS를 이용하여 구현하였다. 바이러스가 퍼지는 시간은 방문처리 리스트에 카운팅하는 방식으로 진행하

이번 문제는 삼성 기출 문제로 백트레킹과 구현을 통해 해결하였다. 처음에 백트레킹을 생각했지만, 브루트포스로도 해결이 가능할 것이라 생각하였고, 브루트포스로 구현을 하였다. cctv의 위치와 종류를 튜플로 하여 cctvs리스트에 담고, 이를 종류의 내림차순으로 정렬한

이번 문제는 삼성 기출 문제로, 조건들을 따져가며 구현하는 방식으로 해결하였다. 컬럼을 확인하는 함수 chk_column과 로우를 확인하는 함수 chk_row를 작성하였다.아래에서 위로 향하며 연속되는 수의 갯수를 DP를 이용하여 dp1에 저장한다.위에서 아래로 향하며

조이스틱으로 알파벳 이름을 완성하세요. 맨 처음엔 A로만 이루어져 있습니다.ex) 완성해야 하는 이름이 세 글자면 AAA, 네 글자면 AAAA조이스틱을 각 방향으로 움직이면 아래와 같습니다.예를 들어 아래의 방법으로 "JAZ"를 만들 수 있습니다.만들고자 하는 이름 n

n명의 권투선수가 권투 대회에 참여했고 각각 1번부터 n번까지 번호를 받았습니다. 권투 경기는 1대1 방식으로 진행이 되고, 만약 A 선수가 B 선수보다 실력이 좋다면 A 선수는 B 선수를 항상 이깁니다. 심판은 주어진 경기 결과를 가지고 선수들의 순위를 매기려 합니다

효진이는 멀리 뛰기를 연습하고 있습니다. 효진이는 한번에 1칸, 또는 2칸을 뛸 수 있습니다. 칸이 총 4개 있을 때, 효진이는(1칸, 1칸, 1칸, 1칸)(1칸, 2칸, 1칸)(1칸, 1칸, 2칸)(2칸, 1칸, 1칸)(2칸, 2칸)의 5가지 방법으로 맨 끝 칸에 도

처리해야 할 동일한 작업이 n 개가 있고, 이를 처리하기 위한 CPU가 있습니다.이 CPU는 다음과 같은 특징이 있습니다.CPU에는 여러 개의 코어가 있고, 코어별로 한 작업을 처리하는 시간이 다릅니다.한 코어에서 작업이 끝나면 작업이 없는 코어가 바로 다음 작업을 수

스트리밍 사이트에서 장르 별로 가장 많이 재생된 노래를 두 개씩 모아 베스트 앨범을 출시하려 합니다. 노래는 고유 번호로 구분하며, 노래를 수록하는 기준은 다음과 같습니다.속한 노래가 많이 재생된 장르를 먼저 수록합니다.장르 내에서 많이 재생된 노래를 먼저 수록합니다.

이번 문제는 삼성 기출 문제로 문제에서 주어진 조건대로 구현하여 해결하였다. 데이터를 관리하는 형태를 정하는 것이 조금 고민 되었는데, 나무의 경우에는 3차원 리스트를 이용하여 한칸의 땅에 나무가 여러그루 있는 것을 구현했고, 영양분의 정보를 2차원 리스트로 따로 관리

카카오톡에 뜬 네 번째 별! 심심할 땐? 카카오톡 게임별~카카오톡 게임별의 하반기 신규 서비스로 다트 게임을 출시하기로 했다. 다트 게임은 다트판에 다트를 세 차례 던져 그 점수의 합계로 실력을 겨루는 게임으로, 모두가 간단히 즐길 수 있다.갓 입사한 무지는 코딩 실력

이번 문제는 삼성 기출 문제였다. 시뮬레이션 문제로, 원판의 회전을 표현해야 하기 때문에 deque의 rotate()함수를 사용하였다. 이를 통해 원판의 회전을 쉽게 구현할 수 있었다. 그러나 원판에서 인접한 곳의 수가 같을 경우에 제거하는 과정에서 조금 오랜 시간이

이번 문제는 삼성 기출 문제로, 시뮬레이션을 구현하는 문제였다. 파이어볼의 좌표가 범위를 벗어나면 어떻게 되는지에 대한 명시가 되어있지 않아 이 부분에 대해서만 질문 검색을 통해 순환한다는 것을 알아냈다. 파이어볼의 저장 방법은 인접 행렬에 값을 갱신하는 형태로 하였다

이번 문제는 삼성 기출 문제로 정말 어렵게 해결하였다. 처음에 데이터 관리 방식에 대해 고민을 많이 하였고, 해당 칸에 존재하는 체스말의 번호를 저장할 3차원 리스트와 각 말의 현재 위치와 방향을 저장할 리스트를 따로 관리하였다. 다음 칸이 0일 경우와 1일 경우에 대

이번 문제는 삼성 기출 문제로, 시뮬레이션 구현과 BFS를 이용하여 해결하였다. 구현에 쉽게 접근하기 위해 각 기능을 함수로 따로 구현하였다.cycle: 얼음의 위치를 돌리는 함수melt: 얼음을 녹이는 함수find_biggest: 가장 큰 얼음 덩어리를 찾는 함수ge

이번 문제는 삼성 기출 문제로, 시간초과와 예외에 걸려 오랜 시간을 투자하였다. 우선 처음에는 bfs함수를 사람의 수만큼 탐색하여 가장 가까운 사람을 찾도록 하였다. 그러나 이럴 경우에 승객이 많아질 경우, bfs함수의 호출 횟수가 늘어 시간초과가 발생한다. 그래서 다

이번 문제는 삼성 기출 문제로, 상어의 이동에 대한 모든 경우를 백트레킹을 통해 구하여 그 중 가장 큰 값을 정답 변수에 저장하는 문제였다. 우선 크게 물고기의 이동과 상어의 이동, 이렇게 2개의 함수로 나눠서 정의하였다.물고기의 이동의 경우에는 물고기의 방향을 반시계

이번 문제는 백트레킹을 통해 가능한 좌표들의 조합을 구하고, 해당 조합을 순회하며 연결되어 있는지 DFS를 통해 확인하도록 하였다. 조합을 구할 때에는 조합 하나가 완성 되었을 때, S가 4개 이상 존재하지 않으면 추가하지 않도록 하여 갯수를 줄였다.

이번 문제는 다익스트라 알고리즘을 통해 해결하였다. 처음에는 백트레킹을 통해 경우의 수를 따져 구하려고 하였지만 다익스트라로 해결할 때에 훨씬 간단하게 해결할 수 있을 것이라는 생각을 중간에 하였고, 다익스트라로 거리를 체크하여 그 중 가장 큰 수를 걸리는 시간으로,

이번 문제는 입력받은 정보를 정렬하고, 이전의 리스트와 현재의 리스트의 같은 레벨을 비교하여 겹치는 부분이 있을 경우에는 그 부분을 건너 뛰고 값을 넣어주는 방식으로 해결하였다. 주어진 예제에서는 레벨 0에 대한 중복 처리만 되어 있었기 때문에 레벨 0에 대한 중복처리

이번 문제는 삼성 기출 문제로, 입력되는 순서대로 학생의 자리를 배정하는 문제이다. 3가지 조건에 만족하는 자리를 찾아 자리를 배정해야 하기 때문에 비어 있는 자리를 모두 확인해보아야 한다. 이 방법에 대해 생각하던 중에 리스트로 관리하면 쉽게 해결할 수 있겠다는 생각

이번 문제는 삼성 기출 문제로, 2차원 배열의 회전과 BFS, 배열 한쪽으로 밀어내기를 이용하여 해결하였다. 각각의 기능을 함수로 모듈화하여 해결하였고, 함수명은 다음과 같다bfs(y, x): 블록 그룹을 찾고, 속하는 무지개색 블록의 갯수와 해당 그룹의 모든 인덱스를

이번 문제는 BFS를 이용하여 해결하였다. 로봇의 위치와 방향에 대한 방문 처리를 위하여 방문 처리 리스트를 3차원 배열로 만들었고, 각 위치와 방향 별로 방문 처리를 하였다. 그리고 앞으로 가는 명령에서 다음 가려는 좌표가 1일 경우에는 그보다 더 앞으로 나아갈 수

이번 문제는 BFS를 통해 해결하였다. 처음에는 문제를 보자마자 벽을 없애는 모든 경우에 대하여 bfs 함수를 돌리는 것으로 생각하고 구현을 하였다. 그러나 N과 M의 범위가 커서 시간 복잡도가 터져 시간 초과가 발생하였다. 그래서 이번에는 bfs 함수 내에서 magi

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 맨 처음에는 브루트포스를 통해 문제를 파악하였고, N, M의 범위가 1000까지기 때문에 당연히 시간 초과가 발생할 것이라 생각하였다. 그래서 다이나믹 프로그래밍으로 접근하였고, 다음과 같이 점화식을 구할 수 있었다.

이번 문제는 구현 문제로, 퀸과 나이트의 이동 방향을 dy, dx 기법으로 구현하여 해결하였다.

이번 문제는 BFS를 통해 해결하였다. 맨 처음에는 백트레킹을 통해 구현하였지만 시간초과가 발생하였고, BFS로 구현하였다. 중요한 포인트는 방문처리 리스트를 3차원 배열로 줘야 한다는 점이었다. 말의 움직임이 k번 남은 경우에 대한 모든 거리를 저장해주어야 답을 구할

이번 문제는 DFS와 DP를 이용하여 해결하였다. 처음에는 DFS만으로 탐색하여 시간초과가 발생하였다. 그래서 DP를 통해 해당 좌표에서의 값을 저장하고, 다음 탐색하고자 할 때의 카운팅 변수가 그 좌표의 dp값보다 작을 경우에는 탐색하지 않도록 하는 방식으로 가지치기

이번 문제는 BFS 알고리즘을 통해 해결하였다. 처음에는 최단거리를 찾으면 바로 방향을 바꾸는 최소 갯수를 구할 수 있을 것이라 생각하였고, BFS 알고리즘을 통해 최단거리를 찾았다. 그러나 최단거리에도 여러 방법이 존재하고, 그때마다 방향을 바꾸는 경우가 여러가지라는

이번 문제는 BFS를 통해 해결하였다. 처음에는 불의 이동을 브루트포스를 통해 구현하고, 상근이의 이동을 BFS로 구현하였다. 그러나 시간초과가 발생하였다. 불의 이동을 위해 불의 좌표를 모두 찾아야 하는 것에서 문제가 된 것으로 판단되었다. 그래서 불의 초기 좌표를

프록시란 대신한다는 의미를 가지고 있다. 네트워크 상에서 두 컴퓨터 간의 통신이 발생할 때에 서로에게 직접 요청하는 것지 않고 중간에서 대리로 통신 역할을 하게 된다. 이렇게 중간에서 역할을 하는 서버를 프록시 서버라고 하고, 이러한구조를 프록시라고 한다. 중간 서버라

이번 문제는 BFS를 통해 현재 위치와 연결된 위치에 자신과 같은 문자가 있는지를 찾고, 같은 문자가 4개 이상이 될 경우에만 방문처리 하도록 하였고, 4개보다 적을 때에는 다시 방문처리를 취소해주었다. 이렇게 해서 방문처리 리스트에 True로 표기되는 위치는 이번 차

이번 문제는 각 숫자의 위치를 deque로 저장한 리스트로 관리하고, BFS를 통해 주변을 탐색하며 0인 경우에 자신으로 숫자를 바꿔주는 방식을 사용하였다. 이때 각 숫자의 모든 위치를 계속해서 deque에 담으면 탐색의 크기가 커지기 때문에 새로 값을 입력한 값들만

이번 문제는 백트레킹을 통해 해결하였다. 처음에는 s에 두가지 연산을 계속해서 적용해보는 백트레킹을 구현하였다. 값은 정확하게 도출되었지만 시간초과가 발생하였다. 그래서 이번에는 t에 두가지 연산의 반대 연산을 계속해서 적용하는 백트레킹을 구현하였다. 이 경우에는 t의

이번 문제는 전에 풀었던 문제와 매우 유사하였다. 물의 좌표를 큐에 담고, 4방향으로 물을 퍼트리며 새로운 좌표를 새로운 큐에 넣은 후, 새로운 좌표들이 담긴 큐를 물의 좌표 큐로 복사시킨다. 이렇게 하면 불필요한 물의 좌표 탐색을 줄일 수 있다. 그리고 고슴도치의 이

이번 문제는 BFS와 DP를 함께 사용하여 해결하였다. BFS로 현재 칸에서 점프할 수 있는 칸에 대한 정보를 담는다. 이때 dp리스트에 들어있는 값을 비교하여 현재 카운팅변수+1보다 다음 칸 dp값이 더 클 경우에만 다음칸에 대한 정보를 담게 된다. 이 과정에서 dp

이번 문제는 BFS를 이용하여 해결하였다. 처음에는 1과 2를 4 방향으로 퍼트리며 임시 큐에 퍼진 위치를 저장하고, 그 위치를 초기의 1과 2의 위치를 저장한 큐에 다시 넣는 방식을 사용했다. 2를 퍼트릴 때 퍼트리려는 좌표가 1의 위치를 저장한 좌표에 존재할 경우

이번 문제는 그리디 알고리즘을 이용하여 해결하였다. 풍선의 위치에 대한 리스트를 순회하며 현재 풍선이 0보다 클 경우에만 화살을 1개 증가시키고, 화살의 현재 위치를 나타내는 변수 cur을 현재 풍선의 높이-1로 선언해준다. 그리고 현재 풍선이 터졌음을 나타내기 위해

이번 문제는 BFS를 통해 해결하였다. 몇달전에 C++로 풀어본 문제였는데, 파이썬으로 다시 한번 풀어보았다. 이 문제의 경우 익은 토마토에 대해서 모든 탐색을 진행하면 시간초과가 발생한다. 그렇기 때문에 새롭게 익은 토마토들로 큐를 갱신해가며 BFS탐색을 진행해야 한

이번 문제는 모든 L 좌표에서의 BFS의 결과값의 최댓값을 구하는 방식으로 해결하였다. 처음에는 이 방식이 시간 초과가 발생할 것이라 우려하여 생각하지 않았지만, 세로 가로의 최댓값이 50이었기 때문에 시간초과가 발생하지 않는 다는 것을 알게 되었고, 이 방식으로 쉽게

이번 문제는 BFS를 이용하여 해결하였다. 세 그룹의 총 합을 미리 구한 후에, 큐에는 두 그룹만 넣고, 이 두 그룹과 총 합을 통해 나머지 하나의 그룹까지 이용할 수 있도록 한다. 세 그룹들을 모든 방법으로 비교하며 주어진 연산을 적용시킨다. 그리고 세 그룹들의 값을

이번 문제는 그리디 알고리즘을 통해 해결하였다. 우선 택배 정보를 정렬해야 했는데, 처음에는 시작점과 끝점을 기준으로 오름차순 정렬하였다. 그러나 이렇게 정렬할 경우, 그 사이에 시작점과 끝점이 존재하는 택배들을 놓치게 되므로, 정렬을 끝점 기준으로만 오름차순 정렬하였

이번 문제는 삼성 기출 문제로, BFS를 통해 상어의 이동을 구현하고, 냄새를 저장하는 리스트를 따로 관리하여 해결하였다. 데이터 저장 방식을 확립하는 것이 헷갈리지 않고 해결할 수 있는 방법이라고 생각했고, 이렇게 복잡한 문제는 모듈화하는 것이 풀이에 유리하므로, 각

이번 문제는 플로이드-와샬 알고리즘을 통해 모든 정점에서 모든 정점으로의 최단 거리를 구하고, 이를 이용하여 사이클의 유무를 확인하는 방식으로 해결하였다.

이번 문제는 BFS를 통해 해결하였다. 처음에는 큐에 방문한 위치를 저장하는 리스트를 함께 넣어, 다음 이동할 위치가 방문한 위치 리스트에 들어있지 않을 경우에만 이동하도록 작성하였다. 그러나 이 과정에서 시간 초과가 발생하였고, visited리스트를 사용하기로 하였다

이번 문제는 삼성 기출 문제로, 시뮬레이션을 구현해야 했다. 시뮬레이션을 쉽게 구현하기 위해 모듈화를 적용하며 풀이했다. 처음에 풀이를 했을 때에는 테스트 케이스의 값들은 잘 나왔지만, 시간초과가 발생하였다. 그래서 변수들의 범위를 확인해보았고, s의 범위가 1000이

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 점화식을 구하기 위해 각 n과 k에 대한 결과들을 정리해보았다. 그 결과 다음과 같은 점화식이 도출되었다.이 점화식을 통해 문제를 금방 해결할 수 있었다.업로드중..

이번 문제는 우선순위 큐를 이용하여 해결하였다. 그리디한 방식으로 접근해보면, 우선 먼저 사용하는 순서대로 정렬된 상태에서 비어있는 pc를 이용하면 된다. 그래서 pc와 사용자 수에 해당하는 리스트 두개를 n만큼의 길이의 0으로 된 리스트로 선언하고, pc리스트에는 사

이번 문제는 시뮬레이션 문제로, 주어진 이동 방향 순서대로 종수를 이동시키고, 미친 아두이노의 움직이는 방향을 종수와의 거리가 가장 가까운 좌표로 이동시키며 결과를 확인하는 문제였다. 시뮬레이션 문제였기에 종수의 움직임과 미친 아두이노의 움직임을 함수로 나눠 구현하였다

이번 문제는 단순하게 구현으로 해결할 수 있는 문제였다. 처음에는 접근 방법이 생각나지 않아 시간을 보냈다. 그러던 중, 현재 위치를 기준으로 좌우의 최댓값에 대하여 값을 더하면 구할 수 있을 것이라 생각하였고, 이러한 방식으로 접근하여 해결하였다.

이번 문제는 주어진 명령 순서대로 각 로봇들을 움직이도록 하는 문제였다. 명령들을 모두 처리하는 동안 범위를 벗어나거나 로봇들 간의 위치가 겹치지 않을 경우에는 OK를 출력하고, 그렇지 않다면 해당하는 문장을 출력해야 한다. 이를 위해 함수로 범위를 벗어나는 경우와 부

이번 문제는 이분탐색을 이용하여 해결하였다. 접근 방식은 다음과 같다.이분탐색에 사용할 left, right를 0과 2e17로 지정한다.mid값을 구하고, mid값을 최대hp로 하는 함수를 호출한다.함수의 반환값이 0 이하일 경우에는 최대hp가 부족한 경우이므로, le

이번 문제는 우선순위큐를 이용하여 해결하였다. 과제들을 오름차순으로 정렬시키고, 날짜 마지막 날부터 감소시키는 순으로 순회하며 과제들을 할 수 있는 날이라면 available에 넣어주고, available을 pop하여 결과값에 더해주도록 하였다. 이때 available

이번 문제는 BFS를 통해 해결하였다. 4개의 계산을 한번씩 적용하여 방문처리가 되어 있지 않은 수일 경우에 큐에 넣어 탐색을 적용하였다. 어려운문제가 아니었는데 시도를 조금 많이 한 것 같다 ..

이번 문제는 백트레킹을 통해 해결하였다. 우선 사다리가 겹치거나 만나면 안되기 때문에 이를 체크할 리스트 ladders를 2차원 리스트로 선언하였다. 그리고 입력받은 사다리에 해당하는 좌표 laddersa를 1로 갱신해주었다. 여기서 주의할 점은 a, b에서 무조건 자

블라인드 공채를 통과한 신입 사원 라이언은 신규 게임 개발 업무를 맡게 되었다. 이번에 출시할 게임 제목은 "프렌즈4블록".같은 모양의 카카오프렌즈 블록이 2×2 형태로 4개가 붙어있을 경우 사라지면서 점수를 얻는 게임이다.만약 판이 위와 같이 주어질 경우, 라이언이

자연수 n 개로 이루어진 중복 집합(multi set, 편의상 이후에는 "집합"으로 통칭) 중에 다음 두 조건을 만족하는 집합을 최고의 집합이라고 합니다.각 원소의 합이 S가 되는 수의 집합위 조건을 만족하면서 각 원소의 곱 이 최대가 되는 집합예를 들어서 자연수 2개

정수 n이 매개변수로 주어집니다. 다음 그림과 같이 밑변의 길이와 높이가 n인 삼각형에서 맨 위 꼭짓점부터 반시계 방향으로 달팽이 채우기를 진행한 후, 첫 행부터 마지막 행까지 모두 순서대로 합친 새로운 배열을 return 하도록 solution 함수를 완성해주세요.n

본 문제는 정확성과 효율성 테스트 각각 점수가 있는 문제입니다.카카오는 하반기 경력 개발자 공개채용을 진행 중에 있으며 현재 지원서 접수와 코딩테스트가 종료되었습니다. 이번 채용에서 지원자는 지원서 작성 시 아래와 같이 4가지 항목을 반드시 선택하도록 하였습니다.코딩테

이번 문제는 문자열 슬라이싱과 정렬을 통해 해결하였다. 우선 전화번호들을 입력 받을 때, 전화번호들을 전화번호의 오름차순으로, 길이의 오름차순으로 정렬하였다. 이렇게 정렬을 한 이유는 2중 for문으로 전화번호들을 비교하는 과정에서 현재 전화번호의 앞부분이 표준이 된

이번 문제는 투포인터를 활용하여 해결하였다. 우선 입력받은 리스트를 오름차순으로 정렬하고, for문을 통해 arr을 하나씩 순회하며 현재 arr을 제외한 임시 리스트를 만들고, 이 안에서 가장 왼쪽, 오른쪽 포인터를 만들고, while문을 돌며 두 포인터가 가리키는 값

이번 문제는 다리를 큐를 이용하여 해결하였다. 다리를 큐로 구현하고, 0을 다리의 길이만큼 큐에 채운다. 그리고 while문을 돌며 큐의 맨 앞을 꺼내고, 이 값이 0이 아닐 경우 도착 리스트에 값을 넣어준다. 그리고 만약 현재 인덱스가 n보다 크거나 같거나, 다리 위

이번 문제는 단순하게 while문으로 이동하는 방법과 bfs를 이용하는 방법 두가지로 풀어보았다. 출구를 찾는 함수, 거울을 만났을 때 방향을 바꾸는 함수를 구현하였고, 이를 이용하여 이동하는 함수를 구현하였다.while문을 이용bfs 이용업로드중..

이번 문제는 처음에 육지에 해당하는 좌표를 모두 리스트로 저장하고, 육지 좌표 리스트를 순회하며 주변 좌표에 육지가 1개 이하일 경우에 해당 육지를 지우도록 하였다. 이때 한번에 지워지는 것이기 때문에 임시 리스트를 선언하여 변경 사항을 임시 리스트에 적용하였다. 출력

이번 문제는 간단한 시뮬레이션 문제였다. 매번 격자를 순회하며 폭탄의 위치를 리스트에 담는 함수, 폭발 함수, 폭탄을 만드는 함수를 구현하여 이를 해결하였다. 처음 1초는 가만히 있는다고 했기 때문에 n을 1 감소시켰고, n이 존재하는 동안 반복하는 while문 안에서

이번 문제는 단어가 원래 자리로 돌아오는 주기를 찾아 반복 횟수를 줄이는 방식으로 해결하였다. 처음에는 입력의 범위를 확인하지 않고, 단순하게 for문을 돌며 주어진 연산의 반대 연산을 실행하도록 구현하였다. 정답은 잘 나왔지만, 시간초과가 났다. 입력의 범위를 확인한

이번 문제는 방문 처리를 진행하며 주어진 순서대로 계속해서 로봇을 움직이도록 하는 문제였다. 처음에는 문제를 제대로 읽지 않아, 주어진 방향 순서로만 이동하고 프로그램을 종료하도록 작성하여 오답 처리를 받았다. 문제를 다시 읽어보니 더 이상 움직일 수 없을 때까지 반복

이번 문제는 deque의 rotate함수를 활용하여 해결하였다. 회전시킬 톱니바퀴를 기준으로 왼쪽에 해당하는 톱니바퀴들을 순회하며 맞닿는 부분의 값이 다를 경우에는 l_chain리스트에 인덱스를 담고, 아닐 경우 순회를 종료하였다. 또한 오른쪽에 해당하는 톱니바퀴들을

이번 문제는 주어진 통로와 벽에 대한 길이 2짜리 선분을 안겹치게 가장 많이 찾아내는 문제였다. 처음에는 백트레킹으로 구현하였고, 주어진 테스트 케이스에 대하여 답이 도출되었지만, 재귀가 터지는 에러가 발생하였다. 이를 보고 다른 방법으로 풀어봐야겠다고 생각하였다. 다

이번 문제는 주어진 최대 높이 256까지 임의로 높이를 지정해가며 각각의 칸에 추가해야 할 블록의 수와 지워야 할 블록의 수를 변수로 저장하고, 인벤토리 값을 갱신한 후, 추가하고 지우는 연산이 가능할 경우에 해당 시간과 높이를 구하도록 하였다. 이때 시간이 최소, 높

이번 문제는 두개의 스택을 사용하여 해결하였다. 처음에는 단순하게 해당 명령이 입력되면 커서 변수와 문자열을 편집해가는 방식으로 구현하였다. 정답은 잘 도출되었지만, 시간초과가 발생하였다. 다른 방식을 생각해보았고, 다음과 같은 방식을 생각하였다.초기 문자열 s를 스택

이번 문제는 에라토스테네스의 체를 통해 주어진 n까지의 소수들을 리스트로 정리하고, 리스트를 순회하며 연속합이 존재하는 경우 결과 변수를 증가시키는 방식으로 코드를 구현하여 해결하였다.

이번 문제는 단순하게 얼음이 녹는 과정과 백조끼리 만날 수 있는지의 여부를 따로따로 구현하면 시간초과가 발생한다.백조끼리 만날 수 있는지 확인할 때에 백조가 얼음을 만나면 해당 좌표를 큐에 다음 주기의 백조의 위치로 저장해주어야 한다. 얼음이 녹는 과정의 경우에는 물의

이번 문제는 이분탐색을 통해 해결하였다. l, r 포인터를 양쪽 끝에 두고 시작하였는데, l의 증가와 r의 감소 타이밍을 생각하는 과정에서 시간이 조금 오래 걸렸다. 그러다가 두 포인터가 가리키는 값의 합이 양수일 경우에는 r을 감소시켜 합을 낮추는 방향으로, 두 포인

이번 문제는 DFS를 통해 학생들 간의 사이클이 존재하는지의 여부를 확인하는 문제이다. 처음에는 dfs함수의 인자로 현재 팀에 속하기로 한 학생들의 번호를 담는 리스트를 넣고, 이를 이용하여 해당 리스트의 첫번째 인자와 현재 학생의 번호가 같을 경우 사이클이므로 팀 리

이번 문제는 플로이드-와샬 알고리즘을 통해 쉽게 해결할 수 있었다. 우선 n+1크기의 2차원 리스트를 선언해주고, 친구 관계를 입력받을 때마다 양방향으로 2차원 리스트를 1로 갱신해준다. 그리고 플로이드-와샬 알고리즘을 통해 건너서 친구가 있는 경우를 찾아 값을 채워준

이번 문제는 최소스패닝트리 문제였다. 처음 접해보는 알고리즘이었기 때문에 구현 방법을 찾아보고 구현하였다. 처음 접근 할 때에는 찾아보지 않고, permutations를 구하여 그 순서대로 방문하는 가중치 중 최솟값을 구하도록 구현하였다. 답은 잘 도출되었지만, 메모리

이번 문제는 간단한 백트레킹을 통해 구현하였다. 처음으로 백준에 질문글까지 작성하였는데... 다음 가중치를 계산하는 부분에 실수가 있어서 해결하지 못한 것이었다. 해당 부분을 수정하고 정답처리를 받을 수 있었다.백트레킹 내부에서는 매번 받은 총 피해량을 확인하며 k 이

이번 문제는 DP를 이용하여 해결하였다. 증가하는 부분 수열의 길이는 구하기 쉬웠지만, 수열을 구하는 과정에서 시간이 걸렸다. 우선 dp리스트를 2중 for문을 통해 순회하며 자신보다 앞에 있는 수 중 자신이 더 클 경우 dp를 갱신하였다. 이렇게 되면 증가하는 수열에

이번 문제는 백트레킹을 통해 해결하였다. 우선 0으로 채워져있는 위치의 인덱스를 리스트에 담고, 이 리스트를 백트레킹을 통해 순회하도록 하였다. 이 과정에서 행과 열을 모두 확인하고, 현재 위치가 속한 작은 사각형을 확인하여 들어가고자 하는 수와 같은 값이 존재하지 않

이번 문제는 heapq와 그리디 알고리즘을 활용하여 해결하였다. 강의의 번호와 시작 시간, 종료 시간을 입력 받으면, heapq에 (시작 시간, 종료시간, 강의 번호) 형식으로 삽입하여 강의 시작 순으로 정렬되도록 한다. 그리고 heapq를 순회한다. 강의실 리스트에는

이번 문제는 누적합을 활용하여 해결하였다. 처음에는 단순하게 공 크기의 오름차순으로 정렬을 하였고, 2중 for문을 이용하여 매번 값을 계산하도록 하였다. 이럴 때 최악의 경우 200,000 x 200,000의 연산이 필요하기 때문에 시간 초과가 발생할 것을 알고는 있

이번 문제는 다익스트라 알고리즘을 통해 해결하였다. 각 칸마다 가중치가 같았다면 BFS를 활용하여 구현했겠지만, 각 칸마다 가중치가 다르기 때문에 다익스트라를 활용하였다. 우선 테라와 출구의 좌표를 구하고, 두 위치의 값을 0으로 바꿔주었다(가중치가 0이기 때문에).

이번 문제는 삼성 기출 문제로, 시뮬레이션과 구현에 포함된 문제이다. 처음에는 상어가 움직일 수 있는 모든 방향을 저장하고, 이 방향 리스트를 가지고 상어를 이동시켰다. 물고기는 리스트를 만들어 좌표에 있는 물고기의 이동 방향을 담아두었다. 그리고 이 리스트를 순회하며

이번 문제는 그리디 알고리즘과 heapq를 이용하여 해결하였다. 그리디 문제는 생각을 다르게 해야되는 경우가 많아 많은 연습이 필요할 것 같다 ... 처음에는 단순하게 입력받은 데이터를 p의 내림차순, d의 오름차순으로 정렬 순위를 정하여 정렬한 후에, 현재 날짜를 세

이번 문제는 그리디 알고리즘과 최소힙을 이용하여 해결하였다. 전에 풀었던 강의실 문제와 거의 유사한 문제였다. 회의 정보를 입력받아 최소힙에 담고, 이를 하나씩 꺼내어 회의실 최소힙의 첫번째 원소와 비교하여 회의 시작 시간이 최소힙의 원소보다 크거나 같을 경우 회의실

이번 문제는 그리디 알고리즘을 통해 쉽게 해결하였다. 동전을 뒤집을 경우, 현재 좌표 이하의 모든 좌표가 함께 뒤집히기 때문에 뒤집는 횟수를 최소로 하기 위해서는 같은 동전의 뒤집히는 횟수가 최소가 되어야 한다. 그렇기 때문에 가장 큰 좌표부터 확인해가며 현재 좌표가

이번 문제는 그리디 알고리즘을 통해 해결하였다. 우선 웅덩이의 정보를 오름차순으로 정렬해야 한다. 그 이후, 현재 위치를 나타내는 변수 cur을 웅덩이의 첫번째 리스트의 첫번째 인자로 지정해준다. 웅덩이 리스트를 순회하며 만약 cur이 현재 웅덩이의 끝보다 클 경우,

이번 문제는 그리디 알고리즘과 투포인터 알고리즘을 활용하여 해결하였다. 값의 정렬이 필요하다고 바로 알 수 있었고, 정렬 방법에 대해 고민을 해보았다. 고민 끝에 남자와 여자 모두 오름차순으로 정렬을 하고, 포인터를 두개 사용하여 값을 비교하기로 하였다. 남자의 포인터

이번 문제는 그리디와 DP를 이용하여 해결하였다. 처음에는 주어진 수에 대하여 가능한 동전을 모두 리스트에 담고, 이 리스트를 내림차순으로 순회하며 주어진 금액에 그때그때 가능한 많은 동전을 사용하여 금액이 0이 될때가지 반복하도록 하였다. 테스트케이스는 잘 맞았지만,

이번 문제는 삼성 기출 문제로, BFS와 시뮬레이션 문제이다. 문제에 대한 이해를 하는데에 시간이 꽤 걸렸던 것 같다. 문제를 해석해보면 주사위는 다음 주어진 조건대로 한칸씩 움직이고, 그 칸에 도착했을 때, 동서남북 4 방향을 확인해가며 현재 칸과 붙어있는 같은 값을

이번 문제는 삼성 기출 문제로, 백트레킹을 통해 해결하였다. 처음 코드는 30분만에 작성하였고, 질문하기 란에 있는 테스트케이스들도 모두 맞았다. 제출한 결과, 85%에서 오답처리되었고, 이 부분에 대해 아무리 코드를 뜯어보고 찾아보았지만 찾지 못하였다. 로직은 주어진

이번 문제는 그리디 알고리즘을 통해 해결하였다. 주어진 데이터를 데드라인을 기준으로 오름차순 정렬한 후에, 이 리스트를 순회하며 최소힙에 (컵라면 수, 데드라인) 형태로 삽입해준다. 삽입한 후에 최소힙의 길이와 현재 데이터의 데드라인과 비교하여, 최소힙의 길이가 더 길

이번 문제는 그리디 알고리즘을 통해 해결하였다. 우선 정렬하는 방법이 가장 중요했는데, 이 부분에서 시행 착오를 겪었다. 처음에는 Da의 오름차순, Db의 내림차순을 적용하여 정렬하였다. 그러나 이 방법은 Db가 내림차순으로 정렬되지 않기 때문에 잘못된 방식이었다.이에

이번 문제는 삼성 기출 문제로 구현과 시뮬레이션에 속하는 문제이다. 격자에 초기 데이터를 입력받고, 상어의 위치를 기준으로 소용돌이치며 나가는 인덱스의 순서에 대한 리스트를 get_nums 함수를 통해 먼저 만들었다. 그리고 상어가 파괴시키는 함수 destroy, 구슬

이번 문제는 그리디 알고리즘을 통해 해결하였다. 우선 초콜릿의 크기를 구하기 위해 2의 제곱 수를 한번씩 비교하며 이전 수보다 크고 현재 수와 같거나 작은 경우를 찾는다. 이를 통해 초콜릿의 크기를 구했다면, 초콜릿의 크기를 2씩 나누며 k에 나눴을 때 나눠 떨어지는

이번 문제는 그리디 알고리즘을 활용하여 해결하였다. 가장 중요한 포인트는 매번 가장 작은 크기의 파일 두개를 꺼내어 합쳐야만 비용이 최소가 된다는 것이다. 이를 보고 최소힙을 활용하기로 하였다. 파일들을 최소힙에 넣고, 최소힙의 크기가 1보다 클 동안 반복하며 heap

공유자원에 여러 개의 스레드가 접근하는 것을 막는 것임계영역을 가진 스레드의 실행 시간을 서로 겹치지 않도록 하여 각각 단독으로 실행하도록 하는 기법다중 프로세서들의 공유 리소스에 대한 접근을 조율하기 위해 synchronized 혹은 lock을 사용하기 때문에, Mu

이번 문제는 그리디 알고리즘을 통해 쉽게 해결하였다. 서류들의 정렬이 중요했다. 처음에는 a, b-a의 오름차순으로 정렬하고, 책 리스트를 만들어 선택될 때 체크하는 과정을 반복하였다. 예제는 잘 맞았지만, 50%에서 오답처리를 받았다. 그래서 50%에 대한 테스트 케

이번 문제는 그리디 알고리즘을 통해 해결하였다. 주어진 문제와 반대로 모든 배열의 값을 0으로 만드는 방향으로 접근하였다. 우선 2로 나누는 연산이 0으로 가까워지기 훨씬 효율적인 연산이므로, 배열의 값 중 하나라도 짝수가 아닐 때까지 전체에 나누는 연산을 적용하였다.

이번 문제는 그리디 알고리즘을 통해 해결하였다. 처음에는 단순하게 정렬했을 때 1부터 1씩 증가하는 리스트가 만들어지면 된다고 생각하였다. 그러나 1 1 2 2 4와 같은 리스트가 입력된다면 다른 케이스가 발생한다. 다른 방법을 생각하던 중, 매 차례마다 사라져야 하는

이번 문제는 그리디 알고리즘을 통해 해결하였다. 우선 마을 리스트를 위치의 오름차순으로 정렬하고, 모든 마을의 인구의 총 합을 구한다. 그리고 이의 절반 값 mid를 구한다. 마을 리스트를 순회하며 인구의 누적합을 구하며, 누적합이 mid보다 크거나 같다면, 이 마을에

이번 문제는 그리디 알고리즘을 활용하여 해결하였다. 우선 학교를 기준으로 왼쪽과 오른쪽에 위치한 아파트를 서로 다른 최소힙에 넣어 관리하였다. 이는 학교로부터의 거리가 먼 순서대로 추출하기 위함이기 때문에 오른쪽에 위치한 아파트들의 위치정보는 음수로 넣어 최대힙으로 이

이번 문제는 그리디 알고리즘을 통해 해결하였다. 처음에는 예제에서 보여주는 출력값을 구하는 방법을 도저히 생각할 수가 없었다. 그래서 다른 사람의 풀이를 찾아보았고, 오차가 10-6 이하면 인정한다는 말을 이용하면 간단하게 볼 수 있다는 사실을 알게 되었다. 편의시설과

이번 문제는 유니온 파인드를 이용하여 해결하였다. 처음에는 gate리스트를 만들고, 비행기 순회하며 gate를 뒤부터 확인하며 도킹할 수 있는 gate에 도킹하도록 하는 방식으로 풀이하였다. 답은 잘 도출되었지만, G와 P의 범위가 10^5이기 때문에 시간초과가 날 수

이번 문제는 함수로 따로 모듈화하여 해결하였다. 궁수가 최대한 많은 적을 죽이기 위해서는 성과 같은 y축에 있어야 한다(적을 최대한 오래 봐야 하기 때문). get_arrows함수는 3명의 궁수의 x축의 모든 경우를 구해야하기 때문에 이를 백트레킹을 통해 구현하였다.

이번 문제는 백트레킹을 통해 바이러스가 존재하는 모든 경우를 구하고, 각 경우마다 BFS를 통해 바이러스가 퍼지는 시간을 갱신하는 방식으로 구현하였다. 각 칸의 바이러스가 퍼지는 시간이 짧은 것이 우선순위가 높으므로 항상 더 작은 값으로 갱신해주었다. 다익스트라 방식과

이번 문제는 BFS와 permutations를 이용하여 해결하였다. 처음에는 permutations를 만들고, 각각의 점에서 점까지의 BFS를 계속해서 실행하도록 하였다. 답은 잘 도출되었지만, 당연히도 시간초과가 발생하였다. 이를 해결하기 위해 로봇에서부터 각 먼지까

이번 문제는 DFS의 백트레킹을 활용하여 연결된 친구들을 모두 탐색하며, 그 연결의 길이가 5일 경우에 1을 출력하도록 하였다. 이렇게 접근하기 위해서 데이터를 인접 리스트로 저장하였고, dfs함수 내에서는 각각의 인접 리스트를 순회하며 방문처리되지 않은 친구에게 방문

이번 문제는 유니온-파인드 알고리즘을 통해 해결하였다. 문제를 보고 사이클 그룹의 갯수를 구해야 한다는 생각을 하고 코드를 작성하였지만, 다른 테스트 케이스들에서 제대로된 그룹의 갯수를 구하지 못하였다. 그래서 다른 사람들의 코드를 참고하게 되었고, 대부분의 사람들이

이번 문제는 BFS를 통해 현재 구간에서의 소들의 수를 구하고, 전체에서 이 소들의 수를 빼는 방식으로 구할 수 있었다. 로직도 바로 생각할 수 있었고, 코드도 바로 짤 수 있었지만, 오답이 자꾸 출력되어 시간을 조금 오래 끌었고, 코드를 처음부터 다시 작성하여 이 문

이번 문제는 삼성 기출 문제로, 문제를 꼼꼼히 읽고 구현하였다. 각각의 말들을 (좌표, 번호, 방향)의 형태로 p라는 리스트에 담아놓았고, location이라는 3차원 리스트에 해당 말의 좌표에 해당하는 칸에 말의 번호를 담았다. 이는 말이 여러 개 있을 때, 쌓여있는

이번 문제는 백트레킹을 통해 모든 경우를 확인하여 해결하였다. 이 문제를 해결하기 위해 다음과 같은 방식으로 접근하였다.매직스타의 위, 왼쪽부터 아래, 오른쪽으로 이동하며 인덱스를 부여했다. (0 ~ 11)일직선으로 위치하는 인덱스들에 대한 조건 판별을 하는 함수를 작

이번 문제는 그리디 알고리즘을 통해 해결하였다. 가장 빨리 끝내는 시간과 가능 여부를 물어봤다면 종료 시간에 대한 오름차순으로 정렬을 했을 것이다. 그러나 여유롭게 시작하는 시간을 물어봤기 때문에 works 리스트를 종료 시간에 대한 내림차순으로 정렬을 하였다. 그리고

이번 문제는 그리디 알고리즘을 통해 해결하였다. 이전에 푼 문제와 같은 문제 같았지만, 다시 풀어보는 마음으로 다시 풀었다. 입력받은 데이터를 위치의 오름차순으로 정렬하고, 전체 사람들의 합을 구한 후, 이의 중간값을 구한다. 그리고 데이터를 순회하며 사람들의 합을 누

이번 문제는 최소힙을 이용한 그리디 문제였다. 이전에 풀어봤던 문제들과 같은 유형의 문제였기 때문에 접근법은 바로 생각해낼 수 있었다. 슬라임들의 크기를 입력받고, 이 값들을 최소힙에 담은 후, 최소힙의 크기가 1이 될때까지 최소힙에서 2개의 값을 꺼내서 곱하고, 이

이번 문제는 종속관계를 구현하여 해결하였다. a건물을 짓기 위해 b, c건물이 지어진 상태여야 한다면 building\[a] = \[b, c]의 형태로 만들어 건물을 짓기 이전에 현재 건물들의 현황을 순회하여 이전에 지어야 하는 모든 건물이 조재할 경우에만 지을 수 있

이번 문제는 DFS를 통해 해결하였다. 처음에는 각 직원의 직속 부하만을 인접 리스트 형태로 저장하고, 칭찬 리스트를 순회하며 각 직원의 직속 부하에게 칭찬 점수를 전달하는 재귀함수를 작성하였다. 그러나 시간 초과가 발생하였고, 재귀 함수를 한번만 호출할 수 있는 방법

이번 문제는 BFS를 통해 해결하였다. BFS를 통해 좌표를 탐색하며 방문처리를 한다. 방문처리를 할 때에는 그때까지 걸린 시간을 방문처리 값으로 넣고, 다음 좌표의 방문 여부를 판단할 때, 다음 좌표의 방문처리값과 현재 시간+1을 비교하여 방문처리값이 더 클 때에만

이번 문제는 BFS를 통해 해결하였다. 일반적인 문제와 다른점은 3차원으로 탐색을 해야 한다는 점이었다. 이를 위해 6가지 방향에 대한 리스트를 3개 만들어 모든 방향을 탐색할 수 있도록 하였고, BFS방식으로 모든 좌표를 탐색하며 답을 구하였다.업로드중..

이번 문제는 백트레킹과 BFS를 통해 해결하였다. 우선 백트레킹을 통해 흰돌을 놓을 수 있는 모든 경우를 만들고, 이를 이용하여 돌들의 상황을 나타내는 리스트의 임시 리스트를 만들어 모든 경우를 각각 반영하여 BFS를 통해 탐색하도록 하였다. 탐색을 할 때에는 빈칸을

이번 문제는 다익스트라 알고리즘을 통해 해결하였다. 우선 점령된 도시와 거리가 s 이하인 도시를 찾아내는 get_costs()함수를 구현하였다. 모든 도시의 숙박 비용을 p로 두고, 점령된 도시에서 BFS를 통해 옆 도시로 이동하며 거리를 카운트하고, s이내라면 비용을

이번 문제는 BFS와 DP를 통해 해결하였다. 처음 풀이에서는 오로지 BFS만 사용하여 각 격자에 존재하는 모든 구슬에 대하여 BFS탐색을 실시하였다. 당연히 답은 잘 도출되었지만, 70%에서 시간초과가 발생하였다. 이를 줄일 수 있는 방법은 메모라이제이션이라 생각하였

이번 문제는 전형적인 그리디 문제 중 하나로, 과제의 마감일을 기준으로 내림차순 정렬한 후에, 이를 순회하며 현재 날짜를 감소시키는 방식으로 해결하였다. 날짜를 감소시킬 때, 만약 현재 날짜보다 과제의 마감일이 더 작을 경우에는 현재 날짜를 과제의 마감일로 갱신하도록

이번 문제는 다익스트라 알고리즘을 통해 해결하였다. 가중치에 대한 정의에 고민을 조금 하였고, 결과적으로 0이 아닌 값을 만날 경우에 다음 가중치를 1 증가시키는 방식으로 접근하였다. 최소힙을 사용하여 시간을 줄였고, 가중치에 해당하는 dists는 초기값을 1e9로 하

이번 문제는 DFS를 통해 사이클의 갯수를 파악하여 해결하는 문제이다. 사이클 당 하나의 선물만 놓아도 구사과는 무조건 그 선물을 받을 수 있기 때문이다. 처음에는 BFS를 통해 사이클을 찾도록 하였다. 그러나 이 방법은 시간초과가 발생하였다. 이에 대한 해결책을 찾아

이번 문제는 BFS를 통해 해결하였다. 벽의 좌표를 리스트로 입력받고, BFS를 통해 움직이는 것을 구현하였다. 이때 벽이 움직이는 시점을 깔끔하게 하기 위해 q 안에 있는 모든 원소들을 순회하며 q를 popleft() 시켰다. 여기서 꺼낸 값들을 주어진 9가지 방향으

이번 문제는 슬라이싱과 투포인터를 통해 해결하였다. 문자열을 입력받으면, 슬라이싱을 통해 거꾸로 돌린 값과 비교한다. 같다면 바로 0을 출력하고, 같지 않다면, r, l 포인터를 각각 0과 문자열의길이-1로 선언한 후, 문자열을 순회한다. 두 포인터가 가리키는 문자가

이번 문제는 BFS를 통해 해결하였다. 현재 좌표와 연결된 좌표 중 같은 값들을 가지는 좌표들을 찾아 이 좌표들의 개수가 k 이상일 경우 이 값들을 없애고, 밑으로 쌓는 문제로, BFS를 통해 각 칸들의 방문처리 여부를 확인하며 탐색하여 해결하였다.업로드중..

이번 문제는 다이나믹프로그래밍을 통해 해결하였다. 전형적인 0-1 배낭 문제로, 최소한의 비용으로 많은 메모리를 비워내는 것이 목표이다. dp리스트는 2차원으로 선언하였고, dpi에서 i는 현재 앱을 의미하고, j는 현재의 비용을 의미한다. dp안에는 해당 비용에서 비

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 0-1 배낭문제를 완전히 익히기 위해 연속해서 배낭 문제를 풀어보았다.

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. dp리스트를 k+1의 크기로 선언하고, 1e9로 채운다. 그리고 동전과 dp를 순회하며 현재 가격에 해당하는 동전의 갯수와 현재가격-동전의가치에서의 동전의 갯수+1를 비교하여 더 작은 값을 취하도록 하였다. 점화식은

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. dp리스트를 a, b 두 수열의 길이로 된 2차원 리스트로 선언하고, 2중 for문을 통해 a, b를 순회하며 만약 ai와 bj가 같을 경우에는 dpi를 dpi-1+ai로 갱신해주고, 같지 않다면 dpi를 dpi-1와

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 스티커를 붙일 수 있는 여부의 패턴을 보면 현재 스티커와 대각선의 위치, 그리고 대각선의 옆 위치에 있는 스티커를 같이 붙일 수 있다. 이를 이용하여 dp리스트를 2차원 리스트로 선언하고, 윗줄 스티커는 아래쪽 대각선

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 건물의 순서를 저장하기 위해 인접리스트 방식으로 현재 건물을 짓기 위해 지어야 하는 건물의 번호를 building이라는 리스트로 저장하였다. 그리고 각 건물의 짓는 시간을 time이라는 리스트로 따로 저장하였다. bu

이번 문제는 그리디 알고리즘을 통해 해결하였다. 처음에는 주어진 리스트에 있는 1, 2, 3의 각 갯수를 세고, 리스트를 앞에서 뒤로, 뒤에서 앞으로 순회하며 연속으로 있는 수의 갯수가 그 수의 전체 갯수의 절반 이상일 경우에 리스트의 다른 곳에서 해당 수를 찾아오는

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. DFS를 통해 탐색해가며 dp리스트에 메모라이제이션한 값을 이용하였다. 처음에는 dpi에 (i, j)가 최대 몇번째 방문 대나무인지에 대한 값을 저장하도록 하였다. 그러나 이 방법은 시간초과가 발생하였다. 다른 풀이에

이번 문제는 BFS를 통해 해결하였다. 전에 풀어보았던 숨바꼭질과 다른 점이 있다면 동생이 매 시간마다 자리를 옮기는 점이다. 이 때문에 이전처럼 방문처리를 하게 되면 동생을 잡을 수 없는 경우가 발생한다. 그래서 우선 방문처리를 하지 않고, 구현해보았다. 결과는 당연

이번 문제는 시뮬레이션 문제로, 캐릭터의 이동 시 해당 방향으로 2칸을 확인하여 조건에 맞도록 캐릭터와 박스를 움직이는 문제이다. 이 문제에서 주의할 점은 다음과 같았다.처음부터 complete의 상태인 경우가 있으므로 complete의 여부부터 확인한다. comple

이번 문제는 다이나믹 프로그래밍을 통해 해결하였다. 정사각형을 이루기 위해서는 최소한 현재 좌표에서 왼쪽, 왼쪽위대각선, 위쪽이 모두 1이 되어야 한다. 이러한 특징을 이용하여 dp리스트를 구성하였다. 2차원 리스트로 선언하고, 현재 좌표에 대한 dp는 왼쪽, 왼쪽위대

이번 문제는 다이나믹 프로그래밍과 DFP를 이용하여 해결하였다. 미로의 범위 내에서 순환하는 좌표와 순환하지 않고 범위를 벗어나는 좌표를 찾아내는 문제로, dp리스트에 순환 여부를 저장하고, DFS를 통해 순회하며 만약 다음 dp가 순환하거나 순환하지 않는다면 현재 d

이번 문제는 수학적으로 접근하여 각 인덱스에 들어갈 숫자를 그때그때 계산하여 더하는 방식으로 해결하였다. 처음에는 문제에서 제시한 행렬을 만드는 함수를 먼저 호출하고, 만들어진 행렬을 돌며 값을 더하는 방식으로 접근하였지만, 메모리 초과가 발생하였다. 행렬 전체를 만드

이번 문제는 다익스트라 알고리즘과 정렬을 통해 해결하였다. 지헌이와 성하의 위치에서 각각 다익스트라 알고리즘을 통해 모든 점으로의 최단 거리를 구하고, 이를 통해 반환받은 최단거리 리스트 두개를 함께 순회하며 지헌이로부터의 거리, 성하로부터의 거리, 장소 번호를 담아

이번 문제는 BFS를 통해 해결하였다. 이 문제에서의 키포인트는 통나무가 세로로 있을 수도 있고, 가로로 있을 수도 있다는 점과 목적지 또한 세로로, 혹은 가로로 있을 수 있다는 점이었다. 길이가 3으로 고정되어 있었기 때문에 3개의 좌표를 모두 관리할지, 중심 좌표와

이번 문제는 피자의 인덱스와 현재 쌓여있는 인덱스를 관리하며 오븐을 순회하는 방법으로 해결하였다. 우선 오븐 리스트를 순회하며 이전 값과 비교하여 더 작은 값으로 오븐을 갱신해준다. 위에 있는 지름이 더 작으면 밑에 있는 지름이 더 커도 의미가 없기 때문이다. 이 과정

이번 문제는 큐를 이용하여 해결하였다. 손님들의 정보를 큐에 담고, 은행을 연 뒤에 오는 손님들의 리스트를 온 시간의 내림차순으로 정렬하였다. w라는 시간동안 손님 정보 큐를 빼고 다시 넣는 것을 반복하였고, 다른 손님이 들어올 시간과 같다면 손님을 손님 정보 큐에 넣

이번 문제는 BFS를 이용하여 해결하였다. 처음에는 벽을 부수는 모든 경우를 백트레킹을 통해 구하고, 이를 적용하여 각각의 경우마다 탐색을 하도록 하였다. 그러나 이 방법은 시간초과가 발생하였다. 그래서 한번의 BFS를 통해 해결해야겠다고 생각하였고, 벽을 만났을 때,

이번 문제는 BFS를 통해 해결하였다. 자신에게 진 사람을 담는 인접 리스트와 자신에게 이긴 사람을 담는 인접 리스트를 만들고 BFS를 통해 두 인접 리스트를 순회하며 자신에게 진 사람의 수, 이긴 사람의 수를 구하였다. 최선의 등수는 1+자신에게 이긴 사람의 수로 구

이번 문제는 BFS를 통해 해결하였다. 처음에는 한번 방문한 좌표는 다시 방문하지 않아도 될 것이라 생각하여 2차원 리스트로 방문처리를 적용하였다. 그러나 같은 좌표를 여러번 지나며 새로운 좌표에 방문하게 되는 경우가 발생한다는 것을 깨닫게 되었고, 방문처리 리스트를

이번 문제는 BFS를 통해 해결하였다. 처음에는 주어진 모든 입력에 대하여 간선을 인접 리스트로 생성하였다. 그러나 이 방식으로 데이터를 관리할 경우 메모리 초과가 발생하였다. 그래서 질문하기를 참고하였고, 간선을 일일히 생성하지 않고, 역 리스트에는 연결된 튜브 번호

이번 문제는 BFS를 통해 해결하였다. 클립으로 복사하는 연산, 클립을 화면에 추가하는 연산, 화면의 이모티콘 하나를 지우는 연산을 가독성을 위해 함수로 정의하였고, 방문처리는 2차원 리스트를 사용하여 화면의 이모티콘수로 활용하였다. 범위를 벗어나지 않도록 다음 화면과

이번 문제는 BFS를 통해 해결하였다. 처음에는 단순하게 좌표들을 돌며 모래성이 있는 좌표를 큐에 담고, BFS를 통해 큐를 탐색하며 8개의 좌표를 확인하며 모래성이 없는 좌표의 갯수를 세어 모래성의 사라짐 유무를 판단하도록 하였다. 만약 모래성이 사라지지 않는다면 새

업로드중..이번 문제는 BFS를 통해 해결하였다. 곰곰이가 있는 정점을 미리 방문처리 해두고, 방문처리되지 않은 정점을 BFS를 통해 탐색하도록 하였고, 만약 더 이상 갈 곳이 없는, 즉 연결된 정점이 없는 정점까지 도달했다면, 곰곰이가 있는 곳을 지나치지 않고 끝까지

이번 문제는 BFS를 통해 해결하였다. 모든 0을 1로 바꾼 모든 경우에 대하여 BFS 탐색을 진행하였고, 시간초과가 발생하였다. 그래서 다른 방법에 대해 생각해보았고, BFS를 통해 기존의 1의 그룹을 저장하고, 0을 탐색하며 상하좌우에 있는 그룹의 크기의 합 중 가

이번 문제는 BFS를 통해 해결하였다. 처음에는 단순하게 생각하여 (n+1)\*(n+1) 크기의 방문처리 리스트를 이용하여 구현하였다. 답은 잘 도출되었지만 n의 범위가 500,000까지였기 때문에 메모리 초과가 발생하였다. 그래서 이번에는 빈 리스트를 n+1개 가진

이번 문제는 BFS를 통해 해결하였다. 처음에는 모든 좌표를 돌며 grid를 각 그룹들의 번호로 바꿔주고, 딕셔너리를 이용하여 각 그룹의 좌표들을 정리하였다. 그리고 주어지는 commands를 순회하며 W가 들어오면 해당 그룹의 딕셔너리 리스트를 확인하여 결과 리스트에

이번 문제는 BFS를 통해 해결하였다. 이 문제에서 중요한 점은 역과 역 간의 연결을 인접 리스트로 나타내면 시간과 메모리 제한에 걸린다는 것이다. 그래서 각 역을 나타내는 리스트 stations에는 각 역이랑 연결된 노선의 번호를 담아야 하고, 노선 정보를 담은 리스

이번 문제는 BFS를 통해 해결하였다. 서로 싫어하는 정보를 인접 행렬로 관리하였다. BFS를 통해 탐색을 하며 비교하는 둘의 인덱스에 해당하는 인접 행렬 값이 1이고, 아직 방문하지 않은 경우에 방문처리를 해주고, 결과 리스트에 현재의 팀과 다른 팀을 넣어주도록 하였

이번 문제는 BFS와 비트마스킹을 통해 해결하였다. 처음 이 문제에 접근할 때, 열쇠를 주울 때마다 방문처리 리스트를 초기화하면 문제가 풀릴거라는 생각을 가지게 되었고, 큐에 방문처리 리스트를 담는 방법을 택했다. 결과는 당연히 메모리 초과가 발생하였다. 새로운 방문처

이번 문제는 BFS를 통해 해결하였다. 처음에는 큐에 각각의 방문 경로를 담은 리스트를 함께 담아 구현하였는데, 시간초과가 발생하였다. 그래서 방문 경로를 전역 리스트 하나에 담기로 하였다. 조건을 만족하는 다음 좌표에 대한 before_node를 현재 좌표로 저장해주

이번 문제는 백트레킹을 통해 해결하였다. 조금 복잡한 백트레킹이었는데, 우선 함수의 인자로 y, x를 받는다. 이는 좌표를 의미하고, 좌표를 오른쪽으로 이동시키면서 끝에 도달하면 아래로 한칸 내리는 식으로 진행하였다. 현재 좌표 값이 1이라면 1~5에 해당하는 색종이

이번 문제는 백트레킹을 통해 해결하였다. 백트레킹을 통해 모든 경우를 구하고, 매 경우마다 기준치를 넘겼는지 확인한다. 만약 넘겼을 경우 정답 변수와 정답 리스트를 더 작은 것으로 갱신시켜주었다. 업로드중..

이번 문제는 백트래킹을 통해 해결하였다. 친구들의 관계를 인접 리스트 형태로 저장하고, 백트래킹을 통해 탐색하였다. 문제에서 선택된 모든 친구들이 서로서로 친구관계여야 하기 때문에 백트래킹에서 다음 재귀 호출을 위해 선택하려는 친구가 선택된 친구들과 모두 친구 관계인지

이번 문제는 BFS를 통해 해결하였다. 처음에는 모든 경우를 확인한다고 생각하여 백트레킹으로 구현하였다. 시작점을 찾고, 백트레킹을 통해 좌표들을 탐색하며 방문처리를 하고, U에 도달했을 때 현재 우산의 내구도를 d로 갱신해주도록 하였다. 그리고 다음 좌표값이 E일 경

이번 문제는 플로이드-와샬과 백트레킹을 통해 해결하였다. 처음에는 비트마스킹을 활용하여 접근하였다. n이 10까지 가능하므로 2^10인 1024를 비트마스킹 범위로 지정하고, 방문처리를 할 때 visited\[도착 행성]\[출발 행성]으로 지정하였고, 출발 행성을 비트

이번 문제는 백트레킹을 통해 해결하였다. 매번 대각선과 가로 세로를 확인하여 이전 차례의 상대의 글자가 일자로 배열해 있는지 확인한다. 그리고 여기서 나오는 결과를 통해 -1, 0, 1 중 하나를 반환하도록 한다. 수가 클 수록 좋은 경우로 배치하였기 때문에 -1, 0

이번 문제는 BFS를 통해 해결하였다. 두 군데를 방문해야 하기 때문에 기존의 BFS와는 조금 다르게 접근해야 했다. 좌표들로 들어오는 방향을 체크하도록 하기 위해 방문처리 리스트를 3차원 리스트로 선언했다. 이 문제에서의 포인트는 다음과 같았다어떠한 목적지에도 도착하

이번 문제는 구현 문제로, 각 상황에서의 주사위들의 위와 아래를 결정하고 측면들 중 가장 큰 값들의 합을 구하는 방식으로 접근하였다. 1번 주사위의 위쪽면을 결정하고, 그 이후의 주사위들을 이전 주사위의 위쪽면을 보고 주사위들의 아래쪽면을 결정하였다. 아래쪽면을 결정하

이번 문제는 구현 시뮬레이션 문제로, 다음 좌표를 찾고 해당 좌표에서의 탐색을 진행하기 위해 BFS를 활용하였다. 딕셔너리를 활용하여 각 블록에 들어왔을 때의 방향과 그에 해당하는 다음 방향을 매핑시켰고, 주어진 파이프대로 따라가다가 .을 만났을 때 주변 4 방향을 확

이번 문제는 그리디 알고리즘을 통해 해결하였다. 나무들의 총 합이 우선 3의 배수여야만 문제의 조건대로 수행이 가능하다. 나무 전체의 합을 3으로 나눈 만큼 물을 주게 되기 때문에 그 수만큼 2뿌리기를 할 수 있어야 한다. 이는 전체를 3으로 나눈 값보다 각 나무를 2

이번 문제는 BFS를 활용하여 해결하였다. BFS를 통해 그룹을 만들고, BFS를 통해 다른 섬을 찾도록 하였다. 우선 섬들의 그룹을 만들어 순서대로 번호를 부여하였다. 그리고 각 섬에서 출발하여 같은 섬 번호의 좌표와 0을 거쳐 다른 섬 번호의 좌표를 만났을 때의 거

이번 문제는 BFS를 통해 해결하였다. a와 b를 입력받으면, a보다 가벼운 b는 heavya에 담고, b보다 무거운 a는 lightb에 담았다. 그리고 BFS를 통해 heavy와 light를 모두 탐색하여 두 탐색에서 한번도 방문하지 않은 노드가 있다면 그 노드는 현

이번 문제는 플로이드-와샬 알고리즘을 활용하여 해결하였다. 2차원 리스트 after를 선언하고, 인접 행렬 형태로 \[먼저]\[나중]에 해당하는 좌표에만 1로 표시를 해주었다. 그리고 플로이드-와샬을 통해 after\[i]\[j]가 0일 때, after\[i]\[d]와

이번 문제는 플로이드-와샬 알고리즘을 통해 해결하였다. 데이터를 저장하는 방식에서 고민을 하였고, a-b가 양방향일 경우에는 way\[a]\[b]와 way\[b]\[a]를 모두 0으로 갱신시켜주었고, a-b가 단방향일 경우에는 way\[a]\[b]만 1로 갱신해주었다.

이번 문제는 다익스트라 알고리즘을 활용하여 해결하였다. 다익스트라에 사용되는 가중치 리스트를 거리에 대한 가중치가 아닌, 경사에 대한 가중치로 설정하였고, 다음 가중치를 결정할 때에는 현재 경사와 다음 칸과 현재 칸 간의 차이 중 더 큰 값으로 결정하였고, 이 가중치보

이번 문제는 유니온-파인드 알고리즘을 통해 해결하였다. 처음에는 플로이드-와샬을 통해 접근하였지만 80%에서 오답처리 되었고, 다른 사람들의 풀이를 참고한 결과 모두 유니온-파인드로 풀이한다는 사실을 알게 되었다. 유니온-파인드를 통해 각 도시들의 루트를 찾고, 계획을

이번 문제는 유니온-파인드 알고리즘을 통해 해결하였다. 부모를 찾는 find 함수와 두 값이 연결되어 있을 때의 루트를 찾는 union 함수를 구현하고, 연결된 값 a, b를 받으면 바로바로 union함수를 통해 두 값의 루트를 찾도록 해준다. 그리고 모든 값들의 루트

이번 문제는 유니온-파인드 알고리즘을 통해 해결하였다. 기존 유니온-파인드와 다르게 값이 str형식으로 들어왔기 때문에 딕셔너리를 사용하였다. 처음에는 딕셔너리를 통해 부모를 찾고, 아직 못찾았을 부모가 있을 수 있으므로 부모 딕셔너리를 순회하며 find함수를 다시 돌

이번 문제는 유니온-파인드 알고리즘을 통해 해결하였다. 문제를 보자마자 유니온-파인드를 통해 각각의 부모를 찾고, 강의실 순서를 순회하며 부모가 다를 경우에 결과 변수를 증가시키면 되겠다 생각하였고, 그렇게 구현하였다. 유니온-파인드를 진행하여도, 완전히 부모를 찾지

이번 문제는 BFS를 통해 해결하였다. 우선 2개의 인덱스 간의 수 교환이 필요하기 때문에 그 모든 경우를 itertools의 combinations을 통해 구해주었다. 그리고 k번 교환이 반복되었을 때의 최댓값을 구해야 하기 때문에 q에 넣을 때 교환 횟수를 세는 카

이번 문제는 BFS와 다익스트라 알고리즘을 활용하여 해결하였다. 나무들의 좌표를 저장하고, 이를 이용하여 BFS를 통해 모든 좌표의 나무까지의 최소 거리를 저장한 리스트를 만들었다. 그리고 다익스트라 알고리즘을 활용하여 이 나무까지의 최소 거리 리스트의 값들을 통해 거

이번 문제는 BFS를 통해 해결하였다. 큐에는 (왼쪽 좌표, 오른쪽 좌표, 현재 약, 먹은 약 갯수) 가 들어간다. 중복을 막기 위해 방문처리 리스트를 2차원 리스트로 구현하였다. 방문처리 리스트는 visited\[왼쪽 좌표]\[오른쪽 좌표] 로 구현하였다. while

이번 문제는 BFS를 통해 해결하였다. 동전의 앞면의 갯수와 뒷면의 갯수를 저장하고, 뒷면의 갯수로 방문처리를 진행하였다. 0~k개만큼 동전을 뒤집을 수 있으므로 앞면의 갯수와 뒷면의 갯수를 이용하여 다음 뒷면의 갯수를 구하고, 만약 뒷면의 갯수가 n일 경우 카운팅 변

이번 문제는 BFS를 통해 해결하였다. 큐에 a의 현재 좌표, b의 현재 좌표, 이동 횟수를 저장하고, 9가지의 방향을 각각 적용하여 주어진 조건이 모두 만족할 경우에 이동시키는 방식으로 구현하였다. 방문처리는 4차원 리스트를 사용하여 a와 b 둘의 위치를 모두 고려하

이번 문제는 다익스트라 알고리즘을 통해 해결하였다. 처음에는 비용만 체크하며 탐색을 진행하였는데, 50%에서 오답처리되었다. 그래서 시간도 같이 체크하며 탐색을 진행하였다. 비용을 저장하는 리스트를 2차원 리스트로 선언하여 각 건물과 시간에 대한 비용을 모두 저장하게

이번 문제는 DP와 DFS를 활용하여 해결하였다. max_dp와 min_dp에 각각 최댓값과 최솟값을 저장하도록 하고, DFS를 통해 탐색하였다. 만약 다음 위치가 연산자라면, dp에 이전 위치의 dp값을 넣어주고, 해당 연산자를 넣어 재귀호출 해주었고, 다음 위치가

이번 문제는 다익스트라 알고리즘을 통해 해결하였다. BFS를 통해 두 로봇의 좌표를 관리하며 모든 이동하는 경우를 탐색하는 방법으로 접근하려다가 다익스트라 알고리즘으로 각 로봇의 위치에서 전체 위치로의 거리를 모두 구해놓고, 이를 비교하는 것이 더 깔끔할 것 같다는 생

이번 문제는 DFS를 통해 해결하였다. 모든 노드에서는 1로 모여야 하므로 1이 트리의 루트가 된다. 그렇기 때문에 루트에서 DFS를 통해 내려가며 늑대가 있다면 현재 양의 수 - 늑대의 수가 0보다 클 때 해당 수를 반환하고, 0보다 작다면 0을 반환하도록 하였고,

이번 문제는 BFS를 통해 해결하였다. 우선 수의 범위가 10억이기 때문에 set()을 통해 방문처리를 하였고, -연산은 무조건 0이 나오기 때문에 따로 처리하지 않았다(s와 t의 범위는 1부터 시작이기 때문에 0을 요구하는 경우는 없다). 아스키코드 오름차순으로 가장

이번 문제는 비트마스킹을 활용한 BFS를 통해 해결하였다. grid를 돌며 시작 위치를 저장하고, num을 1부터 시작하여 X를 만날 때마다 해당 위치의 값을 num으로 바꿔주고 num을 1 증가시키는 방식으로 각각의 물건에 번호를 부여하였다. 그리고 방문처리 리스트를

이번 문제는 BFS를 통해 해결하였다. 처음에는 유니온-파인드로 해결하려 하였지만, 사이클을 따로 확인해야 하는 불편함이 발생하였다. 그래서 BFS를 통해 접근하였다. 그래프를 인접 리스트로 저장하고, BFS를 통해 탐색하며 방문처리를 해준다. 만약 현재 노드가 이미

이번 문제는 다익스트라 알고리즘을 활용하여 해결하였다. 다익스트라 알고리즘에서 가중치에 해당하는 리스트에는 검정색 칸을 흰색 칸으로 변경한 횟수가 들어가게 된다. 가중치 리스트의 초기값을 최댓값으로 채운 후, 탐색을 진행하며 더 작은 수가 들어올 경우 갱신해주는 방식으

이번 문제는 플로이드-와샬 알고리즘을 통해 해결하였다. 데이터를 인접 행렬 형태로 저장하였고, 이때 graph\[무거운 구슬]\[가벼운 구슬]에 해당하는 값만 1로 갱신하였다. 그리고 플로이드-와샬을 통해 모든 구슬간의 관계에 대한 인접 행렬을 완성하였고, 이를 y축과

이번 문제는 플로이드-와샬 알고리즘을 활용하여 쉽게 해결하였다. grid를 2차원 리스트로 선언하고, a가 b를 이겼을 경우 grid\[a]\[b]를 1로 증가시켜준다. 그리고 플로이드-와샬 알고리즘을 통해 grid\[i]\[j]가 0일 경우 grid\[i]\[k]와

이번 문제는 BFS와 에라토스테네스의 체를 이용하여 해결하였다. 우선 4자리 수에 대한 소수 정보를 담은 primes 리스트를 만들기 위해 에라토스테네스의 체를 이용하였다. 그리고 BFS를 통해 주어진 4자리 수를 바꿀 수 있는 모든 경우를 탐색하며 primes리스트

이번 문제는 DFS와 BFS를 활용하여 해결하였다. DFS를 통해 현재 역의 사이클 여부를 확인하고, BFS를 통해 사이클 역에서부터 다른 역까지의 거리를 각각 구하도록 하였다. 그래프 탐색을 위해 인접 리스트로 데이터를 저장하였다.

이번 문제는 플로이드-와샬 알고리즘을 통해 해결하였다. 플로이드-와샬 알고리즘을 통해 각 점에서 다른 점까지의 모든 최단 거리를 구하여 리스트를 만들고, 이 리스트에서 모든 경우의 2개의 행을 확인하며 각 점까지의 더 작은 거리의 2배를 더한 값 중 가장 작은 값과 그

이번 문제는 BFS를 통해 해결하였다. 기존의 벽 부수고 이동하기 문제에서 낮과 밤에 대한 조건이 추가된 문제였고, 이를 위해 낮과 밤의 정보를 담을 변수 time을 사용했다. time이 1일 경우에는 낮이고, -1일 경우에는 밤인 경우이다. 방문처리는 visited\

이번 문제는 BFS를 통해 해결하였다. 처음에는 벽에서마다 BFS를 통해 주변을 탐색하도록 하였는데 시간초과가 발생하였다. 그 이유는 그렇게 되면 같은 통로를 여러번 탐색하기 때문이었다. 그래서 통로들의 그룹을 BFS를 통해 만들어 딕셔너리에 정보를 저장하고, 각 벽에

이번 문제는 에라토스테네스의 체를 통해 소수 리스트를 생성하고, BFS를 통해 핑거스냅으로 일어날 수 있는 수의 모든 변화를 탐색하는 방식으로 해결하였다. 인덱스 에러가 발생하여 문제를 다시 보니 n의 범위가 1,000,000이었는데 범위를 100,000로 잡아 발생한

이번 문제는 BFS, DFS, 배열 돌리기를 활용하여 해결하였다. BFS를 통해 입구에서 출구까지의 이동을 구현하였고, DFS를 통해 배열을 돌리는 모든 경우와 시작점과 끝점이 1일 경우에 BFS를 호출하는 로직을 구현하였고, zip 내장함수를 활용하여 배열 돌리기를

이번 문제는 BFS를 통해 해결하였다. 문제에 대한 데이터들을 입력받고, grid를 만들어 해당 장애물들을 설치해주었다. 그리고 BFS를 통해 grid를 탐색하며 방문처리와 함께 현재 위치의 높이와 다음 위치의 높이를 비교하며 이동을 시켰고, 현재 체력이 0보다 작아지

이번 문제는 다익스트라 알고리즘을 활용하여 해결하였다. 각 좌표에서 왼쪽으로 화살표를 왼쪽 비용이 k가 될때까지 돌리며 힙에 넣고, 오른쪽으로 화살표를 오른쪽 비용이 k가 될때까지 돌리며 힙에 넣고, 안돌리고 화살표대로 힙에 넣도록 하였다. 이때 넣기 전에는 비용 리스

이번 문제는 유니온-파인드 알고리즘을 활용하여 쉽게 해결하였다. 주어지는 두 쌍의 섬들을 합치고 부모를 구하도록 한다. 이 과정에서 갱신되지 않는 경우가 존재하기 때문에 2중 for문을 돌며 i와 j의 find 반환 값이 다를 경우에 i와 j를 출력하고 프로그램을 종료

이번 문제는 BFS를 활용하여 해결하였다. a와 b의 범위가 100,000으로 매우 크기 때문에 방문처리 리스트를 2차원 리스트로 활용할 수 없었다. 그래서 set()으로 정의하고, (a, b) 형태로 담아 방문처리를 진행하였다. 세 종류의 작업의 모든 경우는 a를 채

이번 문제는 이전 자의 두 점을 기억하여 현재 자의 두 점과 비교하는 방식으로 해결하였다. 우선 자에 대한 데이터를 왼쪽 점과 오른쪽 점의 오름차순으로 정렬해주고, for문을 통해 해당 데이터들을 순회하며 이전 왼쪽 점이 현재 왼쪽 점보다 크거나 이전 오른쪽 점이 현재

이번 문제는 다익스트라 알고리즘을 통해 해결하였다. heapq에 다리의 무게제한을 음수로 바꿔 넣어 최대힙으로 활용하였고, 다익스트라 알고리즘으로 탐색을 진행하여 도착 위치에 해당하는 값을 출력하도록 하였다.업로드중..

이번 문제는 DP와 BFS를 활용하여 해결하였다. 문제를 해석하면 현재 노드에서 다음 노드를 결정할 때, 현재 노드와 연결된 갯수보다 다음 노드와 연결된 갯수가 더 많아야 한다. 이 중 가장 많이 이동할 수 있는 경우의 수를 구하는 문제이다. 이 문제를 DP로 해결한

이번 문제는 BFS를 활용하여 해결하였다. 0이 아닌 모든 좌표에서 시작하여 더 이상 움직일 수 없을 때까지 BFS를 통해 이동시켜 이때의 길이와 시작+끝의 값을 결과 리스트에 저장하고, 결과 리스트를 길이, 시작+끝의 내림차순으로 정렬하여 가장 앞의 값을 출력하도록

이번 문제는 BFS를 통해 해결하였다. 큐에 a, b, 지목 횟수를 넣어 BFS를 통해 탐색을 진행하였다. 중복을 제거하기 위해 visited 리스트를 2차원으로 선언하여 a, b를 짝지어 경우를 확인하도록 하였다. a먼저 지목시키고, 기존의 b와 비교한 후, 만약 같

이번 문제는 permutations를 이용하여 해결하였다. 1번 선수는 무조건 4번 타자가 되어야 하므로 1부터 8까지의 수의 permutations를 구하고, 4번째 자리에 1번 선수를 넣어주었다. 그리고 이닝을 진행하며 타자의 번호를 cur 변수로 기억하고 아웃카운

이번 문제는 비트마스킹과 BFS를 통해 해결하였다. 각 좌표별로 벽이 있는 정보를 입력받고, BFS를 통해 탐색하며 벽의 유무를 비트마스킹으로 판별하여 방의 정보를 저장하였다. cnt리스트에는 각 방의 크기를 저장하였고, rooms리스트에는 각 방의 번호를 부여하여 저

이번 문제는 BFS를 통해 해결하였다. 세명의 악당의 위치를 기준으로 BFS를 통해 모든 좌표로의 거리를 구하고, 모든 좌표를 순회하며 세명의 악당으로부터의 거리가 모두 갱신되어 있을 때의 셋 중의 최댓값을 구하고, 이를 결과 변수와 비교하여 더 작은 경우 결과변수를

이번 문제는 BFS를 통해 해결하였다. 도로가 모두 일방통행이므로 정방향에 대한 도로의 정보를 인접 리스트로 저장하고, 역방향에 대한 도로의 정보를 인접 리스트로 저장하였다. 그리고 도로의 정방향에 대하여 BFS를 통해 탐색하며 비용을 저장하는 리스트 costs를 최댓

이번 문제는 BFS를 통해 해결하였다. 기존의 BFS와 달리 상하좌우로 한칸씩 탐색하지 않고, 상하로는 최대한으로 탐색하고, 그 이후에 좌우를 한칸씩 탐색하는 방법으로 해야 방문처리를 2차원 리스트로 수행하면서 모든 방문 위치를 저장할 수 있었다.

이번 문제는 그리디하게 해결하였다. 입력해야 하는 시간이 60을 넘어가면 60을 최대한 누르는 것이 유리하므로 n을 60으로 나눈 몫을 sixty라는 변수에 저장하였고, 60으로 나눈 나머지에서 10을 나눈 몫을 ten이라는 변수에 저장하였다. 그리고 n을 10으로 나

길이가 같은 두 개의 큐가 주어집니다. 하나의 큐를 골라 원소를 추출(pop)하고, 추출된 원소를 다른 큐에 집어넣는(insert) 작업을 통해 각 큐의 원소 합이 같도록 만들려고 합니다. 이때 필요한 작업의 최소 횟수를 구하고자 합니다. 한 번의 pop과 한 번의 i

이번 문제는 BFS와 딕셔너리를 활용하여 해결하였다. 각 플레이어들의 위치를 저장하고, 각 플레이어 별로 BFS를 통해 보스의 위치까지 이동하는 데에 걸리는 시간을 딕셔너리에 저장하였다. 이 결과 만들어지는 걸리는 시간 리스트를 활용하여 보스의 체력이 떨어질 때까지 반

이번 문제는 이분탐색과 BFS를 통해 해결하였다. BFS로 탐색을 수행할 때, 최대 중량의 기준을 인자로 입력받고, 시작점부터 끝점까지 기준 중량을 넘지 않고 통과한다면 True를 반환하도록 하였다. 그리고 이분탐색을 통해 최댓값과 최솟값을 계속 갱신하며 이의 중간값을

오랜만에 백트레킹 문제를 풀어봐야곘다 생각했고, 이 문제를 선택했다. 인자로 들어오는 배열이 좋은 수열인지 확인하는 함수와 백트레킹 함수로 구현했고, 처음에는 백트레킹 함수의 재귀호출 부분에서 조건문을 달지 않고 구현했다. 그러나 이렇게 되면 재귀호출의 가짓수가 너무나

이번 문제는 BFS를 활용하여 해결하였다. 처음에는 해밍턴 거리를 구하기 위해 XOR연산자를 활용하였는데, 이 방법을 쓰는 과정에서 에러가 발생하였다. K의 길이가 최대 30인 것을 보고, 그냥 for문을 통해 확인하는 방식으로 구현하였고, 해결할 수 있었다.업로드중.

이번 문제는 위상정렬과 BFS, DP를 이용하여 해결하였다. 입력값을 저장할 때에 인접 리스트 형태로 저장해주고, 각 건물의 이전에 지어야 하는 건물의 갯수를 cnt리스트로 관리해주도록 하였다. 그리고 큐에 cnt가 0인 건물의 번호를 모두 담고, BFS를 통해 탐색을

이번 문제는 DP와 DFS를 활용하여 해결하였다. 우선 만들고자 하는 단어와 같은 좌표를 모두 start리스트에 저장하고, 3차원 리스트의 dp리스트를 만들었다. dp에는 해당 좌표와 해당 인덱스에서의 가짓수가 저장된다. DFS를 통해 탐색하며 dp리스트를 계속해서 갱

이번 문제는 유니온-파인드를 통해 해결하였다. 확실히 플레티넘 문제라 접근도 어려웠고, 혼자 풀는 것이 힘들었다... 결국은 다른 사람의 풀이를 참고해서 해결하였다. 원리는 가장 가까운 행성들을 우선적으로 찾는 것이었다. 그래서 z, y, x좌표를 각각 다른 리스트로

이중 우선순위 큐는 다음 연산을 할 수 있는 자료구조를 말합니다.이중 우선순위 큐가 할 연산 operations가 매개변수로 주어질 때, 모든 연산을 처리한 후 큐가 비어있으면 0,0 비어있지 않으면 최댓값, 최솟값을 return 하도록 solution 함수를 구현해주

회사원 Demi는 가끔은 야근을 하는데요, 야근을 하면 야근 피로도가 쌓입니다. 야근 피로도는 야근을 시작한 시점에서 남은 일의 작업량을 제곱하여 더한 값입니다. Demi는 N시간 동안 야근 피로도를 최소화하도록 일할 겁니다.Demi가 1시간 동안 작업량 1만큼을 처리

고속도로를 이동하는 모든 차량이 고속도로를 이용하면서 단속용 카메라를 한 번은 만나도록 카메라를 설치하려고 합니다.고속도로를 이동하는 차량의 경로 routes가 매개변수로 주어질 때, 모든 차량이 한 번은 단속용 카메라를 만나도록 하려면 최소 몇 대의 카메라를 설치해야

xx 회사의 2xN명의 사원들은 N명씩 두 팀으로 나눠 숫자 게임을 하려고 합니다. 두 개의 팀을 각각 A팀과 B팀이라고 하겠습니다. 숫자 게임의 규칙은 다음과 같습니다.먼저 모든 사원이 무작위로 자연수를 하나씩 부여받습니다.각 사원은 딱 한 번씩 경기를 합니다.각 경

N개의 아파트가 일렬로 쭉 늘어서 있습니다. 이 중에서 일부 아파트 옥상에는 4g 기지국이 설치되어 있습니다. 기술이 발전해 5g 수요가 높아져 4g 기지국을 5g 기지국으로 바꾸려 합니다. 그런데 5g 기지국은 4g 기지국보다 전달 범위가 좁아, 4g 기지국을 5g

2016년 1월 1일은 금요일입니다. 2016년 a월 b일은 무슨 요일일까요? 두 수 a ,b를 입력받아 2016년 a월 b일이 무슨 요일인지 리턴하는 함수, solution을 완성하세요. 요일의 이름은 일요일부터 토요일까지 각각 SUN,MON,TUE,WED,THU,F

본 문제는 정확성과 효율성 테스트 각각 점수가 있는 문제입니다.카카오 초등학교의 "니니즈 친구들"이 "라이언" 선생님과 함께 가을 소풍을 가는 중에 징검다리가 있는 개울을 만나서 건너편으로 건너려고 합니다. "라이언" 선생님은 "니니즈 친구들"이 무사히 징검다리를 건널