03-control.tex

\documentclass[alsotrans]{beamerswitch}
\usepackage{iprog}

\title{Управляващи оператори в C++}

\date[18.10--8.11.2021 г.]{18 октомври--8 ноември 2021 г.}

\newcommand{\expsum}{\displaystyle \sum_{i=0}^n \limits \frac{x^i}{i!}}

\begin{document}

\begin{frame}
  \titlepage
\end{frame}

\section{Изчислителни процеси}
\begin{frame}
  \frametitle{Изчислителни процеси}

  \begin{itemize}
  \item Алгоритъм: последователност от стъпки за извършване на пресмятане
  \item Блок-схема
  \end{itemize}\ \\[2ex]
  \begin{tikzpicture}
    [node distance=4ex,font=\small]
    \node (begin)  [entry]                  {начало};
    \node (input)  [io,right=of begin]      {%
      \begin{tabular}{l}
        въведи \tt a\\
        въведи \tt b
      \end{tabular}
    };
    \node (assign) [op,right=of input]      {\tt{x = -b/a}};
    \node (output) [io,right=of assign]     {изведи \tt x};
    \node (end)    [entry,right=of output]  {край};

    \graph[use existing nodes,edges=thick]
    { begin -> input -> assign -> output -> end };
  \end{tikzpicture}\\[4ex]
  Пример за линеен процес
\end{frame}

\begin{frame}
  \frametitle{Разклоняващи се процеси}

  \begin{tikzpicture}
    [node distance=4ex,font=\scriptsize]
    \node (begin)  [entry]                  {начало};
    \node (input)  [io,right=of begin]      {%
      \begin{tabular}{l}
        въведи \tt a\\
        въведи \tt b
      \end{tabular}
    };
    \node (a0)     [cond,right=of input]    {\tt{a == 0}};
    \node (assign) [op,right=of a0]         {\tt{x = -b/a}};
    \node (output) [io,right=of assign]     {изведи \tt x};
    \node (p1)     [point,right=of output]  {};
    \node (b0)     [cond,below=of a0]       {\tt{b == 0}};
    \node (nosol)  [io,right=of b0]         {
      \begin{tabular}{l}
        изведи\\
        \tt{"няма решение"}
      \end{tabular}};
    \node (p2)     [point] at (nosol -| p1) {};
    \node (allsol) [io,below=of b0]         {
      \begin{tabular}{l}
        изведи\\
        \tt{"всяко x е решение"}
      \end{tabular}};
    \node (end)    [entry] at (allsol -| p1){край};

    \graph[use existing nodes,edges=thick]
    { begin -> input -> a0 ->[edge label={не}] assign -> output -- p1 -- p2 -> end;
      a0 ->[edge label=да] b0 ->[edge label={не}] nosol -> p2;
      b0 ->[edge label=да] allsol -> end;
    };
  \end{tikzpicture}
\end{frame}

\begin{frame}
  \frametitle{Индуктивни циклични процеси}

  \begin{tikzpicture}
    [node distance=4ex,font=\scriptsize]
    \node (begin)  [entry]                  {начало};
    \node (input)  [io,right=of begin]      {въведи \tt n};
    \node (init)   [op,right=of input]      {
      \begin{tabular}{l}
        \tt{i = 1}\\
        \tt{f = 1}
      \end{tabular}};
    \node (p0)     [point,below=of init]    {};
    \node (guard)  [cond,below=of p0]       {\tt{i <= n}};
    \node (body)   [op,below=of guard]      {
      \begin{tabular}{l}
        \tt{f = f * i}\\
        \tt{i = i + 1}
      \end{tabular}};
    \node (output) [io,right=of guard]      {изведи \tt f};
    \node (end)    [entry,right=of output]  {край};

    \graph[use existing nodes,edges=thick]
    { begin -> input -> init -- p0 -> guard ->[edge label={не}] output -> end;
      guard ->[edge label=да] body ->[to path={-- ++(-10ex,0) |- (p0)}] p0; };
  \end{tikzpicture}\\[-20ex]
  \pause
  \begin{tabular}{|c|c|c|}
    \hline
    \tt n&\tt i&\tt f\\
    \hline\hline
    4&1&1\\
    \hline\tpause
    4&2&1\\
    \hline\tpause
    4&3&2\\
    \hline\tpause
    4&4&6\\
    \hline\tpause
    4&5&24\\
    \hline
  \end{tabular}
