Teza

//1. Simple lists as Stacks
#include<iostream>
using namespace std;

class element{
private:
    int info;
    class element *next;
public:
    element(){ next=NULL; }
    int set_value(int this_value){ info=this_value; }
    int reveal_value(){ return info; }
    int set_next(element *next_element){ next=next_element; }
    element *reveal_next(){ return next; }
};

class some_list{
private:
    element *start,*curent,*sfarsit;
    int lungime;
public:
    some_list(){
        start=curent=sfarsit=NULL;
        lungime=0;
    }
    int reveal_lenght(){ return lungime; }
    int set_lenght(int new_lenght){ lungime=new_lenght; }
    int print_me(){
        element *walker=start;
        cout<<"START : ";
        if (reveal_lenght()>=1){
            while(walker->reveal_next()!=NULL){
                cout<<walker->reveal_value()<<" -> ";
                walker=walker->reveal_next();
            }
            cout<<walker->reveal_value(); cout<<" : STOP ";
            return 1;
        }
        cout<<" : STOP "<<endl;
        return 1;
    }
    int set_start(element *new_start){ start=new_start; }
    int set_curent(element *new_curent){ curent=new_curent; }
    int set_sfarsit(element *new_sfarsit){ sfarsit=new_sfarsit; }
    element *reveal_sfarsit(){ return sfarsit; }
    element *reveal_start(){ return start; }
};

class some_stack:public some_list{
public:
    some_stack(){
        set_start(NULL);
        set_curent(NULL);
        set_sfarsit(NULL);
        set_lenght(0);
    }
    int push(int value);
    int pop(int*old_value);
    int stack_empty();
};
some_stack L;
int main(){
int old_top;
L.push(13);
L.push(17);
L.print_me();
L.pop(&old_top);
cout<<endl<<old_top<<endl;
L.print_me();
return 1;
}

int some_stack::stack_empty(){
    if(reveal_lenght()>=1) return 0;
    return 1;
}
int some_stack::push(int value){
    element *new_one=new element;
    if(new_one==NULL) return 0;
    new_one->set_value(value);
    new_one->set_next(NULL);
    if(stack_empty()){
        set_start(new_one);
        set_curent(new_one);
        set_sfarsit(new_one);
        set_lenght(1);
    }
    else{
        reveal_sfarsit()->set_next(new_one);
        set_curent(new_one);
        set_sfarsit(new_one);
        set_lenght(reveal_lenght()+1);
    }
    return 1;
}
int some_stack::pop(int *old_value){
    if(stack_empty()) return 0;
    if (reveal_lenght()==1){
        *old_value=reveal_sfarsit()->reveal_value();
        delete reveal_sfarsit();
        set_lenght(0);
        set_start(NULL);
        set_curent(NULL);
        set_sfarsit(NULL);
        return 1;
    }
    else{
        element *walker=reveal_start();
        while(walker->reveal_next()!=reveal_sfarsit()) walker=walker->reveal_next();
        *old_value=reveal_sfarsit()->reveal_value();
        delete reveal_sfarsit();
        set_lenght(reveal_lenght()-1);
        set_sfarsit(walker);
        set_curent(walker);
        walker->set_next(NULL);
        return 1;
    }
}






//2. Simple lists as Queue
#include<iostream>
using namespace std;

class element{
private:
    int info;
    class element *next;
public:
    element(){ next=NULL; }
    int set_value(int this_value){ info=this_value; }
    int reveal_value(){ return info; }
    int set_next(element *next_element){ next=next_element; }
    element *reveal_next(){ return next; }
};

