TraceofLight (EN)

Summary of what was learned at Unity Roadshow 2026

Sun, 19 Apr 2026 13:17:51 GMT

Memory Prerequisites

Basic Content

We use Virtual Memory (VM) and do not directly control physical memory.
VM is composed of pages, which may vary depending on the OS.
Windows / Linux 4kb
iOS, MacOS, Android 16kb
A physical memory frame exists corresponding to the page.
Virtual memory is merged into physical memory depending on the level of memory pressure.

Page Fault

A Page Fault occurs when a page that has not been loaded into physical memory is needed.

Clean Page: A page whose original data has not changed; it can be released by the OS at any time and is easy to reclaim.
Dirty Page: A page containing information newly written or modified by an application; it cannot be immediately removed from memory.

Memory Footprint

An indicator representing actual memory pressure, resulting from the sum of the total dirty page sizes.

Memory Footprint != Physical memory usage, Resident memory usage

Memory Management (Windows vs Linux)

Reserved: Does not use physical memory Allocate only virtual memory without reserving
Commit: Allocates physical frames equivalent to the actual virtual memory
Decommit: Releases physical frames while maintaining reserved space

Windows: Provides explicit APIs (virtual alloc, virtual free)

UNIX Like: No explicit separation between reservation and commit

mmap calls implicitly reserve memory

Lazy commit occurs when accessing pages immediately

No explicit API; decommit operates via hints

The OS decides when to reclaim pages

Handling in Unity GC

Managed Heap

All C# memory allocation takes place here
Managed by the Garbage Collector
Indicated as GC.Alloc in Unity Profiler

Garbage Collector

Periodically collects objects from the Heap that do not have valid references
Performing GC does not reduce total virtual memory usage
The space occupied by collected objects is also considered Dirty by the OS

Segment

Defined as a collection of consecutive pages

Managed Heap uses Segments instead of Raw Pages
Multiple objects can be allocated to a single Segment
After allocating and releasing them, there are internally unused instances, but they are marked as RAM usage (because they are dirty)
In most cases, there are no issues and they are reused soon
Cases where they remain empty for too long waste resident memory, so Unity GC handles them intermittently

What Unity GC Does

Uses remapping strategies
After multiple GC runs, Old Empty Segments are dropped, and New Segments of the same size are allocated
Windows Remap Strategy: Decommits without releasing Segments (because it is an explicit process)
UNIX-Like Remap Strategy: Remaps via munmap & mmap (High cache hit rate due to Hot Page effect)
This has the advantage of reducing resident memory

GC.Collect Should Not Be Run Multiple Times Reasons

Do not force segment releases
Collect is expensive and can cause app freezing
The intention itself is to decommit segments that have been empty for a long time
Decommitting segments that are briefly empty is contrary to the intention
Forced decommitting does not improve performance and only incurs CPU costs
Causes a situation where segments that will be reused in the next frame are also decommitted

VM usage in Managed Heap only increases and never decreases

The Heap only increases and never decreases
The inherent characteristics of Boehm GC
There is no reason to trim virtual memory allocations
Large virtual memory != Large physical memory usage
Segments are reused anyway
Game objects are frequently created and destroyed every frame
Shrinking segments every time an object is destroyed only wastes CPU performance

Unity Boehm GC

Unity's Incremental Boehm GC is a Conservative GC
This supports the task of converting C# code written in the past into C++ It came to be primarily used with the provision of IL2CPP.
While IL2CPP enabled support for various environments, it appears that the open-source GC Boehm GC was used because, unlike C#, memory GC was not automated.
Focusing on stability rather than performance, it considers all values that look "like" pointers as references.
Object locations are not changed during GC -> No compaction, and vulnerable to memory fragmentation.

About Compaction

Memory compression is advantageous for resolving memory fragmentation. It clears out all unused space to rearrange it.

Impossible in conservative GCs because accurate reference information is required.

Moving object locations incurs a cost (Stop The World + actual movement).

CoreCLR GC

CoreCLR GC is a Precise GC that accurately knows which values in the memory stack and registers are references.

And .NET uses CoreCLR as its core engine (CLR: Common Language Runtime)

Features supported by CoreCLR

CoreCLR GC

JIT Compiler

Exception Control

misc...

This CoreCLR GC (hereinafter .NET GC) uses a generation-based memory management method

Manages the Heap by dividing it into 3 generations
Generation 0: Primarily consists of newly created objects; frequent and fast GC occurs (most objects die here)
Generation 1: Acts as a buffer for objects that survived Generation 0 to move to
Generation 2: Resides for heavy objects that have survived for a long time; cleaning this area is costly for the GC
LOH: Very large objects are placed in this space

Fragmentation can be reduced as memory compaction is handled during the promotion process

In the case of LOH, compaction was not performed in the past because the STW (Stop-the-World) lengthens, but it is said that it is now handled as an explicit option.

The Value of the Transition?

Basically, Unity to .NET I mentioned that the change in GC is a side effect of the transition, not the primary one. However, if we look for its value...

Memory fragmentation is reduced because Compation is supported.
GC costs can be made predictable.

A quick note about container environments

Thu, 02 Apr 2026 06:58:20 GMT

How Containers Work

Share the host OS's kernel but isolate it like a process

What if the kernel is incompatible?

Of course it won't run, but the reason why it can run on MAC, WINDOW, etc. is because it adds a whole VM layer

Why docker desktop installation on windows tells you to install wsl2. It seems to be because you need to install MS's Linux VM to make that layer-based container work.

Even if the issue is with the kernel version, it can still crash (trying to use features that don't exist due to version differences, etc)

Conclusion.

Kernel types must match, feature support must not be an issue, and CPU architectures must match for containers to run.

VM

Standalone with hypervisor, separate kernel. There is bare-metal / hosted, what we use is mostly hosted, there is performance loss because hypervisor is on top of OS

Volume Binding

Used to preserve data persistence, handled by mounting a specific directory on the host machine. On Linux native, it writes directly to the VFS, on other OSes it burns the internal virtual network and can be relatively slow.

Why Windows ignores chmod.

Windows uses ACLs (Access Control Lists) to manage permissions and doesn't understand how chmod works.

Testimonials from the Crafton Jungle Gametech Lab

Thu, 26 Mar 2026 18:02:12 GMT

enters

Since I've been putting my real life on hold for about half a year since completing the program, I've been a little confused about when to write this review.

However, I think I should write it down before my memory gets a little fuzzy, so here it is.

I've also included a replay of the presentation in the media above, in case anyone reading this is still thinking about it.

Mouth and mouth agony

First of all, I didn't know what I wanted to do right away. I had a lot of plans for what I would be doing in the second half of 2025.

However, I chose to enroll because I realized that most of them hadn't worked out, and I felt like I had a pretty good option.

I've had a few interviews that didn't go well, so I've always wondered how to fill in the gaps in my experience.

I had never touched a commercial real-time 3D engine before, so I couldn't explain the overall functionality, let alone the internal logic.

So, when I stood in front of the interviewer with all the knowledge I had gained from fighting AI, I could only give a superficial explanation.

Looking back on it now, I feel very embarrassed to think about what the interviewer must have thought while listening to those answers.

At the time, I considered the risks of taking the course to be twofold.

I had no idea what the course would be like or what the outcome would be, as I had only one previous ride and hadn't even completed it.

Another risk was that the second semester was scheduled to take place in the second half of the year, and the game companies I was interested in usually recruit interns in the second half of the year.

After weighing the options, I decided on pre-med. Now that I think about it, I think the information session I went to had quite an impact.

There was a game lab in the jungle course, so I was wondering if I should take the course, and if so, which course I should apply for, but after the information session, my decision was clear.

About the course

I'm not sure what the outcome of the course will be, but so far I'm very happy with the experience.

I won't go into detail about what we do in the course and the situations we encounter because, to quote the coaches, it would "spoil the fun for the junglers".

However, I can tell you that TechLab is not an easy process. It's almost impossible to juggle other tasks, and the lights are rarely turned off in the classroom throughout the course.

However, it's safe to say that you'll gain an impressive amount of experience, knowledge, and understanding of commercial real-time 3D engines.

So who should come?

It's probably most intuitive to bring a copy of the presentation.

I think people who want to know more about these things should come. You'll gain a lot of understanding.

I know I said I wasn't going to cover this, but people who are curious about some of the graphics and development environments here should consider taking a tech lab.

After taking the course, you'll be able to at least recite the lunar calendar and share a simple tiki-taka about them.

Final thoughts

Now that I've finished the course, I'm very happy to have completed it, but there are still many things I need to organize in the future because I experienced so much in such a short period of time.

However, after digesting all of them, I think I will be a more mature developer.

There is a lot of talk about downsizing the workforce in the industry due to the development of AI, but I'm going to do what I can.

There's also been a lot of talk about growth gaslighting lately, but I've definitely seen good things happen to people around me who have continued to grow, so I think we'll be able to keep the momentum going for a while.

Setting Up a Unified Terminal Environment for Windows and macOS

Thu, 26 Mar 2026 12:18:01 GMT

Introduction

: After recently upgrading my MacBook Air, I realized I needed to reconfigure my setup.

While I’m satisfied with the performance boost from the M1 to the M5, I found that reconfiguring my existing setup was quite labor-intensive. So, I decided to take this opportunity to document the entire process and standardize it so I can easily set things up again in the future.

[2026 Mac Terminal Complete Setup (Ghostty + Starship + AI Coding Environment)](https://blog.dnd.ac/settings-mac-terminal-2026/

)

The document that left the biggest impression on me during this process was the resource linked above. The author had left a script detailing a clean and well-configured environment, which was a huge help.

To cut to the chase, I was able to build my terminal environment as shown below:

Internally, the setup is based on Wezterm + Nushell + LazyVim.

You can find the complete setup guide at [Github Link](https://www.github.com/TraceofLight/global-terminal-settings

), which I designed to allow you to build the same environment on both Windows and macOS.

Setting

Goals The goals for this project were clear:

Use the same terminal environment on both Windows and macOS
Ensure seamless compatibility with LazyVim-based editors
Maintain a user experience similar to my existing setup
Ensure

ease of use with multiplexer tools like tmux I proceeded with the project to achieve these goals.

Process

First, I had to choose the technology to use. These days, the trend in terminal emulators is toward tools with a GUI capable of GPU-accelerated rendering. The reason these tools are gaining popularity is that they are fast and support customization. Since these features were necessary to build the terminal as described in the link above, I chose Wezterm from among them.

Terminal Emulator

Since I needed to provide the same user experience across platforms, I considered Alacritty and Wezterm as the only cross-platform terminal emulators with established ecosystems. I felt that Alacritty, which prioritizes minimalism, lacked extensibility, so I chose Wezterm. The fact that it includes a multiplexer was also a major advantage.
Shell

Since we needed to ensure a consistent user experience across both platforms, we initially aimed to unify the environment to support Unix commands. As a result, we decided early on to use bash on Windows and zsh on macOS. However, we encountered several issues, and ultimately settled on a unified solution based on Nushell.
LazyVim

Actually, I was already using tools in this area, and since they integrated seamlessly across most environments without any issues, this wasn’t difficult. We originally used SpaceVim, but since it had already been [discontinued](https://wsdjeg.net/why-spacevim-is-archived/

), we had switched to LazyVim some time ago. Since we primarily use an IDE and treat this as a supplementary tool, the installation process went smoothly.

Issues Encountered

There were a few issues during this process, both of which were related to the switch to Nushell.

Bash is noticeably slow on Windows

In fact, upon checking later, this turned out to be an inevitable outcome. I discovered that in a Windows environment, an additional compatibility layer is required to handle POSIX-style operations. I actually considered moving to a WSL2 environment, but ultimately ruled it out because that would be no different from using Linux.

-> To solve this problem, I decided to adopt nushell. I took into account that it is highly compatible with Unix commands, is designed using Rust (which guarantees a certain level of performance), and allows for the same environment setup on macOS.
The navi plugin does not work in nushell on Windows

Navi is a plugin used as a cheat sheet for terminal commands. Although we don’t use it very often, it would be problematic if the tool’s functionality didn’t work at all, so we explored various solutions. Ultimately, we forked Navi to resolve the issue and implemented the newly built plugin.
- Cause: Even when the user’s shell changes, the internal logic applies bash-based syntax, causing issues when using Nushell
- Solution: Instead of handling that part with shell script commands, I removed internal dependencies on bash by using the Rust HTTP client where wget was required and pwsh where bash would normally be used.
- [Detailed Change Log](https://github.com/TraceofLight/navi/tree/fix/nushell-usability

)

Conclusion

Developers frequently use the terminal, and it goes without saying that a unified environment makes things easier to use. That’s why JetBrains IDEs, which support cross-platform compatibility and consistent usability, are so valuable. Similarly, if your goal is to maintain a consistent user experience across various environments when using the terminal, adopting this approach seems like a good idea.

std::variant & std::visit

Mon, 28 Jul 2025 14:13:37 GMT

Additional Information

)

The link above contains information about Variant, which was added starting with C++17, and the reasons behind its addition. To put it simply, the discussion revolves around the fact that Boost had been using this functionality for far too long—something that should have been included as std::optional—and the consensus was to stop dragging it out and just add it to the standard as soon as possible.

Internal Structure

1. Variant

Data Buffer A memory space large enough to store the largest type among those specified as template arguments; it is generally implemented as a union.
Identifier An index or identifier that indicates which type of object is currently stored in the data buffer. By using this identifier, std::variant can ensure type safety.

By having a sufficiently large memory buffer, the variant type can perform the following actions.


	struct Tracer
	{
		std::string name;

		Tracer(const std::string& n) : name(n)
		{
			std::cout << "  [+] '" << name << "' Tracer created (Constructor)\n";
		}

		// Copy Constructor
		Tracer(const Tracer& other) : name(other.name)
		{
			std::cout << "  [*] '" << name << "' Tracer copy-constructed (Copy Constructor)\n";
		}

		~Tracer()
		{
			std::cout << "  [-] '" << name << "' Tracer destroyed (Destructor)\n";
		}
	};

	// 1. Initialize the variant with a Tracer type.
	std::cout << "1. Initializing variant with Tracer(\"Apple\").\n";
	std::variant<int, Tracer> var = Tracer("Apple");
	std::cout << "   Variant now holds Tracer(\"Apple\").\n\n";

	// 2. Assign a value of a different type (int).
	std::cout << "2. Assigning integer 100 to the variant.\n";
	var = 100;
	std::cout << "   Variant now holds integer 100.\n\n";

	// 3. Assign another Tracer type value again.
	std::cout << "3. Assigning Tracer(\"Banana\") to the variant.\n";
	var = Tracer("Banana");
	std::cout << "   Variant now holds Tracer(\"Banana\").\n\n";

	std::cout << "4. main function is about to end.\n";
	return 0;

When you run code like this, you get the following result.

1. Initializing variant with Tracer("Apple").
  [+] 'Apple' Tracer created (Constructor)
  [*] 'Apple' Tracer copy-constructed (Copy Constructor)
  [-] 'Apple' Tracer destroyed (Destructor)
   Variant now holds Tracer("Apple").

2. Assigning integer 100 to the variant.
  [-] 'Apple' Tracer destroyed (Destructor)
   Variant now holds integer 100.

3. Assigning Tracer("Banana") to the variant.
  [+] 'Banana' Tracer created (Constructor)
  [*] 'Banana' Tracer copy-constructed (Copy Constructor)
  [-] 'Banana' Tracer destroyed (Destructor)
   Variant now holds Tracer("Banana").

4. main function is about to end.
  [-] 'Banana' Tracer destroyed (Destructor)

You can observe the sequence where the destructor for the existing value is called first, followed by the creation of a temporary object on the stack, and finally, the copied value is moved into its own memory buffer.

Therefore, by internally reserving space for the largest class using a union, the variant type can be used without issues regardless of what is passed in!

2. Visit

Although this varies by library,

Function pointer table
Switch statement

It is generally categorized into these two main forms. In reality, aside from slight differences in implementation, overhead, and compiler optimization, it can be understood that they are fundamentally implemented to call the appropriate function based on the active type determined by the discriminator.

[Jongman Book] 02. Troubleshooting Strategies

Wed, 18 Dec 2024 04:27:16 GMT

Troubleshooting process

Read and understand the problem.
Redefine the problem in familiar terms.
Plan how to solve the problem.
Validate your plan.
Implement it as a program.
Reflect on how you solved it and look for ways to improve.

1) Read and understand the problem

To avoid making the mistake of misreading the problem, you should read the problem aggressively and try to fully understand what the problem wants. If you miss a small constraint, you will often be unable to solve it, and competitions are often unforgiving of small mistakes.

2) Redefinition and abstraction

Using concepts that are easy for you to work with, rephrasing the problem in your own language is necessary to intuitively understand what the problem is asking of you, and the more complex the problem, the more important it is. Programs that do the same thing can be perceived very differently depending on how you reframe the nature of the problem. Abstraction determines the direction a program will take, as it can make hard problems easier and easy problems harder to solve.

Abstraction: the process of translating real-world concepts into mathematical/computational concepts that are easier for us to deal with.

3) Plan.

Deciding how to solve the problem, choosing the algorithms and data structures to use. This is the most important part of the process, and it's where you'll spend the most time if you don't immediately see a solution to a problem.

4) Validate your plan

Before starting implementation, we need to validate our plan. We need to prove that the algorithm we designed will correctly perform the requirements in all cases, and that the time it takes to perform and the memory it uses are within the limits of the problem.

5) Implementing the plan

Always keep efficiency and accuracy in mind when implementing.

6) Reflect

The step that doesn't have a direct impact right away, but has the biggest impact in the long run. When you re-solve a problem you've solved before, you may find a more efficient algorithm, write more concise code, or even find a more intuitive way to derive the same algorithm. The most effective way to do a retrospective is to write down your experience each time you solve a problem.

Recording your approach, key realizations, and reasons for incorrect answers can help you reduce mistakes and help you pattern. Looking at other people's code that you've solved can also provide insights you might not have thought of.

Refer to other people's code or solutions after a period of time, even if you haven't solved it, but be sure to review it.

Troubleshooting strategies

1) Intuition and systematic approach

Have you solved a similar problem before?
- You should be able to understand and transform principles, not just solve them.
Can you start with a simple method?
- Can you solve it without knowing it? There is also a way to create the simplest algorithm and implement it through optimization, starting from
- You can establish a baseline for algorithmic efficiency
Can I formalize the process of solving the problem?
- Formalize while solving examples given in the problem, etc.
Can I simplify the problem?
- Solving an easier variant of a given problem first
Can it be illustrated?
- Geometric shapes are more intuitive to accept
Can it be expressed as a formula?
- Plain text → formulas can help solve problems
Can the problem be decomposed?
- How to transform the problem into a more tractable form, such as decomposing constraints
Can I solve the problem by thinking from the backwards?
- Typical examples: The ladder game.
- Can you reduce the number of steps by working your way up from the bottom to the top rather than trying all the paths from the front?
Can we enforce the order?
- How to enforce order on a problem that doesn't have it
- Example: Do, don't, or only 2 cases exist for a single variable / order doesn't matter → Decide whether or not to transform in order.
Can we only consider certain forms of answers?
- Normalization techniques
- How to group answers that are different in form but the same in result, and consider only the group representatives

[Effective C++] item 02

Tue, 12 Mar 2024 14:40:14 GMT

#Prefer Const, Enum, and Inline over #define

Expresses preference for compiler over preprocessing

#define FOO 1.024

The above case is a preprocessor that substitutes the string before compilation.
The above symbol FOO can be removed without the compiler being aware of its existence, so it may appear as a constant in errors, so if there is a bug related to this, it will be a waste of time to track it down.

const double FOO = 1.024;

The solution is to replace the macro with a constant.
The constant is clearly observable by the compiler and is also clearly entered in the symbol table. Also, if the substitution is done in bulk through a preprocessor, multiple copies of the object may be created, but in the case of a constant, no more than one copy is created.

[Effective C++] item 01

Tue, 12 Mar 2024 14:01:04 GMT

C++ is a multi-paradigm programming language

Initially started as C with added object-oriented features
Currently supports procedural, object-oriented, functional, generic, and even metaprogramming

Generic programming: A programming paradigm that maximizes reusability by being data type agnostic, meaning that one value can have multiple data types.

Metaprogramming: writing and modifying programs that treat themselves or other programs as data, sometimes referred to as compile-time methods of doing some of the work that needs to be done at runtime.

C++ should not be viewed as a single language, but as a family of languages, each with their own rules.
- C: Many things originated in C, but C++ often provides a better approach and can be used to a more limited and safe extent.
- Object-oriented C++: The core of C++, where classes exist, and where object-oriented design comes into play most directly.
- Template C++: Less frequently encountered and rarely interacts with mainstream C++. It has given rise to a powerful paradigm called TMP.
- STL: Template library, but a very special case; there is a specific way to use STL and you must follow its rules.
If there is a transition between the above sublanguages, you may find yourself in a situation where you have to change your strategy.
C++ will be easier to understand if you understand that it is not a single language, but a collection of sublanguages, each with their own rules.

[Effective C++] enters

Tue, 12 Mar 2024 12:45:19 GMT

It's been a while since I've posted a study post.

I haven't transcribed all of them, but I'm currently working in system development at a company that I thought would be better compared to the company where I wrote about my passing testimonial.

There was talk of studying this book in the company, so I thought it would be good to utilize the existing platform while studying, and I will continue to write accordingly. I want to do a better job by learning about this book, but I feel a little bitter because it seems to be a long way off...

I'll try to keep the posts organized and one for each item. 화이팅!

Review of 42Seoul Rapisin

Sat, 23 Sep 2023 17:19:05 GMT

Introduction

While preparing for my job search, around the middle of this year as SSAFY was nearing its conclusion, I was concerned that my preparation period might be extended. So, while submitting applications to companies, I also took the time to research various bootcamps and training programs.

As a result, I decided to apply to 42Seoul, as I believed it was the program that best suited me.

There were several reasons for this, but among them, the emphasis on self-directed learning and time flexibility compared to other bootcamps, as well as the focus on relatively low-level programming languages, were particularly appealing to me.

The Rapishin Program

After successfully checking in and applying for Rapishin, I received final acceptance offers from several companies while waiting for the Rapishin program to begin. I originally planned to withdraw from the program, but after hearing stories from 42 cadets currently working in the field and considering the 42 curriculum, I judged that it was entirely possible to juggle both. So, I dedicated myself fully to the program in the beginning and then continued it alongside my job.

As those familiar with the 42 program likely know, there is a pre-course called "Rapicin" that must be completed before admission and the main program. This course is quite grueling...

If you’re a non-major with no prior background, keeping up might be a struggle, but if you’re a non-major with some programming knowledge, I believe you can achieve the desired results if you work hard. As for majors, I believe admission to the main program wouldn’t have been difficult unless they were unable to focus on the course for other reasons or were unfairly treated.

This is just my personal opinion, but since the education provided at 42 is quite similar to a university curriculum, I think it might actually be better suited for non-majors. For majors who have already completed a solid education in the field at university, the benefits offered by 42—excluding the financial aid and other support systems—seemed relatively lacking compared to other bootcamps.

The reason I considered joining the program, aside from the financial aid, was that I believed it offered a solid curriculum to fill the gaps in my lack of specialized knowledge. Since that fundamental premise didn’t change even after I secured a job, I was able to complete the Rapishin program.

(Naturally, you can’t receive financial aid after getting a job...)

Results

Fortunately, I achieved a good result and was accepted into the 10th cohort of 42Seoul. Since the program uses a tech stack similar to my current role at work, I’m looking forward to creating a positive feedback loop that benefits both areas.

Q & A

Let me answer some common questions about the program:

1. Can a non-computer science major with no prior experience get accepted?

While it might have been possible in the early cohorts, re-applications are now allowed, and with so much information available today, it’s nearly impossible.

2. Who would you recommend this program to?

Undergraduate students who still have plenty of time left in their degree programs, and non-majors who aren’t focused on immediate employment but want to build a solid foundation over a longer period.

3. What should you know before joining?

The more you know—such as basic C concepts and pointers (which can be hard to grasp at first)—the better. Everyone emphasizes learning how to use the Shell, but I’d also add the advice to familiarize yourself with Git.

4. What would you definitely recommend trying during the program?

Personally, the members of my first Rush team were wonderful people, and having completed the program with them, I’d say that while interacting with others isn’t strictly necessary, if the opportunity arises, don’t miss out on connecting with them. For developers, communication skills are just as important as coding!

[Glossary] File System

Thu, 14 Sep 2023 14:36:39 GMT

in

I realized that my knowledge of the underlying terminology was a bit lacking in my current role, so I decided to take the time to do some additional research and briefly summarize the terms I did know.

File Descriptor

in Linux, Unix-like systems
a type of value used by a Process when dealing with a File.

When a process opens a file, the kernel assigns it the smallest, unused value of the processor's file descriptor number, so that the next time the open file is accessed with a system call, the descriptor value can be used to refer to the file.

Default Assigned Descriptors

standard input (Standard Input)
standard output
Standard Error

Inode

Short for Index Node, a node for quickly locating files.

An inode is a node that indexes all files in Linux and holds metadata about those files. The inode holds the metadata that is output by the list command.

Symbolic Link

A file with information pointing to the inode of the source file.

Internally, files are accessed via inode number
has a new inode that does not hold information about the original file

cf) Hard Link

A file with a new inode, not a file with a new inode, just the inode copied verbatim
The difference from a true copy is that no additional data is written, unlike copying

Block Device & Character Device

Classifies devices by the difference in data transfer method
Block: Transfers data in quantitative units such as blocks or sectors, faster IO transfer speeds
Character: Transfers data in bytes, IO transfer speed may be slightly slower, but performance differences exist through buffering control at the application end.

Raw Device

Device without file system set up

Not buffered by the OS kernel, data is transferred directly from the device, and it has its own caching system.
Good disk IO performance, low CPU overhead.
Avoids OS file system overhead and can reduce OS buffer size.
Used as a raw device because concurrent access is not possible when configured in the system for shared disks.

IO Scheduler

The part of the system that sorts, merges, and determines the order in which requests are processed to make disk I/O efficient.

Particularly useful for devices such as HDDs, where seek times are expensive and merging requests for the same location is effective; effectiveness is halved on SSDs.
Types.
- noop: no-operation, used for high-performance disks
- cfq (completely fair queueing): Give each process an IO queue and schedule them as evenly as possible, used when a large number of processes generate fine-grained IO
- deadline: prioritizes closer to the threshold, optimizes for latency, balances all I/O, and is ideal for environments where a small number of processes generate a large amount of I/O.
- anticipacy: Predicts the location of future I/O requests and processes the closest I/O requests first; the structure used by traditional HDDs, which aggregate input and output, may increase latency.

[BOJ 9519, CPP] sleepy

Mon, 04 Sep 2023 14:32:38 GMT

Problem link

boj 9519

Classification

Implementations, Strings, Simulation

Description

This problem was initially solved by full exploration.

Measure the length of the string first
0 ~ assign a vector of numbers equal to the length of the string
Repeat and flip based on problem conditions
Once flipped a number of times, utilize the corresponding hash value to place them in reverse order
You can see the original look!

