땡땡

[C언어와 C++언어의 차이점에 대해 설명해보아라]

• C는 절차 지향적 언어이고 해야할 작업을 순서대로, 함수 단위로 구성되며 기능별로 묶어놓은 특징이 있다.
• C++은 C언어를 확장시킨 언어이며 객체 지향적 언어로 상속과 다형성을 특징으로 들 수 있습니다. 클래스를 활용하여 각각의 기능별로 구성이 가능하며 이를 나중에 하나로 합쳐서 프로그램의 완성이 가능하다. 객체 별로 개발이 가능하기에 팀 프로젝트를 하기에도 유리한 장점을 가지고 있다. 또한 코드의 재사용이 가능하며 오류 발생 가능석이 적고 안정성이 높다.
• C언어에서는 같은 이름을 가진 함수가 존재할 수 없지만, C++에서는 가능하다.(오버로딩, 오버라이딩)
• C언어에서는 변수, 함수를 초기에 작성해야 하지만, C++에서는 중간에 어디서든 선언이 가능하다.

[malloc()과 new의 차이점]

• malloc()은 함수이고 new는 연산자 입니다. 
• malloc()은 시스템 함수로서 함수안에서 메모리를 할당하지만 new는 연산자로 바로 메모리를 할당하는 것이 아니라 생성자를 호출해서 메모리를 할당합니다.  생성자를 통해서 호출하기 때문에 new로 메모리를 할당하면 생성 시 초기화가 가능한 장점이 있습니다. 

[클래스(class)와 구조체(struct)의 차이점]

• 구조체는 하나의 구조로 묶일수 있는 데이터, 즉 변수들의 집합
• 클래스는 변수 뿐만 아니라 함수(메서드)까지 포함시킬 수 있다는 점.
• 하지만 C에서도 함수포인터를 이용해 구조체를 클래스화 시킬수 있다.

[프로세스와 스레드의 차이점 ]

• 프로세스는 실행되고 있는 프로그램을 말합니다. 프로세스는 운영체제로부터 독립된 시간, 공간 자원을 할당 받아 실행된다.
• 스레드는 프로세스 내에서 실행되는 흐름 단위로 한 프로세스 내에서 많은 자원을 공유하면서 병렬적으로 실행된다.

[스레드에서 동기화란 무엇이며 어떠한 경우에 사용하는가?]

• 다중 스레드에서 하나의 자료에 접근할 때 사용한다.
• 사건이 동시에 일어나거나, 일정한 간격을 두고 일어나도록 시간의 간격을 조정하는 것입니다. 
• 예를 들면, 은행에서 돈을 인출할때 동시 출금 요청이 가능하다면 한쪽에서 출금 처리가 완료 될 때까지 다른 한쪽은 동기화 처리를 해서 기다리게 하는것. 

[포인터]

• 포인터랑 메모리 주소를 저장하는 변수입니다.
• 예를 들면, 엘레베이터에서 포인터는 해당 층을 표시하는 버튼이며, 10층 버튼을 누르면 10으로 이동하듯이 해당 위치를 가르키고 있는 변수이다.

[Call by reference와 Call by value ]

• Call by reference는 매개변수로 원래 주소 값을 전달하는 방식
• Call by value는 매개변수로 기본 데이터 형을 사용하는 것 주어진 값을 복사하여 처리하는 방식으로 함수 내의 처리결과는 함수 밖의 변수에는 영향을 미치지 않는다.

[오버로딩(overloading)과 오버라이딩(overriding)의 차이점]

• 오버로딩이랑 함수의 이름만 같고 매개변수를 다르게 한 것을 말하고
• 오버라이딩은 상속의 개념에서 나온것인데 부모클래스에서 선언된 함수를 자식클래스에서 재정의 하는 것을 말합니다.

[상속에 대해 설명하시오]

