Program nie wypisuje wszystkich danych na ekranie

Witam mam problem z programem. Program oblicza permutacje wariacje, takie dziwne rzeczy z matmy ogolnie ale tu nie chodzi o to jak to liczy tylko nie wyswietla wszystkiego w tym problem. A mianowicie dziala on, ale nie zawsze wypisuje wszystkie opcje, tzn liczy je ale wypisze jak sie poda np 20 wariacji to na ekranie sie wyswietla od 12 do 20. Jak to rozwiazac? Nie mam kompletnie pomyslu. Z gory dziekuje za pomoc.

program waznyprojekt;
uses crt;

procedure losowanie_permutacji(wielkosc_zbioru, k :integer);
var
  tmp : array[0..20,0..1000] of integer;
  zbior : array[0..20] of integer;
  i,j,z,a : integer;
  zmp: integer;
  powtorka,powtorka2 : integer;
  ilosc,przecinek : integer;

begin
for i:=1 to 1000 do
    begin
      for z:=1 to wielkosc_zbioru do
          begin
            tmp[z-1][i]:=0;
          end;
    end;

for i:=1 to wielkosc_zbioru do
    begin
      zbior[i-1]:=0;
    end;

for j:=1 to k do
    begin
      przecinek:=0;
      ilosc:=0;
      powtorka2:=0;
      while powtorka2 =  0 do
       begin
              while ilosc< wielkosc_zbioru do
               begin
                powtorka :=0;
                zmp:=random(wielkosc_zbioru)+1;
                for z:=1 to wielkosc_zbioru do
                    begin
                         if zbior[z-1]=zmp then
                         begin
                           powtorka:=1;
                           break;
                         end;
                    end;
                if powtorka=0 then
                begin
                  ilosc:=ilosc+1;
                  zbior[ilosc-1]:=zmp;
                end;

               end;
                powtorka2:=1;
                for i:=1 to k do
                    begin
                     if tmp[0][i-1]=0 then
                     begin
                       break;
                     end;
                     for z:=1 to wielkosc_zbioru do
                         begin
                          if tmp[z-1][i-1]=zbior[z-1] then
                          begin
                            powtorka2:=0;
                          end else
                          begin
                           powtorka2:=1;
                           break;
                          end;
                         end;
                        if powtorka2=0 then
                        begin
                        for a:=1 to wielkosc_zbioru do
                        begin
                        zbior[a-1]:=0;
                        end;
                        ilosc:=0;
                        break;
                        end;
                    end;

       end;
       writeln('Permutacja',j,': ');
       for i:= 1 to wielkosc_zbioru do
          begin
          write(zbior[i-1]);
          tmp[i-1][j-1]:= zbior[i-1];
          przecinek:= przecinek + 1;
          if przecinek < wielkosc_zbioru  then
                 begin
                    write(', ');
                 end;

          end;
         for i:= 1 to wielkosc_zbioru  do
          begin
                 zbior[i-1] := 0;
          end;
          writeln();


    end;

   end;

procedure permutacja;
var
  wielkosc_zbioru :integer;
  k : integer;
  silnia : integer;
  wyniksilnia, isilnia: integer;
begin
silnia:=0;
wielkosc_zbioru:=0;
while wielkosc_zbioru=0 do
begin
write('Podaj wielkosc zbioru (od 3 do 20): ');
 read(wielkosc_zbioru);
 if (wielkosc_zbioru < 3) AND (wielkosc_zbioru > 20) then
        begin
        writeln();
        writeln();
        writeln();
        writeln('podales liczbe z poza zakresu');
        end;
 end;


wyniksilnia:=1;
isilnia:=1;

 while isilnia<wielkosc_zbioru do
 begin
  isilnia:=isilnia+1;
  wyniksilnia:=wyniksilnia*isilnia;
 end;
silnia:=wyniksilnia;


writeln();
writeln('Ilosc permutacji zbioru ',wielkosc_zbioru,' elementowego wynosi: ', silnia);
writeln('Podaj ilosc generowanych losowych permutacji zbioru ',wielkosc_zbioru,' elementowego: ');
readln(k);
while k>silnia do
begin
  writeln('podales zla wartosc. podaj jeszcze raz ilosc gen. permutacji ');
  readln(k);
  end;
