deeprun

소수찾기

 문제 설명

한자리 숫자가 적힌 종이 조각이 흩어져있습니다. 흩어진 종이 조각을 붙여 소수를 몇 개 만들 수 있는지 알아내려 합니다.

각 종이 조각에 적힌 숫자가 적힌 문자열 numbers가 주어졌을 때, 종이 조각으로 만들 수 있는 소수가 몇 개인지 return 하도록 solution 함수를 완성해주세요.

 제한 사항

• numbers는 길이 1 이상 7 이하인 문자열입니다.
• numbers는 0~9까지 숫자만으로 이루어져 있습니다.
• "013"은 0, 1, 3 숫자가 적힌 종이 조각이 흩어져있다는 의미입니다.

 입출력 예

 Python 코드

from itertools import permutations
 
def solution(numbers):
    
    # 소수 판별할 리스트 만들기
    num_list = [] # 전체 순열 넣어줄 리스트
    for i in range(1,len(numbers)+1) :
        test_list = permutations(numbers,i)       
        for j in test_list :
            num_list.append(int("".join(j)))
        
    num_list = set(num_list) # 중복과 0, 1 제외
    if 0 in num_list :
        num_list.remove(0)        
    if 1 in num_list :
        num_list.remove(1)
        
    # 소수 판별 
    answer = len(num_list) # 모든 수가 소수라 가정하고 시작
    for i in num_list :
        if i != 2 :
            for j in range(2,int(i**0.5)+1) :
                if i % j== 0 :
                    answer -=1
                    break
        
    return answer

* 참고 링크 : https://mentha2.tistory.com/8

 C++ 코드

#include<string>
#include<vector>
#include<cmath>
 
using namespace std;
 
bool Visit[10000000];
bool Select[10];
int Answer;
 
bool IsPrime(int N)
{
    if (N == 0 || N == 1) return false;
 
    for (int i = 2; i <= sqrt(N); i++)
    {
        if (N % i == 0) return false;
    }
    return true;
}
 
void DFS(int Cnt, string S, string Res)
{
    if(Res != "" && Visit[stoi(Res)] == false)
    {
        int Num = stoi(Res);
        Visit[Num] = true;
        if (IsPrime(Num) == true) Answer++;
    }
 
    for (int i = 0; i < S.length(); i++)
    {
        if (Select[i] == true) continue;
        Select[i] = true;
        DFS(Cnt + 1, S, Res + S[i]);
        Select[i] = false;
    }
}
 
int solution(string S)
{
    DFS(0, S, "");
    return Answer;
}

* 참고 링크 : https://yabmoons.tistory.com/336

 출처

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

Apache Tomcat

 Apache Tomcat 연동

0. Eclipse Pakages → Eclipse IDE for Enterprise Java and Web Developers Download

https://www.eclipse.org/downloads/packages/

1. Apache Tomcat 공식 사이트 접속 

https://tomcat.apache.org/

2. Apache Tomcat 공식 사이트 → Download → Tomcat 8 마우스로 클릭

3. Tomcat 8 Software Downloads → 8.5.75 → zip 파일 다운로드

※ C:\ 경로 안에 새로 생성한 폴더 안에 압축 해제할 것 

EX) C:\TEST\apache-tomcat-8.5.75

4. Eclipse 실행 후 우측 상단에 Java EE 아이콘 마우스로 클릭

5. Eclipse 하단에 Servers 탭 → 빈 공간에 마우스로 우클릭 → New → Server

6. New Server → Apache 선택

7. New Server →  Apache → Tomcat v8.5 Server → Next

8. 설치할 디렉토리 설정

- Tomcat installation directory : apache-tomcat 압축 해제한 경로로 설정

EX) C:\TEST\apache-tomcat-8.5.75

- JRE : jdk-8.0.312.7-hotsopt 설정

9. Apache Tomcat Server 연동 완료 → Server  → Tomcat v8.5 Server at localhost [Stopped, Republish] 더블 클릭

10. 3가지 수정

Server Locations 

1. Use Tomcat installation (takes control of Tomcat installation) 체크 

