Sumowanie elementów tablicy

Cześć, mam do napisania program, który sumowałby elementy macierzy tzw. ślimakiem (zdj niżej), zaznaczę chodzi tu o macierze prostokątne. Program napisałem w 90%, ale problem okazał się z tym ślimakiem, ktoś poradziłby? Dodatkowo po wpisaniu danych i elementów program szaleje i też nie wiem do końca w czym problem.

#include<iostream>
#include<stdio.h>
#include<cstdlib>
#include<conio.h>
#include<iomanip>
#include <locale.h>
using namespace std;
void menu ()
{
    cout<<endl<<endl;
    cout<<"    -------------"<<endl;
    cout<<"   | Menu główne |"<<endl;
    cout<<"    -------------"<<endl;
    cout<<"1. Kalkulator. "<<endl;
    cout<<"0. Wyłącz program."<<endl;

    cout<<endl<<endl;
}
void rozmiar1(int &wi1, int &kol1)
{
    cout<<"Wpisz liczbę kolumn oraz wierszy macierzy: "<<endl;
    cout<<"Wiersze: ";
    cin>>wi1;
    cout<<"Kolumn: ";
    cin>>kol1;
}
void def ()
{
    system("cls");
    cout<<"Nie ma takiej opcji w menu"<<endl;
}
void poczatek ()
{
    cout<<"    --------------------------------------------------------------------------"<<endl;
    cout<<"   | Program obliczajacy sume macierzy poprzez wybor elementow tzw. slimakiem |"<<endl;
    cout<<"    --------------------------------------------------------------------------"<<endl;

    cout<<endl;
    cout<<"Na początku proszę o wypisanie macierzy."<<endl;
    cout<<endl;
}
void dane(float mac1[][10], int wi1, int kol1)
{
    int i,j;
    cout<<"Wpisz "<<wi1*kol1<<" Elementy macierzy: "<<endl;
    for(i=0; i<wi1; i++)
        for(j=0; j<kol1; j++)
        {
            cout << "Wpisz wartość elementu A" << i + 1 << j + 1 << " : ";
            cin>>mac1[i][j];
        }
}
void dodawanie(float mac11[][10], float macdod[][10], int wi1, int kol1)
{
    int i, j;
    system("cls");
    {
        {
            cout<<"Powstała macierz to:"<<endl;
            for(i=0; i<wi1; i++)
            {
                for(j=0; j<kol1; j++)
                {
                    macdod[i][j] = mac11[i][j];
                    cout<<macdod[i][j]<<"   ";
                }
                cout<<endl;
            }
        }
    }

}

void zdane(int wi11, int kol11)
{
    if(wi11==0 || kol11==0)
    {
        cout<<"Złe dane";
        exit(0);
    }
}
int main()
{
    int wi1, kol1, wi2;
    char wybor;
    float mac1[10][10], macdod[10][10];
    setlocale(LC_CTYPE, "Polish");
    poczatek();
    rozmiar1(wi1, kol1);
    zdane(wi1, kol1);dane(mac1, wi1, kol1);
    for(;;)
    {
        menu();
        wybor=getch();
        switch (wybor)
        {
        case '1':
            dodawanie(mac1, macdod, wi1, kol1);
            break;
        case '2':
            system("cls");
            dane(mac1, wi1, kol1);
            break;
        case '0':
            exit(0);
            break;
        default:
            def();
        }

    }
    return 0;
}

Czy wiesz że suma elementów sumowanych w różnej kolejności będzie taka sama?

_13th_Dragon napisał(a):

Czy wiesz że suma elementów sumowanych w różnej kolejności będzie taka sama?

Ale głównym założeniem zadania nie jest ogólnie obliczenie sumy, tylko obliczenie sumy danym sposobem. Tak, wiem, że suma będzie taka sama niezależnie od sposobu, ale na tym polega właśnie trudność tego zadania, aby zastosować konkretny sposób.

@xVouq:

Jak na razie nie zrobiłeś ŻADNEGO sumowania

