#include <string>
#include <vector>

using namespace std;

string solution(string my_string, int k) {
    string answer = "";
    
    for(int i=0; i<k; i++){
        answer += my_string;
    }
    
    return answer;
}

#include <string>
#include <vector>

using namespace std;

string solution(vector<string> arr) {
    string answer = "";
    
    for(int i=0; i<arr.size(); i++){
        answer += arr[i];
    }
    
    return answer;
}

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

using namespace std;

string solution(string str1, string str2) {
    string answer = "";
    
    for(int i=0; i<str1.length(); i++){
        answer += str1[i];
        answer += str2[i];
    }
    
    return answer;
}

이 코드와

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

using namespace std;

string solution(string str1, string str2) {
    string answer = "";
    
    for(int i=0; i<str1.length(); i++){
        answer += str1[i] + str2[i];
    }
    
    return answer;
}

이 두개 코드의 차이점을 솔직히 잘 모르겠다 왜..안될까..

1번째는 각 스트링에서 배열값으로 문자를 1개씩 차례대로 answer에 넣는건 알겠다 1번이 답이니까

근데 2번째 코드도 str1과 str2의 각 원소를 더해서 answer에다가 2개씩 집어넣는것 아닌가?..

라고 생각했지만 문자열끼리 더해버리면 아스키코드의 값으로 더해버린다고한다. 그래서 코드에 오류가 나고 더해지지않은것. 중요한거 배웠다ㅎㅎ

결국 1번쨰는 문자를 1개씩 넣어서 문자열을 만들어가는거고

2번째는 문자끼리 더해버려서 아스키코드의 값으로 변환되어 다른 문자로 변해버린다.

# 추억 점수

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

using namespace std;

vector<int> solution(vector<string> name, vector<int> yearning, vector<vector<string>> photo) {
vector<int> answer;

map<string, int> name_score;

for(int i=0; i<name.size(); i++){
    name_score[name[i]] = yearning[i]; //key 이름, 추억 점수
}
for(int i=0; i<photo.size(); i++){
    int sum = 0;
    for(int j=0; j<photo[i].size(); j++){
        sum += name_score[photo[i][j]]; //점수가 있으면 총점에 추가
    }
    answer.push_back(sum);
	}
return answer;
}

추억점수에서의 문제를 풀때 나의 문제점은 현재 vector가 2중으로 사용되면서 2중배열로 사용된다는것을 처음 알게 되었다.

동적으로 배열을 할당해서 사용하는것. 그리고 push_back에 대한 개념도 더 공부해야겠다..

**using namespace std;**는 C++ 프로그래밍에서 매우 흔하게 사용되는 문장 중 하나입니다. 이 문장은 C++ 표준 라이브러리의 모든 요소를 현재의 코드 범위에서 사용 가능하게 해주는 역할을 합니다. 아래에서 자세히 설명하겠습니다.

C++에서 **std**는 "Standard"의 줄임말로, C++ 표준 라이브러리에 정의된 다양한 기능과 객체들을 포함하는 네임스페이스(namespace)입니다. 이 표준 라이브러리는 문자열 처리, 입출력, 컨테이너(배열, 벡터, 리스트 등), 알고리즘 등 다양한 기능을 제공합니다.

그런데, C++에서는 네임스페이스를 사용하여 식별자(변수, 함수 등)가 충돌하는 것을 방지합니다. 예를 들어, 여러 라이브러리나 사용자 정의 코드에서 같은 이름의 함수나 변수를 사용하는 경우 충돌이 발생할 수 있습니다. 따라서 표준 라이브러리의 요소를 사용할 때, C++에서는 해당 요소들을 std 네임스페이스 안에 묶어두었습니다.

using namespace std; 문장은 이러한 std 네임스페이스를 현재의 코드 범위에 가져오는 역할을 합니다.

즉, 이 문장을 사용하면 **std::**를 붙이지 않고도 표준 라이브러리의 요소를 사용할 수 있습니다.

예를 들어, **std::cout**은 표준 출력 스트림을 나타내는데, **using namespace std;**를 사용하면 아래와 같이 간단하게 사용할 수 있습니다.

#include <iostream>int main() {
    cout << "Hello, World!" << endl;
    return 0;
}

