Specyficzna wieża hanoi

0

Cześć. Jestem w klasie 1 TI i dostałem do napisania projekt w pascalu(chciałem w c++ ale nauczyciel mi nie pozwolił, bo jeszcze nie mieliśmy c++, mimo, że bardziej umiem c++ niż pascala). Nie znam się wgl na pascalu, tylko to co było na lekcjach, czyli niewiele. Napisałem już, ale nie działa mi to do końca. Co prawda kompiluje się bezbłędnie, ale: w fpc występuje problem 201 w trakcie działania, a w dev pascal nie ma problemu, ale też nie działa jak należy. Sądzę, że źle sformułowałem warunki, ale nie wiem jak w pascalu robi się inaczej.
Co do warunków to w głównej pętli, gdzie też są wykonywane zmiany na tablicy, jeden warunek się wypełnia, a następnie w fpc błąd 201, a w dev pascal wyrzuca z pętli. Więc na pewno coś źle z warunkami. A i jeszcze w pętli sprawdzania poprawnej wartości określającej długość tablicy w osi y to też warunek nie działa. Nawet gdy jest false to przechodzi do true. Warunek jest zbudowany z dwóch innych, połączony and. Gdy jest prosty warunek to działa.

Proszę o pomoc, a kod wygląda tak(dorzucam do załącznika również):

program hanoi;
uses crt;
var
x,y,i,j,t,z,k,l1,l2,l3,l4,l5:integer;
tab:array [1..3,1..100] of integer; // Deklaracja tablicy 3 x 100
// Objasnienie zmiennych
// x - dlugosc w osi x
// y - ilosc klockow(os y)
// z - wartosc poczatkowa(sprawdzanie poprawnosci wprowadzania ilosci klockow)
// t - prawidlowa wartosc
// i - podglad tablicy(drugi index)
// j - podglad tablicy(pierwszy index)
// k - komorka o indexie 2 na osi x(koncowa)
// l1 - licznik indexu osi x, wartosc komorki, ktory on opisuje jest kopiowana do l2
// l2 - licznik indexu osi x, wartosc komorki, ktory on opisuje jest zastapiona przez l1
// l3 - licznik indexu osi y (x-2)
// l4 - licznik indexu osi y (x-1)
// l5 - licznik indexu osi y (x-0)


// Start - procedura wyswietlania aktualnego stanu tablicy
procedure stan_tablicy;
begin
for i:=1 to y do
begin
     for j:=1 to x do
     begin
     write(' ',tab[j][i]);
     end;
     writeln(' ');
end;
delay(1000);
clrscr();
end;
// Koniec - procedura wyswietlania aktualnego stanu tablicy

begin
x:=3;

writeln('Witaj w programie "Wieza Hanoi"');
writeln();
writeln('Wprowadz liczbe okreslajaca wysokosc wiezy(min 2,max 100)');
// Poczatek sprawdzania poprawnej wartosci
z:=32767;
t:=0;
repeat
readln(y);
               if ((y<=1) and (y>=101)) then
               begin
               t:=t+1;
               writeln('Nieprawidlowa wartosc, sprobuj jeszcze raz');
               end
               else
               begin
               t:=z;
               end;
until (t=z);
// Koniec sprawdzania poprawnej wartosci
writeln();

// Poczatek inicjacji wartosci tablicy
for i:=1 to y do
begin
        j:=1;
        tab[j][i]:=i;
                for j:=2 to x do
                begin
        tab[j][i]:=0;
                end;
end;
// Koniec inicjacji wartosci tablicy

writeln('Wieza ma rozmiary: ',x,' x ',y,' i na poczatku wyglada nastepujaco:');
writeln();
// Poczatek podgladu tablicy
for i:=1 to y do
begin
     for j:=1 to x do
     begin
     write(' ',tab[j][i]);
     end;
     writeln(' ');
end;
delay(3000);
clrscr();
// Koniec podgladu tablicy i czyszczenie stanu ekranu(nastepuje przejscie do wiezy)

stan_tablicy;

k:=x-1;
l1:=1;
l2:=x;
l3:=1;
l4:=y;
l5:=y;

repeat // Start przetwarzania wiezy
        
//
if ((tab[3][y]=0) and (tab[2][y]=0)) or ((tab[2][y]=0) and (tab[1][y]=0)) or ((tab[1][y]=0) and (tab[3][y]=0)) then // gdy na osi x w dwoch komorkach na dole jednoczesnie sa dwa 0
begin
        if (tab[3][y]=0) then
        begin
                if ((l1=1) and (l2=3)) then
                begin
                        if (tab[l1][l3]>=1) then
                        begin
                        tab[l2][l5]:=tab[l1][l3];
                        tab[l1][l3]:=0;
                        l3:=l3+1;
                        l1:=l1+1;
                        l2:=l2-2;
                        stan_tablicy;
                        end
                        else if (tab[l1][l3]=0) then
                        begin
                        l1:=l1+1;
                        end;
                end;
                if ((l1=2) and (l2=3)) then // taka sytuacja nie mozliwa, ale niech bedzie dla pelnosci algorytmu
                begin
                        if (tab[l1][l4]>=1) then
                        begin
                        tab[l2][l5]:=tab[l1][l4];
                        tab[l1][l4]:=0;
                        l4:=l4-1;
                        stan_tablicy;
                        end;
                        l1:=l1-1;
                end;
        end
        else 
        begin
        l1:=l1+1;
        l2:=l2-2;
        end;



        if (tab[2][y]=0) then
        begin   
                if ((l1=3) and (l2=2)) then
                begin
                        if (tab[l1][l5]>=1) then
                        begin
                        tab[l2][l4]:=tab[l1][l5];
                        tab[l1][l5]:=0;
                        l5:=l5+1;
                        l1:=l1-2;
                        l2:=l2+1;
                        stan_tablicy;
                        end
                        else if (tab[l1][l5]=0) then
                        begin
                        l1:=l1-2;
                        end;
                end;
                if ((l1=1) and (l2=2)) then
                begin
                        if (tab[l1][l3]>=1) then
                        begin
                        tab[l2][l4]:=tab[l1][l3];
                        tab[l1][l3]:=0;
                        l3:=l3+1;
                        stan_tablicy;
                        end;
                        l1:=l1+2;
                end;
        end
        else
        begin
        l1:=l1-2;
        l2:=l2+1;
        end;
                

        
        if (tab[1][y]=0) then
        begin
                if ((l1=2) and (l2=1)) then
                begin
                        if (tab[l1][l4]>=1) then
                        begin
                        tab[l2][l3]:=tab[l1][l4];
                        tab[l1][l4]:=0;
                        l4:=l4+1;
                        l1:=l1-1;
                        l2:=l2+1;
                        stan_tablicy;
                        end
                        else if (tab[l1][l4]=0) then
                        begin
                        l1:=l1+1;
                        end;
                end;
                if ((l1=3) and (l2=1)) then
                begin
                        if (tab[l1][l5]>=1) then
                        begin
                        tab[l2][l3]:=tab[l1][l5];
                        tab[l1][l5]:=0;
                        l5:=l5+1;
                        stan_tablicy;
                        end;
                        l1:=l1-1;
                end;
        end
        else 
        begin
        l1:=l1-1;
        l2:=l2+1;
        end;
