deploy

ru/chapter_computational_complexity/time_complexity/index.html

@@ -4830,7 +4830,7 @@
 <p>Но на практике <strong>подсчитывать реальное время выполнения алгоритма и неразумно, и нереалистично</strong>. Во-первых, мы не хотим привязывать оценку времени к конкретной платформе, потому что алгоритм должен запускаться на самых разных платформах. Во-вторых, нам трудно определить время выполнения каждого типа операций, а это делает точную оценку крайне затруднительной.</p>
 <h2 id="231">2.3.1 &nbsp; Подсчет тенденции роста времени<a class="headerlink" href="#231" title="Permanent link">&para;</a></h2>
 <p>Анализ временной сложности оценивает не само время выполнения алгоритма, <strong>а тенденцию роста этого времени по мере увеличения объема данных</strong>.</p>
-<p>Понятие "тенденции роста времени" выглядит довольно абстрактным, поэтому разберем его на примере. Предположим, размер входных данных равен <span class="arithmatex">\(n\)</span> , и даны три алгоритма <code>A</code> , <code>B</code> и <code>C</code> :</p>
+<p>Понятие «тенденции роста времени» выглядит довольно абстрактным, поэтому разберем его на примере. Предположим, размер входных данных равен <span class="arithmatex">\(n\)</span> , и даны три алгоритма <code>A</code> , <code>B</code> и <code>C</code> :</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="2:13"><input checked="checked" id="__tabbed_2_1" name="__tabbed_2" type="radio" /><input id="__tabbed_2_2" name="__tabbed_2" type="radio" /><input id="__tabbed_2_3" name="__tabbed_2" type="radio" /><input id="__tabbed_2_4" name="__tabbed_2" type="radio" /><input id="__tabbed_2_5" name="__tabbed_2" type="radio" /><input id="__tabbed_2_6" name="__tabbed_2" type="radio" /><input id="__tabbed_2_7" name="__tabbed_2" type="radio" /><input id="__tabbed_2_8" name="__tabbed_2" type="radio" /><input id="__tabbed_2_9" name="__tabbed_2" type="radio" /><input id="__tabbed_2_10" name="__tabbed_2" type="radio" /><input id="__tabbed_2_11" name="__tabbed_2" type="radio" /><input id="__tabbed_2_12" name="__tabbed_2" type="radio" /><input id="__tabbed_2_13" name="__tabbed_2" type="radio" /><div class="tabbed-labels"><label for="__tabbed_2_1">Python</label><label for="__tabbed_2_2">C++</label><label for="__tabbed_2_3">Java</label><label for="__tabbed_2_4">C#</label><label for="__tabbed_2_5">Go</label><label for="__tabbed_2_6">Swift</label><label for="__tabbed_2_7">JS</label><label for="__tabbed_2_8">TS</label><label for="__tabbed_2_9">Dart</label><label for="__tabbed_2_10">Rust</label><label for="__tabbed_2_11">C</label><label for="__tabbed_2_12">Kotlin</label><label for="__tabbed_2_13">Ruby</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -5077,11 +5077,11 @@
 </div>
 </div>
 </div>
-<p>Ниже показаны временные сложности трех приведенных выше функций.</p>
+<p>На рисунке 2-7 показаны временные сложности трех приведенных выше функций.</p>
 <ul>
 <li>У алгоритма <code>A</code> есть только одна операция вывода, и время его работы не растет с увеличением <span class="arithmatex">\(n\)</span> . Такую временную сложность называют постоянной.</li>
 <li>В алгоритме <code>B</code> операция вывода выполняется в цикле <span class="arithmatex">\(n\)</span> раз, поэтому время работы растет линейно по мере увеличения <span class="arithmatex">\(n\)</span> . Такая временная сложность называется линейной.</li>
-<li>В алгоритме <code>C</code> операция вывода выполняется <span class="arithmatex">\(1000000\)</span> раз; хотя время работы велико, оно не зависит от размера входных данных <span class="arithmatex">\(n\)</span> . Поэтому временная сложность <code>C</code> такая же, как у <code>A</code> , и тоже является постоянной.</li>
+<li>В алгоритме <code>C</code> операция вывода выполняется <span class="arithmatex">\(1000000\)</span> раз. Хотя время работы велико, оно не зависит от размера входных данных <span class="arithmatex">\(n\)</span> . Поэтому временная сложность <code>C</code> такая же, как у <code>A</code> , и тоже является постоянной.</li>
 </ul>
 <p><img alt="Тенденции роста времени для алгоритмов A, B и C" class="animation-figure" src="../time_complexity.assets/time_complexity_simple_example.png" /></p>
 <p align="center"> Рисунок 2-7 &nbsp; Тенденции роста времени для алгоритмов A, B и C </p>
@@ -5253,16 +5253,16 @@
 </div>
 </div>
 </div>
-<p>Пусть количество операций алгоритма является функцией от размера входных данных <span class="arithmatex">\(n\)</span> и обозначается как <span class="arithmatex">\(T(n)\)</span> ; тогда для приведенной выше функции число операций равно:</p>
+<p>Пусть количество операций алгоритма является функцией от размера входных данных <span class="arithmatex">\(n\)</span> и обозначается как <span class="arithmatex">\(T(n)\)</span>. Тогда для приведенной выше функции число операций равно:</p>
 <div class="arithmatex">\[
 T(n) = 3 + 2n
 \]</div>
 <p><span class="arithmatex">\(T(n)\)</span> - линейная функция, а это означает, что тенденция роста времени работы линейна, следовательно, временная сложность здесь тоже линейна.</p>
