лекция 2

articles/t1l2.md

@@ -194,59 +194,49 @@ flowchart TD
     out5-->finish
 ```
 
-![](../img/t1l2p4.png)
-
-Этот же алгоритм на Kotlin: 
-
-```kt
-fun main(){
-    println("Введите a, b, c:")
-    val a = readLine()!!.toInt()
-    val b = readLine()!!.toInt()
-    val c = readLine()!!.toInt()
-
-    var x1: Float
-
-    if(a==0){
-        if(b==0){
-            if(c==0) println("любое X")
-            else println("нет решений")
-        } else {
-            x1 = -c.toFloat()/b
-            println("X=$x1")
-        }
-    } else {
-        val d = b*b-4*a*c
-        if(d<0) println("нет вещественных корней")
-        else{
-            x1 = (-b+sqrt(d.toFloat()))/(2*a)
-            val x2 = (-b-sqrt(d.toFloat()))/(2*a)
-            println("x1=$x1, x2=$x2")
-        }
-    }
-}
-```
-
 В этом алгоритме многократно использована *структурная команда ветвления*. Общий вид команды ветвления в блок-схемах и на ЯП следующий: 
 
-![](../img/t1l2p5.png)
+```mermaid
+flowchart TD
+    A{условие}
+    A-->|да|B[Процесс 1]
+    A-->|нет|C[Процесс 2]
+```
 
 ```cs
-if (условие) {серия1}
-else {серия2}
+if (условие) {процесс 1}
+else {процесс 2}
 ```
 
-Вначале проверяется условие (вычисляется отношение, логическое выражение). Если условие истинно, то выполняется серия 1 — последовательность команд, на которую указывает стрелка с надписью «да» (положительная ветвь). В противном случае выполняется серия 2 (отрицательная ветвь). В языке Kotlin условие записывается после служебного слова if, положительная ветвь — сразу после условия, отрицательная — после слова else.
+Вначале проверяется условие (вычисляется отношение, логическое выражение). Если условие истинно, то выполняется `процесс 1` — последовательность команд, на которую указывает стрелка с надписью «да» (положительная ветвь). В противном случае выполняется процесс 2 (отрицательная ветвь).
 
 Если на ветвях одного ветвления содержатся другие ветвления, то такой алгоритм имеет структуру *вложенных ветвлений*. Именно такую структуру имеет алгоритм «Корни квадратного уравнения».
 
 Рассмотрим следующую задачу: дано целое положительное число n. Требуется вычислить n! (n-факториал). Вспомним определение факториала: 
 
-![](../img/t1l2p6.png)
+$$
+n! = 
+    \begin{cases}
+        1, & \text{если n = 0}\\
+        1 * 2 ... n, & \text{если n $\geq$ 0} 
+    \end{cases}
+$$
 
-Ниже приведена блок-схема алгоритма. В нем используются три переменные целого типа: n — аргумент; i — промежуточная переменная; F — результат. Для проверки правильности алгоритма построена трассировочная таблица. В такой таблице для конкретных значений исходных данных по шагам прослеживается изменение переменных, входящих в алгоритм. Данная таблица составлена для случая п = 3. 
+Ниже приведена блок-схема алгоритма. В нем используются три переменные целого типа: `n` — аргумент; `i` — промежуточная переменная; `F` — результат. Для проверки правильности алгоритма построена трассировочная таблица. В такой таблице для конкретных значений исходных данных по шагам прослеживается изменение переменных, входящих в алгоритм. Данная таблица составлена для случая `п = 3`. 
 
-![](../img/t1l2p7.png)
+```mermaid
+flowchart TD
+    begin([Начало])
+    begin-->input[/Ввод n/]
+    input-->proc1[F := 1]
+    proc1-->proc2[i := 1]
+    proc2-->if{i $$\leq$$ n}
+    if-->|Да|proc3[F := F * i]
+        proc3-->proc4[i := i + 1]
+        proc4-->if
+    if-->|Нет|output[/Вывод F/]
+    output-->finish([Конец])
+```
 
 Шаг | n |  F  | i | Условие
 :--:|:-:|:---:|:-:|---------
@@ -283,9 +273,16 @@ fun main(){
 
 Этот алгоритм имеет циклическую структуру. В алгоритме использована структурная команда цикл-пока, или цикл с предусловием. Общий вид команды цикл-пока в блок-схемах и в ЯП следующий: 
 
-![цикл с предусловием](../img/t1l2p8.png)
+```mermaid
+flowchart TD
+    start([Начало])
+    start-->if{условие}
+    if-->|Да|case[код]
+        case-->if
+    if-->|Нет|finish([Конец])
+```
 
-```kt
+```cs
 while (условие) {
   //серия
 }
@@ -295,9 +292,23 @@ while (условие) {
 
 Цикл с предусловием — это основная, но не единственная форма организации циклических алгоритмов. Другим вариантом является цикл с постусловием. Вернемся к алгоритму решения квадратного уравнения. К нему можно подойти с такой позиции:  
 
-если а = 0, то это уже не квадратное уравнение и его можно не рассматривать. В таком случае будем считать, что пользователь ошибся при вводе данных, и следует предложить ему повторить ввод. Иначе говоря, в алгоритме будет предусмотрен контроль достоверности исходных данных с предоставлением пользователю возможности исправить ошибку. Наличие такого контроля — еще один признак хорошего качества программы. 
+если `а = 0`, то это уже не квадратное уравнение и его можно не рассматривать. В таком случае будем считать, что пользователь ошибся при вводе данных, и следует предложить ему повторить ввод. Иначе говоря, в алгоритме будет предусмотрен контроль достоверности исходных данных с предоставлением пользователю возможности исправить ошибку. Наличие такого контроля — еще один признак хорошего качества программы. 
 
-![решение квадратного уравнения, блок-схема](../img/t1l2p9.png)
+```mermaid
+flowchart TD
+    start([Начало])
+    start-->input[/Ввод a, b, c/]
+    input-->if1{a $$\neq$$ 0}
+    if1-->|нет|input
+    if1-->|Да|proc1[$$d := b^2 - 4ac$$]
+    proc1-->if2{$$d \geq 0$$}
+    if2-->|Нет|output[/Нет вещественных корней/]
+    output-->finish
+    if2-->|Да|proc2["$$x1 := (-b + \sqrt{d})/(2a)$$"]
+    proc2-->proc3["$$x2 := (-b - \sqrt{d})/(2a)$$"]
+    proc3-->output2[/Вывод x1, x2/]
+    output2-->finish([Конец])
+```
 
 ```kt
 fun main(){