all

#include <iostream>
#include "conio.h"
#include "math.h"
#include "time.h"
#include <windows.h>

float t[50];
float tab[100];

using namespace std;

void zmienne();
void zmienne1();
void zmienne2();
void zmienne3();
void zmienne4();
void zmienne5();
void zmienne6();
void zmienne7();
void zmienne8();
void zmienne9();
void zmienne10();
void petle();
void petle1();
void petle2();
void petle3();
void petle4();
void petle5();
void petle6();
void petle7();
void petle8();
void petle9();
void tablice();
float wypisanie (float t[50]);
float przesuniecie (float t[50]);
float napelnienie (float tab[100]);
float mindod(float tab[100]);

//-------------------------------------------------------------

int main()
{
        int n;
        do
        {
        cout << "Wybierz z ktorej listy chcesz zrobic zadanie" << endl;


        cout << "1 -  Zmienne proste, wejscie/wyjscie, instrukcje warunkowe " << endl
                 << "2 -  Petle oraz proste algorytmy iteracyjne "<< endl
                 << "3 -  Typ tablicowy, przetwarzanie wiekszych iloœci danych" << endl
                 << "4 -  Koniec programu" << endl;
        cout << "Twoj wybor : " ;
        cin >> n;
        switch(n)
        {
        case 1 : zmienne();  break;
        case 2 : petle();    break;
        case 3 : tablice();  break;
        default : cout << "Nie wybrales zadnej z dostepnych opcji" ;
        }

        }
        while (n != 4);

}

//------------------------------------------------------------------
void zmienne()
{
        int n;
        do
        {
                cout << "Ktore zadanie chcesz wykonac?" << endl;

                cout << "1  - Napisz program wczytujacy 4 liczby calkowite i sprawdzajacy " << endl
                         << "ile jest wsrod nich powtorzen (dwojek, trojek lub czworek)" << endl
                         << "2  - Napisz program wczytujacy znaki z klawiatury do momentu" << endl
                         << "az da sie z nich zlozyc slowo  'tato' " << endl
                         << "3  - Napisz program wczytujacy 4 liczby rzeczywiste i wyznaczajacy " << endl
                         << "srednia arytmetyczna z liczb pozostalych po odrzuceniu dwoch najmniejszych wartosci " << endl
                         << "4  - Napisz program wczytujacy z klawiatury 3 liczby rzeczywiste a nastêpnie " << endl
                         << "wyswietlajacy je w kolejnosci rosnacych wartosci " << endl
                         << "5  - Napisz program, który wczyta z klawiatury 4 liczby rzeczywiste, a nastêpnie" << endl
                         << "wyswietli informacje ile z nich ma wartsci ujemne " << endl
                         << "6  - Napisz program, który policzy pierwiastki trojmianu kwadratowego " << endl
                         << "A*x2 + B*x + C = 0,  o wspo³czynnikach A, B, C wprowadzanych z klawiatury" << endl
                         << "7  - Napisz program wczytujacy 4 liczby ca³kowite z klawiatury i sprawdzajacy" << endl
                         << "ile par (liczb o tych samych wartosciach) mozna z nich zlozyc " << endl
                         << "8  - Napisz program wczytujacy 4 dowolne znaki z klawiatury i sprawdzajacy" << endl
                         << "czy da sie z nich ulozyæ slowo  'bajt' " << endl
                         << "9  - Napisz program wczytujacy 4 dowolne znaki z klawiatury i sprawdzajacy" << endl
                         << "czy wiecej z nich jest literami czy cyframi" << endl
                         << "10 - Napisz program wczytujacy 4 liczby rzeczywiste i wyznaczajacy" << endl
                         << "srednia arytmetyczna z liczb pozostalych po odrzuceniu wartosci skrajnych (tzn. maksimum i minimum) " << endl
                         << "11 - Powrot do pierwszego menu" << endl ;
                cout << "Twoj wybor : " ;
                cin >> n;
                cout << endl;
                switch(n)
                {
                case 1 : zmienne1(); break;
                case 2 : zmienne2(); break;
                case 3 : zmienne3(); break;
                case 4 : zmienne4(); break;
                case 5 : zmienne5(); break;
                case 6 : zmienne6(); break;
                case 7 : zmienne7(); break;
                case 8 : zmienne8(); break;
                case 9 : zmienne9(); break;
                case 10 : zmienne10(); break;
                default: cout <<"Nie wybrales zadnego polecenia!" << endl ; break;
                }

        }
        while(n != 11);
}

