private static void life()

MySQL - WSL2 Ubuntu 세팅

lee308812 — Thu, 4 Aug 2022 22:27:40 +0900

1. sudo apt update

2. sudo apt install mysql-server

3. sudo mysql_secure_installation

Securing the MySQL server deployment.

Connecting to MySQL using a blank password.

VALIDATE PASSWORD COMPONENT can be used to test passwords
and improve security. It checks the strength of password
and allows the users to set only those passwords which are
secure enough. Would you like to setup VALIDATE PASSWORD component?

Press y|Y for Yes, any other key for No: n
Please set the password for root here.

New password:

Re-enter new password:
 ... Failed! Error: SET PASSWORD has no significance for user 'root'@'localhost' as the authentication method used doesn't store authentication data in the MySQL server. Please consider using ALTER USER instead if you want to change authentication parameters.

4. sudo mysql - 종료 후, mysql 재실행

5. ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password by 'mynewpassword';

완료

- 서비스 시작 : sudo service mysql start 후 (ps -ef | grep mysqld로 확인)

- 실행 : sudo mysql -uroot -p

lee308812@DESKTOP-OMFP9TN:~$ sudo service mysql start
 * Starting MySQL database server mysqld                                                                                                                                                                                                     su: warning: cannot change directory to /nonexistent: No such file or directory
                                                                                                                                                                                                                                      [ OK ]
lee308812@DESKTOP-OMFP9TN:~$ sudo mysql -uroot -p
Enter password:
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 10
Server version: 8.0.30-0ubuntu0.20.04.2 (Ubuntu)

Copyright (c) 2000, 2022, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>

[프로그래머스] 문자열 압축

lee308812 — Sun, 9 Jan 2022 20:35:52 +0900

문자열 압축

문제 설명

데이터 처리 전문가가 되고 싶은 "어피치"는 문자열을 압축하는 방법에 대해 공부를 하고 있습니다. 최근에 대량의 데이터 처리를 위한 간단한 비손실 압축 방법에 대해 공부를 하고 있는데, 문자열에서 같은 값이 연속해서 나타나는 것을 그 문자의 개수와 반복되는 값으로 표현하여 더 짧은 문자열로 줄여서 표현하는 알고리즘을 공부하고 있습니다.
간단한 예로 "aabbaccc"의 경우 "2a2ba3c"(문자가 반복되지 않아 한번만 나타난 경우 1은 생략함)와 같이 표현할 수 있는데, 이러한 방식은 반복되는 문자가 적은 경우 압축률이 낮다는 단점이 있습니다. 예를 들면, "abcabcdede"와 같은 문자열은 전혀 압축되지 않습니다. "어피치"는 이러한 단점을 해결하기 위해 문자열을 1개 이상의 단위로 잘라서 압축하여 더 짧은 문자열로 표현할 수 있는지 방법을 찾아보려고 합니다.

예를 들어, "ababcdcdababcdcd"의 경우 문자를 1개 단위로 자르면 전혀 압축되지 않지만, 2개 단위로 잘라서 압축한다면 "2ab2cd2ab2cd"로 표현할 수 있습니다. 다른 방법으로 8개 단위로 잘라서 압축한다면 "2ababcdcd"로 표현할 수 있으며, 이때가 가장 짧게 압축하여 표현할 수 있는 방법입니다.

다른 예로, "abcabcdede"와 같은 경우, 문자를 2개 단위로 잘라서 압축하면 "abcabc2de"가 되지만, 3개 단위로 자른다면 "2abcdede"가 되어 3개 단위가 가장 짧은 압축 방법이 됩니다. 이때 3개 단위로 자르고 마지막에 남는 문자열은 그대로 붙여주면 됩니다.

압축할 문자열 s가 매개변수로 주어질 때, 위에 설명한 방법으로 1개 이상 단위로 문자열을 잘라 압축하여 표현한 문자열 중 가장 짧은 것의 길이를 return 하도록 solution 함수를 완성해주세요.

제한사항

s의 길이는 1 이상 1,000 이하입니다.
s는 알파벳 소문자로만 이루어져 있습니다.

입출력 예	result
"aabbaccc"	7
"ababcdcdababcdcd"	9
"abcabcdede"	8
"abcabcabcabcdededededede"	14
"xababcdcdababcdcd"	17

입출력 예에 대한 설명

입출력 예 #1

문자열을 1개 단위로 잘라 압축했을 때 가장 짧습니다.

입출력 예 #2