• 상속은 기존의 클래스를 토대로 해서 새로운 클래스를 만드는 방법이라고 할 수 있다.
• 클래스 A가 클래스 B를 상속받게 만들면 클래스 B는 “부모 클래스”가 되고, 클래스 A는 “자식 클래스”가 된다.
• is-a 관계가 성립되어야한다(~은 ~이다.) 예를 들어 사람과 학생의 관계를 생각해보자(Person-Student)
  • Person is a student : “사람”은 “학생”이다. 이것은 성립이 X. 모든 사람이 학생일수는 X. 
  • Student is a person : “학생”은 “사람”이다. 이것은 성립이 O. 그래서 우리가 상속 클래스를 만들 때, Student 클래스는 자식클래스로 Person 클래스를 상속할 수 있는 것이다.
• 부모 클래스는 자식 클래스에게 자신의 모든 멤버 변수와 함수를 물려준다. 물론 OOP에서는 물질적인 것 뿐만 아니라, 어떤 기본적인 사람의 특성들도 상속의 특성이 될 수 있다.
• 상속받는 클래스를 만들기 위해서 class Student : public [상속할 클래스 이름] 이런식으로 상속이라는 문법을 사용할 수 있다. 
• 상속을 사용한 프로그램은 메모리 공간 할당 -> 부모 클래스의 생성자 실행 -> 자식 클래스의 생성자 실행이라는 순서를 가지게 된다.

[Abstract Class(추상 클래스)에 대해 설명하시오]

• 추상메서드를 하나 이상 가진 클래스이다.
• 자신의 생성자로 객체 생성이 불가능하다. 그 이유는 몸체도 정의되어 있지 않은 추상  클래스의 객체를 만든다는 것은 아무런 의미가 없기 때문.  하지만 추상 클래스의 포인터는 선언이 가능하다.
• 순수가상함수가 하나라도 선언되어있다면 그 클래스는 추상 클래스.
• 하위 클래스를 참조하여 상위 클래스의 객체를 생성한다.
• 하위 클래스를 제어하기 위해 사용한다.

[가상함수와 순수가상함수의 차이점 (virtual void func(); 와 virtual void func() = 0;)]

• 객체포인터 변수에 부모클래스와 자식클래스를 담았을 때 오버라이딩된 함수를 실행하게되면 무조건 부모함수를 실행하게된다. 자식클래스에서 재정의한 의미가 없어짐. 그렇기 때문에 virtual이라는 키워드를 사용하여 가상함수로 만들게 된다면 객체포인터 변수에서 각각 해당하는 클래스의 함수를 호출하게 됨.
• 만약 부모클래스에서 재정의 할 함수 앞에 virtual 키워드를 사용하면 자식클래스는 키워드를 적지 않아도 컴파일러에서 자동으로 가상 함수로 정의가 된다. 하지만 소스 코드의 이해를 돕기 위해 자식클래스에서도 virtual 키워드를 적는 것이 관례.
• 순수가상함수는 가상함수와 달리 함수의 선언만 있고 정의는 없는것으로, 자식 클래스에서 반드시 재정의하여야만 한다. 재정의 하지 않는다면 오류 발생.
• 예를 들면 동물은 먹는다, 잔다, 울다 등의 행동을 가지고 있기 때문에 동물 클래스를 상속받는 자식클래스들은 항상 이 행위들을 가지고 있어야 한다. 개는 멍멍, 고양이는 야옹 등등..

[Virtual table (가상 테이블)에 대해서 설명하시오]

• 클래스 안에 가상함수가 포함되어 있을시 객체를 생성할 때 가상함수를 가리키는 포인터가 생성된다.
• 이 포인터는 가상테이블의 시작주소를 가리키는 포인터고, 각 클래스마다 하나의 고유 가상테이블이 생성되게 됩니다.
• 고유의 가상테이블은 가상함수를 가리키는 함수포인터배열로 되어있다. 즉, 가상 함수를 실행하려면 vptr-> vtable -> func() 를 호출하게 되는 것

[재귀함수에 대해 설명하시오]

• 재귀함수란 함수 내에서 자기 자신을 다시 호출하는 형태
• 장점 : 소스코드의 간결화가 가능하다.
• 단점 : 연산 시간이 오래 걸린다. 또한, 잘못 작성시 프로그램이 무한루프에 빠질 수 있다.

