#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QPainter>
#include <QTimer>
#include <qmath.h>


QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

private:
    Ui::Widget *ui;

    void paintEvent(QPaintEvent *event);
    QTimer* mytimer;

    QPoint create_p(int);

    QList<QPoint> pl;

    int fl_start;
    bool fl_stop;

public slots:
    void press_pbtn_01();
    void press_pbtn_02();

    void event_mytimer();

};
#endif // WIDGET_H

#include "widget.h"
#include "ui_widget.h"




Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);

    mytimer = new QTimer();

    fl_start = false;
    fl_stop = false;

    QObject::connect(ui->pbtn_01, SIGNAL(clicked()), this, SLOT(press_pbtn_01()));
    QObject::connect(ui->pbtn_02, SIGNAL(clicked()), this, SLOT(press_pbtn_02()));

    QObject::connect(mytimer, SIGNAL(timeout()), this, SLOT(event_mytimer()));
}




Widget::~Widget()
{
    delete ui;
}




void Widget::press_pbtn_01()
{

    QPoint p;
    p.setX(width()/2);
    p.setY(height()/2+20);

    for(int i = 0; i < 10; i++) pl << p;

    fl_start = 1;
    fl_stop = false;

    mytimer->start(20);
}



void Widget::press_pbtn_02()
{
    fl_stop = true;
}



QPoint Widget::create_p(int i)
{
    QPoint p;

    float a1 = width()/2;
    float b1 = height()/2+20;

    float rad = i * 3.14159/180;

    p.setX(a1 + 165*cos(rad));
    p.setY(b1 + 165*sin(rad));

    return p;
}




void Widget::event_mytimer()
{
    static int i = 270;

    for(int j = 0; j < fl_start; j++)
    {
        pl[j] = create_p(i+9-j);
    }

    if(fl_stop)
    {
        pl.removeLast();

        if(pl.size() == 1)
                mytimer->stop();
    }

    i++;
    if(i > 359) i == 0;

    if(fl_start < 9) fl_start++;

    this->repaint();
}



void Widget::paintEvent(QPaintEvent *event)
{
    QPainter Pn(this);
    QPoint p1, p2;

    Pn.setRenderHint(QPainter::Antialiasing);

    QPen penG(Qt::gray);
    penG.setWidth(2);
    Pn.setPen(penG);

    p1.setX(30);
    p1.setY(height()/2+20);
    p2.setX(width()-30);
    p2.setY(height()/2+20);

    Pn.drawLine(p1, p2);

    p1.setX(width()/2);
    p1.setY(47);
    p2.setX(width()/2);
    p2.setY(height()-10);

    Pn.drawLine(p1,p2);

    p1.setX(width()/2);
    p1.setY(height()/2+20);

    Pn.drawEllipse(p1, width()/8, width()/8);
    Pn.drawEllipse(p1, width()/4, width()/3.8);
    Pn.drawEllipse(p1, width()/2.6, width()/2.6);


    QColor clr;
    QPen penGr(clr);
    penGr.setWidth(2);

    for(int i = 0; i < pl.size(); i++)
    {
        clr.setRgb(0, 255, 255, 150-i*15);
        penGr.setColor(clr);
        Pn.setPen(penGr);
        Pn.drawLine(p1, pl.at(i));
    }
}

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
//#include <QMessageBox>


QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

    int vin;
    int cx_move;
    int schet[3];

    QList<int> sticst;

    void print_table();

private:
    Ui::Widget *ui;

public slots:
    void onPress_pbtn_01();
    void onPress_pbtn_02();

};
#endif // WIDGET_H

#include "widget.h"
#include "ui_widget.h"

// http://algolist.manual.ru/maths/combinat/hanoi.php

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);

    // подготовка таблицы
    ui->tableWidget->setSelectionMode(QAbstractItemView::NoSelection);

    ui->tableWidget->setColumnWidth(0, 60);
    ui->tableWidget->setColumnWidth(1, 10);
    ui->tableWidget->setColumnWidth(2, 60);
    ui->tableWidget->setColumnWidth(3, 10);
    ui->tableWidget->setColumnWidth(4, 60);

    // инициализация таблицы
    for(int row = 0; row < 7; row++)
        for(int col = 0; col < 5; col++)
        {
            QTableWidgetItem *item = new QTableWidgetItem;
            item->setTextAlignment(Qt::AlignCenter);
            ui->tableWidget->setItem(row, col, item);
        }


    QObject::connect(ui->pbtn_01,SIGNAL(clicked()),this,SLOT(onPress_pbtn_01()));
    QObject::connect(ui->pbtn_02,SIGNAL(clicked()),this,SLOT(onPress_pbtn_02()));
}