The most important thing to note here is that you can flip it over and over again, depending on the conditions of the problem, and the cycle will always come back the same as the initial array.

Once you've found the rule above and refined it, you can use the

Measure the length of the string first
0 ~ assign a vector of numbers equal to the length of the string
- check for a cycle from 1 to (length of string - 1) times
- iterate over the total number of flips divided by the number of cycles to derive the hash
If flipped a certain number of times, utilize that hash value to reverse the order
You can see the original image!

It will look like this

    for (int i = 1; i <= target_length - 1; i++)
    {
        for (int j = 0; j < target_length / 2; j++)
        {
            temp = result.back();
            result.pop_back();
            result.insert(result.begin() + 2 * j + 1, temp);
        }

		if (start_vector == result)
		{
			cycle = i;
			break ;
		}
    }

Initially, we moved the array directly as shown above, but this caused some overhead because we had to move the entire array after the insert, so it took a little longer.

    for (int i = 1; i <= target_length - 1; i++)
    {
		temp_vector.clear();
		temp_vector.resize(target_length);
        for (int j = 0; j < target_length; j++)
        {
			if (!(j % 2))
				temp_vector[j] = result[j / 2];
			else
				temp_vector[j] = result[target_length - 1 - (j / 2)];
        }

		if (start_vector == temp_vector)
		{
			cycle = i;
			break ;
		}
		else
			result = temp_vector;
    }

Therefore, we used the above method to create the array in advance and insert the values one by one, so that the time is only used for the maximum length of the array.

Solving code

// 졸려

#include <iostream>
#include <vector>

using namespace std;

vector<int> flicker_action(int target_length, int count);

int main(void)
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);

    int flicker_number;
    string result_string, init_string;
    vector<char> string_vector;
    vector<int> idx_vector;

    cin >> flicker_number;
    cin.ignore();
    getline(cin, result_string);

    for (int i = 0; i < (int) result_string.length(); i++)
        string_vector.push_back(result_string[i]);
    

    idx_vector = flicker_action(result_string.length(), flicker_number);
    init_string.resize(result_string.length());

    for (int i = 0; i < (int) result_string.length(); i++)
        init_string[idx_vector[i]] = result_string[i];

    cout << init_string << endl;
    return (0);
}

vector<int> flicker_action(int target_length, int count)
{
    vector<int> result, temp_vector, start_vector;
	int cycle;

    for (int i = 0; i < target_length; i++)
        result.push_back(i);

	start_vector = result;
	cycle = 1;

    for (int i = 1; i <= target_length - 1; i++)
    {
		temp_vector.clear();
		temp_vector.resize(target_length);
        for (int j = 0; j < target_length; j++)
        {
			if (!(j % 2))
				temp_vector[j] = result[j / 2];
			else
				temp_vector[j] = result[target_length - 1 - (j / 2)];
        }

		if (start_vector == temp_vector)
		{
			cycle = i;
			break ;
		}
		else
			result = temp_vector;
    }

	result = start_vector;

    for (int i = 0; i < (count % cycle); i++)
    {
		temp_vector.clear();
		temp_vector.resize(target_length);
        for (int j = 0; j < target_length; j++)
        {
			if (!(j % 2))
				temp_vector[j] = result[j / 2];
			else
				temp_vector[j] = result[target_length - 1 - (j / 2)];
        }

		result = temp_vector;
    }

    return (result);
}

[BOJ 4821, CPP] Page counting

Sat, 26 Aug 2023 15:04:16 GMT

Problem link

boj 4821

Classification

Implementations, Strings, Parsing

Include

I recently joined a new company, and it's been quite a busy time. I'm a new employee who feels a lot of pressure just being in the company... However, I've been writing down various stories, so I'm sure I'll be able to tell them sooner or later.

Recently, I had a great opportunity to learn C, and I'm always disappointed when I hit a time wall with Python or Java, so I wanted to take this opportunity to solve problems in C++.

From my short experience with it, I have a pretty good feeling that the implementation is quite cumbersome, but the speed compensates for it. If I can master it, will I be able to take advantage of the speed...? I'm looking forward to it.

Description.

Vector: dynamic array structure, similar to an array, but with the big advantage that the size can be flexibly changed and memory allocation is automatic!

npos: no position, an index value to check when the position is invalid.

stringstream: a device for treating strings as streams, allowing them to be treated in the same way as input and output, often used for parsing

The basic logic is to create a bool array to cover the entire range of pages, then check for all the pages that came in and print the count at the end.

However, it's worth noting that the range of numbers given in the problem can be given as values beyond int, so you'll need to set a variable to control that, and there are exceptions to not check if the range is given in reverse order.

This was fairly easy to do in Python, but in C++, the code became very long...

Solution code

// 페이지 세기

#include <iostream>
#include <vector>
#include <sstream>

using namespace std;

int main(void)
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);

	int				total_page, seperator, start, end, result;
	string			temp, each_range;
	vector<string>	line_info;
	vector<bool>	print_info;
	vector<int>		result_vector;

	while (true)
	{
		cin >> total_page;

		if (!total_page)
			break ;
		else
		{
			print_info.assign(1001, false);
			cin.ignore();
			getline(cin, temp);
			stringstream range_stream(temp);

			while (getline(range_stream, each_range, ','))
			{
				if (each_range.find('-') == string::npos)
				{
					if (each_range.length() < 5 && stoi(each_range) <= 1000)
						print_info[stoi(each_range)] = true;
				}
				else
				{
					seperator = each_range.find('-');
					if (each_range.substr(0, seperator).length() < 5
						&& stoi(each_range.substr(0, seperator)) <= 1000)
						start = stoi(each_range.substr(0, seperator));
					else
						start = 1001;
					if (each_range.substr(seperator + 1, each_range.size()).length() < 5 
						&& stoi(each_range.substr(seperator + 1, each_range.size())) <= 1000)
						end = stoi(each_range.substr(seperator + 1, each_range.size()));
					else
						end = 1001;
					if (start <= end)
					{
						for (int i = start; i <= end; i++)
						{
							if (i <= total_page)
								print_info[i] = true;
						}
					}
				}
			}

			result = 0;
			for (int i = 1; i <= total_page; i++)
			{
				if (print_info[i])
					result++;
			}
			result_vector.push_back(result);
		}
	}

	for (int i = 0; i < (int) result_vector.size(); i++)
		cout << result_vector[i] << endl;

	return (0);
}

Miscellaneous Shell Notes (3)

Tue, 25 Jul 2023 18:05:52 GMT

07/26/23 Corrected typos

07/27/23 Added command

BC

Short for Basic Calculator, this is a calculator provided in accordance with the POSIX standard and available on Unix-based systems.

Key features include:

Stack-based structure
Support for Reverse Polish notation (RPN)

echo '2 + 3' | dc
dc <<< '2 3 + p'

TR

A command that enables character conversion, deletion, and compression. It is typically used in conjunction with additional processes via a pipeline.

*tr [문자열1] [문자열2]

: Takes two strings of equal length and replaces the corresponding characters in string 1 with the characters at the same indices in string 2.

-c: Replaces all characters not present in the second set with the last character of that set.
-s: Removes all repeating sequences and replaces them with a specified character.
-d: Removes the specified character.
-t: Trims both strings to match their lengths before executing the command.

SED (

)

A command that supports various editing functions. It operates primarily on a buffer, so the original file remains unaffected until modifications are applied.

Command Options

Patterns are expressed in the form /[pattern]/.
Add -g to process all matching patterns.
Use commas (,) to specify ranges.
p: Prints all lines and prints an additional line for each pattern match
- Add the -n option: Excludes default output; prints only lines matching the pattern
d: Deletes the pattern
s: Replaces the pattern
e: Edit mode

*n;

: Next line

y: Y-confirmation
i: Insert
c: Change
a: Append

# 약간의 응용

sed -n 'n; p': 짝수 줄 출력
sed -n 'p; n': 홀수 줄 출력

WC

Word Count

-l: Check the number of lines in the file
-c: Check the number of bytes in the file
-m: Check the number of characters in the file
-w: Check the number of words in the file

Miscellaneous Shell History (2)

Thu, 20 Jul 2023 16:49:40 GMT

List

Commands usually used with ls. You can use these commands to see the contents of a directory. The additional commands are useful because they allow you to pull out the list for appropriate purposes.

We'll leave the commands we use most often and the commands we need for specific applications, and if you need more, you can use man to get the manual or refer to the documentation linked below.

-l: Long Default Format. working john 2008-07-25 11:56 csrc 1 alias.c-4.5 27

-al: displays the full text.

-t: Sort by modified time.

-m: output each element separated by commas and spaces (, ) this, is, example

-r: output in the reverse of the current order

-R: recursively prints the contents of subdirectories

-h: Print units in human-readable format (using units like m, k, g, etc.)

List Manual

Find

This command searches for a file, searching through all subdirectories based on a given location and printing the results. It provides a lot more functionality than just output, and if you really want to get the most out of it, you'll need to learn about regular expressions.

-name: This is a command to add information about the name of the search, which can be restricted through regular expressions.

-o: This command works like the or operator, if you want to have an action a if condition A and an action b if condition B, use this command.

-exec: a command that allows you to apply additional commands.

-delete: command to remove the found file

-print: command to print the found files

Similarly, you can search for other commands here.

Find Manual

Echo & Printf

I use echo a lot in the shell, but besides echo, you can also use printf. Honestly, I don't know much about it except whether it defaults to newline or not, so I asked ChatGPT to help me with this part!

Surprisingly, printf is a bit more sophisticated than echo, which I often use. I don't think I'll notice any difference in light use, so I'll go with this information for now...

Miscellaneous Shell History (1)

Mon, 17 Jul 2023 17:25:08 GMT

File creation related

touch: Create file
mkdir: Create folder
chmod: Set file permissions
chown: Set file owner
mv: Move and rename files

Check file information

-rwxr-xr-x Part: Checking the file's permissions

the first digit means File Type (-, d, l)
read-write-execute permissions are expressed in 3-digit form for user, group, and others, The value of rwx can be changed to 7 and -xr can be changed to 4 because r has a value of 4, w has a value of 2, and x has a value of 1 in the form of a binary number.

chmod 744 Slack.lnk

This type of command can be used to set permissions. 3. Number of links (where 1 is written) 4. Information about the owner (blank) and ownership group (197609) 5. File size 6. Information about the last modified time 7. The file name

ssh-keygen

Used in many cases for Git authentication via Secure Shell public key
Included in Window and Linux packages
When generating a key, a key and .pub file is generated, which is used as a key-lock by providing the contents of the .pub file to the server

How to adjust the capacity of a file in the shell

mkfile -n 10k test.sh
fallocate -l 10k test.sh
truncate -s 10k test.sh

You can resize an existing file or create a new file with this command.

Change the file modification history

touch -t 2301011234 timefile.sh

Command to change the modification history of a file to show that it was last modified on 1/1/23/12:34 as an application of touch.

Hard Link & Symbolic Link

Symbolic Link (Soft Link)

A link that makes the original file available in a specific folder, such as a shortcut in Windows, and does not work if the original is deleted.

Hard Link

Unlike a symbolic link, the difference is that it copies the original and creates a copy; when the original is deleted, the symbolic link becomes unusable, but a hard link can still be used because it is the same file after all; links that are involved in the number of links.

Code

ln [대상 폴더] [만들 링크 파일명] # Hard Link
ln -s [대상 폴더] [만들 링크 파일명] # Symbolic Link

The erase command can be lifted with rm, just like erasing a file

Diff & Patch

diff a b > difference.patch

The diff command compares two files on a line-by-line basis, and the patch command allows you to modify a file based on the comparison made by diff.

patch -p{패치 경로의 depth} [원본] [patch 파일] # 패치 파일 적용
patch -p{패치 경로의 depth} -R [원본] [patch 파일] # 적용된 패치 파일을 되돌림

In the same form as above, you can apply and remove the contents determined through diff from an existing file.

2023 Asiana IDT Summer Recruitment Review

Sat, 15 Jul 2023 09:23:14 GMT

in

Development jobs are also affected by the economy, so the number of screenings and hiring is much lower than last year. In the end, the winner is the one who can get the job when the time comes, so I think I need to be more consistent.

Document screening & competency testing

As with other companies, there was nothing unusual about the documents, but the competency test, which is similar to financial recruitment, was unusual.

I thought I answered everything normally, but I was worried because (Caution) appeared, but there was no problem with the cam or microphone, so I submitted it as it was,

I was able to pass without any problems. If I had more time, I would have checked the competency check one more time.

Coding test

The difficulty level and question types reminded me of coding tests in finance. Overall, the difficulty level was average, and SQL was similar.

I passed and got a chance to interview at Asiana IDT!

Final Interview

I picked up my interviewer's visitor's pass at the entrance of the building and went to the interview, which was similar to the other reviews I had read in preparation.

I wasn't expecting to play a big role in the discussion interview, but I thought it was a process to screen out people with communication problems.

In the personality interview, I was asked questions based on a combination of documents, coding test results, etc.

I don't think there are many people like this when applying for a job, but I thought that people who haven't researched the company enough might have difficulty with the questions.
I realized that the company was thinking about the direction of the company's development by asking interviewees for their opinions.

End result.

I thought I answered better than usual in the interview, but I managed to get the job despite the high competition!

Impressions

When entering the IT industry, many people have a vague fear of SI/SM because of all the stories they hear, and that's exactly what I did.

~~Hyper Realism

However, I think that most of the domestic IT industry is centered on SI/SM, not IT services, and if you overlook this, you may make irrational choices.

As the job market is not the same as it used to be, I think it is time to have the sense to consider what is the best option you can do now rather than going for too narrow a goal, and if you keep this in mind, you will get good results!

[Interview Question] What is object-oriented programming?

Wed, 12 Jul 2023 07:28:03 GMT

in

Yesterday, while interviewing for a job at a major company, I had a situation where I had to answer a question about object-oriented programming that I thought I knew and had organized, but when it came time to answer, I stumbled over it.

Thanks to this, I thought I had pointed out my weaknesses and decided to take the time to reorganize!

What is a ### object?

Let's start with a general definition

General theory: something that actually exists Computer science: Something created in memory as defined by a class.

Object-oriented languages define the following

Java: an instance of a class or an array Python: data that has a property value or behavior.

Classes in Java are not instances, but classes in Python are.

Object-oriented programming

Building interactive programs by defining the roles and relationships of objects.

We can define it like this.

Characteristics of object-oriented languages

abstraction

Able to derive common features between objects
The part that defines the class is

Polymorphism

Can be called the same for functions that behave in slightly different ways
Passing interpretation to linked objects for the same command
Override (overriding internal sources), overload (calling another function with the same name based on parameters)

Encapsulation

You can hide the parts of your implementation without exposing them to the outside world
If you need to communicate with the outside world, send and receive information via methods

Inherit from ####

The inheritance of features from one class by another class
Allows you to create new classes in addition to those already created

[BOJ 11689, Python] GCD(n, k) = 1

Fri, 07 Jul 2023 06:49:25 GMT

Problem link

boj 11689

Classification

Mathematics, Number theory, Eulerian functions

Description

Recently, I've been practicing solving Backzun problems without categorizing them in order to really improve my skills. However, when I come across something like this problem, I get quite a headache.

In the case of this problem, I initially thought that I should at least try to get it below O(N), since I need to be able to check the numbers up to 10¹² in 1 second. I thought that if it was a prime factorization, I could just do a normal prime factorization and not have any overlapping numbers, so I used the following code.

def factorize(target_number: int) -> list:

    result = []
    prime_list = find_prime(target_number)

    now_number = target_number
    while now_number > 1:
        for each_prime in prime_list:
            if each_prime > now_number:
                break

            elif not now_number % each_prime:
                while not now_number % each_prime:
                    now_number //= each_prime
                result.append(each_prime)

However, the time complexity was not satisfactory based on this code, so I decided to check the tags and found a new friend in 오일러 피 함수.

As it turns out, the problem itself is a function called

φ(n) = {n, the number of natural numbers less than or equal to n that are prime to each other}

I was able to implement it like this


def euler_phi(number: int) -> int:
    '''
    오일러 피 함수를 활용한 자연수 n과 서로소인 수의 갯수를 구하는 함수
    '''

    checker = 2
    result = number

    while pow(checker, 2) <= number:
        if not number % checker:
            while not number % checker:
                number //= checker

            result -= result // checker

        checker += 1

    if number > 1:
        result -= result // number

    return result

start at 2 and keep going.
if the number is divisible, divide it as much as it is divisible. (prime factorization)
subtract from the resulting number because multiples of that number cannot be prime.
If there is a number left at the end, subtract it from the resulting number because it is a prime number and multiples of that prime number cannot be prime.

This is where things got a little tricky.

result -= result // checker

I wondered why we were removing the divisor from result instead of removing number // checker, but it makes sense. If we remove the multiples of n, and then remove the same number of multiples of m, we end up with 2 multiples of n * m!

To handle these duplicates, we subtract the number of multiples of that number from the number that has already been subtracted once.

Anyway, once you understand how to solve it, it becomes a very easy problem. This seems to be the case with number theory problems, which is great for learning, but a little frustrating because the first approach is always hard...

Solution code

# GCD(n, k) = 1

def euler_phi(target_number: int):
    result = target_number
    check_number = 2

    while pow(check_number, 2) <= target_number:
        if not target_number % check_number:
            while not target_number % check_number:
                target_number //= check_number
            result -= result // check_number
        check_number += 1

    if target_number > 1:
        result -= result // target_number

    return result

target = int(input())
print(euler_phi(target))

[Interview Question] Dependency Injection

Thu, 06 Jul 2023 11:46:58 GMT

Dependency injection

Dependency: a relationship in which an object uses another object. → Dependency injection: something that establishes the relationship

Why do we need dependency injection?

public class Product {

	private Apple apple;
    
    public Product() {
    	this.apple = new Apple();
	}

}

In this example, if a class called Product uses the Apple constructor, we are using it without injecting it. If Product is used, it can be understood as a dependency that comes with Apple. In this case, it's not a connection between objects, but a relationship between classes.

Also, if I wanted to use an additional class called Orange, I would have to make changes to the Product class constructor, which is inflexible.

In conclusion, to summarize why dependency injection is necessary

Strong coupling between classes + inflexible code

These problems can be solved with dependency injection, so I'd say it's necessary!

Application of the solution

public interface Fruit {

}

public class Apple implements Fruit {

}

public class Product {

	private Fruit fruit;
    
    public Product(Fruit fruit) {
    	this.fruit = fruit;
    }
    
}

You can see that each class is guaranteed to be independent.

adding a new Fruit doesn't change Product
relationships between objects are formed instead of class relationships

[Interview Question] The Structure of the Java Stack & Heap

Sun, 02 Jul 2023 17:19:40 GMT

Java Memory Structure

See JVM Structure and Principles

The Java Runtime Data Area we built to run the application is located in memory

The PC Register, Native Method Stack, and Method areas are shared by all threads.
Only the Stack and Heap regions are thread-specific

Structure of the Heap

Eden → Survivor → Old

The objects are moved in the above format, which is basically the order of creation.

The role of the Garbage Collector

Eden: a place where Java objects are stored as soon as they are created.
Survivor & Old: space where objects are moved based on their degree of reference
Mark and Sweep: uses the Mark and Sweep algorithm.

Minor Garbage Collector

Responsible for moving the Eden and Survivor regions (Young Generation) based on object references if their memory exceeds the allowable amount.

Major Garbage Collector

Responsible for removing all unreferenced objects and reclaiming memory when the memory of the Old region (Tenured Generation) exceeds the allowable limit.

Stops all threads except the one running the garbage collector during the deletion process ('Stop-The-World')

Structure of the Stack

Base Type + Local Variables + Parameters

In the case of a parameter, it is used in the form of a reference to an object in the Heap region with the object's address value.

→ If the parameter refers to a different object, the address value will only be different, and the object stored in the Heap will not disappear immediately! (Hold until the Major GC is executed)

Note

Coding Factory's article

[BOJ 27231, Python] Why I'm Looking Forward to 2023

Fri, 30 Jun 2023 10:32:49 GMT

Problem link

boj 27231

Classification

Brute Force Algorithms, Backtracking

Description

It's nice to see that I've been able to solve problems that I couldn't solve before, so it feels good to know that I've improved.

In the case of this problem, my last attempt was submitted to the competition 5 months ago, but I've written down the solution several times in the meantime.

The reason why there are multiple attempts is because there is only one condition missing, but I'm still not sure why I get a timeout for missing this condition. ~~I hope it's a reason that I can make up later.~~ → I thought of this while organizing the content below. Organizing your blog is the best!

Let me introduce the problem-solving approach

Bitmask the coordinates between the * + symbols to check for whole numbers

Set or sort in a list that doesn't allow duplicates
Counting numbers up to the number initially entered (because no matter how you slice it, it can never be larger than that number) with increasing squared size

And here's where we run into a problem.

For a number consisting of 0s and 1s, I should output Hello, BOJ 2023!, because if you break it down to a single number, the value will remain unchanged no matter how many times you square it, but I was simply excluding the case of 1.

To check this part, I was able to handle the edge case by checking for a single number greater than 2 and printing Hello, BOJ 2023! if there is no term greater than 2, which is the correct answer.

Solving code

# 2023년이 기대되는 이유

import sys

input = sys.stdin.readline

def pow_target(target_num: int, exponent: int) -> int:

    result = 0

    now_number = target_num

    while now_number:
        result += pow((now_number % 10), exponent)
        now_number //= 10

    return result

testcase = int(input())
result_dict = dict()
output = []

for _ in range(testcase):

    target_number = input().rstrip('\n')

    if result_dict.get(target_number) is not None:
        output.append(result_dict[target_number])

    else:

        is_under_limit = True

        for each_element in list(target_number):
            if int(each_element) > 1:
                is_under_limit = False
                break

        if is_under_limit:
            result_dict[target_number] = 'Hello, BOJ 2023!'
            output.append('Hello, BOJ 2023!')
            continue

        length = len(target_number)

        check_list = []
        check_list.append(int(target_number))

        for i in range(1, 1 << length):

            calc_result = 0

            now_start = 0
            now_end = 0

            for j in range(length):

                if i & (1 << j):
                    now_end = j
                    if now_end:
                        calc_result += int(target_number[now_start : now_end])
                    now_start = now_end
                    
            calc_result += int(target_number[now_start : length + 1])

            if calc_result not in check_list:
                check_list.append(calc_result)

        else:
            result = 0

            check_amount = len(check_list)
            check_list.sort()

            max_value = check_list[-1]
            pointer = 0
            counter = 1

            while pointer < check_amount:
                now_result = pow_target(int(target_number), counter)

                # 종료 조건 1
                if now_result > max_value:
                    break

                while pointer < check_amount and now_result > check_list[pointer]:
                    pointer += 1

                # 종료 조건 2
                if pointer >= check_amount:
                    break

                if now_result == check_list[pointer]:
                    result += 1

                counter += 1

            result_dict[target_number] = result
            output.append(result)

for result in output:
    print(result)

[BOJ 13325, Python] Binary Trees

Wed, 28 Jun 2023 12:58:52 GMT

Problem link

boj 13325

Classification

Dynamic programming, Trees, Dynamic programming in trees

Description

If you're like me, you're the kind of person who sticks with a problem for a long time, even if it's not solved right away!

So, along with the problems that I tried but didn't get, there are problems that I tried hard but couldn't solve, along with the competition questions...

To get rid of them, I sometimes read through the questions and chew on them, and I'm so glad I finally found the solution in this post today!

I've had this problem for 8 months now, since my first attempt, and I've tinkered with it a few times since my last attempt, but nothing seemed to work.


def pre_order_detail(graph_dict: dict, target_node: int = 1) -> list:

    result = [target_node]

    if len(graph_dict[target_node]) >= 1:
        for each_element in pre_order_detail(graph_dict, graph_dict[target_node][0]):
            result.append(each_element)
        result.append(target_node)

    if len(graph_dict[target_node]) >= 2:
        for each_element in pre_order_detail(graph_dict, graph_dict[target_node][1]):
            result.append(each_element)
        result.append(target_node)

    return result

My original idea was to use a variation of a potential traversal in the form of a recursive function like the one above, taking a picture of the nodes visited, putting them in a stack-like data structure, and then traversing each trunk.

However, I realized that if I restricted the comparison to trunks from the same parent node, it would be cleaner if I just kept adding the larger of the two values to the parent trunk, and then processed it!

I later solved and categorized this type of problem as a tree DP. I thought it was very similar to DP.

Solving code

# 이진 트리

import sys

input = sys.stdin.readline

tree_height = int(input())
node_number = pow(2, tree_height + 1)

edges = [0] + list(map(int, input().split()))
edge_sum = sum(edges)

now_start = node_number // 2 - 1
now_end = node_number - 1