하지만, 네임스페이스를 가져오는 것은 식별자 충돌을 피하기 위해 사용하는 좋은 방법이 아닐 수 있습니다. 특히 큰 프로젝트에서는 식별자 충돌 문제를 디버깅하기 어려울 수 있으므로, 좋은 프로그래밍 습관 중 하나는 using namespace std; 대신 필요한 표준 라이브러리 요소만 선택적으로 가져오는 것입니다. 예를 들어, **using std::cout;**와 같이 필요한 것만 네임스페이스에서 가져와 사용할 수 있습니다. 이렇게 하면 코드의 가독성을 높이고 충돌 가능성을 줄일 수 있습니다.

챗 gpt에게 물어봤지만 C++ 에서의 표준 라이브러리의 모든 요소를 현재의 코드 범위에서 사용 가능하게 해주는 역할이라고 한다.

std가 무슨뜻인지 몰랐지만 Standard라는 뜻이 있는것도 처음 알게됐다

다양한 기능과 객체들을 포함하는 네임스페이스(namespace) 라고 하는데 문자열 처리, 입출력, 컨테이너, 알고리즘 등 다양한 기능을 사용할 수 있다고 한다.

사실 using namespace std; 라는 문장을 std:: 를 사용하지않고 편한 사용을 위해서 그냥 그렇게 쓴다고만 알고 있었다.

대부분의 C++수업이나 강의들은 이런 것 들에 대한 자세한 정보를 알려주지 않는다. 필요없는지는 모르겠지만 나는 항상 이런게 왜 이렇게 사용되는지 너무 궁금했다.

처음 Java를 배웠을때도 나와 뜻이 잘 맞는 친구와 static과 new를 사용해서 객체를 생성했을떄의 차이점이 뭔지 너무 궁금해서 1~2시간 정도의 토론을 나누며 결국 답을 찾아냈다.

지금은 당연하게도 너무 쉬운 설명이다. 하지만 친구와 그렇게 코드에대해 자세하게 토론할 수 있는 친구가 있었던게 너무나 고마웠다.

하여튼 앞으로도 뭔가 알고싶은게 있다면 일일이 다 찾아보고 알아내고야 말겠다!

C++ 포인터

주소 연산자 & 주소 연산자 & 를 사용하면 변수에 할당된 메모리 주소를 확인할 수 있다.

#include <iostream>
using namespace std;

int main() {
int x = 5;
cout << x << '\\n';
cout << &x << '\\n';
return 0;
}

역참조 연산자 * 변수의 주소를 얻는 것 자체로는 그다지 유용하지 않다. 역참조 연산자 * 를 사용하면 특정주소에서 값에 접근할 수 있다.

#include <iostream>
#include <cstdio>
using namespace std;

int main() {
int x = 5;
printf("%d\\n", x);
cout << &x << '\\n'; 	//x변수의 메모리 주소 값
cout << *&x << '\\n';	//x 변수의 메모리 주소값에 할당되어있는 값
return 0;
}

포인터 (Pointer) 주소 연산자 7와 역참조 연산자 *와 함께 이제 포인터에 관해 이야기할 수 있다. 포인터는 어떠한 값을 저장하는 게 아닌 메모리 주소를 저장하는 변수다. 포인터(Pointer) 는 C++ 언어에서 가장 혼란스러운 부분 중 하나로 여겨지지만, 알고 보면 놀랍게도 간단하다.

포인터 선언 (Declaring a pointer) 포인터 변수는 일반 변수처럼 선언되며, 자료형과 변수 이름 사이에 *가 붙는다

자료형 *포인터 이름;

int* iPtr;	//int형 포인터
double* dPtr;	//double형 포인터

int* iPtr2, *iPtr3;	//int형 두 개의 포인터 선언

여러 포인터 변수를 선언하는 경우 별표가 각 변수에 포함되어야 한다.

int* iPtr4, iPtr5 //iPtr4는 int에 대한 포인터지만 iPtr5는 단순한 int다.

일반 변수와 마찬가지로 포인터는 선언 시 초기화되지 않는다. 초기화되지 않은 값은 쓰레기다. int 포인터 라고 말하면 int형에 대한 포인터를 의미한다.

포인터에 값 할당 포인터는 메모리 주소만 저장하므로, 포인터에 값을 할당할 때 그 값은 주소여야 한다. 포인터로 하는 가장 흔한 작업은 다른 변수의 주소를 저장하는 것이다. 변수의 주소를 얻으려면 주소 연산자 & 를 사용한다. 포인터 = &변수;

