Magisches Quadrat (magic square)

C++ :: Aufgabe #332

1 Lösung

Fortgeschrittener - C++ von JKooP - 28.02.2021 um 10:54 Uhr

Von einem Magischen Quadrat spricht man, wenn
- alle Zahlen nur einmal vorkommen und die Summe der Zahlen
- aller Zeilen,
- aller Spalten sowie
- der Diagonalen immer gleich ist.

Beispiele für Magische Quadrate sind als Bilder angehängt.

Schreibe eine Methode/Funktion, mit der man überprüfen kann, ob es sich bei einer
beliebig großen quadratischen Matrix um ein solch magisches Quadrat handelt.
Zusätzlich kann, bei positiver Prüfung, auch die gesuchte Summe ausgegeben werden.

Zur Darstellung der Matrix können je nach Programmiersprache oder Vorliebe Arrays,
Vektoren oder auch generische Listen verwendet werden.

Viel Spaß

Frage einsehen (1)

Bitte melden Sie sich an um zur Aufgabenbeschreibung eine Frage zu stellen.

Frage stellen

Bitte melden Sie sich an um eine Lösung einzureichen.

Lösung einreichen

Lösungen:

von JKooP (18090 Punkte) - 23.05.2021 um 10:33 Uhr

C++ 17

C-Code

#include "Magic_Square.h"

int main()
{
    vector<vector<int>>m{
    { 23, 4, 18, 1, 19 },
    { 5, 10, 15, 14, 21 },
    { 6, 17, 13, 9, 20 },
    { 24, 12, 11, 16, 2 },
    { 7, 22, 8, 25, 3 } };

    Magic_Square ms{m};
    cout << ms;
}

C-Code

#pragma once
#include <iostream>
#include <vector>
using namespace std;

class Magic_Square
{
private:
	vector<vector<int>> magic_;
	int cs_{ compare_sum() };
	void transpose(vector<vector<int>>& v);
	bool sum_rows_equal();
	bool sum_diagonals_equal();
public:
	Magic_Square(const vector<vector<int>>& magic) : magic_{ magic } {}
	bool is_magic_square();
	int compare_sum();
	friend ostream& operator<<(ostream& os, Magic_Square& ms);
};

.cpp

C-Code

#include "Magic_Square.h"

int Magic_Square::compare_sum()
{
    auto sum{ 0 };
    for (const auto& i : magic_[0])
        sum += i;

    return sum;
}

ostream& operator<<(ostream& os, Magic_Square& ms)
{
    os << "Das ist " << (ms.is_magic_square() ? "" : "k") << "ein Magisches Quadrat!\n";
    return os;
}

void Magic_Square::transpose(vector<vector<int>>& v)
{
    if (v.size() == 0)
        return;

    vector<vector<int>> tv(v[0].size(), vector<int>());

    for (size_t i = 0; i < v.size(); i++)
        for (size_t j = 0; j < v[i].size(); j++)
            tv[j].push_back(v[i][j]);

    v = tv;
}

bool Magic_Square::sum_rows_equal()
{
    for (const auto& i : magic_) {
        auto sum{ 0 };

        for (const auto& k : i)
            sum += k;

        if (sum != cs_)
            return false;
    }
    return true;
}

bool Magic_Square::sum_diagonals_equal()
{
    auto max{ magic_[0].size() };
    auto sum_left{ 0 };
    auto sum_right{ 0 };

    for (size_t i = 0; i < max; i++)
    {
        sum_left += magic_[i][i];
        sum_right += magic_[i][max - 1 - i];
    }

    return sum_left == cs_ && sum_right == cs_;
}

bool Magic_Square::is_magic_square()
{
    auto rows{ sum_rows_equal() };
    auto diagonals{ sum_diagonals_equal() };
    transpose(magic_);
    auto columns{ sum_rows_equal() };
    return rows == diagonals == columns;
}

Bitte melden Sie sich an um eine Kommentar zu schreiben.

Kommentar schreiben