TraceofLight (JA)

Unity Roadshow 2026 で学んだ内容のまとめ

Sun, 19 Apr 2026 13:17:51 GMT

メモリの前提知識

基本内容

私たちは仮想メモリ (Virtual Memory、以下 VM) を使用しており、物理メモリを直接コントロールはしない
VM はページで構成されており、OS ごとに異なり得る
- Window / Linux 4kb
- iOS, macOS, Android 16kb
ページに対応する物理メモリのフレームが存在する
メモリ圧迫の度合いに応じて、仮想メモリを物理メモリにマージする

Page Fault

物理メモリにロードされていないページが必要になった場合を Page Fault と呼ぶ

Clean Page: 元データが変わっていないページ。OS がいつでも破棄でき、回収が容易
Dirty Page: アプリケーションが新たに書き込みや変更を加えた情報を持つページ。メモリからすぐに退避できない

Memory Footprint

実質的なメモリ圧迫を表す指標で、全 Dirty Page サイズの合計

Memory Footprint != 物理メモリ使用量、常駐メモリ使用量

メモリ管理方法 (Windows vs Linux)

予約: 物理メモリを使わず仮想メモリのみを確保
コミット: 仮想メモリと同量の物理フレームを割り当てる
デコミット: 予約領域は保ったまま物理フレームを解放する

Windows: 明示的な API を提供 (virtual alloc, virtual free)

UNIX Like: 予約とコミットの明示的な分離がない

mmap 呼び出しは暗黙的にメモリを予約する

ページに直接アクセスした時点で遅延コミットが発生

明示的な API はなく、デコミットはヒントとして動作する

OS がいつページを回収するかを決定する

Unity GC における処理

Managed Heap

C# のメモリ確保はすべてここで行われる
Garbage Collector が管理する
Unity Profiler では GC.Alloc として表示される

Garbage Collector

有効な参照が存在しない Object を Heap から定期的に回収する
GC を実行しても仮想メモリの総使用量は減らない
回収済みのオブジェクト領域も OS から見れば Dirty

Segment

連続したページの集合を Segment と定義する

Managed Heap は Raw Page ではなく Segment を使う
1 つの Segment に複数の Object が割り当てられ得る
割り当てて解放した後、内部的には未使用でも RAM 使用として表示される (Dirty のため)
大半は何の問題もなく、すぐに再利用される
長時間空のままだと常駐メモリの無駄になるため、Unity GC が断続的に処理する

Unity GC の役割

リマッピング戦略を採用している
GC が複数回実行された後、Old Empty Segment を Drop し、同サイズの New Segment を割り当てる
Windows Remap 戦略: Segment を解放せず Decommit (明示的に扱えるため)
UNIX Like Remap 戦略: munmap & mmap による Remap (Hot Page 効果でキャッシュヒット率が高い)
これにより常駐メモリを減らせるという利点がある

GC.Collect を何度も呼ぶべきでない理由

Segment のリリースを強制的に実行しないこと
Collect はコストが高く、アプリがフリーズする恐れがある
もともとの意図は長時間空き状態のセグメントをデコミットすることにある
一時的に空になっただけのセグメントをデコミットするのは意図と異なる
強制的にデコミットしてもパフォーマンスは改善せず、CPU コストだけが発生する
- どうせ次フレームで再利用されるセグメントまでデコミットする状況になる

Managed Heap の VM 使用量は増えるばかりで絶対に減らない

Heap は大きくなるだけで縮小しない
Boehm GC 本来の特性
仮想メモリの割り当て量を Trim する理由がない
- 大きな仮想メモリ != 大きな物理メモリ使用量
- セグメントはどうせ再利用される
- ゲームオブジェクトは毎フレーム頻繁に生成・破棄される
- オブジェクトが破棄されるたびにセグメントを縮めるのは CPU 性能の浪費にしかならない

Unity Boehm GC

Unity の Incremental Boehm GC は保守的な GC (Conservative GC)
これは Unity が、過去に書かれた C# コードを C++ に変換する処理をサポートする IL2CPP を提供したことで主に使われるようになった
- IL2CPP によって多様な環境への対応が可能になったが、C# と違いメモリ GC は自動化されないため、オープンソースの GC である Boehm GC を採用したと考えられる
性能よりも安定性を重視し、ポインタ「のように」見える値はすべて参照とみなす
GC 中にオブジェクトの位置を変えない -> コンパクションがなく、メモリ断片化に弱い

Compaction について

メモリ断片化の解消に有利なメモリ圧縮処理。未使用領域をすべて空けて再配置する

正確な参照情報が必要なため、保守的な GC では不可能

オブジェクトの位置を移動するにはコストがかかる (Stop The World + 実際の移動)

CoreCLR GC

CoreCLR GC は Precise GC で、メモリ・スタック・レジスタ上のどの値が参照かを正確に把握する方式の GC

そして .NET は CoreCLR をコアエンジンとして採用している (CLR: Common Language Runtime)

CoreCLR がサポートする点

CoreCLR GC

JIT コンパイラ

Excecption Control

misc...

この CoreCLR GC (以下 .NET GC) は世代別メモリ管理方式を採用している

Heap を 3 世代に分けて管理する
Gen 0: 生成直後の新しいオブジェクト中心。頻繁かつ高速な GC が走る (大半のオブジェクトはここで消える)
Gen 1: Gen 0 を生き延びたオブジェクトが移される Buffer の役割
Gen 2: 長く生き残っている重いオブジェクトが置かれる領域。ここの GC はコストが比較的大きい
LOH: 非常に大きいオブジェクトはこの領域に配置される

プロモーション過程でメモリ Compaction を行うことで断片化を抑えられる

LOH の場合 STW が長くなるため、以前は Compaction しなかったが、現在は明示的にオプション化して扱っているとのこと

移行の価値?

基本的に Unity が .NET に移行することで生じる副次的な影響として GC が変わるのであって、GC がメインではない、という点が話されていた。それでも価値を挙げるなら...

Compaction が利用できるためメモリ断片化が減る
GC コストを予測可能にできる

コンテナ環境についての簡単なメモ

Thu, 02 Apr 2026 06:58:20 GMT

コンテナ駆動原理

ホストOSのカーネルを共有しながらプロセスと同じように隔離する方式

それでは、カーネル互換性がない場合は？

当然実行されないのが普通、しかし、mac、windowなどで稼働が可能な理由は、vm layerが追加されるから。

Windowsにdocker desktopをインストールする時wsl2をインストールしろと言う理由。MSのLinux VMをインストールしないと、そのレイヤベースのコンテナが動作しにくいからだと思われる。

カーネルバージョンで問題が発生してもクラッシュが発生する可能性がある(バージョンの違いにより存在しない機能を使おうとするなど)

結論

カーネルタイプが一致し、機能サポートに問題がなく、cpuアーキテクチャが一致しなければコンテナを稼働することができません。

VM

Hypervisorを使った独立実行、カーネルを別に使う。bare-metal / hosted方式があり、私たちが使うのはだいたいホスト型、OSの上にハイパーバイザーが上がるため、パフォーマンスの損失がある。

ボリュームバインディング。

データの永続性を保つために使用、ホストマシンの特定のディレクトリをマウントする方法で処理される。Linuxネイティブではvfsに直接記録する方式であり、他のOSの場合は内部仮想ネットワークを燃やす方式で比較的遅い場合がある。

ウィンドウズでchmodを無視する理由。

WindowsではACL(Access Control List)を活用した権限管理を行い、chmodの方式を理解していない。

クラフトン・ジャングル・ゲームテックラボ修了レポート

Thu, 26 Mar 2026 18:02:12 GMT

はじめに

修了後、世俗での生活を半年ほど先延ばしにしていたため、いつ体験記を書こうか少し悩んでいた気がする。

それでも、記憶が薄れる前に記録しておいたほうがいいと思い、今こうして書き留めておく。

おそらくこの記事を読んでいる人は、今まさに悩んでいる最中だろうと思い、上部のメディア欄に説明会動画のアーカイブも添付しておいた。

入学前の悩み

まず、すぐに入学を決断することはできなかった。2025年下半期に何をしているかについて、いくつかの計画があったからだ。

それでも入学した理由は、それらの計画が概してうまくいかず、それでも選べる選択肢の中ではかなり良いと思えたからだ。

何度か面接を受けたものの、良い結果には結びつかなかったため、不足している経験をどう補うべきかという悩みが常にあった。

商用化されたリアルタイム3Dエンジンを扱った経験が全くなかったため、内部ロジックはおろか、全体的な機能についての説明すらできなかった。

そのため、AIと格闘しながら捻り出した知識を持って面接官の前に立ったものの、表面的な説明しか並べることができなかった。

今になって考えてみると、その回答を面接官が聞いてどう思ったかと思うと、非常に恥ずかしい気持ちになる。

当時、そのコースを受講することに対するリスクとして、2つほど考慮した。

先行する期がたった1期だけであり、修了前だったため、どのようなコースなのか、どのような成果が得られるのか全く見当がつかない状況だった。

また、2期は下半期に実施される予定であり、念頭に置いていたゲーム会社は概ね下半期に新卒採用や採用型インターンの募集を行うため、このような試みを諦めなければならないという点もリスクだと考えた。

天秤にかけた末、入科を決めた。今思えば、入科の説明会を聞きに行ったことがかなり影響していたようだ。

ジャングルコースの中にゲームラボもあったため、受講すべきか、受講するならどのコースを申し込むべきか悩んでいたが、説明会に参加した後、すっきりと決心がついた。

コースについて

修了して間もないため、どのような結果につながるかは分からないが、これまでのところ非常に満足のいく経験だったと思っている。

コース内でどのようなことをするのか、どのような状況に置かれるのかについては、コーチの方々の言葉を借りれば「ジャングラーたちの楽しみを半減させてしまう可能性があるため」、ここではあえて書き留めないことにする。

ただ、TechLabが簡単なコースではないことは断言できる。他の作業との並行はほぼ不可能であり、コース期間中、教室の明かりが消えることはほとんどない。

このような過程の中で、印象的な経験を通じて知識が定着し、商用リアルタイム3Dエンジンに対する理解度も高まっていくと考えていいだろう。

では、どのような人が受講すべきか？

説明会の内容を引用するのが最も直感的だろう。

これらについてもっと詳しく知りたいという人なら受講すべきだと思う。これらに対する理解度が大幅に向上する。

こちらは扱わないと言ったが、実はここでグラフィックスや開発環境の一部について疑問がある人は、テックラボの受講を検討してみる必要がある。

受講を終えれば、人によって差はあるものの、少なくともそれらについて知識を語りながら、簡単なやり取りくらいはできる人になれる。

締めくくりの所感

すべての課程を終えた今、非常にすっきりした気分であるのも事実だが、あまりにも短期間で多くの経験を積んだため、今後整理すべき点も多い。

しかし、それらをすべて自分のものとして消化し終えた時には、もう少し成長した開発者になっているだろうと思う。

AIの発展に伴う業界の人員削減の話も絶えないが、私は自分にできることをやっていこうと思う。

「成長ガスライティング」という話も最近よく出ている状況だが、確かに周囲で成長し続けた人たちに良い結果が現れているのを目の当たりにしているため、おそらくしばらくの間は原動力を維持できるだろう。

Windows / macOS 統合ターミナル環境の構築

Thu, 26 Mar 2026 12:18:01 GMT

はじめに

最近MacBook Airをアップグレードしたため、環境を再設定する必要性を感じた。

M1からM5への性能面での変化には満足しているが、以前使っていた環境を再び整えようとすると手間がかかることが分かり、この機会に全プロセスを文書化し、手軽に再設定できるよう標準化しようと思った。

[2026 Mac ターミナル完全設定 (Ghostty + Starship + AI コーディング環境)](https://blog.dnd.ac/settings-mac-terminal-2026/

)

その過程で特に印象に残った資料が、上記のリンク先のものだった。すっきりとしていて見栄えの良い環境がスクリプトとしてまとめられており、大いに参考になった。

結論から言うと、以下のような形でターミナル環境を構築することができました。

内部的には、Wezterm + Nushell + LazyVimを大枠として設定しています。

[Githubリンク](https://www.github.com/TraceofLight/global-terminal-settings

) で設定の全ガイドを確認でき、そのガイドを通じてWindows、MacOSに同一の環境を構築できるようにしています。

目標設定

この作業の目標は明確だった。

Windows / MacOSで同一のターミナル環境を使用すること
LazyVimベースのエディタと問題なく動作すること
既存の使用環境と大きく変わらないこと
tmuxのようなマルチプレクサツールを問題なく使用できること

このような目標を達成するために作業を進めてみた。

進行過程

まず、使用する技術を選定する必要があった。最近のトレンドとしては、GPUアクセラレーションによるレンダリングが可能なGUIを備えたターミナルエミュレーターが主流であり、実際にこうしたツールが注目されている理由は、高速で装飾が可能であるという点にある。前述のリンクで示したように、ターミナルを構築するにはこうした要素が必要だったため、その中からWeztermを選択することにした。

ターミナルエミュレーター

まず、クロスプラットフォームで同一のUXを提供する必要があったため、エコシステムが構築されたクロスプラットフォームのターミナルエミュレーターとしてはAlacrittyやWezterm程度があると考えた。ミニマリズムを追求するAlacrittyは拡張性に欠けると感じたため、Weztermを選択することになった。マルチプレクサーを搭載している点もメリットの一つだ。
シェル

両プラットフォームで同一の操作感を保証する必要があったため、まずはUnixコマンドが使用できる環境に統一しようと試みた。その結果、Windowsではbash、macOSではzshを使用することに初期段階で決定していた。しかし、いくつかの問題があり、最終的にはNushellベースに統一することになった。
LazyVim

実はこちらについては、すでに使用していたツールがあり、問題なくほとんどの環境で統合できたため、難しくはなかった。もともとSpaceVimを使用していたが、こちらはすでに[メンテナンスが終了した状況](https://wsdjeg.net/why-spacevim-is-archived/

)であったため、LazyVimに移行してからある程度時間が経過していたことに加え、基本的にはIDEを使用しており、補助的なツールとして利用しているため、スムーズにインストールが進んだようだ。

問題の発生

この過程でいくつかの問題が存在したが、2つの問題はいずれもNushellへの移行に関連している。

Windowsではbashが体感できるほど遅すぎる

実際、後で確認してみると、これは予見されていた結末だったようだ。Windows環境下では、POSIX式の動作をWindowsで処理するために、互換性のための処理が追加レイヤーとして挿入されることが分かった。そのため、実際にwsl2環境に移行することも検討したが、それは結局Linuxを使用することと変わらないため、除外した。

-> この問題を解決するためのツールとして、nushellを導入することになった。Unixコマンドと互換性のある部分が多い点、Rustベースで設計されておりある程度のパフォーマンスも保証されている点、MacOSでも同様の環境設定が可能である点を考慮した。
Windowsのnushellでnaviプラグインが動作しない

naviは、ターミナルコマンドのチートシートとして参照するためのプラグインである。それほど頻繁に活用するわけではないが、当該ツールの機能が全く動作しないのは困るため、いくつかの方法を検討した。結局、naviをフォークして当該問題を解決した後、新たにビルドしたプラグインを使用することで対処した。
- 原因：ユーザーのシェルが変更されても、内部ではbashベースの構文が適用されるため、nushell使用時に不具合が発生する状況
- 解決策：該当部分をシェルスクリプトによるコマンドで処理する代わりに、関連する依存関係を排除するため、wgetを使用すべき箇所でRustのHTTPクライアントを使用し、bashを使用すべき箇所でpwshを使用するなど、内部ヘルパーがbashに依存している部分を排除した
- [詳細な修正履歴](https://github.com/TraceofLight/navi/tree/fix/nushell-usability

)

結論

開発者はターミナルを使用する機会がかなり多く、環境が一つに統合されれば使い勝手が良くなるのは当然のことだ。だからこそ、クロスプラットフォームかつ同一のユーザビリティをサポートするJetBrainsのIDEにはメリットがあるのではないだろうか。同様に、ターミナルにおいても、自分が追求するものが様々な環境において統一された操作感を維持することであるならば、このような方法を試してみるのも良いと思う。

std::variant & std::visit

Mon, 28 Jul 2025 14:13:37 GMT

その他の情報

)

上記のリンクには、C++17から追加されたVariantとその追加理由について記載されています。簡単に言えば、std::optionalとして追加されるべきだった機能が、Boostで長期間使用されていたため、「これ以上引き延ばさずに、早く実装してしまおう」という議論がなされたということです。

内部構造

1. Variant

データバッファテンプレート引数として与えられた型の中で、最もサイズが大きい型を格納できる十分なサイズのメモリ領域であり、概ねUnionとして実装されている
識別子現在、データバッファにどの型のオブジェクトが格納されているかを示すインデックスまたは識別子であり、この識別子を使用することで、std::variantは型安全性を保証できる

十分なサイズのメモリ領域を持つことにより、variant型は以下のような動作が可能となる。


	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;

このようなコードを実行すると、以下のような結果が得られる。

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)

既存の値に対するデストラクタが先に呼び出され、スタック上に一時オブジェクトを生成した後、コピー生成された値を自身のメモリバッファに取り込む順序を確認できる。

したがって、最大サイズのクラスを格納するスペースを内部的にユニオンとして保持しておけば、variant型にどのような値が入ってきても問題なく使用できるようにすることができる！

2. Visit

これはライブラリによって異なるが、

関数ポインタテーブル
Switch文

大きく2つの形態に分類されるという。実際、実装方式やオーバーヘッド、コンパイラの最適化に若干の違いがあるだけで、基本的には識別子を見て、アクティブ化されたTypeに応じて適切な関数を呼び出せるように実装されていると考えてよいだろう。

[鐘萬冊] 02.問題解決戦略

Wed, 18 Dec 2024 04:27:16 GMT

問題解決のプロセス

問題を読んで理解する。
問題を身近な用語で再定義する。
どのように解くか計画を立てる。
計画を検証する。
プログラムで実装する。
どのように解決したかを振り返り、改善する方法があるか探す。

1) 問題を読んで理解する

問題を読み間違えないように、問題を積極的に読み、問題が求めていることを完全に理解しようとする努力が必要です。些細な制約条件を見逃してしまうと解けなくなる場合も多く、大会では小さなミスも許されない場合がほとんどだからだ。

2) 再定義と抽象化

自分が扱いやすい概念を使って、問題を自分の言語で解くこと、問題が要求することを直感的に理解するために必要なプロセスであり、複雑なプロセスであればあるほど重要である。問題の本質をどのような方法で再構成するかによって、同じことをするプログラムでも全く違うものになる。難しい問題を簡単に、簡単な問題を難しく解くことができるので、抽象化がプログラムが進むべき方向を決定すると見ることができる。

抽象化: 現実世界の概念を私たちが扱いやすい数学的/計算学的概念に置き換えて表現する過程。

3) 計画を立てる

問題をどのように解決するかを決定し、使用するアルゴリズムとデータ構造を選択する過程。最も重要な過程であり、問題を見てすぐに解決方法が思い浮かばない場合、この過程で最も多くの悩みを抱えることになる。

4) 計画を検証する

実装を始める前に計画を検証する段階を経なければならない。この過程で、私たちが設計したアルゴリズムがすべての場合について要求条件を正確に実行することを証明し、実行にかかる時間と使用するメモリが問題の制限内に収まることを確認しなければならない。

5) 計画を実行する

実装においては、効率性と正確性を常に考慮すること。

6) 回顧すること

すぐに直接的な影響はないが、長期的に最も大きな影響を与える段階。一度解いた問題をもう一度解くことで、より効率的なアルゴリズムを見つけたり、簡潔なコードを書くことができるようになったり、同じアルゴリズムを誘導できるより直感的な方法を見つけたりすることができます。効果的に回顧を行う方法としては、問題を解くたびに自分の経験を記録に残すことが一番有効だと思います。

アプローチ方法、決定的な気づき、誤答の原因などを記録することで、間違いを減らし、パターン化に役立つこともある。解決した他の人のコードを確認することで、思いもよらない洞察を得ることもある。

解決できなかった場合でも、一定時間が経過したら他の人のコードや解答を参照するが、必ず復習を伴うこと。

問題解決戦略

1) 直感と体系的なアプローチ

似たような問題を解いたことがあるか？
- 単純に解いた経験ではなく、原理の理解と変形が可能でなければならない。
単純な方法から始められるか？
- 無知で解けるか？から始まる最も単純なアルゴリズムを作り、最適化を通じて実装する方法も存在する。
- アルゴリズムの効率のベースラインを決めることができる。
私が問題を解く過程を数式化できるだろうか？
- 問題に与えられた例題などを解きながら定式化する
問題を単純化できないだろうか？
- 与えられた問題のもう少し簡単な変形版を先に解いてみること。
絵で描いてみることはできないだろうか？
- 幾何学的な図形の方が直感的に受け止めやすい。
数式で表現できるか？
- 平文 → 数式が問題を解決するのに役立つ可能性がある。
問題を分解できるだろうか？

より扱いやすい形に問題を変形させる方法のうち、制約条件を分解する方法 *制約条件の分解方法
後ろから考えて問題を解くことができるか？
- 代表的な例：ラダーゲーム
- 前面からすべてのルートを試すよりも、到着地から逆方向に乗ることで回数を減らすことができる。
順番を強制することができるか？

順序のない問題に順序を強制する方法 * 順序のない問題に順序を強制する方法
- 例示：1つの変数に対して変形をするか、しないか、2つの場合しか存在しない / 順序が関係ない → 順番に変形するかしないかを決めるケース
特定の形の答えだけを考慮できるのか？
- 正規化手法
- 様々な答えのうち、形は違うが結果的に同じものをグループ化し、グループの代表的なものだけを考慮する方法。

[効果的なC++] item 02

Tue, 12 Mar 2024 14:40:14 GMT

#define よりもConst, Enum, Inlineをより好む。

前処理よりコンパイラを好むという表現。

#define FOO 1.024

上記のケースは、コンパイル前に該当の文字列を置換する前処理機
上記のFOOというシンボリックの存在をコンパイラが知らないうちに削除される可能性があり、エラーにも定数で表記される可能性があるため、関連するバグが発生した場合、追跡するのに時間を浪費することになります。

const double FOO = 1.024；

解決策はマクロを定数に置き換えることです。
上記の定数はコンパイラで確実に観測でき、シンボルテーブルにも確実に入力されます。また、前処理機を通じて一括して置換された場合、そのオブジェクトのコピーが複数生成される可能性がありますが、定数の場合はコピーが複数生成されません。

[効果的なC++] item 01

Tue, 12 Mar 2024 14:01:04 GMT

C++ はマルチパラダイムのプログラミング言語