Nie podjąłeś nawet PRÓBY gryzienia się z tematem.
Masz jakieś wklejki z netu, przy czym nawet nazwy funkcji kłamią.

Dobrze wiesz, że nie toleruje się tu żądania "zróbcie za mnie".
Dlatego wkleiłeś jakiś odjazdowy kod z innej bajki, żeby nie było "na pusto" - sądzisz, ze my tu mamy problemy z myśleniem?

ps. a za system(cls), w połączeniu z conio.h to ja cię kiedyś wycałuję.

ZrobieDobrze napisał(a):

@xVouq:

Jak na razie nie zrobiłeś ŻADNEGO sumowania

Nie podjąłeś nawet PRÓBY gryzienia się z tematem.
Masz jakieś wklejki z netu, przy czym nawet nazwy funkcji kłamią.

Dobrze wiesz, że nie toleruje się tu żądania "zróbcie za mnie".
Dlatego wkleiłeś jakiś odjazdowy kod z innej bajki, żeby nie było "na pusto" - sądzisz, ze my tu mamy problemy z myśleniem?

ps. a za system(cls), w połączeniu z conio.h to ja cię kiedyś wycałuję.

Ok, jestem początkujący, ale nie musisz mnie mieszać z innymi. Wkleiłem tutaj ten fragment dla wzoru, bo jak zaznaczyłem "mam problem z obliczeniem sumy metodą ślimaka". Ale jak już wymagacie, żebym musiał się wybielać publicznie to okej, wkleję również pierwotną wersje mimo, że nie wiem po co, skoro jest to kalkulator obliczeń dla dwóch macierzy...

#include<iostream>
#include<stdio.h>
#include<cstdlib>
#include<conio.h>
#include<iomanip>
#include <locale.h>
using namespace std;
void menu ()
{
    cout<<endl<<endl;
    cout<<"    -------------"<<endl;
    cout<<"   | Menu główne |"<<endl;
    cout<<"    -------------"<<endl;
    cout<<"1. Odejmowanie. "<<endl;
    cout<<"2. Dodawanie. "<<endl;
    cout<<"3. Mnożenie. "<<endl;
    cout<<"4. Wprowadź inne dane do podanych macierzy."<<endl;
    cout<<"0. Wyłącz program."<<endl;

    cout<<endl<<endl;
}
void nrowne ()
{
    cout << "Bład! Liczba wierszy i kolumn jest różna dodawanie i odejmowanie jest niewykonalne"<<endl;
}
void menu4 ()
{
    cout << "Bład! Liczba wierszy pierwszej kolumn jest różna od liczby wierszy drugiej macierzy.  "<<endl;
    cout << "Nie można wykonaæ podanej operacji! "<<endl;
}
void rozmiar1(int &wi1, int &kol1)
{
    cout<<"Wpisz liczbę kolumn oraz wierszy pierwszej macierzy: "<<endl;
    cout<<"Wiersze:";
    cin>>wi1;
    cout<<"Kolumn:";
    cin>>kol1;
}
void rozmiar2(int &wi2, int &kol2)
{
    cout<<"Wpisz liczbę kolumn oraz wierszy drugiej macierzy: "<<endl;
    cout<<"Wiersze:";
    cin>>wi2;
    cout<<"Kolumn:";
    cin>>kol2;
}
void def ()
{
    system("cls");
    cout<<"Nie ma takiej opcji w menu"<<endl;
}
void początek ()
{
    cout<<"    -----------------------------------------------------------"<<endl;
    cout<<"   | Program wykonujący podstawowe typy obliczeń na macierzach |"<<endl;
    cout<<"    -----------------------------------------------------------"<<endl;

    cout<<endl;
    cout<<"Na początku proszę o wypisanie interesujących Cię macierzy."<<endl;
    cout<<endl;
}