class some_list{
private:
    element *start,*curent,*sfarsit;
    int lungime;
public:
    some_list(){
        start=curent=sfarsit=NULL;
        lungime=0;
    }
    int reveal_lenght(){ return lungime; }
    int set_lenght(int new_lenght){ lungime=new_lenght; }
    int print_me(){
        element *walker=start;
        cout<<"START : ";
        if (reveal_lenght()>=1){
            while(walker->reveal_next()!=NULL){
                cout<<walker->reveal_value()<<" -> ";
                walker=walker->reveal_next();
            }
            cout<<walker->reveal_value(); cout<<" : STOP ";
            return 1;
        }
        cout<<" : STOP "<<endl;
        return 1;
    }
    int set_start(element *new_start){ start=new_start; }
    int set_curent(element *new_curent){ curent=new_curent; }
    int set_sfarsit(element *new_sfarsit){ sfarsit=new_sfarsit; }
    element *reveal_sfarsit(){ return sfarsit; }
    element *reveal_start(){ return start; }
};
class some_queue:public some_list{
public:
    some_queue(){
        set_start(NULL);
        set_curent(NULL);
        set_sfarsit(NULL);
        set_lenght(0);
    }
    int add(int value);
    int serve(int*old_value);
    int queue_empty();
};
some_queue L;
int main(){
int old_start;
L.add(13);
L.add(17);
L.print_me();
L.serve(&old_start);
cout<<endl<<old_start<<endl;
L.print_me();
return 1;
}
int some_queue::queue_empty(){
    if(reveal_lenght()>=1) return 0;
    return 1;
}
int some_queue::add(int value){
    element *new_one=new element;
    if(new_one==NULL) return 0;
    new_one->set_value(value);
    new_one->set_next(NULL);
    if(queue_empty()){
        set_start(new_one);
        set_curent(new_one);
        set_sfarsit(new_one);
        set_lenght(1);
    }
    else{
        reveal_sfarsit()->set_next(new_one);
        set_curent(new_one);
        set_sfarsit(new_one);
        set_lenght(reveal_lenght()+1);
    }
    return 1;
}

int some_queue::serve(int *old_value){
    if(queue_empty()) return 0;
    if (reveal_lenght()==1){
        *old_value=reveal_sfarsit()->reveal_value();
        delete reveal_sfarsit();
        set_lenght(0);
        set_start(NULL);
        set_curent(NULL);
        set_sfarsit(NULL);
        return 1;
    }
    else{
        *old_value=reveal_start()->reveal_value();
        element *new_start=reveal_start()->reveal_next();
        delete reveal_start();
        set_start(new_start);
        set_lenght(reveal_lenght()-1);
        return 1;
    }
}






//3. Simple lists as NoRestriction
#include<iostream>
using namespace std;

class element{
    private: int info;
             class element *next;
    public: element(){ next=NULL;};
            ~element(){ };
            int set_value(int this_value){ info=this_value; }
            int reveal_value(){ return info; }
            int set_next(element *next_element){ next=next_element; }
            element *reveal_next(){ return next; }
};

class some_list{
    private: element *start,*curent,*sfarsit;
             int lungime;
    public: some_list(){ start=curent=sfarsit=NULL;lungime=0; }
            int set_lenght(int new_lenght){ lungime=new_lenght; }
            int set_start(element *new_start){ start=new_start; }
            int set_curent(element *new_curent){ curent=new_curent; }
            int set_end(element *new_sfarsit){ sfarsit=new_sfarsit; }
            element *reveal_end(){ return sfarsit; }
            element *reveal_start(){ return start; }
            int reveal_lenght(){ return lungime; }
            element *reveal_current(){ return curent; }
            int print_me(){ cout<<endl;element *walker=start; cout<<"START : ";
                int counter=reveal_lenght();
                if (counter>=1){while(counter>=2){
                cout<<walker->reveal_value()<<" -> ";
                walker=walker->reveal_next();counter--;}
                cout<<walker->reveal_value();}
                cout<<" : STOP ";return 1;}
};

class no_strategy:public some_list{
    public: int find_value(int this_value);
            int addsome ( int value, int direction );
            int delsome(int *old_value,int direction);
            int list_empty();
};
no_strategy L;

int main(){
    int old;
    L.addsome(1,1);
    L.addsome(2,1);
    L.addsome(3,1);
    L.print_me();
    L.find_value(2);
    L.delsome(&old,0);
    L.print_me();
}

int no_strategy::list_empty(){
    if(reveal_lenght()>=1) return 0;
    return 1;
}

int  no_strategy::find_value(int this_value){
    element *walker=reveal_start();
    if (reveal_lenght()>=1) {
        while(walker->reveal_next()!=NULL){
            if (walker->reveal_value()==this_value) break ;
                walker=walker->reveal_next();
        }
        if (walker->reveal_value()==this_value) {
            set_curent(walker);
            return 1;
        }
    }
    else return 0;
}

