teme

//1.ConstruiĹŁi o funcĹŁie recursivÄ care calculeazÄ aranjamente de n luate cate k unde n si k citite de la tastatura.
#include<stdio.h>
int aranjamente(int n,int k);
int main(void)
{
int n,k;
printf("Se vor calcula Aranajamente de n luate cate k.\n");
printf("n=");scanf("%d",&n);
printf("k=");scanf("%d",&k);
if(!((1<=k)&&(k<=n)))
{
printf("Pentru datele introduse, nu se poate calcula factorialul.");
return 1;
}
printf("Aranjamente de %d luate cate %d=%d",n,k,aranjamente(n,k));
}
int aranjamente(int n,int k)
{
if(k==1) return n;
else return n*aranjamente(n-1,k-1);
}

//2. Calcului combinari de n luate cate k printr-o functie recursiva
#include<stdio.h>
float combinari(int n,int k);
int main(void)
{
int n,k;
printf("Se vor calcula Combinari de n luate cate k.\n");
printf("n=");scanf("%d",&n);
printf("k=");scanf("%d",&k);
if(!((1<=k)&&(k<=n)))
{
printf("Pentru datele introduse, nu se pot calcula combinarile.");
return 1;
}
printf("Aranjamente de %d luate cate %d=%d",n,k,(int)combinari(n,k));
}
float combinari(int n,int k)
{
if((n==0)||(k==0)||(n==k)) return 1;
else return (float)n/(n-k)*combinari(n-1,k);
}

//3.Calculul celui mai mare divizor comun a douÄ numere utilizând o funcĹŁie recursivÄ.

#include<stdio.h>
int cmmdc(int a,int b);
int main(void)
{
int a,b;
printf("Introduceti mai jos 2 numere. a si b.\n");
printf("a=");scanf("%d",&a);
printf("b=");scanf("%d",&b);
if(!((a>=0)||b>=0))
{
printf("Nu se poate calcula CMMDC pentru cele 2 numere.");
return 1;
}
printf("CMMDC al celor 2 numere este:%d.\n",cmmdc(a,b));
return 0;
}
int cmmdc(int a,int b)
{
if(a==b) return a;
else
{
if(a>b) return cmmdc(a-b, b);
else return cmmdc(a, b-a);
}
}

//4.Se considerÄ recursivitatea:
//an=(an-1+bn-1)/2 Ĺi
//bn=sqrt(an-1*bn-1+2), determinaĹŁi an Ĺi bn, pentru n, a0, b0 introduse de la tastaturÄ.

#include<stdio.h>
#include<math.h>
double an(int n);
double bn(int n);
int a0,b0;
int main(void)
{
int n;
printf("Introduceti numerele:\n");
printf("n=");scanf("%d",&n);
printf("A0=");scanf("%d",&a0);
printf("B0=");scanf("%d",&b0);
printf("A%d=%f iar B%d=%f",n,an(n),n,bn(n));
return 0;
}
double an(int n)
{
if(n==0)return (double)a0;
else return (an(n-1)+bn(n-1))/2;
}
double bn(int n)
{
if(n==0) return (double)b0;
else return sqrt(an(n-1)*bn(n-1)+2);
}

//6.DeterminaĹŁi printr-o funcĹŁie recursivÄ produsul scalar a doi vectori.

#include<stdio.h>
int produs(int *a,int *b,int n);
int main(void)
{
int *a,*b,n;
printf("Introduceti dimensiunea vectorilor:");scanf("%d",&n);
a=new int[n];
b=new int[n];
for(int i=0;i<n;i++)
{
printf("a[%d]=",i);scanf("%d",&a[i]);
}
for(int i=0;i<n;i++)
{
printf("b[%d]=",i);scanf("%d",&b[i]);
}
printf("Produsul scalar a celor 2 vectori este:%d",produs(a,b,n));
}
int produs(int *a,int *b,int n)
{
if(n==0) return 0;
else return (a[n-1]*b[n-1]+produs(a,b,n-1));
}

-------------------------------------------------------------------------------------------------

