배열

문1. 배열 정렬하기

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

using namespace std;

vector<int> solution(vector<int> arr) {
    sort(arr.begin(), arr.end());
    return arr;
}

int main() {
  vector<int> v = {1, 3, 5, 7, 2, 4, 6, 7, 7, 9, 5};

  auto a = solution(v);
  for (auto b : a) {
    cout << b << " ";
  }

  return 0;
}

 

문2. 배열 제어하기

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

using namespace std;

int compare(int a, int b) { // 정렬 기준 정의
  return a > b;
}

vector<int> solution(vector<int> lst) {
  sort(lst.begin(), lst.end(), compare); // 내림차순으로 정렬
  lst.erase(unique(lst.begin(), lst.end()), lst.end()); // 중복값 제거

  return lst;
}

int main() {
  vector<int> v = {1, 3, 5, 7, 2, 4, 6, 7, 7, 9, 5};

  auto a = solution(v);
  for (auto b : a) {
    cout << b << " ";
  }

  return 0;
}

compare() 함수는 앞의 숫자가 뒤의 숫자보다 클 때 참이므로 역순으로 정렬

 

문3. 두 수를 뽑아서 더하기

#include <iostream>
#include <vector>
#include <set>

using namespace std;

vector<int> solution(vector<int> numbers) {
  set<int> sum; // 두 수의 합을 저장할 저장 공간 선언
  
  for(int i = 0; i < numbers.size(); ++i) // 반복문을 수행하면서 두 수의 합을 저장
    for(int j = i + 1; j < numbers.size(); ++j)
      sum.insert(numbers[i] + numbers[j]);

  vector<int> answer(sum.begin(), sum.end()); // 반환 타입을 맞추기 위해 벡터로 변환
  return answer;
}

int main() {
  vector<int> v = {2, 1, 3, 4, 1};

  auto a = solution(v);
  for (const auto& b : a) {
    cout << b << " ";
  }

  return 0;
}

set을 사용한 이유? 중복값을 자동으로 제거, 오름차순으로 데이터를 정렬해주기 때문

 

문4. 모의고사

 

* 모듈러 연산으로 반복 패턴 표현 예제

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

using namespace std;

int main() {
  vector<string> days = {"월", "화", "수", "목", "금", "토", "일"};

  for (int i = 0; i <= 30; ++i) {
    cout << days[i % days.size()] << endl;
  }

  return 0;
}

 

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

using namespace std;

// 각 수포자가 찍는 패턴 정의
vector<int> firstPattern = {1, 2, 3, 4, 5};
vector<int> secondPattern = {2, 1, 2, 3, 2, 4, 2, 5};
vector<int> thirdPattern = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};

vector<int> solution(vector<int> answers) {
  vector<int> answer; // 가장 많이 문제를 맞힌 사람이 저장될 벡터
  // 각 수포자들의 패턴대로 답안을 작성할 때 문제를 맞힌 개수를 저장할 벡터
  vector<int> matchCnt(3);
  // 실제 정답과 각 수포자들의 패턴을 비교해서 맞힌 개수
  for (int i = 0; i < answers.size(); i++) {
    if (answers[i] == firstPattern[i % firstPattern.size()])
      matchCnt[0]++;
    if (answers[i] == secondPattern[i % secondPattern.size()])
      matchCnt[1]++;
    if (answers[i] == thirdPattern[i % thirdPattern.size()])
      matchCnt[2]++;
  }
  // 가장 많이 맞힌 수포자가 얻은 점수
  int max_score = *max_element(matchCnt.begin(), matchCnt.end());
  // 가장 많이 맞힌 수포자의 번호를 저장
  for (int i = 0; i < 3; i++) {
    if (matchCnt[i] == max_score)
      answer.push_back(i + 1);
  }

  return answer;
}

int main() {
  vector<int> v = {1, 2, 3, 4, 5};

  auto a = solution(v);
  for (const auto& b : a) {
    cout << b << " ";
  }

  return 0;
}

 

문5. 행렬의 곱셈

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

using namespace std;

vector<vector<int>> solution(vector<vector<int>> arr1, vector<vector<int>> arr2) {
  // 최초 행렬 곱의 결과를 저장할 벡터 선언
  vector<vector<int>> answer;

  // arr1과 arr2의 행렬 곱을 수행했을 때 최종 행렬의 크기만큼 공간을 할당
  answer.assign(arr1.size(), vector<int>(arr2.size(), 0));

  // arr1의 각 행과 arr2의 각 열에 대해 반복문 수행
  for (int i = 0; i < arr1.size(); i++) 
    for (int j = 0; j < arr2[1].size(); j++)
      for (int k = 0; k < arr2.size(); k++)
        answer[i][j] += arr1[i][k] * arr2[k][j]; // 두 행렬의 곱을 수행

  return answer;
}

int main() {
  vector<vector<int>> v1 = {{1, 4}, {3, 2}, {4, 1}};
  vector<vector<int>> v2 = {{3, 3}, {3, 3}};

  auto a = solution(v1, v2);
  for (const auto& row : a) {
      for (const auto& element : row) {
          cout << element << " ";
      }
      cout << endl;
  }

  return 0;
}

 

문6. 실패율★

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

using namespace std;

// 문제에서 요구하는 조건대로 실패율을 정렬하는 함수
bool compare(pair<int, float>& a, pair<int, float>& b) {
    if (a.second == b.second)
        return a.first < b.first;
    return a.second > b.second;
}

vector<int> solution(int N, vector<int> stages) {
    vector<int> answer; // 최종 답
    vector<float> challenger(N + 2, 0.0); // 각 스테이지에 도달한 적이 있는 도전자의 수
    vector<float> fail(N + 2, 0.0); // 특정 스테이지에 실패한 도전자의 수

    // 각 스테이지의 인원을 기준으로 특정 스테이지에서
    // 실패한 인원수와, 각 스테이지에 도전한 적이 있는 인원수를 구함
    for (int i = 0; i < stages.size(); i++) {
      for (int j = 1; j < stages[i]; j++) 
        challenger[j]++;
    
      fail[stages[i]]++;
    }
    // failRatio는 실패율을 저장, first는 stage정보이고 second는 실패율
    vector<pair<int, float>> failRatio(N);

    // 스테이지 정보 및 실패율을 저장
    for (int i = 0; i < N; i++) {
        failRatio[i].first = i + 1;

        if (challenger[i + 1] == 0)
            failRatio[i].second = 0;
        else
            failRatio[i].second = fail[i + 1] / challenger[i + 1];
    }

    // 계산한 실패율을 문제에서 제시한 조건에 맞게 정렬
    sort(failRatio.begin(), failRatio.end(), compare);

    // 최종 답을 반환하기 위해 실패율을 저장
    for (int i = 0; i < N; i++) {
        answer.push_back(failRatio[i].first);
    }
    
    return answer;
}

int main() {
    int n = 5;
    vector<int> s = {2, 1, 2, 6, 2, 4, 3, 3};
    
    auto a = solution(n, s);
    for (const auto& b : a) {
          cout << b << " ";
    }
    
    return 0;
}