end;
//

// Start - zamiana
        if ((tab[l1][l4]<tab[l2][l3]) and (tab[l1][l4]>=1)) then
        begin
                if (tab[l2][l3]>=1) then
                begin
                l3:=l3-1;
                tab[l2][l3]:=tab[l1][l4];
                tab[l1][l4]:=0;
                        if (tab[l1][l4]>1) then
                        begin
                        l4:=l4+1;
                        end;
                l1:=l1+1;
                l2:=l2+1;
                stan_tablicy;
                end
                else if (tab[l2][l3]<1) then
                begin
                tab[l2][l3]:=tab[l1][l4];
                tab[l1][l4]:=0;
                        if (tab[l1][l4]>1) then
                        begin
                        l4:=l4+1;
                        end;
                l1:=l1+1;
                l2:=l2+1;
                stan_tablicy;
                end;
        end
        else
        begin
        l1:=l1-1;
        l2:=l2+2;
        end;



        if ((tab[l1][l5]<tab[l2][l4]) and (tab[l1][l5]>=1)) then
        begin
                if (tab[l2][l4]>=1) then
                begin
                l4:=l4-1;
                tab[l2][l4]:=tab[l1][l5];
                tab[l1][l5]:=0;
                        if (tab[l1][l5]>1) then
                        begin
                        l5:=l5+1;
                        end;
                l1:=l1-2;
                l2:=l2+2;
                stan_tablicy;
                end
                else if (tab[l2][l4]<1) then
                begin
                tab[l2][l4]:=tab[l1][l5];
                tab[l1][l5]:=0;
                        if (tab[l1][l5]>1) then
                        begin
                        l5:=l5+1;
                        end;
                l1:=l1-2;
                l2:=l2+2;
                stan_tablicy;
                end;
        end
        else
        begin
        l1:=l1-1;
        l2:=l2-1;
        end;


        
        if ((tab[l1][l3]<tab[l2][l5]) and (tab[l1][l3]>=1)) then
        begin
                if (tab[l2][l5]>=1) then
                begin
                l5:=l5-1;
                tab[l2][l5]:=tab[l1][l3];
                tab[l1][l3]:=0;
                        if (tab[l1][l3]>1) then
                        begin
                        l3:=l3+1;
                        end;
                l1:=l1+1;
                l2:=l2-2;
                stan_tablicy;
                end
                else if (tab[l2][l5]<1) then
                begin
                tab[l2][l5]:=tab[l1][l3];
                tab[l1][l3]:=0;
                        if (tab[l1][l3]>1) then
                        begin
                        l3:=l3+1;
                        end;
                l1:=l1+1;
                l2:=l2-2;
                stan_tablicy;
                end;
        end
        else
        begin
        l1:=l1+2;
        l2:=l2-1;
        end;
// Koniec - zamiana

until (tab[k][1]=1); // Koniec przetwarzania wiezy

// Poczatek podgladu tablicy
for i:=1 to y do
begin
     for j:=1 to x do
     begin
     write(' ',tab[j][i]);
     end;
     writeln(' ');
end;
// Koniec podgladu tablicy
writeln(' ');
writeln('Program skonczyl dzialanie, nacisnij dowolny klawisz...');
readkey();
end. 

PS. Wieża hanoi zmienia wartość w kierunku na lewo, oraz dane są przetwarzane na tablicy dwu wymiarowej (takie utrudnienie od nauczyciela dostałem). Z góry dzięki za pomoc i pozdrawiam.

0

Napisałem już, ale nie działa mi to do końca.

O debuggerze słyszał? A użył? Nie? To powinien. A jak debugger nie pomoże to niech wrzuci Call Stack, stany zmiennych, linie błędu etc. etc.

w fpc występuje problem 201 w trakcie działania, a w dev pascal nie ma problemu, ale też nie działa jak należy.

Genialny pomysł! Skoro nie działa na jednym kompilatorze, to uznajemy że to wina kompilatora i zmieniamy!

Sądzę, że źle sformułowałem warunki, ale nie wiem jak w pascalu robi się inaczej.

To znaczy że nie znasz C++. Bo Pascal i C++ mają podobne warunki [tak jak wiele innych rzeczy] (aż dziwne że tablice indeksujesz od 1 skoro jesteś [pseudo?]programistą C++).

Nawet gdy jest false to przechodzi do true. Warunek jest zbudowany z dwóch innych, połączony and. Gdy jest prosty warunek to działa.

Kolejność działań?

0

Kompiluje mi prawidłowo! 0 błędów w kompilacji. Jeżeli nie pomagasz to nie spamuj, bo proszę o konkretną podpowiedź.

0

Genialny pomysł! Skoro nie działa na jednym kompilatorze, to uznajemy że to wina kompilatora i zmieniamy!

kto tu mówi o zmianie? Próbowałem w obu, jezeli mam zainstalwoane to dlaczego nie? W szkole używamy fpc, więc w domu też go mam. ale wolę dev pascal, więc i go mam.

To znaczy że nie znasz C++. Bo Pascal i C++ mają podobne warunki [tak jak wiele innych rzeczy] (aż dziwne że tablice indeksujesz od 1 skoro jesteś [pseudo?]programistą C++).