Widget::~Widget()
{
    delete ui;
}




// set
void Widget::onPress_pbtn_01()
{

    QString str = ui->lineEdit->text();
    int cx_disks = str.toInt();

    if(cx_disks < 0 || cx_disks > 7)
    {
        ui->label->setText("error");
        return;
    }

    ui->label->setText("0");

    cx_move = 0;

    schet[0] = 1;
    schet[1] = 0;
    schet[2] = 2;

    if(cx_disks % 2)
    {
        schet[0] = 2;
        schet[2] = 1;
    }

    int k = 0;

    for(int i = cx_disks; i > 0; i--)
    {
        k *= 10;
        k += i;
    }

    vin = k;

    sticst.clear();
    sticst << k << 0 << 0;

    print_table();
}





// move
void Widget::onPress_pbtn_02()
{
    int x1, x2;
    int k = 0;

    // конец игры
    if(sticst.at(2) == vin) return;

    // нечётные ходы делает только диск №1
    // по алгоритму в schet[]
    if(!(cx_move % 2))
    {
        // поиск диска №1
        for(int i = 0; i < 3; i++)
        {
            if(sticst.at(i) % 10 == 1)
            {
                k = i;
                break;
            }
        }

        x1 = schet[cx_move % 3];
        sticst[x1] *= 10;
        sticst[x1] += sticst.at(k) % 10;
        sticst[k] /= 10;
    }

    // чётные ходы делает наименьший диск не считая 1-го
    // в единственное доступное место
    else
    {
        // поиск наименьшего диска
        x1 = 10;
        for(int i = 0; i < 3; i++)
        {
            x2 = sticst.at(i) % 10;
            if(x2 == 0 || x2 == 1) continue;

            if(sticst.at(i) % 10 < x1)
            {
                x1 = sticst.at(i) % 10;
                k = i;
            }
        }

        // поиск доступного хода
        x1 = sticst.at(k) % 10;

        for(int i = 0; i < 3; i++)
        {
            x2 = sticst.at(i) % 10;
            if(x2 == 0 || x1 < x2 )
            {
                sticst[i] *= 10;
                sticst[i] += x1;
                sticst[k] /= 10;
                break;
            }
        }
    }

    cx_move++;

    ui->label->setNum(cx_move);
    print_table();
}





void Widget::print_table()
{

    int pos;

    // очистка таблицы
    for(int row = 0; row < 7; row++)
        for(int col = 0; col < 5; col++)
        {
            ui->tableWidget->item(row, col)->setText("");
            ui->tableWidget->item(row, col)->setBackgroundColor(Qt::white);
        }

    // вывод на экран по столбикам
    for(int i = 0; i < 3; i++)
    {
        pos = sticst.at(i);
        QString str  = QString::number(sticst.at(i));
        int ln = str.length();

        for(int row = 0; row < ln; row++)
        {
            int x = pos % 10 - 1;
            if(pos > 0)
            {
                ui->tableWidget->item(row+7-ln, i*2)->setText(QString::number(x+1));
                ui->tableWidget->item(row+7-ln, i*2)->setBackgroundColor(Qt::GlobalColor(x+7));
            }

        pos /= 10;
        }
    }
}

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <QTime>
#include <QTimer>


QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

    QTimer *timer;

    struct segm
    {
        int pos_x;
        int pos_y;
        int clr;
    };

    int table_row;
    int table_col;

    int pole[30][50];

    QList<segm> zmeyka;

    void make_zmeyka();
    void print_zmeyka();
    bool move_zmeyka(int);


private:
    Ui::Widget *ui;


public slots:
    void press_pbtn_01();

    void onTimer();

};
#endif // WIDGET_H