//---------------------------------------------------------------

void petle()
{
        int n;
        do
        {
                cout << "Ktore zadanie chcesz wykonac?" << endl;

                cout << "1  - Napisz funkcje drukujaca na ekranie kolejne N liczb nieparzystych" << endl
                         <<     "podzielnych przez 7. Wartosc N powinna byc parametrem " << endl
                         << "2  - Napisz funkcje sprawdzajaca numerycznie ile par" << endl
                         << "liczb calkowitych z przedzialu [a,b] spelnia nierownosc x2 +y2 <= 50" << endl
                         << "Wartosci a,b powinny byæ zadawane jako parametry funkcji " << endl
                         << "3  - Napisz funkcje wczytujaca znaki z klawiatury tak dlugo " << endl
                         << "az zostana podane trzy kolejne znaki o takich samych kodach. " << endl
                         << "Na zakonczenie program powinien wyswietlic podsumowanie" << endl
                         << "czy wiecej nacisnietych klawiszy bylo 'literami' czy 'cyframi'. " << endl
                         << "4  - Napisz funkcje sumujaca kwadraty wszystkich liczb nieparzystych" << endl
                         << "z przedzialu [-N, N ]. Wartosc N powinna byæ parametrem wejsciowym tej funkcji." << endl
                         << "5  - Policz iloczyn wszystkich liczb nieparzystych" << endl
                         << "z domknietego przedzialu liczb calkowitych [ pierwsza  ..  ostatnia ]. " << endl
                         << "Wartosci zmiennych pierwsza, ostatnia nalezy wczytac z klawiatury. " << endl
                         << "6  - Napisz program wyznaczajacy numerycznie sume n wyrazow ciagu" << endl
                         << "o elementach: a0 = 1; a1=sin(1); a2=sin(2); .... ; an=sin(n)" << endl
                         << "7  - Napisz funkcje sprawdzajaca numerycznie jakie liczby calkowite" << endl
                         << "z przedzialu [1,1000] spelniaja rownanie: (x^2 / (50 - x)) - sin(x) >= 0" << endl
                         << "8  - Napisz funkcje sumujaca wszystkie liczby parzyste z przedzialu [-N, N ]." << endl
                         << "Wartosc N powinna byc parametrem wejsciowym tej funkcji. " << endl
                         << "9  - Napisz funkcje wyœwietlajaca na ekranie wszystkie mozliwe" << endl
                         << "4-ro literowe palindromy (wyrazy jednakowo czytane od przodu i od tylu)." << endl
                         << "10 - Powrot do pierwszego menu" << endl ;
                cout << "Twoj wybor : " ;
                cin >> n;
                cout << endl;
                switch(n)
                {

                case 1 : petle1();  break;
                case 2 : petle2();  break;
                case 3 : petle3();  break;
                case 4 : petle4();  break;
                case 5 : petle5();  break;
                case 6 : petle6();  break;
                case 7 : petle7();  break;
                case 8 : petle8();  break;
                case 9 : petle9();  break;
                default: cout <<"Nie wybrales zadnego polecenia!" << endl ; break;
                }

        }
        while(n != 10);
}