W c++ pisałem tego typu warunki i działało bez problemu. poza tym napisałem, że jestem w 1 TI, to dlaczego mnie nazywasz "pseudo programistą?" To myślę o Tobie, bo nawet nie masz własnego nicku a używasz "123"

Kolejność działań?

A co ma do tego kolejność działań? Nie wkopuj się sam, bo Twoje wypowiedzi na inteligentne nie wyglądają. Ogarnąłem już to i po prostu zmieniłem and na or i działa warunek. Ale ja chciałem z and, a jednak nie można w pascalu wszystkiego.

Do załącznika dodaję nowy stan programu.

0

Czemu -123 tak zarozumiale się udzielasz? Ty od razu byłeś asem wśród asów?

0

Dzięki za pomoc, wiem już co źle zrobiłem. Poszukałem w google co oznacza błąd 201 i warunki są dobrze, tylko źle liczniki w niektórych sytuacjach są.

0

Kompiluje mi prawidłowo! 0 błędów w kompilacji. Jeżeli nie pomagasz to nie spamuj, bo proszę o konkretną podpowiedź.

Kto mówi o błędzie kompilacji?

kto tu mówi o zmianie? Próbowałem w obu, jezeli mam zainstalwoane to dlaczego nie? W szkole używamy fpc, więc w domu też go mam. ale wolę dev pascal, więc i go mam.

wolisz dev pascal? Zacznijmy od tego że dev pascal to IDE, zresztą gorsze niż Lazarus. Nie powiedziałeś nawet czy podpiełeś pod to FPC czy GNU, więc wtf? Nie da się kompilować samym środowiskiem, sorry.

W c++ pisałem tego typu warunki i działało bez problemu. poza tym napisałem, że jestem w 1 TI, to dlaczego mnie nazywasz "pseudo programistą?"

Nazywam ciebie pseudo programistą bo gdybyś znał C++ to pascal nie byłby dla ciebie większym problemem.
Warunki w pascalu i C++ są podobne, tylko się zmienia pare nazw i to że w C++ nie ma 'then'. Taka różnica? Jak pisałem w PHP (który ma warunki podobne do C++) to żadnych problemów nie miałem [tylko miałem kurs otwarty], więc stąd jesteś pseudo programistą (zresztą zauważ że dałem znak zapytania).

To myślę o Tobie, bo nawet nie masz własnego nicku a używasz "123"

Jestem pseudo programistą bo używam nicku minus 123 ? Super ;) To ty jesteś pseudo programistą bo używasz nicku 'revosilo'.

A co ma do tego kolejność działań? Nie wkopuj się sam, bo Twoje wypowiedzi na inteligentne nie wyglądają. Ogarnąłem już to i po prostu zmieniłem and na or i działa warunek.

jakbyś nie wiedział to kolejność działań duże ma znaczenie, a ty po prostu tak chaotycznie opisałeś problem że nie wiedziałem o co ci chodzi i zgadywałem.

Ale ja chciałem z and, a jednak nie można w pascalu wszystkiego.

o_O fajnie masz. Czyli w C++ się da? :)

Do załącznika dodaję nowy stan programu.

Jako załącznik dodaję ...

Czemu -123 tak zarozumiale się udzielasz? Ty od razu byłeś asem wśród asów?

Mówisz sam do siebie? Pozdrawiam :) Jak wymyślisz sobie swój nick to pogadamy.

Dzięki za pomoc, wiem już co źle zrobiłem. Poszukałem w google co oznacza błąd 201 i warunki są dobrze, tylko źle liczniki w niektórych sytuacjach są.

A teraz popatrz co mówiłem:

O debuggerze słyszał? A użył? Nie? To powinien. A jak debugger nie pomoże to niech wrzuci Call Stack, stany zmiennych, linie błędu etc. etc.

Czy to nie rozwiązałoby problemu? Z całą pewnością by rozwiązało, tylko że ty się skupiłeś na wyzywaniu mnie :) .

0

Masz pecha bo debugger nic nie wskóra. Przypatrzyłem sobie jeszcze raz krok po kroku jakie zmiany mają być wykonywane na tablicy. Prędzej zmieniłem trochę warunki, a co za tym idzie i liczniki trzeba było zmienić i to zapomniałem zrobić. Liczniki wtedy wychodziły poza zakres tablicy i stąd ten błąd. Błąd 201. Na innym forum byli życzliwi ludzie i pomagali, w porównaniu do tego forum...
Najpierw mogłeś popatrzeć na kod, a później doradzać debugger. Błąd polegał tylko i wyłącznie na zmianie wartości liczników, a debugger tego nie poprawi za człowieka. I co jeszcze mogę dodać, ten dział chyba się nie nazywa offtopic, za takiego dobrego programistę się uważasz, ale brak Ci wiedzy odnośnie ogólnych zasad panujących na forach. Nie pomagasz? - Nie spamuj.

PS. Proszę administrację o usunięcie możliwości pisania postów przez niezarejestrowanych, bo zamiast rozmowa nabierać sensu to jest odwrotnie.

Temat można zamknąć, bo rozwiązałem sam problem.

Pozdrawiam

0

Masz pecha bo debugger nic nie wskóra.

Nie jestem w stanie się z tobą zgodzić. Debugger jest wielką pomocą przy każdym błędzie runtime (np. wiesz że otrzymujesz błąd 201 dzięki kodowi debuggowemu?)

Na innym forum byli życzliwi ludzie i pomagali, w porównaniu do tego forum...

Ja bym chciał żeby wszystkie pytania były tak mądre żebym mógł z czystym sercem pomagać, niestety większość pytań dotyczy podstaw i świadczy o braku umiejętności użycia googla lub wyszukiwarki forum. Im rozmawiasz z mądrzejszą osobą, tym generalnie jest ona bardziej wymagająca co do poziomu pytania - takie jest przynajmniej moje zdanie.

Najpierw mogłeś popatrzeć na kod, a później doradzać debugger.

Obejrzałem pytanie, zobaczyłem błąd 201 (który wiem co znaczy), pobieżnie popatrzyłem na kod (co to za formatowanie o_O) i stwierdziłem że brakuje tobie debuggera.

