메모장

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

using namespace std;

//1.메인벨트와  적재 박스 비교
//2.같은경우 벨트와 적재박스 큐에서 제외 후 ,answer증가
//3.다른경우 서브벨트 top과 비교해서 같은경우 stack과queue에서 제외후 answer증가
//3.둘다 다른경우 서브벨트에 적재

int solution(vector<int> order) {
    int answer = 0;

    queue<int> q_order; // 기사님이 원하는 택배 순서
    queue<int> main_belt;// 메인 컨테이너벨트
    stack<int> sub_belt; // 서브 컨테이너벨트
    
    //택배차의 원하는 택배순서를 queue로 저장
    for (int i = 0; i < order.size(); i++)
    {
        main_belt.push(i + 1); 
        q_order.push(order[i]); 
    }

    while (!q_order.empty())
    {
        //메인 벨트의 택배와 택배차의 order list와 비교
        if (!main_belt.empty() && q_order.front() == main_belt.front())
        {
            answer++;
            q_order.pop();
            main_belt.pop();
        }
        //서브 벨트의 택배와 택배차의 order list와 비교
        else if (!sub_belt.empty() && q_order.front() == sub_belt.top())
        {
            answer++;
            q_order.pop();
            sub_belt.pop();
        }
        //메인 벨트의 서브 벨트 둘다 택배가 없는경우
        else
        {
            //메인 벨트에 택배가 있으면 서브벨트에 해당 택배를 보관 후 다시 순회
            if (!main_belt.empty())
            {
                sub_belt.push(main_belt.front());
                main_belt.pop();
            }
            //메인 벨트에 택배가 없으면 더이상 할 수 없으므로 탈출후 반환
            else { return answer; }
        }

    }

    return answer;
}

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

using namespace std;

int solution(vector<int> topping) {
    int answer = 0;
    
    //A라는 사람의 topping map
    map<int,int>  map_A;
    //A의 빵에 모든 토핑을 올려놓기
    for (int elements : topping)
    {
        map<int, int> ::iterator iter = map_A.find(elements);

        if (iter != map_A.end()) iter->second++;
        else  map_A.insert({ elements,1 });
    }
    
     //A라는 사람의 topping map
    map<int, int> map_B;
    
     //토핑의 갯수만큼 순회를 하며 A의 토핑을 B한테 하나씩 주며 체크하기
    for (int i = 0; i < topping.size(); i++)
    {
        int pivot = topping[i];
 
        //map_A의 원소 제거 (B한테 하나 주기)
        map<int, int> ::iterator iter = map_A.find(pivot);
        if (iter != map_A.end())
        {
            iter->second--;
            if (iter->second <= 0) map_A.erase(iter);
        }

        //map_B의 원소 추가 (A한테서 받은 토핑 추가하기)
        iter = map_B.find(pivot);
        if (iter != map_B.end()) iter->second++;
        else  map_B.insert({ pivot,1 });

        //각 토핑의 map갯수가 같은지 체크 
        if (map_A.size() == map_B.size()) answer++;
    }

    return answer;
}

[재귀함수 장점] -> 가독성 Up

1.변수의 사용을 줄일 수 있다.

2.알고리즘 자체가 재귀함수에 어울리는 경우 ex)Tree 

[재귀함수 단점] -> 시간증가 , 스택오버플로우 발생 

1.함수를 호출이 반복적으로 일어나기에 시간이 반복문보다 더 걸릴 수 있다.

2.함수 호출시마다 스택영역에 메모리가 쌓여서 결국 스택 오버 플로우 발생이 된다.

#include <string>
#include <vector>
#include <array>
#include <algorithm>
#include<cmath>
using namespace std;