void mnowypi(float mnoo[][10], int wi11, int kol22)
{
    int i,j;
//Graficzne przedstawienie wyniku mnożenie macierzy.
    cout << endl << "Mnożenie macierzy: " << endl;
    for(i=0; i<wi11; ++i)
    {
        for(j=0; j<kol22; ++j)
        {
            cout<< mnoo[i][j]<<"  ";
            if(j == kol22-1)
                cout<<endl;
        }
    }
}
void dane(float mac1[][10], float mac2[][10], int wi1, int kol1, int wi2, int kol2)
{
    int i,j;
    cout<<"Wpisz "<<wi1*kol1<<" Elementy pierwszej macierzy: "<<endl;
    for(i=0; i<wi1; i++)
        for(j=0; j<kol1; j++)
        {
            cout << "Wpisz wartość elementu A" << i + 1 << j + 1 << " : ";
            cin>>mac1[i][j];
        }
    cout<<"Wpisz "<<wi2*kol2<<" Elementy drugiej macierzy: "<<endl;
    for(i=0; i<wi2; i++)
        for(j=0; j<kol2; j++)
        {
            cout << "Wpisz wartość elementu B" << i + 1 << j + 1 << " : ";
            cin>>mac2[i][j];
        }
}
void odejmowanie(float mac11[][10], float mac22[][10], float macodej[][10], int wi1, int kol1, int wi2, int kol2)
{
    int i,j;
    system("cls");
    {
        if(wi1==wi2 && kol1==kol2)
        {
            cout<<"Powstała macierz to:"<<endl;
            for(i=0; i<wi1; i++)
            {
                for(j=0; j<kol1; j++)
                {
                    macodej[i][j] = mac11[i][j] - mac22[i][j];
                    cout<<macodej[i][j]<<"   ";
                }
                cout<<endl;
            }
        }
        else
            nrowne();
    }
}
void dodawanie(float mac11[][10], float mac22[][10], float macdod[][10], int wi1, int kol1, int wi2, int kol2)
{
    int i, j;
    system("cls");
    {
        if(wi1==wi2 && kol1==kol2)
        {
            cout<<"Powstała macierz to:"<<endl;
            for(i=0; i<wi1; i++)
            {
                for(j=0; j<kol1; j++)
                {
                    macdod[i][j] = mac11[i][j] + mac22[i][j];
                    cout<<macdod[i][j]<<"   ";
                }
                cout<<endl;
            }
        }
        else
            nrowne();
    }

}
void mnozenie(float mac1[][10], float mac2[][10], float mno[][10], int wi1, int kol1, int wi2, int kol2)
{
    int i,j,k;
    system("cls");
    {
        if(kol1==wi2)
        {
            //Zainicjowanie elementów macierzy mno 0.
            for(i=0; i<wi1; ++i)
                for(j=0; j<kol2; ++j)
                {
                    mno[i][j]=0;
                }

            // Mnozenie macierzy mac1 oraz mac2.
            for(i=0; i<wi1; ++i)
            {
                for(j=0; j<kol2; ++j)
                {
                    for(k=0; k<kol1; ++k)
                    {
                        mno[i][j] += mac1[i][k] * mac2[k][j];
                    }
                }

            }
            mnowypi( mno, wi1, kol2);
        }

        else
        {
            menu4();
        }
    }

}
void zdane(int wi11,int wi22,int kol11,int kol22)
{
    if(wi11==0 || wi22==0 || kol11==0 || kol22==0)
    {
        cout<<"Złe dane";
        exit(0);
    }
}
int main()
{
    int wi1, kol1, wi2, kol2;
    char wybor;
    float mac1[10][10], mac2[10][10], macodej[10][10], macdod[10][10], mno[10][10];
    setlocale(LC_CTYPE, "Polish");
    poczatek();
    rozmiar1(wi1, kol1);
    rozmiar2(wi2, kol2);
    zdane(wi1, wi2, kol1, kol2);
    dane(mac1, mac2, wi1, kol1, wi2, kol2);
    for(;;)
    {
        menu();
        wybor=getch();
        switch (wybor)
        {
        case '1':
            odejmowanie(mac1, mac2, macodej, wi1, kol1, wi2, kol2);
            break;
        case '2':
            dodawanie(mac1, mac2, macdod, wi1, kol1, wi2, kol2);
            break;
        case '3':
            mnozenie( mac1, mac2, mno, wi1, kol1, wi2, kol2);
            break;
        case '4':
            system("cls");
            dane(mac1, mac2, wi1, kol1, wi2, kol2);
            break;
        case '0':
            exit(0);
            break;
        default:
            def();
        }

    }
    return 0;
}