もともとはオブジェクト指向機能を追加した C から始まった
現在は手続き型・オブジェクト指向・関数型・ジェネリック・メタプログラミングまでサポートする

ジェネリックプログラミング: データ型に縛られず、ひとつの値が様々なデータ型を持てるようにすることで再利用性を最大化するプログラミングパラダイム

メタプログラミング: 自身または別のプログラムをデータとして扱い、プログラムを記述・修正すること。実行時に行うべき処理の一部をコンパイル時に行う方式を指すこともある

C++ を単一の言語ではなく言語の連合体として捉え、それぞれのルールに合わせる必要がある
- C: 多くのものは C に由来するが、C++ ではより良いアプローチを提供することが多いため、より制限的で安全な範囲で使うとよい
- オブジェクト指向 C++: クラスが存在する C++ の中心であり、オブジェクト指向設計が最も直接的に作用する領域
- Template C++: 頻繁に触れる領域ではなく、主流の C++ とほぼ相互作用しないが、TMP という強力なパラダイムを生み出した
- STL: Template ライブラリだが非常に特殊なケースであり、STL を使う際には特有の流儀があって必ずそのルールに従う必要がある
上記の下位言語間で切替が起きると、戦略を変える状況に直面することがある
単一のルールではなく、それぞれ独自のルールを持つ下位言語の集合だと理解すれば、C++ はより分かりやすくなるはず

『Effective C++』はじめに

Tue, 12 Mar 2024 12:45:19 GMT

本当に久しぶりに勉強会に関する記事を書いてみる気がする。

すべてを記事に書き出したわけではないが、以前合格体験記を書いた会社と比較して、もう少し良いだろうと思った会社で、システム開発を担当している。

社内でこの本に関する勉強会の話が出たので、勉強するついでに以前から使っていたプラットフォームを活用してみるのも良いと思い、それに伴いコツコツと記事を書いていこうと思う。この本を通じて学習することで、もっと仕事をうまくこなせるようになりたいのだが、まだ先の話のように思えて少し気が重い…。

記事は、1つの項目ごとに1つずつまとめて残していくつもりだ。ファイト！

42Seoul ラピシン口コミ

Sat, 23 Sep 2023 17:19:05 GMT

はじめに

就職活動を進めていた今年の半ば、SSAFYの修了が迫っていた時期、準備期間がさらに長引くのではないかと懸念し、企業への応募書類を作成すると同時に、様々なブートキャンプや教育プログラムについて調べる時間を設けた。

その結果、自分に最も適した教育プログラムは42Seoulだと考え、応募することにした。

理由はいくつかあったが、中でも他のブートキャンプ課程に比べて自律的な学習や時間的な柔軟性があり、比較的Low-Levelの言語を扱うという点に魅力を感じた。

ラピシン課程の進行

チェックインとラピシンへの申し込みを無事に終え、ラピシン課程を待っている間に、いくつかの企業から最終合格の通知を受けた。当初はコースを辞退しようと考えていたが、現場で活躍する42の卒業生たちの話や42の教育課程を考慮した際、十分に両立可能だと判断し、序盤は全力で取り組み、その後は仕事と並行して進めた。

42のコースについて調べた人ならある程度ご存知だろうが、入学・受講前にラピシンと呼ばれるプレコースがある。このコースはかなり過酷な部類に入るのだが…

おそらく基礎のない非専攻者ならついていくのも大変だろうし、ある程度のプログラミング知識がある非専攻者なら、一生懸命取り組めば一定の成果を上げられると思う。専攻者の場合、他の理由でカリキュラムに集中できなかったり、いじめに遭わなければ、本コースへの入学は難しくはなかっただろうと考えている。

個人的な考えだが、42で行われる教育は大学の課程と類似性がかなり高いため、むしろ非専攻者にとってより良いものになる可能性があると思う。大学ですでに十分な関連教育を受けていた専攻者の場合、42が提供する奨学金やその他の制度を除けば、他のブートキャンプに比べてメリットが相対的に乏しく見えた。

私が入学を検討した理由は、奨学金とは別に、専門知識の不足を補える優れた教育課程だと考えたからであり、その大前提は就職したからといって変わらなかったため、ラピシンコースを最後まで完走することができた。

（当然ながら、就職後は奨学金を受け取ることができない…）

結果

幸いにも良い結果を得ることができ、今回の42Seoul第10期として本コースを受講できるようになった。現在、会社で担当している職務と似た技術スタックを使用するため、双方に良い好循環が生まれるだろうと期待している。

Q & A

一般的によくあるコースに関する質問に答えてみると、

1. 基礎知識なしの非専攻者でも合格可能か？

初期の期はともかく、再挑戦が可能になったとはいえ、情報が広く出回っている現時点ではほぼ不可能だ

2. どのような人にこのコースを勧めたいか？

まだ学部在学期間が長く残っている専攻生、就職を考慮せず期間を長く取って基礎知識を築きたい非専攻者。

3. 受講前に知っておくと良いこと？

C言語の基礎的な概念や、初めて触れた時にすぐに理解しにくいポインタなど、知っていればいるほど良い。皆がShellの使い方を強調しているが、そこにGitの使い方を習得しておくようアドバイスしたい。

4. コースを進めながら、ぜひやってみてほしいことは？

個人的には、最初のRushチームのメンバーが本当に素晴らしい人たちで、最後までその方々と完走した立場から言うと、他の人との交流が必ずしも必要というわけではないが、機会があれば逃さず交流してほしい。開発者にとって、コーディングと同じくらいコミュニケーション能力も重要だ！

[簡単な用語整理] File System

Thu, 14 Sep 2023 14:36:39 GMT

はじめに

現在担当している業務でベースとなる用語についての知識が少し不足していると感じたので、ついでに知っていた用語まで追加で調べて、簡単にまとめてみる時間を持つことにした。

File Descriptor

1.Linux,Unix系システムでは 2.ProcessがFileを扱う時使う値の一種。

プロセスがファイルを開く時、カーネルがそのプロセッサのファイルディスクリプタ番号のうち、使用していない最小の値を割り当てることで、以後、システムコールを使ってファイルをアクセスする時、ディスクリプタ値を利用してファイルを参照することができます。

基本割り当てディスクリプタ

標準入力 (Standard Input)
標準出力 (Standard Output) 3.標準エラー (Standard Error)

Inode ### Inode

Index Nodeの略で、ファイルを素早く探すためのノード。

inodeはLinuxの全てのファイルにインデックスを付与し、そのファイルに対するメタデータを保有しているノードです。listコマンドで出力するメタデータをinodeが持っています。

Symbolic Link

元のファイルの inode を指し示す情報を持つファイル。

内部的にファイルへのアクセスはinode番号でアクセスします。

元のファイルに関する情報を持たない新しいinodeを持つ * 内部的にファイルアクセスはinode番号でアクセスする

cf) Hard Link

新しいinodeを持つファイルではなく、inodeだけをそのままコピーしたファイル。
本当のコピーとの違いは、data記録がコピーと違って追加的に発生しないこと。

Block Device & Character Device

データ転送方式の違いでデバイスを分類
Block: ブロックやセクタなどの定量単位でデータ転送、IO転送速度が速い。
Character: Byte単位でデータ転送、IO転送速度が多少遅くなる可能性がありますが、Application端でBuffering制御を通じた性能差が存在します。

Raw Device

ファイルシステムがset upされていないデバイス

OSカーネルによってバッファリングされず、DeviceからDataを直接転送、独自のキャッシュシステムを持つ場合に使用。
Disk IO性能が良く、CPUオーバーヘッドが少ない。
OS ファイルシステムのオーバーヘッドを回避でき、OSバッファサイズを減らすことができる。
shared diskの場合、システムに構成すると同時アクセスができないため、raw deviceとして使用。

IO Scheduler

ディスクI/Oを効率的にするために、リクエストをソート、マージし、処理順序を決定するシステムの一部。

探索時間が高く、同じ場所へのリクエストをマージすることが効果的なHDDのようなデバイスに特に有効で、SSDでは効果が半減します。
種類
- noop: no-operation, 性能の高いディスクに使用します。
- cfq (completely fair queueing)：プロセスごとにIOキューを付与し、できるだけ均等に予約、大量のプロセスが細かなIOを発生させるときに使用。
- deadline: 限界点に近いほど優先処理、遅延時間に対する最適化、I/O全てバランスよく処理し、少数のプロセスが多数のI/Oを発生させる環境に適しています。
- anticipacy: 今後発生するI/O要求の位置を予測し、近い位置に存在するI/O要求から処理する方式、伝統的なHDDで使用する構造、入出力を集めて処理する性質があり、遅延時間が長くなる可能性がある。

[BOJ 9519, CPP] 眠い

Mon, 04 Sep 2023 14:32:38 GMT

問題リンク

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

)

分類

実装、文字列、シミュレーション

説明

この問題については、最初は全探索による解法を試みた。

まず文字列の長さを測定
0 ～文字列の長さ分の数値ベクトルを割り当て
問題の条件に従って繰り返し反転
指定回数だけ反転させた場合、そのハッシュ値を利用して逆順に配置
元の姿を確認できる！

ここで最も重要な点は、問題の条件に従って繰り返し反転させることだが、繰り返し反転させた場合、必ず初期配列と同じ状態に戻る周期が存在するという点が核心である。

上記の規則を見つけた後、その部分を細分化すると

まず文字列の長さを測定
0 ～文字列の長さ分の数値ベクトルを割り当てる
- 1回目から（文字列の長さ - 1）回目まで周期をチェック
- 全体の反転回数を周期で割った回数だけ繰り返し、ハッシュを導出
指定回数だけ反転させた場合、そのハッシュ値を利用して逆順に配置
元の状態を確認できる！

このようになる。

    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 ;
		}
    }

当初は上記のように配列を直接操作する方式を採用していたが、この場合、insert以降の配列をすべて移動させる必要があり、一種のオーバーヘッドが発生するため、処理時間が若干長くなる傾向が見られた。

    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;
    }

そこで、以降は上記のような方式を用いて配列を事前に作成し、値を一つずつ挿入する方式を採用することで、最大でも配列の長さ分の時間しかかからないようにした。

解答コード

// 졸려

#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] ページ数カウント

Sat, 26 Aug 2023 15:04:16 GMT

問題リンク

BOJ 4821

分類

実装、文字列、パース

はじめに

最近入社することになって、かなり忙しい日々が続いている。会社にいること自体に負担を感じる新人なので…しばらくは適応にいっぱいになりそうだ！それでも色々な話を地道に書こうと記録しているので、近いうちに語れるはず。

最近 C を学べる良い機会を得たし、Python や Java で時間切れの壁にぶつかるたびに残念な思いをしていたので、これを機に C++ で問題演習を進めてみたいと思った。

短い期間の使用経験ではあるが、実装の多くの場面で手間がかかるとはいえ、それを速さが補ってくれる感覚をかなり受ける。慣れれば速さという長所だけを取り込めるだろうか…？楽しみだ。

解説

vector: 動的配列構造で、配列に似ているがサイズを動的に変えられ、メモリ確保が自動という大きな利点がある！

npos: no position、有効でない位置をチェックするためのインデックス値

stringstream: 文字列をストリームとして扱うための仕組みで、入出力と同じ方式で扱えるため、パースによく使われる

基本ロジックは、ページ数の上限分の範囲をカバーできる bool 配列を作り、入力で来たページ範囲をすべてチェックし、最後にカウントした値を出力するだけだ。

ただし問題で提示される数値範囲が int を超える値で与えられる可能性があるため、それを制御する変数設定が必要であり、範囲が逆順で与えられた場合はチェックしないという例外も注意する必要がある。

こういった処理を Python で解くときはとても楽だったが、C++ にしたところコードがかなり長くなってしまった…

解法コード

// ページ数え

#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);
}

雑多なShellの記録 (3)

Tue, 25 Jul 2023 18:05:52 GMT

23-07-26 誤記を修正

23-07-27 コマンドを追加

BC

Basic Calculatorの略称。POSIX標準に基づいて提供され、Unix系システムで使用できる計算機である。

特徴としては

スタックベースの構造を採用
逆ポーランド記法（Reverse Polish notation）に対応

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

TR

文字の置換、削除、圧縮などを可能にするコマンド。通常、パイプラインを通じて追加の処理と組み合わせて使用される。

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

: 長さが同じ文字列を2つ使用し、通常は文字列1の対応する文字を、文字列2の同じインデックスの文字に置き換える。

``: 長さが同じ2つの文字列を使用し、通常は文字列1の対応する文字を文字列2の同一インデックスの文字に置き換える。
-c: 2番目のセットの最後の文字が、セットに含まれていない文字をすべて置換する。
-s: 繰り返し発生するシーケンスをすべて削除し、設定された文字に置き換える。
-d: 該当する文字を削除する。
-t: コマンド実行前に、2つの文字列の長さを揃えるように切り取る処理を行う。

SED (

)

様々な編集機能をサポートするコマンド。基本的にバッファに基づいて動作するため、元のファイルは修正されるまで影響を受けない。

コマンドオプション

/[パターン]/ の形式でパターンを指定する。
g を追加すると、一致するすべてのパターンに対して処理を行う
カンマ (,) を使用して範囲を指定する。
p: すべての行を出力し、パターンに一致する場合は1回追加で出力
- -n オプションを追加: 基本出力を除外し、パターンに一致する行のみを出力
d: パターンの削除を実行
s: パターンの置換
e: 複数行編集

*n;

: 次の行

y: 置換
i: 挿入
c: 変更
a: 追加

# 약간의 응용

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

WC

Word Count

-l: ファイルの行数を確認
-c: ファイルのバイト数を確認
-m: ファイル内の文字数を確認
-w: ファイル内の単語数を確認

雑多なShellの記録 (2)

Thu, 20 Jul 2023 16:49:40 GMT

Find

ファイルを検索するコマンド。指定した場所を基準に、サブディレクトリまで全て検索して結果を出力する。出力以外にも様々な機能を提供しており、本当に活用したいのであれば正規表現について学んでみよう。

-name: 検索対象の名前に関する情報を入力するコマンドであり、正規表現による制約が可能である。

-o: or演算子と同じ機能を持つコマンド。Aという条件にaという動作を、Bという条件にbという動作を行わせたい場合は、このコマンドを使用する。

-exec: 追加のコマンドを適用できるコマンド

-delete: 見つかったファイルを削除するコマンド

-print: 見つかったファイルを出力するコマンド

同様に、その他のコマンドはここで検索すればよい。

[Find Manual](https://man7.org/linux/man-pages/man1/find.1.html

)

Echo & Printf

シェルではechoをよく使うが、echo以外にもprintfを使うことができる。正直なところ、改行文字のデフォルト値の有無くらいしか分からなかったので、この部分はChatGPTに助けを求めた！

意外にも、よく使われるechoよりもprintfの方が、より精巧な機能をサポートしているそうだ。軽く使う程度では違いを感じられないので、とりあえずこの程度の情報だけ知っておこうと思う。

雑多なShellの記録 (1)

Mon, 17 Jul 2023 17:25:08 GMT

ファイルの作成関連

*touch

: ファイルの作成

*mkdir

: フォルダの作成

*chmod

: ファイルの権限設定

*chown

: ファイルの所有者の設定

*mv

: ファイルの移動および名前の変更

ファイル情報の確認

*-rwxr-xr-x

の部分: ファイルの権限を確認する部分

先頭の一文字はファイルタイプを表す (-, d, l)
読み取り・書き込み・実行権限について、ユーザー、グループ、その他に対して3桁の形式で表記される。 2進数形式では、rが4、wが2、xが1の値を持つため、rwx

の値は7に、-xr

は4に変換できる。

chmod 744 Slack.lnk

このような形式のコマンドで権限設定が可能である。 3. リンク数（1と書かれている部分） 4. 所有者（空白の部分）と所有グループに関する情報（197609） 5. ファイルサイズ 6. 最終更新日時に関する情報 7. ファイル名

ssh-keygen

Secure Shellの公開鍵によるGit認証に使用されるケースが多い
WindowsおよびLinuxのパッケージに含まれている
鍵を生成すると、keyファイルと.pub

ファイルが生成されるが、.pubファイルの内容をサーバーに提供し、鍵と錠前の形式で使用

シェルでファイルの容量を調整する方法

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

既存のファイルや新規作成するファイルにおいて、このコマンドを使用してファイルのサイズを調整できる。

ファイルの最終更新日時を変更する

touch -t 2301011234 timefile.sh

touchの応用として、2023年1月1日12時34分に最終更新が行われたものとして、ファイルの最終更新日時を変更できるコマンド

ハードリンク & シンボリックリンク

シンボリックリンク (ソフトリンク)

Windowsのショートカットと同様に、特定のフォルダに存在する元のファイルを利用できるようにするリンクであり、元ファイルが削除された場合は機能しない

ハードリンク

シンボリックリンクとは異なり、原本をコピーして複製を作成するという違いがあり、原本が削除された場合、シンボリックリンクは使用できなくなるが、ハードリンクの場合は結局同じファイルであるため、引き続き使用可能である。リンク数に影響するリンク。

コード

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

削除コマンドは ``rm`

` であり、ファイルを削除するのと同じように解除できる

Diff & Patch

diff a b > difference.patch

diff

は、2つのファイルを行単位で比較するコマンドであり、patch

は、diffなどで確認した比較内容に基づいてファイルを修正できるコマンドである。

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

上記のような形式で、既存のファイルに対してdiffで判定された内容をそのまま適用・解除することができる。

2023年アシアナIDT 下半期採用選考の体験談

Sat, 15 Jul 2023 09:23:14 GMT

はじめに

開発職も経済の影響を受けているせいか、採用選考の数や採用人数が昨年より大幅に減少した。結局のところ、チャンスが訪れた時にそれを掴める人が勝者となるため、だからこそ、より一層着実に取り組まなければならないと考えている。

書類選考 & 適性検査

他社と同様、書類選考で特筆すべき点はなかったが、金融業界の採用と同様に適性検査を実施しなければならない点が特徴的だった。

正常にすべて回答したと思っていたが、（注意）と表示されていて不安ではあったものの、カメラやマイクなどに異常はなかったためそのまま提出し、

問題なく書類選考を通過することができた。余裕があれば、適性検査をもう一度確認していたと思う。

コーディングテスト

難易度も問題のタイプも、どちらも金融業界のコーディングテストを思い出した。全体的に平易な難易度で、SQLまで似たような形式だったと思う。

結果は合格、アシアナIDTの面接会場に行く機会を得た！

最終面接

ビルの入り口で面接者の訪問証を受け取り、向かった。準備中に読んだ他の体験談と同様に、ディスカッション面接と人物面接が行われた。

ディスカッション面接については、何か大きな役割を果たすことを期待したというよりは、コミュニケーションに問題がある人を選別するプロセスだと考えた。

人物面接では、書類やコーディングテストの結果などを総合した内容に基づいて質問を受けた。

入社志願者の中でこのような人はほとんどいないだろうが、会社について十分に調べずに来た人は、質問に難しさを感じるかもしれないと思った。
面接官が応募者に意見を求めようとする様子から、会社の発展方向について真剣に考えているのだと感じた。

最終結果

面接では普段よりうまく答えられたと思っていたが、それなりに高い競争率にもかかわらず合格することができた！

所感

IT業界に入るときに聞く話があまりにも多いため、SI/SMに対して漠然とした恐怖心を抱くケースが多く、実際私もそうだった。

~~ハイパーリアリズム~~

それでも、国内IT業界の大部分はITサービスではなくSI/SMが中心であり、これを軽視すれば合理的とは言えない選択をしてしまう可能性もあると思う。

就職市場が以前とは異なるだけに、あまりにも狭い目標に向かって進むよりも、今できる最善の選択肢は何かを考える感覚が必要な時期だと考えており、これを心に留めておけば良い結果を得られるだろうと思う！

[面接質問】オブジェクト指向プログラミングとは？

Wed, 12 Jul 2023 07:28:03 GMT

はじめに

昨日、某企業の面接を進めながら、オブジェクト指向プログラミングについて答えなければならない場面があったのですが、明らかに知っているつもりで整理していたにもかかわらず、いざ答えようとすると、ぎこちなく話してしまったことがありました。

おかげで弱い部分を指摘できたと思い、再度整理する時間を取ってみることにしました！

オブジェクトとは？

一般的な定義から説明すると以下のようになります。

一般論: 実際に存在するものコンピュータサイエンス：クラスに定義された内容でメモリに生成されたもの。

オブジェクト指向言語で定義されているものは以下の通りです。

Java: クラスのインスタンスまたは配列 Python: 属性値や振る舞いを持つデータ

Javaのクラスはインスタンスではないが、Pythonのクラスはインスタンスである。

オブジェクト指向プログラミング

オブジェクトの役割と関係を定義して相互作用を通じてプログラムを構築すること。

このように定義することができます。

オブジェクト指向言語の特徴

抽象化

オブジェクト間の共通の特徴を導き出すことができる。
クラスを定義する部分がこれに該当

多形性

少し違う方法で動作する関数に対して同じように呼び出すことができます。
同じコマンドに対して接続されたオブジェクトに解釈を転嫁する方式
Override(内部ソースのオーバーライド), Overload(パラメータによって同じ名前の他の関数を呼び出す)

カプセル化

実装した部分を外部に公開せずに隠すことができます。
外部とのコミュニケーションが必要な場合、メソッドを通じて情報をやり取りする。

継承

あるクラスが持っている特徴を他のクラスが受け継ぐこと。
既に作成されたクラスに加え、新しいクラスを生成することができる。

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

Fri, 07 Jul 2023 06:49:25 GMT

問題リンク

BOJ 11689

分類

数学、整数論、オイラー・ピー関数

説明

最近、Baekjoonの問題を解く際、真の実力を高めるためには問題の分類を気にせず解くべきだと考え、実践している。しかし、今回取り上げるこの問題のようなものに出くわすと、かなり頭を悩ませることになる。

この問題の場合、最初に¹0¹²までの数字を1秒以内にチェックできなければならないため、少なくともO(N)レベル以下に抑えなければならないとは考えていた。互いに素の判定であれば、通常は素因数分解を行い、重複する数字がなければよいと考えていたため、以下のコードを利用していた。

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)

しかし、このコードを基にした場合、時間計算量を満たすことができなかった。結局、悩んだ末にタグを確認することに決め、오일러 피 함수という新しい友人と出会うことになった。

調べてみると、これはまさにこの問題そのものの関数であり、

> φ(n) = {n以下の自然数のうち、nと互いに素な自然数の個数}

このように実装することができた。


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

2から順に進めていく。
割り切れる数があるなら、割り切れる限り割り切る。（素因数分解）
その数の倍数は互いに素になり得ないため、結果の数から引く。
最後に残った数があるなら、その数は素数であり、その素数の倍数も互いに素になり得ないため、結果の数から引く。