\end{frame}

\begin{frame}
  \frametitle{Итеративни циклични процеси}

  \begin{tikzpicture}
    [node distance=4ex,font=\scriptsize]
    \node (begin)  [entry]                  {начало};
    \node (input)  [io,right=of begin]      {
      \begin{tabular}{l}
        въведи \tt a\\
        въведи \tt b
      \end{tabular}};
    \node (guard)   [cond,right=of input,inner sep=-2pt]   {
      \begin{tabular}{c}
        \tt{a == 0}\\
        или\\
        \tt{b == 0}
      \end{tabular}};
    \node (p)       [point,below=of guard] {};
    \node (nogcd)   [io,right=of guard] {
      \begin{tabular}{l}
        изведи\\
        \tt{"грешка"}
      \end{tabular}};
    \node (end)     [entry,right=of nogcd] {край};
    \node (ab)      [cond,below=of p]  {\tt{a == b}};
    \node (ab1)     [cond,below=of ab]     {\tt{a > b}};
    \node (output)  [io] at (ab -| end)    {изведи \tt a};
    \node (a)       [op,left=of ab1]       {\tt{a = a - b}};
    \node (b)       [op,right=of ab1]       {\tt{b = b - a}};

    \graph[use existing nodes,edges=thick]
    { begin -> input -> guard ->[edge label=да] nogcd -> end;
      guard --[edge label=не] p -> ab ->[edge label=да] output -> end;
      ab ->[edge label=не] ab1 ->[edge label=да] a ->[to path={|- (p)}] p;
      ab1 ->[edge label=не] b ->[to path={|- (p)}] p;};
  \end{tikzpicture}\\[-20ex]
  \pause
  \begin{tabular}{|c|c|}
    \hline
    \tt a&\tt b\\
    \hline\hline
    12&32\\
    \hline\tpause
    12&20\\
    \hline\tpause
    12&8\\
    \hline\tpause
    4&8\\
    \hline\tpause
    4&4\\
    \hline
  \end{tabular}
\end{frame}

\begin{frame}
  \frametitle{Структурни езици — разклонение}

  \begin{columns}
    \begin{column}{.5\textwidth}
      \begin{enumerate}
      \item Въведи \tt a, \tt b
      \item Ако \tt{a == 0}, към 5
      \item \tt{x = -b / a}
      \item Премини към 9
      \item Ако \tt{b == 0}, към 8
      \item ``Няма решения''
      \item Премини към 9
      \item ``Всяко $x$ е решение''
      \item Край
      \end{enumerate}
    \end{column}
    \begin{column}{.5\textwidth}
      \begin{itemize}
      \item Въведи \tt a, \tt b
      \item Ако \tt{a == 0}
        \begin{itemize}
        \item Ако \tt{b == 0}
          \begin{itemize}
          \item ``Всяко $x$ е решение''
          \end{itemize}
        \item Иначе
          \begin{itemize}
          \item ``Няма решения''
          \end{itemize}
        \end{itemize}
      \item Иначе
        \begin{itemize}
        \item \tt{x = -b / a}
        \end{itemize}
      \end{itemize}
    \end{column}
  \end{columns}
\end{frame}