while k>1000 do
begin
  writeln('Podales ilosc losowan poza zakresem! Podaj jescze raz ');
  readln(k);
  end;

 losowanie_permutacji(wielkosc_zbioru,k);



end;




function Silnia(n:byte):longint;
begin
if n=0 then Silnia:=1
else
Silnia:=n*Silnia(n-1);
end;

function ObliczKombinacjeZPowtorzeniami(wielkosc_zbioru, m :integer) :real;
var
 a1, a2:integer;
b1, b2, b3:real;
mianownik:real;
licznik:real;
begin


        a1 := wielkosc_zbioru + m - 1;
        a2 := m;

        b1 := Silnia(a1);
        b2 := Silnia(a2);
        b3 := Silnia(a1-a2);

        mianownik := b2 * b3;
        licznik := b1;

        ObliczKombinacjeZPowtorzeniami:=(licznik / mianownik);
end;

 procedure GENEROWANIE_LOSOWYCH_KOMBINACJI_Z_POWTORZENIAMI_W_LICZBIE_k(wielkosc_zbioru,wielkosc_podzbioru,k:integer)  ;
      var

      tmp:array[0..20,0..1000] of integer;
      podzbior:array[0..20] of integer;
      i, j, z, x,a:integer;
      zmp:integer;
      powtorka:integer;
      powtorka2:integer;
      ilosc:integer;
      przecinek:integer;

     licznik_cyfr:array[0..20] of integer;
     licznik_cyfr2:array[0..20] of integer;
begin


     for i := 1 to 1000 do
     begin
         for z := 1 to wielkosc_podzbioru do
         begin
             tmp[z-1][i] := 0;
         end;
     end;


     for i := 1 to wielkosc_podzbioru do
     begin
          podzbior[i-1] := 0;
     end;


     for j := 1 to k do
     begin
          przecinek := 0;
          ilosc := 0;


          powtorka2 := 0;
          while powtorka2 = 0 do
          begin

               while ilosc < wielkosc_podzbioru do
               begin
                  zmp := random(wielkosc_zbioru) + 1;
                  ilosc := ilosc + 1;
                  podzbior[ilosc-1] := zmp;
               end;
              powtorka2 := 1;

              for i := 1 to wielkosc_zbioru do
              begin
                  licznik_cyfr[i-1] := 0;
              end;

              for i := 1 to wielkosc_zbioru do
              begin
                 for x := 1 to wielkosc_podzbioru do
                 begin
                   if podzbior[x-1] = i then
                   begin
                      licznik_cyfr[i-1] := licznik_cyfr[i-1] + 1;
                   end;
                 end;
              end;

              for i := 1 to  k  do
              begin
                  if (tmp[0][i-1] = 0) then
                  begin
                     break;
                  end;

                  for x := 1 to  wielkosc_zbioru do
                  begin
                     licznik_cyfr2[x-1] := 0;
                  end;

                  for z := 1 to wielkosc_zbioru do
                  begin
                     for x := 1 to wielkosc_podzbioru do
                     begin
                       if tmp[x-1][i-1] = z then
                       begin
                          licznik_cyfr2[z-1] := licznik_cyfr2[z-1] + 1;
                       end;
                     end;
                  end;

                  for z := 1 to wielkosc_zbioru do
                  begin
                      if licznik_cyfr[z-1] = licznik_cyfr2[z-1] then
                      begin
                          powtorka2 := 0;
                      end
                      else
                      begin
                          powtorka2 := 1;
                          break;
                      end;
                  end;

                  if powtorka2 = 0 then
                  begin
                      for a := 1 to wielkosc_podzbioru do
                      begin
                         podzbior[a-1] := 0;
                      end;
                      ilosc := 0;
                      break;
                  end;
              end;
          end;


          writeln('Kombinacja z powtorzeniami: ', j);


          for i := 1 to wielkosc_podzbioru do
          begin
                 writeln(podzbior[i-1]);
                 tmp[i-1][j-1] := podzbior[i-1];
                 przecinek := przecinek + 1;
                 if przecinek < wielkosc_podzbioru then
                 begin
                    writeln();
                 end;
          end;

          for i := 1 to wielkosc_podzbioru do
          begin
                 podzbior[i-1] := 0;
          end;
          writeln();
     end;