ここで少し難しかったのがこの部分だった。

> result -= result // checker

なぜnumber // checkerを削除するのではなく、resultから割り出した値を削除するのか疑問だったが、実は当然のことだった。nの倍数を削除し、mの倍数もその数だけ削除すれば、結果的にn * mの倍数は2回削除されることになる！

このように重複して処理される数字を処理するために、すでに一度除外された数から、その数字の倍数分だけを引き算することになるのだと言えるだろう。

いずれにせよ、この解法を理解した瞬間、非常に簡単な問題になる。整数論の問題にはこういう傾向があるようで、学ぶ時は良いが、いざ最初に取り組む時はいつも難しくて少し不便だ…。

解答コード

# 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))

[面接の質問] 依存性注入

Thu, 06 Jul 2023 11:46:58 GMT

依存性注入

依存性：あるオブジェクトが別のオブジェクトを利用している関係 → 依存性注入：その関係を設定すること

依存性注入が必要な理由？

public class Product {

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

}

このように例を見てみると、ProductというクラスがAppleのコンストラクタを使用している場合、別途注入を受けずにそのまま使用している。 Productを使用する場合、Appleがそのまま付随してくる依存関係として理解できる。こうなると、オブジェクト同士のつながりではなく、クラス間の関係だと見なすことができる。

また、もし私がOrange

というクラスを追加で使用したい場合、Productクラスのコンストラクタに直接変更を加える必要があり、これは柔軟性が低いと言える。

結論として、依存性注入が必要な理由を挙げると

クラス間の強い結合 + コードの柔軟性の低下

このような問題を依存性注入によって解決できるため、必要であると言えるだろう！

解決策の適用

public interface Fruit {

}

public class Apple implements Fruit {

}

public class Product {

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

各クラスが独立性を確保していることが確認できる。

新しいFruitを追加してもProductは変わらない
クラス間の関係ではなく、オブジェクト間の関係が形成される

[面接質問] Java Stack & Heapの構造について

Sun, 02 Jul 2023 17:19:40 GMT

Java のメモリ構造

JVMの構造と原理の内容を参考にしてください

アプリケーション実行のために構築したJava Runtime Data Areaがメモリに位置することになる。

PC Register, Native Method Stack, Method領域は全てのスレッドが共有します。
StackとHeap領域だけがスレッド固有の領域として持つことになります。

Heap の構造

Eden → Survivor → Old

上記のような形でオブジェクトが移動するのですが、基本的には生成順で理解すればいいと思います。

Garbage Collectorの役割

Eden: Javaオブジェクトが生成されるとすぐに保存される空間。
Survivor & Old: 参照度によってオブジェクトが移動された空間。
Mark and Sweep アルゴリズムを使用します。

Minor Garbage Collector

EdenとSurvivor領域(Young Generation)のメモリが許容値を超えた場合、オブジェクトの参照に基づいて領域を移動させる役割。

Major Garbage Collector

Old領域(Tenured Generation)のメモリが許容値を超えた場合、参照されていないオブジェクトを全て削除してメモリを回収する役割。

削除の過程でガベージコレクタを実行するスレッドを除いた残りのスレッドを全て停止('Stop-The-World')。

Stackの構造

基本データ型 + 地域変数 + パラメーター

ここで、パラメータの場合、オブジェクトのアドレス値を持ってHeap領域のオブジェクトを参照する形で使用されます。

→ パラメータが他のオブジェクトを参照する場合、アドレス値が変わるだけで、Heapに保存されたオブジェクトがすぐに消えることはありません！ (Major GCが実行されるまでHold)

参考

コーディングファクトリーの記事

[BOJ 27231, Python] 2023年が楽しみな理由

Fri, 30 Jun 2023 10:32:49 GMT

問題リンク

BOJ 27231

分類

ブルートフォースアルゴリズム、バックトラッキング

説明

最近、以前解けなかった問題が何とか解けるようになってきたのを見ると、実力が向上したと感じて気分が良い。

この問題の場合も、最後の挑戦は5ヶ月前に大会で出題された時だが、その間にも解決の兆しが見えない解法を試行錯誤したことが何度かあった。

最後の挑戦が何度もあった理由は、たった一つの条件が欠けていたからだが、この条件が抜けているだけでなぜタイムリミットオーバーになってしまうのか、その理由はまだよく分からない。 ~~後で補足できる理由ならいいのだが。~~ → 下の内容を整理しているうちに思い出した。やはりブログの整理は最高だ！

問題の解法アプローチを紹介すると

+ 記号を入れる座標をビットマスクを活用して全数チェック
集合、あるいは重複を許さないリストに入れてソート
累乗のサイズを徐々に増やしながら、最終的に最初に与えられた数（どんなに細かく分割してもこの数より大きくなることはないため）まで存在する数字の個数をカウント

そしてここで問題が発生した。

0、1で構成された数の場合、単一の数字に分割すると、いくら累乗しても値が変わらないため、Hello, BOJ 2023!を出力する必要があるが、私は単純に1の場合だけを除外していた。

いくら二乗しても数値が増加しなかったため、whileループに引っかかり、タイムリミットオーバーとなってしまったのだ！その部分を確認するために、単一の数字について2を超えるかどうかをチェックし、2を超える項がない場合は無条件にHello, BOJ 2023!を出力するようにすることで、エッジケースを処理し、正解を得ることができた。

解答コード

# 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] 二分木

Wed, 28 Jun 2023 12:58:52 GMT

問題リンク

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

)

カテゴリ

動的計画法、木、木における動的計画法

説明

私のような場合は、すぐに解けない問題であっても、かなり長い間寝かせてじっくり考えるタイプだ！

そうしているうちに、このように試してみたが正解しなかった問題や、コンテストの問題と共に大掛かりな試みをしたものの解けなかった問題が溜まっていくことになる。

これらを片付けるために、たまに問題を読み返しながらじっくり考えるのだが、今日ついにこの記事で問題の解決法を知ることができてとても嬉しい！

なんと最初の試みから8ヶ月もかかった問題で、直前の試みから何度か手を出してみたことはあったが、適切な案が浮かばず解決できなかった。


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

本来は、上記のような再帰関数の形で前走順回を変形させた形で、訪問するノードを出力した後、スタックのようなデータ構造に入れて各辺をあれこれ処理する方式を考えていた。

しかし、考えてみると、結果的に比較対象を同じ親ノードから出る辺に限定すれば、2つずつ比較した値のうち大きい方を着実に上位の辺に合算しながら処理する場合、きれいに計算できることが分かった！

後で解いて分類を見てみると、この種の問題はツリーDPと呼ばれるらしい。確かにDPのそれとは非常に似ていると実感した。

解答コード

# 이진 트리

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)

最初に考えていた方式よりも、コードの長さも時間計算量もすっきりした形になった。こうして見ると、確かにボトムアップ（Bottom-Up）の形式をとっている。

[余談】IaaS、PaaS、SaaSとは？

Mon, 26 Jun 2023 05:21:36 GMT

共通で書かれた'aaS'の意味は？

'As a Service'の略

第3者がクラウドコンピューティングサービスを提供すること！

###違いは？

サービスとして提供するものがインフラ、プラットフォーム、ソフトウェアで異なる。 → 管理レベルの違いが発生

1. IaaS

オンプレミスインフラストラクチャから発展したタイプ
インフラサービスをクラウドで提供
プロバイダがネットワーク、サーバー、仮想化、ストレージの管理とアクセスを担当。
AWS、Azure、GCPのような業者がこれに該当します。

2. PaaS

IaaSより担当する領域が広くなる。
ユーザーが独自のアプリケーションを開発、実行、管理することができる。
ビルドとデプロイメントのための環境まで提供

3. SaaS

すべてのアプリケーションをプロバイダーが管理
プロバイダーがソフトウェアのメンテナンス、アップグレード、セキュリティを完全に管理します。

注意事項

IaaS vs. PaaS vs. SaaS

[面接の質問] コネクションプールとは？ (Feat. ChatGPT)

Sun, 25 Jun 2023 17:05:44 GMT

DBコネクションプールとは？

> DBに事前に接続しておいたオブジェクトをプールに保存 > クライアントからのリクエスト時に接続を貸し出す > 処理が終了したら接続を返却し、プールに再び保存

あらかじめ接続しておき、必要な時に取り出して使う形式の接続オブジェクトだと理解できるだろう。

使用する理由？

Java Springの場合、

DBに直接接続して処理する方式を使用する場合
毎回JDBCドライバーをロードし、接続オブジェクトを取得する必要がある
リクエストのたびにドライバーのロード、オブジェクトの生成、接続が繰り返し行われる

→ 非常に非効率的であるため、このような問題を解決するためにConnection Poolを使用する。

+ その他のフレームワークでも使用されているという。

特徴

WAS実行時にConnectionオブジェクトをプールに事前に生成
HTTPリクエストに応じてオブジェクトを取得・使用・返却
接続リクエストごとに接続や生成にかかる時間が消費されない → 接続負荷を軽減する効果がある

> - 同時接続者数がプールのオブジェクト数より多い場合は？ > → 事前に生成された接続オブジェクトが不足すると、返却されるまで順番待ちとなる

> プールが大きくなるほど、メモリ消費量↑ 待機時間↓

[雑記] main関数の位置について

Sun, 18 Jun 2023 11:50:50 GMT

はじめに

学んだことを簡単にまとめるために、「자투리

」というカテゴリーを使ってみることにした！

main関数を一番上に

[CS50](https://www.youtube.com/live/ywg7cW0Txs4?feature=share

)の講義を受けていて気づいたことだが、私のような場合、コードを通常このように書く傾向がある。


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

例を挙げると、必要な関数の詳細な定義をすべて最初に並べておき、その後でmain関数を追加で記述する方式だ。

しかし、確かに一番最初に main 関数が来ている方が、コードを読む際に他の人にとって分かりやすくなるのではないかと思った。


def main():
	example()
    this_function()

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

コード全体の構成を示す main 関数を上に移動し、詳細な定義をその後に記述することで、コードの機能をより明確に示せるようにしたい。

平凡な、SSAFY第8期修了レポート

Fri, 16 Jun 2023 17:28:37 GMT

はじめに

ついにサムスン青年SWアカデミー、SSAFY第8期の1年間の旅路が終わる瞬間が訪れた。多くの出来事があったが、息つく間もなく駆け抜けてきたため、今になって、今こそ一度書き留めてみようと思う。SSAFYの体験記を見ると、その大半は「優秀」以上の評価で修了し、賞状を1、2枚は受賞していることがわかるが……

この体験記は受賞多数！「優秀なSSAFY型人材！」といったような凄腕の人物ではなく、どこかにいそうな、それ以外のSSAFY入学生の物語だと考えていただければと思う。また、今後SSAFYの課程を履修される方々にも役立つ経験談になればと願いながら、書き記してみる。

入学

通常、非専攻者にとっては高いとされているSSAFYの壁を、どうにかして突破した。自己紹介書は合格、面接では不合格の通知を受けた……が、その稀な「非専攻者追加合格」の通知を受け、ソウルキャンパスに入学することになった。入学直後に行われるスタートキャンプには、経験した者だけが知る苦労があるというが、本当に本当にギリギリの合格者だったため、スタートキャンプを省略することができた。

SSAFYに入学すると、自分の名札が渡されるのだが、その名札でさえ、他の初期合格者の名前の上に私の名前がフルネームで貼られていた…後で何度も剥がれそうになったので、テープで固定したのが上の写真だ。

今思えば、むしろこの名札のおかげで、もう少し頑張ろうという気持ちになったと思う。得られた機会が本当に貴重であることを常に実感し、モチベーションを維持しながら通うことができたようだ！

1学期、Pythonトラック

1学期にはJavaトラックとPythonトラックがあり、Javaを学ぶのが良いことは知っていたものの、Pythonトラックを受講することになった。1学期に学んだことはいろいろあったが……

いざ2学期に入ると、実際にしっかり学んで活用できたのは、アルゴリズム、Git、Pythonくらいだったと思う。これさえも、Pythonやアルゴリズムはプロジェクトで使うというより、コーディングテストで活用する方が圧倒的に多いレベルで……

（フロントエンドは学ぶが、ほとんどがReactの復習なので存在感もない）

それでもトラックに入れば、SSAFYらしく、ほぼ全員が情熱を持って学んでいく姿が見られる。クラス内で互いに励まし合いながら勉強会を作ったり、カフェで一緒に勉強したりして過ごしたと思う。

私の場合、プログラミングといえば大学の教養科目で少し触れた程度が全てだったので、ほぼゼロベースであり、全てを完璧にこなすことはできないと考え、選択と集中が必要だと判断した。そこで、まずは採用プロセスを確認し、着実に突破できるよう努力しようと決めた。

書類選考 → コーディングテスト → 人物面接 → 技術面接 → 採用

ほとんどの企業がこの範囲から外れないことを確認した。結果的に**「コーディングテストを突破できなければ未来はない」**と考え、これがアルゴリズムに全力を注ぐ「テックツリー」の始まりとなったのだが…

アルゴリズム能力の向上のために勉強会まで作るほど多くの時間を投資したが、結局プラチナ5の達成を最後に事実上燃え尽きてしまった。あの頃からサムスンのソフトウェア能力評価B型を突破するためにJava言語も合間を縫って勉強しながら鍛えたが、残念ながら未取得で終わることになった。体験記は[こちら](/blog/b

)にあり、B型を取得できればSSAFYが提供する様々な特典、体験、連携などにおいて優先順位が上がるため、取得できるなら必ず取得するようにしましょう！

(しかし感覚を失わないために、地道に低レベルの問題でも解き続けることは重要だと考え、コツコツと解き続けた)

あれこれ苦労し、ほぼ毎週行われる理論および実技試験を通過する日々を経て、貫通プロジェクトに到達した。今思えば、ここでは2学期に挑む7週間のプロジェクトを、圧倒的に少ない人員と時間でやり遂げなければならないレベルが求められていた！どこかで素晴らしいコードをうまく持ってきて応用するレベルを見られたとは思っているが、それでも結局、他人ができなかったことを成し遂げたチームが賞を勝ち取ったようだ。（例えば、デプロイといったこと）

2学期、プロジェクトの連続だった日々

2学期の課程では、ずっとプロジェクトに取り組むことになるが、これがSSAFYで最も重要な部分だと考えている。

今考えてみると、1学期の頃は企業に応募したくても、「何か経験はありますか？」と聞かれても答えることがなく、自己紹介書や面接でアピールできる部分が限られていた。しかし、2学期が進むにつれて、結果に関わらず自分がプロジェクトに誠実に取り組んだのであれば、「こういう部分を担当し、こういう点で困難を感じましたが、こういう方法で改善しました」といった話をできるようになるのだ！

テーマがこのように決まっているように見えるが、特化プロジェクトでない限り、テーマに縛られることなく、大抵はチームが望むプロジェクトを進めることができた。私の場合、アプリ開発プロジェクトを2回、モバイル仕様のWeb開発を1回行いました。ポジションに関しては、人によって2学期にやりたいことが異なるかもしれませんが、私はすべてのポジションを経験してみたかったので、バックエンド1回、フロントエンド1回、アプリ1回の経験を持つことになりました。

Pythonトラックに入学すると、大抵はJavaとは縁が遠くなるが、2学期のプロジェクトの99%がSpring Bootを使用するため、否応なくフロントエンドに向かうことになり、これが自身のポジションを固定することにつながる。したがって、バックエンドを希望するという確固たる意志があるなら、Pythonトラックの受講生は別途Javaを並行して学ぶのが良い。筆者もJavaの講義を別途受講し、バックエンドのポジションへの道筋を常に残しておこうとした結果、バックエンドのポジションも1回経験することができた。

就職活動と様々な面接

私がこのように1学期から2学期にかけて、何かをアピールできる夢のような時間を過ごしている間、少数の準備万端な人々は着実に企業とのコンタクトを試み、その結果、その過程でいわゆる「サタル」、SSAFYからの脱出を果たす栄光に浴することになった。そんな人々を見て最初に思ったのは、「まだ準備が足りないから… プロジェクトが全部終わってからでも遅くないだろう」だったが、結果的に2学期を並行して進めていると、自然と脱出する多くの先駆者たちを見て、準備を進めることになる。

誰かが社員証を受け取っている間に、2学期の修了証を受け取って修了する自分の姿が物足りなく感じるかもしれないので、地道に挑戦してみよう。筆者は多くの企業に応募し、結果的に手にしたのは2学期の修了証だったが、それでも後悔のない応募だったと思う。

SSAFYの様々な特典と積み重ねた技術を持ってコーディングテスト、書類選考を通過すれば、面接が残っている。人物面接と技術面接の両方に実際に臨んでみるまでは、どこが不足しているのか分からない場合が多いため、教育期間中に経験できれば本当に本当に良いと思う。

面接は、実際に経験すればするほど確実に実力が伸びる。実際に足りない部分を補っていく能力的な面もそうだが、面接官への対応姿勢などは、その状況や緊張感がなければ経験できないと思うため、自分の能力が許す限り、実際に志望するレベルより低い企業の面接であっても、コツコツと受験し、本当に志望する企業でより良い結果を得られるようにしよう！

修了のその先には…

それで、SSAFYが終わったらこれから何をするの？

この質問について長い間悩んできたし、今も答えを探している最中だ。基本的には、取り組んできたプロジェクトについてじっくり振り返る時間を持ちつつ、学んできた内容の整理もしたいし、やはり就職は早くしたい状況なので…

結局、すべてを着実に進めていくことになるだろうという気がしている。これまで積み重ねてきた勉強が無駄になるわけではないので、その上にさらに積み上げていくのが最善だと信じている。私のSSAFY第8期の旅はここで幕を閉じるが、開発者としてのキャリアがここで終わるわけではない！もっと良い日が待っていると信じて、地道に努力していきたい。

2023 LG CNS上半期採用選考の口コミ

Fri, 16 Jun 2023 08:27:19 GMT

はじめに

今回の上半期にLG CNSの新入社員採用選考に応募し、最終面接まで終了した。結論から言えば、残念ながら良い結果を得ることができなかった。しかし、失敗を覆い隠すのではなく、私がどのような部分が不足していたかを記録して、次回はもっとうまくやればいいという考えがあるので、このように残しておきます。これから採用に参加する人の参考になれば幸いです。

書類選考

書類選考で特異な部分はあまりなかったようだ。特異点といえば、他の企業に比べて自己紹介書の分量が少なかったことくらい？ただ、書類で不合格になったケースが周りにあって、意外に変別要素があったようだ。合格していれば、その後、コーディングテストの手続きを進めることができた。

コーディングテスト

全体的に難易度はそれほど難しくはなかったと思う。シルバー~ゴールド5レベルの問題をランダムに解くことができれば、十分にオールソーが可能だったと思う。敢えて方向性を決めるなら、創造的なアルゴリズムを要求するより、現場でどんな問題が出ても対応できる練習が役に立ったと思う。

@@@ さん

一定レベル以上解決していれば、面接に進むことができ、無事に合格することができた。

1次面接 ### 1次面接

コーディングテストに合格し、1次面接の案内を受けることができました。基本的にビデオ面接で行われ、自己紹介書に書いてあった質問の内容や一般的な面接の質問を中心に聞かれたようです。面接官の方のお話がぼんやりと記憶に残っていますが、新入社員に大きな期待を抱いて能力に対する評価はしないとのことでした。その後も何か言われましたが...緊張していたので記憶から削除された状態です。どうやら、能力をあまり見ないのであれば、人柄や自己紹介内容の検証、誠実さ、カルチャーフィットなどを中心に見ているのではないかと思います！

余談ですが、コーディングテストで良い結果を出した場合、面接官からテストについてちょっとした褒め言葉をもらえることもあります。もしかしたらあるかもしれない反例やエッジケースについて少し気を使ったのですが、結果について確認されたようで、気分が良かったです。

@@@ さん

面接が不慣れで、すごくガチガチでぎこちなく見て、落ちてしまった...と思っていたのですが、2次面接まで行く機会を得ることができました...。やっぱり綿棒は科学だ。

2次面接

他の企業の選考と同様に、実際に入社することになった場合、部署の決定権を持つ方が直接面接に来るようです。最初に自己紹介までしていただいたのですが、緊張しすぎて覚えていないのが残念です。でも、1次面接と同じような感じだと思った瞬間、たまに技術的な部分に突っ込まれ、喋りまくっていたのを覚えています。最後に、もし入社することになったら、どんな姿勢で業務に取り組めば良い結果が得られるか聞いてみたところ、笑顔でいろいろと良いことを言ってくださったのが印象に残っています。そして......。

@ さん

受けた結果は正直、心が痛かった。しかし、面接を終えて考えてみると、残念な部分が多かったので、納得できない結果ではありませんでした。受けられた技術的な質問や、応募した会社に対する認知度など、あまりに不十分な回答をした面があり、面接官から見て、印象的に採用したいと思うような強みがなかったと思います。

感想

@@ さん

どうやら上半期の採用選考の中で最も合格に近かった企業なので、残念でならないわけにはいきません。しかし、今受け取った成績表が今後の方向性を教えてくれると思い、実際に不足していた部分を補完し続けるために努力しています。

この経験を足がかりにして、より良い姿になることを願っています。後で私を採用しなかったことを後悔させることができれば、それこそ良い結果ではないでしょうか。次のCNS採用の時は、**'私が企業を選ぶことができる企業'の立場より'私が企業を選ぶことができる人'**になれるようにもっと努力しなければなりません。

[面接の質問】JVMの構造と原則

Thu, 15 Jun 2023 16:30:41 GMT

23-06-27 未記入内容の補充 > 23-06-27 23-07-01 内容の補充及び作成完了

Java の概要

1. Javaの開発哲学

Write Once, Run Anywhere

プラットフォームと独立した言語を志向
同じ言語で組まれたコードをどのようなオペレーティングシステムでも実行できることに焦点を当てて開発された（一種のクロスプラットフォーム）。

2. JDK

Java Development Kit Java開発ツールであり、JRE、JVMを全て含む。基本的にJavaで作ったプログラムだけを実行すればいいユーザーと違って、開発者はJDKをインストールしなければならない。JDKにはCompilerが含まれています。
Java Runtime Environment Java実行環境としてJava Class Library, Java Class Loader, JVMを含んでいます。クラスローダーとライブラリを介して作成されたJavaコードをライブラリと組み合わせてJVMで駆動できるようにする。
Java Virtual Machine

JVM とは？

Java Virtual Machine、Java仮想マシン。
Javaプログラム実行環境を整えてくれるソフトウェア

Java Code → Compiler → 機械語

アプリケーション実行のためのメモリを割り当てられ、Java Runtime Data Areaを構築する。

Runtime Data Area

Heap領域
Method 領域

上の2つの領域は全てのThreadが共有

PC Register
Native Method Stack
Stack領域

上記の3つの領域はThreadごとに開始時に生成され、終了時に消滅します。

各領域の詳細

1. Heap

クラスのインスタンス、配列が保存される空間。
動的なメモリ管理システム'Garbage Collection'

2. Method

クラス、インターフェースの構造を保存する空間

3. Stack

Cのスタック構造と似ており、地域変数や関数の実行結果を保存する。
関数の呼び出しとリターンを担当し、Stack Frameを持つ。
Stack Frameとは？

各関数ごとに関数の呼び出し情報が含まれている区分された空間。 FrameはLIFO方式で処理される余裕空間がない時にフレームが追加される場合 → Stack Overflow発生プロローグ、エピローグを活用したポインタ方式でスタック復帰位置確認

4. Native Method Stack

C, CPPで作成されたメソッドの実行スタック
コード実行時にNative Method Stackが割り当てられます。
StackOverflowErrorやOutOfMemoryErrorが発生する可能性がある。
スタックのサイズを動的に調整することができます。

5. PC Register

各スレッドごとにPC Registerを保有
スレッドが現在割り当てられている命令を実行する時、命令のアドレスを記録します。
命令ごとに値を安定的に変動させて指し示す値を実行するようにする。

参考

JVM Document gorainiさんのブログ sgwon1996さんのvelog

[面接質問】DB Indexとは？

Tue, 13 Jun 2023 15:20:25 GMT

データベーステーブルの検索速度を向上させるためのデータ構造

インデックス使用のメリット

テーブル参照速度の向上によるパフォーマンス改善
システム負荷を減らせる

インデックス使用のデメリット

DB インデックス用に追加の保存領域が必要になる
DB 管理のための追加作業とオーバーヘッドが発生する

インデックスの管理

インデックスは常に最新の整列状態を保ってこそ目的の値を素早く探索できるため、データが頻繁に更新される属性にインデックスを張ると、逆にオーバーヘッドによる性能低下を招くことがある。

INSERT: 挿入時に挿入されたデータのインデックスを追加
DELETE: 削除されたデータのインデックスを「未使用」として処理する
UPDATE: 既存インデックスを未使用化 + 更新後データのインデックスを追加

使用するデータ構造

B+ Tree

B Tree の改良版

リーフノードのみにデータを格納

リーフノード同士は連結リストの形を持つ

Hash Table

Key - Value のペアでデータを格納非常に短時間でデータを探索できる不等号比較に不向きなのであまり使わない (整列されないため)

インデックスの分類

1. Key による分類

主インデックス: 主キーを含む (Key の順序 = レコードの順序)
補助インデックス: 主キーを含まない (Key の順序 != レコードの順序)

2. ファイル組織による分類

集中インデックス
非集中インデックス

3. データ範囲による分類

密インデックス
疎インデックス

参考

brunchstory by Nathan

[1Day-1CS]各層を処理するための機器

Mon, 05 Jun 2023 15:08:16 GMT

2023-06-18 内容の統一性のために前の記事の内容を統合する

アプリケーションレイヤーを処理する機器

L7スイッチ: ロードバランサーとも呼ばれ、サーバーの負荷を分散する機器

スイッチ: 複数の機器を接続し、データ通信を仲介し、接続されたポートにのみ電気信号を送り、データを転送する通信ネットワーク機器
システム処理可能なトラフィックの増加を目指す。
URL、サーバー、キャッシュ、Cookieなどに基づいてトラフィックを分散させる
不必要な外部データを除外するフィルタリング機能も保有。
トラフィックの監視が可能

= Health Checkを通じて障害が発生したサーバーをトラフィック分散対象から除外する。

L4 スイッチと L7 スイッチの違い

L4 スイッチは伝送層を処理する機器で、ストリーミング関連サービスでは使用できません。
メッセージベースの認識不可、IP＆Portベースのトラフィックの分散
クラウドサービスでL7スイッチのロードバランシングはALB(Application Load Balancer)コンポーネントで、L4スイッチを利用したロードバランシングはNLB(Network Load Balancer)コンポーネントで行います。

Health Check

送信周期と再送回数などを設定し、繰り返しサーバーに要求を送ること。

サーバーに負荷がかからない程度に適切なもの。
様々な方法でリクエストを送信し、正常に処理された場合、正常なサーバーと判断する。

ロードバランサーを活用したサーバーの冗長化

2台以上のサーバーを基盤に仮想IPを提供し、これを基盤に安定的なサービスを提供します。

特定のサーバーでエラーが発生してもサービスが継続されなければならないため、サーバーの冗長化が必要です。

インターネット層を処理する機器

ルーター: 複数のネットワークを接続、分割、区分してくれる役割。 L3スイッチ：L2スイッチ+ルーター

データリンク層を処理する機器

L2スイッチ: デバイスのMacアドレスを管理し、パケットを転送する役割ブリッジ：2つの近距離接続網を相互接続できるようにする通信網接続装置。

物理層を処理する機器

NIC (Network Interface Card)：LANカード、固有の識別Macアドレスがここに存在する。リピータ: 受信した信号を増幅して、他の方に転送する装置 AP: パケットをコピーする機器、有線LANを接続して無線ネットワークに接続するための装置。

[面接の質問] フレームワークとライブラリ（Feat. ChatGPT）

Sat, 03 Jun 2023 13:45:20 GMT

はじめに

今回、面接で初めてこの質問に直面したのだが、正直なところ知っていると思っていた内容だったにもかかわらず、明確に答えられず、もごもごとしてしまい、結局は質問の意図とずれた回答をしてしまった……。そこで、次に同じ質問をされた時にはそうならないようにと、もう少ししっかりと理解しておこうと思い、内容をまとめてみた！

ライブラリ

開発時に共通して使用できる機能をモジュール化したもので、特定の機能を実行するように作成されたプログラム

フレームワーク

様々な機能を持つクラスやライブラリが、特定の結果物を実装するために組み合わされた形態

ChatGPTの回答

上記の定義は、いくつかの記事を読んで、個人的に正解に近いと考えた結果である。しかし、どこか物足りない感じがして、より詳細に定義された回答が聞きたくなり、ChatGPTを活用してみることにした！

Libraryの定義
Frameworkの定義

では、何が違うのか？

上記の回答を通じて、改めてFrameworkとLibraryを整理してみると

Library

再利用可能なコードとリソースの集合関数、クラス、メソッド、データ型などで構成

Framework

ソフトウェア開発のための構造的な枠組み、あるいはプラットフォームあらかじめ定義されたコードとライブラリで構成

この内容を見ると、疑問が湧いてくるのは当然だ。フレームワークはライブラリを含めることができるが、ライブラリはフレームワークを含めることができないのだろうか？

予想通り、フレームワークはライブラリを含めることができるが、その逆は不可能であるという点が確認できた。また、この内容を通じて、フレームワークとライブラリの重要な違いを確認できるのだが……

それはまさにコードフローの制御権である。ライブラリの場合は開発者がライブラリの機能を呼び出して使用する形態だが、フレームワークの場合はフレームワークによって開発者のメソッドが呼び出される形態であるという点に大きな違いがあると言える。

フレームワークで見られるこの形態をIoC（Inversion of Control）、制御の逆転と呼ぶ。Dependency Injectionに関連する内容なので、別途書く機会があるだろうと考え、ここでは詳しく触れないことにする。

結論

ライブラリは再利用可能なコードとリソースの集合であり、フレームワークは開発のための構造的な枠組み、あるいはプラットフォームである。一般的に機能的な側面では同様に動作するため、あえて違いを挙げるとすれば、その使用方法にある。
フレームワークはライブラリを含むことができるが、ライブラリはフレームワークを含むことはできない。コードフローの制御権については、フレームワークの場合はフレームワークが、ライブラリの場合は開発者が持つ。したがって、フレームワークの場合、開発者がフレームワークを修正することは一般的に不可能だが、ライブラリの場合は必要に応じて開発者がカスタマイズすることが可能である。

参考

[カレーユさんのブログ](https://curryyou.tistory.com/363

) ChatGPT 3.5

[面接の質問】ForkとExecの違い

Wed, 31 May 2023 07:48:53 GMT

fork()とexec()の共通点

一つのプロセスが他のプロセスを実行させるため使う

fork()

新しいプロセスのためのメモリを割り当てる
プロセスが追加される (pidが違うプロセスが一つできる)

exec()

新しいプロセスのための追加的なメモリを割り当てることはありません。
既存のプロセスをオーバーライドして新しいプロセスをロード (pidは同じ)

→ 呼び出した後は新しいプロセスが動作するので、既存プログラムのexec時点以降のプログラムは動作しない。

参考

U-chan Seon's Blog

[BOJ 2887, Python] 惑星トンネル

Tue, 30 May 2023 15:33:18 GMT

問題リンク

BOJ 2887

分類

グラフ理論、ソート、最小全域木

解説

この問題に最初に出会ってから、もう半年以上経っていることに驚かされた…とはいえ最近プラチナ問題を疎かにしていた割には、それでも納得できる解法で解けたという点で意味は十分だったと思い、記録することにした。

この問題を正攻法で解くには、最大 10 万個の座標から 2 つを選び、その値を最小値から並べた上で最小辺から取り込んでいく Union-Find + Kruskal の組み合わせで解ける。

しかしそうやって解くと 10⁵ * 10⁵ なので、軽く 100 億通りの場合の数になってしまい、結果として 100 秒程度の実行時間が必要になるため、不可能な解法と言える。

Tip: 1 億回の演算につき約 1 秒と見積もると、計算量を考えやすい！

したがってこの問題の鍵は、O(N²) の場合の数をどう O(N) 単位まで下げるか、と言える。

結論から言うと、本問題では任意の点について全域木を構築するとき、隣接する点以外の点は考慮しなくてよい。

任意の点 A, B が存在し、C という点に接続しなければならない状況を見る。

x の差分 (|X_A - X_B|) が y, z より小さい最小値である場合 → C という点の x 値が A と B の x 値の間に存在すると仮定する

|X_A - X_C| + |X_B - X_C| となる場合、差は存在しない

|X_A - X_B| を維持したまま C を追加でつなぐ任意の |X_A - X_C| や |X_B - X_C| が存在するなら必ず既存の全域木より値が大きくなる → 反例の存在により不可

したがって任意の 2 点を結ぶ辺が本問題で最小全域木に含まれるなら、その 2 点は必ず隣接していなければならない、という証明になる！

この証明を理解できれば鍵を押さえたことになり、残りは一般的な Union-Find 問題と大きく変わらないと思う。

追記) heapq の代わりに PriorityQueue を使ったとき時間切れが発生したが、その問題への回答を見つけることができた。

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

PriorityQueue は Thread Safety を保証するため遅いとのこと。

解法コード

# 惑星トンネル

import sys
from heapq import heappush, heappop

input = sys.stdin.readline

def check_union(union_info: list, now_target: int) -> int:
    """
    該当ノードの現在の Union を照会する関数
    """

    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:
    """
    2 点が同じ Union か確認し、違う場合に統合する関数
    """
    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)

[面接の質問】ProcessとThreadの違い、Multi Thread

Mon, 29 May 2023 17:44:03 GMT

~~まだ執筆中の記事です！~~ ~~23.05.30. 執筆完了~~ → 23.06.09. 内容追加

Program

コンピュータが特定の作業を実行するために書かれた、実行可能な一連の命令のまとまり

さまざまに定義されているが、全体を読んだ上でこのように理解することにした！プログラムの定義を先に確認した理由は、Process の定義がより範囲の狭いプログラムだからである。

Process

「実行中の」プログラムの「インスタンス」 (Task とほぼ同じ意味で使われる)

メモリ上で実行される、OS から見た作業単位

生成に多くの時間と資源を消費する (オーバーヘッドが大きい)

プログラムそのものではなくプログラムのインスタンスとして、複数が同時に存在し得る点が特徴的だと考える。

Thread

プロセス内の作業を実行する、CPU から見た実行単位

すべてのプロセスは 1 つ以上のスレッドを持つ

スレッドはそれぞれ独自のレジスタとスタックを持つ

Heap メモリ領域は共有する

では両者の違いは？

Process がより大きな範囲の単位だと言える

ただ単にここまでの説明だと、かなり包括的な答えだと思われそうなので、よく整理された記事を参考に追加でまとめてみた！

動作のしかた

1. Process の場合

プロセスは実行時に別個のメモリ領域を OS から割り当てられる
メモリ領域は Code/Data/Stack/Heap の形を持つ
他プロセスのメモリ領域にはアクセスできない

2. Thread の場合

Process の Stack 領域は分割し、固有領域を持つ
残りの Code, Data, Heap 領域は共有する

1 つのプロセスのエラーが他プロセスの領域に波及しない

But ひとつのスレッドでエラーが発生するとスレッド全体が終了する → メモリ領域を共有している部分があるため

まとめ

Process と Thread の違いとは？

プロセスは動的に使われているプログラムで、スレッドは作業実行単位の一種であり、概念そのものが異なる
プロセスは最低 1 つ以上のスレッドを含む
プロセス同士は通常メモリ空間を共有しないが、スレッドは共有する
エラー発生時、プロセスは自分だけがダウンするのに対し、スレッドは同一プロセス内のすべてが落ちる

+ Multi-Thread について

1 つのプロセス内で複数のスレッドが同時に作業を実行すること

コンテキストスイッチ (Context Switching)

基本的に同時に処理できる最大作業数は Core の数に等しい Core 数を超えるスレッドが動く場合、各コアが複数の作業を切り替えながら実行するスレッドが切り替わるとき、現時点までの作業状態や次の作業に必要なデータを保存・復元する処理

マルチスレッドとマルチプロセスの長所・短所

1) マルチスレッドの長所

プロセス生成や資源割り当てのためのシステムコールが減り、資源の効率的な管理が可能
1 つのプロセス内では Stack を除くメモリ空間を共有するため、スレッド間のデータのやり取りに掛かる処理コストが小さい
スレッド間の通信方法が複雑ではないため、プログラムの応答時間を短くできる

2) マルチスレッドの短所

デバッグの難しさと設計難易度の上昇
他のプロセスからスレッドを制御できない
メモリ共有による同期問題 (同時に同じ資源へアクセス)
スレッドで問題が起きると、プロセス全体に影響が及ぶ

3) マルチプロセスの長所

