#include<stdio.h>
#include<math.h>
#include<stdbool.h>
#include<stdlib.h>
#include<wchar.h>
#include<wctype.h>
#include<ctype.h>
#include<string.h>

///cw 7_2_1
Zdefiniuj strukturę trojkat przechowującą długości boków trójkąta. Napisz funkcję, która otrzymuje jako argument zmienną typu struct trojkat, i zwraca jako wartość obwód trójkąta przekazanego w argumencie.
struct trojkat{
double a,b,c;
};

double obwod(struct trojkat t){
return t.a+t.b+t.c;
}

double pole(struct trojkat t){
    double p=obwod(t)/2;
return pow(p*(p-t.a)*(p-t.b)*(p-t.c),0.5);
}

///cw 7_2_2Napisz funkcję, która otrzymuje jako argumenty zmienną troj1 typu struct trojkat zdefiniowanego w zadaniu 7.2.1 oraz zmienną troj2 wskaźnik na zmienną typu struct trojkat, i przepisuje za je zawartość zmiennej troj1 do zmiennej wskazywanej przez troj2.

void przepisz(struct trojkat t1, struct trojkat *t2){
    *t2=t1;
}

Zdefiniuj strukturę punkt służącą do przechowywania współrzędnych punktów w trójwymiarowej przestrzeni kartezjańskiej.Napisz funkcję, która otrzymuje jako argumenty tablicę tab o argumentach typu struct punkt oraz jej rozmiar, i zwraca jako wartość najmniejszą spośród odległości pomiędzy punktami przechowywanymi w tablicy tab. Zakładamy, że otrzymana w argumencie tablica
ma co najmniej dwa argumenty.

struct punkt{
double x,y,z;
};

double minimum(struct punkt tab[], int n){
int i,j;
double pom;
double min=sqrt(pow(tab[1].x-tab[0].x,2)
                +pow(tab[1].y-tab[0].y,2)+pow(tab[1].z-tab[0].z,2));
for(i=0;i<n-1;i++)
{
    for(j=i+1;j<n;j++)
    {
        pom=sqrt(pow(tab[j].x-tab[i].x,2)
                +pow(tab[j].y-tab[i].y,2)+pow(tab[j].z-tab[i].z,2));
    }
    if(pom<min)
    {
        min=pom;
    }
}
return min;
}

Zdefiniuj unię super_int, w której będzie można przechowywać zarówno zmienne typu int, jak i unsigned int

union super_int{
int i;
unsigned int u;
};

///Listy bez glowy
Napisz funkcję utworz zwracającą wskaźnik do pustej listy bez głowy o elementach typu element.
struct element{
int i;
struct element *next;
};

struct element *utworz(){
return NULL;
}

Napisz funkcję wyczysc, która dostaje jako argument wskaźnik do pierwszego elementu listy wskaźnikowej bezgłowy o elementach typu element i usuwa wszystkie elementy listy
void wyczysc(struct element* Lista){
struct element *wsk=Lista;
while(Lista!=NULL){
    Lista=Lista->next;
    free(wsk);
    wsk=Lista;
}
}

Napisz funkcję dodaj o dwóch argumentach Lista typu element* oraz a typu int zwracającą wskaźnik do typu element. Funkcja powinna dodawać na początek listy reprezentowanej przez zmienną Lista
nowy element o wartości a pola i oraz zwracać wskaźnik do pierwszego
elementu tak powiększonej listy.

struct element * dodajnapoczatek(struct element* Lista, int a){
struct element *wsk=malloc(sizeof(struct element));
wsk->i=a;
wsk->next=Lista;
return wsk;
}

Napisz funkcję dodajk o dwóch argumentach Lista typu element* i a typu int zwracającą wskaźnik do typu element. Funkcja powinna dodawać na koniec listy reprezentowanej przez zmienną Lista nowy element o wartości a pola i oraz zwracać wskaźnik do pierwszego elementu tak powiększonej listy.

