link: 코딩테스트 연습 - [PCCP 기출문제] 1번 / 동영상 재생기

1. 문제 풀이

mm:ss를 전부 초로 바꾸어 시간을 이동한 뒤 다시 mm:ss 형태로 만들기

주의할 점

• 언제든 오프닝 시간대에 있다면 오프닝은 건너뛰기

• 배열 출력 - toString 까먹지 말자!

  import java.util.Arrays;

  String[] mn = video_len.split(":"); System.out.println(Arrays.toString(mn));

• "mm:ss" 형식으로 출력하기

  1. format 사용

     answer = String.format("%02d:%02d", pos_m, pos_s);

  2. if문 사용

     String mm = (pos_m < 10) ? "0" + pos_m : "" + pos_m;
     String ss = (pos_s < 10) ? "0" + pos_s : "" + pos_s;
     
     answer = mm + ":" + ss;

2. 처음 코드

import java.util.*;

class Solution {
    public String solution(String video_len, String pos, String op_start, String op_end, String[] commands) {
        String answer = "";

        // video_len을 초로 바꾸기
        String[] video_mn = video_len.split(":");        
        int video_m = Integer.parseInt(video_mn[0]);
        int video_s = Integer.parseInt(video_mn[1]);        
        video_s += video_m * 60;

        // pos를 초로 바꾸기
        String[] pos_mn = pos.split(":");
        int pos_m = Integer.parseInt(pos_mn[0]);
        int pos_s = Integer.parseInt(pos_mn[1]);   
        pos_s += pos_m * 60;

        // op_stsrt 초로 바꾸기
        String[] ops_mn = op_start.split(":");
        int ops_m = Integer.parseInt(ops_mn[0]);
        int ops_s = Integer.parseInt(ops_mn[1]);
        ops_s += ops_m * 60;

        // op_end 초로 바꾸기
        String[] ope_mn = op_end.split(":");
        int ope_m = Integer.parseInt(ope_mn[0]);
        int ope_s = Integer.parseInt(ope_mn[1]);        
        ope_s += ope_m * 60;

        // commands 배열의 길이 저장
        int n = commands.length;

        for(int i = 0; i < n; i++){
            // 현재 시간이 오프닝 사이에 있다면 오프닝 건너뛰기
            if(pos_s >= ops_s && pos_s <= ope_s)
                pos_s = ope_s;

            // next일 때 10초 후 비디오 길이 안에 있다면 10초 건너뛰기
            // 비디오 길이를 벗어난다면 비디오 끝으로 이동
            if(commands[i].equals("next")){
                if((pos_s + 10) < video_s)
                    pos_s += 10; 
                else 
                    pos_s = video_s;

            // prev일 때 10초 전 비디오 길이 안에 있다면 10초 되감기
            // 0초보다 전이라면 0초로 이동
            } else if(commands[i].equals("prev")){
                if((pos_s - 10) > 0)
                    pos_s -= 10;
                else
                    pos_s = 0;
            }
        }

        // 현재 시간이 오프닝 사이에 있다면 오프닝 건너뛰기
        if(pos_s >= ops_s && pos_s <= ope_s)
                pos_s = ope_s;

        // 분초로 바꾸기
        pos_m = pos_s / 60;
        pos_s = pos_s % 60;

        // "mm:ss" 형태로 바꾸기
        answer = String.format("%02d:%02d", pos_m, pos_s);

        return answer;
    }
}

변경 코드

오프닝 한 번으로 줄이는 것은 불가능 시간을 초형태로 바꾸는 것은 함수로 빼낼 수 있음

import java.util.*;

class Solution {

    // 분초를 초로 바꾸는 함수
    private int toSec(String mmss){
        String[] ms = mmss.split(":");

        int m = Integer.parseInt(ms[0]);
        int s = Integer.parseInt(ms[1]);

        return s + m * 60;
    }

    public String solution(String video_len, String pos, String op_start, String op_end, String[] commands) {
        String answer = "";

        // 분초를 전부 초로 변경
        int video_s = toSec(video_len);
        int pos_s = toSec(pos);
        int ops_s = toSec(op_start);
        int ope_s = toSec(op_end);

        int n = commands.length;

        for(int i = 0; i < n; i++){
            if(pos_s >= ops_s && pos_s <= ope_s)
                pos_s = ope_s;

            if(commands[i].equals("next")){
                if((pos_s + 10) < video_s)
                    pos_s += 10; 
                else 
                    pos_s = video_s;

            } else if(commands[i].equals("prev")){
                if((pos_s - 10) > 0)
                    pos_s -= 10;
                else
                    pos_s = 0;
            }
        }

        if(pos_s >= ops_s && pos_s <= ope_s)
                pos_s = ope_s;

        int pos_m = pos_s / 60;
        pos_s = pos_s % 60;

        answer = String.format("%02d:%02d", pos_m, pos_s);

        return answer;
    }
}