출처/참고 : https://91ms.tistory.com/4?category=711086 

출처/참고 : https://j2hworld.tistory.com/55

문제 설명

길이가 같은 배열 A, B 두개가 있습니다. 각 배열은 자연수로 이루어져 있습니다.
배열 A, B에서 각각 한 개의 숫자를 뽑아 두 수를 곱합니다. 이러한 과정을 배열의 길이만큼 반복하며, 두 수를 곱한 값을 누적하여 더합니다. 이때 최종적으로 누적된 값이 최소가 되도록 만드는 것이 목표입니다. (단, 각 배열에서 k번째 숫자를 뽑았다면 다음에 k번째 숫자는 다시 뽑을 수 없습니다.)

예를 들어 A = [1, 4, 2] , B = [5, 4, 4] 라면

• A에서 첫번째 숫자인 1, B에서 첫번째 숫자인 5를 뽑아 곱하여 더합니다. (누적된 값 : 0 + 5(1x5) = 5)
• A에서 두번째 숫자인 4, B에서 세번째 숫자인 4를 뽑아 곱하여 더합니다. (누적된 값 : 5 + 16(4x4) = 21)
• A에서 세번째 숫자인 2, B에서 두번째 숫자인 4를 뽑아 곱하여 더합니다. (누적된 값 : 21 + 8(2x4) = 29)

즉, 이 경우가 최소가 되므로 29를 return 합니다.

배열 A, B가 주어질 때 최종적으로 누적된 최솟값을 return 하는 solution 함수를 완성해 주세요.

제한사항

• 배열 A, B의 크기 : 1,000 이하의 자연수
• 배열 A, B의 원소의 크기 : 1,000 이하의 자연수

입출력 예

코드

#include <algorithm>

int solution(vector<int> A, vector<int> B)
{
    int answer = 0;

    sort(A.begin(), A.end());                 // 오름차순 정렬
    sort(B.begin(), B.end(), greater<int>()); // 내림차순 정렬
    
    for(int i = 0; i < A.size(); i++)
    {
        answer += A[i] * B[i] ;
    }
    
    return answer;
}

문제 설명

괄호가 바르게 짝지어졌다는 것은 '(' 문자로 열렸으면 반드시 짝지어서 ')' 문자로 닫혀야 한다는 뜻입니다. 예를 들어

• "()()" 또는 "(())()" 는 올바른 괄호입니다.
• ")()(" 또는 "(()(" 는 올바르지 않은 괄호입니다.

'(' 또는 ')' 로만 이루어진 문자열 s가 주어졌을 때, 문자열 s가 올바른 괄호이면 true를 return 하고, 올바르지 않은 괄호이면 false를 return 하는 solution 함수를 완성해 주세요.

제한사항

• 문자열 s의 길이 : 100,000 이하의 자연수
• 문자열 s는 '(' 또는 ')' 로만 이루어져 있습니다.

입출력 예

코드#1

bool solution(string s)
{
    bool answer = false;
    int size = s.size();
    int check = 0;
    
    for(int i = 0 ; i< size; i++)
    {
        if(s[i] == '(')  check++;
        if(check > 0)
        {
            if(s[i] == ')')  check--;
        }
    }
    
    //첫 시작이'(' , 끝이 ')'
    if(check == 0 && s[0] == '(' && s[size-1] == ')') answer = true;
    
    return answer;
}

코드#2 : Stack 활용

#include <stack>

bool solution(string s)
{
    stack <char> stk;
    bool answer = false;
    int size = s.size();
    
    for(int i = 0; i < size; i++)
    {
        if(s[i] == '(') stk.push(s[i]);
        else 
        {
            if(!stk.empty() && stk.top() == '(') stk.pop();
            else                                 stk.push(s[i]);
        }
    }
    
    if(stk.empty()) answer = true;

    return answer;
}

1. 생성

헤더 파일 : <string>

①  string str("abcd");  // 바로 생성

②  string str1;                 // 선언 후 값 주기

      str1 = "abcd";

③  string str2(str1);

* 문자열 끝에 null이 들어가지 않는다.

