CAP.

10 Generarea elementelor if k=1 then tiparire {dacă a rămas un singur element de permutat
înseamnă că am generat deja o permutare şi aceasta trebuie tipărită}
combinatoriale else begin{dacă mai avem de generat permutări}
for i:=1 to k do begin
x:=a[i];{interschimbăm, rând pe rând elementul k}
10.1 Permutări. Aranjamente. Combinări a[i]:=a[k];{cu elementele de dinaintea lui}
a[k]:=x;
Generarea permutărilor permut(k-1);{generăm permutări pentru k+1 elem}
{Se consideră o secvenŃă de n numere naturale distincte. Se cere să se x:=a[i];{la revenire refacem situaŃia anterioară}
redacteze o procedură care generează toate permutările celor n numere} a[i]:=a[k];
a[k]:=x;
Program Partitionari; end;
uses crt; end;
const nmax=100; end;
var a:array[1..nmax] of integer; begin
n:integer; clrscr;
procedure citire;{citeşte elementele} citire;
var i:integer; permut(n);
begin readln;
write('DaŃi numărul de numere :'); end.
readln(n); Generarea aranjamentelor
for i:=1 to n do {Să se realizeze un program care citeşte o secvenŃă de n caractere
readln(a[i]); diferite şi tipăreşte toate aranjamentele luate câte m (cu repetiŃie) a
end; celor n caractere.}
procedure tiparire;{tipăreşte o permutare} {REZOLVARE}
var j:integer; {Caracterele se vor citi în tabloul text. În tabloul indici se va genera
begin succesiunea de indici corespunzătoare combinărilor.}
for j:=1 to n do write(a[j]);
writeln; OBS. Daca liniile 1, 2, 3 lipsesc se vor afişa aranjamentele cu
end; repetiŃii}
procedure permut(k:integer);{permută k elemente}
var i,x:integer; Program Aranjamente;
begin uses crt;
const maxcar=10;
 var text:array[1..maxcar] of char;{în text se memorează cacacterele} readln(n);
indici:array[1..maxcar] of integer;{în indici[i] vom avea memorată write('luate câte ');
poziŃia pe care se află al i-ulea caracter} readln(m);
m,n:integer; if (n>10) or (m>n) then write('Date eronate')
procedure citeste;{ citeşte caracterele} else begin
var i:integer; write('Textul:');
begin citeste;
for i:=1 to n do readln(text[i]); writeln;
end; aranj(0);
procedure tipareste;{tipăreşte un aranjament} end;
var i:integer; readln;
begin end.
for i:=1 to m do
write(text[indici[i]]); Generarea combinărilor
writeln; {se vor afişa toate combinarile de n numere(de la 1 la n)
end; luate câte k}
procedure aranj(k:integer);{avem de aranjat k elemente} program combinari;
var j,t:integer; var r:array[1..100] of integer;{în r se generează
combinările}
begin n,k:integer;
if k<m then{dacă mai avem de adăugat elemente} procedure citire;
for j:=1 to n do begin{generăm un indice} var i:integer;
indici[k+1]:=j;{pentru elementul ce va fi adăugat} begin
{în secvenŃa de mai jos se verifică dacă elementul j nu a mai fost write('DaŃi n:');readln(n);
write('DaŃi k:');readln(k);
utilizat anterior(dacă nu se găseşte printre primele k elemente)} end;
{1} t:=0; procedure afisare;
{2} repeat t:=t+1;until indici[t]=j; var i:integer;
{3} if t=k+1 then begin
for i:=1 to k do write(r[i],' ');
aranj(k+1); writeln;
end end;
else tipareste;{dacă am adăugat deja m elemente tipărim} {p-nr. termenului al combinaŃiei ce se generează;x-se
end; foloseşte pentru a evita repetiŃiile}
begin procedure combin(p,x:integer);
var i:integer;
clrscr; begin
write('DaŃi numărul de caractere :');
for i:=x to n do{pe poziŃia p vom pune elementele de la x if i>1 then
la n} for j:=1 to i-1 do if a[i]=a[j] then i:=i-1;{dacă elementul a mai fost citit
begin
r[p]:=i;{pe poziŃia p vom pune elementul i} se va repeta citirea}
if p=k then afisare{dacă am pus al k-lea element end;
afişăm} end;
else combin(p+1,i+1);{dacă nu adăugăm pe procedure cartezian;
poziŃia următoare elementele mai mari decât cel adăugat
pe poz. p}
var i,j:integer;
end; begin
end; k:=0;
begin for i:=1 to n do
citire; for j:=1 to m do
combin(1,1);{vom pune elemente pornind de la prima
poziŃie,pe acesta putând pune elemente pornind de la writeln('(',a[i],',',b[j],')');
primul} end;
end. begin
clrscr;
10.1 Produs caertezian. SubmulŃimi. PartiŃii citire(n,a);citire(m,b);
cartezian;
readln;
Generarea produsului cartezian end.
program produs_cartezian;
{Produs cartezian} Generări de submulŃimi
uses crt;
type multime=array[1..100]of integer; program generarea_partitiilor_unei_multimi;
var a,b:multime; {In x[i] se reŃine numărul mulŃimii din care face parte elementul i}
c:array[1..100,1..2] of integer; var x:array[1..100] of integer;
n,m,i,k:integer; n:integer; {nr. de elemente}
procedure citire(var n:integer;var a:multime);{citeşte elementele unei procedure scrie(max:integer); {max reprezintă nr. de partiŃii
mulŃimi} (mulŃimi)}
var i,j:integer; var i,j:integer; {dacă se doreşte doar o anumită mulŃime să fie afişată}
begin begin {atunci se pune condiŃia la afişare}
write('Numărul de elemente a mulŃimii:'); for i:=1 to max do {pentru fiecare mulŃime în parte}
readln(n); begin
for i:=1 to n do begin write('{');
write('DaŃi elementul ',i,' al mulŃimii:'); for j:=1 to n do {tipărim elementul j dacă aparŃine mulŃimii i}
readln(a[i]);
 if x[j]=i then write(j,' '); var i:integer;
