Check if there is at least one sequence of three zeros in the list

[sergeyutkin221]

I need to check if there is at least one sequence of three zeros in the list (array) using an array (a regular array that is completely (!) Filled with 10 elements and then with 10,000 elements).

Also using a bilaterally linked list (DLL) of 10 items and then 10,000 items.

There is a ready-made code, just please help me figure it out, the most complicated one, I would be very grateful.

#include <iostream>
#include <cstring>
#include <ctime>
#include <chrono>
using namespace std;
template<typename Item>
class LinkedList{

private:
    struct Node{
        Item item;
        Node* prev;
        Node* next;
    };

    Node* first;
    Node* last;
    int size;

    enum {
        up = 0,
        down = 1,
    };
    Node& findElement(int pos, int count = up) const;

public:
    LinkedList();
    LinkedList(Item);
    ~LinkedList();

    LinkedList& Add(const Item&);
    LinkedList& Add(const Item&, int pos);
    LinkedList& Delete(int pos, int range = 1);
    Item& operator[](int i);
};

template<typename Item>
typename LinkedList<Item>::Node& LinkedList<Item>::findElement(int pos, int count) const{

    LinkedList<Item>::Node* current;
    if (count == up){
        current = first;
        for (int k = 1; k <= pos; k++)
            current = current->next;
    }else{
        current = last;
        for (int k = size - 2; k >= pos; k--)
            current = current->prev;
    }

    return *current;
}

template<typename Item>
LinkedList<Item>& LinkedList<Item>::Add(const Item& item, int pos){
    LinkedList<Item>::Node* temp = new LinkedList<Item>::Node;
    temp->item = item;

    if (pos >= size){
        last = temp;
        temp->next = nullptr;
    }else{
        temp->next = &findElement(pos);

        (temp->next)->prev = temp;
    }
    if (pos == 0){
        temp->prev = nullptr;
        first = temp;
    }
    else
        if (size != 0){
            temp->prev = &findElement(pos - 1);
            temp->prev->next = temp;
        }

    size++;
    return *this;
}

template<typename Item>
LinkedList<Item>& LinkedList<Item>::Add(const Item& item){
    return Add(item, size);
}



template<typename Item>
LinkedList<Item>::LinkedList(){
    size = 0;
    first = nullptr;
    last = nullptr;
}
template<typename Item>
LinkedList<Item>::LinkedList(Item item){
    size = 1;
    first = last = new LinkedList<Item>::Node;
    first->prev = nullptr;
    first->next = nullptr;
    first->item = item;
}

template<typename Item>
Item& LinkedList<Item>::operator[](int i){
    if (i < 0 || i >= size)
        std::cout << "Out of bounds of an array";
    return findElement(i).item;
}



template<typename Item>
LinkedList<Item>& LinkedList<Item>::Delete(int pos, int range){
    if (pos < 0 || pos >= size)
        std::cout << "Out of bounds of an array";
    int tempSize = size;

    for (int i = pos; i < pos + range && i < size; i++, tempSize--)
        delete& findElement(i, down);

    if (tempSize == 0)
        first = last = nullptr;
    else{
        if (pos == 0)
        {
            first = &findElement(pos + range, down);
            first->prev = nullptr;
        }
        else
            if (pos + range >= size){

                last = &findElement(pos - 1);
                last->next = nullptr;
            }else{
                findElement(pos - 1).next = &findElement(pos + range, down);
                findElement(pos + range, down).prev = &findElement(pos - 1);
            }
    }


    size = tempSize;
    return *this;
}


template<typename Item>
LinkedList<Item>::~LinkedList(){
    Delete(0, size);
}
void arr(int size);
void dll(int size);

int main() {
    srand(time(NULL));
    int size;
    while (true){
        cout << "Insert the size: ";
        cin >> size;

        if (!cin or size <= 0) {
            cin.clear();
            cin.ignore(10000, '\n');
        }
        else
            break;
    }
    arr(size);
    dll(size);
    return 0;
}

void arr(int size) {
    int ind = 0, count = 0;
    int array[size];
    for (int i = 0;i < size;i++) {
        array[i] = rand() % 10;
    }
    auto start = chrono::high_resolution_clock::now();
    for (int i = 0;i < size;i++) {
        if (array[i] == 0) {
            ind++;
            if (ind == 3) { count++;ind = 0; }
        }
        else ind = 0;
    }
    auto end = chrono::high_resolution_clock::now();
    chrono::duration<double> duretion = end - start;
    cout << "Duration: " << duretion.count() << "s" << endl;
    cout << "Number of sequences 000 : " << count << "\n";
}
void dll(int size) {
    int ind = 0, count = 0;
    LinkedList<int>aye;
    for (int i = 0; i < size; i++) {
        aye.Add(rand() % 10);
    }
    auto start = chrono::high_resolution_clock::now();
    for (int i = 0; i < size; i++) {
        if (aye[i] == 0) {
            ind++;
            if (ind == 3) { count++; ind = 0; }
        }
        else ind = 0;
    }
    auto end = chrono::high_resolution_clock::now();
    chrono::duration<double> duretion = end - start;
    cout << "Duration: " << duretion.count() << "s" << endl;
    cout << "Number of sequences 000 : " << count << "\n";
}

[mbozzi]

#include <algorithm>
#include <random>
#include <array>
#include <iostream>

int main()
{
  std::array<int, 3>     ts{};
  std::array<int, 10000> xs;
  
  std::default_random_engine rng;
  std::uniform_int_distribution<> dist(0, 10);
  std::generate(xs.begin(), xs.end(), [&]{ return dist(rng); });
  
  std::cout << (std::search(xs.begin(), xs.end(), ts.begin(), ts.end()) != xs.end()
    ? "Found it\n": "Didn't find it\n");
}

[seeplus]

just please help me figure it out,

Use the debugger to trace through the code to see how it works.

Also, when posting code please use code tags so that the code is readable!