quant developer dave

사라지만 발판 python 풀이 2022 KAKAO BLIND RECRUITMENT 프로그래머스

quantdave — Wed, 1 Jun 2022 14:27:20 +0900

https://programmers.co.kr/learn/courses/30/lessons/92345

코딩테스트 연습 - 사라지는 발판

[[1, 1, 1], [1, 1, 1], [1, 1, 1]] [1, 0] [1, 2] 5 [[1, 1, 1], [1, 0, 1], [1, 1, 1]] [1, 0] [1, 2] 4

programmers.co.kr

minmax tree를 사용해서 풀었다.

game(board, aloc, bloc) 함수는 두가지 값을 반환 하는데 ( Tuple[bool, int] )

첫번째는 이번 차례에 aloc가 이길 수 있는지 여부

두번째는 이길 수 있다면 최소 길이 못 이기면 최대 길이를 반환 한다.

next_aloc는 aloc가 다음번에 이동할 칸의 위치이고,

이때 game(board, bloc, next_aloc) 반환 값을 이용해 최적의 플레이를 하도록 한다.

from typing import Tuple
moves = [(0, 1), (-1, 0), (1, 0), (0, -1)]

def game(board, aloc, bloc,)-> Tuple[bool, int]:
    game_results = []
    
    if board[bloc[0]][bloc[1]] == 0:
        return True, 0
    if board[aloc[0]][aloc[1]] == 0:
        return False, 0
    
    for move in moves:
        next_aloc = (aloc[0]+move[0], aloc[1]+move[1])        
        try:
            if next_aloc[0] < 0 or next_aloc[1] < 0 :
                raise IndexError
            next_board = board[next_aloc[0]][next_aloc[1]]
        except IndexError:
            continue
        
        if next_board == 1:
            board[aloc[0]][aloc[1]] = 0
            win, game_length = game(board, bloc, next_aloc)
            board[aloc[0]][aloc[1]] = 1
            game_results.append((not win, game_length+1))
    
    if len(game_results) == 0:
        return False, 0
    elif any(r[0] for r in game_results):
        return True, min(r[1] for r in game_results if r[0])
    else:
        return False, max(r[1] for r in game_results)

def solution(board, aloc, bloc):
    return game(board, aloc, bloc)[1]

파이썬 튜토리얼 1. 애피타이저 (Whetting Your Appetite)

quantdave — Fri, 10 Jul 2020 22:23:28 +0900

https://docs.python.org/3/tutorial/appetite.html

만약 당신이 컴퓨터로 많은 작업을 한다면, 결국에 당신은 자동화 하고 싶은 일을 발견하게 될겁니다.

예를들면, 당신은 대용량 텍스트 파일에서 찾아바꾸기를 수행하거나, 복잡한 방법으로 많은 사진들을 정리하거나 이름을 바꾸고 싶을 수도 있습니다. 아마도 당신은 작은 커스텀 데이터베이스나 특정 GUI 어플리케이션 혹은 간단한 게임을 만들고 싶을 수도 있습니다.

만약 당신이 전문적인 소프트웨어 개발자라면, C/C++/JAVA 라이브러리를 사용하게 될수도 있지만 그 과정에서 보통 코드작성/컴파일/테스트/리컴파일 싸이클이 너무 많은 시간을 소요합니다. 그리고 당신은 특정 라이브러리를 위한 test suite를 작성하며 test code를 작성하는것이 지루한 일이라는 것을 발견할 것입니다. 혹은 당신이 이미 언어 확장이 가능한 프로그램을 만들었지만, 새로운 언어 전체를 설계하고 구현하고 싶지는 않을수도 있습니다.

파이썬은 당신을 위한 언어 입니다. (Python is just the language for you.)

당신은 위에서 서술한 작업들을 위해 유닉스 쉘 스크립트 혹은 윈도우 배치 파일을 작성할 수 있습니다. 그러나 쉘스크립트는 파일을 이동시키거나 텍스트를 수정하는데는 적합하지만, GUI 어플리케이션 혹은 게임을 만드는데는 적합하지 않습니다. 당신은 C/C++/JAVA를 사용할 수도 있지만, 이는 초안을 개발하기까지도 많은 시간을 필요로 합니다. 파이썬은 사용하기 단순하면서 윈도우 맥 유닉스 시스템 모두에서 사용이 가능하고 빠른 일 처리를 가능하게합니다.

