none
Kombinace - výpis

Odpovědi

  • V jednoduchosti je krása. Dokážu rychleji přemýšlet v PASCALu a proto jsem to napsal v něm. Toto je funkční příklad:

     

                       { Generuj  kombinace o K třídách z N prvku }

    const
    K=3; { K-tá třída } const N=9; { z N prvků } var mnozina:array[1..K] of integer; { sem se generuji mnoziny } procedure generuj(kolikaty, od_prvku: integer); var i,prvek: integer; begin if kolikaty<=K then begin for prvek:=od_prvku to N do begin { vybirej postupne po sobe prvky od prvniho mozneho do posledniho } mnozina[kolikaty]:=prvek; { uloz (prepis) prvek do mnoziny }
    generuj(kolikaty+1,prvek+1); { pokracuj dalsim prvkem v mnozine }
     end; end else begin
    for i:=1 to K do write(mnozina[i],':'); writeln; { prave mame vygenerovanou dalsi mnozinu K prvku, opis ji } end; end; begin generuj(1, 1); { zacni prvni tridou (prvni polozkou mnoziny) a prvnim prvkem } end.


    Program se postupně (rekurzí) zanořuje pro generování prvního, druhého až K-tého prvku množiny. Neopakování je založeno na cyklu od prvku od jedničku větším než je ten, který jsem právě uložil do množiny. Pokud už nejde vytvořit množina (jsem za koncem seznamu prvků), skončí (nebo se ani nezačne vykonávat) cyklus FOR.

    Nechce se mi to převádět do syntaxe C#. To si už uprav sám.


    JCH


    středa 21. prosince 2011 17:43

Všechny reakce

  • Počet kombinací k-té třídy z n prvků s opakováním nebo bez opakování?
    JCH
    středa 21. prosince 2011 16:35
  • Právě že bez opakování.
    středa 21. prosince 2011 16:38
  • No i v tom nevidím velký problém. Stačí kontrolovat existenci (opakování) v už přidělených prvcích.

     

    Jak chceš mít reprezentaci (hodnoty) členů? Stačí třeba vybrat k prvků z čísel od 1 do n?

     

    Pokud ano, vytvoř si pole o k prvcích a budeme ho plnit. Od prvního do k tého prvku.

    Vyplňovat budeme od prvního do posledního prvku.

    Začneme prvním prvkem a prvním prvkem (čísle 1).     Pokračovat potom budeme čísly 2 až n.

    Před posunem na druhý prvek ale začneme plnit druhou pložku pole a teké začneme prvním prvkem (číslem 2) až číslem n.

    A naposled budeme plnit třetí prvek od čísla 3 do n.

     

    Celé to napiš v cyklech nebo ještě lépe rekurzí.


    3 třída z 9 prvků tak bude vypadat takto:

    1 2 3

    1 2 4

    1 2 5

    1 2 6

    1 2 7

    1 2 8

    1 2 9

    ------

    1 3 4

    1 3 5

    1 3 6

    1 3 7

    1 3 8

    1 3 9

    ------

    1 4 5

    1 4 6

    1 4 7

    1 4 8

    1 4 9

    ------

    .... a tak dál

    ------

    2 3 4

    2 3 5

    2 3 6

    2 3 7

    2 3 8

    2 3 9

    ------

    2 4 5

    2 4 6

    2 4 7

    2 4 8

    2 4 9

    ------

    2 5 6

    2 5 7

    2 5 8

    2 5 9

    ------

    .... a tak dál až

    2 8 9

    ------

    3 4 5

    3 4 6

    3 4 7

    3 4 8

    3 4 9

    ------

    3 5 6

    3 5 7

    3 5 8

    3 5 9

    ------

    .... a tak dál až

    3 8 9

    ------

    4 5 6

    4 5 7

    4 5 8

    4 5 9

    ------

    až poslední

    7 8 9

    ------

     

     

    Celkem 84 kombinací bez opakování.


    JCH
    středa 21. prosince 2011 16:57
  • V jednoduchosti je krása. Dokážu rychleji přemýšlet v PASCALu a proto jsem to napsal v něm. Toto je funkční příklad:

     

                       { Generuj  kombinace o K třídách z N prvku }

    const
    K=3; { K-tá třída } const N=9; { z N prvků } var mnozina:array[1..K] of integer; { sem se generuji mnoziny } procedure generuj(kolikaty, od_prvku: integer); var i,prvek: integer; begin if kolikaty<=K then begin for prvek:=od_prvku to N do begin { vybirej postupne po sobe prvky od prvniho mozneho do posledniho } mnozina[kolikaty]:=prvek; { uloz (prepis) prvek do mnoziny }
    generuj(kolikaty+1,prvek+1); { pokracuj dalsim prvkem v mnozine }
     end; end else begin
    for i:=1 to K do write(mnozina[i],':'); writeln; { prave mame vygenerovanou dalsi mnozinu K prvku, opis ji } end; end; begin generuj(1, 1); { zacni prvni tridou (prvni polozkou mnoziny) a prvnim prvkem } end.


    Program se postupně (rekurzí) zanořuje pro generování prvního, druhého až K-tého prvku množiny. Neopakování je založeno na cyklu od prvku od jedničku větším než je ten, který jsem právě uložil do množiny. Pokud už nejde vytvořit množina (jsem za koncem seznamu prvků), skončí (nebo se ani nezačne vykonávat) cyklus FOR.

    Nechce se mi to převádět do syntaxe C#. To si už uprav sám.


    JCH


    středa 21. prosince 2011 17:43
  • Program se všemi podmínkami, aby se nepřekročili prvkové operace. Vhodný pro změnu prvků na výčet hodnot:

     

    const N=9;
    const K=3;
    
    
    var mnozina:array[1..K] of integer;
    
    procedure generuj(kolikaty, od_prvku: integer);
    var prvek,i: integer;
    begin
      for prvek:=od_prvku to N do begin
        mnozina[kolikaty]:=prvek;
        if kolikaty=K then begin
          for i:=1 to K do write(mnozina[i],':'); writeln;
        end;
        if (kolikaty < K)and(prvek < N)then begin
          generuj(kolikaty+1, prvek+1);
        end;
      end;
    end;
    
    
    begin
      generuj(1,1);
    end.
    
    



    JCH
    čtvrtek 22. prosince 2011 9:59
  • Děkuji za pomoc.
    čtvrtek 22. prosince 2011 19:09
  • Pokud je problém vyřešen, označ prosím odpověď.

    JCH
    sobota 14. ledna 2012 8:21