Kolos

#include <iostream>
#include "conio.h"
#include "math.h"
#include "time.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;
}