@xVouq:

Czemu ma służyć wklejenie jeszcze większej ilości kodu nie na temat?
Zasadą wklejania kodu na forach programistycznych jest MVP
https://en.wikipedia.org/wiki/Minimum_viable_product

GDYBYM widział, ze walczysz po X z jakąś pętlą do N, zmniejszasz N, idziesz po Ykach do M, idziesz po Xach od N-1 do prawie jeden ...

#include <iostream>
#include <iomanip>
#include <vector>
using namespace std;

int main()
{
	const int Y=5,X=8;
	int Lf=0,Rt=X-1,Tp=0,Bt=Y-1,i=0;
	vector<vector<int>> tb(Y,vector<int>(X));
	
	while((Lf<=Rt)&&(Tp<=Bt))
	{
	   for(int x=Lf;x<=Rt;++x) tb[Tp][x]=i++;
	   ++Tp;
	   for(int y=Tp;y<=Bt;++y) tb[y][Rt]=i++;
	   --Rt;
	   for(int x=Rt;x>=Lf;--x) tb[Bt][x]=i++;
	   --Bt;
	   for(int y=Bt;y>=Tp;--y) tb[y][Lf]=i++;
	   ++Lf;
	}
	for(int y=0;y<Y;++y,cout<<endl) for(int x=0;x<X;++x) cout<<setw(4)<<tb[y][x];	
	return 0;
}

Dawno nie wrzuciłem żadnego gotowca to czuję się usprawiedliwiony. Fajny przykład overengineeringu tym nie mniej to prostacka implementacja przesuwania palcem po kartce więc do celów edukacyjnych mogłoby chyba być.

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

struct Point {size_t x{0},y{0};};
struct Range {size_t min{0},max{0};};

struct SnailIterator
{
    SnailIterator(size_t maxX, size_t maxY)
        : m_rangeX{0, maxX-1}, m_rangeY{0, maxY-1}
    {
    }

    std::optional<Point> operator()(const Point &prev)
    {
        const auto isWithin = [](size_t p, const Range &range) { return p >= range.min && p <= range.max;};
        const auto isPointWithin = [&](const Point &p) { return isWithin(p.x, m_rangeX) && isWithin(p.y, m_rangeY) ;};
        const auto pointOrNullopt = [&](const Point &p) { return isPointWithin(p) ? std::optional{p} : std::nullopt; };
        
        if(!isPointWithin(prev))
            return std::nullopt;
        
        if(m_direction == Direction::right)
        {
            if(prev.x < m_rangeX.max)
                return Point{prev.x + 1, prev.y};

            m_direction = Direction::down;
            ++m_rangeY.min;
            return pointOrNullopt(Point{prev.x, prev.y + 1});
        }

        if(m_direction == Direction::down)
        {
            if(prev.y < m_rangeY.max)
                return Point{prev.x, prev.y + 1};

            m_direction = Direction::left;
            --m_rangeX.max;
            return pointOrNullopt(Point{prev.x - 1, prev.y});
        }

        if(m_direction == Direction::left)
        {
            if(prev.x > m_rangeX.min)
                return Point{prev.x - 1, prev.y};

            m_direction = Direction::up;
            --m_rangeY.max;
            return pointOrNullopt(Point{prev.x, prev.y - 1});
        }

        if(m_direction == Direction::up)
        {
            if(prev.y > m_rangeY.min)
                return Point{prev.x, prev.y - 1};

            m_direction = Direction::right;
            ++m_rangeX.min;
            return pointOrNullopt(Point{prev.x + 1, prev.y});
        }

        return std::nullopt;
    }

private:
    enum class Direction {right, down, left, up} m_direction {Direction::right};
    Range m_rangeX, m_rangeY;
};