struct element *dodajnakoniec(struct element * Lista, int a){
struct element *wsk;
if(Lista==NULL)
{
    Lista=wsk=malloc(sizeof(struct element));
}
else
    wsk=Lista;
while(wsk->next!=NULL)
{
    wsk=wsk->next;
}
wsk->next=malloc(sizeof(struct element));
wsk=wsk->next;
wsk->i=a;
wsk->next=NULL;
return Lista;
}

Napisz funkcję dodajw o trzech argumentach Lista i elem typu element* oraz a typu int zwracającą wskaźnik do typu element. Funkcja powinna dodawać element o wartości a pola i do listy reprezentowanej przez zmienną Lista na miejscu tuż za elementem wskazywanym przez elem. W przypadku, gdy elem jest równy NULL funkcja powinna wstawić nowy element na początek listy. Funkcja powinna zwrócić jako wartość wskaźnik do pierwszego elementu powiększonej listy.

struct element * dodajodpowiednio(struct element* Lista,
                                struct element* elem, int a){
struct element *wsk=malloc(sizeof(struct element));
wsk->i=a;
if(elem==NULL)
    {
wsk->next=Lista;
Lista=wsk;
}
else
{
    wsk->next=elem->next;
    elem->next=wsk;
}
return Lista;
}

Napisz funkcję znajdz o dwóch argumentach Lista typu element* i a typu int zwracającą wskaźnik do typu element. Funkcja powinna sprawdzać, czy na liście reprezentowanej przez zmienną
Lista znajduje się element o polu i równym a. Jeżeli tak, to funkcja powinna zwrócić wskaźnik do tego elementu. W przeciwnym wypadku funkcja powinna zwrócić wartość NULL.

struct element * znajdz(struct element * Lista, int a){
while((Lista!=NULL)&&(Lista->i!=a))
{
    Lista=Lista->next;
}
return Lista;
}

Napisz funkcję usun o dwóch argumentach Lista typu element* i a typu int zwracającą wskaźnik do typu element. Funkcja powinna usuwać z listy reprezentowanej przez zmienną Lista element o wartości a pola i (o ile taki element znajduje się na liście) oraz zwracać wskaźnik do pierwszego elementu zmodyfikowanej listy (jeżeli po usunięciu elementu lista będzie pusta, to funkcja powinna zwrócić wartość NULL).

struct element * usun(struct element * Lista, int a){
    struct element *wsk,*wsk2;
    if (Lista==NULL)
    {
        return Lista;
    }
    wsk=Lista;
    if(Lista->i==a)
    {
        Lista=Lista->next;
        free(wsk);
    }
    else{
while((wsk->next!=NULL)&&(wsk->next->i!=a))
      {
          wsk=wsk->next;
      }
      if(wsk->next!=NULL){
        wsk2=wsk->next;
        wsk->next=wsk2->next;
        free(wsk2);
      }
return Lista;
}
}

Napisz funkcję usunw o dwóch argumentach Lista i elem typu element* i zwracającą wskaźnik do typu element. Funkcja powinna usuwać z listy reprezentowanej przez zmienną Lista element wskazywany przez elem oraz zwracać wskaźnik do pierwszego elementu
zmodyfikowanej listy (jeżeli po usunięciu elementu lista będzie pusta, to funkcja powinna zwrócić wartość NULL). Dla elem równego NULL funkcja usunw nie powinna nic robić

struct element *usunwybrany(struct element* Lista,
                            struct element *elem){
struct element *wsk,*wsk2;
if(Lista==NULL)
{
    return Lista;
}
wsk=Lista;
                       if(Lista==elem){
                        Lista=Lista->next;
                        free(wsk);
                        return Lista;
                       }
                    while((wsk->next!=NULL)&&(wsk->next!=elem))
                        wsk=wsk->next;
                    if(wsk->next!=NULL)
                    {
                        wsk2=wsk->next;
                        wsk->next=wsk2->next;
                        free(wsk2);
                    }
                    return Lista;
                            };