debugger tego nie poprawi za człowieka

Debugger to narzędzie diagnostyczne, które miało tobie (ew. nam) pomóc znaleźć błąd. Skoro nie umieściłeś nic poza kodem błędu, stwierdziłem że nie umiesz go użyć i napisałem abyś go użył i podał nam to co wypluje żebyśmy mogli stwierdzić co jest nie tak (niestety nie chce nam się wpisywać i kompilować twojego kodu a potem zgadywać co wpisać - cóż, darmowe forum).

za takiego dobrego programistę się uważasz, ale brak Ci wiedzy odnośnie ogólnych zasad panujących na forach

Mi się wydaje na odwrót. Wydaje ci się że jesteś ode mnie lepszy, niestety z tego co piszesz wynika że przynajmniej w FPC lepszy ode mnie póki co nie jesteś.

Nie pomagasz? - Nie spamuj.

Pomagasz - spamuj? Domyślam się że nie o to ci chodzi.
Oczywiście, tobie się wydaje że nie pomogłem, ale wbrew twoim przekonaniom wskazówki które zawarłem są bardzo celne.

PS. Proszę administrację o usunięcie możliwości pisania postów przez niezarejestrowanych, bo zamiast rozmowa nabierać sensu to jest odwrotnie.

Rozmowa odbywa się między dwiema osobami, w tym przypadku zarejestrowaną i niezarejestrowaną, a za jej 'sens' są odpowiedzialne obie te osoby. Zamiast szukać problemu we mnie, przydało by ci się trochę samokrytyki.

Pozdrawiam

Ja ciebie również pozdrawiam, i mam nadzieję że więcej nie będę musiał ciebie odsyłać do googli albo do debuggera. Pytaj tylko jeżeli pytanie nie było już zadawane i jeżeli google jest na ten temat małomówne. Jeżeli jeszcze mądrze zadasz pytanie to jestem pewien że otrzymasz bardziej uprzejme odpowiedzi.

0
revosilo napisał(a):

po prostu zmieniłem and na or i działa warunek. Ale ja chciałem z and, a jednak nie można w pascalu wszystkiego

to nie wina pascala tylko twojej wielkiej niewiedzy. Wiesz co to algebra Boole'a ? A o prawach De Morgana słyszał? Nie wyskakuj tylko teraz, że jesteś jeszcze młody i nie musisz tego wiedzieć bo to nie jest usprawiedliwienie. Ja zaczynając tworzyć własne warunki (czyli na początku swojej przygody z programowaniem) już stosowałem te przekształcenia i zaręczam, że robiło to wielu programistów nie zawsze być może wiedząc jak to się nazywa. To jest logika i skoro taki bat jesteś w c++, że wygodniej byłoby ci napisać ten program w tym języku to przetłumaczenie go na pascal'a powinno zająć ci nie dłużej jak 5 min.

0

Dobra, z tym and i or to akurat w tamtym miejscu miało być or i też sprawdzając all od początku do tego doszedłem, ponieważ pisząc robiłem to w pośpiechu i musiałem przeoczyć, ale z tymi licznikami, to wystarczy, że zła kolejność będzie i od razu źle jest indexowane. Wiem co to jest algebra boola, aż taki cienki to chyba nie jestem; oddawanie dwóch wartości, tj. true i false.
O prawach de Morgana jak i o tym człowieku nie słyszałem. Być może wiem co to jest, ale nie wiem, że tak to się właśnie nazywa. A to, że jestem młody to jest jak najlepsze wytłumaczenie, bo nie jestem w jakimś technikum, gdzie poziom jest bardzo dobry. U mnie w klasie 90% osób, w ogóle pisze bez świadomości znaczenia tej prostej składni, nie wspominając, ze dopiero mieliśmy case, a o tablicach niczego nie było. Tak więc, program który robię to jest poziom wykraczający...Poprawiłem już i mniej więcej działa, jeszcze tylko raz muszę posprawdzać warunki i w niektórych liczniki inaczej podporządkowywać, żeby ostatecznie program spełniał wymagania polecenia. Ale dużo roboty już nie zostało.

Z tymi komórkami tablic na serio można się pogubić, bo ten kod jest skomplikowany i tak od razu zobaczyć co i jak to trudno, bo nie jest przejrzyste. Stan aktualny:

[code]
program hanoi;
uses crt;
var
x,y,i,j,t,z,k,l1,l2,l3,l4,l5:integer;
tab:array [1..3,1..100] of integer; // Deklaracja tablicy 3 x 100
// Objasnienie zmiennych
// x - dlugosc w osi x
// y - ilosc klockow(os y)
// z - wartosc poczatkowa(sprawdzanie poprawnosci wprowadzania ilosci klockow)
// t - prawidlowa wartosc
// i - podglad tablicy(drugi index)
// j - podglad tablicy(pierwszy index)
// k - komorka o indexie 2 na osi x(koncowa)
// l1 - licznik indexu osi x, wartosc komorki, ktory on opisuje jest kopiowana do l2
// l2 - licznik indexu osi x, wartosc komorki, ktory on opisuje jest zastapiona przez l1
// l3 - licznik indexu osi y (x-2)
// l4 - licznik indexu osi y (x-1)
// l5 - licznik indexu osi y (x-0)

// Start - procedura wyswietlania aktualnego stanu tablicy
procedure stan_tablicy;
begin
writeln(l1,' ',l2);
writeln(' ');
for i:=1 to y do
begin
for j:=1 to x do
begin
write(' ',tab[j][i]);
end;
writeln(' ');
end;
//delay(1000);
readkey();
clrscr();
end;
// Koniec - procedura wyswietlania aktualnego stanu tablicy

begin
x:=3;

writeln('Witaj w programie "Wieza Hanoi"');
writeln();
writeln('Wprowadz liczbe okreslajaca wysokosc wiezy(min 2,max 100)');
// Poczatek sprawdzania poprawnej wartosci
z:=32767;
t:=0;
repeat
readln(y);
if ((y>1) and (y<101)) then
begin
t:=z;
end
else if (y<2) or (y>100) then
begin
t:=t+1;
writeln('Nieprawidlowa wartosc, sprobuj jeszcze raz');
end;
until (t=z);
// Koniec sprawdzania poprawnej wartosci
writeln();