#include "widget.h"
#include "ui_widget.h"


Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);

    // инициализация ГСЧ
    qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));

    timer = new QTimer();

    table_row = ui->tableWidget->rowCount();        // 30
    table_col = ui->tableWidget->columnCount();     // 50

    for(int row = 0; row < table_row; row++)
        for(int col = 0; col < table_col; col++)
        {
            pole[row][col] = 0;

            QTableWidgetItem *it = new QTableWidgetItem;
            it->setTextAlignment(Qt::AlignCenter);
            ui->tableWidget->setItem(row, col, it);
        }


    // лабиринт
    for(int i = 0; i < 3; i++)
        for(int j = 5; j < 15; j++)
        {
            pole[j][i+10] = 1;
            pole[j+10][i+10] = 1;

            ui->tableWidget->item(j, i+10)->setBackgroundColor(Qt::gray);
            ui->tableWidget->item(j+10, i+10)->setBackgroundColor(Qt::gray);

            pole[j][i+37] = 1;
            pole[j+10][i+37] = 1;

            ui->tableWidget->item(j, i+37)->setBackgroundColor(Qt::gray);
            ui->tableWidget->item(j+10, i+37)->setBackgroundColor(Qt::gray);
        }


    make_zmeyka();
    print_zmeyka();

    QObject::connect(ui->pbtn_01, SIGNAL(clicked()), this, SLOT(press_pbtn_01()));
    connect(timer,SIGNAL(timeout()),this,SLOT(onTimer()));
}




Widget::~Widget()
{
    delete ui;
}




void Widget::press_pbtn_01()
{
    timer->start(60);

}




bool Widget::move_zmeyka(int k)
{

    QList<segm> sg;

    int lng = zmeyka.length();

    for(int i = 0; i < lng; i++)
    {
        sg << zmeyka.at(i);
    }

    int x = sg.at(0).pos_x;
    int y = sg.at(0).pos_y;

    if(k == 1) sg[0].pos_y--;
    if(k == 2 )sg[0].pos_x--;
    if(k == 3 )sg[0].pos_y++;
    if(k == 4 )sg[0].pos_x++;


    if((sg[0].pos_x < 0) ||
            (sg[0].pos_y < 0) ||
                (sg[0].pos_x > table_row-1) ||
                    (sg[0].pos_y > table_col-1))
                        return true;

    // обход препятствий
    if(pole[sg[0].pos_x][sg[0].pos_y]) return true;


    sg[0].clr = 2;
    zmeyka[0] = sg.at(0);

    sg[0].pos_x = x;
    sg[0].pos_y = y;

    sg[0].clr = 1;


    for(int i = 1; i < lng; i++)
    {
        sg[i] = zmeyka.at(i);

        // последний сегмент белого цвета стирает след змейки
        if(i == lng-1) sg[i-1].clr = 0;

        zmeyka[i] = sg.at(i-1);
    }

    print_zmeyka();
    return false;
}




void Widget::make_zmeyka()
{
    segm sg;

    // длина змейки
    for(int i = 20; i < 30; i++)
    {
        sg.pos_x = 15;
        sg.pos_y = i;

        sg.clr = 1;
        if(i == 20) sg.clr = 2;
        if(i == 29) sg.clr = 0;

        zmeyka << sg;
    }
}




void Widget::print_zmeyka()
{
    segm sg;
    QColor sclr;

    sg = zmeyka.at(zmeyka.size()-1);
    ui->tableWidget->item(sg.pos_x, sg.pos_y)->setBackgroundColor(Qt::white);


    for(int i = 0; i < zmeyka.size(); i++)
    {
        sg = zmeyka.at(i);

        if(sg.clr == 0) sclr = Qt::white;
        if(sg.clr == 1) sclr = Qt::green;
        if(sg.clr == 2) sclr = Qt::red;

        ui->tableWidget->item(sg.pos_x, sg.pos_y)->setBackgroundColor(sclr);
    }
}




void Widget::onTimer()
{
    static int cx = 0;
    static int napr = 3;
    static int oldnapr = 1;

    if(!(cx % 7))
    {
    met_10:

        napr = (qrand() % 4) + 1;

        // запрет возврата в саму себя
        if(napr == 2 && oldnapr == 4)  goto met_10;
        if(napr == 4 && oldnapr == 2)  goto met_10;
        if(napr == 1 && oldnapr == 3)  goto met_10;
        if(napr == 3 && oldnapr == 1)  goto met_10;
    }

    // обход препятствий
    if(move_zmeyka(napr)) goto met_10;

    oldnapr = napr;
    cx++;
}

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <math.h>
#include <QTime>

#include <bitset>
using namespace std;


namespace Ui {
class Widget;
}

class Widget : public QWidget
{
    Q_OBJECT
    
public:
    explicit Widget(QWidget *parent = 0);
    ~Widget();
    
private:
    Ui::Widget *ui;

    QTime m_time;

public slots:
    void MyEventHandler1();
    void MyEventHandler2();
    void MyEventHandler3();
};

#endif // WIDGET_H