end;


procedure kombinacjezpowtorzeniami;
var
         wielkosc_zbioru:integer;
         m:integer;
         k:integer;
         sil:real;
         kombinacje_z_powtorzeniami:real;

begin
        writeln('Podaj wielkosc zbioru (od 3 do 20): ');
        readln(wielkosc_zbioru);



        sil := Silnia(wielkosc_zbioru);

        writeln('Podaj wielkosc podzbioru: ');
        readln(m);


        kombinacje_z_powtorzeniami := ObliczKombinacjeZPowtorzeniami(wielkosc_zbioru, m);
        writeln('Ilosc kombinacji ' , m, ' elementowych z powtorzeniami zbioru ', wielkosc_zbioru ,' elementowego wynosi: ') ;
                 writeln  (kombinacje_z_powtorzeniami:4:0);
        writeln('Podaj ilosc generowanych losowych kombinacji ', m );
        writeln('elementowych z powtorzeniami zbioru ', wielkosc_zbioru ,' elementowego: ');
        readln(k);




        GENEROWANIE_LOSOWYCH_KOMBINACJI_Z_POWTORZENIAMI_W_LICZBIE_k(wielkosc_zbioru, m, k);

        writeln('Nacisnij ENTER');
		readln();
end;

function ObliczKombinacjeBezPowtorzen(sil:real;wielkosc_zbioru, m:integer):real;
var
mianownik:real;
licznik:real;
begin

        mianownik := Silnia(wielkosc_zbioru - m) * Silnia(m);
        licznik := sil;

        ObliczKombinacjeBezPowtorzen:= (licznik / mianownik);
end;






procedure GENEROWANIE_LOSOWYCH_KOMBINACJI_BEZ_POWTORZEN_W_LICZBIE_k(wielkosc_zbioru,wielkosc_podzbioru, k:integer);

 var

      tmp:array[0..20,0..1000] of integer;
      podzbior:array[0..20] of integer;
      i, j, z, x,a:integer;
      zmp:integer;
      powtorka:integer;
      powtorka2:integer;
      ilosc:integer;
      przecinek:integer;


begin




    for i := 1 to 1000 do
     begin
         for z := 1 to wielkosc_podzbioru do
         begin
             tmp[z-1][i] := 0;
         end;
     end;


     for i := 1 to wielkosc_podzbioru do
     begin
          podzbior[i-1] := 0;
     end;


     for j := 1 to k do
     begin
          przecinek := 0;
          ilosc := 0;


          powtorka2 := 0;
          while powtorka2 = 0 do
          begin

              while ilosc < wielkosc_podzbioru do
              begin
                    powtorka := 0;
                    zmp := random(wielkosc_zbioru)   + 1;
                    for z := 1 to wielkosc_podzbioru do
                    begin
                        if podzbior[z-1] = zmp then
                        begin
                           powtorka := 1;
                           break;
                       end;
                    end;

                    if powtorka = 0 then
                    begin
                        ilosc := ilosc + 1;
                        podzbior[ilosc-1] := zmp;
                    end;
              end;

              powtorka2 := 1;
              for i := 1 to k do
              begin
                  if (tmp[0][i-1] = 0)   then
                  begin
                     break;
                  end;
                  for z := 1 to wielkosc_podzbioru do
                  begin
                          for x := 1 to wielkosc_podzbioru do
                          begin
                              if tmp[z-1][i-1] = podzbior[x-1] then
                              begin
                                  powtorka2 := 0;
                                  break;
                              end;
                              powtorka2 := 1;
                          end;
                          if powtorka2 = 1 then
                          begin
                                break;
                          end;
                  end;
                  if powtorka2 = 0   then
                  begin
                      for a := 1 to wielkosc_podzbioru do
                      begin
                         podzbior[a-1] := 0;
                      end;
                      ilosc := 0;
                      break;
                  end;
              end;

          end;


          writeln('Kombinacja bez powtorzen ', j);


          for i := 1 to wielkosc_podzbioru do
          begin
                 writeln(podzbior[i-1]);
                 tmp[i-1][j-1] := podzbior[i-1];
                 przecinek := przecinek + 1;
                 if przecinek < wielkosc_podzbioru then
                 begin
                    writeln();
                 end;
          end;

          for i := 1 to wielkosc_podzbioru do
          begin
                 podzbior[i-1] := 0;
          end;
          writeln();
     end;