int no_strategy::addsome(int value,int direction){
    element *new_one=new element;
        new_one->set_value(value);
        if (list_empty()){
            new_one->set_next(NULL);
            set_lenght(1);
            set_curent(new_one);
            set_start(new_one);
            set_end(new_one);
            return -1;
        }
        if(direction==0){
            if (reveal_current()==reveal_start()){
                new_one->set_next(reveal_current());
                set_curent(new_one);
                set_start(new_one);
                set_lenght(reveal_lenght()+1);
                return -1;
            }
            else{
                element *walker=reveal_start();
                while(walker->reveal_next()!=reveal_current()) walker=walker->reveal_next();
                new_one->set_next(reveal_current());
                walker->set_next(new_one);
                set_lenght(reveal_lenght()+1);
                return 1;
            }
        }
        else{
            if(reveal_current()->reveal_next()==NULL){
                if (new_one==NULL) return 0;
                    new_one->set_next(NULL);
                    reveal_end()->set_next(new_one);
                    set_curent(new_one);
                    set_end(new_one);
                    set_lenght(reveal_lenght()+1);
                return -1;
            }
            else{
                new_one->set_next(reveal_current()->reveal_next());
                reveal_current()->set_next(new_one);
                set_curent(new_one);
                set_lenght(reveal_lenght()+1);
                return 1;
            }
        }
}

int no_strategy::delsome(int *old_value,int direction){
    if(list_empty()) return 0;
    if(reveal_lenght()==1){
        *old_value=reveal_current()->reveal_value();
        delete reveal_current();
        set_curent(NULL);
        set_start(NULL);
        set_end(NULL);
        set_lenght(0);
        return -1;
    }
    if(direction==0){
        if (reveal_current()==reveal_start()) {
            *old_value=reveal_current()->reveal_value();
             element *aux,*aux1;
             int old_lenght;
             old_lenght=reveal_lenght();
             aux1=reveal_current();
             aux=reveal_current();
             aux=aux->reveal_next();
             set_curent(aux);
             set_start(aux);
             set_lenght(old_lenght-1);
             delete aux1;
             return 1;
        }
        if (reveal_current()==reveal_end()) {
            *old_value=reveal_current()->reveal_value();
            int old_lenght;
            old_lenght=reveal_lenght();
            element *walker=reveal_start();
            while(walker->reveal_next()!=reveal_end())
                walker=walker->reveal_next();
            element *aux=new element;
            aux=reveal_current();
            set_curent(walker);
            set_end(walker);
            set_lenght(old_lenght-1);
            delete aux;
            return 1;
        }
        *old_value=reveal_current()->reveal_value();
        int old_lenght;
        old_lenght=reveal_lenght();
        element *walker=reveal_start();
        while(walker->reveal_next()!=reveal_current()) walker=walker->reveal_next();
        element *some_fork=reveal_current()->reveal_next();
        delete reveal_current();
        walker->set_next(some_fork);
        set_curent(walker);
        set_lenght(old_lenght-1);
    }
    else{
        if(reveal_current()==reveal_start()){
        *old_value=reveal_current()->reveal_value();
        element *dead_one=reveal_start();
        set_curent(reveal_start()->reveal_next());
        set_start(reveal_current());
        set_lenght(reveal_lenght()-1);
        delete dead_one;
        return 1;
    }
    if(reveal_current()==reveal_end()){
        *old_value=reveal_current()->reveal_value();
        element *aux=new element;
        aux=reveal_current();
        element *walker=reveal_start();
        while(walker->reveal_next()!=reveal_current())
            walker=walker->reveal_next();
        set_curent(walker);
        set_end(walker);
        set_lenght(reveal_lenght()-1);
        delete aux;
        return 1;
    }
    else{
        *old_value=reveal_current()->reveal_value();
        element *aux=new element;
        aux=reveal_current();
        element *walker=reveal_start();
        while(walker->reveal_next()!=reveal_current())
            walker=walker->reveal_next();
        element *some_fork=reveal_current()->reveal_next();
        walker->set_next(some_fork);
        set_curent(some_fork);
        set_lenght(reveal_lenght()-1);
        delete aux;
        return 1;
    }
    }
}




