#include <iostream>
#include <vector>
#include <cmath>
#include <sstream>

using namespace std;
class BinaryVector{
private:
    int size_array;
    vector<bool> tablica;

public:
    BinaryVector(int size){
        this->size_array = size;
        for(int i = 0; i < size; i++){
            tablica.push_back(false);
        }
    }

    BinaryVector(int size, int value){
        this->size_array = size;

        for (int i=size-1;i>=0; i--){
            (value&(1<<i)?tablica.push_back(true):tablica.push_back(false));
        }

    }

    int getSize(){
        return size_array;
    }

    void setTrue(int position){
        tablica[position] = true;
    }

    bool getAt(int position){
        return tablica[position];
    }



    void printHex(){
        stringstream ss;
        ss<< std::hex << toInt(); // int decimal_value
        std::string res ( ss.str() );

        std::cout << res;
    }

    int toInt(){
        int number = 0;

        for(int x = 0; x < size_array; x++)
            if(tablica[x] == true)number += (pow( 2, (size_array - x - 1)));

        return number;
    }

    void resize(int size){
        int roznica = this->size_array - size;
        if(size < this->size_array){
            tablica.erase(tablica.begin(), tablica.begin()+roznica);
        }else{
            vector<bool>::iterator it;
            it = tablica.begin();
            for(int i = 0; i < roznica; i++){
                tablica.insert(it, false);
            }
        }
        this->size_array = size;
    }

    /////PRZECIAZENIA
    friend ostream & operator<< (ostream &wyjscie, const BinaryVector &s);

    BinaryVector operator&(BinaryVector &drugi){
        int nowy_size;
        int roznica;
        if(this->size_array < drugi.size_array){
            nowy_size = this->size_array;
            roznica = drugi.size_array - this->size_array;
        }else{
            nowy_size = drugi.size_array;
            roznica = this->size_array - drugi.size_array;
        }

        BinaryVector nowa_liczba(nowy_size);

            for(int i = 0; i < nowy_size; i++){
                if(this->size_array < drugi.size_array) {
                    nowa_liczba.tablica[i] = this->getAt(i) && drugi.getAt(i + roznica);
                }else {
                    nowa_liczba.tablica[i] = this->getAt(i+roznica) && drugi.getAt(i);
                }
            }


        return nowa_liczba;
    }

    BinaryVector operator|(BinaryVector &drugi){
        int nowy_size;
        int roznica;
        if(this->size_array < drugi.size_array){
            nowy_size = this->size_array;
            roznica = drugi.size_array - this->size_array;
        }else{
            nowy_size = drugi.size_array;
            roznica = this->size_array - drugi.size_array;
        }

        BinaryVector nowa_liczba(nowy_size);

        for(int i = 0; i < nowy_size; i++){
            if(this->size_array < drugi.size_array) {
                nowa_liczba.tablica[i] = this->getAt(i) || drugi.getAt(i + roznica);
            }else {
                nowa_liczba.tablica[i] = this->getAt(i+roznica) || drugi.getAt(i);
            }
        }


        return nowa_liczba;
    }

    BinaryVector operator^(BinaryVector &drugi){
        int nowy_size;
        int roznica;
        if(this->size_array < drugi.size_array){
            nowy_size = this->size_array;
            roznica = drugi.size_array - this->size_array;
        }else{
            nowy_size = drugi.size_array;
            roznica = this->size_array - drugi.size_array;
        }

        BinaryVector nowa_liczba(nowy_size);

        for(int i = 0; i < nowy_size; i++){
            if(this->size_array < drugi.size_array) {
                nowa_liczba.tablica[i] = this->getAt(i) ^ drugi.getAt(i + roznica);
            }else {
                nowa_liczba.tablica[i] = this->getAt(i+roznica) ^  drugi.getAt(i);
            }
        }


        return nowa_liczba;
    }

    BinaryVector operator<<(int liczba){
        BinaryVector nowa_liczba(this->size_array);
        nowa_liczba.tablica = this->tablica;
        for(int i = 0; i < liczba; i++){
            nowa_liczba.tablica.push_back(false);
            nowa_liczba.tablica.erase(nowa_liczba.tablica.begin(), nowa_liczba.tablica.begin()+1);
        }
        return nowa_liczba;
    }

    BinaryVector operator>>(int liczba){
        BinaryVector nowa_liczba(this->size_array);
        nowa_liczba.tablica = this->tablica;
        vector<bool>::iterator it;
        it = nowa_liczba.tablica.begin();
        for(int i = 0; i < liczba; i++){
            nowa_liczba.tablica.insert(it, false);
            nowa_liczba.tablica.pop_back();
        }
        return nowa_liczba;
    }


};

ostream & operator<<( std::ostream & out, const BinaryVector & t)
{
    for( int i = 0; i < t.size_array ; i++)
        out << t.tablica[i];
    return out;
}

int main() {
    BinaryVector a(5);
    a.setTrue(1);
    a.setTrue(0);
    BinaryVector b(6);
    b.setTrue(2);
    b.setTrue(3);
    b.setTrue(1);
    BinaryVector d(6);
    d.setTrue(2);
    d.setTrue(5);
    cout<<a<<endl;  //11000
    cout<<b<<endl; //011100
    cout<<(a&b)<<endl; //11000
    cout<<(a|b)<<endl; //11100
    cout<<(a^b)<<endl; //00100
    cout<<(a<<2)<<endl; //1100000
    cout<<(a>>2)<<endl; //110
    cout<<(a.toInt())<<endl; //24
    BinaryVector c(6,23);
    cout<<c<<endl; //010111
    b.printHex(); //1C
    cout<<endl;
    c.printHex(); // 17
    cout<<endl<<(c.toInt())<<endl; //23
    c.resize(2);
    cout<<c.toInt(); //3
    cout<<((d<<7)^(b>>2)|(c<<1));

    return 0;
}