プロセスに問題が起きてもその影響が外部のプロセスに広がらない

4) マルチプロセスの短所

コンテキストスイッチでのオーバーヘッドが大きい
プロセス間通信はスレッド間通信に比べて難しく複雑になりがち

参考

위키백과의 프로세스와 스레드 항목 프로세스와 스레드의 차이 by raejoonee 프로세스와 스레드의 차이 by heejeong Kwon

[CI/CD] インスタンスからDooDのデプロイまでの流れ（Nginx、Jenkinsを活用）

Sat, 27 May 2023 14:55:17 GMT

23-06-16 ボリュームマウントを明確にするためにパスを修正 23-07-05 開発の利便性のために設定を調整

はじめに

[CI/CD] Docker + Jenkins + Git Webhook を使った FastAPI サーバの自動デプロイまとめ

今回この記事を書く理由は、上の前回記事で 1 次的に学ぼうとしていた内容を扱ったが、修正すべきところを修正し、整えるべきところを整えてきれいな 1 つの記事にまとめたかったからだ。

前回以降のデプロイ関連タスクや、周りの人のデプロイを手伝う中である程度のノウハウを身につけて定型化できたので、その記録を残し、次回以降のデプロイでも一貫したプロセスとして使えるようにしたい！本記事の手順に沿って進めれば、おそらくデプロイは難しくないはずだ。

1 編以降に学んだ追加の内容

Docker in Docker で実装するより Docker out of Docker で実装する理由は？

そもそも Docker は、Docker コンテナ上でコマンドを実行できるようにすることを推奨していない

Docker in Docker は Docker がインストールされたコンテナに非常に強い権限を付与することになり、セキュリティリスクを招き得る

その点 Docker out of Docker はコンテナ外部の Docker とソケットを共有して docker コマンドを実行する方式

Docker API を使う方式はどう？

実は 1 編で問題解決のために試した方式で、実際に効果があった。ただし Docker out of Docker が無事ビルドできているなら、CI/CD の手順上、いまのところ大きな必要性は感じない…

別記事に分けるのは中途半端な気がしたので、簡単に記録した API 関連の内容

Docker は REST API を通じてエンジンとクライアントが通信するが、ほとんど使う機会はないとはいえ、使うことはできる。

  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

このコードは TLS 証明書を持つ Docker Client を通じて、任意のサーバ上にある Nginx 設定ファイルの内容を修正するコードだ。 -H オプションでそのサーバの port を介して Daemon (Docker Engine) と通信し、残りのコードは証明書による接続セキュリティの手続きだ。

もし証明書を使わずポートを開けっ放しにすると、誰かに開いている port を通してコンテナの「托卵」を喰らう可能性がある！

コンテナ托卵の実体験。Docker でよく使われる port を認証なしで開けっ放しにした結果…

証明書によるセキュリティ処理は必ず行うべきで、やむを得ない事情で行えない場合は、その port を介して実行可能なコマンドを制限することが必須不可欠である。

[Docker API Documents] (https://docs.docker.com/engine/api/v1.43/) の内容を見ると、より詳しく確認できる！

All in One デプロイ基盤構築の手順

1. インスタンス接続とインスタンスのアップデート

ssh -i {secure shell key のパス} {ユーザー名}@{IP アドレス}

sudo apt-get update
sudo apt-get upgrade

ubuntu のセットアップを進める場合、ユーザー名が ubuntu であることが多い。

2. ファイアウォール設定

sudo ufw allow ssh    # ssh は 22 に置き換えても良い
sudo ufw allow http   # http は 80 に置き換えても良い
sudo ufw allow https  # https は 443 に置き換えても良い

sudo ufw enable 	  # ファイアウォールを起動
sudo ufw status 	  # ファイアウォールの状態確認

おそらくクラウドを使う場合、最初からクラウド独自のポートセキュリティ設定があるので、その設定でも開放しておく必要がある。 ufw は Ubuntu のファイアウォールで、最初に設定する際オフになっている場合は、ポートを許可した上で起動する手順が必要だ。上の設定で、基本的な http (80)、https (443)、ssh (22) ポートを開放した状態でファイアウォールを起動できる。

必ず先にポートの allow 設定を行ってから起動することを推奨する。22 番、ssh ポートを閉じたままファイアウォールを起動すると、接続できなくなる…

3. Docker および 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 インストール Documents

2023 年 5 月時点の Documents から必要な内容だけをまとめて記載した。

sudo usermod -aG docker $USER

このコマンドで sudo なしに docker コマンドを使えるようになる。このコマンドを入れない場合 /var/run/docker.sock: connect: permission denied が発生する。

4. 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:
      - {希望のネットワーク名}

デプロイパイプラインのツールとして Jenkins を使う前提で書いた。

追加のネットワークが不要なら networks 部分は省略でき、Docker out of Docker を使うためにソケットのボリュームバインディングを行う。必要に応じて Time Zone や追加のボリュームバインディングも設定可能だ。

5. 使うドメインの DNS 設定

ドメイン事業者によって方式が違う。利用しているドメイン事業者の登録方法に従って、自分のサーバ IP を登録してドメインに紐付ける処理が必要だ。

What's My DNS

登録してすぐ使えるわけではなく、DNS サーバへの反映時間が存在する。手軽に伝播状況を確認できるサイトを上に貼っておいた。

6. 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

この内容を docker-compose.yml に追加し、それ以上の処理は行わない。

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;
     }
}

