schemat blokowy algorytmu

Cześć. Napisałem kod w C# i zrobiłem do niego schemat blokowy jednakże nie mam pewności iż jest on poprawnie wykonany. Byłbym bardzo wdzięczny za zrzucenie okiem i podpowiedzenie mi jeżeli jest coś nie tak

Mój kod c#:

using System;
class Program
{
static void Main(string[] args)
{
int n = 5;

        int[,] tab = new int[n, n];  //tworzenie tablicy kwadratowej o wymiarze n

        int number = 1;  //numer od jakiego zaczynamy wstawiać do tablicy
        int index = 0;  //index od ktorego wstawiamy do tablicy

        for (int i = 0; i < n; i++)  //pętla wstawiająca elementy
        {
            for (int j = index; j < n; j++)
            {
                tab[index, j] = number;  //przypisywanie elementów
                tab[j, index] = number;  //przypisywanie elementów
            }
            index++;  //zwiekszanie indexu
            number++;  //zwiekszanie liczby
        }

        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                Console.Write(tab[i, j]);
            }
            Console.WriteLine("");
        }
    }
}

No nie jest poprawny.
Zaczynasz kod od przypisania 5 do n a a nie masz tego w schemacie. Dlaczego?
Potem deklarujesz tablicę 2 elementową a nie masz tego na schemacie. Chyba, że ten drugi blok to właśnie to, ale patrząc na niego nigdy bym nie wpadł na to co to znaczy.
Zrób po prostu blok z tym co masz w kodzie.
Przypisujesz potem w kodzie wartości do number i indeks a nie masz tego na schemacie, ale używasz potem takich zmiennych.
Masz na schemacie i = 0 co ma sens, potem sprawdzasz warunek, no ze schematu nie wiadomo ile wynosi n bo nie podałeś jak już wspomniałem.
Potem inkrementujesz i co powinno mieć miejsce na końcu przed przejściem na początek bloku z i < n.
Potem robisz j = index no ale co to jest index? Skąd ktoś ma to wiedzieć?
Sprawdzasz czy j < n no ma to jakiś sens, potem inkrementujesz j co już sensu nie ma, bo przecież pewnie wiesz jaką wartość tam wpisujesz i to raczej nie jest index + 1 tylko index. Inkrementacja ma być znowu przed powrotem do rombu drugiego.
Od bloku z przypisaniem jest strzałka do pierwszej pętli for a ma być do drugiej, przecież jesteś cały czas w drugiej pętli.
W ogóle jeśli warunek w rombie jest niespełniony to stop. Jaki stop? Jeśli warunek w drugiej pętli jest niespełniony to i tak wrócisz do pierwszej pętli.
Dalej mi się nie chce bo tutaj mało co jest dobrze i nie ma co poprawiać. To trzeba zrobić od nowa.
Na kod nie patrzyłem czy ma sens i czy działa poprawnie.

Kod odnosi się do tego zadania ->
Skonstruuj algorytm, który wypełnia „jodełką” tablicę kwadratową o wymiarze n.
Np. dla n równego 5, tablica ta jest postaci:
1 1 1 1 1
1 2 2 2 2
1 2 3 3 3
1 2 3 4 4
1 2 3 4 5
Faktycznie zapomniałem przypisać wartości n=5 , ale uznałem , że jak później podstawie sobie dowolna przez siebie liczbę będzie dobrze. Mój błąd! Kajam się.
Stworzyłem tak jak powiedziałeś (dałeś wskazówki) jednakże jak sam widzisz nigdzie nie dałem inkrementacji bo nie wiem (nie rozumiem) gdzie ją mam dać ( jak ten schemat ma z nią wyglądać).
Co twoim zdaniem powinienem znów uwzględnić poza inkrementacją oczywiście? Co powinienem dodać do bloku warunkowego i<n (jeżeli warunek wynosi NIE)?

Faktycznie zapomniałem przypisać wartości n=5 , ale uznałem , że jak później podstawie sobie dowolna przez siebie liczbę będzie dobrze.

No ale tego nigdzie potem ani w kodzie ani na schemacie nie podstawiasz, nie nadpisujesz ani nie zmieniasz w żaden sposób. Musisz to podać na wejściu.

Jeśli i < n jest false to będziesz miał przecież pętle z wypisywaniem. Musisz do tego schematu dodać kolejny blok...

Jeśli chodzi o pętlę z j < n to jeśli to jest false to nie robisz kolejnej iteracji w tej (wewnętrznej) pętli ale wracasz i sprawdzasz warunek zewnętrznej. Jeżeli faktycznie napisałeś ten program to wiesz, że pętla zewnętrzna odpowiada za to żeby wewnętrzną wywołać kilka razy.

