Migrate to Zensical (#1869)

* Fix Russian Ruby code extraction. * Add zensical configs.
2026-04-20 21:00:58 +08:00 · 2026-03-29 05:41:25 +08:00
parent bc4c5ec414
commit 7a78369e4c
84 changed files with 1302 additions and 445 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,12 +1,7 @@
-# macOS
 .DS_Store

-# editors
 .vscode/
-**/.idea
-
-# mkdocs files
-.cache/
+/node_modules

 # build
 /build
--- a/overrides/main.html
+++ b/overrides/main.html
@@ -9,6 +9,8 @@
    {% set announcements = 'Welcome to contribute to Chinese-to-English translation! For more details, please refer to <a href="https://github.com/krahets/hello-algo/blob/main/en/CONTRIBUTING.md">CONTRIBUTING.md</a>.' %}
 {% elif config.theme.language == 'ja' %}
    {% set announcements = '日本語版審閱者を募集しています！詳細は <a href="https://github.com/krahets/hello-algo/blob/main/ja/CONTRIBUTING.md">CONTRIBUTING.md</a> を参照してください。' %}
+{% elif config.theme.language == 'ru' %}
+    {% set announcements = 'Приглашаем вас участвовать в развитии русской версии! Подробнее <a href="/ru/chapter_appendix/contribution/">здесь</a>.' %}
 {% endif %}
 <div class="banner-svg">
    <svg xmlns="http://www.w3.org/2000/svg"
--- a/overrides/partials/.gitignore
+++ b/overrides/partials/.gitignore
@@ -1 +0,0 @@
-comments.html
--- a/overrides/partials/comments.html
+++ b/overrides/partials/comments.html
@@ -0,0 +1,71 @@
+{% if page.meta.comments %}
+  {% if config.theme.language == 'zh' %}
+    {% set comm = "欢迎在评论区留下你的见解、问题或建议" %}
+    {% set lang = "zh-CN" %}
+  {% elif config.theme.language == 'zh-Hant' %}
+    {% set comm = "歡迎在評論區留下你的見解、問題或建議" %}
+    {% set lang = "zh-TW" %}
+  {% elif config.theme.language == 'en' %}
+    {% set comm = "Feel free to drop your insights, questions or suggestions" %}
+    {% set lang = "en" %}
+  {% elif config.theme.language == 'ja' %}
+    {% set comm = "ご意見、ご質問、ご提案があればぜひコメントしてください" %}
+    {% set lang = "ja" %}
+  {% elif config.theme.language == 'ru' %}
+    {% set comm = "Оставляйте свои идеи, вопросы и предложения в комментариях" %}
+    {% set lang = "ru" %}
+  {% endif %}
+
+  <!-- Check-in button above comments -->
+  {% include "partials/checkin.html" ignore missing %}
+
+  <h5 align="center" id="__comments">{{ comm }}</h5>
+
+  <!-- Insert generated snippet here -->
+  <script
+    src="https://giscus.app/client.js"
+    data-repo="krahets/hello-algo"
+    data-repo-id="R_kgDOIXtSqw"
+    data-category="Announcements"
+    data-category-id="DIC_kwDOIXtSq84CSZk_"
+    data-mapping="pathname"
+    data-strict="1"
+    data-reactions-enabled="1"
+    data-emit-metadata="1"
+    data-input-position="top"
+    data-theme="light"
+    data-lang="{{ lang }}"
+    crossorigin="anonymous"
+    async
+  >
+  </script>
+  <!-- Synchronize Giscus theme with palette -->
+  <script>
+    var giscus = document.querySelector("script[src*=giscus]")
+
+    /* Set palette on initial load */
+    var palette = __md_get("__palette")
+    if (palette && typeof palette.color === "object") {
+      var theme = palette.color.scheme === "slate" ? "dark_dimmed" : "light"
+      giscus.setAttribute("data-theme", theme) 
+    }
+
+    /* Register event handlers after documented loaded */
+    document.addEventListener("DOMContentLoaded", function() {
+      var ref = document.querySelector("[data-md-component=palette]")
+      ref.addEventListener("change", function() {
+        var palette = __md_get("__palette")
+        if (palette && typeof palette.color === "object") {
+          var theme = palette.color.scheme === "slate" ? "dark_dimmed" : "light"
+
+          /* Instruct Giscus to change theme */
+          var frame = document.querySelector(".giscus-frame")
+          frame.contentWindow.postMessage(
+            { giscus: { setConfig: { theme } } },
+            "https://giscus.app"
+          )
+        }
+      })
+    })
+  </script>
+{% endif %}
--- a/overrides/zensical/stylesheets/extra.css
+++ b/overrides/zensical/stylesheets/extra.css
@@ -0,0 +1,770 @@
+/* Color Settings */
+/* https://github.com/squidfunk/mkdocs-material/blob/6b5035f5580f97532d664e3d1babf5f320e88ee9/src/assets/stylesheets/main/_colors.scss */
+/* https://squidfunk.github.io/mkdocs-material/setup/changing-the-colors/#custom-colors */
+:root>* {
+  --md-primary-fg-color: #ffffff;
+  --md-primary-bg-color: #1d1d20;
+
+  --md-default-fg-color: #1d1d20;
+  --md-default-bg-color: #ffffff;
+
+  --md-body-bg-color: #22272e;
+  --md-header-bg-color: rgba(255, 255, 255, 0.6);
+
+  --md-code-fg-color: #1d1d20;
+  --md-code-bg-color: #f5f5f5;
+
+  --md-accent-fg-color: #999;
+
+  --md-typeset-color: #1d1d20;
+  --md-typeset-a-color: #349890;
+
+  --md-typeset-btn-color: #55aea6;
+  --md-typeset-btn-hover-color: #52bbb1;
+
+  --md-admonition-icon--pythontutor: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M19.14 7.5A2.86 2.86 0 0 1 22 10.36v3.78A2.86 2.86 0 0 1 19.14 17H12c0 .39.32.96.71.96H17v1.68a2.86 2.86 0 0 1-2.86 2.86H9.86A2.86 2.86 0 0 1 7 19.64v-3.75a2.85 2.85 0 0 1 2.86-2.85h5.25a2.85 2.85 0 0 0 2.85-2.86V7.5h1.18m-4.28 11.79c-.4 0-.72.3-.72.89 0 .59.32.71.72.71a.71.71 0 0 0 .71-.71c0-.59-.32-.89-.71-.89m-10-1.79A2.86 2.86 0 0 1 2 14.64v-3.78A2.86 2.86 0 0 1 4.86 8H12c0-.39-.32-.96-.71-.96H7V5.36A2.86 2.86 0 0 1 9.86 2.5h4.28A2.86 2.86 0 0 1 17 5.36v3.75a2.85 2.85 0 0 1-2.86 2.85H8.89a2.85 2.85 0 0 0-2.85 2.86v2.68H4.86M9.14 5.71c.4 0 .72-.3.72-.89 0-.59-.32-.71-.72-.71-.39 0-.71.12-.71.71s.32.89.71.89Z"/></svg>');
+  --md-admonition-pythontutor-color: #eee;
+}
+
+[data-md-color-scheme="slate"] {
+  --theme-dark-base: #1E1E1E;
+  --theme-dark-mantle: #1A1A1A;
+  --theme-dark-crust: #171717;
+  --hero-starfield-bg-color: var(--theme-dark-base);
+
+  --md-primary-fg-color: var(--theme-dark-base);
+  --md-primary-bg-color: #adbac7;
+
+  --md-default-fg-color: #adbac7;
+  --md-default-bg-color: var(--theme-dark-base);
+
+  --md-body-bg-color: var(--theme-dark-mantle);
+  --md-header-bg-color: rgba(26, 26, 26, 0.8);
+
+  --md-code-fg-color: #adbac7;
+  --md-code-bg-color: var(--theme-dark-crust);
+
+  --md-accent-fg-color: #aaa;
+
+  --md-footer-fg-color: #adbac7;
+  --md-footer-bg-color: var(--theme-dark-mantle);
+
+  --md-typeset-color: #adbac7;
+  --md-typeset-a-color: #52bbb1;
+
+  --md-typeset-btn-color: #52bbb1;
+  --md-typeset-btn-hover-color: #55aea6;
+
+  --md-admonition-pythontutor-color: var(--theme-dark-crust);
+}
+
+[data-md-color-scheme="slate"][data-md-color-primary="black"],
+[data-md-color-scheme="slate"][data-md-color-primary="white"] {
+  --md-typeset-a-color: #52bbb1;
+}
+
+[data-md-color-scheme="slate"] .md-footer,
+[data-md-color-scheme="slate"] .md-footer__inner {
+  background-color: var(--theme-dark-mantle);
+  color: var(--md-footer-fg-color);
+}
+
+[data-md-color-scheme="slate"] .md-footer-meta {
+  background-color: var(--theme-dark-crust);
+  color: var(--md-footer-fg-color);
+}
+
+[data-md-color-scheme="slate"] .md-footer__link {
+  background-color: var(--theme-dark-crust);
+  color: var(--md-footer-fg-color);
+}
+
+[data-md-color-scheme="slate"] .md-footer__link:hover {
+  background-color: var(--theme-dark-base);
+}
+
+[data-md-color-scheme="slate"] .md-footer__title,
+[data-md-color-scheme="slate"] .md-footer__direction,
+[data-md-color-scheme="slate"] .md-footer__button,
+[data-md-color-scheme="slate"] .md-copyright,
+[data-md-color-scheme="slate"] .md-copyright a,
+[data-md-color-scheme="slate"] .md-social,
+[data-md-color-scheme="slate"] .md-social__link {
+  color: var(--md-footer-fg-color);
+}
+
+/* https://github.com/squidfunk/mkdocs-material/issues/4832#issuecomment-1374891676 */
+.md-nav__link[for] {
+  color: var(--md-default-fg-color) !important;
+}
+
+/* Figure class */
+.animation-figure {
+  border-radius: 0.3rem;
+  display: block;
+  margin: 0 auto;
+  box-shadow: var(--md-shadow-z2);
+}
+
+/* Cover image class */
+.cover-image {
+  width: 28rem;
+  height: auto;
+  border-radius: 0.3rem;
+  display: block;
+  margin: 0 auto;
+  box-shadow: var(--md-shadow-z2);
+}
+
+/* Center Markdown Tables (requires md_in_html extension) */
+.center-table {
+  text-align: center;
+}
+
+/* Reset alignment for table cells */
+.md-typeset .center-table :is(td, th):not([align]) {
+  text-align: initial;
+}
+
+/* Font size */
+.md-typeset {
+  font-size: 0.75rem;
+  line-height: 1.5;
+}
+
+.md-typeset pre {
+  font-size: 0.95em;
+}
+
+/* Markdown Header */
+/* https://github.com/squidfunk/mkdocs-material/blob/dcab57dd1cced4b77875c1aa1b53467c62709d31/src/assets/stylesheets/main/_typeset.scss */
+.md-typeset h1 {
+  font-weight: 400;
+  color: var(--md-default-fg-color);
+}
+
+.md-typeset h2 {
+  font-weight: 400;
+}
+
+.md-typeset h3 {
+  font-weight: 500;
+}
+
+.md-typeset h5 {
+  text-transform: none;
+}
+
+.md-typeset a:hover {
+  color: var(--md-typeset-a-color);
+  text-decoration: underline;
+}
+
+.md-typeset code {
+  border-radius: 0.2rem;
+}
+
+.highlight span.filename {
+  font-weight: normal;
+}
+
+/* font-family setting for Win10 */
+body {
+  --md-text-font-family: -apple-system, BlinkMacSystemFont,
+    var(--md-text-font, _), Helvetica, Arial, sans-serif;
+  --md-code-font-family: var(--md-code-font, _), SFMono-Regular, Consolas, Menlo,
+    -apple-system, BlinkMacSystemFont, var(--md-text-font, _), monospace;
+}
+
+/* max height of code block */
+/* https://github.com/squidfunk/mkdocs-material/issues/3444 */
+.md-typeset pre>code {
+  max-height: 25rem;
+}
+
+/* Keep code block scrollbar hover neutral instead of accent-colored */
+.md-typeset pre>code:hover {
+  scrollbar-color: var(--md-default-fg-color--lighter) transparent;
+}
+
+.md-typeset pre>code::-webkit-scrollbar-thumb:hover {
+  background-color: var(--md-default-fg-color--lighter);
+}
+
+/* Make the picture not glare in dark theme */
+[data-md-color-scheme="slate"] .md-typeset img,
+[data-md-color-scheme="slate"] .md-typeset svg,
+[data-md-color-scheme="slate"] .md-typeset video {
+  filter: brightness(0.85) invert(0.05);
+}
+
+/* landing page */
+.header-img-div {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin: 0 auto;
+  width: 100%;
+  /* Default to full width */
+}
+
+/* Admonition for python tutor */
+.md-typeset .admonition.pythontutor,
+.md-typeset details.pythontutor {
+  border-color: var(--md-default-fg-color--lightest);
+  margin-top: 0;
+  margin-bottom: 1.5625em;
+}
+
+.md-typeset .pythontutor>.admonition-title,
+.md-typeset .pythontutor>summary {
+  background-color: var(--md-code-bg-color);
+}
+
+.md-typeset .pythontutor>.admonition-title::before,
+.md-typeset .pythontutor>summary::before {
+  background-color: rgb(55, 118, 171);
+  -webkit-mask-image: var(--md-admonition-icon--pythontutor);
+  mask-image: var(--md-admonition-icon--pythontutor);
+}
+
+/* code block tabs */
+.md-typeset .tabbed-labels>label {
+  font-size: 0.61rem;
+}
+
+.md-typeset .tabbed-labels--linked>label>a {
+  padding: .78125em 1.0em .625em;
+}
+
+/* header banner */
+.md-banner {
+  background-color: var(--md-code-bg-color);
+  color: var(--md-default-fg-color);
+  font-size: 0.75rem;
+}
+
+.md-banner .banner-svg svg {
+  margin-right: 0.3rem;
+  height: 0.63rem;
+  fill: var(--md-default-fg-color);
+}
+
+.pythontutor-iframe {
+  width: 125%;
+  height: 125%;
+  max-width: 125% !important;
+  max-height: 125% !important;
+  transform: scale(0.8);
+  transform-origin: top left;
+  border: none;
+}
+
+/* landing page container */
+.home-div {
+  width: 100%;
+  height: auto;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  background-color: var(--md-default-bg-color);
+  color: var(--md-default-fg-color);
+  font-size: 0.9rem;
+  padding: 3em 2em;
+  text-align: center;
+}
+
+.section-content {
+  width: 100%;
+  height: auto;
+  max-width: 70vw;
+}
+
+/* rounded button */
+.rounded-button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: 10em;
+  margin: 0 0.1em;
+  padding: 0.6em 1.3em;
+  border: none;
+  background-color: var(--md-typeset-btn-color);
+  color: var(--md-primary-fg-color) !important;
+  text-align: center;
+  text-decoration: none;
+  cursor: pointer;
+}
+
+.rounded-button:hover {
+  background-color: var(--md-typeset-btn-hover-color);
+}
+
+.rounded-button span {
+  margin: 0;
+  margin-bottom: 0.07em;
+  white-space: nowrap;
+}
+
+.rounded-button svg {
+  fill: var(--md-primary-fg-color);
+  width: auto;
+  height: 1.2em;
+  margin-right: 0.5em;
+}
+
+/* device image */
+.device-on-hover {
+  width: auto;
+  transition: transform 0.3s ease-in-out, filter 0.3s ease-in-out;
+}
+
+a:hover .device-on-hover {
+  filter: drop-shadow(0 0 0.2rem rgba(0, 0, 0, 0.15));
+  transform: scale(1.01);
+}
+
+/* text button */
+.reading-media {
+  display: flex;
+  justify-content: center;
+  align-items: flex-end;
+  height: 32vw;
+}
+
+.media-block {
+  height: 100%;
+  margin: 0 0.2em;
+}
+
+.text-button {
+  width: auto;
+  color: var(--md-typeset-btn-color);
+  text-decoration: none;
+  text-align: center;
+  margin: 2.7em auto;
+}
+
+.text-button span {
+  white-space: nowrap;
+}
+
+.text-button svg {
+  display: inline-block;
+  fill: var(--md-typeset-btn-color);
+  width: auto;
+  height: 0.9em;
+  background-size: cover;
+  padding-top: 0.17em;
+  margin-left: 0.15em;
+}
+
+a:hover .text-button span {
+  text-decoration: underline;
+}
+
+/* hero image */
+.hero-div {
+  height: min(84vh, 75vw);
+  width: min(112vh, 100vw);
+  margin: 0 auto;
+  margin-top: -2.4rem;
+  padding: 0;
+  position: relative;
+  font-size: min(1.8vh, 2.5vw);
+  font-weight: normal;
+}
+
+.hero-bg {
+  height: 100%;
+  width: 100%;
+  object-fit: cover;
+  position: absolute;
+}
+
+/* hover on the planets */
+.hero-div>a>img {
+  width: auto;
+  position: absolute;
+  transition: transform 0.3s ease-in-out, filter 0.3s ease-in-out;
+}
+
+.hero-div>a>span {
+  margin: 0;
+  position: absolute;
+  transform: translateX(-50%) translateY(-50%);
+  white-space: nowrap;
+  /* prevent line breaks */
+  color: white;
+}
+
+.hero-div>a:hover>img {
+  filter: brightness(1.15) saturate(1.1) drop-shadow(0 0 0.5rem rgba(255, 255, 255, 0.2));
+  transform: scale(1.03);
+}
+
+.hero-div>a:hover>span {
+  text-decoration: underline;
+  color: var(--md-typeset-btn-color);
+}
+
+.heading-div {
+  width: 100%;
+  position: absolute;
+  transform: translateX(-50%);
+  left: 50%;
+  bottom: min(2vh, 3vw);
+  pointer-events: none;
+  color: #fff;
+}
+
+/* code badge */
+.code-badge {
+  width: 100%;
+  height: auto;
+  margin: 1em auto;
+}
+
+.code-badge img {
+  height: 1.07em;
+  width: auto;
+}
+
+/* brief intro */
+.intro-container {
+  display: flex;
+  align-items: center;
+  margin: 2em auto;
+}
+
+.intro-image {
+  flex-shrink: 0;
+  flex-grow: 0;
+  width: 50%;
+  border-radius: 0.5em;
+  box-shadow: var(--md-shadow-z2);
+}
+
+.intro-text {
+  flex-grow: 1;
+  /* fill the space */
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  text-align: left;
+  align-items: flex-start;
+  width: fit-content;
+  margin: 2em;
+}
+
+.intro-text>div {
+  align-self: flex-start;
+  width: auto;
+  margin: 0 auto;
+}
+
+.endor-text {
+  width: 50%;
+}
+
+.intro-quote {
+  color: var(--md-accent-fg-color);
+  font-weight: bold;
+}
+
+/* contributors table */
+.profile-div {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: center;
+  max-width: 40em;
+  margin: 1em auto;
+}
+
+.profile-cell {
+  flex: 1 1 15%;
+  margin: 1em 0;
+  text-align: center;
+}
+
+.profile-img {
+  width: 5em;
+  border-radius: 50%;
+  margin-bottom: 0.5em;
+}
+
+.translator-profile-div {
+  gap: 0.5em;
+}
+
+.translator-profile-cell {
+  flex: 0 0 auto;
+  margin: 0.5em 0;
+  min-width: 8.5em;
+}
+
+.giscus-container {
+  width: 40em;
+  max-width: 100%;
+  margin: 0 auto;
+}
+
+/* Hide navigation */
+@media screen and (max-width: 76.25em) {
+  .section-content {
+    max-width: 95vw;
+  }
+
+  .reading-media {
+    height: 33vw;
+  }
+
+  .contrib-image {
+    width: 100%;
+  }
+}
+
+/* mobile devices */
+@media screen and (max-width: 60em) {
+  .home-div {
+    font-size: 0.75rem;
+  }
+
+  .hero-div {
+    margin-top: -4rem;
+  }
+
+  .intro-container {
+    flex-direction: column;
+  }
+
+  .intro-text {
+    width: auto;
+    order: 2;
+    margin: 0 auto;
+  }
+
+  .endor-text {
+    width: auto;
+    margin: 0 auto;
+  }
+
+  .intro-image {
+    width: 100%;
+    order: 1;
+    margin-bottom: 1em;
+  }
+
+  .text-button {
+    margin: 0.7em auto;
+  }
+
+  .profile-cell {
+    flex: 1 1 30%;
+  }
+}
+
+.video-container {
+  position: relative;
+  padding-bottom: 56.25%;
+  /* 16:9 */
+  height: 0;
+}
+
+.video-container iframe {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+
+/* starfield */
+.starfield {
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  z-index: 0;
+  background-color: var(--hero-starfield-bg-color, transparent);
+}
+
+.starfield-origin {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+}
+
+/* Zensical-specific adjustments merged into the main stylesheet. */
+:root>* {
+  --md-accent-fg-color: var(--md-typeset-a-color);
+  --md-admonition-pythontutor-color: var(--md-code-bg-color);
+  --hello-algo-sidebar-width: 13rem;
+}
+
+[data-md-color-scheme="slate"] {
+  --md-accent-fg-color: var(--md-typeset-a-color);
+  --md-admonition-pythontutor-color: var(--md-code-bg-color);
+  --md-body-bg-color: var(--md-default-bg-color);
+  --md-default-bg-color--light: rgb(30 30 30 / 0.8);
+}
+
+[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary),
+[data-md-color-scheme="slate"] .md-typeset details.pythontutor[open]> :not(summary) :is(p, li, strong, em, sub, sup, code, a) {
+  background-color: #f5f5f5;
+  color: #1d1d20;
+}
+
+body {
+  background-color: var(--md-default-bg-color);
+}
+
+html:has(body[data-md-color-scheme="slate"]) {
+  background-color: #1e1e1e;
+}
+
+html:has(body[data-md-color-scheme="default"]) {
+  background-color: #ffffff;
+}
+
+.home-div[data-md-color-scheme="default"],
+.home-div[data-md-color-scheme="default"] h1,
+.home-div[data-md-color-scheme="default"] h2,
+.home-div[data-md-color-scheme="default"] h3,
+.home-div[data-md-color-scheme="default"] h4,
+.home-div[data-md-color-scheme="default"] h5,
+.home-div[data-md-color-scheme="default"] h6 {
+  color: var(--md-default-fg-color);
+}
+
+.home-div[data-md-color-scheme="slate"],
+.home-div[data-md-color-scheme="slate"] h1,
+.home-div[data-md-color-scheme="slate"] h2,
+.home-div[data-md-color-scheme="slate"] h3,
+.home-div[data-md-color-scheme="slate"] h4,
+.home-div[data-md-color-scheme="slate"] h5,
+.home-div[data-md-color-scheme="slate"] h6 {
+  color: var(--md-default-fg-color);
+}
+
+.home-div .intro-quote {
+  color: var(--md-default-fg-color--light) !important;
+}
+
+.reading-media+p {
+  margin-top: 1em !important;
+}
+
+.md-typeset .admonition-title:before,
+.md-typeset summary:before,
+.md-typeset summary:after {
+  top: 50%;
+}
+
+.md-typeset .admonition-title:before,
+.md-typeset summary:before {
+  transform: translateY(-50%);
+}
+
+.md-typeset summary:after {
+  transform: translateY(-50%) rotate(0deg);
+}
+
+.md-typeset details[open]>summary:after {
+  transform: translateY(-50%) rotate(90deg);
+}
+
+.md-nav__link[for] {
+  color: inherit !important;
+}
+
+.md-nav__link[for].md-nav__link--active {
+  color: var(--md-accent-fg-color) !important;
+}
+
+@media screen and (min-width: 76.25em) {
+  .md-grid {
+    max-width: calc(61rem + 2 * (var(--hello-algo-sidebar-width) - 12.1rem));
+  }
+
+  .md-sidebar--primary,
+  .md-sidebar--secondary {
+    width: var(--hello-algo-sidebar-width);
+  }
+
+  [dir="ltr"] .md-sidebar__inner {
+    padding-right: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
+  }
+
+  [dir="rtl"] .md-sidebar__inner {
+    padding-left: calc(100% - (var(--hello-algo-sidebar-width) - 0.6rem));
+  }
+}
+
+.md-sidebar--primary .md-sidebar__scrollwrap {
+  scrollbar-color: var(--md-default-fg-color--lighter) transparent;
+}
+
+.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb,
+.md-sidebar--primary .md-sidebar__scrollwrap::-webkit-scrollbar-thumb:hover {
+  background-color: var(--md-default-fg-color--lighter);
+}
+
+.md-footer,
+.md-footer__inner,
+.md-footer-meta,
+.md-footer__link,
+.md-footer__link:hover {
+  background-color: var(--md-default-bg-color);
+}
+
+.md-footer {
+  border-top: 0.05rem solid var(--md-default-fg-color--lightest);
+}
+
+[data-md-color-scheme="slate"] .md-footer,
+[data-md-color-scheme="slate"] .md-footer__inner,
+[data-md-color-scheme="slate"] .md-footer-meta,
+[data-md-color-scheme="slate"] .md-footer__link,
+[data-md-color-scheme="slate"] .md-footer__link:hover {
+  background-color: var(--md-default-bg-color);
+}
+
+.md-banner {
+  background-color: var(--md-default-bg-color);
+}
+
+.md-typeset .admonition.pythontutor,
+.md-typeset details.pythontutor,
+.md-typeset .pythontutor>.admonition-title,
+.md-typeset .pythontutor>summary {
+  background-color: var(--md-code-bg-color);
+}
+
+.md-typeset .pythontutor>.admonition-title::before,
+.md-typeset .pythontutor>summary::before,
+.md-typeset .pythontutor>summary::after {
+  top: 50%;
+}
+
+.md-typeset .pythontutor>.admonition-title::before,
+.md-typeset .pythontutor>summary::before {
+  transform: translateY(-50%);
+}
+
+.md-typeset .pythontutor>summary::after {
+  transform: translateY(-50%) rotate(0deg);
+}
+
+.md-typeset details[open].pythontutor>summary::after {
+  transform: translateY(-50%) rotate(90deg);
+}
+
+.md-typeset a:not(.md-button) {
+  text-decoration: none;
+}
+
+.md-typeset a:not(.md-button):hover,
+.md-typeset a:not(.md-button):focus-visible {
+  text-decoration: underline;
+}
--- a/overrides/zensical/zensical.toml
+++ b/overrides/zensical/zensical.toml
@@ -0,0 +1,20 @@
+[project]
+extra_css = [
+  "stylesheets/extra.css",
+]
+
+[project.theme]
+features = [
+  "content.action.edit",
+  "content.code.annotate",
+  "content.code.copy",
+  "content.tabs.link",
+  "content.tooltips",
+  "navigation.indexes",
+  "navigation.top",
+  "navigation.tracking",
+  "search.highlight",
+  "search.share",
+  "search.suggest",
+  "toc.follow",
+]
--- a/ru/codes/ruby/chapter_array_and_linkedlist/array.rb
+++ b/ru/codes/ruby/chapter_array_and_linkedlist/array.rb
@@ -4,7 +4,7 @@ Created Time: 2024-03-18
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Случайный доступ к элементу ###
+### Случайный доступ к элементу ###
 def random_access(nums)
  # Случайным образом выбрать число из интервала [0, nums.length)
  random_index = Random.rand(0...nums.length)
@@ -14,9 +14,9 @@ def random_access(nums)
 end


-# ## Увеличить длину массива ###
-# Обратите внимание: Array в Ruby является динамическим массивом и может быть расширен напрямую
-# Для удобства обучения эта функция рассматривает Array как массив неизменяемой длины
+### Увеличить длину массива ###
+# Обратите внимание: Array в Ruby является динамическим массивом и может расширяться напрямую
+# Для удобства обучения в этой функции Array рассматривается как массив неизменяемой длины
 def extend(nums, enlarge)
  # Инициализировать массив увеличенной длины
  res = Array.new(nums.length + enlarge, 0)
@@ -30,7 +30,7 @@ def extend(nums, enlarge)
  res
 end

-# ## Вставка элемента num по индексу index в массив ###
+### Вставка элемента num по индексу index в массив ###
 def insert(nums, num, index)
  # Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад
  for i in (nums.length - 1).downto(index + 1)
@@ -42,7 +42,7 @@ def insert(nums, num, index)
 end


-# ## Удаление элемента по индексу index ###
+### Удаление элемента по индексу index ###
 def remove(nums, index)
  # Сдвинуть все элементы после индекса index на одну позицию вперед
  for i in index...(nums.length - 1)
@@ -50,7 +50,7 @@ def remove(nums, index)
  end
 end

-# ## Обход массива ###
+### Обход массива ###
 def traverse(nums)
  count = 0

@@ -65,7 +65,7 @@ def traverse(nums)
  end
 end

-# ## Поиск заданного элемента в массиве ###
+### Поиск заданного элемента в массиве ###
 def find(nums, target)
  for i in 0...nums.length
    return i if nums[i] == target
--- a/ru/codes/ruby/chapter_array_and_linkedlist/linked_list.rb
+++ b/ru/codes/ruby/chapter_array_and_linkedlist/linked_list.rb
@@ -7,15 +7,15 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/list_node'
 require_relative '../utils/print_util'

-# ## Вставка узла _p после узла n0 в связном списке ###
-# В Ruby `p` — встроенная функция, а `P` — константа, поэтому вместо этого можно использовать `_p`
+### Вставка узла _p после узла n0 в связном списке ###
+# В Ruby `p` является встроенной функцией, а `P` — константой, поэтому вместо них можно использовать `_p`
 def insert(n0, _p)
  n1 = n0.next
  _p.next = n1
  n0.next = _p
 end

-# ## Удаление первого узла после узла n0 в связном списке ###
+### Удаление первого узла после узла n0 в связном списке ###
 def remove(n0)
  return if n0.next.nil?

@@ -25,7 +25,7 @@ def remove(n0)
  n0.next = n1
 end

-# ## Доступ к узлу связного списка по индексу index ###
+### Доступ к узлу связного списка по индексу index ###
 def access(head, index)
  for i in 0...index
    return nil if head.nil?
@@ -35,7 +35,7 @@ def access(head, index)
  head
 end

-# ## Поиск первого узла со значением target в связном списке ###
+### Поиск первого узла со значением target в связном списке ###
 def find(head, target)
  index = 0
  while head
--- a/ru/codes/ruby/chapter_array_and_linkedlist/my_list.rb
+++ b/ru/codes/ruby/chapter_array_and_linkedlist/my_list.rb
@@ -4,12 +4,12 @@ Created Time: 2024-03-18
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Класс списка ###
+### Класс списка ###
 class MyList
  attr_reader :size       # Получить длину списка (текущее число элементов)
  attr_reader :capacity   # Получить вместимость списка

-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    @capacity = 10
    @size = 0
@@ -17,20 +17,20 @@ class MyList
    @arr = Array.new(capacity)
  end

-  # ## Доступ к элементу ###
+  ### Доступ к элементу ###
  def get(index)
    # Если индекс выходит за границы, выбрасывается исключение; далее аналогично
    raise IndexError, "индекс выходит за границы" if index < 0 || index >= size
    @arr[index]
  end

-  # ## Доступ к элементу ###
+  ### Доступ к элементу ###
  def set(index, num)
    raise IndexError, "индекс выходит за границы" if index < 0 || index >= size
    @arr[index] = num
  end

-  # ## Добавление элемента в конец ###
+  ### Добавление элемента в конец ###
  def add(num)
    # При превышении вместимости по числу элементов запускается расширение
    extend_capacity if size == capacity
@@ -40,7 +40,7 @@ class MyList
    @size += 1
  end

-  # ## Вставка элемента в середину ###
+  ### Вставка элемента в середину ###
  def insert(index, num)
    raise IndexError, "индекс выходит за границы" if index < 0 || index >= size

@@ -57,7 +57,7 @@ class MyList
    @size += 1
  end

-  # ## Удаление элемента ###
+  ### Удаление элемента ###
  def remove(index)
    raise IndexError, "индекс выходит за границы" if index < 0 || index >= size
    num = @arr[index]
@@ -74,7 +74,7 @@ class MyList
    num
  end

-  # ## Расширение списка ###
+  ### Расширение списка ###
  def extend_capacity
    # Создать новый массив длиной в extend_ratio раз больше исходного и скопировать в него исходный массив
    arr = @arr.dup + Array.new(capacity * (@extend_ratio - 1))
@@ -82,7 +82,7 @@ class MyList
    @capacity = arr.length
  end

-  # ## Преобразование списка в массив ###
+  ### Преобразование списка в массив ###
  def to_array
    sz = size
    # Преобразовывать только элементы списка в пределах фактической длины
--- a/ru/codes/ruby/chapter_backtracking/n_queens.rb
+++ b/ru/codes/ruby/chapter_backtracking/n_queens.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-21
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Алгоритм бэктрекинга: n ферзей ###
+### Алгоритм бэктрекинга: n ферзей ###
 def backtrack(row, n, state, res, cols, diags1, diags2)
  # Когда все строки уже обработаны, записать решение
  if row == n
@@ -31,7 +31,7 @@ def backtrack(row, n, state, res, cols, diags1, diags2)
  end
 end

-# ## Решить задачу о n ферзях ###
+### Решить задачу о n ферзях ###
 def n_queens(n)
  # Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку
  state = Array.new(n) { Array.new(n, "#") }
--- a/ru/codes/ruby/chapter_backtracking/permutations_i.rb
+++ b/ru/codes/ruby/chapter_backtracking/permutations_i.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-22
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Алгоритм бэктрекинга: все перестановки I ###
+### Алгоритм бэктрекинга: все перестановки I ###
 def backtrack(state, choices, selected, res)
  # Когда длина состояния равна числу элементов, записать решение
  if state.length == choices.length
@@ -28,7 +28,7 @@ def backtrack(state, choices, selected, res)
  end
 end

-# ## Все перестановки I ###
+### Все перестановки I ###
 def permutations_i(nums)
  res = []
  backtrack([], nums, Array.new(nums.length, false), res)
--- a/ru/codes/ruby/chapter_backtracking/permutations_ii.rb
+++ b/ru/codes/ruby/chapter_backtracking/permutations_ii.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-22
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Алгоритм бэктрекинга: все перестановки II ###
+### Алгоритм бэктрекинга: все перестановки II ###
 def backtrack(state, choices, selected, res)
  # Когда длина состояния равна числу элементов, записать решение
  if state.length == choices.length
@@ -30,7 +30,7 @@ def backtrack(state, choices, selected, res)
  end
 end

-# ## Все перестановки II ###
+### Все перестановки II ###
 def permutations_ii(nums)
  res = []
  backtrack([], nums, Array.new(nums.length, false), res)
--- a/ru/codes/ruby/chapter_backtracking/preorder_traversal_i_compact.rb
+++ b/ru/codes/ruby/chapter_backtracking/preorder_traversal_i_compact.rb
@@ -7,7 +7,7 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Предварительный обход: пример 1 ###
+### Предварительный обход: пример 1 ###
 def pre_order(root)
  return unless root

--- a/ru/codes/ruby/chapter_backtracking/preorder_traversal_ii_compact.rb
+++ b/ru/codes/ruby/chapter_backtracking/preorder_traversal_ii_compact.rb
@@ -7,7 +7,7 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Предварительный обход: пример 2 ###
+### Предварительный обход: пример 2 ###
 def pre_order(root)
  return unless root

--- a/ru/codes/ruby/chapter_backtracking/preorder_traversal_iii_compact.rb
+++ b/ru/codes/ruby/chapter_backtracking/preorder_traversal_iii_compact.rb
@@ -7,7 +7,7 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Предварительный обход: пример 3 ###
+### Предварительный обход: пример 3 ###
 def pre_order(root)
  # Отсечение
  return if !root || root.val == 3
--- a/ru/codes/ruby/chapter_backtracking/preorder_traversal_iii_template.rb
+++ b/ru/codes/ruby/chapter_backtracking/preorder_traversal_iii_template.rb
@@ -7,32 +7,32 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Проверка, является ли текущее состояние решением ###
+### Проверка, является ли текущее состояние решением ###
 def is_solution?(state)
  !state.empty? && state.last.val == 7
 end

-# ## Записать решение ###
+### Записать решение ###
 def record_solution(state, res)
  res << state.dup
 end

-# ## Проверка допустимости этого выбора в текущем состоянии ###
+### Проверка допустимости этого выбора в текущем состоянии ###
 def is_valid?(state, choice)
  choice && choice.val != 3
 end

-# ## Обновить состояние ###
+### Обновить состояние ###
 def make_choice(state, choice)
  state << choice
 end

-# ## Восстановить состояние ###
+### Восстановить состояние ###
 def undo_choice(state, choice)
  state.pop
 end

-# ## Алгоритм бэктрекинга: пример 3 ###
+### Алгоритм бэктрекинга: пример 3 ###
 def backtrack(state, choices, res)
  # Проверить, является ли текущее состояние решением
  record_solution(state, res) if is_solution?(state)
--- a/ru/codes/ruby/chapter_backtracking/subset_sum_i.rb
+++ b/ru/codes/ruby/chapter_backtracking/subset_sum_i.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-22
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Алгоритм бэктрекинга: сумма подмножеств I ###
+### Алгоритм бэктрекинга: сумма подмножеств I ###
 def backtrack(state, target, choices, start, res)
  # Если сумма подмножества равна target, записать решение
  if target.zero?
@@ -26,7 +26,7 @@ def backtrack(state, target, choices, start, res)
  end
 end

-# ## Решить задачу суммы подмножеств I ###
+### Решить задачу суммы подмножеств I ###
 def subset_sum_i(nums, target)
  state = [] # Состояние (подмножество)
  nums.sort! # Отсортировать nums
--- a/ru/codes/ruby/chapter_backtracking/subset_sum_i_naive.rb
+++ b/ru/codes/ruby/chapter_backtracking/subset_sum_i_naive.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-22
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Алгоритм бэктрекинга: сумма подмножеств I ###
+### Алгоритм бэктрекинга: сумма подмножеств I ###
 def backtrack(state, target, total, choices, res)
  # Если сумма подмножества равна target, записать решение
  if total == target
--- a/ru/codes/ruby/chapter_backtracking/subset_sum_ii.rb
+++ b/ru/codes/ruby/chapter_backtracking/subset_sum_ii.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-22
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Алгоритм бэктрекинга: сумма подмножеств II ###
+### Алгоритм бэктрекинга: сумма подмножеств II ###
 def backtrack(state, target, choices, start, res)
  # Если сумма подмножества равна target, записать решение
  if target.zero?
@@ -30,7 +30,7 @@ def backtrack(state, target, choices, start, res)
  end
 end

-# ## Решить задачу суммы подмножеств II ###
+### Решить задачу суммы подмножеств II ###
 def subset_sum_ii(nums, target)
  state = [] # Состояние (подмножество)
  nums.sort! # Отсортировать nums
--- a/ru/codes/ruby/chapter_computational_complexity/iteration.rb
+++ b/ru/codes/ruby/chapter_computational_complexity/iteration.rb
@@ -4,7 +4,7 @@ Created Time: 2024-03-30
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com), Cy (9738314@gmail.com)
 =end