Use custom location (does not modify Tomcat installation) - 수동으로 경로 설정

2. Deploy path : apache-tomcat-8.5.75\webapps 경로 설정

ex) C:\test\apache-tomcat-8.5.75\webapps

Ports

3. Port Name : HTTP/1.1  / Port Number : 8090으로 수정

11. Windows → Web Browser → 3 Chrome 마우스로 클릭

12. http://localhost:8090 접속 여부 확인

 출처

+ 강의 교재

모의고사

 문제 설명

수포자는 수학을 포기한 사람의 준말입니다. 수포자 삼인방은 모의고사에 수학 문제를 전부 찍으려 합니다. 수포자는 1번 문제부터 마지막 문제까지 다음과 같이 찍습니다.

1번 수포자가 찍는 방식: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...
2번 수포자가 찍는 방식: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5, ...
3번 수포자가 찍는 방식: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...

1번 문제부터 마지막 문제까지의 정답이 순서대로 들은 배열 answers가 주어졌을 때, 가장 많은 문제를 맞힌 사람이 누구인지 배열에 담아 return 하도록 solution 함수를 작성해주세요.

 제한 사항

• 시험은 최대 10,000 문제로 구성되어있습니다.
• 문제의 정답은 1, 2, 3, 4, 5중 하나입니다.
• 가장 높은 점수를 받은 사람이 여럿일 경우, return하는 값을 오름차순 정렬해주세요.

 입출력 예

 Python 코드

def solution(answers):
    
    answer = []
    # 패턴정의
    first = [ 1,2,3,4,5 ]
    second = [ 2,1,2,3,2,4,2,5 ]
    third = [ 3,3,1,1,2,2,4,4,5,5 ]
    
    # 점수정의
    first_count = 0
    second_count = 0
    third_count = 0
    
    # 정답확인
    for number in range(len(answers)):
        if answers[ number ] == first[ number % 5 ]:
            first_count += 1
        if answers[ number ] == second[ number % 8 ]:
            second_count += 1
        if answers[ number ] == third[ number %10 ]:
            third_count += 1
    pre_answer = [ first_count,second_count,third_count ]   
    
    # 가장 많이 맞힌 사람
    for person, score in enumerate(pre_answer):
        if score == max(pre_answer):
            answer.append(person + 1)
    return answer

* 참고 링크 : https://sinsomi.tistory.com/entry/%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%A8%B8%EC%8A%A4-%EB%AA%A8%EC%9D%98%EA%B3%A0%EC%82%AC

 C++ 코드

#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int test1[5] = {1, 2, 3, 4, 5};
int test2[8] = {2, 1, 2, 3, 2, 4, 2, 5};
int test3[10] = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};

vector<int> solution(vector<int> answers) {
    vector<int> answer;
    int score[3] = {0, };
    int max_score = 0;
    for (int i = 0; i < answers.size(); i++){
        if (answers[i] == test1[i % 5]) score[0] += 1;
        if (answers[i] == test2[i % 8]) score[1] += 1;
        if (answers[i] == test3[i % 10]) score[2] += 1;
    }
    max_score = max(max(score[0], score[1]), score[2]);
    for (int i = 0; i < 3; i++){
        if (score[i] == max_score)
            answer.push_back(i + 1);
    }
    return answer;
}

* 참고 링크 : https://rile1036.tistory.com/28

 출처

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

Design Circular Queue

 문제 설명

Design your implementation of the circular queue. The circular queue is a linear data structure in which the operations are performed based on FIFO (First In First Out) principle and the last position is connected back to the first position to make a circle. It is also called "Ring Buffer".

One of the benefits of the circular queue is that we can make use of the spaces in front of the queue. In a normal queue, once the queue becomes full, we cannot insert the next element even if there is a space in front of the queue. But using the circular queue, we can use the space to store new values.

Implementation the MyCircularQueue class:

• MyCircularQueue(k) Initializes the object with the size of the queue to be k.
• int Front() Gets the front item from the queue. If the queue is empty, return -1.
• int Rear() Gets the last item from the queue. If the queue is empty, return -1.
• boolean enQueue(int value) Inserts an element into the circular queue. Return true if the operation is successful.
• boolean deQueue() Deletes an element from the circular queue. Return true if the operation is successful.
• boolean isEmpty() Checks whether the circular queue is empty or not.
• boolean isFull() Checks whether the circular queue is full or not.