\begin{frame}
  \frametitle{Структурни езици — индуктивен цикъл}

  \begin{columns}
    \begin{column}{.5\textwidth}
      \begin{enumerate}
      \item Въведи \tt n
      \item \tt{i = 1}
      \item \tt{f = 1}
      \item Ако \tt{i > n}, към 8
      \item \tt{f = f * i}
      \item \tt{i = i + 1}
      \item Премини към 4
      \item Изведи \tt f
      \item Край
      \end{enumerate}
    \end{column}
    \begin{column}{.5\textwidth}
      \begin{itemize}
      \item Въведи \tt n
      \item \tt{i = 1}
      \item \tt{f = 1}
      \item Повтаряй \tt n пъти
        \begin{itemize}
        \item \tt{f = f * i}
        \item \tt{i = i + 1}
        \end{itemize}
      \item Изведи \tt f
      \end{itemize}
    \end{column}
  \end{columns}
\end{frame}

\begin{frame}
  \frametitle{Структурни езици — итеративен цикъл}

  \begin{columns}[t,onlytextwidth]
    \begin{column}{.5\textwidth}
      \begin{enumerate}
      \item Въведи \tt a, \tt b
      \item Ако \tt{a == b}, към 6.
      \item Ако \tt{a > b}, към 5.
      \item \tt{b = b - a}; към 2.
      \item \tt{a = a - b}; към 2.
      \item Изведи \tt a
      \item Край
      \end{enumerate}
    \end{column}
    \begin{column}{.5\textwidth}
      \begin{itemize}
      \item Въведи \tt a, \tt b
      \item Докато \tt{a != b}
        \begin{itemize}
        \item Ако \tt{a > b}
          \begin{itemize}
          \item \tt{a = a - b}
          \end{itemize}
        \item В противен случай
          \begin{itemize}
          \item \tt{b = b - a}
          \end{itemize}
        \end{itemize}
      \item Изведи \tt a
      \end{itemize}
    \end{column}
  \end{columns}
\end{frame}

\section{Основни понятия}

\begin{frame}
  \frametitle{Основни понятия}

  \begin{itemize}
  \item \textbf{Операция} (operator)
  \item \textbf{Израз} (expression)
  \item \textbf{Оператор/команда} (statement)
  \item{}
    \begin{tabular}[t]{@{}rl@{}}
      <израз> ::= &<константа> | <променлива> |\\
      &<едноместна\_операция> <израз> |\\
      &<израз> <двуместна\_операция> <израз> |\\
      &<функция>\tta(<израз>\tta)
    \end{tabular}
  \item{} <оператор> ::= <израз>\tta;
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Оператор за присвояване}

  \begin{itemize}[<+->]
  \item{} <променлива> \tta= <израз>\tta;
  \item{} <lvalue> \tta= <rvalue>\tta;
  \item{} <lvalue> --- място в паметта със стойност, която може да се променя
    \begin{itemize}[<.->]
    \item  \exa променлива
  \end{itemize}
  \item{} <rvalue> --- временна стойност, без специално място в паметта
    \begin{itemize}[<.->]
    \item \exa константа, литерал, резултат от пресмятане
  \end{itemize}
  \item стандартно преобразуване на типовете:\\
    <rvalue> се преобразува до типа на <lvalue>
  \end{itemize}

\end{frame}

\begin{frame}
  \frametitle{Присвояването като операция}
  \begin{fixedarea}[.6]
    \begin{itemize}
    \item<1-> \alert{дясноасоциативна} операция
    \item<2-> \temporal<3>{\tt{a = b = c = 2;}}{\tt{a = (b = (c = 2));}}{$\underbrace{\tt{a = }\underbrace{\tt{(b = }\underbrace{\tt{(c = 2)}}_{\tt c})}_{\tt b}}_{\tt a}$}
    \item<3> \sta{(((a = b) = c) = 2);}
    \item<5-> \exa \lst{cout << x + (b = 2);}
    \item<6-> \exa \lst{(a = b) = a + 3;}
    \end{itemize}
  \end{fixedarea}
\end{frame}