-<p>Линейную временную сложность записывают как <span class="arithmatex">\(O(n)\)</span> ; этот математический символ называется <u>нотацией Big <span class="arithmatex">\(O\)</span> (big-<span class="arithmatex">\(O\)</span> notation)</u> и обозначает <u>асимптотическую верхнюю границу (asymptotic upper bound)</u> функции <span class="arithmatex">\(T(n)\)</span> .</p>
+<p>Линейную временную сложность записывают как <span class="arithmatex">\(O(n)\)</span>. Этот математический символ называется <u>нотацией Big <span class="arithmatex">\(O\)</span> (big-<span class="arithmatex">\(O\)</span> notation)</u> и обозначает <u>асимптотическую верхнюю границу (asymptotic upper bound)</u> функции <span class="arithmatex">\(T(n)\)</span> .</p>
 <p>Иными словами, анализ временной сложности сводится к определению асимптотической верхней границы числа операций <span class="arithmatex">\(T(n)\)</span>, и у этого понятия есть строгое математическое определение.</p>
 <div class="admonition note">
 <p class="admonition-title">Асимптотическая верхняя граница функции</p>
-<p>Если существуют положительное действительное число <span class="arithmatex">\(c\)</span> и действительное число <span class="arithmatex">\(n_0\)</span> , такие что для всех <span class="arithmatex">\(n &gt; n_0\)</span> выполняется <span class="arithmatex">\(T(n) \leq c \cdot f(n)\)</span> , то можно считать, что <span class="arithmatex">\(f(n)\)</span> задает асимптотическую верхнюю границу для <span class="arithmatex">\(T(n)\)</span> ; это записывается как <span class="arithmatex">\(T(n) = O(f(n))\)</span> .</p>
+<p>Если существуют положительное действительное число <span class="arithmatex">\(c\)</span> и действительное число <span class="arithmatex">\(n_0\)</span> , такие что для всех <span class="arithmatex">\(n &gt; n_0\)</span> выполняется <span class="arithmatex">\(T(n) \leq c \cdot f(n)\)</span> , то можно считать, что <span class="arithmatex">\(f(n)\)</span> задает асимптотическую верхнюю границу для <span class="arithmatex">\(T(n)\)</span>. Это записывается как <span class="arithmatex">\(T(n) = O(f(n))\)</span> .</p>
 </div>
 <p>Как показано на рисунке 2-8, вычислить асимптотическую верхнюю границу - значит найти такую функцию <span class="arithmatex">\(f(n)\)</span> , что при стремлении <span class="arithmatex">\(n\)</span> к бесконечности функции <span class="arithmatex">\(T(n)\)</span> и <span class="arithmatex">\(f(n)\)</span> имеют один и тот же порядок роста и отличаются только постоянным коэффициентом <span class="arithmatex">\(c\)</span>.</p>
 <p><img alt="Асимптотическая верхняя граница функции" class="animation-figure" src="../time_complexity.assets/asymptotic_upper_bound.png" /></p>
@@ -5276,7 +5276,7 @@ T(n) = 3 + 2n
 <ol>
 <li><strong>Игнорировать константы в <span class="arithmatex">\(T(n)\)</span></strong>. Они не зависят от <span class="arithmatex">\(n\)</span> , а значит не влияют на временную сложность.</li>
 <li><strong>Опускать все коэффициенты</strong>. Например, циклы на <span class="arithmatex">\(2n\)</span> раз или <span class="arithmatex">\(5n + 1\)</span> раз можно упростить до <span class="arithmatex">\(n\)</span> раз, потому что коэффициент перед <span class="arithmatex">\(n\)</span> не влияет на временную сложность.</li>
-<li><strong>При вложенных циклах использовать умножение</strong>. Общее число операций равно произведению числа операций внешнего и внутреннего циклов; при этом для каждого уровня цикла по-прежнему можно применять приемы из пунктов <code>1.</code> и <code>2.</code> .</li>
+<li><strong>При вложенных циклах использовать умножение</strong>. Общее число операций равно произведению числа операций внешнего и внутреннего циклов. При этом для каждого уровня цикла по-прежнему можно применять приемы из пунктов <code>1.</code> и <code>2.</code> .</li>
 </ol>
 <p>Для заданной функции мы можем использовать перечисленные выше приемы и подсчитать число операций:</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="4:13"><input checked="checked" id="__tabbed_4_1" name="__tabbed_4" type="radio" /><input id="__tabbed_4_2" name="__tabbed_4" type="radio" /><input id="__tabbed_4_3" name="__tabbed_4" type="radio" /><input id="__tabbed_4_4" name="__tabbed_4" type="radio" /><input id="__tabbed_4_5" name="__tabbed_4" type="radio" /><input id="__tabbed_4_6" name="__tabbed_4" type="radio" /><input id="__tabbed_4_7" name="__tabbed_4" type="radio" /><input id="__tabbed_4_8" name="__tabbed_4" type="radio" /><input id="__tabbed_4_9" name="__tabbed_4" type="radio" /><input id="__tabbed_4_10" name="__tabbed_4" type="radio" /><input id="__tabbed_4_11" name="__tabbed_4" type="radio" /><input id="__tabbed_4_12" name="__tabbed_4" type="radio" /><input id="__tabbed_4_13" name="__tabbed_4" type="radio" /><div class="tabbed-labels"><label for="__tabbed_4_1">Python</label><label for="__tabbed_4_2">C++</label><label for="__tabbed_4_3">Java</label><label for="__tabbed_4_4">C#</label><label for="__tabbed_4_5">Go</label><label for="__tabbed_4_6">Swift</label><label for="__tabbed_4_7">JS</label><label for="__tabbed_4_8">TS</label><label for="__tabbed_4_9">Dart</label><label for="__tabbed_4_10">Rust</label><label for="__tabbed_4_11">C</label><label for="__tabbed_4_12">Kotlin</label><label for="__tabbed_4_13">Ruby</label></div>