You must solve the problem without using the built-in queue data structure in your programming language. 

 제한 사항

• 1 <= k <= 1000
• 0 <= value <= 1000
• At most 3000 calls will be made to enQueue, deQueue, Front, Rear, isEmpty, and isFull.

 입출력 예

Example 1:

Input
["MyCircularQueue", "enQueue", "enQueue", "enQueue", "enQueue", "Rear", "isFull", "deQueue", "enQueue", "Rear"]
[[3], [1], [2], [3], [4], [], [], [], [4], []]
Output
[null, true, true, true, false, 3, true, true, true, 4]

Explanation
MyCircularQueue myCircularQueue = new MyCircularQueue(3);
myCircularQueue.enQueue(1); // return True
myCircularQueue.enQueue(2); // return True
myCircularQueue.enQueue(3); // return True
myCircularQueue.enQueue(4); // return False
myCircularQueue.Rear();     // return 3
myCircularQueue.isFull();   // return True
myCircularQueue.deQueue();  // return True
myCircularQueue.enQueue(4); // return True
myCircularQueue.Rear();     // return 4

 Python 코드

Python code 

class MyCirculurQueue:
    def __init__(self, k):
        self.q = [None] * k
        self.maxlen = k
        self.p1 = 0
        self.p2 = 0

    # enQueue(): rear 포인터 이동
    def enQueue(self, value):
        if self.q[self.p2] is None:
            self.q[self.p2] = value
            self.p2 = (self.p2 + 1) % self.maxlen
            return True
        else:
            return False

    # deQueue(): front 포인터 이동
    def deQueue(self):
        if self.q[self.p1] is None:
            return False
        else:
            self.q[self.p1] = None
            self.p1 = (self.p1 + 1) % self.maxlen
            return True

    def Front(self):
        return -1 if self.q[self.p1] is None else self.q[self.p1]

    def Rear(self):
        return -1 if self.q[self.p2 - 1] is None else self.q[self.p2 - 1]

    def isEmpty(self):
        return self.p1 == self.p2 and self.q[self.p1] is None

    def isFull(self):
        return self.p1 == self.p2 and self.q[self.p1] is not None

* 참고 링크 : https://deep-learning-study.tistory.com/480

 C++ 코드

C ++ code

class MyCircularQueue {
public:
  MyCircularQueue(int k): q_(k) {}
  
  bool enQueue(int value) {
    if (isFull()) return false;
    q_[(head_ + size_) % q_.size()] = value;    
    ++size_;
    return true;
  }
  
  bool deQueue() {
    if (isEmpty()) return false;
    head_ = (head_ + 1) % q_.size();
    --size_;
    return true;
  }
 
  int Front() { return isEmpty() ? -1 : q_[head_]; }
 
  int Rear() { return isEmpty() ? -1 : q_[(head_ + size_ - 1) % q_.size()]; }
 
  bool isEmpty() { return size_ == 0; }
 
  bool isFull() { return size_ == q_.size(); }
private:
  vector<int> q_;
  int head_ = 0;
  int size_ = 0;
};

* 참고 링크 : https://zxi.mytechroad.com/blog/desgin/leetcode-622-design-circular-queue/

 출처

https://leetcode.com/problems/design-circular-queue/

Implement Queue using Stacks

 문제 설명

Implement a first in first out (FIFO) queue using only two stacks. The implemented queue should support all the functions of a normal queue (push, peek, pop, and empty).

Implement the MyQueue class:

• void push(int x) Pushes element x to the back of the queue.
• int pop() Removes the element from the front of the queue and returns it.
• int peek() Returns the element at the front of the queue.
• boolean empty() Returns true if the queue is empty, false otherwise.

Notes:

• You must use only standard operations of a stack, which means only push to top, peek/pop from top, size, and is empty operations are valid.
• Depending on your language, the stack may not be supported natively. You may simulate a stack using a list or deque (double-ended queue) as long as you use only a stack's standard operations.

 제한 사항

