#202

Se citeste un numar natural n. Afisati permutarile multimii 1,2,3...n in care elementele pare sunt
puncte fixe (se afla pe pozitie egale cu valoarea lor).
#include <fstream>
using namespace std;
ifstream fin("date.in");
ofstream fout("date.out");
int n, sol[40], p[40];
void afis()
{
for(int i=1;i<=n;i++)
if(i%2==0) fout<<i<<" ";
else fout<<sol[i]<<" ";
fout<<endl;
}
void back(int k)
{
for(int i=1;i<=n;i=i+2)
if(p[i]==0)
{
sol[k]=i;
p[i]=1;
if(n%2==0 && k==n-1 || n%2==1 && k==n) afis();
else back(k+2);
p[i]=0;
}
}
int main()
{
fin>>n;
back(1);
fin.close();
fout.close();
}

#1322
Se citesc doua numere naturale n si k, k fiind mai mic decat numarul de cifre ale numarului n. Afisati
cel mai mare numar care se poate forma eliminand k cifre din numarul n.
#include <iostream>
using namespace std;
int n, a[10],x[10],maxx,k;
int numar(int a[10],int x[10], int c)
{
int nr=0;
for(int i=1;i<=c;i++)
nr=nr*10+a[x[i]];
return nr;
}
void back(int k, int c)
{
for(int i=n;i>=1;i--)
if(i<x[k-1] || k==1)
{
x[k]=i;
if(k==c)
{
int nr=numar(a,x,c);
if(nr>maxx) maxx=nr;
}
else back(k+1,c);
}
}
int main()
{
cin>>n>>k;
int i=0;
while(n)
{
a[++i]=n%10;
n=n/10;
}
n=i;
back(1,n-k);
cout<<maxx;
return 0;
}

#1832
Se dă un număr natural s. Determinaţi, în ordine lexicografică, toate modalităţile de
a-l scrie pe s ca produs de divizori proprii distincți ai lui s.
# include <iostream>
# include <algorithm>
using namespace std;

int D[205];
short nr,da,Sol[205];
unsigned long long S;

inline void divi(int x)

{
int i=0,d=2;
while (x>1)
{
if (d*d==x)
{
D[i++]=d;
x=1;
}
 else
{
if (x%d==0)
{
D[i++]=d;
D[i++]=x/d;
}
d++;
}
if (d*d>x)
x=1;
}
nr=i;
sort(D,D+nr);
}

inline void bac (int poz, int di, unsigned long long s)
{
if (s==S)
{
da=1;
for (int i=0;i<poz;i++)
cout<<D[Sol[i]]<<' ';
cout<<'\n';
}
else
{
unsigned long long p;
short co=1;
for (int i=di; co && i<nr; i++)
{
p=s*D[i];
if (p<=S)
{
Sol[poz]=i;
bac (poz+1, i+1, p);
}
else
co=0;
}
}
}

int main (void)

{
cin>>S;
divi(S);
bac(0,0,1);
if (!da)
 cout<<"NU EXISTA";
return 0;
}

#324
Se dă un număr natural n şi o mulţime cu m elemente, numere naturale nenule. Determinaţi, în ordine
lexicografică, toate modalităţile de a-l scrie pe n ca sumă de termeni din acea mulţime.
#include <iostream>

#include <fstream>

using namespace std;

ifstream f("partitiinumar4.in");

ofstream g("partitiinumar4.out");

int n, m, x[41], v[41];

void afis(int k)

for(int i = 1; i <= k; i++)

g << v[x[i]] << ' ';

g << endl;

void sort()

for(int i = 1; i < m; i++)

for(int j = i + 1; j <= m; j++)

if(v[i] > v[j])

int aux = v[i];

v[i] = v[j];

v[j] = aux;
 }

void backt(int k, int s)

for(int i = x[k - 1]; i <= m; i++)

x[k] = i;

int sum = s + v[x[k]];

if(sum <= n) //valid

if(sum == n) //este solutie

afis(k);

else

backt(k + 1, sum);

int main()

f >> n >> m;

for(int i = 1; i <= m; i++)

f >> v[i];

sort();

x[0] = 1; //artificiu !!

backt(1, 0);
 return 0;

#1477
Scrieţi un program care încrucişează o mulţime de cuvinte într-
un careu.
#include <iostream> // cin, cout, endl
#include <cstring> // strstr, strlen