-# ## Цикл for ###
+### Цикл for ###
 def for_loop(n)
  res = 0

@@ -16,7 +16,7 @@ def for_loop(n)
  res
 end

-# ## Цикл while ###
+### Цикл while ###
 def while_loop(n)
  res = 0
  i = 1 # Инициализация условной переменной
@@ -46,7 +46,7 @@ def while_loop_ii(n)
  res
 end

-# ## Двойной цикл for ###
+### Двойной цикл for ###
 def nested_for_loop(n)
  res = ""

--- a/ru/codes/ruby/chapter_computational_complexity/recursion.rb
+++ b/ru/codes/ruby/chapter_computational_complexity/recursion.rb
@@ -4,7 +4,7 @@ Created Time: 2024-03-30
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Рекурсия ###
+### Рекурсия ###
 def recur(n)
  # Условие завершения
  return 1 if n == 1
@@ -14,7 +14,7 @@ def recur(n)
  n + res
 end

-# ## Имитация рекурсии итерацией ###
+### Имитация рекурсии итерацией ###
 def for_loop_recur(n)
  # Использовать явный стек для имитации системного стека вызовов
  stack = []
@@ -34,7 +34,7 @@ def for_loop_recur(n)
  res
 end

-# ## Хвостовая рекурсия ###
+### Хвостовая рекурсия ###
 def tail_recur(n, res)
  # Условие завершения
  return res if n == 0
