승열의 프로그래밍 시네마

LeetCode 1448. Count Good Nodes in Binary Tree

코드 유랑자 승열 — Sun, 25 Jan 2026 22:03:27 +0900

1448. Count Good Nodes in Binary Tree

Problem

Solution

The requirements of this problems are as follows:

A node is called good if its value is the largest on the path from the root to that node.
Return the number of good nodes.

To satifsy these requirments, I used a preorder traversal with a stack.

First, initialize stack as a list containing root and root.val and set good as 0.

Each element in the stack stores the current node and the maximum value seen so far on its path.

While stack is not empty,do the following steps:

Pop the last node and maximum from stack.
If the current value of the node is greater or equal to maximum, increase good by 1 and update maximum.
If the node has a right child, append it with maximum to stack.
If the node has a left child, append it with maximum to stack.

By pushing the right child first, the left subtree is processed first.

This keeps the comparison consistent with a preorder traversal.

At the end of the loop, return good.

class Solution(object):
    def goodNodes(self, root):
        stack = [(root, root.val)]
        good = 0

        while stack:
            node, maximum = stack.pop()

            if node.val >= maximum:
                good += 1
                maximum = node.val


            if node.right:
                stack.append((node.right, maximum))
            if node.left:
                stack.append((node.left, maximum))

        return good

https://github.com/K-MarkLee/LeetCode-Practice

GitHub - K-MarkLee/LeetCode-Practice: A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2

A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2.0](https://github.com/maitreya2954/LeetHub-2.0-Firefox) - K-MarkLee/LeetCode-Practice

github.com

LeetCode 872. Leaf-Similar Trees

코드 유랑자 승열 — Sat, 24 Jan 2026 22:28:33 +0900

872. Leaf-Similar Trees

Problem

Solution

The key requirement of this problem is as follows:

Return True if the leaf of sequences of root1 and root2 are the same otherwise return False.

To satisfy this requirement, I used a preorder traversal with a stack.

Since we need to process two binary trees, I created a helper function getLeaves.

First, initialize stack as a list containing root, and set leaves as an empty list.

If root is None, return leaves because the tree is empty.

While stackis not empty, do the following steps:

Pop the last node from stack.
If the current node has no left and right children, append its value to leaves.
Otherwise, if the node has a right child, append it to stack.
If the node has a left child, append it to stack.

By pushing the right child first, the left subtree is processed first.

This keeps the leaf order consistent with a preorder traversal.

At the end of the loop, return the leaves.

Outside of getLeaves, call it for both trees and compare the results.
If both leaf lists are the same, return True otherwise return False.

class Solution(object):
    def leafSimilar(self, root1, root2):
        def getLeaves(root):
            stack = [root]
            leaves = []
            if not stack:
                return leaves

            while stack:
                node = stack.pop()
                if not node.left and not node.right:
                    leaves.append(node.val)
                else:
                    if node.right:
                        stack.append(node.right)
                    if node.left:
                        stack.append(node.left)

            return leaves

        tree1 = getLeaves(root1)
        tree2 = getLeaves(root2)
        return tree1 == tree2

https://github.com/K-MarkLee/LeetCode-Practice

GitHub - K-MarkLee/LeetCode-Practice: A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2

A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2.0](https://github.com/maitreya2954/LeetHub-2.0-Firefox) - K-MarkLee/LeetCode-Practice

github.com

LeetCode 104. Maximum Depth of Binary Tree

코드 유랑자 승열 — Sat, 24 Jan 2026 22:10:35 +0900

104. Maximum Depth of Binary Tree

Problem

Solution

The key requirement of this problem is as follows:

Return the maximum depth of given binary tree.

To satisfy this requirement, I used level-order-traversal with a queue.

First, it root is None, return 0 because the tree is empty.

Initialize value as a list containing root, and set depth to 0.

The list value stores all nodes at the current level.

When value becomes empty, it means all nodes have been processed.

While value is not empty, do the following steps:

Increase depth by 1.
Store the current length of value in level which represents how many nodes exist at the current depth.
Repeat the folowing stepts level times:
1. Pop the first node from value.
2. If the node has left child, append it to value.
3. If the node has right child, append it to value.

This way, each iteration of the while loop processes exactly one level of the tree.

When the loop ends, return depth as the result.

class Solution(object):
    def maxDepth(self, root):
        if root is None:
            return 0

        value = [root]
        depth = 0

        while value:
            depth += 1
            level = len(value)

            for i in range(level):
                node = value.pop(0)

                if node.left:
                    value.append(node.left)
                if node.right:
                    value.append(node.right)
        return depth

https://github.com/K-MarkLee/LeetCode-Practice

GitHub - K-MarkLee/LeetCode-Practice: A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2

A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2.0](https://github.com/maitreya2954/LeetHub-2.0-Firefox) - K-MarkLee/LeetCode-Practice

github.com

LeetCode 2130. Maximum Twin Sum of a Linked List

코드 유랑자 승열 — Fri, 23 Jan 2026 17:33:28 +0900

2130. Maximum Twin Sum of a Linked List

Problem

Solution

The key requirements of this problem are as follows:

The linked list has an even legnth.
The ith node is paired with the (length-1-i)th node.
Return the maximum sum among all twin pairs.

To satisfy these requirements, I used a two-pointer approach.

First, I split the problem into three steps.

Find the middle nodes of the list.
Reverse the second half of the list.
Compare the two halves node by node and track the maximum sum.

To find the middle, I use slow and fast pointer.

slow starts as head and moves single step at a time.
fast starts as head and moves two steps at a time.

When fast reaches the end, slow points to the middle of the list.

To reverse the second half, initialize three pointers.

prev starts as None.
rev starts as slow.
ahead is used to store the next node during iteration.

During reverse is like below.

Store rev.next in ahead.
Change rev.next to point to prev.
Move prev to rev
Move rev to ahead.

Repeat until the second half is fully reversed.

After that, prev points to the head of the reversed half.

Now, simply compare the two halves.

In each iteration, add prev.val and head.val and update when result is smaller than the sum.

At the end of the loop, return the result.


class Solution(object):
    def pairSum(self, head):

        slow = fast = head
        result = 0

        while fast:
            fast = fast.next.next
            slow = slow.next

        prev = None
        rev = slow

        while rev:
            ahead = rev.next
            rev.next = prev
            prev = rev
            rev = ahead

        while prev:
            temp = prev.val+head.val
            if temp > result:
                result = temp
            prev = prev.next
            head = head.next

        return result

https://github.com/K-MarkLee/LeetCode-Practice

GitHub - K-MarkLee/LeetCode-Practice: A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2

A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2.0](https://github.com/maitreya2954/LeetHub-2.0-Firefox) - K-MarkLee/LeetCode-Practice

github.com

LeetCode 206. Reverse Linked List

코드 유랑자 승열 — Thu, 22 Jan 2026 21:59:08 +0900

206. Reverse Linked List

Problem

Solution

The requirement of this problem is as follows:

Return the reversed linked list.

To satisfy this problem, I used a two-pointer approach.

First, to reverse the list, at least two nodes are nedded.

So if head is None or head.next is None, return head directly.

In the main logic, I initialize the two pointers prev and ahead.

prev starts as None, because the first node will point to None after reversing.
ahead starts at head.next which stores the next node before the link is changed.

I use while loop.
Since ahead always represent the next node of head, when ahead reaches None, this means head is pointing to the last node.

To reverse the list, the key step is to change head.next to point to prev.

After that, move the pointers.

Move prev to head.
Move head to ahead.
Move ahead to ahead.nextfor the next iteration.

After the loop, when I return head, it just return last node.

The problem is, at the end of the iteration, head points last node and I forgot to connect to prev.

So I set head.next = prev to complete the reversal.

Actually, I misunderstood the role of head at first.
I thought it always represented the first node, but it is also just a pointer that moves through the list.

class Solution(object):
    def reverseList(self, head):
        """
        :type head: Optional[ListNode]
        :rtype: Optional[ListNode]
        """
        if not head or not head.next:
            return head

        prev = None
        ahead = head.next

        while ahead:
            head.next = prev
            prev = head
            head = ahead
            ahead = ahead.next
        head.next = prev

        return head

https://github.com/K-MarkLee/LeetCode-Practice

GitHub - K-MarkLee/LeetCode-Practice: A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2

A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2.0](https://github.com/maitreya2954/LeetHub-2.0-Firefox) - K-MarkLee/LeetCode-Practice

github.com

LeetCode 328. Odd Even Linked List

코드 유랑자 승열 — Wed, 21 Jan 2026 21:39:45 +0900

328. Odd Even Linked List

Problem

Solution

The key requirements of this problem are as follows:

Seperate the linked list into odd and even positions.
After seperating them, place the odd group first and then even group after it.
Return the reordered list.

To satisfy these requirements, I used the two-pointer approach.

First, to seperate off and even positions, we need at least two nodes.
So if head is None or head.next is None, return head directly.

In the main logic, I initialize odd, even, and even_head.

odd starts at head
even starts at head.next
even_head stores the first node of the even group, so that I can connect the odd group to the even group at the end.

During grouping, the next node of odd should be the next odd node, and the next node of even should be the next even node.

So I reconnect the links by alternating the pointers:

odd.next is connected to the next odd node even.next
even.next is connected to the next even node odd.next

By reapeating this process, all nodes are grouped into the odd list and the even list.

I use a while loop for thos.

Since the even group ends first, I stop when even is None or even.next is None.

Finally, to combine the two groups by connect odd.next to even_head.

Then return head as the result.

class Solution(object):
    def oddEvenList(self, head):

        if not head or not head.next:
            return head

        odd = head
        even_head = even = head.next

        while even and even.next:
            odd.next = even.next
            odd = odd.next

            even.next = odd.next
            even = even.next

        odd.next = even_head
        return head

https://github.com/K-MarkLee/LeetCode-Practice

GitHub - K-MarkLee/LeetCode-Practice: A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2

A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2.0](https://github.com/maitreya2954/LeetHub-2.0-Firefox) - K-MarkLee/LeetCode-Practice

github.com

LeetCode 2095. Delete the Middle Node of a Linked List

코드 유랑자 승열 — Sat, 17 Jan 2026 00:17:14 +0900

Delete the Middle Node of a Linked List

Problem

You are given the head of a linked list. Delete the middle node, and return the head of the modified linked list.

The middle node of a linked list of size n is the ⌊n / 2⌋th node from the start using 0-based indexing, where ⌊x⌋ denotes the largest integer less than or equal to x.

    For n = 1, 2, 3, 4, and 5, the middle nodes are 0, 1, 1, 2, and 2, respectively.



Example 1:

Input: head = [1,3,4,7,1,2,6]
Output: [1,3,4,1,2,6]
Explanation:
The above figure represents the given linked list. The indices of the nodes are written below.
Since n = 7, node 3 with value 7 is the middle node, which is marked in red.
We return the new list after removing this node. 

Example 2:

Input: head = [1,2,3,4]
Output: [1,2,4]
Explanation:
The above figure represents the given linked list.
For n = 4, node 2 with value 3 is the middle node, which is marked in red.

Example 3:

Input: head = [2,1]
Output: [2]
Explanation:
The above figure represents the given linked list.
For n = 2, node 1 with value 1 is the middle node, which is marked in red.
Node 0 with value 2 is the only node remaining after removing node 1.



Constraints:

    The number of nodes in the list is in the range [1, 105].
    1 <= Node.val <= 105

Solution

The key requirements of this problem are as follows:

Delete the middle node using 0-based indexing.
Return the modified linked list after removing the middle node.

To satisfy these requirements, I used a two-pointer approach.

First, initialize three pointers : left, right and prev, all pointing to head.

Using the two-pointer, when tthe left moves to the next node, the right moves two steps at a time.

Therefore, when right reaches the end of the linked list, the left is located at the middle node.

During the iteration, prev always keeps tracking just before left.

After the end of the loop, left points the middle node and prev.next points to left.

By setting prev.next = left.next, the middle node is skipped and removed from the linked list.

Since a linked list is connected through next references, once the link is changed, the removed node is no longer reachable and will be deleted by garbage collector.

If the list contains only one node or is empty, return None directly.

class Solution(object):
    def deleteMiddle(self, head):
        left = head
        right = head
        prev = head

        if not head or not head.next:  
            return None

        while right and right.next:
            prev = left
            left = left.next
            right = right.next.next

        prev.next = left.next

        return head

https://github.com/K-MarkLee/LeetCode-Practice

LeetCode 649. Dota2 Senate

코드 유랑자 승열 — Sat, 10 Jan 2026 21:07:13 +0900

649. Dota2 Senate

Problem

Solution

The key requirements of this problem are as follows:

The senate is represesnted as a string consisting of R and D, which represent Radiant and Dire.
Each senator can ban one opponent senator in order.
The process continues until only one group remains.
Return the group that finally left.

To satisfy these requirements, I used queue-based approach without importing any external libraries.

First, I separate the senators into two lists, one for Radiant and one for Dire.

Using enumerate, I store the index of each senator in the list.

After storing all senators, I initialize idx as 0 and start comparing the senators.

While idx is smaller than the length of one of the lists, I compare r[idx] and d[idx].

If r[idx] is smaller, this means the Radiant senator acts first and ban the Dire senator.

Therefore, the Radiant senator will appear again in the next round, so I append r[idx] + len(senate) ro the Radiant list.

If d[idx] is smaller, the same process is applied to the Dire list.

After each comparison, increase idx by 1.

When idx reaches the length of one of the lists, this means that group has no more senators to compare.

Therefore, the group with the larger list survives and is returned as the final result.

class Solution(object):
    def predictPartyVictory(self, senate):
        r = []
        d = []

        for i, j in enumerate(senate):
            if j == "R":
                r.append(i)
            else:
                d.append(i)

        idx = 0
        while idx < len(r) and idx < len(d):
            if r[idx] < d[idx]:
                r.append(r[idx] + len(senate))
            else:
                d.append(d[idx] + len(senate))
            idx += 1

        return "Radiant" if len(r) > len(d) else "Dire"

https://github.com/K-MarkLee/LeetCode-Practice

GitHub - K-MarkLee/LeetCode-Practice: A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2

A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2.0](https://github.com/maitreya2954/LeetHub-2.0-Firefox) - K-MarkLee/LeetCode-Practice

github.com

LeetCode 933. Number of Recent Calls

코드 유랑자 승열 — Fri, 9 Jan 2026 15:23:37 +0900

933. Number of Recent Calls

Problem

You have a RecentCounter class which counts the number of recent requests within a certain time frame.

Implement the RecentCounter class:

    RecentCounter() Initializes the counter with zero recent requests.
    int ping(int t) Adds a new request at time t, where t represents some time in milliseconds, and returns the number of requests that has happened in the past 3000 milliseconds (including the new request). Specifically, return the number of requests that have happened in the inclusive range [t - 3000, t].

It is guaranteed that every call to ping uses a strictly larger value of t than the previous call.



Example 1:

Input
["RecentCounter", "ping", "ping", "ping", "ping"]
[[], [1], [100], [3001], [3002]]
Output
[null, 1, 2, 3, 3]

Explanation
RecentCounter recentCounter = new RecentCounter();
recentCounter.ping(1);     // requests = [1], range is [-2999,1], return 1
recentCounter.ping(100);   // requests = [1, 100], range is [-2900,100], return 2
recentCounter.ping(3001);  // requests = [1, 100, 3001], range is [1,3001], return 3
recentCounter.ping(3002);  // requests = [1, 100, 3001, 3002], range is [2,3002], return 3



Constraints:

    1 <= t <= 109
    Each test case will call ping with strictly increasing values of t.
    At most 104 calls will be made to ping.

Solution

The key requirements of this probem are as follows:

Initialize the counter with zero recent requests.
Add a new request at time t.
Return the number of requests within the inclusive range [t - 3000, 3]

To satisfy these requirements, I used a queue-based approach.

I do not use any external libraries to solve problems

First, the RecentCounter class must be initialized, so I create a queue q in the __init__ method.

I initialize q as a list.

Although it is possible to import collections and use deque, I choose to use a list to solve the problem without impoting any external libraries.

When the program starts, ping is called one by one.

Each incomming time t is appended to the list q.

Since append always adds elements in order, and the problem gurantees that t is strictly increasing, smaller ping values are always stored at the front of the list.

While the first element of q is smaller than t - 3000, it is no loger valid, so I remove it from the queue.

After removing all invalid values, the remaining elements in q represent the number of recent calls.

According to the requirements, I return the length of q, not the queue itself.

class RecentCounter(object):

    def __init__(self):
        self.q = []

    def ping(self, t):
        self.q.append(t)
        while self.q[0] < t - 3000:
            self.q.pop(0)

        return len(self.q)

https://github.com/K-MarkLee/LeetCode-Practice

GitHub - K-MarkLee/LeetCode-Practice: A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2

A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2.0](https://github.com/maitreya2954/LeetHub-2.0-Firefox) - K-MarkLee/LeetCode-Practice

github.com

LeetCode 394. Decode String

코드 유랑자 승열 — Wed, 7 Jan 2026 21:34:19 +0900

394. Decode String

Problem

Given an encoded string, return its decoded string.

The encoding rule is: k[encoded_string], where the encoded_string inside the square brackets is being repeated exactly k times. Note that k is guaranteed to be a positive integer.

You may assume that the input string is always valid; there are no extra white spaces, square brackets are well-formed, etc. Furthermore, you may assume that the original data does not contain any digits and that digits are only for those repeat numbers, k. For example, there will not be input like 3a or 2[4].

The test cases are generated so that the length of the output will never exceed 105.



Example 1:

Input: s = "3[a]2[bc]"
Output: "aaabcbc"

Example 2:

Input: s = "3[a2[c]]"
Output: "accaccacc"

Example 3:

Input: s = "2[abc]3[cd]ef"
Output: "abcabccdcdcdef"



Constraints:

    1 <= s.length <= 30
    s consists of lowercase English letters, digits, and square brackets '[]'.
    s is guaranteed to be a valid input.
    All the integers in s are in the range [1, 300].

Solution

The key requirements of this problem are as follows:

Value of s is made of the k[string] format.
Decode the string by multiplying string k times.
Return final decoded string.

To satisfy this requirements, I used a stack approach with multiple lists.

The elements of s are digits, characters and brackets.

First, while iterating though the string, append each element to the result list as long as the element is not a closing bracket.

ex)
s = "21[abc]3[cd]ef"
result = ["2", "1", "[", "a" , "b", "c"]