/*2.Fie un sistem de calcul care urmÄreĹte controlul unui proces de transmisie a datelor pe o linie principalÄ avĂ˘nd
un debit maxim de 40MB/s. Fluxul de date de pe aceastÄ linie este ĂŽmpÄrĹŁit de cÄtre 10 utilizatori, traficul pe
liniile oferite lor putĂ˘ndu-se efectua cu debite ĂŽntre 2 Ĺi 40 MB/s. ImpÄrĹŁirea debitelor pe cele 10 linii se face ĂŽn
mod dinamic de cÄtre sistemul de control considerĂ˘nd pentru fiecare linie i, i=0,...,9 , o pondere subunitarÄ pi,
asociatÄ la configurarea sistemului funcĹŁie de utilizator. IntroduceĹŁi iniĹŁial cele 10 ponderi pi astfel ĂŽncĂ˘t suma
lor sÄ fie egalÄ cu 1. DacÄ aceastÄ condiĹŁie este verificatÄ generaĹŁi toate soluĹŁiile posibile considerĂ˘nd cÄ pe
linia principalÄ vom avea cel puĹŁin un debit de 2MB/s, deci de 2...40MB/s determinĂ˘nd ĂŽn aceste cazuri
debitele posibile pe cele 10 linii de intrare ale utilizatorilor (ajustate la sute de KB/s). Se pune pe 0, dacÄ nu se
poate asigura minimul de 2MB. AfiĹaĹŁi aceste soluĹŁii. Implementarea poate fi recursivÄ sau nerecursivÄ. */

#include <stdio.h>
#include <iostream>
using namespace std;
#include <math.h>
#include <stdlib.h>
#include <conio.h>
#define NRCANALE 10

void afis_sol(void);

int x[NRCANALE],n=1,cont;
float pond[10];
int nmin=2, nmax=40;

void main(void)
{
int k,i;
float p=0;
cout << "Introdu cele 10 ponderi: \n\n";

for(i=0;i<NRCANALE;i++)
{
cout<<"Ponderea nr"<<i+1<<" : ";
cin>>pond[i];
p=p+pond[i];
}
if((int)p!= 1)
{
cout <<"\nPonderi gresite";exit(0);} ;
cout <<"\nIntrodu debitul pe linia principala(2-40 mbps).Debitul=0 te scoate din ciclu.";
while(n!=0)
{
cout << "Debitul: ";
cin >> n;
cout<<"\nSolutiile sunt:\n";
if (n <=nmax)
{
cont=0;
k=0;
x[k]=0;
do
{
while(x[k]<nmax)
{
x[k]=x[k]+1;
if(x[k] > nmin-1)
if(k==(NRCANALE-1))afis_sol();
else
{
k++; x[k]=0;
}
}
k--;

}
while(!(k<0));
}
else cout <<"\nDebit invalid!";
}

}

void afis_sol(void)
{
int l,i;
dublu fraction, integer;
double number=0;
for(i=0;i<10;i++)
number=(double)(number+pond[i]*x[i]);
l=(int)number;
if (l==n)
{
for (i=0;i<NRCANALE;i++)
cout<<x[i]*pond[i]<<" ";
cout<<endl;
cont++;
if(cont >20)
{
cont=0;cout <<"\nIntrodu un caracter pentru continuare\n";
getch();
}
}
}

/*3.Ăn cadrul unei companii de software se pune problema difuzÄrii unor pachete de date la mai multe filiale,
maxim 7, valoarea fiind introdusÄ de la intrarea standard. Filialele sunt dispuse ĂŽn mai multe puncte din lume,
costurile de transmisie fiind dependente de poziĹŁia lor geograficÄ. Pachetele trebuie sÄ ajungÄ la fiecare filialÄ
chiar dacÄ nu existÄ o legÄturÄ directÄ ĂŽntre toate filialele ci prin intermediul unei alte filiale caz ĂŽn care
pachetul va urma o rutÄ ocolitoare. Costurile necesare transmiterii datelor ĂŽn reĹŁea se introduc iniĹŁial la
generarea sistemului. SÄ se determine Ĺi afiĹeze ruta pe care trebuie transmise pachetele de date astfel ĂŽncĂ˘t
pornind de la filiala i, cititÄ de la intrarea standard pachetul sÄ fie transmis cu cost minim (eventual cu
confirmare adicÄ pachetul poate sÄ se ĂŽntoarcÄ ĂŽnapoi). Implementarea poate fi recursivÄ sau nerecursivÄ.*/

#include <stdio.h>
#include <conio.h>

#define MAX 7

int x[MAX],Y[MAX];
int COST[MAX][MAX];
void cit(int [][MAX],int &);
void afis(int [][MAX],int &);
int max_cost(int [][MAX],int &);
void afis_sol(long &);
int posibil(int);
int n;