ファイルを作成し、server_name の後ろに自分のドメインを記載した内容を入れる。

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/*;

}

nginx を初めてインストールするときの内容を基に、適度な初期設定を入れた。

4) 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

証明書発行の手続きを助けてくれるファイルを外部から取得し、権限を設定する。その後、自分のドメインとメールアドレスをファイルに入力し、そのファイルを実行することで証明書発行を進められる。発行に失敗した場合はログを見て原因を見つけ、修正して再試行すれば良い。

7. 証明書更新まで考慮した Nginx 設定

# 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;'"

Let's Encrypt で発行した証明書には使用期限があり、代わりに有効期限が近づくと再発行できる。certbot コンテナと nginx コンテナに再発行関連のコマンドを追加することで、証明書更新が自動で進むよう処理できる。証明書発行が完了している状態なので、nginx がエラーでコンテナビルドに失敗することはなくなる。

8. Jenkins コンテナ内に Docker をインストール

追加した内容) もともとはコマンドを直接並べていたが、直感的でないと感じたので修正！

# /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

既存の docker インストール手順から sudo を抜いたコードを sh ファイルにした。このファイルをマウントで内部に入れて実行すれば、すっきりと一発でインストールできる！

9. 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;'"

このように Jenkins 設定まで追加したあと

docker-compose -f {yml ファイルの場所およびファイル名} up -d

コマンドでコンテナを全て立ち上げられる。

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

このように Jenkins コンテナ内部に Docker をインストールすることで、Jenkins 内部の Shell コマンドから Docker Engine を制御できるようになる。既存の Docker Documents を参考にしたが、違いは sudo を使わない点と、Debian 用 Docker をインストールする点だ。

オプション

1. 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

インスタンス性能や必要に応じてインスタンスが落ちないように、スワップメモリ設定を行うことができる。

2. Jenkins プラグインインストールエラー時の対処方法

<解決策 1> Jenkins の管理 > Plugin Manager > Advanced settings > 更新サイトのパートにアクセス https://updates.jenkins.io/update-center.json を http://updates.jenkins.io/update-center.json に変更

<解決策 2> skip-certificate-check という名前のプラグインをインストール

完璧な解決策ではないが、これらの対策を全て適用することである程度効果が見られた。

締めくくりに

Docker 関連の内容は、後で扱う一部フレームワークのデプロイを除けば、ここでひと段落させる予定だ。それでも自分が作ったものを実際のネットワーク上で確認できるという達成感があるので、デプロイに関する内容は機会があれば今後ももう少し書いていきたい。

[面接の質問] RESTful APIとは何ですか？

Sun, 21 May 2023 17:27:57 GMT

RESTful API

RESTfulなAPIを指す。

。極めて当たり前の言葉だが、まさにその通りだ！それでは、各単語の意味を見ていけば、RESTful APIがどのようなものなのかが分かるだろう。

API

Application Programming Interfaceの略称。定義およびプロトコルの集合を用いて、2つのソフトウェアコンポーネントが相互に通信できるようにするメカニズム。

このように定義されている。私なりの理解で言えば、ソフトウェアのコンポーネント同士でもオブジェクトなどを扱う方法がそれぞれ異なるため、この隔たりを処理するために規約を定め、相互に通信・相互作用できるようにしたものを指すと考えてよいだろう。

REST

Representational State Transferの略称。 World Wide Webなどの分散ハイパーメディアシステムのためのソフトウェアアーキテクチャの一つ。

RESTは当初、インターネットのような複雑なネットワークにおける通信を管理するための指針として作成され、大規模な通信において安定したサポートが可能であると言われ、実装や修正も容易である。

RESTアーキテクチャの原則

一様なインターフェース (Uniform Interface)
- サーバーが標準形式で情報を送信する
- 標準形式は、サーバー内のリソースの内部表現とは異なる場合がある
- 同一のリソースに対するすべてのAPIリクエストは、特定の言語やプラットフォームに関係なく同一である
ステートレス (Stateless)
- 各リクエストは、他のすべてのリクエストに対して独立している
- サーバーは追加情報なしにリクエストを完全に理解し、実行できる
階層化システム (Layered System)
- クライアントのリクエストを処理するために連携して動作する様々なアプリケーションが存在する
- サーバーは多層構造で構成され、サーバーとクライアントの間にも、承認された仲介者が存在し得る
- プロキシ、ゲートウェイなどの中間媒体、暗号化、ロードバランシング層などが追加され得る
- クライアントには見えない状態が維持される
キャッシュ可能性 (Cacheable)
- サーバーの応答時間を改善するために、一部の応答を保存するキャッシュをサポート
- クライアント側またはサーバー側でキャッシュを実装する
オンデマンドコード (On Demand Code)
- 一般的に静的なリソースを送信
- 必要に応じて実行コードをレスポンスに含め、クライアント機能を一時的に拡張またはカスタマイズ可能

RESTful APIの利用メリット

スケーラビリティ
- クライアントとサーバー間の相互作用を最適化するため、規模の調整が可能
柔軟性
- 完全なクライアント・サーバー分離をサポート
- 各部分が独立して発展できるよう、サーバーコンポーネントを簡素化・分離
独立性
- 使用される技術に依存しない
- APIの設計に関係なく、様々なプログラミング言語を使用してクライアントおよびサーバーアプリケーションを作成し、技術を変更できる

まとめ

RESTful APIとは？ RESTアーキテクチャを使用したアプリケーションプログラミングインターフェースを指し、RESTアーキテクチャの原則に準拠したプログラム間の相互作用を定めた規約である。

では、どのような利点があるのでしょうか？当該APIを使用する場合、拡張性、柔軟性、独立性の面でメリットがあると言える！

参考

[[AWS] RESTful APIとは何ですか？](https://aws.amazon.com/ko/what-is/restful-api/

)

[1Day-1CS]ネットワーク機器の処理範囲

Fri, 19 May 2023 17:06:42 GMT

2023-06-18 内容範囲編集

階層別処理範囲 ### 層別処理範囲

アプリケーション層：L7スイッチ
インターネット層: L3スイッチ、ルーター
データリンク層: L2スイッチ、ブリッジ
物理層: NIC、リピータ、AP

面接の質問まとめ、スタート！（質問内容）

Tue, 16 May 2023 22:32:46 GMT

きっかけ

本格的に企業へ履歴書を送り始めてからどれくらい経っただろうか……それでも3ヶ月は経った気がする。コーディングテストはすべて合格しているわけではないが、合格率はかなり高く、最近になって何度か面接を受けてきた成果があった！

しかし、面接に行っても、それなりにCSの勉強をしたとしても、面接で出される質問と私が勉強したCSの知識には違いがあることに気づいた…… そこで、面接で出題された問題について、ピンポイントで勉強した内容をブログにまとめてみようと思う。

質問リスト

全体

[RESTful APIとは？](/blog/restful-api

)

[プロセスとスレッドの違い](/blog/process-thread

)

[ForkとExecの違い](/blog/fork-exec

)

[フレームワークとライブラリ](/blog/framework-library

)

トランザクションとは？
OSI 7層モデルについて
サブネットとゲートウェイ、プライベートIPについて

バックエンド

[DBインデックスとは？](/blog/db-index

)

[コネクションプールとは？](/blog/connection-pool

)

[JVMの構造と原理](/blog/jvm

)

[Javaのヒープとスタックの構造](/blog/java-stack-heap

)

[依存性注入](/blog/dependency-injection

)

Spring IoCコンテナがどのようにBeanを管理するか + プロキシパターン、Spring Beanはプロキシであるにもかかわらず、どのようにマルチスレッド動作を実現しているか
シングルトンパターンとSpringの依存性注入

Frontend

アドレスバーにアクセスURLを入力すると何が起こるか

[1Day-1CS] 層間データ送受信プロセス & PDU

Sun, 07 May 2023 17:02:23 GMT

カプセル化・非カプセル化プロセス

カプセル化: 上位階層のヘッダとデータを下位階層のデータ部分に含めて、その階層のヘッダを挿入するプロセス。

アプリケーション → 伝送 → インターネット → リンク層への転送
伝送層に転送され、セグメント化またはデータグラム化 + TCP (Layer 4) ヘッダーを追加。
インターネット層に転送され、IP(Layer 3)ヘッダーを追加 = パケットに追加
リンク層に転送され、フレームヘッダー + フレームトレーラーを追加 = フレーム

非包装化: 下位層から上位層に進み、各層のヘッダ部分を削除する過程。

非包装化は逆に進行
フレーム → パケット → セグメント、データグラム → メッセージ
最終的にアプリケーションのTDU(Transmission Data Unit)メッセージに転送します。

Protocol Data Unit

層から層から層へデータが伝達されるときの一塊の単位。

メッセージ、セグメント、データグラム、パケット、フレーム、ビットなど階層ごとに名称が異なる。
ビットで送信するのが最も速く、効率が高い。
アプリケーション層では、文字列ベースの送受信(拡張が容易であるという理由に由来)

[1Day-1CS]半二重化通信(2), 無線通信とイーサネットフレーム

Thu, 04 May 2023 14:01:28 GMT

半二重化通信の種類

CSMA/CD: データを送信した後、衝突が発生した場合、一定時間後に再送信する方式。
CSMA/CA: データを送信する前にキャリア検出などで事前に可能な限り衝突を防止する方式。
- データ送信前に無線媒体の確認
- 回線が空いているかどうかを判断（キャリア検出）。
- 使用中の場合、ランダム値を基に間隔を増やしながら使用可能性チェック(IFS)を行います。

無線通信

Wifi: 電子機器が無線LAN信号に接続できるようにする技術、無線接続装置が必要。
BSS(Basic Service Set)
- 基本サービスセットを意味する。
- ルーターを通じた単純接続 + 同じBSS内のAPおよびデバイス同士が通信可能。
ESS(Extended Service Set)
- 一つ以上の接続されたBSSグループ
- 長距離無線通信を提供
- BSSと比較して、より多くの可用性とモビリティをサポートします。
- ある場所から別の場所に移動して、中断することなくネットワークに接続し続けることができます。

イーサネットフレーム

データリンク層で使用される伝送メカニズム

Preamble: イーサネットフレームの開始を通知します。
SFD (Start Frame Delimiter)：次のバイトからMACアドレスフィールドが始まることを知らせる。
DMAC, SMAC: 送受信MACアドレス
EtherType: IPプロトコルを定義
Payload: 受け取ったデータ
CRC: エラーチェックビット

[BOJ 2473, Python] 3つの溶液

Thu, 04 May 2023 13:15:05 GMT

問題リンク

BOJ 2473

カテゴリ

二分探索、ソート、ツーポインター

説明

典型的なツーポインター問題から少し発展した問題のようだ。

最初にこの問題を解く際、3つの溶液を混ぜ合わせなければならないことから、何か別の解法があるだろうと考えてしまい、意外にも正攻法を使わなかった。その結果、実際の解法が遅れることになってしまった。

この問題で注意すべき点は、溶液の総数が5000以下であるという点だ。この条件がなければ、この問題を絶対に制限時間内に解くことはできない……当初、この条件を注意深く見ていなかったために、他の解法を探し続けてしまった点は、今思っても残念な点だった。

したがって、この問題の解決方法は次のように提示できるだろう。

順序ソート → 溶液1つを固定 → 残りの溶液について、その溶液と合算して0に最も近くなるように2点法アルゴリズムを使用 → すべて巡回したか、0に達した場合は終了

解答コード

# 세 용액

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] 全二重化通信と半二重化通信 (1)

Mon, 01 May 2023 16:24:13 GMT

全二重化通信

両方の装置が同時に送受信できる方式

送信路と受信路を区分してデータを送受信する。
現代の高速イーサネットが該当方式を使用

半二重化通信

双方のデバイスは互いに通信できるが、同時に通信することはできません。一度に一つの経路に基づいて、一度に一つの方向のみ通信します。

データを送信した後、衝突が発生した場合、一定時間後に再送信を行います。
有線LAN
- ツイストペアケーブル: ノイズ(CrossTalk)を低減するため、撚り合わせたケーブル。
- 光ファイバーケーブル：コアとケーブルの屈折率差を利用した光の伝送ケーブル。
無線LAN
- 送信と受信に同じチャンネルを使用するため、半二重化通信を使用します。

[1Day-1CS】インターネット層とリンク層

Thu, 27 Apr 2023 03:32:49 GMT

インターネット層

デバイスから受信したネットワークパケットをIPアドレスで指定された宛先に送信するために使用される層です。

リンク層

実質的にデータを転送し、デバイス間で信号を送受信するルールを決める層、ネットワークアクセス層とも呼ばれる。

物理層: LANを介して0、1で構成されたデータを送る層。
データリンク層：Ethernet Frameを介してエラー確認、フローおよびアクセス制御を担当する層。

[1Day-1CS] 伝送層

Tue, 25 Apr 2023 17:14:48 GMT

伝送レイヤ ### 伝送レイヤ

送信者と受信者をつなぐ通信サービスを提供接続指向のデータストリームのサポート、信頼性、フロー制御を提供します。アプリケーションとインターネット層間のデータ転送中継の役割 > アプリケーションとインターネット層間のデータ転送中継の役割

TCP: 順序保証、接続指向のプロトコル使用、受信可否の確認(仮想回線パケット交換方式)
UDP: 順序保証X、受信可否確認X、単純なデータ転送(データグラムパケット交換方式)

仮想回線パケット交換方式

各パケットに仮想回線識別子を含む。
すべてのパケットを送信したら仮想回線を解除、パケットは送信順に到着。

データグラムパケット交換方式

パケットが独立して移動し、最適な経路を選択します。
異なる経路で送信することができ、順序も異なる場合がある。

TCPの接続成立と解除の過程

接続: 3-way handshake

1.クライアントが自分のISNを含む接続要求フラグを送信。 2.サーバーが承認番号でサーバーのISNとクライアントのISN + 1を返送する。 3.クライアントがサーバーのISN + 1を承認番号と一緒に再応答する。

接続解除: 4-way handshake

1.クライアントがFIN設定されたセグメントを送信してFIN_WAIT突入 2.デーラーを受け取ったサーバーがクライアントにACK承認セグメントを送り、CLOSE_WAITに突入。 3.ACKを送った後、一定時間が経過した後、FINセグメントを送信。 4.ACKを受け取ったクライアントがTIME_WAITに突入し、サーバーにACKを再送信します。 5.受信したサーバーがCLOSE

TIME_WAITを使う理由: 遅延パケットの可能性、接続解除を確実に確認する。

[BOJ 7490, Python] 0を作る

Mon, 24 Apr 2023 16:15:36 GMT

問題リンク

BOJ 7490

カテゴリ

バックトラッキング、ブルートフォースアルゴリズム、実装、文字列

説明

典型的なバックトラッキング問題だと思う。しかし、処理の流れが少し分かりにくい点があり、ソート順がASCII順であるという点も少し独特だったようだ。

PythonのEval関数を使えば簡単に解けると思ったが、その方法を使わず、正攻法で解いた。

基本的には、数字の合計と未処理の数字2つを持ち、バックトラッキングを進めながら、「加算」、「減算」、「演算しない」という3つのケースについてすべて確認するという考え方で試したところ、正解と判定された。

解答コード

# 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] TCP/IP 4層モデルとアプリケーション層

Mon, 24 Apr 2023 15:18:37 GMT

インターネットプロトコルスイート (Internet Protocol Suite)

インターネット上でコンピュータ同士が情報をやり取りするために使用されるプロトコルの集合

TCP/IP 4層モデルまたはOSI 7層モデルを用いて説明される

TCP/IP 4層

ネットワークの範囲に応じて、4つの抽象化層で構成される
- アプリケーション層
- 伝送層
- インターネット層
- リンク層
OSI層は、アプリケーション層およびリンク層を細分化したことが特徴

アプリケーション層

FTP、HTTP、SSH、SMTP、DNSなど、アプリケーションが使用されるプロトコル層
- FTP: デバイス間のファイル転送
- SSH: Secure Shell Protocol、暗号化ネットワークプロトコル
- HTTP: World Wide Webを通じてウェブサイトを利用するために使用されるプロトコル
- SMTP: 電子メール転送のためのインターネット標準通信プロトコル
- DNS: ドメイン名とIPアドレスを対応付けするサーバー
実質的に人々にサービスを提供する層

[BOJ 25542, Python] 待ち合わせ場所

Sun, 23 Apr 2023 18:10:04 GMT

問題リンク

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

)

カテゴリ

ブルートフォースアルゴリズム、実装、文字列

説明

初めてこの問題をコンテストで見た時、アイデア自体は難しくないと思っていた。しかし、思った以上に実装に手間がかかる問題であり、7ヶ月前の私はPythonのコードを書くことさえ非常に苦手にしていたため、この問題を解くことができなかった。

3ヶ月前の私もこの問題を解決しようとしたが、構想したアイデアにさらなるプルーニングが必要だという結論に至り、再び挫折して問題を後回しにするしかなかった。

最近、余裕もできたし、以前解けなかった問題に再挑戦したいという欲求があったので、改めて試してみたところ、ついに解くことができた！しかし、依然としてこの問題がシルバー問題であるということには疑問がある……

当初は、既存の文字列だけで結果を導き出そうとしたが、当然ながら反例が存在するため失敗に終わった。

次に試したコードも実装を少し工夫したが、やはり既存の文字列のみを使用していたため、それ以外の文字列を使った反例を解決できなかった。以下のコードを添付する。

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)

当初、未使用の文字を使用しようと試みたことはあったが、実装力が不足していたため実際の実装には移せなかったが、その方法を通じて「正解」を得ることができた。

解答コード

# 약속 장소

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]ボトルネック、ネットワークの分類と分析

Sun, 23 Apr 2023 13:06:14 GMT

ボトルネック

システム全体の性能や容量が一つのコンポーネントによって制限される現象。

サーバーでイベントを開いた時、トラフィックが多く発生し、うまく管理しなければ発生する。
ネットワークトポロジに関する情報がなければ、ボトルネック現象を正しく解決することができません。
ボトルネック現象の主な原因
- ネットワーク帯域幅
- ネットワークトポロジ
- サーバーCPU、メモリ使用量
- 非効率的なネットワーク構成

ネットワークの分類

ネットワークは規模に基づいて分類

LAN (Local Area Network)
- 近距離通信網
- 伝送速度が速く、混雑していない。
MAN (Metropolitan Area Network)
- 大都市圏ネットワーク
- 伝送速度は平均、LANより混雑しています。
WAN (Wide Area Network)
- 広域ネットワーク
- 伝送速度が遅く、MANより混雑している。

ネットワーク性能分析コマンド

ping
- 状態を確認したい対象ノードに一定サイズのパケットを送信します。
- パケット受信状態や到達時間などの情報を確認することができます。
netstat
- 接続されたサービスのネットワーク状態を表示
- ネットワーク接続、ルーティングテーブル、ネットワークプロトコルなどのリストを表示します。
nslookup
- DNS関連の内容を確認するために使用します。
- 特定のドメインにマッピングされたIPを確認することができます。
tracert (traceroute)
- 目的地ノードまでのネットワーク経路を確認する際に使用します。
- どの区間で応答時間が遅くなるのかなどを確認することができます。
その他様々なコマンドが存在し、wireshark, netmonなどのプログラムを使用する。

[1Day-1CS] ネットワークトポロジー

Thu, 20 Apr 2023 12:56:24 GMT

ネットワークトポロジー

ノードとリンクがどのように配置されているかについての方式、接続形態

ツリートポロジー

階層型トポロジー、ツリー状に配置されたネットワーク構成

ノードの追加、削除が容易
特定のノードにトラフィックが集中する場合、サブノードに影響を与える。

バストポロジ

中央通信回線1本に複数のノードを接続する。

近距離通信網に使用
設置費用が少なく、信頼性に優れ、中央通信回線にノードの追加、削除が容易。
スプーフィングの問題が存在

スプーフィング： LAN上で送信と関係ない他のホストに 行かないようにするスイッチ機能を麻痺させたり、騙したりすること。 特定のノードにそのパケットが来るように処理すること。

スタートポロジ

中央にあるノードに全て接続されているネットワーク構成

ノードを追加したり、エラーを検出しやすい。
パケットの衝突が発生する可能性が少ない
中央ノード障害発生時、ネットワーク全体を使用できない。
設置費用が大きい

リング型トポロジ

ノードからノードへデータを移動、リング状の経路でパケットを処理する。

ノード数が増加してもネットワーク上の損失がほとんどない。
衝突発生可能性が少なく、ノードの故障発見が容易。
ネットワーク構成の変更が難しい
障害が発生すると、ネットワーク全体に影響を与える。

メッシュトポロジ

網状トポロジー、網目状接続構造

一つの端末に障害が発生しても、複数の経路が存在し、ネットワークの継続使用が可能。
トラフィックの分散処理が可能
ノードの追加が難しく、構築及び運用費用が大きい。

[1Day-1CS]ネットワーク起動、スループットと遅延時間

Mon, 17 Apr 2023 14:32:41 GMT

はじめに

いよいよ自叙伝の季節が到来し、最近忙しすぎるようですが、それでもコツコツと勉強することが役に立つと思うので、頑張ってみようという決意をもう一度してみます！

ネットワーク

ノードとリンクが相互に接続されているか、接続やリソースを共有している集合を意味する。

Node: サーバー、ルーター、スイッチなどの装置 Link: ワイヤレス or 有線

スループットと遅延時間

多くのスループットを処理することができ、遅延時間が短く、障害頻度が少なく、優れたセキュリティを備えたネットワークを意味する。

スループット：リンク内で正常に転送されたデータの量
トラフィック：特定の時点でリンク内に流れるデータの量。 → トラフィックが多くなった = 流れるデータが多くなった。 → スループットが多くなった = 処理されるトラフィックが多くなった。

スループットは、トラフィック、帯域幅、ネットワーク発生エラー、デバイススペックの影響を受ける。

遅延時間：リクエストが処理される時間、往復で測定。

遅延時間は、メディアの種類、パケットのサイズ、ルータのパケット処理時間に影響されます。

[1Day-1CS】デザインパターン＆パラダイムまとめ

Mon, 10 Apr 2023 16:56:14 GMT

はじめに

いままとめている内容はすべて「面接のための CS 専攻知識ノート」を基にしている。本来 1 日 1CS を始めるときに触れておくべき内容だったかもしれないが、ㅋㅋ 今からでも書き残しておく。

デザインパターン

プログラムを設計するときに発生した問題を、オブジェクト同士の関係などを通じて解決できるようにつくった規約

Singleton パターン: 1 クラス 1 インスタンス / モジュール結合の問題を解くために依存性注入を活用

Factory パターン: 上位クラスで大枠を決め、下位クラスが継承で具体化する

Strategy パターン: カプセル化されたアルゴリズムを Context 内部で差し替えながら使う

Observer パターン: 状態変化を観察し、変化時にメソッドなどで変更内容を伝える

Proxy パターン: 対象オブジェクトにアクセスする前に流れを差し挟むインターフェイスの役割

Iterator パターン: イテレータを使ってコレクションの要素にアクセスし、ひとつのインターフェイスで巡回できる

公開モジュール (Revealing Module) パターン: アクセス制御子を作るパターン

MVC パターン: Model, View, Controller で構成され、アプリケーションの構成要素を分割して開発できるようにする

MVP パターン: Controller を Presenter に置き換える

MVVM パターン: Controller を View Model に置き換える

プログラミングパラダイム

宣言型と命令型の区別 → 宣言型は「何を」？命令型は「どうやって」？
宣言型
- 関数型プログラミング: 純粋関数を積み上げてロジックを実装
命令型
- オブジェクト指向プログラミング: オブジェクトの相互作用を表現し、オブジェクトのメソッドを活用
- 手続き型プログラミング: 連続した計算で構成され、コードをそのまま記述すれば成立する

[1Day-1CS] 手続き型プログラミングとパラダイムの混合

Sat, 08 Apr 2023 15:32:23 GMT

手続き型プログラミング

ロジックが実行される連続的な計算プロセスで構成される
コードが進行手順通りに実装されるため、可読性が高く、実行速度が速い
モジュール化が難しく、保守性が低いという欠点がある

パラダイムの選択

パラダイムに絶対的な優位性といったものは存在しない
サービスの特徴やビジネスロジックを考慮してパラダイムを選択する
ロジックに応じて適宜選択するのも良い

[1Day-1CS] オブジェクト指向プログラミングの設計原則

Thu, 06 Apr 2023 12:27:00 GMT

単一責任の原則

Single Responsibility Principle

すべてのクラスは、それぞれ1つの責任のみを持つべきである。

開閉原則

Open Closed Principle

メンテナンスの際、既存のコードへの変更は最小限に抑え、拡張が容易でなければならない。

リスコフの置換の原則

Liskov Substitution Principle

オブジェクトは、プログラムの正確性を損なうことなく、サブタイプのインスタンスと置き換え可能でなければならない。つまり、継承が問題なく機能するようにしなければならないという意味である。

インターフェース分離の原則

Interface Segregation Principle

1つの一般的なインターフェースの代わりに、具体的な複数のインターフェースを作成すること

依存性反転の原則

Dependency Inversion Principle

上位層は下位層の変化から独立していなければならない。自分よりも変化しやすいものに影響を受けないよう、上位クラスや抽象インターフェースを配置すべきである。

サムスンソフトウェアコンピテンシー評価B型レビュー

Thu, 06 Apr 2023 12:08:47 GMT

はじめに

まず結論から言うと、これまでに与えられた3回のチャンスのうち2回を逃してしまった。そこで、今後どのような勉強をすれば成功できるのかを残しておきたいと思います。

資格 ### 資格

サムスン青年ソフトウェアアカデミーの模擬能力評価A型資格を持って受験した。

回顧 ###回顧

従来は、どうしても実装することに時間を割きすぎただけでなく、最適化の部分においても多くの不足を感じました。今後、受験できる機会が1回ほど残っていますが、最適化について勉強をたくさんして臨まなければならないと思いました。

1.オブジェクトの使用不足

どうやらPythonを使ってきたからか、オブジェクトを中心にコーディングすることに慣れていない面があり、たくさん習得しようとしましたが、まだ実力不足を感じています。特にComparatorのようにoverrideして使う部分が難しいと感じます。

2.資料構造熟知状態

B型合格者たちの話を聞いてみると、全体的にデータ構造についての話をたくさん強調していますが、私がその分、データ構造を十分に熟達しているかと聞かれたら、まだ足りない面があるので、最後のテスト時点まで復習する時間を十分に持つ必要があると思います。

+追加

4月末を最後に3回のB型の旅が終了した。結果的にB型の資格を取得することができず、最後の問題はほぼ出題されたのですが、最後の一歩を踏み出せなかったのが残念です。

しかし、挑戦しようとしたからこそ努力したし、努力したからこそ、ある程度のレベルアップができたと思う。

おかげで、企業入社のコーディングテストを受ける際に、比較的問題が易しそうなのは明らかなメリット。

たぶん、現在私が持っている資格は仮A型なので、SSAFY修了後にもうB型を見る機会はないだろうが、それでももう一つ終わったという点ではスッキリした！

[1Day-1CS] 命令型プログラミング & オブジェクト指向プログラミング

Fri, 31 Mar 2023 11:39:05 GMT

コマンド型プログラミングの種類

オブジェクト指向プログラミング（Object-Oriented Programming)

オブジェクトの集合でプログラムの相互作用を表現し、オブジェクト内部に宣言されたメソッドを活用する方式。
設計に多くの時間がかかり、速度が他のプログラミングパラダイムに比べて遅い。

オブジェクト指向プログラミングの特徴

抽象化: 複雑なシステムから核心的な概念、機能を簡略化すること。
カプセル化：オブジェクトの属性とメソッドを一つにまとめ、一部を外部から隠蔽すること。
継承性: 上位クラスの特性を下位クラスが引き継ぎ、再使用、追加、拡張が可能。
多形性：一つのメソッドやクラスが様々な方法で動作可能。
Overloading: 同じ名前のメソッドを複数持つこと、'コンパイル'中に発生する'静的'多形性。
Overriding：親クラスから継承したメソッドを子クラスが上書きすること、「実行時」に発生する「動的」多形性。

[1Day-1CS] Declarative Programming

Fri, 31 Mar 2023 11:36:56 GMT

プログラミングパラダイム

プログラマーにプログラミングの観点を持たせる役割を果たす開発方法論

宣言型 vs 命令型

宣言型: 何を解くかに焦点を当てるパラダイム (What)
命令型: どのように解くかに焦点を当てるパラダイム (How)

例) 宣言型: 家の住所 (位置を正確に指定) 命令型: 家までの経路 (位置までの行き方を提示)

宣言型プログラミングの種類

関数型プログラミング

小さな純粋関数をブロックのように積み上げてロジックを実装し、高階関数を実装して再利用性を高めるプログラミングパラダイム

純粋関数: 出力が入力にのみ依存する関数

高階関数: 関数を値のように引数として受け取りロジックを構築する関数

言語が 1 級オブジェクト (First Class Object) を扱えるなら高階関数の使用が可能

1 級オブジェクトの特徴

変数やメソッドに関数を代入できる

関数の中に関数を引数として渡せる

関数が関数を返せる

[1Day-1CS]MVCパターンと類似パターン

Thu, 30 Mar 2023 16:36:43 GMT

MVC パターン

Model, View, Controller で構成されるデザインパターン

アプリケーションの構成要素を 3 分割し、それぞれの要素にのみ集中して開発できるようにする
再利用性と拡張性が高い
アプリケーションの複雑度が高くなるほど Model と View の関係が複雑になる欠点がある

Model

アプリケーションのデータで、DB・定数・変数などを指す

View

ユーザーインターフェイス要素を指し、Model を基にユーザーが見る画面を表す

モデルが持つ情報を別途保存せず、画面表示用の情報のみを保持する

変更点が発生すると Controller に伝える

Controller

Model と View をつなぐ Bridge の役割

Event などのメインロジックを担い、Life Cycle も管理する

Model または View の変更を通知されると、対応する内容を必要な構成要素へ伝える

類似パターン

MVP パターン: Controller を Presenter に置き換える。View と Presenter の関係が 1:1 のため結合度がより強い
MVVM パターン: Controller を View Model に置き換える。Command と Data Binding を持ち、UI の再利用性と単体テストの容易性を確保できる

[1Day-1CS] プロキシパターン＆イテレータパターン＆露出モジュールパターン

Tue, 28 Mar 2023 23:30:10 GMT

プロキシパターン

ターゲットオブジェクトにアクセスする前に、そのアクセスの流れを傍受し、ターゲットオブジェクトの前段のインターフェースとして機能するデザインパターン。
セキュリティ、データ検証、キャッシュ、ロギングに使用し、オブジェクトではなくサーバーとしても活用される。

プロキシサーバー

サーバーとクライアントの間で動作
クライアントが自分を通して他のネットワークサービスに間接的にアクセスできるようにするシステムまたはプログラム。

代表的な例としてApache、Nginx、CloudFlareなどが存在する。

プロキシサーバーの使用例

プロキシを経由するため、実際に使用するポートを隠すことができます。
Nginx を通じて静的リソースを gzip したり、メインサーバーの前段でロギングすることが可能。
CloudFlareの場合、HTTPS構築に容易さを提供し、DDOS攻撃防御が可能。
フロントエンドプロキシサーバーを通じてCross Origin Resource Sharing (CORS) エラーを防止することができます。

イテレータパターン

イテレータを使ってコレクションの要素にアクセスするデザインパターン。

データ型の構造に関係なくイテレータという一つのインターフェースで巡回が可能という利点があります。
通常イテラブルなオブジェクトをイテレータプロトコルを通じて巡回することができる。

露出モジュールパターン

即時実行関数でprivate, publicのようなアクセスコントローラを作るパターン。

JSの場合は別途アクセス制御者が存在しないので、これを実装して構築することもある。

[1Day-1CS] ファクトリーパターン・戦略パターン・オブザーバーパターン

Mon, 27 Mar 2023 22:36:03 GMT

ファクトリパターン

オブジェクトを使用するコードにおいて、オブジェクト生成部分を抽象化したパターン
親クラスが重要な骨格を決定
子クラスがオブジェクト生成に関する具体的な内容を決定

ファクトリパターンの特徴および利点

クラスの分離による疎結合を実現親クラスの柔軟性を確保し、保守性を向上

ストラテジーパターン (ポリシーパターン)

オブジェクトの振る舞いを変更したくない場合、直接修正しない
戦略に相当するカプセル化されたアルゴリズムをコンテキスト内で変更できるように設計し、交換可能にする

コンテキスト

開発者が特定の作業を完了するために必要な関連情報を意味する
ある動作が発生するために不可欠な必須コンテキストと、動作を効果的に実行するための選択的コンテキストが存在する。

オブザーバーパターン

主体が特定のオブジェクトの状態変化を観察する
状態変化時にメソッドなどを通じて、オブザーバーに変化の事実を提供する
主体とオブジェクトを分離せず、可変的なオブジェクトに基づいて構築することもある
MVCパターンでも活用されている

[1Day-1CS]シングルトンパターン

Mon, 27 Mar 2023 15:29:32 GMT

デザインパターンとは？

プログラム設計時に発生した問題点が存在 → オブジェクト間の相互関係などを利用して解決できるように一つの規約にする。

シングルトンパターン

一つのクラス＝一つのインスタンス
クラスごとに複数の個別インスタンスを作ることができますが、そうせずに一つだけ使用します。
通常DBモジュールに多く使用
生産性 ↑, 依存性 ↓.

シングルトンパターンのデメリット

TDD(Test Driven Development:テスト主導型開発)時、ユニットテストを進行する時、Issue発生の可能性

依存性が高いシングルトンパターンの特性上、各テストごとに独立したインスタンスを作るのが難しい。

依存性注入

シングルトンパターンのモジュール間の結合を強くする短所を解決するための方法
メインモジュールが直接他のサブモジュールに依存性を与える代わりに依存性インジェクタを通じて間接的に依存性を注入(デカップリング)

長所

モジュールを簡単に交換できる構造、Testing & Migrationが容易、依存性の方向性の一貫性、Application推論が簡単になる、関係の明確性など

短所

モジュールがさらに分離 → クラス数の増加で複雑性増大、ランタイムペナルティ

依存性注入の原則

上位モジュールは下位モジュールから何も取り込まない。
両方とも抽象化に依存する必要がある + 抽象化は詳細に依存しない

[CI/CD] Docker + Jenkins + Git Webhookを活用したFastAPIサーバーの自動デプロイまとめ

Fri, 24 Mar 2023 02:08:12 GMT

内容整理中 > 2023 年 5 月時点で 1 次更新完了デプロイ関連の内容は、もう少し整えた 2 編を参照するのがよいです。

はじめに

現在進めているプロジェクトで、AI モデルを活用したアウトプットを提供するサービスを構築していた。

その機能を Firebase Cloud Function で構築したかったが、モデルをロードする過程などで nodeJS + tensorflow.js を使う関係上モデルの変形が避けられず、もともと重いことによるタイムアウトなど、さまざまな形で苦戦したため、AI モデルを通じた結果を返すシンプルなサーバを構築してみることにした。

これに伴いサーバの構築とデプロイ作業が自分の役目となり、一次目標として自動デプロイの実現、その後の追加目標として無停止デプロイまで自分の手で進めることにした。

本記事では AWS などのインスタンスをベースとしたシステム構築および自動デプロイまでだけを扱う。

事前知識

CI: Continuous Integration (継続的インテグレーション)

開発者向けの自動化プロセスで、コード変更点がビルド・テストを経て定期的に共有リポジトリへマージされるという過程。これを自動化することで、開発過程のリスクを減らす手段として使われている

CI Server, Source Control Management, Build Tool, Test Tool などで構成される

CD: Continuous Delivery / Deployment (継続的デリバリー / デプロイ)

デプロイ自動化プロセスを意味し、パイプラインの追加段階を自動化することで、手動の介入なしに変更点が product まで自動的にデプロイされ得る。継続的インテグレーションの裏付けが必要であり、信頼できる環境を作れば 1 日に何度でもリリース可能になる

結果として、こうした CI/CD 過程を通じて製品リリースまでの時間を短縮でき、人員の効率を高め、漸進的かつ継続的なプロセスの連続なので、大きな問題が発生する確率を減らしていける。

Docker 環境のセットアップ

インスタンス情報

EC2 のフリーティアの代わりに、相対的に条件のよい Oracle Cloud のフリーティアを採用 arm64 ベースの Ampere A1 Compute 2 Core と 12GB RAM を割り当てて使用

このほかにもバックアップなどのオプションを無料である程度サポートしているので参考に！

Linux のセットアップ EC2 を password で接続する方法 - ログイン関連の利便のため、ssh セットアップを扱う記事 Docker のインストール - Ubuntu 基準の Docker インストール公式 DOCS

筆者が参考にした資料をまとめた。Docker のインストール手順やインスタンスのセットアップに関する記事は多数存在するので、調べながら Docker をセットアップすれば良い。

Docker in Docker のセットアップ (失敗 > API を活用した Docker out of Docker で進行)

使う理由

Docker の上でさらに Docker を扱う理由は、コンテナをコンテナで制御するためであり、基本的にそのコンテナの権限が非常に強くなるためセキュリティ上のリスクは指摘されるが、それ自体として魅力的なのは確かだ。

試したセットアップ方法

1. Docker 上で Jenkins コンテナを構築

まず Jenkins コンテナを Docker で構築する。 Docker Compose を使うとより楽に構築できるので参考に。

docker pull jenkins/jenkins:lts

まず Jenkins LTS 版のコンテナを取得する。

vim docker-compose.yml

yml ファイルをこのコマンドで作成 / 開く。

version: "2.5.0" # compose のバージョンを入力すること

services:

  jenkins:
    container_name: jenkins
    image: jenkins/jenkins:lts # Jenkins LTS 版を使う
    restart: always # 自動再起動オプション

    ports:
      - "8181:8080" # host の 8181 ポートを Jenkins の 8080 ポートに接続

    volumes: # host の volume をこのオプションで共有可能
      - /home/opendocs/jenkins:/var/jenkins_home
      - /var/run/docker.sock:/var/run/docker.sock

    user: root
    privileged: true # Docker In Docker のための重要オプション

yml ファイルに例示コードのように必要な内容を記述する。

docker-compose -f {ファイル名} up

このコマンドで docker-compose.yml をベースにしたセットアップを進められる。ファイル名を変えずに docker-compose.yml そのままなら -f オプションは不要。詳細は Docker Compose Docs を参照すること。

Docker Compose Documents

+ sudo を使わずに docker を扱う方法 → Docker グループに現在のユーザーを追加する

# このコマンドで現ユーザーを Docker グループに追加できる
sudo usermod -aG docker $USER

2. Jenkins Container のセットアップ

設定した IP アドレスの Docker から割り当てた Port Number でブラウザにアクセス
Jenkins インストールログに記載されたキーを画面に入力する

# このコマンドでコンテナのログを確認できる
docker logs jenkins

推奨プラグインのインストール

問題が起きうるが、ひとまずインストールを完了してから対処すれば良い。完了せずにいると、未インストールのプラグインに起因する依存性エラーが続く…

プラグインインストールの Time Out 対処法

GitHub API Plugin のインストール

Webhook トリガーで動かすためのプラグイン。インストールしたあと、Secret として Git ID/PW を登録しておくこと。

3. GitHub の設定

Settings の Developer Settings 内で Token を作る。本記事執筆時点では Classic トークンを使い、repo と admin:repo_hook 程度の権限設定で十分。
自動デプロイ対象 Repo の設定で Webhooks に Webhook を追加する。http://{jenkins_url}/github-webhook/ 程度に設定すればよい。最後の / を外すと問題が起きうるのでおとなしく付けておくこと。

4. Jenkins プロジェクトのセットアップ

プロジェクトを追加する。
ビルド設定 - ソースコード管理で Git を選び、登録済みの Secret を選べば webhook 信号を受け取れる。
GitHub hook trigger for GITScm polling オプションを選ばないとトリガーが動作しない。
必要に応じてブランチ選定も行い、セットアップを締めくくってテストする。

[BOJ 4803, Java] 木

Tue, 28 Feb 2023 00:26:49 GMT

問題リンク

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

)

カテゴリ

データ構造(data_structures)、深さ優先探索(dfs)、分離集合(disjoint_set)、グラフ理論(graphs)、グラフ探索(graph_traversal)、木(trees)

説明

木の性質を利用して、木の数をカウントする問題だった。この問題では、連結要素で構成されたものの中からサイクルを除外することで解決できる。

すべてのノードについて訪問確認
未訪問の点について、木に組み込みながら深さ優先探索
サイクルを形成している場合、構成しているすべての点を訪問済みとして処理
サイクルを形成していない場合、その集合は木であるため1をカウント

上記のようなロジックで実装し、深さ優先探索を行いながらカウント処理をどうするか悩んだ結果、以下のコードを作成した。


    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;

    }

最初の点から再帰的に訪問処理を行いながら探索し、サイクルが見つかった場合は基本的にすべての点を巡回した後、0を返す構造で作成した。

もしサイクルが現れなかった場合は、正常に巡回を終えて1を返すため、その関数の戻り値をカウントし続けることで、木の数を把握できる！

解答コード


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] 正方形

Sat, 25 Feb 2023 03:05:13 GMT

問題リンク

BOJ 1485

カテゴリ

幾何学(geometry)、ソート(sorting)

説明

この手順に従って正方形の判定を行えばよい。

4つの点を結ぶ6本の辺の長さをすべて確認
ソート
先頭4つの長さが同じか確認
後方2つが正方形の対角線の長さとして適切か確認
すべてを満たす場合のみ、正方形を描画可能として処理

解答コード

# 정사각형

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] 本台の散歩 2

Wed, 22 Feb 2023 14:05:40 GMT

問題リンク

BOJ 12850

カテゴリ

分割統治法を用いた累乗（exponentiation_by_squaring）、グラフ理論（graphs）、数学（math）

説明

分割統治法 (Divide and Conquer)

そのままでは解決が難しい問題を、小さな問題に分割して解決するアルゴリズム

この問題の場合、隣接行列を描き、その隣接行列のn乗演算を行った結果の行列の値が目的地に到達する回数が答えであることを知っていれば、難なく解決できる。

分割統治法と行列演算に関する学習が前提となるが、低難易度の問題をいくつか組み合わせたレベルであり、納得のいく難易度だったと思う。

解答コード

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();

    }

}

リファクタリング 1 - 1. 型「...」は型「...」に代入できません

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>

問題の発生

このようなコードをTypeScriptでmapを使用して再構築する過程でエラーが発生した。

> Type 'string' is not assignable to type '"text" | "outlined" | "contained" | undefined'."

上記のようなエラーで、MUIを使用しており、MUI Buttonのvariantプロパティの値でエラーが発生していた。これを解決するためにかなり悩んだ末、StackOverflowやChatGPTを徹底的に調べた結果、ようやく解決策を見つけることができた。

解決方法


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}
	/>
  )
)}

上記のような形式で、typeという値を通じてvariantに入る属性値をあらかじめ定義し、interfaceにも記述する必要がある。実はこの部分よりも、以下に書く内容の方が重要だ。

const loginButtonSettings = [
  {
    onClick: loginHandler,
    contains: <div>Login</div>,
    variant: "contained" as Variant, // 바로 여기!
  },

ここに書かれているように、「contained」は一般的にstringとして認識されるため、Variantという属性値に含まれていたまさにその値であることを認識させる必要がある！

リファクタリングに入る

Tue, 21 Feb 2023 16:26:20 GMT

記録の理由

約7週間の短ければ短くて長ければ長いプロジェクトを経験してReactとある程度仲良くなる時間はあったと思います。でも、思ったと違って私はこの友達を綺麗に育てたいのですが、いつの間にか乱雑になるのが勝手に生えたひげを見てるような感じです...。

それでこのコードを修正してみよう！と思うようになり、簡単に今までのプロジェクトの記録を残しながらこの機会にTypeScriptも使ってみる機会を持とうと思います。

なぜReactを使うのか？

以前参加したプロジェクトではVueJSも使ってみる機会があってVueをベースにコードを作った経験があったのですが、何か長所と短所を持って比較できる熟練者ではなかったし、Reactを使ったこともなかったので、とりあえず今一番ホットなフレームワークだから使ってみよう！という考えを持って使うことになりました。どうやらVueと比較した時、Vueの短所を体感するよりReactの長所を体感するきっかけになったようです。

エコシステムが広い

これは数値的にもそうですし、よく知られているメリットだと思いますが、Vueで使ってたほとんどのライブラリはReactでも使えるし、こちらがメインでVueはおまけみたいな感じで提供されてる感じがしました。

直感的です。

まだ様々なHookを使ってないからか、Propsを処理する方法やコード作成方法など、もっと楽だと感じました。

ueの場合はまるで頭、胸、腹のようにtemplate、script、styleを作成する形でコード間の区別感を生かした感じでしたが、Reactは基本的にFuction ComponentをJavaScriptコードと区別感を与えない形で作成する方なので、変数アクセスなどにおいてもっと便利だと感じました。

もちろん、Vueのように分離するとコードを読む時もっと楽かも分かりませんが、作成する基準としては明確な違いがあり、今となってもどっちを使うかと聞かれたらReactを使うでしょう。

Event処理が便利でした。

上の内容とある程度共有する部分がある内容ですが、EventHandlerを作成する時、Vueを使ってた時よりずっと直観的に書くことができたと思います。Vueの場合はFunctionとVariableを別々に分けて書く部分が多かったようですが、Reactは一般的なプログラミング言語を使うようにその場で変数宣言して処理する形が可能なので、毎日食べてた白飯のような安心感がありました。

TypeScriptを使う理由

実際の業界で選ぶ長所と短所とは違うかもしれませんが、個人的にはReactの上記のような長所を挙げることができ、Refactoringの過程でもReactを選んだ理由になりました。

同じようにRefactoringをする時、なぜJSの代わりにTSを使うのかの理由も書いておいた方がいいと思うのでここに書いておきます。

エラーキャッチャー

TSの長所でJSの短所を解決する部分がすごく大きいと思います。基本的にJSは非常に緩い言語だと思うし、実際そうです。そのため、エラーが変なところで発生し、解決も難解な時がたまにあるのですが、このような部分をTSがうまく解決してくれると期待しています。

慣れてる

JSはどうしようもない開発履歴によって個人的にプログラミング言語らしくない部分がすごく多いと思います。しかし、TSは明らかにJSベースであるにもかかわらず、とてもしっくりくる構造を提供することで、JSで残念だった部分を解決してくれました！もちろん、手はもっとたくさん必要ですが、むしろ安定した構造の慣れから来る快適さがTSを使うように誘導しています。

おわりに

今後、今まで使っていたコードと比較しながら、あるいは学んだ内容を、この投稿の下にどんどん残していく予定です。どれくらい時間がかかるかは分かりませんが、とてもやりがいのある作業になることを期待しています！

[BOJ 1922, Java] ネットワーク接続

Mon, 20 Feb 2023 07:55:51 GMT

問題リンク

BOJ 1922

分類

グラフ理論、最小スパンニングツリー

説明

はじめに

最近は問題を解くことばかりに追われて、理論をおろそかにしている気がするため、理論を簡単でも整理しつつ、問題の解法を記録しておこうと思う。

MST（minimum spanning tree、最小スパニングツリー）

スパニングツリーとは？

グラフ内のすべての頂点を含む木を意味する。

最小スパンニングツリー

スパンニングツリーの中で、辺の総長が最も短いもの

主な特徴

n個の頂点を通る(n - 1)本の辺を持つ長さを最小限に抑えるため、社内ネットワークの構築などに活用可能

プリムアルゴリズム

初期の頂点を1つ選択
MSTに含まれる頂点に接続された辺のうち、最も短いものを順次選択
すべての頂点が接続された場合、終了

クルスカルのアルゴリズム

すべての辺を重み順に並べ替える
サイクルを形成しない範囲で、辺を順次追加
すべての頂点が接続された場合、終了

実装コード

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] ロボット掃除機

Sat, 18 Feb 2023 12:31:09 GMT

問題リンク

BOJ 14503

カテゴリ

実装(implementation)、シミュレーション(simulation)

説明

典型的な実装問題ですが、問題の説明を理解する段階から少し難解な部分があります。その部分についてだけ、簡単に補足しておこうと思います。

現在のマスを掃除
現在のマスを基準に反時計回りに90度回転した方向からチェック
一周して最初に見ていた位置まで確認した後、掃除する場所がなければ後退
後退する場所もなければ掃除終了

この問題において、正面基準で左側を先にチェックするという部分を見落として解いてしまうと、実装云々以前に迷い続けるしかない構造になっている。その点に必ず注意して解くようにしよう！

解答コード

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();

    }

}

初めての面接体験談

Tue, 07 Feb 2023 11:30:12 GMT

2023-07-06 サムネイル編集 (作家 storyset 出典 Freepik)

はじめに

久しぶりに書く記事になった気がする。

現在 SSAFY 8 期の課程を受けているため、思ったより腰を据えて記事を書く時間がとれなかった。

ただ、面接のような重要な経験を経たあとにこういったものを整理しておかないと、自分の成長に役立たないと思い、無理にでも記事にしてみる。

面接の流れ

ビデオ面接で行われ、想定面接時間が長くなかったため、技術面接よりは人物面接寄りだと予想していたが、予想どおり技術面接ではなかった。

これを「事前に予想して準備していたのは幸いだった」と捉えるべきか、それとも「経験を得る機会を逃して残念」と捉えるべきか悩むレベルだった…

面接の質問は、覚えているものだけ並べると

毎回出てくる自己紹介 1 分

専攻ではない現在の分野を選んだ理由は？(筆者は非専攻者)

空白期間について

勤務環境がこういう形だが、思っていたものと違うかもしれない、それでも大丈夫か？

少し抽象的に書いたが、思ったよりは準備していた内容で対応できる水準だったので幸いだった。特に非専攻者の場合は、専攻者と比べて CS 知識の不足を念頭に置いて関連質問を狙ってくることが多いため、ある程度の準備は必要だ！

個人的な所感

ただ、技術面接ではなかったため技術関連の質問があまり交わされなかった点は、次のコーディングテスト通過がいつになるか分からないだけにより一層惜しかった気がする。

そしていつも念頭に置くべきことだが、会社が面接者を見定める一方で、面接者も会社の値踏みができる時間でもある、と聞いたことがあるが、今回の面接でその点を骨身に沁みて感じた気がする。

今回面接を受けた会社は、自分が考えていた職務とはあまりに違う仕事をすることになりそうだったため、合格しても多くの悩みを抱えることになりそうだ…！

[BOJ 16934, Java] ゲームのニックネーム

Wed, 28 Dec 2022 00:35:18 GMT

問題リンク

BOJ 16934

カテゴリ

データ構造(data_structures)、ハッシュを用いた集合とマップ(hash_set)、文字列(string)、木(trees)、トライ(trie)

説明

個人的には文字列の問題が苦手で、もう少し勉強しなければならないと思っているが、今回の問題はトライアルゴリズムを使って解くことができた。

例題が多かったので反例チェックは難しくはなかったが、もしこの問題が例題まで明確でなかったら、もっと頭を悩ませることになっただろう…

Javaで木構造を実装したことがなかったため、多少時間はかかったが、誰の助けも借りずに実装できたことに意義を見出そう！

解答コード

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] ハイパートマト

Thu, 22 Dec 2022 04:36:35 GMT

問題リンク

[BOJ 17114] (<https://www.acmicpc.net/problem/17114>)

カテゴリ

実装(implementation)、グラフ理論(graphs)、グラフ探索(graph_traversal)、幅優先探索(bfs)

説明

個人的には、BFSがどこまで複雑になり得るかをよく示している問題だと思う。

問題の存在は以前から知っていたし、解法自体もすでに有名で広く知られているが、自分が解く方法を実装することとはまた別の問題であることを改めて学んだ。

高速な入出力は基本であり、幅優先探索を行う際に余計な処理を省かないとタイムリミットオーバーになる可能性がある問題。

Pythonでsys.stdin.readlineを使って解決できるかは分からないが、Javaでは幸いにもBufferedReaderで処理が可能だった。

この問題を解いた後に調べてみると、スマートな解法が別途あるようだが、ここでは古典的なBFSを力業で拡張することで解決した。

11次元配列に座標情報を入力
未熟なトマトはカウントし、熟したトマトは座標を記録
熟したトマトを順巡し、隣接する未熟なトマトを熟したトマトのリストに追加しながらカウント値を減少させ、条件に応じてこの過程を繰り返す
カウントが0になったらすべて熟したことになるため、かかった日数を出力
カウントが0にならなかったが、既存の未熟なトマトに対して(3)の処理を繰り返しても数が変化しなかった場合、これ以上熟すことは不可能であるため、-1を出力する。

この問題を解く際、2番と3番の処理において別の方法、つまりカウントを毎回更新する方式や、一度使用した熟したトマトの座標を削除しない場合、タイムリミットオーバーになる可能性があるが… ここでかなり迷いながら解決した。

解答コード

コードがかなり長いが…11重のforループを使用し、隣接する座標を表現している点から、やむを得ない部分だと考えている。


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] 学会会員

Mon, 12 Dec 2022 13:50:33 GMT

問題リンク

BOJ 3865

カテゴリ

幅優先探索(bfs)、データ構造(data_structures)、深さ優先探索(dfs)、グラフ理論(graphs)、グラフ探索(graph_traversal)、ハッシュを用いた集合とマップ(hash_set)、パーシング(parsing)、文字列(string)

説明

最近直面したコーディングテストでは、文字列に関する問題がよく出題される傾向にあるようで、どうしても文字列に関連する問題を探していたところ見つけた問題。

深さ優先探索を使う問題だったので、やはり馴染みがあり、まだJava言語への習熟度が不足しているため、解法には少し時間がかかったが、大枠は深さ優先探索の範囲から外れることはなかった。

文字列データをうまく加工し、学会と学生名について訪問記録の集合を常にチェックしながら、まだ訪問していない場合は各ケースに対して再帰＋カウント処理で仕上げることができる問題だった。

解答コード

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合格体験記と資料

Tue, 29 Nov 2022 15:32:31 GMT

第47回SQL開発者資格試験に合格した。進路を完全に転換してから初めて取得した資格なので、とてもやりがいを感じている。

当初は1ヶ月ほど時間をかけようと思っていたが、他の用事に追われたり、理論的にばかりアプローチしすぎたりして……かなり時間を無駄にしてしまった気がして、残念な点もある。勉強しながら確認した点をここに記しておく。

最後のパートには個人的に整理した概念が記載されているが、その後で実戦的な部分や、自分が覚えやすいように編集した点が所々に残っており、整合しない部分などが存在するかもしれない！それでも、もし誰かが勉強する際に役立つかもしれないので、全体の内容を残しておき、後で思い出したら編集する予定だ。

所要時間および勉強方法

実質的に費やした時間は約2週間、問題演習には約1週間を費やした。

最初は[Data on Air](https://dataonair.or.kr/

)が提供する概念解説を通じて、王道に近い方向で勉強を進めたかったが、SQLD自体が概念的な部分よりも実戦的なSQL構文の形で出題される問題の方がはるかに多いことを知り、序盤で断念することになった。しかし、依然として内容自体は良いと思うので、時間があれば一度確認することをお勧めする！

次に、YouTubeにある様々な形式の講義を通じて、大まかな概要を把握した。SQLDに限っては、かなり多くの整理された講義が存在するため、良さそうなものを選んで視聴するだけで十分だろう。

最後に問題演習だが、問題に関しては関連するカフェやブログに過去問を復元した資料が存在する。いわゆる「ノランイ」と呼ばれる本も良いが、過去問の解説も疎かにしないことが重要だ！ノランイの場合は第2章まで1回通読し、誤答ノートを整理するにとどめ、残りの時間はすべて過去問の演習に費やした。

個人的に推奨する過去問復元サイトは、[このブログ](https://yunamom.tistory.com/category/자격증/SQLD 기출문제

)をお勧めしたい。解答を入力するだけで、即座にその問題の正誤を確認できるからだ。

概念の整理

参考事項：第1章は第2章に比べて問題の比重が低いため後回しにされ、それに伴い必要な内容のみを記載しているため、内容が不十分である可能性がある

第1章

エンティティの分類

基本／キーエンティティ
中心エンティティ
行為エンティティ

データモデリング

情報システム構築のための、データ視点による業務分析手法
現実世界のデータを、定められた表記法によって表現
データベースを構築するための分析／設計のプロセス

データモデリングを行う際の留意点

重複
柔軟性の欠如
不整合

データモデリングの種類

概念的：抽象化レベルが高く、業務中心に包括的に進める
論理的：キー、属性、関係などを正確に表現し、再利用性が高くなるよう設計する
物理的：実際のデータベースに移植できるようにし、物理的な特性を考慮する

データベーススキーマの構造

外部
概念
内部

ERDの作成手順

エンティティを描く。
エンティティを適切に配置する。
エンティティ間の関係を設定する。
関係名を記述する。
関係参加度を記述する。
関係の必須・非必須を記述する。

エンティティの特徴

当該業務において必要であり、管理すべき情報
一意の識別子でなければならない。
2つ以上のインスタンスを持つ。
実際に使用されなければならない。
属性を持たなければならない。
少なくとも1つ以上の関係を形成しなければならない。

1개 엔터티: 2개 이상의 인스턴스 집합 + 2개 이상의 속성
1개 속성: 1개 이상의 속성값

属性の特性による分類

基本属性
設計属性
派生属性

ドメイン

各属性が持つことができる値の範囲
エンティティ内の属性に対するデータ型、サイズ、制約の指定

属性の命名

当該業務で使用される名称でなければならない。
記述的な属性名は使用しない。
略語の使用は控える。
データモデル全体で一意性を確保しなければならない。

ERDでは実体関係と行為関係を区別しない。しかし、クラス図では区別し、関連関係、依存関係を記述しなければならない。

関係の表記法

関係名：関係の名前
関係次数：1：1、1：M、M：N
関係選択仕様：必須、選択

関係の読み方

基準エンティティを「1つ（One）」または「各（Each）」と読む。
対象エンティティの関係参加度を読み取る。
関係の選択仕様と関係名を読み取る。

識別子の種類

代表性：主識別子 vs 副識別子
自己生成の有無：内部 vs 外部
単一属性識別：単一 vs 複合
意味の有無：本質的 vs 人工的

主識別子の特徴

一意性
希少性
不変性
存在性

パフォーマンスデータモデリング

データベースのパフォーマンス向上を目的として、パフォーマンス関連事項をデータモデリングに反映

第1正規化の対象

重複属性の分離
行単位の重複
カラム単位の重複

半正規化

正規化されたエンティティ、属性、関係の重複、統合、分離を通じてシステムのパフォーマンスを向上させ、開発および運用の簡素化を図る整合性が損なわれる可能性があるにもかかわらず、パフォーマンスの低下が予想される場合に実施する。

手順

半正規化の対象の調査
- 範囲処理の頻度
- 大量の範囲処理
- 統計的処理
- テーブル結合（JOIN）の数
他の方法で対応可能な場合は、その方法への誘導を検討
- 結合（JOIN）が多い場合は、ビュー（view）やテーブルを使用
- 大量のデータ処理時にはクラスタリング
- 大量のデータを保有する場合は、パーティショニングによるデータ分割
- インデックスのメンテナンス
- アプリケーションのロジック変更

スーパー／サブタイプデータモデル変換技術

個別に発生するトランザクション → 個別テーブルスーパー＋サブタイプ → スーパー＋サブテーブル全体 → 単一のテーブル

PKの順序を決定する基準

インデックスを効率的に利用できるよう指定
先頭にある属性の値が比較対象となること
可能な限り「=」、「BETWEEN」、「<>」

分散データベースの長所および短所

長所

局所性、システムの容量を段階的に拡張可能
信頼性と可用性／有用性と柔軟性
高速な応答速度、通信コストの削減、地域ユーザーのニーズへの対応力向上
データの可用性と信頼性の向上、システム規模の調整

短所

開発コストおよびエラー発生の可能性の増加、処理コストの増加、データの完全性を脅かす
設計プロセスの困難さ、管理の複雑さとコスト、不安定な応答速度、制御の難しさ

第2章

SQL文の種類

DCL

Data Control Language、権限を管理するコマンド

GRANT

権限を付与する役割
``GRANT {permission} ON {table} TO {user};`

の形式で使用

```text
WITH GRANT, WITH ADMIN의 비교

GRANT: 특정 사용자에게 권한 부여가 가능한 권한을 부여, 부여한 부모의 권한이 회수될 때 자식의 권한도 회수
ADMIN: 테이블에 대한 모든 권한을 부여, 부여한 부모의 권한 회수와 관계 없는 권한
```

REVOKE

権限を取り消す役割
``REVOKE {permission} ON {table} FROM {user};`

` の形式で使用

権限の種類

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、データを定義するコマンド

SQL Server では Auto Commit をサポート

CREATE

テーブル構造の作成
「CREATE TABLE {table_name} {table_elements};

」の形式で使用

```sql
CREATE TABLE EXAMPLE (
/* 
  컬럼명은 영어, 한글, 숫자 전부 가능 
  첫 글자를 문자로 지정해야 하며, 컬럼의 데이터 타입은 반드시 설정해야 한다.
*/
		NAME  varchar2(max_length)  -- 최대 길이를 가진 가변길이 문자열
  	ID번호 char(length)          -- 고정된 길이 문자열
		나이_2 number(max_length)    -- 숫자형 데이터 타입
  	생일   date                  -- 날짜형 데이터 타입
);
```

##### CONSTRAINT (制約)

* default: デフォルト値の指定

* not null: NULL値の入力不可

* primary key: 主キーの指定 (not null, unique, 複数可)

* foreign key: 外部キーの指定 (複数可)

ALTER

テーブルおよびカラムに対して、名前や属性の変更、追加、削除などの構造修正を行う
「ALTER TABLE {table_name} {detail_order} {detail_property(if need)} TO {change_target};

」の形式で使用

#### 詳細なコマンド

* RENAME: テーブル、カラムの名前を変更

* MODIFY: カラムの属性を変更

* ADD: カラムを追加

* DROP: カラムを削除

* ADD CONSTRAINT / DROP CONSTRAINT: 制約を追加、削除

RENAME

ALTERを使用せずに、テーブルやカラムの名前を変更できる
複数のテーブル名を同時に変更可能

DROP

ALTERを使用せずに、テーブルやカラムを削除できる

#### TABLE {table_name} CASCADE CONSTRAINT

* Oracleにのみ存在するオプションで、SQL Serverには存在しない

* 外部キー制約において、参照テーブルを先に削除し、その後、対象テーブルを削除する。

* 対象テーブルのデータおよび外部キー参照制約もすべて削除する

TRUNCATE

テーブルの初期化（削除ではない！）
内部データのみが削除され、テーブルの存在およびカラムは残る。

#### DROP vs TRUNCATE vs DELETE

* DROP: テーブルを丸ごと削除した後、メモリを解放

* TRUNCATE: テーブル、カラムの存在は残り、残りのデータに対するメモリを解放

* DELETE: レコードを削除。データに対するログが残るため、反映されるまではロールバックが可能。メモリは解放されない

DML

Data Manipulation Language（データ操作言語）。レコードを操作するコマンド

INSERT

データをレコードに入力
``INSERT INTO {table_name} {column_name} VALUES {change_column_name};`

