\documentclass[margin=0px]{article}

\usepackage{listings}
\usepackage[utf8]{inputenc}
\usepackage{graphicx}
\usepackage{float}
\usepackage[a4paper, margin=0.7in]{geometry}
\usepackage{amsthm}
\usepackage{amssymb}
\usepackage{amsmath}
\usepackage{fancyhdr}
\usepackage{pdfpages}
\usepackage{setspace}

\onehalfspacing

\newenvironment{tetel}[1]{\paragraph{#1 \\}}{}
\renewcommand{\figurename}{ábra}
\makeatletter
\renewcommand\paragraph{%
	\@startsection{paragraph}{4}{0mm}%
	{-\baselineskip}%
	{.5\baselineskip}%
	{\normalfont\normalsize\bfseries}}
\makeatother

\pagestyle{fancy}
\lhead{\it{PTI BSc Záróvizsga tételek}}
\rhead{7. Programozás}

\title{\textbf{{\Large ELTE IK - Programtervező Informatikus BSc} \vspace{0.2cm} \\ {\huge Záróvizsga tételek}} \vspace{0.3cm} \\ 7. Programozás}
\author{}
\date{}

\begin{document}
\maketitle

\begin{tetel}{Programozás}
    A felsoroló fogalma. Nevezetes gyűjtemények (intervallum, tömb, sorozat, szekvenciális inputfájl) felsorolói. Felsorolóra megfogalmazott programozási tételek (összegzés, számlálás, maximum kiválasztás, feltételes maximumkeresés, lineáris keresés, kiválasztás). A visszavezetés módszere. Programozási tételekkel készült programok tesztelése.
\end{tetel}

\section{Egyszerű programozási feladat megoldásának lépései}
\subsection{Bevezetés}
Egy programozási feladat megoldása a kódoláson túl jó néhány tevékenységet tartalmaz.
Az első teendő a feladat pontos meghatározása, a specifikáció. Ez a feladat szöveges és formalizált, matematikai leírásán (a specifikáció ún. szűkebb értelmezésén) túl tartalmazza a megoldással szemben támasztott követelményeket, környezeti igényeket is (ami a specifikáció ún. tágabb értelmezése).

A specifikáció alapján meg lehet tervezni a programot, elkészülhet a megoldás algoritmusa és az algoritmus által használt adatok leírása. Az algoritmus és az adatszerkezet finomítása egymással párhuzamosan halad, egészen addig a szintig, amelyet a programozó ismeretei alapján már könnyen, hibamentesen képes kódolni. Gyakran előfordul, hogy a tervezés során derül fény a specifikáció hiányosságaira, így itt visszalépésekre számíthatunk.

Az algoritmusírás után következhet a kódolás. Ha a feladat kitűzője nem rögzítette, akkor ez előtt választhatunk a megoldáshoz programozási nyelvet. A kódolás eredménye a programozási nyelven leírt program.

A program első változatban általában sohasem hibátlan, a helyességéről csak akkor beszélhetünk, ha meggyőződtünk róla. A helyesség vizsgálatának egyik lehetséges módszere a tesztelés. Ennek során próbaadatokkal próbáljuk ki a programot, s az ezekre adott eredményből következtetünk a helyességre. (Ne legyenek illúzióink afelől, hogy teszteléssel eldönthető egy program helyessége. Hisz hogy valójában helyes-e a program – sajnos – nem következik abból, hogy nem találtunk hibát.)

Ha a tesztelés során hibajelenséggel találkozunk, akkor következhet a hibakeresés, a hibajelenséget okozó utasítás megtalálása, majd pedig a hibajavítás. A hiba kijavítása több fázisba is visszanyúlhat. Elképzelhető, hogy kódolási hibát kell javítanunk, de az is lehet, hogy a hibát már a tervezésnél követtük el. Javítás után újra tesztelni kell, hiszen – legyünk őszinték magunkhoz!– nem kizárt, hogy hibásan javítunk, illetőleg – enyhe optimizmussal állítjuk:– a javítás újabb hibákat fed fel, ...

E folyamat végeredménye a helyes program. Ezzel azonban még korántsem fejeződik be a programkészítés. Most következnek a minőségi követelmények. Egyrészt a hatékonyságot kell vizsgálnunk (végrehajtási idő, helyfoglalás), másrészt a kényelmes használhatóságot. Itt újra visszaléphetünk a kódolási, illetve a tervezési fázisba is. Ezzel elérkeztünk a jó programhoz.

\subsection{Specifikáció}
A programkészítés menetének első lépése a feladat meghatározása, precíz "újrafogalmazása". Milyen is legyen, mit várjunk el tőle? Nézzünk meg néhány – jónak tűnő – követelményt egyelőre címszavakban! (A továbbiakban a specifikáció szűkebb értelmezéséről lesz szó.) A specifikáció legyen:

\begin{itemize}
    \item helyes, egyértelmű, pontos, teljes
    \item rövid, tömör, ami legegyszerűbben úgy érhető el, hogy ismert formalizmusokra építjük
    \item szemléletes, érthető (amit időnként nehezít a formalizáltság)
\end{itemize}

A specifikáció első közelítésben lehetne a feladatok szövege. Ez azonban több problémát vethet fel:

\begin{itemize}
    \item mi alapján adjuk meg a megoldást
    \item mit is kell pontosan megadni?
\end{itemize}

Például az a feladat, hogy adjuk meg N ember közül a legmagasabbat. A legmagasabb ember megadása mit jelent? Adjuk meg a sorszámát, vagy a nevét, vagy a személyi számát, vagy a magasságát, esetleg ezek közül mindegyiket?
Tanulságként megállapíthatjuk, hogy a specifikációnak tartalmaznia kell a bemenő és a kimenő adatok leírását.

\begin{verbatim}
	Bemenet: 
	    N : az emberek száma,
	    A : a magasságukat tartalmazó sorozat.
	
	Kimenet:
	    MAX : a legmagasabb ember sorszáma.
	\end{verbatim}


Tudjuk-e, hogy a bemenő, illetve a kimenő változók milyen értéket vehetnek fel? Például az emberek magasságát milyen mértékegységben kell megadni? Az eredményül kapott sorszám milyen érték lehet: 1-től sorszámozunk, vagy 0-tól? Megállapíthatjuk tehát, hogy a specifikációban a bemeneti és a kimeneti változók értékhalmazát is meg kell adnunk.

\begin{verbatim}
	Bemenet:
	    N : az emberek száma, természetes szám;
	    A : a magasságukat tartalmazó sorozat, egész számok, amelyek a magasságot
	        centiméterben fejezik ki (a sorozatot 1-től N-ig indexeljük).
	Kimenet: 
	    MAX : a legmagasabb ember sorszáma, 1 és N közötti természetes szám.
	\end{verbatim}

Most már a bemenő és a kimenő változók értékhalmazát pontosan meghatároztuk, csupán az a probléma, hogy a feladatban használt fogalmakat és az eredmények kiszámítási szabályát nem definiáltuk. A specifikációnak tehát tartalmaznia kell a feladatban használt fogalmak definícióját, valamint az eredmény kiszámítási szabályát. Itt lehetne megadni a bemenő adatokra vonatkozó összefüggéseket is. A bemenő, illetve a kimenő adatokra kirótt feltételeket nevezzük előfeltételnek, illetve utófeltételnek. Az előfeltétel nagyon sokszor egy azonosan igaz állítás, azaz a bemenő adatok értékhalmazát semmilyen "külön” feltétellel nem szorítjuk meg.

\begin{verbatim}
	Bemenet: 
     	N : az emberek száma, természetes szám,
     	A : a magasságukat tartalmazó sorozat, egész számok, 
        	amelyek a magasságot centiméterben tartalmazzák (a sorozatot 1-tol N-ig indexeljük).
	Kimenet:	
     	MAX : a legmagasabb ember sorszáma, 1 és N közötti természetes szám.
	
	Elofeltétel: 
    	A[i]-k pozitívak.
	
	Utófeltétel: 	
	    MAX olyan 1 és N közötti szám, amelyre A[MAX] nagyobb vagy egyenlo, 	
	    mint a sorozat bármely eleme (az 1. és az N. között).
	\end{verbatim}

Újabb probléma merülhet fel bármelyik feladattal kapcsolatban: az eddigiek alapján a "várttól” lényegesen különböző – nyugodtan állíthatjuk: "banális” –, az elő- és utófeltételnek megfelelő megoldást is tudunk készíteni.

Itt persze arról a hallgatólagos (tehát még meg nem fogalmazott, ki nem mondott) feltételezésről van szó, hogy a bemeneti változók értéke nem változik meg. Ez sajnos nem feltétlenül igaz. A probléma megoldására kétféle utat követhetünk (a későbbiekben mindkettőt alkalmazni fogjuk):

\begin{itemize}
    \item	az utófeltételbe automatikusan beleértjük, hogy "és a bemeneti változók értéke nem változik meg”, s külön kiemeljük, ha mégsem így van;
    \item az elő- és az utófeltételt a program paramétereire fogalmazzuk meg, amelyeket formailag megkülönböztetünk a program változóitól, és emiatt nem a paraméterek fognak változni, hanem a programbeli változók (ebben az esetben természetesen az elő- és az utófeltételben meg kell fogalmazni a paraméterek és a megfelelő programbeli változók értékének azonosságát).
\end{itemize}

A második megoldásból az következik, hogy meg kell különböztetnünk egymástól a feladat és a program elő–, illetve utófeltételét! Ez hosszadalmasabbá – bár precízebbé – teszi a feladat megfogalmazását, emiatt ritkábban fogjuk alkalmazni.

Előfordulhat, hogy a feladat megfogalmazása alapján nem lehet egyértelműen meghatározni az eredményt, ugyanis az utófeltételnek megfelelő több megoldás is létezik. Ez a jelenség a feladat ún. nemdeterminisztikussága. Ehhez a nemdeterminisztikus feladathoz tehát determinisztikus programot kell írnunk, aminek az utófeltétele már nem engedheti meg a nem egyértelműséget, a nemdeterminisztikusságot. E probléma miatt tehát mindenképpen meg kell különböztetnünk egymástól a feladat és a program elő–, illetve utófeltételét!

\begin{verbatim}
	Bemenet: 
    	N : az emberek száma, természetes szám,
    	A : a magasságukat tartalmazó sorozat, egész számok, 
        	amelyek a magasságot centiméterben tartalmazzák (a sorozatot 1-tol N-ig indexeljük).
	Kimenet:	
    	MAX : a legmagasabb ember sorszáma, 1 és N közötti természetes szám.
	
	Elofeltétel: 
	   A[i]-k pozitívak.
	
   	Utófeltétel: 	
     	MAX olyan 1 és N közötti szám, amelyre A[MAX] nagyobb vagy egyenlo, 	
	    mint a sorozat bármely eleme (az 1. és az N. között).
	    
	Program utófeltétel: 	
	   	MAX olyan 1 és N közötti szám, amelyre A[MAX] nagyobb vagy egyenlo, 	
	   	mint a sorozat bármely eleme (az 1. és az N. között) és elotte
	   	nincs vele egyenlo.
	\end{verbatim}

Megállapíthatjuk ebből, hogy a program utófeltétele lehet szigorúbb, mint a feladaté, emellett az előfeltétele pedig lehet gyengébb.

Visszatekintve a specifikáció eddig "bejárt pályájára” egy szemléletes modellje körvonalazódik a feladatmegoldásnak. Nevezetesen: nyugodtan mondhatjuk azt, hogy a feladatot megoldó program egy olyan automatát határoz meg, amelynek pillanatnyi állapota a feladat paraméterei (a program változói) által "kifeszített” halmaz egy eleme. (E halmaz annyi dimenziós, ahány paraméterváltozója van a programnak; minden dimenzió egyik változó értékhalmaza. Tehát egy konkrét időpillanatban e "gép” állapota: a változóinak abban a pillanatban érvényes értékeinek együttese.) Ezt a halmazt nevezzük a program állapotterének. Amikor megfogalmazzuk az előfeltételt, akkor tulajdonképpen kihasítjuk ebből az állapottérből azt a részt (azt az altért), amelyből indítva elvárhatjuk az automatánktól (amit a megoldó program vezérel), hogy a helyes eredményt előállítja egy végállapotában. A végállapotot jelöltük ki az utófeltétellel.

Ezt a modellt elfogadva adódik még egy további megoldásra váró kérdés. Akkor ugyanis, amikor a programot írjuk, lépten-nyomon a részeredmények tárolására újabb és újabb változókat vezetünk be. Fölvetődik a kérdés: hogyan egyeztethető össze az imént elképzelt modellel? A válasz egyszerű: minden egyes újabb változó egy újabb dimenziót illeszt az eddig létrejött állapottérhez. Tehát a programozás folyamata – leegyszerűsítve a dolgot – nem áll másból, mint annak pontosításából, hogy hogyan is nézzen ki a megoldó automata állapottere (és persze: hogyan kell az egyik állapotból a másik állapotba jutnia). A feladatban szereplő paraméterek meghatározta "embrionális” állapotteret hívhatjuk paramétertérnek, ami csak altere a program valódi állapotterének. Ez is azt sugallja, hogy a feladat előfeltétele gyengébb (azaz az általa kijelölt állapothalmaz) lehet, mint a program előfeltétele.

Foglaljuk most össze, hogy melyek a specifikáció részei! Ezek az eddigiek, valamint a programra vonatkozó további megkötések lesznek.

\begin{enumerate}
    \item A feladat specifikálása
          \begin{itemize}
              \item a feladat szövege,
              \item a bemenő és a kimenő adatok elnevezése, értékhalmazának leírása,
              \item a feladat szövegében használt fogalmak definíciói (a fogalmak fölhasználásával),
              \item a bemenő adatokra felírt előfeltétel (a fogalmak fölhasználásával),
              \item a kimenő adatokra felírt utófeltétel.
          \end{itemize}
    \item A program specifikálása
          \begin{itemize}
              \item a bemenő és a kimenő adatok elnevezése, értékhalmazának leírása,
              \item (a feladat elő-, illetve utófeltételétől esetleg különböző) program elő- és utófeltétel,
              \item a feladat megfogalmazásában használt fogalmak definíciói.
          \end{itemize}
\end{enumerate}

\noindent Ezek az absztrakt specifikáció elemei. Az alábbiak másodlagos, mondhatjuk: technikai specifikáció részei:

\begin{itemize}
    \item a program környezetének leírása (számítógép, memória- és perifériaigény, programozási nyelv, szükséges fájlok stb.),
    \item a programmal szembeni egyéb követelmények (minőség, hatékonyság, hordozhatóság stb.).
\end{itemize}

\noindent A technikai specifikáció nélküli leírást a program szűkebb specifikációjának nevezik.\\

\noindent Progos specifikáció:\\\\
$A=(N : \mathbb{N}, A: \mathbb{N}^{1..N})$\\
$Ef=(\forall i \in {1..N} : A_{i}>0)$\\
$Uf=(Ef \land \forall i \in {1..N} : A_{MAX}>=A_{i} \land \forall j \in {1..MAX-1} : A_{i}<A_{MAX})$

\subsection{Tervezés}

A tervezés során algoritmusleíró eszközöket használunk, amelynek célja a feladatok megoldásának leírása programozási nyelvtől független nyelven. A programozási nyelvek ugyanis szigorú szintaxisúak, a tervezés szempontjából lényegtelen sallangokat tartalmaznak. A programozási nyelven történő tervezés esetén nehézzé válhat a program átírása más nyelvre, más gépre.

Többféle algoritmusleíró eszköz is létezik, mi tanulmányaink során a struktogramot alkalmaztuk.

A struktogram a programgráfot élek nélkül ábrázolja. Így egyetlen egy alapelem marad, a téglalap. Ezzel az alapelemmel építhetjük fel a szokásos strukturált alapszerkezeteket (és csak azokat).

\begin{figure}[H]
    \centering
    \includegraphics[width=0.7\linewidth]{img/stuki_alapszerk1}
    \caption{A struktogram összetett alapszerkezetei.}
    \label{fig:stuki_alapszerk1}
\end{figure}

Szekvenciánál a téglalapok egymás alatti sorrendje dönti el a végrehajtás sorrendjét. Az elágazásfeltétel igaz értéke esetén az i betűvel jelölt bal oldali téglalap utasítását kell végrehajtani, hamis értéke esetén pedig az n betűvel jelölt jobb oldali téglalapét. Ha az elágazás valamelyik ága üres, akkor a neki megfelelő téglalap is üres marad. A ciklus elöltesztelős, azaz a benne levő utasítást mindaddig végre kell hajtani, amíg a feltétel igaz.

Az utasítások helyén lehet egyetlen elemi utasítás, lehet a három algoritmikus szerkezet valamelyike, és lehet egy eljáráshívás. Ezt a leíróeszközt még többféle elemmel szokták bővíteni: az eljárásdefinícióval, a sokirányú elágazással, illetve a hátultesztelős ciklussal.

\begin{figure}[H]
    \centering
    \includegraphics[width=0.7\linewidth]{img/stuki_alapszerk2}
    \caption{A struktogram további összetett alapszerkezetei.}
    \label{fig:stuki_alapszerk2}
\end{figure}

\noindent Sokirányú elágazásnál azt az ágat kell végrehajtani, amelynek igaz értékű a feltétele (közülük minden esetben pontosan egy teljesülhet).\\

\noindent A lokális adatokat az eljárások téglalapjai mellett, az eljárásnév után sorolhatjuk fel.\\

\noindent Nézzük meg ezzel az eszközzel leírva a következő példát!\\

\noindent Feladat: N tanuló év végi átlagának ismeretében adjuk meg a jeles átlagú tanulók számát!

\begin{figure}[H]
    \centering
    \includegraphics[width=0.4\linewidth]{img/stuki_pelda}
    \caption{A példafeladat megoldása struktogrammal.}
    \label{fig:stuki_pelda}
\end{figure}

\subsection{Megvalósítás}

A.k.a. kódolás.
\subsection{Tesztelés}
A tesztelés célja, hogy minél több hibát megtaláljunk a programban. Ahhoz, hogy az összes hibát fölfedezzük, kézenfekvőnek tűnik a programot kipróbálni az összes lehetséges bemenő adattal. Ez azonban sajnos nem lehetséges.

\noindent Példaként tekintsük a következő - pszeudokóddal megadott - egyszerű programot:

\begin{verbatim}
		Program:
		    Változó A,B:Egész
		   	Be: A,B
		    Ki: A/B
		Program vége.
		\end{verbatim}

Mivel $2^{16}$ különböző értékű egész számot tudunk tárolni, ezért az összes lehetőség $2^{32}$, aminek a leírásához már 9 számjegyre van szükség. Ez rengeteg időt venne igénybe, így nem is járható út.

Ha ezt a programot olyan bemenő adatokkal próbáljuk ki, amelyben A=0 vagy B=1, akkor a program helyesen működik, a hibát nem tudjuk felfedezni. Ezután azt gondolhatnánk, hogy reménytelen helyzetbe kerültünk: hiszen minden lehetséges adattal nem tudjuk kipróbálni a programot; ha pedig kevesebbel próbáljuk ki, akkor lehet, hogy nem vesszük észre a hibákat. A helyzet azért nem ennyire rossz: célunk csak az lehet, hogy a tesztelést olyan módszerrel hajtsuk végre, amellyel a próbák száma erősen lecsökkenthető.\\

Tesztesetnek a be- és kimeneti adatok és feltételek együttes megadását nevezzük. Akkor tudunk a tesztelés eredményeiről bármit is mondani, ha van elképzelésünk arról, hogy adott bemenő adatra milyen eredményt várunk.\\

\noindent Fogalmazzuk meg a tesztelés alapelveit:
\begin{itemize}
    \item 	A jó teszteset az, ami nagy valószínűséggel egy még felfedetlen hibát mutat ki a programban. Például két szám legnagyobb közös osztóját számoló programot az [5,5] adatpár után a [6,6]-tal teljesen felesleges kipróbálni (ugyanis igencsak rafinált, valószínűtlen elírás esetén viselkedhet a program [6,6]-ra másként, mint [5,5]-re).

    \item 	A teszteset nemcsak bemenő adatokból, hanem a hozzájuk tartozó eredményekből is áll. Egyébként nem tudnánk a kapott eredmény helyes vagy hibás voltáról beszélni. A későbbi felhasználás miatt célszerű a teszteseteket is leírni a fejlesztői dokumentációban vagy egy önálló tesztelési jegyzőkönyvben.

    \item	A meg nem ismételhető tesztesetek kerülendők, feleslegesen megnövelik a program-tesztelés költségeit, idejét. Nem is beszélve arról a bosszúságról, amikor a programunk egy hibás futását nem tudjuk megismételni, és így a hiba is felfedetlen marad.

    \item	Teszteseteket mind az érvénytelen, mind az érvényes adatokra kell készíteni.

    \item 	Minden tesztesetből a lehető legtöbb információt "ki kell bányászni”, azaz minden teszteset eredményét alaposan végig kell vizsgálni. Ezzel jelentősen csökkenthető a szükséges próbák száma.

    \item	Egy próba eredményeinek vizsgálata során egyaránt fontos megállapítani, hogy miért nem valósít meg a program valamilyen funkciót, amit elvárunk tőle, illetve hogy miért végez olyan tevékenységeket is, amelyeket nem feltételeztünk róla.

    \item	A program tesztelését csak a program írójától különböző személy képes hatékonyan elvégezni. Ennek oka, hogy a tesztelés nem "jóindulatú” tevékenység, saját munkájának vizsgálatához mindenki úgy áll hozzá, hogy önkéntelenül jónak feltételezi.
\end{itemize}

A programtesztelés módszereit két csoportba oszthatjuk aszerint, hogy a tesztelés során végrehajtjuk-e a programot, vagy nem. Ha csak a program kódját vizsgáljuk, akkor statikus (erről nem esik több szó), ha a programot végre is hajtjuk a tesztelés során, akkor dinamikus tesztelésről beszélünk.

\paragraph{Dinamikus tesztelési módszerek}
A dinamikus tesztelési módszerek alapelve az, hogy a programot működés közben vizsgáljuk. Teszteseteket kétféle módon tudunk választani. Egy lehetőség az ún. feketedoboz-módszer, más néven adatvezérelt tesztelés. E módszer alkalmazásakor a tesztelő nem veszi figyelembe a program belső szerkezetét, pontosabban nem azt tekinti elsődleges szempontnak, hanem a teszteseteket a feladat meghatározás alapján választja meg.

A cél természetesen a lehető leghatékonyabb tesztelés elvégzése, azaz az összes hiba megtalálása a programban. Ez ugyan elvileg lehetséges, kimerítő bemenet tesztelést kell végrehajtani, a programot ki kell próbálni az összes lehetséges bemenő adatra. Ezzel a módszerrel azonban, mint korábban láttuk, mennyiségi akadályba ütközhetünk.

Egy másik lehetőség a fehérdoboz-módszer (logika vezérelt tesztelés). Ebben a módszerben a tesztesetek megválasztásánál lehetőség van a program belső szerkezetének figyelembevételére is.

A cél a program minél alaposabb tesztelése, erre jó módszer a kimerítő út tesztelés. Ez azt jelenti, hogy a programban az összes lehetséges utat végigjárjuk, azaz annyi tesztesetet hozunk létre, hogy ezt elérhessük vele. Az a probléma, hogy még viszonylag kis programok esetén is igen nagy lehet a tesztelési utak száma. Gondoljunk a ciklusokra! Sőt ezzel a módszerrel a hiányzó utakat nem lehet felderíteni.

Mivel sem a fehérdoboz-módszerrel, sem a feketedoboz-módszerrel nem lehetséges a kimerítő tesztelés, el kell fogadnunk, hogy nem tudjuk egyetlen program hibamentességét sem szavatolni. A további cél ezek után az összes lehetséges teszteset halmazából a lehető leghatékonyabb teszteset-csoport kiválasztása lehet.

A tesztelés hatékonyságát kétféle jellemző határozza meg: a tesztelés költsége és a felfedett hibák aránya. A leghatékonyabb teszteset-csoport tehát minimális költséggel maximális számú hibát fed fel.

A feketedoboz- és fehérdoboz-teszteken kívül még érdemes megemlíteni olyan speciális teszteket, amikor nem a helyesség belátása a cél. Ilyen pl. a stresszteszt (nagy adatmennyiséget hogyan bír kezelni a program, jól skálázódik-e) vagy a hatékonysági teszt (végrehajtási idő tesztelése).

\section{Az adattípus fogalma}

\subsection{Alapfogalmak, jelölések}

\begin{itemize}

    \item	$A^{*}$ az A-beli véges sorozatok halmazát, $A^{\infty}$ az A-beli végtelen sorozatok halmazát jelöli.
          A kettő uniója $A^{**} = A^{*} \cup A^{\infty}$ pedig az A-beli véges vagy végtelen sorozatok halmazát jelenti.

    \item	Legyen $R \subseteq A \times \mathbb{L}$ egy logikai reláció. Ekkor az R igazsághalmaza
          $\lceil R \rceil ::= R^{-1}(\left\{{igaz}\right\}) $

    \item	Legyen I egy véges halmaz és legyenek $A_{i}, i \in I$ tetszőlege véges vagy megszámolható, nem üres halmazok.
          Ekkor az $A = \underset{i \in I}{\times} A_{i}$ halmazt állapottérnek, az $A_{i}$ halmazokat pedig típusértékhalmazoknak nevezzük.

    \item	Feladat: feladatnak nevezünk egy $F \subseteq A \times A$ relációt.\\
          A feladat fenti definíciója természetes módon adódik abból, hogy a feladatot egy
          leképezésnek tekintjük az állapottéren, és az állapottér minden pontjára megmondjuk,
          hova kell belőle eljutni, ha egyáltalán el kell jutni belőle valahova.

    \item Program:\\
          Programnak nevezzük az $S \subseteq A \times A^{**}$ relációt, ha
          \begin{enumerate}
              \item	$\mathcal{D}_{S}=A$ (az állapottér minden pontjához rendel valamit, azaz a program minden pontban csinál valamit)
              \item	$\forall \alpha \in \mathcal{R}_{S} : \alpha = red(\alpha)$ (az állapot megváltozik, vagy ha mégsem, az az abnormális működés jele)
              \item	$\forall a \in A : \forall \alpha \in S(A) : |\alpha| \not = 0$ és $\alpha_{1}=a$
          \end{enumerate}
          \noindent A fenti definícióval a "működés” fogalmát akarjuk absztrakt módon megfogalmazni.

\end{itemize}

\subsection{Típusspecifikáció}

Először bevezetünk egy olyan fogalmat, amelyet arra használhatunk, hogy pontosan
leírjuk a követelményeinket egy típusértékhalmazzal és a rajta végezhető
műveletekkel szemben.\\

\noindent A $\mathcal{T_{S}}=(H,I_{S},\mathbb{F})$ hármast típusspecifikációnak nevezzük, ha
teljesülnek rá a következő feltételek:

\begin{enumerate}
    \item H az alaphalmaz,

    \item $I_{S} : H \to \mathbb{L} $ a specifikációs invariáns,

    \item $T_{\mathcal{T}} = \left\{ {(\mathcal{T},x) | x \in \lceil I_{S}} \rceil\right\}$ a típusértékhalmaz,

    \item $\mathbb{F} = \left\{ {F_{1},F_{2},...,F_{n}}\right\}$ a típusműveletek specifikációja, ahol\\
          $\forall i \in [1..n]: F_{i} \subseteq A_{i} \times A_{i}$, $A_{i} = A_{i_{1}} \times ... \times A_{i_{n_{i}}}$ úgy,\\
          hogy $\exists j \in [1..n_{i}]: A_{i_{j}} = T_{\mathcal{T}} $
\end{enumerate}

Az alaphalmaz és az invariáns tulajdonság segítségével azt fogalmazzuk meg,
hogy mi az a halmaz, $T_{\mathcal{T}}$, amelynek elemeivel foglalkozni akarunk, míg a feladatok
halmazával azt írjuk le, hogy ezekkel az elemekkel milyen műveletek végezhetők
el.

Az állapottér definíciójában szereplő típusértékhalmazok mind ilyen típusspecifikációban
vannak definiálva. Az állapottér egy komponensét egy program csak a típusműveleteken keresztül változtathatja meg.
\subsection{Típus}

Vizsgáljuk meg, hogy a típusspecifikációban leírt követelményeket hogyan valósítjuk
meg.\\

\noindent A $\mathcal{T}=(\rho,I,\mathbb{S})$ hármast típusnak nevezzük, ha

\begin{enumerate}
    \item $\rho \subseteq E^{*} \times T$ a reprezentációs függvény (reláció),\\
          T a típusértékhalmaz,\\
          E az elemi típusértékhalmaz
    \item $I : E^{*} \to \mathbb{L} $ típusinvariáns
    \item $\mathbb{S} = \left\{ {S_{1},S_{2},...,S_{m}}\right\}$, ahol\\
          $\forall i \in [1..m]: S_{i} \subseteq B_{i} \times B_{i}^{**}$ program, $B_{i} = B_{i_{1}} \times ... \times B_{i_{m_{i}}}$ úgy,\\
          hogy $\exists j \in [1..m_{i}]: B_{i_{j}} = E^{*}$ és $\not \exists j \in [1..m_{i}]: B_{i_{j}} = T$
\end{enumerate}

A típus első két komponense az absztrakt típusértékek reprezentációját írja le, míg a programhalmaz a típusműveletek implementációját tartalmazza. Az elemi típusértékhalmaz lehet egy tetszőleges másik típus típusértékhalmaza vagy egy, valamilyen módon definiált legfeljebb megszámolható halmaz.

\subsection{Invariáns}

Az invariáns lényege, hogy ezt a tulajdonságot soha nem sérthetjük meg. Például halmaz típus esetén nem szabad, hogy megsérüljön
az az invariáns tulajdonság, hogy egy halmazban egy elem csak egyszer fordulhat elő.

\subsection{Reprezentáció}

Azt, hogy egy típust milyen típusok segítségével, milyen módszerrel, stb., valósítottunk meg, reprezentációnak nevezzük. Például
egy verem típust meg lehet valósítani tömb segítségével, de láncolt listával is.

A reprezentáció a típusspecifikáció típusértékhalmazának leképezése a konkrét típusban, amit a reprezentációs függvény ad meg.

\subsection{Implementáció}

Az implementáció a típusspecifikáció típusműveleteinek megvalósítása a konkrét típus programhalmaza által.

Az implementáció során a típus megvalósításakor a típusértékhalmaz megadását követően definiálni kell a típusműveleteket. Ahogyan a modellben is, a gyakorlatban is az állapottér változásait a program csak a típusműveleteken keresztül végezheti el.

\subsection{Emészthetőbb módon}

\begin{figure}[H]
    \centering
    \includegraphics[width=0.7\linewidth]{img/adattipus}
    \caption{Adattípus}
    \label{fig:adattipus}
\end{figure}

\begin{figure}[H]
    \centering
    \includegraphics[width=0.7\linewidth]{img/adattipus_pelda}
    \caption{BigNumber példa}
    \label{fig:adattipus_pelda}
\end{figure}

\section{A visszavezetés módszere}

A programozási feladatok megoldásához különböző programozási mintákat, ún. programozási tételeket használunk fel, ezekre vezetjük vissza
a megoldást.\\

\noindent Lépései:
\begin{enumerate}
    \item	Megsejtjük a feladatot megoldó programozási tételt.
    \item	Specifikáljuk a feladatot a programozási tétel jelöléseivel.
    \item	Megadjuk a programozási tétel és a feladat közötti eltéréseket:
          \begin{itemize}
              \item	intervallum határok: konkrét érték vagy kifejezés (pl. $[1..\frac{n}{2}]$),
                    a típusuk a $\mathbb{Z}$ helyett lehet annak valamely része (pl. $\mathbb{N}$)

              \item	$\beta:[m..n] \to \mathbb{L}$ és/vagy $f:[m..n] \to H$ konkrét megfelelői

              \item	a H megfelelője a szükséges művelettel
                    \begin{itemize}
                        \item	$(H,>)$ helyett pl. $(\mathbb{Z},>)$ vagy $(\mathbb{Z},<)$
                        \item	$(H,+)$ helyett pl. $(\mathbb{Z},+)$ vagy $(\mathbb{R},*)$
                    \end{itemize}
              \item	a változók átnevezése
          \end{itemize}
    \item	A különbségek figyelembe vételével a tétel algoritmusából elkészítjük a konkrét feladatot megoldó algoritmust.
\end{enumerate}

\section{Felsoroló, a felsoroló típus specifikációja}

A gyűjtemény (tároló, kollekció, iterált) egy olyan adat
(objektum), amely valamilyen elemek tárolására alkalmas.
\begin{itemize}
    \item	Ilyenek az összetett szerkezetű, de különösen az iterált szerkezetű
          típusok értékei: halmaz, sorozat (verem, sor, fájl), fa, gráf

    \item	De vannak úgynevezett virtuális gyűjtemények is: pl. egész számok
          egy intervallumának elemei, vagy egy természetes szám prím-osztói
\end{itemize}

\noindent Egy gyűjtemény feldolgozásán a benne levő elemek
feldolgozását értjük.
\begin{itemize}
    \item	Keressük a halmaz legnagyobb elemét!
    \item	Hány negatív szám van egy számsorozatban?
    \item	Válogassuk ki egy fa leveleiben elhelyezett értékeket!
    \item	Járjuk be az [m .. n] intervallum minden második elemét visszafelé!
    \item	Adjuk össze az n természetes szám prím-osztóit!
\end{itemize}

\noindent A feldolgozni kívánt elemek felsorolását (bejárását) az alábbi
műveletekkel szabványosítjuk:
\begin{itemize}
    \item	First() : Rááll a felsorolás első elemére, azaz elkezdi a felsorolást
    \item	Next() : Rááll az elkezdett felsorolás soron következő elemére
    \item	End() : Mutatja, ha a felsorolás végére értünk
    \item	Current() : Visszaadja a felsorolás aktuális elemét
\end{itemize}

Egy felsorolásnak különböző állapotai vannak (indulásra kész,
folyamatban van, befejeződött), és a műveletek csak bizonyos
állapotokban értelmezhetők (máshol a hatásuk nem definiált).
A feldolgozó algoritmus garantálja,	hogy a felsoroló műveletek mindig
megfelelő állapotban kerüljenek	végrehajtásra.

\begin{figure}[H]
    \centering
    \includegraphics[width=0.4\linewidth]{img/felsorolas_stuki}
    \caption{A felsorolás algoritmusa}
    \label{fig:felsorolas_stuki}
\end{figure}

A felsorolást sohasem a felsorolni kívánt gyűjtemény, hanem
egy külön felsoroló objektum végzi.

\begin{figure}[H]
    \centering
    \includegraphics[width=0.7\linewidth]{img/felsorolo_speci}
    \caption{A felsoroló objektum és típusa}
    \label{fig:felsorolas_stuki}
\end{figure}

\section{Felsorolóra megfogalmazott programozási tételek}

\includepdf[pages={1-2}]{progtetel_felsorolo.pdf}

\section{Nevezetes gyűjtemények felsorolói}

\subsection{Intervallum}
\begin{figure}[H]
    \centering
    \includegraphics[width=0.7\linewidth]{img/felsorolo_intervallum}
    \caption{Intervallum felsorolója}
    \label{fig:felsorolo_intervallum}
\end{figure}

\subsection{Tömb}
Itt két különböző tömbtípus felsorolóját mutatjuk be: az egydimenziós (vektor) és a kétdimenziós tömbét (mátrix).

\begin{figure}[H]
    \centering
    \includegraphics[width=0.7\linewidth]{img/felsorolo_vektor}
    \caption{Vektor felsorolója}
    \label{fig:felsorolo_vektor}
\end{figure}

\begin{figure}[H]
    \centering
    \includegraphics[width=0.7\linewidth]{img/felsorolo_matrix}
    \caption{Mátrix sorfolytonos felsorolója}
    \label{fig:felsorolo_matrix}
\end{figure}

Megjegyzés: a felsorolás történhet másképpen is, például vektor esetén végezhetjük a felsorolást visszafelé, a tömb végétől kezdve, vagy mátrixnál alkalmazhatunk pl. oszlopfolytonos bejárást.

\subsection{Sorozat}
\begin{figure}[H]
    \centering
    \includegraphics[width=0.7\linewidth]{img/felsorolo_sorozat}
    \caption{Sorozat felsorolója}
    \label{fig:felsorolo_sorozat}
\end{figure}

\subsection{Halmaz}
\begin{figure}[H]
    \centering
    \includegraphics[width=0.7\linewidth]{img/felsorolo_halmaz}
    \caption{Halmaz felsorolója}
    \label{fig:felsorolo_halmaz}
\end{figure}

\subsection{Szekvenciális inputfájl}
\begin{figure}[H]
    \centering
    \includegraphics[width=0.7\linewidth]{img/felsorolo_seqin}
    \caption{Szekvenciális inputfájl felsorolója}
    \label{fig:felsorolo_seqin}
\end{figure}

\section{Programozási tételekkel készült programok tesztelése}
Három féle tesztelési stratégia van, ezek az alábbiak.
\begin {enumerate}
	\item Fekete doboz: a feladat (specifikációja) alapján felírt tesztesetek.
		\begin {enumerate}
			\item Az előfeltételt kielégítő (érvényes), illetve azt megszegő (érvénytelen)
tesztadatokkal felírt tesztesetek.
			\item Az utófeltétel alapján (?) generált tesztesetek vizsgálata.
		\end {enumerate}
	\item Fehér doboz: a kód alapján felírt tesztesetek.
		\begin {enumerate}
			\item Algoritmus minden utasításának kipróbálása
			\item Algoritmus minden vezérlési csomópontjának (elágazás, ciklus) kipróbálása
		\end {enumerate}
	\item Szürke doboz: végrehajtható specifikáció által előrevetített algoritmus
működését ellenőrző tesztesetek.
		\begin {enumerate}
			\item Ha a végrehajtható specifikáció ráadásul egy algoritmus-mintából származik,
akkor az algoritmus-minta szokásos teszteseteit kell megvizsgálni.
		\end {enumerate}
\end {enumerate}
A programozási tételek algoritmus-minták, ezért itt azok teszteseteivel fogunk foglalkozni.
\begin{figure}[H]
    \centering
    \includegraphics[width=0.7\linewidth]{img/algoritmus-mintak_tesztesetei}
    \caption{Algoritmus-minták tesztesetei}
    \label{fig:algoritmus-mintak_tesztesetei}
\end{figure}

Példafeladat programozási tételre (programozási-mintára) építve:
\begin{figure}[H]
    \centering
    \includegraphics[width=0.7\linewidth]{img/programozasi_tetelre_epulo_feladat}
    \caption{Feladat programozási tételre építve}
    \label{fig:programozasi_tetelre_epulo_feladat}
\end{figure}

\begin{figure}[H]
    \centering
    \includegraphics[width=0.7\linewidth]{img/tesztesetek}
    \caption{Példa tesztesetek}
    \label{fig:tesztesetek}
\end{figure}

\end{document}