\begin{frame}
  \frametitle{Операция за изброяване}

  \begin{itemize}[<+->]
  \item{} <израз1>\tta, <израз2>
  \item<.-> оценява и двата израза, но крайният резултат е оценката на втория израз
  \item \tt{a, b, c, d} $\Leftrightarrow$ \tt{(a, (b, (c, d)))}
  \item<.-> \alert{дясноасоциативна}
  \item<.-> използва се рядко
  \item \exa \lst{a = (cout << x, x);}
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Съкратени операции за присвояване}

  \begin{itemize}[<+->]
  \item \tt{a = a + 2} $\Leftrightarrow$ \tt{a += 2}
  \item \tt{-=}, \tt{*=}, \tt{/=}, \tt{\%=}
  \item \tt{a = a + 1}  $\Leftrightarrow$ \tt{++a}
  \item \tt{a = a - 1}  $\Leftrightarrow$ \tt{-{}-a}
  \item \tt{a++} увеличава a с 1, но връща предишната стойност на \tt a
    \begin{itemize}
    \item \tt{a++} $\Leftrightarrow$ \tt{(a = (tmp = a) + 1, tmp)}
    \end{itemize}
  \item \tt{a-{}-} действа аналогично
  \item \tta{++a} връща a, което е \alert{<lvalue>}
    \begin{itemize}
    \item \exa \lst{++a += 5;}
    \end{itemize}
  \item \tta{a++} връща предишната стойност на a, което е \alert{<rvalue>}
    \begin{itemize}
    \item \exa \lst{x = a++ * b;} \sta{a++ += 5;}
    \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Оператор за блок}

  \begin{itemize}[<+->]
  \item \tta\{ \{ <оператор> \} \tta\}
  \item \tta\{ <оператор$_1$> <оператор$_2$> \ldots <оператор$_n$> \tta\}
  \item Вложени блокове\\
\begin{lstlisting}
{
  int x = 2;
  {
    x += 2;
    cout << x;
  }
}
\end{lstlisting}
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Област на действие (scope)}

  \begin{itemize}[<+->]
  \item областта на действие се простира от дефиницията на
    променливата до края на блока, в който е дефинирана
  \item дефиниция на променлива със същото име в същия блок е
    забранена
  \item дефиниция на променлива във вложен блок покрива всички външни
    дефиниции със същото име
  \end{itemize}
\end{frame}

\begin{frame}<1-10>
  \frametitle{Област на действие (scope) --- пример}

  \begin{columns}[T,onlytextwidth]
    \begin{column}{.4\textwidth}
      \begin{tabular}{|l|l|l|}
        \hline
        \multicolumn3{|l|}{\lst{int x = 0;}}\\
        \multicolumn3{|l|}{\tt\{}\\
        \multicolumn1{|l}{}&\multicolumn2{l|}{\lst{x++;}}\\
        \cline{2-3}
                           &\multicolumn2{l|}{\lst{double y = 2.3;}}\\
                           &\multicolumn2{l|}{\tt\{}\\
        \cline{3-3}
                           &&\multicolumn1{l|}{\lst{double x = 1.6;}}\\
                           &&\multicolumn1{l|}{\lst{y = x * x;}}\\
        \cline{3-3}
                           &\multicolumn2{l|}{\tt\}}\\
                           &\multicolumn2{l|}{\sta{double y = 2.4;}}\\
                           &\multicolumn2{l|}{\lst{x += 3;}}\\
        \cline{2-3}
        \multicolumn3{|l|}{\tt\}}\\
        \multicolumn3{|l|}{\lst{x += 4;}}\\
        \multicolumn3{|l|}{\sta{y /= 2.1;}}\\
        \hline
      \end{tabular}
    \end{column}
    \pause
    \begin{column}{.6\textwidth}
      \begin{tabular}{p{3ex}|p{4ex}|p{8ex}|p{8ex}|p{3ex}}
        \multicolumn1l{}&\multicolumn1l{\tt x}&\multicolumn1l{\only<4-8>{\tt y}}&\multicolumn1l{\only<5-6>{\tt x}}&\multicolumn1l{}\\
        \hline
        \rowcolor{diagramblue}
        \ldots&\tt{\temporal<3-7>{0}{1}{\alt<8-9>{4}{8}}}&\tt{\temporal<4-5>{}{2.3}{\alt<6-8>{2.56}{}}}&\tt{\only<5-6>{1.6}}&\ldots\\
        \hline
      \end{tabular}
    \end{column}
  \end{columns}