#include "widget.h"
#include "ui_widget.h"


Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget)
{
    ui->setupUi(this);

    QObject::connect(ui->pushBtn_01, SIGNAL(clicked()), this, SLOT(MyEventHandler1()));
    QObject::connect(ui->pushBtn_02, SIGNAL(clicked()), this, SLOT(MyEventHandler2()));
    QObject::connect(ui->pushBtn_03, SIGNAL(clicked()), this, SLOT(MyEventHandler3()));
}



Widget::~Widget()
{
    delete ui;
}




//функция добавляет пробелы в число 12345678 -> 12 345 678
//---------------------------------------------------------------------------
QString fn_SpsToInt(QString str)
{
    int x = str.length() - 3;
    while(x > 0) {str.insert(x, QString(" ")); x -= 3;}

    return str;
}




// обычное решето эрастофена
void Widget::MyEventHandler1()
{
    QString str = ui->lineEdit->text();
    str = str.remove(" ");

    quint64 N = str.toULongLong();
    quint64 M = sqrt(N)+1;

    // с битсетом
    bitset<0x8FFFFFFF> *bbuf = new bitset<0x8FFFFFFF>;
    bbuf->reset();

    quint64 i, j;


    // начало отсчёта времени
    quint64 t_begin = m_time.elapsed();

    // решето
    for(i = 2; i < M; i++)
    {
        if(!bbuf->test(i))
        {
            for(j = i*i; j < N; j+=i) bbuf->set(j, true);
        }
    }


    // подсчет результата
    quint64 cx = 0;
    quint64 summ = 0;

    for(i = 2; i < N; i++)
     {
        if(!bbuf->test(i))
        {
            cx++;
            summ += i;
        }
     }

    // конец отсчёта времени
    qint64 msecs = m_time.elapsed() - t_begin;
    QTime time(0,0,0,0);

    ui->label_01->setText(fn_SpsToInt(QString::number(cx)));
    ui->label_02->setText(fn_SpsToInt(QString::number(summ)));
    ui->label_03->setText(time.addMSecs(msecs).toString("hh:mm:ss.zzz"));

    delete bbuf;
}





// ускоренное решето без чётных чисел
void Widget::MyEventHandler2()
{
    QString str = ui->lineEdit->text();
    str = str.remove(" ");

    quint64 N = str.toULongLong() / 2;
    quint64 M = sqrt(N)+1;

    // с битсетом
    bitset<0x8FFFFFFF> *bbuf = new bitset<0x8FFFFFFF>;
    bbuf->reset();

    quint64 i, j, k;


    // начало отсчёта времени
    quint64 t_begin = m_time.elapsed();

    // решето
    for(i = 0; i < M; i++)
    {
        if(!bbuf->test(i))
        {
            k = (i*2)+3;
            for(j = k*(i+1)+i; j < N; j+=k) bbuf->set(j,true);
        }
    }


    // подсчет результата
    quint64 cx = 1;
    quint64 summ = 2;

    for(i = 0; i < N-1; i++)
    {
        if(!bbuf->test(i))
        {
            k = (i*2 + 3);
            cx++;
            summ += k;
        }
    }

    // конец отсчёта времени
    qint64 msecs = m_time.elapsed() - t_begin;
    QTime time(0,0,0,0);

    ui->label_04->setText(fn_SpsToInt(QString::number(cx)));
    ui->label_05->setText(fn_SpsToInt(QString::number(summ)));
    ui->label_06->setText(time.addMSecs(msecs).toString("hh:mm:ss.zzz"));

    delete bbuf;
}



// решето 30*
void Widget::MyEventHandler3()
{
    QString str = ui->lineEdit->text();
    str = str.remove(" ");

    quint64 N = str.toULongLong();
    quint64 M = sqrt(N);
    quint64 V = N/30 + 1;

    static int Rest[8] = {1, 7, 11, 13, 17, 19, 23, 29};

    quint8 kos;
    quint32 p, i, j;
    quint32 x, d, r, m;

    QByteArray bbuf(0x2fffffff, 0);

    bbuf[0] = 1;


    // начало отсчёта времени
    quint64 t_begin = m_time.elapsed();

    // решето
    for(i = p = 0; p <= M; i++)
    {
        for(j = 0; j < 8; j++)
        {
            if (bbuf[i] & (1 << j)) continue;
            p = 30*i + Rest[j];

            for(x = 7 * p; ;x += 2 * p)
            {
                d = x / 30;
                if (d >= V) break;
                r = x % 30;

                for(m = 0; m < 8; m++) if (r == Rest[m]) break;
                if (m == 8) continue;

                kos = bbuf[d];
                kos |= (1 << m);
                bbuf[d] = kos;
            }
        }
    }


    // подсчет результата
    quint64 cx = 3;
    quint64 summ = 10;

    for(i = 0; i < V; i++)
    {
        for(j = 0; j < 8; j++)
        {
            if (bbuf[i] & (1 << j)) continue;

            x = 30*i + Rest[j];
            if(x > N) break;

            cx++;
            summ += x;
        }
    }

    // конец отсчёта времени
    qint64 msecs = m_time.elapsed() - t_begin;
    QTime time(0,0,0,0);

    ui->label_07->setText(fn_SpsToInt(QString::number(cx)));
    ui->label_08->setText(fn_SpsToInt(QString::number(summ)));
    ui->label_09->setText(time.addMSecs(msecs).toString("hh:mm:ss.zzz"));
}