Next, when a closing bracket is encountered, move characters from result to the chars list while result[-1] != "[", and pop each character from result.

ex)
s = "21[abc]3[cd]ef"
result = ["2", "1", "["]
chars = ["c", "b", "a"]

Since the stack stores elements in reverse order, reverse chars to restore the correct order.

Afther that, pop the opening bracket.

Then, while result is not empty and result[-1].isdigit() is true, build the digit string using str_num = result.pop() + str_num.

The reason why adding digits this way is that stack pops elements in reverse order.

For example, 21 is stored as "2" then "1", so "1" is popped first.

ex)
s = "21[abc]3[cd]ef"
result = []
chars = ["a", "b", "c"]
str_num = '21'

Convert str_num into an integer and multiply the decoded string.

Using ''.join(chars) * num , the string "abc" is repeated 21 times and appended to result.

ex)
result = ["abc", "abc"...]

After finishing the iteration, return the final decoded string.

class Solution(object):
    def decodeString(self, s):
        result = []
        for i in s:
            if i != "]":
                result.append(i)
            else:
                char = []
                while result[-1] != "[":
                    char.append(result.pop())
                char.reverse()
                result.pop()

                str_num = ''
                while result and result[-1].isdigit():
                    str_num = result.pop() + str_num

                num = int(str_num)if str_num else 1
                temp = ''.join(char) * num
                for i in temp:
                    result.append(i)

        return ''.join(result)

https://github.com/K-MarkLee/LeetCode-Practice

GitHub - K-MarkLee/LeetCode-Practice: A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2

A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2.0](https://github.com/maitreya2954/LeetHub-2.0-Firefox) - K-MarkLee/LeetCode-Practice

github.com

LeetCode 2352. Equal Row and Column Pairs

코드 유랑자 승열 — Mon, 5 Jan 2026 16:02:50 +0900

2352. Equal Row and Column Pairs

Problem

Given a 0-indexed n x n integer matrix grid, return the number of pairs (ri, cj) such that row ri and column cj are equal.

A row and column pair is considered equal if they contain the same elements in the same order (i.e., an equal array).



Example 1:

Input: grid = [[3,2,1],[1,7,6],[2,7,7]]
Output: 1
Explanation: There is 1 equal row and column pair:
- (Row 2, Column 1): [2,7,7]

Example 2:

Input: grid = [[3,1,2,2],[1,4,4,5],[2,4,2,2],[2,4,2,2]]
Output: 3
Explanation: There are 3 equal row and column pairs:
- (Row 0, Column 0): [3,1,2,2]
- (Row 2, Column 2): [2,4,2,2]
- (Row 3, Column 2): [2,4,2,2]



Constraints:

    n == grid.length == grid[i].length
    1 <= n <= 200
    1 <= grid[i][j] <= 105

Solution

The key requirement of this problem is as follows:

Return the number of paris (r[i], c[j] such that row r[i] and column c[j] are equal.

To satisfy this requirement, I used hashmap and tuple approach.

In order to use a value as a key in hashmap, the value must be immutable.

Therefore, each row is converted into a tuple and used as a key.

First, iterate through the grid and store each row as a tuple in the hashmap, while countind its frequency,

After that, iterate through each column.

For each columm, create a tuple using grid[i][j] for all rows i, and check whether this tuple exists in the row hashmap.

The reason for seperating row and column iteration is that, in a single loop, it is not possivle to construct a full column array directly.

Using seperate loops makes it easier to build row and column tuples correctly.

At the end of iteration, return the result.

class Solution(object):
    def equalPairs(self, grid):
        n = len(grid)
        row = {}
        result = 0

        for i in range(n):
            key = tuple(grid[i])
            row[key] = row.get(key, 0) + 1

        for j in range(n):
            key = tuple(grid[i][j] for i in range(n))
            result += row.get(key, 0)

        return result

https://github.com/K-MarkLee/LeetCode-Practice

GitHub - K-MarkLee/LeetCode-Practice: A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2

A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2.0](https://github.com/maitreya2954/LeetHub-2.0-Firefox) - K-MarkLee/LeetCode-Practice

github.com

LeetCode 1657. Determine if Two Strings Are Close

코드 유랑자 승열 — Mon, 5 Jan 2026 15:07:37 +0900

1657. Determine if Two Strings Are Close

Problem

Two strings are considered close if you can attain one from the other using the following operations:

    Operation 1: Swap any two existing characters.
        For example, abcde -> aecdb
    Operation 2: Transform every occurrence of one existing character into another existing character, and do the same with the other character.
        For example, aacabb -> bbcbaa (all a's turn into b's, and all b's turn into a's)

You can use the operations on either string as many times as necessary.

Given two strings, word1 and word2, return true if word1 and word2 are close, and false otherwise.



Example 1:

Input: word1 = "abc", word2 = "bca"
Output: true
Explanation: You can attain word2 from word1 in 2 operations.
Apply Operation 1: "abc" -> "acb"
Apply Operation 1: "acb" -> "bca"

Example 2:

Input: word1 = "a", word2 = "aa"
Output: false
Explanation: It is impossible to attain word2 from word1, or vice versa, in any number of operations.

Example 3:

Input: word1 = "cabbba", word2 = "abbccc"
Output: true
Explanation: You can attain word2 from word1 in 3 operations.
Apply Operation 1: "cabbba" -> "caabbb"
Apply Operation 2: "caabbb" -> "baaccc"
Apply Operation 2: "baaccc" -> "abbccc"



Constraints:

    1 <= word1.length, word2.length <= 105
    word1 and word2 contain only lowercase English letters.

Solution

The key requirements of this problem are as follows:

It is possible to swap any two existing characters.
It is possible to change occurrence of one existing character into another existing character.
Return True when the two strings are same after iteration of these two operations.

To satisfy these requirements, I used a hashmap approach (Python discription).

First, to check whether both strings contain the same set of characters, convert each string to a set and compare each other.

After that, count the frequency of each characters in both strings.

If the sorted frequency values of the two strings are the same, return true otherwise, return false.

class Solution(object):
    def closeStrings(self, word1, word2):
        if set(word1) != set(word2):
            return False

        freq1 = {}
        freq2 = {}

        for i in word1:
            freq1[i] = freq1.get(i, 0) + 1

        for i in word2:
            freq2[i] = freq2.get(i, 0) + 1

        return sorted(freq1.values()) == sorted(freq2.values())

Alternatively, without explictly using a loop to count frequencies, we can directly create sorted frequency lists.

class Solution(object):
    def closeStrings(self, word1, word2):
        if set(word1) != set(word2):
            return False

        freq1 = sorted([word1.count(i) for i in set(word1)])
        freq2 = sorted([word2.count(i) for i in set(word2)])
        return freq1 == freq2

https://github.com/K-MarkLee/LeetCode-Practice

GitHub - K-MarkLee/LeetCode-Practice: A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2

A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2.0](https://github.com/maitreya2954/LeetHub-2.0-Firefox) - K-MarkLee/LeetCode-Practice

github.com

LeetCode 1207. Unique Number of Occurrences

코드 유랑자 승열 — Sat, 3 Jan 2026 16:38:24 +0900

Unique Number of Occurrences

Problem

Given an array of integers arr, return true if the number of occurrences of each value in the array is unique or false otherwise.



Example 1:

Input: arr = [1,2,2,1,1,3]
Output: true
Explanation: The value 1 has 3 occurrences, 2 has 2 and 3 has 1. No two values have the same number of occurrences.

Example 2:

Input: arr = [1,2]
Output: false

Example 3:

Input: arr = [-3,0,1,-3,1,1,1,-3,10,0]
Output: true



Constraints:

    1 <= arr.length <= 1000
    -1000 <= arr[i] <= 1000

Solution

The requirement of this problem is as follows:

Return true if the number of occurrences of each value in the array is Unique, otherwise return false

To satisfy this problem, I used a hashmap approach(Python dictionary).

First, iterate through the array and count the frequency of each number.

The statement result[i] = result.get(i,0) + 1 means: for key i, get the current value if it exists, otherwise use 0 as the default value, and then add 1.

To determine whether the frequencies are unique, use set and compare each value.

If the same value already exists in the set, return False.
Otherwise, add the value to the set and continue.
If the iteration finishes without duplication, return True

class Solution(object):
    def uniqueOccurrences(self, arr):
        result = {}

        for i in arr:
            result[i] = result.get(i, 0) + 1

        setarr = set()
        for i in result.values():
            if i in setarr:
                return False
            setarr.add(i)
        return True

Alternatively, without using iteration through set, we can compare the length of result.values() and aset(result.values()).

Since set removes duplicate values, if both lengths are the same, it means all the occurrences each values are unique.

class Solution(object):
    def uniqueOccurrences(self, arr):
        result = {}

        for i in arr:
            result[i] = result.get(i, 0) + 1

        values = result.values()
        return len(values) == len(set(values))

https://github.com/K-MarkLee/LeetCode-Practice

GitHub - K-MarkLee/LeetCode-Practice: A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2

A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2.0](https://github.com/maitreya2954/LeetHub-2.0-Firefox) - K-MarkLee/LeetCode-Practice

github.com

LeetCode 1004. Max Consecutive Ones III

코드 유랑자 승열 — Wed, 31 Dec 2025 20:59:49 +0900

Max Consecutive Ones III

Problem

Given a binary array nums and an integer k, return the maximum number of consecutive 1's in the array if you can flip at most k 0's.



Example 1:

Input: nums = [1,1,1,0,0,0,1,1,1,1,0], k = 2
Output: 6
Explanation: [1,1,1,0,0,1,1,1,1,1,1]
Bolded numbers were flipped from 0 to 1. The longest subarray is underlined.

Example 2:

Input: nums = [0,0,1,1,0,0,1,1,1,0,1,1,0,0,0,1,1,1,1], k = 3
Output: 10
Explanation: [0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1]
Bolded numbers were flipped from 0 to 1. The longest subarray is underlined.



Constraints:

    1 <= nums.length <= 105
    nums[i] is either 0 or 1.
    0 <= k <= nums.length

Solution

The key requirements of this problem are as follows:

Return the maximum number of consecutive 1s.
It is allowed to flip 0 to 1 at most k times.

To satisfy these requirements, I used a two-pointer and sliding window approach.

First, move the right pointer and check the value.
If the value is 0, decrease k.
When k becomes smaller than 0, move the left pointer until k becomes 0 again.

At the end of each iteration, caculate the window size, which represents the numver of consecutive elements in the current window.

If this value is larger than the current result, update the result.

Whe the right pointer reaches the end of the array, return the result.

class Solution(object):
    def longestOnes(self, nums, k):
        left = result = 0
        for right in range(len(nums)):
            if nums[right] == 0:
                k -= 1
            while k < 0:
                if nums[left] == 0:
                    k += 1
                left += 1
            count = right - left + 1
            if result < count:
                result = count
        return result

https://github.com/K-MarkLee/LeetCode-Practice

LeetCode 1456. Maximum Number of Vowels in a Substring of Given Length

코드 유랑자 승열 — Tue, 30 Dec 2025 19:54:46 +0900

Maximum Number of Vowels in a Substring of Given Length

Problem

Given a string s and an integer k, return the maximum number of vowel letters in any substring of s with length k.

Vowel letters in English are 'a', 'e', 'i', 'o', and 'u'.



Example 1:

Input: s = "abciiidef", k = 3
Output: 3
Explanation: The substring "iii" contains 3 vowel letters.

Example 2:

Input: s = "aeiou", k = 2
Output: 2
Explanation: Any substring of length 2 contains 2 vowels.

Example 3:

Input: s = "leetcode", k = 3
Output: 2
Explanation: "lee", "eet" and "ode" contain 2 vowels.



Constraints:

    1 <= s.length <= 105
    s consists of lowercase English letters.
    1 <= k <= s.length

Solution

The key requirement of this problem is as follows:

Return maximum number of volwel letters in any substring s with length k.

This problem can be solved simply using a sliding window approach.

First, set the initial substring s[:k] and count how many characters are vowels.

If a character is in vowels, increase the count.

After checking the first window, set this value as max_count.

If the count is equal to k, which means already maximum value, return k immediately.

After that, move the sliding window.

When s[i] is a vowel, increase the count.
When s[i - k]is a vowel, decrease the count.

At the end of each iteration, compare the current count with max_count and update it if the current count if greater.

At last, return max_count

class Solution(object):
    def maxVowels(self, s, k):
        count = max_count = 0
        vowels = set("aeiou")

        for i in s[:k]:
            if i in vowels:
                count += 1

        max_count = count
        if count == k:
            return k

        for i in range(k, len(s)):
            if s[i] in vowels:
                count += 1
            if s[i - k] in vowels:
                count -= 1

            if count > max_count:
                max_count = count
                if count == k:
                    return k

        return max_count

https://github.com/K-MarkLee/LeetCode-Practice

GitHub - K-MarkLee/LeetCode-Practice: A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2

A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2.0](https://github.com/maitreya2954/LeetHub-2.0-Firefox) - K-MarkLee/LeetCode-Practice

github.com

LeetCode 643. Maximum Average Subarray I

코드 유랑자 승열 — Tue, 30 Dec 2025 18:46:18 +0900

Maximum Average Subarray I

Problem

You are given an integer array nums consisting of n elements, and an integer k.

Find a contiguous subarray whose length is equal to k that has the maximum average value and return this value. Any answer with a calculation error less than 10-5 will be accepted.



Example 1:

Input: nums = [1,12,-5,-6,50,3], k = 4
Output: 12.75000
Explanation: Maximum average is (12 - 5 - 6 + 50) / 4 = 51 / 4 = 12.75

Example 2:

Input: nums = [5], k = 1
Output: 5.00000



Constraints:

    n == nums.length
    1 <= k <= n <= 105
    -104 <= nums[i] <= 104

Solution

The key requirements of this problem are as follows:

Find the maximum average value of a subbarray with length k
The return type must be a float.

First Attempt:

To satisfy the requirements, I first used a simple loop with slicing.

By using slicing, it is possible to calculate sum of values from index i to i + k.

Since the subarray length is fixed to k, the loop runs len(nums) - k + 1 times.

Because I am using python, this returns same type which is integer when both types are integers so I converted k to float to get a float result.

class Solution(object):
    def findMaxAverage(self, nums, k):
        result = float('-inf')
        length = len(nums) - k + 1
        for i in range(length):
            end = i + k
            result = max((sum(nums[i:end]) / float(k)),result)
        return result

Second Attempt:

However, the first approach is inefficient because slicing and summing are repeated every time.

To optimize this, I used a sliding window approach.

First, calculate the sum of the first k number of elements.
Then, while moving the window, subtract the first value of previous window and add the next value.

Since the divisor k is always the same, the division is performed only once at the end.

class Solution(object):
    def findMaxAverage(self, nums, k):
        first = sum(nums[:k])
        result = first

        for i in range(k,len(nums)):
            first += nums[i] - nums[i-k]
            result = max(result, first)
        return result / float(k)

https://github.com/K-MarkLee/LeetCode-Practice

GitHub - K-MarkLee/LeetCode-Practice: A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2

A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2.0](https://github.com/maitreya2954/LeetHub-2.0-Firefox) - K-MarkLee/LeetCode-Practice

github.com

LeetCode 1679. Max Number of K-Sum Pairs

코드 유랑자 승열 — Tue, 30 Dec 2025 17:18:30 +0900

Max Number of K-Sum Pairs

Problem

You are given an integer array nums and an integer k.

In one operation, you can pick two numbers from the array whose sum equals k and remove them from the array.

Return the maximum number of operations you can perform on the array.



Example 1:

Input: nums = [1,2,3,4], k = 5
Output: 2
Explanation: Starting with nums = [1,2,3,4]:
- Remove numbers 1 and 4, then nums = [2,3]
- Remove numbers 2 and 3, then nums = []
There are no more pairs that sum up to 5, hence a total of 2 operations.

Example 2:

Input: nums = [3,1,3,4,3], k = 6
Output: 1
Explanation: Starting with nums = [3,1,3,4,3]:
- Remove the first two 3's, then nums = [1,4,3]
There are no more pairs that sum up to 6, hence a total of 1 operation.



Constraints:

    1 <= nums.length <= 105
    1 <= nums[i] <= 109
    1 <= k <= 109

Solution

The key requirement of this problem are as follows:

Count the maximum number of pairs in the array which sum of two numbers equals k.

Unsophisticate approach for this problem is using the two-pointer method.

First, sort the array so that we can compare sum with k.

While left pointer and right pointer move toward each other, calculate the sum of the two value and compare it with k.

If the sum is eqaul to k, increase result count and move both pointers.
Otherwise, due to the sum value, if the value is smaller than k move left pointer and in other case move right pointer.

At the end of the loop, return final result value.

class Solution(object):
    def maxOperations(self, nums, k):
        nums.sort()
        left = result = 0
        right = len(nums)-1

        while left < right:
            sum_now = nums[left] + nums[right]
            if sum_now == k:
                result += 1
                left += 1
                right -= 1
            elif sum_now < k:
                left += 1
            else:
                right -= 1
        return result

https://github.com/K-MarkLee/LeetCode-Practice

LeetCode 11. Container With Most Water

코드 유랑자 승열 — Mon, 29 Dec 2025 17:16:39 +0900

Container With Most Water

Problem

ou are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]).