\end{frame}

\begin{frame}
  \frametitle{Празен оператор}
  \begin{itemize}
  \item \tta;
  \item \tt; $\Leftrightarrow$ \tt{\{\}}
  \item няма никакъв ефект
  \end{itemize}
\end{frame}

\section{Структури за разклонение}

\begin{frame}
  \frametitle{Условен оператор}

  \begin{itemize}[<+->]
  \item \tta{if (}<израз>\tta) <оператор> [\tta{else} <оператор>]
  \item Съкратената форма $\Leftrightarrow$ пълна форма с празен оператор
    \begin{itemize}
    \item \lst{if (A) X;} $\Leftrightarrow$ \lst{if (A) X; else;}
    \end{itemize}
  \item \exa \lst{if ( x < 2 ) y = 2;}
  \item \exa \lst{if ( x > 5 ) y = 5; else y = 3;}
  \end{itemize}
\end{frame}

\begin{frame}<1-5>[fragile]
  \frametitle{Вложени условни оператори}

  Какво имаме предвид, когато пишем:
  \lst{if (a > 0) if (b > 0) cout << 1; else cout << 3;}\\[1em]
  \pause
  \begin{tabular}{l@{\hskip 6em}c@{\hskip 4em}l}
\begin{lstlisting}
if (a > 0) @\only<3->{\{}@
  if (b > 0)
@\only<4->{\hskip 2em// $a > 0$ \&\& $b > 0$}@
    cout << 1;
  else
@\only<4->{\hskip 2em// $a > 0$ \&\& $b \leq 0$}@
    cout << 3;
@\only<3->{\}}@
\end{lstlisting}%
\onslide<2-4>
    &или&%
\begin{lstlisting}
if (a > 0) @\only<3->{\{}@
  if (b > 0)
@\only<4->{\hskip 2em// $a > 0$ \&\& $b > 0$}@
    cout << 1;
@\only<3->{\}}@
else
@\only<4->{\hskip 1em// $a \leq 0$}@
  cout << 3;
\end{lstlisting}
  \end{tabular}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Съкратено оценяване на логически операции}
Представяне на логически операции с вложени условни оператори:\\[2ex]
\begin{tabular}{l@{$\qquad\Leftrightarrow\qquad$}l}
\begin{lstlisting}
if (!A) X;
else    Y;
\end{lstlisting}
  &
\begin{lstlisting}
if (A) Y;
else   X;
\end{lstlisting}\\[3ex]
\tpause
\begin{lstlisting}
if (A && B) X;
else        Y;
\end{lstlisting}
&
\begin{lstlisting}
if (A)
  if (B) X;
  else   Y;
else Y;
\end{lstlisting}\\[5ex]
\tpause
\begin{lstlisting}
if (A || B) X;
else        Y;
\end{lstlisting}
&
\begin{lstlisting}
if (A) X;
else
  if (B) X;
  else   Y;
\end{lstlisting}
\end{tabular}\\[2ex]
\pause
\exa \lst{if (x > 0 && log(x) < 5) ...}\\
\exa \lst{if (x == 0 || y / x == 1) ...}
\end{frame}

\begin{frame}
  \frametitle{Условна \alert{операция}}
  \begin{itemize}[<+->]
  \item{} <булев\_израз> ? <израз$_1$> : <израз$_2$>
  \item триместна (тернарна) операция
  \item пресмята се <булев\_израз>
    \begin{itemize}
    \item При \tt{true} се пресмята <израз$_1$> и се връща резултатът
    \item При \tt{false} се пресмята <израз$_2$> и се връща резултатът
    \end{itemize}
  \item \exa \lst{x = y < 2 ? y + 1 : y - 2;}
  \item \lst{A} $\Leftrightarrow$ \lst{A ? true : false}
  \item \lst{!A} $\Leftrightarrow$ \lst{A ? false : true}
  \item \lst{A && B} $\Leftrightarrow$ \lst{A ? B : false}
  \item \lst{A || B} $\Leftrightarrow$ \lst{A ? true : B}
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Задачи за условен оператор}

  \begin{enumerate}[<+->]
  \item Да се провери дали три числа образуват растяща редица
  \item Да се намери най-малкото от три числа
  \item Да се подредят три числа в растяща редица
  \item Да се провери дали три числа образуват Питагорова тройка
  \end{enumerate}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Оператор за многозначен избор}

  \begin{itemize}
  \item
    \tta{switch (}<израз>\tta{) \{}\\
    \hspace{3ex}\{ \tta{case} <константен\_израз> \tta: \{ <оператор> \} \}\\
    \hspace{3ex}[ \tta{default :} \{ <оператор> \} ]\\
    \tta\}
  \item \exa
\begin{lstlisting}
switch (x) {
	case 1 : x++;
	case 2 : x += 2;
	default : x += 5;
}
\end{lstlisting}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Оператор за прекъсване}

  \begin{itemize}
  \item \tta{break;}
  \item \exa