Napisz funkcję usunw2 o dwóch argumentach Lista i elem typu
7.3. Listy jednokierunkowe 43
element* i zwracającą wskaźnik do typu element. Funkcja powinna usuwać z listy reprezentowanej przez zmienną Lista element wskazywany przez elem->next oraz zwracać wskaźnik do pierwszego elementu zmodyfikowanej listy (jeżeli po usunięciu elementu lista będzie pusta, to funkcja powinna zwrócić wartość NULL). Dla elem równego NULL funkcja powinna usunąć pierwszy element listy (o ile taki istnieje). Dla elem różnego od NULL i elem->next równego NULL funkcja usunw2 nie powinna nic robić.

struct element *usunwybrany2(struct element* Lista,
                            struct element *elem){
struct element *wsk;
if(Lista==NULL)
{
    return Lista;
}
                       if(Lista==elem){
                            wsk=Lista;
                        Lista=Lista->next;
                       }
                       else if(elem->next==NULL)
                    {
                        return Lista;
                    }
                    else
                    {
                        wsk=elem->next;
                        elem->next=wsk->next;
                    }
                    free(wsk);
                    return Lista;
                            }

///Listy z glowa
Napisz funkcję utworz tworzącą pustą listę z głową o elementach typu element i zwracającą jako wartość wskaźnik do głowy utworzonej listy

struct element *utworzzglowa(){
    struct element *wsk=malloc(sizeof(struct element));
    wsk->next=NULL;
return wsk;
}

Napisz funkcję wyczysc, która dostaje jako argument wskaźnik do listy wskaźnikowej z głową o elementach typu element i usuwa wszystkie elementy listy (razem z głową).

void wyczysczglowa(struct element* Lista){
struct element *wsk=Lista->next;
Lista=wsk;
while(Lista!=NULL){
    Lista=Lista->next;
    free(wsk);
    wsk=Lista;
}
}

Napisz funkcję dodaj o dwóch argumentach Lista typu element* i a typu int. Funkcja powinna dodawać na początek listy reprezentowanej przez zmienną Lista nowy element o wartości a pola i.

void dodajnapoczatekzglowa(struct element *Lista,int a){
struct element *wsk=malloc(sizeof(struct element));
wsk->i=a;
wsk->next=Lista->next;
Lista->next=wsk;
}

Napisz funkcję dodajk o dwóch argumentach Lista typu element*
i a typu int. Funkcja powinna dodawać na koniec listy reprezentowanej przez zmienną Lista nowy element o wartości a pola i.

void dodajnakonieczglowa(struct element *Lista,int a){
struct element *wsk=Lista;
while(wsk->next!=NULL)
{
    wsk=wsk->next;
}
wsk->next=malloc(sizeof(struct element));
wsk=wsk->next;
wsk->i=a;
wsk->next=NULL;
}

///Pozostale zadania z list jednokierunkowych
Napisz funkcję zeruj, która dostaje jako argument listę wskaźnikową o elementach typu element i nadaje wartość 0 polom i we wszystkich elementach listy. Napisz dwie wersje funkcji: dla list z głową
i dla list bez głowy.

///bezglowy
void zeruj(struct element * Lista){
while(Lista!=NULL){
 Lista->i=0;
 Lista=Lista->next;
}
}

///z glowa
void zerujzglowa(struct element *Lista){
while(Lista->next!=NULL){
 Lista=Lista->next;
 Lista->i=0;
}
}

///mozna tez modyfikujac algorytm bez glowy
void zerujzglowa2(struct element * Lista){
    Lista=Lista->next;
while(Lista!=NULL){
 Lista->i=0;
 Lista=Lista->next;
}
}

Napisz funkcję bezwzględna, która dostaje jako argument listę wskaźnikową o elementach typu element i zapisuje do pól i wszystkich
elementów listy wartość bezwzględną ich pierwotnej wartości. Napisz
dwie wersje funkcji: dla list z głową i dla list bez głowy.