• 1 <= x <= 9
• At most 100 calls will be made to push, pop, peek, and empty.
• All the calls to pop and peek are valid.

 입출력 예

Example 1:

Input
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
Output
[null, null, null, 1, 1, false]

Explanation
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

 Python 코드

Python code 

class MyQueue: 
	def __init__(self): 
		// 문제에서 2개의 스택을 사용하라고 하니, 배열을 2개를 사용
		self.stack1 = [] 
		self.stack2 = [] 
		
	def push(self, x: int): 
		// stack1에는 push 데이터를 넣어줌
		self.stack1.append(x) 
		
	def pop(self): 
	// pop을 할때에는 stack1의 배열을 거꾸로 변경하는 과정이 필요
	// pop을 할때, stack1.pop()을 하여, stack2에 넣어줌
	// stack1 [1, 2, 3] -> stack2 = [3, 2, 1] 
		self.peek() 
		return self.stack2.pop() 
		
	def peek(self): 
		// peek는 큐의 첫번째 값을 가져와야 하므로 
		// stack1의 모든 값을 거꾸로 stack2에 넣어서, stack2[-1]을 리턴
		
		if not self.stack2: 
		// stack1의 모든 값이 나올때까지 해주는데, 
		// stack2가 비어있지 않은 경우에 stack2에 값을 넣을 경우 
		// pop()이 힘들어지니 stack1을 그대로 이용
		
		// 1) stack1 [1, 2, 3] -> stack2 [3, 2, 1] 
		// 2) MyQueue.push(4) 
		// 3) stack1 -> [4] , stack2 [3, 2, 1] 의 경우 
		// stack1의 값을 넣어주면 stack2는, [3, 2, 1, 4]가 되므로 pop을 하기가 힘듬 
		// 4) stack1의 [4]는 어차피 stack2가 다 빌때까지 필요없으므로 
		// 그냥 stack2가 빌때까지 stack1에 넣어둠 
		
			while self.stack1: 
				self.stack2.append(self.stack1.pop()) 
		return self.stack2[-1] 
		
		
	def empty(self): 
		return (len(self.stack1) == 0) and (len(self.stack2) == 0)

* 참고 링크 : https://jasmine46.tistory.com/71

 C++ 코드

C ++ code

// Time:  O(1), amortized
// Space: O(n)

class Queue {
public:
    // Push element x to the back of queue.
    void push(int x) {
        A_.emplace(x);
    }

    // Removes the element from in front of queue.
    void pop(void) {
        peek();
        B_.pop();
    }

    // Get the front element.
    int peek(void) {
        if (B_.empty()) {
          // Transfers the elements in A_ to B_.
          while (!A_.empty()) {
            B_.emplace(A_.top());
            A_.pop();
          }
        }
        if (B_.empty()) {  // B_ is still empty!
          throw length_error("empty queue");
        }
        return B_.top();
    }

    // Return whether the queue is empty.
    bool empty(void) {
        return A_.empty() && B_.empty();
    }

 private:
  stack<int> A_, B_;
};

* 참고 링크 : https://shareablecode.com/snippets/implement-queue-using-stacks-c-solution-leetcode-FaBa-R43B

 출처

https://leetcode.com/problems/implement-queue-using-stacks/

Implement Stack using Queues

 문제 설명

Implement a last-in-first-out (LIFO) stack using only two queues. The implemented stack should support all the functions of a normal stack (push, top, pop, and empty).

Implement the MyStack class:

• void push(int x) Pushes element x to the top of the stack.
• int pop() Removes the element on the top of the stack and returns it.
• int top() Returns the element on the top of the stack.
• boolean empty() Returns true if the stack is empty, false otherwise.

Notes:

• You must use only standard operations of a queue, which means that only push to back, peek/pop from front, size and is empty operations are valid.
• Depending on your language, the queue may not be supported natively. You may simulate a queue using a list or deque (double-ended queue) as long as you use only a queue's standard operations.

 제한 사항