\begin{lstlisting}
switch (x) {
	case 1 : x++; break;
	case 2 : x += 2; break;
	default : x += 5;
}
\end{lstlisting}
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Задачи за многозначен избор}

  \begin{enumerate}[<+->]
  \item Да се пресметне избрана от потребителя целочислена аритметична операция
  \item Да се провери дали дадена буква е гласна или съгласна
  \end{enumerate}
\end{frame}

\section{Циклични структури}

\begin{frame}
  \frametitle{Циклични структури}

  \begin{itemize}[<+->]
  \item Да се пресметне $\displaystyle\sum_{i=1}^5\limits i^2$
    \begin{itemize}
    \item \lst{x += 1*1; x += 2*2; x += 3*3; x += 4*4; x += 5*5;}
    \item \lst{x += i*i;} за $i = 1, 2, 3, 4, 5$
    \item индуктивен цикличен процес
    \item \lst{for(int i = 1; i <= 5; i++) x += i * i;}
    \end{itemize}
  \item Да се намери първата цифра на $x$
    \begin{itemize}
    \item \lst{if (x >= 10) x /= 10; if (x >= 10) x /= 10; ...}
    \item \lst{x /= 10;} докато е вярно, че \lst{x >= 10}
    \item итеративен цикличен процес
    \item \lst{while (x >= 10) x /= 10;}
    \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Оператор \lst{for}}

  \begin{itemize}[<+->]
  \item \tta{for (} <израз> \tta; <израз> \tta; <израз> \tta) <оператор>
  \item \tta{for (} <инициализация> \tta; <условие> \tta; <корекция> \tta) <тяло>
  \item Семантика:
    \begin{itemize}
    \item<.-> <инициализация>\tt;
    \item<.-> \lst{if (}<условие>\tt{) \{} <тяло> <корекция>\tt{;\}}
    \item<.-> \lst{if (}<условие>\tt{) \{} <тяло> <корекция>\tt{;\}}
    \item<.-> \lst{if (}<условие>\tt{) \{} <тяло> <корекция>\tt{;\}}
    \item<.-> \ldots
    \end{itemize}
  \item \alert{Изключение:} <инициализация> може да е не просто израз, а дефиниция на променлива
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Оператор \lst{for} --- примери}