@@ -42,7 +42,7 @@ def tail_recur(n, res)
  tail_recur(n - 1, res + n)
 end

-# ## Последовательность Фибоначчи: рекурсия ###
+### Последовательность Фибоначчи: рекурсия ###
 def fib(n)
  # Условие завершения: f(1) = 0, f(2) = 1
  return n - 1 if n == 1 || n == 2
--- a/ru/codes/ruby/chapter_computational_complexity/space_complexity.rb
+++ b/ru/codes/ruby/chapter_computational_complexity/space_complexity.rb
@@ -8,13 +8,13 @@ require_relative '../utils/list_node'
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Функция ###
+### Функция ###
 def function
  # Выполнить некоторые операции
  0
 end

-# ## Постоянная сложность ###
+### Постоянная сложность ###
 def constant(n)
  # Константы, переменные и объекты занимают O(1) памяти
  a = 0
@@ -27,7 +27,7 @@ def constant(n)
  (0...n).each { function }
 end

-# ## Линейная сложность ###
+### Линейная сложность ###
 def linear(n)
  # Список длины n занимает O(n) памяти
  nums = Array.new(n, 0)
@@ -46,7 +46,7 @@ def linear_recur(n)
  linear_recur(n - 1)
 end

-# ## Квадратичная сложность ###
+### Квадратичная сложность ###
 def quadratic(n)
  # Двумерный список занимает O(n^2) памяти
  Array.new(n) { Array.new(n, 0) }
--- a/ru/codes/ruby/chapter_computational_complexity/time_complexity.rb
+++ b/ru/codes/ruby/chapter_computational_complexity/time_complexity.rb
@@ -4,7 +4,7 @@ Created Time: 2024-03-30
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Постоянная сложность ###
+### Постоянная сложность ###
 def constant(n)
  count = 0
  size = 100000
@@ -14,7 +14,7 @@ def constant(n)
  count
 end

-# ## Линейная сложность ###
+### Линейная сложность ###
 def linear(n)
  count = 0
  (0...n).each { count += 1 }
@@ -33,7 +33,7 @@ def array_traversal(nums)
  count
 end

-# ## Квадратичная сложность ###
+### Квадратичная сложность ###
 def quadratic(n)
  count = 0

@@ -106,7 +106,7 @@ def log_recur(n)
  log_recur(n / 2) + 1
 end

-# ## Линейно-логарифмическая сложность ###
+### Линейно-логарифмическая сложность ###
 def linear_log_recur(n)
  return 1 unless n > 1

--- a/ru/codes/ruby/chapter_computational_complexity/worst_best_time_complexity.rb
+++ b/ru/codes/ruby/chapter_computational_complexity/worst_best_time_complexity.rb
@@ -4,7 +4,7 @@ Created Time: 2024-03-30
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Создать массив с элементами: 1, 2, ..., n в случайном порядке ###
+### Создать массив с элементами: 1, 2, ..., n в случайном порядке ###
 def random_numbers(n)
  # Создать массив nums =: 1, 2, 3, ..., n
  nums = Array.new(n) { |i| i + 1 }
@@ -12,7 +12,7 @@ def random_numbers(n)
  nums.shuffle!
 end

-# ## Найти индекс числа 1 в массиве nums ###
+### Найти индекс числа 1 в массиве nums ###
 def find_one(nums)
  for i in 0...nums.length
    # Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)
--- a/ru/codes/ruby/chapter_divide_and_conquer/binary_search_recur.rb
+++ b/ru/codes/ruby/chapter_divide_and_conquer/binary_search_recur.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-13
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Бинарный поиск: задача f(i, j) ###
+### Бинарный поиск: задача f(i, j) ###
 def dfs(nums, target, i, j)
  # Если интервал пуст, целевой элемент отсутствует, вернуть -1
  return -1 if i > j
@@ -24,7 +24,7 @@ def dfs(nums, target, i, j)
  end
 end

-# ## Бинарный поиск ###
+### Бинарный поиск ###
 def binary_search(nums, target)
  n = nums.length
  # Решить задачу f(0, n-1)
--- a/ru/codes/ruby/chapter_divide_and_conquer/build_tree.rb
+++ b/ru/codes/ruby/chapter_divide_and_conquer/build_tree.rb
@@ -7,7 +7,7 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Построить двоичное дерево: разделяй и властвуй ###
+### Построить двоичное дерево: разделяй и властвуй ###
 def dfs(preorder, inorder_map, i, l, r)
  # Завершить при пустом диапазоне поддерева
  return if r - l < 0
@@ -25,7 +25,7 @@ def dfs(preorder, inorder_map, i, l, r)
  root
 end

-# ## Построить двоичное дерево ###
+### Построить двоичное дерево ###
 def build_tree(preorder, inorder)
  # Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам
  inorder_map = {}
--- a/ru/codes/ruby/chapter_divide_and_conquer/hanota.rb
+++ b/ru/codes/ruby/chapter_divide_and_conquer/hanota.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-13
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Переместить один диск ###
+### Переместить один диск ###
 def move(src, tar)
  # Снять диск с вершины src
  pan = src.pop
@@ -12,7 +12,7 @@ def move(src, tar)
  tar << pan
 end

-# ## Решить задачу Ханойской башни f(i) ###
+### Решить задачу Ханойской башни f(i) ###
 def dfs(i, src, buf, tar)
  # Если в src остался только один диск, сразу переместить его в tar
  if i == 1
@@ -28,7 +28,7 @@ def dfs(i, src, buf, tar)
  dfs(i - 1, buf, src, tar)
 end

-# ## Решить задачу Ханойской башни ###
+### Решить задачу Ханойской башни ###
 def solve_hanota(_A, _B, _C)
  n = _A.length
  # Переместить верхние n дисков из A в C с помощью B
--- a/ru/codes/ruby/chapter_dynamic_programming/climbing_stairs_backtrack.rb
+++ b/ru/codes/ruby/chapter_dynamic_programming/climbing_stairs_backtrack.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Бэктрекинг ###
+### Бэктрекинг ###
 def backtrack(choices, state, n, res)
  # Когда подъем достигает n-й ступени, число вариантов увеличивается на 1
  res[0] += 1 if state == n
@@ -19,7 +19,7 @@ def backtrack(choices, state, n, res)
  # Откат
 end

-# ## Подъем по лестнице: бэктрекинг ###
+### Подъем по лестнице: бэктрекинг ###
 def climbing_stairs_backtrack(n)
  choices = [1, 2] # Можно подняться на 1 или 2 ступени
  state = 0 # Начать подъем с 0-й ступени