파이썬은 단순하지만, 쉘 스크립트 혹은 배치 파일에 비해 훨씬 더 구조적이며 대규모 프로그램 개발을 지원합니다.

한편, 파이썬은 C언어에 비해 훨씬 더 많은 에러 체킹 기능을 지원하고 가변길이 배열(flexible array)과 사전 자료형(dictionary)과 같은 built-in high-level data type을 지원하는 high level language 입니다. 제너럴 데이터 타입 덕분에 파이썬은 Awk 혹은 펄에 비해 훨씬 더 큰 프로램에도 적용 될 수 있습니다. 적어도 파이썬에서 많은 것들을 그 언어들만큼 쉽게 구현 할 수 있습니다.

파이썬은 당신의 프로그램을 다른 파이썬 프로그램에서 재사용 가능한 모듈로 분리할수 있게 해줍니다. 파이썬에는 당신의 프로그램의 기반이 되어주거나 프로그램을 배울때 예시가 되어줄 다양한 표준 모듈이 있습니다. 이런 모듈중 일부는 file I/O, 시스템 콜 그리고 Tk와 같은 GUI 툴킷까지도 제공을 합니다.

대경권 대학생 프로그래밍 경진대회 3번 with 프로그래머스

quantdave — Sat, 28 Apr 2018 15:47:26 +0900

요약하면 문제는 입력된 명령어대로 움직였을 때, 지나온 길의 수를 찾는것이다. 입력이 매우 작으므로 그냥 나올 수 있는 모든 길을 저장하는 2차원 배열(footprints)을 선언해 메모이제이션 했다.

코드

#include <string>
#include <algorithm>
#include <memory.h>
using namespace std;


# -5~5의 범위를 가지는 2차원 좌표를 정수 하나로 변환 해주는 함수.
int flatten(int y, int x){
    y += 5;
    x += 5;
    return y*11+x;
}

int footprints[122][122];
int solution(string dirs)
{
    int answer = 0;
    int now_y = 0;
    int now_x = 0;

    for (auto i=dirs.begin(); i!=dirs.end(); i++){
        int prev_y = now_y;
        int prev_x = now_x;

		switch (*i){
            case 'U':
                now_y += 1;
                break;
            case 'D':
                now_y -= 1;
                break;
            case 'R':
                now_x += 1;
                break;
            case 'L':
                now_x -= 1;
                break;
        }

        if(now_y < -5) now_y = -5;
        if(now_y > 5) now_y = 5;
        if(now_x < -5) now_x =-5;
        if(now_x > 5) now_x = 5;

        int flat_prev = flatten(prev_y, prev_x);
        int flat_now = flatten(now_y, now_x);

        if( (flat_prev != flat_now)
           && (footprints[flat_prev][flat_now] == 0)){
            footprints[flat_prev][flat_now] = 1;
            footprints[flat_now][flat_prev] = 1;
            answer += 1;
        }
    }
    return answer;
}

대경권 대학생 프로그래밍 경진대회 2번 with 프로그래머스

quantdave — Sat, 28 Apr 2018 15:29:54 +0900

오랜만에 알고리즘 문제를 푸니 기분이 좋아 대회 리뷰를 남긴다. 1번은 너무 단순한 구현 문제라 생략한다.

전형적인 dp 문제.

첫번째 입력 예제인 [1,1,1,1] 문제를 (0, [1,1,1,1])로 두고 (1, [1,1,1])과 (-1, [1,1,1]) 경우로 나누는 방법으로 recursive property를 찾아 문제를 해결했다.

코드

#include <string>

#include <vector>

#include <memory.h>

using namespace std;

int d[102][1001*2], N;

vector<int> input;

int dp(int state, int value){

int index_value = value + 1001;

int &ret = d[state][index_value] ;

if (ret != -1)

return ret;

if (state == N)

return value == 0;

int result = 0;

result += dp(state+1, value+input[state]);

result += dp(state+1, value-input[state]);

result %= 100000;

return ret=result;

}

int solution(vector<int> numbers) {

input = numbers;

N = input.size();

memset(d,-1,sizeof(d));

return dp(0, 0);

}

boj 14699 관악산 등산

quantdave — Wed, 27 Sep 2017 23:09:32 +0900

