#123Permutari

Cerinţa
Se citeşte un număr natural nenul n. Să se afişeze, în ordine lexicografică, permutările
mulţimii {1,2,..,n}.

Date de intrare
Fişierul de intrare permutari.in conţine pe prima linie numărul n.

Date de ieşire
Fişierul de ieşire permutari.out va conţine pe fiecare linie elementele unei permutări,
separate prin câte un spaţiu.

Restricţii şi precizări
• 0<n<9

#include<fstream> g<<x[i]<<" ";

using namespace std; g<<endl;
ifstream f("permutari.in"); }
ofstream g("permutari.out"); void Back(int k) {
int x[10],n; for( int i=1;i<=n;i++)
int Solutie(int k){ {
if(k==n) x[k]=i;
return 1; if(Ok(k))
else return 0; if(Solutie(k))
} Afisare(k);
int Ok (int k) else Back(k+1);
{ }
for (int i=1; i<k; i++) }
if (x[k]==x[i]) return 0; int main()
return 1; {
} f>>n;
void Afisare (int k) Back(1);
{ return 0;
for(int i=1;i<=k;i++)
 #124Permutari1
Cerinţa
Se citeşte un număr natural nenul n. Să se afişeze, în ordine invers lexicografică,
permutările mulţimii {1,2,..,n}.

Date de intrare
Fişierul de intrare permutari1.in conţine pe prima linie numărul n.

Date de ieşire
Fişierul de ieşire permutari1.out va conţine pe fiecare linie elementele unei permutări,
separate prin câte un spaţiu.

Restricţii şi precizări
• 0<n<9

#include <fstream> void Afisare(int k)

using namespace std; { for(int i=1; i<=k; i++)
ifstream f("permutari1.in"); g<<x[i]<<" ";
ofstream g("permutari1.out"); g<<endl;}
int x[10],n; void Back(int k)
{ for(int i = n ; i >= 1 ; i--)
int Solutie(int k) { x[k]=i;
{if(k==n) if( OK(k) )
return 1; if(Solutie(k))
else Afisare(k);
return 0; else
} Back(k+1); }
int OK(int k) }
{for(int i=1; i<k; i++) int main()
if(x[k]==x[i]) { f>>n;
return 0; Back(1);
return 1; return 0;
} }
#125Permutari2
Cerinţa
Se citeşte un număr natural nenul n, apoi n numere naturale distincte. Să se afişeze, în
ordine lexicografică, permutările mulţimii formate din cele n numere citite.

Date de intrare
Fişierul de intrare permutari2.in conţine pe prima linie numărul n, ia r pe a doua
linie n numere naturale.

Date de ieşire
Fişierul de ieşire permutari2.out va conţine pe fiecare linie elementele unei permutări,
separate prin câte un spaţiu.

Restricţii şi precizări
• 0<n<9
• cele n numere de pe a doua linie a fişierului de intrare sunt mai mici decât 100

#include <fstream> { for(int i = 1 ; i <= n ; i++)

using namespace std; {x[k]=i;
ifstream f("permutari2.in"); if( OK(k) )
ofstream g("permutari2.out"); if(Solutie(k))
int x[10],n,v[10],aux; Afisare(k);
int Solutie(int k) else
{ if(k==n) Back(k+1); } }
return 1; int main()
else return 0;} {f>>n;
int OK(int k) for(int i=1; i<=n; i++)
{ for(int i=1; i<k; i++) f>>v[i];
if(x[k]==x[i]) for(int i=1; i<n; i++)
return 0; for(int j=i+1; j<=n; j++)
return 1;} if(v[i]>v[j])
void Afisare(int k) { aux= v[i];
{ for(int i=1; i<=k; i++) v[i]=v[j];
g<<v[x[i]]<<" "; v[j]=aux;}
g<<endl;} Back(1);
void Back(int k) return 0; }
#202PermPF
Fie mulţimea M={1,2,..,n} şi P(1),P(2),...,P(n) o permutare a ei. Elementul x din M se
numeşte punct fix dacă P(x)=x.

Cerinţa
Se citeşte un număr natural nenul n. Să se afişeze, în ordine lexicografică, permutările
fără puncte fixe ale mulţimii {1,2,..,n}.

Date de intrare
Fişierul de intrare permpf.in conţine pe prima linie numărul n.

Date de ieşire
Fişierul de ieşire permpf.out va conţine pe fiecare linie elementele unei permutări,
separate prin câte un spaţiu.

Restricţii şi precizări
• 0<n<9

#include <fstream> return 1;

using namespace std; }
ifstream f ("permpf.in"); void Afisare (int k)
ofstream g ("permpf.out"); {for (int i = 1; i <= k; i++)
int x[10], n,v[10]; g << x[i] << " ";
int g << endl;
Solutie (int k) }
{if (k == n) void Back (int k)
return 1; { for (int i = 1; i <= n; i++)
else { x[k] = i;
return 0; if (OK (k))
} if (Solutie (k))
int Afisare (k);
OK (int k) else
{ for (int i = 1; i < k; i++) Back (k + 1);
if (x[k] == x[i]) } } int main ()
return 0; {f >> n;
if(x[k]==k) Back (1);
return 0; return 0;}
#1281Regine1
Cerința
Se consideră o tablă de șah de dimensiune n. Să se plaseze pe tablă n regine astfel
încât să nu existe două regine care să se atace.

Date de intrare
Programul citește de la tastatură numărul n.

Date de ieșire
Programul va afișa pe ecran o singură configurație validă a tablei de șah. Ea va fi
alcătuită din n linii cu câte n caractere - sau *, separate prin câte un spațiu.
Caracterul - reprezintă o poziție liberă de pe tablă, iar caracterul * reprezintă o poziție de
pe tablă ocupată de o regină.

Restricții și precizări
• 4 ≤ n ≤ 10;
• două regine se atacă dacă se află pe aceeași linie, aceeași coloană sau aceeași
diagonală;
• orice configurație validă a tablei este acceptată.

#include <iostream> if(x[i]==j)

#include <cmath> cout<<"*";
using namespace std; else cout<<"-";
int x[10],n, ns, abs(); cout<<endl;
int Solutie(int k) }}
{if(k==n) void Back(int k)
return 1; {for(int i = 1 ; i <= n ; i++)
else { x[k]=i;
return 0;} if( OK(k) )
int OK(int k) if(Solutie(k))
{for(int i=1; i<k; i++) { ns++;
if(x[i]==x[k]||(abs(x[i]-x[k])==k- if(ns==1)
i)) Afisare(k); }
return 0; else Back(k+1); }
return 1; } int main()
} void Afisare(int k) {cin>>n;
{ for(int i=1; i<=k; i++) ns=0;
{for(int j=1; j<=n; j++) Back(1); return 0;}
#1327SirPIE
Cerinţa
Se citeşte un număr natural nenul n, apoi n numere naturale distincte. Să se afişeze, în
ordine lexicografică, șirurile din cele n valori cu proprietatea că oricare două valori
învecinate sunt prime între ele.

Date de intrare
Fişierul de intrare sirpie.in conţine pe prima linie numărul n, iar pe a doua linie n numere
naturale.

Date de ieşire
Fişierul de ieşire sirpie.out va conţine pe fiecare linie elementele unei șir, separate prin
câte un spaţiu.

Restricţii şi precizări
• 1 ≤ n < 10
• cele n numere de pe a doua linie a fişierului de intrare sunt mai mici decât 10000

#include <fstream>
using namespace std;
ifstream f ("sirpie.in");
ofstream g ("sirpie.out");
int x[10], n,v[10];
int
Solutie (int k)
{
if (k == n)
return 1;
else
return 0;
}
int cmmdc(int a, int b)
{
int r;
r=a%b;
while(r!=0)
 { }
a=b; void Back (int k)
b=r; {for (int i = 1; i <= n; i++)
r=a%b; { x[k] = i;
} if (OK (k))
return b; if (Solutie (k))
} Afisare (k);
int else Back (k + 1);
OK (int k) }}
{ int main ()
for (int i = 1; i < k; i++) {
if (x[k] == x[i]) int i,j,aux;
return 0; f >> n;
if(k>1) for(i=1; i<=n; i++)
if(cmmdc(v[x[k- f>>v[i];
1]],v[x[k]])!=1) for(i=1; i<n; i++)
return 0; for(j=i+1; j<=n; j++)
return 1; if(v[i]>v[j])
} {
void Afisare (int k) aux=v[i];
{ v[i]=v[j];
for (int i = 1; i <= k; i++) v[j]=aux; }
g << v[x[i]] << " "; Back (1);
g << endl; return 0;}
#3161permutari5
Cerința
Se citește o multime cu n numere naturale. Afișați în ordine lexicografică toate
permutările mulțimii citite în care elementul minim nu își schimbă poziția.

Date de intrare
Programul citește de la tastatură numărul n, iar apoi n numere naturale distincte,
separate prin spații.

Date de ieșire
Programul va afișa pe ecran permutările cerute, pe rânduri separate, fiecare permutare
având elementele separate prin câte un spațiu.

Restricții și precizări
• 1 ≤ n ≤ 10
• cele n numere citite vor fi mai mici decât 1.000.000.000 și vor fi distincte

#include <iostream> if(Solutie(k))

using namespace std; Afisare(k);
int x[10],n,aux,v[100],vmin,pmin; else Back(k+1); } }
int Solutie(int k) int main(){ cin>>n;
{ if(k==n) return 1; for(int i=1;i<=n;i++)
else return 0; cin>>v[i];
} int OK(int k) vmin=v[1];
{for(int i=1;i<k;i++) pmin=1;
if(x[i]==x[k]) return 0; for(int i=1;i<=n;i++)
if(v[x[k]]==vmin && k!=pmin) if(v[i]<vmin)
return 0; {vmin=v[i];
return 1;} pmin=i;}
void Afisare(int k) for(int i=1;i<n;i++)
{for(int i=1;i<=k;i++) for(int j=i+1;j<=n;j++)
cout<<v[x[i]]<<" "; if(v[i]>v[j])
cout<<endl; } { aux=v[i];
void Back(int k){ v[i]=v[j];
for(int i=1;i<=n;i++) v[j]=aux; }
{ x[k]=i; Back(1); return 0;}
if(OK(k))
#196 Aranjamente
Se numește anagramă a unui cuvânt dat, un alt cuvânt ce conține toate literele primului,
eventual în altă ordine.

Cerinţa
Se dă un cuvânt din cel mult 8 litere distincte. Să se afișeze, în ordine alfabetică, toate
anagramele acestui cuvânt.

Date de intrare
Fişierul de intrare anagrame1.in conţine pe pe prima linie un cuvânt S, format din cel
mult 8 litere distincte ale alfabetului englez.

Date de ieşire
Fişierul de ieşire anagrame1.out va conţine toate anagramele cuvântului S, fiecare pe o
linie, în ordine alfabetică.

#include <fstream> for (int i=1; i<=k; i++)

using namespace std; g<<x[i]<<" ";
ifstream f("aranjamente.in"); g<<endl;
ofstream g("aranjamente.out"); }
int x[10],n,p;
int Solutie(int k) void Back(int k)
{ {
if (k==p) for(int i =1 ; i <= n ; ++i)
return 1; {
else x[k]=i;
return 0; if( OK(k) )
} if(Solutie(k))
int OK(int k) Afisare(k);
{ else
for (int i=1; i<k; i++) Back(k+1);
if (x[k]==x[i]) }
if(k==p) }
return 0; int main()
return 1; {
} f>>n>>p;
void Afisare(int k) Back(1);
{ return 0;}
#197Combinari
Cerinţa
Se citesc două numere naturale nenule n și k. Să se afişeze, în ordine lexicografică,
submulțimile de câte k elemente ale mulţimii {1,2,..,n}.

Date de intrare
Fişierul de intrare combinari.in conţine pe prima linie numerele n și k, separate printr-un
spatiu.

Date de ieşire
Fişierul de ieşire combinari.out va conţine pe fiecare linie câte k valori, separate prin câte
un spaţiu, reprezentând elementele unei submulțimi.

Restricţii şi precizări
• 1 ≤ k ≤ n ≤ 15
• elementele fiecărei submulţimi vor fi afişate în ordine crescătoare

#include <fstream> {for (int i=1;i<=k;i++)

using namespace std; g<<x[i]<<" ";
ifstream f("combinari.in"); g<<endl;}
ofstream g("combinari.out"); void Back(int k){
int x[10],n,p; for(int i =1 ; i <= n ; ++i)
int Solutie(int k){ {x[k]=i;
if (k==p) return 1; if( OK(k) )
else return 0; if(Solutie(k))
} int OK(int k){ Afisare(k);
for (int i=1; i<k;i++) else
if (x[k]==x[i]) return 0; Back(k+1); } }
if (k>1) int main(){
if(x[k-1]>x[k]) return 0; f>>n>>p;
return 1; Back(1);
} void Afisare(int k) return 0;}
#3156perm_min_max
Cerința
Se citește o mulțime cu n numere naturale. Afișați în ordine lexicografică toate
permutările mulțimii citite în care elementul minim și cel maxim nu își schimbă poziția.

Date de intrare
Programul citește de la tastatură numărul n, iar apoi n numere naturale distincte,
separate prin spații.

Date de ieșire
Programul va afișa pe ecran permutările cerute, pe rânduri separate, fiecare permutare
având elementele separate prin câte un spațiu.

Restricții și precizări
• 1 ≤ n ≤ 10
• cele n numere citite vor fi mai mici decât 1.000.000.000 și vor fi distincte

#include <iostream>
using namespace std;
int x[10],n,aux,v[100],vmin,pmin,pmax,vmax;
int Solutie(int k)
{ if(k==n)
return 1;
else return 0;
} int OK(int k)
{ for(int i=1;i<k;i++)
if(x[i]==x[k]) return 0;
if(v[x[k]]==vmin && k!=pmin) return 0;
if (v[x[k]]==vmax && k!=pmax) return 0;
return 1;}
void Afisare(int k)
{ for(int i=1;i<=k;i++)
cout<<v[x[i]]<<" ";
cout<<endl;
} void Back(int k){
for(int i=1;i<=n;i++)
{ x[k]=i;
if(OK(k))
if(Solutie(k))
Afisare(k);
else Back(k+1); } }
int main(){
cin>>n;
for(int i=1;i<=n;i++)
cin>>v[i];
vmin=v[1];
pmin=1;
for(int i=1;i<=n;i++)
if(v[i]<vmin)
{vmin=v[i];
pmin=i;}
vmax=v[1];
pmax=1;
for(int i=1;i<=n;i++)
if(v[i]>vmax)
{vmax=v[i];
pmax=i;}
for(int i=1;i<n;i++)
for(int j=i+1;j<=n;j++)
if(v[i]>v[j])
{
aux=v[i];
v[i]=v[j];
v[j]=aux;
}
Back(1);
return 0;}