메모장

위 링크는 첫번째 결과값을 작동원리를 설명했으니 나는 정렬한 두번째 값(10 10 10 20 20 30)으로 설명을 해보겠다.

//unique함수 원문
template <class ForwardIterator>
  ForwardIterator unique (ForwardIterator first, ForwardIterator last)
  {
  if (first==last) return last;

  ForwardIterator result = first;
  while (++first != last)
  {
    if (!(*result == *first))  // or: if (!pred(*result,*first)) for version (2)
      *(++result)=*first;
  }
  return ++result;
}//출처 : https://www.cplusplus.com/reference/algorithm/unique/

  if (first==last) return last;

first iter와 last iter가 같은경우는 원소가 1개 이하라는 뜻이므로 end() 값을 리턴

while 반복문에 들어와서 

 if (!(*result == *first)) , if조건문이 있는데  result와 first가 같으므로 true에 !를 만나 false를 반환

다시 while 반복문의 조건을 확인해서 계속 roop 시키면 ......

 if (!(*result == *first)의 true임으로 if문이 동작한다.

*first 가 가르키고 있는 20의 data를 result의 다음 반복자(++result)에 data를 정의하는것이다. 

그럼 vector의 [1] index의 data는 10-> 20으로 변경된다. 그리고 이 과정을 while이 false가 나올때까지 반복하게 되면  

중복 되지 않은 원소는 전부 앞으로 정렬하게 되고, 중복된 원소들은 뒤로 밀리게 되며 반환되는 return 값은 현재 가르키고있는 result의 다음 iter 값이 반환된다. 즉, unique함수의 return값은 쓰게기값(중복값)들이 모여있는 첫번째 인덱스를 iter를 반환하게 된다. 

이 점을 이용하여 unique한뒤 erase함수로 현재 반환 받은 값에서부터 end() 까지 지워버리면 

10 20 30 만 남게 되는것이다. 

이 문제는 규칙에 의한 이진 변환시 roop 돌은 횟수와 roop를 돌면서 지운 0의 갯수를 구하는 문제이다.

<플로우 차트>

1.0 제거하기

1-1.문자열 s안에 있는 0과 1을 내림차순 정렬 하기

1-2. 문자열의 0의 첫번째 index값을 찾음

1-3. index값 반환에 성공한경우 if문 동작해서 0을 제거

2. 0을 제거한 문자열 s의 길이 체크후 이진변환

2-1. 문자열을 2로 계속 나눠서 이진 변환시키기

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

using namespace std;

vector<int> solution(string s) {
    vector<int> answer;
    int roop = 0; //roop를 돈 횟수 
    int zero_del = 0; //roop를 돌면서 지워진 0의 갯수
	
    //s이 "1"이되면 roop 종료 
    while (s != "1")
    {
        int zero_index = 0;

        //1. 0제거하기
        sort(s.rbegin(), s.rend());//내림차수 정렬 ex)111100000
        zero_index = s.find("0");
		
        //0을 찾을경우 if문 동작
        if (zero_index != -1)
        {
            zero_del += s.length() - zero_index; // 현재 roop에서 지운 0의 갯수 카운트
            s.erase(s.begin() + zero_index, s.end());
            //문자열의 0 첫번째 index(s.begin() + zero_index) , 문자열 끝index를 지워주면 1만 남게된다.
        }
       

        //2. 0을 제거한 s의 길이 체크후 이진변환
        int zero_del_str = s.length();
        s = ""; //s문자열 초기화 

        while (zero_del_str != 0)
        {
        //10진수를 2진수로 변환하는 방법
            s += to_string(zero_del_str % 2);
            zero_del_str /= 2;
        }
        reverse(s.begin(), s.end());// s문자열 원소를 뒤집어 원하는값으로 바꾸기 
        roop++; //1회 roop
    }


    return { roop,zero_del};
}

이진수를 vector<bool>값으로 나타냈으며 , 반복문 while에 들어가기전 for_each문을 사용하여 문자열s의 값을 vector<bool> 이진수 로 변경을 하였고 반복문에서 반복작업을 하였다. 

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

vector<int> solution(string s)
{
    int zeros{ 0 }, num_transform{ 0 };
    vector<bool> bin;

    for_each(s.cbegin(), s.cend(), [&bin](const char c) {bin.emplace_back(c == '1'); });  //s를 이진수로 변환

    while (true)
    {
        if (bin == vector<bool>{true})
            break;
        
        int ones = count(bin.cbegin(), bin.cend(), true);    //1갯수를 셈
        zeros += bin.size() - ones;                          //0갯수를 셈
        bin.clear();
        
        while (ones > 0)
        { 
            bin.emplace_back(ones % 2);
            ones /= 2; 
        }//1갯수를 2진수로 바꿈. 순서는 거꾸로지만 계산에는 영향없음
        
        ++num_transform;                                   //이진변환 횟수 기록
    }

    return { num_transform,zeros };
}

현재 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;
}