2. 인자 접근

① str.at(index);

해당 위치(index)에 해당하는 문자를 반환한다. index가 범위를 벗어나면 예외 리턴.

함수 예시 : str.at(0);    // "Hello" -> 'H'를 리턴

② str.operator[index]

일반 배열처럼 대괄호를 이용해서 인자에 접근 가능하다. 

해당 위치(index)에 해당하는 문자를 반환한다.

*at과 다른 점 : index(인덱스) 범위를 검사하지 않기 때문에 at 함수보다는 빠르다.

하지만 예외를 리턴하지 않는다. 

함수 예시: str[0];    // "Hello" -> 'H'를 리턴

③ str.front();

맨 앞 인자를 반환한다.

함수 예시: str.front();    // "Hello" -> 'H'를 리턴

④ str.back();

맨 뒤 인자를 반환한다.

함수 예시: str.back();    // "Hello" -> 'o'를 리턴

3. size 관련 함수

① str.size();

사이즈를 반환한다.

함수 예시: str.size();    // "Hello" -> 5를 리턴

② str.length();

길이를 반환한다. (size()와 같다고 생각하면 된다.)

함수 예시: str.length();    // "Hello" -> 5를 리턴

③ str.capacity();

할당된 메모리 크기(bytes)를 반환한다.

메모리 할당을 size(길이)에 대비해서 여유롭게 한다.

size(길이)가 capacity(메모리)를 넘게 될 때 새롭게 더 큰 capacity(메모리)를 할당한다.

함수 예시 : str1.capacity();    // "HelloHello" size(길이)는 10, capacity(메모리)는 15

함수 예시 : str2.capacity();    // "HelloHelloHelloH" size(길이)는 16, capacity(메모리)는 31

④ str.resize(n); , str.resize(n,c);

string을 n만큼의 크기로 만든다. 

만약 그 크기가 원래 사이즈보다 작다면, 남은 스트링을 버린다.  

만약 그 크기가 원래 사이즈 보다 크다면, 빈 공간으로 남은 공간을 채운다.

만약 c를 사용한다면 남은 공간을 c로 채울 수 있다.

함수 예시 : str.resize(5)          // "HelloHello" -> "Hello" size는 5

함수 예시 : str.resize(6)          // "Hello" -> "Hello " size는 6, 제일 뒤에 빈칸

함수 예시 : str.resize(10, 'v') // "Hello" -> "Hello vvvv" 

⑤ str.shrink_to_fit();

string 길이에 비해 낭비되고 있는 capacity(메모리)를 줄이는 함수이다.

함수 예시 : str.resize(5);                // "HelloHelloHelloH" 

                                                                  > "Hello" size(길이)는 5지만  capacity(메모리)는 여전히 31

함수 예시 : str.shrink_to_fit();    // "Hello"처럼 size(길이) 5가 된 string의 capacity(메모리)에

                                                                    알맞게 str의 capacity(메모리)가  31->15으로 줄어든다.

⑥ str.reserve(n);

string을 넣기 전, 미리 n만큼의 size(길이)에 맞는 capacity(메모리)를 할당하는 함수이다.

⑦ str.clear();

 스트링에 들어있는 문자열을 지우는 함수이다. 

이때, size와 length는 0이 되고, capacity는 그대로 남게 됩니다.

함수 예시 : str.clear();    // "Hello" -> "" 

                                                    size와 lenth는 0이 되고, capacity(메모리)는 15 그대로 이다.

                                                    (메모리 해제X)

⑧ str.empty();

스트링이 비었는지 확인하는 함수이다. 비었으면 true를 반환한다. 

비었음의 기준은 size, length가 0인 것 이다. capacity(메모리)와는 관계가 없다.

함수 예시 : if(str.empty()) { return true; }  

4. 

① str.c_str();

C++의 string 문자열을 C의 문자열로 변경해주는 함수이다.

함수 예시 : const char* arr = str.c_str();    // "HelloHello" -> "HelloHello\0"로 반환.

② str.substr(); , str.substr(index); , str.substr(index, len);

string을 잘라서 반환하는 함수이다.