자판 배열을 한컴 입력기에서 Microsoft 입력기로 변경해주면 된다... 엄청 뻘짓 했네..ㅎㅎ

link: 코딩테스트연습 - 나머지가 1이 되는 수 찾기

문제풀이

반복문 안에서 자연수 1부터 하나씩 늘려 가장 작은 자연수 x 찾기 x를 찾으면 반복문 탈출(break) break가 없다면 가장 큰 자연수 x를 찾을 수 있다.

class Solution {
    public int solution(int n) {
        int answer = 0;
        int x = 1;

        while(x < n){
            if(n%x == 1){
                answer = x;
                break;
            }
            x++;
        }
        return answer;
    }
}

link: 코딩테스트 연습 - x만큼 간격이 있는 n개의 숫자

1. 배열 long[] 사용

주의할 점

• 배열에 크기를 미리 지정해주어야 함

  long[] answer = new long[n];

• add() 사용 불가능 - add()는 ArrayList에 있는 함수이다.

• long타입 지정해주기

  answer[i] = (long)x*(i+1);

class Solution {
    public long[] solution(int x, int n) {
        long[] answer = new long[n];

        for(int i=0; i<n; i++){
            answer[i] = (long)x*(i+1);
        }

        return answer;
    }
}

2. ArrayList<> 사용

주의할 점

• 프로그래머스는 이미 지정된 타입이 있기 때문에 타입 변경이 필요함

  long[] answer = new long[n];
        for(int i = 0; i < n; i++){
            answer[i] = list.get(i);
        } 

• ArrayList<> 타입을 쓸 때는 대문자!

  ArrayList<Long> list = new ArrayList<>();

• int를 long 타입으로 변경해주기

  list.add((long)x*(i+1));

• import java.util.*; 추가 해주기

  import java.util.*;

  import java.util.*;

class Solution { public long[] solution(int x, int n) { ArrayList list = new ArrayList<>();

    for(int i = 0; i < n; i++){
        list.add((long)x*(i+1));
    }

    long[] answer = new long[n];
    for(int i = 0; i < n; i++){
        answer[i] = list.get(i);
    }