Find two lines that together with the x-axis form a container, such that the container contains the most water.

Return the maximum amount of water a container can store.

Notice that you may not slant the container.



Example 1:

Input: height = [1,8,6,2,5,4,8,3,7]
Output: 49
Explanation: The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49.

Example 2:

Input: height = [1,1]
Output: 1



Constraints:

    n == height.length
    2 <= n <= 105
    0 <= height[i] <= 104

Solution

The key requirement of the problem are as follows:

The array contains heights of vertical lines.
Return the maximum amount of water a container can store.
The time complexixy should not be O(n^2)

This Problem can be solved using the two-pointer approach.

The amount of water is calculated as height x width.

In this array, the height comes from the values of the two pointer, and the width is the distance between the left and right pointers.

Since the water cannot be stored higher than the shorter line, the height is determined by the smaller value between two pointers.

Using the height, calculate the current area.
If this area is larger than the stored value, update the result.

After that, move the pointer with the smaller height and repeat this process until the two pointers meet. Then return the final result.

class Solution(object):
    def maxArea(self, height):
        left = result = 0
        right = len(height) - 1

        while left < right:
            if height[left] < height[right]:
                water = height[left] * (right - left)
                result = max(water, result)
                left += 1
            else:
                water = height[right] * (right - left)
                result = max(water, result)
                right -= 1
        return result

https://github.com/K-MarkLee/LeetCode-Practice

LeetCode 382. Is Subsequence

코드 유랑자 승열 — Mon, 29 Dec 2025 16:30:43 +0900

Is Subsquence

Problem

Given two strings s and t, return true if s is a subsequence of t, or false otherwise.

A subsequence of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., "ace" is a subsequence of "abcde" while "aec" is not).



Example 1:

Input: s = "abc", t = "ahbgdc"
Output: true

Example 2:

Input: s = "axc", t = "ahbgdc"
Output: false



Constraints:

    0 <= s.length <= 100
    0 <= t.length <= 104
    s and t consist only of lowercase English letters.


Follow up: Suppose there are lots of incoming s, say s1, s2, ..., sk where k >= 109, and you want to check one by one to see if t has its subsequence. In this scenario, how would you change your code?

Solution

The key requirement of this problem is as follows:

Return true if s is a subsequence of t.

This problem can be solved using a single loop.

While iterating through the elements of t, compare each element with the current element of s.

When both elements match, increase the checked count.

At the end of the loop, if the checked count is the same as the length of string s, return true.

class Solution(object):
    def isSubsequence(self, s, t):
        checked = 0
        
        for char in t:
            if checked < len(s) and char == s[checked]:
                checked += 1
        
        return checked == len(s)

https://github.com/K-MarkLee/LeetCode-Practice

LeetCode 283. Move Zeros

코드 유랑자 승열 — Mon, 29 Dec 2025 16:08:11 +0900

Move Zeroes

Problem

Given an integer array nums, move all 0's to the end of it while maintaining the relative order of the non-zero elements.

Note that you must do this in-place without making a copy of the array.



Example 1:

Input: nums = [0,1,0,3,12]
Output: [1,3,12,0,0]

Example 2:

Input: nums = [0]
Output: [0]



Constraints:

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


Follow up: Could you minimize the total number of operations done?

Solution

The key requirements of this problem are as follows:

Move all 0 to the end of array.
Solve this probelm in-place, without creating an additional array.

To satisfy these requirements, I decided to overwrite only the non-zero numbers.

At first, I tried slove using swapping.

While iterating throught the array, when I found a 0, I searched for the next non-zero element and swapped their positions, then continued this process.

However, the biggest problem with this approach was time complexity

Because this method does not immediately move 0s to the end, when the size of nums becomes largem it ends up doing too many repeated swaps, which makes it inefficient.

Therefore, I chose a simpler approach.

I overwrite the array by placing all non-zero numbers at the front.

After that, based of the length of the array, I filled left of the positions with 0s.

class Solution(object):
    def moveZeroes(self, nums):
        notzero = 0

        for i in range(len(nums)):
            if nums[i] != 0:
                nums[notzero] = nums[i]
                notzero += 1

        while notzero < len(nums):
            nums[notzero] = 0
            notzero += 1

https://github.com/K-MarkLee/LeetCode-Practice

LeetCode 443. String Compression

코드 유랑자 승열 — Fri, 26 Dec 2025 21:00:12 +0900

String compression

Problem

Given an array of characters chars, compress it using the following algorithm:

Begin with an empty string s. For each group of consecutive repeating characters in chars:

    If the group's length is 1, append the character to s.
    Otherwise, append the character followed by the group's length.

The compressed string s should not be returned separately, but instead, be stored in the input character array chars. Note that group lengths that are 10 or longer will be split into multiple characters in chars.

After you are done modifying the input array, return the new length of the array.

You must write an algorithm that uses only constant extra space.

Note: The characters in the array beyond the returned length do not matter and should be ignored.



Example 1:

Input: chars = ["a","a","b","b","c","c","c"]
Output: Return 6, and the first 6 characters of the input array should be: ["a","2","b","2","c","3"]
Explanation: The groups are "aa", "bb", and "ccc". This compresses to "a2b2c3".

Example 2:

Input: chars = ["a"]
Output: Return 1, and the first character of the input array should be: ["a"]
Explanation: The only group is "a", which remains uncompressed since it's a single character.

Example 3:

Input: chars = ["a","b","b","b","b","b","b","b","b","b","b","b","b"]
Output: Return 4, and the first 4 characters of the input array should be: ["a","b","1","2"].
Explanation: The groups are "a" and "bbbbbbbbbbbb". This compresses to "ab12".



Constraints:

    1 <= chars.length <= 2000
    chars[i] is a lowercase English letter, uppercase English letter, digit, or symbol.

Solution

The key requirements of this problem are as follows:

Count consecutive reapeating characters and overwrite the result in the original array.
The count must be stored as individual characters.
Return the total length of the compressed array.

To satisfy these requirements, the solution modifies the input charsarray in place without using any additional data structure.

There fore, two pointers are used : read and write

While iterating through the array, the read pointer counts how many times the same character appears consecutively.

Once the end of a group is reached, the character is written to chars[write], and the writepointer is incremented.

After all characters have been processed, the value of write represents the length of the compressed array.

class Solution(object):
    def compress(self, chars):
        write = read = 0
        n = len(chars)

        while read < n:
            char = chars[read]
            count = 0

            while read < n and chars[read] == char:
                read += 1
                count += 1

            chars[write] = char
            write += 1

            if count > 1:
                for digit in str(count):
                    chars[write] = digit
                    write += 1

        return write

https://github.com/K-MarkLee/LeetCode-Practice

LeetCode 334. Increating Triplet Subsequence

코드 유랑자 승열 — Fri, 26 Dec 2025 19:26:16 +0900

Increating Triplet Subsequence

Problem

Given an integer array nums, return true if there exists a triple of indices (i, j, k) such that i < j < k and nums[i] < nums[j] < nums[k]. If no such indices exists, return false.



Example 1:

Input: nums = [1,2,3,4,5]
Output: true
Explanation: Any triplet where i < j < k is valid.

Example 2:

Input: nums = [5,4,3,2,1]
Output: false
Explanation: No triplet exists.

Example 3:

Input: nums = [2,1,5,0,4,6]
Output: true
Explanation: One of the valid triplet is (1, 4, 5), because nums[1] == 1 < nums[4] == 4 < nums[5] == 6.



Constraints:

    1 <= nums.length <= 5 * 105
    -231 <= nums[i] <= 231 - 1


Follow up: Could you implement a solution that runs in O(n) time complexity and O(1) space complexity?

Solution

Due to the time complexity requirement, using a double which is the easiest way would be too slow.

So instead, I tried to solve it in one pass by tracking two numbers: first and second.

I initialized them with a very large value (like max(nums)) so they can easily be updated.

While scanning the array, if the current number is smaller than or equal to first, override first.

Otherwise, if it is smaller than or equal to second, override second.

If the current number is larger than both first and second, that means I found an increasing triplet.

At first, I use max(nums) for initialization, but max also read all the list once so the time compleity becomes O(2n).

Therefore, I use float('inf') to avoid extra pass.

class Solution(object):
    def increasingTriplet(self, nums):
        first = second = float('inf')

        for i in nums:
            if first >= i:
                first = i
            elif second >= i:
                second = i
            else:
                return True
        return False

https://github.com/K-MarkLee/LeetCode-Practice

GitHub - K-MarkLee/LeetCode-Practice: A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2

