공대생의 비망록

[Linux] 내 개인 서버 (가상 머신 등)의 일반 사용자에 sudo 작업을 비밀번호 없이 수행하도록 수정하기

myungsup1250 — Sun, 15 Feb 2026 22:38:37 +0900

Amazon EC2와 같은 서비스의 가상 머신을 사용하다 보면 sudo가 필요한 작업을 수행해도 ec2-user와 같은 Linux 사용자에게 sudo 비밀번호 입력을 요구하지 않는다.

사용자가 애초에 인스턴스 생성 시에 비밀번호를 입력하지 않았기도 하고, 보안적인 관점에서도 SSH Key pair (키페어)를 사용하는 것이 보다 안전하기 때문에 ec2-user와 같은 Linux 사용자를 sudo 권한 사용 시에 비밀번호가 필요 없도록 사용자를 sudo 그룹에 추가해둔다.

Linux 사용자를 sudo 그룹에 추가하는 방법은 다양하지만, 아래에서 내가 활용했던 간단한 방법을 공유하고자 한다.

최초 설정 시에는 sudo 비밀번호가 필요하므로 root 비밀번호를 미리 확인해두는 것은 필수인 점 유의 바란다.

아래와 같은 명령어를 입력, 실행한다 (아직 Linux 사용자에 sudo 권한을 부여하지 않았으므로 이 때 비밀번호가 필요하다.):

$ sudo visudo

기존 sudo 권한을 부여받은 다양한 사용자 (root)의 정보가 확인되는데, 적절한 위치에 아래와 같은 내용을 입력하면 된다:

[USERID] ALL=NOPASSWD: ALL

예를 들어, ec2-user Linux 사용자에 대하여 sudo 권한을 부여하고 싶다면 아래와 같이 [USERID] 부분을 'ec2-user'으로 대체하면 된다:

ec2-user ALL=NOPASSWD: ALL

올바르게 설정되었다면 이후 쉘 세션을 종료하고 다시 로그인하여 sudo 권한을 확인해보면 된다.

끝!

[LeetCode][Easy] Two Sum II - Input Array Is Sorted 문제 Python 풀이

myungsup1250 — Tue, 10 Feb 2026 18:19:06 +0900

투 포인터를 사용해서 푸는 대표적인 문제이다.

풀이:

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        left = 0; right = len(numbers) - 1
        while left < right:
            temp = numbers[left] + numbers[right]
            if temp == target:
                return [left + 1, right + 1]
            elif temp < target:
                left += 1
            else:
                right -= 1

[LeetCode][Easy] Valid Parentheses 문제 Python 풀이

myungsup1250 — Tue, 10 Feb 2026 15:24:52 +0900

자료구조를 공부하게 되면 Stack의 특성을 활용하도록 꼭 한번은 경험하게 되는 문제를 LeetCode 플랫폼에서도 풀게 되었다.

기존에는 C나 C++, Java로 구현했었는데 이번에는 Python으로 여러 방법을 구현해보았다.

if-else 구문을 떡칠해서 문제를 해결하는 가장 기본적인 (멍청한) 방식:

class Solution:
    def isValid(self, s: str) -> bool:
        stack = list()
        for ch in s:
            if ch == '(' or ch == '{' or ch == '[':
                stack.append(ch)
            elif ch == ')':
                if len(stack) > 0 and stack[-1] == '(':
                    stack.pop()
                else:
                    return False
            elif ch == '}':
                if len(stack) > 0 and stack[-1] == '{':
                    stack.pop()
                else:
                    return False
            elif ch == ']':
                if len(stack) > 0 and stack[-1] == '[':
                    stack.pop()
                else:
                    return False
            # else: # ch is not '(', ')', '{', '}', '[', ']'
            #     continue
        if len(stack) == 0:
            return True
        return False

Dictionary 자료구조를 활용해서 괄호 유형 별로 쌍을 이루어 보다 간결한 로직으로 문제를 해결하는 방법:

class Solution:
    def isValid(self, s: str) -> bool:
        mydict = {')':'(', '}':'{', ']':'['}
        stack = list()
        for ch in s:
            if ch in mydict.values(): # '(', '{', '['
                stack.append(ch)
            elif ch in mydict.keys(): # ')', '}', ']'
                if len(stack) > 0 and stack[-1] == mydict[ch]:
                    stack.pop()
                else:
                    return False

        if len(stack) == 0:
            return True
        return False

Dictionary 자료구조 활용 방식을 보다 개선하고 코드를 보다 Pythonic하게 수정한 방법:

class Solution:
    def isValid(self, s: str) -> bool:
        mydict = {'(':')', '{':'}', '[':']'}
        stack = list()
        for ch in s:
            if ch in mydict.keys(): # '(', '{', '['
                stack.append(mydict[ch])
            elif ch in mydict.values(): # ')', '}', ']'
                if len(stack) > 0 and stack[-1] == ch:
                    stack.pop()
                else:
                    return False

        return len(stack) == 0

[LeetCode][Easy] Longest Common Prefix 문제 Python 풀이

myungsup1250 — Mon, 9 Feb 2026 18:06:50 +0900

주어진 문자열 배열 strs에 대하여, 가장 긴 공통문자열을 찾는 문제.

예를 들어 "flower", "flow", "flight" 문자열들이 주어졌다면 "fl"을 찾아 반환해야 한다.

문제 풀이:

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        length = 201 # Since the max length for this problem is 200.
        # length = min(len(w) for w in strs) # Pythonic way
        for s in strs: # set var length as the shortest string's length.
            if length > len(s):
                length = len(s)

        common = ""
        for i in range(length):
            tmp = strs[0][i]; add = True
            for s in strs:
                if tmp != s[i]:
                    return common
            common += tmp
        return common

[LeetCode][Easy] Valid Palindrome 문제 Python 풀이

myungsup1250 — Mon, 9 Feb 2026 10:46:12 +0900

영어 대소문자와 공백, 특수문자가 섞여 있는 문자열에서 영어 소문자만 가지고 회문 여부를 검증하는 문제.

실제로 요구하는 대로 소문자만 존재하는 문자열로 가공하여 회문 여부를 검증하는 방법과 주어진 문자열 그대로 투 포인터를 사용하여 문제를 해결하는 방법을 각각 구현해보았습니다.

문자열 가공 후 회문을 판단하는 방법:

class Solution:
    def isPalindrome(self, s: str) -> bool:
        lower = s.lower()
        trimmed = str()
        for ch in lower:
            if ch.islower() or ch.isdigit():
                trimmed += ch
        for i in range(len(trimmed) // 2):
            if trimmed[i] != trimmed[-i - 1]:
                return False
        return True

주어진 문자열 그대로 투 포인터로 문제를 해결하는 방법:

class Solution:
    def isPalindrome(self, s: str) -> bool:
        left = 0
        right = len(s) - 1  # left, right = 0, len(s) - 1
        while left < right:
            while left < right and not s[left].isalnum():
                left += 1
            while left < right and not s[right].isalnum():
                right -= 1
            if s[left].lower() != s[right].lower():
                return False
            left += 1
            right -= 1
        return True

[LeetCode][Easy] First Unique Character in a String 문제 Python 풀이

myungsup1250 — Mon, 9 Feb 2026 01:07:23 +0900

주어진 문자열 s에서 첫 번째의 고유 문자 위치를 찾아 반환하는 문제.

문자열을 1회차로 순회하며 dictionary 자료구조에 모든 문자의 빈도를 저장하도록 하고, 2회차로 순회할 때 dictionary에 빈도가 1이라면 그 위치를 반환하도록 하여 문제를 해결하였다.

문제 풀이 (시간복잡도는 O(n)이다.):

class Solution:
    def firstUniqChar(self, s: str) -> int:
        seen = {}
        for i in range(len(s)):
            if s[i] not in seen:
                seen[s[i]] = 1
            else:
                seen[s[i]] += 1

        for i in range(len(s)):
            if seen[s[i]] == 1:
                return i
        
        return -1

[LeetCode][Easy] Valid Anagram 문제 Python 풀이

myungsup1250 — Sun, 8 Feb 2026 18:49:28 +0900

주어진 두 문자열 s, t가 애너그램 (Anagram)인 지 판단하는 문제.

문제에서는 문자열 안에는 소문자만 포함된다고 하였으나 확장성을 고려하여 딕셔너리 (dictionary) 자료구조를 활용하여 푼 버전과 소문자 26개 (혹은 존재하는 소문자 수)만큼의 길이를 가지는 배열 (list)을 활용하여 푼 버전을 각각 구현해보았다:

딕셔너리 활용 버전:

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        if len(s) != len(t):
            return False

        dicts = {}; dictt = {}
        for ch in s:
            if ch not in dicts:
                dicts[ch] = 1
            else:
                dicts[ch] += 1

        for ch in t:
            if ch not in dictt:
                dictt[ch] = 1
            else:
                dictt[ch] += 1

        for key in dicts.keys():
            if key not in dictt or dicts[key] != dictt[key]:
                return False

        return True

문자열 활용 버전:

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        if len(s) != len(t):
            return False
        
        sets = set(s); sett = set(t)
        if len(sets - sett) != 0 or len(sett - sets) != 0:
            return False
        
        mydict = {}; i = 0
        for ch in sets:
            mydict[ch] = i
            i += 1  
        chars = [0 for _ in range(len(s))]
        for j in range(len(s)):
            sindex = mydict[s[j]]
            chars[sindex] += 1
            tindex = mydict[t[j]]
            chars[tindex] -= 1
        for num in chars:
            if num != 0:
                return False
        return True

[LeetCode][Easy] Count Monobit Integers 문제 Python 풀이

myungsup1250 — Sun, 8 Feb 2026 17:51:52 +0900

주어진 n에 대하여 0부터 n까지 "0" 혹은 "1"으로만 비트가 구성되어 있는 정수 (Monobit Integer)를 구하는 문제.

처음에는 모든 비트가 같아야 한다는 점에 착안, 0부터 n까지 모든 수를 비트 문자열로 만들어 XOR 비트 연산을 수행하여 문제를 해결하도록 구현하였으나 매우 비효율적이었고, 그 후로

초기 방법 (모든 수를 비트 문자열로 생성하여 XOR 연산):

class Solution:
    def countMonobit(self, n: int) -> int:
        if n == 0:
            return 1
        bitified = ["0"]
        for i in range(1, n + 1):
            m = i
            bit = ""
            while m > 0:
                if m % 2 == 1:
                    bit += "1"
                else:
                    bit += "0"
                m //= 2
            bitified.append(bit)

        cnt = 0
        for bit in bitified:
            comp1 = ""; comp2 = ""
            for i in range(len(bit)):
                comp1 += "0"
                comp2 += "1"
            if int(comp1) ^ int(bit) == 0 or int(comp2) ^ int(bit) == 0:
                cnt += 1
        return cnt

첫 번째 개선 버전 (n의 비트 길이를 계산하여 그 길이만큼의 Monobit Integers의 경우의 수를 계산하여 답을 반환):

class Solution:
    def countMonobit(self, n: int) -> int:        
        if n == 0:
            return 1
        max_len = 0; tmp = n
        while tmp > 0:
            tmp //= 2
            max_len += 1
        
        bit = ""
        for i in range(max_len):
            bit += "1"
        
        if n < int(bit, 2):
            return max_len
        else:
            return max_len + 1

추가 개선 버전 (n의 비트 길이 계산을 python 함수로 해결하고 실제 비트 문자열을 만들지 않고도 해결하도록 개선):

class Solution:
    def countMonobit(self, n: int) -> int:
        if n == 0:
            return 1
        max_len = n.bit_length()
        
        if n < (1 << max_len) - 1:
            return max_len
        else:
            return max_len + 1

[LeetCode][Easy] Single Number 문제 Python 풀이

myungsup1250 — Sun, 8 Feb 2026 15:38:47 +0900

set으로 만들어서 고유한 숫자만 남겨 sum을 2배로 하여 nums의 sum 값과 차감하여 숫자를 찾아내는 풀이:

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        mySum = sum(set(nums)) * 2
        diff = mySum - sum(nums)
        return diff

XOR 비트 연산으로 배열을 순회하여 숫자를 찾아내는 풀이: (연달아 XOR 비트 연산으로 풀 수 있는 문제를 만나 습득하게 되었습니다.)

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        res = 0
        for num in nums:
            res ^= num
        return res

[LeetCode][Easy] Missing Number 문제 Python 풀이

myungsup1250 — Sun, 8 Feb 2026 01:35:09 +0900

이 문제는 보자마자 Python에 익숙한 사람이라면 누구나 쉽게 풀 수 있는 문제라는 생각이 들었다.

for-loop을 통해 0부터 n까지 하나씩 확인하는 방법: (시간복잡도 O(n)이나 비효율적인 편)

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        for i in range(len(nums) + 1):
            if i not in nums:
                return i

set을 사용하며 쉽고 빠르게 문제를 해결하는 방법:

class Solution:
    def missingNumber(self, nums: List[int]) -> int:
        comp = set(range(len(nums) + 1))
        missing = comp - set(nums)
        return missing.pop()

그 외에도 본 문제를 해결하는 방법에는 가우스 공식 (n * n+1 / 2)을 활용하는 방법, XOR 비트연산을 활용하는 방법... 등이 있겠다.

끝!