//-------------------------------------------------------------------
void tablice()
{
int n;
        do
        {
        cout << "Ktore zadanie chcesz wykonac?" << endl;


        cout << "1 - Napisz funkcje przesuwajaca ca³a zawartosc tablicy 50 liczb calkowitych" << endl
                 << "'o jedno miejsce w gore' (tzn. pierwszy element na druga pozycje, " << endl
                 << "element o indeksie 'i' na pozycje o indeksie “i+1”, " << endl
                 << "a element ostatni na pierwsza pozycje w tablicy) " << endl
                 << "2 -  Napisz funkcje, ktora sprawdzi czy tablica N liczb rzeczywistych " << endl
                 << "(podawana jako parametr funkcji) ma symetryczna zawartosc " << endl
                 << "tzn. czy element pierwszy jest równy ostatniemu, drugi – przedostatniemu, itd." << endl
                 << "3 - Napisz funkcje otrzymuj¹ca jako parametr wejœciowy 100 -elementowa " << endl
                 << "tablice liczb ca³kowitych Tab. Funkcja powinna zwracaæ wartoœæ minimalna " << endl
                 << "z dodatnich elementow tablicy Tab." << endl
                 << "4 -  Napisz funkcje sprawdzajaca ile ró¿nych liter 'a'-'z'" << endl
                 << "wystepuje wiêcej ni¿ jeden raz w 200-elementowej tablicy znakow " << endl
                 << "podawanej jako dane wejsciowe tej funkcji." << endl
                 << "5 - Napisz funkcje wyswietlajaca w odwrotnej kolejnoœci (od ostatniego do pierwszego)" << endl
                 << "zawartosc 20-elementowej tablicy TAB liczb typu calkowitego." << endl
                 << "6 - Koniec programu" << endl;

        cout << "Twoj wybor : " ;
        cin >> n;
        switch(n)
        {
        case 1 : wypisanie(&t[50]); przesuniecie(&t[50]);   break;
        case 2 :   break;
        case 3 :
        napelnienie(&tab[100]);
        cout << "Najmniejsza dodatnie liczba tablicy: " <<  mindod(tab) << endl;  break;
        case 4 :   break;
        case 5 :   break;
        default : cout << "Nie wybrales zadnej z dostepnych opcji" ;
        }

        }
        while (n != 6);
}
//-------------------------------------------------------------------
void zmienne1()
{
        /*
        Napisz program wczytuj¹cy 4 liczby ca³kowite i sprawdzaj¹cy
        ile jest wœród nich powtórzeñ (dwójek, trójek lub czwórek).
        */
        int a,b,c,d;
        cout << "Podaj 4 liczby" << endl;
        cin >> a >> b >> c >> d;
        if( a == b == c == d)
        {
                cout << "Wszystkie liczby sa takie same" << endl;
        }
        else if(a == b == c || a == b == d || a == c == d || b == c == d)
        {
                cout << "  3 z 4 liczb sa takie same" << endl;
        }
        else if(a == b || a == c || a == d || b == c || b == d || c == d)
        {
                cout << "2 z 4 liczb sa takie same" << endl;
        }
        else
        cout << "Brak powtorzen" << endl;
        system("pause");
}

//----------------------------------------------------------------------------------------------

void zmienne2()
{
        /*
        Napisz program wczytuj¹cy znaki z klawiatury
        do momentu a¿ da siê z nich z³o¿yæ s³owo “ tato ” .
        */
        char klawisz;
        float t = 0;
        float a = 0;
        float o = 0;
        cout << "Podawaj znaki" << endl;
        while(t < 2 || a < 1 || o < 1)
        {
                klawisz = getche();
                if(klawisz == 't')
                { t++; }
                if(klawisz == 'a')
                {a++;}
                if(klawisz == 'o')
                {o++;}
                cout << endl ;
        }
        cout <<"Z podanych liter da sie ulozyc slowo tato wiec konczymy" << endl;
        system("pause");
}

//-----------------------------------------------------------------------------------------------