--- a/ru/codes/ruby/chapter_dynamic_programming/climbing_stairs_constraint_dp.rb
+++ b/ru/codes/ruby/chapter_dynamic_programming/climbing_stairs_constraint_dp.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Подъем по лестнице с ограничениями: динамическое программирование ###
+### Подъем по лестнице с ограничениями: динамическое программирование ###
 def climbing_stairs_constraint_dp(n)
  return 1 if n == 1 || n == 2

--- a/ru/codes/ruby/chapter_dynamic_programming/climbing_stairs_dfs.rb
+++ b/ru/codes/ruby/chapter_dynamic_programming/climbing_stairs_dfs.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Поиск ###
+### Поиск ###
 def dfs(i)
  # dp[1] и dp[2] уже известны, вернуть их
  return i if i == 1 || i == 2
@@ -12,7 +12,7 @@ def dfs(i)
  dfs(i - 1) + dfs(i - 2)
 end

-# ## Подъем по лестнице: поиск ###
+### Подъем по лестнице: поиск ###
 def climbing_stairs_dfs(n)
  dfs(n)
 end
--- a/ru/codes/ruby/chapter_dynamic_programming/climbing_stairs_dfs_mem.rb
+++ b/ru/codes/ruby/chapter_dynamic_programming/climbing_stairs_dfs_mem.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Поиск с мемоизацией ###
+### Поиск с мемоизацией ###
 def dfs(i, mem)
  # dp[1] и dp[2] уже известны, вернуть их
  return i if i == 1 || i == 2
@@ -17,7 +17,7 @@ def dfs(i, mem)
  mem[i] = count
 end

-# ## Подъем по лестнице: поиск с мемоизацией ###
+### Подъем по лестнице: поиск с мемоизацией ###
 def climbing_stairs_dfs_mem(n)
  # mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи
  mem = Array.new(n + 1, -1)
--- a/ru/codes/ruby/chapter_dynamic_programming/climbing_stairs_dp.rb
+++ b/ru/codes/ruby/chapter_dynamic_programming/climbing_stairs_dp.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Подъем по лестнице: динамическое программирование ###
+### Подъем по лестнице: динамическое программирование ###
 def climbing_stairs_dp(n)
  return n  if n == 1 || n == 2

@@ -18,7 +18,7 @@ def climbing_stairs_dp(n)
  dp[n]
 end

-# ## Подъем по лестнице: динамическое программирование с оптимизацией памяти ###
+### Подъем по лестнице: динамическое программирование с оптимизацией памяти ###
 def climbing_stairs_dp_comp(n)
  return n if n == 1 || n == 2

--- a/ru/codes/ruby/chapter_dynamic_programming/coin_change.rb
+++ b/ru/codes/ruby/chapter_dynamic_programming/coin_change.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Размен монет: динамическое программирование ###
+### Размен монет: динамическое программирование ###
 def coin_change_dp(coins, amt)
  n = coins.length
  _MAX = amt + 1
@@ -27,7 +27,7 @@ def coin_change_dp(coins, amt)
  dp[n][amt] != _MAX ? dp[n][amt] : -1
 end

-# ## Размен монет: динамическое программирование с оптимизацией памяти ###
+### Размен монет: динамическое программирование с оптимизацией памяти ###
 def coin_change_dp_comp(coins, amt)
  n = coins.length
  _MAX = amt + 1
--- a/ru/codes/ruby/chapter_dynamic_programming/coin_change_ii.rb
+++ b/ru/codes/ruby/chapter_dynamic_programming/coin_change_ii.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Размен монет II: динамическое программирование ###
+### Размен монет II: динамическое программирование ###
 def coin_change_ii_dp(coins, amt)
  n = coins.length
  # Инициализация таблицы dp
@@ -26,7 +26,7 @@ def coin_change_ii_dp(coins, amt)
  dp[n][amt]
 end

-# ## Размен монет II: динамическое программирование с оптимизацией памяти ###
+### Размен монет II: динамическое программирование с оптимизацией памяти ###
 def coin_change_ii_dp_comp(coins, amt)
  n = coins.length
  # Инициализация таблицы dp
--- a/ru/codes/ruby/chapter_dynamic_programming/edit_distance.rb
+++ b/ru/codes/ruby/chapter_dynamic_programming/edit_distance.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Редакционное расстояние: полный перебор ###
+### Редакционное расстояние: полный перебор ###
 def edit_distance_dfs(s, t, i, j)
  # Если s и t пусты, вернуть 0
  return 0 if i == 0 && j == 0
@@ -41,7 +41,7 @@ def edit_distance_dfs_mem(s, t, mem, i, j)
  mem[i][j] = [insert, delete, replace].min + 1
 end

-# ## Редакционное расстояние: динамическое программирование ###
+### Редакционное расстояние: динамическое программирование ###
 def edit_distance_dp(s, t)
  n, m = s.length, t.length
  dp = Array.new(n + 1) { Array.new(m + 1, 0) }
@@ -63,7 +63,7 @@ def edit_distance_dp(s, t)
  dp[n][m]
 end

-# ## Редакционное расстояние: динамическое программирование с оптимизацией памяти ###
+### Редакционное расстояние: динамическое программирование с оптимизацией памяти ###
 def edit_distance_dp_comp(s, t)
  n, m = s.length, t.length
  dp = Array.new(m + 1, 0)
--- a/ru/codes/ruby/chapter_dynamic_programming/knapsack.rb
+++ b/ru/codes/ruby/chapter_dynamic_programming/knapsack.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Рюкзак 0-1: полный перебор ###
+### Рюкзак 0-1: полный перебор ###
 def knapsack_dfs(wgt, val, i, c)
  # Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0
  return 0 if i == 0 || c == 0
@@ -17,7 +17,7 @@ def knapsack_dfs(wgt, val, i, c)
  [no, yes].max
 end

-# ## Рюкзак 0-1: поиск с мемоизацией ###
+### Рюкзак 0-1: поиск с мемоизацией ###
 def knapsack_dfs_mem(wgt, val, mem, i, c)
  # Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0
  return 0 if i == 0 || c == 0
@@ -32,7 +32,7 @@ def knapsack_dfs_mem(wgt, val, mem, i, c)
  mem[i][c] = [no, yes].max
 end

-# ## Рюкзак 0-1: динамическое программирование ###
+### Рюкзак 0-1: динамическое программирование ###
 def knapsack_dp(wgt, val, cap)
  n = wgt.length
  # Инициализация таблицы dp
@@ -52,7 +52,7 @@ def knapsack_dp(wgt, val, cap)
  dp[n][cap]
 end

-# ## Рюкзак 0-1: динамическое программирование с оптимизацией памяти ###
+### Рюкзак 0-1: динамическое программирование с оптимизацией памяти ###
 def knapsack_dp_comp(wgt, val, cap)
  n = wgt.length
  # Инициализация таблицы dp
--- a/ru/codes/ruby/chapter_dynamic_programming/min_cost_climbing_stairs_dp.rb
+++ b/ru/codes/ruby/chapter_dynamic_programming/min_cost_climbing_stairs_dp.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Минимальная стоимость подъема по лестнице: динамическое программирование ###
+### Минимальная стоимость подъема по лестнице: динамическое программирование ###
 def min_cost_climbing_stairs_dp(cost)
  n = cost.length - 1
  return cost[n] if n == 1 || n == 2
--- a/ru/codes/ruby/chapter_dynamic_programming/min_path_sum.rb
+++ b/ru/codes/ruby/chapter_dynamic_programming/min_path_sum.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Минимальная сумма пути: полный перебор ###
+### Минимальная сумма пути: полный перебор ###
 def min_path_sum_dfs(grid, i, j)
  # Если это верхняя левая ячейка, завершить поиск
  return grid[i][j] if i == 0 && j == 0
@@ -17,7 +17,7 @@ def min_path_sum_dfs(grid, i, j)
  [left, up].min + grid[i][j]
 end

-# ## Минимальная сумма пути: поиск с мемоизацией ###
+### Минимальная сумма пути: поиск с мемоизацией ###
 def min_path_sum_dfs_mem(grid, mem, i, j)
  # Если это верхняя левая ячейка, завершить поиск
  return grid[0][0] if i == 0 && j == 0
@@ -32,7 +32,7 @@ def min_path_sum_dfs_mem(grid, mem, i, j)
  mem[i][j] = [left, up].min + grid[i][j]
 end

-# ## Минимальная сумма пути: динамическое программирование ###
+### Минимальная сумма пути: динамическое программирование ###
 def min_path_sum_dp(grid)
  n, m = grid.length, grid.first.length
  # Инициализация таблицы dp
@@ -51,7 +51,7 @@ def min_path_sum_dp(grid)
  dp[n -1][m -1]
 end

-# ## Минимальная сумма пути: динамическое программирование с оптимизацией памяти ###
+### Минимальная сумма пути: динамическое программирование с оптимизацией памяти ###
 def min_path_sum_dp_comp(grid)
  n, m = grid.length, grid.first.length
  # Инициализация таблицы dp
--- a/ru/codes/ruby/chapter_dynamic_programming/unbounded_knapsack.rb
+++ b/ru/codes/ruby/chapter_dynamic_programming/unbounded_knapsack.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-29
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Полный рюкзак: динамическое программирование ###
+### Полный рюкзак: динамическое программирование ###
 def unbounded_knapsack_dp(wgt, val, cap)
  n = wgt.length
  # Инициализация таблицы dp
--- a/ru/codes/ruby/chapter_graph/graph_adjacency_list.rb
+++ b/ru/codes/ruby/chapter_graph/graph_adjacency_list.rb
@@ -6,11 +6,11 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)

 require_relative '../utils/vertex'

-# ## Класс неориентированного графа на основе списка смежности ###
+### Класс неориентированного графа на основе списка смежности ###
 class GraphAdjList
  attr_reader :adj_list
  
-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize(edges)
    # Список смежности, где key — вершина, а value — все смежные ей вершины
    @adj_list = {}
@@ -22,12 +22,12 @@ class GraphAdjList
    end
  end

-  # ## Получение числа вершин ###
+  ### Получение числа вершин ###
  def size
    @adj_list.length
  end

-  # ## Добавление ребра ###
+  ### Добавление ребра ###
  def add_edge(vet1, vet2)
    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)

@@ -35,7 +35,7 @@ class GraphAdjList
    @adj_list[vet2] << vet1
  end

-  # ## Удаление ребра ###
+  ### Удаление ребра ###
  def remove_edge(vet1, vet2)
    raise ArgumentError if !@adj_list.include?(vet1) || !@adj_list.include?(vet2)

@@ -44,7 +44,7 @@ class GraphAdjList
    @adj_list[vet2].delete(vet1)
  end

-  # ## Добавление вершины ###
+  ### Добавление вершины ###
  def add_vertex(vet)
    return if @adj_list.include?(vet)

@@ -52,7 +52,7 @@ class GraphAdjList
    @adj_list[vet] = []
  end

-  # ## Удаление вершины ###
+  ### Удаление вершины ###
  def remove_vertex(vet)
    raise ArgumentError unless @adj_list.include?(vet)

@@ -64,7 +64,7 @@ class GraphAdjList
    end
  end

-  # ## Вывести список смежности ###
+  ### Вывести список смежности ###
  def __print__
    puts 'Список смежности ='
    for vertex in @adj_list
--- a/ru/codes/ruby/chapter_graph/graph_adjacency_matrix.rb
+++ b/ru/codes/ruby/chapter_graph/graph_adjacency_matrix.rb
@@ -6,10 +6,10 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)

 require_relative '../utils/print_util'

-# ## Класс неориентированного графа на основе матрицы смежности ###
+### Класс неориентированного графа на основе матрицы смежности ###
 class GraphAdjMat
  def initialize(vertices, edges)
-    # ## Конструктор ###
+    ### Конструктор ###
    # Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»
    @vertices = []
    # Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»
@@ -21,12 +21,12 @@ class GraphAdjMat
    edges.each { |e| add_edge(e[0], e[1]) }
  end

-  # ## Получение числа вершин ###
+  ### Получение числа вершин ###
  def size
    @vertices.length
  end

-  # ## Добавление вершины ###
+  ### Добавление вершины ###
  def add_vertex(val)
    n = size
    # Добавить значение новой вершины в список вершин
@@ -38,7 +38,7 @@ class GraphAdjMat
    @adj_mat.each { |row| row << 0 }
  end

-  # ## Удаление вершины ###
+  ### Удаление вершины ###
  def remove_vertex(index)
    raise IndexError if index >= size

@@ -50,7 +50,7 @@ class GraphAdjMat
    @adj_mat.each { |row| row.delete_at(index) }
  end

-  # ## Добавление ребра ###
+  ### Добавление ребра ###
  def add_edge(i, j)
    # Параметры i и j соответствуют индексам элементов vertices
    # Обработка выхода индекса за границы и случая равенства
@@ -62,7 +62,7 @@ class GraphAdjMat
    @adj_mat[j][i] = 1
  end

-  # ## Удаление ребра ###
+  ### Удаление ребра ###
  def remove_edge(i, j)
    # Параметры i и j соответствуют индексам элементов vertices
    # Обработка выхода индекса за границы и случая равенства
@@ -73,7 +73,7 @@ class GraphAdjMat
    @adj_mat[j][i] = 0
  end

-  # ## Вывести матрицу смежности ###
+  ### Вывести матрицу смежности ###
  def __print__
    puts "Список вершин = #{@vertices}"
    puts 'Матрица смежности ='
--- a/ru/codes/ruby/chapter_graph/graph_bfs.rb
+++ b/ru/codes/ruby/chapter_graph/graph_bfs.rb
@@ -8,7 +8,7 @@ require 'set'
 require_relative './graph_adjacency_list'
 require_relative '../utils/vertex'

-# ## Обход в ширину ###
+### Обход в ширину ###
 def graph_bfs(graph, start_vet)
  # Использовать список смежности для представления графа, чтобы получать все смежные вершины заданной вершины
  # Последовательность обхода вершин
--- a/ru/codes/ruby/chapter_graph/graph_dfs.rb
+++ b/ru/codes/ruby/chapter_graph/graph_dfs.rb
@@ -8,7 +8,7 @@ require 'set'
 require_relative './graph_adjacency_list'
 require_relative '../utils/vertex'

-# ## Вспомогательная функция обхода в глубину ###
+### Вспомогательная функция обхода в глубину ###
 def dfs(graph, visited, res, vet)
  res << vet # Отметить посещенную вершину
  visited.add(vet) # Отметить эту вершину как посещенную
@@ -20,7 +20,7 @@ def dfs(graph, visited, res, vet)
  end
 end

-# ## Обход в глубину ###
+### Обход в глубину ###
 def graph_dfs(graph, start_vet)
  # Использовать список смежности для представления графа, чтобы получать все смежные вершины заданной вершины
  # Последовательность обхода вершин
--- a/ru/codes/ruby/chapter_greedy/coin_change_greedy.rb
+++ b/ru/codes/ruby/chapter_greedy/coin_change_greedy.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-07
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Размен монет: жадный алгоритм ###
+### Размен монет: жадный алгоритм ###
 def coin_change_greedy(coins, amt)
  # Предположить, что список coins упорядочен
  i = coins.length - 1
--- a/ru/codes/ruby/chapter_greedy/fractional_knapsack.rb
+++ b/ru/codes/ruby/chapter_greedy/fractional_knapsack.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-07
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Предмет ###
+### Предмет ###
 class Item
  attr_accessor :w # Вес предмета
  attr_accessor :v # Стоимость предмета
@@ -15,7 +15,7 @@ class Item
  end
 end

-# ## Дробный рюкзак: жадный алгоритм ###
+### Дробный рюкзак: жадный алгоритм ###
 def fractional_knapsack(wgt, val, cap)
  # Создать список предметов с двумя свойствами: вес и стоимость
  items = wgt.each_with_index.map { |w, i| Item.new(w, val[i]) }