int solution(int x, int y, int n) 
{
    int answer = 0;

    vector<int> dp;
    for (int i = 0; i < y + 1; i++) { dp.push_back(-1); }//dp 배열 data값을 전부 -1 초기화

    dp[x] = 0; // 초기 시작값 설정
   
    for (int i = x; i < y + 1; i++)
    {
        //해당 dp[i]에는 접근하지 않았기에 넘어감
        if (dp[i] == -1) continue;

        if (i * 2 <= y)
        {
            //계산한 값이 -1이면 접근하지 않았기에 바로 dp에 계산값을 초기화
            if (dp[i * 2] == -1) { dp[i * 2] = dp[i] + 1; }//해당 dp자리에 연산 횟수data가 있는경우 최소값을 골라서 초기화
            else { dp[i * 2] = min(dp[i] + 1, dp[i * 2]); }
        }

        if (i * 3 <= y)
        {
            if (dp[i * 3] == -1) { dp[i * 3] = dp[i] + 1; }
            else { dp[i * 3] = min(dp[i] + 1, dp[i * 3]); }
        }

        if (i + n <= y)
        {
            if (dp[i + n] == -1) { dp[i + n] = dp[i] + 1; }
            else { dp[i + n] = min(dp[i] + 1, dp[i + n]); }

        }
    }
    //dp배열 길이만큼 순회 후 dp[y]에 도달한 연산 횟수 값을 반환 
    return dp[y];
}

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

using namespace std;

vector<long long> solution(vector<long long> numbers) {
    vector<long long> answer;
    
    for(long long i =0; i < numbers.size() ; i++)
    {
        long long number = numbers[i];
        long long index_0 = 0; //처음보는 0의 index
        
        //number를 이진법으로 변환하며 처음 만나는 0 찾기
        while(number > 0)
        {
            if(number % 2 == 0) { break; } // 해당 이진법의 자리가 0인경우 탈출
            index_0++; //0이 아닌경우 index가 증가함
            number *= 0.5;
        }

        //0뒤의 숫자1의 index를 알아야하기 때문에 -1을 계산
        if(index_0 > 0) { index_0 -= 1;} 

        //number에 더해줄 2^count 를 구함
        long long sum = 1;
        for(long long i =0; i< index_0; i++) {  sum *= 2;}
        
        answer.push_back(numbers[i] + sum);
    }
    return answer;
}

현재 index와 다음 index 값을 비교해서 다를경우,

answer에 현재 index값을 저장 후 roop를 진행한다.

index+1 했을때 arr의 size보다 크거나 같을경우 마지막 숫자를 answer에 추가하면서

반복문을 탈출한다.

#include <vector>
#include <iostream>

using namespace std;

vector<int> solution(vector<int> arr) 
{
    vector<int> answer;
	
    //arr의 갯수만큼 roop
    for(int i = 0 ; i< arr.size() ; i++)
    {
    	//배열이 범위를 벗어나지 않게 하기위한 조건문
        if( i+1 >= arr.size())
        {
            answer.push_back(arr[i]);
            break;
        }
        
        //현재 index와 다음 index가 다를경우 값을 저장 
        if(arr[i] != arr[i+1])
        {
            answer.push_back(arr[i]);
        }
    }
    
    return answer;
}

algorithm헤더의 unique함수와 std::vector의 erase 함수 두개를 활용하면 해당 배열의 원소 중 중복값을 없앨수 있다.

unique 함수 : 배열에서 원소를  앞에서부터 채워나가며 채운 함수중에 중복이 있으면 뒤로 보내는 함수이다.

unique함수는 중복되지 않은 값들을 나열 한뒤 남은 중복 원소의 첫번째 iterator 값을 반환, 

unique함수를 사용하기전에 sort 함수를 하여 정렬할 필요가 있다.

(unique함수로부터 반환된 iterator , 배열의 끝  iterator) 범위를 eraser함수하면
함수 고유의 값들만 남아있다. 

하지만 이 문제는 함수의 순서를 바꾸지 말라고 하였기에 sort함수를 사용하지 않고 바로 unique함수를 활요한 것이다.

#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

vector<int> solution(vector<int> arr) 
{
	//vector 에서 중복되는 함수들을 한곳에 모아 삭제할때 쓰는 구조다.
    arr.erase(unique(arr.begin(), arr.end()),arr.end());

    vector<int> answer = arr;
    return answer;
}