\begin{lstlisting}
double sum = 0, x;
int n;
cout << "Въведете брой числа: ";cin >> n;
for(int i = 1; i <= n; i++) {
  cout << "Въведете число: ";
  cin >> x;
  sum += x;
}
cout << "Средно аритметично: " << sum / n << endl;
\end{lstlisting}
\pause
\begin{lstlisting}
for(int i = 1, x = 0, y = 1; i < 5; i++) {
  x += i;
  y *= x;
}
\end{lstlisting}
\end{frame}

\begin{frame}
  \frametitle{Задачи за \lst{for}}

  \begin{enumerate}[<+->]
  \item Да се пресметне $n!$
  \item Да се пресметне сумата $\expsum$
  \item Да се намери броят на тези от числата $x_i = n^3 + 5i^2n -8i$, които са кратни на 3 за $i=1,\ldots,n$
  \item Да се намери най-голямото число от вида $x_i = n^3 + 5i^2n -8i$ за $i=1,\ldots,n$
  \end{enumerate}
\end{frame}

\begin{frame}
  \frametitle{Оператор \lst{while}}

  \begin{itemize}[<+->]
  \item \tta{while (}<израз>\tta) <оператор>
  \item \tta{while (}<условие>\tta) <тяло>
  \item Семантика:
    \begin{itemize}
    \item<.-> \lst{if (}<условие>\tt) <тяло>
    \item<.-> \lst{if (}<условие>\tt) <тяло>
    \item<.-> \lst{if (}<условие>\tt) <тяло>
    \item<.-> \ldots
    \end{itemize}
  \item \lst{while} чрез \lst{for}
    \begin{itemize}
    \item \lst{while (}<условие>\tt) <тяло> $\quad\Leftrightarrow\quad$
      \lst{for(;}<условие>\tt{;)}<тяло>
    \end{itemize}
  \item \lst{for} чрез \lst{while}
    \begin{itemize}
    \item \lst{for(}<инициализация>\tt;<условие>\tt;<корекция>\tt)<тяло>\\
      $\Leftrightarrow$\\
      <инициализация>\tt; \lst{while(}<условие>\tt{) \{ }<тяло> <корекция>\tt{;\}}
    \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Оператор \lst{while} --- примери}

\begin{lstlisting}
cout << "НОД(" << a << ',' << b << ") = ";
while (a != b)
  if (a > b) a %= b;
  else       b %= a;
cout << a << endl;
\end{lstlisting}
\pause
\begin{lstlisting}
int n, i = 0;
cout << "Въведете n: ";cin >> n;
while (n > 1) {
  if (n % 2 == 0) n /= 2;
  else           (n *= 3)++;
  cout << "n = " << n << endl;
  i++;
}
cout << "Направени " << i << " стъпки" << endl;
\end{lstlisting}
\end{frame}

\begin{frame}<1-3>
  \frametitle{Задачи за \lst{while}}

  \begin{enumerate}[<+->]
  \item Да се пресметне $n!$
  \item Да се намери средното аритметично на поредица от числа
  \item Да се пресметне сумата $\expsum$ с точност $\varepsilon$
  \item Да се намери сумата на цифрите на $n$
  \item Да се провери дали $n$ съдържа цифрата $5$
  \end{enumerate}
\end{frame}

\begin{frame}
  \frametitle{Оператор \lst{do/while}}

  \begin{itemize}[<+->]
  \item \tta{do} <оператор> \tta{while (}<израз>\tta{);}
  \item \tta{do} <тяло> \tta{while (}<условие>\tta{);}
  \item Семантика:
    \begin{itemize}
    \item<.-> <тяло>
    \item<.-> \lst{while (}<условие>\tt) <тяло>
    \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}[fragile,fragile]
  \frametitle{Оператор \lst{do/while} --- пример}

\begin{lstlisting}
@\only<4->{\tt{char c;}}@
do {
  @\only<1-3>{\alert<2-3>{\tt{char c;}}}@
  cout << "Въведете символ: ";
  cin >> c;
  cout << "ASCII код: " << (int)c;
} while (@\alert<3>{c != 'q'});
\end{lstlisting}
\end{frame}