//4. program #include<iostream>
using namespace std;
class element
{
    private:
        int info;
        class element *next;
    public:
        element(){ next=NULL; }
        int set_value(int this_value){ info=this_value; }
        int reveal_value(){ return info; }
        int set_next(element *next_element){ next=next_element; }
        element *reveal_next(){ return next; }
};
class some_list
{
    private:
        element *start,*curent,*sfarsit;
        int lungime;
    public:
        some_list()
        {
            start=curent=sfarsit=NULL;
            lungime=0;
        }
    int set_lenght(int new_lenght){ lungime=new_lenght; }
    int set_start(element *new_start){ start=new_start; }
    int set_curent(element *new_curent){ curent=new_curent; }
    int set_sfarsit(element *new_sfarsit){ sfarsit=new_sfarsit; }
    element *reveal_sfarsit(){ return sfarsit; }
    int reveal_lenght(){ return lungime; }
    element *reveal_current(){ return curent; }
    int print_me(){
        cout<<endl;
        element *walker=start;
        cout<<" START : ";
        if (reveal_lenght()>=1){
            while(walker->reveal_next()!=NULL){
                cout<<walker->reveal_value()<<" -> ";
                walker=walker->reveal_next();
            }
            cout<<walker->reveal_value();
            cout<<" : STOP ";
            return 1;
        }
        cout<<" : STOP ";return 0;
    }
    element *reveal_start(){ return start; }
};
class some_stack:public some_list
{
    public:
        some_stack()
            {
            set_start(NULL);
            set_curent(NULL);
            set_sfarsit(NULL);
            set_lenght(0);
            };
    int push(int value);
    int stack_empty();
};
class some_queue:public some_list{
public:
    some_queue(){
        set_start(NULL);
        set_curent(NULL);
        set_sfarsit(NULL);
        set_lenght(0);
                       };
    int add(int value);
    int serve(int *old_topvalue);
    int queue_empty();
};
class no_strategy:public some_stack,public some_queue{
    public :
        int  find_value(int this_value) {
            element *walker=some_stack::reveal_start();
            if (some_stack::reveal_lenght()>=1) {
                while(walker->reveal_next()!=NULL){
                    if (walker->reveal_value()==this_value)  break ;
                    walker=walker->reveal_next();
                }
                if (walker->reveal_value()==this_value) {
                    some_stack::set_curent(walker);
                    return 1;
                }
            }
            else return 0;
        }
        int  addsome ( int value, int direction ){
            if (stack_empty()){
                element *new_one;
                new_one->set_value(value);
                new_one->set_next(NULL);
                some_stack::set_lenght(1);
                some_stack::set_curent(new_one);
                some_stack::set_start(new_one);
                some_stack::set_sfarsit(new_one);
                return -1;
            }
            if (direction==0) {
                if (some_stack::reveal_current()==some_stack::reveal_start()){
                    element *new_one;
                    new_one->set_value(value);
                    new_one->set_next(some_stack::reveal_current());
                    some_stack::set_curent(new_one);
                    some_stack::set_start(new_one);
                    some_stack::set_lenght(some_stack::reveal_lenght()+1);
                    return -1;
                }
                else {
                    element *new_one=new element;
                    new_one->set_value(value);
                    new_one->set_next(some_stack::reveal_current());
                    element *walker=some_stack::reveal_start();
                    while(walker->reveal_next()!=some_stack::reveal_current())
                    walker=walker->reveal_next();
                    new_one->set_next(some_stack::reveal_current());
                    walker->set_next(new_one);
                    some_stack::set_curent(new_one);
                    some_stack::set_lenght(some_stack::reveal_lenght()+1);
                    return 1;
                }
            }
            else{
                if(some_stack::reveal_current()==some_stack::reveal_sfarsit()){
                    element *new_one=new element;
                    new_one->set_value(value);
                    new_one->set_next(NULL);
                    some_stack::reveal_sfarsit()->set_next(new_one);
                    some_stack::set_curent(new_one);
                    some_stack::set_sfarsit(new_one);
                    some_stack::set_lenght(some_stack::reveal_lenght()+1);
                    return -1;
                }
                else{
                    element *new_one=new element;
                    new_one->set_value(value);
                    new_one->set_next(some_stack::reveal_current()->reveal_next());
                    some_stack::reveal_current()->set_next(new_one);
                    some_stack::set_curent(new_one);
                    some_stack::set_lenght(some_stack::reveal_lenght()+1);
                    return 1;
                }
            }
            return 1;
        }
};
no_strategy L;
int main(){
L.push(1);
L.push(3);
L.push(4);
L.some_stack::print_me();
L.find_value(1);
L.addsome(2,1);
L.some_stack::print_me();
return 0;
}
int some_stack::stack_empty(){
    if(this->reveal_lenght()>=1) return 0;
    return 1;
}
int some_stack::push(int value)
    {
    element *new_one=new element;
    if (new_one==NULL) return 0;
    new_one->set_value(value);
    new_one->set_next(NULL);
    if (reveal_lenght()==0){
            set_start(new_one);
            set_curent(new_one);
            set_sfarsit(new_one);
            set_lenght(1);}
    else{
        reveal_sfarsit()->set_next(new_one);
        set_curent(new_one);
        set_sfarsit(new_one);
        set_lenght(reveal_lenght()+1);}
return 1;
}