while now_end:

    for i in range((now_end - now_start) // 2):

        child_edge = now_start + (2 * i)
        next_node = child_edge // 2

        edges[next_node] += max(edges[child_edge], edges[child_edge + 1])
        edge_sum += abs(edges[child_edge] - edges[child_edge + 1])

    now_end = now_start
    now_start = now_start // 2

print(edge_sum)

This is a cleaner code length and time complexity than I initially thought. Now that we have it laid out like this, it's definitely bottom-up.

[Archive] What is IaaS, PaaS, and SaaS?

Mon, 26 Jun 2023 05:21:36 GMT

What does "aaS" mean in common parlance?

Abbreviation for 'As a Service'

It means that a third party provides cloud computing services!

What's the difference?

Different infrastructure, platforms, and software are provided as a service. → Different management level

1. IaaS

Evolved from on-premises infrastructure
Infrastructure services delivered to the cloud
Provider is responsible for the management and access to network, servers, virtualization, and storage
Examples include AWS, Azure, GCP, etc.

2. PaaS

Broader scope of responsibility than IaaS
Allows users to develop, run, and manage their own applications
Provides an environment for build and deployment

3. SaaS

All applications are managed by the provider
Provider manages all maintenance, upgrades, and security of the software

Note

IaaS vs. PaaS vs. SaaS

[Interview Question] What is a Connection Pool? (Feat. ChatGPT)

Sun, 25 Jun 2023 17:05:44 GMT

What is DB Connection Pool?

Store objects that have already connected to the DB in the pool. Borrow the connection when a client requests it When processing is finished, return the connection and save it back to the Pool

I think you can understand that it is like a connection object that is connected in advance and then retrieved when needed.

Why use it?

For Java Spring,

If you're using a direct connection to the DB for processing, you can use the
Need to load the JDBC Driver and get the connection object each time
Driver loading, object creation, and connection is repeated for each request

→ This is very inefficient, so we use Connection Pools to solve these problems.

+ Other frameworks also use it.

Features

Pre-created in the Connection object pool when WAS runs
Get, write and return objects based on HTTP requests
No connection, creation time consumed per Connection request → Reduces connection load

What if the number of concurrent connections is more than the number of objects in the pool? → If there are not enough pre-created connection objects, wait in order until returning

Larger pools consume more memory and reduce latency.

[Side Note] Regarding the location of the main function

Sun, 18 Jun 2023 11:50:50 GMT

Introduction

I’ve decided to use the “자투리

” category to share brief insights I’ve learned!

Placing the main Function at the Top

This is something that occurred to me while taking the [CS50](https://www.youtube.com/live/ywg7cW0Txs4?feature=share

) course. Personally, I tend to write code like this:


def example():
	print('hello')
    
def main():
	example()
    
main()

For example, I list all the necessary function definitions at the beginning and then add the main function afterward.

However, I realized that having the main function right at the top definitely makes the code clearer for others to understand.


def main():
	example()
    this_function()

def example():
	print('hello')
    
def this_function():
	print('function')
    
main()

I should move the main function—which demonstrates the overall structure of the code—to the top and list the detailed definitions afterward to better illustrate the code’s functionality.

SSAFY 8th year review, nothing extraordinary

Fri, 16 Jun 2023 17:28:37 GMT

in

It's finally the end of the year-long journey of the 8th edition of the Samsung Youth SW Academy, SSAFY. It's been a lot of work, but it's been a lot of fun, so I thought I'd write about it now. If you look at the SSAFY reviews, you'll see that most of them have completed the program with a grade of excellent or higher, and even received a certificate or two...

I think you can think of this review as the story of an SSAFY student who is out there somewhere, not someone who has won many awards and is an excellent SSAFY-type person. I also hope that it can be helpful to those who will take the SSAFY course in the future.

입과

I somehow managed to break through the barrier of SSAFY, which is usually known to be high for non-majors. I passed the self-introduction and failed the interview... but I was notified that I was accepted as a non-major, which is rare, and I joined the Seoul campus. I was able to skip the start camp because I was a last-minute admitted student, but I was told that the start camp is only for those who have been through it.

When you get into SSAFY, you are given a name tag, but even the name tag had my name pasted on top of the other early adopters' names... I had to tape it up afterward because it kept falling off.

Looking back on it now, I think it actually made me work a little harder. I think it kept me motivated and constantly reminded me that the opportunity I was given was priceless!

1st semester, Python track

In the first semester, there was a Java track and a Python track, and although I knew I wanted to learn Java, I chose to take the Python track. There are many things that I learned in the first semester...

In the second semester, I think the only things I actually learned and used well were Algorithm, Git, and Python. Even so, Python and Algorithm are overwhelmingly more often used for coding tests than for projects...

(I'm learning Frontend, but I'm mostly re-learning React, so it doesn't even exist)

Still, if you join the track, you can see that almost everyone is passionate about learning, just like SSAFY. I think I spent a lot of time in the class, making studies and studying at the cafe together.

In my case, I had almost zero experience in programming because all I had was a neat college education, and I thought that I couldn't be good at everything, so I thought that I needed to choose and focus. So I thought that I should look at the recruitment process first and try to break through it step by step.

Screening → Coding test → Personality interview → Technical interview → Hiring

I found that most companies stay within this range. As a result, I thought, “If you can't pass the coding test, you have no future,” and this is the beginning of the algorithmic tech tree...

I invested a lot of time in studying to improve my algorithmic abilities, but eventually, I virtually exhausted myself after achieving Platinum 5. From that time, I also studied the Java language in order to pass the Samsung Software Competency Assessment Type B, but unfortunately, I ended up not passing. The review is here and if you get Type B, you will be prioritized for various benefits, experiences, and connections provided by SSAFY, so if you can get it, do it!

(However, I think it is important to solve even low-level problems steadily so that you don't lose your sense, so I solved them steadily)

After struggling through the theory and practical exams almost every week, I reached the culminating project. This was a 7-week project that, in hindsight, would have been challenging in the second semester and required overwhelmingly fewer people and less time to accomplish! I'm sure I've seen some nice code and pretty applications somewhere, but in the end, the prize went to the team that did what others couldn't (e.g., deployment).

Second semester, one project after another.

In the second semester, you work on projects the whole time, which I think is the most important part of SSAFY.

In the first semester, even if you want to apply to a company, if they ask you "What have you done?", you have nothing to answer, so you have a limited amount of things you can appeal to in your self-introduction or interview, but as you gradually progress through the second semester, regardless of the outcome, if you have faithfully participated in the project, you can say things like "I did such and such, and I had difficulties in such and such, but I improved in such and such a way"!

If the topic seems to be this or that, but it's not a specialized project, I've been able to work on whatever the team wants without getting stuck on a topic. In my case, I worked on two app development projects and one web development project with mobile specifications. As for the positions, different people may have different things they want to do in the second semester, but I wanted to get experience in all positions, so I went with one backend, one frontend, and one app experience.

If you're in the Python track, you'll mostly be building a wall with Java, and since 99% of the projects in the second semester use Spring Boot, you'll inevitably end up on the front end, which is where you'll get the fix for your position. So if you're a Python track student, it's a good idea to take Java separately if you know you want to be on the back end. In my case, I took the Java course separately to keep myself open for backend positions, and as a result, I was able to get one backend position.

Job Hunting and Interviews

While I had the illusion of showing something from semester 1 to semester 2, a small group of prepared people were consistently trying to get in touch with companies, and as a result, had the honor of having a SSAFY escape in between. My first thought when I saw those people was, "I'm not ready yet...". It won't be too late when I finish my project,' but as a result, after two semesters, you naturally start to prepare by watching various leaders who escape.

You may be disappointed to see yourself accepting and completing the second semester certificate while someone else is getting the employee certificate, so you should keep trying. I applied to a lot of places and I ended up accepting the second semester certificate, but I think I'm glad I did.

Once you have passed the coding test and document screening with the various benefits of SSAFY and the skills you have built up, there is still the interview. You often don't know where you are lacking until you have both personality and technical interviews, so I think it's really good if you can experience it during the training period.

You definitely get better at interviewing the more you do it. I think that you can't experience how to deal with the interviewer unless you are in the situation and nervous, so if you are capable of it, keep taking interviews with companies that are lower than the level you actually want so that you can get better results at the company you actually want!

Afterward.

So what are we going to do after SSAFY?

I spent a lot of time thinking about this question and I'm still trying to figure out the answer. Basically, I want to take some time to calmly reflect on the projects I've worked on, but I also want to summarize what I've learned, and I still want to find a job as soon as possible, so...

In the end, I think I'll continue with everything. I believe it's best to keep building from the bottom up, because the work I've done so far won't disappear. My SSAFY 8th year journey is coming to an end, but my life as a developer doesn't end here! I believe that better days are waiting for me and I will continue to work hard.

2023 LG CNS H1 Recruitment Review

Fri, 16 Jun 2023 08:27:19 GMT

in

In the first half of this year, I applied for the LG CNS entry-level recruitment process and made it to the final interview. To conclude, unfortunately, I didn't get a good result. However, rather than covering up my failures, I would like to write down what I lacked and do better next time. I hope it will be helpful for those who are looking for jobs in the future.

Screening

I don't think there was anything unusual about the screening process. The only thing that was unusual was that the self-introduction letter was shorter than other companies. However, there were cases where I was rejected, so I think there was a differentiating factor. If you passed, you could proceed to the coding test.

Coding test

Overall, I don't think the difficulty level was too hard. If you can randomly solve the Silver ~ Gold 5 level questions, I think you can do well enough. If I had to give a direction, I think it would be helpful to practice being able to respond to any problem in the field rather than asking for creative algorithms.

If you've solved the problem to a certain level, you can move on to the interview, and I passed with flying colors.

First Interview

After passing the coding test, I received information about the first round interview. It was basically a video interview, and I think they asked me about the questions in my cover letter and general interview questions. I don't remember what the interviewer said, but he said that they don't have high expectations for new hires and don't evaluate competencies. He also said something after that, but I was nervous and deleted it from my memory. I think if we look at competencies less, we would focus on things like personality, self-introduction verification, integrity, and culture fit!

On a side note, if you did well on the coding test, you might get a small compliment from the interviewer about the test. I felt good because I paid attention to the counterexamples and edge cases that might be there, and it felt like I got a confirmation of the result.

I was unfamiliar with the interview, so I was very stiff and clumsy, and I thought I failed... But I got the opportunity to go to the second interview. After all, selling noodles is a science.

2nd interview

Similar to other corporate screenings, the people who have the power to decide which department you will work in if you are hired come to interview you in person. They introduced themselves at the beginning, but I was too nervous to remember. I think they were trying to make it easy for me, but I only remember that when I thought it was similar to the first interview, they started to ask me technical questions and I was rambling. Finally, I asked him what kind of attitude he would have if he joined the company with ambition, and I remember him smiling and saying some good things. And...

I was honestly heartbroken when I got the answer. However, when I thought about it after the interview, it wasn't an unreasonable result because there were many things that I was disappointed with. I think that I answered the technical questions I was asked and my level of awareness of the company I applied to too poorly, so I didn't have any strengths that the interviewer thought would impress them and make them want to hire me.

Final thoughts

I'm disappointed because I was the closest I've ever been to getting hired in the first half of the program. However, I believe that the report card I received now gives me a direction to move forward, and I am working hard to improve the areas that I was lacking.

I hope to use this experience as a springboard to become a better version of myself. If I can make them regret not hiring me in the future, that would be a good outcome. In the next CNS recruitment, I will try harder to be the person who can choose the company instead of the company choosing me.

[Interview Question] Structure and Principles of the JVM

Thu, 15 Jun 2023 16:30:41 GMT

23-06-27 Complete Unfinished Content 23-07-01 Complete and fill in content

Java Overview

1. Java's Development Philosophy

Write Once, Run Anywhere

Aim for a platform-independent language
Developed with the focus on being able to run code written in the same language on any operating system (sort of cross-platform)

2. JDK

Java Development Kit It is a Java development tool and includes both JRE and JVM. Unlike users, who basically only need to run programs written in Java, developers need to install the JDK. The JDK includes a compiler.
Java Runtime Environment The Java Runtime Environment, which includes the Java Class Library, the Java Class Loader, and the JVM. Java code written through the class loader and the library can be combined with the library and run on the JVM.
Java Virtual Machine

What is JVM?

Java Virtual Machine, Java Virtual Machine.
Software that provides an environment for running Java programs.

Java Code → Compiler → Machine Language

Builds the Java Runtime Data Area by allocating memory for the application to run.

Runtime Data Area

Heap Area
Method Area

The above two areas are shared by all Threads

PC Register
Native Method Stack
Stack Area

The above three areas are created at startup and destroyed at termination for each thread.

Details of each area

1. Heap

Space where instances of classes, arrays are stored

Garbage Collection * Dynamic memory management system

2. Method

Space to store the structure of classes, interfaces

3. Stack

Similar to C's stack structure, stores local variables and the results of function execution
It is responsible for calling and returning functions and has a Stack Frame.
What is Stack Frame?

A delimited space for each function that contains the function's call information. Frames are handled in a LIFO fashion If a frame is added when there is no free space → Stack Overflow occurs Pointer method using prologue and epilogue to determine stack return location

4. Native Method Stack

Execution stack of methods written in C, CPP
Native Method Stack is assigned when executing code
May result in StackOverflowError or OutOfMemoryError
Can dynamically resize the stack

5. PC Register

Each thread has a PC Register
Records the address of the instruction when the thread executes the currently assigned instruction
Steadily fluctuates the value from instruction to instruction to execute the pointed-to value

Notes

JVM Document 고랭이님의 블로그 sgwon1996's velog

[Interview Question] What is DB Index?

Tue, 13 Jun 2023 15:20:25 GMT

Data structures to speed up searches of database tables

Advantages of using indexes

Improved performance due to faster table lookups
Can reduce system load

Disadvantages of using indexes

Requires additional storage space for DB indexing
Additional work and overhead for DB management

Index management

Because indexes must always be kept up-to-date and sorted to quickly find the desired value, hanging an index on a property whose data is frequently modified can result in a performance penalty due to overhead.

INSERT: Adds an index of the inserted data on insertion
DELETE: indexes on deleted data should be disabled
UPDATE: Disable existing indexes + add indexes for updated data

Data structures used

B+ Tree

B Tree enhancement specification

Store data only in leaf nodes

Leaf nodes have a linked list between them

Hash Table

Stores data as key - value pairs Data can be navigated in a very short amount of time Not often used due to inequality operations (sort X)

Classification of indexes

1. Classification by Key

Primary index: contains primary key (order of key = order of records)
Secondary index: without primary key (order of keys != order of records)

2. Classification based on file organization

Focused index
Non-centralized indexes

3. Categorize by data scope

Dense indexes
Sparse indexes

Note

brunchstory by Nathan

[1Day-1CS] Devices that handle each layer

Mon, 05 Jun 2023 15:08:16 GMT

2023-06-18 Merge content from previous posts for content consistency

Devices that handle the application layer

L7 switch: also known as a load balancer, a device that balances the load on servers

Switch: A telecommunications network device that connects multiple devices and mediates data communications, sending electrical signals only to the connected ports to transmit data.
Aimed at increasing the amount of traffic a system can handle
Distribute traffic based on URLs, servers, caches, cookies, etc.
Has filtering capabilities to keep out unnecessary external data
Allows you to monitor traffic

= Health Check excludes failed servers from traffic distribution via a health check

Difference between L4 and L7 switches

L4 switches are devices that handle the transport layer and cannot be used for streaming-related services.
Message-based unawareness, IP & Port based traffic distribution
In cloud services, load balancing with L7 switches is done with ALB (Application Load Balancer) component and load balancing with L4 switches is done with NLB (Network Load Balancer) component

Health Check

Sending requests to the server repeatedly by setting the transmission cycle and number of retransmissions, etc.

Appropriate enough to not overload the server
Sending requests in different ways and determining if they are processed correctly.

Server redundancy with load balancers

Provide virtual IPs based on 2 or more servers and provide stable services based on them

Server redundancy is necessary because the service must continue even if a specific server fails.

Devices that handle the Internet layer

Router: connects, divides, and separates multiple networks. L3 switch: L2 switch + router

Devices that handle the data link layer

L2 switch: Manages the Mac addresses of devices, sends packets, etc. Bridge: a telecommunications network connection device that allows two local area networks to interconnect

Devices that handle the physical layer

Network Interface Card (NIC): LAN card, uniquely identifyingMac addresses reside here. Repeater: Amplifies an incoming signal and forwards it to the other end. AP: a device that copies packets; connects a wired LAN to a wireless network.

[Interview Question] Frameworks and Libraries (Feat. ChatGPT)

Sat, 03 Jun 2023 13:45:20 GMT

Introduction

This time, I was asked this question for the first time in an interview, and although I honestly thought I knew the answer, I couldn't answer it clearly and ended up giving an alumni answer... So, I'm writing this article to know a little more clearly, thinking that I shouldn't do that next time!

Library

A program designed to perform a specific function by modularizing functions that can be used commonly in development.

Framework

A collection of classes and libraries with multiple functions that are put together to achieve a specific result.

ChatGPT's answer

The above definitions are what I personally thought were close to the correct answers after reading several articles. However, something felt incomplete and I wanted a more detailed answer, so I decided to utilize ChatGPT!

Definition of Library
Definition of Framework

So what's the difference?

If we go back to the answer above and look at Frameworks and Libraries, we can see that the

Library

Collection of reusable code and resources Organized into functions, classes, methods, data types, etc.

Framework

A structured framework or platform for developing software. Consists of predefined code and libraries

It's hard not to look at this and wonder. If frameworks can contain libraries, why can't libraries contain frameworks?

As expected, it turns out that frameworks can contain libraries, but not vice versa. The article also highlights an important difference between frameworks and libraries.

It's the control of code flow. In the case of a library, the developer calls the library's functions and uses them, but in the case of a framework, the developer's methods are called by the framework.

The form that appears in a framework is called IoC (Inversion of Control). Since it is related to Dependency Injection, I won't write much about it because I think there will be something else to write about.

Conclusion

A library is a collection of reusable code and resources, while a framework is a structural framework or platform for development. They generally work similarly in terms of functionality, so the difference is in how they are used.
Frameworks can contain libraries, but libraries cannot contain frameworks. Control of the code flow is in the hands of the framework and the developer in the hands of the library, so it's generally not possible for a developer to modify a framework, while a library can be customized by the developer as needed.

[Interview Question] What is the difference between Fork and Exec?

Wed, 31 May 2023 07:48:53 GMT

What do fork() and exec() have in common?

Used by one process to execute another process

fork()

Allocates memory for a new process
process is added (we have one process with a different PID)

exec()

does not allocate additional memory for the new process
Load the new process by overwriting the existing process (same PID)

→ The new process will work after the call, so programs after the execution point of the existing program will not work

Notes.

U-chan Seon's Blog

[BOJ 2887, Python] Planetary Tunnels

Tue, 30 May 2023 15:33:18 GMT

Problem link

boj 2887

Classification

Graph theory, Sorting, Minimal spanning trees

Description

I'm surprised that it's been more than half a year since I first encountered this problem... but I thought it was worth documenting because it was solved with a solution that made sense to me, even though I've been neglecting Platinum issues lately.

To solve this problem formally, you can use a combination of the Union Find + Kruskal algorithm, which picks two coordinates out of a maximum of 100,000, lists their values from the smallest to the largest, and then includes the smallest trunk line.

However, this would result in a solution time of 10⁵ * 10⁵, which is roughly 10 billion cases, which would require a solution time of about 100 seconds, making it an infeasible solution method.

Tip: If we consider 1 second per 100 million operations, it is easy to compute!

So the key to this problem is how to reduce the number of cases from O(N²) to O(N).

To summarize, in the current problem, when building a spanning tree for an arbitrary point, we don't need to consider points other than neighboring points.

Consider a situation where we have arbitrary points A, B, and we need to connect them to a point C.

If the difference between their x-values (|X_A - X_B|) is the smallest value less than y, z → Assume that the x-value of the point C lies between the x-values of A and B.

if |X_A - X_C| + |X_B - X_C|, then the difference does not exist

Any arbitrary |X_A - X_B| that retains |X_A - X_C| or |X_B - X_C| that further connects C must be larger than the existing spanning tree → cannot exist as a counterexample.

Thus, if a trunk line connecting two arbitrary points is included in the minimal spanning tree of the current problem, it proves that the two points must be adjacent!

Solving this proof is the key, and I don't think the rest of the problem is much different from a typical union find problem.

Addition) I was getting timeouts when using PriorityQueue instead of heapq, and I was able to find an answer to that issue.

What's the difference between heapq and PriorityQueue in python?

The answer is that PriorityQueue is slower because it guarantees thread safety.

Solution code

# 행성 터널

import sys
from heapq import heappush, heappop

input = sys.stdin.readline

def check_union(union_info: list, now_target: int) -> int:
    """
    해당 노드의 현재 유니온을 조회하는 함수
    """

    if union_info[now_target] == -1:
        union_info[now_target] = now_target

    elif union_info[now_target] != now_target:
        union_info[now_target] = check_union(union_info, union_info[now_target])

    return union_info[now_target]

def make_union(union_info: list, target_1: int, target_2: int) -> None:
    """
    두 점이 같은 유니온인지 확인하고 아니라면 합쳐주는 함수
    """
    union_1 = check_union(union_info, target_1)
    union_2 = check_union(union_info, target_2)

    if union_1 == union_2:
        return True

    else:
        if union_1 > union_2:
            union_info[union_1] = union_2
        else:
            union_info[union_2] = union_1

        return False

planet_number = int(input())
coord_list = []

for i in range(planet_number):
    coord_list.append([i] + list(map(int, input().split())))

cost_queue = []

for i in range(1, 4):
    coord_list.sort(key=lambda x: x[i])
    for j in range(planet_number - 1):
        heappush(
            cost_queue,
            (
                coord_list[j + 1][i] - coord_list[j][i],
                (coord_list[j][0], coord_list[j + 1][0]),
            ),
        )

union_info = [-1 for _ in range(planet_number)]

total_length = 0
line_number = 0

while cost_queue:
    if line_number == planet_number - 1:
        break

    now_length, nodes = heappop(cost_queue)
    node_a, node_b = nodes

    if not make_union(union_info, node_a, node_b):
        total_length += now_length
        line_number += 1

print(total_length)

[Interview Question] Difference between Process and Thread, Multi Thread

Mon, 29 May 2023 17:44:03 GMT

~~Still writing!~~ ~~23. 05. 30. writing completed~~ → 23. 06. 09. add content

Program

A set of executable instructions written for a computer to perform a specific task.

It's defined in many different ways, but this is how I understood it when I read it! The reason I checked the definition of a program first is because the definition of a process is a narrower scope program.

Process

'instance' of a 'running' program (used almost interchangeably with Task)

An operating system-based unit of work that runs in memory.

Consumes a lot of time and resources to create (high overhead)

I think the unique part is that it is possible to have multiple instances of a program simultaneously, rather than the program itself.

Thread

A CPU-based unit of execution that performs work within a process.

Every processor has at least one thread

Threads have their own registers and stack

Heap memory space is shared

So what's the difference between the two?

Processes can be viewed as a larger categorical unit

However, I think this would be a very comprehensive answer if I simply left it at that, so I've added some additional clarification by referring to some well-organized articles!

How it works

1. For Process

The process is allocated a separate memory area by the operating system when it runs.
The memory area has the following format: Code/Data/Stack/Heap
Cannot access memory regions of other processes

2. For Threads

Process's Stack region is partitioned and has its own region
The rest of the Code, Data, and Heap areas are shared

Errors in one process don't spread to other processes' regions

But if one thread fails, all threads terminate. → because there are shared memory regions

Summary

What is the difference between Process and Thread?

A process is a program in dynamic use, while a thread is a unit of execution of some kind of work.
A process contains at least one thread
Processes do not typically share memory space, but threads do.
Processes go down alone on each failure, threads go down all within the same process

+ About Multi-Thread

Multiple threads performing tasks simultaneously within one process.

Context Switching (Context Switching)

By default, the maximum number of tasks that can be processed simultaneously is the number of cores. If more threads are running than the number of cores, each core alternately performs multiple tasks. Saving and reading the current state of the task or the data required for the next task when the thread is switched.

Advantages and disadvantages of multithreading and processes

1) Advantages of Multi-Threading

System calls for process creation and resource allocation are sleepy, allowing for efficient resource management.
Less processing cost for sending and receiving data between threads because they share memory space except for the stack within one process.
Reduced program response time due to less complex communication methods between threads.

2) Disadvantages of Multi-Threading

Increased debugging difficulty and design difficulty
Cannot control threads from other processes
Synchronization problems due to memory sharing (accessing the same resources at the same time)
Problems with a thread affect the entire process

3) Advantages of multiprocessing

If something goes wrong in a process, the impact doesn't spread outside that process

4) Disadvantages of Multi-Process

High overhead in context exchange
Inter-process communication is more difficult and complex than inter-thread communication

Note

Wikipedia's entry on processes and threads Difference between process and thread by raejoonee Difference between process and thread by heejeong Kwon

[CI/CD] Flow from Instance to DooD Deployment (Feat. Nginx, Jenkins)

Sat, 27 May 2023 14:55:17 GMT

23-06-16 Modified path for volume mounting clarity 23-07-05 Adjust settings for development convenience

Introduction

[CI/CD] Organizing automatic deployment of FastAPI server using Docker + Jenkins + Git Webhook

The reason for writing this post is that the last post above contains what I initially tried to learn, but I wanted to fix what needs to be fixed, polish what needs to be polished, and complete it in one neat post.

I've gained a certain amount of know-how and structured my deployment tasks since the last time and helped people around me deploy, so I hope I can keep a record of it and use it as a consistent process for the next time I deploy! If you follow this post in order, I don't think you'll find it difficult to deploy.

Additional things I've learned since part 1

Why implement out of Docker rather than in Docker?

By default, Docker discourages allowing commands to be executed on top of Docker containers

Docker in Docker grants powerful privileges to the Docker-installed container, which can be a security risk

Docker out of Docker allows you to run Docker commands through a socket share with Docker outside of the container.

What about using the Docker API?

Actually, that's what I used to solve the problem in part 1, and it worked. But if you have a successful build out of Docker, I don't think you'll need it much in your CI/CD process...

Something about the API that I thought was too vague to write about separately, so I just wrote it down.

Docker uses a REST API to communicate between the engine and the client, which is mostly unused, but is available.

  docker --tlsverify --tlscacert=/.docker/ca.pem \
  --tlscert=/.docker/cert.pem --tlskey=/.docker/key.pem \
  -H={server_ip}:{port_number} exec nginx \
  sed -i '4s/.*$/ server {container}:8000;/' /etc/nginx/sites-available/default.conf

This code modifies the contents of an Nginx configuration file located on an arbitrary server via a Docker Client with a TLS certificate. It communicates with the Daemon (Docker Engine) through the port on that server via the -H command, and the rest of the code is a procedure to secure access via the certificate.

If you leave a port open without using a certificate, someone can crash your container through that port!

Real world experience with container jamming. I left a common port used by Docker open without authentication security...

Securing via certificates is a must, and if for some unavoidable reason you can't, it's imperative to limit the commands that can be run through that port.

See [Docker API Documents] (https://docs.docker.com/engine/api/v1.43/) for more details!

Procedure for building an All in One deployment base

1. Access and update instances

ssh -i {secure shell key 경로} {사용자 이름}@{IP 주소}

sudo apt-get update
sudo apt-get upgrade

If you are setting up ubuntu, the username is often ubuntu.

2. Firewall settings

sudo ufw allow ssh    # ssh를 22로 대체할 수 있다.
sudo ufw allow http   # http를 80으로 대체할 수 있다.
sudo ufw allow https  # https를 443으로 대체할 수 있다.

sudo ufw enable 	  # 방화벽 가동
sudo ufw status 	  # 방화벽 상태 확인

If you are using the cloud, you will probably have to open the port in the cloud's own port security settings by default. UFW is Ubuntu's firewall, and if it is turned off when you initially set it up, you need to authorize the port and turn it on. With the above settings, you can turn on the firewall with the default HTTP(80), HTTPS(443), and SSH(22) ports open.

It is recommended to turn on the port allow setting first. If you turn on the firewall with SSH port 22 closed, you will not be able to connect to it.

3. Install Docker and Docker Compose

# Docker 설치

sudo apt-get update
sudo apt-get install ca-certificates curl gnupg

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
https://download.docker.com/linux/ubuntu \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Docker Compose 설치

sudo apt install docker-compose

Ubuntu Docker Installation Documents

As of May 2023, I've culled only what I needed from the Documents.

sudo usermod -aG docker $USER

This command allows you to use docker commands without sudo. If you don't include it, you will get /var/run/docker.sock: connect: permission denied.

4. Write docker-compose.yml

version: '3.8'

networks:
  {원하는 네트워크 이름}:
    driver: bridge

services:

  # Jenkins Container 설정
  jenkins:
    container_name: jenkins
    image: jenkins/jenkins:lts
    restart: unless-stopped
    ports:
      - "{원하는 포트 번호}:8080"
    volumes:
      - ./mount/jenkins:/var/jenkins_home
      - /var/run/docker.sock:/var/run/docker.sock
    user: root
    environment:
      - TZ=Asia/Seoul
    networks:
      - {원하는 네트워크 이름}

We wrote the deployment pipeline tool as if it were utilizing Jenkins.

If you don't have a network to add, you can leave out the network part altogether and proceed with the volume bindings for the sockets to use out of Docker. You can set the time zone or additional volume bindings as needed.

5. Set up DNS for the domain you want to use

Different domain providers use different methods. You'll need to look at your domain provider's registration instructions and go through the process of registering the IP of the server you'll be using and associating it with your domain.

What's My DNS

It's not instantaneous, it takes time for DNS servers to reflect it. I've attached a site above where you can easily check how much it's spread.

6. Issuing a certificate using Let's Encrypt

1) docker-compose.yml