void zmienne3()
{
        /*
        Napisz program wczytuj¹cy 4 liczby rzeczywiste i wyznaczaj¹cy œredni¹
        arytmetyczn¹ z liczb pozosta³ych po odrzuceniu dwóch najmniejszych wartoœci.
        */
        double a, b, c, d;
        double srednia;

        cout << "Podaj 4 liczby rzeczywiste" << endl ;
        cin >> a >> b >> c >> d;
        if(a == b == c == d)
        {
                srednia = (a + b + c + d) / 4;
        }
        else if( d >= a && d >= b && c >= a && c >= b)
        {
                srednia = (d + c) / 2;
        }
        else if(d >= a && d >= c &&  b >= a && b >= c )
        {
                srednia = (b + d) / 2;
        }
        else if(b >= a && b >= d && c >= a && c >= d)
        {
                srednia = (b + c) / 2;
        }
        else if(a >= b && a >= c && d >= b && d >= c)
        {
                srednia = (a + d) / 2;
        }
        else if(a >= b && a >= d && c >= b && c >= d)
        {
                srednia = (a + c) / 2;
        }
        else if(a >= c && a >= d && b >= c && b >= d)
        {
                srednia = (a + b) / 2;
        }
        cout << "Srednia po odrzuceniu dwoch najmniejszych liczb wynosi: " << srednia << endl;
        system("pause");
}

//------------------------------------------------------------------------------------------

void zmienne4 ()
{
        /*
        Napisz program wczytuj¹cy z klawiatury 3 liczby rzeczywiste
a nastêpnie wyœwietlaj¹cy je w kolejnoœci rosn¹cych wartoœci.
        */

        double a, b, c;


        cout << "Podaj 3 liczby rzeczywiste" << endl ;
        cin >> a >> b >> c;

        if(a == b == c || c >= b && c >= a && b >= a)
        {
                cout << a << b << c;
        }
        else if(b >= a && b >= c && c >= a)
        {
                cout << a << c << b;
        }
        else if(c >= a && c >= b && a >= b)
        {
                cout << b << a << c;
        }
        else if(a >= b && a >= c && c >= b)
        {
                cout << b << c << a;
        }
        else if(b >= a && b >= c && a >= c)
        {
                cout << c << a << b;
        }
        else if(a >= b && a >= c && b >= c)
        {
                cout << c << b << a;
        }
        cout << endl;

        system("pause");


}

//----------------------------------------------------------------------------

void zmienne5()
{
        /*
        Napisz program, który wczyta z klawiatury 4 liczby rzeczywiste,
        a nastêpnie wyœwietli informacjê ile z nich ma wartoœci ujemne.
        */

        double a, b, c, d;
        cout << "Podaj 4 liczby rzeczywiste" << endl;
        cin >> a >> b >> c >> d;

        if(a < 0 && b < 0 && c < 0 && d < 0)
        {
                cout <<"Podales 4 liczby ujemne" << endl;
        }
        else if(a < 0 && b < 0 && c < 0 || a < 0 && b < 0 && d <0 || b < 0 && c < 0 && d < 0)
        {
                cout << "Podales 3 liczby ujemne" << endl;
        }
        else if(a < 0 && b < 0 || a < 0 && c < 0 || a < 0 && d < 0 || b < 0 && c <0 || b < 0 && d < 0 || c < 0 && d < 0)
        {
                cout << "Podales 2 liczby ujemne" << endl;
        }
        else if(a < 0 || b < 0 || c < 0 || d < 0)
        {
                cout <<"Podales 1 liczbe ujemna" << endl;
        }
        else
        {
                cout << "Nie podales liczb ujemnych" << endl;
        }
        system("pause");
        }

//-----------------------------------------------------------------------------------------------------------------

void zmienne6()
{
        /*
        Napisz program, który policzy pierwiastki trójmianu kwadratowego
A*x2 + B*x + C = 0,  o wspó³czynnikach A, B, C wprowadzanych z klawiatury
*/

        double A, B, C, delta, x1, x2;
        cout << "Program obliczajacy pierwiastki rownania kwadratowego Ax^2+Bx+C\n" ;
        cout << "Podaj ile wynosi A: " ; cin >> A ;
        cout << "Podaj ile wynosi B: " ; cin >> B ;
        cout << "Podal ile wynosi C: " ; cin >> C ;
        delta=(B*B)-(4*A*C);
        while(A==0)
        {
        cout << "To nie jest rownanie kwadratowe!\n" ;
        cout << "Podaj inne A: "; cin >> A ;
        }
                if(delta < 0)
                {
                cout << "To rownianie nie ma rozwiazania! \n" ;
                }
                if(delta == 0)
                {
                x1 = -B / (2 * A);
                cout << "To rownanie ma 1 rozwiazanie x= " << x1 << endl;
                }
                if(delta > 0)
                {
                 x1=(-B - sqrt(delta)) / (2 * A);
             x2=(-B + sqrt(delta))/(2 * A);
                 cout << "To rownianie ma 2 roziazanie x1= "<< x1 <<" i x2= " << x2 << endl;
                }
                cout << endl;

}