문자열을 8개 단위로 잘라 압축했을 때 가장 짧습니다.

입출력 예 #3

문자열을 3개 단위로 잘라 압축했을 때 가장 짧습니다.

입출력 예 #4

문자열을 2개 단위로 자르면 "abcabcabcabc6de" 가 됩니다.
문자열을 3개 단위로 자르면 "4abcdededededede" 가 됩니다.
문자열을 4개 단위로 자르면 "abcabcabcabc3dede" 가 됩니다.
문자열을 6개 단위로 자를 경우 "2abcabc2dedede"가 되며, 이때의 길이가 14로 가장 짧습니다.

입출력 예 #5

문자열은 제일 앞부터 정해진 길이만큼 잘라야 합니다.
따라서 주어진 문자열을 x / ababcdcd / ababcdcd 로 자르는 것은 불가능 합니다.
이 경우 어떻게 문자열을 잘라도 압축되지 않으므로 가장 짧은 길이는 17이 됩니다.

[ 내코드 ]

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

using namespace std;

int solution(string s) {
    const size_t len = s.size();
    const size_t halfLen = s.size() / 2;
    int answer = len;

    for (int i = 1; i <= halfLen; i++)
    {
        int localAnswer = 0;

        int baseStartIdx = 0;
        int count = 1;

        for (int j = i; j < len; j += i)
        {
            if (s.substr(baseStartIdx, i) != s.substr(j, i))
            {
                if (count > 1) localAnswer += to_string(count).length();
                count = 1;

                localAnswer += s.substr(j, i).length();
                baseStartIdx = j;
            }
            else
            {
                count++;
            }
        }

        if (count > 1) localAnswer += to_string(count).length();
        localAnswer += i;

        if (answer > localAnswer) answer = localAnswer;
    }

    return answer;
}

[프로그래머스] 로또의 최고 순위와 최저 순위

lee308812 — Sat, 1 Jan 2022 21:20:07 +0900

입출력 예

lottos	win_nums	result
[44, 1, 0, 0, 31, 25]	[31, 10, 45, 1, 6, 19]	[3, 5]
[0, 0, 0, 0, 0, 0]	[38, 19, 20, 40, 15, 25]	[1, 6]
[45, 4, 35, 20, 3, 9]	[20, 9, 3, 45, 4, 35]	[1, 1]

0은 알 수 없는 번호일 때, 나올 수 있는 최고 순위/최저 순위를 출력하는 코드 작성하기.

순위	당첨 내용
1	6개 번호가 모두 일치
2	5개 번호가 일치
3	4개 번호가 일치
4	3개 번호가 일치
5	2개 번호가 일치
6(낙첨)	그 외

#include <string>
#include <vector>

using namespace std;

vector<int> solution(vector<int> lottos, vector<int> win_nums) {
    vector<int> answer;
    return answer;
}

[ 풀이 ]

- 만약 lottos에 있는 한 번호가 win_nums에 존재하는 번호라면, 그 번호는 무조건 모두 일치하는 번호이다.

- 0일 경우, 번호를 일치하게 만들거나 일치하지 않게 만드는 것이 모두 가능하다.

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

using namespace std;

vector<int> solution(vector<int> lottos, vector<int> win_nums) {
    vector<int> answer(2, 0);
    
    for(int item : lottos)
    {
        if(item == 0)
            answer[0]++;
        else
        {
            if(std::find(win_nums.begin(), win_nums.end(), item) != win_nums.end())
            {
                answer[0]++;
                answer[1]++;
            }
        }
    }
    
    for(int& item : answer)
    {
        item = (lottos.size() - item) + 1;
        if(item > 6) item = 6;
    }
    
    return answer;
}

[Leetcode] Binary Tree Inorder Traversal

lee308812 — Tue, 6 Jul 2021 21:23:55 +0900

[ 정답 - 반복 버전 ]

1) 초기 상태

2) 현재 ptr을 포함하여, 더이상 내려갈 수 없을 때까지 왼쪽으로 내려가며 그 위치를 스택에 쌓는다.

3) Stack에서 하나를 꺼내고 정답 vector에 넣는다. 현재 ptr은 Stack에서 마지막에 꺼내진 4를 가리키고 있다.

4) ptr을 현재 가리키고있는 ptr의 우측으로 이동한다. (여기서는 4의 우측 자손이 없으므로 ptr == nullptr일 것이다.)

5) 2),3) 4) 동작을 반복한다.