using namespace std;

char litere[30], matrice_cuvinte[30][30], careu[30][30];

unsigned int indice_litere = 0, numar_cuvinte, linii_careu = 0, coloane_careu = 0;

bool matrice_afisata = false;

/**
* Verific daca cuvantul trimis ca parametru se afla in careu
* (pe verticala sau orizontala)
*/
bool cuvant_existent_in_careu(char cuvant[])
{
unsigned int indice_linie, indice_coloana;

// orizontala
for (indice_linie = 0; indice_linie < linii_careu; ++indice_linie)
{
if (strstr( careu[indice_linie], cuvant))
{
return true;
}
}

// verticala
char caractere_verticale[100];
for (indice_coloana = 0; indice_coloana < coloane_careu; ++indice_coloana)
{
for (indice_linie = 0; indice_linie < linii_careu; ++indice_linie)
{
caractere_verticale[indice_linie] =
careu[indice_linie][indice_coloana];
}
caractere_verticale[indice_linie] = '\0';
if (strstr(caractere_verticale, cuvant) != NULL)
{
return true;
}
}
return false;
}

/**
* Fiecare cuvant introdus de la tastatura se afla in careu
*/
bool careu_valid()
{
unsigned int it;
 for (it = 0; it < numar_cuvinte; ++it)
{
if (!cuvant_existent_in_careu(matrice_cuvinte[it]))
{
return false;
}
}
return true;
}

/**
* Verific daca caracterul c exista deja in vectorul de litere
*/
bool array_litere_contine_litera(char c)
{
for (unsigned int it = 0; it < indice_litere; ++it)
{
if (litere[it] == c)
{
return true;
}
}
return false;
}

/**
* Creez un vector cu literele din cuvintele introduse de la tastatura,
* pentru a nu introduce in careu, de exemplu, litera Q daca ea nu se afla
* in niciun cuvant.
*/
void creare_litere()
{
litere[indice_litere++] = '-';
for(unsigned int it = 0; it < numar_cuvinte; ++it)
{
unsigned int numar_caractere = strlen(matrice_cuvinte[it]);
for (unsigned int it2 = 0; it2 < numar_caractere; ++it2)
{
if (!array_litere_contine_litera(matrice_cuvinte[it][it2]))
{
litere[indice_litere++] = matrice_cuvinte[it][it2];
}
}
}
litere[indice_litere] = '\0';
}
void afis_careu()
{
for (unsigned int i = 0; i < linii_careu; ++i)
{
for (unsigned int j = 0; j < coloane_careu; ++j)
{
cout << careu[i][j] << ' ';
}
cout << endl;
}
cout << endl << endl;
}

void backtracking(unsigned int indice_linie, unsigned int indice_coloana)

{
 if (!matrice_afisata)
{
for (unsigned int it = 0; it < indice_litere; ++it)
{
careu[indice_linie][indice_coloana] = litere[it];
if (careu_valid())
{
matrice_afisata = true;
afis_careu();
}
if (!matrice_afisata)
{
if (indice_linie != linii_careu - 1 ||
indice_coloana != coloane_careu - 1)
{
if (indice_coloana == coloane_careu - 1)
{
backtracking(indice_linie + 1, 0);
}
else
{
backtracking(indice_linie,
indice_coloana + 1);
}
}
}
}
}
}

int main()
{
cout << "Introduceti numarul de cuvinte: ";
cin >> numar_cuvinte;

for (unsigned int it = 0; it < numar_cuvinte; ++it)

{
cin >> matrice_cuvinte[it];
}

cout << "Numar linii careu: ";

cin >> linii_careu;

cout << "Numar coloane careu: ";

cin >> coloane_careu;

creare_litere();

for (unsigned int i = 0; i < linii_careu; ++i)

{
for (unsigned int j = 0; j < coloane_careu; ++j)
{
careu[i][j] = '-';
}
}

backtracking(0, 0);

if (!matrice_afisata)
{
for (unsigned int i = 0; i < linii_careu; ++i)
{
for (unsigned int j = 0; j < coloane_careu; ++j)
 {
cout << "- ";
}
cout << endl;
}
}

return 0;
}