void main(void)
{
int k;
long cost_M,C;
printf("Introdu dim matrice costuri(nr.orase <=7):\n");
scanf("%d",&n);
printf("Introdu si afis matricea costurilor C:\n");
cit(COST,n);
afis(COST,n);
cost_M=(n+1)*(long)max_cost(COST,n)+1;
k=0;
printf("Introdu orasul initial (0 ~ n-1):");
scanf("%d",&x[k]);
k=1;
x[k]=-1;
do
{
while(x[k] < n) //mai sunt valori posibile pentru componenta k
{
x[k]++; //trec la urmatoarea valoare
if(posibil(k)) if(k==(n-1))
{
C=0;
for(int i=0;i<n-1;i++)
C+=COST[x[i]][x[i+1]];
if(C<cost_M)
for(int i=0;i<n;i++)
{
Y[i]=x[i]; cost_M=C;
}

}
else
{
k++;x[k]=-1;
} //trec la urmatoarea componenta cu valori de la zero
}// sfarsit de while
k--; //nu mai sunt valori pentru componenta k. Revin la componenta k-1
}
while(!(k<1));//m-am intors mai mult decit se putea
afis_sol(cost_M); //solutie
}

int posibil(int k)
{
if(k==0)return 1;
if(COST[x[k-1]][x[k]]!=0)
{
for(int i=0;i<k;i++)
if(x[k]==x[i]) return 0;
return 1;
}
return 0;
}

void afis_sol(long &CF)
{
for(int i=0;i<n;i++)
printf("%d ",Y[i]);
printf("\nCostul este %ld",CF);
printf("\n");
}

void cit(int a[][MAX],int &n)
{
for(int i=0;i<n-1;i++)
{
a[i][i]=0;
for(int j=i+1;j<n;j++)
{
printf("Introdu Elem[%d][%d]= ",i,j);
scanf("%d",&a[i][j]);
a[j][i]=a[i][j];
}
}
}

void afis(int a[][MAX], int &n)
{
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
printf("%4d ",a[i][j]);
printf("\n");
}
}

int max_cost(int a[][MAX],int &n)
{
int max=a[0][0];
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
if(a[i][j] > max)
max=a[i][j];
return max;
}

*/4.Problema investirii optime de capital: pentru un investitor cu un capital C Ĺi n oferte la care trebuie avansate
fondurile fi Ĺi care aduc beneficiile bi, se cere selectarea acelor oferte care ĂŽi aduc beneficiul maxim. */

#include <stdio.h>
#include <iostream>
using namespace std;

void Back_SubSet(int);
int Posibil(int, int&);
int ben(int k);

struct oferta
{
int f,b;
};

struct oferta v[20];
int x[20],y[20],c,n,maxim=0,nr;

void main(void)
{ int i;
printf("Introduceti capitalul care urmeaza sa fie investit: ");
scanf("%d",&c);
printf("\nIntroduceti numarul de oferte diverse (<=20): ");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("\nOferta %d:",i+1);
scanf("%d",&v[i].f);
printf("Beneficiul %d:",i+1);
scanf("%d",&v[i].b);
}; //citirea ofertelor si a beneficiilor

Back_SubSet(0);

cout<<"\nBeneficiul maxim este: "<<maxim;
cout<<"\nEl se obtine pentru ofertele: \n";
for (i=0;i<nr;i++)
cout<<v[y[i]].f<<" ";
cout<<"\nCare adc beneficiile: \n";
for (i=0;i<nr;i++)
cout<<v[y[i]].b<<" ";

cout<<endl;

}

void Back_SubSet(int k)
{
int sum,j,t;
for(j=0;j<n;j++)
{
x[k]=j;
if(Posibil(k, sum))
{
if(sum==c)
{
if (ben(k)>maxim)
{
maxim=ben(k);
for(t=0;t<k+1;t++)
y[t]=x[t];
nr=k+1;
}
}
else
Back_SubSet(k+1);
}
}
}

int Posibil(int k, int &s)
{ int ok=1,i;
s=0;
if(k==0)
return 1;
for (i=0;i<k;i++)
if (x[i]==x[k])
ok=0;
if (x[0]==x[1])
ok =0;

if(ok==1)
{
for( int i=0;i<=k;i++)
s += v[x[i]].f;
if(s <= c) return 1;
}
return 0;
}

int ben(int k)
{
int i,benef=0;
for(int i=0;i<=k;i++)
benef=benef+v[x[i]].b;
return benef;
}