` の形式で使用する

カラム名を指定しなくても入力可能だが、指定しない場合はすべての値を入力する必要がある。

UPDATE

既存のデータを修正
``UPDATE {table_name} SET {column_name} = {column_value} WHERE {condition};`

` の形式で使用する

DELETE

既存のデータを削除
``DELETE FROM {table_name} WHERE {condition};`

` の形式で使用する

FROM は省略可能

SELECT

特定のデータを照会
``SELECT {select_target} FROM {select_origin} WHERE {condition};`

` の形式で使用する

``GROUP BY {calc_type} HAVING {condition} / ORDER BY {sort_condition}`

` の形式で条件を指定することもある

#### DISTINCT

重複値を除いて照会する条件 (a, b, NULL, a, b, NULL) =&gt; (a, b, NULL)

COUNT

(\*): NULL値を含めて全行数をカウント

({column\_name}): NULLを除いて特定のカラムの行数をカウント

TCL

Transaction Control Language、トランザクション制御コマンド

Transaction: DBの状態を変化させる操作

* transaction의 특징
고립성: 실행되는 동안 다른 transaction에 영향을 받아 잘못된 결과를 만들면 안됨
일관성: 실행 전 데이터베이스에 잘못된 점이 없다면 transaction 수행 후에도 내용에 오류가 있으면 안됨
지속성: transaction이 갱신한 데이터베이스 내용은 영구적으로 저장
원자성: transaction에서 정의한 연산은 모두 성공적으로 실행되거나 전혀 실행되지 않음 (All or Nothing)

COMMIT

データへの変更をDBに反映

SAVEPOINT

コード分割の分岐点となるようsavepointを指定
``SAVEPOINT {savepoint_name};`