\begin{frame}
  \frametitle{\lst{while} или \lst{do/while}?}

  Как да изберем кой от циклите да използваме?
  \begin{itemize}[<+->]
  \item Ако допускаме тялото да не се изпълни нито веднъж --- \lst{while}
  \item Ако искаме тялото да се изпълни поне веднъж --- \lst{do/while}
  \item \lst{do} <тяло> \lst{while (}<условие>\lst{);}\\
    $\Leftrightarrow$\\
    <тяло> \lst{while (}<условие>\tt) <тяло>
  \item \lst{while (}<условие>\tt) <тяло>\\
    $\Leftrightarrow$\\
    \lst{do if (}<условие>\tt) <тяло> \lst{while (}<условие>\tt{);}
    \begin{itemize}
    \item \alert{стига <условие> да няма странични ефекти...}
    \item \exa \lst{while (--i > 0) cout << i << endl;}
    \end{itemize}
  \end{itemize}
\end{frame}

\begin{frame}
  \frametitle{Задачи за \lst{do/while}}

  \begin{enumerate}[<+->]
  \item Да се провери дали $n$ е просто число
  \item Да се изчисли приблизително $\sqrt x$ по метода на Нютон:
    \begin{equation*}
      \begin{array}{l}
      y_0 = x\\
      y_{n+1} = \frac12\left(y_n + \frac x{y_n}\right)\\
      \lim_{n\to\infty}\limits y_n = \sqrt x
      \end{array}
    \end{equation*}
  \end{enumerate}
\end{frame}

\section{Вложени цикли}

\begin{frame}
  \frametitle{Вложени цикли --- примери}
  \begin{columns}[T,onlytextwidth]
    \begin{column}{.5\textwidth}
      \begin{itemize}
      \item a = 1
        \begin{itemize}
        \item b = 1
        \item b = 2
        \item b = 3
        \end{itemize}
      \item a = 2
        \begin{itemize}
        \item b = 1
        \item b = 2
        \item b = 3
        \end{itemize}
      \item a = 3
        \begin{itemize}
        \item b = 1
        \item b = 2
        \item b = 3
        \end{itemize}
      \item a = 4
        \begin{itemize}
        \item b = 1
        \item b = 2
        \item b = 3
        \end{itemize}
      \end{itemize}
    \end{column}
    \pause
    \begin{column}{.5\textwidth}
      \begin{itemize}
      \item i = 1
        \begin{itemize}
        \item j = 1
          \begin{itemize}
          \item k = 1
          \item k = 2
          \end{itemize}
        \item j = 2
          \begin{itemize}
          \item k = 1
          \item k = 2
          \end{itemize}
        \item j = 3
          \begin{itemize}
          \item k = 1
          \item k = 2
          \end{itemize}
        \end{itemize}
      \item i = 2
        \begin{itemize}
        \item j = 1
          \begin{itemize}
          \item k = 1
          \item k = 2
          \end{itemize}
        \item \ldots
        \end{itemize}
      \item \ldots
      \end{itemize}
  \end{column}
  \end{columns}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Вложени цикли --- примери}

  \begin{columns}
    \begin{column}{.5\textwidth}
      Пирамида\\[2ex]
\begin{verbatim}
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
...
\end{verbatim}
    \end{column}
    \pause
    \begin{column}{.5\textwidth}
      Брояч\\[2ex]
\begin{verbatim}
2:03
2:02
2:01
2:00
1:59
1:58
...
1:01
1:00
0:59
...
0:01
0:00
\end{verbatim}
    \end{column}
  \end{columns}
\end{frame}

\begin{frame}
  \frametitle{Задачи за вложени цикли}

  \begin{enumerate}[<+->]
  \item Да се изведат всички плочки за играта домино
  \item Да се провери дали в едно число има две еднакви цифри
  \item Да се изведат всички цифри, които се срещат едновременно в числата $m$ и $n$
  \end{enumerate}
\end{frame}
\end{document}