--- a/ru/codes/ruby/chapter_greedy/max_capacity.rb
+++ b/ru/codes/ruby/chapter_greedy/max_capacity.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-07
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Максимальная вместимость: жадный алгоритм ###
+### Максимальная вместимость: жадный алгоритм ###
 def max_capacity(ht)
  # Инициализировать i и j так, чтобы они располагались по двум концам массива
  i, j = 0, ht.length - 1
--- a/ru/codes/ruby/chapter_greedy/max_product_cutting.rb
+++ b/ru/codes/ruby/chapter_greedy/max_product_cutting.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-07
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Максимальное произведение разрезания: жадный алгоритм ###
+### Максимальное произведение разрезания: жадный алгоритм ###
 def max_product_cutting(n)
  # Когда n <= 3, обязательно нужно выделить одну 1
  return 1 * (n - 1) if n <= 3
--- a/ru/codes/ruby/chapter_hashing/array_hash_map.rb
+++ b/ru/codes/ruby/chapter_hashing/array_hash_map.rb
@@ -4,7 +4,7 @@ Created Time: 2024-04-13
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Пара ключ-значение ###
+### Пара ключ-значение ###
 class Pair
  attr_accessor :key, :val

@@ -14,20 +14,20 @@ class Pair
  end
 end

-# ## Хеш-таблица на основе массива ###
+### Хеш-таблица на основе массива ###
 class ArrayHashMap
-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    # Инициализировать массив, содержащий 100 корзин
    @buckets = Array.new(100)
  end

-  # ## Хеш-функция ###
+  ### Хеш-функция ###
  def hash_func(key)
    index = key % 100
  end

-  # ## Операция поиска ###
+  ### Операция поиска ###
  def get(key)
    index = hash_func(key)
    pair = @buckets[index]
@@ -36,42 +36,42 @@ class ArrayHashMap
    pair.val
  end

-  # ## Операция добавления ###
+  ### Операция добавления ###
  def put(key, val)
    pair = Pair.new(key, val)
    index = hash_func(key)
    @buckets[index] = pair
  end

-  # ## Операция удаления ###
+  ### Операция удаления ###
  def remove(key)
    index = hash_func(key)
    # Присвоить nil, что означает удаление
    @buckets[index] = nil
  end

-  # ## Получить все пары ключ-значение ###
+  ### Получить все пары ключ-значение ###
  def entry_set
    result = []
    @buckets.each { |pair| result << pair unless pair.nil? }
    result
  end

-  # ## Получить все ключи ###
+  ### Получить все ключи ###
  def key_set
    result = []
    @buckets.each { |pair| result << pair.key unless pair.nil? }
    result
  end

-  # ## Получить все значения ###
+  ### Получить все значения ###
  def value_set
    result = []
    @buckets.each { |pair| result << pair.val unless pair.nil? }
    result
  end

-  # ## Вывести хеш-таблицу ###
+  ### Вывести хеш-таблицу ###
  def print
    @buckets.each { |pair| puts "#{pair.key} -> #{pair.val}" unless pair.nil? }
  end
--- a/ru/codes/ruby/chapter_hashing/hash_map_chaining.rb
+++ b/ru/codes/ruby/chapter_hashing/hash_map_chaining.rb
@@ -6,9 +6,9 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)

 require_relative './array_hash_map'

-# ## Хеш-таблица с цепочками ###
+### Хеш-таблица с цепочками ###
 class HashMapChaining
-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    @size = 0 # Число пар ключ-значение
    @capacity = 4 # Вместимость хеш-таблицы
@@ -17,17 +17,17 @@ class HashMapChaining
    @buckets = Array.new(@capacity) { [] } # Массив корзин
  end

-  # ## Хеш-функция ###
+  ### Хеш-функция ###
  def hash_func(key)
    key % @capacity
  end

-  # ## Коэффициент загрузки ###
+  ### Коэффициент загрузки ###
  def load_factor
    @size / @capacity
  end

-  # ## Операция поиска ###
+  ### Операция поиска ###
  def get(key)
    index = hash_func(key)
    bucket = @buckets[index]
@@ -39,7 +39,7 @@ class HashMapChaining
    nil
  end

-  # ## Операция добавления ###
+  ### Операция добавления ###
  def put(key, val)
    # Когда коэффициент загрузки превышает порог, выполнить расширение
    extend if load_factor > @load_thres
@@ -58,7 +58,7 @@ class HashMapChaining
    @size += 1
  end

-  # ## Операция удаления ###
+  ### Операция удаления ###
  def remove(key)
    index = hash_func(key)
    bucket = @buckets[index]
@@ -72,7 +72,7 @@ class HashMapChaining
    end
  end

-  # ## Расширение хеш-таблицы ###
+  ### Расширение хеш-таблицы ###
  def extend
    # Временно сохранить исходную хеш-таблицу
    buckets = @buckets
@@ -88,7 +88,7 @@ class HashMapChaining
    end
  end

-  # ## Вывести хеш-таблицу ###
+  ### Вывести хеш-таблицу ###
  def print
    for bucket in @buckets
      res = []
--- a/ru/codes/ruby/chapter_hashing/hash_map_open_addressing.rb
+++ b/ru/codes/ruby/chapter_hashing/hash_map_open_addressing.rb
@@ -6,11 +6,11 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)

 require_relative './array_hash_map'

-# ## Хеш-таблица с открытой адресацией ###
+### Хеш-таблица с открытой адресацией ###
 class HashMapOpenAddressing
  TOMBSTONE = Pair.new(-1, '-1') # Удалить метку

-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    @size = 0 # Число пар ключ-значение
    @capacity = 4 # Вместимость хеш-таблицы
@@ -19,17 +19,17 @@ class HashMapOpenAddressing
    @buckets = Array.new(@capacity) # Массив корзин
  end

-  # ## Хеш-функция ###
+  ### Хеш-функция ###
  def hash_func(key)
    key % @capacity
  end

-  # ## Коэффициент загрузки ###
+  ### Коэффициент загрузки ###
  def load_factor
    @size / @capacity
  end

-  # ## Найти индекс корзины, соответствующий key ###
+  ### Найти индекс корзины, соответствующий key ###
  def find_bucket(key)
    index = hash_func(key)
    first_tombstone = -1
@@ -54,7 +54,7 @@ class HashMapOpenAddressing
    first_tombstone == -1 ? index : first_tombstone
  end

-  # ## Операция поиска ###
+  ### Операция поиска ###
  def get(key)
    # Найти индекс корзины, соответствующий key
    index = find_bucket(key)
@@ -64,7 +64,7 @@ class HashMapOpenAddressing
    nil
  end

-  # ## Операция добавления ###
+  ### Операция добавления ###
  def put(key, val)
    # Когда коэффициент загрузки превышает порог, выполнить расширение
    extend if load_factor > @load_thres
@@ -80,7 +80,7 @@ class HashMapOpenAddressing
    @size += 1
  end

-  # ## Операция удаления ###
+  ### Операция удаления ###
  def remove(key)
    # Найти индекс корзины, соответствующий key
    index = find_bucket(key)
@@ -91,7 +91,7 @@ class HashMapOpenAddressing
    end
  end

-  # ## Расширение хеш-таблицы ###
+  ### Расширение хеш-таблицы ###
  def extend
    # Временно сохранить исходную хеш-таблицу
    buckets_tmp = @buckets
@@ -105,7 +105,7 @@ class HashMapOpenAddressing
    end
  end

-  # ## Вывести хеш-таблицу ###
+  ### Вывести хеш-таблицу ###
  def print
    for pair in @buckets
      if pair.nil?
--- a/ru/codes/ruby/chapter_hashing/simple_hash.rb
+++ b/ru/codes/ruby/chapter_hashing/simple_hash.rb
@@ -4,7 +4,7 @@ Created Time: 2024-04-14
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Аддитивное хеширование ###
+### Аддитивное хеширование ###
 def add_hash(key)
  hash = 0
  modulus = 1_000_000_007
@@ -14,7 +14,7 @@ def add_hash(key)
  hash % modulus
 end

-# ## Мультипликативное хеширование ###
+### Мультипликативное хеширование ###
 def mul_hash(key)
  hash = 0
  modulus = 1_000_000_007
@@ -24,7 +24,7 @@ def mul_hash(key)
  hash % modulus
 end

-# ## XOR-хеширование ###
+### XOR-хеширование ###
 def xor_hash(key)
  hash = 0
  modulus = 1_000_000_007
@@ -34,7 +34,7 @@ def xor_hash(key)
  hash % modulus
 end

-# ## Хеширование с циклическим сдвигом ###
+### Хеширование с циклическим сдвигом ###
 def rot_hash(key)
  hash = 0
  modulus = 1_000_000_007
--- a/ru/codes/ruby/chapter_heap/my_heap.rb
+++ b/ru/codes/ruby/chapter_heap/my_heap.rb
@@ -6,11 +6,11 @@ Author: Blue Bean (lonnnnnnner@gmail.com)

 require_relative '../utils/print_util'

-# ## Максимальная куча ###
+### Максимальная куча ###
 class MaxHeap
  attr_reader :max_heap

-  # ## Конструктор, строящий кучу по входному списку ###
+  ### Конструктор, строящий кучу по входному списку ###
  def initialize(nums)
    # Добавить элементы списка в кучу без изменений
    @max_heap = nums
@@ -20,42 +20,42 @@ class MaxHeap
    end
  end

-  # ## Получить индекс левого дочернего узла ###
+  ### Получить индекс левого дочернего узла ###
  def left(i)
    2 * i + 1
  end

-  # ## Получить индекс правого дочернего узла ###
+  ### Получить индекс правого дочернего узла ###
  def right(i)
    2 * i + 2
  end

-  # ## Получить индекс родительского узла ###
+  ### Получить индекс родительского узла ###
  def parent(i)
    (i - 1) / 2     # Округление вниз при делении
  end

-  # ## Обмен элементов ###
+  ### Обмен элементов ###
  def swap(i, j)
    @max_heap[i], @max_heap[j] = @max_heap[j], @max_heap[i]
  end

-  # ## Получить размер кучи ###
+  ### Получить размер кучи ###
  def size
    @max_heap.length
  end

-  # ## Проверка, пуста ли куча ###
+  ### Проверка, пуста ли куча ###
  def is_empty?
    size == 0
  end

-  # ## Доступ к элементу на вершине кучи ###
+  ### Доступ к элементу на вершине кучи ###
  def peek
    @max_heap[0]
  end

-  # ## Добавление элемента в кучу ###
+  ### Добавление элемента в кучу ###
  def push(val)
    # Добавление узла
    @max_heap << val
@@ -63,7 +63,7 @@ class MaxHeap
    sift_up(size - 1)
  end

-  # ## Начиная с узла i, выполнить просеивание снизу вверх ###
+  ### Начиная с узла i, выполнить просеивание снизу вверх ###
  def sift_up(i)
    loop do
      # Получение родительского узла для узла i
@@ -77,7 +77,7 @@ class MaxHeap
    end
  end

-  # ## Извлечение элемента из кучи ###
+  ### Извлечение элемента из кучи ###
  def pop
    # Обработка пустого случая
    raise IndexError, "куча пуста" if is_empty?
@@ -91,7 +91,7 @@ class MaxHeap
    val
  end

-  # ## Начиная с узла i, выполнить просеивание сверху вниз ###
+  ### Начиная с узла i, выполнить просеивание сверху вниз ###
  def sift_down(i)
    loop do
      # Определить узел с максимальным значением среди i, l и r и обозначить его как ma
--- a/ru/codes/ruby/chapter_heap/top_k.rb
+++ b/ru/codes/ruby/chapter_heap/top_k.rb
@@ -6,31 +6,31 @@ Author: Blue Bean (lonnnnnnner@gmail.com)

 require_relative "./my_heap"

-# ## Добавление элемента в кучу ###
+### Добавление элемента в кучу ###
 def push_min_heap(heap, val)
  # Инвертировать знак элемента
  heap.push(-val)
 end

-# ## Извлечение элемента из кучи ###
+### Извлечение элемента из кучи ###
 def pop_min_heap(heap)
  # Инвертировать знак элемента
  -heap.pop
 end

-# ## Доступ к элементу на вершине кучи ###
+### Доступ к элементу на вершине кучи ###
 def peek_min_heap(heap)
  # Инвертировать знак элемента
  -heap.peek
 end

-# ## Извлечение элементов из кучи ###
+### Извлечение элементов из кучи ###
 def get_min_heap(heap)
  # Инвертировать все элементы кучи
  heap.max_heap.map { |x| -x }
 end

-# ## Поиск k наибольших элементов массива с помощью кучи ###
+### Поиск k наибольших элементов массива с помощью кучи ###
 def top_k_heap(nums, k)
  # Инициализация минимальной кучи
  # Обратите внимание: мы инвертируем все элементы кучи, чтобы с помощью максимальной кучи имитировать минимальную
--- a/ru/codes/ruby/chapter_searching/binary_search.rb
+++ b/ru/codes/ruby/chapter_searching/binary_search.rb
@@ -4,7 +4,7 @@ Created Time: 2024-04-09
 Author: Blue Bean (lonnnnnnner@gmail.com)
 =end

-# ## Бинарный поиск (двусторонне замкнутый интервал) ###
+### Бинарный поиск (двусторонне замкнутый интервал) ###
 def binary_search(nums, target)
  # Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно
  i, j = 0, nums.length - 1
@@ -26,7 +26,7 @@ def binary_search(nums, target)
  -1  # Целевой элемент не найден, вернуть -1
 end

-# ## Бинарный поиск (лево замкнутый, право открытый интервал) ###
+### Бинарный поиск (лево замкнутый, право открытый интервал) ###
 def binary_search_lcro(nums, target)
  # Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно
  i, j = 0, nums.length
--- a/ru/codes/ruby/chapter_searching/binary_search_edge.rb
+++ b/ru/codes/ruby/chapter_searching/binary_search_edge.rb
@@ -6,7 +6,7 @@ Author: Blue Bean (lonnnnnnner@gmail.com)

 require_relative './binary_search_insertion'

-# ## Бинарный поиск самого левого target ###
+### Бинарный поиск самого левого target ###
 def binary_search_left_edge(nums, target)
  # Эквивалентно поиску точки вставки target
  i = binary_search_insertion(nums, target)
@@ -17,7 +17,7 @@ def binary_search_left_edge(nums, target)
  i # Найти target и вернуть индекс i
 end

-# ## Бинарный поиск самого правого target ###
+### Бинарный поиск самого правого target ###
 def binary_search_right_edge(nums, target)
  # Преобразовать задачу в поиск самого левого target + 1
  i = binary_search_insertion(nums, target + 1)
--- a/ru/codes/ruby/chapter_searching/binary_search_insertion.rb
+++ b/ru/codes/ruby/chapter_searching/binary_search_insertion.rb
@@ -4,7 +4,7 @@ Created Time: 2024-04-09
 Author: Blue Bean (lonnnnnnner@gmail.com)
 =end

-# ## Бинарный поиск точки вставки (без повторяющихся элементов) ###
+### Бинарный поиск точки вставки (без повторяющихся элементов) ###
 def binary_search_insertion_simple(nums, target)
  # Инициализировать двусторонне замкнутый интервал [0, n-1]
  i, j = 0, nums.length - 1
@@ -25,7 +25,7 @@ def binary_search_insertion_simple(nums, target)
  i # target не найден, вернуть точку вставки i
 end

-# ## Бинарный поиск точки вставки (с повторяющимися элементами) ###
+### Бинарный поиск точки вставки (с повторяющимися элементами) ###
 def binary_search_insertion(nums, target)
  # Инициализировать двусторонне замкнутый интервал [0, n-1]
  i, j = 0, nums.length - 1
--- a/ru/codes/ruby/chapter_searching/hashing_search.rb
+++ b/ru/codes/ruby/chapter_searching/hashing_search.rb
@@ -6,14 +6,14 @@ Author: Blue Bean (lonnnnnnner@gmail.com)

 require_relative '../utils/list_node'