게을러져서 문제도 많이 안풀고 풀이 남기는 것도 귀찮았는데 그래도 주1회 정도는 포스팅을 하려고 다시 마음을 먹었다.

서울대 프로그래밍 콘테스트 문제를 하나씩 풀어나가고 있다.

문제링크 : https://www.acmicpc.net/problem/14699

문제를 읽고 처음 든 순간은 최단거리네? 최단거리 알고리즘 중에 아무꺼나 하나 골라 쓰자였다. 그 생각에 사로잡혀 문제 조건도 확인안하고 다익스트라를 n번 돌리는걸로 답을 구해 시간초과 ... 와샬플로이드써서 시간초과 ....

그렇게 두번 실패를 하고 찬찬히 다시 문제를 읽어보니 간단한 dp 문제였다. 코딩 테스트 같은걸 볼때 쉬운 문제라도 이런 실수를 해버리면 시간안에 못풀수있겠다는 생각이 든다. 경각심을 가져야겠다.

풀이 : 일단 더 위쪽 쉼터에서 아래로 내려가는 경우가 없으므로 양방향이 아닌 단방향(저 -> 고)으로 그래프를 만든다. 그 후에 dfs로 탐색을 하는데 현재 쉼터 s에서 들릴 수 있는 최대 쉼터 갯수 d(s)는 max( d(s에서 갈 수 있는 모든 쉼터) + 1) 이다. 재귀적인 속성을 가지므로 재귀함수로 작성을 하면 간단하다. 또한 d(s)는 중복 호출이 많이 되므로 메모이제션을 해서 중복 계산을 막는다.

소스코드

#include <iostream>

#include <vector>

#include <cstdio>

#include <algorithm>

using namespace std;

int a, b, V, E;

const int MAX_V = 5001;

const int INF = 987654320;

vector<pair<int, int>>adj[MAX_V];

vector<int> cache(MAX_V, -1);

int dp(int s) {

int &ret = cache[s];

if (ret != -1) return ret;

int res = 1;

for (int i = 0; i < adj[s].size(); i++) {

res = max(res, dp(adj[s][i].first) + 1);

}

return ret = res;

}