// Poczatek inicjacji wartosci tablicy
for i:=1 to y do
begin
j:=1;
tab[j][i]:=i;
for j:=2 to x do
begin
tab[j][i]:=0;
end;
end;
// Koniec inicjacji wartosci tablicy

writeln('Wieza ma rozmiary: ',x,' x ',y,' i na poczatku wyglada nastepujaco:');
writeln();
// Poczatek podgladu tablicy
for i:=1 to y do
begin
for j:=1 to x do
begin
write(' ',tab[j][i]);
end;
writeln(' ');
end;
delay(3000);
clrscr();
// Koniec podgladu tablicy i czyszczenie stanu ekranu(nastepuje przejscie do wiezy)

stan_tablicy;

k:=x-1;
l1:=1;
l2:=x;
l3:=1;
l4:=y;
l5:=y;

repeat // Start przetwarzania wiezy

// Start - gdy na dole na osi y w osi x sa dwa 0
if ((tab[3][y]=0) and (tab[2][y]=0)) then
begin
if (tab[3][y]=0) then
begin
if ((l1=1) and (l2=3)) then
begin
if (tab[l1][l3]>0) then
begin
tab[l2][l5]:=tab[l1][l3];
tab[l1][l3]:=0;
l3:=l3+1;
l2:=l2-1;
stan_tablicy;
end;
end;
end;

if (tab[2][y]=0) then
begin	
	if ((l1=1) and (l2=2)) then
	begin
		if (tab[l1][l3]>0) then
		begin
		tab[l2][l4]:=tab[l1][l3];
		tab[l1][l3]:=0;
		l3:=l3+1;
		l1:=l1+2;
		stan_tablicy;
		end;
	end;
end

end
else if ((tab[2][y]=0) and (tab[1][y]=0)) then
begin
//l5=1
//l1=3;
//l2=3;
//l3=y;
if (tab[2][y]=0) then
begin
if ((l1=3) and (l2=2)) then
begin
if (tab[l1][l5]>0) then
begin
tab[l2][l4]:=tab[l1][l5];
tab[l1][l5]:=0;
l5:=l5+1;
l2:=l2-1;
stan_tablicy;
end;
end;
end;

if (tab[1][y]=0) then
begin	
	if ((l1=3) and (l2=1)) then
	begin
		if (tab[l1][l5]>0) then
		begin
		tab[l2][l3]:=tab[l1][l5];
		tab[l1][l5]:=0;
		l5:=l5+1;
		l1:=l1-1;
		stan_tablicy;
		end;
	end;
end

end;
// Koniec - gdy na dole na osi y w osi x sa dwa 0

// Start - zamiana
if ((l1=3) and (l2=2)) then
begin
if (((tab[l1][l5]<tab[l2][l4]) or (tab[l2][l4]=0)) and (tab[l1][l5]>0)) then
begin
if (tab[l2][l4]>0) then
begin
l4:=l4-1;
tab[l2][l4]:=tab[l1][l5];
tab[l1][l5]:=0;
if (l5<y) then
begin
l5:=l5+1;
end;
l1:=l1-2;
l2:=l2+1;
stan_tablicy;
end
else if (tab[l2][l4]<1) then
begin
tab[l2][l4]:=tab[l1][l5];
tab[l1][l5]:=0;
if (l5<y) then
begin
l5:=l5+1;
end;
l1:=l1-2;
l2:=l2+1;
stan_tablicy;
end;
end
else
begin
l2:=l2-1;
if (((tab[l1][l5]<tab[l2][l3]) or (tab[l2][l3]=0)) and (tab[l1][l5]>0)) then
begin
// else
if (tab[l2][l3]>0) then
begin
l3:=l3-1;
tab[l2][l3]:=tab[l1][l5];
tab[l1][l5]:=0;
if (l5<y) then
begin
l5:=l5+1;
end;
l1:=l1-1;
stan_tablicy;
end
else if (tab[l2][l3]<1) then
begin
tab[l2][l3]:=tab[l1][l5];
tab[l1][l5]:=0;
if (l5<y) then
begin
l5:=l5+1;
end;
l1:=l1-1;
stan_tablicy;
end;
// else
end
else
begin
//przesuwamy liczniki
l1:=l1+2;
l2:=l2-0;
end;
end;
end;

if ((l1=1) and (l2=3)) then
begin
if (((tab[l1][l3]<tab[l2][l5]) or (tab[l2][l5]=0)) and (tab[l1][l3]>0)) then
begin
if (tab[l2][l5]>0) then
begin
l5:=l5-1;
tab[l2][l5]:=tab[l1][l3];
tab[l1][l3]:=0;
if (l3<y) then
begin
l3:=l3+1;
end;
l1:=l1+1;
l2:=l2-2;
stan_tablicy;
end
else if (tab[l2][l5]<1) then
begin
tab[l2][l5]:=tab[l1][l3];
tab[l1][l3]:=0;
if (l3<y) then
begin
l3:=l3+1;
end;
l1:=l1+1;
l2:=l2-2;
stan_tablicy;
end;
end
else
begin
l2:=l2-1;
if (((tab[l1][l3]<tab[l2][l4]) or (tab[l2][l4]=0)) and (tab[l1][l3]>0)) then
begin
// else
if (tab[l2][l4]>0) then
begin
l5:=l5-1;
tab[l2][l4]:=tab[l1][l3];
tab[l1][l3]:=0;
if (l3<y) then
begin
l3:=l3+2;
end;
l1:=l1+1;
stan_tablicy;
end
else if (tab[l2][l4]<1) then
begin
tab[l2][l4]:=tab[l1][l3];
tab[l1][l3]:=0;
if (l3<y) then
begin
l3:=l3+1;
end;
l1:=l1+2;
stan_tablicy;
end;
// else
end
else
begin
//przesuwamy liczniki
l1:=l1-1;
l2:=l2-0;
end;
end;
end;