//---------------------------------------------------------------------------------------

void zmienne7 ()
{
        /*
        Napisz program wczytuj¹cy 4 liczby ca³kowite z klawiatury
        i sprawdzaj¹cy ile par (liczb o tych samych wartoœciach) mo¿na z nich z³o¿yæ.
        */

        int a,b,c,d;
        cout << "Podaj 4 liczby calkowite" << endl;
        cin >> a >> b >> c >> d;

        if(a == b && a == c  && a == d)
        {
                cout << "Z podanych liczb mozna stworzyc 8 par liczb o tych samych wartosciach" ;
        }
        else if (a == b && a == c || b == c && c == d)
        {
                cout << "Z podanych liczb mozna utworzyc 3 pary liczb o tych samych wartosciach" ;
        }
        else if (a == b && c == d)
        {
                cout << "Z podanych liczb mozna utworzyc 4 liczby o tych samych wartosciach" ;
        }
        else
        {
                cout << "Z podanych liczb nie mozna stworzyc zadnych par liczb o tych samych wartosciach" ;
        }
        cout << endl;
        system("pause");
}

//----------------------------------------------------------------------------------------

void zmienne8 ()
{
        /*
        Napisz program wczytuj¹cy 4 dowolne znaki z klawiatury
        i sprawdzaj¹cy czy da siê z nich u³o¿yæ s³owo “ bajt ”.

        */
        char klawisz;
        float b = 0;
        float a = 0;
        float j = 0;
        float t = 0;
        cout << "Podawaj znaki" << endl;
        while(t < 1 || a < 1 || j < 1 || b < 1)
        {
                klawisz = getche();
                if(klawisz == 't')
                { t++; }
                if(klawisz == 'a')
                {a++;}
                if(klawisz == 'j')
                {j++;}
                if(klawisz == 'b')
                {b++;}
                cout << endl ;
        }
        cout <<"Z podanych liter da sie ulozyc slowo tato wiec konczymy" << endl;
        system("pause");
}

//----------------------------------------------------------------------------------------------

void zmienne9()
{
        /*
        Napisz program wczytuj¹cy 4 dowolne znaki z klawiatury
        i sprawdzaj¹cy czy wiêcej z nich jest literami czy cyframi.
        */
        int klawisz=0;
        float ilosc = 0;
        float litery = 0;
        float cyfry = 0;
        while(ilosc < 4)
        {
                cout << "Nacisnij jakis klawisz\n";
                klawisz = getche();
                if('a'<=klawisz && klawisz<='z')
                        litery++;
                else if('A'<=klawisz && klawisz <='Z')
                litery++;
                else if('0'<=klawisz && klawisz<='9')
                        cyfry++;
                ilosc++;
                cout << endl;

        }
        if(litery > cyfry)
        {
                cout <<"Podales wiecej liter";
        }
        else if(litery == cyfry)
        {
                cout <<"Podales tyle samo liter co cyfr";
        }
        else
                cout << "podales wiecej cyfr";
        cout << endl;
        system("pause");
}


//---------------------------------------------------------------------------------

void zmienne10 ()
{
        /*
        Napisz program wczytuj¹cy 4 liczby rzeczywiste
        i wyznaczaj¹cy œredni¹ arytmetyczn¹ z liczb pozosta³ych
        po odrzuceniu wartoœci skrajnych (tzn. maksimum i minimum).
        */

        double a, b, c, d;
        cout << "Podaj 4 liczby rzeczywiste" << endl;
        cin >> a >> b >> c >> d;
        double max;
        double min;
        double srednia = 0;

        max = a;
        if(max < b) max = b;
        if(max < c) max = c;
        if(max < d) max = d;

        min = a;
        if(min > b) min = b;
        if(min > c) min = c;
        if(min > d) min = d;

        srednia = (a+b+c+d-min-max) / 2;
        cout <<" Srednia po odrzuceniu wartosci skrajnych wynosi: " << srednia << endl;
        system("pause");
}