함수 예시 : str.substr();            // "HelloHello" 그대로 반환.

함수 예시 : str.substr(6);         // "ello"를  반환. index 5 번째 인자부터 끝까지의 string을 반환.

함수 예시 : str.substr(6, 1);    // "e"를 반환. 5번째 인자부터, 1의 길이만큼 string을 반환.

③ str.replace(index, len, str2);

string의 index위치에서 len 길이까지의 범위를 매개변수로 들어온 str2 전체로 대체 하는 함수이다.

함수 예시 : str1.replace(5, 2, str2);

// "HelloHello"의 5번째 인자에서부터 2개를 str2("AAAA")로 대체한다.

     -> "HelloAAAAllo" 로 변경
함수 예시 : str1.replace(str1.find("AAAA"), 2, "He");

// "HelloAAAAllo"에서 "AAAA"를 찾아 "He"로 대체한다.

     -> "HelloHello" 로 변경

④ str.compare(str2); 

매개변수로 들어온 str을 비교해서 같으면 0을 반환하고, 다르면 0이 아닌 값을 반환하는 함수이다.

매개변수로 들어온 스트링의 값보다 작을때(사전순 빠를때) 음수(0보다 작은값)를 반환하고 ,

매개변수로 들어온 스트링의 값보다 클때(사전순 느릴때) 양수(0보다 큰값)를 반환한다.

함수 예시 : str1.compare(str2);

// str1("Hello"), str2("HiHi")는 같지 않기 때문에 0이 아닌 값을 반환하고,

     H까지는 둘이 똑같고, 그다음 str1의 "e"와, str2의 "i"를 비교한다.

    이때, "e"가 "i"보다 사전상 더 앞선글자이기 때문에 str1이 더 작은 글자가 된다.

    그렇기 때문에 음수(0보다 작은값)를 반환하게 된다.

함수 예시 : str1.compare("Hello");

// str1("Hello")와 "Hello"는 같기 때문에 0을 반환한다.

함수 예시 : str1.compare(0, 1, str2);