-# ## Хеш-поиск (массив) ###
+### Хеш-поиск (массив) ###
 def hashing_search_array(hmap, target)
  # key хеш-таблицы: целевой элемент, value: индекс
  # Если такого key нет в хеш-таблице, вернуть -1
  hmap[target] || -1
 end

-# ## Хеш-поиск (связный список) ###
+### Хеш-поиск (связный список) ###
 def hashing_search_linkedlist(hmap, target)
  # key хеш-таблицы: целевой элемент, value: объект узла
  # Если такого key нет в хеш-таблице, вернуть None
--- a/ru/codes/ruby/chapter_searching/linear_search.rb
+++ b/ru/codes/ruby/chapter_searching/linear_search.rb
@@ -6,7 +6,7 @@ Author: Blue Bean (lonnnnnnner@gmail.com)

 require_relative '../utils/list_node'

-# ## Линейный поиск (массив) ###
+### Линейный поиск (массив) ###
 def linear_search_array(nums, target)
  # Обход массива
  for i in 0...nums.length
@@ -16,7 +16,7 @@ def linear_search_array(nums, target)
  -1 # Целевой элемент не найден, вернуть -1
 end

-# ## Линейный поиск (связный список) ###
+### Линейный поиск (связный список) ###
 def linear_search_linkedlist(head, target)
  # Обойти связный список
  while head
--- a/ru/codes/ruby/chapter_searching/two_sum.rb
+++ b/ru/codes/ruby/chapter_searching/two_sum.rb
@@ -4,7 +4,7 @@ Created Time: 2024-04-09
 Author: Blue Bean (lonnnnnnner@gmail.com)
 =end

-# ## Метод 1: полный перебор ###
+### Метод 1: полный перебор ###
 def two_sum_brute_force(nums, target)
  # Два вложенных цикла, временная сложность O(n^2)
  for i in 0...(nums.length - 1)
@@ -16,7 +16,7 @@ def two_sum_brute_force(nums, target)
  []
 end

-# ## Метод 2: вспомогательная хеш-таблица ###
+### Метод 2: вспомогательная хеш-таблица ###
 def two_sum_hash_table(nums, target)
  # Вспомогательная хеш-таблица, пространственная сложность O(n)
  dic = {}
--- a/ru/codes/ruby/chapter_sorting/bubble_sort.rb
+++ b/ru/codes/ruby/chapter_sorting/bubble_sort.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-02
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Пузырьковая сортировка ###
+### Пузырьковая сортировка ###
 def bubble_sort(nums)
  n = nums.length
  # Внешний цикл: неотсортированный диапазон [0, i]
--- a/ru/codes/ruby/chapter_sorting/bucket_sort.rb
+++ b/ru/codes/ruby/chapter_sorting/bucket_sort.rb
@@ -4,7 +4,7 @@ Created Time: 2024-04-17
 Author: Martin Xu (martin.xus@gmail.com)
 =end

-# ## Сортировка корзинами ###
+### Сортировка корзинами ###
 def bucket_sort(nums)
  # Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
  k = nums.length / 2
--- a/ru/codes/ruby/chapter_sorting/counting_sort.rb
+++ b/ru/codes/ruby/chapter_sorting/counting_sort.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-02
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Сортировка подсчетом ###
+### Сортировка подсчетом ###
 def counting_sort_naive(nums)
  # Простая реализация, не подходит для сортировки объектов
  # 1. Найти максимальный элемент массива m
@@ -24,7 +24,7 @@ def counting_sort_naive(nums)
  end
 end

-# ## Сортировка подсчетом ###
+### Сортировка подсчетом ###
 def counting_sort(nums)
  # Полная реализация, позволяет сортировать объекты и является стабильной сортировкой
  # 1. Найти максимальный элемент массива m
--- a/ru/codes/ruby/chapter_sorting/heap_sort.rb
+++ b/ru/codes/ruby/chapter_sorting/heap_sort.rb
@@ -4,7 +4,7 @@ Created Time: 2024-04-10
 Author: junminhong (junminhong1110@gmail.com)
 =end

-# ## Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз ###
+### Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз ###
 def sift_down(nums, n, i)
  while true
    # Определить узел с максимальным значением среди i, l и r и обозначить его как ma
@@ -22,7 +22,7 @@ def sift_down(nums, n, i)
  end
 end

-# ## Сортировка кучей ###
+### Сортировка кучей ###
 def heap_sort(nums)
  # Построение кучи: выполнить heapify для всех узлов, кроме листовых
  (nums.length / 2 - 1).downto(0) do |i|
--- a/ru/codes/ruby/chapter_sorting/insertion_sort.rb
+++ b/ru/codes/ruby/chapter_sorting/insertion_sort.rb
@@ -4,7 +4,7 @@ Created Time: 2024-04-02
 Author: Cy (3739004@gmail.com), Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Сортировка вставками ###
+### Сортировка вставками ###
 def insertion_sort(nums)
  n = nums.length
  # Внешний цикл: отсортированный диапазон [0, i-1]
--- a/ru/codes/ruby/chapter_sorting/merge_sort.rb
+++ b/ru/codes/ruby/chapter_sorting/merge_sort.rb
@@ -4,7 +4,7 @@ Created Time: 2024-04-10
 Author: junminhong (junminhong1110@gmail.com)
 =end

-# ## Слияние левого и правого подмассивов ###
+### Слияние левого и правого подмассивов ###
 def merge(nums, left, mid, right)
  # Интервал левого подмассива: [left, mid], правого подмассива: [mid+1, right]
  # Создать временный массив tmp для хранения результата слияния
@@ -39,7 +39,7 @@ def merge(nums, left, mid, right)
  end
 end

-# ## Сортировка слиянием ###
+### Сортировка слиянием ###
 def merge_sort(nums, left, right)
  # Условие завершения
  # Когда длина подмассива равна 1, рекурсия завершается
--- a/ru/codes/ruby/chapter_sorting/quick_sort.rb
+++ b/ru/codes/ruby/chapter_sorting/quick_sort.rb
@@ -4,10 +4,10 @@ Created Time: 2024-04-01
 Author: Cy (3739004@gmail.com), Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Класс быстрой сортировки ###
+### Класс быстрой сортировки ###
 class QuickSort
  class << self
-    # ## Разбиение с опорными указателями ###
+    ### Разбиение с опорными указателями ###
    def partition(nums, left, right)
      # Взять nums[left] в качестве опорного элемента
      i, j = left, right
@@ -26,7 +26,7 @@ class QuickSort
      i # Вернуть индекс опорного элемента
    end

-    # ## Класс быстрой сортировки ###
+    ### Класс быстрой сортировки ###
    def quick_sort(nums, left, right)
      # Рекурсивно обрабатывать, пока длина подмассива не станет равной 1
      if left < right
@@ -44,7 +44,7 @@ end
 # ## Класс быстрой сортировки (оптимизация медианой) ###
 class QuickSortMedian
  class << self
-    # ## Выбрать медиану из трех кандидатов ###
+    ### Выбрать медиану из трех кандидатов ###
    def median_three(nums, left, mid, right)
      # Выбрать медиану из трех кандидатов
      _l, _m, _r = nums[left], nums[mid], nums[right]
@@ -77,7 +77,7 @@ class QuickSortMedian
      i # Вернуть индекс опорного элемента
    end

-    # ## Быстрая сортировка ###
+    ### Быстрая сортировка ###
    def quick_sort(nums, left, right)
      # Рекурсивно обрабатывать, пока длина подмассива не станет равной 1
      if left < right
@@ -95,7 +95,7 @@ end
 # ## Класс быстрой сортировки (оптимизация глубины рекурсии) ###
 class QuickSortTailCall
  class << self
-    # ## Разбиение с опорными указателями ###
+    ### Разбиение с опорными указателями ###
    def partition(nums, left, right)
      # Использовать nums[left] как опорный элемент
      i = left
--- a/ru/codes/ruby/chapter_sorting/radix_sort.rb
+++ b/ru/codes/ruby/chapter_sorting/radix_sort.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-03
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Получить k-й разряд элемента num, где exp = 10^(k-1) ###
+### Получить k-й разряд элемента num, где exp = 10^(k-1) ###
 def digit(num, exp)
  # Передача exp вместо k позволяет избежать повторного выполнения дорогостоящих вычислений степени
  (num / exp) % 10
@@ -34,7 +34,7 @@ def counting_sort_digit(nums, exp)
  (0...n).each { |i| nums[i] = res[i] }
 end

-# ## Поразрядная сортировка ###
+### Поразрядная сортировка ###
 def radix_sort(nums)
  # Получить максимальный элемент массива, чтобы определить максимальное число разрядов
  m = nums.max
--- a/ru/codes/ruby/chapter_sorting/selection_sort.rb
+++ b/ru/codes/ruby/chapter_sorting/selection_sort.rb
@@ -4,7 +4,7 @@ Created Time: 2024-05-03
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Сортировка выбором ###
+### Сортировка выбором ###
 def selection_sort(nums)
  n = nums.length
  # Внешний цикл: неотсортированный диапазон [i, n-1]
--- a/ru/codes/ruby/chapter_stack_and_queue/array_deque.rb
+++ b/ru/codes/ruby/chapter_stack_and_queue/array_deque.rb
@@ -4,29 +4,29 @@ Created Time: 2024-04-05
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Двусторонняя очередь на основе кольцевого массива ###
+### Двусторонняя очередь на основе кольцевого массива ###
 class ArrayDeque
-  # ## Получение длины двусторонней очереди ###
+  ### Получение длины двусторонней очереди ###
  attr_reader :size

-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize(capacity)
    @nums = Array.new(capacity, 0)
    @front = 0
    @size = 0
  end

-  # ## Получить вместимость двусторонней очереди ###
+  ### Получить вместимость двусторонней очереди ###
  def capacity
    @nums.length
  end

-  # ## Проверка, пуста ли двусторонняя очередь ###
+  ### Проверка, пуста ли двусторонняя очередь ###
  def is_empty?
    size.zero?
  end

-  # ## Добавление в голову очереди ###
+  ### Добавление в голову очереди ###
  def push_first(num)
    if size == capacity
      puts 'Двусторонняя очередь заполнена'
@@ -41,7 +41,7 @@ class ArrayDeque
    @size += 1
  end

-  # ## Добавление в хвост очереди ###
+  ### Добавление в хвост очереди ###
  def push_last(num)
    if size == capacity
      puts 'Двусторонняя очередь заполнена'
@@ -55,7 +55,7 @@ class ArrayDeque
    @size += 1
  end

-  # ## Извлечение из головы очереди ###
+  ### Извлечение из головы очереди ###
  def pop_first
    num = peek_first
    # Указатель головы сдвигается на одну позицию назад
@@ -64,21 +64,21 @@ class ArrayDeque
    num
  end

-  # ## Извлечение из хвоста очереди ###
+  ### Извлечение из хвоста очереди ###
  def pop_last
    num = peek_last
    @size -= 1
    num
  end

-  # ## Доступ к элементу в начале очереди ###
+  ### Доступ к элементу в начале очереди ###
  def peek_first
    raise IndexError, 'двусторонняя очередь пуста' if is_empty?

    @nums[@front]
  end

-  # ## Доступ к элементу в хвосте очереди ###
+  ### Доступ к элементу в хвосте очереди ###
  def peek_last
    raise IndexError, 'двусторонняя очередь пуста' if is_empty?

@@ -87,7 +87,7 @@ class ArrayDeque
    @nums[last]
  end

-  # ## Вернуть массив для вывода ###
+  ### Вернуть массив для вывода ###
  def to_array
    # Преобразовывать только элементы списка в пределах фактической длины
    res = []
@@ -99,7 +99,7 @@ class ArrayDeque

  private

-  # ## Вычислить индекс в кольцевом массиве ###
+  ### Вычислить индекс в кольцевом массиве ###
  def index(i)
    # С помощью операции взятия по модулю соединить начало и конец массива
    # Когда i выходит за конец массива, он возвращается в начало
--- a/ru/codes/ruby/chapter_stack_and_queue/array_queue.rb
+++ b/ru/codes/ruby/chapter_stack_and_queue/array_queue.rb
@@ -4,29 +4,29 @@ Created Time: 2024-04-05
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Очередь на основе кольцевого массива ###
+### Очередь на основе кольцевого массива ###
 class ArrayQueue
-  # ## Получение длины очереди ###
+  ### Получение длины очереди ###
  attr_reader :size

-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize(size)
    @nums = Array.new(size, 0) # Массив для хранения элементов очереди
    @front = 0 # Указатель head, указывающий на первый элемент очереди
    @size = 0 # Длина очереди
  end

-  # ## Получить вместимость очереди ###
+  ### Получить вместимость очереди ###
  def capacity
    @nums.length
  end

-  # ## Проверка, пуста ли очередь ###
+  ### Проверка, пуста ли очередь ###
  def is_empty?
    size.zero?
  end

-  # ## Добавление в очередь ###
+  ### Добавление в очередь ###
  def push(num)
    raise IndexError, 'очередь заполнена' if size == capacity

@@ -38,7 +38,7 @@ class ArrayQueue
    @size += 1
  end

-  # ## Извлечение из очереди ###
+  ### Извлечение из очереди ###
  def pop
    num = peek
    # Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива
@@ -47,14 +47,14 @@ class ArrayQueue
    num
  end

-  # ## Доступ к элементу в начале очереди ###
+  ### Доступ к элементу в начале очереди ###
  def peek
    raise IndexError, 'очередь пуста' if is_empty?

    @nums[@front]
  end

-  # ## Вернуть список для вывода ###
+  ### Вернуть список для вывода ###
  def to_array
    res = Array.new(size, 0)
    j = @front
--- a/ru/codes/ruby/chapter_stack_and_queue/array_stack.rb
+++ b/ru/codes/ruby/chapter_stack_and_queue/array_stack.rb
@@ -4,43 +4,43 @@ Created Time: 2024-04-06
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Стек на основе массива ###
+### Стек на основе массива ###
 class ArrayStack
-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    @stack = []
  end

-  # ## Получить длину стека ###
+  ### Получить длину стека ###
  def size
    @stack.length
  end

-  # ## Проверка, пуст ли стек ###
+  ### Проверка, пуст ли стек ###
  def is_empty?
    @stack.empty?
  end

-  # ## Помещение в стек ###
+  ### Помещение в стек ###
  def push(item)
    @stack << item
  end

-  # ## Извлечение из стека ###
+  ### Извлечение из стека ###
  def pop
    raise IndexError, 'стек пуст' if is_empty?

    @stack.pop
  end

-  # ## Доступ к верхнему элементу стека ###
+  ### Доступ к верхнему элементу стека ###
  def peek
    raise IndexError, 'стек пуст' if is_empty?

    @stack.last
  end

-  # ## Вернуть список для вывода ###
+  ### Вернуть список для вывода ###
  def to_array
    @stack
  end
--- a/ru/codes/ruby/chapter_stack_and_queue/linkedlist_deque.rb
+++ b/ru/codes/ruby/chapter_stack_and_queue/linkedlist_deque.rb
@@ -10,30 +10,30 @@ class ListNode
  attr_accessor :next # Ссылка на узел-преемник
  attr_accessor :prev # Ссылка на узел-предшественник

-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize(val)
    @val = val
  end
 end

-# ## Двусторонняя очередь на основе двусвязного списка ###
+### Двусторонняя очередь на основе двусвязного списка ###
 class LinkedListDeque
-  # ## Получение длины двусторонней очереди ###
+  ### Получение длины двусторонней очереди ###
  attr_reader :size

-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    @front = nil  # Головной узел front
    @rear = nil   # Хвостовой узел rear
    @size = 0     # Длина двусторонней очереди
  end

-  # ## Проверка, пуста ли двусторонняя очередь ###
+  ### Проверка, пуста ли двусторонняя очередь ###
  def is_empty?
    size.zero?
  end