A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2.0](https://github.com/maitreya2954/LeetHub-2.0-Firefox) - K-MarkLee/LeetCode-Practice

github.com

LeetCode 238. Product of Array Except Self

코드 유랑자 승열 — Fri, 26 Dec 2025 15:30:35 +0900

Product of Array Except Self

Problem

Given an integer array nums, return an array answer such that answer[i] is equal to the product of all the elements of nums except nums[i].

The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer.

You must write an algorithm that runs in O(n) time and without using the division operation.



Example 1:

Input: nums = [1,2,3,4]
Output: [24,12,8,6]

Example 2:

Input: nums = [-1,1,0,-3,3]
Output: [0,0,9,0,0]



Constraints:

    2 <= nums.length <= 105
    -30 <= nums[i] <= 30
    The input is generated such that answer[i] is guaranteed to fit in a 32-bit integer.



Follow up: Can you solve the problem in O(1) extra space complexity? (The output array does not count as extra space for space complexity analysis.)

Solution

What this problem requires are:

Multiply all other nums in nums array without itself in loop
Time complexity must be O(n)

At first, the problem just requires multiply all the numbers except itself.

However, doing this with a loop would clearly takesO(n²) time.

After I check the hint and it mentioned:

Think how you can efficiently utilize prefix and suffix products to calculate the product of all elements except self for each index. Can you pre-compute the prefix and suffix products in linear time to avoid redundant calculations?

Then I realize that for each index, what is really need is multiply left and right side of specific number.

So, I decided to calculate the product of all elements from left to right first.

One import detail was to hangle the first and last index.

There is no value before and after first and last index, i replace as 1.

class Solution(object):
    def productExceptSelf(self, nums):
        n = len(nums)
        result = [1]* n

        prefix = 1
        for i in range(n):
            result[i] = prefix
            prefix *= nums[i]

        suffix = 1
        for i in range(n -1, -1, -1):
            result[i] *= suffix
            suffix *= nums[i]

        return result

https://github.com/K-MarkLee/LeetCode-Practice

GitHub - K-MarkLee/LeetCode-Practice: A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2

A collection of LeetCode questions to ace the coding interview! - Created using [LeetHub 2.0](https://github.com/maitreya2954/LeetHub-2.0-Firefox) - K-MarkLee/LeetCode-Practice

github.com

LeetCode 605.Can Place Flowers

코드 유랑자 승열 — Wed, 24 Dec 2025 20:39:24 +0900

Can Place Flowers

Problem

You have a long flowerbed in which some of the plots are planted, and some are not. However, flowers cannot be planted in adjacent plots.

Given an integer array flowerbed containing 0's and 1's, where 0 means empty and 1 means not empty, and an integer n, return true if n new flowers can be planted in the flowerbed without violating the no-adjacent-flowers rule and false otherwise.



Example 1:

Input: flowerbed = [1,0,0,0,1], n = 1
Output: true

Example 2:

Input: flowerbed = [1,0,0,0,1], n = 2
Output: false



Constraints:

    1 <= flowerbed.length <= 2 * 104
    flowerbed[i] is 0 or 1.
    There are no two adjacent flowers in flowerbed.
    0 <= n <= flowerbed.length

Solution

First Attempt:

The initial idea was as follows:

Identify segments of consecutive 0s in the flowerbed.
Since flowers cannot be planted in adjacent plots, cacluate the number of connected 0s and determine whether n flowers can be planted.

What I tried was to count the number of connected 0s in the flowerbed and return true when the count was greater than or equal to (n * 2) - n

The issue with this approach were:

First, it did not properly handle dege plots.

Second, it did not update the flowerbed after planting a new flower.

Second Attempt:

In the second approach, I compared the left and right plots for each position.

For edge cases, I handled them seperatly.

class Solution(object):
    def canPlaceFlowers(self, flowerbed, n):
        count = 0
        for i in range(len(flowerbed)):
            if flowerbed[i] == 0:
                left = (i == 0 or flowerbed[i-1] == 0)
                right = (i == len(flowerbed) - 1 or flowerbed[i+1] == 0)

                if left and right:
                    flowerbed[i] = 1
                    count += 1

        return count >= n

https://github.com/K-MarkLee/LeetCode-Practice

LeetCode 1071. Greatest Common Divisor of Strings

코드 유랑자 승열 — Tue, 23 Dec 2025 21:13:50 +0900

Greatest Common Divisor of Strings

GCD / Euclidean Algorithm

Problem

For two strings s and t, we say "t divides s" if and only if s = t + t + t + ... + t + t (i.e., t is concatenated with itself one or more times).

Given two strings str1 and str2, return the largest string x such that x divides both str1 and str2.



Example 1:

Input: str1 = "ABCABC", str2 = "ABC"

Output: "ABC"

Example 2:

Input: str1 = "ABABAB", str2 = "ABAB"

Output: "AB"

Example 3:

Input: str1 = "LEET", str2 = "CODE"

Output: ""

Example 4:

Input: str1 = "AAAAAB", str2 = "AAA"

Output: ""



Constraints:

    1 <= str1.length, str2.length <= 1000
    str1 and str2 consist of English uppercase letters.

Solution

First Attempt:

This problem requires two main steps.

Check whether two strings share a repeating pattern.
Find the smallest possible pattern that can generate both strings.

The key idea that if two strings are made from the same pattern,changing the order of concatenation should not change the result.

Therefore, str1+str2 != str2+str1 can filter out strings that do not share same pattern.

To find the smallest possible pattern in these two strings, we use the greatest common divisor of the lengths of the two strings.

This is done using the Euclidean Algorithm, which repeatedly calculates remainders until the second value becomes zero.

The remaining value is the greatest common divisor.

class Solution(object):
    def gcdOfStrings(self, str1, str2):
        if str1 + str2 != str2 + str1:
            return  ""

        def gcd(a,b):
            while b:
                a, b = b , a % b
            return a

        length = gcd(len(str1), len(str2))
        return str1[:length]

https://github.com/K-MarkLee/LeetCode-Practice

LeetCode 383. Ransom Note

코드 유랑자 승열 — Tue, 23 Dec 2025 18:24:43 +0900

Ransome Note

Brute force / Counter

Problem:

Given two strings ransomNote and magazine, return true if ransomNote can be constructed by using the letters from magazine and false otherwise.

Each letter in magazine can only be used once in ransomNote.



Example 1:

Input: ransomNote = "a", magazine = "b"
Output: false

Example 2:

Input: ransomNote = "aa", magazine = "ab"
Output: false

Example 3:

Input: ransomNote = "aa", magazine = "aab"
Output: true



Constraints:

    1 <= ransomNote.length, magazine.length <= 105
    ransomNote and magazine consist of lowercase English letters.

Try:

First Try: Brute force

I tried to extract each character from ransomNote and compare it with the characters in magazine.

When a character from ransomNote matches one in magazine, I replace specific character from margazine and override it.

If all characters from ransomNote are sucessfully matched and covers by magazine, returns True.

Otherwise, it returns False

-- However, this attempt has a time complexity if O(N x M) , and it can be optimized.

class Solution(object):
    def canConstruct(self, ransomNote, magazine):
        for char in ransomNote:
            if char in magazine:
                magazine = magazine.replace(char, "", 1)
            else:
                return False

        return True

Second Try: Hash Map

I find the method to solve this problem by HashMap.

A dictionary is used to store all the characters from magazine and count the amount.

Each characters in ransomNote is compared againse the dictionary.

If the character exists, decrease its count in the dictionary.

When all characters in randomNote are successfully processed, the function returns True;
otherwise, it returns False

class Solution(object):
    def canConstruct(self, ransomNote, magazine):
        magazine_counts = {}

        for char in magazine:
            if char in magazine_counts:
                magazine_counts[char] += 1 
            else:
                magazine_counts[char] = 1

        for char in ransomNote:
            if char not in magazine_counts or magazine_counts[char] <= 0:
                return False
            magazine_counts[char] -= 1

        return True

Third Try: List

There is a similar method that solves this problem using a list .

by using the ordfunction, each character in magazine is mapped to an index and the restore the count by

frequency of chatacter.

Each character in ransomNote is then processed same way.

class Solution(object):
    def canConstruct(self, ransomNote, magazine):
        counts = [0] * 26

        for char in magazine:
            counts[ord(char) - ord('a')] += 1

        for char in ransomNote:
            index = ord(char) - ord('a')

            if counts[index] == 0:
                return False

            counts[index] -= 1

https://github.com/K-MarkLee/LeetCode-Practice

백준 파이썬 코딩테스트 (대표값2)

코드 유랑자 승열 — Fri, 17 Oct 2025 08:26:39 +0900

백준 2587번 문제

대표값2

문제

풀이

이 문제의 요구조건은 아래와 같다.

1. 다섯번째 줄 까지 각 N의 인풋을 가지고 평균과 중앙값을 출력하라.

이 문제에서 생각해야할 점은 딱 2가지이다.

평균, 중앙값 이다.

만약 이 문제가 각 줄이 랜덤하게 설정이 되어있다면 말이 다르겠지만, 현재로써는 무조건 5개의 숫자만이 존재한다.

이는 이를 그저 리스트로 받고 리스트의 sum에 5를 나누게 되면 이는 평균이 된다.

중앙값은 조금 다르다.

중앙값의 경우에는 2가지의 조건이 필요한데 이는 숫자의 갯수에 따라 달라진다.

하지만 현재는 5개의 인풋이 고정된 상태이기 때문에, 정렬 후 리스트의 2번째 인덱스의 값을 불러오면 된다.

결과

import sys
L = list(map(int,sys.stdin.read().strip().split()))

print(f"{sum(L)//5}\n{sorted(L)[2]}")

https://github.com/K-MarkLee/Coding_Test/tree/main/%EB%B0%B1%EC%A4%80/Bronze/2587.%E2%80%85%EB%8C%80%ED%91%9C%EA%B0%922

구름 프로펙트 TIL (2025.10.16)

코드 유랑자 승열 — Thu, 16 Oct 2025 22:04:29 +0900

실수를 반복하지 말자

소감

오늘도 긴 하루가 지나갔다.

오늘은 많이 팀원들에게 부끄러운 시간을 가져서 개인적으로는 많이 힘들었다.

회의를 맡아 녹음하고 정리하기로 했는데 두번씩이나 녹음을 하지 못하였다.

중요한 강사님 피드백시간에는 팀장님이 어느정도 녹음을 하셔서 다행이다.

하루가 멀다 할수록 공부할 거리가 늘고... 나의 실력은 점점 바닥을 드러내고 있다.

그래도... 열심히 하고싶고 해보고 싶다.

오늘 한 일

오늘 사실은 상세 기능 명세서에 대해서 마무리 작업을 하게 되었다.

MVP개발을 이제 ai에게 맡기고 우리는 빠르게 최적화로 넘어가려고 플랜을 세우다 보니까

디테일하게 기능 명세서를 하고 난 다음에 개발을 넘어가는 것이 매우 좋겠다고 의견이 나왔다.

아마 이 중에서는 검색쪽을 2차 3차때 최적화 하지 않을가 싶다.

오후의 일이지만, 강사님께서는 내가 자바를 지금 배우고 있는 입장에서 es로 바로 하기에는 좀 많이 무리가 있지 않겠냐 해서

MySQL혹은 MariaDB로 MVP를 하고 2차 3차 가서 최적화를 하는 것도 좋을것 같다고 하셧다.

오전에는 내가 이전에 사용했던 anima라는 툴을 사용해서 무신사의 페이지를 클론코딩하여 프론트로 치환도 하였다.

우리는 사실 이 툴을 보고 좀더 일정을 빠르게 가져가려고 했다. 프론트에 시간을 많이 쏟지 않고 백엔드 개발도 빠르게 ai를 사용해서 처리한다면 최적화에 시간을 더 많이 사용 할 수 있지 않을가 했기 때문이다.

오후에는 erd를 작성하기 시작했다.

사실 초반까지는 너무 디테일하게 erd를 잡을 생각을 계속해서 머리가 아팠는데

물론 그 이유도 있지만, 내가 erd에 대한 전반적인 이해도가 너무 많이 떨어지는 것 도 있다.

처음에는 identifying도 몰랐도 종속성이나 pk니 fk니 들어는 봣지만 정확하게 명확하게 할 줄 몰랏다.

사실 지금도 마찬가지 이지만 현재시점에서는 어떻게든 나의 파트를 마무리 하긴 했다. (정확한지는 모르겠다)

하면할수록 해야할게 많고

그만큼 집중도 안되고 우선순위도 못잡고 하다보니까

내가 꼭해야 할 일도 못한것 같아서 매우 아쉽다.

회의 녹음은 내가 담당을 맡아서 한다고 하고 나머지는 솔찍히 다른분께 양해를 구하고 하는 편이 좋을거 같다.

구름 프로펙트 TIL (25.10.15)

코드 유랑자 승열 — Wed, 15 Oct 2025 21:57:02 +0900

매일 매일 새로운 도전의 시작

소감

오늘도 또 하나의 도전이 생기는것 같다.

내가 지금까지 해온것은 파이썬 기반으로한 프로그래밍 언어였는데,

이제는 springboot 즉 자바 기반을 사용하여 프로젝트를 해야한다.

2달 남짓한 시간에 새로운 언어로 고도화까지 해야한다고 생각하니 눈앞이 막막하다.

하지만 집도 가까운데 하루종일 하다보면 어떻게 잘 되지 않을가 싶다.

처음 drf배울때도 그랬지만, 강의가 5시간이라도 하다보면 10시간 15시간 이렇게 지나가는거같다.

열심히 해야겠다.

오늘 한 일

오늘은 기능명세서를 작성했다.

각각의 파트를 나눠서 기능명세서를 작성을 했고, MVP를 구별했다.

나는 이때, 회원관리를 맡았는데 사실 이 부분에 대해서는 고도화 할 수 있는 부분이 없어서 따른 메인 파트를 맡아야 했다.

사실 내가 좀 생각한 부분은 AI를 어떻게든 사용하고자 했지만, 문제는 데이터이다.

이커머셜에서의 추천 시스템을 구현을 해보려고 해도, 실제의 데이터가 없는 상태에서의 구현은 어불성설이다.

그러한 고로 새로운 다른 메인 파트를 찾아야 한다.

아마도 내가 생각하는것은 제품관리 및 리뷰 쪽이며 이에 고도화를 하게 된다면 카테고리나 검색쪽이 될 것이다.

어떠한 데이터에서 카테고리분류나 검색에서 고도화를 하기위에서 어떤 데이터를 참조할건지 테이블이나 기술등 알고리즘으로 최적화를 깊게 팔 수 있는것 같다.

지금까지는 일부의 데이터. 즉 몇십개 만큼의 테스트만 해왔었는데

이제는 내가 직접 대규모 트레픽처리를 한다고 가정을 하고 테스트를 하고 고도화를 해야하기 떄문에

이러한 상황에서 파이썬이 굉장히 불리 한 것이다.

일반적인 최적화를 한다면 몇만건 이렇게 들어와 버린다면 생각보다 시간이 오래 걸릴 수 있다.

이는 실제 서비스시, 시간이 너무 오래 걸린다면 사용자의 이탈을 야기하기 때문에, 이는 문제가 많다는 것이다.

이러한 것들을 2달동안 배우면서 한층 성장해나가겠다.

회고

오늘의 회고는 나의 목표를 두개씩이나 이루지 못 한 것이다.

1. 코테풀기. (코테를 풀 시간이 좀 없었는데 내일부터는 오전에 와서 코테 한문제 먼저 시작하는걸로 해보겠다)

2. 제일 마지막으로 나가기.

2번은 큰 이유는 없다만 오늘은 조금 이르게 집에 가서 하고 싶은 맘이다.

현재시간 22시 오늘은 이만 마무리 하도록 하겠다.

구름 프로펙트 TIL (25.10.14 - D+1)

코드 유랑자 승열 — Tue, 14 Oct 2025 21:08:17 +0900

타협하지말고 욕심을 부리자

오늘은 구름 프로펙트의 첫날이다.

OT를 진행했고, 기본적인 프로펙트 2개월간의 진행에 대한 설명이 주를 이뤘으며, 과정중 지원을 받을 수 있는 부분과,

주의사항등을 안내받았다.

중요한 변경점이 있다면, 지금껏 사용하던 윈도우 랩탑을 벗어나 맥을 사용한다는 것이다.

일반적인 기능개발에서 만족하는 기존의 방식에서는 크게 상관이 없지만,

교육과정내의 배포에 따른 최적화를 할 때, 사용하는 프로그램이나 시스템적인 테스트를

윈도우에서는 아무리 최적화를 하고 해도, 배포환경인 aws에서는 리눅스 기반으로 많이 다를것이라는 의견.

그러하여 맥을 사용하면 거의 동일한 환경에서의 패키지관리와 배포설정을 가능케 하여 좀더 최적화를 할 수 있다는 의견으로 맥을 처음 접하게됬다.

물론 맥을 쓰는것만으로도 머리가 아플 만큼 쉽지않다.

오늘한 것

1. 프로젝트 러프 도메인 토론

프로젝트의 도메인을 이커머셜로 지정. 이는 큰 범위에서 팀원들의 각각 원하는 바를 전부 담을 수 있을거 같고, 백엔드에 조금 더 치중된 개발의 선호가 기존 이커머셜의 클론코딩후 고도화를 할때 성능의 차이를 크게 느낄 수 있고 데이터를 모으기 쉬운 이커머셜로 선정함.

나는 이에 ai쪽 기술을 사용하고 싶어 추천기능 및 요리를 입력하면 그에맞는 재료를 찾아주는등으로 아이디어를 냄.

추천기능으로 좁혀서 리서치를 진행했는데, 생각보다 딥해서 쉽지 않을 수 있겠다 생각.

2. 새로 찾은 매니지먼트 툴 비교

이번에 알게된 superthread와 기존의 jira를 비교하여 어떤 걸 사용하면 좋을지 비교를 함.

기본적으로 우리의 목표인 실전경험을 얻기 위해서는 실제로 기업들이나 실무에서 많이 사용하는 툴인 jira를 사용하는게 맞다는 리서치 결과.

이유인 즉슨 superthread는 아직 신생 플랫폼으로 학습하고 참고할만한 데이터가 적다는점.

superthread가 추구하는 ai를 이용한 자동화는 우리 프로젝트의 목적과 엇나간다는점.

jira가 에자일 방법론에 따른 도구들을 완벽하게 지원하는 등의 이유로 jira를 설정하는게 맞다는 결론.

회고

생각보다 프로펙트 2개월의 시간이 쉽지않을 것 같다는 생각을 한다.

처음에는 기능구현을 통해서 좀더 기능적으로 접근하고 이를 강화하는 정도에 머물것이라고 생각했지만,

실제 배포를 한다 가정하여 부하도 검사 및 최적화를 끝까지 딥게파서 수준을 올리는 것을 목표로 하는 것이었기에

자신감은 박살이남.

하지만 이런편이 내가 프로펙트를 지원하게된 나의 객관적인 실력을 파악하게하고, 바쁘게 공부하고 치열하게 개발하는것이 나에게 도움이 될 것이라는 생각이다.

이에 나는 목표를 세웠다.

이 프로펙트 기간에서 할수 있는 최선을 다한다.

ai를 최소한으로 가져가면서 학습과 생산성 모두를 추구하겠다.

최대한 남아서 마지막까지 하다 가며, 가장 처음으로와서 준비하겠다.

백준 파이썬 코딩테스트 (수 정렬하기)

코드 유랑자 승열 — Tue, 14 Oct 2025 09:01:52 +0900

백준 2750번 문제

수 정렬하기

문제

풀이

이 문제의 요구조건은 아래와 같다.

1. 첫줄의 인풋값N은 아래에 나올 숫자들의 갯수이다.

2. 첫줄N의 갯수만큼 있는 숫자를 한줄씩 크기 순서대로 출력하라.

이 문제는 사실 첫번째 인풋을 사용하지 않고도 풀 수 있다.

map으로 변수 지정할때, N, *M으로 하면 첫번째 값은 N으로 나머지는 전부 M으로 간다.

이러면 자연스럽게 M에 N제외 모든 수가 들어가고, 이를 sort로 정렬한다.

이때 num in M으로 반복하여 프린트를 하거나,

print('\n'.join(map(str,M)))을 한다.

결과

import sys
N, *M = map(int,sys.stdin.read().strip().split())

M.sort()

print('\n'.join(map(str,M)))

Coding_Test/백준/Bronze/2750. 수 정렬하기 at main · K-MarkLee/Coding_Test · GitHub

Coding_Test/백준/Bronze/2750. 수 정렬하기 at main · K-MarkLee/Coding_Test

This is an auto push repository for Baekjoon Online Judge created with [BaekjoonHub](https://github.com/BaekjoonHub/BaekjoonHub). - K-MarkLee/Coding_Test

github.com

백준 파이썬 코딩테스트 (설탕배달)

코드 유랑자 승열 — Mon, 13 Oct 2025 21:20:41 +0900

백준 2839번 문제

설탕배달

문제

풀이

이 문제의 요구조건은 아래와 같다.

1. 인풋 N은 무게이다. 이때, 3키로봉지와 5키로 봉지를 사용하여 최소갯수로 모든 무게를 담을 수 있을때, 그 최소갯수를 출력하라.

2. 만약 무게가 딱 떨어지지 않는다면 -1을 출력하라.

이 문제도 2가지 방법으로 풀 수 있을거 같은데 한개밖에 우선은 모르겠다.

내가 생각한 첫번째 방법은

무조건 최소값을 출력해야하니까 5키로 봉지에 최대한 담아야 한다는것을 이용해서

N을 무조건 5로 먼저 나눈다. divmod를 사용하면, 몫 과 나머지를 얻을 수 있다.

이때 나머지가 0이면 몫을 출력한다.

보통은 나머지가 생길 것이다.
이때, 나머지가 3이 아닌 경우에는 5키로 봉지의 몫을 뺀다.

즉 n이 16일때 5로 나누게 되면 3과 1이 나오는데,

이때 나머지가 1이니까 5x2로 하고 나머지를 6으로 만든다.

이때 그 나머지가 3의 배수면 카운트해서 출력한다.

이때 5키로 봉지의 갯수가 0인데도 3의 배수가 아니라면 -1을 출력한다. (이는 5와 3으로 만들 수 없는 수)

생각해보니 반복문을 사용할때는 i가 0부터 올라가는 편이 훨씬 사용하기가 편하다

왜냐면 5의 최대치에서부터 빼는것에는 5의 최대치를 미리 계산해야하기 때문.

그래서 반복문 i 를 3에 곱한 후 divmode로 5로 나눴을때의 몫과 나머지를 사용하여 계산하는것으로 변경.

문제를 틀려서 보니, i를 1부터 시작했다 ㅎㅎ

내가 생각해두고도 5의 배수로만 되있을 수 있는 수의 경우를 제거해버린 셈이다.

결과

import sys
N = int(sys.stdin.read().strip())
result = -1
for i in range(N//3+1):
    a, b = divmod(N-3*i,5)
    if b == 0 :
        result = a+i
        break
print(result)

다행이 이번에는 44ms로 나왔다.

Coding_Test/백준/Silver/2839. 설탕 배달 at main · K-MarkLee/Coding_Test · GitHub

Coding_Test/백준/Silver/2839. 설탕 배달 at main · K-MarkLee/Coding_Test

This is an auto push repository for Baekjoon Online Judge created with [BaekjoonHub](https://github.com/BaekjoonHub/BaekjoonHub). - K-MarkLee/Coding_Test

github.com

백준 파이썬 코딩테스트 (영화감독 숌)

코드 유랑자 승열 — Thu, 9 Oct 2025 16:39:20 +0900

백준 1436번 문제

영화감독 숌

문제

풀이

이 문제의 요구사항은 아래와 같다.

1. 입력값 N을 받았을때, 666이 들어가는 숫자를 작은순서대로 나열했을때의 N번째의 숫자를 출력하라.

이는 쉽게
666 > 1666 > 2666 > 3666

이런식으로 갈 것 같지만, 5666 이후는 6666 보다 6661 이 더 작기 때문에 서치를 해야한다.

아마 계산을 하는건 잘 모르겠고, 브루탈 포스를 이용한다면, N은 10000보다 작거나 같은 자연수 이기 때문에

result= []리스트를 만들어서 모든 666이 들어간 숫자를 1부터 10000까지 서치해서 저장한다.

이때, N이 들어오면, result[n-1]을 출력하면 될 것같다.

이때, 투포인터를 사용을 해봐도 좋을 듯 싶다.

문제가 투포인터를 사용하면 범위 설정에 문제가 있다. 왜냐면 N이 10000이지 최대값이 100000이 아니기 때문.

이는 명백한 문제파악의 실수이다 ㅜ

그러면 투포인터를 사용하지 않고 그대로 하면 된다.

이때, 1번 방식처럼 모든 숫자를 미리 넣고 N-1로 찾는게 아닌

N-1 번 까지만 찾으면 된다.

즉 조건을 넣어서 len(result) == N-1: break 하게 한다.

결과

n = int(input())
c, i = 0, 0
while c != n:
    if i%10 != 6:
        t = i*1000 + 666
        c += 1
    else:
        six, tmp = 1, i
        while tmp%10 == 6:
            six *= 10
            tmp //= 10
        
        for j in range(six):
            t = i*1000 + 666//six*six + j
            c += 1
            if c == n: break
    i += 1
print(t)

Coding_Test/백준/Silver/1436. 영화감독 숌 at main · K-MarkLee/Coding_Test · GitHub

Coding_Test/백준/Silver/1436. 영화감독 숌 at main · K-MarkLee/Coding_Test

This is an auto push repository for Baekjoon Online Judge created with [BaekjoonHub](https://github.com/BaekjoonHub/BaekjoonHub). - K-MarkLee/Coding_Test

github.com

백준 파이썬 코딩테스트 (체스판 다시 칠하기)

코드 유랑자 승열 — Thu, 9 Oct 2025 14:48:54 +0900

백준 1018번 문제

체스판 다시 칠하기

문제

풀이

이 문제의 요구조건은 아래와 같다.

1. 인풋의 두 숫자는 n x m 사이즈의 입력값을 의미한다.

2. 이때, n x m의 사이즈 중 8 x 8의 사이즈의 체스판을 필요로 한다.

3. 이 8 x 8의 사이즈 중 가장 적게 색을 칠해야 하는 경우, 그 숫자를 출력한다.

이 문제를 풀기 위해서는 2가지의 경우를 모두 체크해야한다.

하나는 wb시작 그리고 다른 하나는 bw시작이다.

우선은 먼저 각각wb와 bw의 리스트를 만든다.

"WBWBWBWB""BWBWBWBW"을 x 4해서 wb를

"BWBWBWBW""WBWBWBWB"를 x 4해서 bw를 만든다.

그 후 인풋값을 받는다.

이때, 온전하게 비교를 하기 위해 줄을 살려야 함으로
인풋을 받을때는 N을 사용해서 list = [input() for _ in range(N)]으로 받는다.

이는 몇줄까지 받을지를 의미한다.

그 후,

이미 8 x 8의 사이즈를 비교하는것이니, n과 m에 -7을 해야한다.

인덱스는 0 부터 라서 그렇다.

그 후 2중 반복문을 통해서 list[i][j] 일때, wb나 bw의 [i][j]를 검사한다.

이때 틀린 경우를 매개변수로 저장하고, 최대치와, wb그리고 bw를 비교 (min을 사용)

이때 최대치를 사용하는 이유는 글로벌로 저장해야하기 때문.

그냥 i와 j를 좌표로 하면 문제가 생긴다.

문제를 풀다보니 생긴 문제가 i 와 j는 그저 8 x 8의 범위를 설정 한 것이었다.

그러면 그 8 x 8 범위 안에서의 좌표값을 따로 구해야 한다.

이는 그럼 그 안에 2중 반복문을 한개 더 만들어야 함을 뜻한다.

x 와 y를 추가하여 list[x][y]와 wb그리고 bw와 비교를 해야 함이 맞다.

여기서도 단순하게 x와 y가 아니라 8 x 8의 좌표는 계속 움직일 테니

i+x와 j+y가 됨이 맞다.

결과

import sys

N, M = map(int,sys.stdin.readline().strip().split())
num = [sys.stdin.readline().strip() for _ in range(N)]

wb = ["WBWBWBWB","BWBWBWBW"]*4
bw = ["BWBWBWBW","WBWBWBWB"]*4
result = 64

for i in range(N-7):
    for j in range(M-7):
        wb_count = 0
        bw_count = 0
        for x in range(8):
            for y in range(8):
                if num[i+x][j+y] != wb[x][y]:
                    wb_count += 1
                if num[i+x][j+y] != bw[x][y]:
                    bw_count += 1
                    
        result = min(wb_count, bw_count, result)

print(result)

Coding_Test/백준/Silver/1018. 체스판 다시 칠하기 at main · K-MarkLee/Coding_Test · GitHub

Coding_Test/백준/Silver/1018. 체스판 다시 칠하기 at main · K-MarkLee/Coding_Test

This is an auto push repository for Baekjoon Online Judge created with [BaekjoonHub](https://github.com/BaekjoonHub/BaekjoonHub). - K-MarkLee/Coding_Test

github.com

백준 파이썬 코딩테스트 (수학은 비대면강의입니다)

코드 유랑자 승열 — Fri, 26 Sep 2025 15:09:37 +0900

백준 19532번 문제

수학은 비대면강의입니다

문제

풀이

이 문제의 요구사항은 아래와 같다.

1. 연립방정식이 존재하고 이 a,b,c,d,e,f에 맞는 숫자가 인풋으로 들어온다.

2. 이때, 문제의 정답인 x와 y를 출력해라.

이 문제의 풀이 방법은 2개로 나뉠 수 있다.

이 문제의 항목 자체가 부르탈 포스 즉 모든 가능성을 탐색 하는것 이기 때문에 조건에 있는 -999에서 999 아래의 정수를 모두 대입해서 찾는것과, 다른 1개는 실제로 연립방적식의 풀이를 그대로 차용해서 푸는 방법이다.

시간초가 1초이지만 범위가 -999 에서 999 이기 때문에 그렇게 많은 범위를 탐색하지 않아서 가능하지 않을가 싶다.

우선은 연립방정식에 대해서 먼저 공부를 해봤다.

저렇게 두 식이 존재하면 다른 하나의 식에서 x나 y를 가지고 하나의 식에 대입하여 x내지는 y를 특정하는 방식이다.

1번식을 사용해서 x를 구하면, x = c-by//a가 된다.

이때, dx+ey=f에 대입을 하자면

d(c-by//2)+ey-f가 된다.

dc-dby+eay=fa

-dby+eay = fa-dc

y(-db+ea) = fa-dc

즉 y = fa-dc // ea-db가 된다.

이를 x = c-by//a에 넣고 계산을 하게되면, 결국 x = ce-bf//ea-db가 된다.

이를 이용해서 x와 y를 구할 수 있고 아니면 그냥 -999에서 999까지의 모든 수를 넣었을때,
ax+by=c 그리고 dx+ey=f에 해당하는 x와 y를 구한다. 이는 2중 루프로 n^2만큼 만 탐색하면 된다.

결과

1. 순차적 탐색 방법

import sys
a,b,c,d,e,f = map(int,sys.stdin.read().strip().split())

for i in range(-999,1000):
    for j in range(-999,1000):
        if (a*i)+(b*j)==c and (d*i)+(e*j)==f:
            print(f"{i} {j}")

2. 식으로 계산 방법

import sys
a,b,c,d,e,f = map(int,sys.stdin.read().strip().split())

print(f"{((c*e)-(b*f))//((e*a)-(d*b))} {((f*a)-(d*c))//((e*a)-(d*b))}")

Coding_Test/백준/Bronze/19532. 수학은 비대면강의입니다 at main · K-MarkLee/Coding_Test

This is an auto push repository for Baekjoon Online Judge created with [BaekjoonHub](https://github.com/BaekjoonHub/BaekjoonHub). - K-MarkLee/Coding_Test

github.com

파이썬 (탐색 범위 최적화)

코드 유랑자 승열 — Thu, 25 Sep 2025 18:02:36 +0900

파이썬 탐색 범위 최적화

에 대해서 알아보자

이것은 이전 코딩테스트 문제의 풀이들을 보고 gpt와 공부를 통해 알게된점을 나열한다.

파이썬의 탐색 범위

파이썬에서는 탐색을 하는 경우가 매우 많다.

어떠한 한 값을 찾기위해서 모든 조건을 탐색하고, 조건을 위한 한 값을 찾기 위해 탐색을 하는 경우도 많다.

이 탐색은 탐색은 기본적으로 정직하게 조건에따라 실행횟수가 정해져 있다.

즉 2중반복문의 탐색이라면, 각 반복문의 범위의 곱셈만큼 반복을 하게 될 것이다.

하지만 이때, 이 탐색의 범위를 줄일 수 있다면 어떨가?

이는 파이썬 2231번 문제 분해합을 통해서 한번 보자.

2231번: 분해합

이 문제는 자연수 N의 최소 생정자를 찾으면 된다.

생성자란, 특정숫자+ 그 숫자 의 각 자리의 합이 N이 되는 수를 의미한다.

즉 생성자가 123이라면, 123+1+2+3 즉 129가 자연수 N 이 되는 것이다.

보통 모든 조건을 그대로 따라가게 된다면, 1부터 N의 범위 까지 숫자 하나씩 계산을 하면서 해당이 되면 출력을 하는 로직이 나올 것이다. 만약 생성자가 없다면 0을 출력 하기에 최대 N까지의 반복을 진행한다.

하지만 다른사람들의 풀이에는 이상한 로직을 보았는데.

1부터 N까지가 아닌 1 혹은 N-53중 큰 수를 시작으로 하는 로직이었다.

나는 이게 왜 이런지 이해할 수 없었고 찾아보기 시작했다.

파이썬의 탐색 범위 최적화

사실 N-53은 탐색 범위 최적화 보다는 전체 프로세스의 최적화에 조금더 가깝다고 볼 수 있다.

우선 왜 N-53을 하는지 알아보자.

자 이 문제 분해합에서는 생성자 라는 것을 찾아야 한다.

생성자는 특정 숫자에 특정숫자의 모든 자리수의 합이 되야한다.

즉 이는 N = 특정숫자 + 특정숫자 자리수의 합 일때, N-특정숫자 자리수 = 특정숫자 가 된다.

i를 특정숫자, s(i)를 자리수의합이라고 한다면

i+s(i)=N이다.

이때 s(i)의 최대치는 9 * d이다. 왜냐면 특정 자리수의 최대값은 결국 9이며 이때 자리수의 합을 곱하면 최대치의 특정수의 자리수의 합의 최대치가 된다.

즉 결국 i 가 99라고 가정했을때의 s(i)가 18이기 때문에
i가 99가 아니라면, 즉 98이라면, N은 더 작아질 수 밖에 없다.

왜냐면, 이미 N에 최대치를 빼고 있는 상태에서 99가 아닌 98이 들어가면
i 에는 98+9+8 즉 116 이는 N이다.
98 과 116-18 즉 97이된다.

이는 i가 N이 되는 방식의 역이용인데, i + s(i)가 N이라 여기서 이미 최대치 즉 99라고 가정을 하고 N에 뺏기 때문에, 최대치가 아닌이상에야 점점 줄어들 수 밖에 없다.

즉 이는 i >= N-9d가 된다.

그러면 즉 max(1,N-9d)를 하면 1과 N-9d중 더 큰 수를 고르게 된다.

자 이때 왜 -53을 쓰는지를 이야기해 주겟다.

이렇게 N-9d를 하려면 새로운 개념인 d즉 len(input)을 해야한다. 그러기 때문에 최대치인 수6자리의 최대치인 53을 잡고

설정을 하는 것이다.

이는 완벽한 최적화는 아니지만, N이 2자리수 이상이라면 어느정도 효과적으로 탐색의 범위를 지울 수 있다.

결국 이 문제는 max (1, N-9d)에서 N까지 반복하게 되며,

i+sum(map(int,str(i))) 가 N이면 이를 프린트 하게 된다.

결국 최소부터 시작을 했기 때문에 가장먼저 나오는 수가 최소의 분해수이며 N을 넘어가게 되면 0을 프린트 하면된다.

N = int(input())
result = 0

for i in range(max(1, N - len(str(N)) * 9), N):
    s = i + sum(map(int, str(i)))
    if N == s:
        result = i
        break

print(result)

파이썬 (투 포인터)

코드 유랑자 승열 — Tue, 23 Sep 2025 13:00:26 +0900

파이썬 투 포인터 기법 에 대해서

알아보자.

투 포인터

투 포인터는 각각 다른 스타트를 가진 두 지점에서 한 곳으로 점점 모이면서 탐색을 하는 기법이다.

나도 특정 문제에서 이 기법을 사용하여서 문제를 해결한 코드를 보고 이를 이해하며, 설명하고자 한다.

그 문제는 백준 2798번 문제이다.

2798번: 블랙잭

우선 이 문제를 풀기전에 투 포인터의 로직을 설명을 해보겠다.

기본적으로 투 포인터란 정렬 기준을 전재로 한다.

sorted_num = [1,2,3,4,5]

이러한 정렬된 리스트가 존재할때, 하나의 포인트는 1, 또다른 포인트는 5 에서부터 시작한다.

즉 포인트 1번은 sorted_num[0] 시작

포인트 2번은 sorted_num[-1]에서 시작 이다.

이 이유는 그 다음 로직때문에 존재하는데, 결국 탐색은 특정한 조건을 만족하기 위한 수 혹은 조건을 의미한다.

그러면 결국 두 수로 인해서 생기는 조건을 만족하면 그 값을 저장하고 추가적인 로직을 통하여 정답을 도출한다.

지금은 그저 예시로 두 숫자를 더했을때 조건 N을 만족해야한다고 하자.

그 N이 3이라고 생각해보자.

첫번째 덧셈은 1+5가 될 것이다. 이때 6은 N보다 크다. 그렇다면 포인트 2번이 앞으로 전진한다.

이 이유는 정렬을 했기 때문에, 포인트 2번이 전진을 하면 즉 합이 작아질 것이고, 만약 N보다 작다면 포인트 1번을 전진해야 합이 커질 것이다.

여기서 말하는 전진은 가운데 한 지점 즉 서로 교차하는 점까지의 전진을 의미한다.

즉

1. 1+5

2. 1+4

3. 1+3

4. 1+2

이 순으로 반복을 하며 N == pointer1 + pointer2 가 될 것이다.

이는 아래 처럼 구현 할 수 있다.

sorted_list = [1,2,3,4,5]
N = 3
pointer1 = 0
pointer2 = len(sorted_list)-1

while pointer1 < pointer2:
    num_sum = sorted_list[pointer1]+sorted_list[pointer2]
    if num_sum == N:
        print(sorted_list[pointer1],sorted_list[pointer2])
        break
    elif num_sum > N:
        pointer2 -= 1
    else:
        pointer1 += 1

이렇게 정확하게 1개의 조합만 찾는것이 아닌 조건문을 더 붙여서 break하지 않고 모든 조합을 찾거나 할 수 있다.

이를 이용해서 백준 2798번 문제를 풀어보았다.

백준 문제 블랙잭은 3가지 숫자의 조합을 찾아야 한다.

이는 투포인트에서 문제가 될 수있는게, 투 포인터는 현재의 개념으로는 2개의 각 포인터로 움직여서 탐색하는 것 인데, 어떻게 3숫자의 조합을 알 수 있느냐 라는 문제이다.

이 문제는 쉽게 해결이 가능하다.

자 이 문제의 아주 정직한 풀이 방식은 3중 반복문을 통하여 모든 조합을 찾는것 일것이다.

우리는 3중 반복문이 뭔지를 봐야한다.

2중 반복문은 i가 특정 조건에 따라 증가할때 그 각 증가하는 숫자에서 j가 특정 조건에 따라 증가하며 더하거나 곱하거나 다른 작업을 하는 것을 의미한다.

즉 i가 1-3 까지이고 j가 1-5까지이면 i가 1인 경우에 j는 1-5까지 2인경우에도... 3인경우까지 j는 1-5를 이어간다.

우리가 투 포인터를 쓰는거는 2 수의 모든 조합 즉 2중 반복문을 뜻한다.

그러면 첫번째 루프를 지정하고 그 안에서 투 포인트를 쓰면 된다.

하지만 이는 어디까지나 특정 조건을 맞추기 위함이다.

- 2중 반복문 = 모든 조합을 찾음

- 투 포인터 = 모든 조합을 찾지는 못함

왜냐하면 투 포인터는 특정 조건에 맞을때 스킵을 하기 때문에 모든 조합을 찾기는 어렵다.

하지만 이를 쓰는 이유는 특정조건에 맞는 모든 조합은 찾을 수 있기 때문이다.

자 그러면 백준 2798번 블랙잭 문제를 풀어보자.

먼저 N과 M이 주어진다.

N은 숫자의 갯수이며, M은 특정 조건이다.

즉 N개의 숫자의 3가지 조합의 합에서 M과 같거나 가장 가까운 조합의 합을 구하면 된다.

import sys

N,M,*num_list=map(int,sys.stdin.read().strip().split())
result = 0
num_list.sort()

for i in range(N-2):
    pointer1 = i+1
    pointer2 = N-1
    
    while pointer1 < pointer2:
        sum_num = num_list[i]+num_list[pointer1]+num_list[pointer2]
        
        if sum_num <= M:
            if sum_num > result:
                result = sum_num
            pointer1 += 1
        else:
            pointer2 -= 1
            
        if result == M:
            print(result)
            sys.exit(0)
print(result)

이렇게 풀면 된다.

즉 투 포인트란

어떠한 조건을 만족하기까지 두개의 포인터를 각각 움직여 조합을 찾아내는것으로

이는 모든 조합을 찾을 수는 없지만, 조건을 만족하는 조합을 찾을 순 있으며

이러한 불필요한 조합의 찾기를 최소화하여 탐색의 시간을 단축 시킬 수 있다.

백준 파이썬 코딩테스트 (분해합)

코드 유랑자 승열 — Mon, 22 Sep 2025 22:42:14 +0900

백준2231번 문제

분해합

문제

풀이

이 문제의 요구사항은 아래와 같다.

1. 입력값을 받아서 최소 생성자를 구해라.

(생성자는 어떠한 수와 1의 자리수의 합이 그 숫자가 되는 수를 의미 즉 예시의 245는 245+2+4+5 즉 256이다. 그러면 256의 생성자는 245인것이다)

2. 이때 생성자가 없다면 0을 출력한다.

이... 문제는 시간의 문제인것 같다.

결국에는 입력값의 자리수를 확인해서

그 자리수의 모든 조합을 계산을 해보는 수 밖에 없다.

이렇게 되면 타임아웃 하지 않을가 걱정이 된다.

그렇다고 모든조합 을 다 계산하지 않고 문제를 풀기에는 아직은 잘 모르겠다.

즉 특정 n*n의 조합일때, 각 조합의 combined_num과 sum(list)를 더해서 N일때의 최소수를 계속 업데이트 하면 된다.

이때 combined_num은 무작위조합의 리스트에 ''.join을 사용하여 합하고 int를 붙여 정수로 변경한다.

전제자체가 틀렸다.

몇자리 숫자인지 모르고 n*n을 하는게 문제였다.

이러면 기하급수적으로 늘어날 뿐이다.

그냥 O(n)의 방법을 써보자.

즉 1부터 N까지 숫자를 검증하는것이다.

그렇게 되면 제일먼저 찾은 숫자가 최소숫자가 될것이다.

즉 i를 1부터 N까지 반복, 이때, i + 각자리수 합해야하지 sum(map(int,str(i)))하면 되지 않을가?

문자열 i를 int로 분해한다음 합치는 것이다.

이때의 값이 N.이라면 print i 아니라면 반복.

이때 result = 0으로 하면 결국은 없다면 0이 출력될 것이다.

결과

N = int(input())
result = 0

for i in range(1,N):
    sum_num = i + sum(map(int,str(i)))
    if sum_num == N:
        result = i
        break
        
print(result)

Coding_Test/백준/Bronze/2231. 분해합 at main · K-MarkLee/Coding_Test

백준 파이썬 코딩테스트 (블랙잭)

코드 유랑자 승열 — Fri, 19 Sep 2025 11:29:01 +0900

백준 2798번 문제

블랙잭

문제

풀이

이 문제의 요구 사항은 아래와 같다.

1. 카드 개수 n과 최대숫자 m을 받는다.

2. n개의 숫자중 3개를 더해 m과 가장 가까운 수를 출력해야한다.

이는 이 전 알고리즘에서 힌트를 얻을 수 있다.

3숫자의 모든 조합 즉 모든 합을 찾아서 가장 큰 숫자만을 출력하는 것이다.

이는 방법이 2개가 존재한다.

모든 조합을 더해서 리스트에 append시킨 후, max로 최대 수 찾기.

반복문을 통해서 중간에 수 3개의 더함이 m과 동일하면 멈추기. 그렇지 않나면 result 변수를 설정하고 이게 새로운 덧샘보다 작아지면 업데이트 하기 로 구현 할 수 있을거 같다.

문제는 이 조합을 어떻게 더하게 구현을 하느냐가 문제이다.

반복문을 해서 3중으로 하면 되지 않을가?

i는 n까지, j는 i+1부터 n까지 k는 j+1부터 n 까지 해서 인풋의 n개 숫자들을 리스트로 받아서

i인덱스 + j인덱스 + k인덱스 를 append하거나 올리는 방식으로.

결과

우선 모든 조합을 찾는 것 보다 m과 동일 하면 중간에 멈추는게 맞다고 생각한다.

import sys
n,m = map(int,sys.stdin.readline().strip().split())
num = list(map(int,sys.stdin.readline().strip().split()))

result = 0
found = False

for i in range(n):
    if found:
        break
    for j in range(i+1,n):
        if found:
            break
        for k in range(j+1,n):
            sum = num[i]+num[j]+num[k]
            if sum == m:
                print(m)
                found = True
                break
            elif sum > result and sum <= m:
                result = sum
if not found:
    print(result)

근데 문제는 이렇게 하면 3중이기 때문에 break를 여러번 해줘야 한다.

그러면 return을 써보면 어떨가?

함수로 만들어서 중간에 값을 return하면 멈추는 성질을 이용해서 작성해보겠다.

import sys

def newblackjack(n,m,cards):
    final = 0
    for i in range(n):
        for j in range(i+1,n):
            for k in range(j+1,n):
                total = cards[i]+cards[j]+cards[k]
                if total == m:
                    return m
                elif total < m and total > final:
                    final = total
    return final
                
n,m,*cards = map(int,sys.stdin.read().strip().split())

print(newblackjack(n,m,cards))

Coding_Test/백준/Bronze/2798. 블랙잭 at main · K-MarkLee/Coding_Test

This is an auto push repository for Baekjoon Online Judge created with [BaekjoonHub](https://github.com/BaekjoonHub/BaekjoonHub). - K-MarkLee/Coding_Test

github.com

백준 파이썬 코딩테스트 (알고리즘 수업 - 점근적 표기 1)

코드 유랑자 승열 — Thu, 18 Sep 2025 16:28:58 +0900

백준24313번 문제

알고리즘 수업 - 점근적 표기 1

문제

풀이

이 문제의 요구사항은 아래와 같다.

1. 첫째 줄에 함수의 값 a1과 a0가 들어온다.

2. 둘째 줄에 c가 주어진다.

3. 셋때 줄에 n0이 주어진다.

4. 이때 빅 오 표기법의 증명을 만족하는지 확인하고 만족한다면 1을 아니면 0을 출력해라.

빅 오 표기법 정리한 것과 같이

f(n) = O(g(n))을 증명해야한다.

이는 f(n) <= c * g(n) 을 의미한다.

상수아래에 있을때 c*g(n)이 f(n)보다 크거나 같아야 범위 안에 있다고 볼 수 있기 때문이다.

이 문제는 빅 오 표기법에 대해서 이해하기 쉽도록 만들어진

간단한 산수의 문제이지만 좀 어려워서 공부를 하고 이를 블로그에 정리를 하고 난 후에 문제를 푸는 중이다.

사실 간단한 산수 인것은 예제 아래에서 알 수 있었지만, 뭔가 이런게 아닌거같아서 찾아보니

빅오표기법 즉 시간복잡도 내지 다항식 등과 연관이 있었다.

이때 문제에서는 함수 f(n) = a1n+a0이다.

그러면 (a1*n0)+a0 <= n0*c를 하면 된다.

import sys
a1,a0,c,n0 = map(int,sys.stdin.read().strip().split())

if (a1*n0)+a0 <= n0*c :
    print(1)
else:
    print(0)

틀려서 알고 보니 빅 오 표기법에는 다른 조건도 있다.

a1 <= c라는 조건도 있었다.

그러면 and를 통해서 조건을 추가하면 될 것 같다.

이 문제의 악랄함은 빅 오 표기법을 모르면 풀 수가 없게 되어있다.

매우 악랄하다.

결과

import sys
a1,a0,c,n0 = map(int,sys.stdin.read().strip().split())

if a1<=c and (a1*n0)+a0 <= n0*c :
    print(1)
else:
    print(0)

Coding_Test/백준/Silver/24313. 알고리즘 수업 － 점근적 표기 1 at main · K-MarkLee/Coding_Test

This is an auto push repository for Baekjoon Online Judge created with [BaekjoonHub](https://github.com/BaekjoonHub/BaekjoonHub). - K-MarkLee/Coding_Test

github.com

파이썬 (빅 오 표기법)

코드 유랑자 승열 — Thu, 18 Sep 2025 16:08:47 +0900

파이썬 빅 오 표기법에 대해서

알아보자

빅 오 표기법

빅오 표기법이란 알고리즘의 증가 속도를 표현하는 수학적 표기법이다.

알고리즘의 시간복잡도 O(n) 를 표현하는 표기법이다.

어떠한 알고리즘에서 시간복잡도를 가지고 있을때 이를 식으로 표현한 것이며

이를 증명을 통해서 이 알고리즘이 올바른지 파악을 할 수 있다.

정확하게 빅 오 표기법이 뭔지 어떤일을 하는지는 아주 정확하게 이해를 하지못했지만

쉽게 생각하면

시간복잡도는 n이 무한대로 늘어날때 가장 크게 작동하는 시간 즉 가장 많은 시간에 비중이 큰 값이 들어가는것이며,

빅 오 표기법은 이러한 알고리즘이 범위(허용가능한 범위 내의 시간의 효율성) 안에 있는지 증명하는 것이다.

빅 오 증명은

f(n) = O(g(n))이다.

이는 동일하다 라기보다 f(n)의 식이 O(g(n))의 범위 안에 존재해야한다라는 의미이다.

이때 f(n)은 실질적 알고리즘의 다항식? 이며 g(n)은 기준이 되는 식? 이다.

이 기준은 f(n)에서 n이 무한대로 늘어났을때의 커지는 속도가 일정 기준이상이면

너무 오래걸리기 때문에 g(n)이라는 기준을 잡고 이 보다는 커지면 안된다라는 기준선에 가깝다.

그러나 g(n)이라는 선을 넘었다고 해서 틀렸다는 것이 아닌 비효율적임을 증명하는 것인거 같다.

하나 예를 들어보자.

1 + 1이라는 아주 간단한 풀이를 알고리즘에서 할 수 있다고 가정해보자.

이때 g(n)은 1정도의 시간이 걸릴거라고 예상을 한다. 이는 기준치 일 것이다.

하지만 이떄 이 알고리즘은 1 + 1을 하기 위해서 간단한 덧셈이 아닌 1 + 1을 거의 증명하는 수준으로 막대한 계산을 해서 값을 도출해낸다고 생각해보자.

만약 f(n) 에서의 시간이 10 이라고 한다면

f(n) = O(g(n))에 위배가 된다. 그러면 이 알고리즘은 효율적이지 않다 라는걸 의미한다.

결국 빅 오 표기법은 어떠한 알고리즘에 시간이 이정도 걸릴 것이다 라는걸 의미하는것이며

이 증명을 벗어나면 빅 오 표기법의 예상가능한 수치 (n이 무한대에 가깝다고 할때) 보다 훨씬 클것이며 즉 빅 오 표기법이랑 맞지 않음을 의미한다.

알고리즘 문제를 풀면서 안 새로운 사실인데

빅오 표기법의 증명은 2개이다.

f(n) =O(g(n))

즉 f(n) <=c*g(n)이다

그리고 a1<=c라는 조건도 포함이었다.

이떄의 a1은 함수(f(n)의 최고차항을 의미한다.

백준 파이썬 코딩테스트 (알고리즘 수업 - 알고리즘의 수행 시간6)

코드 유랑자 승열 — Thu, 18 Sep 2025 14:27:55 +0900

백준 24267번 문제

알고리즘 수업 - 알고리즘의 수행 시간 6

문제

풀이

이 문제의 요구사항의 아래와 같다.

1. 인풋 n을 받은 알고리즘의 수행 횟수를 출력하시오.

2. 이때, 수행 횟수를 다항식으로 치환했을때의 최고차항의 차수를 출력하시오. (다항식이 안되거나 최고차항의 차수가 3이 넘으면 4를 출력)

이 문제도 이전의 문제들과 같이 먼저 알고리즘을 파악해야한다.

자 첫번째 반복문은 1 부터 n-2까지
두번째 반복문은 첫번째 반복문에서 +1 부터 n-1까지

세번째 반복문은 두번째 반복문에서 +1부터 n까지이다.

이 알고리즘의 수행 방식은 수학을 잘 모르는 나의 입장에서는 조금 어려웠다.

자 이제 설명을 해보겠다.

우선 이 문제는 조합을 생각하면 된다. 결국 1부터 n이라는 숫자 사이를 중복되지않고 모두 조합을 하면 된다.
이때 첫번쨰와 두번째 숫자는 n-2와 n-1이라는 제한이 있으므로
n * (n-1) * (n-2) 가 모든 숫자들의 조합이 된다.

하지만 중복이 되는 경우가 있다.

예를들어서 이렇게 하게되면 조건에 맞지않고 중복이 생기는 경우가 있다.

n을 임의의 숫자로 설정했을때 첫번째숫자가 1이고 두번째 숫자가 2이면 세번쨰 숫자는 3이다. 이것은 가장 초반의 조건이다.

하지만 모든 숫자들의 조합에서는 이를 따지지 않는다.

i가 1 j가 3 k가 2인 경우도 존재를 하기 때문에 이를 걸러줘야한다.

이런 중복의 경우는 숫자의 선택지의 팩토리얼을 한 만큼 생긴다.

즉 3!인 6을 나눠야 한다. 이는 첫번쨰 자리에 올 경우 3개 두번쨰 자리에 올 경우 2개 세번쨰 자리에 올 경우 1개를 곱하는 것과 같기 때문이다.

즉 n* (n-1) * (n-2) // 3! 이 된다.

이를 다항식으로 나타내면

n³-3n²+2n // 6 이 된다. 그러면 최고차항의 차수는 3 이다.

결과

n = int(input())
print(f"{n*(n-1)*(n-2)//(3*2*1)}\n3")

Coding_Test/백준/Bronze/24267. 알고리즘 수업 － 알고리즘의 수행 시간 6 at main · K-MarkLee/Coding_Test

Coding_Test/백준/Bronze/24267. 알고리즘 수업 － 알고리즘의 수행 시간 6 at main · K-MarkLee/Codi

This is an auto push repository for Baekjoon Online Judge created with [BaekjoonHub](https://github.com/BaekjoonHub/BaekjoonHub). - K-MarkLee/Coding_Test

github.com

백준 파이썬 코딩테스트 (알고리즘 수업 - 알고리즘의 수행 시간 5)

코드 유랑자 승열 — Wed, 17 Sep 2025 16:26:38 +0900

백준 24266번 문제

알고리즘 수업 - 알고리즘의 수행 시간 5

문제

풀이

이 문제의 요구조건은 아래왁 같다.

1. 인풋이 알고리즘의 n으로 들어갔을때의 수행 횟수를 출력하라.

2. 수행 횟수를 다항식으로 나타낼때, 최고차항의 차수를 출력하라. (3이상이거나 없다면 4)

이 문제도 이 전 문제들과 같다.

먼저 알고리즘을 보자.

이번에는 1부터 n까지를 3번 반복하는 3중 반복문이다.

이러면 코드 1 은 당연히 n의 3제곱 만큼 반복을 하게 될 것이다.

그러하다면 당연하게도 f(n) = n³가 될것이고 최고차항의 차수는 3이다.

결과

print(f"{int(input())**3}\n3")

Coding_Test/백준/Bronze/24266. 알고리즘 수업 － 알고리즘의 수행 시간 5 at main · K-MarkLee/Coding_Test

Coding_Test/백준/Bronze/24266. 알고리즘 수업 － 알고리즘의 수행 시간 5 at main · K-MarkLee/Codi

This is an auto push repository for Baekjoon Online Judge created with [BaekjoonHub](https://github.com/BaekjoonHub/BaekjoonHub). - K-MarkLee/Coding_Test

github.com

백준 파이썬 코딩테스트 (알고리즘 수업 - 알고리즘의 수행 시간 4)

코드 유랑자 승열 — Wed, 17 Sep 2025 15:26:02 +0900

백준 24265번 문제

알고리즘 수업 - 알고리즘의 수행 시간 4

문제

풀이

이 문제의 요구조건은 아래와 같다.

1. 인풋은 알고리즘의 n에 해당하며, 이때의 코드의 수행 횟수를 출력하라.

2. 수행 횟수를 다항식으로 나타냈을때, 최고차항의 차수를 출력한다. 이때 다항식이 안되거나 3보다 크다면 4를 출력한다.

이 문제는 n²에 비례하는 알고리즘이다.

알고리즘을 먼저 보자면,

첫번째 루프는 i 가 1부터 시작해서 n-1까지이며,

두번째 루프는 j 가 i+1부터 시작해서 n까지이다.

그러면 i가 1일때, j는 2 부터 n까지 즉 반복 횟수는 n-1회.

i가 2면, j는 3부터 n 까지 즉 n-2회.

이런식으로 결국 n-1회 까지 간다면, j는 n-1 부터 n까지 즉 1회가 된다.

즉 이 횟수는 1에서 n-1까지의 덧셈을 의미한다.

이는 k(k+1)/2 로 계산 할 수 있는데, 그러면 n(n-1)/2가 된다.

이때 식을 풀게되면 n²-n/2 가 다항식이되고 최고차항은 n² 즉 O(n²)이다.

결과

n = int(input())
print(f"{n*(n-1)//2}\n2")

Coding_Test/백준/Bronze/24265. 알고리즘 수업 － 알고리즘의 수행 시간 4 at main · K-MarkLee/Coding_Test

Coding_Test/백준/Bronze/24265. 알고리즘 수업 － 알고리즘의 수행 시간 4 at main · K-MarkLee/Codi

This is an auto push repository for Baekjoon Online Judge created with [BaekjoonHub](https://github.com/BaekjoonHub/BaekjoonHub). - K-MarkLee/Coding_Test

github.com

백준 파이썬 코딩테스트 (알고리즘 수업 - 알고리즘의 수행 시간 3)

코드 유랑자 승열 — Wed, 17 Sep 2025 12:55:21 +0900

백준 24264번 문제

알고리즘 수업 - 알고리즘의 수행 시간 3

문제

풀이

이 문제의 요구사항은 아래와 같다.

1. 인풋 n 이 들어갔을때의 알고리즘의 수행 횟수를 출력.

2. 수행 횟수를 다항식으로 표현했을때의 최고차항의 차수를 출력 (3보다 크거나 만들수 없다면 4를 출력)

예제입력 밑에 보면 나와있듯이 알고리즘의 수행 시간에 대해서 미리 알려주고 시작한다.

하지만 알고리즘부터 파악해보자.

자 이번에는 2중 루프인 것을 바로 알 수 있다. 이러면 보통 n^2만큼 반복을 하는것이다.

자세히 보면, sum에 이번에는 n번 반복할때, 1부터 n하나마다 1부터 n을 곱해서 sum에 더한다.

그러면 다항식은 f(n) = n² 이 될것이고, 시간복잡도는 O(n²)이 된다.

그러면 최고차항의 차수는 2가 될 것이다.

결과

print(f"{int(input())**2}\n2")

제곱은 파이썬으로 **로 한다. 3*2 = 6 / 3**2 = 9

Coding_Test/백준/Bronze/24264. 알고리즘 수업 － 알고리즘의 수행 시간 3 at main · K-MarkLee/Coding_Test

백준 파이썬 코딩테스트 (알고리즘 수업 - 알고리즘의 수행 시간 2)

코드 유랑자 승열 — Wed, 17 Sep 2025 12:42:29 +0900

백준 24263번 문제

알고리즘 수업 - 알고리즘의 수행 시간 2

문제

풀이

이 문제의 요구사항은 아래와 같다.

1. 인풋의 숫자는 주어진 알고리즘의 입력값이다.

2. 입력값을 받은 알고리즘의 수행횟수를 출력한다.

3. 이 수행 횟수를 다항식으로 나타내었을때의 최고차항의 차수를 출력한다.(차수가 3보다 크거나 없으면 4를 출력)

이 문제는 알고리즘을 봐야한다.

이는 n번반복하는 루프안에 1부터 n의 모든 숫자를 더하는 알고리즘이다.

그렇다면 당연하게도 다항식은 그냥 f(n) = n이고 시간복잡도는 몇번을 O(n)이 된다.

그렇다면 최고차항은 1이된다.

횟수는 루프이기 때문에 n번만큼 반복이니

그냥 입력값을 프린트하고 1을 프린트 하면 된다.

결과

print(input());print(1)

print(f"{input()}\n1")

뭐 둘중에 아무거나 해도 될 것 같다.

import sys 안쓴 이유는 인풋값이 1개이며 그냥 작은수 이다보니 굳이 라는 느낌이다.

Coding_Test/백준/Bronze/24263. 알고리즘 수업 － 알고리즘의 수행 시간 2 at main · K-MarkLee/Coding_Test

Coding_Test/백준/Bronze/24263. 알고리즘 수업 － 알고리즘의 수행 시간 2 at main · K-MarkLee/Codi

This is an auto push repository for Baekjoon Online Judge created with [BaekjoonHub](https://github.com/BaekjoonHub/BaekjoonHub). - K-MarkLee/Coding_Test

github.com

백준 파이썬 코딩테스트 (알고리즘 수업 - 알고리즘의 수행 시간 1)

코드 유랑자 승열 — Tue, 16 Sep 2025 14:36:07 +0900

백준 24262번 문제

알고리즘 수업 - 알고리즘의 수행 시간 1

문제

풀이

이 문제의 요구사항은 아래와 같다.

1. 인풋은 알고리즘의 반복 횟수이다. 이때 수행 횟수를 출력해라.

2. 이 수행횟수에 대한 다항식의 최고차항의 차수를 출력해라. 이때 다항식으로 나타내지 못하거나 최고차항의 수가 3보다 크면 4를 출력하라.

이 문제는 시간복잡도를 알게 되면 매우 쉽다.

그 이유는 입력값이 얼마가 들어가던 주어진 알고리즘은 1번은 수행횟수만을 거친다.

즉 항상 결과값은 1이며 O(1)의 최고차항은 0이다.

결국 입력값이 뭐가 되었던 간에 항상 1과 0이 출력되야한다.

결과

print(1); print(0)

Coding_Test/백준/Bronze/24262. 알고리즘 수업 － 알고리즘의 수행 시간 1 at main · K-MarkLee/Coding_Test

Coding_Test/백준/Bronze/24262. 알고리즘 수업 － 알고리즘의 수행 시간 1 at main · K-MarkLee/Codi

This is an auto push repository for Baekjoon Online Judge created with [BaekjoonHub](https://github.com/BaekjoonHub/BaekjoonHub). - K-MarkLee/Coding_Test

github.com

파이썬 (시간복잡도 , 다항식, 최고차항)

코드 유랑자 승열 — Tue, 16 Sep 2025 14:31:12 +0900

파이썬 시간복잡도, 다항식, 최고차항

에 대해서 알아보자.

시간복잡도

시간복잡도란 알고리즘에서 걸리는 시간을 계산하는 방법이다.

이는 대체로 어떤 알고리즘을 돌렸을때 걸리는 시간을 예상하는 방법이다.

주로 시간복잡도는 5개로 나누어서 볼 수 있다.

1. O(1)

: 이는 단 한번만 하는 일이라는 의미다.

어떤 값이 들어가도 1번만 계산을 하는 것이다. 예를들어 n이 100이든 10000이든 n+1의 값을 내는 알고리즘이 있다면 항상 시간복잡도는 O(1)인 것이다.

2. O(n)

: 이는 n번 일을 해야한다는 의미이다.

보통 이는 반복문에서 볼 수 있다.

PrintN(n):
    for i in range(n):
        print(i)

위와 같은 알고리즘이 있다면, 결국 n번만큼 반복을 하기 때문에 시간복잡도가 O(n)이 되는 것이다.

3. O(n²)

: 이는 2중 n번의 일을 반복해야한다는 의미이다.

즉 2중 반복문의 구조일때는 시간 복잡도가 O(n²)이 되는것이다.

PrintSum:
    for i in range(n):
        for j in range(n):
            print(i+j)

이렇게 2중으로 반복을 하게 된다면 n이 0 일때 그 반복문 안에서 n번 반복 할 것이고 이는 i가 n에 도달할때까지 즉 n x n의 횟수만큼 반복 하기에 시간복잡도가 O(n²)이 된다.

4. O(log n)

: 이는 n에서 절반씩 나눠가며 찾는다는 의미이다.

이해는 하는데 정확하게 어디서 쓰일지는 잘 모르겠다.

예로

리스트에 숫자가 n만큼 있고 특정 숫자를 찾아야 한다. 이때의 log n 은 n/2를 하고 그 특정 숫자 보다 큰지 작은지를 보고 다시 작으면 작은쪽으로 /2 크면 큰쪽으로 /2를 한다.

즉 n이 1000이라고 해보자. 3을 찾는다면,

1. 중간인덱스 500은 3보다 크다.

2. 중간인덱스 250은 3보다 크다.

3. 중간인덱스 125는 3보다 크다.

4. 중간인덱스 62는 3보다 크다.

5. 중간인덱스 31은 3보다 크다.

6. 중간인덱스 15는 3보다 크다.

7. 중간인덱스 7은 3보다 크다.

8. 중간인덱스 3은 3과 같다.

이런식으로 반 갈라서 계산하는것과 같다.

5. O(2ⁿ)

: 이는 n의 가능한 모든 조합 을 의미한다.

나도 솔찍히 정확하게 이해를 하지 못했다.

이는 가능한 모든 조합 즉 부분집합을 탐색하는 경우인것 같다.

예시로 n만큼의 리스트요소가 존재하면 빈집합과 1개인 집합의 조합부터 n개가 1개로 조합되어있는 것 까지 계산을 한다면 2ⁿ만큼의 갯수가 나 올 것이다.

예로 n이 3인경우를 보자.

1. 빈집합 1개

2. 숫자가 1개씩 있는 집합 3개

3. 숫자가 2개씩 있는 집합 3개

4. 숫자가 3개씩 있는 집합 1개

총 8개가 된다.

이렇게 계산하는데 O(2ⁿ)이다.

다항식

다항식은 어떠한 알고리즘의 실행 횟수를 식으로 나타낸 것을 의미한다.

한 알고리즘이 위처럼 하나씩의 계산만 하는것이 아닌 여러 횟수들의 반복으로 이루어져 있을 확률이 높다.

이를 하나하나 전부 계산식으로 변환한것을 다항식이라고 한다.

근데 이때 다항식을 이해하기 위해서는

지수함수와 다항식을 구분할 줄 알아야 한다.

지수함수는 2ⁿ과 같이 입력값 n이 지수로 올라가 있는 형태를 뜻한다.

다항식은 n이 존재할때 n^x와 같이 특정 자연수가 거듭제곱으로 존재를 해야한다.

즉 n^2+n^3은 다항식이며 여기서 n^3+n^2+2^n은 복합식으로 본다.

최고차항

최고차항은 다항식에서 자연수의 거듭제곱이 가장 큰 숫자를 의미한다.

만약 복합식에서 최고차항을 알려달라고 한다면 이는 지수함수를 제외한 나머지 다항수에서의 최고차항을 뜻한다.

즉 n^2+n^3 이거나 n^3+n^2+2^n 일때의 최고차항은 3인 것이다.

이는 시간복잡도와도 관련이 있는데, 결국 시간복잡도는 최고차항이 들어간 값이다.

위와같은 n^2+n^3식이라면 사실 순서가 잘못되서 n^3+n^2가 맞다. 아무튼 시간복잡도는 O(n^3)이 될 것이다.

하지만 만약 n^3+n^2+2^n이런 복합식이 된다면 시간복잡도는 가장 큰 값이 전체의 시간에 영향을 가장 많이 줌으로,

지수함수가 O(2^n)이 된다.

하지만 이렇게 생각할 수 있다.

다항식이 훨씬 크면 어떻게 하지?

예시로 n이 2로 명시를 한다고 가정해보자.

n^15+n^2+2^n이라는 복합식이 존재한다고 해보자.

이때는 n^15가 2^n보다 훨씬 클 것이다. 하지만 이론상 n이 증가할수록 시간복잡도가 2^n이 훨씬 빠르게 증가하기 때문에

시간복잡도는 정확한 시간이 아닌 성장률을 분석하는 개념 즉 시간의 예측이기때문에 n이 커지면 커질수록 기하급수적으로 값이 커지는 지수함수가 시간복잡도에 들어가게된다.

백준 파이썬 코딩테스트 (세 막대)

코드 유랑자 승열 — Mon, 15 Sep 2025 11:50:25 +0900

백준 14215번 문제

세 막대

문제

풀이

이 문제의 요구조건은 아래와 같다.

1. 인풋은 3개 a, b, c 가 주어진다.

2. 이 인풋은 세 막대의 길이로 이 길이를 줄일 수 있다.

3. 이를 사용하여 둘레가 최대인 삼각형을 만들고, 둘레를 출력한다.

이 문제는 인풋을 받아서 삼각형의 조건에 맞는 최대치 삼각형을 만들고, 둘레를 구하는 것이다.

지켜야 하는것은 삼각형의 세 변중 가장 큰 변의 길이는 나머지 두 변의 길이의 합보다 길어야 한다라는 것이다.

우선 조건으로는 양수이며 1보다 크거나 같고, 100보다 작거나 같다.

이때 최소로 길이를 빼는 법은 사실 매우 쉽다.

결국 가장큰수 - 나머지 두수의 합이 음수가 되야 한다.

리스트에 숫자를 넣고 max(list) - sum(list)-max(list) 는 < 0 이 되야한다.

예시를 사용해보자.

1 2 3이 들어왔다면, 3과 6-3 의 뺄샘이 0보다 작아야한다.

3-3은 0이기 때문에 0보다 작은 음수가 되려면 -1이 필요하고 이는 sum(list) - 1을 하게되면 이는 최대 둘레가 되게된다.

2 2 2 와 같이 동일한 수는 결국 2 - 4 즉 이미 음수이기 때문에 sum(list)가 최대둘레이다.

1 100 1 처럼 두 변의길일가 동일한 경우도 마찬가지로 100 - 2 = 98 즉 sum(list) 에서 99를 빼야한다.

98만 빼면 0이 될테니 1을 더 제외해야하는것.

확인해보니 정답인데 좀더 짧게 가능한 버전도 있다.

인풋이 3개로 고정이 되어있다면 sort를 사용해서 조건문을 좀 짧게 작성할 수 있다.

sorted를 사용하면 바로 가능하다 sort는 따로 변수할당해야한다.

import sys
a, b, c = sorted(map(int,sys.stdin.read().strip().split()))

print(2*(a+b)-1 if a+b<=c else a+b+c)

혹은

import sys
a, b, c = sorted(map(int,sys.stdin.read().strip().split()))

print(min(a+b+c, 2*(a+b)-1))

결과

import sys
num = list(map(int,sys.stdin.read().strip().split()))

if max(num)-(sum(num)-max(num)) < 0:
    print(sum(num))
else:
    print(sum(num)-(max(num)-(sum(num)-max(num)))-1)

Coding_Test/백준/Bronze/14215. 세 막대 at main · K-MarkLee/Coding_Test

This is an auto push repository for Baekjoon Online Judge created with [BaekjoonHub](https://github.com/BaekjoonHub/BaekjoonHub). - K-MarkLee/Coding_Test

github.com

백준 파이썬 코딩테스트 (삼각형 과 세 변)

코드 유랑자 승열 — Fri, 12 Sep 2025 11:20:16 +0900

백준 5073번 문제

삼각형과 세 변

문제

풀이

이 문제의 요구사항은 아래와 같다.

1. 가가 줄에 숫자 3개가 들어온다.

2. 각 숫자는 삼각형의 세 변의 길이이다.

3. 세변을 보고 Equilateral, Isosceles, Scalene, Invalid중 맞는 1개를 출력하라.

4. 이때, 0 0 0 이 들어온다면 멈춘다.

이다.

조건이 조금 더 까다로워졌다고 볼 수 있다.

출력이 한줄씩이니 반복문으로 출력을 해야한다.

일단 조건이 0 0 0이 들어오면 멈추는거니까 while 로 반복문을 작성한다.

우선 아까의 각 에서 길이의 합이라는 제한이 있기 때문에 생각할게 1개 더 추가된다.

숫자를 리스트로 받아서 set으로 치환했을때, 숫자가 1개면 Equilateral, 2개면 Isosceles까지는 동일하다.

하지만 숫자가 3개 인 경우에 가장 큰 숫자를 제외한 두 숫자의 합이 가장 큰 숫자보다 작다면 이는 Invalid가 된다.

이는 높이와 밑변의 합보다 빗변의 길이가 작아야하는 삼각형의 성질 때문이다. 이를 위배하면 삼각형이 되지 않는다.

import sys

while True:
    num=list(map(int,sys.stdin.readline().strip().split()))
    
    if sum(num) == 0:
        break
    
    if len(set(num)) == 1:
        print("Equilateral")
    elif len(set(num)) == 2:
        print("Isosceles")
    else:
        if max(num) < sum(num)-max(num):
            print("Scalene")
        else:
            print("Invalid")

아마 Invalid의 조건이 더 있는것 같다.

지금은 뭐가 문제인지 모르겠다만 한번 생각해봐야겠다.

아마 Isosceles에서도 Invalid의 조건을 넣어야 할것 같다.

10 10 100 라면 Isosceles 로 나오지만 삼각형의 조건에 안맞기 때문에 Invalid가 나와야 할 것같다.

그러면 Invalid를 좀 더 크게 걸러야 할 것 같다.

이번에는 조건에서 Invalid를 먼저 걸러낼 거다.

max(num) >= sum(num) - max(num)으로 한다. 이유는 max(num)보다 커야하니까 같거나 작은 경우 Invalid를 출력한다.

여기서 set의 len이 1이면 Equilateral, 2라면 Isosceles 그리고 나머지는 Scalene.

결과

import sys

while True:
    num=list(map(int,sys.stdin.readline().strip().split()))
    
    if sum(num) == 0:
        break
    
    if max(num) >= sum(num) - max(num):
        print("Invalid")
    elif len(set(num)) == 1:
        print("Equilateral")
    elif len(set(num)) == 2:
        print("Isosceles")
    else:
        print("Scalene")

이게 조건의 대소를 잘 확인해야겠다.

결국 삼각형의 조건을 만족 한 뒤에 구분을 해야하는데 텍스트로만 코드를 작성하고 생각이나 이런걸 하지 못했다.

Coding_Test/백준/Bronze/5073. 삼각형과 세 변 at main · K-MarkLee/Coding_Test

This is an auto push repository for Baekjoon Online Judge created with [BaekjoonHub](https://github.com/BaekjoonHub/BaekjoonHub). - K-MarkLee/Coding_Test

github.com