/*5.Sa se scrie o aplicatie C/C++ care sa genereze aleator 10 valori intregi, ce vor fi memorate intr-un vector. Sa
se verifice daca o alta valoare generata aleator apartine acestui vector, utilizand functia _lsearch(). */

#include <stdlib.h>
#include <stdio.h>
#include <search.h>
#include <ctime>
int *gen(int n);
int compare(const void *a, const void *b);
int main(void)
{
const int nr=10;
srand(time(NULL));
int *v,*rez;
v=gen(nr);
int key;
key=rand()%100+1;
rez=(int*) lsearch (&key, v, (size_t *)&nr, sizeof (int), compare);
if(rez==NULL)
{
printf("Valoarea %d nu a fost gasita in vectorul generat initial",key);
}
else printf("Valoarea %d a fost gasita",*rez);
printf("\n");
for(int i=0;i<nr;i++)
{
printf("v[%d]=%d\n",i,v[i]);
}
return 0;
}
int *gen(int n)
{
int *ptr;
ptr=new int[n];
for(int i=0;i<n;i++)
{
//srand(time(NULL)+i);
ptr[i]=rand()%100+1;
}
return ptr;
}
int compare(const void *a, const void *b)
{
return(*(int*)a-*(int*)b);
}

/*6.ScrieĹŁi o aplicaĹŁie C/C++ care sÄ gÄseascÄ imaginile cele mai apropiate întrebuințând pe rĂ˘nd o cheie de cÄutare din
antetul imaginii. Antetul este reprezentat printr-o structurÄ ce conĹŁine un nume de fiĹier (String), o cale
(String), o rezoluĹŁie de tărie (ĂŽntreg), o dimensiune ĂŽn octeĹŁi (ĂŽntreg). Pentru fiecare cheie folosiĹŁi o
metodÄ diferitÄ de cÄutare. Antetul imaginilor se aflÄ stocat ĂŽntr-un fiĹier sau se citeĹte ĂŽntr-un tablou de
structuri de la tastaturÄ. */

#include<stdio.h>
#include <string.h>
#include <search.h>
struct imagine
{
char nume[256];
char cale[256];
int rezolutie;
int dimensiune;
};
int n;
struct poză *read_data(char cale[]);
void afis_antet(struct fotografie *img);
int cmp(struct imagine *v1,struct imagine *v2);
int main(void)
{
char calea[]="header.txt";
/*
* Fisierul va contine pe întâia linie numarul de headere
* Pe urmatoarele linii va contine in ordine separate prin spatiu urmatoarele:
* nume cale rezolutie dimensiune
* indiferent ce modificare asupra structurii fisierului header poate duce la o rulare anormala a programului
* dupa fiecare header de imagine se da enter fara a se lasa spatiu liber intre dimensiune si enter
* toate elementele care depasesc numarul declarat in prima linie vor fi ignorate
*/
struct imagine *img=read_data(calea);
struct imagine *img_ptr;
char key_value[256];
printf("Introduceti numele pozei pe care doriti sa o cautati: ");scanf("%s",key_value);
img_ptr = (struct imagine *)lfind(&key_value, img, (size_t *)&n, sizeof(struct imagine),
(int (*) (const void *, const void *)) cmp);
if(img_ptr != NULL)
{
printf("Sa gasit urmatoarea imagine:\n");
afis_antet(img_ptr);
}
else printf("Imaginea cautata nu a fost gasita.\n");
return 0;
}
struct imagine *read_data(char cale[])
{
FILE *fp;
if((fp = fopen(cale, "r")) == NULL)
{
return NULL;
}
fscanf(fp, "%d\n", &n);
struct imagine *img=new struct imagine[n];
for(int i=0;i<n;i++)
{
fscanf(fp,"%s %s %d %d\n",img[i].nume,img[i].cale,&img[i].rezolutie,&img[i].dimensiune);
}
fclose(fp);
return img;
}
void afis_antet(struct imagine *img)
{
printf("Imaginea cu numele: \"%s\" care se gaseste la calea: \"%s\" avand rezolutia %d MP are mărimea %d",img->nume,img->cale,img->rezolutie,img->dimensiune);
}
int cmp(struct imagine *v1,struct imagine *v2)
{
return strcmp(v1->nume,v2->nume);
}

_________________
Detinator MiniZone
www.zappdivercity.blogspot.com