-  # ## Операция добавления в очередь ###
+  ### Операция добавления в очередь ###
  def push(num, is_front)
    node = ListNode.new(num)
    # Если связный список пуст, пусть front и rear оба указывают на node
@@ -55,17 +55,17 @@ class LinkedListDeque
    @size += 1 # Обновить длину очереди
  end

-  # ## Добавление в голову очереди ###
+  ### Добавление в голову очереди ###
  def push_first(num)
    push(num, true)
  end

-  # ## Добавление в хвост очереди ###
+  ### Добавление в хвост очереди ###
  def push_last(num)
    push(num, false)
  end

-  # ## Операция извлечения из очереди ###
+  ### Операция извлечения из очереди ###
  def pop(is_front)
    raise IndexError, 'двусторонняя очередь пуста' if is_empty?

@@ -95,31 +95,31 @@ class LinkedListDeque
    val
  end

-  # ## Извлечение из головы очереди ###
+  ### Извлечение из головы очереди ###
  def pop_first
    pop(true)
  end

-  # ## Извлечение из головы очереди ###
+  ### Извлечение из головы очереди ###
  def pop_last
    pop(false)
  end

-  # ## Доступ к элементу в начале очереди ###
+  ### Доступ к элементу в начале очереди ###
  def peek_first
    raise IndexError, 'двусторонняя очередь пуста' if is_empty?

    @front.val
  end

-  # ## Доступ к элементу в хвосте очереди ###
+  ### Доступ к элементу в хвосте очереди ###
  def peek_last
    raise IndexError, 'двусторонняя очередь пуста' if is_empty?

    @rear.val
  end

-  # ## Вернуть массив для вывода ###
+  ### Вернуть массив для вывода ###
  def to_array
    node = @front
    res = Array.new(size, 0)
--- a/ru/codes/ruby/chapter_stack_and_queue/linkedlist_queue.rb
+++ b/ru/codes/ruby/chapter_stack_and_queue/linkedlist_queue.rb
@@ -6,24 +6,24 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)

 require_relative '../utils/list_node'

-# ## Очередь на основе связного списка ###
+### Очередь на основе связного списка ###
 class LinkedListQueue
-  # ## Получение длины очереди ###
+  ### Получение длины очереди ###
  attr_reader :size

-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    @front = nil  # Головной узел front
    @rear = nil   # Хвостовой узел rear
    @size = 0
  end

-  # ## Проверка, пуста ли очередь ###
+  ### Проверка, пуста ли очередь ###
  def is_empty?
    @front.nil?
  end

-  # ## Добавление в очередь ###
+  ### Добавление в очередь ###
  def push(num)
    # Добавить num после хвостового узла
    node = ListNode.new(num)
@@ -41,7 +41,7 @@ class LinkedListQueue
    @size += 1
  end

-  # ## Извлечение из очереди ###
+  ### Извлечение из очереди ###
  def pop
    num = peek
    # Удалить головной узел
@@ -50,14 +50,14 @@ class LinkedListQueue
    num
  end

-  # ## Доступ к элементу в начале очереди ###
+  ### Доступ к элементу в начале очереди ###
  def peek
    raise IndexError, 'очередь пуста' if is_empty?

    @front.val
  end

-  # ## Преобразовать связный список в Array и вернуть ###
+  ### Преобразовать связный список в Array и вернуть ###
  def to_array
    queue = []
    temp = @front
--- a/ru/codes/ruby/chapter_stack_and_queue/linkedlist_stack.rb
+++ b/ru/codes/ruby/chapter_stack_and_queue/linkedlist_stack.rb
@@ -6,21 +6,21 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)

 require_relative '../utils/list_node'

-# ## Стек на основе связного списка ###
+### Стек на основе связного списка ###
 class LinkedListStack
  attr_reader :size

-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    @size = 0
  end

-  # ## Проверка, пуст ли стек ###
+  ### Проверка, пуст ли стек ###
  def is_empty?
    @peek.nil?
  end

-  # ## Помещение в стек ###
+  ### Помещение в стек ###
  def push(val)
    node = ListNode.new(val)
    node.next = @peek
@@ -28,7 +28,7 @@ class LinkedListStack
    @size += 1
  end

-  # ## Извлечение из стека ###
+  ### Извлечение из стека ###
  def pop
    num = peek
    @peek = @peek.next
@@ -36,14 +36,14 @@ class LinkedListStack
    num
  end

-  # ## Доступ к верхнему элементу стека ###
+  ### Доступ к верхнему элементу стека ###
  def peek
    raise IndexError, 'стек пуст' if is_empty?

    @peek.val
  end

-  # ## Преобразовать связный список в Array и вернуть ###
+  ### Преобразовать связный список в Array и вернуть ###
  def to_array
    arr = []
    node = @peek
--- a/ru/codes/ruby/chapter_tree/array_binary_tree.rb
+++ b/ru/codes/ruby/chapter_tree/array_binary_tree.rb
@@ -7,19 +7,19 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Класс двоичного дерева в массивном представлении ###
+### Класс двоичного дерева в массивном представлении ###
 class ArrayBinaryTree
-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize(arr)
    @tree = arr.to_a
  end

-  # ## Вместимость списка ###
+  ### Вместимость списка ###
  def size
    @tree.length
  end

-  # ## Получить значение узла с индексом i ###
+  ### Получить значение узла с индексом i ###
  def val(i)
    # Если индекс выходит за границы, вернуть nil, обозначающий пустую ячейку
    return if i < 0 || i >= size
@@ -27,22 +27,22 @@ class ArrayBinaryTree
    @tree[i]
  end

-  # ## Получить индекс левого дочернего узла узла с индексом i ###
+  ### Получить индекс левого дочернего узла узла с индексом i ###
  def left(i)
    2 * i + 1
  end

-  # ## Получить индекс правого дочернего узла узла с индексом i ###
+  ### Получить индекс правого дочернего узла узла с индексом i ###
  def right(i)
    2 * i + 2
  end

-  # ## Получить индекс родительского узла узла с индексом i ###
+  ### Получить индекс родительского узла узла с индексом i ###
  def parent(i)
    (i - 1) / 2
  end

-  # ## Обход в ширину ###
+  ### Обход в ширину ###
  def level_order
    @res = []

@@ -54,7 +54,7 @@ class ArrayBinaryTree
    @res
  end

-  # ## Обход в глубину ###
+  ### Обход в глубину ###
  def dfs(i, order)
    return if val(i).nil?
    # Предварительный обход
@@ -67,21 +67,21 @@ class ArrayBinaryTree
    @res << val(i) if order == :post
  end

-  # ## Предварительный обход ###
+  ### Предварительный обход ###
  def pre_order
    @res = []
    dfs(0, :pre)
    @res
  end

-  # ## Симметричный обход ###
+  ### Симметричный обход ###
  def in_order
    @res = []
    dfs(0, :in)
    @res
  end

-  # ## Обратный обход ###
+  ### Обратный обход ###
  def post_order
    @res = []
    dfs(0, :post)
--- a/ru/codes/ruby/chapter_tree/avl_tree.rb
+++ b/ru/codes/ruby/chapter_tree/avl_tree.rb
@@ -7,19 +7,19 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## AVL-дерево ###
+### AVL-дерево ###
 class AVLTree
-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    @root = nil
  end

-  # ## Получение корневого узла двоичного дерева ###
+  ### Получение корневого узла двоичного дерева ###
  def get_root
    @root
  end

-  # ## Получить высоту узла ###
+  ### Получить высоту узла ###
  def height(node)
    # Высота пустого узла равна -1, высота листового узла равна 0
    return node.height unless node.nil?
@@ -27,13 +27,13 @@ class AVLTree
    -1
  end

-  # ## Обновить высоту узла ###
+  ### Обновить высоту узла ###
  def update_height(node)
    # Высота узла равна высоте более высокого поддерева + 1
    node.height = [height(node.left), height(node.right)].max + 1
  end

-  # ## Получить коэффициент баланса ###
+  ### Получить коэффициент баланса ###
  def balance_factor(node)
    # Коэффициент баланса пустого узла равен 0
    return 0 if node.nil?
@@ -42,7 +42,7 @@ class AVLTree
    height(node.left) - height(node.right)
  end

-  # ## Операция правого вращения ###
+  ### Операция правого вращения ###
  def right_rotate(node)
    child = node.left
    grand_child = child.right
@@ -56,7 +56,7 @@ class AVLTree
    child
  end

-  # ## Операция левого вращения ###
+  ### Операция левого вращения ###
  def left_rotate(node)
    child = node.right
    grand_child = child.left
@@ -70,7 +70,7 @@ class AVLTree
    child
  end

-  # ## Выполнить вращение, чтобы снова сбалансировать поддерево ###
+  ### Выполнить вращение, чтобы снова сбалансировать поддерево ###
  def rotate(node)
    # Получить коэффициент баланса узла node
    balance_factor = balance_factor(node)
@@ -99,7 +99,7 @@ class AVLTree
    node
  end

-  # ## Вставка узла ###
+  ### Вставка узла ###
  def insert(val)
    @root = insert_helper(@root, val)
  end
@@ -122,7 +122,7 @@ class AVLTree
    rotate(node)
  end

-  # ## Удаление узла ###
+  ### Удаление узла ###
  def remove(val)
    @root = remove_helper(@root, val)
  end
@@ -158,7 +158,7 @@ class AVLTree
    rotate(node)
  end

-  # ## Поиск узла ###
+  ### Поиск узла ###
  def search(val)
    cur = @root
    # Искать в цикле и выйти после прохода за листовой узел
--- a/ru/codes/ruby/chapter_tree/binary_search_tree.rb
+++ b/ru/codes/ruby/chapter_tree/binary_search_tree.rb
@@ -7,20 +7,20 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Двоичное дерево поиска ###
+### Двоичное дерево поиска ###
 class BinarySearchTree
-  # ## Конструктор ###
+  ### Конструктор ###
  def initialize
    # Инициализировать пустое дерево
    @root = nil
  end

-  # ## Получение корневого узла двоичного дерева ###
+  ### Получение корневого узла двоичного дерева ###
  def get_root
    @root
  end

-  # ## Поиск узла ###
+  ### Поиск узла ###
  def search(num)
    cur = @root

@@ -41,7 +41,7 @@ class BinarySearchTree
    cur
  end

-  # ## Вставка узла ###
+  ### Вставка узла ###
  def insert(num)
    # Если дерево пусто, инициализировать корневой узел
    if @root.nil?
@@ -74,7 +74,7 @@ class BinarySearchTree
    end
  end

-  # ## Удаление узла ###
+  ### Удаление узла ###
  def remove(num)
    # Если дерево пусто, сразу вернуть
    return if @root.nil?
--- a/ru/codes/ruby/chapter_tree/binary_tree_bfs.rb
+++ b/ru/codes/ruby/chapter_tree/binary_tree_bfs.rb
@@ -7,7 +7,7 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Обход в ширину ###
+### Обход в ширину ###
 def level_order(root)
  # Инициализировать очередь и добавить корневой узел
  queue = [root]
--- a/ru/codes/ruby/chapter_tree/binary_tree_dfs.rb
+++ b/ru/codes/ruby/chapter_tree/binary_tree_dfs.rb
@@ -7,7 +7,7 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 require_relative '../utils/tree_node'
 require_relative '../utils/print_util'

-# ## Предварительный обход ###
+### Предварительный обход ###
 def pre_order(root)
  return if root.nil?

@@ -17,7 +17,7 @@ def pre_order(root)
  pre_order(root.right)
 end

-# ## Симметричный обход ###
+### Симметричный обход ###
 def in_order(root)
  return if root.nil?

@@ -27,7 +27,7 @@ def in_order(root)
  in_order(root.right)
 end

-# ## Обратный обход ###
+### Обратный обход ###
 def post_order(root)
  return if root.nil?

--- a/ru/codes/ruby/utils/list_node.rb
+++ b/ru/codes/ruby/utils/list_node.rb
@@ -4,7 +4,7 @@ Created Time: 2024-03-18
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Класс узла связного списка ###
+### Класс узла связного списка ###
 class ListNode
  attr_accessor :val  # Значение узла
  attr_accessor :next # Ссылка на следующий узел
@@ -15,7 +15,7 @@ class ListNode
  end
 end

-# ## Десериализация списка в связный список ###
+### Десериализация списка в связный список ###
 def arr_to_linked_list(arr)
  head = current = ListNode.new(arr[0])

@@ -27,7 +27,7 @@ def arr_to_linked_list(arr)
  head
 end

-# ## Сериализация связного списка в список ###
+### Сериализация связного списка в список ###
 def linked_list_to_arr(head)
  arr = []

--- a/ru/codes/ruby/utils/print_util.rb
+++ b/ru/codes/ruby/utils/print_util.rb
@@ -6,14 +6,14 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)

 require_relative "./tree_node"

-# ## Вывести матрицу ###
+### Вывести матрицу ###
 def print_matrix(mat)
  s = []
  mat.each { |arr| s << " #{arr.to_s}" }
  puts "[\n#{s.join(",\n")}\n]"
 end

-# ## Вывести связный список ###
+### Вывести связный список ###
 def print_linked_list(head)
  list = []
  while head
@@ -39,8 +39,8 @@ def show_trunk(p)
  print p.str
 end

-# ## Вывести двоичное дерево ###
-# Этот вывод дерева заимствован из TECHIE DELIGHT
+### Вывести двоичное дерево ###
+# This tree printer is borrowed from TECHIE DELIGHT
 # https://www.techiedelight.com/c-program-print-binary-tree/
 def print_tree(root, prev=nil, is_right=false)
  return if root.nil?
@@ -66,12 +66,12 @@ def print_tree(root, prev=nil, is_right=false)
  print_tree(root.left, trunk, false)
 end

-# ## Вывести хеш-таблицу ###
+### Вывести хеш-таблицу ###
 def print_hash_map(hmap)
  hmap.entries.each { |key, value| puts "#{key} -> #{value}" }
 end

-# ## Вывести кучу ###
+### Вывести кучу ###
 def print_heap(heap)
  puts "Массивное представление кучи:#{heap}"
  puts "Древовидное представление кучи:"
--- a/ru/codes/ruby/utils/tree_node.rb
+++ b/ru/codes/ruby/utils/tree_node.rb
@@ -4,7 +4,7 @@ Created Time: 2024-03-30
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Класс узла двоичного дерева ###
+### Класс узла двоичного дерева ###
 class TreeNode
  attr_accessor :val    # Значение узла
  attr_accessor :height # Высота узла
@@ -17,7 +17,7 @@ class TreeNode
  end
 end

-# ## Десериализация списка в двоичное дерево: рекурсия ###
+### Десериализация списка в двоичное дерево: рекурсия ###
 def arr_to_tree_dfs(arr, i)
  # Если индекс выходит за длину массива или соответствующий элемент равен nil, вернуть nil
  return if i < 0 || i >= arr.length || arr[i].nil?
@@ -29,12 +29,12 @@ def arr_to_tree_dfs(arr, i)
  root
 end

-# ## Десериализация списка в двоичное дерево ###
+### Десериализация списка в двоичное дерево ###
 def arr_to_tree(arr)
  arr_to_tree_dfs(arr, 0)
 end

-# ## Сериализация двоичного дерева в список: рекурсия ###
+### Сериализация двоичного дерева в список: рекурсия ###
 def tree_to_arr_dfs(root, i, res)
  return if root.nil?

@@ -45,7 +45,7 @@ def tree_to_arr_dfs(root, i, res)
  tree_to_arr_dfs(root.right, 2 * i + 2, res)
 end

-# ## Сериализация двоичного дерева в список ###
+### Сериализация двоичного дерева в список ###
 def tree_to_arr(root)
  res = []
  tree_to_arr_dfs(root, 0, res)
--- a/ru/codes/ruby/utils/vertex.rb
+++ b/ru/codes/ruby/utils/vertex.rb
@@ -4,7 +4,7 @@ Created Time: 2024-04-25
 Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end