//------------------------------------------------------------------------------------

void petle1()
{
        /*
        Napisz funkcjê drukuj¹c¹ na ekranie kolejne N liczb nieparzystych
        podzielnych przez 7. Wartoœæ N powinna byæ parametrem.
        */

        int n ;
        int i = 0;
        float ilosc = 0;
        cout << "Podaj ile liczb nieparzystych podzielnych przez 7 wyswietlic: ";
        cin >> n;
        while(ilosc < n)
        {
                i +=7;
                if(i % 2 != 0)
                {
                cout << i << endl;
                ilosc++;
                }
        }
        system("pause");
}

//-----------------------------------------------------------------------------

void petle2()
{
        /*
        Napisz funkcjê sprawdzaj¹c¹ numerycznie ile par
        liczb ca³kowitych z przedzia³u [a,b] spe³nia nierównoœæ x2 +y2 <= 50 .
        Wartoœci a,b powinny byæ zadawane jako parametry funkcji.
        */

        int a,b ;
        float ilosc = 0;
        cout << "Podaj w jakim przedziale spradzic czy rowanie ma rozwiazania" << endl ;
        cin >> a >> b;
        for(int x = a; x < b+1; x++)
        {
                for(int y = a; y < b+1; y++)
                {
                        if((x * x) + (y * y) <= 50 )
                        {
                                ilosc++;
                                cout <<"Znaleziono pare x = " << x << " i y = " << y << endl;
                        }
                }

        }
        cout << "Lacznie znaleziono: " << ilosc << " par" << endl;
        system("pause");
}

//---------------------------------------------------------------------------------

void petle3()
{
        /*

        Napisz funkcjê wczytuj¹c¹ znaki z klawiatury tak d³ugo,
        a¿ zostan¹ podane trzy kolejne znaki o takich samych kodach.
        Na zakoñczenie program powinien wyœwietliæ podsumowanie
        czy wiêcej naciœniêtych klawiszy by³o "literami" czy "cyframi".

        */
                char n;
        char klawisz;
        cout << "Podawaj kolejne znaki" << endl;
        float powtorzenia = 0;
        while(powtorzenia < 3)

        {
                klawisz = getche();
                if(powtorzenia == 0)
                {
                        n = klawisz;
                }
                if(klawisz == n)
                {
                        n = klawisz;
                        powtorzenia++;
                }
                if(klawisz != n)
                {
                        powtorzenia = 0;
                }
        }
        system("pause");
}

//------------------------------------------------------------------
void petle4()
{
        /*

        Napisz funkcjê sumuj¹c¹ kwadraty wszystkich liczb nieparzystych
        z przedzia³u [-N, N ]. Wartoœæ N powinna byæ parametrem wejœciowym tej funkcji.

        */
        int N;
        float suma = 0;
        cout << "Podaj wartosc parametru wejsciowego N" << endl;
        cin >> N;
        for(int i = -N; i < N+1; i++)
        {
                if(i % 2 != 0)
                {
                suma += (i*i);
                }
        }


        cout << "Suma kwadratow wszystkich liczb nieparzystych y tego przedzialu wynosi: " << suma << endl;
        system("pause");
}

//-----------------------------------------------------------------------------------------------------------

void petle5()
{
        /*

        Policz iloczyn wszystkich liczb nieparzystych
        z domkniêtego przedzia³u liczb ca³kowitych [ pierwsza  ..  ostatnia ].
        Wartoœci zmiennych pierwsza, ostatnia nale¿y wczytaæ z klawiatury.

        */

        int a,b ;
        float iloczyn = 1;
        cout << "Podaj ile wynosci poczatek i koniec przedzialu " << endl;
        cout << "Poczatek: " ;
        cin >> a;
        cout << "Koniec: ";
        cin >> b;
        for(int i = a; i < b+1; i++)
        {
                if(i % 2 != 0)
                {
                        iloczyn *= i;
                }
        }
        cout << "Iloczyn liczb nieparzystych z podanego przedzialy wynosi : " << iloczyn << endl;
        system("pause");
}