` の形式で使用

ROLLBACK

以前の状態に戻すコマンド
SAVEPOINTまたは直前のCOMMITまでロールバックが可能

*ROLLBACK TO {rollback_point};

の形式で使用

セーブポイントがない場合は、最新のCOMMIT時点に復元

TCLの効果

データ整合性の保証
永続的なデータ変更前に、変更内容を確認
論理的に関連する処理をグループ化して処理可能

関数

文字列関数

SELECT、WHEREなどの条件を指定する際によく使用される

LOWER

英字文字列を小文字に変換

UPPER

英字文字列を大文字に変換

CONCAT

2つの文字列を結合
Oracleの'||'、SQL Serverの'+'と同様の役割

SUBSTR

文字列のM番目の位置からN文字を残して削除

LENGTH, LEN

空白を含む文字列の長さ

TRIM, LTRIM, RTRIM

両端の指定された文字をすべて削除。指定された文字がない場合は空白を削除

数値型関数

ROUND

四捨五入

TRUNC

切り捨て

CEIL

それ以上の最小の整数

FLOOR

以下となる最大の整数

MOD

剰余演算

SIGN

正の数は1、0は0、負の数は-1を返す

ABS

絶対値

日付型関数

SYSDATE

クエリを実行している現在の日付および時刻を出力

EXTRACT

``EXTRACT ({information} FROM {data})`

` の形式で使用

日付型データから必要な値を抽出する方法

型変換

これらの関数を使用してデータ型を変更できる

TO_NUMBER

文字列 > 数値

TO_CHAR

数値、日付 > 文字列（フォーマットによって生成結果が異なる）

TO_DATE

文字列 > 日付（フォーマットによって生成結果が異なる）

基本構造

DECODE

IF文
条件がシンプルに整理できる場合

CASE WHEN

長くなったIF文
条件の整理に多くの行数が必要な場合

ORDER BY

取得したテーブルのソート
基準を複数使用可能

WHERE

IN, NOT IN: リスト内の値のいずれか一つでも一致、または不一致であれば条件を満たす
IS NULL, IS NOT NULL: NULLかどうかを判断して T / F を返す
BETWEEN a AND b: a と b の間に値が存在するかどうかを確認して T / F を返す（a と b を含む）
比較演算子：=、>、<、>=、<= など
A LIKE B：a に対して b と類似した文字列を検索する
%：1文字以上が存在することを意味する
_：1文字

명시적 형변환 vs 암시적 형변환

명시적 형변환: 함수를 활용하여 데이터 타입을 변경
암시적 형변환: 데이터베이스가 알아서 바꿔주는 것
>> 숫자 타입의 PK는 암묵적으로 인덱스가 되는데 데이터의 조회 등으로 암시적 형변환이 발생한 경우, 인덱스로 사용이 불가능

WITH

サブクエリを使用して、一時テーブルやビューのように使用可能
別名を指定可能
インラインビューまたは一時テーブルとして扱われる
``WITH {table_name} AS {table_condition}`