if ((l1=2) and (l2=1)) then
begin
if (((tab[l1][l4]<tab[l2][l3]) or (tab[l2][l3]=0)) and (tab[l1][l4]>0)) then
begin
if (tab[l2][l3]>0) then
begin
l3:=l3-1;
tab[l2][l3]:=tab[l1][l4];
tab[l1][l4]:=0;
if (l4<y) then
begin
l4:=l4+1;
end;
l1:=l1+1;
l2:=l2+1;
stan_tablicy;
end
else if (tab[l2][l3]<1) then
begin
tab[l2][l3]:=tab[l1][l4];
tab[l1][l4]:=0;
if (l4<y) then
begin
l4:=l4+1;
end;
l1:=l1+1;
l2:=l2+1;
stan_tablicy;
end;
end
else
begin
l2:=l2+2;
if (((tab[l1][l4]<tab[l2][l5]) or (tab[l2][l5]=0)) and (tab[l1][l4]>0)) then
begin
// else
if (tab[l2][l5]>0) then
begin
l5:=l5-1;
tab[l2][l5]:=tab[l1][l4];
tab[l1][l4]:=0;
if (l4<y) then
begin
l4:=l4+1;
end;
l1:=l1-1;
stan_tablicy;
end
else if (tab[l2][l5]<1) then
begin
tab[l2][l5]:=tab[l1][l4];
tab[l1][l4]:=0;
if (l4<y) then
begin
l4:=l4+1;
end;
l1:=l1-1;
stan_tablicy;
end;
// else
end
else
begin
//przesuwamy liczniki
l1:=l1+1;
l2:=l2-0;
end;
end;
end;
// Koniec - zamiana

until (tab[k][1]=1); // Koniec przetwarzania wiezy

// Poczatek podgladu tablicy
for i:=1 to y do
begin
for j:=1 to x do
begin
write(' ',tab[j][i]);
end;
writeln(' ');
end;
// Koniec podgladu tablicy
writeln(' ');
writeln('Program skonczyl dzialanie, nacisnij dowolny klawisz...');
readkey();
end.
[/code]

0

Jeżeli problem z licznikiem był, licznik był źle dodawany to nie wiem czy debugger by to wychwycił ale mniejsza o to, nie patrzyłem na ten kod nie szukałem to nie wiem na czym polegał błąd. Chcę ci tylko dać mała podpowiedź na przyszłość. Jeżeli piszesz algorytm dłuższy, którego nie jesteś w stanie objąć, że się tak wyrażę, umysłem to bardzo pomocne staje się dodawanie kody testowego czyli inaczej w twoim przypadku w odpowiednich miejscach wyrzucanie info na temat stanu danej zmiennej. Kiedy wszystko będzie śmigać usuniesz go i gitara. W dużych projektach kod testowy się zostawia do ponownego użycia. Ja mam głupi nawyk, że jak coś już niepotrzebne to usuwam, a potem często muszę pisać go na nowo bo się okazało, że po zmianach coś nie gra. Ale zostawianie kody to już w takich projektach na minimum 1,5k lini kodu.

0

Właśnie był problem z dodawaniem/odejmowaniem liczników.

Ja sobie do testów napisałem nad tablicą wartości 1 i 2 licznika, bo z nimi największy problem był i dzięki temu wiedziałem gdzie poprawić dodawanie/odejmowanie, to na prawdę bardzo dobry pomysł jest, takie ułatwienie. Trochę pracochłonne to było i dzisiaj doła mam, więc nie umiałem się pozbierać. Pomyślałem, że odpocznę, to lepiej mi się będzie robiło, bo normalnie to głowa cała już zapełniona tymi licznikami i nie tylko.
Przed chwilą wszystko co było do poprawy to poprawiłem i...działa! Cieszę się, że wreszcie to skończyłem, teraz się mogę zająć projektem z urządzeń techniki komputerowej :)
Dołączam kod, gdyby komuś się to przydało:

program hanoi;
uses crt;
var
x,y,i,j,t,z,k,l1,l2,l3,l4,l5:integer;
m:int64;
tab:array [1..3,1..100] of integer; // Deklaracja tablicy 3 x 100
// Objasnienie zmiennych
// x - dlugosc w osi x
// y - ilosc klockow(os y)
// z - wartosc poczatkowa(sprawdzanie poprawnosci wprowadzania ilosci klockow)
// t - prawidlowa wartosc
// i - podglad tablicy(drugi index)
// j - podglad tablicy(pierwszy index)
// k - komorka o indexie 2 na osi x(koncowa)
// l1 - licznik indexu osi x, wartosc komorki, ktory on opisuje jest kopiowana do l2
// l2 - licznik indexu osi x, wartosc komorki, ktory on opisuje jest zastapiona przez l1
// l3 - licznik indexu osi y (x-2)
// l4 - licznik indexu osi y (x-1)
// l5 - licznik indexu osi y (x-0)
// m - liczy ilość wykonywanych zmian


// Start - procedura wyswietlania aktualnego stanu tablicy
procedure stan_tablicy;
begin
for i:=1 to y do
begin
     for j:=1 to x do
     begin
     write(' ',tab[j][i]);
     end;
     writeln(' ');
end;
writeln(' ');
writeln('Do tej pory zostalo przeprowadzone ',m,' zmian');
//delay(100);// Zwolnienie przetwarzania
clrscr();
end;
// Koniec - procedura wyswietlania aktualnego stanu tablicy

begin
x:=3;

writeln('Witaj w programie "Wieza Hanoi"');
writeln();
writeln('Wprowadz liczbe okreslajaca wysokosc wiezy(min 2,max 100)');
// Poczatek sprawdzania poprawnej wartosci
z:=32767;
t:=0;
repeat
readln(y);
               if ((y>1) and (y<101)) then
			   begin
               t:=z;
               end
			   else if (y<2) or (y>100) then
               begin
               t:=t+1;
               writeln('Nieprawidlowa wartosc, sprobuj jeszcze raz');
               end; 
until (t=z);
// Koniec sprawdzania poprawnej wartosci
writeln();

// Poczatek inicjacji wartosci tablicy
for i:=1 to y do
begin
        j:=1;
        tab[j][i]:=i;
		for j:=2 to x do
		begin
        tab[j][i]:=0;
		end;
end;
// Koniec inicjacji wartosci tablicy