#1502
Se consideră un şir de cifre zecimale (de la 0 la 9). În acest şir trebuie să inserăm virgule, separând
astfel cifrele în scopul de a forma numere.
Scrieţi un program care să insereze virgule în şirul de cifre astfel încât să se obţină o secvenţă de
numere strict crescătoare, iar ultimul număr din secvenţă să fie minim.
#include <fstream>
#include <cstring>
using namespace std;
ifstream fin("virgule.in");
ofstream fout("virgule.out");
bool poz[100], sol[100], first = true; //sol[i] - este adevarat daca exista virgula inainte de caracterul
de pe pozitia i
int grd = 0, gc;
int n;
//compara numerele dintre pozitiile b1 si e1, si b2 si e2; returneaza true daca numarul format intre
b1 si e1 este mai mare
bool cmp(char *s, int b1, int e1, int b2, int e2)
{
while (s[b1] == '0' && b1 < e1) b1++;
while (s[b2] == '0' && b2 < e2) b2++;

if (e1 - b1 != e2 - b2)
return (e1 - b1) > (e2 - b2);
while (s[b1] == s[b2] && b1 < e1) {b1++; b2++;}
return s[b1] > s[b2];
}
//verifica daca solutia curenta este mai buna decat solutia optima, conform precizarilor din
problema
void verif_sol(char *s)
{
if (first == true)
{
grd = gc;
for (int i = 0; i < n; i++)
sol[i] = poz[i];
first = false;
}
else if (gc == grd)
{
int b1 = 0, e1 = 1, b2 = 0, e2 = 1;
while (e1 < n && e2 < n)
 {
while (poz[e1] != 1 && e1 < n) e1++;
while (sol[e2] != 1 && e2 < n) e2++;
bool v1 = cmp(s, b1, e1 - 1, b2, e2 - 1);
bool v2 = cmp(s, b2, e2 - 1, b1, e1 - 1);
if (v1 != v2)
{
if (v1)
{
for (int i = 0; i < n; i++)
sol[i] = poz[i];
}
return;
}
else
{
b1 = e1++; b2 = e2++;
}
}

}
}
void print_sol(char *s)
{
fout << s[0];
for (int i = 1; i < n; i++)
{
if (sol[i])
fout << ',';
fout << s[i];
}
}
void bkt(char *s, int b, int e)
{
if (b == 0)
{
verif_sol(s);
return;
}
for (int i = b - 1; i >= 0; i--)
{
if (cmp(s, b, e, i, b - 1))
{
poz[i] = 1;
bkt(s, i, b - 1);
poz[i] = 0;
}
else break;
}
}

int main()
{
char s[100];
fin.getline(s, 100);
n = strlen(s);
for (int i = n - 1; i >= 0 && (first || s[i] == '0'); i--)
{
gc = n - i;
poz[i] = 1;
bkt(s, i, n - 1);
poz[i] = 0;
}
print_sol(s);
return 0;
}

#1355
Să se genereze toate şirurile strict crescătoare de n numere naturale nenule cel mult egale cu S și cu
proprietatea că oricare ar fi a şi b două numere dintr-un astfel de şir a-b divide a+b.
#include <fstream>
using namespace std;

ifstream fin("sirab.in");
ofstream fout("sirab.out");

int S, n, v[7];
bool afisat = false;

void afisare()
{
afisat = true;
for(int i = 0; i < n; i++)
fout<<v[i]<<' ';
fout<<'\n';
}
bool verificare(int k, int val)
{
for(int i = 0; i < k; i++)
if((v[i] + val) % (v[i] - val)) return false;

return true;
}
void bkt(int k, int first)
{
if(k == n)
{
 afisare();
return;
}
for(int i = first; i <= S; i++)
{
if(k == 0)
{
v[0] = i;
bkt(k + 1, i + 1);
}
else if(verificare(k, i))
{
v[k] = i;
bkt(k + 1, i + 1);
}
}
}

int main()
{
fin>>S>>n;
bkt(0, 1);
if(!afisat) fout<<0;
}