` の形式で使用

GROUP BY

条件に基づいてグループ化を行う命令
値の組み合わせが異なれば別のグループ

HAVING

グループ化後の状態に基づく条件文
COUNT（カウント）、SUM（合計）、AVG（平均）、MAX（最大）、MIN（最小）、STDDEV（標準偏差）、VARIAN（分散）など
DISTINCT（重複除去）、ALL（すべて）などの条件を使用可能

NULL関数

NVL、ISNULL

NULLの場合、別の値に変更する関数
データ型が異なる場合は使用できない

NVL2

NULLかどうかによって異なる結果を返す関数
NULLでない場合は第1引数、NULLの場合は第2引数を返す

NULLIF

2つの引数が同じ場合はNULLを返し、異なる場合は第1引数を返す

COALESCE

NULLではない最初の値を返す

GROUP関数

グループ化対象の列値、集計対象の列値はNULLとして出力される

一般的なグループ関数でも同様の結果を抽出できる

ROLLUP

部分合計と全体合計を表示する。
関数の引数が与えられた順序によって結果値が異なり、階層構造で集計値を返す。

CUBE

グループ化可能なすべてのケースについて、引数の集合を生成する

GROUPING SETS

括弧で囲んだ集合ごとの集計が可能

GROUPING

小計、合計などが計算された場合は1を返し、そうでない場合は0を返す関数

JOIN

一般的にテーブル間の結合であり、集合に類似している

テーブルとテーブル、結合結果とテーブル、結合結果同士のJOINが可能

関連する2つのテーブルに少なくとも1つの共通属性が存在する場合に適用可能

JOINを明示するANSI標準形式のクエリと、そうでない非標準形式のクエリが存在する。

JOINが列挙されている場合、一度に2つずつ処理され、すべてを同時に処理することはできない

共通部分

*

INNER JOIN
- 非標準形式の表記では、に省略
- 両方のテーブルの共通部分（交差）を結合
*

LEFT JOIN
- 非標準表記を使用する場合、左側に (+) を表記
- 左側のテーブルの全レコードと、右側のテーブルの共通部分のみを結合
RIGHT JOIN
- 非標準表記を使用する場合、右側に (+) を表記
- 右側のテーブルの全レコードと、左側のテーブルの共通レコードのみを結合
*

OUTER JOIN
- 両側に「+」を使用できないためOUTER JOINは使用できず、ANSI標準形式のクエリを使用する必要がある。
- UNIONとは異なり、共通属性が1つだけ存在しても適用可能。
和集合

*

UNION (ALL)
- 照会対象の列数が同じで、各列の属性が同一の場合に適用できる結合方式
- データ量は Data1 + Data2 となる。
- UNION ALL は重複データを削除せずに結合する
差集合

交集合を除外し、一つの集合のみを確認したい場合に適用可能

*

MINUS(Oracle)

EXCEPT(SQL Server)

結合対象間の一致度
- EQUI JOIN: 同一の列を使用して2つのリレーションを結合
- non-EQUI JOIN: 正確に一致しない列を使用して2つのリレーションを結合
```
ex) A.key <, >, <=, >= B.key
```

CROSS JOIN

キーなしでJOINすると、2つのテーブルに対してデカルト積が発生する
```
5개의 행 * 3개의 행 = 15개의 행으로 조회
```

SELF JOIN

1つのテーブル内で関連性を持つ2つのカラム間のJOIN
テーブル名およびカラム名がすべて一致するため、ALIASの使用が必須

オプティマイザ・ジョイン

JOINを実行する過程で、パフォーマンス最適化のための方式を選択し、Hintとして指定する

階層型クエリ

ツリー形式のデータに対してクエリを実行すること

階層構造の開始点はSTART WITHで設定（ROOT NODE）
子ノードを持たないノード = LEAF NODE
階層をLEVELで表記

CONNECT BY

階層構造の接続方向性を確認
- 子 > 親
- 親 > 子

##### CONNECT BY PRIOR a = b

* a 列と b 列が同一レコード間で階層化が発生

* b -&gt; a の順に再配置

SIBLINGS BY

兄弟ノード間の配置順序を決定

WINDOW関数

レコード間の関係を簡単に定義するための関数。

SELECT WINDOW_FUNCTION {arguments} OVER {partition by column} {order_style} FROM {table};

の形式で使用

WINDOW_FUNCTION

ウィンドウ関数
- グループ内の集計関数：COUNT、SUM、MIN、MAX、AVGなど
- グループ内の順位関数
  
  順位関数を作成しても自動的にソートは行われないため、ORDER BY句を活用する必要がある。
  
  *
  
  RANK
  - 同一の順位に対しては同一の順位を付与
  - 同一の順位を1件としてカウントしない
  *
  
  DENSE_RANK
  - 同一順位には同一の順位を付与
  - 同一順位を1件としてカウント
  *
  
  ROW_NUMBER
  - 同一順位には一意の順位を付与
- グループ内の比率関連関数
  
  *
  
  PERCENT_RANK
  - 値ではなく「順序」を対象とし、パーティション内での順序ごとの百分率を照会する
  *
  
  NTILE(n)
  - パーティションごとに総件数をn等分した値を返す
  *
  
  CUME_DIST
  - パーティション全体において、現在の行の値以下のレコード数に対する累積割合を取得する
  - 累積分布上で0～1の値をとる
- グループ内の行順序関数
  
  *
  
  FIRST_VALUE
  - パーティション内で最初に現れる値を返す
  *
  
  LAST_VALUE
  - パーティション内で最後に現れる値を返す
  *
  
  LAG(column_name, record_difference)
  - 前の行を取得する
  *
  
  LEAD(column_name, record_difference, value_if_null)
  - 次の行を取得する。
  - DEFAULT = 1

ARGUMENTS

引数（列名など、関数の処理が行われる対象）

PARTITION BY

テーブルのレコードを分割する基準

ORDER BY

分割されたレコード内、またはテーブル全体において、レコードをどのような基準で並べ替えるかを指定

WINDOWING

関数の演算対象となるレコードの範囲を指定

*

RANGE
- 範囲指定時に使用
*

BETWEEN a AND b
- aからbまでを適用
*

UNBOUNDED PRECEDING
- 開始位置 = 最初の行
*

UNBOUNDED FOLLOWING
- 開始位置 = 最後の行
*

CURRENT ROW
- 開始位置 = 現在の行

テーブルパーティション

大容量のテーブルを複数のデータファイルに分割して保存すること

物理的に分離されたデータファイルに保存 => パフォーマンスの向上および独立した管理が可能

検索範囲を狭める効果 => パフォーマンスの向上

RANGE PARTITION

値の範囲を基準にパーティションを分割して保存する方法

LIST PARTITION

特定の値を基準に分割

ハッシュパーティション

データベース管理システムが独自にハッシュ関数を使用して分割・管理する方式

オプティマイザ

同じSQL文であっても、その実行方法によってパフォーマンスが異なる（パフォーマンスの指標：所要時間、リソース使用量など）

したがって、SQL文を分析し、一定の基準に基づいて実行計画を立てる必要があり、この際にオプティマイザを使用する。

オプティマイザは実行パフォーマンスに影響を与える可能性はあるが、結果値は変わらない。

SQL문 작성 => 파싱 (문법 검사, 구문 분석) => 옵티마이저 (비용 기반 / 규칙 기반) => 실행 계획 (PLAN_TABLE 저장) => SQL 실행

コストベース

最新のOracleでは、コストベースのオプティマイザがデフォルトで使用される
システム統計とオブジェクト統計を通じて、当該SQL文の実行にかかる総コストを計算した後、最小コストの実行計画を策定

コストベース

最新のOracleでは、コストベースのオプティマイザがデフォルトで使用される
システム統計とオブジェクト統計を通じて、当該SQL文の実行にかかる総コストを計算し、最小コストの実行計画を策定する

ルールベース

15種類の優先順位に基づいて実行計画を策定する
一般的に、ROWIDに基づいてスキャンすることが最も優先順位が高い

インデックス

インデックスキーに基づいてソートされる => 検索が高速化される
PKは自動的にインデックス化される
1つのテーブルに複数のインデックスを作成でき、1つのインデックスが複数のカラムで構成されることもある
降順で作成およびソートされる
頻繁に変化する属性をインデックスに設定するのは好ましくない
セカンダリインデックスには、UNIQUE属性のインデックスでない限り、重複データの入力が可能である。
インデックススキャンよりもフルスキャンの方が効率的であり、コスト面でも有利な場合がある
パーティションテーブルでは、パーティションに対してパーティションキーインデックスを作成可能であり、これをグローバルインデックスと呼ぶ
インデックスが増えると当然データ量も増加するため、挿入、削除、更新の速度低下を招く可能性がある
すべてのデータ型でインデックスの作成が可能
インデックスの種類として、シーケンシャルインデックス、ビットマップ、結合インデックス、クラスター、ハッシュインデックスが存在する。

#### SCAN方式

*<br />



  ##### Index Unique SCAN

  * インデックスキーの値が重複しない場合、そのキーを通じて検索を行う

*<br />



  ##### Index Unique SCAN

  * 特定の範囲を照会するWHERE句を使用して、該当領域をスキャン

  * 範囲によっては、1件または0件の結果が出力されることもある

*<br />



  ##### Index Full SCAN

  * インデックスの先頭から末尾まで全てをスキャン

オプティマイザ結合の種類

#### Nested Loop JOIN

* 外部（先行、Driving）テーブルを先に検索して結合対象データを見つけ、内部（後続）テーブルと結合

* 先行テーブルの処理範囲によって処理量が決定されるため、先行テーブルのサイズが小さいものを見つける必要がある

* 行間処理、テーブル間処理のいずれも順次発生

* 最適な順序を見つけることが重要

* ランダムアクセスが発生するため（先行テーブルから2番目のテーブルを参照する際に発生）、パフォーマンスの遅延を低減するために、ランダムアクセスの発生を少なくする必要がある

* 先行テーブルの処理範囲が広かったり、ランダムアクセスの範囲が広かったりする場合は、SORT MERGE JOINよりも不利になるケースがある

* 「インデックス必須」、一意インデックスの場合は有利

* オンライントランザクション処理（OLTP）に有用

* ネストされたループと同じ形式で、先行テーブルの条件を満たすケースの数だけ反復的に実行

#### ソートマージ結合（Sort Merge JOIN）

* 2つのテーブルをそれぞれソートし、完了後にマージ

* ソートが発生するため、データ量が多い場合は処理が遅くなる。

* ソート対象のデータ量が多い場合、一時ディスクを使用するため、パフォーマンスが低下する。

* EQIU JOIN、non-EQIU JOINの両方が可能

HASH JOIN

* 2つのテーブルのうち小さい方のテーブルをHASHメモリにロードし、2つのテーブルのJOINキーを使用してハッシュテーブルを作成

* 2つのテーブルを同時にスキャン

* 先行テーブルには「データ量の少ない方」が先に来る必要がある

* システムリソースを最大限に活用可能だが、リソースを過剰に消費する可能性があり、負荷などの懸念がある

* 大容量処理において高速な処理速度を示す

* EQUI JOINでのみ可能

* インデックスを使用しない

* JOIN方式

  ```text
  먼저 선행 테이블을 결정, 선행 테이블에서 주어진 조건에 해당하는 레코드를 선택
  해당 행이 선택되면 JOIN Key를 기준으로 해시 함수를 사용
  해시 테이블을 메인 메모리에 생성, 후행 테이블에서 주어진 조건을 만족하는 행을 찾음
  후행 테이블의 JOIN Key를 사용해서 해시함수를 적용, 해당 버킷을 검색
  ```

PL/SQL

SQLを拡張し、多様な手続き型プログラミングを可能にした言語

ブロック構造になっているため、機能別にモジュール化が可能
DECLARE文で始まり、変数および定数を宣言して使用可能
- DECLARE、BEGIN ～ ENDは必須、EXCEPTIONは任意
DML、IF、LOOPなど、様々な手続き型言語を使用
Oracleに組み込まれており、同じ言語を使用するプログラムとの互換性がある
アプリケーションのパフォーマンスを向上させる
Procedure、User Defined Function、Triggerオブジェクトを作成できる。
- プロシージャ内部に記述された手続き型コードはPL/SQLエンジンが処理し、一般的なSQL文はSQL実行エンジンが処理する。

分散データベース

単一のデータベースシステム（DBMS）がネットワークを介して物理的に分離されたデータベース群を制御する形態のDB

性能向上：分散データベースは並列処理を行うため、処理速度が速い
モジュール化されているため、他のモジュールに影響を与えることなくシステムの更新が可能
分散データベースの追加による容量の拡張が可能
重要データの保護が容易
信頼性が高い
管理および制御の難しさ
セキュリティ管理、整合性制御の難しさ
複雑な構造

메모

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] ゲリマンダーリング

Mon, 07 Nov 2022 11:14:53 GMT

問題リンク

BOJ 17471

カテゴリ

幅優先探索(bfs)、ブルートフォースアルゴリズム(bruteforcing)、組み合わせ論(combinatorics)、深さ優先探索(dfs)、グラフ理論(graphs)、グラフ探索(graph_traversal)、数学(math)

説明

最初は、この問題をユニオン・ファインド問題だと考えてアプローチし、辺を削除してみたり、他の制約条件を設定してみたりしたが、むしろ正直にアプローチして解くべき問題だった。

0.5秒という制約条件を取り除いてみると、すべての組み合わせについて深さ優先探索を通じてチェックしようという考えが浮かぶが、Pythonを使用していたため、時間が短く与えられると正直な解法を排除してしまうことが敗因となった。

区域の数が最大10個と限られていることを考慮すれば、十分にブルートフォースで解決可能であり、かえって別の方向に力を注ぐと痛い目を見る問題だ。

したがって、この問題はすべての区域を2つに分割して選挙区が成立するかを確認し、成立する場合は2つの選挙区の人口差を確認して、既存の人口差の値より小さい値が出たら更新するという方向で解決できる。

解答コード

# 게리맨더링

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] 数列とクエリ 17

Tue, 01 Nov 2022 13:52:01 GMT

問題リンク

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

)

カテゴリ

セグメントツリー(segtree)、データ構造(data_structures)

説明

セグメントツリーを初めて学ぶ人が最もよく遭遇するセグメントツリー系の問題だと考えられる。

区間和、区間積、区間内の最大値など、様々な値について、線形リストを基準としたO(NlogN)の時間で構築でき、各区間に関する情報にO(logN)という高速な速度でアクセスできるという利点がある。

この問題は、大きく分けてセグメントツリーを構築する関数、区間情報を検索する関数、変更された値を反映する関数に分けることができる。

生成関数

まず、セグメントツリーを生成する関数

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]

を見ると、基本的にはリスト全体を区間ごとに分割し、各区間に関する情報をセグメントツリーの各ノードに格納する過程を示している。

再帰方式を使用しているため、区間の長さが1になるまで再帰が進行するにつれて再帰スタックが積み上げられ、到達した場合はそのアドレスにリスト1つの値に関する情報を入力する。

その後、返された値を通じて、リーフノードではないノードは条件に合う値を選別しながら、最終的にルートに到達することになる。

したがって、ルートノードに含まれる値は、全区間において問題で要求された条件に最も適合する値となる。

探索関数

次に、区間内の最小値を探す関数について確認すると、

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)

基本的に、探している区間が含まれている場所であれば詳細に処理を進め、完全に探している区間のみが含まれるようになるまで処理を行い、その値を返して親関数で確認できるようにコードを構成した。

もし範囲外の場合はNoneを返すようにし、条件を通じてPruningを行うだけで、完全に範囲内にある区間のみを選択して比較することができる。

修正関数

最後に、値の修正が行われた場合に反映する関数を見てみよう。


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])

現在変更された値のインデックスが含まれる区間であればすべて変更する必要があるため、そのインデックスを含む区間かどうかを基準に判別を行う。

生成関数と同様に、1つのインデックスに絞り込まれるまで再帰スタックを積み上げ、そのインデックス1つだけを含むノードの値の変更から返却を進めながら修正された値を反映し、最終的にルートノードまでチェックして完了することになる。

解答コード

上記の過程を通じて、問題で要求された動作をすべてモジュール化することができ、以下に全体コードを確認できる。

# 수열과 쿼리 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入門

Fri, 28 Oct 2022 13:19:01 GMT

はじめに

Gitについて学習する中で、必要な内容をまとめた記事です。大きな変更がない限り、あるいは追加の学習が必要とならない限り、これがイントロであり、最後の記事になると思います。

Gitとは？

バージョン管理ツールの一種であり、バージョン管理を通じてファイルの変更履歴を記録し、特定の時点の状態を再び利用できるようにするシステムです。

ローカルでのバージョン管理

ディレクトリのコピー
- 最も単純な方法
- 誤ってファイルを間違って修正したり、間違ってコピーしたりする可能性がある。
VCS (Version Control System)
- DBを活用してファイルの変更情報を管理
- Revision Control Systemが代表的
- Patch Set（ファイルの変更部分）を管理
- 一連のPatch Setを活用して、すべてのファイルを特定の時点に戻すことができる

集中型バージョン管理

プロジェクトを進める場合、他の開発者との共同作業が頻繁にある
このような場合、ファイルを管理するサーバーが別途存在し、クライアントが中央サーバーからファイルを取得して使用する方式が有利
中央サーバーに問題が発生した場合、システムのバックアップが存在しなければすべての履歴を失う可能性があり、これはローカルにも存在していた問題

分散型バージョン管理システム

単にスナップショットを保管するだけでなく、リポジトリと履歴を同時に複製する。
サーバーに問題が発生した場合、その複製を通じて作業を再開できる
クライアントの中からどれか一つを選んでサーバーを復元することも可能
リモートリポジトリの存在により、多様な形式のコラボレーションが可能
GitHubもこのリモートリポジトリの一種

一般的な使用法

設定およびファイルアクセスコマンド

# 전역 사용자 설정
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 # 브랜치를 시각화하여 분기를 표현한 그래프 형태로 정보를 표시

リポジトリ管理に使用するコマンド

git status # 변경사항을 확인하는 명령어
git commit -m {message} # 현재 스테이지에 존재하는 변경 사항을 커밋

git add {file_name} # 특정한 파일을 스테이지에 추가하는 경우
git add . # 해당 레포지토리의 변경사항을 전부 스테이지에 추가하는 경우

Gitの取り消し

ステージのクリア

git rm --cached # root commit이 존재하지 않을 때
git restore --staged # root commit이 존재할 때

コミットの修正

git commit --amend 
# 스테이지에 파일이 없는 경우: 직전 커밋의 메시지를 수정
# 스테이지에 파일이 있는 경우: 기존 커밋에 현재 스테이지를 더하여 덮어쓰기 진행

コミットを特定の時点まですべて元に戻す

git reset --soft {commit_id} # 미래 파일들 전부 stage에 돌려놓음
git reset --mixed {commit_id} # default, 미래 파일들을 전부 working directory에 유지 (add 필요)
git reset --hard {commit_id} # 미래 파일 전부 제거

過去のコミットを削除

git revert {commit_id} # 과거 commit을 제거 후, 제거했음을 commit으로 추가

resetはコミット数が減るため共同作業には不向き。したがって、共同作業時はresetの代わりにrevertの使用を推奨

Git Branch

Branch: 作業領域を分割し、独立して作業できるようにする仕組み

元の状態を維持できるため安全
1つのブランチで1つの作業を進めることで、共同作業の効率が向上
Gitの場合、ブランチの作成速度も速く、ファイル容量も大きくない

Git Merge

分岐したブランチを統合するプロセス

マージの種類

Fast-Forward: ブランチが指すコミットを先頭に移動
3-Way Merge: 各ブランチの最新のコミット2つ + 両ブランチの共通の祖先を使用したマージ
Merge Conflict: 同じファイルを修正した場合に発生する衝突 => 衝突を解決した後、3-Way Mergeを実行

# 해당 브랜치를 현재 위치한 브랜치에 병합
git merge {merged_branch}

Git Fork

所有権のないリモートリポジトリを複製すること。主にオープンソースのような、多数の協力者がいる場合に使用される

Forkされたソースに自分のコミットが反映されるプロセス

#
#    원본 원격 저장소 (upstream) <----------- 복제본 원격 저장소 (origin)
#                \           merge request      /|
#                 \                              |
#                  \                 push branch | pull master
#                   \                            |
#                    \     ( pull upstream )     |/
#                     ------------------> 로컬 저장소 (user)
#

元のリポジトリを自分のリモートリポジトリに複製
当該リモートリポジトリからローカルに保存
ローカルでブランチを作成し、作業後にその変更をコミット
元のリモートリポジトリに変更内容に関するマージリクエストをプッシュ
元のリモートリポジトリでその変更をマージ
元のリモートリポジトリから変更内容をプル
- pull upstream
- sync origin & pull origin
ローカルでマージされた自分のブランチを削除

[BOJ 7579, Python] アプリ

Fri, 28 Oct 2022 10:13:23 GMT

問題リンク

BOJ 7579

分類

ダイナミックプログラミング(dp), バックパック問題(knapsack)

説明

この問題を解く時、個人的に重要視した部分を挙げるなら、問題条件だと思います。

使用中のメモリバイトの条件は10^7で、活性化アプリの数は最大100個、コストの場合も100以下の条件を満たさなければなりませんでした。

数値を確認する用途でメモリバイト条件を活用するには範囲が非常に広く、それに応じて適切な変数でコストを設定し、すべてのコストごとにアドレスを割り当てて最大限減らすことができるメモリを記録する方法を使うことにしました。

ここでDPを使わなければならないことを推測し、さらに、cost、value値がそれぞれ存在する時、値によって既存の値を更新する方式を使用したknapsackアルゴリズムを利用して解決するという設計を試みることができました。

解決コード

# 앱

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] 監視

Sun, 23 Oct 2022 10:46:34 GMT

問題リンク

BOJ 15683

分類

ブルートフォースアルゴリズム(bruteforcing)、実装(implementation)、シミュレーション(simulation)

説明

分類はブルートフォースアルゴリズムとなっている問題だが、この問題を実装する際にはバックトラッキングアルゴリズムを使用した。

基本的には、すべての監視カメラが見ることができる方向について調査を行い、すべての監視カメラの方向設定が完了した時点で関数を呼び出し、監視の死角の数を確認し、既存の最小値より小さければその値を更新するという方法を採用した。

解法を作成した後、すぐにコメント処理を行う傾向があるため、今後の投稿においても詳細な解法はコードのコメントに記載される予定。

解答コード

# 감시

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)

最初の投稿

Sat, 22 Oct 2022 18:26:40 GMT

以前は、記録を個人的なものとして、自分だけが読めるように整理していました。

しかし、それならわざわざきれいに整理する必要もないのではないかと思い、悩み始めました。そして、「きれいに整理して見やすい場所に掲載する」か「適当に書く」かの間で、見やすい場所に掲載することを選びました。

勉強してまとめた内容が、私自身にとっても、そして万が一この記事を読むことになった他の誰かのためにも、役立つことを願っています。

TraceofLight (JA)

Unity Roadshow 2026 で学んだ内容のまとめ

メモリの前提知識

基本内容

Page Fault

メモリ管理方法 (Windows vs Linux)

Unity GC における処理

Managed Heap

Garbage Collector

Segment

Unity GC の役割

GC.Collect を何度も呼ぶべきでない理由

Managed Heap の VM 使用量は増えるばかりで絶対に減らない

Unity Boehm GC

CoreCLR GC

移行の価値?

コンテナ環境についての簡単なメモ

コンテナ駆動原理

それでは、カーネル互換性がない場合は？

結論

VM

ボリュームバインディング。

ウィンドウズでchmodを無視する理由。

クラフトン・ジャングル・ゲームテックラボ修了レポート

はじめに

入学前の悩み

コースについて

では、どのような人が受講すべきか？

締めくくりの所感

Windows / macOS 統合ターミナル環境の構築

はじめに

[2026 Mac ターミナル完全設定 (Ghostty + Starship + AI コーディング環境)](https://blog.dnd.ac/settings-mac-terminal-2026/

目標設定

進行過程

問題の発生

結論

std::variant & std::visit

その他の情報

内部構造

1. Variant

2. Visit

[鐘萬冊] 02.問題解決戦略

問題解決のプロセス

1) 問題を読んで理解する

2) 再定義と抽象化

3) 計画を立てる

4) 計画を検証する

5) 計画を実行する

6) 回顧すること

問題解決戦略

1) 直感と体系的なアプローチ

[効果的なC++] item 02

#define よりもConst, Enum, Inlineをより好む。

[効果的なC++] item 01

C++ はマルチパラダイムのプログラミング言語

『Effective C++』はじめに

42Seoul ラピシン 口コミ

はじめに

ラピシン課程の進行

結果

Q & A

1. 基礎知識なしの非専攻者でも合格可能か？

2. どのような人にこのコースを勧めたいか？

3. 受講前に知っておくと良いこと？

4. コースを進めながら、ぜひやってみてほしいことは？

[簡単な用語整理] File System

はじめに

File Descriptor

基本割り当てディスクリプタ

Symbolic Link

cf) Hard Link

Block Device & Character Device

Raw Device

IO Scheduler

[BOJ 9519, CPP] 眠い

問題リンク

分類

説明

解答コード

[BOJ 4821, CPP] ページ数カウント

42Seoul ラピシン口コミ

2023年アシアナIDT 下半期採用選考の体験談