( 반복 동작 - [Stack이 비어있지 않다 or 현재가 nullptr이 아니다]의 조건을 만족하는 동안 )

현재 ptr == nullptr이므로

- [2) 왼쪽으로 더이상 내려갈 수 없을때까지 왼쪽으로 간다]는 수행되지 않을 것이다.

- [3) 스택에서 하나 꺼내고 정답 vector에 넣는다]가 수행되어 Stack에서 2가 꺼내짐과 동시에 ptr은 2를 가리킬 것이다. 그리고 정답 vector에 2가 들어가게 된다.

- [4) ptr을 현재 가리키고 있는 ptr의 우측으로 이동한다]에 의해 5로 이동할 것이다.

[ 연습용 코드 ]

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>
#include <iostream>
#include <set>

using namespace std;

struct TreeNode
{
	int val;
	TreeNode* left = nullptr;
	TreeNode* right = nullptr;

	TreeNode() : val(0) {}
	TreeNode(int x) : val(x) {}
	TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) { }
};

class Solution {
public:
	vector<int> inorderTraversal(TreeNode* root)
	{
	}
};

int main()
{
	TreeNode n4(4, nullptr, nullptr);
	TreeNode n5(5, nullptr, nullptr);
	TreeNode n6(6, nullptr, nullptr);

	TreeNode n2(2, &n4, &n5);
	TreeNode n3(3, &n6, nullptr);

	TreeNode n1(1, &n2, &n3);

	Solution s;
	vector<int> result = s.inorderTraversal(&n1); // [4 2 5 1 6 3]

	return 0;
}

[ 정답 - 반복 버전 ]

/*
struct TreeNode
{
	int val;
	TreeNode* left = nullptr;
	TreeNode* right = nullptr;

	TreeNode() : val(0) {}
	TreeNode(int x) : val(x) {}
	TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) { }
};
*/

class Solution {
public:
	vector<int> inorderTraversal(TreeNode* root)
	{
		stack<TreeNode*> s;
		vector<int> result;

		TreeNode* now = root;

		while (s.empty() == false || now != nullptr)
		{
			while (now != nullptr)
			{
				s.push(now);
				now = now->left;
			}

			now = s.top();
			s.pop();
			result.push_back(now->val);

			now = now->right;
		}

		return result;
	}
};

[ 정답 - 재귀버전 ]

/*
struct TreeNode
{
	int val;
	TreeNode* left = nullptr;
	TreeNode* right = nullptr;

	TreeNode() : val(0) {}
	TreeNode(int x) : val(x) {}
	TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) { }
};
*/

class Solution {
public:
    vector<int> result;
    
    vector<int> inorderTraversal(TreeNode* root)
    {
        Inorder(root);
        
        return result;
    }
    
    void Inorder(TreeNode* root)
    {
        if(root == nullptr)
            return;
        
        Inorder(root->left);
        result.push_back(root->val);
        Inorder(root->right);
    }
};

[Leetcode] Binary Tree Preorder Traversal

lee308812 — Mon, 5 Jul 2021 21:44:53 +0900

[ 연습용 코드 ]

#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>
#include <iostream>
#include <set>

using namespace std;

struct TreeNode
{
	int val;
	TreeNode* left = nullptr;
	TreeNode* right = nullptr;

	TreeNode() : val(0) {}
	TreeNode(int x) : val(x) {}
	TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) { }
};

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root)
    {
    }
};

int main()
{
	
	TreeNode n3(3, nullptr, nullptr);
	TreeNode n4(4, nullptr, nullptr);

	TreeNode n2(2, &n3, &n4);
	TreeNode n5(5, nullptr, nullptr);

	TreeNode n1(1, &n2, &n5);

	Solution s;
	vector<int> result = s.preorderTraversal(&n1); // [1 2 3 4 5]

	return 0;
}

[ Pre-order : 재귀버전 ]

class Solution {
public:
	vector<int> result;

	vector<int> preorderTraversal(TreeNode* root)
	{
		if (root == nullptr)
			return result;

		result.push_back(root->val);
		preorderTraversal(root->left);
		preorderTraversal(root->right);

		return result;
	}
};

[ Pre-order : 반복문 버전 ]


class Solution {
public:
	vector<int> preorderTraversal(TreeNode* root)
	{
		stack<TreeNode*> s;
		vector<int> result;

		if (root == nullptr)
			return result;

		s.push(root);
		TreeNode* now = nullptr;

		while (s.empty() == false)
		{
			now = s.top();
			s.pop();

			result.push_back(now->val);

			// LIFO 이므로 right를 먼저 넣는다.
			if (now->right) s.push(now->right);
			if (now->left) s.push(now->left);
		}

		return result;
	}
};