end;


procedure kombinacjebezpowtorzen;
var
		 wielkosc_zbioru:integer;
         m:integer;
         k:integer;
         sil:real;
         kombinacje_bez_powtorzen:real;

begin

        writeln('Podaj wielkosc zbioru (od 3 do 20): ');
        readln(wielkosc_zbioru);



        sil := Silnia(wielkosc_zbioru);

        writeln('Podaj wielkosc podzbioru: ');
        readln(m);


        kombinacje_bez_powtorzen := ObliczKombinacjeBezPowtorzen(sil, wielkosc_zbioru, m);
        writeln('Ilosc kombinacji ', m ,' elementowych bez powtorzen zbioru  ', wielkosc_zbioru,' elementowego wynosi: ');
       writeln(kombinacje_bez_powtorzen:4:0);

        writeln('Podaj ilosc generowanych losowych kombinacji ', m, ' elementowych bez powtorzen zbioru ',wielkosc_zbioru,'  elementowego: ');
        readln(k);


        GENEROWANIE_LOSOWYCH_KOMBINACJI_BEZ_POWTORZEN_W_LICZBIE_k(wielkosc_zbioru, m, k);

        writeln('Nacisnij ENTER');
        readln();


end;




       function ObliczWariacjeZPowtorzeniami(wielkosc_zbioru,m:integer):real;
var
wynik,i:integer;
begin
        wynik := wielkosc_zbioru;
        for  i := 1 to m-1 do
        begin
                wynik := wynik * wielkosc_zbioru;
        end;
        ObliczWariacjeZPowtorzeniami:=wynik;
end;





procedure GENEROWANIE_LOSOWYCH_WARIACJI_Z_POWTORZENIAMI_W_LICZBIE_k(wielkosc_zbioru,wielkosc_podzbioru,k:integer);

var
      tmp:array[0..20,0..1000] of integer;
      podzbior:array[0..20] of integer;
      i, j, z,a:integer;
      zmp:integer;
      powtorka:integer;
      powtorka2:integer;
      ilosc:integer;
      przecinek:integer;

   begin

     for i := 1 to 1000 do
     begin
         for z := 1 to wielkosc_podzbioru do
         begin
             tmp[z-1][i] := 0;
         end;
     end;

     for i := 1 to  wielkosc_podzbioru do
     begin
          podzbior[i-1] := 0;
     end;

     for j := 1 to k do
     begin
          przecinek := 0;
          ilosc := 0;


          powtorka2 := 0;
          while powtorka2 = 0 do
          begin

              while ilosc < wielkosc_podzbioru do
              begin
                 zmp := random(wielkosc_zbioru)   + 1;
                 ilosc := ilosc + 1;
                 podzbior[ilosc-1] := zmp;
             end;

              powtorka2 := 1;
              for i := 1 to k do
              begin
                  if (tmp[0][i-1] = 0) then
                  begin
                     break;
                  end;
                  for z := 1 to wielkosc_podzbioru do
                  begin
                      if tmp[z-1][i-1] = podzbior[z-1] then
                      begin
                          powtorka2 := 0;
                      end
                      else
                      begin
                          powtorka2 := 1;
                          break;
                      end;
                  end;
                  if (powtorka2 = 0) then
                  begin
                      for a:= 1 to wielkosc_podzbioru do
                      begin
                         podzbior[a-1] := 0;
                      end;
                      ilosc := 0;
                      break;
                  end;
              end;
          end;
 writeln('Wariacja z powtorzeniami ', j);

          for i := 1 to wielkosc_podzbioru do
          begin
                 writeln(podzbior[i-1]);
                 tmp[i-1][j-1] := podzbior[i-1];
                 przecinek := przecinek + 1;
                 if przecinek < wielkosc_podzbioru then
                 begin
                    writeln();
                 end;
          end;

          for i := 1 to wielkosc_podzbioru do
          begin
                 podzbior[i-1] := 0;
          end;
          writeln();
     end;
end;



procedure wariacjezpowtorzeniami;
var
 wielkosc_zbioru:integer;
 m:integer;
 k:integer;
 sil:real;
 wariacje_z_powtorzeniami:real;