int value = 5; int *ptr = &value; //변수값의 주소로 ptr 초기화

ptr은 값으로 value 변수 값의 주소를 가지고 있다. 그러므로 ptr은 value 변수를 가르키는 값이라고 할 수 있다.

#include <iostream>

int main()
{
int value = 5;
int *ptr = &value; // 변수 값의 주소로 ptr 초기화

std::cout << &value << '\\\\n'; // value 변수의 주소 출력
std::cout << ptr << '\\\\n';    // ptr 변수 값 출력

return 0;

}

// 0012FF7C // 0012FF7C

포인터 변수의 자료형은 가리키는 변수의 자료형과 같아야 한다.

int iValue = 5;
double dValue = 7.0;

int *iPtr = &iValue; // ok
double *dPtr = &dValue; // ok
iPtr = &dValue; // wrong -- int 포인터는 double 변수의 주소를 가리킬 수 없다.
dPtr = &iValue; // wrong -- double 포인터는 int 변수의 주소를 가리킬 수 없다.

다음 사항도 올바르지 않다.

int *ptr = 5;

포인터가 주소만 보유할 수 있고 정수 리터럴 5에는 메모리 주소가 없기 때문이다. 위 코드를 시도하면 컴파일러는 정수를 정수 포인터로 변환할 수 없으므로 오류가 발생한다.

C++에서는 포인터에 리터럴 메모리 주소를 직접 할당할 수 없다.

double *dPtr = 0x0012FF7C; // not okay (정수 리터럴을 할당하는 것으로 취급된다.)

주소 연산자 &는 피연산자의 주소를 리터럴로 반환하지 않는다. 대신 피연산자의 주소가 들어있는 포인터를 반환한다.

포인터는 여러 가지 경우에서 유용하다.

배열은 포인터를 사용하여 구현된다. 포인터는 배열을 반복할 때 사용할 수 있다. (배열 인덱스 대신 사용 가능) C++에서 동적으로 메모리를 할당할 수 있는 유일한 방법이다. (가장 흔한 사용 사례) 데이터를 복사하지 않고도 많은 양의 데이터를 함수에 전달할 수 있다. 함수를 매개 변수로 다른 함수에 전달하는 데 사용할 수 있다. 상속을 다룰 때 다형성을 달성하기 위해 사용한다. 하나의 구조체/클래스 포인터를 다른 구조체/클래스에 두어 체인을 형성하는 데 사용할 수 있다. 이는 연결리스트 및 트리와 같은 고급 자료구조에서 유용하다.

포인터는 내가 컴퓨터의 메모리에 보다 직접적으로 접근해서 이를 제어할 수 잇도록 해주는 도구. 비유하자면 기다란 집게이다.

변수에 입력된 값들은 메모리의 어딘가에 저장된다. 한정된 공간 안아세 변수나 함수들의 값들이 필요에따라 쓰이고 치워지고 하면서 프로그램이 돌아간다 프로그램을 짜다 보면 어느 변수에 지정한 값을 다른 여러곳에 써야 할 때가 있다.

c에서의 어느 함수에 '변수가 인자로 주어질 때는그 값이 복사되어서 , 즉 베껴 적어져서 넘어가게 된다. 복사가 된다는건 메모리의 값이 어딘가의 그 크기만큼 중복된 값이 차지한다. 그렇게 메모리를 낭비하지 않고 페이지 번호만 적어서 보내줄 수 있도록 하는게 포인터 이다.

메모리의 모든 칸에는 각각의 주소가 있다. 위치를 가르킨다는 말은 충분하지 않다. 시작하는 페이지와 줄을 줬으면 어디서 끝나는지도 알아야한다. 변수에 쓰이는 메모리는 어떤 자료형이냐에 따라 크기가 다르다. 정수는 1이든 100이든 천만자리수든 4바이트(32비트)를 차지한다. double도 1.0이란 값에도 8바이트를 차지한다 컴퓨터의 데이터는 수많은 0과 1, 즉 On, OFF로 나뉜다. 메모리의 칸 하나하나가 ON, OFF가 되어 2진수를 만든다

int num = 1;
int y = 100;
int* p1 = #

printf("p1 %d \\n", *p1); 	//일때는 1값이 나오고