• 1 <= x <= 9
• At most 100 calls will be made to push, pop, top, and empty.
• All the calls to pop and top are valid.

 입출력 예

Example 1:

Input
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
Output
[null, null, null, 2, 2, false]

Explanation
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // return 2
myStack.pop(); // return 2
myStack.empty(); // return False

더보기

 Python 코드

Python code 

class MyStack:

    def __init__(self):
        self.q = deque()

    def push(self, x: int) -> None:
        self.q.append(x)

    def pop(self) -> int:
        for i in range(len(self.q) - 1):
            self.push(self.q.popleft())
        return self.q.popleft()

    def top(self) -> int:
        return self.q[-1]

    def empty(self) -> bool:
        return len(self.q) == 0

# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()

* 참고 링크 : https://www.youtube.com/watch?v=rW4vm0-DLYc 

 C++ 코드

C ++ code

class MyStack {
    queue<int>q;
public:
    /** Initialize your data structure here. */
    MyStack() {
        
    }
    
    /** Push element x onto stack. */
    void push(int x) 
    {
        q.push(x);
        for (int i=0; i<q.size()-1; i++)
        {
            q.push(q.front());
            q.pop();
        }        
    }
    
    /** Removes the element on top of the stack and returns that element. */
    int pop() 
    {
        int result=q.front();
        q.pop();
        return result;
    }
    
    /** Get the top element. */
    int top() 
    {
        return q.front();
    }
    
    /** Returns whether the stack is empty. */
    bool empty() 
    {
        return q.empty();
    }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * bool param_4 = obj.empty();
 */

* 참고 링크 : https://github.com/wisdompeak/LeetCode/blob/master/Stack/225.Implement-Stack-using-Queues/225.Implement%20Stack%20using%20Queues.cpp

 출처

https://leetcode.com/problems/implement-stack-using-queues/submissions/

Evaluate Reverse Polish Notation

 문제 설명

Evaluate the value of an arithmetic expression in Reverse Polish Notation.

Valid operators are +, -, *, and /. Each operand may be an integer or another expression.

Note that division between two integers should truncate toward zero.

It is guaranteed that the given RPN expression is always valid. That means the expression would always evaluate to a result, and there will not be any division by zero operation.

* 역폴란드 표기법 : https://ko.wikipedia.org/wiki/역폴란드_표기법

 제한 사항

• 1 <= tokens.length <= 104
• tokens[i] is either an operator: "+", "-", "*", or "/", or an integer in the range [-200, 200].

 입출력 예

Example 1:

Input: tokens = ["2","1","+","3","*"]
Output: 9
Explanation: ((2 + 1) * 3) = 9

더보기

Example 2:

Input: tokens = ["4","13","5","/","+"]
Output: 6
Explanation: (4 + (13 / 5)) = 6

더보기

Example 3:

Input: tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
Output: 22
Explanation: ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

 Python 코드

Python code 

class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        stack = []
        for t in tokens:
            if t not in {"+", "-", "*", "/"}:
                stack.append(int(t))
            else:
                b, a = stack.pop(), stack.pop()
                if t == "+": stack.append(a + b)
                elif t == "-": stack.append(a - b)
                elif t == "*": stack.append(a * b)
                else: stack.append(trunc(a / b))
        return stack[0]

* 참고 링크 : https://dev.to/seanpgallivan/solution-evaluate-reverse-polish-notation-192l

* 설명 참고 링크 : https://www.youtube.com/watch?v=P8xYysvjLd0 

 C++ 코드

C ++ code

int evalRPN(vector<string>& tokens)
{
    stack<int>st;
    for(auto it : tokens)
    {
        if(it=="+" || it=="-" || it=="*" || it=="/"  )
        {
            int f = st.top();st.pop();
            int s = st.top();st.pop();

            if (it == "+")
              { int r = s + f;  st.push(r); }
            else if (it == "*")
              { int r = s * f;  st.push(r); }
            else if (it == "-")
              { int r = s - f;   st.push(r); }
            else if (it == "/")
              { int r = s / f;   st.push(r); }
        }
        else{ st.push( stoi(it)); }
    }
    return st.top();
}

* 참고 링크 : https://leetcode.com/problems/evaluate-reverse-polish-notation/discuss/1234191/c-easy-optimized-solution-150-evaluate-reverse-polish-notation