int Prime(quint64 a)
{
     quint64 i1, i2, i3, i4, i5, i6, i7, i8, bound;

     if (a == 0 || a == 1) return 0;

     if (a == 2 || a == 3 || a == 5 || a == 7 || a == 11 || a == 13 || a == 17
             || a == 19 || a == 23 || a == 29) return 1;

     if (a%2 == 0 || a%3 == 0 || a%5 == 0 || a%7 == 0 || a%11 == 0 ||
         a%13 == 0 || a%17 == 0 || a%19 == 0 || a%23 == 0 || a%29 == 0)
         return 0;

     bound = sqrt((double)a);

     i1 = 31; i2 = 37; i3 = 41; i4 = 43; i5 = 47; i6 = 49; i7 = 53; i8 = 59;

     while(i8 <= bound && a%i1 && a%i2 && a%i3 && a%i4 && a%i5 && a%i6 && a%i7 && a%i8)
     {
         i1 += 30; i2 += 30; i3 += 30; i4 += 30; i5 += 30; i6 += 30; i7 += 30; i8 += 30;
     }

     if( i8 <= bound ||
        (i1 <= bound && a % i1 == 0) ||
        (i2 <= bound && a % i2 == 0) ||
        (i3 <= bound && a % i3 == 0) ||
        (i4 <= bound && a % i4 == 0) ||
        (i5 <= bound && a % i5 == 0) ||
        (i6 <= bound && a % i6 == 0) ||
        (i7 <= bound && a % i7 == 0) )  return 0;

     return 1;
}

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>
#include <qmath.h>
#include <QTime>


#define FUNC_FIND_D   while(!(n % x))\
                      {\
                          sum *= x;\
                          str += QString::number(x) + "  ";\
                          n /= x;\
                          if(n % x) str += "\n";\
                       }


QT_BEGIN_NAMESPACE
namespace Ui { class Widget; }
QT_END_NAMESPACE

class Widget : public QWidget
{
    Q_OBJECT

public:
    Widget(QWidget *parent = nullptr);
    ~Widget();

private:
    Ui::Widget *ui;

    QTime m_time;
    quint64 t_begin;

public slots:
    void press_pbtn_01();
};
#endif // WIDGET_H

#include "widget.h"
#include "ui_widget.h"





Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);

    QObject::connect(ui->pbtn_01,SIGNAL(clicked()),this,SLOT(press_pbtn_01()));
}





Widget::~Widget()
{
    delete ui;
}




// start
void Widget::press_pbtn_01()
{
    QString str = ui->lineEdit->text();


    quint64 n, x;
    quint64 sum = 1;
    quint64 N = str.toULongLong();

    quint64 qn = sqrt(N)/6 + 2;

    ui->textEdit->clear();
    ui->label_01->clear();
    QApplication::processEvents();

    // проверка на переполнение
    if((N < 1) || (N > 18446744073709551615uL))
    {
        ui->textEdit->setText("Incorrect (low, large) digit");
        return;
    }

    str = "1\n";
    n = N;

    // начало отсчёта времени выполнения
    m_time.start();

    x = 2;
    FUNC_FIND_D

    x = 3;
    FUNC_FIND_D

    for(quint64 i = 1; i < qn; i++)
    {
        x = i * 6 - 1;
        FUNC_FIND_D

        x++;
        x++;
        FUNC_FIND_D
    }

    n = N / sum;
    if(n > 1) str += QString::number(n);


    // конец отсчёта времени выполнения
    qint64 msecs = m_time.elapsed();
    QTime time(0,0,0,0);

    ui->textEdit->append(str);
    ui->label_01->setText(time.addMSecs(msecs).toString("hh:mm:ss.zzz"));
}