Zadania domowe C++ - pomoże ktoś?

Witam bardzo serdecznie, mam dwa zadania domowe do zrobienia z C++, niestety nie jestem w stanie się z tym uporać, może jest jakiś specjalista, dla którego nie będzie to sprawiało żadnego problemu albo może gdzieś są już rozwiązania takich przykładów. Będę bardzo wdzięczny za okazaną pomoc.

Zadanie 1:
Napisz program sprawdzający, czy wszystkie cyfry wczytanej liczby całkowitej dodatniej są jednocyfrowymi liczbami parzystymi. Program powinien wypisać słowo "TAK" lub "NIE".

Zadanie 2:
Napisz program, który sprawdzi, czy podana liczba całkowita dodatnia jest liczbą palindromiczną (czytana od lewej do prawej i od prawej do lewej ma tę samą wartość).

Pozdrawiam.

Zasady na forum są takie: jeśli Chcesz gotowca, to Ogłoszenia Drobne za $$$, jeśli nie, to napisz co dało przeszukiwanie sieci, dokumentacji, podręcznika, etc. Co już zrobiłeś, dlaczego nie działa.

Rozwiązanie na Windows czy Linux?

@kq: Windows

Dobra, tu masz pierwsze

Najistotniejsza część:

int main()
{
    int val;
    if (std::cin >> val) {
        using namespace ctre::literals;
        std::stringstream conv;
        conv << val;
        std::string str = conv.str();
        if ("^[24680]+$"_ctre.match(str))
            std::cout << "TAK\n";
        else
            std::cout << "NIE\n";
    } else {
        std::cout << "NIE\n";
    }
}

To drugie to musisz dać mi z pół godziny, bo jest nietrywialne.

@kq: Dzięki wielkie za pomoc.

Nie sprawdzałem dla wszystkich wartości, ale wydaje mi się, że jest dobrze. Sprawdzam palindromiczność metodą macierzową, tj wpisuję cyfry do macierzy i obliczam jej wyznacznik. Jeśli jest zero, to znaczy że jest palindromem.

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

template<typename T>
class simple_2d_matrix_view
{
	T* data_;
	size_t width_;
	size_t height_;
 
public:
 
	simple_2d_matrix_view(T* ptr, size_t h, size_t w):
		data_{ptr},
		width_{w},
		height_{h}
	{}
 
	size_t width() const { return width_; }
	size_t height() const { return height_; }
 
	T& operator()(size_t h, size_t w) {
		assert(w < width_);
		assert(h < height_);
		return data_[width_ * h + w];
	}
 
	T const& operator()(size_t h, size_t w) const {
		return const_cast<simple_2d_matrix_view&>(*this)(h, w);
	}
};

long long matrix_det(simple_2d_matrix_view<int> v)
{
    assert(v.height() == v.width());
    long long det = 0;

    for(int i = 0; i < v.width(); i++) {
        long long plus = 1, minus = 1;
        for(int j = 0; j < v.height(); j++) {
            int x_plus = (i + j) % v.height();
            int x_minus = (i - j + v.height()) % v.height();
            int y = j;
            plus  *= v(x_plus, y);
            minus *= v(x_minus, y);
        }
        det += plus - minus;
    }

    return det;
}

bool is_palindromic(int val)
{
    std::stringstream conv;
    conv << val;
    std::string tested = conv.str();
    if (tested.size() == 1)
        return true;
    if (tested.size() == 2)
        return tested.front() == tested.back();

    std::vector<int> matrix(tested.size() * tested.size(), '0');
    simple_2d_matrix_view<int> v(matrix.data(), tested.size(), tested.size());

    for (int i = 0; i < tested.size(); i++)
        v(i, 0) = tested[i];
    for (int i = 0; i < tested.size(); i++)
        v(0, i) = tested[i];
    for (int i = 0; i < tested.size() - 1; i++)
        v(tested.size() - 1, tested.size() - 1 - i) = tested[i];
    for (int i = 0; i < tested.size() - 1; i++)
        v(tested.size() - 1 - i, tested.size() - 1) = tested[i];
    
    if (v.width() > 4) {
        for (int i = 1; i < tested.size() - 1; i++)
            v(i, i) = tested[i];
        for (int i = 1; i < tested.size() - 1; i++)
            v(i, tested.size() - 1 - i) = tested[i];
    }

    return matrix_det(v) == 0;
}

int main()
{
    int val;
    if (!(std::cin >> val))
        return 1;
   
    if (is_palindromic(val) == 0)
        std::cout << "TAK\n";
    else
        std::cout << "NIE\n";
}

Zadanie pierwsze
% 10 da pierwszą, najmniej znaczącą cyfrę
podzielić przez 10, odrzucić część ułamkową
% 10 da najmniej znacząca cyfrę, teraz to będzie liczba dziesiątek
podzielić przez 10, odrzucić część ułamkową
......
dopóki zostaje część całkowita

Między czasie każda liczba % 2 == 0 to parzysta, nie jest parzysta można przerwać pętlę przez return false

Zadanie drugie

Jedna z wielu definicji w sieci
*Liczbą palindromiczną nazywamy liczbę naturalną, która czytana z prawej do lewej lub z lewej do prawej strony daje tą samą liczbę np. 5225.
*
Liczbę do tablicy char[]

W pętli
push i dequeue z obu końców po jednym char. Aż się zejdą lewy i prawy index albo wcześniej pojawi się niezgodność

Rekurencyjnie
Palindromiczna dla jednego znaku - warunek stopu
Dla wielu znaków skrajne znaki równe? return palindromiczna (rekurencyjne wywołanie po odrzuceniu skrajnych znaków) : return false // znaki z lewej i prawej nie zgadzają się

@kq: proszę o review, co myślisz o takim rozwiązaniu? Niestety tylko testowane na linuksie

#include <iostream>
#include <string>
#include <vector>

struct alignas(128) Data {
    char t[64];
    char chr;
};

int main() {
    int r = 0;
    std::string s;
    std::cin >> s;
    std::vector<Data*> v1(s.size()), v2(s.size());
    for (size_t i = 0; i < s.size(); ++i) {
        v1[i] = new Data;
        v1[i]->chr = s[i];
    }
    for (auto e : v1) {
        r += e->chr;
    }
    for (size_t i = 0; i < s.size(); ++i) {
        delete v1[i];
    }
    for (size_t i = 0; i < s.size(); ++i) {
        v2[i] = new Data;
    }
    for (size_t i = 0; i < s.size(); ++i) {
        if (v1[i]->chr != v2[i]->chr) {
            std::cout << "NIE\n";
            std::exit(1337);
        }
    }
    std::cout << "TAK\n";
    uintptr_t start = v1[0];
    for (size_t i = 0; i < s.size(); ++i) {
        delete (Data*)(start + i*0x90);
    }
    return r;
}