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

0

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.

5

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

3

Rozwiązanie na Windows czy Linux?

0

@kq: Windows

6

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

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

0

@kq: Dzięki wielkie za pomoc.

6

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

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ę

2

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

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0