 출처

https://leetcode.com/problems/evaluate-reverse-polish-notation/

IAM이란?

IAM(Identity and Access Management)은 AWS 리소스에 대한 액세스를 안전하게 제어할 수 있는 웹 서비스입니다. IAM을 사용하여 리소스를 사용하도록 인증(로그인) 및 권한 부여(권한 있음)된 대상을 제어합니다.

 출처

https://docs.aws.amazon.com/ko_kr/IAM/latest/UserGuide/introduction.html

1. udemy 홈페이지 접속

https://www.udemy.com/

2. 수강을 원하는 강의 들어가기

3. 우측 하단에 CC라고 되어있는 아이콘 마우스로 클릭

4. CC - 자막설정 [Caption settings] 마우스로 클릭

5. 자막설정 [Caption settings] - 동영상 아래 표시 [Display under video] 체크

6. 동영상 강의 아래 자막 확인

7. CC 옆에 문서모양 클릭하여 동영상 강의 전체 자막(Transcript) 확인

8. 동영상 강의 전체 자막(Transcript)에서 마우스 우클릭하여 한국어로 번역 선택

9. F12 Key로 개발자 모드로 들어간 다음 아래 코드 입력 후 Enter

if(typeof window.i==='undefined'){clearInterval(window.i)}
else{
let lastText='';
function check(){
let toEl=$('.well--container--2edq4 span');
let fromEl=$('p[data-purpose="transcript-cue-active"] span');
let currentText=fromEl.html();
if(lastText!==currentText){toEl.html(currentText)}lastText=fromEl.html()}window.i=setInterval(check,200)
}

10. Code 입력 후 Enter 친 다음 숫자가 나오면 성공적으로 적용된 것으로 다시 강의로 돌아와도 한국어로 번역되어 플레이됨

* 참고 링크 1 : https://fomaios.tistory.com/entry/Udemy-%EC%8B%A4%EC%8B%9C%EA%B0%84-%ED%95%9C%EA%B8%80-%EC%9E%90%EB%A7%89%EC%9C%BC%EB%A1%9C-%EB%B3%B4%EB%8A%94-%EB%B0%A9%EB%B2%95featChrome

* 참고 링크 2 : https://liberspiritus.tistory.com/14

============================================================================

https://chrome.google.com/webstore/detail/yakuu-automatic-subtitle/mfjgefhkaljdlpmnnfcaebgmchfhakcf?utm_source=chrome-ntp-icon 

2022.01.20 (목) 기준으로 크롬에서 한글로 번역 되었다가 말았다가 하네요.

edge로는 번역된게 적용이 잘되고 있습니다. 

크롬이 안되신다면 edge로 강의 들으시길 바랍니다.

MyBatis(마이바티스)란?

MyBatis (마이바티스)는  XML 설명자 또는 주석 을 사용하여 저장 프로시저 또는 SQL 문과 개체를 연결 하는 Java 지속성 프레임워크