2개의 벡터가 주어지는데 각 벡터의 원소들을 곱하고서 그 합의 최솟값을 구하는 문제이다.
즉, (첫번째 작은 값 * 첫번째 큰 값) + (두번째 작은 값 * 두번째 큰 값) + .... = 최솟값 이 나온다 

2개의 벡터에 하나는 오름차순으로 정렬 하나는 내림차순으로 정렬한뒤

반복문을 이용하여 작은값 * 큰값을 roop할 수 있게 해주면된다.

#include <iostream>
#include<vector>
#include<algorithm>
using namespace std;

int solution(vector<int> A, vector<int> B)
{
    int answer = 0;
    
    sort(A.begin(),A.end());
    sort(B.begin(),B.end());
    reverse(B.begin(),B.end());

    
    //양쪽 벡터에서 가장 작은 숫자 하나와 가장큰숫자를 골라서 곱한다.
    
    for(int i=0; i< A.size(); i++)
    {
        answer += A[i] * B[i];
    }

    return answer;
}

#include <vector>
#include <numeric>
#include <algorithm>
using namespace std;
int solution(vector<int> A, vector<int> B){
    sort(A.begin(),A.end());  sort(B.rbegin(),B.rend());
    return inner_product(A.begin(),A.end(),B.begin(),0);
}

 익숙하지 않은 명령어들이 있어서 정리하려고 가져왔다.

*inner_product();

numeric 헤더에 포함된 명령어이며, 내적을 구할때 사용하는 명령어이다.

inner_product(시작값A,마지막값A,시작값B,초기값) 으로 사용된다. 

예제 코드 및 추가적인 내용은 밑에 링크 확인

https://01149.tistory.com/14

*rbegin(),rend()

std::vector 자료형의 내림차순 정렬이 필요할때 , rbegin, rend 함수를 활용하면 가독성 좋은 코드를 짤 수 있다. 

예제 코드 및 추가적인 내용은 밑에 링크 확인

https://01149.tistory.com/15

#include <string>
#include <vector>

using namespace std;

int solution(vector<int> a, vector<int> b) {
    int answer = 0;
    
    for(int i=0; i < a.size() ; i++)
    {
        answer += a[i] * b[i];
    }
    
    return answer;
}

0~9 까지의 숫자중 nuebers vector에 없는 원소를 다 더하는 문제다.

0.사전준비

0-1. 0~9의 list 만들기

0-2.numbers를 오름차순으로 정렬하기

1.list와 nubers의 원소를 비교하여 없는 원소 합 구하기

1-1.list와 number의 원소값이 다른경우 list의 현재 index값을 answer에 더한다.

1-2.list의 index만 증가시키고 다시 비교 후 원소값이 같지 않으면 1-1 반복, 같은경우 반복문을 진행

1-3.numbers의 index가 사이즈와 같거나 큰 경우 list와 비교하지 않은 원소들을 전부 answer에 더한다.

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

using namespace std;

int solution(vector<int> numbers) {
    int answer = 0;
    vector<int> list = {0,1,2,3,4,5,6,7,8,9};
    
    sort(numbers.begin(),numbers.end());
    
    for(int i=0 , j=0; i< list.size() ; i++,j++)
    {
        if(j >= numbers.size())
        {
           answer += list[i];
            continue;
        }
        
        while(list[i] != numbers[j])
        {
            answer += list[i];
            i++;
        }
    }
    
    return answer;
}

숫자의 범위는 0~9까지 변동이 없기 때문에 총합은 45로 고정되어있다.
numbers에서 총합45를 하나씩 빼면 남는 숫자는 numbers의 제외된 숫자의 총합이기 때문에 이렇게 간단히 쓸수있다.

나의 풀이는 각 어떤 원소가 남이있는지에 중점을 두다 보니 이렇게 코드를 짯다. 하지만 원하는건 제외된 숫자의 총합이기 떄문이다. 다음에 문제를 풀때는 원하는 값이 무엇인지 더욱 생각해야될듯하다. 

#include <string>
#include <vector>

using namespace std;

int solution(vector<int> numbers) {

    int answer = 45;

    for (int i = 0 ; i < numbers.size() ; i++)
        answer -= numbers[i];

    return answer;
}