writeln('}'); begin
write('n=');
end; for i:=1 to k-1 do write(x[i],'+');
readln; writeln(x[k]);
end; readln;
procedure partitioneaza(k:integer); {k = nr. elementului ce se adaugă} end;
{k=nr. de partiŃii;n=nr. ce se partiŃionează}
var a,max,i:integer; procedure part(k,n:integer);
begin var i:integer;
max:=0; {vom căuta nr. maxim al mulŃimii la care a fost adăugat begin
unul} for i:=1 to n do
for i:=1 to k-1 do {din primele k-1 elemente, acesta este practic} begin
x[k]:=i; {partiŃia k poate lua orice val. pozitivă mai
if x[i]>max then max:=x[i]; {numărul de mulŃimi} mică ca n}
if k=n+1 then scrie(max) {dacă nr. de elem. ce se va adăuga este n+1 if n-i>0 then part(k+1,n-i) {dacă mai poate fi
se afişează} partiŃionat se partiŃionează}
else else
scrie(k); {dacă nu, se afişează}
{vom încerca să adăugăm elementul k mulŃimii nr. a} end;
for a:=1 to max+1 do {deci îl vom adăuga mulŃimii 1, apoi la mult. 2 end;
...} begin
begin write('DaŃi n:');readln(n);
x[k]:=a; {elementul k face parte din mulŃimea a} part(1,n);
end.
partitioneaza(k+1); {se trece la următorul element}
end;
end; program generarea_partitiilor_unei_multimi;
begin {In x[i] se reŃine numărul mulŃimii din care face parte
write('Dati n:');readln(n); elementul i}
var x:array[1..100] of integer;
partitioneaza(1); n:integer; {nr. de elemente}
end. procedure scrie(max:integer); {max reprezintă nr. de
partiŃii(mulŃimi)}
Generarea partiŃiilor var i,j:integer;
begin
for i:=1 to max do {pentru fiecare mulŃime în parte}
program generarea_partitiilor_unui_nr_natural;
begin
var x:array[0..100] of integer;
write('{');
n:integer; for j:=1 to n do {tipărim elementul j dacă aparŃine
procedure scrie(k:integer); {afişează pe n ca sumă de k
mulŃimii i}
nr.} if x[j]=i then write(j,' ');
 writeln('}');
end;
readln;
end;
procedure partitioneaza(k:integer); {k = nr. elementului
ce se adaugă}
var a,max,i:integer;
begin
max:=0; {vom căuta nr. maxim al mulŃimii la care a fost
adăugat unul}
for i:=1 to k-1 do {din primele k-1 elemente, acesta
este practic}
if x[i]>max then max:=x[i]; {numărul de mulŃimi}
if k=n+1 then scrie(max) {dacă nr. de elem. ce se va
adăuga este n+1 se afişează}
else
{vom încerca să adăugăm elementul k mulŃimii nr. a}
for a:=1 to max+1 do {deci îl vom adăuga mulŃimii 1,
apoi la mulŃ. 2 ...}
begin
x[k]:=a; {elementul k face parte din mulŃimea a}
partitioneaza(k+1); {se trece la următorul element}
end;
end;
begin
write('DaŃi n:');readln(n);
partitioneaza(1);
end.