// str1("Hello")의 0번째 인덱스 부터 길이가 1인 문자열 "H"와 

     str2("HiHi) 를 비교한다. 두 문자열이 다르기 때문에 0이 아닌 수를 반환합니다.

함수 예시 : str1.compare(0, 1, str2, 0, 1);   

// str1("Hello")의 0번째 인덱스 부터 길이 1인 문자열 "H"와 

     str2("HiHi")의 0번째 인덱스 부터 길이 1인 문자열 "H"를 비교한다.

     비교할 문자열이 같기 때문에 0을 반환한다.

⑤ str1.copy(arr, len, index);

복사를 하는 함수이다.

함수 원형 : size_t copy(char* arr, size_t len, size_t index = 0) const;

첫번째 매개변수 : char* 인걸 보면, C언어의 문자열(배열타입)을 받습니다. 

두번째 매개변수 : 복사할 문자열의 길이

세번째 매개변수 : 복사를 시작할 위치

return 값 :  실제로 복사된 길이, arr의 길이를 반환합니다.

함수 예시 :  char arr[10];                                          // 문자열을 복사해서 넣을 빈 배열을 만듭니다.

                      int arrLen = str1.copy(arr, 3, 2);    // index 2부터 3의 길이만큼 복사 -> "Hello"   

                                                                                             실제로 복사된 길이 3 반환

                      arr[arrLen] = '\0';                                 // C의 문자열의 끝에는 '\0'

⑥ str.find(str2); , str.find(str2, index);

매개변수로 들어온 문자열과 일치하는 게 있는지 확인하는 함수이다.  

만약에 일치하는게 있다면, 일치하는 부분의 첫번째 순서(index)를 반환한다.

두번째 매개변수로 들어온 index는 찾을 위치.

함수 예시 : str1.find("Hello");         // str1("HelloHello") 와 "Hello"를 비교

                                                                      -> 일치하는 부분의 첫번째 순서(index)인 0을 반환

함수 예시 : str1.find("Hello", 5);    // str1("HelloHello") 와 "Hello"를 5번째 인자부터 비교

                                                                       -> 일치하는 부분의 첫번째 순서(index)인 5를 반환

⑦ str.push_back(c);

함수를 호출하는 스트링의 맨뒤에 문자 c를 더하는 함수 이다.

함수 예시 : str.push_back('a');      //"HelloHello" -> "HelloHelloa"

⑧ str.pop_back();

함수를 호출하는 스트링의 맨뒤에 있는 문자 하나를 없애는 함수 이다.

함수 예시 : str.pop_back();            //"HelloHelloa" -> "HelloHello"

5. iterator 종류

① str.begin();

문자열의 첫 번째 문자를 가리키는 반복자(iterator 포인터)를 반환

② str.end();

문자열의 마지막의 바로 다음을 가리키는 반복자(iterator 포인터)를 반환

5. 기타 등등

① swap(str1, str2)

str1과 str2를 바꾸는 함수. 서로 참조(reference)를 교환해서 스왑을 한다.

함수 예시 : swap(str1, str2);       // str1("Hello") ,str2("HiHi") -> str1("HiHi"), str2("Hello")

② operator+

이어붙이기

함수 예시 : str1 += str2;                // str1("HiHi") += str2("Hello") = str1("HiHiHello") 

*[개발자 지망생]님 블로그를 보고 공부하며 제가 보기 편하게 정리 한 글 입니다.*

출처: https://blockdmask.tistory.com/338 [개발자 지망생]

문제 설명

피보나치 수는 F(0) = 0, F(1) = 1일 때, 1 이상의 n에 대하여 F(n) = F(n-1) + F(n-2) 가 적용되는 수 입니다.

예를들어

• F(2) = F(0) + F(1) = 0 + 1 = 1
• F(3) = F(1) + F(2) = 1 + 1 = 2
• F(4) = F(2) + F(3) = 1 + 2 = 3
• F(5) = F(3) + F(4) = 2 + 3 = 5

와 같이 이어집니다.

2 이상의 n이 입력되었을 때, n번째 피보나치 수를 1234567으로 나눈 나머지를 리턴하는 함수, solution을 완성해 주세요.

제한 사항

• n은 2 이상 100,000 이하인 자연수입니다.

입출력 예

입출력 예 설명

피보나치수는 0번째부터 0, 1, 1, 2, 3, 5, ... 와 같이 이어집니다.

코드

int solution(int n) {
    int fibo[100001];
    int answer = 0;
    
    fibo[0] = 0;
    fibo[1] = 1;
    
    for(int i = 2 ; i<= n; i++)
    {
        fibo[i] = fibo[i-1] + fibo[i-2];
        fibo[i] = fibo[i] % 1234567;
    }
    
    answer = fibo[n];
    
    return answer;
}

문제 설명

명함 지갑을 만드는 회사에서 지갑의 크기를 정하려고 합니다. 다양한 모양과 크기의 명함들을 모두 수납할 수 있으면서, 작아서 들고 다니기 편한 지갑을 만들어야 합니다. 이러한 요건을 만족하는 지갑을 만들기 위해 디자인팀은 모든 명함의 가로 길이와 세로 길이를 조사했습니다.

아래 표는 4가지 명함의 가로 길이와 세로 길이를 나타냅니다.

명함 번호가로 길이세로 길이

가장 긴 가로 길이와 세로 길이가 각각 80, 70이기 때문에 80(가로) x 70(세로) 크기의 지갑을 만들면 모든 명함들을 수납할 수 있습니다. 하지만 2번 명함을 가로로 눕혀 수납한다면 80(가로) x 50(세로) 크기의 지갑으로 모든 명함들을 수납할 수 있습니다. 이때의 지갑 크기는 4000(=80 x 50)입니다.

모든 명함의 가로 길이와 세로 길이를 나타내는 2차원 배열 sizes가 매개변수로 주어집니다. 모든 명함을 수납할 수 있는 가장 작은 지갑을 만들 때, 지갑의 크기를 return 하도록 solution 함수를 완성해주세요.

제한사항

• sizes의 길이는 1 이상 10,000 이하입니다.
  • sizes의 원소는 [w, h] 형식입니다.
  • w는 명함의 가로 길이를 나타냅니다.
  • h는 명함의 세로 길이를 나타냅니다.
  • w와 h는 1 이상 1,000 이하인 자연수입니다.

입출력 예

코드

int solution(vector<vector<int>> sizes) 
{
    int answer = 0;
    
    int max_w = 0, max_h = 0;	// 최대 w, h 크기
    int dump = 0;
    int size = sizes.size();
    
    for(int i = 0; i < size; i++)
    {
        if(sizes[i][0] < sizes[i][1])
        {
           dump = sizes[i][0];
           sizes[i][0] = sizes[i][1];
           sizes[i][1] = dump;
        }
        if(max_w < sizes[i][0]) max_w = sizes[i][0];
        if(max_h < sizes[i][1]) max_h = sizes[i][1];
    }
    
    answer = max_w*max_h;
    
    return answer;
}

문제 설명

네오와 프로도가 숫자놀이를 하고 있습니다. 네오가 프로도에게 숫자를 건넬 때 일부 자릿수를 영단어로 바꾼 카드를 건네주면 프로도는 원래 숫자를 찾는 게임입니다.

다음은 숫자의 일부 자릿수를 영단어로 바꾸는 예시입니다.

• 1478 → "one4seveneight"
• 234567 → "23four5six7"
• 10203 → "1zerotwozero3"

이렇게 숫자의 일부 자릿수가 영단어로 바뀌어졌거나, 혹은 바뀌지 않고 그대로인 문자열 s가 매개변수로 주어집니다. s가 의미하는 원래 숫자를 return 하도록 solution 함수를 완성해주세요.

참고로 각 숫자에 대응되는 영단어는 다음 표와 같습니다.

숫자영단어

제한사항

• 1 ≤ s의 길이 ≤ 50
• s가 "zero" 또는 "0"으로 시작하는 경우는 주어지지 않습니다.
• return 값이 1 이상 2,000,000,000 이하의 정수가 되는 올바른 입력만 s로 주어집니다.

입출력 예

코드

int solution(string s) {
    int answer = 0;
    string dump = "";
    int size = s.size();

    for (int i = 0; i < size; i++)
    {
        if (s[i] >= '0' && s[i] <= '9') dump.push_back(s[i]);
        if (s.find("zero", i)  == i)    dump.push_back('0');
        if (s.find("one", i)   == i)    dump.push_back('1');
        if (s.find("two", i)   == i)    dump.push_back('2');
        if (s.find("three", i) == i)    dump.push_back('3');
        if (s.find("four", i)  == i)    dump.push_back('4');
        if (s.find("five", i)  == i)    dump.push_back('5');
        if (s.find("six", i)   == i)    dump.push_back('6');
        if (s.find("seven", i) == i)    dump.push_back('7');
        if (s.find("eight", i) == i)    dump.push_back('8');
        if (s.find("nine", i)  == i)    dump.push_back('9');
    }

    answer = stoi(dump);

    return answer;
}

문제 설명

어떤 정수들이 있습니다. 이 정수들의 절댓값을 차례대로 담은 정수 배열 absolutes와 이 정수들의 부호를 차례대로 담은 불리언 배열 signs가 매개변수로 주어집니다. 실제 정수들의 합을 구하여 return 하도록 solution 함수를 완성해주세요.

제한사항

• absolutes의 길이는 1 이상 1,000 이하입니다.
  • absolutes의 모든 수는 각각 1 이상 1,000 이하입니다.
• signs의 길이는 absolutes의 길이와 같습니다.
  • signs[i] 가 참이면 absolutes[i] 의 실제 정수가 양수임을, 그렇지 않으면 음수임을 의미합니다.

입출력 예

코드

int solution(vector<int> absolutes, vector<bool> signs) 
{
    int answer = 0;
    int size = absolutes.size();
    
    for(int i = 0 ; i< size; i++)
    {
        if(signs[i]) answer+=absolutes[i];
        else         answer-=absolutes[i];
    }
    
    return answer;
}