///bezglowy
void bezwzgledna(struct element * Lista){
while(Lista!=NULL){
 Lista->i=abs(Lista->i);
 Lista=Lista->next;
}
}

Zdefiniuj strukturę trojka mającą służyć jako typ elementu jednokierunkowej listy wskaźnikowej przechowującej trójki dodatnich liczb
całkowitych a. b, c. Napisz funkcję pitagoras, która dostaje w argumencie listę wskaźnikową o elementach typu trojka i usuwa z otrzymanej listy wszystkie elementy nieprzechowujące trójek pitagorejskich (czyli takich, że a^2 + b^2 = c^2). Napisz dwie wersje funkcji: dla list z głową i dla list bez głowy. W wersji dla list bez głowy funkcja powinna zwracać wskaźnik do pierwszego elementu przekształconej listy. Jeżeli wynikowa lista bez głowy będzie pusta, funkcja powinna zwrócić NULL.

struct trojka{
unsigned int a,b,c;
struct trojka * next;
};

bool czyspelnia(struct trojka *e){
if(e->a*e->a+e->b*e->b==e->c*e->c)
{
    return true;
}
else
{
    return false;
}
}

///wersja bez glowy
struct trojka * pitagoras(struct trojka*Lista){
struct trojka * pom,*pom2;
while((Lista!=NULL)&&(!czyspelnia(Lista))){
    pom=Lista;
    Lista=Lista->next;
    free(pom);
}
if(Lista==NULL)
{
    return NULL;
}
pom=Lista;
while(pom->next!=NULL){
    if(czyspelnia(pom->next))
    {
        pom=pom->next;
    }
    else
    {
        pom2=pom->next;
        pom->next=pom2->next;
        free(pom2);
    }
}
return Lista;
}

///z glowa
void pitagoraszglowa(struct trojka * Lista){
struct trojka* pom;
while(Lista->next!=NULL){
    if(czyspelnia(Lista->next))
    {
        Lista=Lista->next;
    }
    else
    {
        pom=Lista->next;
        Lista->next=pom->next;
        free(pom);
    }
}
}
Napisz funkcję suma, która dostaje jako argument listę wskaźnikową o elementach typu element i zwraca jako wartość sumę pól  Listy jednokierunkowe 45
ze wszystkich elementów listy. Napisz dwie wersje funkcji: dla list z głową i dla list bez głowy
int suma(struct element *Lista){
int sum=0;
while(Lista!=NULL){
    sum=sum+Lista->i;
    Lista=Lista->next;
}
return sum;
}

int sumazglowa(struct element * Lista){
int sum=0;
Lista=Lista->next;
while(Lista!=NULL){
    sum=sum+Lista->i;
    Lista=Lista->next;
}
}

) Napisz funkcję minimum, która dostaje jako argument listę wskaźnikową o elementach typu element i zwraca jako wartość najmniejszą spośród wartości pól i elementów listy. Napisz dwie wersje funkcji: dla list z głową i dla list bez głowy

int minimumbezglowy(struct element * Lista){
int min=Lista->i;
while(Lista!=NULL){
    if(Lista->i<min)
    {
        min=Lista->i;
    }
    Lista=Lista->next;
}
return min;
}

int minimumzglowa(struct element * Lista){
int min=Lista->next->i;
while(Lista!=NULL){
        Lista=Lista->next;
    if(Lista->i<min)
    {
        min=Lista->i;
    }
}
return min;
}

///wyswietl
void wyswietl(struct element *Lista){
while(Lista!=NULL){
    printf("%d\n",Lista->i);
    Lista=Lista->next;
}
}

///wczytaj


int main(){
    struct element *Lista=utworz();
dodajnakoniec(Lista,4);
dodajnakoniec(Lista,7);
dodajnakoniec(Lista,5);
dodajnakoniec(Lista,2);
printf("%d",Lista->i);
wyswietl(Lista);
return 0;
}