    return answer;
}

} ```

팀원의 것을 풀 받고 푸시를 했어야 했는데 풀을 받지 않고 푸시를 해버려서 충돌이 생김 검색해보니 충돌이 나는 변경사항을 직접 고치고 풀 받으면 된다는데 나는 내가 작성중인 파일이 아니라 이미 커밋해버린 상태에서 충돌이 났기 때문에 해당이 안됐다.

1. git bash로 $ git pull --no-rebase 정확히는 까먹었지만 저기 나와있는 경고창대로 써보니 pull이 되기는 했다. 하지만 팀원의 파일이 반영이 된 것이 아니라 내 기존 파일에 팀원의 파일이 추가되어 내가 다시 팀원의 변경사항을 커밋했어야했다. -> 팀원의 코드를 다시 내가 커밋하는 것이므로 해결x

2. 팀원의 커밋 전까지로 내 커밋상태 돌리기 기능 하나만 추가된 상태여서 내가 추가한 변경사항들을 따로 백업을 하고 커밋을 되돌려 추가했다. 커밋을 되돌린 후에 다시 팀원의 것을 풀 받고 내가 수정한 코드를 다시 추가했다. -> 성공!

코드를 다시 작성하고 싶지 않아서 계속 찾아봤는데 이 방법이 제일 빠르고 해결이 쉬웠다...😅

• 제네릭스
• 컬렉션
• 예외처리
• 입출력
• Enum
• 람다식
• Stream

후기

자바를 배우면 배울수록 더 어려워지고 있다... 자동완성이 없었다면 따라가기 힘들었을 것... 근데 이번주 수업을 통해 함수 먼저 짜고 해결하던 방법에서 객체지향적으로 생각하는 방법을 조금 알게 된 것 같다. 일단 전체적으로 필요한 기능들에 대해 생각하고 기능을 타고 타고 만들어가는 방법을 연습한 주였다. 배운 내용을 복습하기 위해 스터디원과 함께 포켓몬 게임 프로젝트를 진행했는데 우리가 하는 것을 보고 선생님께서 우리 프로젝트를 잘 진행할 수 있는 수업을 진행해주셔서 좋았다.

😊 좋았던 점

• 배운 내용으로 작은 팀프로젝트 진행

🤔 아쉬웠던 점

• 팀프로젝트를 통해 나의 개발 실력이 아직 많이 부족하다는 것을 알았다...

• JAVA
  • 배열
  • 제어문
  • 클래스와 객체
  • 상속
  • 다형성
  • 인터페이스
  • 자주 쓰는 API

후기

클래스와 객체 파트에 들어가면서 내용도 많아지고 많이 어려워졌다. 분명 예전에 배웠던 내용인데 처음 듣는 것 같은 기분..ㅎㅎ 오버로딩은 동일한 메소드 이름으로 다양한 종류의 매개변수에 따라 처리해야하는 경우 적용하는 기술이고 오버라이딩은 부모클래스에서 상속받은 메소드를 자식 클래스가 재정의하여 사용하기 위한 기술이라는 둘의 명확한 차이를 알게되었다.

😊 좋은 점

• 개념들을 새로 쌓을 수 있었다.
• 스터디를 통해 배운 개념들을 직접 클래스를 만들고 예제를 직접 생각해서 복습이 되었다.

🤔 아쉬웠던 점

• CS 면접을 위해 더 열심히 정리해놔야겠다...

📘 문제풀이

입력배열을 받아 공백은 건너뛰고 배열 row를 기준으로 0번 인덱스부터 읽음

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        char[][] input = new char[5][15];
        for (int i = 0; i < 5; i++) {
            String str = sc.next();
            for (int j = 0; j < str.length(); j++) {
                input[i][j] = str.charAt(j);
            }
        }

        String answer = "";
        for (int i = 0; i < input[0].length; i++) {
            for (int j = 0; j < input.length; j++) {
                if(input[j][i] == '\u0000') continue;
                else {
                    answer += input[j][i];
                }
            }
        }
        System.out.println(answer);
    }
}

문자열을 어떻게 한문자씩 넣을 수 있을까 생각하는 것이 제일 어려웠다.
구글링으로 str.charAt(i)를 찾아서 사용하였다.
charAt은 문자를 하나씩 넣다보니 가변 배열로 사용할 수 없었고 정변 배열을 써야만 넣을 수 있었다.
split을 사용하면 가변 배열로 사용할 수 있을 것 같다.

📘 문제풀이

10개의 값을 입력받고 42로 나눈 나머지를 배열에 넣고 배열에 있는 나머지들 중에 다른 것이 들어오면 cnt를 추가한다. 만약 같은 나머지가 있다면 for문을 빠져나와 cnt가 추가되지 않게 한다.

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] inputArr = new int[10];
        int cnt = 1;

        for (int i = 0; i < 10; i++){
            inputArr[i] = sc.nextInt();
            inputArr[i] %= 42;
            for (int j = 0; j < i; j++){
                if(inputArr[j] != inputArr[i]) {
                    if (j == i-1){
                        cnt++;
                    }
                } else{
                    break;
                }
            }
        }
        System.out.println(cnt);
    }
}

• JAVA
  • literal
  • 변수
  • 연산자
  • 메소드
  • API
  • 조건문

후기

팀프로젝트가 끝나고 자바를 시작하였다. 자바는 한 번 배웠던 것이고 이번주는 너무 기초적인 부분이라 수업에 잘 집중할 수 있을까 걱정하였었다. 그런데 그동안 내가 그냥 쓰면 쓰는거지 생각하고 코드를 이론적인 부분을 가르쳐주셔서 수업이 재미있었다. 그리고 타이핑 할 때 유용한 팁들을 많이 가르쳐주셔서 코드 칠 때도 정말 유용했다.

😊 좋은 점

• 이론적인 지식
• 타이핑 속도 향상

🤔 아쉬운 점

• 노션 정리 열심히 하자,,ㅎㅎ

📘 문제풀이

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int hour = sc.nextInt();
        int minute = sc.nextInt();

        // minite이 45분 이상일 때
        if(minute >= 45) {
            minute -= 45;
        } else { // 45분 미만일 때
            if(hour == 0) // 자정일 때
                hour = 24;
            hour -= 1;
            minute = minute + 60 - 45;
            //minute += 15;            //조금 더 빠름
        }

        System.out.println(hour + " " + minute);
    }
}

그동안 백준을 파이썬으로만 풀어서 잘 몰랐는데 
자바는 클래스 이름을 Main으로 해야 컴파일 에러가 생기지 않는다.

• 운영체제(OS)
• 리눅스

후기

이번주 진도는 여유롭게 진행되었다. 리눅스는 처음 배워보는 것이었는데 신기한 경험이었다. 일단 윈도우 말고 새로운 OS를 써보는 것이 처음이라 신기했고 명령어만 익숙진다면 어렵지는 않을 것 같다. 정규표현식은 어려울 수도 있는데 파이썬을 공부하면서 몇 번 작성해봐서 이해할 수 있었다. 3주차는 수업보다 팀플 위주로 많이 진행되서 수업 끝나고 DB팀플에 집중했다. 저번주에 팀원들과 프로젝트에 대해 기준과 기능 이야기를 많이 해서 이번주는 내용작성이 더 수월하였다. 근데 분명 잘 작성해서 수정할게 없다고 생각했던 ERD와 요구사항명세서는 몇 번이나 수정이 되는건지..ㅎㅎㅎㅎ 역시 세상엔 완벽한게 없다... 하지만 팀원들 덕분에 잘 헤쳐오는 중!

😊 좋았던 점

• 리눅스 첫 경험!
• 저번주보다 수월하게 진행된 팀프로젝트

🤔 아쉬웠던 점

• 개인공부량이 부족한 것 같다. 자바를 시작하면 더 어렵고 양도 많아질테니 확실히 개인공부가 필요!

• SQL문
• DML
• DB 제약조건
• VIEW
• INDEX
• TRIGGER
• DB 모델링 개요
• ERD

후기

1주차보다 양도 많고 진도도 좀 더 빨라졌다고 느꼈다. 코드 적으면서 설명도 듣는게 멀티가 잘 안되서 약간 어려웠다. 노션에 설명해주시는 내용을 따라 적으면서 하려다 보니 조금씩 놓치게 된 부분도 있는 것 같다. 앞으로는 강의 자료를 다 받고 그 안에서 추가된 부분을 적는 방식을 시도해 봐야겠다. 새해 팀 과제로 ERD 모델링을 하게 되었는데 큰 프로젝트는 아니었지만 시간이 꽤 오래걸렸다. 그래서 생각한 것은 엔티티를 만들기 전에 일단 우리가 만들 프로젝트에 대해 정확한 의도와 자세한 기능 소개를 먼저 팀원들과 이야기를 하고 엔티티를 짜는 방향으로 가야 시간을 효율적으로 쓸 수 있다고 느꼈다. 같은 엔티티 이름, 같은 속성 이름이지만 팀원들마다 생각하는 의도가 달라서 이부분을 맞추는게 굉장히 오래 걸렸기 때문이다. 하지만 같이 기능과 속성을 확실히 정하고 나니 회의가 수월하게 진행되었다. 내일 발표가 기대된다!

😊 좋았던 점

• SQL문을 직접 따라쓰면서 작성 방법이 익숙해졌다.
• 과제를 통해 ERD를 그리는 방법에 대해 알 게 되었다.
• 처음 같이 한 팀프로젝트이지만 싸우지 않고 의견을 잘 조율해서 진행이 잘 된 것 같다.

🤔 아쉬웠던 점

• 감기에 걸려서 이번주 수업은 제대로 집중하지 못한 것 같다. (건강관리 필수! 부트캠프 내에서도 감기가 유행중 ㅜ)

후기

✏ 1주차에 배운 것

• SW공학
  • Git
    • Github
    • UML
    • 요구사항
  • SW 개발 프로세스
• DB
  • DB개요
  • MariaDB
  • SQL(SELECT, ORDER BY, WHERE, DISTINCT, LIMIT, JOIN)
    

불규칙적인 생활을 해오다가 부트캠프를 신청하고 오랜만에 9시부터 6시까지 공부하는 규칙적인 생활을 하게되었다.

처음엔 어색했지만 같이 수업을 듣는 동기도 있고 ot도 진행해서 금방 적응할 수 있었다. 그리고 첫째주라 그런지 엄청 어려운 수업을 하진 않아서 따라가기 벅찬 수업은 아니었다. 노션 정리는 처음이라 어색한데 수업을 진행하다보면 나만의 패턴을 만들 수 있지 않을까 기대가 된다.

😊좋았던 점

일주일동안 스터디 팀원들과 밥을 먹으며 많이 친해진 것 같다. 하브루타를 통해 그날 배우 수업을 복습하고 이해할 수 있는 시간을 가져서 좋았다. 팀스터디를 통해 수업시간에 어려웠던 부분을 더 잘 이해할 수 있게 되었다.

🤔아쉬웠던 점

점심시간이 너무 짧은 것 같다...😂 노션 정리를 더 열심히 하고 싶지만 못하고 있는 나에게 조금 아쉽다.

📘 문제풀이

def solution(cacheSize, cities):
    answer = 0
    cache = []

    if cacheSize == 0:
        return len(cities) * 5

    for c in cities:
        c = c.lower()
        #캐시 안에 있을 때       
        if c in cache:
            i =  cache.index(c)
            p = cache.pop(i)
            cache.append(p)
            answer += 1
        #캐시 안에 없을 때
        else:
            if len(cache) < cacheSize:
                cache.append(c)
            else:
                del cache[0]
                cache.append(c)
            answer += 5

    return answer

LRU 알고리즘
가장 오랫동안 교체되지 않은 페이지 교체

😎코딩테스트 연습>2018 KAKAO BLIND RECRUITMENT>[3차] 파일명 정렬

📘 문제풀이

import re

def solution(file_names):
    filt = re.compile(r'([a-zA-Z\-\s]+)([0-9]{0,5})(.*)')
    files = []

    for file_name in file_names:
        files.extend(filt.findall(file_name))

    files.sort(key=lambda x: (x[0].lower(), int(x[1])))
    answer = [''.join(i) for i in files]

    return answer

<정규표현식>
re.compile(): 미리 패턴을 컴파일
r'': 컴파일 해야하는 정규식이 raw string(순수한 문자)임을 알려줌 

참고링크

📘 문제풀이

from collections import deque 
def solution(targets):
    answer = 0
    interception = deque()
    targets.sort()
    for t in targets:
        st, et = t
        n = len(interception)
        while n >= 0:
            if n == 0:
                interception.append((st, et))
                break

            s, e = interception[n-1]

            if s <= st < e or s < et <= e:
                if s <= st < et <= e:
                    interception.pop()
                    interception.append((st, et))
                elif s <= st:
                    interception.pop()
                    interception.append((st, e))
                else:
                    interception.pop()
                    interception.append((s, et))
                break
            n -= 1


    return len(interception)

굉장히 비효율적인 방법이었지만...ㅎㅎ
큐를 만들어서 겹치는 구간이 있는 타켓은 합치고 아니면 추가하는 방식을 사용했다. 
처음엔 n을 0부터 시작했는데 답은 맞았지만 시간초과 오류가 나서
끝에서부터 추가하는 방식으로 바꿨다.

📘 문제풀이

def solution(m, n, board):
    answer = 0    
    board = [list(i) for i in board]

    while True:
        d = set() #중복제거

        #지울 블록 찾기
        for i in range(m-1):
            for j in range(n-1):
                if (board[i][j] == board[i][j+1] == board[i+1][j] == board[i+1][j+1]) and board[i][j] != '':
                    d.add((i, j))
                    d.add((i, j+1))
                    d.add((i+1, j))
                    d.add((i+1, j+1))
        #지울 블록 개수 세기
        answer += len(d)
        if not d:
            break

        #블록 지우기
        for p in d:
            x, y = p
            board[x][y] = ''

        #블록 내리기
        for i in range(m-1, -1, -1):
            for j in range(n):
                if board[i][j] == '':
                    tmp = i

                    while tmp >= 0 and board[tmp][j] == '':
                        tmp -= 1
                    if tmp >= 0:
                        board[i][j] = board[tmp][j]
                        board[tmp][j] = ''

    return answer

소혜언니의 코드 참고했다.. ㅎ

import sys

h, w = map(int, sys.stdin.readline().split())
rain = list(map(int, sys.stdin.readline().split()))

answer = 0
cnt = 0
p = rain[0]
max_i = rain.index(max(rain))

for i in range(1, len(rain)):
    if p > rain[i]:
        cnt += p - rain[i]
    else:
        answer += cnt
        cnt = 0
        p = rain[i]
    if i == max_i:
        break

p = rain[w-1]
for i in range(w-1, max_i-1, -1):
    if p > rain[i]:
        cnt += p - rain[i]
    else:
        answer += cnt
        cnt = 0
        p = rain[i]

print(answer)

처음엔 풀지 못했다가 max indax 값을 찾아서 반대로 돌면 어떻겠냐는 
스터디원의 조언 덕분에 해결! 

📘 문제풀이

def solution(bandage, health, attacks):
    T = 0 #전체시간
    ct = 0 #회복지속시간
    h = health

    #at 공격시간,  피해량
    for at, a in attacks:
        ct = at - T -1

        #회복량
        h += ct * bandage[1]
        #추가회복량
        while ct >= bandage[0]:
            h += bandage[2]
            ct -= bandage[0]
        #체력보정    
        if h > health:
            h = health
        #공격피해
        h -= a
        #죽음
        if h <= 0:
            return -1
        #현재시간
        T = at

    return h

현재 시간에서 공격 당한 그 시간 사이만큼 회복 가능
연속으로 공격 당하면 회복x