강의를 듣기전 일단 먼저 문제를 풀었다.

내가 처음 제출한 코드는 이렇다. 다행히(?) 한번에 통과했다.

#include <iostream>
#include <vector>
#include <limits>

using namespace std;

int N;
vector<int> numV;
vector<int> oper(4, 0);
int minAns = numeric_limits<int>::max();
int maxAns = numeric_limits<int>::min();

// 입력
void input() {
    // 숫자 갯수 받기
    cin >> N;

    int temp;
    // 숫자 벡터 채우기
    for (int i = 0; i < N; i++) {
        cin >> temp;
        numV.push_back(temp);
    }
    // 연산자 벡터 채우기
    for (int i = 0; i < 4; i++) {
        cin >> oper[i];
    }
}

int sum(int a, int b) {
    return a + numV[b];
}

int sub(int a, int b) {
    return a - numV[b];
}

int mul(int a, int b) {
    return a * numV[b];
}

int di(int a, int b) {
    if (a < 0) {
        return (-1) * ((-1 * a) / numV[b]);
    }

    return a / numV[b];
}

void rec_func(int k, int ans) {
    // 연산완료
    if (k == N) {
        if (minAns > ans) {
            minAns = ans;
        }

        if (maxAns < ans) {
            maxAns = ans;
        }

        return;
    }

    // 연산
    for (int i = 0; i < 4; i++) {
        if (oper[i] == 0) {
            continue;
        }

        // 연산 후 다음단계 이동
        oper[i]--;
        switch(i) {
            case 0:
                rec_func(k + 1, sum(ans, k));
                break;
            case 1:
                rec_func(k + 1, sub(ans, k));
                break;
            case 2:
                rec_func(k + 1, mul(ans, k));
                break;
            case 3:
                rec_func(k + 1, di(ans, k));
                break;
        }

        // 연산자 변경
        oper[i]++;
        continue;
    }

}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    input();
    rec_func(1, numV[0]);

    // 결과 출력
    cout << maxAns << "\n" << minAns;
    return 0;
}

현재 수강중인 내용은 완전탐색. 완전탐색이라서기보다는 언제읽어도 무슨 코드인지 알 수 있게 지금은 가독성 중시 및 모듈화하는 연습을 하고 있다. 사실 처음에는 이게 모듈화 최선인줄 알았다.

수강 후 수정한 코드는 이렇다.

#include <iostream>
#include <vector>
#include <limits>

using namespace std;

int N;
vector<int> numV;
vector<int> operators(4, 0);
int minAns = numeric_limits<int>::max();
int maxAns = numeric_limits<int>::min();

// 입력
void input() {
    // 숫자 갯수 받기
    cin >> N;

    int temp;
    // 숫자 벡터 채우기
    for (int i = 0; i < N; i++) {
        cin >> temp;
        numV.push_back(temp);
    }
    // 연산자 벡터 채우기
    for (int i = 0; i < 4; i++) {
        cin >> operators[i];
    }
}

// 계산 함수
int calc(int operand1, int oper, int operand2) {
    switch(oper) {
        case 0:
            return operand1 + operand2;
        case 1:
            return operand1 - operand2;
        case 2:
            return operand1 * operand2;
        case 3:
            if (operand1 < 0) {
                return -1 * ((-1 * operand1) / operand2);
            }
            return operand1 / operand2;
    }
}

void rec_func(int k, int ans) {
    // 연산완료
    if (k == N) {
        if (minAns > ans) {
            minAns = ans;
        }

        if (maxAns < ans) {
            maxAns = ans;
        }

        return;
    }

    // 연산
    for (int i = 0; i < 4; i++) {
        if (operators[i] == 0) {
            continue;
        }

        // 연산 후 다음단계 이동
        operators[i]--;
        rec_func(k + 1, calc(ans, i, numV[k]));

        // 연산자 변경
        operators[i]++;
        continue;
    }

}

int main() {
    // 최적화
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    // 입력 + 연산 + 출력
    input();
    rec_func(1, numV[0]);
    cout << maxAns << "\n" << minAns;
    return 0;
}

계산을 여기저기서 할게 아니라 '계산'이라는 함수를 따로 만드는게 더 깔끔하다는 걸 알았다.

아무래도 계속 연습하는 것만이 답인 것 같다. 이 함수가 어디까지를 책임질지를 잘 고민해봐야겠다. 어찌보면 이 또한도 객체지향적인 코드를 짜는 연습이 되지 않을까 싶다. (요즘 많이 고민하는 부분 ㅎㅎ)

우선은 알고리즘에 의해 발견된 영상 하나를 간략하게 요약해보려고 한다.

https://www.youtube.com/watch?v=pYAYTJ0vFfs

FSD의 풀네임은 Feature-Sliced Design. 기능별로 잘라서 디자인을 하겠다는 뜻이다. 그렇다고 개발자 위주로 나누는 것이냐? 아니 사용자의 이용을 중심으로 나누는 것이다. (참고: https://feature-sliced.design/)

(출처: 구글검색)

이렇게 layer단위로 먼저 나누고, 레이어 안에는 slice, 그 안에는 segement로 이루어지게 된다. 같은 layer안에 있다 해도 슬라이스와 슬라이스는 참조할 수 없으며 같은 슬라이스 안에 있는 세그먼트더라도 세그먼트끼리는 참조할 수 있다. 오직 layer들 만이 위에서 아래방향으로 참조할 수 있다.

즉, app은 widget을 참조할 수 있지만 widget은 app을 참조할 수 없다.

그렇다면 각각의 layer는 무엇을 기준으로 나누느냐! 사실 이건 상대적인 것이다. 팀 내에서 소통을 통해 정하면 된다. 프로젝트 당시에도 features는 무엇이며 entities에는 무엇이 들어가는건지 감이 안잡혔었는데 논의가 필요한 부분이라고 해서 살짝 안심했다.

아마 제대로 이해하려면 간단한 토이프로젝트에 이 구조를 적용시켜봐야 조금이나마 더 이해한채로 글을 작성할 수 있을 것이다.

ORM이란?

서버단과 DB단을 연결해주는 기술. 직접적으로 쿼리문을 적지 않아도 데이터를 조회, 생성, 삭제, 수정 할 수 있다.

🔸 언어별 대표 ORM 예시

JPA란?

JAVA의 ORM. JPA는 interface고 실제 구현체는 Hibernate, EclipseLink