p1++ 	//이렇게 포인터에 정수값을 더하면 자로형의 크기 곱하기 그 값만큼
//오른쪽으로 메모리의 값이 이동하게 된다.
//그러면 y값이 나와야 하지 않겠느냐 라고 생각하겠지만
//전혀 다른 값이 나와버린다
p1--	//다시 포인터의 값을 --해주면 원래대로 돌아온다.

int number[] = {1, 2, 3, 4, 5, 6, 7}
int* p2 = &numbers[0];

printf("p2 %d \\n", *p2); 	//일때는 배열의 1번째 즉 1의 값이 나온다.
p2++;		//포인터 값을 증가시키면
printf("p2 %d \\n", *p2); 	//일때는 배열의 2번째 즉 2의 값이 나온다.

포인터는 이런식으로 배열과 연계되어서 사용될 수 있다.

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

using namespace std;

vector<string> solution(vector<string> players, vector<string> callings) {
    vector<string> answer;

    map<string, int> playerC;     
    map<int, string> playerN;
    
    for(int i=0; i<players.size(); i++){
        playerC[players[i]] = i;
        playerN[i] = players[i];
    }
    
    for(int i=0; i<callings.size(); i++){
        int idx = playerC[callings[i]];
        string temp = playerN[idx - 1];
        playerC[callings[i]] = idx - 1;
        playerC[temp] = idx;
        playerN[idx - 1] = callings[i];
        playerN[idx] = temp;
    }
    
    for(auto c : playerN) answer.push_back(c.second);
    return answer;
}

스트래티지 패턴

스트래티지 패턴(Strategy Pattern)은 객체 지향 프로그래밍에서 사용되는 디자인 패턴 중 하나로,
알고리즘을 정의하고 이를 캡슐화하여 동적으로 변경할 수 있는 패턴입니다.
이 패턴을 사용하면 알고리즘을 사용하는 클라이언트 코드와 분리하여 각각 독립적으로 변경하고 확장할 수 있습니다.
주로 전략을 변경해야 하는 경우나, 유사한 여러 알고리즘이 존재할 때 유용하게 쓰입니다.

스트래티지 패턴의 구성 요소:
1. 컨텍스트(Context): 전략 객체를 사용하는 역할로, 실제 사용자가 호출하는 메서드가 포함되어 있습니다.
2. 전략(Strategy): 알고리즘을 추상화한 인터페이스나 추상 클래스입니다.
3. 구체적인 전략(Concrete Strategy)L 실제 알고리즘을 구현한 클래스들 입니다.

스트래티지 패턴 예시 코드:

// 전략(Strategy) 인터페이스
public interface IAttackStrategy
{
    void Attack();
}

// 구체적인 전략(Concrete Strategy) 클래스들
public class MeleeAttackStrategy : IAttackStrategy
{
    public void Attack()
    {
        Console.WriteLine("근접 공격을 수행합니다.");
    }
}

public class RangedAttackStrategy : IAttackStrategy
{
    public void Attack()
    {
        Console.WriteLine("원거리 공격을 수행합니다.");
    }
}

// 컨텍스트(Context) 클래스
public class Character
{
    private IAttackStrategy attackStrategy;

    public void SetAttackStrategy(IAttackStrategy strategy)
    {
        attackStrategy = strategy;
    }

    public void PerformAttack()
    {
        if (attackStrategy != null)
        {
            attackStrategy.Attack();
        }
    }
}

// 클라이언트 코드
class Program
{
    static void Main(string[] args)
    {
        Character warrior = new Character();
        Character archer = new Character();

        warrior.SetAttackStrategy(new MeleeAttackStrategy());
        archer.SetAttackStrategy(new RangedAttackStrategy());

        warrior.PerformAttack(); // Output: 근접 공격을 수행합니다.
        archer.PerformAttack();  // Output: 원거리 공격을 수행합니다.
    }
}

위의 예시 코드에서 IAttackStrategy 인터페이스는 알고리즘을 추상화합니다. 
MeleeAttackStrategy와 RangedAttackStrategy는 이 인터페이스를 구현하여 각각의 공격 방식을 
구체적으로 정의합니다. Character 클래스는 전략을 변경할 수 있는 메서드를 제공하고, 
클라이언트 코드에서 해당 전략을 설정하고 공격을 수행합니다.

스트래티지 패턴을 사용하면 새로운 공격 방식을 추가하거나 기존 공격 방식을 변경해야 할 때, 
기존 코드의 수정 없이 새로운 전략을 추가하거나 교체할 수 있습니다.