[Leetcode] Find All Numbers Disappeared in an Array ★★★★★

lee308812 — Sun, 27 Jun 2021 21:59:08 +0900

Given an array nums of n integers where nums[i] is in the range [1, n], return an array of all the integers in the range [1, n] that do not appear in nums.

Example 1:

Input: nums = [4,3,2,7,8,2,3,1]

Output: [5,6]

Example 2:

Input: nums = [1,1]

Output: [2]

Constraints:

n == nums.length
1 <= n <= 105
1 <= nums[i] <= n

Follow up: Could you do it without extra space and in O(n) runtime? You may assume the returned list does not count as extra space.

- Hash기반의 unordered_set도 생각했으나 추가 메모리 공간의 정의 없이 O(n) 안에 해결하는 Solution이 아니므로 패스했다.

- 도저히 어떻게 해야할지 몰라서 검색을 했는데, 추가 배열을 정의하지 않기 위해 nums의 각 원소값에 해당하는 index의 절대값-1 (최소값인 1이면 index 0에 매핑하기 위해서) 을 음수로 표기하는 방법으로 해결한 풀이가 있었다.

- 입력은 1 이상만 들어오므로 가능한 방법인 것 같다. 매우 생소한 방법이었으므로 여러번 복습해두자.

[ 참고 코드 ]

class Solution {
public:
    vector<int> findDisappearedNumbers(vector<int>& nums)
	{
		vector<int> resultVec;

		for (auto i = 0; i < nums.size(); i++)
		{
			int m = abs(nums[i]) - 1;
			nums[m] = -abs(nums[m]);
		}

		for (auto i = 0; i < nums.size(); i++)
		{
			if (nums[i] > 0)
				resultVec.push_back(i + 1);
		}

		return resultVec;
    }
};

[Leetcode] Third Maximum Number

lee308812 — Sun, 27 Jun 2021 19:31:06 +0900

Given integer array nums, return the third maximum number in this array. If the third maximum does not exist, return the maximum number.

Example 1:

Input: nums = [3,2,1]

Output: 1

Explanation: The third maximum is 1.

Example 2:

Input: nums = [1,2]

Output: 2

Explanation: The third maximum does not exist, so the maximum (2) is returned instead.

Example 3:

Input: nums = [2,2,3,1]

Output: 1

Explanation: Note that the third maximum here means the third maximum distinct number. Both numbers with value 2 are both considered as second maximum.

Constraints:

1 <= nums.length <= 104
-231 <= nums[i] <= 231 - 1

Follow up: Can you find an O(n) solution?

[ 내 코드 ]

- O(n)으로 풀려고 많은 고민을 했는데, 결국 std::set를 이용해서 O(nlogn)으로 풀었다..

class Solution {
public:
    int thirdMax(vector<int>& nums)
    {
        set<int> s;
        for(int num : nums)
        {
            s.insert(num);
        }

        int maxVal = numeric_limits<int>::min();
        int cnt = 0;
        for(auto it = s.rbegin(); it != s.rend(); ++it)
        {
            cnt++;
            maxVal = std::max(maxVal, *it);
            if(cnt == 3) return *it;
        }

        return maxVal;
    }
};

수행속도 상위 코드는 그냥 정렬로 풀어져 있었고,

class Solution {
public:
    int thirdMax(vector<int>& nums) {
        int saveIndex = 0;
        int times = 0;
        sort(nums.begin(), nums.end(), std::greater<int>());
        for (int i = 0; i < nums.size() - 1; i++){
            if (nums[i] != nums[i + 1]){
                times++;
                }
            if (times == 2){
                saveIndex = i + 1;
                break;
                }
        }
        return nums[saveIndex];
    }
};

수행속도 최상위 코드는 봤는데, 그냥 쌩구현으로 풀었다.

class Solution {
public:
    int thirdMax(vector<int>& nums) {
        long first = LONG_MIN, second = LONG_MIN, third = LONG_MIN;
        
        for(auto const& x: nums){
            if(x != first && x!= second && x!= third){
                if(x > second){
                    if(x > first)
                        third = second, second = first, first = x;
                    else
                        third = second, second = x;
                }
                else{
                    if(x > third)
                        third = x;
                }
            }
        }
        
        if(third != LONG_MIN) return third;
        else return max(first, second);
    }
};