# Nginx 설정
  nginx:
    container_name: nginx
    image: nginx:latest
    restart: unless-stopped
    volumes:
      - ./mount/nginx/nginx.conf:/etc/nginx/nginx.conf 			# Nginx 설정을 위한 바인딩
      - ./mount/nginx/sites-available:/etc/nginx/sites-available
      - ./data/certbot/conf:/etc/letsencrypt				# 인증서 공유를 위한 바인딩
      - ./data/certbot/www:/var/www/certbot
    ports:
      - 80:80
      - 443:443
    environment:
      - TZ=Asia/Seoul
    networks:
      - {원하는 네트워크 이름}

  # Certbot 컨테이너 설정
  certbot:
    container_name: certbot
    image: certbot/certbot
    restart: unless-stopped
    volumes:
      - ./data/certbot/conf:/etc/letsencrypt
      - ./data/certbot/www:/var/www/certbot
    environment:
      - TZ=Asia/Seoul

Add this to docker-compose.yml and don't process it.

2) mount/sites-available/default.conf

server {
     listen 80;
     listen [::]:80;

     server_name my_domain.org; 

     location /.well-known/acme-challenge/ {
             allow all;
             root /var/www/certbot;
     }
}

file and include server_name followed by your domain.

3) mount/nginx.conf

user nginx;
worker_processes auto;
worker_priority 0;

pid /run/nginx.pid;
include /etc/nginx/modules-enabled/*.conf;

events {
        worker_connections 1024;
        multi_accept off;
}

http {

        sendfile on;
        tcp_nopush on;
        tcp_nodelay on;
        keepalive_timeout 65;
        types_hash_max_size 2048;
        server_tokens off;

        include /etc/nginx/mime.types;
        default_type application/octet-stream;
        log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                          '$status $body_bytes_sent "$http_referer" '
                          '"$http_user_agent" "$http_x_forwarded_for"';

        ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3; # Dropping SSLv3, ref: POODLE
        ssl_prefer_server_ciphers on;

        access_log /var/log/nginx/access.log main;
        error_log /var/log/nginx/error.log debug;

        gzip on;

        include /etc/nginx/sites-available/*;

}

This is a pretty basic setup based on what you'll find when you first install nginx.

4) Issue a validated certificate through Let's Encrypt

curl -L https://raw.githubusercontent.com/wmnnd/nginx-certbot/master/init-letsencrypt.sh -o init-letsencrypt.sh
chmod +x init-letsencrypt.sh
vi init-letsencrypt.sh			# 여기서 도메인과 메일 주소를 입력해야 함
sudo ./init-letsencrypt.sh

Get the file that will help you with the certificate issuance process externally and set the permissions. You can then enter your domain and email address into the file and run the file to issue the certificate. If the issuance fails, you can view the logs to find out why it failed, fix it, and try again.

7. Setting up Nginx for certificate renewal

# Nginx 설정
  nginx:
    container_name: nginx
    image: nginx:latest
    restart: unless-stopped
    volumes:
      - ./mount/nginx.conf:/etc/nginx/nginx.conf
      - ./mount/sites-available:/etc/nginx/sites-available
      - ./data/certbot/conf:/etc/letsencrypt
      - ./data/certbot/www:/var/www/certbot
    ports:
      - 80:80
      - 443:443
    environment:
      - TZ=Asia/Seoul
    networks:
      - {연결을 원하는 네트워크 이름}
    command: "/bin/sh -c 'while :; do sleep 6h & wait $${!}; nginx -s reload; done & nginx -g \"daemon off;\"'"

  # Certbot 컨테이너 설정
  certbot:
    container_name: certbot
    image: certbot/certbot
    restart: unless-stopped
    volumes:
      - ./data/certbot/conf:/etc/letsencrypt
      - ./data/certbot/www:/var/www/certbot
    environment:
      - TZ=Asia/Seoul
    entrypoint: "/bin/sh -c 'trap exit TERM; while :; do certbot renew; sleep 12h & wait $${!}; done;'"

Certificates issued by Let's Encrypt have a limited lifespan, but you can reissue them if they are nearing expiration. You can add reissue-related commands to the certbot and nginx containers to handle certificate renewals automatically. This will prevent nginx from failing to build the container with an error because the certificate has been issued.

8. Install Docker inside the Jenkins container

Added) I originally listed the commands directly, but realized it wasn't intuitive, so I fixed it!

# /jenkins-docker-install.sh

apt-get update
apt-get install ca-certificates curl gnupg

install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
chmod a+r /etc/apt/keyrings/docker.gpg

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
https://download.docker.com/linux/debian \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
tee /etc/apt/sources.list.d/docker.list > /dev/null

apt-get update
apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

I created a sh file with the code to remove the sudo command from the existing docker installation method. You can put this file inside via mount and run it for a clean, one-room installation!

9. Processing Docker Compose

version: '3.8'

networks:
  {네트워크 이름}:
    driver: bridge

services:

  # Jenkins Container 설정
  jenkins:
    container_name: jenkins
    image: jenkins/jenkins:lts
    restart: unless-stopped
    ports:
      - "{포트 번호}:8080"
    volumes:
      - ./mount/jenkins:/var/jenkins_home
      - /var/run/docker.sock:/var/run/docker.sock
      - ./mount/jenkins-html:/var/lib/jenkins
      - ./jenkins-docker-install.sh:/jenkins-docker-install.sh
    user: root
    environment:
      - TZ=Asia/Seoul
    networks:
      - {네트워크 이름}

# Nginx 설정
  nginx:
    container_name: nginx
    image: nginx:latest
    restart: unless-stopped
    volumes:
      - ./mount/nginx/nginx.conf:/etc/nginx/nginx.conf
      - ./mount/nginx/sites-available:/etc/nginx/sites-available
      - ./data/certbot/conf:/etc/letsencrypt
      - ./data/certbot/www:/var/www/certbot
    ports:
      - 80:80
      - 443:443
    environment:
      - TZ=Asia/Seoul
    networks:
      - {네트워크 이름}
    depends_on:
      - {선행 컨테이너}
    command: "/bin/sh -c 'while :; do sleep 6h & wait $${!}; nginx -s reload; done & nginx -g \"daemon off;\"'"

  # Certbot 컨테이너 설정
  certbot:
    container_name: certbot
    image: certbot/certbot
    restart: unless-stopped
    volumes:
      - ./data/certbot/conf:/etc/letsencrypt
      - ./data/certbot/www:/var/www/certbot
    environment:
      - TZ=Asia/Seoul
    entrypoint: "/bin/sh -c 'trap exit TERM; while :; do certbot renew; sleep 12h & wait $${!}; done;'"

After adding these Jenkins configurations, run

docker-compose -f {yml 파일 위치 및 파일명} up -d

command to bring up all the containers.

docker exec -it jenkins bin/bash
sh /jenkins-docker-install.sh

By installing Docker inside the Jenkins container, we can control the Docker Engine through the Jenkins internal Shell commands. We'll follow the existing Docker documentation, but the difference is that we won't be using sudo and we'll be installing Docker for Debian.

Optional

1. Set up Swap Memory

# swap memory 설정

sudo fallocate -l {설정 용량} /swapfile   # 설정 용량은 대체로 G 단위로 설정한다.
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

# 재부팅 시에도 지속 사용을 원할 경우

sudo vi /etc/fstab 			# '/swapfile swap swap defaults 0 0' 내용을 해당 파일에 삽입

# swap 비활성화

sudo vi /etc/fstab 			# '/swapfile swap swap defaults 0 0' 내용을 제거
sudo swapoff -v /swapfile
sudo rm /swapfile

Depending on your instance performance and needs, you can set up swap memory to prevent instances from popping.

2. What to try if you get a Jenkins plugin installation error

<Solution 1 Access Jenkins Administration > Plugin Manager > Advanced settings > Update sites part Change https://updates.jenkins.io/update-center.json to http://updates.jenkins.io/update-center.json

<Solution 2> Install the plugin named skip-certificate-check

This is not a perfect solution, but we have seen some success with all of these solutions.

Closing remarks

I'm going to stop writing about Docker here, except for some framework deployments later on. I'll write more about deployments in the future if I get the chance, as it's a great feeling to see your work on a real network.

[Interview Question] What is a RESTful API?

Sun, 21 May 2023 17:27:57 GMT

RESTful API

Refers to a RESTful API.

It's pretty self-explanatory, but it is what it sounds like! So let's take a look at what each word means, and you'll see what a RESTful API is all about.

API

Short for Application Programming Interface. A mechanism that allows two software components to communicate with each other using a set of definitions and protocols.

This is how I define it. The way I understand it is that different components of software have different ways of dealing with objects and so on, and to deal with this disparity, a convention is established so that they can communicate and interact with each other.

REST

Representational State Transfer. One of the software architectures for distributed hypermedia systems such as the World Wide Web.

REST was initially created as a guideline for managing communication in complex networks such as the Internet, and is said to be reliable for large-scale communication and easy to implement and modify.

Principles of REST Architecture

Uniform Interface
- Server sends information in a standardized format
- The standard format may differ from the internal representation of the resource on the server
- All API requests for the same resource are the same regardless of the specific language, platform, etc.
Stateless
- Each request is independent of all other requests
- Server can fully understand and fulfill the request without additional information
Layered System
- Multiple applications working together to fulfill client requests
- Multiple tiers of servers, where different authorized intermediaries may exist between the server and the client
- Additional intermediaries such as proxies and gateways, encryption, load-balancing layers, etc.
- Remains invisible to the client
Cacheable (Cacheable)
- Supports caching to store some responses to improve server response times
- Implements caching on the client or server side
On Demand Code (On Demand Code)
- Deliver resources that are typically static
- Includes executable code in responses on demand, allowing you to temporarily extend or customize client functionality

Benefits of using RESTful APIs

Scalability
- Scalable because it optimizes client-server interactions
Flexibility
- Supports full client-server separation
- Simplify & separate server components so each part can evolve independently
Independence
- Independent of the technology used
- Ability to write client & server applications using different programming languages and change technologies, regardless of API design

Summary

What is RESTful API? It refers to an application programming interface using REST architecture, which is a convention that organizes the interaction between programs that adhere to the principles of REST architecture.

So what are the benefits? The benefits of using these APIs are scalability, flexibility, and independence!

[1Day-1CS] Coverage of network devices

Fri, 19 May 2023 17:06:42 GMT

2023-06-18 Edit Content Scope

Hierarchical processing scope

Application layer: L7 switches
Internet layer: L3 switches, routers
Data link layer: L2 switches, bridges
Physical layer: NICs, repeaters, APs

Start organizing your interview questions! (Question history)

Tue, 16 May 2023 22:32:46 GMT

Instrument

I don't know how long it's been since I started putting my resume in front of companies in earnest... I think it's been about 3 months, but I'm not passing all the coding tests, but I'm passing quite a few of them, and I've had a few interviews recently!

But even if I go to an interview, even if I have studied CS, there is a difference between the questions that come up in the interview and the CS knowledge I have studied... So I would like to blog about the questions that came up in the interview and what I studied with Pinpoint.

List of questions

Overall

What is RESTful API?
The difference between Process and Thread
- Difference between Fork and Exec
Framework vs. Library
What is a Transaction?
About OSI Layer 7
Subnets, Gateways, and Private IPs

Backend

What is DB Index?
What is Connection Pool?
JVM의 구조와 원리
Java Heap & Stack의 구조
Dependency Injection
How Spring IoC containers manage beans. + Proxy pattern, how Spring Beans are proxies and how to achieve multithreaded behavior.
Singleton pattern and Spring Dependency Injection

Frontend

What happens when you type the access URL in the address bar

[1Day-1CS] Cross-Tier Data Sending and Receiving Courses & PDUs

Sun, 07 May 2023 17:02:23 GMT

Encapsulation & decapsulation process

Encapsulation: embedding the header and data of a higher layer into the data portion of a lower layer and inserting the header of that layer.

Application → Transport → Internet → Pass to link layer
Passed to transport layer, where it is segmented or datagrammed + TCP (Layer 4) headers added
Passes to the Internet layer, where an IP (Layer 3) header is added = packet
Passes to the link layer and adds a frame header + frame trailer = frame

Decapsulation: the process of removing the header portion of each layer as it goes from lower to higher layers

Decapsulation proceeds in reverse
Frame → Packet → Segment, Datagram → Message
Eventually delivered as Transmission Data Unit (TDU) messages in the application

Protocol Data Unit

A unit of chunk when data is passed from layer to layer

Different layers have different names, such as message, segment, datagram, packet, frame, bit, etc.
Transmitting in bits is fastest and most efficient
String-based sending and receiving at the application layer (due to ease of scaling)

[1Day-1CS] Half-duplex communication (2), wireless communication and Ethernet frames

Thu, 04 May 2023 14:01:28 GMT

Types of half-duplex communication

CSMA/CD: Sends data and retransmits after a period of time if a collision occurs.
CSMA/CA: Avoids collisions as much as possible by proactively detecting carriers before sending data, etc.
- Checking the wireless medium before sending data
- Determining if the line is empty (carrier detection)
- If busy, checks for availability at increasing intervals based on random values (IFS)

Wireless Communications

Wifi: Technology that allows electronic devices to connect to a wireless LAN signal; requires a wireless access device.
BSS (Basic Service Set)
- Standing for Basic Service Set
- Simple access through a router + APs and devices within the same BSS can communicate with each other
Extended Service Set (ESS)
- One or more connected BSS groups
- Provides long-range wireless communication
- Enables more availability and mobility than BSS
- Allows you to move from one location to another and stay connected to the network without interruption

Ethernet frames

A transport mechanism used at the data link layer

Preamble: announces the start of an Ethernet frame
SFD (Start Frame Delimiter): Signals that the MAC address field begins with the next byte.
DMAC, SMAC: Transmit and receive MAC addresses
EtherType: defines the IP protocol
Payload: Data received
CRC: Error checking bits

[BOJ 2473, Python] Tax Solutions

Thu, 04 May 2023 13:15:05 GMT

Problem link

boj 2473

Classification

Bisection, sorting, two pointers

Description

This is a slightly more advanced version of the classic two-pointer problem.

When I first solved this problem, I thought there must be a different solution because I had to combine the three solutions, so I surprisingly didn't use the exact method, which slowed down the actual solution.

The important thing to note about this problem is that the total number of solutions is 5000 or less. Without this condition, this problem would never be solved in time... I'm glad I didn't pay attention to this condition in the beginning, as it led me to keep looking for other solutions.

So, the solution to this problem is as follows.

Sort the order → fix one solution → use a two-pointer algorithm for the remaining solutions to sum with that solution to get closest to zero → stop when all have been traversed or when zero is reached

Solving code

# 세 용액

import sys

input = sys.stdin.readline

solution_number = int(input())
solution_list = list(map(int, input().split()))

solution_list.sort()
characteristic_value = 3000000000

for idx in range(solution_number):

    pointer_1 = 0
    pointer_2 = solution_number - 1

    while pointer_1 < pointer_2:

        if pointer_1 == idx:
            pointer_1 += 1
        if pointer_2 == idx:
            pointer_2 -= 1

        if pointer_1 >= pointer_2:
            break

        now_value = sum([solution_list[idx], solution_list[pointer_1], solution_list[pointer_2]])

        if abs(now_value) < characteristic_value:
            characteristic_value = abs(now_value)
            result = [solution_list[idx], solution_list[pointer_1], solution_list[pointer_2]]

            if not characteristic_value:
                break

        if now_value < 0:
            pointer_1 += 1
        elif now_value > 0:
            pointer_2 -= 1

    if not characteristic_value:
        break

result.sort()

print(*result)

[1Day-1CS] Full and half duplex communication (1)

Mon, 01 May 2023 16:24:13 GMT

Full-duplex communication

A method in which both devices can transmit and receive simultaneously.

Separate transmit and receive paths to send and receive data
Modern Fast Ethernet uses this method

Half-duplex communication

Both devices can communicate with each other, but not at the same time Only one direction of communication at a time based on one path

If there is a collision after sending data, proceed with retransmission after a period of time
Wired LAN
- Twisted pair cable: cable twisted together to reduce noise (crosstalk)
- Fiber optic cable: A cable that transmits light by utilizing the difference in refractive index of the core and cable.
Wireless LAN
- Half-duplex communication, which uses the same channel for both transmitting and receiving.

[1Day-1CS] Internet Layer and Link Layer

Thu, 27 Apr 2023 03:32:49 GMT

Internet Layer

Layer used to transmit network packets received from a device to the destination specified by its IP address.

Link layer

The layer that actually passes data and sets the rules for signaling back and forth between devices, also known as the network access layer.

Physical layer: The layer that sends data consisting of 0s and 1s over the LAN.
Data link layer: The layer responsible for error checking, flow and access control over Ethernet frames.

[1Day-1CS] Transport Layer

Tue, 25 Apr 2023 17:14:48 GMT

Transport Layer

Provides communication services that connect senders and receivers. Provides connection-oriented data stream support, reliability, and flow control Serves as a data delivery intermediary between the application and Internet layers

TCP: Guarantees order, uses connection-oriented protocol, acknowledges receipt (virtual line packet exchange)
UDP: ordering X, acknowledgments X, simple data delivery (datagram packet exchange)

Virtual line packet exchange method

Each packet contains a virtual line identifier
Virtual line is released when all packets have been sent, packets arrive in order of transmission

How datagram packets are exchanged

Packets travel independently, choose the best path
Can be sent on different paths and in different order

How TCP establishes and tears down connections

connection: 3-way handshake

client sends connection request flag with its ISN
server sends back server's ISN and client's ISN + 1 with authorization number
client replies back with server's ISN + 1 with authorization number

Disconnecting: 4-way handshake

client sends FIN set segment and enters FIN_WAIT
the server that received the data sends an ACK acknowledgment segment to the client and enters CLOSE_WAIT
sends FIN segment after some time has passed since ACK was sent
client receives ACK, enters TIME_WAIT and resends ACK back to server
the receiving server sends a CLOSE

Reasons for using TIME_WAIT: Possibility of delayed packets, confirmation of disconnection

[BOJ 7490, Python] Create 0

Mon, 24 Apr 2023 16:15:36 GMT

Problem link

boj 7490

Classification

Backtracking, Brute Force Algorithms, Implementations, Strings

Description

I think this is a classic backtracking problem. However, I found the processing a bit esoteric and the ASCII sorting a bit unusual.

I saw that it could be easily solved using Python's Eval function, but I didn't use that approach and solved it the hard way.

Basically, I took the sum of a number and two previously unprocessed numbers and backtracked, thinking that it would check for all three cases of 'addition', 'subtraction', and 'no operation', and I was able to get the correct answer.

Solved code.

# 0 만들기

import sys

input = sys.stdin.readline

def make_sum_zero(
    result_arr: set,
    target_arr: list,
    last_index: int,
    now_index: int = 0,
    sum_now: int = 0,
    now_calc: int = 0,
    log=[],
) -> None:
    """
    백트래킹을 활용하여 숫자들의 합이 0이 되도록 만드는 함수
    """
    if last_index == now_index:
        if not sum_now + now_calc:
            result_arr.add("".join(log))

    else:
        if not now_index:
            make_sum_zero(
                result_arr,
                target_arr,
                last_index,
                now_index + 1,
                0,
                target_arr[now_index],
                [str(target_arr[now_index])],
            )

        else:
            new_number = target_arr[now_index]

            make_sum_zero(
                result_arr,
                target_arr,
                last_index,
                now_index + 1,
                sum_now + now_calc,
                new_number,
                log + ["+", str(new_number)],
            )
            make_sum_zero(
                result_arr,
                target_arr,
                last_index,
                now_index + 1,
                sum_now + now_calc,
                -new_number,
                log + ["-", str(new_number)],
            )

            if now_calc < 0:
                make_sum_zero(
                    result_arr,
                    target_arr,
                    last_index,
                    now_index + 1,
                    sum_now,
                    10 * now_calc - new_number,
                    log + [" ", str(new_number)],
                )
            else:
                make_sum_zero(
                    result_arr,
                    target_arr,
                    last_index,
                    now_index + 1,
                    sum_now,
                    10 * now_calc + new_number,
                    log + [" ", str(new_number)],
                )

testcase = int(input())
output = []

for _ in range(testcase):
    arr_length = int(input())
    result = set()

    # 함수를 통해 결과 확인
    target_arr = [i for i in range(1, arr_length + 1)]
    make_sum_zero(result, target_arr, arr_length)

    # 혹여라도 겹치는 결과가 있다면 Set을 통해 배제, ASCII 순으로 정렬
    sort_result = sorted(list(result), key=lambda x: ascii(x))
    output.append(sort_result)

# 문제 조건에 맞춰 출력
for idx in range(testcase):
    for element_idx in range(len(output[idx])):
        print(output[idx][element_idx])

    if idx != testcase - 1:
        print("")

[1Day-1CS] The TCP/IP 4-layer model and the application layer

Mon, 24 Apr 2023 15:18:37 GMT

Internet Protocol Suite (

) A set of protocols used by computers to exchange information over the Internet

Explained using the TCP/IP 4-layer model or the OSI 7-layer model

TCP/IP 4-layer model

Composed of four abstraction layers based on the scope of networking
- Application layer
- Transport layer
- Internet Layer
- Link Layer
The OSI model is characterized by its further subdivision of the Application Layer and Link Layer

Application Layer

The protocol layer where applications such as FTP, HTTP, SSH, SMTP, and DNS are used
- FTP: File transfer between devices
- SSH: Secure Shell Protocol, an encrypted network protocol
- HTTP: The protocol used to access websites via the World Wide Web
- SMTP: An Internet standard communication protocol for email transmission
- DNS: A server that maps domain names to IP addresses
The layer that actually provides services to users

[BOJ 25542, Python] Meeting Place

Sun, 23 Apr 2023 18:10:04 GMT

Problem Link

[BOJ 25542](https://www.acmicpc.net/problem/25542

)

Categories

Brute Force Algorithm, Implementation, Strings

Description

When I first encountered this problem in a contest, I thought the idea itself wasn’t difficult. However, it turned out to be more labor-intensive to implement than I expected, and since I was struggling even with writing Python code seven months ago, I couldn’t solve it.

I also tried to solve this problem three months ago, but I concluded that my initial idea required additional pruning, so I had to set the problem aside once again.

Recently, I’ve had some free time and felt the urge to revisit problems I hadn’t been able to solve before, so I gave it another shot—and finally managed to solve it! However, I still have my doubts about why this is classified as a Silver-level problem...

At first, I tried to generate results using only the given strings, but this inevitably failed because counterexamples existed.

The code I tried next included a bit more implementation, but since it still relied solely on the given strings, it couldn’t handle counterexamples using other strings. I’ve attached the code below.

import sys
from itertools import product

input = sys.stdin.readline

def is_similar(checker: str, target: str) -> bool:
	'''
    두 문자열이 비슷한지 확인하는 함수
    '''
    
    length = len(checker)
    counter = 0

    for idx in range(length):

        if checker[idx] != target[idx]:
            counter += 1

    if counter <= 1:
        return True
    
    else:
        return False

# 입력
store_number, name_length = map(int, input().split())

# 각 문자열의 동일 인덱스를 집합화
name_list = []
store_chr_arr = [set() for _ in range(name_length)]

for _ in range(store_number):
    each_name = list(input())
    name_list.append(each_name)

    for idx in range(name_length):
        store_chr_arr[idx].add(each_name[idx])

result = None

# 겹치지 않는 문자열의 Product를 비교
for each_name_combination in product(*store_chr_arr):
    target_name = ''.join(each_name_combination)
    
    is_answer = True

    for check_name in name_list:
        if not is_similar(target_name, check_name):
            is_answer = False
            break

    if is_answer:
        result = target_name
        break

if result is None:
    print('CALL FRIEND')

else:
    print(result)

I had tried using unused characters at first, but my implementation skills weren’t sufficient enough to actually put it into practice; however, I was able to get a “Correct” result using that method.

Solution Code

# 약속 장소

import sys

input = sys.stdin.readline

def is_similar(checker: str, target: str) -> bool:
    '''
    두 문자열이 비슷한지 확인하는 함수
    '''

    length = len(checker)
    counter = 0

    for idx in range(length):

        if checker[idx] != target[idx]:
            counter += 1

    if counter <= 1:
        return True
    else:
        return False

# 정보 입력
store_number, name_length = map(int, input().split())

name_list = []
first_checker = True

# 첫 문자열만 따로 분류하고 나머지는 이름 리스트에 기록
for _ in range(store_number):
    each_name = list(input().rstrip('\n'))

    if first_checker:
        target_name = each_name
        first_checker = False

    else:
        name_list.append(each_name)

# 첫 문자열을 통해 문자열 변형된 후보를 양산
result_set = set()

for idx in range(name_length):
    for alpha in range(65, 91):
        temp = target_name[:]
        temp[idx] = chr(alpha)
        result_set.add(''.join(temp))

# 확인하면서 후보를 소거
while result_set and name_list:

    now_check_name = name_list.pop()
    remove_target = set()

    for each_result in result_set:
        if not is_similar(now_check_name, each_result):
            remove_target.add(each_result)

    for each_target in remove_target:
        result_set.remove(each_target)

# 후보가 안 남았다면 문구를 출력, 후보가 남았다면 후보 중 하나를 출력한다.
if not result_set:
    print('CALL FRIEND')

else:
    print(result_set.pop())

[1Day-1CS] Bottlenecks, classification and analysis of networks

Sun, 23 Apr 2023 13:06:14 GMT

Bottleneck

A situation where the performance or capacity of an entire system is limited by one component.

Caused by high traffic when opening events on the server and not well managed
Requires information about the network topology to properly troubleshoot bottlenecks
The main causes of bottlenecks
- Network bandwidth
- Network topology
- Server CPU, memory usage
- Inefficient network configuration

Categorize your network

Networks are categorized based on size

Local Area Network (LAN)
- Local Area Network
- Fast and uncongested transmission speeds
Metropolitan Area Network (MAN)
- Metropolitan area network
- Transmission speed is average, more congested than LAN
Wide Area Network (WAN)
- Wide area network
- Slower transmission speed, more congested than MAN

Network Performance Analysis Commands

ping
- Sends a certain size packet to the target node whose status you want to check
netstat
- Displays the network status of connected services
- netstat * Shows a list of network connections, routing tables, network protocols, etc.
nslookup
- Used to look up DNS-related content
tracert (traceroute)
- Used to verify the network route to the destination node
- Can be used to see where response times are slowing down, etc.
Many other commands exist and use programs like wireshark, netmon, etc.

[1Day-1CS] Network Topology

Thu, 20 Apr 2023 12:56:24 GMT

Network Topology

How the nodes and links are arranged and how they are connected.

Tree topology

Hierarchical topology, a network organization laid out in the form of a tree.

Easy to add and delete nodes
Concentration of traffic on a particular node affects subordinate nodes

Bus Topology

Connecting multiple nodes to one centralized communication line

Used for local area networks
Low installation cost, high reliability, and easy to add and remove nodes to the centralized communication line
Spoofing issues exist

Spoofing: to another host on the LAN that is not involved in the transmission. paralyzing or tricking a switch's ability to prevent the packet from going to treating a packet as if it were coming from a specific node.

Star topology

A network configuration where everyone is connected to a centrally located node.

Easy to add nodes or detect errors
Packets are less likely to collide
Entire network is unavailable in the event of a central node failure
High installation cost

Ring Topology

Moving data from node to node, processing packets through a ring-shaped path

Little loss on the network as the number of nodes increases
Less likely to crash and easier to detect node failures
Difficult to change network configuration
Failure affects the entire network

Mesh topology

Mesh topology, a reticulated connection structure

Multiple paths exist to keep the network up and running if one terminal fails
Possibility to distribute traffic
Difficult to add nodes and expensive to build and operate

[1Day-1CS] Network startup, throughput and latency

Mon, 17 Apr 2023 14:32:41 GMT

Introduction

It's that time of the year again, and I've been so busy lately, but I think it helps to keep studying, so I'm going to try my best!

Network

A set of nodes and links that are only connected to each other or share connections and resources.

Node: A device such as a server, router, switch, etc. Link: Wireless or wired

Throughput and latency

A network that can handle a lot of throughput, has low latency, fewer failures, and good security

Throughput: The amount of data successfully passed within a link.
Traffic: The amount of data flowing within a link at any given time. → More traffic = more data flowing. → More throughput = more traffic being processed.

Throughput is affected by traffic, bandwidth, network-induced errors, and device specs

Latency: The time a request is processed, measured in round trips.

Latency is affected by the type of medium, the size of the packet, and the router's packet processing time

[1Day-1CS] Design Patterns & Paradigms Cleanup

Mon, 10 Apr 2023 16:56:14 GMT

Introduction

Everything I'm organizing now is based on "CS Major Knowledge Notes for Interview". Actually, I think I should have mentioned it at the beginning of Day 1 CS, but I'm writing it now.

Design Patterns

Conventions created to solve problems that occurred when designing a program through object interrelationships, etc.

Singleton pattern: utilizing dependency injectors to solve the 1-class 1-stance / module binding issue

Factory Pattern: Parent class provides the big picture and subclasses refine it through inheritance

Strategy Pattern: Leverage encapsulated algorithms by swapping them around inside the context

Observer pattern: observes state changes and communicates changes through methods, etc.

Proxy pattern: acting as an interface to intercept the flow before accessing the target object

Iterator pattern: accessing elements of a collection using an iterator, allowing traversal through a single interface.

ExposureModule pattern: a pattern for creating access controllers

MVC pattern: consists of a Model, View, and Controller, allowing you to develop the components of your application in a compartmentalized manner.

MVP pattern: Replaces only the Controller with a Presenter

MVVM pattern: Replaces only Controller with View Model

Programming paradigm

Declarative vs. Imperative → What is declarative and what is imperative?
Declarative
- Functional programming: Stacking pure functions to implement logic
Imperative
- Object-oriented programming: express the interaction of objects, leverage object methods
- Procedure-oriented programming: consists of continuous computation, satisfied by verbatim implementation of code

[1Day-1CS] Procedural Programming & Mixing Paradigms

Sat, 08 Apr 2023 15:32:23 GMT

Procedural Programming

Consists of a sequential series of computational steps that the logic must perform
Since the code is implemented exactly as the process unfolds, it offers good readability and fast execution speed
Disadvantages include difficulty in modularization and poor maintainability

Choosing a Paradigm

There is no such thing as an absolute superiority among paradigms
Choose a paradigm based on the characteristics of the service or the business logic
It is also advisable to select a paradigm based on the specific logic involved

[1Day-1CS] Design Principles of OOP

Thu, 06 Apr 2023 12:27:00 GMT

Single Responsibility Principle

Every class should have only one responsibility.

Open-Closed Principle

Existing code should be modified as little as possible during maintenance, and it should be easy to extend.

Liskov Substitution Principle

Objects must be replaceable with instances of their subtypes without breaking the program’s correctness. This means that inheritance must function properly without issues.

Interface Segregation Principle

Create multiple specific interfaces instead of a single general interface

Dependency Inversion Principle

The upper layer should be independent of changes in the lower layer; to avoid being affected by elements that change more frequently than itself, a superclass or abstract interface should be used.

Samsung Software Capability Assessment Type B Review

Thu, 06 Apr 2023 12:08:47 GMT

Introduction

Let's start with the bottom line: I've missed two out of three opportunities so far. So I'd like to leave you with a few tips on how to succeed in the future.

Qualifications

I took the mock competency assessment at Samsung Youth Software Academy with a qualification of A.

Recap

In the past, I felt that not only did I spend too much time on implementation, but I was also lacking in optimization. I have about one more chance to take the exam, and I think I should study a lot about optimization.

1. Poor use of objects

I was not familiar with object-oriented coding because I was using Python, and I tried to master it a lot, but I still feel that I am not good enough. In particular, I find it difficult to override and use parts such as Comparator...

2. Familiarize yourself with the data structure

If you listen to the stories of the passers of Type B, they emphasize the material structure a lot, but if you ask me whether I have mastered the material structure enough, I think I need to have enough time to review until the final test because I still have some deficiencies.

+ More

The end of April marks the end of my 3-month Type B journey. As a result, I didn't qualify for Type B, which is a shame because I was so close to the final question but couldn't take that last step.

But I tried, I tried, I tried, and I think I was able to improve to some degree because I tried.

This is definitely an advantage when it comes to taking a coding test for a corporate job.

The qualification I have now is probably a provisional A, so I won't have the chance to take the B anymore after SSAFY, but it's nice to have another one over with!

[1Day-1CS] Imperative Programming & Object-Oriented Programming

Fri, 31 Mar 2023 11:39:05 GMT

Types of imperative programming

Object-Oriented Programming

A way of representing the interactions of a program as a collection of objects and utilizing methods declared inside the objects.
Time-consuming to design and slower than other programming paradigms

Features of Object-Oriented Programming

Abstraction: distilling core concepts, functionality, and functionality from complex systems.
Encapsulation: bundling an object's properties and methods together and hiding some of them from the outside world.
Inheritance: allowing a child class to inherit the characteristics of a parent class, allowing it to be reused, added to, and extended.
Polymorphism: A single method or class can behave in many different ways.
Overloading: having multiple methods with the same name, "static" polymorphism that occurs during "compilation
Overriding: A child class overriding a method inherited from a parent class, 'dynamic' polymorphism that occurs during 'runtime'.

[1Day-1CS] Declarative Programming

Fri, 31 Mar 2023 11:36:56 GMT

Programming Paradigms

A development methodology that serves to give programmers a perspective on programming.

Declarative vs. Imperative

Declarative: a paradigm that focuses on solving for what (What)
Imperative: a paradigm that focuses on how to solve (How)

Example) Declarative: the address of your house (specify exactly where it is) Imperative: the route to the house (showing how to get to the location)

Types of Declarative Programming

Functional Programming

A programming paradigm that implements logic by stacking small pure functions like blocks, and higher-order functions for greater reusability.

Pure functions: A function whose output depends only on its input.

Higher-order functions: Functions that take parameters as values to generate logic.

Higher-order functions can be used if the language is First Class Object.

Characteristics of First Class Objects

Functions can be assigned to variables or methods

Can contain functions as parameters inside functions

Functions can return functions

[1Day-1CS] MVC Patterns and Similar Patterns

Thu, 30 Mar 2023 16:36:43 GMT

MVC Pattern

Design pattern consisting of Model, View, Controller

Divides the components of an application into three parts, allowing you to focus on each component and develop them separately
Facilitates reusability and determinism
Has the disadvantage that as the complexity of the application increases, the relationship between Model and View becomes more complex

Model

Data in the application, meaning DB, constants, variables, etc.

View

Refers to a user interface element and refers to the screen that a user can see based on the Model

Doesn't store any information from the model, only the screen display information

Passes changes to Controller when they occur

Controller

Acts as a bridge between Model and View

Responsible for main logic such as Events, and also manages Life Cycle

When notified of a change in the Model or View, it delivers the corresponding content to the required components.

Similar Patterns

MVP Pattern: Replaces Controller with Presenter, which has a stronger coupling since the relationship between View and Presenter is 1:1
MVVM pattern: Replaces Controller with View Model, has Command and Data Binding, enables UI reusability and easier unit testing

[1Day-1CS] Proxy Patterns & Iterator Patterns & Exposure Module Patterns

Tue, 28 Mar 2023 23:30:10 GMT

Proxy Pattern

A design pattern that acts as an interface to a target object by intercepting its flow before it is accessed and acting as a front-end to the target object.
Used for security, data validation, caching, and logging; also utilized as a server rather than an object

Proxy Server

Works between server and client
A system or program that allows clients to access other network services indirectly through it.

Examples include Apache, Nginx, CloudFlare, etc.

Example usage of a proxy server

Go through a proxy, so you can hide the actual port you're using
Allows you to gzip static resources through Nginx, or logging in front of your main server
CloudFlare makes it easy to deploy HTTPS, which can help defend against DDOS attacks
Front-end proxy servers can be used to prevent Cross Origin Resource Sharing (CORS) errors

Iterator Pattern

Design pattern for accessing elements of a collection through an iterator.

Regardless of the structure of the data types, it is possible to traverse them with one interface: an iterator.
Normally iterable objects can be traversed via the iterator protocol

Exposed Module Pattern

Pattern that creates access controllers such as private, public through immediate functions

In case of JS, access controllers don't exist separately, so we also build them by implementing them

[1Day-1CS] Factory Pattern, Strategy Pattern, and Observer Pattern

Mon, 27 Mar 2023 22:36:03 GMT

Factory Pattern

A pattern that abstracts the object creation process from the code that uses the objects
The superclass determines the essential framework
The subclass determines the specific details of object creation

Characteristics and Advantages of the Factory Pattern

Achieves loose coupling through class separation Ensures flexibility in the superclass and improves maintainability

Strategy Pattern

Do not modify the object directly if you do not want to change its behavior
Designed to allow replacement by changing the encapsulated algorithm corresponding to the strategy within the context

Context

Refers to the relevant information required for a developer to complete a task
There exists a mandatory context essential for an action to occur, as well as an optional context for the effective execution of the action.

Observer Pattern

A subject observes state changes in a specific object
When a state change occurs, the subject notifies observers of the change via methods, etc.
Sometimes built based on mutable objects rather than separating the subject and the object
Also utilized in the MVC pattern

[1Day-1CS] Singleton Patterns

Mon, 27 Mar 2023 15:29:32 GMT

What are design patterns?

A problem exists when designing a program → Create a convention to solve it by using interrelationships between objects, etc.

Singleton Pattern

One class = one instance
We could create multiple separate instances per class, but we don't, we use only one
Usually used for DB modules
Productivity ↑, dependency ↓

Disadvantages of the Singleton Pattern

Possibility of issues when running unit tests during Test Driven Development (TDD)

Difficult to create an independent instance for each test due to the highly dependent nature of the singleton pattern

Dependency Injection

A way to address the disadvantages of the singleton pattern's strong coupling between modules.
Instead of the main module directly giving dependencies to other submodules, it injects dependencies indirectly through a dependency injector (decoupling)

Advantages

Easier to replace modules, Easier to test & migrate, Consistency in dependency orientation, Easier to reason about application, Clarity of relationships, etc.

Cons

Modules are more decoupled → Increased complexity due to increased number of classes, runtime penalty

Principles of Dependency Injection

Parent module does not import anything from child modules
Both must rely on an abstraction + Abstraction does not depend on details

[CI/CD] A Guide to Automated Deployment of FastAPI Servers Using Docker, Jenkins, and Git Webhooks

Fri, 24 Mar 2023 02:08:12 GMT

Notes in progress > First update completed as of May 2023 For deployment-related content, please refer to part 2 which is more polished.

Intro

While working on a current project, I was building a service that exposes outputs powered by an AI model.

I wanted to build that feature on Firebase Cloud Functions, but loading the model with nodeJS + tensorflow.js forced model conversion, the runtime was inherently heavy and kept timing out — for various reasons it kept getting blocked, so I decided to build a small server that returns results from the AI model.

That meant the server build and deployment fell on me, and as a first goal I aimed to get automated deployment working, then later push toward zero-downtime deployment with my own hands.

This post only covers the system build on top of an instance such as AWS and the automated deployment.

Background concepts

CI: Continuous Integration

An automated process for developers in which code changes go through build and test and are regularly merged into a shared repository. Automating this process is used as a way to reduce risk during development.

Composed of CI Server, Source Control Management, Build Tool, Test Tool, etc.

CD: Continuous Delivery / Deployment

Refers to the deployment automation process. By automating the additional pipeline stages, changes can flow all the way to production without manual intervention. Continuous Integration must back it up, and once a reliable environment is in place, multiple releases per day become possible.

As a result, going through this CI/CD process shortens the time to product release, increases workforce efficiency, and reduces the chance of major issues because everything is a chain of incremental, continuous steps.

Setting up the Docker environment

Instance info

Instead of the EC2 free tier, I went with Oracle Cloud's free tier, which has relatively better terms. Allocated and used an arm64 Ampere A1 Compute with 2 cores and 12GB RAM.

It also provides things like backups for free to some extent — worth checking out!

Linux setup How to connect to EC2 with a password - an article about ssh setup for login convenience Docker installation - the official Docker install DOCS for Ubuntu

I gathered the references I used. There are plenty of articles about installing Docker and setting up the instance, so look them up and set up Docker accordingly.

Setting up Docker in Docker (failed > switched to Docker out of Docker via the API)

Why use it

The reason for handling Docker on top of Docker is to control containers through a container, and while the privileges of that container become very strong (which raises security concerns), the approach itself is undeniably appealing.

The setup I tried

1. Build a Jenkins container on Docker

First, build the Jenkins container with Docker. Using Docker Compose makes the build a bit easier, so keep that in mind.

docker pull jenkins/jenkins:lts

First pull the Jenkins LTS container.

vim docker-compose.yml

Create or open the yml file with that command.

version: "2.5.0" # specify the compose version

services:

  jenkins:
    container_name: jenkins
    image: jenkins/jenkins:lts # use the Jenkins LTS image
    restart: always # auto-restart option

    ports:
      - "8181:8080" # map host port 8181 to Jenkins port 8080

    volumes: # share host volumes through this option
      - /home/opendocs/jenkins:/var/jenkins_home
      - /var/run/docker.sock:/var/run/docker.sock

    user: root
    privileged: true # the key option to enable Docker in Docker

Fill in the yml file with the necessary content like the example.

docker-compose -f {filename} up

This command runs the setup based on docker-compose.yml. If you keep the default name docker-compose.yml, you can omit the -f option. See the Docker Compose Docs for details.

Docker Compose Documents

+ How to use docker without sudo → add the current user to the Docker group

# this command adds the current user to the Docker group
sudo usermod -aG docker $USER

2. Setting up the Jenkins Container

Open the configured IP and the assigned Port Number in a browser
Enter the key shown in the Jenkins install log on the screen

# this command lets you check the container logs
docker logs jenkins

Install the recommended plugins

You may run into issues, but for now finish the install and resolve them afterwards. If you don't finish, dependency errors caused by uninstalled plugins keep coming up...

Workaround for plugin install timeouts

Install the GitHub API Plugin

A plugin that lets webhook triggers work. Install it. After installing, register your Git ID/PW as a Secret.

3. GitHub configuration

Create a Token under Settings > Developer Settings. As of writing, I use a Classic token, and only repo and admin:repo_hook permissions are needed.
In the settings of the repo to be auto-deployed, add a Webhook under Webhooks. Setting it to roughly http://{jenkins_url}/github-webhook/ works. Leaving off the trailing / can cause problems, so just keep it.

4. Setting up the Jenkins project

Add a project.
Under build configuration > source code management, choose Git and pick the previously registered Secret to receive webhook signals.
You must select the GitHub hook trigger for GITScm polling option for the trigger to fire.
Pick the branch as needed, finish the configuration, and run a test.

[BOJ 4803, Java] Tree

Tue, 28 Feb 2023 00:26:49 GMT

Problem Link

[BOJ 4803](https://www.acmicpc.net/problem/4803

)

Categories

Data Structures, Depth-First Search (DFS), Disjoint Sets, Graph Theory, Graph Traversal, Trees

Description

This problem involved counting the number of trees using tree properties. It can be solved by excluding cycles from the set of connected elements.

Check if every node has been visited
Perform depth-first search while adding unvisited nodes to the tree
If a cycle is formed, mark all nodes in the cycle as visited
If no cycle is formed, the set is a tree, so count it as 1

I implemented the logic described above. After much deliberation on how to handle the counting during depth-first search, I wrote the following code:


    public static int dfs(int nowNode, int parent, boolean[] visitLog, HashMap<Integer, ArrayList<Integer>> graph) {

        for (int nextNode : graph.get(nowNode)) {

            if (nextNode != parent && !visitLog[nextNode]) {

                visitLog[nextNode] = true;

                int result = dfs(nextNode, nowNode, visitLog, graph);
                if (result == 0) {
                    return 0;
                }

            } else if (nextNode != parent && visitLog[nextNode]) {
                return 0;
            }

        }

        return 1;

    }

I wrote the code to start from the root node and perform a recursive search; if a cycle is encountered, it traverses all nodes and returns 0.

If no cycle is found, the traversal completes normally and returns 1. By continuously counting these return values, we can determine the number of trees!

Solution Code


import java.io.*;
import java.util.*;

public class Main {

    public static int dfs(int nowNode, int parent, boolean[] visitLog, HashMap<Integer, ArrayList<Integer>> graph) {

        for (int nextNode : graph.get(nowNode)) {

            if (nextNode != parent && !visitLog[nextNode]) {

                visitLog[nextNode] = true;

                int result = dfs(nextNode, nowNode, visitLog, graph);
                if (result == 0) {
                    return 0;
                }

            } else if (nextNode != parent && visitLog[nextNode]) {
                return 0;
            }

        }

        return 1;

    }

    public static void main(String[] args) throws IOException {

        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));

        int testCase = 0;

        ArrayList<String> outputArr = new ArrayList<>();

        while (true) {

            StringTokenizer treeInfo = new StringTokenizer(input.readLine(), "[ ]");
            int nodeNumber = Integer.parseInt(treeInfo.nextToken());
            int edgeNumber = Integer.parseInt(treeInfo.nextToken());

            if (nodeNumber == 0 && edgeNumber == 0) {
                break;
            }

            testCase += 1;

            int treeCount = 0;
            boolean[] isVisited = new boolean[nodeNumber + 1];

            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append("Case ");
            stringBuilder.append(testCase);
            stringBuilder.append(": ");

            HashMap<Integer, ArrayList<Integer>> treeGraph = new HashMap<>();
            for (int i = 1; i < nodeNumber + 1; i++) {
                treeGraph.put(i, new ArrayList<>());
            }

            for (int i = 0; i < edgeNumber; i++) {

                StringTokenizer edgeInfo = new StringTokenizer(input.readLine(), "[ ]");
                int startNode = Integer.parseInt(edgeInfo.nextToken());
                int endNode = Integer.parseInt(edgeInfo.nextToken());

                treeGraph.get(startNode).add(endNode);
                treeGraph.get(endNode).add(startNode);

            }

            for (int i = 1; i < nodeNumber + 1; i++) {

                isVisited[i] = true;
                treeCount += dfs(i, 0, isVisited, treeGraph);
            }

            if (treeCount == 0) {
                stringBuilder.append("No trees.");
            } else if (treeCount == 1) {
                stringBuilder.append("There is one tree.");
            } else if (treeCount > 1) {
                stringBuilder.append("A forest of ");
                stringBuilder.append(treeCount);
                stringBuilder.append(" trees.");
            }

            outputArr.add(stringBuilder.toString());

        }

        for (int i = 0; i < testCase; i++) {

            if (i != testCase - 1) {
                output.write(outputArr.get(i) + "\n");
            } else {
                output.write(outputArr.get(i));
            }

        }

        output.flush();
        output.close();

    }

}

[BOJ 1485, Python] Square

Sat, 25 Feb 2023 03:05:13 GMT

Problem Link

BOJ 1485

Categories

Geometry, Sorting

Description

You can determine whether a shape is a square by following these steps.

Check the lengths of all 6 edges connecting the 4 points
Sort them
Check if the first 4 lengths are equal
Check if the last 2 lengths are suitable as the diagonals of a square
Only if all conditions are satisfied, treat it as a valid square

Solution Code

# 정사각형

import sys
from math import sqrt, isclose
from itertools import combinations

input = sys.stdin.readline

def distance(coord_1: list, coord_2: list) -> int:
    return sqrt(pow(coord_1[0] - coord_2[0], 2) + pow(coord_1[1] - coord_2[1], 2))

testcase = int(input())

output = []

for _ in range(testcase):

    is_square = True

    coord_info = []

    for _ in range(4):
        coord_info.append(list(map(int, input().split())))

    edge_info = []

    for edge_distance in combinations(coord_info, 2):
        edge_info.append(distance(edge_distance[0], edge_distance[1]))

    edge_info.sort()

    for idx in range(1, 4):
        if not isclose(edge_info[0], edge_info[idx]):
            is_square = False
            break

    if is_square:
        for idx in range(4, 6):
            if not isclose(pow(edge_info[0], 2) * 2, pow(edge_info[idx], 2)):
                is_square = False
                break

    if is_square:
        output.append(1)

    else:
        output.append(0)

for result in output:
    print(result)

[BOJ 12850, Java] Walking the Main Campus 2

Wed, 22 Feb 2023 14:05:40 GMT

Problem link

boj 12850

Classification

Exponentiation_by_squaring, Graph theory, Graphs, Mathematics, Division and Conquest

Description

Devide and Conquer

An algorithm that solves an intractable problem by breaking it down into smaller problems.

This problem can be solved by drawing a neighboring matrix and knowing that the number of times you can reach the destination is the number of times you can perform n squared operations on the neighboring matrix.

It does require some study of divide-and-conquer and matrix operations, but I found it to be a reasonable level of difficulty, combining several lower-level problems.

Solution code

import java.io.*;
import java.util.*;

public class Main {

    public static HashMap<Integer, int[][]> matrixRecord = new HashMap<>();

    public static int[][] matrixCalculation(int[][] matrix1, int[][] matrix2) {
        /* 행렬 연산 함수 */

        int[][] resultArr = new int[8][8];

        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {

                long sum = 0;

                for (int k = 0; k < 8; k++) {
                    sum += ((long) matrix1[i][k] * (long) matrix2[k][j]) % 1000000007;
                }

                resultArr[i][j] = (int) (sum % 1000000007);

            }
        }

        return resultArr;
    }

    public static int[][] matrixDivision(HashMap<Integer, int[][]> matrixInfo, int calculationCount) {
        /* 분할 정복을 통한 행렬 연산 함수 */

        int halfCount = calculationCount / 2;

        int[][] halfMatrix;
        int[][] otherHalfMatrix;

        // 기존 값이 존재할 경우 불러오기
        if (matrixInfo.containsKey(halfCount)) {
            halfMatrix = matrixInfo.get(halfCount);
        } else {
            halfMatrix = matrixDivision(matrixInfo, halfCount);
        }

        if (matrixInfo.containsKey(calculationCount - halfCount)) {
            otherHalfMatrix = matrixInfo.get(calculationCount - halfCount);
        } else {
            otherHalfMatrix = matrixDivision(matrixInfo, calculationCount - halfCount);
        }

        // 연산 후 행렬 반환
        int[][] calculationResult = matrixCalculation(halfMatrix, otherHalfMatrix);
        matrixInfo.putIfAbsent(calculationCount, calculationResult);

        return calculationResult;
    }

    public static void main(String[] args) throws IOException {

        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));

        int walkTime = Integer.parseInt(input.readLine());

        // 기본 행렬 및 본대 인접 행렬 선언
        int[][] baseMatrix = {
                {1, 0, 0, 0, 0, 0, 0, 0},
                {0, 1, 0, 0, 0, 0, 0, 0},
                {0, 0, 1, 0, 0, 0, 0, 0},
                {0, 0, 0, 1, 0, 0, 0, 0},
                {0, 0, 0, 0, 1, 0, 0, 0},
                {0, 0, 0, 0, 0, 1, 0, 0},
                {0, 0, 0, 0, 0, 0, 1, 0},
                {0, 0, 0, 0, 0, 0, 0, 1},
        };

        int[][] graph = {
                {0, 1, 1, 0, 0, 0, 0, 0},
                {1, 0, 0, 1, 0, 0, 0, 0},
                {1, 0, 0, 1, 1, 0, 0, 0},
                {0, 1, 1, 0, 1, 1, 0, 0},
                {0, 0, 1, 1, 0, 1, 1, 0},
                {0, 0, 0, 1, 1, 0, 1, 1},
                {0, 0, 0, 0, 1, 1, 0, 1},
                {0, 0, 0, 0, 0, 1, 1, 0},
        };

        // 해시맵에 초기값들 등록
        matrixRecord.put(0, baseMatrix);
        matrixRecord.put(1, graph);

        // 함수를 통해 분할정복 연산 실행
        matrixDivision(matrixRecord, walkTime);

        // 결과 출력
        output.write(Integer.toString(matrixRecord.get(walkTime)[7][7]));

        output.flush();
        output.close();

    }

}