writeln('Wieza ma rozmiary: ',x,' x ',y,' i na poczatku wyglada nastepujaco:');
writeln(' ');
// Poczatek podgladu tablicy
for i:=1 to y do
begin
     for j:=1 to x do
     begin
     write(' ',tab[j][i]);
     end;
     writeln(' ');
end;
writeln(' ');
writeln('Nacisnij dowolny klawisz, aby przejsc do przetwarzania wiezy...');
readkey();
clrscr();
// Koniec podgladu tablicy i czyszczenie stanu ekranu(nastepuje przejscie do wiezy)

stan_tablicy;

m:=0;
k:=x-1;
l1:=1;
l2:=x;
l3:=1;
l4:=y;
l5:=y;

repeat // Start przetwarzania wiezy
	
// Start - gdy na dole na osi y w osi x sa dwa 0
if ((tab[3][y]=0) and (tab[2][y]=0)) then
begin
l1:=1;
l2:=3;
	if (tab[3][y]=0) then
	begin
		if ((l1=1) and (l2=3)) then
		begin
			if (tab[l1][l3]>0) then
			begin
			tab[l2][l5]:=tab[l1][l3];
			tab[l1][l3]:=0;
			l3:=l3+1;
			l2:=l2-1;
			m:=m+1;
			stan_tablicy;
			end;
		end;
	end;

	if (tab[2][y]=0) then
	begin	
		if ((l1=1) and (l2=2)) then
		begin
			if (tab[l1][l3]>0) then
			begin
			tab[l2][l4]:=tab[l1][l3];
			tab[l1][l3]:=0;
			l3:=l3+1;
			l1:=l1+2;
			m:=m+1;
			stan_tablicy;
			end;
		end;
	end
end
else if ((tab[2][y]=0) and (tab[1][y]=0)) then
begin
l1:=3;
l2:=2;

	if (tab[2][y]=0) then
	begin
		if ((l1=3) and (l2=2)) then
		begin
			if (tab[l1][l5]>0) then
			begin
			tab[l2][l4]:=tab[l1][l5];
			tab[l1][l5]:=0;
			l5:=l5+1;
			l2:=l2-1;
			m:=m+1;
			stan_tablicy;
			end;
		end;
	end;

	if (tab[1][y]=0) then
	begin	
		if ((l1=3) and (l2=1)) then
		begin
			if (tab[l1][l5]>0) then
			begin
			tab[l2][l3]:=tab[l1][l5];
			tab[l1][l5]:=0;
			l5:=l5+1;
			l1:=l1-1;
			m:=m+1;
			stan_tablicy;
			end;
		end;
	end
end;
// Koniec - gdy na dole na osi y w osi x sa dwa 0

// Start - zamiana
if ((l1=3) and (l2=2)) then // index x=3
begin	
	if (((tab[l1][l5]<tab[l2][l4]) or (tab[l2][l4]=0)) and (tab[l1][l5]>0)) then
	begin
		if (tab[l2][l4]>0) then
		begin
		l4:=l4-1;
		tab[l2][l4]:=tab[l1][l5];
		tab[l1][l5]:=0;
			if (l5<y) then
			begin
			l5:=l5+1;
			end;
		l1:=l1-2;
		l2:=l2+1;
		m:=m+1;
		stan_tablicy;
		continue;
		end
		else if (tab[l2][l4]<1) then
		begin
		tab[l2][l4]:=tab[l1][l5];
		tab[l1][l5]:=0;
			if (l5<y) then
			begin
			l5:=l5+1;
			end;
		l1:=l1-2;
		l2:=l2+1;
		m:=m+1;
		stan_tablicy;
		continue;
		end;
	end
	else
	begin
	if (tab[l1][l5]=0) then
	begin
	l1:=l1-2;
	l2:=l2-2;
	continue;
	end
	else if (tab[l1][l5]<>0) then
	begin
	l2:=l2-1;
	if (((tab[l1][l5]<tab[l2][l3]) or (tab[l2][l3]=0)) and (tab[l1][l5]>0)) then
	begin	
		// else
		if (tab[l2][l3]>0) then
		begin
		l3:=l3-1;
		tab[l2][l3]:=tab[l1][l5];
		tab[l1][l5]:=0;
			if (l5<y) then
			begin
			l5:=l5+1;
			end;
		l1:=l1-1;
		m:=m+1;
		stan_tablicy;
		continue;
		end
		else if (tab[l2][l3]<1) then
		begin
		tab[l2][l3]:=tab[l1][l5];
		tab[l1][l5]:=0;
			if (l5<y) then
			begin
			l5:=l5+1;
			end;
		l1:=l1-1;
		m:=m+1;
		stan_tablicy;
		continue;
		end;
		// else
	end
	else if (tab[l1][l5]>tab[l2][l3]) or (tab[l1][l5]>tab[l2][l4]) then
	begin
	//przesuwamy liczniki
	l1:=l1-1;
	l2:=l2-0;
	continue;
	end;
	end;
	end;
end;	

if ((l1=1) and (l2=3)) then // index x=2
begin		
	if (((tab[l1][l3]<tab[l2][l5]) or (tab[l2][l5]=0)) and (tab[l1][l3]>0)) then
	begin
		if (tab[l2][l5]>0) then
		begin
		l5:=l5-1;
		tab[l2][l5]:=tab[l1][l3];
		tab[l1][l3]:=0;
			if (l3<y) then
			begin
			l3:=l3+1;
			end;
		l1:=l1+1;
		l2:=l2-2;
		m:=m+1;
		stan_tablicy;
		continue;
		end
		else if (tab[l2][l5]<1) then
		begin
		tab[l2][l5]:=tab[l1][l3];
		tab[l1][l3]:=0;
			if (l3<y) then
			begin
			l3:=l3+1;
			end;
		l1:=l1+1;
		l2:=l2-2;
		m:=m+1;
		stan_tablicy;
		continue;
		end;
	end
	else
	begin
	if (tab[l1][l3]=0) then
	begin
	l1:=l1+2;
	l2:=l2-1;
	continue;
	end
	else if (tab[l1][l3]<>0) then
	begin
	l2:=l2-1;
	if (((tab[l1][l3]<tab[l2][l4]) or (tab[l2][l4]=0)) and (tab[l1][l3]>0)) then
	begin
		// else
		if (tab[l2][l4]>0) then
		begin
		l4:=l4-1;
		tab[l2][l4]:=tab[l1][l3];
		tab[l1][l3]:=0;
			if (l3<y) then
			begin
			l3:=l3+1;
			end;
		l1:=l1+2;
		m:=m+1;
		stan_tablicy;
		continue;
		end
		else if (tab[l2][l4]<1) then
		begin
		tab[l2][l4]:=tab[l1][l3];
		tab[l1][l3]:=0;
			if (l3<y) then
			begin
			l3:=l3+1;
			end;
		l1:=l1+2;
		m:=m+1;
		stan_tablicy;
		continue;
		end;
		// else
	end
	else if (tab[l1][l3]>tab[l2][l4]) then //or (tab[l1][l3]>tab[l2][l5]) then
	begin
	//przesuwamy liczniki
	l1:=l1+2;
	l2:=l2-0;
	continue;
	end;
	end;
	end;