begin

        writeln('Podaj wielkosc zbioru (od 3 do 20): ');
        readln(wielkosc_zbioru);



        sil := Silnia(wielkosc_zbioru);

        writeln('Podaj wielkosc podzbioru: ');
        readln(m);



        wariacje_z_powtorzeniami := ObliczWariacjeZPowtorzeniami(wielkosc_zbioru, m);
        writeln('Ilosc wariacji ' ,m, ' elementowych z powtorzeniami zbioru ', wielkosc_zbioru, ' elementowego wynosi: ');
        writeln(wariacje_z_powtorzeniami:4:0);

        writeln('Podaj ilosc generowanych losowych wariacji ',m,' elementowych z powtorzeniami zbioru ',wielkosc_zbioru,' elementowego: ' );
        readln(k);


        GENEROWANIE_LOSOWYCH_WARIACJI_Z_POWTORZENIAMI_W_LICZBIE_k(wielkosc_zbioru, m, k);

        writeln('Nacisnij ENTER');
		readln();

end;



 function ObliczWariacjeBezPowtorzen( sil:real;wielkosc_zbioru, m:integer):real;
var
 mianownik:real;
 licznik:real;
begin
        mianownik := Silnia(wielkosc_zbioru - m);
        licznik := sil;

        ObliczWariacjeBezPowtorzen:=licznik / mianownik;
end;

procedure GENEROWANIE_LOSOWYCH_WARIACJI_BEZ_POWTORZEN_W_LICZBIE_k(wielkosc_zbioru,wielkosc_podzbioru,k:integer);
var
	tmp:array[0..20,0..1000] of integer;
      podzbior:array[0..20] of integer;
      i, j, z,a:integer;
      zmp:integer;
      powtorka:integer;
      powtorka2:integer;
      ilosc:integer;
      przecinek:integer;

begin

    for i := 1 to 1000 do
     begin
         for z := 1 to wielkosc_podzbioru do
         begin
             tmp[z-1][i] := 0;
         end;
     end;


     for i := 1 to  wielkosc_podzbioru do
     begin
          podzbior[i-1] := 0;
     end;


     for j := 1 to k do
     begin
          przecinek := 0;
          ilosc := 0;


          powtorka2 := 0;
          while powtorka2 = 0 do
          begin

              while ilosc < wielkosc_podzbioru   do
              begin
                    powtorka := 0;
                    zmp := random(wielkosc_zbioru) + 1;
                    for z := 1 to wielkosc_podzbioru do
                    begin
                        if podzbior[z-1] = zmp then
                        begin
                           powtorka := 1;
                           break;
                        end;
                    end;

                    if powtorka = 0 then
                    begin
                        ilosc := ilosc + 1;
                        podzbior[ilosc-1] := zmp;
                    end;
              end;


              powtorka2 := 1;
              for i := 1 to k do
              begin
                  if tmp[0][i-1] = 0 then
                  begin
                     break;
                  end;
                  for z := 1 to wielkosc_podzbioru do
                  begin
                      if tmp[z-1][i-1] = podzbior[z-1] then
                      begin
                          powtorka2 := 0;
                      end
                      else
                      begin
                          powtorka2 := 1;
                          break;
                      end;
                  end;
                  if powtorka2 = 0 then
                  begin
                      for a := 1 to wielkosc_podzbioru do
                      begin
                         podzbior[a-1] := 0;
                      end;
                      ilosc := 0;
                      break;
                  end;
              end;

          end;


          writeln('Wariacja bez powtorzen ', j);


          for i := 1 to wielkosc_podzbioru do
          begin
                 writeln(podzbior[i-1]);
                 tmp[i-1][j-1] := podzbior[i-1];
                 przecinek := przecinek + 1;
                 if przecinek < wielkosc_podzbioru then
                 begin
                    writeln();
                 end;
          end;

          for i := 1 to  wielkosc_podzbioru do
          begin
                 podzbior[i-1] := 0;
          end;
          writeln();
     end;
end;


  procedure wariacjebezpowtorzen;
var
		wielkosc_zbioru:integer;
         m:integer;
         k:integer;
         sil:real;
         wariacje_bez_powtorzen:real;