Refactoring 1 - 1. Type '...' is not assignable to type "..."

Tue, 21 Feb 2023 16:40:07 GMT

<Button
onClick={handleLogin}
variant="contained"
  >
    LOGIN
</Button>
<Button onClick={handleGoogleLogin}>
  <img
src={logoSrc}
alt="alternative image"
/>
  <p>Social Login</p>
</Button>

Problem occurred

When rebuilding this code using maps in TypeScript, an error occurred.

Type 'string' is not assignable to type '"text" | "outlined" | "contained" | undefined'."

I was using the MUI and it was spitting out the error in the value of the variant property of the MUI Button. I struggled with this for a while and searched high and low through StackOverFlow and ChatGPT until I finally figured it out.

Solution.


type Variant = "text" | "outlined" | "contained" | undefined;

interface SubmitButtonProps extends ButtonProps {
  variant?: Variant;
  onClick?: () => Promise<void>;
  contains?: React.ReactNode;
}

{loginButtonSettings.map(
  ({ onClick, contains, variant }: SubmitButtonProps, index: number) => (
    <SubmitButton
    key={index}
  	onClick={onClick}
	contains={contains}
	variant={variant}
	/>
  )
)}

As shown above, we need to predetermine the attribute values that will go into the variant through the value of type, and we also need to attach it to the interface. Actually, the next part is more important than this.