end;

if ((l1=2) and (l2=1)) then // index x=1
begin	
	if (((tab[l1][l4]<tab[l2][l3]) or (tab[l2][l3]=0)) and (tab[l1][l4]>0)) then
	begin
		if (tab[l2][l3]>0) then
		begin
		l3:=l3-1;
		tab[l2][l3]:=tab[l1][l4];
		tab[l1][l4]:=0;
			if (l4<y) then
			begin
			l4:=l4+1;
			end;
		l1:=l1+1;
		l2:=l2+1;
		m:=m+1;
		stan_tablicy;
		continue;
		end
		else if (tab[l2][l3]<1) then
		begin
		tab[l2][l3]:=tab[l1][l4];
		tab[l1][l4]:=0;
			if (l4<y) then
			begin
			l4:=l4+1;
			end;
		l1:=l1+1;
		l2:=l2+1;
		m:=m+1;
		stan_tablicy;
		continue;
		end;
	end
	else
	begin
	if (tab[l1][l4]=0) then
	begin
	l1:=l1-1;
	l2:=l2+2;
	continue;
	end
	else if (tab[l1][l4]<>0) then
	begin
	l2:=l2+2;
	if (((tab[l1][l4]<tab[l2][l5]) or (tab[l2][l5]=0)) and (tab[l1][l4]>0)) then
	begin
		// else
		if (tab[l2][l5]>0) then
		begin
		l5:=l5-1;
		tab[l2][l5]:=tab[l1][l4];
		tab[l1][l4]:=0;
			if (l4<y) then
			begin
			l4:=l4+1;
			end;
		l1:=l1-1;
		m:=m+1;
		stan_tablicy;
		continue;
		end
		else if (tab[l2][l5]<1) then
		begin
		tab[l2][l5]:=tab[l1][l4];
		tab[l1][l4]:=0;
			if (l4<y) then
			begin
			l4:=l4+1;
			end;
		l1:=l1-1;
		m:=m+1;
		stan_tablicy;
		continue;
		end;
		// else
	end
	else if (tab[l1][l4]>tab[l2][l5]) or (tab[l1][l4]>tab[l2][l3]) then
	begin
	//przesuwamy liczniki
	l1:=l1-1;
	l2:=l2-0;
	continue;
	end;
	end;
	end;
end;
// Koniec - zamiana

until (tab[k][1]=1); // Koniec przetwarzania wiezy

// Poczatek podgladu tablicy
for i:=1 to y do
begin
     for j:=1 to x do
     begin
     write(' ',tab[j][i]);
     end;
     writeln(' ');
end;
// Koniec podgladu tablicy
writeln(' ');
writeln('Zostalo przeprowadzone ',m,' zmian');
writeln(' ');
writeln('Program skonczyl dzialanie, nacisnij dowolny klawisz...');
readkey();
end.

Dzięki za wszystko i pozdrawiam.

0

Jeżeli problem z licznikiem był, licznik był źle dodawany to nie wiem czy debugger by to wychwycił

Kolejny 'ekspert' który debuggera nie umie używać. Skoro nie ogarniasz arsenału środków jakimi dysponuje nowoczesny debugger, to po co się odzywasz?

jeżeli piszesz algorytm dłuższy, którego nie jesteś w stanie objąć, że się tak wyrażę, umysłem to bardzo pomocne staje się dodawanie kody testowego czyli inaczej w twoim przypadku w odpowiednich miejscach wyrzucanie info na temat stanu danej zmiennej.

Debugger też to umie, ale kogo to obchodzi? (lepiej zapytać na forum!) Niemniej, logowanie czasami jest przydatne (zwłaszcza tak jak mówisz dalej w większych projektach). Wtedy to nawet w konstrukcje IFDEF logowania można się bawić.

@revosilo : Naucz się formatować kod i zamiast pisać "Z tymi komórkami tablic na serio można się pogubić, bo ten kod jest skomplikowany" to naucz się pisać porządny i zrozumiały kod tj. dziel na procedury etc. .

0

Uwzględniłem wyświetlanie stanu tablicy w procedurze, a resztę to trudno, żeby dzielić na procedury, bo później przy sprawdzaniu tzreba skakać do góry, zeby zobaczyć co w procedurze, później na dół itp. Więc szybciej przy analizowaniu i sprawdzaniu kodu jest normalne napisanie kodu.

0

@-123 Spokojnie, napisałem przecież że nie patrzyłem na kod i nie sprawdzałem co to za błąd. Poza tym jeszcze mi się nie zdarzyło, żeby debugger wyłapał, że przykładowo zapominałem zwiększać licznika i pętla stała się nieskończona. Nie wiem, może nie umiem korzystać z niego tak dobrze jak ty. Założę się, że masz kilku-kilkunastoletnie doświadczenie nie to co ja z dwuletnim doświadczeniem. Co do wartości zmiennych to masz racje, że da się robić to bez kodu testów nie mniej jednak śmiem stwierdzić, że mi łatwiej jest sprawdzać kodem testowym niż debuggerem w trakcie działania natomiast stan zmiennych ukazanych przez debuggera pomaga mi w przypadku wywalenia się programu, wtedy to otwieram i analizuje poszczególne wartości.

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