int main() {

cin >> V >> E;

for (int i = 0; i<E; i++) {

scanf("%d%d", &a, &b);

a--; b--;

//더 위에 있는 쉼터만 연결함.

if (height[a] < height[b]) adj[a].push_back(pair<int, int>(b, 1));

else if (height[a] > height[b]) adj[b].push_back(pair<int, int>(a, 1));

}

int res = 0;

for (int j = 0; j < V; j++) {

cout << dp(j) << endl;

}

5월 인바디 결과

quantdave — Sun, 28 May 2017 00:03:29 +0900

원래 인바디를 잴 때 마다 업로드 하려 했으나 3월은 귀찮아서 못했다.

바빠서 운동을 집에서 풀업하고 딥스 팔굽혀펴기 정도 밖에 못해서 크게 변한건 없는 듯 하다.

3월에 비해 골격근 0.8kg / 체지방 0.1kg 이 늘었다.

6월은 더 바쁘겠지만 그래도 시간 내서 운동 가보려고 다시 헬스장을 등록했다.

6월 말에 다시 재러 가야겠다.

팁스타운 배 코드챌린지 본선 - 3번

quantdave — Tue, 23 May 2017 03:17:34 +0900

예전에 풀었던 백준넷 단어와 주기율표 문제의 다운그레이드 버전

https://www.acmicpc.net/problem/4507

저 문제는 조건이 상당히 까다로워 아직도 푼 사람이 두명밖에 없어서 뿌듯하다 ㅋㅋㅋ

동적 계획법 문제인데, dp(state)를 state~끝 문장을 처리 할 때 필요한 최소 단어 조각 갯수로 정의했다

최대 단어 조각 길이는 5이므로 state부터 한자리씩 추가해가면서 단어 조각 목록에 있는지를 검사해 있으면 그 다음 글자부터 필요한 단어 조각 갯수를 계산하는 과정을 다섯번 반복한다. 그 중 최소값을 반환하면 된다.

int d[20001];

set<string> dictionary;

string str;

int dp( int state)

{

if(state>=str.length()) return 0;

int &ret = d[state];

if(ret != -1) return ret;

int res = 987654321;

string match = "";

for(int i=state; i<state+5; i++)

{

match+=str[i];

if(dictionary.find(match) != dictionary.end())

{

res = min(res, dp(i+1)+1);

}

return ret = res;

}

int solution(vector<string> strs, string t)

{

int answer = 0;

dictionary.clear();

memset(d,-1,sizeof(d));

str = t;

for(auto i=strs.begin(); i!=strs.end(); i++)

dictionary.insert(*i);

int ret = dp(0);

if(ret > 20001) return -1;

return ret;

}

팁스타운 배 코드챌린지 본선 - 2번

quantdave — Tue, 23 May 2017 03:09:23 +0900

전형적인 스택 사용 문제

순차적으로 입력받은 문자열을 순회하면서 스택이 비어 있거나 최상단 문자와 다르면 푸시

최상단 문자와 같으면 팝 하는 과정을 반복 후에 스택이 비어있으면 모두 제거가능하다.

시간 복잡도 O(n)

int solution(string s)

{

stack<char> st;

for(int i=0; i<s.length(); i++)

{

if(st.empty() || st.top() != s[i])

{

st.push(s[i]);

}

else if(st.top() == s[i])

{

st.pop();

}

return st.empty();

}

프로그래머스 - Summer coding 온라인 예선 3번

quantdave — Sun, 21 May 2017 00:26:58 +0900

5월 20일 오후 한시에 있었던 스타트업 인턴 채용을 위한 대회인 Summer coding 온라인 예선에 참가하게 되었고 문제와 해답을 공유 합니다. 제가 공유한 코드는 전부 만점이긴 하지만, 대회라는 시간이 촉박한 상황에서 작성 했기 때문에 다소 지저분한 코드가 있을 수 있습니다.

문제

N개의 스티커가 원형으로 연결되어 있습니다. 다음 그림은 N = 8인 경우의 예시입니다.

원형으로 연결된 스티커에서 몇 장의 스티커를 뜯어내어 뜯어낸 스티커에 적힌 숫자의 합이 최대가 되도록 하고 싶습니다. 단 스티커 한 장을 뜯어내면 양쪽으로 인접해있는 스티커는 찢어져서 사용할 수 없게 됩니다.

예를 들어 위 그림에서 14가 적힌 스티커를 뜯으면 인접해있는 10, 6이 적힌 스티커는 사용할 수 없습니다. 스티커에 적힌 숫자가 배열 형태로 주어질 때, 스티커를 뜯어내어 얻을 수 있는 숫자의 합의 최댓값을 return 하는 solution 함수를 완성해 주세요. 원형의 스티커 모양을 위해 배열의 첫 번째 원소와 마지막 원소가 서로 연결되어 있다고 간주합니다.

제한 사항

•sticker는 원형으로 연결된 스티커의 각 칸에 적힌 숫자가 순서대로 들어있는 배열로, 길이(N)는 1 이상 100,000 이하입니다.

•sticker의 각 원소는 스티커의 각 칸에 적힌 숫자이며, 각 칸에 적힌 숫자는 1 이상 100 이하의 자연수입니다.

•원형의 스티커 모양을 위해 sticker 배열의 첫 번째 원소와 마지막 원소가 서로 연결되어있다고 간주합니다.

입출력 예

sticker	answer
[14, 6, 5, 11, 3, 9, 2, 10]	36
[1, 3, 2, 5, 4]	8

입출력 예 설명

입출력 예 #1

6, 11, 9, 10이 적힌 스티커를 떼어 냈을 때 36으로 최대가 됩니다.

입출력 예 #2
3, 5가 적힌 스티커를 떼어 냈을 때 8로 최대가 됩니다.

풀이

간단한 동적 계획법 문제인데, 가장 코드가 마음에 안드는 문제.

처음 스티커를 제거하면 마지막 스티커를 획득 못하고, 마지막 스티커를 제거하면 처음 스티커를 획득 하지 못합니다.

이 조건 처리가 상당히 귀찮아서 캐싱 배열을 두배로 잡았습니다

처음 스티커를 획득하면 b = 0 / 아닌 경우는 b=1을 넣어서 호출합니다.

s번째 스티커를 때는 경우 = d[s+2] + sticker[s]

s번째 스티커를 안때는 경우 = d[s+1]

s번째 부터 끝까지 스티커를 때서 얻을 수 있는 최댓값 = max ( d[s+2] + sticker[s], d[s+1] )

* 마지막 스터커 처리는 기저 조건에서 처음 스티커를 땠으면 마지막 스티커를 획득 못하게 합니다.

int d[100001][2],len;

int dp(const vector<int>&sticker, int s, int b)

{

if(s>=len) return 0;

if(s==len-1)

{

if(b==0)return sticker[s];

else return 0;

}

int &ret= d[s][b];

if(ret != -1) return ret;

return ret = max(sticker[s]+dp(sticker,s+2,b) , dp(sticker,s+1,b));

}

int solve(const vector<int>&skicker)

{

len =sticker.size();

memset(d,-1,sizeof(d));

return max(dp(sticker, 2, 1 ) + sticker[0] , dp(sticker,1,0));

}

int solution(vector<int> sticker)

{

int answer = solve(sticker);

return answer;

}

프로그래머스 - Summer coding 온라인 예선 2번

quantdave — Sun, 21 May 2017 00:14:08 +0900

문제

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

예를 들어 11개의 아파트가 쭉 늘어서 있고, [4, 11] 번째 아파트 옥상에는 4g 기지국이 설치되어 있습니다. 만약 이 4g 기지국이 전파 도달 거리가 1인 5g 기지국으로 바뀔 경우 모든 아파트에 전파를 전달할 수 없습니다. (전파의 도달 거리가 W일 땐, 기지국이 설치된 아파트를 기준으로 전파를 양쪽으로 W만큼 전달할 수 있습니다.)

•초기에, 1, 2, 6, 7, 8, 9번째 아파트에는 전파가 전달되지 않습니다.

•1, 7, 9번째 아파트 옥상에 기지국을 설치할 경우, 모든 아파트에 전파를 전달할 수 있습니다.

•3개의 아파트보다 더 많은 아파트 옥상에 기지국을 설치할 경우에도 모든 아파트에 전파를 전달할 수 있습니다.

이때, 우리는 기지국을 최소로 설치하면서 모든 아파트에 전파를 전달하려고 합니다. 위의 예시에선 최소 3개의 아파트 옥상에 기지국을 설치해야 모든 아파트에 전파를 전달할 수 있습니다.

아파트의 개수 N, 현재 기지국이 설치된 아파트의 번호가 담긴 1차원 배열 stations, 전파의 도달 거리 W가 매개변수로 주어질 때, 모든 아파트에 전파를 전달하기 위해 증설해야 할 기지국 개수의 최솟값을 리턴하는 solution 함수를 완성해주세요

제한사항

•N: 20,000,000 이하의 자연수

•stations의 크기: 10,000 이하의 자연수

•stations는 오름차순으로 정렬되어 있고, 배열에 담긴 수는 N보다 같거나 작은 자연수입니다.

•W: 10,000 이하의 자연수

•시간제한: 7ms

입출력 예

N	stations	W	answer
11	[4, 11]	1	3
16	[9]	2	3

입출력 예 설명

입출력 예 #1
문제의 예시와 같습니다

입출력 예 #2

•초기에, 1~6, 12~16번째 아파트에는 전파가 전달되지 않습니다.

•3, 6, 14번째 아파트 옥상에 기지국을 설치할 경우 모든 아파트에 전파를 전달할 수 있습니다.

풀이

왼쪽부터 탐색하다가 전파가 닿지 않는 공간이 나왔을 때, 가능한 오른쪽에 배치하는게 가장 최적의 해입니다. (그리디)

따라서 n 위치가 전파가 닿지 않는다면 n+w에 기지국을 설치하고 n+w+w+1부터 탐색을 계속해 나가는 것이 최적 입니다.

s+w 위치에 기지국이 있다면 , 기지국을 설치할 수 있는 가장 오른쪽에 기지국을 설치합니다.

int solution(int n, vector<int> stations, int w)

{

int state = 0;

int left = 1,count=0;

while(true){

//find left

if(state<stations.size() && left >= stations[state] - w)

{

left = stations[state]+w+1;

state++;

}

else{

int newleft = left+w;

if( (state<=(int)stations.size()-2) && newleft>=stations[state+1]-w )newleft = stations[state+1]-w-1;

left=newleft+w+1;

count++;

}

if(left> n)break;

}

return count;

}