//------------------------------------------------------------------------------------------------------------

void petle6()
{
        /*
        Napisz program wyznaczaj¹cy numerycznie sumê n wyrazów ci¹gu
        o elementach: a0 = 1; a1=sin(1); a2=sin(2); .... ; an=sin(n)
        */

        int n;
        float suma = 1;
        cout << "Podaj ilosc wyrazu ciagu: " ;
        cin >> n;
        for(double i = 1; i < n + 1; i++)
        {
        suma += sin(i);
        }
        cout << "Suma elementow tego ciagu wynosi: " << suma;
        system("pause");
}

//----------------------------------------------------------------

void petle7()
{
        /*

        Napisz funkcjê sprawdzaj¹c¹ numerycznie jakie liczby ca³kowite
z przedzia³u [1,1000] spe³niaj¹ równanie: (x^2 / (50 - x)) - sin(x) >= 0

        */
        cout << "Rozwiazaniami rownania (x^2 / (50 - x)) - sin(x) >= 0 sa liczby: " << endl;
        for(double x = 1; x < 1001; x++)
        {
                if((x*x / (50 - x)) - sin(x) >= 0)
                {
                        cout << x << " ";
                }
        }

        cout << endl;
        system("pause");
}

//------------------------------------------------------------------

void petle8()
{
        /*
        Napisz funkcjê sumuj¹c¹ wszystkie liczby parzyste z przedzia³u [-N, N ].
        Wartoœæ N powinna byæ parametrem wejœciowym tej funkcji.
        */

        int N;
        float suma = 0;
        cout << "Podaj wartosc parametru wejsciowego N: " ;
        cin >> N;
        for(int i = -N; i < N + 1; i++)
        {
                if(i % N == 0)
                {
                        suma += i;
                }
        }
        cout << "Suma elementow parzystych tego przedzialu wynosi: " << suma << endl;
        system("pause");
        }

//----------------------------------------------------------------------------------------

void petle9()
{
        /*

        Napisz funkcjê wyœwietlaj¹c¹ na ekranie wszystkie mo¿liwe
        4-ro literowe palindromy (wyrazy jednakowo czytane od przodu i od ty³u

        */

        cout << "Funkcja wyswietlajaca wszystkie mozliwe 4-ro literowe palindromy" << endl;
        int i,j;
    for(i=97;i<123;i++)
    {
        for(j=97;j<123;j++)
                {
     cout << (char)i <<(char)j << (char)j <<(char)i << "\t";
                }
        }
        cout << endl;
        system("pause");
}

//-------------------------------------------------------------------------------------------

float wypisanie (float t[50])
{
        srand(time(0));
        for(int i = 0; i < 50; i++)
        {
                t[i] = (rand() % 80) - 30;
        }
        for(int i = 0; i < 50; i++)
        {
                cout << "t [" << i << "] = "<<t[i];
                cout << endl;
        }
        cout << endl;

        return t[50];

}

//---------------------------------------------------------------------
float przesuniecie(float t[50])
{
        for(int i = 0; i < 50; i++)
        {
                if(i == 0)
                {
                        cout << " t [0] = " << t[1] << endl;
                }
                if(i > 0 && i < 49)
                {
                t[i] = t[i+1];
                cout << "t [" << i << "] = " << t[i];
                cout << endl;
                }
                if(i == 49)
                {
                        t[49] = t[0];
                        cout << "t [49] = " << t[0] ;
                        cout << endl;
                }
        }
        system("pause");
        return t[50];
}

//-----------------------------------------------------------------------------------------

float napelnienie(float tab[100])
{
        for(int i = 0; i < 100; i++)
        {
                tab[i] = 2*i;
        }
        return tab[100];
}

//------------------------------------------------------------------------------

float mindod(float tab[100])
{
        float min = 9e6;
        for(int i = 0; i < 100; i++)
        {
                if(tab[i] < min)
                        min = tab[i];
        }
        return min;
}