#123
Se citeşte un număr natural nenul n. Sa se afiseze in ordine lexicografica submultimile multimii
{1,2,...,n}.
#include<iostream.h>
int n, s[20];
void afis(int n)
{
for(int i=1;i<=n;i++) cout<<s[i]<<" ";
cout<<endl;
}
void back(int k)
{ for(int i=s[k-1]+1;i<=n;i++)
{ s[k]=i;
afis(k);
back(k+1);
}
}
void main()
{ cin>>n;
back(1);
}
SAU ASA CU FISIER
#include<iostream>
#include<fstream>
using namespace std;
int st[12], n, x;
ifstream fin("permutari.in");
ofstream fout("permutari.out");
void tipar(int l)
{
int i;
for(i=1;i<=l;i++)
fout<<st[i]<<" ";
fout<<endl;
}
int valid(int l)
{
int i;
for(i=1;i<l;i++)
if(st[i]==st[l]) return 0;
return 1;
}
void back(int vf)
{
int k;
for(k=1;k<=n;k++)
{
st[vf]=k;
if(valid(vf))
{
if(vf==n) tipar(vf);
else back(vf+1);
}
}
}
int main()
{
fin>>n; //st[0]=0;
back(1);
return 0;
}

#1277
Se dau două numere naturale nenule n și m. Considerăm mulțimea A={1,2,..,n}. Să se genereze în
ordine lexicografică elementele produsului cartezian Am=A×A×⋯×A.
#include <fstream>
using namespace std;
ifstream fin("produscartezian1.in");
ofstream fout("produscartezian1.out");
int n, m;
int a[10], len = 0;
void push(int x)
{
a[len++] = x;
}
void pop()
{
if(len > 0)
len--;
}
void afisare_sir()
{
for(int i = 0; i < len; i++)
{
fout<<a[i]<<' ';
}
fout<<'\n';
}
void bkt(int k)
{
if (k < m)
{
for(int i = 1; i <= n; i++)
{
push(i);
bkt(k + 1);
pop();
}
}
else
{
afisare_sir();
}
}
int main()
{
fin>>n>>m;
bkt(0);
}
#1287
Se dau două cifre a b și un număr n. Să se genereze toate numerele cu exact n cifre cuprinse între a
și b.
#include <iostream>
using namespace std;
int n, x[10], a, b;
void afis(int k){
for(int i=1 ; i <= k ; ++i)
cout << x[i];
cout << endl;
}
void back(int k){
for(int i = a; i <= b ; ++i)
{
x[k]=i;
if(k == n)
afis(k);
else
back(k+1);
}
}

int main(){
cin >> a >> b >> n;
back(1);
return 0;
}

#125
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.
#include <fstream>
#include <algorithm>
using namespace std;
int x[10], a[10] ,n;
ofstream fout("permutari.out");
int OK(int k)
{
for(int i=1;i<k;++i)
if(x[k]==x[i]) return 0;
return 1;
}
void back(int k)
{
for(int i=1 ; i<=n ; ++i)
{ x[k]=i;
if( OK(k) )
if(k==n)
{
for( int j=1;j<n;j++)
fout<<a[x[j]]<<" ";
fout<<a[x[n]]; fout<<endl;
}
else back(k+1);
}
}
int main()
{
ifstream fin("permutari.in");
 fin>>n;
for(int i=1;i<=n;++i)
fin >> a[i];
fin.close();
sort(a+1 , a+n+1);
back(1);
fout.close();
return 0;
}
SAU!!!!!!!!!!!!!!!!!!!!
PERMUTĂRI DE CUVINTE
Se citeşte N natural. Se citesc N cuvinte. Să se genereze permutările mulţimii formate din cuvintele
citite.
typedef char cuvant[20];
int N, V[10];
cuvant T[10];
void Citeste ()
{
for (int i=1; i<=N; i++)
{
cout << "cuvantul " << i << " ";
cin >> T[i];
}
}
int Solutie (int k)
{
return (k==N);
}
void Tipar (int k)
{
cout << endl;
for (int j=1; j<=k; j++)
cout<< setw(4) << T[V[j]]<< " ";
}
int Valid (int k)
{
for (int i=1; i<=k-1; i++)
if (V[k]==V[i])
return 0;
return 1;

}
void Permutari_cuvinte ()
{
for (int k=1; k<=N; k++)
V[k]=0;
k=1;
while (k>0)
{
 while (V[k]<N)
{
V[k] ++;
if (Valid(k))
if (Solutie(k))
Tipar (k);
else
k++;
}
V[k--]=0;
}
}
void main (void)
{
cout << "N="; cin >> N;
Citeste();
Permutari_cuvinte ();
}