@@ -5498,7 +5498,7 @@ T(n) = 3 + 2n
 </div>
 </div>
 </div>
-<p>Следующая формула показывает результаты подсчета до и после использования перечисленных выше приемов; в обоих случаях выводимая временная сложность равна <span class="arithmatex">\(O(n^2)\)</span> .</p>
+<p>Следующая формула показывает результаты подсчета до и после использования перечисленных выше приемов. В обоих случаях выводимая временная сложность равна <span class="arithmatex">\(O(n^2)\)</span> .</p>
 <div class="arithmatex">\[
 \begin{aligned}
 T(n) &amp; = 2n(n + 1) + (5n + 1) + 2 &amp; \text{полный подсчет (-.-|||)} \newline
@@ -5544,7 +5544,7 @@ T(n) &amp; = n^2 + n &amp; \text{ленивый подсчет (o.O)}
 </table>
 </div>
 <h2 id="234">2.3.4 &nbsp; Распространенные типы<a class="headerlink" href="#234" title="Permanent link">&para;</a></h2>
-<p>Пусть размер входных данных равен <span class="arithmatex">\(n\)</span> ; распространенные типы временной сложности показаны на рисунке 2-9 в порядке от меньшей к большей.</p>
+<p>Пусть размер входных данных равен <span class="arithmatex">\(n\)</span>. Распространенные типы временной сложности показаны на рисунке 2-9 в порядке от меньшей к большей.</p>
 <div class="arithmatex">\[
 \begin{aligned}
 &amp; O(1) &lt; O(\log n) &lt; O(n) &lt; O(n \log n) &lt; O(n^2) &lt; O(2^n) &lt; O(n!) \newline
@@ -6029,7 +6029,7 @@ T(n) &amp; = n^2 + n &amp; \text{ленивый подсчет (o.O)}
 <p><div style="height: 459px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=def%20array_traversal%28nums%3A%20list%5Bint%5D%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%D0%9B%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%B0%D1%8F%20%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D1%8C%20%28%D0%BE%D0%B1%D1%85%D0%BE%D0%B4%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B0%29%22%22%22%0A%20%20%20%20count%20%3D%200%0A%20%20%20%20%23%20%D0%A7%D0%B8%D1%81%D0%BB%D0%BE%20%D0%B8%D1%82%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B9%20%D0%BF%D1%80%D0%BE%D0%BF%D0%BE%D1%80%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%20%D0%B4%D0%BB%D0%B8%D0%BD%D0%B5%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B0%0A%20%20%20%20for%20num%20in%20nums%3A%0A%20%20%20%20%20%20%20%20count%20%2B%3D%201%0A%20%20%20%20return%20count%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20n%20%3D%208%0A%20%20%20%20print%28%22%D0%A0%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%20%D0%B2%D1%85%D0%BE%D0%B4%D0%BD%D1%8B%D1%85%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85%20n%20%3D%22%2C%20n%29%0A%0A%20%20%20%20count%20%3D%20array_traversal%28%5B0%5D%20%2A%20n%29%0A%20%20%20%20print%28%22%D0%A7%D0%B8%D1%81%D0%BB%D0%BE%20%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B9%20%D0%BB%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%BE%D0%B9%20%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D0%B8%20%28%D0%BE%D0%B1%D1%85%D0%BE%D0%B4%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B0%29%20%3D%22%2C%20count%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=3&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
 <div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=def%20array_traversal%28nums%3A%20list%5Bint%5D%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%D0%9B%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%B0%D1%8F%20%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D1%8C%20%28%D0%BE%D0%B1%D1%85%D0%BE%D0%B4%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B0%29%22%22%22%0A%20%20%20%20count%20%3D%200%0A%20%20%20%20%23%20%D0%A7%D0%B8%D1%81%D0%BB%D0%BE%20%D0%B8%D1%82%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B9%20%D0%BF%D1%80%D0%BE%D0%BF%D0%BE%D1%80%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%20%D0%B4%D0%BB%D0%B8%D0%BD%D0%B5%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B0%0A%20%20%20%20for%20num%20in%20nums%3A%0A%20%20%20%20%20%20%20%20count%20%2B%3D%201%0A%20%20%20%20return%20count%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20n%20%3D%208%0A%20%20%20%20print%28%22%D0%A0%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%20%D0%B2%D1%85%D0%BE%D0%B4%D0%BD%D1%8B%D1%85%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85%20n%20%3D%22%2C%20n%29%0A%0A%20%20%20%20count%20%3D%20array_traversal%28%5B0%5D%20%2A%20n%29%0A%20%20%20%20print%28%22%D0%A7%D0%B8%D1%81%D0%BB%D0%BE%20%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B9%20%D0%BB%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%BE%D0%B9%20%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D0%B8%20%28%D0%BE%D0%B1%D1%85%D0%BE%D0%B4%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B0%29%20%3D%22%2C%20count%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=3&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">Во весь экран &gt;</a></div></p>
 </details>
-<p>Стоит отметить, что <strong>размер входных данных <span class="arithmatex">\(n\)</span> нужно определять конкретно в зависимости от типа входа</strong>. Например, в первом примере переменная <span class="arithmatex">\(n\)</span> сама является размером входных данных; во втором примере размером данных служит длина массива.</p>
+<p>Стоит отметить, что <strong>размер входных данных <span class="arithmatex">\(n\)</span> нужно определять конкретно в зависимости от типа входа</strong>. Например, в первом примере переменная <span class="arithmatex">\(n\)</span> сама является размером входных данных. Во втором примере размером данных служит длина массива.</p>
 <h3 id="3-on2">3. &nbsp; Квадратичная сложность <span class="arithmatex">\(O(n^2)\)</span><a class="headerlink" href="#3-on2" title="Permanent link">&para;</a></h3>
 <p>Квадратичная сложность характеризуется тем, что число операций растет квадратично относительно размера входных данных <span class="arithmatex">\(n\)</span> . Квадратичная сложность обычно встречается во вложенных циклах: временная сложность внешнего и внутреннего циклов равна <span class="arithmatex">\(O(n)\)</span> , поэтому общая временная сложность составляет <span class="arithmatex">\(O(n^2)\)</span> :</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="8:13"><input checked="checked" id="__tabbed_8_1" name="__tabbed_8" type="radio" /><input id="__tabbed_8_2" name="__tabbed_8" type="radio" /><input id="__tabbed_8_3" name="__tabbed_8" type="radio" /><input id="__tabbed_8_4" name="__tabbed_8" type="radio" /><input id="__tabbed_8_5" name="__tabbed_8" type="radio" /><input id="__tabbed_8_6" name="__tabbed_8" type="radio" /><input id="__tabbed_8_7" name="__tabbed_8" type="radio" /><input id="__tabbed_8_8" name="__tabbed_8" type="radio" /><input id="__tabbed_8_9" name="__tabbed_8" type="radio" /><input id="__tabbed_8_10" name="__tabbed_8" type="radio" /><input id="__tabbed_8_11" name="__tabbed_8" type="radio" /><input id="__tabbed_8_12" name="__tabbed_8" type="radio" /><input id="__tabbed_8_13" name="__tabbed_8" type="radio" /><div class="tabbed-labels"><label for="__tabbed_8_1">Python</label><label for="__tabbed_8_2">C++</label><label for="__tabbed_8_3">Java</label><label for="__tabbed_8_4">C#</label><label for="__tabbed_8_5">Go</label><label for="__tabbed_8_6">Swift</label><label for="__tabbed_8_7">JS</label><label for="__tabbed_8_8">TS</label><label for="__tabbed_8_9">Dart</label><label for="__tabbed_8_10">Rust</label><label for="__tabbed_8_11">C</label><label for="__tabbed_8_12">Kotlin</label><label for="__tabbed_8_13">Ruby</label></div>
@@ -6521,8 +6521,8 @@ T(n) &amp; = n^2 + n &amp; \text{ленивый подсчет (o.O)}
 <div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=def%20bubble_sort%28nums%3A%20list%5Bint%5D%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%D0%9A%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%B8%D1%87%D0%BD%D0%B0%D1%8F%20%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D1%8C%20%28%D0%BF%D1%83%D0%B7%D1%8B%D1%80%D1%8C%D0%BA%D0%BE%D0%B2%D0%B0%D1%8F%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0%29%22%22%22%0A%20%20%20%20count%20%3D%200%20%20%23%20%D0%A1%D1%87%D0%B5%D1%82%D1%87%D0%B8%D0%BA%0A%20%20%20%20%23%20%D0%92%D0%BD%D0%B5%D1%88%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%BD%D0%B5%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%20%5B0%2C%20i%5D%0A%20%20%20%20for%20i%20in%20range%28len%28nums%29%20-%201%2C%200%2C%20-1%29%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%92%D0%BD%D1%83%D1%82%D1%80%D0%B5%D0%BD%D0%BD%D0%B8%D0%B9%20%D1%86%D0%B8%D0%BA%D0%BB%3A%20%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D0%B8%D1%82%D1%8C%20%D0%BC%D0%B0%D0%BA%D1%81%D0%B8%D0%BC%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%20%D0%BD%D0%B5%D0%BE%D1%82%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE%20%D0%B4%D0%B8%D0%B0%D0%BF%D0%B0%D0%B7%D0%BE%D0%BD%D0%B0%20%5B0%2C%20i%5D%20%D0%B2%20%D0%B5%D0%B3%D0%BE%20%D0%BF%D1%80%D0%B0%D0%B2%D1%8B%D0%B9%20%D0%BA%D0%BE%D0%BD%D0%B5%D1%86%0A%20%20%20%20%20%20%20%20for%20j%20in%20range%28i%29%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20if%20nums%5Bj%5D%20%3E%20nums%5Bj%20%2B%201%5D%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20%D0%9F%D0%BE%D0%BC%D0%B5%D0%BD%D1%8F%D1%82%D1%8C%20%D0%BC%D0%B5%D1%81%D1%82%D0%B0%D0%BC%D0%B8%20nums%5Bj%5D%20%D0%B8%20nums%5Bj%20%2B%201%5D%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20tmp%20%3D%20nums%5Bj%5D%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20nums%5Bj%5D%20%3D%20nums%5Bj%20%2B%201%5D%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20nums%5Bj%20%2B%201%5D%20%3D%20tmp%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20count%20%2B%3D%203%20%20%23%20%D0%9E%D0%B1%D0%BC%D0%B5%D0%BD%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%BE%D0%B2%20%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B0%D0%B5%D1%82%203%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%D1%80%D0%BD%D1%8B%D0%B5%20%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B8%0A%20%20%20%20return%20count%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20n%20%3D%208%0A%20%20%20%20print%28%22%D0%A0%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%20%D0%B2%D1%85%D0%BE%D0%B4%D0%BD%D1%8B%D1%85%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85%20n%20%3D%22%2C%20n%29%0A%0A%20%20%20%20nums%20%3D%20%5Bi%20for%20i%20in%20range%28n%2C%200%2C%20-1%29%5D%20%20%23%20%5Bn%2C%20n-1%2C%20...%2C%202%2C%201%5D%0A%20%20%20%20count%20%3D%20bubble_sort%28nums%29%0A%20%20%20%20print%28%22%D0%A7%D0%B8%D1%81%D0%BB%D0%BE%20%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B9%20%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%B8%D1%87%D0%BD%D0%BE%D0%B9%20%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D0%B8%20%28%D0%BF%D1%83%D0%B7%D1%8B%D1%80%D1%8C%D0%BA%D0%BE%D0%B2%D0%B0%D1%8F%20%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0%29%20%3D%22%2C%20count%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=3&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">Во весь экран &gt;</a></div></p>
 </details>
 <h3 id="4-o2n">4. &nbsp; Экспоненциальная сложность <span class="arithmatex">\(O(2^n)\)</span><a class="headerlink" href="#4-o2n" title="Permanent link">&para;</a></h3>
-<p>Типичный пример экспоненциального роста в биологии - деление клеток: в начальном состоянии есть одна клетка, после одного деления их становится 2, после двух делений - 4 и так далее; после <span class="arithmatex">\(n\)</span> раундов деления клеток становится <span class="arithmatex">\(2^n\)</span> .</p>
-<p>На рисунке 2-11 и в следующем коде моделируется процесс деления клеток; временная сложность равна <span class="arithmatex">\(O(2^n)\)</span> . Здесь входное значение <span class="arithmatex">\(n\)</span> обозначает число раундов деления, а возвращаемое значение <code>count</code> обозначает общее число делений.</p>
+<p>Типичный пример экспоненциального роста в биологии - деление клеток: в начальном состоянии есть одна клетка, после одного деления их становится 2, после двух делений - 4 и так далее. После <span class="arithmatex">\(n\)</span> раундов деления клеток становится <span class="arithmatex">\(2^n\)</span> .</p>
+<p>На рисунке 2-11 и в следующем коде моделируется процесс деления клеток. Временная сложность равна <span class="arithmatex">\(O(2^n)\)</span> . Здесь входное значение <span class="arithmatex">\(n\)</span> обозначает число раундов деления, а возвращаемое значение <code>count</code> обозначает общее число делений.</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="10:13"><input checked="checked" id="__tabbed_10_1" name="__tabbed_10" type="radio" /><input id="__tabbed_10_2" name="__tabbed_10" type="radio" /><input id="__tabbed_10_3" name="__tabbed_10" type="radio" /><input id="__tabbed_10_4" name="__tabbed_10" type="radio" /><input id="__tabbed_10_5" name="__tabbed_10" type="radio" /><input id="__tabbed_10_6" name="__tabbed_10" type="radio" /><input id="__tabbed_10_7" name="__tabbed_10" type="radio" /><input id="__tabbed_10_8" name="__tabbed_10" type="radio" /><input id="__tabbed_10_9" name="__tabbed_10" type="radio" /><input id="__tabbed_10_10" name="__tabbed_10" type="radio" /><input id="__tabbed_10_11" name="__tabbed_10" type="radio" /><input id="__tabbed_10_12" name="__tabbed_10" type="radio" /><input id="__tabbed_10_13" name="__tabbed_10" type="radio" /><div class="tabbed-labels"><label for="__tabbed_10_1">Python</label><label for="__tabbed_10_2">C++</label><label for="__tabbed_10_3">Java</label><label for="__tabbed_10_4">C#</label><label for="__tabbed_10_5">Go</label><label for="__tabbed_10_6">Swift</label><label for="__tabbed_10_7">JS</label><label for="__tabbed_10_8">TS</label><label for="__tabbed_10_9">Dart</label><label for="__tabbed_10_10">Rust</label><label for="__tabbed_10_11">C</label><label for="__tabbed_10_12">Kotlin</label><label for="__tabbed_10_13">Ruby</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -6958,8 +6958,8 @@ T(n) &amp; = n^2 + n &amp; \text{ленивый подсчет (o.O)}
 </details>
 <p>Экспоненциальный рост происходит очень быстро и часто встречается в переборных методах, грубой силе, поиске с возвратом и тому подобных подходах. Для задач большого масштаба экспоненциальная сложность неприемлема, и обычно приходится применять динамическое программирование, жадные алгоритмы и другие стратегии.</p>
 <h3 id="5-olog-n">5. &nbsp; Логарифмическая сложность <span class="arithmatex">\(O(\log n)\)</span><a class="headerlink" href="#5-olog-n" title="Permanent link">&para;</a></h3>
-<p>В противоположность экспоненциальной, логарифмическая сложность описывает ситуацию, когда <strong>в каждом раунде размер задачи уменьшается вдвое</strong>. Пусть размер входных данных равен <span class="arithmatex">\(n\)</span> ; так как на каждом шаге размер уменьшается вдвое, число итераций равно <span class="arithmatex">\(\log_2 n\)</span> , то есть является обратной функцией к <span class="arithmatex">\(2^n\)</span> .</p>
-<p>На рисунке 2-12 и в следующем коде моделируется процесс, в котором <strong>в каждом раунде размер задачи уменьшается вдвое</strong>; временная сложность равна <span class="arithmatex">\(O(\log_2 n)\)</span> и кратко записывается как <span class="arithmatex">\(O(\log n)\)</span> :</p>
+<p>В противоположность экспоненциальной, логарифмическая сложность описывает ситуацию, когда <strong>в каждом раунде размер задачи уменьшается вдвое</strong>. Пусть размер входных данных равен <span class="arithmatex">\(n\)</span>. Так как на каждом шаге размер уменьшается вдвое, число итераций равно <span class="arithmatex">\(\log_2 n\)</span> , то есть является обратной функцией к <span class="arithmatex">\(2^n\)</span> .</p>
+<p>На рисунке 2-12 и в следующем коде моделируется процесс, в котором <strong>в каждом раунде размер задачи уменьшается вдвое</strong>. Временная сложность равна <span class="arithmatex">\(O(\log_2 n)\)</span> и кратко записывается как <span class="arithmatex">\(O(\log n)\)</span> :</p>
 <div class="tabbed-set tabbed-alternate" data-tabs="12:13"><input checked="checked" id="__tabbed_12_1" name="__tabbed_12" type="radio" /><input id="__tabbed_12_2" name="__tabbed_12" type="radio" /><input id="__tabbed_12_3" name="__tabbed_12" type="radio" /><input id="__tabbed_12_4" name="__tabbed_12" type="radio" /><input id="__tabbed_12_5" name="__tabbed_12" type="radio" /><input id="__tabbed_12_6" name="__tabbed_12" type="radio" /><input id="__tabbed_12_7" name="__tabbed_12" type="radio" /><input id="__tabbed_12_8" name="__tabbed_12" type="radio" /><input id="__tabbed_12_9" name="__tabbed_12" type="radio" /><input id="__tabbed_12_10" name="__tabbed_12" type="radio" /><input id="__tabbed_12_11" name="__tabbed_12" type="radio" /><input id="__tabbed_12_12" name="__tabbed_12" type="radio" /><input id="__tabbed_12_13" name="__tabbed_12" type="radio" /><div class="tabbed-labels"><label for="__tabbed_12_1">Python</label><label for="__tabbed_12_2">C++</label><label for="__tabbed_12_3">Java</label><label for="__tabbed_12_4">C#</label><label for="__tabbed_12_5">Go</label><label for="__tabbed_12_6">Swift</label><label for="__tabbed_12_7">JS</label><label for="__tabbed_12_8">TS</label><label for="__tabbed_12_9">Dart</label><label for="__tabbed_12_10">Rust</label><label for="__tabbed_12_11">C</label><label for="__tabbed_12_12">Kotlin</label><label for="__tabbed_12_13">Ruby</label></div>
 <div class="tabbed-content">
 <div class="tabbed-block">
@@ -7376,10 +7376,10 @@ T(n) &amp; = n^2 + n &amp; \text{ленивый подсчет (o.O)}
 <p><div style="height: 423px; width: 100%;"><iframe class="pythontutor-iframe" src="https://pythontutor.com/iframe-embed.html#code=def%20log_recur%28n%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%D0%9B%D0%BE%D0%B3%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F%20%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D1%8C%20%28%D1%80%D0%B5%D0%BA%D1%83%D1%80%D1%81%D0%B8%D0%B2%D0%BD%D0%B0%D1%8F%20%D1%80%D0%B5%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F%29%22%22%22%0A%20%20%20%20if%20n%20%3C%3D%201%3A%0A%20%20%20%20%20%20%20%20return%200%0A%20%20%20%20return%20log_recur%28n%20%2F%202%29%20%2B%201%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20n%20%3D%208%0A%20%20%20%20print%28%22%D0%A0%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%20%D0%B2%D1%85%D0%BE%D0%B4%D0%BD%D1%8B%D1%85%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85%20n%20%3D%22%2C%20n%29%0A%0A%20%20%20%20count%20%3D%20log_recur%28n%29%0A%20%20%20%20print%28%22%D0%A7%D0%B8%D1%81%D0%BB%D0%BE%20%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B9%20%D0%BB%D0%BE%D0%B3%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B9%20%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D0%B8%20%28%D1%80%D0%B5%D0%BA%D1%83%D1%80%D1%81%D0%B8%D0%B2%D0%BD%D0%B0%D1%8F%20%D1%80%D0%B5%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F%29%20%3D%22%2C%20count%29&codeDivHeight=472&codeDivWidth=350&cumulative=false&curInstr=4&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false"> </iframe></div>
 <div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=def%20log_recur%28n%3A%20int%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%D0%9B%D0%BE%D0%B3%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F%20%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D1%8C%20%28%D1%80%D0%B5%D0%BA%D1%83%D1%80%D1%81%D0%B8%D0%B2%D0%BD%D0%B0%D1%8F%20%D1%80%D0%B5%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F%29%22%22%22%0A%20%20%20%20if%20n%20%3C%3D%201%3A%0A%20%20%20%20%20%20%20%20return%200%0A%20%20%20%20return%20log_recur%28n%20%2F%202%29%20%2B%201%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20n%20%3D%208%0A%20%20%20%20print%28%22%D0%A0%D0%B0%D0%B7%D0%BC%D0%B5%D1%80%20%D0%B2%D1%85%D0%BE%D0%B4%D0%BD%D1%8B%D1%85%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85%20n%20%3D%22%2C%20n%29%0A%0A%20%20%20%20count%20%3D%20log_recur%28n%29%0A%20%20%20%20print%28%22%D0%A7%D0%B8%D1%81%D0%BB%D0%BE%20%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%86%D0%B8%D0%B9%20%D0%BB%D0%BE%D0%B3%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B9%20%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D0%B8%20%28%D1%80%D0%B5%D0%BA%D1%83%D1%80%D1%81%D0%B8%D0%B2%D0%BD%D0%B0%D1%8F%20%D1%80%D0%B5%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F%29%20%3D%22%2C%20count%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=4&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">Во весь экран &gt;</a></div></p>
 </details>
-<p>Логарифмическая сложность часто встречается в алгоритмах, основанных на стратегии "разделяй и властвуй", и отражает идеи разбиения на части и упрощения сложной задачи. Она растет медленно и считается одной из самых желательных временных сложностей после константной.</p>
+<p>Логарифмическая сложность часто встречается в алгоритмах, основанных на стратегии «разделяй и властвуй», и отражает идеи разбиения на части и упрощения сложной задачи. Она растет медленно и считается одной из самых желательных временных сложностей после константной.</p>
 <div class="admonition tip">
 <p class="admonition-title">Каково основание у <span class="arithmatex">\(O(\log n)\)</span> ?</p>
-<p>Точнее говоря, "разделение на <span class="arithmatex">\(m\)</span> частей" соответствует временной сложности <span class="arithmatex">\(O(\log_m n)\)</span> . А по формуле перехода к другому основанию логарифма мы получаем равные по сложности выражения с разными основаниями:</p>
+<p>Точнее говоря, «разделение на <span class="arithmatex">\(m\)</span> частей» соответствует временной сложности <span class="arithmatex">\(O(\log_m n)\)</span> . А по формуле перехода к другому основанию логарифма мы получаем равные по сложности выражения с разными основаниями:</p>
 <div class="arithmatex">\[
 O(\log_m n) = O(\log_k n / \log_k m) = O(\log_k n)
 \]</div>
@@ -7775,7 +7775,7 @@ n! = n \times (n - 1) \times (n - 2) \times \dots \times 2 \times 1
 
 <p>Следует отметить, что поскольку при <span class="arithmatex">\(n \geq 4\)</span> всегда выполняется <span class="arithmatex">\(n! &gt; 2^n\)</span> , факториальная сложность растет еще быстрее, чем экспоненциальная, и при больших <span class="arithmatex">\(n\)</span> становится неприемлемой.</p>
 <h2 id="235">2.3.5 &nbsp; Худшая, лучшая и средняя временная сложность<a class="headerlink" href="#235" title="Permanent link">&para;</a></h2>
-<p><strong>Временная эффективность алгоритма часто не фиксирована, а зависит от распределения входных данных</strong>. Предположим, на вход подается массив <code>nums</code> длины <span class="arithmatex">\(n\)</span> , состоящий из чисел от <span class="arithmatex">\(1\)</span> до <span class="arithmatex">\(n\)</span> , каждое из которых встречается ровно один раз; при этом порядок элементов случайно перемешан. Задача состоит в том, чтобы вернуть индекс элемента <span class="arithmatex">\(1\)</span> . Тогда можно сделать следующие выводы.</p>
+<p><strong>Временная эффективность алгоритма часто не фиксирована, а зависит от распределения входных данных</strong>. Предположим, на вход подается массив <code>nums</code> длины <span class="arithmatex">\(n\)</span> , состоящий из чисел от <span class="arithmatex">\(1\)</span> до <span class="arithmatex">\(n\)</span> , каждое из которых встречается ровно один раз. При этом порядок элементов случайно перемешан. Задача состоит в том, чтобы вернуть индекс элемента <span class="arithmatex">\(1\)</span> . Тогда можно сделать следующие выводы.</p>
 <ul>
 <li>Когда <code>nums = [?, ?, ..., 1]</code> , то есть когда последний элемент равен <span class="arithmatex">\(1\)</span> , нужно полностью пройти по массиву, <strong>что дает худшую временную сложность <span class="arithmatex">\(O(n)\)</span></strong> .</li>
 <li>Когда <code>nums = [1, ?, ?, ...]</code> , то есть когда первый элемент равен <span class="arithmatex">\(1\)</span> , независимо от длины массива продолжать обход не нужно, <strong>что дает лучшую временную сложность <span class="arithmatex">\(\Omega(1)\)</span></strong> .</li>
@@ -8139,12 +8139,12 @@ n! = n \times (n - 1) \times (n - 2) \times \dots \times 2 \times 1
 <div style="margin-top: 5px;"><a href="https://pythontutor.com/iframe-embed.html#code=import%20random%0A%0Adef%20random_numbers%28n%3A%20int%29%20-%3E%20list%5Bint%5D%3A%0A%20%20%20%20%22%22%22%D0%A1%D0%B3%D0%B5%D0%BD%D0%B5%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%20%D1%81%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%D0%BC%D0%B8%201%2C%202%2C%20...%2C%20n%20%D0%B2%20%D1%81%D0%BB%D1%83%D1%87%D0%B0%D0%B9%D0%BD%D0%BE%D0%BC%20%D0%BF%D0%BE%D1%80%D1%8F%D0%B4%D0%BA%D0%B5%22%22%22%0A%20%20%20%20%23%20%D0%A1%D0%BE%D0%B7%D0%B4%D0%B0%D1%82%D1%8C%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%20nums%20%3D%3A%201%2C%202%2C%203%2C%20...%2C%20n%0A%20%20%20%20nums%20%3D%20%5Bi%20for%20i%20in%20range%281%2C%20n%20%2B%201%29%5D%0A%20%20%20%20%23%20%D0%A1%D0%BB%D1%83%D1%87%D0%B0%D0%B9%D0%BD%D0%BE%20%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%88%D0%B0%D1%82%D1%8C%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%D1%8B%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B0%0A%20%20%20%20random.shuffle%28nums%29%0A%20%20%20%20return%20nums%0A%0Adef%20find_one%28nums%3A%20list%5Bint%5D%29%20-%3E%20int%3A%0A%20%20%20%20%22%22%22%D0%9D%D0%B0%D0%B9%D1%82%D0%B8%20%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%20%D1%87%D0%B8%D1%81%D0%BB%D0%B0%201%20%D0%B2%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B5%20nums%22%22%22%0A%20%20%20%20for%20i%20in%20range%28len%28nums%29%29%3A%0A%20%20%20%20%20%20%20%20%23%20%D0%9A%D0%BE%D0%B3%D0%B4%D0%B0%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%201%20%D0%BD%D0%B0%D1%85%D0%BE%D0%B4%D0%B8%D1%82%D1%81%D1%8F%20%D0%B2%20%D0%BD%D0%B0%D1%87%D0%B0%D0%BB%D0%B5%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B0%2C%20%D0%B4%D0%BE%D1%81%D1%82%D0%B8%D0%B3%D0%B0%D0%B5%D1%82%D1%81%D1%8F%20%D0%BB%D1%83%D1%87%D1%88%D0%B0%D1%8F%20%D0%B2%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F%20%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D1%8C%20O%281%29%0A%20%20%20%20%20%20%20%20%23%20%D0%9A%D0%BE%D0%B3%D0%B4%D0%B0%20%D1%8D%D0%BB%D0%B5%D0%BC%D0%B5%D0%BD%D1%82%201%20%D0%BD%D0%B0%D1%85%D0%BE%D0%B4%D0%B8%D1%82%D1%81%D1%8F%20%D0%B2%20%D0%BA%D0%BE%D0%BD%D1%86%D0%B5%20%D0%BC%D0%B0%D1%81%D1%81%D0%B8%D0%B2%D0%B0%2C%20%D0%B4%D0%BE%D1%81%D1%82%D0%B8%D0%B3%D0%B0%D0%B5%D1%82%D1%81%D1%8F%20%D1%85%D1%83%D0%B4%D1%88%D0%B0%D1%8F%20%D0%B2%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F%20%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D1%8C%20O%28n%29%0A%20%20%20%20%20%20%20%20if%20nums%5Bi%5D%20%3D%3D%201%3A%0A%20%20%20%20%20%20%20%20%20%20%20%20return%20i%0A%20%20%20%20return%20-1%0A%0A%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20n%20%3D%2010%0A%20%20%20%20nums%20%3D%20random_numbers%28n%29%0A%20%20%20%20index%20%3D%20find_one%28nums%29%0A%20%20%20%20print%28%22%5Cn%D0%9C%D0%B0%D1%81%D1%81%D0%B8%D0%B2%20%5B1%2C%202%2C%20...%2C%20n%5D%20%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%20%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D1%88%D0%B8%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F%20%3D%22%2C%20nums%29%0A%20%20%20%20print%28%22%D0%98%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%20%D1%87%D0%B8%D1%81%D0%BB%D0%B0%201%20%3D%22%2C%20index%29&codeDivHeight=800&codeDivWidth=600&cumulative=false&curInstr=25&heapPrimitives=nevernest&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false" target="_blank" rel="noopener noreferrer">Во весь экран &gt;</a></div></p>
 </details>
 <p>Стоит отметить, что на практике лучшая временная сложность используется редко, поскольку обычно она достигается лишь с очень малой вероятностью и может вводить в заблуждение. <strong>Худшая временная сложность гораздо практичнее, потому что задает безопасную оценку эффективности</strong> и позволяет уверенно использовать алгоритм.</p>
-<p>Из приведенного выше примера видно, что худшая и лучшая временные сложности возникают только при особых распределениях данных; вероятность таких случаев может быть низкой, и они не всегда реально отражают эффективность алгоритма. Напротив, <strong>средняя временная сложность способна показать эффективность алгоритма на случайных входных данных</strong> и обозначается символом <span class="arithmatex">\(\Theta\)</span> .</p>
-<p>Для некоторых алгоритмов можно относительно просто вывести средний случай при случайном распределении данных. Например, в приведенном выше примере входной массив перемешан, а вероятность появления элемента <span class="arithmatex">\(1\)</span> на любом индексе одинакова; следовательно, среднее число итераций алгоритма равно половине длины массива, то есть <span class="arithmatex">\(n / 2\)</span> , а средняя временная сложность равна <span class="arithmatex">\(\Theta(n / 2) = \Theta(n)\)</span> .</p>
+<p>Из приведенного выше примера видно, что худшая и лучшая временные сложности возникают только при особых распределениях данных. Вероятность таких случаев может быть низкой, и они не всегда реально отражают эффективность алгоритма. Напротив, <strong>средняя временная сложность способна показать эффективность алгоритма на случайных входных данных</strong> и обозначается символом <span class="arithmatex">\(\Theta\)</span> .</p>
+<p>Для некоторых алгоритмов можно относительно просто вывести средний случай при случайном распределении данных. Например, в приведенном выше примере входной массив перемешан, а вероятность появления элемента <span class="arithmatex">\(1\)</span> на любом индексе одинакова. Следовательно, среднее число итераций алгоритма равно половине длины массива, то есть <span class="arithmatex">\(n / 2\)</span> , а средняя временная сложность равна <span class="arithmatex">\(\Theta(n / 2) = \Theta(n)\)</span> .</p>
 <p>Однако для более сложных алгоритмов вычислить среднюю временную сложность часто непросто, потому что трудно проанализировать полное математическое ожидание на заданном распределении данных. В таких случаях обычно используют худшую временную сложность как критерий оценки эффективности алгоритма.</p>
 <div class="admonition question">
 <p class="admonition-title">Почему символ <span class="arithmatex">\(\Theta\)</span> встречается так редко?</p>
-<p>Возможно, потому что символ <span class="arithmatex">\(O\)</span> звучит слишком привычно, и мы часто используем его для обозначения средней временной сложности. Но строго говоря, это некорректно. В этой книге и в других материалах, если встретится выражение вроде "средняя временная сложность <span class="arithmatex">\(O(n)\)</span>", просто понимай его как <span class="arithmatex">\(\Theta(n)\)</span> .</p>
+<p>Возможно, потому что символ <span class="arithmatex">\(O\)</span> звучит слишком привычно, и мы часто используем его для обозначения средней временной сложности. Но строго говоря, это некорректно. В этой книге и в других материалах, если встретится выражение вроде «средняя временная сложность <span class="arithmatex">\(O(n)\)</span>», просто понимай его как <span class="arithmatex">\(\Theta(n)\)</span> .</p>
 </div>
 
 <!-- Source file information -->