const loginButtonSettings = [
  {
    onClick: loginHandler,
    contains: <div>Login</div>,
    variant: "contained" as Variant, // 바로 여기!
  },

As you can see, "contained" is generally recognized as a string, so we need to make sure that it is the value that was contained in the Variant property value!

Entering Refactoring

Tue, 21 Feb 2023 16:26:20 GMT

Reason for recording

After about 7 weeks of short and long projects, I think I've gotten to know React to a certain extent. But unlike I thought, I want to keep this friend nice and neat, but somehow it's like watching a beard that grows messy...

So, I thought, "Let's fix that code!" and I'm going to take this opportunity to try out TypeScript while keeping a record of my simple project.

Why React?

In the previous project I participated in, I had the opportunity to use VueJS, so I had experience writing code based on Vue, but I wasn't experienced enough to compare the pros and cons, and I hadn't even used React before, so I thought, "It's the hottest framework right now, so let's try it!". I think it was an opportunity to realize the advantages of React rather than the disadvantages of Vue.

Ecosystem is wide

I think this is a well-known advantage, both numerically and otherwise, but most of the libraries I used in Vue are also available in React, and I felt that this is the main thing and Vue is a freebie.

Intuitive

I don't know if it's because I haven't used a lot of Hooks yet, but I felt much more comfortable with the way Props are handled and the way I write code.

In the case of UE, I felt like I had to write templates, scripts, and styles like a head, chest, and stomach to make a sense of distinction between the code, but React basically writes the Function Component in a way that does not distinguish it from the JavaScript code, so I felt much more convenient in accessing variables, etc.

Of course, if you separate them like Vue, it might be easier to read the code, but from a writing perspective, there was a clear difference, and even now, if I were to ask, "What should I use?" I would use React.

Event handling was convenient

This is somewhat shared with the above, but I remember that writing EventHandlers was much more intuitive than when I was using Vue. In the case of Vue, I think there were many parts that separated functions and variables, but React allows you to declare and process variables on the spot, just like using a general programming language, so it felt like a warm and comforting feeling like the vitiligo I used to eat every day.

Why do you want to use TypeScript?

Although the pros and cons of React may be different from the pros and cons of the actual industry, I was able to personally point out the above advantages of React and still chose React in the refactoring process.

Similarly, I think it's good to write down the reasons why I want to use TS instead of JS when refactoring, so I'll leave it here.

Error Catching

I think a lot of the strengths of TS address the weaknesses of JS. Basically, I think JS is a very loose language, and it is, so there are times when errors occur in strange places and are difficult to solve, and I expect TS to catch them well.

Familiarity

JS has a lot of things that I personally don't like about it as a programming language due to its inevitable development history. However, TS is obviously based on JS, but it provides a very tight structure that solves what JS was lacking! Of course, it can be tweaked more, but the comfort that comes from the familiarity of a stable structure is what makes me use TS...

Conclusion

I will continue to write about what I've learned and compare it to my previous code in future posts. I don't know how long it will take, but I expect it to be a very rewarding process!

[BOJ 1922, Java] Network Connection

Mon, 20 Feb 2023 07:55:51 GMT

Problem Link

BOJ 1922

Description

Introduction

Lately, I’ve been focusing solely on solving problems, which has made me feel like I’ve been neglecting the theory. So, I’d like to document my problem-solving process while briefly reviewing the theory.

MST (Minimum Spanning Tree)

What is a spanning tree?

A spanning tree is a tree that contains every vertex in a graph.

Minimum Spanning Tree (MST)

: The spanning tree with the shortest total edge length.

Key Features

: It has (n - 1) edges passing through n vertices. : Since it minimizes edge length, it can be used for building internal networks, etc.

Prim’s Algorithm

Select one initial vertex
Sequentially select the shortest edge among those connected to vertices included in the MST
Terminate when all vertices are connected

Kruskal's Algorithm

Sort all edges by weight
Sequentially add edges while ensuring no cycles are formed
Terminate when all vertices are connected

Solution Code

import java.io.*;
import java.util.*;

public class Main {

    // 간선 정보 클래스 선언
    public static class Connection implements Comparable<Connection> {

        private final int cost;
        private final int start;
        private final int end;

        public Connection(int cost, int start, int end) {
            this.cost = cost;
            this.start = start;
            this.end = end;
        }

        // 가중치를 통한 비교
        public int compareTo(Connection other) {
            return this.cost - other.cost;
        }

    }

    // 정점의 집합을 확인하는 함수
    public static int checkUnion(int[] unionInfo, int targetVertex) {

        if (unionInfo[targetVertex] != targetVertex) {
            unionInfo[targetVertex] = checkUnion(unionInfo, unionInfo[targetVertex]);
        }

        return unionInfo[targetVertex];
    }

    // 정점 2개가 집합을 이루는지 확인하는 함수
    public static boolean isUnion(int[] unionInfo, int vertex1, int vertex2) {
        return checkUnion(unionInfo, vertex1) == checkUnion(unionInfo, vertex2);
    }

    // 집합을 합쳐주는 함수
    public static void makeUnion(int[] unionInfo, int vertex1, int vertex2) {

        int group1 = checkUnion(unionInfo, vertex1);
        int group2 = checkUnion(unionInfo, vertex2);

        if (group2 > group1) {
            unionInfo[group2] = group1;
        } else {
            unionInfo[group1] = group2;
        }

    }

    public static void main(String[] args) throws IOException {

        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));

        // 정점 및 간선의 갯수 입력
        int vertexNumber = Integer.parseInt(input.readLine());
        int edgeNumber = Integer.parseInt(input.readLine());

        // 간선 정보를 담을 우선순위 큐 선언
        PriorityQueue<Connection> costPriorityQueue = new PriorityQueue<>();

        // 간선 정보 입력
        for (int i = 0; i < edgeNumber; i++) {
            StringTokenizer connectionInfo = new StringTokenizer(input.readLine(), "[ ]");

            int startNode = Integer.parseInt(connectionInfo.nextToken());
            int endNode = Integer.parseInt(connectionInfo.nextToken());
            int cost = Integer.parseInt(connectionInfo.nextToken());

            Connection connection = new Connection(cost, startNode, endNode);
            costPriorityQueue.add(connection);

        }

        // 집합에 포함된 정점의 갯수와 최소 가중치 정보를 담을 변수 선언
        int totalCost = 0;
        int totalEdge = 0;

        // 집합 정보를 담을 배열 선언
        int[] groupInfo = new int[vertexNumber + 1];
        for (int i = 0; i < vertexNumber + 1; i++) {
            groupInfo[i] = i;
        }

        // Kruskal's Algorithm
        while (totalEdge < vertexNumber - 1 && !costPriorityQueue.isEmpty()) {

            // 가중치 순으로 확인
            Connection nowConnection = costPriorityQueue.poll();

            // 집합 관계를 확인하여 아직 집합이 아닌 경우 집합에 추가하고 가중치 가산
            if (!isUnion(groupInfo, nowConnection.start, nowConnection.end)) {
                makeUnion(groupInfo, nowConnection.start, nowConnection.end);
                totalEdge += 1;
                totalCost += nowConnection.cost;
            }

        }

        // 최종 최소 가중치값 출력
        output.write(Integer.toString(totalCost));

        output.flush();
        output.close();

    }

}

[BOJ 14503, Java] Robot Vacuum Cleaner

Sat, 18 Feb 2023 12:31:09 GMT

Problem link

boj 14503

Classification

implementation, simulation, simulation

Description

This is a typical implementation problem, but the description of the problem is a little tricky to understand. I'll try to comment only on that part.

clean the current cell
check the direction from the current slot (counterclockwise 90 degrees)
go all the way around to where you were looking at the beginning and back up if there is nothing to clean.
if there is nothing left to clean, end cleaning

If you overlook the part of the problem that checks the left side of the face first, you will get confused about the implementation. Be careful when solving this problem!

Solving code

import java.io.*;
import java.util.*;

public class Main {

    public static int height;
    public static int width;

    public static boolean isNeedClean(int[][] table, int nowYIndex, int nowXIndex) {
        return table[nowYIndex][nowXIndex] == 0;
    }

    public static void main(String[] args) throws IOException {

        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));

        StringTokenizer mapSize = new StringTokenizer(input.readLine(), "[ ]");

        // 뒷 방향 등록 해시맵 선언
        HashMap<Integer, Integer> backward = new HashMap<>();
        backward.put(0, 2);
        backward.put(2, 0);
        backward.put(1, 3);
        backward.put(3, 1);

        height = Integer.parseInt(mapSize.nextToken());
        width = Integer.parseInt(mapSize.nextToken());

        int[][] mapInfo = new int[height][width];

        StringTokenizer startingPoint = new StringTokenizer(input.readLine(), "[ ]");

        int nowY = Integer.parseInt(startingPoint.nextToken());
        int nowX = Integer.parseInt(startingPoint.nextToken());
        int nowDirection = Integer.parseInt(startingPoint.nextToken());

        for (int i = 0; i < height; i++) {
            StringTokenizer mapLine = new StringTokenizer(input.readLine(), "[ ]");

            for (int j = 0; j < width; j++) {
                mapInfo[i][j] = Integer.parseInt(mapLine.nextToken());
            }

        }

        int cleanCounter = 0;

        int[] directionY = new int[]{-1, 0, 1, 0};
        int[] directionX = new int[]{0, 1, 0, -1};

        Loop:
        while (true) {

            // 현재 칸이 청소가 필요하다면 청소 실시
            if (isNeedClean(mapInfo, nowY, nowX)) {
                mapInfo[nowY][nowX] = 2;
                cleanCounter += 1;
            }

            // 주변 칸에 대해서 확인
            for (int i = 1; i < 5; i++) {

                int targetDirection = (nowDirection + 4 - i) % 4;
                int targetY = nowY + directionY[targetDirection];
                int targetX = nowX + directionX[targetDirection];

                // 청소할 칸이 있는 경우 이동 및 방향 전환
                if (isNeedClean(mapInfo, targetY, targetX)) {
                    nowY = targetY;
                    nowX = targetX;
                    nowDirection = targetDirection;
                    break;
                }

                // 청소할 칸이 없는 경우 뒷칸 확인
                if (i == 4) {
                    targetY = nowY + directionY[backward.get(nowDirection)];
                    targetX = nowX + directionX[backward.get(nowDirection)];

                    // 뒤로 이동할 수 없는 경우 청소 종료
                    if (mapInfo[targetY][targetX] == 1) {
                        break Loop;

                        // 이동할 수 있다면 뒤로 1칸 후진
                    } else {
                        nowY = targetY;
                        nowX = targetX;
                    }
                }

            }

        }

        // 이동 결과 출력
        output.write(Integer.toString(cleanCounter));

        output.flush();
        output.close();

    }

}

First interview reviews

Tue, 07 Feb 2023 11:30:12 GMT

2023-07-06 Thumbnail Edit (author storyset from Freepik)

Introduction

It's been a while since I've written anything.

I'm currently completing my 8th SSAFY course, so I haven't had as much time to write as I thought I would.

However, after going through an important process such as an interview, I don't think it would be helpful for my development if I don't organize these things, so I write this article hastily.

Interview process

It was a video interview, and I expected it to be more of a personality interview than a technical interview, but as expected, it was not a technical interview.

I'm not sure if I should be glad that I anticipated and prepared for this, or if I should be disappointed that I lost the opportunity to gain experience...

As for the interview questions, off the top of my head, I'd say they were

1 minute introductions every time

Why did you choose your current field as opposed to your major? (I'm a non-major)

About the gap

The work environment is this and that, but it may not be what you thought it would be, is that okay?

I wrote a little abstractly, but I was glad that I was able to respond with what I had prepared. Especially for non-majors, there are always questions that are aimed at their lack of CS knowledge compared to majors, so you need to be prepared to some extent!

Personal reflections

However, since it was not a technical interview, I think it was more disappointing that there were not many questions about it, as I don't know when I will pass the next coding test.

I've heard that the interview is as much a time for the interviewer to re-estimate the company as it is for the company to judge the interviewee, and I think I felt that in this interview.

In the case of the company I interviewed with this time, I think I will be doing something very different from the job I was thinking of, so I wonder if I will have a lot of trouble even if I get the job...!

[BOJ 16934, Java] Game Nickname

Wed, 28 Dec 2022 00:35:18 GMT

Problem Link

BOJ 16934

Categories

Data Structures, Sets and Maps Using Hashes, Strings, Trees, Tries

Description

Personally, I feel I’m not very good at string problems and think I need to study a bit harder, but this problem could be solved using the trie algorithm.

There were plenty of test cases, so checking for counterexamples wasn’t difficult, but if the examples hadn’t been so clean, this problem would have been a real headache...

Since I hadn’t implemented tree-based structures in Java before, it took me a bit of time, but let’s take pride in the fact that I implemented it without any outside help!

Solution Code

import java.io.*;
import java.util.*;

public class Main {

    public static class Node {

        char nowChar;
        String value;
        int count = 0;
        boolean isUnique = true;
        HashSet<Node> childSet;

        // 헤드에 사용하기 위한 정의 방식
        Node() {

            this.childSet = new HashSet<>();
            this.value = "";
            this.isUnique = false;

        }

        // 일반적인 서브노드들을 위한 정의 방식
        Node(char target) {

            this.nowChar = target;
            this.childSet = new HashSet<>();
            this.value = "";

        }

    }

    public static class Trie {

        // 헤드 노드 1개를 보유하고 시작
        Node head = new Node();

        /**
         * 문자열 1개를 트라이 클래스에 추가하는 메서드
         */
        public void addString(String target) {

            Node nowNode = this.head;
            int targetLength = target.length();

            for (int i = 0; i <= targetLength; i++) {

                if (i == targetLength) {

                    nowNode.count += 1;
                    nowNode.value = target;

                } else {

                    boolean hasChild = false;

                    for (Node subNode : nowNode.childSet) {

                        if (subNode.nowChar == target.charAt(i)) {

                            nowNode = subNode;
                            hasChild = true;
                            break;

                        }

                    }

                    if (!hasChild) {

                        Node madeNode = new Node(target.charAt(i));
                        nowNode.childSet.add(madeNode);
                        nowNode = madeNode;

                    }

                }

            }

        }

        /**
         * 문자열의 고유 별칭을 찾아내는 메서드
         */
        public String findUnique(String target) {

            Node nowNode = this.head;
            int targetLength = target.length();
            boolean isFirstTime = true;
            int result = -1;
            int resultCount = -1;

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

                // 첫 번째로 만나는 고유값이 해당 문자열의 별칭
                if (nowNode.isUnique && isFirstTime) {

                    nowNode.isUnique = false;
                    isFirstTime = false;
                    result = i;
                    resultCount = nowNode.count;

                    // 이후로도 만나는 고유값은 고유값이 아니도록 처리
                } else {

                    if (nowNode.isUnique) {
                        nowNode.isUnique = false;
                    }

                }

                // 마지막 문자까지 확인
                if (i == targetLength) {

                    // 마지막 문자까지 고유값을 체크하지 못한 경우
                    if (result == -1) {
                        result = targetLength;
                        resultCount = nowNode.count;
                    }

                    // 카운팅 갯수에 따른 값을 반환
                    if (nowNode.count == 1) {
                        return target.substring(0, result);

                    } else {
                        return target + resultCount;
                    }

                    // 마지막 문자 이전까지는 트라이 내 탐색 방식으로 진행
                } else {

                    for (Node subNode : nowNode.childSet) {

                        if (subNode.nowChar == target.charAt(i)) {
                            nowNode = subNode;
                            break;

                        }

                    }

                }

            }

            return "ERROR!";

        }

    }

    public static void main(String[] args) throws IOException {

        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));

        // Trie Algorithm

        // 트라이 인스턴스 선언
        Trie nickNameTrie = new Trie();

        // 유저 수 입력
        int userNumber = Integer.parseInt(input.readLine());

        // 모든 유저에 대해 진행
        for (int i = 0; i < userNumber; i++) {

            // 닉네임 입력 및 트라이에 추가
            String nickName = input.readLine();
            nickNameTrie.addString(nickName);

            // 함수를 호출하여 해당 닉네임에 대한 별칭 출력
            if (i == userNumber - 1) {
                output.write(nickNameTrie.findUnique(nickName));

            } else {
                output.write(nickNameTrie.findUnique(nickName) + "\n");
            }

        }

        output.flush();
        output.close();

    }

}

[BOJ 17114, Java] Hyper Tomato

Thu, 22 Dec 2022 04:36:35 GMT

Problem Link