begin
        writeln('Podaj wielkosc zbioru (od 3 do 20): ');
        readln(wielkosc_zbioru);


        sil := Silnia(wielkosc_zbioru);

        writeln('Podaj wielkosc podzbioru: ');
        readln(m);


        wariacje_bez_powtorzen := ObliczWariacjeBezPowtorzen(sil, wielkosc_zbioru, m);
        writeln('Ilosc wariacji ',  m ,' elementowych bez powtorzen zbioru ', wielkosc_zbioru ,' elementowego wynosi: ');
        writeln(wariacje_bez_powtorzen:4:0);

        writeln('Podaj ilosc generowanych losowych wariacji ' ,m,' elementowych bez powtorzen zbioru ', wielkosc_zbioru ,' elementowego: ');
        readln(k);


        GENEROWANIE_LOSOWYCH_WARIACJI_BEZ_POWTORZEN_W_LICZBIE_k(wielkosc_zbioru, m, k);

        writeln('Nacisnij ENTER');
readln();
end;



var
         wybor:integer;


BEGIN

    writeln('1 permutacja');
    writeln('2 kombinacje z powtorzeniami');
    writeln('3 kombinacje bez powtorzen');
    writeln('4 wariacje z powtorzeniami');
    writeln('5 wariacje bez powtorzen');
     writeln('Twoj wybor? ');
     readln(wybor);

     case wybor of
   1: permutacja;
   2: kombinacjezpowtorzeniami;
   3: kombinacjebezpowtorzen;
   4: wariacjezpowtorzeniami;
   5: wariacjebezpowtorzen;

   else writeln('zly wybor');
 end;

 readln();
END.

Wrzuciłeś o dużo za dużo kodu.

Wytnij wszystkie części, które są zbędne, dopóki nie zostanie najmniejsza wersja Twojego programu dalej prezentująca problem (a i przy okazji może sam naprawisz dzięki temu błąd).

Pro tip: użyj debuggera i analizuj działanie programu linijka po linijce. Dzięki temu sam dość szybko znajdziesz miejsce, w którym program zaczyna działać nieprawidłowo. Wartości zmiennych możesz podglądnąć w oknie Watches (trzeba sobie dodać te, które chcesz podglądać), ale też możesz najechać kursorem na nazwę zmiennej i pojawi się hint z zawartością (w trakcie debuggowania rzecz jasna).

Właśnie nie wiem co jest zbedne i gdzie to moze byc, a debuggerem probowalem ale nie widze tego jakos :/.

Chodzi tak dokladniej o to ze jak otworzy sie program to wybieram np 2 kombinacje bez powtorzen,
nastepnie wielkosc zbioru daje np 5,
potem wielkosc podzbioru np 5,
i teraz trzeba podac ilosc generowanych losowych kombinacji i tu jak dam 3 to mi wyswietli kombinacje z powturzeniami 2 i kombinacje z powturzeniami 3 bez 1 kombinacji.
a jak dam np 2 to wyswietli mi dwie akurat.

@studencik156288:
odpaliłem Twój program, zrobiłem tak jak napisałeś i otrzymałem trzy kombinacje

EDT....
A może masz banalny problem :) Aplikacja konsolowa wyświetla treść w oknie tekstowym,które z tego co pamiętam domyślnie pokazuje 25 wierszy tekstu, i wtedy na samym dole masz tylko dwie ostatnie, widzialne kombinacje. A wystarczy przescrollować treść okna i zobaczysz również pierwszą kombinację

Z tego co zauważyłem to problem jest jak się ustawi więcej wariacji niż jest kombinacji, czy coś w tym rodzaju. Czyli jak wpiszemy po kolei 1, 1, 20 to wyświetli się jedna kombinacja i program zawiśnie prawdopodobnie na pętli while powtorka2 = 0 do.

Jak byśmy wpisali kolejno 5, 5, 20 to powinno być ok... Dobrze tego nie sprawdziłem. Kod jest z tego co widzę "podzielony", można wyciągnąć do analizy tylko dwie funkcje, np:

procedure GENEROWANIE_LOSOWYCH_WARIACJI_BEZ_POWTORZEN_W_LICZBIE_k(wielkosc_zbioru,wielkosc_podzbioru,k:integer);
procedure wariacjebezpowtorzen;

i wywołać tą drugą.