//5.#include<iostream>
using namespace std;
class element{
private:
    int info;
    class element *next;
public:
    element(){ next=NULL; }
    int set_value(int this_value){ info=this_value; }
    int reveal_value(){ return info; }
    int set_next(element *next_element){ next=next_element; }
    element *reveal_next(){ return next; }
};

class some_list{
private:
    element *start,*curent,*sfarsit;
    int lungime;
public:
    some_list(){
        start=curent=sfarsit=NULL;
        lungime=0;
    }
    int set_lenght(int new_lenght){ lungime=new_lenght; }
    int set_start(element *new_start){ start=new_start; }
    int set_curent(element *new_curent){ curent=new_curent; }
    int set_sfarsit(element *new_sfarsit){ sfarsit=new_sfarsit; }

    element *reveal_sfarsit(){ return sfarsit; }
    int reveal_lenght(){ return lungime; }
    element *reveal_current(){ return curent; }
    int print_me(){ cout<<endl;
                           element *walker=start; cout<<" START : ";
                           if (reveal_lenght()>=1) {
                           while(walker->reveal_next()!=NULL){
                                cout<<walker->reveal_value()<<" -> ";
                                walker=walker->reveal_next();}
                           cout<<walker->reveal_value(); cout<<" : STOP ";return 1;}

                           cout<<" : STOP ";return 0;}
     element *reveal_start(){ return start; }
};

class some_stack:public some_list{
public:
    some_stack(){
        set_start(NULL);
        set_curent(NULL);
        set_sfarsit(NULL);
        set_lenght(0);
                       };
    int push(int value);
    // int pop(int *old_topvalue);
    int stack_empty();
};

class some_queue:public some_list{
public:
    some_queue(){
        set_start(NULL);
        set_curent(NULL);
        set_sfarsit(NULL);
        set_lenght(0);
                       };
    int add(int value); // identica cu push
    int serve(int *old_topvalue); // se elimina doar primul element din lista
    int queue_empty(); // identica cu stack_empty
};

class no_strategy:public some_stack,public some_queue
                      {
                      public :
// find_value cauta incepand cu primul element pana la ultimul o anumita valoare
// daca valoare NU este gasit metoda intoarce FALSE 0
// pentru prima situatie (!) cand valoarea este gasita  pozitionam element curent
// in acel element si metoda intoarce TRUE 1
                      int  find_value(int this_value) {
                      element *walker=some_stack::reveal_start();
                       if (some_stack::reveal_lenght()>=1) {
                           while(walker->reveal_next()!=NULL){
                            if (walker->reveal_value()==this_value)  break ;
                            walker=walker->reveal_next();
                                                                                 }
                           if (walker->reveal_value()==this_value) {
                                                                        some_stack::set_curent(walker);
                                                                        return 1;
                                                                                     }
                                                                }

                            else return 0;
                                        }


                      int  addsome ( int value, int direction )
                      {
                       if (stack_empty())  {
                                                    element *new_one;
                                                    new_one->set_value(value);
                                                    new_one->set_next(NULL);
                                                    some_stack::set_lenght(1);
                                                    some_stack::set_curent(new_one);
                                                    some_stack::set_start(new_one);
                                                    some_stack::set_sfarsit(new_one);
                                                    return -1;
                                                   }
                      if (direction==0) {
                                                    if (some_stack::reveal_current()==some_stack::reveal_start())
                                                    {
                                                        // .... (!)  // pentru curent pe primul element
                                                        return -1;
                                                    }
                                        else {
                                                    element *new_one=new element;
                                                    new_one->set_value(value);
                                                    new_one->set_next(some_stack::reveal_current());
                                                    element *walker=some_stack::reveal_start();
                                                    while(walker->reveal_next()!=some_stack::reveal_current())
                                                                            walker=walker->reveal_next();
                                                    new_one->set_next(some_stack::reveal_current());
                                                    walker->set_next(new_one);
                                                    some_stack::set_lenght(some_stack::reveal_lenght()+1);
                                                    return 1;
                                                 }
                                        }

                                    //.... (!)  pentru  direction!=0 adica adaugarea la dreapta
                        return 1;
                      }
                      };