[BOJ 17114] (<https://www.acmicpc.net/problem/17114>)

Categories

Implementation, Graph Theory, Graph Traversal, Breadth-First Search (BFS)

Description

Personally, I think this problem really demonstrates just how messy BFS can get.

I’ve known about this problem for a while, and even though the solution itself is well-known and famous, I’ve learned once again that implementing my own solution is a different challenge altogether.

Fast I/O is a given, and if you don’t trim the fat when performing breadth-first search, you’re likely to get a timeout.

I’m not sure if you can solve this using sys.stdin.readline in Python, but fortunately, in Java, I was able to handle it using BufferedReader.

After solving this problem and doing some research, it seems there are smarter ways to solve it, but here I solved it by brutally extending the classic BFS.

Input coordinate information into an 11-dimensional array
Count unripe tomatoes; record the coordinates of ripe tomatoes
Iterate through ripe tomatoes, adding adjacent unripe tomatoes to the list of ripe tomatoes while decrementing the count; repeat this process based on the conditions
If the count reaches 0, all tomatoes are ripe, so output the number of days taken
If the count does not reach 0, but the number of unripe tomatoes does not change when repeating step (3) on the existing unripe tomatoes, it means they can no longer ripen, so output -1.

When solving this problem, if you handle steps 2 and 3 differently—that is, if you increment the counter every iteration or fail to remove the coordinates of ripe tomatoes that have already been used—you may receive a timeout... I struggled with this for quite a while before finally solving it.

Solution Code

The code is quite long... but I think it’s unavoidable given the use of 11 nested for loops and the need to represent adjacent coordinates.


import java.io.*;
import java.util.*;

public class Main {

    public static int tomatoLeft;

    /**
     * 토마토가 익는 메커니즘을 반영하여 1일 뒤의 배열로 변경하는 함수
     */
    public static void ripeTomato(int[][][][][][][][][][][] target, Queue<int[]> tomatoQueue, int[] sizeInfo) {

        int[][] movements = new int[][]{
                new int[]{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                new int[]{-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                new int[]{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                new int[]{0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                new int[]{0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0},
                new int[]{0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0},
                new int[]{0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
                new int[]{0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0},
                new int[]{0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
                new int[]{0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0},
                new int[]{0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0},
                new int[]{0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0},
                new int[]{0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0},
                new int[]{0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0},
                new int[]{0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0},
                new int[]{0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0},
                new int[]{0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
                new int[]{0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0},
                new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
                new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0},
                new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
                new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
        };

        ArrayList<int[]> ripeList = new ArrayList<>();

        for (int[] nowIdx : tomatoQueue) {

            for (int[] movement : movements) {

                boolean isNotOverIndex = true;

                for (int i = 0; i < 11; i++) {
                    if (0 > nowIdx[i] + movement[i] || nowIdx[i] + movement[i] >= sizeInfo[i]) {
                        isNotOverIndex = false;
                        break;
                    }
                }

                int nextIdx00 = nowIdx[0] + movement[0];
                int nextIdx01 = nowIdx[1] + movement[1];
                int nextIdx02 = nowIdx[2] + movement[2];
                int nextIdx03 = nowIdx[3] + movement[3];
                int nextIdx04 = nowIdx[4] + movement[4];
                int nextIdx05 = nowIdx[5] + movement[5];
                int nextIdx06 = nowIdx[6] + movement[6];
                int nextIdx07 = nowIdx[7] + movement[7];
                int nextIdx08 = nowIdx[8] + movement[8];
                int nextIdx09 = nowIdx[9] + movement[9];
                int nextIdx10 = nowIdx[10] + movement[10];

                if (

                        isNotOverIndex

                                && target[nextIdx00][nextIdx01][nextIdx02]
                                [nextIdx03][nextIdx04][nextIdx05][nextIdx06]
                                [nextIdx07][nextIdx08][nextIdx09][nextIdx10]
                                == 0

                ) {

                    ripeList.add(

                            new int[]{
                                    nextIdx00, nextIdx01, nextIdx02,
                                    nextIdx03, nextIdx04, nextIdx05, nextIdx06,
                                    nextIdx07, nextIdx08, nextIdx09, nextIdx10
                            }

                    );

                }

            }

        }

        tomatoQueue.clear();

        for (int[] ripeCoord : ripeList) {

            if (

                    target[ripeCoord[0]][ripeCoord[1]][ripeCoord[2]]
                            [ripeCoord[3]][ripeCoord[4]][ripeCoord[5]][ripeCoord[6]]
                            [ripeCoord[7]][ripeCoord[8]][ripeCoord[9]][ripeCoord[10]] == 0

            ) {

                target[ripeCoord[0]][ripeCoord[1]][ripeCoord[2]]
                        [ripeCoord[3]][ripeCoord[4]][ripeCoord[5]][ripeCoord[6]]
                        [ripeCoord[7]][ripeCoord[8]][ripeCoord[9]][ripeCoord[10]] = 1;

                tomatoLeft -= 1;

                tomatoQueue.add(ripeCoord);

            }

        }

    }

    public static void main(String[] args) throws IOException {

        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));

        // 배열 사이즈 입력
        int[] storageSize = new int[11];
        StringTokenizer sizeInput = new StringTokenizer(input.readLine(), "[ ]");

        for (int i = 0; i < 11; i++) {
            storageSize[i] = Integer.parseInt(sizeInput.nextToken());
        }

        // 창고 정보 입력
        int[][][][][][][][][][][] tomatoStorage = new int[storageSize[0]][storageSize[1]][storageSize[2]]
                [storageSize[3]][storageSize[4]][storageSize[5]][storageSize[6]]
                [storageSize[7]][storageSize[8]][storageSize[9]][storageSize[10]];

        Queue<int[]> ripeTomatoQueue = new LinkedList<>();

        for (int idx10 = 0; idx10 < storageSize[10]; idx10++) {
            for (int idx09 = 0; idx09 < storageSize[9]; idx09++) {
                for (int idx08 = 0; idx08 < storageSize[8]; idx08++) {
                    for (int idx07 = 0; idx07 < storageSize[7]; idx07++) {
                        for (int idx06 = 0; idx06 < storageSize[6]; idx06++) {
                            for (int idx05 = 0; idx05 < storageSize[5]; idx05++) {
                                for (int idx04 = 0; idx04 < storageSize[4]; idx04++) {
                                    for (int idx03 = 0; idx03 < storageSize[3]; idx03++) {
                                        for (int idx02 = 0; idx02 < storageSize[2]; idx02++) {
                                            for (int idx01 = 0; idx01 < storageSize[1]; idx01++) {

                                                StringTokenizer storageInfo = new StringTokenizer(input.readLine(), "[ ]");

                                                for (int idx00Counter = 0; idx00Counter < storageSize[0]; idx00Counter++) {

                                                    int nowInput = Integer.parseInt(storageInfo.nextToken());

                                                    if (nowInput == 1) {

                                                        ripeTomatoQueue.add(
                                                                new int[]{
                                                                        idx00Counter, idx01, idx02,
                                                                        idx03, idx04, idx05, idx06,
                                                                        idx07, idx08, idx09, idx10
                                                                }
                                                        );

                                                    } else if (nowInput == 0) {

                                                        tomatoLeft += 1;

                                                    }

                                                    tomatoStorage[idx00Counter][idx01][idx02]
                                                            [idx03][idx04][idx05][idx06]
                                                            [idx07][idx08][idx09][idx10]
                                                            = nowInput;

                                                }

                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        // 지난 날짜 카운팅 변수 및 모두 익지 못하는 상황을 체크하기 위한 Flag 선언
        int dayCounter = 0;
        boolean cantComplete = false;

        // 모두 익지 않았다면 반복
        while (tomatoLeft > 0) {

            // 함수를 호출하여 기존 배열 깊은 복사 후 1일 뒤의 배열 확인
            int lastTomato = tomatoLeft;
            ripeTomato(tomatoStorage, ripeTomatoQueue, storageSize);

            // 날짜 1 카운트
            dayCounter += 1;

            // 아직 다 익지 않았지만 기존이랑 차이가 없다면 전부 익을 수 없는 상황이므로 Flag 변경 후 break
            if (tomatoLeft != 0 && tomatoLeft == lastTomato) {
                cantComplete = true;
                break;
            }

        }

        // 문제 조건에 따라서 출력
        if (cantComplete) {
            output.write("-1");
        } else {
            output.write(Integer.toString(dayCounter));
        }

        output.flush();
        output.close();

    }

}

[BOJ 3865, Java] Society Member

Mon, 12 Dec 2022 13:50:33 GMT

Problem Link

BOJ 3865

Categories

Breadth-First Search (BFS), Data Structures, Depth-First Search (DFS), Graph Theory, Graph Traversal, Sets and Maps Using Hashes, Parsing, Strings(string)

Description

It seems that string-related problems have been appearing frequently in recent coding tests, so I came across this problem while looking for string-related challenges.

Since it involved depth-first search, I was familiar with the approach. Although I’m still not fully proficient in Java, so it took me a bit of time to solve it, the overall solution stayed within the framework of depth-first search.

It was a problem that could be solved by properly processing the string data, continuously checking the set of visit records for the conference and student names, and using recursion combined with counting for each case where a visit hadn’t yet occurred.

Solution Code

import java.io.*;
import java.util.*;

public class Main {

    /**
     * 해당 학회의 총 인원수를 반환하는 함수
     */

    public static int getTotalPerson(String target) {

        // 결과값 변수 선언
        int result = 0;

        // 아직 방문하지 않은 경우에 대해서만 처리
        if (!visitLog.contains(target)) {

            // 방문 기록
            visitLog.add(target);

            // 사람이 아닌 학회일 경우
            if (clubGraph.containsKey(target)) {

                // 해당 학회의 방문하지 않은 구성원에 대해 재귀함수를 호출, 결과값에 합산
                for (String eachPerson : clubGraph.get(target)) {

                    // 구성원이 학회라면 재귀함수 호출
                    if (clubGraph.containsKey(eachPerson)) {
                        result += getTotalPerson(eachPerson);

                    // 학생이라면 아직 방문하지 않았을 경우 결과값 1 추가
                    } else {

                        if (!visitLog.contains(eachPerson)) {

                            visitLog.add(eachPerson);
                            result += 1;

                        }

                    }

                }

            }

        }

        // 결과값을 반환
        return result;

    }

    public static int strToInt(String inputString) {
        return Integer.parseInt(inputString);
    }

    // 학회 수, 첫 학회, 학회 관계 그래프, 학생 기록 집합 정적 변수 선언
    static int clubNumber;
    static String firstClub;
    static HashMap<String, ArrayList<String>> clubGraph = new HashMap<>();
    static Set<String> visitLog = new HashSet<>();

    public static void main(String[] args) throws IOException {

        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));

        // 학회의 수 입력, 입력값이 0이라면 반복 종료
        while ((clubNumber = strToInt(input.readLine())) != 0) {

            clubGraph.clear();
            visitLog.clear();

            for (int i = 0; i < clubNumber; i++) {

                // 줄 단위 입력
                StringTokenizer clubInfo = new StringTokenizer(input.readLine(),"[:,.]");

                // 학회 이름 변수 선언
                String clubName = clubInfo.nextToken();

                // 첫 학회라면 따로 변수에 기록
                if (i == 0) {
                    firstClub = clubName;
                }

                // 기존에 없던 학회라면 추가
                if (!clubGraph.containsKey(clubName)) {
                    clubGraph.put(clubName, new ArrayList<>());
                }

                // 나머지를 전부 학회의 원소로 추가
                while (clubInfo.hasMoreTokens()) {
                    clubGraph.get(clubName).add(clubInfo.nextToken());
                }

            }

            // 함수를 호출하여 결과값을 출력 스택에 추가
            System.out.println(getTotalPerson(firstClub));

        }

    }

}

SQLD Exam Pass Review and Study Materials

Tue, 29 Nov 2022 15:32:31 GMT

I passed the 47th SQL Developer Certification Exam. Since this is the first certification I’ve earned after completely changing my career path, I feel a great sense of pride.

At first, I wanted to dedicate about a month to it, but I ended up wasting quite a bit of time—either getting swamped with other tasks or approaching it too theoretically—so I do have some regrets. I’m leaving a record here of the points I confirmed while studying.

The final section contains concepts I organized personally, and since there are practical details or edits I made to help me memorize them scattered throughout, there may be some parts that don’t quite match up! Still, since this might help someone, I’m leaving the entire content as is and plan to edit it later if I think of anything.

Time Spent and Study Method

I actually spent about two weeks on this, with about one week dedicated to solving practice problems.

At first, I wanted to study using the concept explanations provided by [Data on Air](https://dataonair.or.kr/

) as a standard approach, but I gave up on that early on after realizing that the SQLD exam itself features far more questions based on practical SQL syntax than on theoretical concepts. However, I still think the content itself is good, so I recommend checking it out if you have the time!

Next, I got a general overview by watching various types of lectures on YouTube. Since there are quite a few well-organized lectures specifically for the SQLD exam, it should be sufficient to just pick the ones that look promising.

Finally, there’s the practice problems. For these, there are resources available on related forums or blogs that have compiled past exam questions. While the book commonly known as the “Yellow Book” is good, it’s important not to neglect the solutions to past exam questions! For the Yellow Book, I only read through the first two chapters once and organized my error log; I spent the rest of my time entirely on solving past exam questions.

The website I personally recommend for a collection of reconstructed past exam questions is [this blog](https://yunamom.tistory.com/category/자격증/SQLD 기출문제

). This is because you can immediately check whether your answer is correct simply by entering it.

Concept Review

Note: Since Chapter 1 has fewer practice problems than Chapter 2, it was prioritized lower; consequently, only the necessary content is included here, so the coverage may not be exhaustive.

Chapter 1 Classification of Entities

Basic / Key Entities
Central Entities
Activity Entities

Data Modeling

A business analysis technique from a data perspective for building information systems
Representing real-world data using agreed-upon notation
The analysis and design process for building a database

Points to Note When Performing Data Modeling

Redundancy
Inflexibility
Inconsistency

Types of Data Modeling

Conceptual: High level of abstraction; comprehensive and business-centric approach
Logical: Accurately represents keys, attributes, and relationships; designed for high reusability
Physical: Designed to be portable to an actual database and takes physical characteristics into account

Structure of a Database Schema

External
Conceptual
Internal

Steps for Creating an ERD

Draw the entities.
Arrange the entities appropriately.
Define the relationships between entities.
Label the relationship names.
Specify the degree of participation in the relationship.
Indicate whether the relationship is mandatory.

Characteristics of an Entity

Information required and managed within the specific business process
Must be a unique identifier.
Has two or more instances.
Must be used in practice.
Must have attributes.
Must form at least one relationship.

1개 엔터티: 2개 이상의 인스턴스 집합 + 2개 이상의 속성
1개 속성: 1개 이상의 속성값

Classification of Attributes by Characteristics

Basic Attributes
Design Attributes
Derived Attributes

Domain

The range of values each attribute can take
Specifies the data type, size, and constraints for attributes within an entity

Naming Attributes

Names must be those used in the relevant business context.
Do not use descriptive attribute names.
Avoid using abbreviations.
Ensure uniqueness across the entire data model.

ERDs do not distinguish between ontological and behavioral relationships. However, Class Diagrams do make this distinction and must describe association and dependency relationships.

Relationship Notation

Relationship Name: The name of the relationship
Relationship Degree: 1:1, 1:M, M:N
Relationship Specification: Required, Optional

Reading Relationships

Read the reference entity as "One" or "Each."
Read the relationship participation of the target entity.
Read the relationship specifier and relationship name.

Types of Identifiers

Representativeness: Primary Identifier vs. Secondary Identifier
Self-Generation: Internal vs. External
Single-Attribute Identification: Single vs. Composite
Semantic Significance: Natural vs. Artificial

Characteristics of Primary Keys

Uniqueness
Rarity
Immutability
Existence

Performance Data Modeling

Reflecting performance-related considerations in data modeling to improve database performance

Targets of First Normal Form

Separation of redundant attributes
Row-level redundancy
Column-level redundancy

Denormalization

By duplicating, consolidating, or separating normalized entities, attributes, and relationships, system performance is improved, and development and operations are simplified. This is performed when performance degradation is expected, even if it may compromise data integrity.

Procedure

Identify targets for denormalization
- Frequency of range processing
- Massive range processing
- Statistical processes
- Number of table joins
If alternative methods are available, consider redirecting to those methods
- Use view tables when there are many joins
- Use clustering when processing large volumes of data
- Split data using partitioning when holding large volumes of data
- Index maintenance
- Modify application logic

Super/Subtype Data Model Transformation Techniques

Individual Transactions -> Individual Tables Super + Sub-types -> Super + Sub-tables Entire Data Set -> Single Table

Criteria for Determining Primary Key Order

Specify to enable efficient use of indexes
The value of the attribute located at the beginning should serve as the comparison operator
Preferably use '=', BETWEEN, or '<>'

Advantages and Disadvantages of Distributed Databases

Advantages

Local autonomy; enables gradual system capacity expansion
Reliability and availability / Efficiency and flexibility
Fast response times, reduced communication costs, and better accommodation of local user needs
Increased data availability and reliability; scalability of system size

Disadvantages

Increased development costs and potential for errors, higher processing costs, and threats to data integrity
Difficulties in the design process, administrative complexity and costs, inconsistent response times, and difficulty in control

Chapter 2 Types of SQL Statements

DCL

Data Control Language, commands for managing permissions

GRANT

Used to grant permissions
Used in the form: ``GRANT {permission} ON {table} TO {user};`

(e.g.,

```text
WITH GRANT, WITH ADMIN의 비교

GRANT: 특정 사용자에게 권한 부여가 가능한 권한을 부여, 부여한 부모의 권한이 회수될 때 자식의 권한도 회수
ADMIN: 테이블에 대한 모든 권한을 부여, 부여한 부모의 권한 회수와 관계 없는 권한
```

REVOKE

Used to revoke permissions
Used in the form: ``REVOKE {permission} ON {table} FROM {user};`

Types of Permissions:

ALL -- 모든 권한 부여
SELECT INSERT UPDATE DELETE /*  */
REFERENCES ALTER INDEX /*  */

/* ROLE: 다양한 권한을 하나의 그룹으로 묶어서 관리 */
CREATE ROLE {role_name}; -- 권한 그룹 생성
GRANT {permission_type} TO {role_name}; -- 해당 그룹에 권한 등록
GRANT {role_name} TO {user_1}, {user_2}...; -- 다른 유저들에게 권한 그룹 부여

DDL

Data Definition Language: Commands that define data

Supports Auto Commit in SQL Server

CREATE

Creates table structure
Used in the form: ``CREATE TABLE {table_name} {table_elements};`

```sql
CREATE TABLE EXAMPLE (
/* 
  컬럼명은 영어, 한글, 숫자 전부 가능 
  첫 글자를 문자로 지정해야 하며, 컬럼의 데이터 타입은 반드시 설정해야 한다.
*/
		NAME  varchar2(max_length)  -- 최대 길이를 가진 가변길이 문자열
  	ID번호 char(length)          -- 고정된 길이 문자열
		나이_2 number(max_length)    -- 숫자형 데이터 타입
  	생일   date                  -- 날짜형 데이터 타입
);
```

##### CONSTRAINT (Conditions)

* default: Specifies a default value

* not null: Prevents null values

* primary key: Specifies a primary key (not null, unique, multiple allowed)

* foreign key: Specifies a foreign key (multiple allowed)

ALTER

Used to modify the structure of tables and columns, including changing, adding, or deleting names and properties
Used in the form ``ALTER TABLE {table_name} {detail_order} {detail_property(if need)} TO {change_target};`

#### Detailed Commands

* RENAME: Renames a table or column

* MODIFY: Changes a column&#x27;s properties

* ADD: Adds a column

* DROP: Removes a column

* ADD CONSTRAINT / DROP CONSTRAINT: Adds or removes constraints

RENAME

Allows you to change the names of tables and columns without using ALTER
Allows you to change multiple table names simultaneously

DROP

Allows you to remove tables and columns without using ALTER

#### TABLE {table_name} CASCADE CONSTRAINT

* An option unique to Oracle; it does not exist in SQL Server

* For foreign key constraints, the referenced table is dropped first, followed by the dropping table.

* All foreign key constraints referencing the data in the dropped table are also removed

TRUNCATE

Initializes the table (not a delete!)
Only the internal data is removed; the table’s existence and columns remain.

#### DROP vs TRUNCATE vs DELETE

* DROP: Removes the entire table and releases memory

* TRUNCATE: The table and columns remain, but memory is released for the remaining data

* DELETE: Removes records; a log of the data remains, allowing for rollback until the change is applied; no memory is released

DML

Data Manipulation Language, commands for manipulating records

INSERT

Inserts data into records
Used in the form ``INSERT INTO {table_name} {column_name} VALUES {change_column_name};`

You can insert data without specifying column names, but if you do not specify them, all values must be provided.

UPDATE

Modifies existing data
Used in the form: ``UPDATE {table_name} SET {column_name} = {column_value} WHERE {condition};`

DELETE

Removes existing data
Used in the form: ``DELETE FROM {table_name} WHERE {condition};`

FROM can be omitted

SELECT

Retrieves specific data
Used in the form: ``SELECT {select_target} FROM {select_origin} WHERE {condition};`

Conditions can also be added in the form: ``GROUP BY {calc_type} HAVING {condition} / ORDER BY {sort_condition}`

#### DISTINCT

Condition to retrieve data without duplicates: (a, b, NULL, a, b, NULL) =&gt; (a, b, NULL)

COUNT

(\*): Counts the total number of rows, including NULL values

({column_name}): Counts the number of rows in a specific column, excluding NULL values

TCL

Transaction Control Language, transaction control commands

Transaction: An operation that changes the state of the database

* transaction의 특징
고립성: 실행되는 동안 다른 transaction에 영향을 받아 잘못된 결과를 만들면 안됨
일관성: 실행 전 데이터베이스에 잘못된 점이 없다면 transaction 수행 후에도 내용에 오류가 있으면 안됨
지속성: transaction이 갱신한 데이터베이스 내용은 영구적으로 저장
원자성: transaction에서 정의한 연산은 모두 성공적으로 실행되거나 전혀 실행되지 않음 (All or Nothing)

COMMIT

Applies changes to the data in the database

SAVEPOINT

Specify a savepoint to serve as a branching point for code segmentation
Used in the form: ``SAVEPOINT {savepoint_name};`

ROLLBACK

Command to revert to a previous state
Can roll back to a savepoint or the most recent COMMIT
Used in the form: ``ROLLBACK TO {rollback_point};`

If no savepoint exists, the system reverts to the most recent COMMIT

Benefits of TCL

Ensures data integrity
Allows verification of data changes before making permanent modifications
Enables grouping and processing of logically related tasks

Functions

String Functions

Frequently used when specifying conditions such as SELECT and WHERE

LOWER

Converts an English string to lowercase

UPPER

Converts an English string to uppercase

CONCAT

Concatenates two strings
Equivalent to Oracle's '||' and SQL Server's '+'

SUBSTR

Removes characters from the Mth position, leaving N characters

LENGTH, LEN

Returns the length of a string, including spaces

TRIM, LTRIM, RTRIM

Removes all specified characters from both ends; if no characters are specified, removes spaces

Numeric Functions

ROUND

Rounds

TRUNC

Truncates

CEIL

The smallest integer greater than or equal to the number

FLOOR

The largest integer less than or equal to the number

MOD

Modulo operation

SIGN

Returns 1 for positive numbers, 0 for zero, and -1 for negative numbers

ABS

Absolute value

Date Functions

SYSDATE

Returns the current date and time when the query is executed

EXTRACT

Used in the format ``EXTRACT ({information} FROM {data})`

How to extract desired values from date data

Data Type Conversion

You can change data types using these functions

TO_NUMBER

String > Number

TO_CHAR

Number, Date > String (Generated differently depending on the format)

TO_DATE

String > Date (Generated differently depending on the format)

Basic Structure

DECODE

IF statement
When conditions are simple

CASE WHEN

Extended IF statement
When conditions require a lengthy list

ORDER BY

Sorting the retrieved table
Multiple criteria can be used

WHERE

IN, NOT IN: The condition is satisfied if the value matches or does not match any of the values in the list
IS NULL, IS NOT NULL: Determines whether the value is NULL or not, returning T / F
BETWEEN a AND b: Checks if a value exists between a and b and returns T/F (including a and b)
Comparison operators: =, >, <, >=, <=, etc.
A LIKE B: Finds a string similar to b for a
%: Indicates the presence of one or more characters
_: Represents a single character

명시적 형변환 vs 암시적 형변환

명시적 형변환: 함수를 활용하여 데이터 타입을 변경
암시적 형변환: 데이터베이스가 알아서 바꿔주는 것
>> 숫자 타입의 PK는 암묵적으로 인덱스가 되는데 데이터의 조회 등으로 암시적 형변환이 발생한 경우, 인덱스로 사용이 불가능

WITH

Can be used like a temporary table or view by using a subquery
Aliases can be specified
Treated as an inline view or temporary table
Used in the form ``WITH {table_name} AS {table_condition}`

GROUP BY

A command that performs grouping based on conditions
Different combinations of values result in different groups

HAVING

A conditional statement based on the state after grouping
Supports functions such as COUNT (count), SUM (sum), AVG (average), MAX (maximum), MIN (minimum), STDDEV (standard deviation), and VARIAN (variance)
Conditions such as DISTINCT (remove duplicates) and ALL (all) can be used

NULL Functions

NVL, ISNULL

Functions that replace NULL values with other values
Cannot be used if the data types are different

NVL2

A function that returns different results depending on whether the value is NULL or not
Returns the first parameter if the value is not NULL, and the second parameter if it is NULL

NULLIF

Returns NULL if both parameters are the same; otherwise, returns the first parameter

COALESCE

Returns the first non-NULL value

GROUP functions

Column values used for grouping and aggregation are output as NULL

The same results can be obtained using standard group functions

ROLLUP

Displays subtotals and grand totals.
The result varies depending on the order of the function’s arguments, and it returns aggregated values in a hierarchical structure.

CUBE

Generates a sum of arguments for every possible grouping

GROUPING SETS

Allows aggregation by sets enclosed in parentheses

GROUPING

A function that returns 1 if a subtotal or total is calculated, and 0 otherwise

JOIN

Generally refers to the combination of tables; similar to sets

JOINs are possible between tables, between a join result and a table, and between join results

Applicable when at least one common attribute exists between the two related tables

There are ANSI-standard queries that explicitly specify JOINs and non-standard queries that do not.

When JOINs are listed, they are processed two at a time; it is not possible to process all of them simultaneously

Intersection

*

INNER JOIN
- Non-standard notation, abbreviated as
- JOINs the intersection of both tables
*

LEFT JOIN
- When using non-standard notation, place a (+) on the left
- Joins all rows from the left table with only the intersection from the right table
*

RIGHT JOIN
- When using non-standard notation, place a (+) on the right
- Joins all rows from the right table with only the intersection from the left table
*

OUTER JOIN
- Since OUTER JOIN cannot be used with a (+) on both sides, you must use an ANSI-standard query.
- Unlike UNION, it can be applied even if there is only one common attribute.
Union

*

UNION (ALL)
- A join method applicable when the number of columns in the joined tables is the same and the attributes of each column are identical
- The total amount of data becomes Data1 + Data2.
- UNION ALL combines the data without removing duplicates
Union

Applicable when you want to examine only a single set by excluding the intersection

*

MINUS (Oracle)

EXCEPT (SQL Server)

Degree of matching between the joined entities
- EQUI JOIN: Combines two relations using identical columns
- non-EQUI JOIN: Combines two relations using columns that do not exactly match
```
ex) A.key <, >, <=, >= B.key
```

CROSS JOIN

If a JOIN is performed without a key, a Cartesian product is generated for the two tables
```
5개의 행 * 3개의 행 = 15개의 행으로 조회
```

SELF JOIN

A JOIN between two columns within the same table that have a relationship
Since both the table name and column names match, the use of an ALIAS is mandatory

Optimizer Join

Selection of methods for performance optimization during the JOIN process; specified using hints

Hierarchical Query

Performing a query on tree-structured data

The starting point of the hierarchy is set using START WITH (ROOT NODE)
A node with no child nodes = LEAF NODE
Hierarchical levels are denoted by LEVEL

CONNECT BY

Determines the direction of the hierarchical structure
- Child > Parent
- Parent > Child

##### CONNECT BY PRIOR a = b

* Hierarchical relationships occur between records where columns a and b are identical

* Records are reordered in the sequence b -&gt; a

SIBLINGS BY

Determines the ordering of sibling nodes

WINDOW FUNCTIONS

Functions used to easily define relationships between records, in the form of `

SELECT WINDOW_FUNCTION {arguments} OVER {partition by column} {order_style} FROM {table};

WINDOW_FUNCTION

Window functions
- Aggregate functions within a group: COUNT, SUM, MIN, MAX, AVG, etc.
- Ranking functions within a group
  
  Even when using rank functions, sorting is not performed automatically, so you must use the ORDER BY clause.
  
  *
  
  RANK
  - Assigns the same rank to records with the same rank
  - Does not count records with the same rank as a single instance
  *
  
  DENSE_RANK
  - Assigns the same rank to records with the same rank
  - Counts records with the same rank as a single record
  *
  
  ROW_NUMBER
  - Assigns a unique rank to records with the same rank
- Functions related to ratios within a group
  
  *
  
  PERCENT_RANK
  - Returns the percentile rank within a partition based on "order" rather than the value
  *
  
  NTILE(n)
  - Returns the value obtained by dividing the total count into n equal parts per partition
  *
  
  CUME_DIST
  - Returns the cumulative percentage of records within the partition that are equal to or less than the current row's value
  - Returns a value between 0 and 1 on the cumulative distribution
- Row Order Functions Within a Group
  
  *
  
  FIRST_VALUE
  - Returns the first value within a partition
  *
  
  LAST_VALUE
  - Returns the last value within a partition
  *
  
  LAG(column_name, record_difference)
  - Retrieves the previous row
  *
  
  LEAD(column_name, record_difference, value_if_null)
  - Retrieves the next row.
  - DEFAULT = 1

ARGUMENTS

Arguments (column names, etc., the targets on which the function operates)

PARTITION BY

Criteria for partitioning table records

ORDER BY

Specifies the criteria for sorting records within the partitioned records or across the entire table

WINDOWING

Defines the range of records on which the function operates

*

RANGE
- Used when specifying a range
*

BETWEEN a AND b
- Applies from a to b
*

UNBOUNDED PRECEDING
- Start position = first row
*

UNBOUNDED FOLLOWING
- Starting position = last row
*

CURRENT ROW
- Starting position = current row

Table Partitioning

Storing a large table by splitting it into multiple data files

Stored in physically separate data files => Improved performance and independent management

Effectively narrows the scope of queries => Improved performance

RANGE PARTITION

A method of storing data by partitioning based on value ranges

LIST PARTITION

Partitioning based on specific values

HASH PARTITION

A method where the database management system uses its own hash function to partition and manage data

Optimizer

Even for the same SQL statement, performance varies depending on how it is executed (performance metrics: execution time, resource usage, etc.)

Therefore, it is necessary to analyze the SQL statement and create an execution plan based on certain criteria; this is where the optimizer is used.

The optimizer can affect execution performance, but it does not change the result.

SQL문 작성 => 파싱 (문법 검사, 구문 분석) => 옵티마이저 (비용 기반 / 규칙 기반) => 실행 계획 (PLAN_TABLE 저장) => SQL 실행

Cost-Based

In the latest Oracle versions, the cost-based optimizer is used by default
Calculates the total cost of executing the SQL statement using system and object statistics, then establishes the execution plan with the lowest cost

Rule-Based

Develops an execution plan based on 15 priority rules
Generally, a scan based on ROWID has the highest priority

INDEX

Sorted by index key => Faster lookup
Primary keys (PKs) are automatically indexed
Multiple indexes can be created on a single table, and a single index can consist of multiple columns
Created and sorted in descending order
It is not advisable to index attributes that change frequently
For secondary indexes, duplicate data can be inserted unless the index has a UNIQUE constraint.
A full table scan may be more efficient and cost-effective than an index scan
Partitioned tables can have partition key indexes created for each partition; these are called global indexes
As the number of indexes increases, so does the amount of data, which can lead to slower insert, delete, and update speeds
Indexes can be created on all data types
Types of indexes include sequential indexes, bitmap indexes, composite indexes, clustered indexes, and hash indexes.

#### SCAN Methods<br />



* 

  ##### Index Unique SCAN

  * Searches using the index key when the key values are unique

*<br />



  ##### Index Unique SCAN

  * Scans the specified range using a WHERE clause

  * Depending on the range, it may return a single result or no results at all

*<br />



  ##### Index Full SCAN

  * Scans the entire index from start to finish

Types of Optimizer Joins

#### Nested Loop JOIN

* First queries the outer (driving) table to find the data to be joined, then joins it with the inner (driven) table

* Throughput is determined by the processing range of the driving table; therefore, it is necessary to find a driving table with a small size

* Both row-level and table-level processing occur sequentially

* It is important to find the optimal order

* Since random access occurs (when the driving table references the second table), random access must be minimized to reduce performance latency

* In cases where the driving table’s processing range is large or the random access range is extensive, this method may be less efficient than a Sort Merge Join

* &quot;Index required&quot;; advantageous with a unique index

* Useful for Online Transaction Processing (OLTP)

* Same format as nested loops; executed iteratively as many times as there are rows that satisfy the conditions of the leading table

#### Sort Merge JOIN

* Sorts each of the two tables and merges them upon completion

* Performance slows down when data volume is large due to the sorting process

* Performance degrades when a large amount of data is sorted because temporary disk space is used

* Supports both EQIU JOIN and non-EQIU JOIN

HASH JOIN

* Load the smaller of the two tables into hash memory and create a hash table using the join keys of both tables

* Scan both tables simultaneously

* The &quot;smaller data&quot; must come first in the leading table

* Can maximize utilization of system resources, but may consume excessive resources and raise concerns about system load

* Demonstrates fast processing speeds for large-scale data

* Available only with EQUAL JOIN

* Does not use indexes

* JOIN methods

  ```text
  먼저 선행 테이블을 결정, 선행 테이블에서 주어진 조건에 해당하는 레코드를 선택
  해당 행이 선택되면 JOIN Key를 기준으로 해시 함수를 사용
  해시 테이블을 메인 메모리에 생성, 후행 테이블에서 주어진 조건을 만족하는 행을 찾음
  후행 테이블의 JOIN Key를 사용해서 해시함수를 적용, 해당 버킷을 검색
  ```

PL/SQL

A language that extends SQL to enable various forms of procedural programming

Structured in blocks, allowing for modularization by function
Begins with a DECLARE statement, allowing variables and constants to be declared and used
- DECLARE, BEGIN–END are mandatory; EXCEPTION is optional
Uses various procedural language features such as DML, IF, and LOOP
Built into Oracle and compatible with programs using the same language
Improves application performance
Allows the creation of Procedure, User-Defined Function, and Trigger objects.
- Procedural code written within a procedure is processed by the PL/SQL engine, while standard SQL statements are processed by the SQL executor.

Distributed Database

A database system (DBMS) that controls physically separate databases over a network

Improved performance: Distributed databases perform parallel processing, resulting in faster speeds
Modular design allows for system updates without affecting other modules
Capacity can be expanded by adding distributed databases
Easy to protect critical data
High reliability
Difficulties in management and control
Difficulties in security management and integrity control
Complex structure

메모

count(*): 전체 행의 수를 카운팅, null 포함
count({column_name}) null 을 제외한 행의 수를 카운팅
null: 모르는 값을 상징, 값의 부재를 말함
(null is null) = TRUE
null과의 모든 비교는 null 반환
0 혹은 ' '과 동일한 값이 아님 

서브쿼리: SELECT문 내의 SELECT문이 반복 사용된 쿼리, 단일행 및 다중행으로 구분
- 정렬을 수행하는 ORDER BY를 사용할 수 없다.
- 여러 행을 반환하는 서브 쿼리는 다중 행 연산자를, 단일 행을 반환하는 서브쿼리는 단일 행 연산자를 사용
- 메인 쿼리에서 서브 쿼리의 컬럼을 자유롭게 사용할 수 없음
- EXIST는 True 혹은 False를 반환한다

스칼라 서브쿼리: 한 행과 한 컬럼만 반환하는 서브쿼리
인라인뷰: 서브쿼리가 FROM 절 내에 쓰여진 것

view 테이블
- 사용상의 편의를 위해 사용
- 수행속도의 향상을 위해 사용
- SQL의 성능을 향상시키기 위해 사용
- 임시적인 작업을 위해 사용
- 보안관리를 위해 사용

실행 순서
SELECT ALIAS => FROM => WHERE => GROUP BY => HAVING => SELECT => ORDER BY

조회 행수 제한
몇 번째 행을 조회하는지 부여하는 조건문
ROWNUM {row_number}: Oracle
TOP {row_number}: SQL Server
LIMIT {row_number}: MySQL

ROWID
해당 데이터가 어떤 데이터 파일 상에서 어느 블록에 저장되었는지 알려준다.
데이터베이스에 저장되어 있는 데이터를 구분할 수 있는 유일한 값이다.
ROWID의 번호는 데이터 블록에 데이터가 저장된 순서이다.
테이블에 데이터를 입력하면 자동으로 생성된다.

[BOJ 17471, Python] Gerrymandering

Mon, 07 Nov 2022 11:14:53 GMT

Problem Link

BOJ 17471

Categories

Breadth-First Search (BFS), Brute Force Algorithm, Combinatorics, Depth-First Search (DFS), Graph Theory, Graph Traversal, Mathematics

Description

At first, I approached this problem as a Union-Find problem, trying to remove edges and experiment with different constraints, but it turned out to be a problem that required a straightforward solution.

If we disregard the 0.5-second time limit, one might consider checking all combinations using depth-first search. However, since I was using Python, the short time limit led me to rule out a straightforward solution, which was a critical mistake.

Considering that the number of districts is limited to a maximum of 10, this problem can easily be solved using brute force; in fact, focusing your efforts in the wrong direction could lead to failure.

Therefore, the solution involves splitting each district into two parts to check if a valid electoral district is formed. If a valid district is formed, compare the population difference between the two districts; if the resulting value is smaller than the existing population difference, update it.

Solution Code

# 게리맨더링

import sys
from itertools import combinations

input = sys.stdin.readline

# 상한값 선언
INF = 2000000000

# 구역 갯수 입력
area_number = int(input())

# 구역별 인구 정보 입력
people_number = [0] + list(map(int, input().split()))

# 인접 구역 관계 그래프 입력
graph = [[] for _ in range(area_number + 1)]
for area_idx in range(1, area_number + 1):
    near_area, *graph[area_idx] = map(int, input().split())

# 총 인구수 확인
max_people = sum(people_number)

# 최소 차이값 변수 선언
min_difference = INF

# 한 선거구의 포함될 모든 구역 수에 대해 체크 
for areas in range(1, area_number // 2 + 1):

    # 모든 구역 중에서 한 선거구에 포함될 구역 확정
    for target_areas in combinations(range(1, area_number + 1), areas):

        # 해당 선거구에 포함되는 구역 집합 선언 및 해당 선거구 인원수 변수 선언
        target_set = set(target_areas)
        sum_areas = 0

        # Depth First Search

        # 집합에 포함된 한 구역에서 시작하는 깊이 탐색
        for first_area in target_set:

            # 선거구 내 구역 수 체크 카운터 선언
            counter = 1

            # 방문 리스트 선언
            is_visited = [False for _ in range(area_number + 1)]

            # 깊이 탐색을 진행할 스택 선언 및 초기 조건 입력
            progress_stack = [first_area]
            sum_areas += people_number[first_area]
            is_visited[first_area] = True

            # 탐색 진행
            while progress_stack:

                # 현재 구역 확인
                now_area = progress_stack.pop()

                # 모든 인접 구역에 대해 확인
                for next_area in graph[now_area]:

                    # 같은 선거구에 속해있고 방문하지 않았을 경우만 조사
                    if next_area in target_set:
                        if not is_visited[next_area]:

                            # 방문 처리, 인구수 합산, 선거구 카운팅
                            is_visited[next_area] = True
                            sum_areas += people_number[next_area]
                            counter += 1

                            # 다음 구역 스택에 추가
                            progress_stack.append(next_area)

            # 1회의 조사로 선거구의 모든 정보를 획득하므로 반복하지 않음
            break

        # 남은 구역들에 대해서 다른 하나의 선거구라 가정하고 깊이 탐색 진행

        other_set = set(range(1, area_number + 1)) - set(target_set)
        sum_other_areas = 0

        for first_other_area in other_set:

            other_counter = 1
            sum_other_areas += people_number[first_other_area]

            progress_stack = [first_other_area]
            is_visited[first_other_area] = True

            while progress_stack:
                
                now_area = progress_stack.pop()

                for next_area in graph[now_area]:
                    if next_area in other_set:
                        if not is_visited[next_area]:
                            is_visited[next_area] = True
                            sum_other_areas += people_number[next_area]
                            progress_stack.append(next_area)
                            other_counter += 1

            break

        # 양쪽 선거구를 조사했을 때 남는 구역이 없을 경우만 성립
        if counter + other_counter == area_number:

            # 두 선거구의 인구 차이를 확인하여 기존값보다 작다면 갱신
            now_min = abs(sum_areas - sum_other_areas)
            if min_difference > now_min:
                min_difference = now_min

# 한 번도 갱신하지 못했다면 선거구 분할 실패이므로 -1 출력
if min_difference == INF:
    print(-1)

# 갱신한 경우 결과를 출력
else:
    print(min_difference)

[BOJ 14438, Python] Sequences and Queries 17

Tue, 01 Nov 2022 13:52:01 GMT

Problem Link

[BOJ 14438](https://www.acmicpc.net/problem/14438

)

Categories

Segment Tree, Data Structures

Description

I believe this is the most common type of segment tree problem encountered by beginners.

Compared to a linear list, a segment tree offers the advantage of being constructed in O(NlogN) time for various operations such as range sum, range product, and maximum value within a range, while allowing access to information for each range in O(logN) time.

This problem can be broadly divided into three functions: the function to construct the segment tree, the function to retrieve range information, and the function to update the values.

Construction Function

Looking first at the function that constructs the segment tree (

def make_segtree(target_list: list, result_list: list, start: int, end:int, now_node: int) -> int:
    '''
    최소 숫자 정보를 담는 세그먼트 트리를 생성하는 함수
    '''

    # 포인터가 한 곳으로 모인 경우
    if start == end:

        # 해당 노드는 포인터가 가리키는 인덱스의 값과 동일
        result_list[now_node] = target_list[start]

    # 포인터가 범위를 나타내는 경우
    else:

        # Devide and Conquer Algorithm

        # 중간 지점 선언
        mid = (start + end) // 2

        # 중간 지점을 기준으로 구간을 분할하여 최소값으로 갱신
        val_1 = make_segtree(target_list, result_list, start, mid, 2 * now_node)
        val_2 = make_segtree(target_list, result_list, mid + 1, end, 2 * now_node + 1)

        # 두 구간의 최소값을 비교하여 둘 중 최소값을 현재 노드에 기록
        result_list[now_node] = min(val_1, val_2)

    # 현재 노드의 값을 반환
    return result_list[now_node]

), it essentially demonstrates the process of splitting the entire list into intervals and storing information about each interval in the corresponding nodes of the segment tree.

Since a recursive approach is used, the recursion continues until the interval length reaches 1, building up the recursion stack along the way. When this condition is met, the information for a single list value is stored at that address.

Subsequently, using the returned values, nodes that are not leaf nodes filter out values that meet the conditions, eventually reaching the root.

Therefore, the value stored in the root node is the value that best matches the conditions specified in the problem across the entire range.

Search Function

Next, let’s examine the function that finds the minimum value within a range:

def find_min_number(target_tree: list, start: int, end: int, left: int, right: int, now_node: int) -> int:
    '''
    해당 구간의 최소값을 찾는 함수
    '''

    # 범위 내로 포인터가 좁혀진 경우
    if left <= start and right >= end:

        # 현재 노드값을 반환
        return target_tree[now_node]

    # 범위를 아예 벗어난 경우
    elif left > end or right < start:

        # None 값을 반환
        return None

    # 범위가 걸친 경우
    else:

        # Devide and Conquer Algorithm

        # 중간 지점 선언
        mid = (start + end) // 2

        # 중간 지점을 기준으로 구간을 분할하여 값을 확인
        val_1 = find_min_number(target_tree, start, mid, left, right, 2 * now_node)
        val_2 = find_min_number(target_tree, mid + 1, end, left, right, 2 * now_node + 1)

        # 반환된 값들 중 None이 존재하는 경우
        if val_1 is None and val_2 is None:
            return None

        elif val_1 is None:
            return val_2

        elif val_2 is None:
            return val_1

        # None이 없다면
        else:

            # 두 구간의 최소값 중에서 더 작은 값을 반환
            return min(val_1, val_2)

. Essentially, if the range I’m searching for is included, the function proceeds to narrow it down until it contains only the exact range I’m looking for, then returns that value so the parent function can verify it.

If the range is exceeded, it returns None. By applying pruning based on these conditions, we can ensure that only ranges within the specified limits are selected and compared.

Modification Function

Finally, let’s look at the function that applies changes when a value is modified:


def change_segtree(target_tree: list, start: int, end: int, target_idx: int, target_val: int, now_node: int) -> None:
    '''
    리스트에 생긴 변경점을 트리에 반영하는 함수
    '''
    
    # 포인터가 한 곳으로 모인 경우
    if start == end:

        # 목표로 하는 인덱스랑 동일하다면 변경값을 반영
        if start == target_idx:
            target_tree[now_node] = target_val

    # 포인터가 범위로 주어진 경우
    else:

        # 목표 인덱스가 범위 내에 존재할 경우에만 갱신 가능성 존재
        if start <= target_idx <= end:

            # Devide and Conquer Algorithm

            # 중간 지점 선언
            mid = (start + end) // 2

            # 중간 지점을 기준으로 변경될 수 있는 인덱스를 재조사
            change_segtree(target_tree, start, mid, target_idx, target_val, 2 * now_node)
            change_segtree(target_tree, mid + 1, end, target_idx, target_val, 2 * now_node + 1)

        # 하위 노드들의 갱신이 진행된 이후 현재 노드의 갱신 진행
        target_tree[now_node] = min(target_tree[2 * now_node], target_tree[2 * now_node + 1])

. Since all values within the interval containing the index of the modified value must be updated, the function determines whether the interval includes that index or not.

Just like the creation function, a recursive stack is built until it narrows down to a single index. Starting with the modification of the node containing only that single index, the function returns while reflecting the updated values, and finally checks all the way down to the root node to complete the process.

Solution Code

Through the above process, all the operations required by the problem can be modularized. You can view the full code below.

# 수열과 쿼리 17

import sys
from math import ceil, log2

input = sys.stdin.readline

def make_segtree(target_list: list, result_list: list, start: int, end:int, now_node: int) -> int:
    '''
    최소 숫자 정보를 담는 세그먼트 트리를 생성하는 함수
    '''

    # 포인터가 한 곳으로 모인 경우
    if start == end:

        # 해당 노드는 포인터가 가리키는 인덱스의 값과 동일
        result_list[now_node] = target_list[start]

    # 포인터가 범위를 나타내는 경우
    else:

        # Devide and Conquer Algorithm

        # 중간 지점 선언
        mid = (start + end) // 2

        # 중간 지점을 기준으로 구간을 분할하여 최소값으로 갱신
        val_1 = make_segtree(target_list, result_list, start, mid, 2 * now_node)
        val_2 = make_segtree(target_list, result_list, mid + 1, end, 2 * now_node + 1)

        # 두 구간의 최소값을 비교하여 둘 중 최소값을 현재 노드에 기록
        result_list[now_node] = min(val_1, val_2)

    # 현재 노드의 값을 반환
    return result_list[now_node]

def find_min_number(target_tree: list, start: int, end: int, left: int, right: int, now_node: int) -> int:
    '''
    해당 구간의 최소값을 찾는 함수
    '''

    # 범위 내로 포인터가 좁혀진 경우
    if left <= start and right >= end:

        # 현재 노드값을 반환
        return target_tree[now_node]

    # 범위를 아예 벗어난 경우
    elif left > end or right < start:

        # None 값을 반환
        return None

    # 범위가 걸친 경우
    else:

        # Devide and Conquer Algorithm

        # 중간 지점 선언
        mid = (start + end) // 2

        # 중간 지점을 기준으로 구간을 분할하여 값을 확인
        val_1 = find_min_number(target_tree, start, mid, left, right, 2 * now_node)
        val_2 = find_min_number(target_tree, mid + 1, end, left, right, 2 * now_node + 1)

        # 반환된 값들 중 None이 존재하는 경우
        if val_1 is None and val_2 is None:
            return None

        elif val_1 is None:
            return val_2

        elif val_2 is None:
            return val_1

        # None이 없다면
        else:

            # 두 구간의 최소값 중에서 더 작은 값을 반환
            return min(val_1, val_2)

def change_segtree(target_tree: list, start: int, end: int, target_idx: int, target_val: int, now_node: int) -> None:
    '''
    리스트에 생긴 변경점을 트리에 반영하는 함수
    '''
    
    # 포인터가 한 곳으로 모인 경우
    if start == end:

        # 목표로 하는 인덱스랑 동일하다면 변경값을 반영
        if start == target_idx:
            target_tree[now_node] = target_val

    # 포인터가 범위로 주어진 경우
    else:

        # 목표 인덱스가 범위 내에 존재할 경우에만 갱신 가능성 존재
        if start <= target_idx <= end:

            # Devide and Conquer Algorithm

            # 중간 지점 선언
            mid = (start + end) // 2

            # 중간 지점을 기준으로 변경될 수 있는 인덱스를 재조사
            change_segtree(target_tree, start, mid, target_idx, target_val, 2 * now_node)
            change_segtree(target_tree, mid + 1, end, target_idx, target_val, 2 * now_node + 1)

        # 하위 노드들의 갱신이 진행된 이후 현재 노드의 갱신 진행
        target_tree[now_node] = min(target_tree[2 * now_node], target_tree[2 * now_node + 1])

# 수열의 크기 및 수열 정보 입력
target_length = int(input())
target_arr = ['*'] + list(map(int, input().split()))

# 수열의 구간 최소 숫자를 담을 세그먼트 트리 리스트 선언
segtree_arr = [None for _ in range(pow(2, ceil(log2(target_length) + 1)))]

# 함수를 호출하여 트리 생성
make_segtree(target_arr, segtree_arr, 1, target_length, 1)

# 퀴리 갯수 입력 및 출력 리스트 선언
query_number = int(input())
output = []

# 쿼리 실행
for _ in range(query_number):

    # 각 쿼리의 정보
    order_type, num_1, num_2 = map(int, input().split())

    # 타입 1의 경우
    if order_type == 1:

        # 리스트 값을 변경 및 함수를 호출하여 트리에 반영
        target_arr[num_1] = num_2
        change_segtree(segtree_arr, 1, target_length, num_1, num_2, 1)

    # 타입 2의 경우
    elif order_type == 2:

        # 함수를 호출하여 해당 구간의 최소 숫자를 출력 리스트에 추가
        output.append(find_min_number(segtree_arr, 1, target_length, num_1, num_2, 1))

# 결과 출력
for result in output:
    print(result)

Git Intro

Fri, 28 Oct 2022 13:19:01 GMT

Intro

This post summarizes the essential information I gathered while studying Git. Unless there are significant changes or further study is required, I believe this will serve as both an introduction and the final post.

What is Git?

It is a type of version control tool that records changes to files and allows the records from a specific point in time to be reused.

Local Version Control

Copying Directories

The most naive method
You might accidentally modify files incorrectly or copy them incorrectly.

VCS (Version Control System)

Manages file change information using a database.
Revision Control Systems are a representative example.
Manages Patch Sets (parts of a file that are changed).
By utilizing a series of Patch Sets, all files can be reverted to a specific point in time.

Centralized Version Control

Collaboration with other developers is frequent when working on a project.
In such cases, it is advantageous to have a separate server managing files, where clients receive and use files from the central server.
If a problem occurs with the central server and there is no system backup, the entire history can be lost; this is a problem that also existed locally.

Distributed Version Control System

It replicates the repository and history simultaneously, rather than simply storing snapshots.
If a problem occurs on the server, work can be resumed using the clone.
It is also possible to restore the server by selecting any client.
The existence of remote repositories enables various forms of collaboration.
GitHub is also a type of remote repository.

General Usage

Configuration and File Access Commands

# 전역 사용자 설정
git config --global user.name {name} # 이름
git config --global user.email {email_address} # 이메일

# 로컬 사용자 설정 (해당 디렉토리에서 실행)
git config user.name {name} # 이름
git config user.email {email_address} # 이메일

# 설정 조회
git config --list

# 생성
git mkdir {path}/{folder_name} # 폴더
git touch {file_name} # 파일
git init # 파일 관리 시스템

# 저장소 및 히스토리 복제
git clone {repository_url}

# 원격 저장소
git remote add {remote_repo_name} {remote_repo_url} # 추가
git remote -v # 정보 확인

# commit history
git log
git log --oneline # 정보 표시 간략화
git log --all # 현재 head 이후의 최신 기록들을 포함한 전체 정보를 표시
git log --graph # 브랜치를 시각화하여 분기를 표현한 그래프 형태로 정보를 표시

Commands Used for Repository Management

git status # 변경사항을 확인하는 명령어
git commit -m {message} # 현재 스테이지에 존재하는 변경 사항을 커밋

git add {file_name} # 특정한 파일을 스테이지에 추가하는 경우
git add . # 해당 레포지토리의 변경사항을 전부 스테이지에 추가하는 경우

Git Undoing

Clearing the Stage

git rm --cached # root commit이 존재하지 않을 때
git restore --staged # root commit이 존재할 때

Modifying a Commit

git commit --amend 
# 스테이지에 파일이 없는 경우: 직전 커밋의 메시지를 수정
# 스테이지에 파일이 있는 경우: 기존 커밋에 현재 스테이지를 더하여 덮어쓰기 진행

Reverting All Commits Up to a Specific Point

git reset --soft {commit_id} # 미래 파일들 전부 stage에 돌려놓음
git reset --mixed {commit_id} # default, 미래 파일들을 전부 working directory에 유지 (add 필요)
git reset --hard {commit_id} # 미래 파일 전부 제거

Removing Past Commits

git revert {commit_id} # 과거 commit을 제거 후, 제거했음을 commit으로 추가

Reset is unsuitable for collaboration because it reduces the number of commits; therefore, using revert instead of reset is recommended for collaboration.

Git Branch

Branch: A mechanism that helps divide the workspace and allow for independent work.

Allows you to maintain the original state. Safety
Increased collaboration efficiency by performing a single task on a single branch
In the case of Git, branch creation is fast and file sizes are small

Related Commands

# 조회
git branch # 로컬 저장소의 브랜치 대상
git branch -r # 원격 저장소의 브랜치 대상

# 생성
git branch {branch_name}
git branch {branch_name} {commit_id} # 특정 커밋 지점을 기준점으로 생성

# 제거
git branch -d {branch_name} # 병합 완료된 경우
git branch -D {branch_name} # 병합하지 못한 브랜치 강제 삭제

# 브랜치 이동
# 이동 전 반드시 현재 브랜치의 변경사항을 기록할 것
git switch {branch_name} # 이미 있는 브랜치로 이동
git switch -c {branch_name} # 해당 이름의 브랜치를 생성 후 이동
git switch -c {branch_name} {commit_id} # 특정 커밋 지점을 기준점으로 하는 해당 이름의 브랜치를 생성 후 이동

Git Merge

The process of merging branched branches

Types of Merging

Fast-Forward: Moves the commit pointed to by the branch to the very beginning
3-Way Merge: A merge using the 2 most recent commits from each branch + the common ancestor of the two branches
Merge Conflict: Conflicts occur when the same file is modified => Resolve the conflict and then proceed with a 3-Way Merge

# 해당 브랜치를 현재 위치한 브랜치에 병합
git merge {merged_branch}

Git Fork

Clone a remote repository without ownership; mainly used when there are multiple collaborators, such as with open source projects

The process of my commits being reflected in the forked source

#
#    원본 원격 저장소 (upstream) <----------- 복제본 원격 저장소 (origin)
#                \           merge request      /|
#                 \                              |
#                  \                 push branch | pull master
#                   \                            |
#                    \     ( pull upstream )     |/
#                     ------------------> 로컬 저장소 (user)
#

Clone the original repository to my remote repository
From that remote repository to the local Save
Create a branch locally, work on it, and commit the changes.
Push a merge request for the changes to the original remote repository.
Merge the changes in the original remote repository.
Pull the changes from the original repository.

pull upstream
sync origin & pull origin

Remove my merged branch locally.

[BOJ 7579, Python] Apps

Fri, 28 Oct 2022 10:13:23 GMT

Problem link

boj 7579

Classification

Dynamic Programming (DP), Knapsack problems

Description

Personally, I think the most important thing to look at when solving this problem was the problem conditions.

The memory bytes in use condition was 10^7, the number of active apps had to be at most 100, and the cost had to be less than or equal to 100.

This was a very large range to use a memory byte condition to check for false positives, so I decided to set the cost to the appropriate variable and assign an address to every cost to record how much memory I could save.

I guessed that DP should be used here and further designed a solution using the knapsack algorithm, which used to update the existing value based on the value when cost and value existed.

Solving code

# 앱

import sys

input = sys.stdin.readline

# 앱 갯수, 필요 메모리 입력
app_number, need_memory = map(int, input().split())

# 각 앱의 메모리와 비활성화 시의 비용 입력
app_memories = list(map(int, input().split()))
disable_costs = list(map(int, input().split()))

# 앱의 메모리와 비용 합쳐서 짝을 지어줌
memories_and_costs = list(zip(app_memories, disable_costs))

# 최대 필요 비용 연산
sum_cost = sum(disable_costs)

# 각 비용별 최대 절약 가능한 메모리 리스트 선언
cost_list = [0 for _ in range(sum_cost + 1)]

# Knapsack Algorithm

# 모든 앱에 대해 확인
for now_memory, now_cost in memories_and_costs:

    # 최대 필요 비용까지 조사
    for last_cost in range(sum_cost, -1, -1):

        # 최대 비용을 넘지 않는 선에서 확인
        if last_cost + now_cost <= sum_cost:

            # 기존 최대값보다 컸다면 갱신
            cost_list[last_cost + now_cost] = max(
                cost_list[last_cost + now_cost], cost_list[last_cost] + now_memory
            )

# 비용을 0에서부터 조사해서 기준 메모리 이상을 절약한 경우의 비용을 출력
for idx in range(sum_cost + 1):
    if cost_list[idx] >= need_memory:
        print(idx)
        break

[BOJ 15683, Python] Surveillance

Sun, 23 Oct 2022 10:46:34 GMT

Problem Link

BOJ 15683

Categories

Brute-force algorithm, Implementation, Simulation

Description

Although this problem is categorized as a brute-force algorithm, I used a backtracking algorithm to implement it.

Basically, I examined all possible directions that each surveillance camera could see. Once the direction settings for all cameras were complete, I called a function to check the number of blind spots. If this number was smaller than the current minimum value, I updated the minimum value accordingly.

Since I tend to add comments immediately after solving a problem, detailed solution methods will be included in the code comments in future posts as well.

Solution Code

# 감시

import sys

input = sys.stdin.readline

def check_blind_spot(matrix: list, y_range: int, x_range: int) -> int:
    '''
    현재 사무실 내 사각지대 갯수를 반환하는 함수
    '''

    # 사각지대 변수 선언
    blind_here = 0

    # 모든 좌표에 대해서 조사
    for y_idx in range(y_range):
        for x_idx in range(x_range):

            # 해당 좌표값이 0일 경우만 카운팅
            if not matrix[y_idx][x_idx]:
                blind_here += 1

    # 결과 반환
    return blind_here

# 사무실 가로 및 세로 크기 입력
height, width = map(int, input().split())

# CCTV 정보 및 사무실 정보를 담을 리스트 선언
cctvs = []
work_space = []

# 초기 사각지대 갯수 확인
blind_spot = 0

# 사무실 정보 입력
for y_idx in range(height):

    # 행 정보 확인
    temp = list(input().split())

    # 모든 요소들에 대해 조사
    for x_idx in range(width):

        # 만약 CCTV가 있다면 리스트에 추가
        if temp[x_idx] in '12345':
            cctvs.append(((y_idx, x_idx), int(temp[x_idx])))

        # CCTV도 아니고 벽도 아니라면 초기 사각지대
        else:
            if temp[x_idx] == '0':
                blind_spot += 1

    # 행 정보를 리스트에 추가
    work_space.append(list(map(lambda x: int(x), temp)))

# CCTV 갯수 변수 선언
cctv_amount = len(cctvs)

# CCTV 방향 정보 딕셔너리 선언
cctv_directions = {
    1: {0: [(1, 0)], 1: [(-1, 0)], 2: [(0, 1)], 3: [(0, -1)]},
    2: {0: [(1, 0), (-1, 0)], 1: [(0, 1), (0, -1)]},
    3: {0: [(-1, 0), (0, 1)], 1: [(0, 1), (1, 0)], 2: [(1, 0), (0, -1)], 3: [(0, -1), (-1, 0)]},
    4: {0: [(-1, 0), (0, 1), (0, -1)], 1: [(1, 0), (0, 1), (0, -1)], 2: [(1, 0), (-1, 0), (0, -1)], 3: [(1, 0), (-1, 0), (0, 1)]},
    5: {0: [(1, 0), (-1, 0), (0, 1), (0, -1)]},
}

# 각 CCTV의 방향 정보를 담은 리스트 선언
max_direction = ['dummy', 4, 2, 4, 4, 1]

# CCTV가 존재하지 않는 경우 기존 사각지대의 갯수를 출력
if not cctv_amount:
    print(blind_spot)

# 만약 존재한다면 CCTV 방향에 따른 사각지대의 갯수를 조사
else:

    # 최종 사각지대 갯수 변수 선언
    result = blind_spot

    def min_blind_spot(field: list, cctv_list: list, sight: dict, max_direction: list,
                       now_cctv: int = 0, y_range: int = height, x_range: int = width,
                       limit_cctv: int = cctv_amount) -> None:
        '''
        CCTV를 모두 최적의 상태로 설치할 때 최소 사각지대 갯수를 확인하는 함수
        '''

        # 결과값 전역 변수 등록
        global result

        # Back Tracking

        # 모든 CCTV를 전부 확인한 경우
        if now_cctv == limit_cctv:

            # 현재 사각지대 갯수 확인
            now_result = check_blind_spot(field, y_range, x_range)

            # 기존 최소값보다 작은 경우 갱신
            if result > now_result:
                result = now_result

            return

        # 아직 확인하지 않은 CCTV가 존재하는 경우
        else:

            # 현재 확인할 CCTV 정보 확인
            cctv_idx, cctv_type = cctv_list[now_cctv]

            # 좌표 분리
            y_cctv, x_cctv = cctv_idx

            # CCTV에 종류에 따라 감시 방향의 경우의 수만큼 조사
            for direction_code in range(max_direction[cctv_type]):

                # 현재 주시 방향 확인
                cctv_directions_now = sight[cctv_type][direction_code]

                # 해당 주시 방향에서 볼 수 있는 좌표를 담을 리스트 선언
                now_view = []

                # 깊이 탐색을 진행할 방향 설정
                for direction in cctv_directions_now:

                    # 이동 방향 좌표 분리
                    move_y, move_x = direction

                    # 초기 좌표 설정
                    now_y, now_x = y_cctv, x_cctv

                    # 해당 방향에 대해서 반복 조사
                    while True:

                        next_y, next_x = now_y + move_y, now_x + move_x

                        # 사무실 범위를 벗어나지 않은 경우
                        if 0 <= next_y < y_range and 0 <= next_x < x_range:

                            # 벽을 만났다면 반복 종료
                            if field[next_y][next_x] == 6:
                                break

                            # 벽을 만난 것이 아닐 경우
                            else:

                                # 해당 좌표가 사각지대일 경우
                                if not field[next_y][next_x]:

                                    # 리스트에 기록 후 비사각지대 처리
                                    now_view.append((next_y, next_x))
                                    field[next_y][next_x] = '#'

                                # 현재 좌표 갱신
                                now_y, now_x = next_y, next_x

                        # 사무실 범위를 벗어났다면 반복 종료
                        else:
                            break

                # 수집한 좌표들을 다음 CCTV에 조사
                min_blind_spot(field, cctvs, cctv_directions, max_direction, now_cctv + 1)

                # 초기화
                for y_idx, x_idx in now_view:
                    field[y_idx][x_idx] = 0

    # 함수를 호출하여 결과 도출
    min_blind_spot(work_space, cctvs, cctv_directions, max_direction)

    # 결과값 출력
    print(result)

First Post

Sat, 22 Oct 2022 18:26:40 GMT

In the past, I used to organize my notes privately, so that only I could see them.

But then I started wondering if there was really any point in taking the time to organize them neatly if that was the case. After weighing my options—between organizing them neatly and posting them somewhere accessible, or just jotting them down roughly and posting them somewhere accessible—I decided to go with the latter.

I hope that the material I’ve studied and organized will be helpful not only to me, but also to anyone else who happens to read this.