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;
}

Wersja zadania nr 1 pod Windows 10 / gcc 9.3.0

#include <iostream>
using namespace std;

int main() {
	int a;
	while(cin >> a) {
		int star{a};
		bool tak = true;
		while(a && !((a % 10) % 2)) {
			a /= 10;
		}
		tak = a ? false : tak;
		cout << star << "?: " << (tak ? "TAK" : "NIE") << endl;
	}
	return 0;
}

https://ideone.com/v6k0d0

Muszę się poprawić, poprzedni algorytm zwracał błędne wyniki dla ok 1‰ przypadków (ok 0.8 na tysiąc), tutaj wersja poprawiona

#include <algorithm>
#include <iostream>
#include <sstream>
#include <iterator>
#include <vector>

int primes[] = {
6337,9067,6551,6323,8609,9677,7907,9343,9803,7561,11411,10657,6607,9689,10457,
9277,11369,9907,7297,8681,10477,8443,9973,10589,10957,7039,7307,9749,9349,6907,
10427,10709,11471,11087,8263,6151,6581,8009,10613,7589,9173,8647,8117,10781,
8093,7487,9227,11299,7901,9049,7393,6397,9421,7963,8171,6793,8929,9871,8011,
10091,8893,11159,8237,6857,10177,11399,8887,6599,8039,9319,8863,8963,10847,
6737,8123,9439,11383,11171,7759,9601,10753,9791,9661,10253,11503,10883,6997,
6521,8731,8761,9833,6977,8377,10247,6971,8527,7789,9161,10529,11621,8017,7127,
8719,10259,7549,8821,8699,11149,8167,8707,10141,11083,7187,9187,10729,7867,6317,
6679,6961,6991,9091,11527,9629,7207,9739,9157,7793,10007,9311,10711,8147,8161,
8623,8629,8369,7643,6871,7459,10267,6761,9433,10597,7829,7541,10459,7457,7699,
11467,7517,11329,6359,10631,8287,10301,7877,10099,6361,8521,7937,8663,9901,9109,
9403,8291,10343,8363,10453,6863,8353,7499,6733,7559,6389,6911,8389,6689,10303,
10739,10837,6967,8233,8111,9059,8599,10771,11497,8971,6829,9613,6673,7109,8447,
9203,10333,6473,6311,8501,6299,7069,8311,7639,7213,6959,8779,6637,8089,9199,
11273,9257,10111,7333,10987,6427,11251,7727,6709,7951,9631,10889,10313,6659,
10601,6247,8467,7417,11047,8677,11239,7321,9769,10973,11587,6691,6269,9413,
11003,7369,10501,6197,7577,9859,7433,8689,9397,11597,9001,10867,8839,11161,
10321,7591,8693,11549,10331,10133,7253,8293,11113,10103,11593,7219,7919,8209,
};

static_assert(std::size(primes) > 256);

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);
	}
};

int sign(std::vector<int> const& vec)
{
    int cnt = 0;
    for(int i = 0; i < vec.size(); i++)
        for(int j = i + 1; j < vec.size(); j++)
            if (vec[i] > vec[j]) cnt++;
    return cnt % 2 == 0 ? 1 : -1;
}

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

    std::vector<int> indices(v.width());
    std::iota(indices.begin(), indices.end(), 0);

    do {
        long long val = 1;
        for(int x = 0; x < v.height(); x++) {
            int y = indices[x];
            val *= v(x, y);
        }
        det += val * sign(indices);
    } while(std::next_permutation(indices.begin(), indices.end()));

    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(std::begin(primes), std::end(primes));
    matrix.resize(tested.size() * tested.size());
    simple_2d_matrix_view<int> v(matrix.data(), tested.size(), tested.size());

    for (int i = 0; i < tested.size(); i++)
        v(0, i) = tested[i] - '0';
    for (int i = 0; i < tested.size(); i++)
        v(tested.size() - 1, tested.size() - 1 - i) = tested[i] - '0';

    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";
}

Dziękuję wszystkim za zainteresowanie i pomoc.