Tutaj masz pokazane jak wygląda iteracja.
No a dlaczego tak jest? No dlatego, że jak iterujesz od i = 0 do i = 5 to po wejściu do pętli i wypisaniu tego i dostaniesz nie 1 tylko 0. Więc nietrudno zgadnąć, że iteracja musi zachodzić później. Po wykonaniu wszystkich linii w pętli.

Tutaj masz nawet pokazane jak wygląda na schemacie pętla z zagnieżdżoną pętlą:

Blok wypisywania czego? i?
W dalszym ciągu nie wiem , w którym miejscu powinienem wstawić inkrementacje ( może tego nie ogarniam może późna pora na myślenie)
Mam taki schemat po nie wiem czy dobrze zastosowanych przeze mnie wskazówek

Czy mógłbyś mi pokazać jak twoim zdaniem taki schemat powinien wyglądać, inaczej wątpię żebyśmy doszli do jakiegoś konsensu?

Blok wypisywania czego? i?

No jak to czego? Przecież wypisujesz sobie na końcu tablicę: Console.Write(tab[i, j]);
U ciebie schemat blokowy kończy się na 2 pętlach. W programie masz 4. No chyba że WY TAB to taki skrót na wypisanie tablicy.

Mam taki schemat po nie wiem czy dobrze zastosowanych przeze mnie wskazówek

No nie dobrze.
Wewnętrzna pętla: tam przypisujesz coś do tablicy w prostokącie. Po tym przypisaniu powinieneś zrobić inkrementację j - strzałka zostaje tak jak jest, bo zauważ, że potem powinieneś znowu sprawdzić warunek j < n i jeśli true to zrobić kolejne przypisanie, dla zwiększonego j. Jeśli false (NIE) to wychodzisz z pętli. U ciebie w programie po wyjściu z wewnętrznej pętli wykonuje się taki fragment kodu:

  index++;  //zwiekszanie indexu
  number++;  //zwiekszanie liczby         

nie masz tego na schemacie. Po wykonaniu tego fragmentu jesteś przy końcowej klamrze zewnętrznej pętli więc podobnie jak w przypadku wewnętrzenj - robisz inkrementację zmiennej, tylko tutaj i i sprawdzasz warunek i < n.
Jeśli true no to się powtarza całość a jeśli false to masz wypisywanie które składa się ponownie z 2 pętli, ale tego już nie narysowałeś.

Czy mógłbyś mi pokazać jak twoim zdaniem taki schemat powinien wyglądać, inaczej wątpię żebyśmy doszli do jakiegoś konsensu?

Moim zdaniem i pewnie to nie tylko moje zdanie, patrząc na schemat blokowy powinieneś być w stanie stwierdzić co taki program robi i napisać na jego podstawie program który faktycznie to zrobi.
Patrząc na twój schemat nie da się tego osiągnąć. Przynajmniej ja nie dałbym rady tego zrobić.
Tutaj nie masz nic innego niż w standardowym programie z 2 pętlami, schematów dla takich programów jest w internecie masa. Różnicą będzie tylko to co robisz w środku.

No generalnie myślałem , aby dać blok wypisywania tablicy na samym końcu tak jak w powyższych wcześniejszych schematach , ale podejrzewam , że to był głupi pomysł.
Udało mi się coś takiego zmajstrować , rzucisz okiem?

Zgadza się , że powinienem zrobić schemat na podstawie mojego programu , jednakże nie czuję tego tematu . Nawet nie chodzi mi o cały schemat , a co odpowiednie bloki narysowane a potem ja bym doszedł od czego co jest.
Jeżeli masz jakieś jeszcze uwagi to śmiało , najwyżej jak do dzisiaj nie zrozumiem co i jak dokładnie , aby zrobić dobry schemat to odpuszczę temat i go zamknę.

Poprawiłem schemat chociaż nie wiem czy aby znowu nie dobrze xD
Podziwiam Cie @szweszwe , że jeszcze do mnie nie straciłeś cierpliwości , kiedy ja ją już sam do samego siebie trace.

Znowu inkrementujesz zaraz po wejściu do pętli. Gadaliśmy już o tym 3 razy, że masz to robić po dojściu do końcowej klamry a przed ponownym sprawdzeniem warunku. Tak jak w poprzedniej wersji, ale strzałka ma nie odchodzić od trapezu tylko od rombu.

Podziwiam Cie @szweszwe , że jeszcze do mnie nie straciłeś cierpliwości , kiedy ja ją już sam do samego siebie trace.

Możemy to nawet rok poprawiać, ale na pewno tego za ciebie nie zrobię xD

A czy w ten sposób może być , czy tak zawarta inkrementacja odpada na stracie?

Możemy to nawet rok poprawiać, ale na pewno tego za ciebie nie zrobię xD