int main()
{
    size_t nums[4][4] = {
        {1,2,3,   4},
        {12,13,14,5},
        {11,16,15,6},
        {10,9,8,  7}
    };

    SnailIterator next(4,4);
    for(auto it = std::optional<Point>{Point{}}; it; it = next(*it) )
        std::cout << nums[it->y][it->x] << " ";

    std::cout << "\n";
    size_t nums_2[4][5] = {
        {1,2,3,4,5},
        {14,15,16,17,6},
        {13,20,19,18,7},
        {12,11,10,9,8}
    };

    SnailIterator next_2(5,4);
    for(auto it = std::optional<Point>{Point{}}; it; it = next_2(*it) )
        std::cout << nums_2[it->y][it->x] << " ";
    
    return 0;
}

@_13th_Dragon:

@several:
Jeszcze mam pytanie poboczne, czy po wprowadzeniu tego mojego programu z postu głównego do konsoli też wam tak program szaleje po podaniu danych? I czym to może być spowodowane, bo mimo wszystko już chciałbym na tym bazować.

xVouq napisał(a):

@_13th_Dragon:

@several:
Jeszcze mam pytanie poboczne, czy po wprowadzeniu tego mojego programu z postu głównego do konsoli też wam tak program szaleje po podaniu danych? I czym to może być spowodowane, bo mimo wszystko już chciałbym na tym bazować.

Ja tam nawet nie będę próbować, od razu widać że nie tędy droga: poczynając od menu, poprzez nazewnictwo, iterowaniem kończąc.
Co do menu: https://4programmers.net/Forum/C_i_C++/352675-stos_funkcje_zapisu_i_odczytu_pliku_binarnego?p=1772198#id1772198

Uruchomię ten program pod warunkiem usunięcia zależności od conio.h i zastąpięnia jego funkcjonalności czymś standardowym.

@several: Postaram się zastąpić, ale program już nie świruje, do...while i exit (0) zamiast case zerowego poradziły.

Ustal sobie limity minX, maxX, minY, maxY i jakiś kierunek.
kierunek może się zmieniać tylko w jedną stronę (prawo -> dół -> lewo ->góra ...)
Za każdym razem jak zmienisz kierunek musisz zmniejszyć odpowiedni limit.

xVouq napisał(a):

_13th_Dragon napisał(a):

Czy wiesz że suma elementów sumowanych w różnej kolejności będzie taka sama?

Ale głównym założeniem zadania nie jest ogólnie obliczenie sumy, tylko obliczenie sumy danym sposobem. Tak, wiem, że suma będzie taka sama niezależnie od sposobu, ale na tym polega właśnie trudność tego zadania, aby zastosować konkretny sposób.

To nie jest "trudność tego zadania", tylko durnota tego kto to wymyślił.

To już lepiej byłoby je wyrzucić do listy zachowującej kolejność, żeby było widać faktycznie jak iterowałeś po tych elementach.

#include <iostream>

using namespace std;

int main()
{
    int x=5;
    int y=5;
    int i=0,j=0;
    int suma=0;
    int mat[10][10];
 
 for (i=0;i<10;i++)
 for (j=0;j<10;j++)
 {
 mat[i][j]=0; 
 }
    
    mat[x][y]=0;
    
    x=x+1;
    mat[x][y]=1;    
    
    
    y=y+1;
    mat[x][y]=2; 
    
    
    x=x-1;
    mat[x][y]=3;
    
    x=x-1;
    mat[x][y]=4;
    
    y=y-1;
    mat[x][y]=5;
    
 
 for (i=0;i<10;i++)
 for (j=0;j<10;j++)
 {
 suma=suma+mat[i][j]; 
 }

 cout << suma;
}