 MyBatis(마이바티스) 특징 1

• MyBatis는 SQL을 별도의 파일로 분리해서 관리
• 객체-SQL 사이의 파라미터 Mapping 작업을 자동으로 해줌
• MyBatis는 개발자가 익숙한 SQL을 그대로 이용하면서 JDBC 코드 작성의 불편함도 제거
• 도메인 객체나 VO 객체를 중심으로 개발이 가능하다는 장점이 있음

* Domain Object (도메인 객체) - 개발하고자 하는 영역을 분석하고, 그 분석의 결과로 도출된 객체들을 의미

* Value Object (VO 객체) - DTO의 읽기 버전 (VO는 출력 : Read Only)

MyBatis(마이바티스) 특징 2

1. 쉬운 접근성과 코드의 간결함

• 가장 간단한 퍼시턴스 프레임워크
• XML 형태로 서술된 JDBC 코드라고 생각해도 될 만큼 JDBC의 모든 기능을 MyBatis가 대부분 제공
• 복잡한 JDBC코드를 걷어내며 깔끔한 소스코드를 유지할 수 있음
• 수동적인 파라미터 설정과 쿼리 결과에 대한 맵핑 구문을 제거할 수 있음

2. SQL문과 프로그래밍 코드의 분리

• SQL에 변경에 있을 때마다 자바 코드를 수정하거나 컴파일하지 않아도 된다.

3.  다양한 프로그래밍 언어로 구현가능

• Java, C#, .NET, Ruby

MyBatis와 MyBatis-Spring을 사용한 DB Access Architecture

• 개발자가 지정한 SQL, 저장 프로시저 그리고 몇 가지 고급 매핑을 지원하는 SQL Mapper
• JDBC로 처리하는 상당 부분의 코드와 파라미터 설정 및 결과 매핑을 대신해준다.

• 기존에 JDBC를 사용할 때는 DB와 관련된 여러 복잡한 설정(Connection)들을 다루어야 했지만 SQL Mapper는 자바 객체를 실제 SQL문에 연결함으로써, 빠른 개발과 편리한 테스트 환경을 제공한다.
• 데이터베이스 record에 원시 타입과 Map 인터페이스 그리고 자바 POJO를 설정해서 매핑하기 위해 xml과 Annotation을 사용할 수 있다.
  
  

장점
- SQL에 대한 모든 컨트롤을 하고자 할때 매우 적합하다.
- SQL쿼리들이 매우 잘 최적화되어 있을 때에 유용하다.

단점
- 애플리케이션과 데이터베이스 간의 설계에 대한 모든 조작을 하고자 할 때는 적합하지 않다.
- 애플리케이션과 데이터베이스 간에 서로 잘 구조화되도록 많은 설정이 바뀌어야 하기 때문이다.

 MyBatis를 사용하는 Data Access Layer

• MyBatis는 Data Access Layer에서 사용하는 framework
• Controller에서 Service 호출
• Service가 DAO 계층에 있는 method를 호출하면 DAO에서 MyBatis를 호출

 MyBatis의 주요 컴포넌트

SqlSession Factory Builder가 Config File을 읽고 Factory를 생성해준다. 개발자가 DB에 insert하거나 Read하는 메서드를 호출하면 SqlSession Factory가 SqlSession를 생성하고 개발자가 작성한 Application코드에 반환해준다.

SqlSession은 개발자가 작성한 SQL문을 호출해주는 기능을 해준다고 생각하면된다.

(1) Appication에서 SqlSession Factory Builder라고 하는 interface 호출

(2) SqlSession Factory Builder가 MyBatis Config File 정보를 읽음

(3) SqlSession Factory Builder가 SqlSession Factory 생성

(4) 개발자가 Appication에 있는 DB Access하는 READ하거나 INSERT하는 Method를 호출

(5) SqlSession Factory를 Appication 상에서 호출

(6) SqlSession Factory가 SqlSession이라는 컴포넌트 생성

(7) SqlSession을 개발자가 작성하는 Appication Code에 retrun(반환) 해줌

- return 받아서 SqlSession에 있는 Method 호출

(8) SqlSession은 핵심 기능으로 볼 수 있으며 개발자가 작성한 SQL문(Mapping File)을 호출해줌

 MyBatis의 주요 컴포넌트의 역할