no_strategy L;
int main(){
L.push(1);
L.push(2);
L.push(3);
// lista are valorile 1 2 3
// a fost construita prin apeluri push => deci "curent" este pe ultimul element
L.addsome(0,0);
// adaug 0 la stanga element
// deci lista trebuie sa fie 1 2 0 3
L.some_stack::print_me();
// apelez "print_me" la care am acces prin mostenire public la ambii parinti
// some_queue  si some_stack
// si utilizez rezolutie :: pentru a referi acea metoda "print_me" din
// some_stack
 L.find_value(3); // !!!
cout<<endl<<(L.some_stack::reveal_current())->reveal_value()<<endl;
L.addsome(0,0);
L.some_stack::print_me(); // sa avem 1 0 2 0 3

return 0;
}

int some_stack::stack_empty(){
    if(this->reveal_lenght()>=1) return 0;
    return 1;
}

int some_stack::push(int value)
    {
    element *new_one=new element;
    if (new_one==NULL) return 0;
    new_one->set_value(value);
    new_one->set_next(NULL);
    if (reveal_lenght()==0){
            set_start(new_one);
            set_curent(new_one);
            set_sfarsit(new_one);
            set_lenght(1);}
    else{
        reveal_sfarsit()->set_next(new_one);
        set_curent(new_one);
        set_sfarsit(new_one);
        set_lenght(reveal_lenght()+1);}
return 1;
}






//6.#include<iostream>
using namespace std;
class element{
private:
    int info;
    class element *next;
public:
    element(){ next=NULL; }
    int set_value(int this_value){ info=this_value; }
    int reveal_value(){ return info; }
    int set_next(element *next_element){ next=next_element; }
    element *reveal_next(){ return next; }
};

class some_list{
private:
    element *start,*curent,*sfarsit;
    int lungime;
public:
    some_list(){
        start=curent=sfarsit=NULL;
        lungime=0;
    }
    int set_lenght(int new_lenght){ lungime=new_lenght; }
    int set_start(element *new_start){ start=new_start; }
    int set_curent(element *new_curent){ curent=new_curent; }
    int set_sfarsit(element *new_sfarsit){ sfarsit=new_sfarsit; }

    element *reveal_sfarsit(){ return sfarsit; }
    int reveal_lenght(){ return lungime; }
    element *reveal_current(){ return curent; }
    int print_me(){ cout<<endl;
                           element *walker=start; cout<<" START : ";
                           if (reveal_lenght()>=1) {
                           while(walker->reveal_next()!=NULL){
                                cout<<walker->reveal_value()<<" -> ";
                                walker=walker->reveal_next();}
                           cout<<walker->reveal_value(); cout<<" : STOP ";return 1;}

                           cout<<" : STOP ";return 0;}
     element *reveal_start(){ return start; }
};

class some_stack:public some_list{
public:
    some_stack(){
        set_start(NULL);
        set_curent(NULL);
        set_sfarsit(NULL);
        set_lenght(0);
                       };
    int push(int value);
    // int pop(int *old_topvalue);
    int stack_empty();
};

class some_queue:public some_list{
public:
    some_queue(){
        set_start(NULL);
        set_curent(NULL);
        set_sfarsit(NULL);
        set_lenght(0);
                       };
    int add(int value); // identica cu push
    int serve(int *old_topvalue); // se elimina doar primul element din lista
    int queue_empty(); // identica cu stack_empty
};