-# ## Класс вершины ###
+### Класс вершины ###
 class Vertex
  attr_accessor :val

@@ -13,12 +13,12 @@ class Vertex
  end
 end

-# ## На вход подается список значений vals, на выходе возвращается список вершин vets ###
+### На вход подается список значений vals, на выходе возвращается список вершин vets ###
 def vals_to_vets(vals)
  Array.new(vals.length) { |i| Vertex.new(vals[i]) }
 end

-# ## На вход подается список вершин vets, на выходе возвращается список значений vals ###
+### На вход подается список вершин vets, на выходе возвращается список значений vals ###
 def vets_to_vals(vets)
  Array.new(vets.length) { |i| vets[i].val }
 end
--- a/ru/docs/chapter_appendix/terminology.md
+++ b/ru/docs/chapter_appendix/terminology.md
@@ -3,135 +3,135 @@
 В таблице ниже перечислены важные термины, встречающиеся в книге. Обратите внимание на следующие моменты.

 - Рекомендуем запомнить английские названия терминов, чтобы легче читать англоязычную литературу.
- В русской версии третий столбец дублирует основной перевод, чтобы сохранить единый формат таблицы.
+- В русской версии приводится единый рекомендуемый перевод каждого термина.

 <p align="center"> Таблица <id> &nbsp; Важные термины по структурам данных и алгоритмам </p>

-| English                        | Русский                        | Русский                        |
-| ------------------------------ | ------------------------------ | ------------------------------ |
-| algorithm                      | алгоритм                       | алгоритм                       |
-| data structure                 | структура данных               | структура данных               |
-| code                           | код                            | код                            |
-| file                           | файл                           | файл                           |
-| function                       | функция                        | функция                        |
-| method                         | метод                          | метод                          |
-| variable                       | переменная                     | переменная                     |
-| asymptotic complexity analysis | асимптотический анализ сложности | асимптотический анализ сложности |
-| time complexity                | временная сложность            | временная сложность            |
-| space complexity               | пространственная сложность     | пространственная сложность     |
-| loop                           | цикл                           | цикл                           |
-| iteration                      | итерация                       | итерация                       |
-| recursion                      | рекурсия                       | рекурсия                       |
-| tail recursion                 | хвостовая рекурсия             | хвостовая рекурсия             |
-| recursion tree                 | дерево рекурсии                | дерево рекурсии                |
-| big-$O$ notation               | нотация big-$O$                | нотация big-$O$                |
-| asymptotic upper bound         | асимптотическая верхняя граница | асимптотическая верхняя граница |
-| sign-magnitude                 | прямой код                     | прямой код                     |
-| 1’s complement                 | обратный код                   | обратный код                   |
-| 2’s complement                 | дополнительный код             | дополнительный код             |
-| array                          | массив                         | массив                         |
-| index                          | индекс                         | индекс                         |
-| linked list                    | связный список                 | связный список                 |
-| linked list node, list node    | узел связного списка           | узел связного списка           |
-| head node                      | головной узел                  | головной узел                  |
-| tail node                      | хвостовой узел                 | хвостовой узел                 |
-| list                           | список                         | список                         |
-| dynamic array                  | динамический массив            | динамический массив            |
-| hard disk                      | жесткий диск                   | жесткий диск                   |
-| random-access memory (RAM)     | оперативная память             | оперативная память             |
-| cache memory                   | кеш-память                     | кеш-память                     |
-| cache miss                     | промах кеша                    | промах кеша                    |
-| cache hit rate                 | коэффициент попадания в кеш    | коэффициент попадания в кеш    |
-| stack                          | стек                           | стек                           |
-| top of the stack               | вершина стека                  | вершина стека                  |
-| bottom of the stack            | основание стека                | основание стека                |
-| queue                          | очередь                        | очередь                        |
-| double-ended queue             | двусторонняя очередь           | двусторонняя очередь           |
-| front of the queue             | голова очереди                 | голова очереди                 |
-| rear of the queue              | хвост очереди                  | хвост очереди                  |
-| hash table                     | хеш-таблица                    | хеш-таблица                    |
-| hash set                       | хеш-набор                      | хеш-набор                      |
-| bucket                         | корзина                        | корзина                        |
-| hash function                  | хеш-функция                    | хеш-функция                    |
-| hash collision                 | хеш-коллизия                   | хеш-коллизия                   |
-| load factor                    | коэффициент заполнения         | коэффициент заполнения         |
-| separate chaining              | цепная адресация               | цепная адресация               |
-| open addressing                | открытая адресация             | открытая адресация             |
-| linear probing                 | линейное зондирование          | линейное зондирование          |
-| lazy deletion                  | ленивое удаление               | ленивое удаление               |
-| binary tree                    | двоичное дерево                | двоичное дерево                |
-| tree node                      | узел дерева                    | узел дерева                    |
-| left-child node                | левый дочерний узел            | левый дочерний узел            |
-| right-child node               | правый дочерний узел           | правый дочерний узел           |
-| parent node                    | родительский узел              | родительский узел              |
-| left subtree                   | левое поддерево                | левое поддерево                |
-| right subtree                  | правое поддерево               | правое поддерево               |
-| root node                      | корневой узел                  | корневой узел                  |
-| leaf node                      | листовой узел                  | листовой узел                  |
-| edge                           | ребро                          | ребро                          |
-| level                          | уровень                        | уровень                        |
-| degree                         | степень                        | степень                        |
-| height                         | высота                         | высота                         |
-| depth                          | глубина                        | глубина                        |
-| perfect binary tree            | идеальное двоичное дерево      | идеальное двоичное дерево      |
-| complete binary tree           | совершенное двоичное дерево    | совершенное двоичное дерево    |
-| full binary tree               | полное двоичное дерево         | полное двоичное дерево         |
-| balanced binary tree           | сбалансированное двоичное дерево | сбалансированное двоичное дерево |
-| binary search tree             | двоичное дерево поиска         | двоичное дерево поиска         |
-| AVL tree                       | АВЛ-дерево                     | АВЛ-дерево                     |
-| red-black tree                 | красно-черное дерево           | красно-черное дерево           |
-| level-order traversal          | обход по уровням               | обход по уровням               |
-| breadth-first traversal        | обход в ширину                 | обход в ширину                 |
-| depth-first traversal          | обход в глубину                | обход в глубину                |
-| binary search tree             | двоичное дерево поиска         | двоичное дерево поиска         |
-| balanced binary search tree    | сбалансированное двоичное дерево поиска | сбалансированное двоичное дерево поиска |
-| balance factor                 | фактор баланса                 | фактор баланса                 |
-| heap                           | куча                           | куча                           |
-| max heap                       | максимальная куча              | максимальная куча              |
-| min heap                       | минимальная куча               | минимальная куча               |
-| priority queue                 | приоритетная очередь           | приоритетная очередь           |
-| heapify                        | упорядочивание кучи            | упорядочивание кучи            |
-| top-$k$ problem                | поиск $k$ наибольших элементов | поиск $k$ наибольших элементов |
-| graph                          | граф                           | граф                           |
-| vertex                         | вершина                        | вершина                        |
-| undirected graph               | неориентированный граф         | неориентированный граф         |
-| directed graph                 | ориентированный граф           | ориентированный граф           |
-| connected graph                | связный граф                   | связный граф                   |
-| disconnected graph             | несвязный граф                 | несвязный граф                 |
-| weighted graph                 | взвешенный граф                | взвешенный граф                |
-| adjacency                      | смежность                      | смежность                      |
-| path                           | путь                           | путь                           |
-| in-degree                      | входящая степень               | входящая степень               |
-| out-degree                     | исходящая степень              | исходящая степень              |
-| adjacency matrix               | матрица смежности              | матрица смежности              |
-| adjacency list                 | список смежности               | список смежности               |
-| breadth-first search           | поиск в ширину                 | поиск в ширину                 |
-| depth-first search             | поиск в глубину                | поиск в глубину                |
-| binary search                  | двоичный поиск                 | двоичный поиск                 |
-| searching algorithm            | алгоритм поиска                | алгоритм поиска                |
-| sorting algorithm              | алгоритм сортировки            | алгоритм сортировки            |
-| selection sort                 | сортировка выбором             | сортировка выбором             |
-| bubble sort                    | сортировка пузырьком           | сортировка пузырьком           |
-| insertion sort                 | сортировка вставкой            | сортировка вставкой            |
-| quick sort                     | быстрая сортировка             | быстрая сортировка             |
-| merge sort                     | сортировка слиянием            | сортировка слиянием            |
-| heap sort                      | пирамидальная сортировка       | пирамидальная сортировка       |
-| bucket sort                    | блочная сортировка             | блочная сортировка             |
-| counting sort                  | сортировка подсчетом           | сортировка подсчетом           |
-| radix sort                     | поразрядная сортировка         | поразрядная сортировка         |
-| divide and conquer             | разделяй и властвуй            | разделяй и властвуй            |
-| hanota problem                 | задача о Ханойской башне       | задача о Ханойской башне       |
-| backtracking algorithm         | алгоритм поиска с возвратом    | алгоритм поиска с возвратом    |
-| constraint                     | ограничение                    | ограничение                    |
-| solution                       | решение                        | решение                        |
-| state                          | состояние                      | состояние                      |
-| pruning                        | отсечение                      | отсечение                      |
-| permutations problem           | задача о перестановках         | задача о перестановках         |
-| subset-sum problem             | задача о сумме подмножеств     | задача о сумме подмножеств     |
-| $n$-queens problem             | задача о $n$ ферзях            | задача о $n$ ферзях            |
-| dynamic programming            | динамическое программирование  | динамическое программирование  |
-| initial state                  | начальное состояние            | начальное состояние            |
-| state-transition equation      | уравнение перехода состояния   | уравнение перехода состояния   |
-| knapsack problem               | задача о рюкзаке               | задача о рюкзаке               |
-| edit distance problem          | задача о расстоянии редактирования | задача о расстоянии редактирования |
-| greedy algorithm               | жадный алгоритм                | жадный алгоритм                |
+| English                        | Русский                        |
+| ------------------------------ | ------------------------------ |
+| algorithm                      | алгоритм                       |
+| data structure                 | структура данных               |
+| code                           | код                            |
+| file                           | файл                           |
+| function                       | функция                        |
+| method                         | метод                          |
+| variable                       | переменная                     |
+| asymptotic complexity analysis | асимптотический анализ сложности |
+| time complexity                | временная сложность            |
+| space complexity               | пространственная сложность     |
+| loop                           | цикл                           |
+| iteration                      | итерация                       |
+| recursion                      | рекурсия                       |
+| tail recursion                 | хвостовая рекурсия             |
+| recursion tree                 | дерево рекурсии                |
+| big-$O$ notation               | нотация big-$O$                |
+| asymptotic upper bound         | асимптотическая верхняя граница |
+| sign-magnitude                 | прямой код                     |
+| 1’s complement                 | обратный код                   |
+| 2’s complement                 | дополнительный код             |
+| array                          | массив                         |
+| index                          | индекс                         |
+| linked list                    | связный список                 |
+| linked list node, list node    | узел связного списка           |
+| head node                      | головной узел                  |
+| tail node                      | хвостовой узел                 |
+| list                           | список                         |
+| dynamic array                  | динамический массив            |
+| hard disk                      | жесткий диск                   |
+| random-access memory (RAM)     | оперативная память             |
+| cache memory                   | кеш-память                     |
+| cache miss                     | промах кеша                    |
+| cache hit rate                 | коэффициент попадания в кеш    |
+| stack                          | стек                           |
+| top of the stack               | вершина стека                  |
+| bottom of the stack            | основание стека                |
+| queue                          | очередь                        |
+| double-ended queue             | двусторонняя очередь           |
+| front of the queue             | голова очереди                 |
+| rear of the queue              | хвост очереди                  |
+| hash table                     | хеш-таблица                    |
+| hash set                       | хеш-набор                      |
+| bucket                         | корзина                        |
+| hash function                  | хеш-функция                    |
+| hash collision                 | хеш-коллизия                   |
+| load factor                    | коэффициент заполнения         |
+| separate chaining              | цепная адресация               |
+| open addressing                | открытая адресация             |
+| linear probing                 | линейное зондирование          |
+| lazy deletion                  | ленивое удаление               |
+| binary tree                    | двоичное дерево                |
+| tree node                      | узел дерева                    |
+| left-child node                | левый дочерний узел            |
+| right-child node               | правый дочерний узел           |
+| parent node                    | родительский узел              |
+| left subtree                   | левое поддерево                |
+| right subtree                  | правое поддерево               |
+| root node                      | корневой узел                  |
+| leaf node                      | листовой узел                  |
+| edge                           | ребро                          |
+| level                          | уровень                        |
+| degree                         | степень                        |
+| height                         | высота                         |
+| depth                          | глубина                        |
+| perfect binary tree            | идеальное двоичное дерево      |
+| complete binary tree           | совершенное двоичное дерево    |
+| full binary tree               | полное двоичное дерево         |
+| balanced binary tree           | сбалансированное двоичное дерево |
+| binary search tree             | двоичное дерево поиска         |
+| AVL tree                       | АВЛ-дерево                     |
+| red-black tree                 | красно-черное дерево           |
+| level-order traversal          | обход по уровням               |
+| breadth-first traversal        | обход в ширину                 |
+| depth-first traversal          | обход в глубину                |
+| binary search tree             | двоичное дерево поиска         |
+| balanced binary search tree    | сбалансированное двоичное дерево поиска |
+| balance factor                 | фактор баланса                 |
+| heap                           | куча                           |
+| max heap                       | максимальная куча              |
+| min heap                       | минимальная куча               |
+| priority queue                 | приоритетная очередь           |
+| heapify                        | упорядочивание кучи            |
+| top-$k$ problem                | поиск $k$ наибольших элементов |
+| graph                          | граф                           |
+| vertex                         | вершина                        |
+| undirected graph               | неориентированный граф         |
+| directed graph                 | ориентированный граф           |
+| connected graph                | связный граф                   |
+| disconnected graph             | несвязный граф                 |
+| weighted graph                 | взвешенный граф                |
+| adjacency                      | смежность                      |
+| path                           | путь                           |
+| in-degree                      | входящая степень               |
+| out-degree                     | исходящая степень              |
+| adjacency matrix               | матрица смежности              |
+| adjacency list                 | список смежности               |
+| breadth-first search           | поиск в ширину                 |
+| depth-first search             | поиск в глубину                |
+| binary search                  | двоичный поиск                 |
+| searching algorithm            | алгоритм поиска                |
+| sorting algorithm              | алгоритм сортировки            |
+| selection sort                 | сортировка выбором             |
+| bubble sort                    | сортировка пузырьком           |
+| insertion sort                 | сортировка вставкой            |
+| quick sort                     | быстрая сортировка             |
+| merge sort                     | сортировка слиянием            |
+| heap sort                      | пирамидальная сортировка       |
+| bucket sort                    | блочная сортировка             |
+| counting sort                  | сортировка подсчетом           |
+| radix sort                     | поразрядная сортировка         |
+| divide and conquer             | разделяй и властвуй            |
+| hanota problem                 | задача о Ханойской башне       |
+| backtracking algorithm         | алгоритм поиска с возвратом    |
+| constraint                     | ограничение                    |
+| solution                       | решение                        |
+| state                          | состояние                      |
+| pruning                        | отсечение                      |
+| permutations problem           | задача о перестановках         |
+| subset-sum problem             | задача о сумме подмножеств     |
+| $n$-queens problem             | задача о $n$ ферзях            |
+| dynamic programming            | динамическое программирование  |
+| initial state                  | начальное состояние            |
+| state-transition equation      | уравнение перехода состояния   |
+| knapsack problem               | задача о рюкзаке               |
+| edit distance problem          | задача о расстоянии редактирования |
+| greedy algorithm               | жадный алгоритм                |