 출처

• MyBatis 정의 : https://en.wikipedia.org/wiki/MyBatis
• MyBatis 특징 & 주요 컴포넌트 & Data Access Layer : https://www.youtube.com/watch?v=9b5P4YiyqOY 
• MyBatis와 MyBatis-Spring을 사용한 DB Access Architecture : https://gmlwjd9405.github.io/2018/12/25/difference-jdbc-jpa-mybatis.html
• Domain Object & Value Object : https://sb.pe.kr/7312

+ 강의 교재

1. MyBatis 홈페이지 접속

https://blog.mybatis.org/

2. Products →  Project → MyBatis 3 download link 마우스로 클릭

3. mybatis-3.5.9 → Assets → mybatis-3.5.9.zip 파일 다운로드

4. mybatis-3.5.9.zip 압축 해제 후 mybatis-3.5.9.jar 파일 확인

5. Eclipse에서 자바 프로젝트 생성 → 생성된 프로젝트 마우스로 우클릭 → [Build Path] → [Configure Build Path ...]

순으로 클릭

6. [Libraries] → [Add External JARs...] 마우스로 클릭

7. ojdbc6_g.jar 파일 열기

* 경로 : C:\oraclexe\app\oracle\product\11.2.0\server\jdbc\lib

해당 경로는 버전에 따라 다를 수 있음

8. [Libraries] → [Add External JARs...] 다시 마우스로 클릭

9. mybatis-3.5.9.jar 파일 열기

10.  [Libraries] → ojdbc6_g.jar & mybatis-3.5.9.jar 확인 → Apply and Close 버튼 마우스로 클릭

11. Reterenced Libraries에 mybatis-3.5.9.jar와 ojdbc6_g.jar 생성 여부 확인

주식가격

 문제 설명

초 단위로 기록된 주식가격이 담긴 배열 prices가 매개변수로 주어질 때, 가격이 떨어지지 않은 기간은 몇 초인지를 return 하도록 solution 함수를 완성하세요.

 제한 사항

• prices의 각 가격은 1 이상 10,000 이하인 자연수입니다.
• prices의 길이는 2 이상 100,000 이하입니다.

 입출력 예

 Python 코드

from collections import deque

def solution(prices):
    queue = deque(prices)  # prices로 queue를 초기화
    answer = []
    
    
    # 반복문 돌면서 앞에서부터 하나씩 popleft 한 뒤의 남은 queue를 순회하며 값이 작아지기 전까지
    # 초를 증가시키는 것을 queue가 빌때까지 반복
    while queue:
        price = queue.popleft() 
        sec = 0
        for q in queue:
            sec += 1
            if price > q:
                break 
        answer.append(sec)        
    return answer

* 참고 링크 : https://velog.io/@soo5717/%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%A8%B8%EC%8A%A4-%EC%A3%BC%EC%8B%9D%EA%B0%80%EA%B2%A9-Python

def solution(prices):
    answer = [0] * len(prices)
    stack = []

    for i, price in enumerate(prices):

        while stack and price < prices[stack[-1]]:
            j = stack.pop()
            answer[j] = i - j
        stack.append(i)

    while stack:
        j = stack.pop()
        answer[j] = len(prices) - 1 - j

    return answer

* 참고 링크 : 

def solution(prices):
    # answer = 몇초 후 가격이 떨어지는지 저장하는 배열
    answer = [len(prices)-i-1 for i in range(len(prices))]
    
    # stack = prices의 인덱스를 차례로 담아두는 배열
    stack = [0]
    
    for i in range(1, len(prices)):
        while stack:
            index = stack[-1]
            
            # 주식 가격이 떨어졌다면
            if prices[index] > prices[i]:
                answer[index] = i - index
                stack.pop()
            
            # 떨어지지 않았다면 다음 시점으로 넘어감 (주식 가격이 계속 증가하고 있다는 말)
            else:
                break
        
        # 스택에 추가한다.
        # 다음 시점으로 넘어갔을 때 다시 비교 대상이 될 예정이다.
        stack.append(i)
        
    return answer

* 참고 링크 : https://tngusmiso.tistory.com/34

 C++ 코드

#include <string>
#include <vector>
#include <stack>

using namespace std;

vector<int> solution(vector<int> prices) {
    vector<int> answer(prices.size());
    stack<int> s;
    int size = prices.size(); // 계속 size를 계산하는 것보다 상수값으로 저장하면 전체 함수 처리 시간 감소
    
    for (int i = 0; i < size; ++i){
        while (!s.empty() && prices[s.top()] > prices[i]){ // 가격이 줄어들었다면
            answer[s.top()] = i - s.top(); // 현재 시간 - 당시 시간
            s.pop();
        }
        s.push(i);
    }
    while (!s.empty()){
        answer[s.top()] = size - 1 - s.top(); // 종료 시간 - 당시 시간
        s.pop();
    }
    
    return answer;
}

* 참고 링크 : https://ssocoit.tistory.com/15

 출처

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