class no_strategy:public some_stack,public some_queue
                      {
                      public :
// find_value cauta incepand cu primul element pana la ultimul o anumita valoare
// daca valoare NU este gasit metoda intoarce FALSE 0
// pentru prima situatie (!) cand valoarea este gasita  pozitionam element curent
// in acel element si metoda intoarce TRUE 1
                      int  find_value(int this_value) {
                      element *walker=some_stack::reveal_start();
                       if (some_stack::reveal_lenght()>=1) {
                           while(walker->reveal_next()!=NULL){
                            if (walker->reveal_value()==this_value)  break ;
                            walker=walker->reveal_next();
                                                                                 }
                           if (walker->reveal_value()==this_value) {
                                                                        some_stack::set_curent(walker);
                                                                        return 1;
                                                                                     }
                                                                }

                            else return 0;
                                        }


                      int  addsome ( int value, int direction )
                      {
                       if (stack_empty())  {
                                                    element *new_one;
                                                    new_one->set_value(value);
                                                    new_one->set_next(NULL);
                                                    some_stack::set_lenght(1);
                                                    some_stack::set_curent(new_one);
                                                    some_stack::set_start(new_one);
                                                    some_stack::set_sfarsit(new_one);
                                                    return -1;
                                                   }
                      if (direction==0) {
                                                    if (some_stack::reveal_current()==some_stack::reveal_start())
                                                    {
                                                        // .... (!)  // pentru curent pe primul element
                                                        return -1;
                                                    }
                                        else {
                                                    element *new_one=new element;
                                                    new_one->set_value(value);
                                                    new_one->set_next(some_stack::reveal_current());
                                                    element *walker=some_stack::reveal_start();
                                                    while(walker->reveal_next()!=some_stack::reveal_current())
                                                                            walker=walker->reveal_next();
                                                    new_one->set_next(some_stack::reveal_current());
                                                    walker->set_next(new_one);
                                                    some_stack::set_lenght(some_stack::reveal_lenght()+1);
                                                    return 1;
                                                 }
                                        }

                                    //.... (!)  pentru  direction!=0 adica adaugarea la dreapta
                        return 1;
                      }
                      };

no_strategy L;
int main(){
L.push(1);
L.push(2);
L.push(3);
// lista are valorile 1 2 3
// a fost construita prin apeluri push => deci "curent" este pe ultimul element
L.addsome(0,0);
// adaug 0 la stanga element
// deci lista trebuie sa fie 1 2 0 3
L.some_stack::print_me();
// apelez "print_me" la care am acces prin mostenire public la ambii parinti
// some_queue  si some_stack
// si utilizez rezolutie :: pentru a referi acea metoda "print_me" din
// some_stack
 L.find_value(3); // !!!
cout<<endl<<(L.some_stack::reveal_current())->reveal_value()<<endl;
L.addsome(0,0);
L.some_stack::print_me(); // sa avem 1 0 2 0 3

return 0;
}

int some_stack::stack_empty(){
    if(this->reveal_lenght()>=1) return 0;
    return 1;
}

int some_stack::push(int value)
    {
    element *new_one=new element;
    if (new_one==NULL) return 0;
    new_one->set_value(value);
    new_one->set_next(NULL);
    if (reveal_lenght()==0){
            set_start(new_one);
            set_curent(new_one);
            set_sfarsit(new_one);
            set_lenght(1);}
    else{
        reveal_sfarsit()->set_next(new_one);
        set_curent(new_one);
        set_sfarsit(new_one);
        set_lenght(reveal_lenght()+1);}
return 1;
}






//7. functii cu numar variabil de parametri
#include<iostream>
#include<stdarg.h>
using namespace std;
int aduna(int n,...)
{
va_list VA;
int response=0;
va_start(VA,n);// de initializat lista  , apel de va_start  // de parcurs lista prin va_arg
int val;
for(int i=1;i<=n;i++){
    val=va_arg(VA,int);
    response+=val;
}
va_end(VA); // destructor , dezaloca lista
return response;
}
int main(){// prim parametru indica numarul valorilor transmise
cout<<aduna(3,1,2,3) ; // 6 !
cout<<endl<<aduna(4,1,2,3,4); // 10 !
return 0;
}