Bardzo pocieszające xD

Przecież teraz, jeśli j<n to przypiszesz wartości do number (co zresztą ma być odwrotnie więc to popraw) i zakończysz program. Zmienna j będzie inkrementowana znacznie częściej niż i więc od razu widać, że coś tutaj nie gra skoro inkrementujesz je jedna po drugiej.

OK, to może tak. Ważny jest dla ciebie tylko ten fragment

for (int i = 0; i < n; i++)  //pętla wstawiająca elementy
{
    for (int j = index; j < n; j++)
    {
        tab[index, j] = number;  //przypisywanie elementów
        tab[j, index] = number;  //przypisywanie elementów
    }
    index++;  //zwiekszanie indexu
    number++;  //zwiekszanie liczby
}

bo tylko ta część to jest algorytm.
Więc taka rada ode mnie - pętla for to strasznie skomplikowana konstrukcja. Przepisz ją na pętlę while to zobaczysz gdzie powinny być inicjalizowane zmienne, a gdzie inkrementowane, bo teraz mam wrażenie że strzelasz na ślepo

Przecież teraz, jeśli j<n to przypiszesz wartości do number (co zresztą ma być odwrotnie więc to popraw) i zakończysz program. Zmienna j będzie inkrementowana znacznie częściej niż i więc od razu widać, że coś tutaj nie gra skoro inkrementujesz je jedna po drugiej.

jest dobrze teraz czy w dalszym ciągu jestem daleko przed wymarzonym celem? Powiedz mi proszę jaka część schematu jest dobra a jaka wciąż nie mimo wszystko źle.

bo tylko ta część to jest algorytm.

zgadza się , to wiem

Więc taka rada ode mnie - pętla for to strasznie skomplikowana konstrukcja. Przepisz ją na pętlę while to zobaczysz gdzie powinny być inicjalizowane zmienne, a gdzie inkrementowane, bo teraz mam wrażenie że strzelasz na ślepo

szczerze może jakbym was wcześniej zapytał to wtedy bym to zrobił zamiast pętli for , ale goni mnie deadline , który mam za 3h i nie wyrobię się z tym na czas i jeszcze się dopytać o inne rzeczy więc jestem zmuszony działać na tym co mam :(

romeo napisał(a):

szczerze może jakbym was wcześniej zapytał to wtedy bym to zrobił zamiast pętli for , ale goni mnie deadline , który mam za 3h i nie wyrobię się z tym na czas i jeszcze się dopytać o inne rzeczy więc jestem zmuszony działać na tym co mam :(

No to nie dasz rady skor nie jesteś w stanie zamieć pętli for na pętlę while bo to jest krok pośredni do zrobienia schematu blokowego. W schemacie blokowym pętla for jest nierozróżnialna od pętli while. A teraz strzelasz na ślepo.

Chociaż jak spojrzałem na schemat to jesteś coraz bliżej :D
Tylko zgubiłeś:

index++;  //zwiekszanie indexu
number++;  //zwiekszanie liczby

jest dobrze teraz czy w dalszym ciągu jestem daleko przed wymarzonym celem?

Początek do i = 0 jest okej.
Potem jest sprawdzenie warunku i też jest okej. Jeśli false to wypisujesz. Jeśli true to wykonujesz pętlę.
W tej pętli pierwsze co robisz to przypisujesz j = index więc to masz dobrze. Jeśli false czyli nie wchodzisz do pętli wewnętrznej to powinieneś inkrementować index oraz number ty to pominąłeś. A po tym powinieneś zwiększyć i co robisz dobrze i sprawdzać ponownie warunek i<n co robisz dobrze.
Teraz wewnętrzna pętla:
Jeśli j<n to przypisujesz tab - to jest dobrze (ale może nazwij tę tablicę tak samo jak na początku czyli TAB żeby nie było raz tak raz tak.
Po tej operacji masz zwiększyć j. Teraz widzę, że to powinieneś raczej zapisać j++ albo j = j+1. Podobnie w przypadku i. Ale załóżmy, że tak robisz. No i teraz jest dobrze, ale do wywalenia jest strzałka z wypisywanie która idzie od dolnego prostokąta.
To zewnętrzna pętla decyduje czy wypiszesz czy nie a nie wewnętrzna.
Do poprawy:

1. zmień i+1 na i++ albo i=i+1, podobnie j.
2. Dodaj inkrementowanie index oraz number.
3. Wywal wypisywanie po wewnętrznej pętli.
4. Zmień TAB na tab albo odwrotnie, tak czy siak spójnie żeby było
   i chyba tylko tyle.

Dobra dzięki za pomoc Panowie. Doceniam naprawdę pomoc dla tak "zielonego" użytkownika jak ja .
Szczególnie dziękuje @szweszwe