[Leetcode] Replace Elements with Greatest Element on Right Side

lee308812 — Sat, 26 Jun 2021 18:10:47 +0900

Given an array arr, replace every element in that array with the greatest element among the elements to its right, and replace the last element with -1.

After doing so, return the array.

Example 1:

Input: arr = [17,18,5,4,6,1]

Output: [18,6,6,6,1,-1]

Explanation:

- index 0 --> the greatest element to the right of index 0 is index 1 (18).

- index 1 --> the greatest element to the right of index 1 is index 4 (6).

- index 2 --> the greatest element to the right of index 2 is index 4 (6).

- index 3 --> the greatest element to the right of index 3 is index 4 (6).

- index 4 --> the greatest element to the right of index 4 is index 5 (1).

- index 5 --> there are no elements to the right of index 5, so we put -1.

Example 2:

Input: arr = [400]

Output: [-1]

Explanation: There are no elements to the right of index 0.

Constraints:

1 <= arr.length <= 104
1 <= arr[i] <= 105

[ 내 코드 ]

class Solution {
public:
    vector<int> replaceElements(vector<int>& arr)
    {
		size_t size = arr.size();
		int localMax = -1;

		for (int i = size - 1; i >= 0; i--)
		{
			int tmpValue = arr[i];
			arr[i] = localMax;

			localMax = std::max(localMax, tmpValue);
		}

		return arr;
    }
};

- 따로 max 함수를 구현해도 되지만, std::max를 쓰면 된다.

- 오른쪽부터 계산하면 O(N)으로 폴 수 있다. 배열 관련 문제가 나오면 반대 순서로 탐색하는 방법도 생각해 볼 수 있도록 해야 할 듯.

[Leetcode] Check If N and Its Double Exist ★★

lee308812 — Sat, 26 Jun 2021 16:07:45 +0900

Given an array arr of integers, check if there exists two integers N and M such that N is the double of M ( i.e. N = 2 * M).

More formally check if there exists two indices i and j such that :

i != j
0 <= i, j < arr.length
arr[i] == 2 * arr[j]

Example 1:

Input: arr = [10,2,5,3]

Output: true

Explanation: N = 10 is the double of M = 5,that is, 10 = 2 * 5.

Example 2:

Input: arr = [7,1,14,11]

Output: true

Explanation: N = 14 is the double of M = 7,that is, 14 = 2 * 7.

Example 3:

Input: arr = [3,1,7,11]

Output: false

Explanation: In this case does not exist N and M, such that N = 2 * M.

Constraints:

2 <= arr.length <= 500
-10^3 <= arr[i] <= 10^3

class Solution {
public:
    bool checkIfExist(vector<int>& arr)
    {
        size_t size = arr.size();

        unordered_set<int> s;

        for (size_t i = 0; i < size; i++)
        {
            int num = arr[i] * 2;

            if (s.find(num) != s.end())
                return true;

            if (arr[i] % 2 == 0)
            {
                if (s.find(arr[i] / 2) != s.end())
                    return true;
            }

            s.insert(arr[i]);
        }

        return false;
    }
};

unordered_set : set과 달리 정렬되지 않고, Hash 함수 기반의 set

[Leetcode] Duplicate Zeros

lee308812 — Sat, 26 Jun 2021 16:00:10 +0900

Given a fixed length array arr of integers, duplicate each occurrence of zero, shifting the remaining elements to the right.

Note that elements beyond the length of the original array are not written.

Do the above modifications to the input array in place, do not return anything from your function.

Example 1:

Input: [1,0,2,3,0,4,5,0]

Output: null

Explanation: After calling your function, the input array is modified to: [1,0,0,2,3,0,0,4]

Example 2:

Input: [1,2,3]

Output: null

Explanation: After calling your function, the input array is modified to: [1,2,3]

Note:

1 <= arr.length <= 10000
0 <= arr[i] <= 9

[ 내 코드 ]

class Solution {
public:
	void duplicateZeros(vector<int>& arr)
	{
		size_t size = arr.size();

		for (int i = 0; i < size - 1; i++)
		{
			if (arr[i] == 0)
			{
				for (int j = size - 2; j >= i; j--)
				{
					arr[j + 1] = arr[j];
				}

				i++;
			}			
		}
	}
};

- 똑같은 값이 삽입되어야 하는데, 뒤에서부터 밀어야 함에 유의해야 한다.