//8.#include<iostream>
#include<algorithm>
using namespace std;
int V[100]={2,1,3};
int n=3;
int (*nume)(int*,int);
int afisez(int V[], int dim){
    cout<<"Found order !"<<endl;
}
int sortez(int V[],int dim){
    cout<<"No order !"<<endl;
    sort(V,V+dim);
}
int ma_adaptez(int V[], int dim){
    int response=1;
    for(int i=0;i<dim-1;i++){
        if(V[i]<=V[i+1]){
            response=1;
        }
        else{
            response=0;
            break;
        }
    }
    if(response==1) nume=&afisez;
    else nume=&sortez;
}
int main(){
ma_adaptez(V,n);
(*nume)(V,n);
ma_adaptez(V,n);
(*nume)(V,n);
return 0;
}







//9.#include<iostream>
#include<string>
using namespace std;

int main(int argc, char *argv[]){
cout<<" having "<<argc<<" parameters !";
int sum=0;
for(int i=1;i<=argc;i++){
    if(argv[i]!=NULL){
        int term=stoi(argv[i]);
        sum+=term;
    }
}
cout<<endl<<" Suma = "<<sum;
return 0;
}







//10.#include<iostream>
#include<thread>
#include<limits.h>
using namespace std;
int V[100]={5,2,3,4,1};
int n=5;
int mid=n/2;
int min1,min2;
int first_half(){
    min1=INT_MAX;
    for(int i=0;i<mid;i++){
        if(V[i]<min1){
            min1=V[i];
        }
    }
    return min1;
}
int second_half(){
    min2=INT_MAX;
    for(int i=mid-1;i<n;i++){
        if(V[i]<min2) min2=V[i];
    }
    return min2;
}
thread t1(first_half);
thread t2(second_half);
int main(){
    t1.join();
    t2.join();
    int minim;
    if(min1<min2) minim=min1;
    else minim=min2;
    cout<<endl<<"Minim="<<minim;
    return 0;
}






//11.#include<iostream>
#include<fstream>
using namespace std;
int main(){
fstream f;
fstream g;
f.open("hello.exe",ios::in|ios::binary);
g.open("copy_hello.exe",ios::out|ios::binary);
char *buffer=new char;;
while(!f.eof()){
    f.read(buffer,sizeof(char));
    g.write(buffer,sizeof(char));
}
return 0;
}






//12.#include<iostream>
#include<fstream>
#include<string.h>
using namespace std;
char* the_string=new char;
char* the_copy=new char;
void read_data(){
    ifstream f("input.dat");
    f.getline(the_string,100);
}

void break_str(){
    char* piece=new char;
    piece=strtok(the_string," ");
    while(piece){
        cout<<piece<<endl;
        piece=strtok(NULL," ");
    }
}
int main(){
read_data();
break_str();
return 0;
}







//13.#include<iostream>
#include<fstream>
#include<string.h>
using namespace std;
char* the_string=new char;
char* the_copy=new char;
void read_data(){
    ifstream f("input.dat");
    f.getline(the_string,255);
}
int main(){
    read_data();
    strcpy(the_copy,the_string);
    char* piece=new char;
    char* words[100];
    piece=strtok(the_string," ");
    int nr=1;
    while(piece){
        words[nr]=piece;
        piece=strtok(NULL," ");
        nr++;
    }
    nr--;
    for(int i=1;i<=nr;i++){
        int freq=0;
        for(int j=1;j<=nr;j++){
            if(strcmp(words[i],words[j])==0){
                freq++;
            }
        }
        cout<<words[i]<<" "<<freq<<endl;
    }
    return 0;
}








//14.#include<iostream>
#include<fstream>
#include<string.h>
char the_string[]="Ana are mere Ana";
char position[]="Ana";
using namespace std;
int results()
{
    int counter=0;
    char *piece=strtok(the_string," ");
    while(piece!=NULL){
        if(strcmp(piece,position)==0) counter++;
        piece=strtok(NULL," ");
    }
    return counter; // intoarce numarul de aparitii in sirul "in_care_caut"
                    // al subsirului "pe_care_caut"
}

int main()
{
//read_data(); // "abc aBc abc"
             // "abc"
cout<<results(); // 2
return 0;
}








//15.#include<iostream>
#include<fstream>
#include<string.h>
using namespace std;
char* the_string=new char;
char* the_copy=new char;
void read_data(){
    ifstream f("input.dat");
    f.getline(the_string,100);
}
void break_str(){
    char* piece=new char;
    piece=strtok(the_string," ");
    while(piece){
        cout<<piece<<" ";
        piece=strtok(NULL," ");
    }
}
int main(){
read_data();
break_str();
return 0;
}