Firul

/* Exemplificare structura program C/C++ */
#include<stdio.h>
main()
{
int numar;
numar=1;
printf("\nProgramul exemplifica structura unui program.\n");
printf("%d este primul numar \n",numar);
}
________________________________________________________________________
/* Exemplificare structura program C */
#include<stdio.h>
main()
{
int numar;
numar=1;
printf("%d este primul numar \n",numar);
}
________________________________________________________________________
/* exemplul 1b, de program simplu, in C */
#include <stdio.h>
main()
/* un program simplu */
{
int
num;
/* se defineste variabila num */
num = 1;
/* se initializeaza variabila num cu valoarea 1 */
printf("\nEste un simplu "); /* utilizarea functiei printf() */
printf("exemplu de program.\n");
printf("Numarul favorit este %d, deoarece ");
printf("este primul.\n", num);
}
________________________________________________________________________
/* Programul afiseaza doar un simplu mesaj de salut */
#include <stdio.h>
main()
{
printf(" S A L U T !\n");
}
________________________________________________________________________
/* Exemplu de program simplu si structura sa, in C++ */
se afiseaza: Un exemplu de program simplu C++
1 este primul numar
*/
#include <iostream.h>
#include <conio.h>
void main(void)
{
int numar;
numar = 1;
cout << endl;
cout << "Un exemplu de program simplu C++; afisarea unui numar :"
<< endl;
cout << numar << " este primul numar" << endl;
getch();
}
________________________________________________________________________
/* Programul exemplifica utilizarea a unui sir de caractere*/
#include <stdio.h>
#define SIR "daca asta ti-e numele"
main ( )
{
char nume[50];
printf("\nProgramul exemplifica citirea/scrierea unui sir de caractere.\n");
printf("Cum te cheama ?\n");
scanf("%s", nume);
/* descriptorul %s citeste o data de tip sir de caractere*/
printf("Salut, %s , %s !\n", nume, SIR);
}
________________________________________________________________________
/* Programul exemplifica utilizarea unui sir de caractere, si a unor functii */
#include <stdio.h>
#include <string.h>
#define SIR "Am retinut numai numele."
main ( )
{
char nume[50];
printf("\nProgramul exemplifica citirea/scrierea unui sir de carcatere,\n"
"precum si spatiul de memorie ocupat de un sir de caractere.\n");
printf("Cum te cheama ?\n");
scanf("%s", nume);
printf("Salut, %s !. %s \n", nume, SIR);
printf("Numele are %d litere, si ocupa %d octeti.\n",
strlen(nume), sizeof nume);
printf("Propozitia \"SIR\": \"%s\"\n\tare %d litere, si ocupa %d octeti.\n",
SIR , strlen(SIR), sizeof (SIR));
}
________________________________________________________________________
/* Programul calculeaza varsta in luni, pentru o varsta data in ani si luni */
#include <stdio.h>
main ( )
{
int ani, luni, ani_l ; /* se definesc aceste variabile */
printf("\nProgramul va determina varsta in numarul total de luni.\n");

printf ( "Cati ani aveti ( ani , luni ) ? " ) ;
/* se solicita varsta in ani si luni */
scanf ("%d %d", & ani, &luni);
/* citeste varsta */
ani_l =ani*12+luni;
/* calculeaza varsta in luni */
printf ("Varsta in luni:%d\n",ani_l);
}
________________________________________________________________________
/* Exemplu de utilizare de secvente (caractere) de tip 'escape '*/
#include <stdio.h>
main( )
{
float salariu ;
printf("\nExemplificarea utilizarii secventelor de tip \"escape\"\n");
printf ("\nSpecificati salariul lunar : ");
printf (" $
\b\b\b\b\b\b\b\b") ;
scanf ("%f", &salariu) ;
printf ( "\ n\t\t $%.2f pe luna=$%.2f pe an", salariu, salariu*12.0);
printf ( "\r Oho ! \n") ;
printf ( "\t\t\"\\\\\\\\\\\\\\\\\\\\\\\t\\\\\\\\\"\n" );
}
________________________________________________________________________
/* Programul afiseaza codul numeric ASCII pentru un caracter */
#include <stdio.h>
#include <conio.h>
main ( )
{
char car ;
clrscr();
printf("Programul afiseaza codul unei taste in zecimal, hexa si octal.\n");
printf ("Apasati o tasta:" ) ;
scanf ("%c", &car) ; /* citeste codul tastei (caracterului) */
printf ("Codul tastei (caracterului) \"%c\" este %d (zecimal), "
"%x (hexa), %o (octal)\n", car, car , car, car);
}
________________________________________________________________________
/* Programul testeaza daca un numar este pozitiv, negativ sau zero*/
#include <stdio.h>
main()
{
int numar;
printf("\nSe determina daca numarul este pozitiv, negativ sau zero!\n");
printf("Introduceti un numar acum ---> ");
scanf("%d", &numar );
printf("Numarul este");
(numar < 0) ? printf("negativ\n") : ((numar > 0) ?
printf(" pozitiv\n") : printf(" zero\n"));

}
________________________________________________________________________
/* Programul exemplifica eroarea de rotunjire a unui rezultat real */
/* Testeaza efectuarea adunarii/scaderii cand diferenta dintre exponentii
celor doua numere este mai mare decat nuamarul de cifre utilizat
pentru reprezentarea interna (
7 cifre exacte pentru tipul
float,
15 cifre exacte pentru tipul double,
19 cifre exacte pentru tipul long double)
Rezultatul va fi egal cu numarul cel mai mare dintre cele doua */
# include <stdio.h>
main ( )
{
float a , b ;
printf("\nExemplifica rotunjirea rezultatului unei operatii de tip aditiv "
"cu numere reale.\n");
printf("La numarul real, de tip \"float\", 5.0e+7 se aduna, respectiv "
"scade 1 -> a, b: \n");
a = 5.0e+7 + 1.0 ;
b = 5.0e+7 - 1.0 ;
printf (" a = %f \n" , a);
printf (" b = %f \n" , b);
printf("Micsorand cu o unitate exponentul numarului scaderea/adunarea\n"
"unei unitati se va reflecta in reazultat:\n");
a = 5.0e+6 + 1.0 ;
b = 5.0e+6 - 1.0 ;
printf (" a = %f \n" , a);
printf (" b = %f \n" , b);
}
________________________________________________________________________
/* Programul afiseaza intervalul intreg [k, k+1] in care se afla o valoare reala */
#include <stdio.h>
main ()
{
float num;
int limita1, limita2;
printf("\nProgramul afiseaza intervalul intreg [ k , k+1 ] "
"in care se afla un numar real.\n");
printf ( "Introduceti un numar real : " );
scanf ( "%f" , &num ) ;
limita1 = num ;
limita2 = (limita1 >= 0 ) ? limita1+1 : limita1 - 1;
(limita1>=0)? printf ("Numarul este in intervalul [%d , %d]\n",limita1, limita2) :
printf ("Numarul este in intervalul [%d , %d]\n", limita2, limita1);}
/* Programul exemplifica operatori la nivel de bit; se utilizeaza

o functie pentru inversarea ultimilor biti dintr-un numar */
#include <stdio.h>
#include <conio.h>
int inver_ultim (int numar , int n )
{
int
masca = 0;
int
val_bit = 1;
while (n -- > 0 )
{
masca |= val_bit;
val_bit <<= 1;
}
return ( numar ^ masca );
}
void main ( void )
{
int
numar, nr_bit;
printf("\nProgramul exemplifica utilizarea operatorilor la nivel de bit.\n");
printf ("Numarul caruia i se vor inversea ultimii 'n' biti este:");
scanf ("%d", &numar );
printf("Numarul de biti de inversat (n) : ");
scanf("%d", &nr_bit);
printf("Numarul cu ultimii %d biti inversati este: %d\n", nr_bit,
inver_ultim (numar, nr_bit ) );
getch();
}
________________________________________________________________________
/* Converteste si afiseaza in binar o valoare intreaga*/
#include<stdio.h>
main()
{
char *int_la_str_bin(int,char[]);
char strbin[1+8*sizeof(int)];
int numar;
printf ("\nSe converteste o valoare intreaga din zecimal in binar.\n");
printf ("Conversia ia sfarsit cu o valoare nenumerica.\n");
printf ("Numar = ");
while (scanf ("%d", &numar) == 1)
printf ("Valoarea binara a numarului %d este %s\nNumar = ",
numar, int_la_str_bin(numar,strbin));
}
char *int_la_str_bin ( int n, char *ps )
{
int i;
static int dim = 8*sizeof ( int );
for ( i = dim-1 ; i >= 0 ; i--, n >>= 1 )

ps[i] = ( 1&n ) + '0';
ps[dim] = '\0';
return ( ps );
}
________________________________________________________________________
/* Exemplu utilizare functi in C++ */
void citeste_valori(int sir[], int numar_de_elemente)
/*
aceasta functie citeste un sir de
"numar_de_elemente" valori de tip intreg */
{
int i;
for (i = 0; i < numar_de_elemente; i++)
{
cout << "Introduceti valoarea " << i+1 << ": ";
cin >> sir[i];
}
}
void main(void)
{
int numar[3];
cout << "Programul citeste 3 valori de tip intreg pe care le afiseaza" <<
endl;
citeste_valori(numar, 3); /* se citeste un vector de 3 valori intregi */
cout << "Valorile sirului sunt:" << endl;
for (int i = 0; i < 3; i++)
/* dupa care se tiparesc */
cout << "val(" << i+1 << ")=" << numar[i] << endl;
}
________________________________________________________________________
/* Programul exemplifica utilizarea poiterilor la tipuri standard */
#include <stdio.h>
main()
{
int i1, i2 ;
int *p1, *p2;
printf("\nProgramul exemplifica utilizarea poiterilor la tipuri de date "
"standard.\n");
i1=5;
p1 = &i1;
/* pointer la i1, la valoarea intreaga 5 */
i2 = *p1/2 + 10;
/* 5/2 + 10 = 12, deoarece *p1 este de tip int*/
p2 = p1;
/* pointerului p2 i se atribuie aceeasi valoare cu p1 */
printf("i1 = %i, i2 = %i, *p1 = %i , *p2 = %i , dupa instructiunile: "
"p1=&i1, p2=p1.\n", i1, i2, *p1, *p2);
printf ("p1 = %p, p2 = %p, valori tiparite cu specificatorul p\n", p1, p2);
printf ("p1 = %x, p2 = %x, valori tiparite cu specificatorul x\n", p1, p2);
}
________________________________________________________________________
/* programul care realizeaza conversia unui numar binar -> la intreg */
#include <stdio.h>
main()
{
char car;
int
val = 0;
printf ("\nProgramul realizeaza conversia din binar la intreg zecimal.\n");
printf ("Introduceti un numar binar:");
scanf ("%c", &car);
while (car == '0' || car == '1' )
{
val = val*2 + (car & 1);
scanf ("%c", &car);
}
printf ("Valoarea zecimala (intreaga) este: %d\n", val);
}
________________________________________________________________________
/* Programul determina relatia de precedenta dintre doua numere
utilizand operatorul conditional ? : */
#include <stdio.h>
main()
{
float a,b;
printf("\nProgramul determina relatia de precedenta dintre 2 numere.\n");
printf("Introduceti doua numere:");
scanf("%f%f",&a,&b);
printf("%f %c %f\n",a,a<b ? '<': a>b ? '>' : '=',b);
}
________________________________________________________________________
/* Programul determina maximul dintre doua numere utilizand
operatorul conditional ? :
*/
#include <stdio.h>
main()
{
float a,b,max;
printf("\nProgramul determina maximul dintre doua numere.\n");
printf("Introduceti doua numere:");
scanf("%f%f",&a,&b);
max = a >= b ? a : b;
printf("maximul dintre cele doua numere este: %f",max);

}
________________________________________________________________________
/* Programul determina maximul dintre trei numere (if) */
#include <stdio.h>
main()
{
int a , b , c , x;
printf("\nProgramul detremina maximul dintre 3 numere.\n");
printf("Introduceti trei numere(a,b,c):\n");
printf("a=");
scanf("%d",&a);
printf("b=");
scanf("%d",&b);
printf("c=");
scanf("%d",&c);
if ( a > b )
x=a;
else
x=b;
if ( x < c )
x=c;
printf("Maximul dintre cele trei numere este: %d\n",x);
}
________________________________________________________________________
/* Programul afiseaza intervalul intreg in care se afla o valoare
reala, utilizand operatorul conditional ? :
*/
#include<stdio.h>
void main()
{
double numar;
int l_s,l_d;
printf("\nProgramul afiseaza intervalul intreg al unei valori.\n");
printf("Se utilizeaza \"operatorul conditional\".\n");
printf("Introduceti un numar real= ");
scanf("%lf",&numar);
l_s=numar;
l_d=l_s>=0 ? l_s+1 : l_s-1;
printf("%i %c %5.2f %c %i \n",l_s >= 0 ? l_s:l_d,'<',
numar,'<',l_s >= 0 ? l_d:l_s);
}
________________________________________________________________________
/* Programul determina daca un an este sau nu bisect */
main ( )
{
int an;
printf("\nProgramul determina daca un an este bisect sau nu.\n");

printf ("Introduceti anul de testat: ");
scanf ("%i", &an);
if ((an%4==0 && an%100!=0) || an%400==0)
printf ("Este an bisect. \n");
else
printf ("Nu este an bisect. \n");
}
________________________________________________________________________
/* Programul afiseaza codurile tastelor apasate, pana se apasa ESC */
# include <stdio.h>
# include <conio.h>
void main(void)
{
char ch;
clrscr();
printf("Programul afiseaza in zecimal, codurile ASCII pentru tastele "
"apasate.\n\n");
printf("Apasati ESC penru oprire\n");
do
{
ch=getch();
if(ch==0)
{
printf("Caracter special:");
ch=getch();
}
printf("%c=%d\n",ch,ch);
}
while(ch!=27);
}
________________________________________________________________________
/* Programul exemplifica utilizarea operatorului conditional ? :
pentru a determina modulul unui numar
*/
#include<stdio.h>
void main()
{
double numar,modul;
printf("\nSe calculeaza modulul unui numar utilizand operatorul "
"conditional.\n");
printf("numar= ");
scanf("%lf",&numar);
modul = numar >= 0 ? numar : -numar;
printf("modulul numarului este : %lf\n",modul);
}
/* Programul afiseaza o valoare numerica, cuprinsa in intervalul 0..999,

in litere si cifre. Programul se va executa ciclic pana se introduce
valoarea -1.
*/
#include <stdio.h>
main()
{
int numar, sute, zeci, unitati;
printf("\nProgramul afiseaza o valoare numerica,"
" cuprinsa in intervalul 0..999,\n\tin litere si cifre.\n"
"Programul se va executa ciclic pana se introduce valoarea -1.\n");
do
{
printf("Numar= ");
scanf("%d", &numar);
}
while ( numar < -1 || numar > 999 );
while ( numar >= 0 && numar <= 999 )
{
unitati = numar % 10;
zeci = numar / 10 % 10;
sute = numar / 100;
switch ( sute )
{
case 0 : break;
case 1 : printf("o"); break;
case 2 : printf("doua"); break;
case 3 : printf("trei"); break;
case 4 : printf("patru"); break;
case 5 : printf("cinci"); break;
case 6 : printf("sase"); break;
case 7 : printf("sapte"); break;
case 8 : printf("opt"); break;
case 9 : printf("noua"); break;
default: printf("eroare");
}
if ( sute == 1 )
printf("suta");
else if ( sute >= 2 )
printf ("sute");
if (zeci==1)
{
switch (unitati)
{
case 1: printf ("un"); break;
case 2: printf ("doi"); break;
case 3: printf ("trei"); break;

case 4: printf ("patru"); break;
case 5: printf ("cinci"); break;
case 6: printf ("sase"); break;
case 7: printf ("sapte"); break;
case 8: printf ("opt"); break;
case 9: printf ("noua"); break;
}
if (unitati == 0)
printf ("zece");
else
printf ("sprezece");
}
else
{
switch (zeci)
{
case 0: /* nimic */ break;
case 1: /* a fost tiparit anterior */ break;
case 2: printf ("doua");
break;
}
if (zeci >=2 && zeci <= 9)
{
printf ("zeci");
if ( unitati != 0 )
printf ("si");
}
switch (unitati)
{
case 0: if ( numar == 0 )
printf ("zero");
break;
case 1: printf ("unu"); break;

}
/* switch */
/* else zeci */
}
printf ("\n");
do
{
printf ("Introduceti numar (pozitiv si <999, sau -1 pt. oprire):");
scanf ("%d", &numar);
}
}
/* while */
}
/* sfarsit main */
________________________________________________________________________
/* Programul determina pentru doua puncte din plan, specificate prin
coordonatele lor (x1,y1) si (x2,y2), daca sunt:
- in acelasi cadran,
- pe prima sau a doua bisectoare,
- simetrice fata de origine, sau
- simetrice fata de abscisa;
*/
#include <STDIO.H>
main()
{
float x1,y1,x2,y2;
printf("\nProgramul determina pozitia in plan a doua puncte:\n"
"\tin acelasi cadran, pe prima sau pe a doua bisectoare,\n"
"\tsimetrice fata de origine sau de abscisa.\n");
printf("Introduceti coordonatele celor doua puncte:\n");
printf("Punctul A ( coord.:x1,y1 ):");
scanf("%f %f",&x1,&y1);
printf("Punctul B ( coord.:x2,y2 ):");
scanf("%f %f",&x2,&y2);
if ( x1*x2>0 && y1*y2>0 )
printf("Cele doua puncte sunt in acelasi cadran\n");
else
printf("Cele doua puncte nu sunt in acelasi cadran\n");
if ( x1 == y1 && x2 == y2 )
printf("Cele doua puncte sunt pe prima bisectoare\n");
else if ( x1 == -y1 && x2 == -y2 )
printf("Cele doua puncte sunt pe a doua bisectoare\n");
if ( x1 == -x2 && y1 == -y2 )
printf("Cele doua puncte sunt simetrice fata de origine\n");
if ( y1 == -y2 && x1 == x2 )
printf("Cele doua puncte sunt simetrice fata de abscisa\n");
}
/* Programul evalueaza expresii: valoare operator valoare (varianta 2)

ce utilizeaza pentru selectie operator instructiunea switch */
# include <stdio.h>
main ( )
{
double val1, val2;
char operator;
printf("\nEvaluarea unei expresii simple: Op.1 Operator Op.2\n"
"utilizand pentru selectarea operatiilor: +, -, * (x, X) sau /\n"
"instructiunea de selectie \"switch\".\n");
printf ("Introduceti expresia: ");
scanf ("%lf%c%lf%", &val1, &operator, & val2);
printf("Rezultatul: ");
switch (operator)
{
case '+':
printf ("%.2f\n", val1+val2);
break;
case '-':
printf ("%.2f\n", val1-val2);
break;
case '*':
/* se poate utiliza pe langa '*' */
case 'x':
/* si caracterul 'x' */
case 'X':
/* sau 'x' */
printf ("%.2f\n", val1*val2);
break;
case '/':
/* pentru impartire se poate utiliza '/' */
case ':':
/* sau ':' */
if (val2==0)
printf ("Impartire prin zero.\n");
else
printf ("%.2f\n", val1/val2);
break;
default:
printf ("Operator necunoscut.\n");
break;
}
/* sfarsit selectie */
}
________________________________________________________________________
/* Programul evalueaza expresii de forma: valoare operator valoare
utilizand pentru selectie operator instructiunea if */
#include <stdio.h>
void main ()
{
char operatie;
double val1, val2;
printf("\nEvaluarea unei expresii simple: Op.1 Operator Op.2\n"

"utilizand pentru selectarea operatiilor: +, -, * sau /\n"
"instructiunea de decizie if, respectiv else if.\n");
scanf ("%lf%c%lf", &val1, &operatie, &val2);
if (operatie =='+')
printf ("%.2lf\n", val1+val2);
else if (operatie =='-')
printf ("%.2lf\n", val1-val2);
else if (operatie =='x')
printf ("%.2lf\n", val1*val2);
else if (operatie =='/')
if (val2 ==0)
printf ("Impartire la zero.\n");
else
printf ("%.2lf\n", val1/val2);
else
printf ("Operator necunoscut \n");
}
________________________________________________________________________
/* Programul stabileste daca 3 numere date sunt in progresie aritmetica
sau in progresie geometrica
*/
# include <stdio.h>
main()
{
int
a, b, c;
printf("\nProgramul stabileste daca 3 numere sunt in "
"progresie aritmetica sau geometrica\n");
printf("Intorduceti cele 3 numere.\n");
printf("a="); scanf("%d",&a);
printf("b="); scanf("%d",&b);
printf("c="); scanf("%d",&c);
if ((a + c) / 2 == b)
printf("Progresie aritmetica: %d , %d , %d\n",a,b,c);
else if ((a + b) / 2 == c)
printf("Progresie aritmetica: %d , %d , %d\n",a,c,b);
else if ((b + c) / 2 == a)
printf("Progresie aritmetica: %d , %d , %d\n",c,a,b);
else if (a * c == b * b)
printf("Progresie geometrica: %d , %d , %d\n",a,b,c);
else if (a * b == c * c)
printf("Progresie geometrica: %d , %d , %d\n",a,c,b);
else if (b * c == a * a)
printf("Progresie geometrica: %d , %d , %d\n",b,c,a);

else
printf("Numerele a=%d,b=%d si c=%d nu sunt in progresie"
" aritmetica sau geometrica.\n",a,b,c);
}
________________________________________________________________________
/* Programul determina daca trei numere : a , b , c pot fi
laturile unui triunghi; si daca da, determina tipul triunghiului:
echilateral, isoscel, dreptunghic sau oarecare
*/
#include <stdio.h>
void main()
{
int a,b,c;
printf("\nProgramul determina daca 3 numere pot fi laturile unui triunghi"
", si daca da,\ndetermina tipul triunghiului: echilateral, isoscel,"
" dreptunghic sau oarecare.\n");
printf("Introduceti valorile pt cele trei laturi:\n");
if(a < b + c && b< a + c && c < a + b)
{ /* este triunghi , si se determina tipul triunghiului */
printf("Este triunghi");
if ( a==b && b==c ) /* triunghi echilateral */
printf(" echilateral\n");
else if ( a==b )
/* triunghi isoscel, si se determina baza */
printf(" isoscel, cu baza c\n");
else if ( a==c)
printf(" isoscel, cu baza b\n");
else if ( b==c)
printf(" isoscel, cu baza a\n");
else if ( a*a==b*b+c*c ) /*triunghi dreptunghic, si se afla ipotenuza*/
printf(" dreptunghic, cu ipotenuza a\n");
else if ( b*b==c*c+a*a )
printf(" dreptunghic, cu ipotenuza b\n");
else if ( c*c==a*a+b*b)
printf(" dreptunghic, cu ipotenuza c\n");
else
printf(" oarecare\n");
}
else
printf("Nu este triunghi");
}
/* Programul determina cel mai mare divizor comun pentru doua numere
a,b pozitive */
#include<stdio.h>
void main()
{
int a, b, rest;
printf ("\nIntroduceti doua numere intregi:\n");
scanf ("%d %d", &a, &b);
while (b)
{
rest = a % b;
a = b;
b = rest;
}
printf ("Cel mai mare divizor este: %d\n", a);
}
________________________________________________________________________
/* Se realizeaza conversia unui numar intreg intr-o baza oarecare - 2..36 */
#include <stdio.h>
#define LUNG_MAX 32
void main ()
{
char cifra[LUNG_MAX];
int numar, baza, indice;
printf ("\nNumar de convertit: ");
printf("In baza: ");
scanf ("%d", &baza);
indice = 0;
printf("Numarul %d in baza \"%d\" este: ", numar, baza);
if ( numar < 0 )
{
printf("-");
numar = - numar;
}
do
{
if ( numar % baza < 10 )
cifra[indice] = '0' + numar % baza;
else
cifra[indice] = 'A' + numar % baza - 10;
numar /= baza;
indice++;
} while(numar>0);
for ( indice-- ; indice >= 0 ; indice-- )
printf("%c", cifra[indice]);
printf("\n");
}
/* Program ce citeste un numar (si cu parte fractionara) intr-o baza

oarecare, cuprinsa intre 2 si 10 facandu-i apoi conversia in zecimal*/
#include <stdio.h>
void main()
{
const char blanc = ' ', punct = '.', plus = '+', minus = '-';
char semn, car;
double valoare;
int p_subunitar, baza;
printf ("\nBaza=");
scanf ("%d", &baza); while ( getchar() != '\n' );
printf ("\nIntroduceti numarul\n");
car = blanc;
while (car == blanc)
scanf("%c", &car);
semn = '+';
if (car == plus || car == minus)
{
semn = car;
scanf ("%c", &car);
};
valoare = 0;
while(car >= '0' && car < ('0'+baza))
{
valoare = valoare*baza + car - '0';
scanf("%c", &car);
}
if (car == punct)
{
p_subunitar = 0;
scanf("%c", &car);
while(car >= '0' && car < ('0'+baza))
{
valoare = valoare*baza + car - '0';
scanf("%c", &car);
p_subunitar++;
}
while (p_subunitar > 0)
{
valoare /= baza;
p_subunitar--;
}
}
if (semn == minus)
valoare = -valoare;
printf("Valoarea zecimala este:%f\n", valoare);}
/* Program pentru calculul datei zilei urmatoare pe baza datei curente

data este data prin: an, luna, zi;daca data zilei precedente nu este
ultima zi din luna se incrementeaza doar ziua si se obtine data curenta.;
daca este ultima zi din luna se actualizeaza ziua cu 1 si se incrementeaza
luna, daca nu este ultima din an; daca este ultima din an se initializeaza
si luna cu 1 si se incrementeaza anul. Ultima zi dintr-o luna depinde de
tipul (numarul) lunii, iar daca este luna a 2-a depinde si de tipul anului
( bisect sau nu ) */
#include <stdio.h>
#include <conio.h>
void main()
{
int zi, luna , an, ultima_zi;
/*citeste data zilei precedente si pune in ultima_zi data ultimei zile din luna:*/
printf("\tIntroduceti data curenta (zi-luna-an):\n");
scanf("%d-%d-%d", &zi, &luna, &an);
switch (luna)
{
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
ultima_zi=31; break;
case 4:
case 6:
case 9:
case 11:
ultima_zi=30; break;
case 2: if((an % 4 == 0 && an % 100 != 0) || (an % 400 == 0))
ultima_zi=29;
else
ultima_zi=28;
}
/*calculeaza data zilei urmatoare*/
if (zi == ultima_zi)
{
if(luna == 12)
{
luna=1;
an++;
}
else
luna++;
zi=1;
}
else
zi++;
/*scrie rezultatul obtinut*/
printf("Data curenta(zi/luna/an) este: %2d-%2d-%4d\n",zi,luna,an);
}
________________________________________________________________________
/* Program de rezolvare a ecuatiei de gradul II */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
void main()
{
double a, b, c, delta, real, imag;
printf ("Introduceti coeficientii ecuatiei de gradul al doilea:\ "
"\n\t\t ( ax^2+bx+c=0 )\na=");
scanf ("%lf", &a);
printf ("b=");
scanf ("%lf", &b);
printf ("c=");
scanf ("%lf", &c);
if (a)
{
delta = pow (b,2) - 4*a*c;
real = -b/2/a;
imag = sqrt(fabs(delta))/2/a;
if (delta >= 0)
printf ("X1=%5.2lf , X2=%5.2lf\n", real-imag, real+imag);
else
printf ("X1=%5.2lf-i*(%5.2lf), X2=%5.2lf+i*(%5.2lf)\n",
real, imag, real, imag);
}
else
if(b)
printf ("Ecuatia de grad I cu solutia X=%5.2lf\n", -c/b);
else
printf ("Ecuatie degenerata\n");
}
________________________________________________________________________
/* Program ce afiseaza (genereaza) numerele prime in intervalul [3,n];
intervalul este parcurs cu un pas egal cu 2, deoarece numerele prime
sunt numai printre numerele impare
*/
#include<stdio.h>
void main()
{
long int n, i, div, este_prim, contor_np=2;
printf ("\nAfiseaza numerle prime pana la n=");
scanf ("%ld", &n);

printf ("\n%9d,%9d", 1, 2);
for( i=3 ; i <= n ; i += 2 )
{
div=3;
do
{
este_prim = i % div;
div += 2;
}
while(este_prim && div*div <= i);
if (este_prim)
{
printf(",%9ld", i);
contor_np++;
}
}
printf(".\nNumarul total de numere prime este: %ld\n", contor_np);
}
________________________________________________________________________
/* Programul numara vocalele dintr-un text introdus de la tastatura */
#include <stdio.h>
void main()
{
int nr_a, nr_e, nr_i, nr_o, nr_u; /* contoare pentru numarul de vocale */
char car;
nr_a = nr_e = nr_i = nr_o = nr_u = 0;
printf("\nProgramul determina numarul de vocale dintr-un text.\n");
printf ("Introduceti un text care se termina cu #\n");
while ( ( car = getchar() ) != '#' )
{
switch (car)
{
case 'A':
case 'a':
nr_a++;
break;
case 'E':
case 'e':
nr_e++;
break;
case 'I':
case 'i': nr_i++;
break;
case 'O':
case 'o':
nr_o++;
break;
case 'U':
case 'u':
nr_u++;
break;
}
}
printf ("Numarul de vocale\n A, E, I, O
, U, din text "
"este:\n%5d %5d %5d %5d %5d\n",nr_a, nr_e, nr_i, nr_o, nr_u);
}
________________________________________________________________________
/* programul determina daca un numar este par sau nu */
#include <stdio.h>
main()
{
int numar, rest;
printf("\nProgramul determina daca un numar intreg este par sau nu.\n");
printf ("Introduceti numarul:");
rest = numar % 2;
if (rest )
printf ("Este numar impar\n");
else
printf ("Este numar par\n");
}
________________________________________________________________________
/* Programul calculeaza puterea intreaga a unui numar real, x^n,
utilizand un numar minim de inmultiri de numere reale */
#include <stdio.h>
#include <math.h>
void main()
{
int n,ni, p=1, nr_inmult=0; /* p=cea mai mica putere a lui 2 mai mare ca n*/
int
semn; /* memoreaza semnul lui n */
double x, y=1; /* y = x^n, nr_inmult = numarul de inmultiri efectuate */
printf ("\nSe calculeaza x^n, utilizand un numar minim de inmultiri.\n");
printf ("x (real) = "); scanf ("%lf", &x);
printf ("n (intreg) = "); scanf ("%d", &n);
ni = n;
semn = n < 0;
n = abs ( n );
while ( p <= n )
p = p * 2;
do
{
p = p / 2;
y = y*y;
nr_inmult++;
if ( n >= p )
{
n = n - p;
y=y*x;
nr_inmult++;
}
} while ( p > 1 );
if ( semn )
y=1/y;
printf("x^n = %e, utilizand %d inmultiri .\n", y, nr_inmult);
printf("Rezultatul obtinut cu functia \"pow(x,n)\" = %f (dupa "
"%d inmultiri)\n", pow(x,ni), ni);
}
________________________________________________________________________
/* Calculeaza radacina patrata a unui numar real, folosind sirul
definit prin relatia de recurenta Heron: Xn=(Xn-1+a/Xn-1)/2, Xo=a/2 */
#include <stdio.h>
#include <math.h>
#define MAX_TERMENI 100
void main()
{
double radacina, a, precizia, modul;
int n=0;
printf ("\nCalculeaza radacina patrata a unui numar real (ca limita a "
"sirului Heron).\n");
printf ("Introduceti numarul: ");
scanf ("%lf", &a);
if (a < 0)
printf ("Nu se poate calcula radical dintr-un numar negativ\n");
else
if (a == 0)
printf ("Radacina este 0\n");
else
{
radacina = a/2;/* initializare */
precizia = a/1E+15; /*valoarea preciziei*/
do
{
radacina = (radacina + a/radacina)/2;
modul = a - radacina*radacina;
if (modul < 0)
modul = -modul;
n++;
}
while ( modul > precizia && n < MAX_TERMENI);
printf ("Radacina patrata din %g este %f obtinuta "
"dupa %d iteratii\n", a, radacina, n);
printf ("Valoarea returnata de functia standard sqrt "

"este : %f\n", sqrt(a));
printf ("Diferenta fata de functia standard este %g\n",
sqrt(a)-radacina);
}
}
________________________________________________________________________
/* Calculeaza suma factorialelor pentru un n dat:
suma = -1! +2! -3! +4! -5! +6! -7! +8! - . . . . . .
folosind direct formula "suma de (-1)^k * k */
#include<stdio.h>
void main()
{
long int sum = 0, i, k, n, fact;
printf("\nProgramul calculeaza suma: -1! +2! -3! +4! -5! +. . . +(-)n. .\n");
printf ("n="); scanf ("%li", &n);
for ( k = 1 ; k <= n ; ++k )
{
fact = 1;
for ( i = 1 ; i <= k ; i++ )
fact = fact * i;
if ( k % 2 )
fact = - fact;
sum += fact;
}
printf("Pentru n=%li, suma factorialelor este: %li\n", n, sum);
}
________________________________________________________________________
/* Calculeaza suma factorialelor pentru un n dat:
suma = -1! +2! -3! +4! -5! +6! -7! +8! - . . . . . .
tinand cont ca, k! = (k-1)! * k , unde (k-1)! a fost calculat la pasul
anterior si schimband semnul produsului (factorialului) la fiecare pas,
in loc de a calcula, la fiecare pas, factorialul k! pornind de la inceput
(k=1)
*/
#include<stdio.h>
void main()
{
long int suma = 0, k, n, fact;
printf("\nProgramul calculeaza suma: -1! +2! -3! +4! -5! +. . . +(-)n. .\n");
printf ("n=");
scanf ("%ld", &n);
fact = 1;
for ( k = 1 ; k <= n ; k++ )
{
fact = - fact*k;
suma += fact;
}
printf("Suma factorialelor este: %li\n", suma);
}
________________________________________________________________________
/* Calculeaza pana la o limita specificata suma seriei:
1 + 1/2 + 1/3 + 1/4 + . . . 1/n > limita
programul va afisa fiecare suma si in final numarul de termeni insumati*/
#include <stdio.h>
void main()
{
long int n = 0;
long double suma = 0, limita;
printf("\nProgramul calculeaza suma unei serii pana la o limita,\n\tdar nu "
"mai mult de %d termeni.\nSeria este: 1 + 1/2 + 1/3 + 1/4 + . . . "
"1/n > limita\n", MAX_TERMENI);
printf ("Specificati limita: ");
scanf ("%Lf", &limita);
do
{
n ++;
if (n % 100 == 0)
printf ("Pasul=%li\tSuma=%Lf\n", n, suma);
suma += (long double) 1/n;
}
while (suma < limita && n < MAX_TERMENI);
printf("Suma finala este : %Lf\n", suma );
printf("Numarul de termeni insumati este: %li\n", n);
}
________________________________________________________________________
/* Programul citeste un caracter si in functie de acesta se termina sau se
executa ciclic; daca caracterul este 'd', 'D', 'n' sau'N' se executa
ciclic pana se introduce un caracter diferit de acestea;
le terminarea programului se emite un sunet
*/
void main(void)
{
int gata = 1;
char litera;
while (gata)
{
cout << endl;
cout << "Programul citeste caractere, cat timp acestea sunt: d, D, n sau N."
<< endl;
cout << "Pentru orice alt caracter tastat programul se termina si "
"afiseaza caracterul." << endl;
cout << "Tasteaza D(d) sau N(n) si apoi Enter pentru a continua: ";
cin >> litera;
if ((litera != 'D') && (litera != 'd') && (litera != 'N') && (litera != 'n'))
{
gata = 0;
cout << '\a'; //Sunet pentru altfel de caracter
}
}
cout << "Carcaterul tastat a fost " << litera << endl;
}
________________________________________________________________________
/* Tipareste un numar intreg (de maxim 9-10 cifre) in ordie inversa*/
#include<stdio.h>
void main()
{
long int numar, rest;
printf("\nProgramul afiseaza un numar intreg (maxim 9-10 cifre) in ordie "
"inversa.\n");
printf ("Introduceti un numar intreg:");
scanf ("%li",&numar);
printf ("Numarul scris in ordine inversa:");
do
{
rest=numar%10;
printf("%d", rest);
numar/=10;
}
while (numar);
printf ("\n");
}
________________________________________________________________________
/* Determinarea valorii unei functii, definite pe intervale intr-un punct
dat, x */
#include <stdio.h>
#include <math.h>
main()
{
float x, f;
printf ("\nSe calculeaza valoarea functiei f(x), definita astfel:\n");
printf ("
| x^2 - 2*x + 5 , pt. x<= 1\n");
printf ("f(x) = | x*sin(x) - 2 , pt. 1<x<=5\n");
printf ("
| ln(2*x^2 + 1) - 5
, pt. x>5\n");
printf ("Introduceti valoarea lui x:");
scanf ("%f", &x);
if ( x <= 1 )
f = pow(x,2) - 2*x +5;
else if ( x <= 5 )
f = x*sin(x) -2;
else
f = log(2*pow(x,2) + 1 ) - 5;
printf ("f(%.2f)=%.3f\n", x, f);
}
________________________________________________________________________
/* Media valorilor pozitive dintr-un sir de valori ce se termina cu 0 */
#include<stdio.h>
void main()
{
double val, suma = 0;
int nv =1, nvp = 0;
printf ("\nProgramul determina media numerelor pozitive\n");
printf ("Introduceti numere (0 = sfarsit)\nNumar (1)=");
scanf ("%lf", &val);
while (val != 0)
{
nv++;
if (val > 0)
{
nvp++;
suma += val;
}
printf ("Numar (%d)= ", nv);
} /* while */
if(nvp>0)
printf ("Media valorilor pozitive este %5.2f\n", suma/nvp);
else
printf ("Nu s-au introdus valori pozitive\n");
}
________________________________________________________________________
/* Programul determina numarul de caractere citite de la tastatura */
#include <stdio.h>
main()
{
int nc=0;
printf("\nProgramul determina numarul de caractere dintr-un text.\n"
"Textul se va termina cu sfarsit de fisier: CTRL-Z, ENTER.\n"
"Introduceti textul:\n");
for ( ; getchar() != EOF ; ++nc );
printf("/n Numarul de caractere din textul introdus este : %d\n",nc);
}
/* Programul determina numarul de caractere, blancuri, virgule si puncte

dintr-un text citit de la tastatura */
#include <stdio.h>
void main ()
{
const char blanc = ' ' , virgula = ',' , punct = '.' ;
int nrc = 0, nrb = 0, nrv = 0, nrp = 0;
char car;
printf("\nProgramul determina numarul de caractere, blancuri, virgule si "
"puncte\n\tdintr-un text citit de la tastatura.\n");
printf("Textul se va termina cu CTRL-Z, ENTER.\n");
printf ("Introduceti textul: \n");
while ((car=getchar( ))!=EOF)
{
if (car!= '\n')
{
nrc++;
if (car == blanc)
nrb++;
else if (car == virgula)
nrv++;
else if (car == punct)
nrp++;
}
}
printf ("%d caractere \n", nrc);
printf ("%d blancuri \n", nrb);
printf ("%d virgule \n", nrv);
printf ("%d puncte \n", nrp);
}
________________________________________________________________________
/* Converteste un numar intreg intr-o alta baza din domeniul {2,...,16} */
#include<stdio.h>
void main()
{
char cifre_baza[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C',
'D','E','F'};
int numar_convertit[32],baza,indice,ind_cifre;
long int numar;
printf("\nProgramul converteste un numar intreg in alta baza (2-16).\n");
printf("Introduceti un numar intreg: ");
scanf("%li",&numar);
printf("Baza in care se converteste: ");
scanf("%i",&baza);
indice=0;
do
{
numar_convertit[indice]=numar%baza;
numar/=baza;
indice++;
}
while(numar);
printf("Numarul convertit este: ");
for(indice--;indice>=0;indice--)
{
ind_cifre=numar_convertit[indice];
printf("%c",cifre_baza[ind_cifre]);
}
printf("\n");
}
________________________________________________________________________
/* programul afiseaza o valoare numerica, cuprinsa in intervalul 0..999,
in litere si cifre.
Programul se va executa ciclic pana se introduce valoarea -1. */
#include <stdio.h>
main()
{
int numar, sute, zeci, unitati;
printf("\nProgramul afiseaza o valoare numerica,"
" cuprinsa in intervalul 0..999,\nin litere si cifre.\n"
"Programul se va executa ciclic pana se introduce valoarea -1.\n");
do
{
printf("numar= ");
}
while ( numar >= 0 && numar <= 999 )
{
printf("%d=",numar);
unitati = numar % 10;
zeci = numar / 10 % 10;
sute = numar / 100;
switch ( sute )
{
case 0 : break;
case 1 : printf("o"); break;
case 2 : printf("doua"); break;
case 3 : printf("trei"); break;
case 4 : printf("patru"); break;
case 5 : printf("cinci"); break;
case 6 : printf("sase"); break;

case 7 : printf("sapte"); break;
case 8 : printf("opt"); break;
case 9 : printf("noua"); break;
default: printf("eroare");
}
if ( sute == 1 )
printf("suta");
else if ( sute >= 2 )
printf ("sute");
if (zeci==1)
{
switch (unitati)
{
case 1: printf ("un"); break;
}
if (unitati == 0)
printf ("zece");
else
printf ("sprezece");
}
else
{
switch (zeci)
{
case 0: /* nimic */ break;
case 1: /* a fost tiparit anterior */ break;
case 2: printf ("doua");
break;
}
if (zeci >=2 && zeci <= 9)
{
printf ("zeci");
if ( unitati != 0 )
printf ("si");
}
switch (unitati)
{
case 0: if ( numar == 0 )
printf ("zero");
break;
case 1: printf ("unu"); break;
}
/* switch */
}
/* else zeci */
printf ("=\n");
do
{
printf ("Introduceti numar (>0 si <999, sau -1 = stop):");
}
}
/* while */
}
/* sfarsit main */
________________________________________________________________________
/* programul determina valoarea constantei PI, utilizand relatia:
PI = 4 ( 1 - 1/3 +1/5 -1/7 + 1/9 - 1/11 + . . . .
cu o anumita 'precizie'
*/
#include <stdio.h>
void main()
{
double precizia,termen, pi=4;
long int iteratia=1,i=1,n=1;
printf("\nProgramul calculeaza constanta \"pi\" cu o anumita precizie, "
"utilizand seria:\n"
"PI = 4 ( 1 - 1/3 +1/5 -1/7 + 1/9 - 1/11 + . . . .\n"
"(se insumeaza cel mult %d termeni)\n", MAX_TERMENI);
printf("Introduceti precizia: ");
scanf("%lf",&precizia);
do
{
n += 2 ;iteratia++;
i=-i;
termen=((double)4*i)/n;
pi+=termen;
if ( iteratia % 5000 == 0 )
printf("Iteratia %li , PI = %lf\n", iteratia, pi);
}
while( termen*i > precizia && n < MAX_TERMENI);
printf ("Rezultatul este: %.15lg , dupa %li iteratii\n",pi, iteratia);
}
________________________________________________________________________
/* atoi : converteste un sir de caractere s la un intreg, versiunea 2 */
#include <stdio.h>
#include <ctype.h>
int atoi ( char s[ ] )
{
int i , n , semn ;
for ( i = 0 ; isspace ( s[ i ] ) ; i++ ); /* se ignora spatiile albe */
semn = ( s[ i ] == '-' ) ? -1 : 1;
if (s[ i ] == '+' || s[ i ] == '-' )
i++;
for ( n = 0 ; isdigit ( s[ i ] ) ; i++ )
n = 10 * n + ( s [ i ] - '0' );
return semn * n ;
}
void main()
{
char sir[20];
int valoare;
printf("\nSe converteste o valoare numerica, citita ca sir de caractere"
" la un numar\n");
printf("Introduceti valoarea: ");
scanf("%s", sir);
valoare = atoi ( sir);
printf("Valoarea numerica este: %i\n", valoare);
}
________________________________________________________________________
/* Converteste un numar intreg intr-o alta baza din domeniul {2,...,16} */
#include<stdio.h>
void main()
{
char cifre_baza[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
int numar_convertit[32],baza,indice,ind_cifre;
long int numar;
printf("\nProgramul converteste un numar intreg din zecimal intr-o alta "

"baza (2-16).\n");
printf("Introduceti un numar intreg: ");
scanf("%li",&numar);
printf("Baza in care se converteste: ");
scanf("%i",&baza);
indice=0;
do
{
numar_convertit[indice]=numar%baza;
numar/=baza;
indice++;
}
while(numar);
printf("Numarul convertit este: ");
for(indice--;indice>=0;indice--)
{
ind_cifre=numar_convertit[indice];
printf("%c",cifre_baza[ind_cifre]);
}
printf("\n");
}
________________________________________________________________________
/* Se evalueaza expresii: valoare operator valoare , varianta 2 (switch)*/
# include <stdio.h>
main ( )
{
double val1, val2;
char oper;
printf("\nProgramul evalueaza expresii de tipul: \"val operator val\",\n"
"unde operatorul poate fi: +, -, * (x, X) sau /\n");
scanf ("%lf%c%lf%", &val1, &oper, & val2);
switch (oper)
{
case '+':
printf ("%.2f\n", val1+val2);
break;
case '-':
printf ("%.2f\n", val1-val2);
break;
case '*':
/* se poate utiliza pe langa '*' */
case 'x':
/* si caracterul 'x' */
case 'X':
/* sau 'x' */
printf ("%.2f\n", val1*val2);
break;
case '/':
case ':':
/* pentru impartire se poate utiliza '/' */

/* sau ':' */
if (val2==0)
printf ("Impartire prin zero.\n");
else
printf ("%.2f\n", val1/val2);
break;
default:
printf ("Operator necunoscut.\n");
break;
}
/* sfarsit selectie */
}
________________________________________________________________________
/* programul evalueaza expresii de forma: valoare operator valoare
utilizand pentru selectia operatorului instructiunea if / else if*/
#include <stdio.h>
main ( )
{
double val1, val2;
char oper;
printf("\nProgramul evalueaza expresii de tipul: \"val operator val\",\n"
"unde operatorul poate fi: +, -, * (x, X) sau /\n");
printf ("Introduceti expresia: \n");
scanf ("%lf%c%lf", &val1, &oper, &val2);
if (oper =='+')
printf ("%.2lf\n", val1+val2);
else if (oper =='-')
printf ("%.2lf\n", val1-val2);
else if (oper =='x'|| oper =='*')
printf ("%.2lf\n", val1*val2);
else if (oper =='/')
if (val2 ==0)
printf ("Impartire la zero.\n");
else
printf ("%.2lf\n", val1/val2);
else
printf ("Operator necunoscut \n");
}
________________________________________________________________________
/* calculul lui e^x, utilizand dezvoltarea in serie Taylor:
1 + x/1! + x^2/2! + x^3/3! + . . . + x^n/n! , cu o anumita precizie */
#include <stdio.h>
#include <math.h>
void main ()
{
double ex, x, precizie, termen;

int
n=0;
printf("\nProgramul calculeaza exp(x), cu o anumita prezizie."
"\nIntroduceti x=");
scanf("%lf",&x);
printf("Cu precizia:");
scanf("%lf",&precizie);
ex = 1; termen = 1;
do
{
n++;
termen = termen * x / n;
ex = ex + termen;
}
while ( termen > precizie );
printf("seria Teylor exp(%f)=%f, dupa %d iteratii.\n",x,ex,n);
printf("Functia C exp(%f)=%f\n",x,exp(x));
}
________________________________________________________________________
/* determina maximul dintre trei numere */
#include <stdio.h>
main()
{
int a , b , c , x;
printf("\nProgramul determina maximul dintre 3 numere.\n");
printf("Introduceti trei numere(a,b,c):\n");
printf("a=");
scanf("%d",&a);
printf("b=");
scanf("%d",&b);
printf("c=");
scanf("%d",&c);
if ( a > b )
x=a;
else
x=b;
if ( x < c )
x=c;
printf("Maximul dintre cele trei numere este: %d\n",x);
}
________________________________________________________________________
/* Programul altereaza o linie de text, tiparind in locul caracterului
curent caracterul alfabetic urmator, dar pastreaza spatiile */
#include <stdio.h>
#define SPATIU ' '
main ( )
{
char car;
printf("\nProgramul inlocuieste caracterele dintr-o linie de text cu "
"caracterul alfabetic\nurmator, dar pastreaza spatiile. "
"Introduceti linia de text:\n");
while ((car = getchar())!='\n')
{
if (car == SPATIU)
putchar (car);
else
putchar (car+1);
}
printf("\n");
}
________________________________________________________________________
/* Programul determina cate numere sunt pozitive, negative sau egale cu 0 */
#include <stdio.h>
#include <conio.h>
void main(void)
{
int p=0,n=0,z=0,nr,max,i;
clrscr();
printf("Programul afiseaza cate numere sunt pozitive, negative si "
"cate sunt zero.\n");
printf("Introduceti numarul de elemente:");
scanf("%d",&max);
for(i=0;i<max;i++)
{
printf("Numarul(%d)= ",i+1);
scanf("%d",&nr);
if(nr<0)
n++;
else
if(nr==0)
z++;
else
p++;
}
printf("\nNumere egale cu zero: %d;\n",z);
printf("Numere
negative: %d;\n",n);
printf("Numere
pozitive: %d.\n",p);
}
________________________________________________________________________
/* Programul determina daca doua numere sunt prime intre
ele, determinand cel mai mare divizor comun; daca
acesta este 1 -> numerele sunt prime intre ele,
daca este diferite de 1 -> nu sunt numere prime intre ele */

#include <stdio.h>
void main()
{
int a , b , rest;
printf("\nProgramul determina daca doua numere sunt prime intre ele.\n");
printf("Introduceti cele doua numere a, b =");
scanf("%d%d",&a,&b);
if ( a*b != 0 )
{
while ( b != 0 )
{
rest = a % b;
a = b;
b = rest ;
}
if (a == 1)
printf("Numerele sunt prime intre ele.\n");
else
printf("Nu sunt numere prime intre ele; au cmmdc = %d. \n",a);
}
else
printf("Unul dintre cele doua numere este 0.\n");
}
________________________________________________________________________
/* programul determina daca un numar dat este prim sau nu
cautand divizori, pentru numarul dat, in intervalul
[2,sqrt(numar)]
*/
#include <math.h>
#include <stdio.h>
#include <conio.h>
main()
{
long int a,n,x;
clrscr();
printf("Programul stabileste daca un numar este prim.\n");
printf("Introduceti numarul:");
scanf("%ld",&n);
a=2;
x=(int)(sqrt(n));
while(((n%a)!=0)&&(a<=x))
{
if(a==2)
a=3;
else
a=a+2;
}
if((n%a)==0)
printf("Numarul %ld nu este prim.",n);
else
printf("Numarul %ld este prim.",n);
printf("\nApasa o tasta pentru a termina programul.\n");
getch();
}
________________________________________________________________________
/* Programul numara cifre, spatii albe si alte caractere */
#include <stdio.h>
void main ()
{
int car, i, nr_sp_alb, nr_alt_car, nr_cifre[ 10 ];
printf("\nProgramul numara cifre, spatii albe si alte caractere dintr-un\n"
"text introdus de la tastatura, ce se termina cu CTRL-Z,ENTER.\n");
nr_sp_alb = nr_alt_car = 0 ;
for ( i = 0 ; i < 10 ; i++ )
nr_cifre[ i ] = 0 ;
while ( ( car = getchar ( ) ) != EOF ) {
switch ( car ) {
case '0' : case '1': case '2' : case '3' : case '4' :
case '5' : case '6': case '7' : case '8' : case '9' :
nr_cifre [ car - '0' ]++ ;
break ;
case ' ' :
case '\n':
case '\t' :
nr_sp_alb ++ ;
break;
default :
nr_alt_car++ ;
break ;
}
}
printf ("Cifre = ") ;
for ( i = 0 ; i <10 ; i ++ )
if (nr_cifre[i])
printf ("%d-%d, ", i, nr_cifre [ i ]);
printf ("\nSpatii albe = %d ,\nAlte caractere = %d\n",
nr_sp_alb , nr_alt_car ) ;
return 0 ;
}
/* Secventa care afiseaza caracterele cu ecou si

numara caracterele diferite de blank
( este folosita instructiunea -continue- )
*/
#include<stdio.h>
void main()
{
int contor;
char car;
contor=0;
printf("\nProgramul afiseaza cu ecou numai caracterele diferite de blanc\n"
"si le numara.\nTextul se termina cu CTRL-Z, Enter.\n");
while((car=getchar())!=EOF)
{
if(car==' ')
continue;
putchar(car);
contor++;
}
printf("Numar de caractere (diferite de spatiu): %d\n",contor);
}
________________________________________________________________________
/* programul calculeaza puterea unui numar real, la o putere reala
x^n, folosind metoda logaritmica:
y = x^n;
-> ln(y) = n*ln(x);
-> e^ln(y) = e^(n*ln(x));
-> y = e^(n*ln(x));
*/
#include <stdio.h>
#include <math.h>
main()
{
double x,y,n;
printf("\nProgram de ridicare la putere (metoda logaritmica).\n");
printf("Introduceti numarul=");
scanf("%lf",&x);
printf("Introduceti puterea=");
scanf("%lf",&n);
y=exp(n*log(x));
printf("(%.2lf)^(%.2lf) = %.2lf\n",x,n,y);
}
________________________________________________________________________
/* Programul determina o radacina a unei functii, separata intr-un
interval (a,b), utilizand metoda injumatatirii intervalului
*/
# include <stdio.h>
/*
definirea unei functii de o variabila */
/*
f(x) = x^2 - 4x -5, care are solutiile x1=-1, x2=5 */
double f ( double x )
{
double valf;
valf = x*x -4*x -5;
return ( valf );
}
void main()
{
double a,b,mijloc,precizia,modul;
printf("\nProgramul localizeaza radacina unei functii, intr-un interval dat\n"
"prin metoda \"injumatatirii intervalului\".\n"
"functia este f(x) = x^2 - 4x -5, sol. x1=-1, x2=5\n");
printf("Introduceti intervalul a,b: ");
scanf("%lf",&a);
scanf("%lf",&b);
printf("introduceti precizia de localizare a radacinii:");
scanf("%lf",&precizia);
do
{
mijloc=(a+b)/2;
if(f(a)*f(mijloc)<0)
b=mijloc;
else if (f(mijloc)*f(b)<0)
a=mijloc;
else goto gata;
modul =a-b;
if ( modul < 0 )
modul = -modul;
}
while(modul>precizia);
gata : printf("Solutia : %lf \n",( a+ b)/2 );
}
________________________________________________________________________
/* Programul rezolva un sistem de doua ecuatii cu doua necunoscute:
a11*x + a12*y = c1
a21*x + a22*y = c2
*/
#include <stdio.h>
float a11,a12,c1,a21,a22,c2,det,detx,dety;
main()
{
printf("\nProgramul rezolva un sistem de doua ecuatii cu doua necunoscute:\n"
"
a11*x + a12*y = c1\n"
"
a21*x + a22*y = c2\n");
printf("Introduceti valorile coeficientilor (a11, a12, c1, a21, a22, c2):\n");
scanf("%f%f%f%f%f%f",&a11,&a12,&c1,&a21,&a22,&c2);
det = a11*a22 - a12*a21;
detx=c1*a22-c2*a12;
dety=c2*a11-c1*a21;
if (det!=0)
printf("x=%3.2f y=%3.2f\n",detx/det,dety/det);
else if ( detx == 0 )
printf("sistem compatibil nedeterminat\n");
else
printf("sistem incompatibil\n");
}
________________________________________________________________________
/* Programul calculeaza suma cifrelor unui numar intreg */
#include <stdio.h>
void main ( )
{
long int numar;
int suma, cifra;
printf("\nProgramul calculeaza suma cifrelor unui numar intreg.\n");
printf ("Introduceti un numar intreg:\n");
scanf ("%li", &numar);
suma=0;
do
{
cifra = numar % 10;
suma += cifra;
numar /= 10;
}
while (numar>0);
printf ("Suma cifrelor numarului introdus este:%i\n",suma);
}
________________________________________________________________________
/* Programul calculeza suma 1+1/a + 1/a^2 +1/a^3 + . . 1/a^n pentru a>1,
cu o precizie specificata; sa se afiseze si puterea lui a la care
s-a ajuns (n) */
#include <stdio.h>
#define MAX_TERM 1000
void main ( )
{
double precizie, a, suma, termen;
int n;
printf("\nProgramul calculeza suma 1+1/a + 1/a^2 +1/a^3 + . . 1/a^n\n"
"pentru a>1, cu o precizie specificata;\nafiseaza si puterea lui a"
"la care s-a ajuns (n), dar nu peste %\n", MAX_TERM);
printf ("Introduceti a (a>1):");
scanf ("%lg", &a);

printf ("Precizia de calcul:");
scanf ("%lf", &precizie);
if (a <=1)
printf ("Serie divergenta\n");
else
{
suma = termen =1; n=0;
do
{
termen /= a;
suma += termen;
n++;
}
while (termen >= precizie && n < MAX_TERM);
printf ("Suma = %lf, obtinuta cu %d termeni \n", suma, n);
}
}
________________________________________________________________________
/*
Programul determina media valorilor pozitive dintr-un sir de valori
introduse de la tastatura; sirul se termina cu valoarea zero.
De asemenea programul calculeaza si afiseaza numarul total de valori
citite de la tastatura, precum si numarul de octeti afisati pe display.
Functia scanf() , pe langa citirea valorilor introduse de la
tastatura, determina numarul de valori citite si le asociaza numelui
acestei functii.
Functia printf(), pe langa tiparirea sirului de caractere inclus
intre ghilimele si a valorilor asociate variabilelor sau expresiilor, din
lista sa de argumente, determina si numarul de octeti afisati pe display,
pe care-l asociaza numelui sau.
*/
#include <stdio.h>;
void main()
{
int n=0,nr_val=0,no;
double val,media=0;
no = printf("\nProgramul calculeaza media valorilor pozitive din sir.\n");
no += printf("Se afiseaza si numarul de carcatere tiparite.\n");
no += printf("Introduceti un sir de valori ce se termina cu 0:\n");
no += printf("valoarea:");
nr_val=scanf("%lf",&val);
while ( val != 0 )
{
if ( val > 0 )
{
n++;
media += val;
}
no += printf("valoarea:");
nr_val += scanf("%lf",&val);
}
if ( n==0 )
no += printf("Sir vid de valori\n");
else
{
media /= n;
no += printf("Media valorilor pozitive este: %.2lf\n",media);
}
no += printf("Numarul total de valori citite este : %d\n",nr_val);
printf("Numar de caractere afisate:%d\n",no);
}
________________________________________________________________________
/* Program ce determina tipul caracterului tastat */
#include <stdio.h>
void main ( )
{
char c;
printf("\nProgram ce determina tipul caracterului tastat\n"
"\t(litera, cifra sau caracter special).\n");
printf ("Introduceti un singur caracter: ");
scanf ("%c", &c);
if ((c>='a' && c<='z') || (c>='A' && c<='Z'))
printf ("Este un caracter alfabetic \n");
else if (c>='0' && c<='9')
printf ("Este o cifra \n");
else
printf ("Este un caracter special \n");
}
________________________________________________________________________
/* Programul determina daca trei numere : a , b , c pot fi laturile unui
triunghi; si daca da, determina tipul triunghiului: echileteral,
isoscel, dreptunghic sau oarecare */
#include <stdio.h>
main()
{
int a,b,c;
printf("\nProgramul determina daca trei numere : a, b, c, pot fi laturile"
" unui triunghi;\nsi daca da, determina tipul triunghiului:\n"
"echileteral, isoscel, dreptunghic sau oarecare.\n");
printf("Introduceti valorile pt cele trei laturi\n");
if(a < b + c && b< a + c && c < a + b)
{ /* este triunghi , si se determina tipul triunghiului */
printf("este triunghi");
if ( a==b && b==c ) /* triunghi echilateral */
printf(" echilateral\n");
else if ( a==b )
/* triunghi isoscel, si se determina baza */
printf(" isoscel, cu baza c\n");
else if ( a==c)
printf(" isoscel, cu baza b\n");
else if ( b==c)
printf(" isoscel, cu baza a\n");
else if ( a*a==b*b+c*c ) /*triunghi dreptunghic, si se afla ipotenuza*/
printf(" dreptunghic, cu ipotenuza a\n");
else if ( b*b==c*c+a*a )
printf(" dreptunghic, cu ipotenuza b\n");
else if ( c*c==a*a+b*b)
printf(" dreptunghic, cu ipotenuza c\n");
else
printf(" oarecare\n");
}
else
printf("nu este triunghi");
}
________________________________________________________________________
// Sa se calculeze valoarea polinomului pn(x) si a polinomului derivat
// pn'(x), in ipoteza ca termenii se dau
// in ordinea descrescatoare a puterilor lui x.
#include <stdio.h>
main()
{
int i,n;
float valp=0,valdp=0,x,c;
printf("\nProgramul calculeaza valoarea unui polinom p(x) si a polinomului"
" derivat p'(x)\nin punctul x; termenii se dau in ordinea"
" descrescatoare a puterilor lui x.\n");
printf("x=");
scanf("%f",&x);
printf("Grad polinom = ");
scanf("%d",&n);
i=n;
while(i>=0)
{
printf("Coeficient rang %d = ",i);
scanf("%f",&c);
valp=valp*x+c;
if ( i )
valdp = valdp * x + c*i;
i--;
}
printf("Valoarea polinomului = %f\n",valp);
printf("Valoarea derivatei = %f\n",valdp);
}
________________________________________________________________________
/* Programul calculeaza valorea unui polinom , intr-un punct x dat.
Ind.: se va utiliza pentru calculul valorii forma de inmultire prin
impachetare :
P(x) = {..{{{ a(n)*x + a(n-1) }*x + a(n-2) }*x + a(n-3)}*x +..a(1)}*x+a(0)
*/
#include <stdio.h>
#include <conio.h>
void main(void)
{
int grad, i, val, x;
int coef[10];
clrscr();
printf ("Programul calculeaza valoarea unui polinom de grad n "
"intr-un punct x dat\n\n");
printf ("Introduceti gradul polinomului:");
scanf ("%d", &grad);
for ( i = grad ; i >= 0 ; i--)
{
printf ("Introduceti coeficientul lui x la puterea %d:", i);
scanf ("%d", &coef[i]);
}
printf ("Introduceti x-ul in care se calculeaza valoarea polinomului:");
scanf ("%d", &x);
val = 0;
for ( i = grad ; i >= 0 ; i--)
val = val * x + coef[i];
printf ("Valoarea este: %d", val);
}
________________________________________________________________________
/* Conversia unui numar intreg intr-o baza oarecare - 2..36 */
#include <stdio.h>
#define LUNG_MAX 32
void main ()
{
long int numar, baza, indice;
printf("\nConversia unui numar intreg intr-o baza oarecare (2..36)\n");
printf ("Numar de convertit: ");
scanf ("%ld", &numar);

printf("In baza: ");
scanf ("%ld", &baza);
indice = 0;
if ( numar < 0 )
{
printf("-");
numar = - numar;
}
do
{
cifra[indice] = '0' + numar % baza;
else
cifra[indice] = 'A' + numar % baza - 10;
numar /= baza;
indice++;
} while(numar);
for ( indice-- ; indice >= 0 ; indice-- )
printf("%c", cifra[indice]);
printf("\n");
}
________________________________________________________________________
/* Programul genereaza cel mult 100 numere Fibonacci */
#include <stdio.h>
void main ( )
{
long int fib[50];
int i , n ;
fib [0] = 0 ; fib [1] = 1 ;
/* initializarea primelor doua numere */
printf("\nProgramul genereaza cel mult 100 numere Fibonacci.\n");
printf ("Specificati dimensiunea sirului Fibonacci (<= 50) : ") ;
scanf ("%d", &n ) ;
for (i =2 ; i < n ; i++)
fib [i] = fib [i-1] +fib [i-2] ;
for (i = 0 ; i < n ; i++)
printf ( " %12li / " , fib [i] ) ;
printf("\n");
}
________________________________________________________________________
/* Programul ordoneaza un sir, utilizand algoritmul Shell;
metoda inventata in 1959 de Donlad Shell: compara, initial, elemente
aflate la o anumita distanta si le interschimba, pentru a elimina o mare
parte din dezordinea sirului; intervalul dintre elemetele comparate este
progresiv scazut, pana devine 1; la acest nivel metoda devine de
interschimbare a elementelor adiacente.
Se defineste o functie de sortare utilizand acest algoritm */

/* functia de sortare shellsort a vectorului v, cu n elemente,
in ordine crescatoare */
void shellsort ( double v[ ] ,int m )
{
int pas, i, j, temp;
for ( pas = m/2 ; pas > 0 ; pas /= 2 )
for ( i = pas ; i < m ; i++ )
for ( j = i -pas ; j>= 0 && v[j]>v[j+pas] ; j-=pas )
{
temp = v[j] ;
v[j] = v[j+pas] ;
v[j+pas] = temp ;
}
}
#include <stdio.h>
#define N_MAX 100
main ( )
{
double sir [N_MAX], a;
int n, i, j , inv ,pas;
printf("\nProgramul ordoneaza un sir, utilizand algoritmul Shell.\n");
printf ("Numarul de elemente ale sirului (<= 100): ");
scanf ("%d", &n);
for ( i = 0 ; i < n ; ++i )
{
printf ("sir[%d]= ", i+1);
scanf ("%lf", &a);
sir[i]=a;
}
shellsort( sir , n );
for ( i = 0 ; i < n ; ++i )
printf (" inv [%d]= %.2lf / " , i+1 , sir [i]);
printf("\n");
}
________________________________________________________________________
/* Programul ordoneaza un sir utilizand algoritmul Shell */
#include <stdio.h>
#define N_MAX 100
void main ( )
{
double sir [N_MAX], a;
int n, i, j , inv ,pas;
printf("\nProgramul ordoneaza un sir utilizand algoritmul Shell.\n");
printf ("Numarul de elemente ale sirului (<= 100): ");
scanf ("%d", &n);

for ( i = 0 ; i < n ; ++i )
{
printf ("sir[%d]= ", i+1);
scanf ("%lf", &sir[i]) ;
}
pas = n;
while ( pas >1 )
{
pas = pas / 2 ;
do
{
inv = 0 ;
/* fals */
for (i = 0 ; i < n - pas ; ++i)
{
j = i+pas ; /* sau if (inv [i] , inv [i+pas ] )*/
if ( sir [i] > sir [j] )
{
a = sir [j];
sir [j] = sir [i];
sir[i] = a;
inv = 1;
}
}
} while (inv);
}
for ( i = 0 ; i < n ; ++i )
printf (" inv [%d]= %.2lf / " , i+1 , sir [i]);
printf("\n");
}
________________________________________________________________________
/* Programul determina numerele prime din intervalul [2 , n] */
#include <stdio.h>
#include <math.h>
void main ( )
{
int i, n, p, este_prim, prim [1000], index_prim;
prim [0] = 2;
prim [1] = 3;
printf ("\nSe determina numerele prime in intervalul [2 , n], n= ");
scanf ("%d", &n);
index_prim = 1;
for (p = 5 ; p <= n ; p = p + 2)
{
este_prim = 1;
for (i = 1; este_prim && i <= index_prim; i++)
este_prim = p % prim [i];

if (este_prim)
{
index_prim ++;
prim [ index_prim ] = p;
}
}
for ( i = 0 ; i <= index_prim ; i++)
printf ( "%6i / " , prim [i]);
printf (" \n " ) ;
}
________________________________________________________________________
/* Programul afiseaza numere prime utilizand sita lui Eratostene */
#include <stdio.h>
#define MAXIM 1001
void main ( )
{
int prim [ MAXIM ], n , index , contor , multiplu;
printf ("\nDetermina numerele prime (alg. Eratostene) in intervalul 2-n ,n =");
scanf ("%d" , &n);
for ( index = 2 ; index < n ; ++index )
prim [index] = 1 ; /* primele 2 elemente nu sunt folosite */
contor = 0 ;
index = 1;
do
{
index ++;
if (prim [index])
{
printf (" %d /", index); contor++;
for (multiplu = 2 ; multiplu <= n/index ; ++ multiplu )
if ( prim[ index * multiplu ] )
{
prim [index * multiplu] = 0;
contor ++;
}
}
} while (contor <n-1);
printf("\n");
}
________________________________________________________________________
/* Se calculeaza produsul a doua matrice, daca se pot inmulti (adica
numarul de coloane de la prima este egal cu numarul de linii de la a 2-a)
*/
#include <stdio.h>
#define DIM 10
void main()
{
double a[DIM][DIM], b[DIM][DIM], c[DIM][DIM];
double x;
int la, ca, lb, cb, i, j, k;
printf("\nSe calculeaza produsul a doua matrice, daca se pot inmulti.\n");
printf ("Dimensiunea matricei A (linii,coloane):");
scanf ("%d%d", &la, &ca);
printf ("Dimensiunea matricei B (linii,coloane):");
scanf ("%d%d", &lb, &cb);
if (ca != lb)
printf ("Nu se pot inmulti\n");
else
{
printf ("Matricea A:\n");
for ( i = 0 ; i < la ; i++)
for ( j = 0; j < ca ;j++)
{
printf ("A(%d,%d)=",i+1, j+1);
scanf ("%lf", &x);
a[i][j] = x;
}
printf("Matricea B:\n");
for ( i = 0 ; i < lb ; i++)
for ( j = 0 ; j < cb ; j++)
{
printf ("B(%d,%d)=", i+1, j+1);
scanf ("%lf", &x);
b[i][j] = x;
}
printf("Matricea rezultata dupa inmultire:\n");
for ( i = 0 ; i <la ; i++)
for ( j = 0 ; j < cb ; j++)
{
c[i][j] = 0;
for ( k = 0 ; k < ca ; k++)
c[i][j] += a[i][k] * b[k][j];
printf ("C(%d,%d)=%.2lf\n", i+1, j+1, c[i][j]);
}
}
}
________________________________________________________________________
/* Programul numara cate valori, dintr-un sir sunt egale cu o valoare data
*/
#include<stdio.h>
#define NMAX 100
void main()
{
double V[NMAX], valoare;
int n,i,contor=0;
printf("\nProgramul numara cate valori, dintr-un sir sunt egale"
"cu o valoare data.\n");
printf("Numarul de elemente din sir este:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("V(%d)=",i+1);
scanf("%lf",&V[i]);
}
printf("\n\tValoarea cautata este:");
scanf("%lf",&valoare);
for(i=0;i<=n;i++)
{
if(V[i]==valoare)
contor++;
}
if(contor==0)
printf("\nNu exista nici o valoare a sirului care sa fie egala"
" cu valoarea data\n\n");
else
printf("\nNumarul de valori ale sirului egale cu valoarea data"
" este:%d\n",contor);
}
________________________________________________________________________
/* Pentru n dat, sa se calculeze coeficientii c0,c1,...,cn, stiind ca:
c0
c1
cp
----- + --- +...+ --- = 1, pentru p=0,1,...,n.
p+1 p
1
*/
#include <stdio.h>
#define DIM 201
main()
{
int
n, p, k, nvl=0;
double c[DIM];
printf("Programul calculeaza coeficientii:\n");
printf(" c0
c1
cp
\n");
printf("----- + --- +...+ --- = 1, pentru p=0,1,...,n.\n");
printf(" p+1 p
1
\n");
printf("Specificati n (n<200) =");
scanf("%d", &n);
for ( p = 0 ; p <=n ; p++ )

{
c[p] = 1;
for ( k = 0 ; k <= p-1 ; k++ )
c[p] = c[p] - c[p-k-1] / (k + 2);
printf("c[%d]=%.2lf ", p, c[p]);
nvl++; /* numarul de valori afisate pe linie */
if (nvl % 5 == 0)
printf("\n");
}
}
________________________________________________________________________
/* Se introduc n,m, se cere sa se afle cmmdc folosind algoritmul:
1. Se afla pentru fiecare nr divizorii primi cu puterea lor
2. Se afla cmmdc luand divizorii primi comuni cu puterea cea mai mica. */
#include<stdio.h>
#include<math.h>
int cmmdc[5000];
int div1[5000],div2[5000];
int n1,n2;
int ni1,ni2;
int x1,x2;
int i;
int prim(int k)
{
int i,true=1;
for(i=2;i<sqrt(k);i++)
if(k%i==0) true=0;
return (true);
}
void divizor()
{
int k,i;
ni1=n1;
ni2=n2;
for (k=2;k<10;k++)
{
if (prim(k))
{
x1=0;
x2=0;
do
{
if (ni1%k==0)
{
x1++;
ni1=ni1/k;
}
} while (ni1%k==0);
div1[k]=x1;
do{
if(ni2%k==0)
{
x2++;
ni2=ni2/k;
}
} while (ni2%k==0);
div2[k]=x2;
}
}
}
int min(int a,int b)
{
if(a<b)
return a;
else
return b;
}
void afla_cmmdc()
{
int i,j;
for(i=1;i<10000;i++)
if((div1[i]!=0)&&(div2[i]!=0))
cmmdc[i]=min(div1[i],div2[i]);
}
void main()
{
for(i=0;i<1000;i++)
cmmdc[i]=0;
scanf("%d",&n1);
scanf("%d",&n2);
divizor();
afla_cmmdc();
for(i=1;i<1000;i++)
{
if (cmmdc[i]!=0)
printf("%d - %d.",i,cmmdc[i]);
}
}
________________________________________________________________________
/* Se calculeaza cel mai mare divizor comun a doua numere n , m utilizind
algoritmul :
- se construiesc doua tablouri cu factorii primi ai celor doua numere si
factorii de multiplicitate pentru fiecare factor prim;
- se vor selecta in c.m.m.d.c factorii primi comuni , cu factorul de
multiplicitate minim dintre cei doi.
*/
#include <math.h>
#define NMAX 100
void descompune(int *a,int *n,int nr)
{ int i=2,mult=0,n1=nr,num=0;
while(n1>1)
{ if(n1%i==0)
{ mult++;n1/=i;}
else
{
if(mult>0)
{
*(a+num*2)=i;
*(a+num*2+1)=mult;
num++;
}
if(i<nr)
{ i++;
mult=0;
}
}
}
*(a+num*2)=i;
*(a+num*2+1)=mult;
*n=num;
}
void main(void)
{
int a[NMAX][2],b[NMAX][2],c[NMAX][2],nr1,nr2,nd1,nd2,u=0,j=-1;
cout << "\nProgramul determina cmmdc pentru 2 numere." << endl;
cout <<"Nr1=";cin >> nr1;
cout <<"Nr2=";cin >> nr2;
descompune(&a[0][0],&nd1,nr1);
descompune(&b[0][0],&nd2,nr2);
for(int i=0;i<=nd2;i++)
{
j=-1;
for(int q=0;q<=nd1;q++)
if(b[q][0]==a[i][0]) j=q;
if(j!=-1)
{
c[u][0]=a[i][0];
c[u][1]=(b[j][1]>=a[i][1])?a[i][1]:b[j][1];
u++;
}
}
cout <<"Numitorul comun este:";
if(u>0)
{
for(i=0;i<u-1;i++)
cout <<c[i][0] <<"^" <<c[i][1] <<"*";
cout <<c[u-1][0] <<"^" <<c[u-1][1];
}
else
cout <<"1";
}
________________________________________________________________________
/* Programul afiseaza o valoare intreaga in toate bazele de la 2 la 16 */
#include <stdio.h>
#include <conio.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
void main(void)
{
int nr,i,j;
char numar[17];
clrscr();
printf("\nProgram care afiseaza o valuare intreaga in orice baza de la 2"
" la 16.\n");
printf("\nIntoduceti numarul:");
scanf("%d",&nr);
printf("\n\n");
for(i=16;i>1;i--)
{
itoa(nr,numar,i);
for(j=0;j<strlen(numar);j++)
numar[j]=toupper(numar[j]);
printf("%16s in baza %d\n",numar,i);}}
/* Programul descompune o suma de bani, de platit, intr-un numar

minim de bancnote
*/
#include <stdio.h>
void main()
{
enum bancnota { CSM=0, OSM, CZM, ZM, CM, OM, CS, OS, CZ, DZ, ZECE};
bancnota diviziune;
unsigned long int suma , nr_bancnote , total , rest;
unsigned long int valoare[] =
{ 500000, 100000, 50000, 10000, 5000, 1000, 500, 100, 50, 20, 10 };
printf("\nProgramul descompune o suma de bani, de plata, intr-un numar "
"minim de bancnote.\n");
printf("Introduceti suma de descompus :");
scanf ("%lu" , &suma );
total = 0;
rest = suma;
for (diviziune=CSM ; diviziune <= ZECE && suma ; diviziune++)
{
nr_bancnote = suma / valoare[diviziune];
suma %= valoare[diviziune];
total += nr_bancnote * valoare[diviziune];
if ( nr_bancnote )
printf("%8lu * %-8lu = %10lu\n", nr_bancnote ,
valoare[diviziune], nr_bancnote * valoare[diviziune]);
}
printf("--------------------------------\n");
printf("
total = %lu\n",total);
if (total-rest)
{
printf("%28c",' ');
printf("(suma de plata a fost rotunjita cu %i lei)\n",total-rest);
}
printf("\n\n");
}
________________________________________________________________________
/* Programul genereaza literele alfabetului latin */
void main(void)
{
char alfabet[27]; // 26 litere plus NULL
char litera;
int index;
cout << endl;
cout << "Programul genereaza , si afiseaza in 2 moduri, "
"literele alfabetului latin." << endl;

// initializare litera si index-ul tabloului alfabet;
// actualizare litera si index
for (litera = 'A', index = 0; litera <= 'Z'; litera++, index++)
alfabet[index] = litera;
alfabet[index] = NULL; // ultimul caracter tiparibil
cout << "Literele alfabetului sunt: " << alfabet << endl;
// tiparirea se poate face si astfel :
cout << "Literele alfabetului sunt:";
for ( index = 0; index < 26 ; index++)
// in acest caz nu mai este necesar caracterul NULL
cout << alfabet[index] << ' ' ;
cout << endl ;
}
________________________________________________________________________
/* Programul insereaza o valoare data intr-un sir ordonat,
pe pozitia corespunzatoare */
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
void main(void)
{
int val,i,n,m=0;
int sir[100];
clrscr();
printf("Programul insereaza o valoare intr-un sir ordonat.\n");
printf("Numar componente sir:");
scanf("%u",&n);
printf("\nIntroduceti sirul:\n");
sir[0]=0;
for(i=0;i<n;i++)
{
printf("Sir[%2d]=",i+1);
scanf("%d",&sir[i]);
if(i && sir[i]<sir[i-1])
{
printf("\nSirul nu este ordonat crescator");
exit(EXIT_SUCCESS);
}
}
printf("\nValoare de inserat:");
scanf("%d",&val);
printf("Sirul final:\n");
for(i=0;i<n;i++)
{
if((val<=sir[i])&&(m==0))
{
printf("%d ",val);
m=1;
}
printf("%d ",sir[i]);
}
if(m==0)
printf("%d\n",val);
}
________________________________________________________________________
/* Se considera urmatorul joc : N copii , identificati prin numerele :
1,2,3,...,N se aseaza in cerc si incepind de la copilul K se numara de
la 1 pina la M , eliminindu-l din joc pe ultimul ; se reia numaratoarea
cu urmatorul si se elimina al 2-lea copil din joc , s.a.m.d.,
pana ramane unul singur (castigatorul)
Sa se stabileasca ordinea de iesire din joc.
*/
#include <stdio.h>
#define MAX_COPII 100
void main(void)
{
int copil[MAX_COPII], out[MAX_COPII];
// primul tablou va contine 1 pentru copii ce sunt in joc, 0 pt. eliminati
// cel de-al doilea va contine copii in ordinea eliminarii lor
int n,k,e; // nr. copii, k-pozitia de unde incepe eliminarea, e- pasul
int j, o, i, contor;
printf("\nSe considera urmatorul joc : N copii, identificati prin numerele:"
"1,2,3,...,N\nse aseaza in cerc si incepind de la copilul K se"
"numara de la 1 pina la M,\neliminindu-l din joc pe ultimul;"
"se reia numaratoarea cu urmatorul si se elimina\nal 2-lea copil "
"din joc , s.a.m.d., pana ramane unul singur (castigatorul)\n"
"Sa se stabileasca ordinea de iesire din joc.\n");
do
{
printf("Nr. de copii care intra in joc(max.%d): ",MAX_COPII);
scanf("%d",&n);
} while ( n < 1 || n > MAX_COPII );
do
{
printf("De la ce copil se incepe numaratoarea (1-%d): ",n);
scanf("%d",&k);
} while ( k < 1 || k > n );
do
{
printf("Pasul de numarare (al catalea copil se elimina) (1-%d): ",n);
scanf("%d",&e);
} while ( e < 1 || e > n );
for(i=1; i<=n; i++)

copil[i]=1; // initializarea copiilor din joc
o = 0; // indexul copilului curent de eliminat
contor = 0; // contor-ul copiilor eliminati din joc
j = 0; // contor curent al copilului de eliminat
while( contor < n ) {
while ( copil[k] == 0 ) // se cauta urmatorul copil ramas in joc
k = k % n + 1;
j++;
if ( j == e ) {
copil[k] = 0; // eliminare copil
contor++; // contorizare copil eliminat
o++; // actualizare index copil eliminat
out[o]=k; // memorare copil eliminat
j = 0; // initializare contor copil de eliminat
}
k = k % n + 1; // indexul urmatorului copil
}
printf("Cel care a ramas in joc este al %d-lea copil.\n", out[n]);
printf("Copii au fost scosi din joc in urmatoarea ordine:\n");
for( i = 1 ; i <= n ; i++ )
printf("%4d ->", out[i]);
printf("\n");
}
________________________________________________________________________
/* Programul determina maximul dintr-un vector cu n componente
si pozitia acestuia */
#include<stdio.h>
#define DIM 100
void main()
{
double vector[DIM], maxim, v;
int n,i,pozitie;
printf("\nProgramul determina maximul dintr-un vector cu n elemente "
"si pozitia acestuia.\n");
printf("Introduceti numarul de elemente din sir: ");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("v(%d)=",i+1);
scanf("%lf",&v);
vector[i] = v;
}
maxim=vector[1];
pozitie=0;
for(i=0;i<n;i++)
if(maxim<vector[i])
{
maxim=vector[i];
pozitie=i;
}
printf("Valoarea maxima este: v(%d)=%g.\n",pozitie+1,maxim);
}
________________________________________________________________________
/* Programul determina maximul dintr-un vector cu n componente
si pozitia acestuia
*/
#include<stdio.h>
#define DIM 100
main()
{
double vector[DIM], maxim, v;
int n,i,pozitie;
printf("\nProgramul determina maximul dintr-un vector cu n elemente "
"si pozitia acestuia.\n");
printf("Introduceti numarul de elemente din sir: ");
scanf("%d",&n);
printf("Introduceti valori:\n");
for(i=0;i<n;i++)
{
printf("v(%d)=",i+1);
scanf("%lf",&v);
vector[i] = v;
}
maxim=vector[1];
pozitie=0;
for(i=0;i<n;i++)
if(maxim<vector[i])
{
maxim=vector[i];
pozitie=i;
}
printf("Valoarea maxima este v(%d)=%lg\n",pozitie+1,maxim);
}
________________________________________________________________________
/* Programul determina subsirul e monotonie maxima dintr-un sir dat */
#include <stdio.h>
#include <conio.h>
void main(void)
{
int lc,ld,n,i,j;
int s[100],sc[100],sd[100];
clrscr();
printf("Programul determina subsirul e monotonie maxima dintr-un sir dat\n\n");
j=2;
lc=0;
ld=0;
printf("Numar componente:");
scanf("%d",&n);
clrscr();
s[0]=0;
for(i=1;i<=n;i++)
{
gotoxy(1,24);
clreol();
printf("Sir[%2d]=",i);
scanf("%d",&s[i]);
if(s[i]>s[i-1])
{
j++;
sc[lc]=s[i];
lc++;
gotoxy(1,2);printf("Subsir cresc:");
gotoxy(1,j);printf("%d",s[i]);
}
else
{
j++;
sd[ld]=s[i];
ld++;
gotoxy(35,2);printf("Subsir descresc:");
gotoxy(35,j);printf("%d",s[i]);
}
}
}
________________________________________________________________________
/* Programul determina maximul de pe fiecare linie a unei matrici */
#include<stdio.h>
#include<conio.h>
void main()
{
int a[10][10],M[10];
int n,i,j,*matrice;
clrscr();
printf("\nProgramul determina maximul de pe fiecare linie a unei matrici.\n");
printf("Introduceti dimensiunea matricei :");
scanf("%d",&n);
for (i=0;i<n;i++)
for (j=0;j<n;j++)
{
printf("a(%d,%d)=",i+1,j+1);
scanf("%d",&a[i][j]);
}
matrice=&a[0][0];
for(i=0;i<n;i++)
{
M[i]=*(matrice+i*10 + i);
for(j=0;j<n;j++)
{
if (*(matrice+i*10+j)>M[i])
M[i]=*(matrice+i*10+j);
}
}
printf("\n Elementele maxime sunt :\n");
for (i=0;i<n;i++)
printf("linia %i = %d\n",i+1,M[i]);
}
________________________________________________________________________
/* Programul numara cifrele (de cate ori apare fiecare cifra),
spatiile albe si celelalte caractere */
#include <stdio.h>
main ( )
{
int car, i, spatiu_alb, alte_car;
int nr_cifre [ 10 ], suma_nr_cif = 0;
spatiu_alb = alte_car = 0 ;
printf("\nProgramul numara cifrele (de cate ori apare fiecare cifra),\n"
"spatiile albe si celelalte caractere, dintr-un text.\n"
"Textul se termina cu CTRL-Z, ENTER.\nIntroduceti textul:\n");
for ( i = 0 ; i < 10 ; ++i )
nr_cifre [ i ] = 0 ;
while ( ( car = getchar ( ) ) != EOF )
if ( car>= '0' && car <= '9' )
++ nr_cifre [car- '0' ] ;
else if ( car == ' ' || car == '\n' || car == '\t' )
++ spatiu_alb ;
else
++ alte_car ;
for ( i = 0 ; i < 10 ; ++i )
suma_nr_cif += nr_cifre[i];
if (suma_nr_cif)
printf ( "cifre = " ) ;
for ( i = 0 ; i < 10 ; ++i )
if ( nr_cifre [i] != 0 )
printf ( " cifra %d, de %d ori\n", i, nr_cifre [ i ] ) ;
printf ( "spatii albe = %d , alte caractere = %d\n" ,
spatiu_alb, alte_car ) ;
}
________________________________________________________________________
/* Un numar perfect este un numar egal cu suma divizorilor sai,
printre care se considera si divizorul 1. Sa se determine toate
numerele perfecte mai mici sau egale cu un numar dat n.
De exemplu 28 este un numar perfect deoarece 28=1+2+4+7+14
(1,2,4,7 si 14 fiind divizorii lui 28).
*/
#include <stdio.h>
#include <conio.h>
#define DIM 10000
main()
{
int i, a, b, k, j, index=0;
int num_perfect[DIM];
clrscr();
printf("Un numar perfect este un numar egal cu suma divizorilor sai,\n"
"printre care se considera si divizorul 1. Programul afla toate\n"
"numerele perfecte dintr-un interval dat.\n"
"De exemplu 28 este un numar perfect deoarece 28=1+2+4+7+14,\n"
"(1,2,4,7 si 14 fiind divizorii lui 28).\n");
printf("Specificati intervalul [a,b], in care se cauta numere "
"perfecte:");
scanf("%d%d", &a, &b);
for (j = a ; j <= b ; j++)
{
k=0;
for (i = 1 ; i <= j/2 && k<= j ; i++)
if (j%i == 0)
k=k+i;
if (k==j)
num_perfect[index++]=k;
}
if (--index >= 0)
for (i = 0 ; i <= index ; i++)
printf("perfect[%d]=%d\n", i+1, num_perfect[i]);
else
printf("In intervalul dat nu este nici un numar perfect\n");
}
/* Programul genereaza toate permutarile unui vector cu 'n' elemente */

#include <stdio.h>
#include <conio.h>
#define MAX 50
main()
{
void afisare_vector( int vect[] , int ne );
int vector[MAX], perm[MAX], nr_perm[MAX], aux;
int i,p,n,npt=0,np;
printf("\nProgramul genereaza toate permutarile unui vector cu 'n' elemente\n");
printf("Dimensiunea vectorului:");
scanf("%d",&n);
for ( i=1 ; i<=n ; i++ )
{
printf("v[%d]=",i);
scanf("%d",&vector[i]);
}
for ( i=1 ; i<=MAX ; i++ )
perm[i]= 0;
for ( i=1 ; i<=MAX ; i++ )
nr_perm[i]= i;
np = 1;
for ( i=1 ; i <=n ; i++ )
np *= i;
do
{
i=2;
do
{
aux = vector[1];
for ( p=2 ; p <= i ; p++ )
vector[p-1] = vector[p];
vector[i]= aux;
afisare_vector ( vector , n );
perm[i] = ( perm[i] + 1 ) % nr_perm[i];
npt++;
if (npt % 20 ==0) /* cate 20 de permutari afisate */
{
printf("\n");
getch();
}
} while ( perm[i] != 0 );
do
{
i++;
aux = vector[1];
for ( p=2 ; p <= i ; p++ )
vector[p-1] = vector[p];
vector[i]= aux;
perm[i] = ( perm[i] + 1 ) % nr_perm[i];
} while ( perm [i] == 0 && i < n );
} while (npt != np );
}
void afisare_vector ( int vect[], int ne )
{
int i;
for ( i=1 ; i <= ne ; i++ )
printf(" %d ", vect[i]);
printf("\n");
}
________________________________________________________________________
/*
Programul determina numerele prime n intervalul [2,n]
si le depune intr-un tablou , daca nu se determina nici un
divizor in intervalul [ 2 , sqrt(n)]
*/
#include<stdio.h>
#define N_MAX 100
void main()
{
int n,p,i,este_prim,prim[N_MAX],index;
do
{
printf("\n\nSe determina numerele prime\
in intervalul 2, n <= 500\nn=");
scanf("%d",&n);
}
while(n>530);
prim[0]=2;
prim[1]=3;
index=2;
for(p=5;p<=n;p+=2)
{
este_prim=1;
for(i = 3;este_prim && i*i <= p;i += 2)
este_prim =!(p%i==0);
if(este_prim)
prim[index++]=p;
}
for(i=0;i<index;i++)
printf("%4d/",prim[i]);
printf("\nIn total %d numere prime\n\n",index);
}
________________________________________________________________________
/*
Determina numere prime utilizand sita lui Eratostene:
se "elimina" multiplii numerelor prime dintr-un vector boolean
care este initializat cu 'adevarat' pentru toate numerele
*/
#include<stdio.h>
#include <conio.h>
#define MAX 5000
void main()
{
int n,index,multiplu,contor,prim[MAX], nr_val_ecran = 0;
printf("\nDetermina numere prime utilizand sita lui Eratostene:\n"
"se \"elimina\" multiplii numerelor prime dintr-un vector boolean\n"
"care este initializat cu 'adevarat' pentru toate numerele.\n");
printf("Intervalul in care se determina numerele prime [2,n]; n= ");
scanf("%d",&n);
for(index=1;index<=n;index++)
prim[index]=1;
contor=1;
index=1;
do
{
index++;
if(prim[index])
{
printf("%4d/ ",index);
nr_val_ecran++;
if ( nr_val_ecran % 50 == 0 ) /* se afiseaza serii de cate 50 nr. */
{
printf("\n");
getch();
}
contor++;
for(multiplu=2;multiplu*index<n;multiplu++)
if(prim[multiplu*index])
{
prim[multiplu*index]=0;
contor++;
}
}
}
while(contor<n-1);
printf("\n");
}
________________________________________________________________________
/* produsul scalar a doi vectori tridimensionali */
# include <stdio.h>
# include <conio.h>
void main(void)
{
float x, u[3], v[3], ps=0;
int s;
clrscr();
printf("Program pentru determinarea produsului scalar a doi vectori "
"tridimensinali\n");
printf("Vectorul U:\n");
for(s=0;s<3;s++)
{
printf("u[%d]=",s);
scanf("%f",&x);
u[s] = x;
}
printf("\nVectorul V:\n");
for(s=0;s<3;s++)
{
printf("v[%d]=",s);
scanf("%f",&x);
v[s] = x;
}
for(s=0;s<3;s++)
ps=ps+u[s]*v[s];
printf("\nProdusul scalar=%10.2f\n",ps);
}
________________________________________________________________________
/* Program: Separa un sir in doua subsiruri, dupa cum valorile din
sirul sursa sunt mai mici sau mai mari decat o valoare data
*/
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
main()
{
int
k, i, j, j1, j2, n, val;
int
sir[100], subsir1[100], subsir2[100];
clrscr();
printf("Problema : Se da o valoare y si un sir x cu n componente.\n"
"Sa se separe sirul x in doua subsiruri astfel incat:\n"
"
- elementele din primul sa fie mai mici decat y,\n"
"
- iar din al doilea mai mari sau egale decat y.\n");
printf("Valoarea numarului y= "); scanf("%d",&val);
printf("Numarul de componente n= "); scanf("%d",&n);
clrscr();
for (k = 0; k < n; k += 2)
{
if ( ((k+1)/2) % 24 == 0 )
clrscr();
gotoxy(5, ((k+1)/2) % 24 + 1); delline();
printf("Sir[%d]= ",k+1); scanf("%d",&sir[k]);
if ( k + 1 < n )
{
gotoxy(35, ((k+1)/2) % 24 +1);
printf("Sir[%d]= ",k+2); scanf("%d",&sir[k+1]);
}
}
printf("\n\nApasa o tasta si se vor construi cele doua siruri");
getch();
j1 = 0; j2 = 0;
for (i = 0; i < n; i++)
if (sir[i] < val)
{
subsir1[j1] = sir[i];
j1 = j1 + 1;
}
else
{
subsir2[j2] = sir[i];
j2 = j2 + 1;
}
clrscr();
j = j1 > j2 ? j1 : j2;
gotoxy(5,1); printf("Subsir de val < %d.",val);
gotoxy(35,1); printf("Subsir de val >= %d.",val);
for ( i = 0 , k = 2 ; i < j ; i++ , k ++ )
{
if ( k % 24 == 0 )
{
printf("\nApasa o tasta si se continua afisarea");
getch();
clrscr();
}
if ( i < j1 )
{
gotoxy(5, k % 24 + 1);delline();
printf("subsir1(%d)=%d",i+1,subsir1[i]);
}
if ( i < j2 )
{
gotoxy(35, k % 24 + 1);
printf("subsir2(%d)=%d",i+1,subsir2[i]);
}
}
printf("\n\nApasa o tasta si se termina executia programului");
getch();
}
________________________________________________________________________
/* Programul rezolva un sistem triunghiular inferior, de forma:
a(1,1)*x(1)
=b(1)
a(2,1)*x(1)+a(2,2)*x(2)
=b(2)
a(3,1)*x(1)+a(3,2)*x(2)+a(3,3)*x(3)
=b(3)
...................................................................
a(n,1)*x(1)+a(n,2)*x(2)+a(n,3)*x(3)+.............+a(n,n)*x(n) =b(n) */
#include <stdio.h>
#include <conio.h>
void main()
{
int i,j,n;
double x,c[50],a[50][50],b[50],s;
clrscr();
printf("Programul rezolva un sistem triunghiular inferior \n");
printf("Exemplu: un sistem de 3 ecuatii : \n");
printf("a[1][1]*x1
=b[1] \n");
printf("a[2][1]*x1+a[2][2]*x2
=b[2] \n");
printf("a[3][1]*x1+a[3][2]*x2+a[3][3]*x3=b[3] \n");
printf("a[n][1]*x1+a[n][2]*x2+ . . +a[n][n]*xn=b[n] \n");
printf("Introduceti numarul de ecuatii:");scanf("%d",&n);
for (i=0;i<n;i++)
for (j=0;j<n;j++)
if (i<j)
a[i][j]=0;
else {
printf("a[%d][%d]=",i+1,j+1);scanf("%lf",&x);
a[i][j] = x;
}
for (i=0;i<n;i++)
{
printf("b[%d]=",i+1);scanf("%lf",&x);
b[i] = x;
}
c[0]=b[0]/a[0][0];
for (i=1;i<n;i++)
{
s=0;
for (j=0;j<i;j++)
s=s+a[i][j]*c[j];
c[i]=(b[i]-s)/a[i][j];
}
printf("Solutiile sistemului sint : \n");
for (j=0;j<n;j++)
printf("x%d=%lf \n",j+1,c[j]);
}
________________________________________________________________________
/*
programul ordoneaza un sir de valori, utilizand metoda inversiunilor
*/
#include<stdio.h>
#define MAX 100
void main()
{
int n,i,test,contor=0;
float sir[MAX],a;
do
{
printf("\nOrdonare sir prin metoda inversiunilor.\n");
printf("Introduceti numarul de termeni ai sirului(<100), n= ");
scanf("%d",&n);
}
while(n>99);
for(i=0;i<n;i++)
{
printf(" sir(%d)=",i+1);
scanf("%f",&a);
sir[i] = a;
}
do
{
test=0;
for(i=0;i<n-1;i++)
if(sir[i]>sir[i+1])
{
a=sir[i];
sir[i]=sir[i+1];
sir[i+1]=a;
contor++;
test=1;
}
}
while(test);
printf("\nSirul sortat este:\n");
for(i=0;i<n;i++)
printf(" sir(%d)=%G\n",i+1,sir[i]);
printf("\nPentru sortare s-au facut %d inversiuni.\n",contor);
}
________________________________________________________________________
/* Programul calculeaza subsirul crescator maxim dintr-un sir dat */
#define n 100
void main(void)
{
int st[n],sol[n],vect[n],max=-1,k=1,as,ev,mar;
cout << "\nProgramul calculeaza subsirul crescator maxim dintr-un sir dat\n";
cout <<"Dimensiune sir, n=";cin >>mar;
for(int i=0;i<mar;i++)
{
cout <<"v[" <<i+1 <<"]=";
cin >>vect[i];
}
st[0]=0;st[k]=0;
while(k>-1)
{
do{
as=1;
if(st[k]<mar-1)
{st[k]++;}
else
as=0;
ev=0;
if((as==1)&&(k>0))
{if(vect[st[k-1]]<vect[st[k]]) ev=1;}
if((as==1)&&(k==0)) ev=1;
}while((as==1)&&(ev==0));
if(as==0)
{
k--;
if(max<k)
{ for(i=0;i<=k;i++) sol[i]=st[i];
max=k;
}
}
if(ev==1)
{
if(k<mar-1)
{
k++;
st[k]=st[k-1];
}
}
}
cout << max+1 <<"\n";
for(i=0;i<=max;i++)
cout <<vect[sol[i]] <<" ";
cout <<"\n\n";
}
________________________________________________________________________
/* Programul calculeaza valoarea polinomului pn(x) si a polinomului derivat
pn'(x), in ipoteza ca termenii se dau in ordinea descrescatoare
a puterilor lui x. */
#include <stdio.h>
main()
{
int i,n;
float valp=0,valdp=0,x,c;
printf("\nProgramul calculeaza valoarea polinomului pn(x) si a polinomului\n"
"derivat pn'(x), in ipoteza ca termenii se dau in ordinea\n"
"descrescatoare a puterilor lui x.\n");
printf("Punctul in care se calculeaza valoarea polinomului, x=");
scanf("%f",&x);
printf("Grad polinom = ");
scanf("%d",&n);
i=n;
while(i>=0)
{
printf("Coeficient rang %d = ",i);
scanf("%f",&c);
valp=valp*x+c;
if ( i )
valdp = valdp * x + c*i;
i--;
}
printf("Valoarea polinomului = %f\n",valp);
printf("Valoarea derivatei partiale = %f\n",valdp);
}
________________________________________________________________________
/*Programul afiseaza un tablou de caractere*/
#include <stdio.h>
void main(void) {
char salut [] = {'S', 'a', 'l', 'u', 't', '!'};
int i;
printf("\nProgramul afiseaza un tablou de caractere:\n");

for ( i =0; i < 6; ++i)
printf("%c", salut[i]);
printf("\n");
}
________________________________________________________________________
/*Programul afiseaza un sir de caractere, ca un tablou de caractere*/
#include <stdio.h>
void main(void) {
char salut [] = {'S', 'a', 'l', 'u', 't', '!', '\0'};
int i;
printf("\nSe afiseaza un sir de caractere, ca un tablou de caractere:\n");
for ( i =0; i < 6; ++i)
printf("\n");
printf("\nSe afiseaza acelasi sir de caractere, ca un sir:\n");
printf("%s!\n", salut);
}
________________________________________________________________________
/* Programul realizeaza conversia unui numar intreg intr-o alta baza */
#include <stdio.h>
#include <conio.h>
#define LUNG_MAX 32
void main ()
{
long int numar, baza, ind1, ind2;
char cifra [ LUNG_MAX ], aux;
clrscr();
printf("Programul coverteste un numar intreg intr-o alta baza (2-36).\n");
printf ("Numarul de convertit = ");
printf ("Conversie in baza :");
scanf ("%ld%", &baza);
if ( numar < 0 )
{
printf ("-");
numar = - numar;
}
ind1 = 0 ;
do
{
ind1 ++;
cifra [ ind1 ] = '0' + numar % baza;
else
cifra [ ind1 ] = 'A' + numar % baza - 10;
numar /= baza;
} while ( numar > 0 );
for ( ind2 = 0 ; ind2 <= ind1/2 ; ind2 ++ )
{
aux = cifra[ind2];
cifra[ind2] = cifra[ind1-ind2];
cifra[ind1-ind2] = aux;
}
cifra[ind1] = '\0';
printf ("%s", cifra);
printf("\n");
}
________________________________________________________________________
/* Programul concateaza doua siruri de caractere, utilizand o functie,
si determina lungimea sirului obtinut */
#include <stdio.h>
void main()
{
void concat ( char rezultat[], char sir1[], char sir2[]);
int lungime ( char sir[]);
char s1[]={"Test pentru"};
char s2[]={" concatenare siruri de caractere"};
char s[60];
printf("\n\nProgram pentru concatenarea a doua siruri.\n");
printf("Sirurile initiale sunt: s1=\"%s\",\n\t\t\ts2=\"%s\"\n", s1, s2);
concat (s, s1, s2);
printf ("Sirul rezultat este:\n\t\t\"%s\"\n", s);
printf ("Lungimea sirului este final (concatenat): %d\n", lungime(s));
}
void concat (char rezultat[], char s1[], char s2[])
{
int i, j;
for ( i = 0 ; s1[i] != '\0' ; i++)
rezultat[i] = s1[i];
for ( j = 0 ; s2[j] != '\0' ; j++)
rezultat[i+j] = s2[j];
rezultat[i+j] = '\0';
}
int lungime (char sir[])
{
int contor=0;
for ( contor++ ; sir[contor] != '\0' ; contor++);
return (contor-1);
}
________________________________________________________________________
/* Programul elimina spatiile (blancurile) dintr-un sir de caractere */
#include <stdio.h>
#include <conio.h>
#include <string.h>
void main(void)
{
int i, j;
char sir[100], sir1[100];
clrscr();
printf ("Porgramul elimina spatiile dintr-o linie de text.\n");
printf ("Introduceti linia (sirul de caractere):\n");
gets (sir1);
j = 0; /* contorul de caractere pentru sirul nou, fara spatii */
for( i = 0 ; i <= (strlen(sir1)) ; i++)
{
if (sir1[i] != ' ')
{
sir[j] = sir1[i];
j++;
}
}
sir[j] = '\0';
printf("Sirul fara spatii:\n\"%s\"\n",sir);
}
________________________________________________________________________
/* Programul inverseaza tipul de caractere dintr-un text:
de la litera mare la litera mica si invers */
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#define LIMITA 30
#define DIMENS 81
main()
{
void transforma ( char linie[] );
char text [LIMITA] [DIMENS];
int nr_linie =0 , i;
printf("\nProgramul inverseaza tipul de litere dintr-un text.\n");
printf ("Introduceti cel mult %d linii pentru transformare.\n", LIMITA);
printf ("Introducerea se termina cu ENTER, pe o linie noua.\n");
while ( nr_linie < LIMITA && gets(text[nr_linie]) != NULL &&
strcmp ( text[nr_linie], "") !=0 )
nr_linie ++;
for ( i = 0 ; i < nr_linie ; i++)
{
transforma ( text[i] );
puts ( text[i] );
}
}
void transforma ( char *ptr_car )
{
while ( *ptr_car != '\0' )
{
if ( isupper ( *ptr_car ) )
*ptr_car = tolower ( *ptr_car );
else if ( islower ( *ptr_car ) )
*ptr_car = toupper ( *ptr_car );
ptr_car++;
}
}
________________________________________________________________________
/* Programul numara cuvintele dintr-un text, citit de la consola;
textul se termina cu caracterul '#', la inceputul unei linii noi */
#include <stdio.h>
#define MAX_LINIE 80
int litera (char c)
{
if(( c>= 'a' && c <= 'z' ) || ( c >= 'A' && c <= 'Z' ))
return (1); /* daca este o litera */
else
return (0); /* daca nu este o litera */
}
int numara_cuvinte ( char linie[] )
{
int contor_cuv = 0, cuvant = 1, i = 0; /* cuvant=1, s-a terminat un cuvant */
while ( linie[i] != '\0' )
{
if( litera ( linie[i] ) )
{
if (cuvant)
{
contor_cuv ++;
cuvant = 0; /* a inceput un nou cuvant */
}
}
else
cuvant = 1;
i++;
}
return ( contor_cuv );
}
void citeste_linie ( char l_text[] )
{
int i = 0;
char c;
do
/*
sau in loc de do{ . . .}
{
/*
while (( l_text[i++] = getchar()) != '\n');
c = getchar();
/*
l_text [i-1] = '\0';
if (c != '\n' && i < MAX_LINIE)
{
l_text[i] = c;
i++;
}
} while (c != '\n');
l_text[i] = '\0'; /* pune marcajulul de sfarsit de sir de caractere */
}
*/
*/
*/
void main()
{
int sf_text = 0, total_cuv = 0;
char text[MAX_LINIE + 1];
printf("\nProgramul numara cuvintele dintr-un text, citit de la consola.\n");
printf ("Introduceti un text terminat prin '#' la inceputul unei linii.\n");
while ( !sf_text )
{
citeste_linie ( text );
if ( text[0] == '#' )
sf_text = 1;
else
total_cuv += numara_cuvinte (text);
}
printf ("\nNumarul total de cuvinte este %d\n", total_cuv);
}
________________________________________________________________________
/* Programul citeste si tipareste numele utilizatorului */
#include <stdio.h>
#include <string.h>
#include <conio.h>
#define INTREB "Cum te cheama ? "
#define SALUT "Salut ! "
void main ( )
{
char nume [50] ;
printf("\nProgramul citeste si tipareste numele utilizatorului.\n");
printf (INTREB);
scanf ("%s", nume);
printf (SALUT" %s ", nume);
printf ("\nNumele tau are %d litere, dar s-au rezervat %d locatii "
"de memorie.\n", strlen (nume), sizeof nume);

printf ("Propozitia \"%s\" are %d caractere ", INTREB, strlen(INTREB));
printf ("si ocupa %d octeti de memorie\n", sizeof (INTREB));
getch();
}
________________________________________________________________________
/*Programul afiseaza un tablou de caractere*/
#include <stdio.h>
void main(void) {
char salut [] = {'S', 'a', 'l', 'u', 't', '!'};
int i;
printf("\nProgramul afiseaza un tablou de caractere:\n");
for ( i =0; i < 6; ++i)
printf("\n");
}
________________________________________________________________________
/* nr_linii.c */
/* programul numara liniile introduse */
# include <stdio.h>
void main ( )
{
int car, nr_linii;
nr_linii = 0;
while ( ( car = getchar( ) ) != EOF)
if (car == '\n' )
++nr_linii;
printf ("numarul de linii introduse este: %d\n", nr_linii);
}
________________________________________________________________________
# include <stdio.h>
# include <conio.h>
# include <stdlib.h>
# include <string.h>
void main(void)
{
char sir[250],sir1[250];
int i,x,j,k;
clrscr();
printf("Programul insereaza blancuri dupa fiecare cinci caractere,\n"
"intr-un sir continuu de caractere (pana la primul spatiu alb).\n");
printf("Introduceti sirul:\n");
scanf("%s",&sir);
x=strlen(sir);
sir1[0]=sir[0];
j=1;
for(i=1;i<(x+1);i++)
{
k=i/5;
if((k*5)==i)
{
sir1[j]=' ';
j++;
}
sir1[j]=sir[i];
j++;
}
printf("\nSirul nou:\n%s\n",sir1);
}
________________________________________________________________________
/* Programul citeste un set de linii de text si afiseaza linia cea mai
lunga */
#include <stdio.h>
#include <conio.h>
#define MAXLINIE 1000
/* dimensiunea maxima a liniei */
int getline ( char linie [ ] , int maxlinie );
void copy ( char catre [ ] , char de_la [ ] );
main ( )
{
int lung ;
/* lungimea curenta a liniei */
int max ;
/* lungimea maxima determinata */
char linie [ MAXLINIE ];
/* linia curenta */
char cea_mai_lunga [ MAXLINIE ];
/* linia cea mai lunga, salvata */
clrscr();
printf("\nProgramul citeste un set de linii de text si afiseaza linia "
"cea mai lunga.\nTextul se va termina cu CTRL-Z, ENTER."
" Introduceti liniile de text:\n");
max = 0;
while ( ( lung = getline ( linie , MAXLINIE ) ) > 0 )
if ( lung > max ) {
max = lung ;
copy ( cea_mai_lunga , linie ) ;
}
if ( max > 0 )
/* aceasta a fost cea mai lunga linie */
printf ("%s", cea_mai_lunga );
return 0 ;
}
/* getline : citeste o linie in s, si returneaza lungimea */
int getline ( char s[ ] , int lim )
{
int c, i;
for ( i = 0 ; (i< lim - 1) && (c = getchar ()) != EOF && c!='\n'; ++i )
s[ i ] = c ;
if ( c == '\n' ) {
s[ i ] = c;
++i ;
}
s[ i ] = '\0' ;
return i ;
}
/* copy: copiaza ` de_la ` ` catre ` ; presupune ca este suficient de mare */
void copy ( char catre[ ] , char de_la [ ] )
{
int i ;
i=0;
while ( ( catre [ i ] = de_la [ i ] ) != '\0')
++ i ;
}
________________________________________________________________________
/* Programul numara caractere, cuvinte, linii */
# include <stdio.h>
# define STOP '#'
# define DA 1
# define NU 0
void main ( )
{
char c;
/* contine caracter */
long nr_car=0L;
/* numara caracterele */
int nr_linii=1;
/* numara liniile */
int nr_cuv=0;
/* numara cuvintele */
int cuvant=NU;
/* ==DA, daca c este un cuvant */
printf("\nProgramul numara caractere, cuvinte, linii dintr-un text, "
"ce se termina cu \"#\".\nIntroduceti textul:\n");
while ((c=getchar( ))!=STOP)
{
nr_car++;
/*numara caracterul */
if (c=='\n')
nr_linii++;
/* numara liniile */
if (c!=' ' && c!='\n' && c!='+' && cuvant==NU)
{
cuvant=DA;
/*incepe un nou cuvant */
nr_cuv++;
/* numara cuvintele */
}
if ((c==' ' || c=='\n' || c== '+') && cuvant==DA)
cuvant=NU;
/* sfarsitul cuvantului */
}
printf ("%ld caractere / %d cuvinte / %d linii \n", nr_car, nr_cuv, nr_linii);
}
________________________________________________________________________
/* Programul numara liniile, cuvintele si caracterele introduse */
#include <stdio.h>
#define IN 1
/* este un caracter din interiorul unui cuvant*/
#define OUT 0 /* este in afara unui unui cuvant */
void main ( )
{
int car, nr_linii, nr_cuvinte, nr_car, stare;
stare = OUT;
nr_linii = nr_cuvinte = nr_car = 0;
printf("\nProgramul numara liniile, cuvintele si caracterele dintr-un text,\n"
"ce se termina cu CTRL-Z, ENTER.\nIntroduceti textul:\n");
while ( ( car = getchar ( ) ) != EOF )
{
++ nr_car;
if ( car == '\n' )
++nr_linii ;
if(car==' '||car=='\n'||car=='\t'||car==','||car=='.'||car==';')
stare = OUT ;
else if ( stare == OUT ) {
stare = IN ;
++ nr_cuvinte;
}
}
printf ("\nNumar de linii/ cuvinte/ caractere: %d, %d, %d.\n",
nr_linii , nr_cuvinte, nr_car);
}
________________________________________________________________________
/* Programul realizeaza inventarul cartilor dintr-o biblioteca
*/
#include <stdio.h>
#include <string.h>
#include <conio.h>
/* Numarul maxim de caractere pentru : titluri, autori,
si numarul maxim de carti
*/
#define MAXTIT 150
#define MAXAUT 50
#define MAXCARTI 100
/* STOP = sirul vid de caractere, care va termina introducerea datelor
*/
#define STOP ""
struct s_carte
{
char titlu [ MAXTIT ];
char autor [ MAXAUT ];
double
pret;
};
void main()
{
struct s_carte carte [ MAXCARTI ]; /* tablou cu structura de carte */
int
index , contor = 0;
double val;
clrscr();
printf("\nProgramul realizeaza inventarul cartilor dintr-o biblioteca.\n");
printf ("Introduceti titlurile cartilor.\n");
printf ("Pentru oprire se va tasta RETURN, la inceputul unei linii.\n");
printf ("\nTitlu carte:");
while ( contor < MAXCARTI && strcmp ( gets ( carte [contor].titlu ),
STOP ) != 0 )
{
printf ("Nume autor:");
gets (carte[contor].autor);
printf ("Pretul cartii:");
while ( getchar() != '\n'); /* sterge linia curenta */
carte[contor++].pret = val;
if ( contor < MAXCARTI )
printf ("\nTitlu carte:");
}
printf ("\nInventarul cartilor introduse :\n");
for ( index = 0 ; index < contor ; index++ )
printf ("\"%s\" de %s : $ %.2lf\n", carte[index].titlu,
carte[index].autor, carte[index].pret );
}
________________________________________________________________________
/* Programul listeaza studentii, dintr-o grupa, in ordinea descrescatoare
a mediilor; se citesc, pentru fiecare student: numele, notele si
se calculeaza media.
Se citesc datele respective pentru studentii dintr-un an.
Pentru listare nu se sorteaza vectorul studentilor dupa medii, ci se
parcurge vectorul studenti, se determina studentul ce are cea mai mare
medie si nu a fost inca listat; pentru fiecare student listat se
actualizeaza campul "afisat"; aceste campuri au fost initializate la
introducerea datelor, pentru fiecare student. Ciclul de listare va lua
sfarsit dupa ce s-au listat toti studentii din grupa respectiva. */
#include <stdio.h>
#include <string.h>
#include <conio.h>
#define MAXGR 5
#define MAXSTUD 25
#define MAXNOTE 12
#define MAXNUME 15
struct s_student
{
char nume [MAXNUME];
char prenume [MAXNUME];
int nota [MAXNOTE];
double media;
int afisat;
/* acest camp precizeaza daca studentul respectiv a fost listat */
};
struct s_grupa
{
char numeg [MAXNUME];
int nr_stud;
struct s_student stud [MAXSTUD];
};
struct s_an
{
char numean [MAXNUME];
int nr_grupe;
int nr_note;
struct s_grupa grupa [MAXGR];
};
void main()
{
struct s_an an;
int ig, is, im, imax, contor;
double medie, medmax;
char numegr [MAXNUME];
clrscr();
printf("\nProgramul listeaza clasamentul studentilor, dintr-o grupa,\n"
"specificata de utilizator.\nSe citesc, pentru fiecare grupa si "
"student:\n\t\tnumele, prenumele, notele si se calculeaza media.\n"
"Se citesc datele respective pentru toti studentii dintr-un an.\n");
printf ("Nume an:");
gets (an.numean);
printf("Numarul de note(materii):");
scanf("%d", &an.nr_note);
while ( getchar() !='\n'); /* sterge restul liniei */
printf ("Numar grupe:");
scanf ("%d", &an.nr_grupe); /* numarul de grupe din an */
while ( getchar() != '\n');
for ( ig = 0 ; ig < an.nr_grupe ; ig++)
{
printf ("\nNume grupa:"); /* numele grupei */
gets ( an.grupa[ig].numeg );
printf ("Numar studenti:"); /* numarul de studenti */

scanf ("%d", &an.grupa[ig].nr_stud);
for ( is = 0 ; is < an.grupa[ig].nr_stud ; is++)
{
/* citesc datele pentru fiecare sudent */
printf ("\nNume student (%d):", is+1);
gets ( an.grupa[ig].stud[is].nume );
printf ("Prenume student (%d):", is+1);
gets ( an.grupa[ig].stud[is].prenume );
medie = 0;
for ( im = 0 ; im < an.nr_note ; im++)
{
printf ("Materia (%d):", im+1);
scanf ("%d", &an.grupa[ig].stud[is].nota[im]);
medie += an.grupa[ig].stud[is].nota[im];
}
while ( getchar () != '\n');
an.grupa[ig].stud[is].media = medie/an.nr_note;
an.grupa[ig].stud[is].afisat =0; /* initializare camp 'afisat' */
}
}
printf ("\nGrupa de afisat:"); /* numele grupei de afisat */
gets ( numegr );
ig = 0; /* se determina, pe baza numelui, numarul grupei de afisat */
while ( ig < an.nr_grupe && strcmp(an.grupa[ig].numeg,numegr) != 0)
ig++;
if ( ig >= an.nr_grupe )
printf ("Eroare nume grupa \n"); /* nu avem ce afisa */
else
{
contor = 0; /* contorul numarului de studenti listati */
while ( contor < an.grupa[ig].nr_stud )
{
imax = 0; /* se determina indexul studentului cu media maxima */
while ( an.grupa[ig].stud[imax].afisat ) /* care nu a fost listat */
imax++;
medmax = an.grupa[ig].stud[imax].media; /* si media acestuia */
for ( is = imax+1 ; is < an.grupa[ig].nr_stud; is++)
if (( !an.grupa[ig].stud[is].afisat) && (medmax <
an.grupa[ig].stud[is].media))
{
imax = is;
medmax = an.grupa[ig].stud[is].media;
}
an.grupa[ig].stud[imax].afisat = 1; /* la afisare se actualizeaza */
printf ("%-*s %-*s %5.2lf\n", MAXNUME,

an.grupa[ig].stud[imax].nume, MAXNUME,
an.grupa[ig].stud[imax].prenume,
an.grupa[ig].stud[imax].media);
contor++;
}
}
}
________________________________________________________________________
#include <stdio.h>
#include <conio.h>
#include <string.h>
typedef struct {
char event[30];
char country[30];
int score;
}c;
int n,sport=-1,tab[100][2];
c count[100];
char *ev[30];
void main(void)
{
int i,j,k=-1,m,t,var;
printf("\nNumber of countries:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("\nSport event:");
scanf("%s",count[i].event);
printf("\nCountry:");
scanf("%s",count[i].country);
printf("\nScore:");
scanf("%d",&count[i].score);
}
for(i=0;i<n;i++)
if(!strcmp(count[i].event,"Box"))
printf("\n %s %s %d ",count[i].event,count[i].country,count[i].score);
printf("\nEVENT
COUNTRY
SCORE");
printf("\n------------------------------------------------");
for(i=0;i<n;i++)
{ for(j=0;j<=sport;j++)
if(!(strcmp(ev[j],count[i].event)))break;
if(j==(sport+1))ev[++sport]=count[i].event;
}
for(i=0;i<=sport;i++)
{
k=-1;
for(j=0;j<n;j++)
if(!(strcmp(count[j].event,ev[i]))){ tab[++k][0]=j;
tab[k][1]=count[j].score;
}
for(m=0;m<=k;m++)
for(t=0;t<k;t++)
if(tab[t][1]<tab[t+1][1]){ var=tab[t][1];
tab[t][1]=tab[t+1][1];
tab[t+1][1]=var;
var=tab[t][0];
tab[t][0]=tab[t+1][0];
tab[t+1][0]=var;
}
for(m=0;m<=k;m++)
printf("\n%s
%s
%d",count[tab[m][0]].event,count[tab[m]
[0]].country,count[tab[m][0]].score);
printf("\n------------------------------------------------");
}
getch();
}
________________________________________________________________________
#include <stdio.h>
#include <dos.h>
main()
{ void getdate ( struct date *dateblk);
void gettime ( struct time *timep);
struct date
{
int da_year;
char da_day;
char da_mon;
};
struct time
{
unsigned char ti_min;
unsigned char ti_hour;
unsigned char ti_hund;
unsigned char ti_sec;
};
struct date today;
struct time now;
printf("\nProgramul afiseaza data si ora curenta a sistemului:\n");
getdate(&today);
printf("Data de astazi este: %d/%d/%d\n",
today.da_day,today.da_mon,today.da_year);
gettime(&now);
printf("Ora este: %2d:%2d:%2d:%2d\n",
now.ti_hour,now.ti_min,now.ti_sec,now.ti_hund);
}
________________________________________________________________________
/* a) Sa se descrie tipurile punct si dreapta ca structuri;
b) Sa se defineasca o functie avind ca parametri doua drepte , un punct
si o variabila booleana , care stabileste daca cele doua drepte se
intersecteaza sau nu ; cele doua situatii sint separate de variabila
booleana . Daca se intersecteaza se calculeaza si returneaza punctul
de intersectie;
c) Sa se scrie un program care citeste datele pentru n drepte ( n<= 100 )
si afiseaza perechile de drepte paralele , iar pentru cele care se
intersecteaza coordonatele punctului de intersectie;*/
#include<stdio.h>
struct punct
{
float x,y;
};
struct dreapta
{
struct punct p1;
struct punct p2;

};
void intersectie(struct dreapta d1, struct dreapta d2,
struct punct &p, int &paralele)
//aceasta procedura primeste doua drepte si returneaza daca sunt paralele
//si daca nu punctul de intersectie
{
float p1,p2;
float b1,b2;
if(((d1.p1.x-d1.p2.x)==0)&&((d2.p1.x-d2.p2.x)==0))
{
paralele=1;
}
else
if(((d1.p1.x-d1.p2.x)==0)&&((d2.p1.x-d2.p2.x)!=0))
{
b2=d2.p2.x*(d2.p1.y-d2.p2.y)/(d2.p2.x-d2.p1.x)+d2.p2.y;
paralele=0;
p.x=d1.p1.x;
p.y=p2*p.x+b2;
}
else
if(((d1.p1.x-d1.p2.x)!=0)&&((d2.p1.x-d2.p2.x)==0))
{
paralele=0;
p.x=d2.p1.x;
p.y=p1*p.x+b1;
}
else
{
p1=(d1.p1.y-d1.p2.y)/(d1.p1.x-d1.p2.x);
p2=(d2.p1.y-d2.p2.y)/(d2.p1.x-d2.p2.x);
if(p1==p2)
{
paralele=1;
}
else
{
paralele=0;
p.x=(b1-b2)/(p2-p1);
p.y=p1*p.x+b1;
}
}
}
void main()
{
int nr_drepte,i,j;
int paralele;
struct dreapta d1,d2,d[100];
struct punct p;
float x1,y1,x2,y2;
printf("\nDeterminam pozitia relativa (paralele/intersectie)"
" pentru mai multe drepte.\n");
printf("Numarul de drepte: ");
scanf("%d",&nr_drepte);
for(i=0;i<nr_drepte;i++)
{
printf("Coordonate dreapta (%d) x1/y1, x2/y2 = ", i+1);
scanf("%f%f%f%f", &x1, &y1, &x2, &y2);
d[i].p1.x=x1; d[i].p1.y=y1; d[i].p2.x=x2; d[i].p2.y=y2;
}
for(i=0;i<nr_drepte-1;i++)
for(j=i+1;j<nr_drepte;j++)
{
intersectie(d[i],d[j],p,paralele);
if(paralele)
{
printf("\nDreptele %d si %d sunt paralele.",i+1,j+1);
}
else
{
printf("\nDreptele %d si %d nu sunt paralele.",i+1,j+1);
printf(" Punctul de intersectie: x=%.2f y=%.2f",p.x,p.y);
}
}
printf("\n");
}
________________________________________________________________________
/* Un experiment fizic este precizat prin numarul de determinari si valorile
masurate (numarul de determinari este maxim 100).
a) Sa se descrie structura experimentului folosind tipul structura;
b) Sa se defineasca o functie, avand ca parametru un experiment,care
calculeaza media aritmetica a masuratorilor nenule;
c) Sa se defineasca o functie, avand ca parametrii un experiment si
o valoare reala, care anuleaza (le face zero) toate determinarile
mai mari decat valoarea transmisa ca parametru;

d) Sa se scrie un program care citeste un experiment, calculeaza media
determinarilor (pct. b), anuleaza determinarile care depasesc
dublul mediei (pct. a) si calculeaza si afiseaza media
determinarilor ramase. */
#include <stdio.h>
struct ex{
int nr_determ;
int val_masurata[100];
};
void afisare(struct ex tt){
int i;
printf("Valori masurate:");
for (i=0;i<tt.nr_determ;i++)
{
printf(" %d",tt.val_masurata[i]);
}
printf("\n");
}
float medie_nenula(struct ex tt){
int i;
float medie=0;
int nr=0;
for(i=0;i<tt.nr_determ;i++)
{
if(tt.val_masurata[i]!=0)
{
medie=medie+tt.val_masurata[i];
nr++;
}
}
return(medie/nr);
}
void anulare(struct ex *tt,int u){
int i;
for (i=0;i<tt->nr_determ;i++)
{
if (tt->val_masurata[i]>u)
tt->val_masurata[i]=0;
}
}
void main(){
struct ex tt;
int i;
float med;
printf("\nProgramul citeste un experiment, calculeaza media determinarilor,\n"
"anuleaza determinarile care depasesc dublul mediei si calculeaza\n"
"si afiseaza media determinarilor ramase.\n");
printf("\nCate determinari are experimentul ? ");
scanf("%d",&tt.nr_determ);
for (i=0;i<tt.nr_determ;i++)
{
printf("Introduceti valoarea (%d) = ",i+1);
scanf("%d",&tt.val_masurata[i]);
}
med=medie_nenula(tt);
afisare(tt);
anulare(&tt,2*med);
printf("Valorile ramase dupa anularea celor mai mari decat dublul mediei:\n");
afisare(tt);
printf("Media masuratorilor ramase: %f\n",medie_nenula(tt));
}
________________________________________________________________________
/*
6. Se cosidera urmatoarele definiri de tipuri :
#define NR_MAX_ORASE 20
struct tip_oras
{ char nume[15];
char tara[15];
float nr_loc;
float supraf;
int vechime;
struct tip_oras orase[NR_MAX_ORASE] ;
Se cere sa se defineasca:
a) O functie de initializare a informatiilor referitoare la o lista
de orase ;
b) o functie care returneaza indicele orasului , din lista , a carui
populatie este cea mai apropiata ca numar de o valoare de tip nr_loc
transmisa ca parametru;
c) programul care citeste datele despre un numar de orase si listeaza
informatiile referitoare la orasul cu numarul de locuitori , cel mai
apropiat de un numar specificat.
d) procedurile care listeaza ordonat orasele dupa nume ,dupa numar de
locuitori , suprafata , vechime , tari ;
e) programul care afiseaza orasele in ordinea mentionata mai sus.
*/
#include <stdio.h>
#include <conio.h>
#include <math.h>
#define NR_MAX_ORASE 20
struct tip_oras
{
char nume[15];
char tara[15];
float nr_loc;
float supraf;
int vechime;
};
struct tip_oras orase[NR_MAX_ORASE] ;
void initializare(int nr_orase)
{
int i;
float suprafata, numar_loc;
for (i=0;i<nr_orase;i++)
{
printf("\nIntroduceti nume oras (%d) : ",i+1);
scanf("%s",orase[i].nume);
printf("Introduceti numele tarii careia ii apartine : ");
scanf("%s",orase[i].tara);
printf("Introduceti numarul de locuitori : ");
scanf("%f",&numar_loc);
orase[i].nr_loc = numar_loc;
printf("Introduceti suprafata: ");
scanf("%f",&suprafata);
orase[i].supraf = suprafata;
printf("Introduceti vechimea : ");
scanf("%d",&orase[i].vechime );
}
}
int indice( float pop, int nr_orase)
{
int j, ind_posibil;
long int posibil;
posibil=fabs(pop-orase[0].nr_loc);
ind_posibil=0;
for (j=1;j<nr_orase;j++)
{
if ( fabs (pop-orase[j].nr_loc) < posibil)
{
posibil=fabs (pop-orase[j].nr_loc);
ind_posibil=j;
}
}
return(ind_posibil);
}
main()
{
float pop_ceruta;
int i,nr_de_orase;
clrscr();
printf("\nIntroduceti numarul de orase: ");
scanf("%d",&nr_de_orase);
initializare(nr_de_orase);
printf("\nOrasele introduse sunt:\n");
for (i=0;i<nr_de_orase;i++)
{
printf("%s ",orase[i].nume);
}
printf("\nIntroduceti populatia care o cautati : ");
scanf("%f",&pop_ceruta);
i=indice(pop_ceruta,nr_de_orase);
printf("\nCel mai apropiat, ca populatie, este urmatorul oras:\n");
printf ("\n Orasul are indicele: %d ",i+1);
printf("\n Numele orasului este: %s",orase[i].nume);
printf("\n Numarul de locuitori este: %f",orase[i].nr_loc);
printf("\n Suprafata este: %f",orase[i].supraf );
printf("\n Vechimea este: %d ani",orase[i].vechime);
printf("\n Tara: %s\n",orase[i].tara);
}
________________________________________________________________________
/*
5. Se considera urmatoarele definiri de date :
#define DIM_MAX 100
struct tip_st_zbor
{ int numar_zbor;
char destinatie[15];
char data_plecare[10];
char companie[10];
float cost;
}
struct tip_st_zbor zbor[DIM_MAX];
Sa se defineasca :
a) o functie de initializare a informatiilor referitoare la
zborurile de pe un aeroport;
b) o functie care afiseaza numele companiilor ce au curse pe o anumita
ruta , datele zborurilor ,precum si costul acestora;

c) programul care citeste datele referitoare la zborurile de pe un
aeroport , numele orasului de destinatie ( sosire ) si afiseaza numele
companiilor si informatii referitoare la zbor , pentru ruta
specificata.
************************************************************************
*
*/
#include <stdio.h>
#include <string.h>
#include <conio.h>
#define DIM_MAX 100
struct tip_st_zbor
{ int numar_zbor;
char destinatie[15];
char data_plecare[10];
char companie[10];
float cost;
};
typedef struct tip_st_zbor ZBOR;
int n, i;
float temp;
ZBOR zbor[DIM_MAX];
void Initializare(ZBOR zbor[DIM_MAX], int n)
{
for (i=0; i<n; i++)
{
printf("Numarul zborului: ");
scanf("%d", &zbor[i].numar_zbor);
printf("Destinatie: ");
scanf("%s", zbor[i].destinatie);
printf("Data plecare: ");
scanf("%s", zbor[i].data_plecare);
printf("Compania: ");
scanf("%s", zbor[i].companie);
printf("Pret: ");
scanf("%f", &temp );
zbor[i].cost = temp;
}
}
void Afisare(ZBOR zbor[DIM_MAX], int n)
{
for (i=0; i<n; i++)
{
printf("%d - ", zbor[i].numar_zbor);
printf("%s - ", zbor[i].destinatie);
printf("%s - ", zbor[i].data_plecare);
printf("%s - ", zbor[i].companie);
printf("%f\n", zbor[i].cost);
}
}
void Afis(ZBOR zbor[DIM_MAX], int i)
{
printf("%d - ", zbor[i].numar_zbor);
printf("%s - ", zbor[i].destinatie);
printf("%s - ", zbor[i].data_plecare);
printf("%s - ", zbor[i].companie);
printf("%f\n", zbor[i].cost);
}
void Testare(ZBOR zbor[DIM_MAX], int n)
{
char cRuta[15];
printf("Dati destinatia avionului cautat:");
scanf("%s",cRuta);
for (i=0; i<n; i++)
if (strcmp(cRuta, zbor[i].destinatie)==0)
Afis(zbor, i);
}
void main()
{
clrscr();
printf("\nProgramul citeste informatiile referitoare la zborurile\n"
"de pe un aeroport (numar, data, compania, pret,..)\n"
"si listeaza aceste zboruri, dupa care listeaza numai zborurile\n"
"catre o anumita destinatie specificata de utilizator.\n");
printf("Dati numarul zborurilor: ");
scanf("%d",&n);
Initializare(zbor, n); /* Initializeaza vectorul de structuri */
printf("\n");
Afisare(zbor, n); /* Afiseaza toate elementele vectorului de structuri */
Testare(zbor, n); /* Daca avionul are o anumiota ruta, afiseaza datele..*/
getch();
}
________________________________________________________________________
/*
programul listeaza angajatii, unei firme, dupa tipul pregatirii:
- fara pregatire;
- cu scoala generala, pentru care se specifica numarul de clase;
- cu liceu : anul absolvirii liceului si media;
- cu facultate: universitatea, facultatea, anul abs. si media
*/
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <conio.h>
#define MAXNUME 20
#define MAXPERS 50
main()
{
enum pregatire
{ fara , scgen , liceu , facultate };
union u_studii
{
struct /* studii: facultate
*/
{
char nume_univ[MAXNUME];
char nume_facult[MAXNUME];
int
anf;
double mediaf;
} st_univ;
struct /*
studii: liceu */
{
int
anl;
double medial;
}
st_liceu;
int
nr_clase;
/* studii: scoala generala
*/
};
struct
{
char nume[MAXNUME];
char prenume[MAXNUME];
int
varsta, sex;
enum pregatire
preg;
union u_studii studii;
} angajat[MAXPERS];
enum pregatire sel_preg;
int
i, n;
char tip_pregatire[MAXNUME];
double val;
clrscr();
printf("\nProgramul listeaza angajatii, unei firme, dupa tipul pregatirii:\n"
"\t- fara pregatire;\n"
"\t- cu scoala generala, pentru care se specifica numarul de clase;\n"
"\t- cu liceu : anul absolvirii liceului si media;\n"

"\t- cu facultate: universitatea, facultatea, anul abs. si media.\n");
printf ("\nNumarul de angajati ai firmei este:");
scanf ("%d", &n);while(getchar() != '\n');
for ( i = 0 ; i < n ; i++ )
{
printf ("\nNume angajat(%d):",i+1);
gets ( angajat[i].nume );
printf ("Prenume angajat(%d):",i+1);
gets ( angajat[i].prenume );
printf ("Varsta : ");
scanf ("%d", &angajat[i].varsta);
printf ("Sex(0-femeie,1-barbat) : ");
scanf("%d", &angajat[i].sex); while( getchar() != '\n');
printf("Studii(fara, scoala generala, liceu, universitate):");
gets (tip_pregatire);
switch ( tip_pregatire[0] ) /* se ia doar primul caracter din tipul pregatirii */
{
case 'f':
case 'F':
angajat[i].preg = fara; break;
case 's':
case 'S':
angajat[i].preg = scgen;
printf("Numarul de clase:");
scanf ("%d", angajat[i].studii.nr_clase);
while(getchar()!='\n');
break;
case 'l':
case 'L':
angajat[i].preg = liceu;
printf ("Anul absolvirii liceului:");
scanf ("%d", &angajat[i].studii.st_liceu.anl);
printf ("Media de absolvire a liceului:");
angajat[i].studii.st_liceu.medial = val;
break;
case 'u':
case 'U':
angajat[i].preg = facultate;
printf ("Universiatatea:");
gets (angajat[i].studii.st_univ.nume_univ);
printf ("Facultatea:");
gets (angajat[i].studii.st_univ.nume_facult);
printf ("Anul absolvirii facultatii:");
scanf("%d", &angajat[i].studii.st_univ.anf);
printf ("Media de absolviria a facultatii:");
scanf("%lf", &val);
angajat[i].studii.st_univ.mediaf = val;
while( getchar() != '\n');

break;
};
}
printf ("Angajatii cu ce fel de pregatire doriti sa fie listati?\n");
gets (tip_pregatire); /* tipul de angajati ce se doreste a fi listati */
switch ( tip_pregatire[0] )
{
/* tiparire antet lista */
case 'f':
case 'F':
sel_preg = fara;
printf("Lista angajatilor fara pregatire:\n");
break;
case 's':
case 'S':
sel_preg = scgen;
printf("Angajatilor cu studii scoala generala(nr.clase):\n");
break;
case 'l':
case 'L':
sel_preg = liceu;
printf("Lista angajatilor cu studii liceul:\n");
break;
case 'u':
case 'U':
sel_preg = facultate;
printf("Lista angajatilor cu studii universitare:\n");
break;
};
for ( i = 0 ; i < n ; ++i )
if ( angajat[i].preg == sel_preg )
{
printf ("%-*s %-*s, varsta: %2d, sex:", MAXNUME, angajat[i].nume,
MAXNUME, angajat[i].prenume, angajat[i].varsta);
switch ( angajat[i].sex )
/* tiparire sex */
{
case 0 :printf("femeie\n");
break;
case 1 :printf("barbat\n");
break;
}
}
}
________________________________________________________________________
/*
programul listeaza angajatii, unei firme, dupa tipul pregatirii:
- fara pregatire;
- cu scoala generala, pentru care se specifica numarul de clase;
- cu liceu : anul absolvirii liceului si media;
- cu facultate: universitatea, facultatea, anul abs. si media
*/
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <conio.h>
#define MAXNUME 20
#define MAXPERS 50
main()
{
enum pregatire
{ fara , scgen , liceu , facultate };
union u_studii
{
struct /* studii: facultate
*/
{
char nume_univ[MAXNUME];
char nume_facult[MAXNUME];
int
anf;
double mediaf;
} st_univ;
struct /*
studii: liceu */
{
int
anl;
double medial;
}
st_liceu;
int
nr_clase;
/* studii: scoala generala
*/
};
struct
{
char nume[MAXNUME];
char prenume[MAXNUME];
int
varsta, sex;
enum pregatire
preg;
union u_studii studii;
} angajat[MAXPERS];
enum pregatire sel_preg;
int
i, n;
char tip_pregatire[MAXNUME];
double val;
clrscr();
printf("\nProgramul listeaza angajatii, unei firme, dupa tipul pregatirii:\n"
"\t- fara pregatire;\n"
"\t- cu scoala generala, pentru care se specifica numarul de clase;\n"
"\t- cu liceu : anul absolvirii liceului si media;\n"
"\t- cu facultate: universitatea, facultatea, anul abs. si media.\n");
printf ("Numarul de angajati ai firmei este:");
scanf ("%d", &n);while(getchar() != '\n');
for ( i = 0 ; i < n ; i++ )

{
printf ("Nume angajat(%d):",i+1);
gets ( angajat[i].nume );
printf ("Prenume angajat(%d):",i+1);
gets ( angajat[i].prenume );
printf ("Varsta : ");
scanf ("%d", &angajat[i].varsta);
printf ("Sex(0-femeie,1-barbat) : ");
scanf("%d", &angajat[i].sex); while( getchar() != '\n');
printf("Studii(fara, scoala generala, liceu, universitate):");
gets (tip_pregatire);
switch ( tip_pregatire[0] ) /* se ia doar primul caracter din tipul pregatirii */
{
case 'f':
case 'F':
angajat[i].preg = fara; break;
case 's':
case 'S':
angajat[i].preg = scgen;
printf("Numarul de clase:");
scanf ("%d", angajat[i].studii.nr_clase);
while(getchar()!='\n');
break;
case 'l':
case 'L':
angajat[i].preg = liceu;
printf ("Anul absolvirii liceului:");
scanf ("%d", &angajat[i].studii.st_liceu.anl);
printf ("Media de absolvire a liceului:");
angajat[i].studii.st_liceu.medial = val;
break;
case 'u':
case 'U':
angajat[i].preg = facultate;
printf ("Universiatatea:");
gets (angajat[i].studii.st_univ.nume_univ);
printf ("Facultatea:");
gets (angajat[i].studii.st_univ.nume_facult);
printf ("Anul absolvirii facultatii:");
scanf("%d", &angajat[i].studii.st_univ.anf);
printf ("Media de absolviria a facultatii:");
scanf("%lf", &val);
angajat[i].studii.st_univ.mediaf = val;
while( getchar() != '\n');
break;
};
}
printf ("Angajatii cu ce fel de pregatire doriti sa fie listati?\n");
gets (tip_pregatire); /* tipul de angajati ce se doreste a fi listati */
switch ( tip_pregatire[0] )
{
/* tiparire antet lista */
case 'f':
case 'F':
sel_preg = fara;
printf("Lista angajatilor fara pregatire:\n");
break;
case 's':
case 'S':
sel_preg = scgen;
printf("Angajatilor cu studii scoala generala(nr.clase):\n");
break;
case 'l':
case 'L':
sel_preg = liceu;
printf("Lista angajatilor cu studii liceul:\n");
break;
case 'u':
case 'U':
sel_preg = facultate;
printf("Lista angajatilor cu studii universitare:\n");
break;
};
for ( i = 0 ; i < n ; ++i )
if ( angajat[i].preg == sel_preg )
{
printf ("%-*s %-*s, varsta: %2d, sex:", MAXNUME, angajat[i].nume,
MAXNUME, angajat[i].prenume, angajat[i].varsta);
switch ( angajat[i].sex )
/* tiparire sex */
{
case 0 :printf("femeie\n");
break;
case 1 :printf("barbat\n");
break;
}
}
}
________________________________________________________________________
/* Program - exemplu de alocare dinamica de memorie; se aloca dinamic
memorie pentru 40 de valori intregi, care sunt apoi initializate,
tiparite, dupa care se elibereaza memoria alocata*/
#include <stdio.h>
#include <stdlib.h> /* sau alloc.h */
main( )
{ int *ptr, val;
ptr = (int*) malloc (40*sizeof (int) );
printf("\nProgramul aloca dinamic memorie pentru 40 de valori intregi,\n"
"care sunt apoi initializate si tiparite,\n"

"dupa care se elibereaza memoria alocata:\n");
if (!ptr)
/*testam daca s-a alocat memorie */
printf ("Memorie plina! Eroare de alocare! \n");
else
{
for ( val = 0 ; val < 40 ;++val )
*(ptr + val) = val + 1;
for ( val = 0 ; val < 40 ; ++val)
printf ("%4d", *(ptr + val) );
free ( ptr);
printf("\n\n");
}
}
________________________________________________________________________
/* Programul citetse un sir de caractere (max. 80) si
afiseaza sirul, numai dupa primul spatiu */
#include <stdio.h>
void main ( )
{
char s[80];
char *ptrc=s;
int i;
printf("\nProgramul citeste un sir de caractere dintr-o linie de text si\n"
"afiseaza numai carterele de dupa primul spatiu.\n");
printf ("Introduceti un sir de caractere:\n");
gets(s); /* citeste un sir de caractere pana cand se tasteaza '\n' */
/* se determina primul spatiu sau sfarsit de sir */
if ( *ptrc )
{
while ( *ptrc != ' ' && *ptrc )
ptrc++;
if ( *ptrc == ' ' )
ptrc++;
printf("\nSirul de caractere de dupa primul spatiu:\n");
puts( ptrc );
}
else
printf("Sir vid de caractere.\n");
}
________________________________________________________________________
/* Programul citetse un sir de caractere (max. 80) si
afiseaza sirul, numai dupa primul spatiu */
#include <stdio.h>
void main ( )
{
char s[80];
char *ptrc;
int i;
printf("\nProgramul citeste un sir de caractere, dintr-o linie de text si\n"
"afiseaza numai carterele de dupa primul spatiu.\n");
printf ("Introduceti un sir de caractere:\n");
gets(s); /* citeste un sir de caractere pana cand se tasteaza '\n' */
/* se determina primul spatiu sau sfarsit de sir */
if ( s[0] )
{
for ( i = 0 ; s[i] && s[i] != ' '; i++);
ptrc = &s[i+1];
printf("\nSirul de caractere de dupa primul spatiu:\n");
printf ("%s\n",ptrc);
/* sau puts (ptrc), tipareste sirul de dupa primul blanc */
}
else
printf("Sir vid de caractere.\n");
}
________________________________________________________________________
/* Programul afiseaza zilele saptamanii, dintr-un tablou de
pointeri la siruri de caractere (zilele sapamanii) */
#include <stdio.h>
main()
{
int i;
char *zile[] = {"Luni", "Marti", "Miercuri", "Joi", "Vineri",
"Sambata","Duminica"};
/* tiparim zilele saptamanii */
printf("\nProgramul afiseaza zilele saptamanii, dintr-un tablou de\n"
"pointeri la siruri de caractere (zilele saptamanii):\n");
for ( i = 0 ; i < 7 ; i++ )
printf("%-10s",zile[i]);
printf("\n");
}
________________________________________________________________________
/* Programul construieste, apoi tipareste, o lista de valori intregi,
de tip coada */
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
struct intrare
{
int
valoare;
struct intrare *urmator;

};
struct intrare *start, *ptr_lista;
int valoare;
start = NULL;
clrscr();
printf("\nProgramul construieste, apoi tipareste,\n"
"o lista de valori intregi, de tip coada.\n");
printf ("Introduceti un sir de valori intregi, terminat cu 0.\n");
printf ("Valoare:");
scanf ("%d", &valoare);
while ( valoare )
{
if ( start == NULL )
{
start = ( struct intrare * ) malloc( sizeof (struct intrare ));
/* se poate utiliza si functia NEW in loc de MALLOC */
start-> valoare = valoare;
start-> urmator = NULL;
ptr_lista = start;
}
else
{
ptr_lista ->urmator=(struct intrare*)malloc(sizeof(struct intrare));
if ( ptr_lista -> urmator != NULL ) /* se adauga la lista */
{
ptr_lista = ptr_lista -> urmator;
ptr_lista -> valoare = valoare;
ptr_lista -> urmator = ( struct intrare* ) NULL;
}
else
exit (0);
}
printf ("Valoare:");
scanf ("%d", &valoare);
}
/* afisare lista */
ptr_lista = start;
/* initializare adresa de inceput a listei */
if ( ptr_lista != NULL )
{
printf("Lista de numere (de tip coada) este:\n");
do
{
if (wherex() > 70) printf("\n-> ");
/* daca s-a ajuns cu tiparirea peste coloana 70
se trece pe linia urmatoare */
printf ("%d -> ", ptr_lista -> valoare);

ptr_lista = ptr_lista -> urmator;
} while ( ptr_lista != NULL );
printf ("NULL\n");
}
else
printf ("Lista vida ( NULL )\n");
}
________________________________________________________________________
/* Programul copiaza un sir de la sursa la destinatie,
utilizand pentru copiere pointeri */
#include <stdio.h>
void main ( )
{
char sir_sursa []= {"Acesta este sirul de copiat"};
char sir_dest[50];
char *de_la , *catre ;
printf("\nProgramul copiaza un sir de la sursa la destinatie,\n"
"utilizand un pointer. Sirul de copiat este:\n");
printf("\"%s\"\n",sir_sursa);
de_la = sir_sursa;
catre = sir_dest;
while ( *de_la )
/* sau for (;*de_la!='\0';++de_la,++catre) */
* catre ++ = *de_la++;
/*
*catre = +de_la;
*/
* catre = '\0';
/* *catre ='\0';
*/
printf ("Sirul destinatie (copiat) este : \"%s\"\n", sir_dest);
}
________________________________________________________________________
/* Programul afiseaza continutul memoriei, incepand de la o adresa
specificata de utilizator (adresa relativa, adresa de segment este cea
continuta de registrul DS); afisarea ia sfarsit cand se introduce de la
tastatura sfarsit de fisier (CTRL-Z) */
#include <stdio.h>
void main()
{
unsigned int start, adr_seg = _DS;
int
n, e = 1, afis_adr_pag =1;
char *p;
printf("\nProgramul afiseaza continutul memoriei ,\n"
"incepand de la o adresa specificata de utilizator\n"
"(adresa relativa, adresa de segment este cea continuta "
"de registrul DS)\n"
"Afisarea ia sfarsit cand se introduce de la tastatura"
" sfarsit de fisier (CTRL-Z)\n");
printf ("Adresa relativa (adr. seg. este cea din registrul DS),"
"\nde start a zonei de memorie afisata:");
scanf ("%x", &start);

while ( getchar() !='\n');
p = ( char *) start;/* valoarea este transformata in pointer la tipul char*/
for (n = 1 ;
; n++, p++)
{if ( afis_adr_pag ) /* s-a afisat adresa de inceput a paginii ? */
{printf("Adresa de inceput a paginii afisate este"
"(Sf. afisare=CTRL-Z): %p:%p\n", adr_seg, p );
afis_adr_pag = 0;
};
printf ("%04X ", *p ); /* afisarea se face in hexazecimal */
if ( ! ( n % 8 ) )
{
e++; /* variabila e contorizeaza numarul de linii pe ecran */
printf("\n") ; /* si se trece pe o linie noua */
};
if ( ! ( e % 24 ) && ! ( n % 8 ) )
{e=1; /* la fiecare ecran se va tipari din nou adresa zonei*/
afis_adr_pag = 1; /* curenta a zonei de memorie afisata */
if ( getchar() == EOF ) /* se testeaza daca s-a introdus
caracterul de sfarsit CTRL-Z, ENTER*/
break;
/* de sfarsit listare memorie */
}
}
}
________________________________________________________________________
/* Programul afiseaza continutul memoriei, incepand de la o adresa
(segment:offset) specificata de utilizator; afisarea ia sfarsit cand
se introduce de la tastatura sfarsit de fisier (CTRL-Z) */
#include <stdio.h>
#include <dos.h>
void main()
{
unsigned int start, seg, off;
int
n, e = 1, afis_adr_pag =1;
printf("\nProgramul afiseaza continutul memoriei ,\n"
"incepand de la o adresa specificata de utilizator\n"
"(adresa segment : adresa relativa)\n"
"Afisarea ia sfarsit cand se introduce de la tastatura"
" sfarsit de fisier (CTRL-Z)\n");
printf ("Adresa de start (segment:offset) a zonei de memorie afisata:\n");
printf("Segment:Offset=");
scanf ("%x:%x", &seg,&off);
while(getchar() !='\n');
for (n = 1 ;
; n++, off++)
{if ( afis_adr_pag ) /* s-a afisat adresa de inceput a paginii ? */
{printf("Adresa de inceput a paginii afisate este"
"(Sf. afisare=CTRL-Z) :%p:%p\n", seg, off);

afis_adr_pag = 0;
};
printf ("%04X ", peek(seg,off));/*afisarea se face in hexazecimal*/
if ( ! ( n % 8 ) )
{
e++; /* variabila e contorizeaza numarul de linii pe ecran */
printf("\n") ; /* si se trece pe o linie noua */
};
if ( ! ( e % 24 ) && ! ( n % 8 ) )
{e=1; /* pt. fiecare ecran se va tipari din nou adresa */
afis_adr_pag = 1; /* curenta a zonei de memorie afisata */
if ( getchar() == EOF ) /* se testeaza daca s-a introdus
caracterul de sfarsit CTRL-Z, ENTER */
break;
/* de sfarsit listare memorie */
}
}
}
________________________________________________________________________
/* Programul exemplifica operatii cu pointeri */
#include <stdio.h>
main ( )
{
static int vect [3] = { 100, 200, 300 };/* vector este initializat cu aceste valori */
int * ptr1 , * ptr2 ; /* se vor utiliza doi pointeri pentru exemplificare */
ptr1 = vect ; /* sau ptr1=&vect[0], ptr1=&vect, atribuirea unei adrese de la pointer*/
ptr2 = &vect [2] ; /* sau ptr2 = vect+2 */
printf("\nExemplificarea operatiilor cu pointeri:\n");
printf("Cei doi pointeri (ptr1, ptr2) sunt initializati cu adresele:\n"
"primului respectiv ultimului element dintr-un vector cu 3 elem.\n");
printf ("ptr1 = %p (=%u), *ptr1 = %d, &ptr1 = %p (=%u)\n",
ptr1, ptr1, *ptr1, &ptr1, &ptr1);
/* valorile continute : ptr1 , referita de ptr1 si adresa lui ptr1 */
ptr1++ ; /* incrementare pointer */
printf("Incrementare pointer:\n");
++ptr2 ; /* avansat dupa tabloul definit , vect*/
printf("Incrementare pointer ce refera ultima valoare din tablou:\n");
ptr2 , ptr2, *ptr2 , &ptr2, &ptr2);
/* scadere intre doi pointeri , de acelasi tip*/
printf("Diferenta dintre cei doi pointeri:\n");
printf ("ptr2-ptr1 = %u\n" , ptr2-ptr1);}
/* Programul utilizeaza un pointer pentru a referi o structura */

#include <stdio.h>
#define LUNG 20
struct s_nume {
char nume [LUNG];
char prenume [LUNG];
};
struct tip {
struct s_nume apel;
int varsta ;
char ocupatie [LUNG] ;
float venit ;
};
void main ( )
{
static struct tip persoana [2]={
{{"Ionescu ", "Ilie"} , 30,"inginer",150.0},
{{"Georgescu ", " George "} ,35 , "profesor" , 130.0}
};
struct tip *el ; /* pointer la structura */
printf("\nProgramul utilizeaza pointeri pentru referirea unei structuri.\n");
el = &persoana [0];/* sau el = persoana, initializam poinerul */
printf ("adresa pointer #1:%p (=%u), adr. pointer #2:%p (=%u)\n",
el, &persoana[0], el +1, &persoana[1]);
printf("Valorile referite de cei doi pointeri sunt:\n");
printf("%s,%s,%d ani, ocupatie :%s, venit: %5.2f\n",
el -> apel.nume, el -> apel.prenume,
el -> varsta, el -> ocupatie, el->venit);
el ++;
printf ("%s%s,%d ani, ocupatie :%s, venit: %5.2f\n",
el -> apel.nume, el -> apel.prenume,
el -> varsta, el -> ocupatie, el -> venit);
}
________________________________________________________________________
/* Exemplu de utilizare de pointer la pointer, adica dubla indirectare */
#include <stdio.h>
void main( )
{
int x, *p, **q;
x = 10;
p = &x;
q = &p;
printf("\nExemplificare dubla indirectare (pointer la pointer):\n");
printf ("adresa pointer = %p (%u)\ncontinut pointer = %p (%u)\n"
"valorea referita (dubla dereferentiere): %d\n", q, q, *q, *q, **q);
/*tipareste valoarea lui x referita indirect de q*/}
/* Programul exemplifica utilizarea unui pointer la un caracter */

#include <stdio.h>
void main ( )
{
char car = 'c' ;
char *ch_ptr = &car ; /* ch_ptr e initializat cu adresa variabilei car */
printf("\nExemplificare pointer la caractere:\n");
printf("Valoare continuta de pointer : %p (%u)\n",
ch_ptr, ch_ptr);
printf("valoare caracter: valoarea referita de pointer:\n");
printf("%10c%25c\n", car , *ch_ptr );
car = '?' ;
printf ("%10c%25c\n" , car , *ch_ptr);
*ch_ptr = '+';
printf ("%10c%25c\n" , car , *ch_ptr) ;
}
________________________________________________________________________
/* Program pentru exemplificare utilizare pointeri */
#include <stdio.h>
void main ( )
{
int numar = 10 , x;
int *int_ptr;
int_ptr = &numar;
x = *int_ptr; /* x ia valoarea referita de int_ptr, adica 10 (numar) */
printf("\nProgram simplu exemplificare utilizare pointeri:\n");
printf ("numar = %i , x =% i\n", numar , x );
printf("valoarea referita de pointer: %i\n", *int_ptr);
printf("valoarea (adresa) continuta de pointer: %p (%u)\n",
int_ptr, int_ptr);
}
________________________________________________________________________
/* Program ce defineste o structura ce contine pointeri */
#include <stdio.h>
void main ( )
{
struct int_ptr
{
int *p1 ; /* se defineste o structura ce contine */
int *p2 ; /* doi pointeri */
};
struct int_ptr ptr ;
int i1 = 1000, i2;
printf("\nExemplificare structura ce contine doi pointeri.\n");
ptr.p1 = &i1;
ptr.p2 = &i2;
*ptr.p2 = i1-100;
printf("Valorile continute de structura (cei doi pointeri):\n");
printf("ptr.p1 = %p(%u), ptr.p2 = %p(%u)\n",ptr.p1, ptr.p1,
ptr.p2, ptr.p2);
printf("Valorile referite de cele doua variabile si de cei doi "
"pointeri\n(initilaizati cu adresele lor):\n");
printf ("i1 = %i ; *ptr.p1 = %i\n", i1, *ptr.p1);
printf ("i2 = %i ; *ptr.p2 = %i\n", i2, *ptr.p2);
}
________________________________________________________________________
/* Programul insumeaza elementele unui vector utilizand un pointer
pentru a referi elementele vectorului*/
#include <stdio.h>
void main ( )
{
int valori [10] = { 3,7, -9, 5, 18, 35, -11, 100, -225, 77 };
int sum = 0 , * ptr ;
printf("\nProgramul insumeaza elementele unui vector utilizand un pointer\n"
"pentru a referi elementele vectorului.\n");
int * ptr_sfarsit = valori + 10 ;
printf("Valorile componentelor vectorului sunt:\n");
for ( ptr = valori ; ptr < ptr_sfarsit ; ++ ptr )
{
printf("%5d",*ptr);
sum += *ptr ;
}
printf ("\nSuma valorilor este: %i.\n" , sum ) ;
}
________________________________________________________________________
/* Programul calculeaza suma elementelor de pe diagonala principala a
unei matrici, utilizand pentru adresarea elementelor matricii un pointer,
initializat pentru fiecare linie, cu adresa de inceput a liniei resp. */
#include <stdio.h>
#include <conio.h>
void main()
{
int vect[10][10];
int suma = 0, *ptr, n, i, j;
clrscr();
printf ("Programul calculeaza suma elementelor de pe diagonala principala\n"
"utilizand pentru adresare un pointer initializat la fiecare\n");
printf("ciclu cu adresa de inceput a liniei respective\n");
printf ("Dimensiune matrice(patrata):");
scanf ("%d", &n);
for ( i = 0 ; i < n ; i++)
for ( j = 0 ; j < n ; j++)
{
printf ("vect[%d][%d]=", i+1, j+1);
scanf ("%d", &vect[i][j]);
}
for ( i = 0 ; i < n ; i++)
{
ptr = vect[i];
suma += *(ptr+i);
}
printf ("Suma= %d \n", suma);
}
________________________________________________________________________
/*
Exemplificarea operatiilor cu pointeri */
#include<stdio.h>
main()
{
int vector[3]={100,200,300};
int *ptr1,*ptr2;
ptr1=vector; /* sau ptr1=&vector[0] sau ptr1=&vector */
ptr2=&vector[2]; /* sau ptr2=vector+2 */
printf("\nExemplificare utilizare pointeri.\n");
printf("Initializare pointeri cu adresele:\nprimului, respectiv ultimului"
" element din vector\n");
printf("Valoare prim element din vector, val. referita de pointer:\n");
printf("Vector[0]=%d, *ptr1=%d\n",vector[0],*ptr1);
printf("Adresa pointer si valoarea continuta de primul pointer:\n");
printf("&ptr1=%p (=%u), ptr1=%p (=%u)\n",&ptr1, &ptr1, ptr1, ptr1);
printf("Valoare ultim element din vector, val. referita de pointer:\n");
printf("Vector[2]=%d, *ptr2=%d\n",vector[2],*ptr2);
printf("Adresa pointer si valoarea continuta de al doilea pointer:\n");
printf("&ptr2=%p (=%u), ptr2=%p (=%u)\n",&ptr2, &ptr2, ptr2, ptr2);
ptr2++;
printf("Diferenta dintre cei doi pointeri, dupa incrementarea celui"
" de-al doilea:\n");
printf("ptr2-ptr1= %u\n",ptr2-ptr1); /* =3 */
}
________________________________________________________________________
/* numara cuvinte cheie C ; versiunea cu pointer */
/* deeclaratia externa keytab nu trebuie modificata,
dar main() si binsearch() trebuie modificate */
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#define MAXWORD 100
int getword (char * , int );
struct key *binsearch (char * , struct key * ,int );
main ( )
{
char word [MAXWORD];
struct key *p ;
while (getword (word ,MAXWORD ) != EOF )
if (isalpha(word[0] ))
if ( (p=binsearch(word, keytab,NKEYS) ) !=NULL)
p->count++;
for (p = keytab; p < keytab + NKEYS; p++)
if (p->count > 0)
printf ("%4d %s\n", p->count,p->word);
return 0;
}
/* binsearch: cauta cuvantul in tab[0] ... tab[n-1] */
struct key *binsearch (char *word , struct key *tab , int n)
{
int cond ;
struct key *low = &tab[0];
struct key *high = &tab[n];
struct key *mid;
while (low < high ) {
mid = low + ( high-low ) / 2;
if ((cond = strcmp (word, mid ->word) ) < 0)
high = mid;
else if (cond > 0)
low = mid + 1 ;
else
return mid ;
}
return NULL;
}
________________________________________________________________________
/* getint: citeste urmatorul numar intreg de la tastatura intr-un pointer
*pn; functia returneaza 0, daca apare eroare la citire numar. */
#include <ctype.h>
#include <stdio.h>
void ungetch (int);
int getint ( int *pn )
{
int c , semn;
while ( isspace (c = getchar ()) ) ; /* ignora spatiile albe */
if ( !isdigit (c) && c != EOF && c !='+' && c !='-' )
{
ungetch (c) ; /* nu este un numar */
return 0 ;
}
semn = (c =='-') ? -1: 1;
if (c=='+' || c== '-' )
c=getchar( ) ;
for ( *pn = 0; isdigit (c) ; c = getchar ( ) )
*pn = 10* *pn + (c - '0');
*pn *= semn ;
if (c !=EOF)
ungetch (c) ;
return c;
}
void main () {
int *ptr_nr;
printf("\nProgramul citeste un numar intreg caracter cu caracter.\n");
printf("Si face conversia la un numar intreg.\n");
printf("Citirea se face pana la un carcatre diferit de cifra, sau ENTER.\n");
printf("Numarul de convertit: ");
if (!getint(ptr_nr))
printf("Nu s-a introdus un numar corect.\n");
else
printf("Valoarea convertita: %d\n", *ptr_nr);
printf("Problema: "
"Scrieti o functie getfloat analoaga acestei functii (getint).\n");
}
________________________________________________________________________
/* Programul copiaza un sir de caractere, dintr-un vector intr-altul,
utilizand o functie: strcpy()-copiaza un sir de caractere, utilizand
un vector, pentru copiere */
#include <stdio.h>
void strcpy (char *s, char *t)
{
int i;
i=0;
while ((s[i] = t[i] ) != '\0')
i++;
}
main()
{
char sirs[200],sird[200];
printf("\nProgramul copiaza un sir de caractere, dintr-un vector intr-altul,\n"
"utilizand o functie.\n");
printf("Functia utilizeaza pentru copiere tablouri.\n");
printf("Introduceti un sir de caractere:\n");
gets(sirs);
strcpy( sird, sirs );
printf("Sirul copiat este:\n");

puts(sird);
}
________________________________________________________________________
utilizand o functie: strcpy()- versiune 2, care copiaza sirul de
caractere t in s, utilizand un pointer, pentru copierea sirului */
#include <stdio.h>
void strcpy (char *s, char *t)
{
while (( *s = *t ) !='\0' )
{
s++;
t++;
}
}
main()
{
"utilizand o functie.\n");
printf("Functia utilizeaza pentru copiere pointeri.\n");
gets(sirs);
puts(sird);
}
________________________________________________________________________
utilizand o functie: strcpy, versiunea a 3-a, care utilizeaza tot un
pointer */
#include <stdio.h>
void strcpy(char *s, char *t)
{
while (( *s++ = *t++) != '\0');
}
void main()
{
"utilizand o functie (bazata pe pointeri).\n");
gets(sirs);

puts(sird);
}
________________________________________________________________________
/* Programul calculeaza suma elementelor de pe diagonala principala
a unei matrici, utilizand pentru adresarea elementelor matricii
un pointer, initializat cu adresa de inceput a tabloului vect
*/
#include <stdio.h>
#include <conio.h>
void main()
{
int vect[10][10];
int suma = 0, *ptr, n, i, j;
clrscr();
printf("Programul calculeaza suma elementelor de pe diagonala "
"principala\nutilizand pentru adresare un pointer.\n");
printf("Dimensiune matrice(patrata):");
scanf("%d",&n);
for (i=0;i<n;i++)
for (j=0;j<n;j++)
{
printf("vect[%d][%d]=",i+1,j+1);
scanf("%d",&vect[i][j]);
};
ptr = &vect[0][0];
for (i=0;i<n;i++)
suma+=*(ptr+i*10 + i);
printf("Suma= %d \n",suma);
}
________________________________________________________________________
/* Programul urmator calculeaza distanta dintre doua puncte din planexemplu de utilizare 'typedef'*/
#include<stdio.h>
#include<math.h>
main()
{
typedef struct
{
double x,y;
} PUNCT;
PUNCT p1,p2;
double difx,dify;
printf("\nProgramul exemplifica utilizarea declaratiei \"typedef\"\n"
"si determina distanta dintre doua puncte din plan.\n");
printf("Coordonatele punctului A(x,y):\n");
scanf("%lf%lf",&p1.x,&p1.y);
printf("Coordonatele punctului B(x,y):\n");
scanf("%lf%lf",&p2.x,&p2.y);
difx=p1.x-p2.x;
dify=p1.y-p2.y;
printf("Distanta dintre cele doua puncte este: %5.2lf\n",
sqrt(pow(difx,2)+pow(dify,2)));
}
________________________________________________________________________
/* programul deseneaza un numar n de patrate (dreptunghiuri) incluse unele in altele */
#include <graphics.h>
#include <stdio.h>
int initializare( int *pxmax, int *pymax )
/*
se initializeaza modul grafic, prin
*/
{
int gdriver = DETECT, gmode, errorcode;
/* initializare variabile grafice si locale */
initgraph( &gdriver, &gmode, "");
/* citeste rezultatul initializarii */
errorcode = graphresult();
/* se testeaza daca a aparut o eroare, la initializare, si se
tipareste un mesaj de eroare impreuna cu codul de eroare */
if (errorcode != grOk)
{
printf("Eroare de initializare a modului grafic: %s\n",
grapherrormsg( errorcode ) );
printf("Apasati o tasata pentru a termina programul.");
getchar();
return(1);
}
/* se seteaza culoarea cu care se deseneaza la valoarea maxima */
setcolor(getmaxcolor());
/* se determina dimensiunile maxime ale ecranului */
*pxmax = getmaxx();
*pymax = getmaxy();
return 0;
}
void desencub ( int xss, int yss , int xdj , int ydj )
{
line ( xss , yss , xdj , yss );
line ( xss , yss , xss , ydj );
line ( xss , ydj , xdj , ydj );
line ( xdj , yss , xdj , ydj );
}
main()
{
int xmax, ymax, midx , midy , i;

char mesaj [25];
if ( initializare( &xmax, &ymax) == 0 )
{
for ( i = 0; i <= 20 ; i += 5)
desencub(11 *i, 6 *i, xmax - 11*i , ymax - 6*i);
/* se tiparesc dimensiunile ecranului, in modul grafic in centrul acestuia*/
midx = xmax/2;
midy = ymax /2;
moveto ( midx-80 , midy );
sprintf (mesaj,"dim ecran = %d * %d",xmax,ymax);
outtext (mesaj);
/* se deseneaza o linie pe diagonala principala a ecranului */
line(0, 0, xmax, ymax);
/* se inchide modul grafic */
getchar();
closegraph();
}
}
________________________________________________________________________
/* programul deseneaza un numar n de patrate (dreptunghiuri) incluse unele in altele */
#include <graphics.h>
#include <stdio.h>
int initializare( int *pxmax, int *pymax )
/*
se initializeaza modul grafic, prin
*/
{
int gdriver = DETECT, gmode, errorcode;
/* initializare variabile grafice si locale */
initgraph( &gdriver, &gmode, "");
/* citeste rezultatul initializarii */
errorcode = graphresult();
/* se testeaza daca a aparut o eroare, la initializare, si se
tipareste un mesaj de eroare impreuna cu codul de eroare */
if (errorcode != grOk)
{
printf("Eroare de initializare a modului grafic: %s\n",
grapherrormsg( errorcode ) );
printf("Apasati o tasata pentru a termina programul.");
getchar();
return(1);
}
/* se seteaza culoarea cu care se deseneaza la valoarea maxima */
setcolor(getmaxcolor());
/* se determina dimensiunile maxime ale ecranului */
*pxmax = getmaxx();
*pymax = getmaxy();
return 0;
}
void desencub ( int xss, int yss , int xdj , int ydj )
{
line ( xss , yss , xdj , yss );
line ( xss , yss , xss , ydj );
line ( xss , ydj , xdj , ydj );
line ( xdj , yss , xdj , ydj );
}
main()
{
int xmax, ymax, midx , midy , i;
char mesaj [25];
if ( initializare( &xmax, &ymax) == 0 )
{
for ( i = 0; i <= 20 ; i += 5)
desencub(11 *i, 6 *i, xmax - 11*i , ymax - 6*i);
/* se tiparesc dimensiunile ecranului, in modul grafic in centrul acestuia*/
midx = xmax/2;
midy = ymax /2;
moveto ( midx-80 , midy );
sprintf (mesaj,"dim ecran = %d * %d",xmax,ymax);
outtext (mesaj);
/* se deseneaza o linie pe diagonala principala a ecranului */
line(0, 0, xmax, ymax);
/* se inchide modul grafic */
getchar();
closegraph();
}
}
________________________________________________________________________
/* Programul afiseaza valorile unui numar intreg in toate bazele
de la 2 la 16, utilizand pentru conversia intr-o baza data,
ca parametru, o functie (conversie).
*/
#include <stdio.h>
#define LUNG_MAX 32
const int baza_max = 16;
void main()
{
long int numar;
int domeniu;
void conversie (long int valoare, int baza);
printf ("\n\nProgramul afiseaza valoarea unui numar intreg in "
"toate bazele de la 2 la 16.\n");
printf ("Valoarea de convertit:");
scanf ("%li", &numar);

for (domeniu=2 ; domeniu <= baza_max ; ++domeniu)
{
conversie (numar, domeniu);
printf (" /baza: %d \n", domeniu);
}
}
void conversie (long int valoare, int baza)
{
int index = 0;
if (valoare < 0)
{
printf("-");
valoare = -valoare;
}
do
{
if (valoare % baza < 10)
cifra[index] = '0' + valoare % baza;
else
cifra [index] = 'A' + valoare % baza-10;
index ++;
valoare /= baza;
} while (valoare > 0);
for (--index ; index >= 0; --index)
printf ("%c", cifra[index]);
}
________________________________________________________________________
/* Programul afiseaza un numar intreg intr-o baza ,folosind o
functie pentru conversia in baza specificata;
Se utilizeaza pentru transferul parametrilor intre functii:
VARIABILE GLOBALE
*/
#include <stdio.h>
int numar_convertit[16];
int numar, baza;
void main()
{
void citeste_numar_baza(void);
void conversie (void);
printf("\n\nProgramul converteste un intreg intr-o baza data.\n");
citeste_numar_baza();
if (baza < 2 || baza > 16)
{
printf ("Baza eronata ! Implicit baza = 10 \n");
baza = 10;
}
conversie();
}
void citeste_numar_baza(void)
{
printf ("Numar de convertit:");
printf ("In baza:");
scanf ("%d", &baza);
}
void conversie (void)
{
char cifra_baza[]={'0','1','2','3','4','5','6','7','8','9',
'A','B','C','D','E','F'};
int index=0;
if (numar < 0)
{
printf("-");
numar = -numar;
}
do
{
numar_convertit[index] = numar % baza;
numar /= baza;
index ++;
} while (numar != 0);
for ( --index ; index >= 0 ; --index )
printf ("%c", cifra_baza[numar_convertit[index]]);
printf ("\n");
}
________________________________________________________________________
/* Programul determina cel mai mare divizor comun pentru perechi
de numere intregi, introduse de la tastatura,
pana se introduce o valoare egala cu zero, utilizand o functie
*/
#include <stdio.h>
int cmmdc (int a,int b)
{
int rest;
while ( b != 0 )
{
rest = a % b;
a = b;
b = rest;
}
return ( a );
}
void main ()
{
int cmmdc (int a, int b);
int x, y;
printf("\n\nProgramul determina \"cel mai mare divizor comun\","
"pentru perechi de numere.\nProgramul ia sfarsit "
"cand unul dintre cele doua numere este 0.\n");
printf ("Introduceti doua numere (0=stop): ");
scanf ("%d%d", &x, &y);
while ( ( x*y ) != 0 )
{
printf ("Cel mai mare divizor comun este :%d\n", cmmdc (x,y));
printf ("Introduceti doua numere (0=stop): ");
scanf ("%d%d", &x, &y);
}
}
________________________________________________________________________
/* Programul calculeaza si afiseaza sumele partiale ale seriei:
1 + 1/2 + 1/3 + 1/4 + 1/5 + 1/6 + . . . + 1/n
afisarea se face sub forma unor numere rationale, de tip fractii ireductibile a/b.
Se utilizeaza doua functii:
- prima aduna doua fractii, si returneaza fractia rezultata;
- a doua simplifica o fractie, si o returneaza;
Transferul parametrilor se face prin referinta ( pointeri ).
*/
#include <stdio.h>
void main()
{
int nr_linii = 1;
long int numarator, numitor, i, n;
void aduna_fractii (long int *pa1,long int *pb1,long int pa2, long int pb2);
void simplifica (long int *pa, long int * );
printf("\n\nProgramul calculeaza si afiseaza sumele partiale ale seriei:\n"
"1 + 1/2 + 1/3 + 1/4 + 1/5 + 1/6 + . . . + 1/n\n"
"afisarea se face ca numar rational, "
"de tip fractie ireductibila a/b.\n");
printf("\nIntroduceti numarul n= ");
scanf("%li", &n);
numarator = 1;
numitor = 1;
printf("\n");
printf("%10li/%-10li ", numarator, numitor);
for ( i = 2 ; i <= n ; ++i)
{
aduna_fractii ( &numarator, &numitor, 1, i);

simplifica ( &numarator, &numitor);
printf("%10li/%-10li ", numarator, numitor);
nr_linii++;
/* numarul de fractii afisate pe o linie */
if (nr_linii % 3 == 0)
printf("\n");
}
}
void aduna_fractii ( long int *pa1, long int *pb1, long int a2, long int b2)
{
*pa1 = (*pa1)*b2+(*pb1)*a2;
*pb1 = (*pb1)*b2;
}
void simplifica (long int *pa, long int *pb)
{
long int ca, cb, rest;
ca = *pa;
cb = *pb;
while ( cb != 0 )
{
rest = ca % cb;
ca = cb;
cb = rest;
}
*pa /= ca;
*pb /= ca;
}
________________________________________________________________________
/* Programul manipuleaza o lista de tip coada, utilizand diferite functii:
initqueue - initializare coada;
addone - pozitia unui nou element in coada;
emptyqueue - determina daca coada este goala;
enqueue - introduce un nou element in coada;
dequeue - extrage un element din coada;
front - afiseaza primul element din coada;
error - afiseaza un mesaj de eroare;
Lista este implementata utilizand o structura ce contine:
un tablou de NAXQUEUE elemente, si doi intregi ce reprezinta:
pozitia primului, respectiv ultimului element din coada
*/
#include <stdio.h>
#include <conio.h>
#define MAXQUEUE 10
struct s_coada
{
int elem[MAXQUEUE];
int first, last;

};
void initqueue ( struct s_coada *q )
{
/* initializare coada goala */
q -> first = 1;
q -> last = MAXQUEUE;
};
int addone ( int i )
{
return ( i % MAXQUEUE + 1 );
}
int emptyqueue ( struct s_coada *q )
{
return ( addone (q->last) == q -> first );
};
void enqueue ( struct s_coada *q, int el )
{
void error ( char mesaj[] );
if ( addone ( addone ( q -> last )) == q -> first )
error ("queue full\n");
else
{
q -> last = addone ( q -> last );
q -> elem [ q -> last ] = el;
}
};
int dequeue ( struct s_coada *q )
{
int el_out;
if ( emptyqueue (q) )
error("queue full\n");
else
{
el_out = q -> elem [ q -> first ];
q -> first = addone ( q -> first );
return ( el_out);
}
};
int front ( struct s_coada *q)
{
if ( emptyqueue ( q ) )
error ("empty queue \n");
else
return ( q -> elem [ q -> first ] );
}
void error ( char mesaj[] )
{
printf ( "%s", mesaj );
}
void main ()
{
struct s_coada *coada;
int i , val;
char optiune[15];
clrscr();
printf("\nProgramul implementeaza o lista de tip coada.\n");
do {
printf ("Optiune (Init, Push, Extract, Top, Display, Finish):");
scanf("%15s", optiune );
switch ( optiune[0] )
{
case 'd':
case 'D': if ( ! emptyqueue ( coada ) )
{ for ( i = coada->first; i <= coada->last ; i++ )
printf("%d -> ", coada -> elem [ i ]);
printf("NULL\n");
}
else error ("empty queue\n");
break;
case 'i':
case 'I': clrscr();
printf("\nProgramul implementeaza o lista de tip coada.\n");
initqueue ( coada); break;
case 'p':
case 'P': printf("Elementul de introdus in coada:");
scanf ("%d", &val);
enqueue ( coada , val );
break;
case 'e':
case 'E':
if ( ! emptyqueue ( coada ) )
{
printf("extracted element: %d\n", front ( coada ));
dequeue ( coada );
};
case 't':
case 'T':
if ( ! emptyqueue ( coada ) )
printf("First element is :%d\n",front(coada));
else
printf("Empty queue\n");
break;
}
} while ( optiune [0] != 'f' && optiune[0] != 'F' );
}
________________________________________________________________________
/* Se construieste tabloul coeficientilor dezvoltarii binomului (a+b)^n
n coeficienti
0 1
1 1 1
2 1 2 1
3 1 3 3 1
4 1 4 6 4 1
5 1 5 10 10 5 1
......................
utilizand functii pentru calculul combinarilor (factorialelor)
*/
#include <stdio.h>
#include <conio.h>
unsigned long fact(n){
unsigned long i;
unsigned long res=1;
for(i=1;i<=n;i++)
{
res=res*i;
}
return(res);
}
unsigned long combinari(unsigned long n,unsigned long k){
return(fact(n)/(fact(k)*fact(n-k)));
}
void main(){
unsigned long i,a;
int n;
clrscr();
printf("\n\nProgramul construieste tabloul coeficientilor "
"dezvoltarii binomului (a+b)^n.\n");
do
{
printf("Introduceti n (max. 12): ");
scanf("%d",&n);
} while (n<0 || n>12);
printf(" n | Coeficenti\n");
for (i=0;i<=n;i++)
{
printf("%2d | ",i);
for(a=0;a<i+1;a++)
{
printf("%3d ",combinari(i,a));
}
printf("\n");
}
}
________________________________________________________________________
/* Programul citeste un set de linii de text si
afiseaza linia cea mai lunga; se utilizeaza variabile globale */
#include <stdio.h>
#include <conio.h>
#define MAXLINIE 10
/* lungimea curenta a liniei */
int max ;
/* lungimea maxima determinata */
char linie [ MAXLINIE ] ;/* linia curenta */
char cea_mai_lunga [ MAXLINIE ] ;/* linia cea mai lunga, salvata */
int getline ( void ) ;
void copy ( void ) ;
void main ( )
{
int lung ;
extern int max ;
extern char cea_mai_lunga [ ] ;
clrscr();
printf("Programul citeste linii de text pana la CTRL-Z,ENTER.\n");
printf("Si determina si afiseaza linia de text cea mai lunga.\n");
printf("Introduceti linii de text, separate cu ENTER:\n");
max = 0 ;
while ( ( lung = getline ( ) ) > 0 )
if ( lung > max )
{
max = lung ;
copy ( ) ;
}
printf("Linia cea mai lunga a fost: \n");
if ( max > 0 )
/* aceasta a fost linia */
printf ("%s" , cea_mai_lunga);
}
/* getline : versiunea specializata */
int getline ( void )
{
int c, i;
extern char linie [ ] ;

for ( i = 0 ; i < MAXLINIE && (c=getchar ()) != EOF && c!='\n'; ++i )
linie [ i ] = c ;
if ( c == '\n' )
{
linie [ i ] = c ;
++i ;
}
linie [ i ] = '\0';
return i ;
}
/* copy: versiunea specializata */
void copy ( void )
{
int i ;
extern char linie[ ], cea_mai_lunga [ ];
i=0;
while ( ( cea_mai_lunga [ i ] = linie [ i ] ) != '\0')
++ i ;
}
________________________________________________________________________
/* Programul manipuleaza o lista de tip stiva, utilizand diferite functii:
initstack - initializare stiva;
emptystack - determina daca stiva este goala;
push - introduce un nou element in coada;
pop - extrage un element din coada;
top - afiseaza elementul dinvarful stivei
error - afiseaza un mesaj de eroare;
Lista este implementata utilizand o structura ce contine:
un tablou de NAXSTACK elemente, si un intreg ce reprezinta:
pozitia elementului din varful stivei
*/
#include <stdio.h>
#include <conio.h>
#define MAXSTACK 10
struct s_stiva
{
int elem[MAXSTACK];
int sp;
};
void initstack ( struct s_stiva *s )
{
s->sp = 0;
};
int emptystack ( struct s_stiva *s )
{
return ( s->sp == 0 );
};
void push ( struct s_stiva *s, int el )
{
if ( s -> sp == MAXSTACK )
error("stack full\n");
else
{
s -> sp ++;
s -> elem[s -> sp ] = el;
}
};
int pop ( struct s_stiva *s )
{
int ts;
if ( emptystack ( s ) )
error ("empty stack\n");
else
{
ts = s -> elem [ s -> sp ];
s -> sp --;
return ( ts );
}
};
int top ( struct s_stiva *s)
{
if ( emptystack ( s ) )
error ("empty stack\n");
else
return ( s -> elem [ s -> sp ] );
}
void error ( char mesaj[] )
{
printf ( "%s", mesaj );
}
main ()
{
struct s_stiva *stiva;
int i , val;
char optiune[15];
clrscr();
printf("\nProgramul implementeaza o stiva si operatiile cu aceasta.\n");
do {
printf ("Optiune (Init, Push, Extract, Top, Display, Finish):");
scanf("%15s", optiune );
switch ( optiune[0] )
{
case 'd':
case 'D': if ( ! emptystack ( stiva ) )
{ for ( i = stiva -> sp ; i > 0 ; i-- )
printf("%d -> ", stiva -> elem [ i ]);
printf("NULL\n");
}
else error ("empty stack\n");
break;
case 'i':
case 'I': clrscr();
printf("\nProgramul implementeaza o stiva.\n");
initstack ( stiva); break;
case 'p':
case 'P': printf("Elementul de introdus in stiva:");
scanf ("%d", &val);
push ( stiva , val );
break;
case 'e':
case 'E': if ( ! emptystack ( stiva ) )
{
printf("extracted element: %d\n", top ( stiva ));
pop ( stiva );
}
else
error("empty stack\n");
break;
case 't':
case 'T': if (!emptystack(stiva))
printf("Elementul din varful stivei este: %d\n", top(stiva));
else
error("empty stack.\n");
break;
}
} while ( optiune [0] != 'f' && optiune[0] != 'F' );
}
________________________________________________________________________
/* Programul determina valoarea minima dintr-un sir de valori
utilizand pentru determinarea valorii minime o functie */
#include<stdio.h>
double minim (double vector[], int nr)
{
int i;
double val_min;
val_min = vector[0];
for ( i = 1 ; i < nr ; i++)
if ( vector[i] < val_min)
val_min = vector[i];
return ( val_min );
}
void main()
{
double sir[100], val;
int ne, i;
printf("\nProgramul determina valoarea minima dintr-un sir de valori.\n");
printf("Minimul este furnizat de o functie.\n");
printf ("Numar elemente din vector:");
scanf ("%d",&ne);
for ( i = 0 ; i < ne ; i++)
{
printf ("sir(%d)=", i+1);
sir[i] = val;
}
printf ("Valoarea minima este:%.5le\n", minim(sir,ne));
}
________________________________________________________________________
/* Inmultirea unei matrici cu un scalar, utilizand functii */
#include <stdio.h>
void citire_matrice( double matc [][8], int *pnl, int *pnc )
{
int
i,j;
printf ("Dimensiunile matricii (linii,coloane):");
scanf ("%i%i", pnl, pnc);
for ( i = 0 ; i < *pnl ; i++)
for ( j = 0 ; j < *pnc ; j++)
{
printf("mat(%i,%i)=", i+1, j+1);
scanf("%lf", &matc[i][j]);
}
}
void multiplica_scalar ( double matm [][8], int nlinii,
int ncoloane,double valoare )
{
int i,j;
for ( i = 0 ; i < nlinii ;i++)
for ( j = 0 ; j < ncoloane ; j++)
matm[i][j] *= valoare;
}
void afisare_matrice ( double mata[][8], int linii, int coloane )
{
int
i, j, nr_elem_pe_linie = 1;
for ( i = 0 ; i < linii ; i++)
for ( j = 0; j < coloane ; j++, nr_elem_pe_linie++ )
{
printf ("mat(%i,%i)=%7.2f ", i+1, j+1, mata[i][j]);
if ( nr_elem_pe_linie % 4 == 0 )
printf("\n"); /* se afiseaza cate 4 valori/linie */
}
printf("\n");
}
void main()
{
double matrice [8][8], scalar;
int l, c;
printf("\nProgramul inmulteste o matrice (reala) cu un scalar.\n");
printf("Se utilizeaza functii pentru citire, inmultire si afisare.\n");
printf ("Introduceti matricea :\n");
citire_matrice ( matrice, &l, &c );
printf ("Scalarul cu care se inmultesc elementele matricii: ");
scanf ("%lf", &scalar );
multiplica_scalar ( matrice, l, c, scalar );
printf ("Matricea multiplicata cu scalarul %.3f este :\n", scalar );
afisare_matrice( matrice, l, c );
}
________________________________________________________________________
/* Program de ordonare crescatoare sir, utilizand metoda de selectie directa,
adica: din sirul initial se pune valoarea minima pe prima pozitie,
apoi pentru subsirul ramas [2,n] se pune valoarea minima din el pe
pozitia 2, s.a.m.d
*/
#include<stdio.h>
void sort (double sir[], int nrelem)
{
int i,j;
double aux;
for( i = 0 ; i < nrelem-1; ++i )
for( j = i+1;j < nrelem ; ++j)
if ( sir[i] > sir[j] )
{
aux = sir[i];
sir[i] = sir[j];
sir[j] = aux;
}
}
void main()
{
int ne, i;
printf("\nProgramul ordoneaza un sir de valori reale.\n");
printf("Functia ce ordoneaza utilizeaza metoda \"Selectiei directe\".\n");
printf ("Numarul de elemente din vector: ");
scanf ("%d",&ne);
for ( i = 0 ; i < ne ; ++i)
{
printf (" sir(%d)=", i+1);
sir[i] = val;
}
sort(sir,ne);
for( i = 0 ; i < ne ; ++i )
printf ("sir(%2d)=%8.2lf ", i+1, sir[i]);
printf("\n");
}
________________________________________________________________________
/* Programul inmulteste o matrice cu un scalar, utilizand o
functie care inmulteste un vector cu un scalar
*/
#include <stdio.h>
void main ()
{
static int mat [3][4] = {
{ 1, 2, 3, 4},
{ 5, 7, 9, 11},
{ 16, 25, 36, 49}
};
int i, j;
void mult_scalar ( int vect [ ] , int dim, int scalar );
printf("\nProgramul inmulteste o matrice cu un scalar, utilizand\n"
"o functie care inmulteste un vector cu un scalar.\n");
printf("Maticea initiala este:\n");
for ( i = 0 ; i < 3 ; i++ )
{
for ( j = 0 ; j < 4 ; j++ )
printf ("m(%d,%d)=%d ", i+1, j+1, mat [i][j] );
putchar ( '\n' );
}
printf("Scalarul cu care se inmulteste: 2.\n");
printf("Matricea rezultata:\n");
mult_scalar ( mat, 3*4, 2 ); /* se inmultesc cele 3*4 = 12 elemente cu 2 */
for ( i = 0 ; i < 3 ; i++ )

{
for ( j = 0 ; j < 4 ; j++ )
printf ("m(%d,%d)=%d ", i+1, j+1, mat [i][j] );
putchar ( '\n' );
}
}
void mult_scalar ( int vect [ ] , int dim , int scalar )
{
int i ;
for ( i = 0 ; i < dim ; i++ )
vect [i] *= scalar;
}
________________________________________________________________________
/* cauta liniile identice */
/* aceeasi problema, dar cu deosebirea ca se pot specifica, in linia de comanda, anumiti
parametrii:
cauta -x -n sirul_de _cautat
adica: x - listarea liniilor cu exceptia celor care se potrivesc cu sirul_de_cautat
n - precedarea fiecarei linii afisate de numarul ei
argumentele pot apare in orice ordine */
#include <stdio.h>
#include <string.h>
int getline(char *linie, int max);
/* cauta : afiseaza liniile care coincid cu primul argument din linia de comanda */
main (int argc , char *argv[ ] )
{
char linie [MAXLINIE];
long nr_linie = 0;
int c, except = 0, numar = 0, gasit = 0;
while (--argc > 0 && (*++argv[0] ) == '-')
while (c = *++argv[0] )
switch (c)
{
case 'x':
except =1;
break;
case 'n':
numar = 1;
break;
default:
printf ("cauta: optiune eronata %c\n", c);
argc =0;
gasit =-1;
break ;
}
if (argc !=1)
printf ("Utilizare: cauta x n sir_de_caractere\n");

else
while ( getline ( linie, MAXLINIE ) > 0 )
{
nr_linie ++;
if ((strstr ( linie , *argv) != NULL ) != except )
{
if (numar )
printf ("%1d:" ,nr_linie );
printf ("%s", linie);
}
}
return gasit ;
}
________________________________________________________________________
static char tab_zi[2][13]={
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};
/* zi_din_an: calculeaza numarul zilei din an pe baza datei: zi / luna */
int zi_din_an (int an, int luna, int zi)
{
int i, bisect;
bisect = an % 4 == 0 && an % 100 != 0 || an%400 == 0;
for ( i = 1; i < luna ; i++ )
zi += tab_zi [ bisect ][i];
return zi;
}
/* luna_zi : determina luna / zi pe baza zilei din an */
void luna_zi (int an, int an_zi, int *pluna, int *pzi)
{
int i, bisect;
bisect = an % 4 == 0 && an % 100 != 0 || an % 400 == 0;
for ( i = 1; an_zi > tab_zi[bisect][i] ; i++ )
an_zi -= tab_zi[bisect][i] ;
*pluna = i;
*pzi = an_zi ;
}
________________________________________________________________________
/* se afiseaza liniile care sunt identice (se potrivesc) cu primul argument din linia de
comanda */
/* si numara cate linii identice cu argumentul din linia de comanda, au fost gasite */
#include <stdio.h>
#include <string.h>

int getline(char *line, int max);
{
int gasit =0;
if (argc !=2)
printf ("Utilizare : cauta sir_de_caractere\n");
else
while (getline (linie , MAXLINIE ) >0)
if ( strstr (linie,argv[1] ) !=NULL)
{
printf ("%s", linie);
gasit ++ ;
}
return gasit ;
}
________________________________________________________________________
#include <stdio.h>
#include <string.h>
#define MAXLINII 5000
/*numarul max de linii ce pot fi sortate */
char * ptr_linie [MAXLINII] ;
/* pointeri la liniile de text */
int cit_linii (char *ptr_linie [ ] , int nr_linii );
void scrie_linii (char *ptr_linie [ ], int nr_linii);
void qsort (char *ptr_linie [ ], int stanga ,int dreapta);
/* sorteaza liniile de intrare */
main ( )
{
int nr_linii;
/* numarul de linii citite */
if ((nr_linii = cit_linii (ptr_linie , MAXLINII )) >= 0)
{
qsort ( ptr_linie , 0 , nr_linii-1);
scrie_linii (ptr_linie , nr_linii) ;
return 0;
}
else
{
printf ("eroare: numar de linii prea mare pentru a fi sortate\n");
return 1;
}
}
#define MAXLUNG 1000 /* lungimea maxima a unei linii */
int getline (char *, int );
char *alloc (int );

/* cit_linii: citeste liniile din intrare si returneaza numarul de linii citite sau -1 daca sunt
prea multe linii */
int cit_linii (char *ptr_linie [ ], int maxlinii )
{
int lung , nr_linii;
char *p, linie [MAXLUNG];
nr_linii = 0;
while (( lung = getline (linie,MAXLUNG)) >0)
if ( nr_linii >=maxlinii || (p = alloc (lung) ) ==NULL)
return -1;
else
{
linie [lung -1] = '\0'; /*sterge linia noua */
strcpy (p, linie);
ptr_linie [nr_linii++] = p;
}
return nr_linii ;
}
/* scrie_linii: scrie liniile de iesire */
void scrie_linii (char *ptr_linie [ ], int nr_linii)
{
int i;
for ( i = 0; i < nr_linii ; i ++)
printf ("%s\n", ptr_linie[i] );
}
/* functia scrie_linii care scrie liniile de iesire se poate scrie si altfel, */
/* deoarece ptr_linie este numele unui tablou, el poate fi tratat ca un pointer */
/*void scrie_linii (char *ptr_linie [ ], int nr_linii)
{
while ( nr_linii -- > 0 )
printf ("%s\n", *ptr_linie++ );
} */
/* qsort : ordoneaza v[stanga]v[dreapta] in ordine crescatoare */

void qsort (char *v[ ], int stanga , int dreapta )
{
int i, ultim;
void swap (char *v[ ], int i, int j);
if ( stanga >= dreapta ) /* nu se face nimic daca vectorul */
return ;
/* contine mai putin de doua elemente */
swap (v, stanga, ( stanga + dreapta ) /2 );

ultim = stanga;
for (i = stanga + 1; i <= dreapta ; i++ )
if ( strcmp ( v[i] , v[stanga] ) < 0 )
swap (v, ++ultim, i ) ;
swap (v, stanga , ultim );
qsort ( v, stanga, ultim - 1 );
qsort (v, ultim+1, dreapta );
}
/* swap : interschimba v[i] si v[j] */
void swap (char *v[ ], int i , int j)
{
char *temp;
temp = v[i];
v[i] = v[j];
v[j] =temp;
}
/*
________________________________________________________________________
/* Programul afiseaza liniile care contin primul argument din linia de
comanda si numara cate linii identice cu argumentul din linia de comanda,
au fost gasite */
#include <stdio.h>
#include <string.h>
int getline(char *line, int max);
{
int gasit =0;
printf("\nProgr. afiseaza liniile de text introduse de la tastatura, ce\n");
printf("contin sirul de caract. transmis ca argument, in linia de c-da.\n");
printf("Programul numara si afiseaza cate linii au fost identice cu arg.\n");
printf("Programul se termina cu CTRL-Z, ENTER.\n");
if (argc !=2)
printf ("Utilizare : cauta sir_de_caractere\n");
else
while (getline (linie , MAXLINIE ) >0)
if ( strstr (linie,argv[1] ) != NULL)
{
printf ("%s\n", linie);
if ( strcmp (linie, argv[1]) == 0 )
gasit ++ ;
}
printf("Numarul de linii identice cu \"%s\" este: %d\n", argv[1], gasit);
return gasit ;
}
/* getline : citeste o linie in s, si returneaza lungimea */
int getline ( char s[ ] , int lim )
{
int c, i;
for ( i = 0 ; (i< lim - 1) && (c = getchar ()) != EOF && c!='\n'; ++i )
s[ i ] = c ;
s[ i ] = '\0' ;
return i ;
}
________________________________________________________________________
/* sortarea liniilor se poate face lexicografic sau numeric; algoritmul de sortare este
indepenedent de
operatia de comparare si interschimbare a obiectelor de sortat;
din acest motiv putem transmite diferite functii pentru comparare si interschimbare, astfel
ca putem
aranja sortarea in functie de anumite criterii. Vom utiliza o functie strcmp pentru
comparare lexicografica si o functie numcmp care realizeaza comparatia valorilor
numerice ale liniilor si returneaza
acelasi tip de indicator de conditie ca functia strcmp. Una dintre aceste functii va fi
transmisa printr-un pointer ca argument la functia qsort, pentru a face sortarea adecvata.
*/
#include <stdio.h>
#include <string.h>
#define MAXLINII 5000
/* numarul maxim de linii de sortat */
char ptr_linie [MAXLINII] ;
/* pointeri la liniile de text */
int cit_linii (char *ptr_linie [ ], int nr_linii );
void scrie_linii (char *ptr_linie [ ] , int nr_linii);
void qsort (void *ptr_linie [ ] , int stanga , int dreapta ,
int (*comp) (void *, void *));
int numcmp ( char *, char *);
/* sorteaza liniile */
{
int nr_linii ;
/* number de linii citite */
int numeric =0;
/* 1 daca se face sortare numerica */
if (argc > 1 && strcmp (argv [1] ,"-n") == 0 )
numeric = 1;
if (( nr_linii = cit_linii ( ptr_linie , MAXLINII)) >=0)
{
qsort (( void **) ptr_linie , 0, nr_linii - 1,
(int (*) (void*, void*)) (numeric ? numcmp : strcmp ));
scrie_linii (ptr_linie , nr_linii );
return 0;
}
else
{
printf ("numar prea mare de linii pentru a fi sortate\n ");
return 1;
}
}
/* qsort: sorteaza v[stanga]... v[dreapta] in ordine craescatoare */
void qsort (void *v[ ] , int stanga , int dreapta ,
int (* comp ) ( void *,void *) )
{
int i , ultim ;
void swap (void *v [ ] , int , int );
if ( stanga >= dreapta ) /* nu face nimic daca vectorul */
return;
/* mai putin de doua elemente */
swap (v, stanga , (stanga + dreapta )/2 );
ultim = stanga ;
for (i = stanga+1; i <= dreapta ; i++ )
if ( ( *comp) (v[i], v[stanga] ) < 0 )
swap ( v, ++ ultim , i );
swap (v, stanga , ultim );
qsort (v, stanga, ultim-1, comp);
qsort (v, ultim+1 , dreapta ,comp );
}
# include <stdlib.h>
/* numcmp : compara numeric doua siruri de caractere s1 si s2 */
int numcmp (char *s1, char *s2 )
{
double v1, v2 ;
v1 = atof (s1);
v2 = atof (s2);
if (v1 <v2 )
return - 1;
else if ( v1 > v2 )
return 1;
else
return 0;
}
________________________________________________________________________
/* constiva.cpp - prog. construieste o stiva de numere intregi, distincte,
pe care o afiseaza, utilizand functiile: adauga_stiva si afisare_stiva */
/*
Alte probleme propuse:
- construirea unei liste ordonate de numere;
- organizarea unui dictionar de cuvinte, ca o lista inlantuita. */

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
struct s_stiva
{
int
valoare;
int nr_aparitii; /* numarul de aparitii ale numarului in stiva */
struct s_stiva *urmator;
};
struct s_stiva *adauga_stiva (struct s_stiva *ultimul, int val)
{
/*Functia returneaza un pointer la ultimul element din stiva daca s-a putut
adauga un nou element, sau NULL daca nu s-a adaugat ("Memorie plina!") */
struct s_stiva *ptr_stiva;
if (ultimul==NULL)
{
ultimul=(struct s_stiva *) malloc(sizeof(struct s_stiva));
if (ultimul==NULL)
{printf("Memorie plina!\n");
return(NULL);
}
else
{
ultimul->valoare=val;
ultimul->nr_aparitii=1;
ultimul->urmator=NULL;
return(ultimul);
}
}
else
{
ptr_stiva=ultimul;
/* se cauta daca exista valoarea */
while(ptr_stiva->valoare!=val && ptr_stiva->urmator!=NULL)
ptr_stiva=ptr_stiva->urmator;
if(ptr_stiva->valoare==val)
{ptr_stiva->nr_aparitii++;
return(ultimul);
}
else
{ptr_stiva=(struct s_stiva *)malloc(sizeof(struct s_stiva));
if (ptr_stiva==NULL)
{printf("Mmeorie plina!\n");
return(NULL);
}
else
{ptr_stiva->valoare=val;
ptr_stiva->nr_aparitii=1;
ptr_stiva->urmator=ultimul;
return(ptr_stiva);
}
}
}
}
void afisare_stiva(struct s_stiva *ultim)
{
int nr_val_linie = 0;
while (ultim!=NULL)
{
printf("%2d(%d)-> ", ultim->valoare, ultim->nr_aparitii);
ultim=ultim->urmator;
nr_val_linie++; /* contor pentru nr. de valori afisate pe linie */
if (nr_val_linie%8==0)
printf("\n");
}
printf ("\n");
}
void eliberare_spatiu (struct s_stiva *ptrs){
struct s_stiva *p=ptrs;
while(p){ptrs=p;
p=p->urmator;
free(ptrs);
}
}
void main()
{
struct s_stiva *ultim=NULL;
int numar;
clrscr();
printf("Prg. construieste si afiseaza o stiva de nr. intregi, distincte.\n");
printf("Introducerea se termina cu EOF(CTRL-Z, ENTER.\n");
printf("Introduceti numar: ");
while(scanf("%d", &numar)!=EOF)
{if((ultim=adauga_stiva(ultim, numar))==NULL)
break;
}
afisare_stiva(ultim);
eliberare_spatiu(ultim);
}
________________________________________________________________________
/* Programul realizeaza conversia unui sir de caractere,
din linia de comanda,la o valoare numerica */
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
main (int argc, char *argv[])
{
const int baza = 10;
char *ptr_sf;
long int val_int;
double val_reala;
int i;
printf("\n\nProgramul determina tipul unor valori numerice (intregi sau "
"reale)\ncitite din linia de comanda, la lansarea programului.\n");
if (argc < 2)
printf ("Utilizare: %d numere\n", argv[0]);
else
for (i = 1 ; i < argc ; i++)
{
val_int = strtol (argv [i] , &ptr_sf, baza);
if ( (*ptr_sf) == '\0')
printf ("Argumentul %d este un numar intreg: %li\n",i, val_int);
else if (ispunct (*ptr_sf))
{
val_reala = strtod (argv[i], &ptr_sf);
if ( (*ptr_sf) == '\0')
printf ("Argumentul %d este un numar real: %lf\n",
i, val_reala );
else
printf ("Argumentul %d nu este o valoare numerica\n",i);
}
else
printf ("Argumentul %d nu este o valoare numerica\n",i);
}
printf("\n");
}
________________________________________________________________________
/* Programul inverseaza tipul de caracter dintr-un text:
de la litera mare la litera mica si invers */
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#define LIMITA 30
#define DIMENS 81
void main()
{
void transforma (char linie[]);
char text [LIMITA] [DIMENS];
int nr_linie = 0, i;
printf("\nProgramul inverseaza tipul literelor (mici <-> mari) dintr-un text.\n");
printf("Introduceti cel mult %d linii pentru transformare\n", LIMITA);
printf("Introducerea se termina cu ENTER, pe o linie noua\n");
while (nr_linie < LIMITA && gets( text[nr_linie] ) != NULL &&
strcmp (text[nr_linie],"") != 0)
nr_linie++;/* numarul liniei curente din vectorul de siruri de caractere */
for (i = 0 ; i < nr_linie ; i++)
{
transforma (text[i]);
puts (text[i]);
}
}
void transforma (char *ptr_car)
{
while (*ptr_car != '\0')
{
if ( isupper (*ptr_car) )
*ptr_car = tolower ( *ptr_car );
else if ( islower ( *ptr_car ) )
*ptr_car = toupper ( *ptr_car );
ptr_car++;
}
}
________________________________________________________________________
/* Programul citeste siruri de caractere si realizeaza
sortarea (ordonarea) lor*/
#include <stdio.h>
#include <string.h>
#define DIMENS 81
#define LIMITA 30
#define STOP ""
main()
{
void sort_sir ( char *sirc[], int lung );
static char intrare[LIMITA][DIMENS];/* vector ce memoreaza intrarile */
char *ptr_str [LIMITA]; /* vector de variabile pointer */
int contor = 0, cont_tip;
printf("\nProgramul sorteaza lexicografic linii de text.\n");
printf ("Introduceti cel mult %d linii,pentru sortare.\n", LIMITA);

printf ("Introducerea se termina cu ENTER , pe o linie noua.\n\n");
while ( contor < LIMITA && gets(intrare[contor]) != NULL &&
strcmp(intrare[contor], STOP) !=0 )
{
/* se depune in vectorul de pointeri adresa curenta din intrare */
ptr_str[contor] = intrare[contor]; /* a sirului de caractere, curent */
contor++;
}
sort_sir( ptr_str, contor ); /* ordonarea vectorului de siruri de caractere */
puts("\nLista ordonata :\n");
for ( cont_tip = 0 ; cont_tip < contor ; cont_tip++)
puts ( ptr_str[cont_tip] );
}
void sort_sir ( char *sirc[], int lung)
{
char *temp;
int i,j;
for ( i = 0 ; i < lung-1 ; i++)
for ( j = i+1 ; j < lung ; j++)
if ( strcmp( sirc[i], sirc[j] ) > 0 )
{
temp = sirc[i];
sirc[i] = sirc[j];
sirc[j] = temp;
}
}
________________________________________________________________________
/* Programul converteste un sir de caractere la o valoare de tip double,
definind o functie in acest scop: atod (Ascii TO Double) */
#include <stdio.h>
#include <ctype.h>
#define DIMMAX 20
double atof ( char s[ ] )
{
double val , putere ;
int i, semn ;
for ( i = 0 ; isspace ( s[i]) ; i++ ); /* ignora spatiile albe */
semn = ( s[i] == '-' ) ? -1 : 1 ;
if ( s[i] == '+' || s[i] == '-' )
i++;
for ( val = 0.0 ; isdigit (s[i]) ; i++ )
val = 10.0 * val + (s[i] - '0' );
if ( s[i] == '.' )
i++ ;
for ( putere = 1.0; isdigit (s[i]) ; i++ )
{
val = 10.0 * val + ( s[i] -'0' ) ;

putere *= 10.0 ;
}
return semn * val / putere ;
}
main ()
{
char valoare[DIMMAX];
printf("\nProgramul converteste un sir de cifre, citite ca si carcatere,\n"
"la o valoare de tipul \"double\".\n");
printf("Introduceti un sir de cifre ce va fi convertit la tipul double:\n");
scanf("%s", valoare);
printf("Valoarea introdusa este: %.15le\n", atof(valoare));
}
________________________________________________________________________
/* Programul determina si afiseaza imediat sirul de caractere cautat
din toate liniile in care se afla sirul cautat
*/
#include <stdio.h>
#include <conio.h>
#include <string.h>
#define MAXLINIE 100 /* dimensiunea maxima a unei linii */
int citlinie ( char linie[ ], int max ) ;
int strindex ( char sir_sursa [ ], char sir_cautat [ ] ) ;
char cautat [ ] = "sirul de caractere" ; /* sirul de cautat */
main ( )
{
char linie [ MAXLINIE ] ;
int gasit = 0, i, j;
clrscr();
printf("Programul afiseaza sirul de caractere cautat, din fiecare linie,\n");
printf("in care intalneste respectivul sir:\"%s\"\n", cautat);
printf("Introduceti linii de text (ce se termina cu CTRL-Z, ENTER):\n");
while ( citlinie ( linie, MAXLINIE ) > 0 )
if ( (i = strindex (linie, cautat)) >= 0 )
{
for (j=0 ; j < strlen (cautat) ; j++)
printf ("%c" , linie[i+j]);
printf("\n");
gasit ++ ;
}
printf("numarul de linii care contin sirul:\n\"%s\" este: %4d\n"
, cautat, gasit);
return ( gasit );
}
/* citlinie : citeste o linie si o depune in s, returneaza lungimea ei */

int citlinie (char s[ ] , int lung)
{
int car, i;
i=0;
while ( --lung > 0 && ( car = getchar () ) != EOF && car != '\n' )
s[i++] = car;
if ( car == '\n' )
s[i++] = car;
s[i] = '\0';
return i ;
}
/* strindex : returneaza indexul sirului t in s, sau -1 daca nu este in s */
int strindex ( char s[ ] , char t[ ] )
{
int i, j, k;
for ( i = 0 ; s[i] != '\0' ; i++ )
{
for ( j = i, k = 0 ; t[k] != '\0' && s[j] == t[k] ; j++, k++);
if ( k > 0 && t[k] == '\0' )
return i ;
}
return -1 ;
}
________________________________________________________________________
/* Programul converteste un sir de caractere s la intreg, int,
definind o functie pentru aceasta: "atoi" */
int atoi (char s[ ] )
{
int i, n;
n=0;
for ( i = 0 ; s[i] >='0' && s[i]<='9';++i)
n=10 *n + (s[i] - '0');
return n;
}
/*lower : conversie caracter la litera mica; numai carcatere ASCII */
int lower (int c)
{
if (c >= 'A' && c<='Z' )
return c + 'a' - 'A' ;
else
return c;
}
/* stergerea unui anumit caracter dintr-un sir de caractere */

void sterge (char s[ ], int c )
{
int i , j;
for ( i = j = 0; s[i] != '\0' ; i++ )
if ( s[i] != c )
s[j++] = s[i];
s[j] = '\0';
}
________________________________________________________________________
/* Programul inverseaza ordinea caracterelor din sirul de caractere s */
#include <string.h>
#include <stdio.h>
#define DIM_MAX 80
void reverse (char s[ ] )
{
int c, i, j;
for (i = 0, j = strlen(s)-1 ; i < j ; i ++, j--)
{
c = s[i];
s[i] = s[j];
s[j] = c;
}
}
void main ()
{
char s[DIM_MAX];
printf("\nProgramul inverseaza un sir de cel mult %d caractere.\n",DIM_MAX);
printf("Introduceti textul de inversat:\n");
gets(s);
printf("Textul inversat este:\n");
reverse (s);
puts(s);
}
________________________________________________________________________
/* Programul converteste un numar n intr-un sir de caractere s, folosind
o functie "itoa", care este inversa functiei "atoi" */
#include <stdio.h>
#include <string.h>
#define DIM_MAX 80
void reverse (char s[ ] )
{
int c, i, j;
for (i = 0, j = strlen(s)-1 ; i < j ; i ++, j--)
{
c = s[i];
s[i] = s[j];
s[j] = c;
}
}
void itoa ( int n, char s[ ] )
{
int i, semn ;
if ( ( semn = n ) < 0 ) /* memoreaza semnul */
n = - n ; /* transforma n-ul in pozitiv */
i=0;
do {
/* genereaza cifrele in ordine inversa */
s[i++] = n % 10 + '0' ; /* ia urmatoarea cifra */
} while ( ( n /= 10 ) > 0 ) ; /* continua cat timp mai sunt cifre */
if ( semn < 0 )
s[i++] = '-' ;
s[i] = '\0' ; /* pune caracterul de sfarsit de sir */
reverse (s) ; /* apeleaza functia de inversare a ordinii caracterelor */
}
/* deoarece numarul a fost obtinut in ordine inversa */
void main ()
{
char s[DIM_MAX];
int numar;
printf("\nProgramul converteste o valoare intreaga [-32767,+32767]\n"
"intr-un sir de caractere.\n");
printf("Se utilizeaza o functie \"itoa\" Int -> TO -> Ascii.\n");
printf("Introduceti valoarea intreaga de convertit la sir de caractere:\n");
scanf("%6d", &numar);
itoa(numar, s);
printf("Sirul de caractere convertit este:\n");
puts(s);
}
________________________________________________________________________
/* conversia unui sir la un intreg */
#include <stdio.h>
#include <stdlib.h>
char string[] = "1234";
main()
{
int val;
val = atoi( string );
printf("Numar = %d\n", val );
}
________________________________________________________________________
/* convresia unui intreg la un sir de caractere */
#include <stdio.h>
#include <stdlib.h>
main()
{
int numar;
char sircar[20];
printf("Introduceti un intreg: ");
scanf(" %d", &numar );
printf("Ca sir de caractere numarul este \"%s\"\n", itoa(numar, sircar, 10));
}
________________________________________________________________________
/* Programul actualizeaza un fisier de produse, PRODUSE.DTA,
creat de programul initprod.c, cu datele curente introduse de la
tastatura
*/
#include <stdlib.h>
#include <stdio.h>
#define MAX_PROD 100
void main()
{
struct struct_produs {
char nume [20];
int nr_prod;
double stoc;
float pret;
char moneda [10];
};
struct struct_produs *prod;
FILE *ptr_fis;
int pnr;
double stoc;
float pret;
char optiune[10];
printf("Initializare floating point, real=");
scanf("%lf", &stoc);
printf("\nProgramul actualizeaza un fisier de produse, PRODUSE.DTA,\n"
"creat de programul \"initprod.c\", cu datele curente introduse "
"de la tastatura.\n");
if ( (ptr_fis = fopen ("produse.dta", "r+b")) == NULL )
{
printf ("Fisierul: PRODUSE.DTA nu poate fi deschis"
" pentru citire/scriere \n");
exit ( 1 );
}
else
{
printf ("Numarul produsului de actualizat (0=stop):");
scanf ("%d", &pnr); while ( getchar() != '\n');
while ( pnr >= 1 && pnr <= MAX_PROD )

{
fseek (ptr_fis, (pnr-1)*sizeof( struct struct_produs),
SEEK_SET);
fread (prod, sizeof(struct struct_produs), 1, ptr_fis);
printf ("%s, val: %d, stoc: %lf, pret: %f, moneda:%s, \n",
prod->nume,prod->nr_prod, prod->stoc,
prod->pret,prod->moneda);
printf ("Actualizare: nume/stoc/pret/moneda:");
gets (optiune);
while (optiune [0] != '\0')
{
switch (optiune[0])
{
case 'N':
case 'n': printf ("Nume nou :");
gets (prod->nume);
break;
case 's':
case 'S': printf ("Stoc actualizat:");
scanf ("%lf", &stoc);
prod->stoc = stoc;
while(getchar() != '\n');
break;
case 'p':
case 'P': printf ("Pret nou:");
scanf ("%f", &pret);
prod->pret = pret;
while (getchar() != '\n');
break;
case 'm':
case 'M': printf ("Moneda:");
gets (prod -> moneda);
}
printf ("Actualizare:Nume/Stoc/Pret/Moneda:");
gets (optiune );
}
fseek (ptr_fis, (pnr-1)*sizeof(struct struct_produs),SEEK_SET);
/*sau: fseek ( ptr_fis, -sizeof(struct struct_produs),SEEK_CUR);*/
fwrite (prod, sizeof(struct struct_produs), 1, ptr_fis);
printf ("Numar produs de actualizat (0=stop):");
scanf ("%d", &pnr); while (getchar()!= '\n');
}
fclose(ptr_fis);
}
}
/* Programul permite, la prima utilizare, crearea unui

fisier "cuvinte.txt", iar la utilizarile ulterioare, adaugare de
noi cuvinte la acest fisier. Pentru a determina sfarsitul citirii
de cuvinte si a depunerii lor in fisier se compara cuvantul [0]
cu '\0', deoarece functia gets () descarca caracterul '\n'. */
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
void main()
{
FILE *pf;
char *cuvant;
clrscr();
printf("Programul permite, la prima utilizare, crearea unui fisier\n"
"\"cuvinte.txt\", iar la utilizarile ulterioare, adaugare de\n"
"noi cuvinte la acest fisier.\nIntroducerea cuvintelor ia sfarsit\n"
"cu o linie vida (ENTER la inceputul liniei)\n");
if ( ( pf = fopen ("cuvinte.txt", "a+") ) == NULL )
{
fprintf (stderr, "Nu se poate deschide fisierul \"cuvinte.txt\"\n");
exit ( 1 );
}
puts ("Introduceti cuvintele pentru adaugare la fisier,");
puts ("Pentru sfarsit folositi tasta Enter la inceputul unei linii noi");
puts ("sau CTRL-Z, Return, oriunde in cadrul textului.");
while (gets (cuvant) != NULL && cuvant [0] != '\0')
fprintf (pf, "%s\n", cuvant); /* functia puts trece automat */
fclose (pf);
if ( ( pf = fopen ("cuvinte.txt", "a+")) == NULL )
{
fprintf (stderr, "Nu se poate deschide fisierul \"cuvinte.txt\"\n");
exit ( 1 );
}
puts ("Fisierul contine urmatoarele cuvinte: ");/* la linie noua */
rewind (pf); /* pozitionare la inceputul fisierului */
while (fscanf (pf, "%s", cuvant) == 1)
puts (cuvant);
fclose (pf);
}
________________________________________________________________________
/* Programul adauga continuturile unei liste de fisiere
la un anumit fisier; parametrii sunt transmisi prin linia de comanda:
adauga fis_sursa1, fis_sursa2, fis_dest
care va adauga fis_sursa1 si fis_sursa2 la fis_dest.
*/
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define DIMBUF 1024
char buffer[DIMBUF];
void adauga (FILE *sursa, FILE *dest);
void main (int argc, char*argv[])
{
FILE *pfa, *pfr;
int nrfisier;
/*Daca sunt mai putin de doua argumente in linia de comanda ,
programul se termina*/
clrscr();
printf("Programul concateneaza mai multe fisiere, intr-unul singur.\n"
"Numele fisierelor sursa si destinatie se transmit prin linia de\n"
"comanda:\tadauga fis_sursa1, . . . fis_sursa2, fis_dest\n");
if ( argc < 3 )
{
printf ("Utilizare:%s fisiere_sursa fisier_destinatie\n", argv[0]);
exit(1);
}
/*daca nu se poate deschide fisierul destinatie:EROARE si STOP*/
if ( (pfa = fopen (argv[argc-1], "a") ) == NULL)
{
printf ("Nu se poate deschide fisierul:%s\n", argv[argc-1]);
exit(2);
}
/*Se initializeaza un buffer de 1024 octeti pt acest fisier*/
if ( setvbuf (pfa, NULL, _IOFBF, DIMBUF) != 0 )
{
fputs ( "Nu se poate crea bufferul de iesire\n", stderr );
exit(3);
}
/* pentru fiecare fisier din linia de comanda:
- daca are acelasi nume cu destinatia -> trece la fisierul urmator;
- daca nu poate fi deschis pentru citire -> urmatorul fisier;
- adauga continutul fisierului la fisierul destinatie */
for (nrfisier = 1 ; nrfisier < argc-1 ; nrfisier++)
{
if (strcmp (argv[argc-1], argv[nrfisier]) == 0)
printf ( "Nu se poate adauga fisierul la el insusi\n" );
else if ( (pfr = fopen (argv[nrfisier], "r")) == NULL )
printf ("Nu se poate deschide fisierul: %s\n", argv[nrfisier]);
else
{
if ( setvbuf (pfr, NULL, _IOFBF, DIMBUF) != 0 )

{
printf ("Nu se poate crea buffer de iesire\n");
continue;
}
adauga (pfr, pfa);
fclose (pfr);
}
}
fclose(pfa);
}
void adauga (FILE *sursa, FILE *dest)
{
size_t octeti;
extern char buffer[];
while ( (octeti = fread (buffer, sizeof (char), DIMBUF, sursa) ) > 0 )
fwrite (buffer, sizeof(char), octeti, dest);
}
________________________________________________________________________
/* Copierea unui fisier sursa intr-unul destinatie;
Programul se va lansa astfel:
cop_fis.exe fis_sursa.txt fis_dest.txt
*/
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int main (int argc, char*argv[])
{
FILE *in, *out; /* se utilizeaza doua fisiere: sursa si destinatia */
int c;
long int contor = 0;
clrscr();
printf("\nProgramul copiaza un fisier sursa intr-unul destinatie.\n"
"Fisierele sunt transmise prin linia de comanda:\n"
"\t\t\"cop_fis.exe fis_sursa.txt fis_dest.txt\"\n");
if ( argc != 3 )
{
/* daca nu sunt doua fisiere -> eroare !! */
fprintf (stderr,"\nTrebuie doua nume de fisier\n");
return(EXIT_FAILURE);
}
if ((in = fopen (argv[1], "r")) == NULL)
{/* nu se poate deschide primul fisier(citire)? ->eroare!! */
fprintf (stderr, "\nNu se poate citi fisierul: %s.\n", argv[1]);
return (EXIT_FAILURE);
}
if ((out = fopen (argv[2], "w")) == NULL)

{/* nu se poate deschide al doilea fisier(scriere)?->eroare!!*/
fprintf (stderr, "\nNu se poate scrie in fisierul: %s.\n", argv[2]);
return (EXIT_FAILURE);
}
while ( (c = getc (in)) != EOF )
{
putc (c, out);
putc (c, stdout);
contor++;
}
fclose (in);
fclose (out);
printf ("\nFisierul a fost copiat.\n");
printf ("Fisierul \"%s\" contine %ld caractere\n", argv[1], contor);
return (EXIT_SUCCESS);
}
________________________________________________________________________
/* Programul initializeza un fisier, numit PRODUSE.DTA,
care va contine date pentru un numar produse (MAX_PROD)
cu structura struct_produs */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
void main()
{
char nume [20];
int nr_prod;
double stoc;
float pret;
char moneda [10];
};
FILE *ptr_fis;
int i;
clrscr();
printf("\nProgramul initializeaza un fisier (PRODUSE.DTA) cu linii vide\n"
"pentru %d produse (nume/numar produs/stoc/pret/moneda)\n",MAX_PROD);
if ( ( ptr_fis = fopen("PRODUSE.DTA", "wb")) == NULL )
{
printf ( "Fisierul:PRODUSE.DTA, "
"nu poate fi deschis pentru scriere\n");
exit(1);
}
else
{
prod -> nume[0] = ' ';
prod -> nume[1] = '\0';
prod -> stoc = 0;
prod -> pret = 0;
prod -> moneda[0] =' ';
prod -> moneda[1] = '\0';
for ( i = 1 ; i <= MAX_PROD ; i++ )
{
prod->nr_prod = i;
fwrite ( prod, sizeof ( struct struct_produs), 1, ptr_fis);
}
fclose(ptr_fis);
printf("\nA fost initializat fisierul \"PRODUSE.DTA\"\n");
}
}
________________________________________________________________________
/* Programul afiseaza pe display fisierul PRODUSE.DTA,
creat de programul 'initprod.c 'si actualizat de programul 'actuprod.c'*/
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
main()
{
char nume [20];
int nr_prod;
double stoc;
float pret;
char moneda [10];
};
FILE *ptr_fis;
int pnr;
double stoc; float pret;
char optiune[10];
clrscr();
printf("Programul listeaza produsele din fisierul \"PRODUSE.DTA\"\n");
if ( ( ptr_fis = fopen ( "produse.dta", "r+b") ) == NULL )
{
printf ("Fisierul: PRODUSE.DTA nu poate fi deschis"
" pentru citire/scriere \n");
exit ( 1 );
}
else
{
if ( ( ptr_fis = fopen ("PRODUSE.DTA", "rb")) == NULL )
{
printf("Fisierul PRODUSE.DTA,nu poate fi deschis pentru
citire\n");
exit(1);
}
else
{
while ( fread ( prod, sizeof ( struct struct_produs ), 1, ptr_fis ) == 1 )
if ( prod -> nume[0] != ' ')
printf("%-20s, cod:%3d, stoc:%8.2lf, pret:%6.2f, moneda:%5s \n",
prod->nume, prod->nr_prod, prod->stoc,
prod->pret, prod->moneda);
fclose ( ptr_fis );
}
}
printf("\n");
}
________________________________________________________________________
/* Programul realizeaza afisarea unui fisier in ordinea inversa;
fisierul de tiparit invers, de la coada la capat, se transmite
ca parametru, dupa numele programului,in linia de comanda */
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#define CTRL_Z '\032'
/* marcaj sfarsit fisier EOF */
void main (int argc, char *argv[])
{
char car;
FILE *pf;
long int contor, ultim;
clrscr();
printf("Programul afiseaza un fisier, transmis ca parametru, in linia\n"
"de comanda, in ordine inversa (de la sfarsit la inceput).\n");
if (argc != 2)
{
printf ("Lipseste numele fisierului din linia de comanda\n");
exit (1);
}
if((pf = fopen (argv[1], "r+b")) == NULL)
{
printf ("Nu se poate deschide fisierul:%s\n", argv[1]);
exit (1);
/* deschis in: binar,citeste binar */
}
fseek (pf, 0L, SEEK_END); /* pozitionare la sfarsit de fisier */
ultim = ftell (pf);
/* ultima pozitie */
for (contor = 1L ; contor <= ultim ; contor++)

{
fseek (pf, -contor, SEEK_END);
car = getc (pf);
if (car != CTRL_Z && car != '\r')
putchar(car);
}
printf("\n");
fclose(pf);
}
________________________________________________________________________
/*
fgets: citeste cel mult n caractere din fisierul iop */
/*
citeste urmatoarea linie din intrare, inclusiv 'linie noua' */
char *fgets (char *s, int n, FILE *iop)
{
register int c;
register char *cs;
cs = s;
while (--n > 0 && (c = getc(iop)) ! =EOF)
if ( (*cs++ = c) == '\n' )
break;
*cs = '\0';
return (c == EOF && cs == s) ? NULL : s;
}
/*fputs: scrie sirul s in fisierul iop */
int fputs (char *s, FILE *iop)
{
int c;
while (c= *s++)
putc(c, iop);
return ferror (iop) ? EOF : 0;
}
/* se poate implementa functia de citire a unei linii, utilizand fgets */
/* getline: functia citeste o linie si returneaza lungimea ei */
int getline ( char *linie, int max )
{
if ( fgets ( linie, max, stdin ) == NULL )
return 0;
else
return ( strlen ( linie ) );
}
________________________________________________________________________
/*1b.Sa se construiasca un fisier care contine urmatoarele date pentru
studentii dintr-o grupa :
char nume[20];
enum sex { barbat, femeie };
enum sport { fotbal, tenis, inot,volei };
float media;
Sa se construiasca un nou fisier, pe baza acestuia, care sa contina numai
studentii care joaca tenis si au media peste 9.
*/
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#define MAX_NOTE 15
#define MAX_NUME 20
main()
{
enum tsex {barbat, femeie};
enum tsport {fotbal, tenis, inot, volei};
struct struct_student {
char nume[MAX_NUME];
enum tsex sex;
enum tsport sport;
int nota[MAX_NOTE];
int nr_note;
float media;
};
struct struct_student *stud;
FILE *ptr_fis;
int i, j, ns;
char *materii[]={"Analiza","Desen","Programare C","Mecanica","Sport"};
char ssex[6], ssport[6];
float suma_note;
clrscr();
if ((ptr_fis = fopen("STUDENT.DAT", "wb")) == NULL )
{
printf ( "Fisierul:STUDENT.DAT, "
"nu poate fi deschis pentru scriere\n");
exit(1);
}
printf("Numarul de materii(note):");
scanf("%d",&stud->nr_note);
printf("Introduceti numarul de studenti: ");scanf("%d",&ns);
for (i=1;i<=ns;i++)
{
printf("Nume: ");
gets(stud->nume);
printf("Sex (barbat, femeie): ");
gets(ssex);
switch(ssex[0])
{
case 'f': case 'F': stud->sex=femeie; break;
case 'b': case 'B': stud->sex=barbat; break;
}
printf("Sport (fotbal, tenis, inot, volei): ");
gets(ssport);
switch(ssport[0])
{
case 'f': case 'F': stud->sport=fotbal; break;
case 't': case 'T': stud->sport=tenis; break;
case 'i': case 'I': stud->sport=inot; break;
case 'v': case 'V': stud->sport=volei; break;
}
suma_note = 0;
printf("Notele studentului la materiile:\n");
for (j=1; j<=stud->nr_note;j++)
{
printf("%s: ",materii[j]);
scanf("%d", stud->nota[j]);
suma_note += stud->nota[j];
}
stud->media = suma_note / stud->nr_note;
fwrite ( stud, sizeof ( struct struct_student), 1, ptr_fis);
}
fclose(ptr_fis);
if ((ptr_fis = fopen("STUDENT.DAT", "rb")) == NULL )
{
printf ( "Fisierul:STUDENT.DAT, "
"nu poate fi deschis pentru citire\n");
exit(1);
}
while (fread (stud, sizeof (struct struct_student),1, ptr_fis)!=0)
printf("%-*s\n", MAX_NUME, stud->nume);
fclose(ptr_fis);
}
________________________________________________________________________
/* Programul citeste linii de text de la tasatura, si depune
intr-un fisier (cuvinte.txt), cuvintele din acest text;
textul se termina cu RETURN la inceputul unei linii noi, sau
cu CTRL-Z, Return, oriunde in cadrul textului
*/
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define LUNG 20
void main ()
{
FILE *pf;
char *cuvant;
clrscr();
printf("Programul adauga la un fisier de cuvinte (\"cuvinte.txt\")\n"
"cu cuvinte introduse de la tastatura, sau il creeaza(1-a data).\n");
if((pf=fopen("cuvinte.txt", "a+"))==NULL)
{
fprintf(stderr,"nu se poate deschide fisierul:cuvinte.txt\n");
exit(1);
}
puts("Introduceti cuvintele pt adaugare la fisier.");
puts("Pentru terminare tastati ENTER la inceputul unei linii noi, sau");
puts("CTRL-Z, RETURN, oriunde in cadrul textului");
while(gets(cuvant) != NULL && cuvant[0] != '\0')
fprintf(pf, "%s\n", cuvant);
puts("Fisierul contine cuvintele:"); /*trece automat la linie noua */
rewind(pf); /*pozitionare la inceputul fisierului*/
while(fscanf(pf, "%s", cuvant) == 1)
puts(cuvant);
fclose(pf);
}
________________________________________________________________________
/* Programul realizeaza afisare de fisiere, versiunea 1;
se copiaza, de fapt fisierul din linia de comanda la disply ("stdout") */
#include <conio.h>
#include <stdio.h>
main (int argc, char *argv[ ])
{
FILE *fp;
void filecopy (FILE * ,FILE *);
clrscr();
printf("Programul copiaza un fisier din linia de comanda la \"stdout\"\n"
"Daca nu se transmite numele fisierului se copiaza intrarea.\n");
if (argc == 1) /* nu sunt argumente; se va copia intrarea standard*/
{
printf("Nu s-au introdus argumente in linia de comanda!!\n"
"Se va copia intrarea standard\n");
filecopy (stdin, stdout );
}
else
while (--argc > 0)
if (( fp= fopen ( *++argv, "r") ) == NULL)
{
printf("concat: nu se poate deschide %s\n", *argv);
return 1;
}
else
{
printf("Continutul fisierului %s, este:\n", *argv);
filecopy (fp, stdout);
fclose (fp);
printf("\n");
}
printf("\n\n");
return 0;
}
/* copiere fisier: copiaza fisierul ifp in fisierul ofp */
void filecopy (FILE *ifp ,FILE *ofp)
{
int c;
while ( (c = getc(ifp) ) != EOF)
putc (c, ofp);
}
________________________________________________________________________
/* Programul realizeaza afisare fisier, varianta 2, care afiseaza si
numele programului daca nu exista parametru in linia de comanda*/
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
void main(int argc, char *argv[ ])
{
FILE *fp;
void filecopy (FILE * ,FILE *);
char *prog = argv[0];
/* numele programului pentru raportare erori */
clrscr();
printf("\nProgramul realizeaza afisare fisier, varianta 2, care afiseaza\n"
"si numele programului daca nu exista parametru in linia de comanda.\n");
if (argc == 1) /* nu sunt argumente; copiaza intrarea standard */
filecopy (stdin, stdout);
else
while (--argc > 0)
if (( fp= fopen ( *++argv, "r") ) == NULL)
{
fprintf (stderr, "%s: nu se poate deschide %s\n",
prog, *argv );
exit(1);
}
else
{
filecopy (fp, stdout );
fclose(fp);
}
if (ferror (stdout) )
{
fprintf (stderr, "%s: eroare de scriere in stdout\n", prog );
exit (2);
}
exit (0);
}
/* copiere fisier: copiaza fisierul ifp in fisierul ofp */
void filecopy (FILE *ifp ,FILE *ofp)
{
int c;
while ( (c = getc(ifp) ) != EOF)
putc (c, ofp);
}
________________________________________________________________________
/* Programul citeste o lista de nume de fisiere din linia de comanda
si apoi afiseaza numele fiecarui fisier
urmat de ultimile 2(3) linii ale acelui fisier.
*/
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main (int argc, char *argv[])
{
void afis_linie (char *nume, FILE *pfis, int ultimele_linii);
FILE *pf;
int fisier, ultim_lin = 2;
clrscr();
printf("Programul afiseaza ultimele %d linii ale fisierelor.\n", ultim_lin);
printf("Numele fisierelor sunt citite din linia de comanda.\n");
if (argc<2)
{
printf ("ERR: Lipsesc numele fisierelor din linia de comanda.\n");
exit (1);
}
for (fisier =1; fisier < argc; fisier++)
{
if ((pf = fopen (argv[fisier], "r"))== NULL)
printf ("Fisierul: %s, nu poate fi deschis\n", argv [fisier]);

else
afis_linie (argv [fisier], pf, ultim_lin);
printf("\n");
}
}
void afis_linie (char *nume, FILE *pfis, int ultimele_linii)
{
int car;
int linii = 0;
long int contor, start, ultim;
printf ("\nUltimele %d linii ale fisierului %s sunt:\n",
ultimele_linii, nume);
start = ftell (pfis);
/* pozitia de start, intrucat fisierul abia a fost deschis */
fseek(pfis, 0L, SEEK_END);
/* pozitionare la sfarsit */
ultim = ftell(pfis);
for (contor = 1L; contor <= ultim; contor++)
{
fseek(pfis, -contor, SEEK_END);
/* parcurgerea de la sfarsit
catre inceput */
car = getc (pfis);
if (car == '\n')
linii++;
if (linii == ultimele_linii+1)
{
start = ftell(pfis);
break;
}
}
fseek(pfis, start, SEEK_SET);
while ((car = getc(pfis)) != EOF)
putchar(car);
fclose(pfis);
}
________________________________________________________________________
/* Programul realizeza concatenarea fisierelor */
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void main()
{
FILE *pf1, *pf2, *pf3;
char *text1, *text2;
clrscr();
printf("Programul realizeza concatenarea fisierelor.\n");
if ( ( pf1 = fopen ("fis1.txt", "wt") ) == NULL )
{
fprintf (stderr, "Nu se poate deschide fisierul \"fis1.txt\"\n");
exit ( 1 );
}
puts ("Fisierul 1:");
while (gets (text1) != NULL && text1 [0] != '\0')
fprintf (pf1, "%s\n", text1);
fclose (pf1);
{
exit ( 1 );
}
puts ("Fisierul 2:");
while (gets (text1) != NULL && text1 [0] != '\0')
fclose (pf2);
{
exit ( 1 );
}
pf1 = fopen ("fis1.txt", "rt");
while (fscanf (pf1, "%s", text1) == 1)
fclose (pf1);
fclose (pf2);
fclose (pf3);
puts ("Fisierul concatenat: ");
puts (text1);
fclose (pf3);
while (!kbhit());
}
________________________________________________________________________
/* Copierea unui fisier sursa intr-unul destinatie
Programul se va lansa astfel:
cop_fis.exe fis_sursa.txt fis_dest.txt
*/
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
int main (int argc,char*argv[])

{
FILE *in,*out;
int c;
clrscr();
printf("Programul copiaza un fisier sursa intr-unul destinatie.\n"
"Programul se va lansa astfel:\n"
"\t\tcop_fis.exe fis_sursa.txt fis_dest.txt\n");
if (argc!=3)
{
fprintf(stderr,"EROARE: Trebuie doua nume de fisier\n");
}
if (( in=fopen(argv[1],"r"))==NULL)
{ fprintf(stderr,"Nu pot citi : %s.\n",argv[1]);
}
if ((out=fopen(argv[2],"w"))==NULL)
{
fprintf(stderr,"Nu pot scrie in %s.\n",argv[2]);
}
while ((c=getc(in))!=EOF)
putc(c,out);
printf ("Fisierul \"%s\" a fost copiat in fisierul:\"%s\".\n",
argv[1], argv[2]);
return (EXIT_SUCCESS);
}
________________________________________________________________________
/* Programul realizeaza copierea unor linii, cu ecou, pe ecran.
Sfarsitul e o linie doar cu "\n" sau CTRL-Z, RETURN oriunde in text
ecoulinie.c - utilizand fgets ( ) si fputs ( ) */
# include <stdio.h>
# define MAXLINIE 80
main ( )
{
printf("\n\nProgramul reafiseaza la consola, linie cu linie,\n"
"un text introdus de la consola.\n"
"Sfarsitul e o linie doar cu \"\\n\""
" sau CTRL-Z, RETURN oriunde in text\n");
while (fgets (linie, MAXLINIE,stdin)!=NULL&&linie [0]!='\n')
fputs(linie, stdout);
}
________________________________________________________________________
/* Programul copieaza, dintr-un fisier sursa intr-unul destinatie,
fiecare al treilea caracter. Fisierul destinatie va avea acelasi nume

cu cel sursa, dar i se va pune extensia ".red". Numele fisierului
sursa va fi luat din linia de comanda. Se reduce fisierul sursa cu 2/3 */
#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <stdlib.h>
void main (int argc, char*argv[ ])
{
FILE *sursa, *dest;
int car;
char nume [40];
int contor=0;
clrscr();
printf("Fisierul sursa trebuia sa aiba nume fara extensie\n");
printf("Programul reduce dimensiunea fisierului sursa cu 2/3\n");
printf("intr-un fisier destinatie cu acelasi nume + extensia .red\n");
if (argc < 2) /* verificarea numelui fisierului in linia comanda */
{
fprintf (stderr,"Eroare! E necesar un nume de fisier destinatie.\n");
exit (1);
}
if ((sursa = fopen (argv [1], "r")) == NULL)
{
fprintf (stderr,"Nu se poate deschide fisierul:%s\n", argv [1]);
exit (2);
}
strcpy (nume, argv [1]);
/* copiaza numele */
strcat (nume, ".red");
/* adauga extensia la nume */
if ((dest = fopen (nume,"w")) == NULL)
{
fprintf (stderr,"Nu se poate crea fisierul:%s\n", nume);
exit (3);
}
while ((car = getc(sursa)) != EOF)
if (contor++ %3 == 0)
putc (car, dest);
fclose (sursa); fclose (dest);
printf ("\nFisierul sursa are: %d caractere, iar cel destinatie: %d caractere",
contor, contor/3);
}
________________________________________________________________________
/* Calculul lui e^x, utilizand dezvoltarea in serie Taylor:
1 + x/1! + x^2/2! + x^3/3! + . . . + x^n/n! , cu o anumita precizie
si compararea cu valoarea furnizata de functia standard exp(x) */
#include <stdio.h>
#include <math.h>
void main ()
{
double ex, x, precizie, termen;
int n = 0;
printf ("Programul calculeaza exp(x), utilizand seria Taylor;\n"
"Introduceti x=");
scanf ("%lf", &x);
printf ("Precizia de calcul este:");
scanf ("%lf", &precizie);
ex = 1; termen = 1;
do
{
n++;
termen = termen * x / n;
ex = ex + termen;
} while ( termen > precizie );
printf ("seria Taylor exp(%f)=%20.14le, calculata dupa %d iteratii\n", x, ex, n);
printf ("Functia C exp(%f)=%20.14le\n\n", x, exp(x));
}
________________________________________________________________________
/* Programul calculeaza puterea unui numar real, la o putere reala x^n,
folosind metoda logaritmica:
y = x^n;
-> ln(y) = n*ln(x);
-> e^ln(y) = e^(n*ln(x));
-> y = e^(n*ln(x));
*/
# include <stdio.h>
# include <math.h>
main()
{
double x,y,n;
printf ("\nProgram de ridicare la o putere intreaga a unui numar real\n"
"\t\t(metoda logaritmica).\n");
printf ("\nIntroduceti numarul=");
scanf ("%lf", &x);
printf ("Introduceti puterea=");
scanf ("%lf", &n);
y = exp ( n * log ( x ) );
printf ("(%.2lf)^(%.2lf) = %.2lf\n\n", x, n, y);
}
________________________________________________________________________
/* Programul determina o radacina a unei functii f(x)definita de utilizator, separata intr-un interval (a,b),
utilizand metoda injumatatirii intervalului*/
# include <stdio.h>
/*
/*
f(x) = x^2 - 4x -5, care are solutiile x1 = -1, x2 = 5 */
{
double valf;
valf = x*x -4*x -5;
return ( valf );
}
void main()
{
double a, b, mijloc, precizia, modul;
int gasit = 0, nr_iteratii = 0;
printf("\nProgramul localizeaza o radacina a unei functii f(x), separata\n"
"intr-un interval (a,b), cu o anumita precizie data de utilizator,\n"
"utilizand metoda injumatatirii intervalului.\n");
printf("Functia utilizata pentru test este:\n"
"\t\tf(x) = x^2 - 4x -5, cu solutiile: x1=-1 si x2=5.\n");
printf ("Intervalul a,b in care este localizata o radacina: ");
scanf ("%lf", &a);
scanf ("%lf", &b);
printf ("Precizia de localizare a radacinii:");
scanf ("%lf", &precizia);
do
{
nr_iteratii++;
mijloc = (a+b)/2;
if ( f (a) * f (mijloc) < 0 )
b = mijloc;
else if ( f ( mijloc ) * f(b) < 0 )
a=mijloc;
else if ( f ( mijloc ) == 0 )
gasit = 1;
else
{
printf("In intervalul dat (%lf,%lf) nu se afla nici o "
"radacina.\n", a, b);
goto gata;
}
modul =a-b;
if ( modul < 0 )
modul = -modul;
} while ( modul > precizia && !gasit );
printf ("Solutia este : %lf, obtinuta dupa %d iteratii\n\n", ( a+ b)/2,
nr_iteratii);
gata:;
}
/* Programul determina o radacina a unei functii f(x)definita de utilizator, separata intr- un interval (a,b),
utilizand metoda coardei:
ecuatia coardei intre a si b este:
y=m*x+n
undem = ( f(b) - f(a) ) / ( b - a );
n = f(a) - m * a;
se determina pentru fiecare noua pereche ( a , b ) intersectia
coardei cu axa Ox, adica y = 0 :
x = -n / m;
Daca f(a) * f(x) < 0 atunci b = x;
daca f(x) * f(b) < 0 atunci a = x,
altfel s-a gasit radacina;
Algoritmul ia sfarsit cand (b-a) < precizia sau
pentru un numar maxim admis
de iteratii.
*/
#include <stdio.h>
#define MAX_ITERATII 1000
/*
/*
f(x) = x^2 - 4x -5, care are solutiile x1 = -1, x2 = 5 */
{
double valf;
valf = x*x - 4*x - 5;
return ( valf );
}
void main()
{
double a, b, x, x_vechi, m, n, precizia, modul;
int iteratie = 0, gasit = 0;
printf("\nProgramul localizeaza o radacina a unei functii f(x), separata\n"
"intr-un interval (a,b), cu o anumita precizie data de utilizator,\n"
"utilizand metoda \"coardei\".\n");
printf("Functia utilizata pentru test este:\n"
"\t\tf(x) = x^2 - 4x -5, cu solutiile: x1=-1 si x2=5.\n");
printf ("Intervalul a,b in care este localizata o radacina: ");
scanf ("%lf", &a);
scanf ("%lf", &b);
if ( f(a)*f(b) > 0 )
{
printf("In intervalul dat (%lf,%lf) nu se afla nici o "
"radacina.\n", a, b);
goto gata;
}
printf ("introduceti precizia de localizare a radacinii:");
scanf ("%lf", &precizia);
x=a;
do
{
x_vechi = x;
/* daca f(a)=f(b), se modifica putin unul dintre puncte (b+0.1) */
if ( f(b) == f(a) )
b+=0.1;
m = ( f(b) - f(a) ) / ( b - a ); /* panta coardei */
n = f(a) - m * a; /* termenul liber al ecuatiei coardei */
x = -n / m ; /* intersectia cu Ox */
if ( f (a) * f (x) < 0 )
b = x;
else if ( f (x) * f(b) < 0 )
a = x;
else if ( f(x) == 0 )
gasit = 1;
modul = x-x_vechi;
if ( modul < 0 )
modul = -modul;
iteratie++;
} while ( modul > precizia && iteratie < MAX_ITERATII && !gasit);
printf ("Solutia : %20.15lf , obtinuta dupa %d iteratii\n", x, iteratie);
gata:;
}
________________________________________________________________________
/* Programul construieste o coada utilizand o functie
adauga_coada, si apoi tipareste lista de valori intregi,
de tip coada
*/
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
struct s_coada
{
int
valoare;
int
nr_aparitii; /* numarul de aparitii ale numarului in coada */
struct s_coada *urmator;
};
int adauga_coada ( struct s_coada *primul, int val )
{
struct s_coada *ptr_coada;
if ( primul == NULL )
{
primul = (struct s_coada *) malloc (sizeof(struct s_coada));
if ( primul == NULL )
{
printf ("Memorie plina\n");

return ( 0 );
}
else
{
primul -> valoare = val;
primul -> nr_aparitii = 1;
primul -> urmator = NULL;
return ( 1 );
}
}
else
{
ptr_coada = primul ;
while ( ptr_coada -> valoare != val && ptr_coada -> urmator != NULL )
ptr_coada = ptr_coada -> urmator;
if ( ptr_coada -> valoare == val )
{
ptr_coada -> nr_aparitii ++;
return ( 1 );
}
else
{
ptr_coada -> urmator =
( struct s_coada *) malloc(sizeof (struct s_coada));
if ( ptr_coada == NULL )
{
printf ("Memorie plina!\n");
return ( 0 );
}
else
{
ptr_coada -> valoare = val;
ptr_coada -> nr_aparitii = 1;
ptr_coada -> urmator = NULL;
return ( 1 );
}
}
}
}
void afisare_coada ( struct s_coada * primul )
{
struct s_coada *ptr;
ptr = primul;
if (ptr == NULL)
printf("Coada goala!!\n");
while ( ptr != NULL )
{
printf ( "Numar: %d, numar de aparitii: %d\n", ptr -> valoare,
ptr -> nr_aparitii );
ptr = ptr -> urmator;
}
}
void main()
{
struct s_coada *prim = (struct s_coada *) malloc (sizeof(struct s_coada));
/* initializarea adresei variabilei 'prim'; altfel daca prim = NULL
functia 'adauga_coada' nu primeste o adresa valida la care incepe
lista si la care se face actualizarea (adaugare element sau daca
acesta exista se incrementeaza campul 'nr_aparitii')
*/
int numar;
prim -> valoare = 0;
prim -> nr_aparitii = 0;
prim -> urmator = NULL;
clrscr();
printf ("Programul construieste si afiseaza o coada (lista) de numere,\n"
"lista se va termina cu CTRL-Z, ENTER.\nProgramul "
"va afisa numerele din lista si frecventa aparitiei lor.\n");
printf ("Introduceti un numar:");
while ( scanf ("%d", &numar ) != EOF )
{
if (adauga_coada (prim , numar) == 0)
break;
printf ( "Introduceti numar:");
}
afisare_coada ( prim );
free ( prim );
}
________________________________________________________________________
/*
stiva_f.cpp - programul construieste o stiva utilizand o functie
adauga_stiva, si apoi tipareste lista de valori intregi, (stiva)
*/
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
struct s_stiva
{
int valoare;
int nr_aparitii; /* numarul de aparitii ale numarului in stiva */
struct s_stiva *urmator;
};
struct s_stiva * adauga_stiva (struct s_stiva *ultimul, int val)
{
/* functia returneaza un pointer la ultimul element din stiva daca s-a putut
adauga un nou element, sau NULL daca nu s-a adaugat ("Memorie plina")
*/
struct s_stiva *ptr_stiva;
if (ultimul == NULL)
{
ultimul=(struct s_stiva *) malloc (sizeof(struct s_stiva));
if ( ultimul == NULL )
{
printf("Memorie plina\n");
return (NULL);
}
else
{
ultimul->valoare=val;
ultimul->nr_aparitii=1;
ultimul->urmator=NULL;
return (ultimul);
}
}
else
{
ptr_stiva=ultimul ;
while (ptr_stiva->valoare != val && ptr_stiva->urmator != NULL )
ptr_stiva=ptr_stiva->urmator;
if (ptr_stiva->valoare == val)
{ptr_stiva->nr_aparitii ++;
return (ultimul);
}
else
{
ptr_stiva=(struct s_stiva *) malloc(sizeof(struct s_stiva));
if (ptr_stiva == NULL)
{
printf("Memorie plina!\n");
return (NULL);
}
else
{
ptr_stiva->valoare=val;
ptr_stiva->nr_aparitii=1;
ptr_stiva->urmator=ultimul;
return (ptr_stiva);
}
}
}
}
void afisare_stiva (struct s_stiva * ultimul)
{
while (ultimul != NULL)
{
printf("%2d(%2d)->", ultimul->valoare, ultimul->nr_aparitii);
ultimul=ultimul->urmator;
}
printf("NULL\n");
}
main()
{
struct s_stiva *ultim = NULL, *ptrc;
int numar;
clrscr();
printf("Programul construieste si afiseaza o stiva de numere\n");
printf("Introduceti un numar:");
while (scanf("%d", &numar) != EOF)
{
if ((ptrc=adauga_stiva (ultim , numar)) == NULL)
break;
ultim=ptrc;
}
afisare_stiva(ultim);
free (ultim);
}
________________________________________________________________________
/* Programul construieste o coada utilizand o functie
adauga_coada, si apoi tipareste lista de valori intregi, de tip coada */
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
struct s_coada
{
int
valoare;
int
nr_aparitii; /* numarul de aparitii ale numarului in coada */
};
int adauga_coada ( struct s_coada *primul, int val )
{
struct s_coada *ptr_coada;
ptr_coada = primul ;
while ( ptr_coada -> valoare != val && ptr_coada -> urmator != NULL )
if ( ptr_coada -> valoare == val )
ptr_coada -> nr_aparitii ++;
else
{
ptr_coada -> urmator =
( struct s_coada *) malloc(sizeof (struct s_coada));
if ( ptr_coada == NULL )
{
printf ("Memorie plina!\n");
return ( 0 );
}
else
{
ptr_coada -> valoare = val;
ptr_coada -> nr_aparitii = 1;
ptr_coada -> urmator = NULL;
return ( 1 );
}
}
}
void afisare_coada ( struct s_coada * primul )
{
struct s_coada *ptr;
ptr = primul;
if (ptr == NULL)
printf("Coada goala!!\n");
while ( ptr != NULL )
{
printf ( "Numar: %d, numar de aparitii: %d\n", ptr -> valoare,
ptr -> nr_aparitii );
ptr = ptr -> urmator;
}
}
void main()
{
struct s_coada *prim;
int numar;
/* definesc primul element din lista */
prim = (struct s_coada *) malloc (sizeof(struct s_coada));
prim -> valoare = numar;
prim -> nr_aparitii = 1;
prim -> urmator = NULL;
clrscr();
printf ("Programul construieste si afiseaza o coada (lista) de numere,\n"
"lista se va termina cu CTRL-Z, ENTER.\nProgramul "
"va afisa numerele din lista si frecventa aparitiei lor.\n");
printf ("Introduceti numar:");
while ( scanf ("%d", &numar ) != EOF )
{
if (adauga_coada (prim , numar) == 0)
break;
}
afisare_coada ( prim );
free ( prim );
}
________________________________________________________________________
/* Programul citeste cuvinte, de la tastatura, pana la introducerea
cuvantului vid (ENTER la inceputul unei linii, dupa care permite
afisarea cuvintelor ce incep cu o anumita litera (specificata)
Cuvintele citite sunt depuse intr-o lista pe doua niveluri:
- pe primul nivel este lista ce contine literele de inceput ale
cuvintelor introduse;
- pe cel de-al doilea nivel (legat la primul) se afla numai cvintele
ce incep cu litera corespunzatoare nivelului respectiv
*/
#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <stdlib.h>
#define SIZE 20
#define STOP ""
struct s_listh
{
char word[SIZE];
struct s_listh *nexth;
};
struct s_listv
{
char c;
struct s_listh *nexto;
struct s_listv *nextv;
};
struct s_listv * insert (struct s_listv *prim, char cuv[])
{ /* functia insereaza un cuvant in lista (2) si/sau o litera in 1-a lista */
struct s_listv *listv, *prev, *newv;
struct s_listh *listh, *preh, *newh;
int gasit;
prev = NULL;
listv = prim;
gasit = listv->c == cuv[0];
while (!gasit && cuv[0] > listv->c && listv->nextv != NULL)
{
prev = listv;
listv = listv->nextv;
gasit = listv->c == cuv[0];
}
if (gasit)
{
/* daca s-a gasit litera in lista verticala */
listh = listv->nexto;
preh = NULL; /* se cauta pozitia cuvantului in lista orizontala */
while (strcmp(listh->word, cuv) < 0 && listh != NULL)
{
preh = listh;
listh = listh->nexth;
}
newh = (struct s_listh *) malloc(sizeof(struct s_listh));
newh->nexth = listh;
strcpy(newh->word,cuv);
if (preh!=NULL)
preh->nexth = newh;
else
listv->nexto = newh;
}
else /* se insereaza un nou element in lista pe verticala (1-ul nivel) */
{
newv = (struct s_listv *) malloc(sizeof(struct s_listv));
newv->c = cuv[0];
newv->nextv = listv;
if(prev!=NULL)
prev->nextv = newv;
else
prim = newv;
newh = (struct s_listh *)malloc(sizeof(struct s_listh));
newv->nexto = newh;
strcpy(newh->word,cuv);
newh->nexth = NULL;
}
return prim;
}
void afiseaza_cuvinte ( struct s_listv *primu, char carc )
{
struct s_listv *plist;
struct s_listh *pcuv;

plist = primu;
while (plist->c!=carc && plist != NULL)
plist = plist->nextv;
if (plist == NULL)
printf("Lista ordonata (de tip dictionar) nu contine cuvinte "
"ce incep cu \"%c\"\n",carc);
else
{
pcuv = plist->nexto;
while(pcuv != NULL)
{
printf("%s ", pcuv->word);
pcuv = pcuv->nexth;
}
}
}
void main (void)
{
char car,word[SIZE];
struct s_listv *first;
struct s_listh *lh;
first = NULL;
clrscr();
printf("Programul construieste un dictionar cu cuvintele de la tastatura.\n"
"Cuvintele sunt depuse intr-o lista pe doua niveluri:\n"
"-primul nivel contine literele de inceput ale cuvintelor,\n"
"-al doilea nivel contine cuvintele ce incep cu litera respectiva.\n"
"Ambele liste (litere, cuvinte) sunt ordonate alfabetic.\n");
printf("Dupa construirea listei se pot lista cuvintele ce incep cu o anumita"
" litera.\n");
printf("Introducerea cuvintelor si construirea se termina cu un cuvant vid.\n"
"Introduceti cuvinte:\n");
while ( strcmp (gets(word), STOP) !=0 )
{
if (first == NULL)
{
first = (struct s_listv *) malloc (sizeof(struct s_listv));
first -> c = word[0];
lh = (struct s_listh *) malloc (sizeof(struct s_listh));
first -> nexto = lh;
first -> nextv = NULL;
strcpy (lh-> word, word);
lh -> nexth = NULL;
}
else
first = insert (first, word);
}
do
{
printf("Litera din alfabet pentru care vreti sa listati "
"cuvintele introduse: ");
car = getchar();
afiseaza_cuvinte(first,car);
printf("\n");
printf("\nMai doriti afisarea si altor cuvinte? (D/N):");
car = getchar();
} while (car == 'd' || car == 'D');
}
________________________________________________________________________
/* recursiv.cpp - exemplificarea recursivitatii */
/* programul apeleaza functia recursiva "apel_si_revenire"
care afiseaza nivelul apelului si la apelarea recursiva a functiei
si la revenirea din apelul recursiv, dupa apasarea tastei ENTER */
#include <stdio.h>
#include <conio.h>
void apel_si_revenire (int );
main ()
{
clrscr();
apel_si_revenire ( 1 );
}
void apel_si_revenire ( n )
int n;
{
int nr_apeluri = 3; /* numarul de apeluri recursive */
printf("Program de exemplificare a mecanismului functiilor recursive.\n");
printf("Apasa ENTER pentru apel recursiv, n=%d",n);
/* se tipareste nivelul apelului recursiv dupa ce se apasa tasta ENTER */
printf ("Nivel apel: %d.\n", n);
if ( n < nr_apeluri )
apel_si_revenire ( n + 1 );
/* se tipareste nivelul revenirii din apel dupa ce se apasa tasta ENTER */
printf("Apasa ENTER pentru revenire din apelul recursiv, n=%d",n);
printf ("Nivel revenire: %d.\n", n);
}
/* Functia factorial implementata iterativ */

#include<stdio.h>
long int factorial ( long int n )
{
long int j, rezultat = 1;
for ( j = 1 ; j <= n ; ++j )
rezultat *= j;
return ( rezultat );
}
void main(void)
{
long int i;
printf("\nProgramul calculeaza iterativ valoarea factorialului.\n");
printf("\nProgramul se executa pana la citirea unei valoari nenumerice.\n");
printf ( "Valoarea pentru care se calculeaza factorial, i = " );
while ( scanf ( "%li", &i ) == 1)
{
if ( i < 0 )
printf("NU introduceti numere negative.\n\n");
else if ( i > 15 )
printf("Introduceti numere mai mici decat 16.\n\n");
else
printf ("Factorial(%li) = %li\n\n", i, factorial(i));
}
printf("\n");
}
________________________________________________________________________
/* Exemplu de functie recursiva : functia factorial */
#include <stdio.h>
#include <conio.h>
long int factorial ( long int n )
{
long int rezultat;
if ( n <= 0 )
rezultat = 1;
else
rezultat = n * factorial ( n-1 );
}
void main(void)
{
long int i;
printf("\nProgramul calculeaza recursiv valoarea factorialului.\n");
printf("\nProgramul se executa pana la citirea unei valori nenumerice.\n");
printf ("Valoarea pentru care se calculeaza factorial, i = ");
while ( scanf ( "%li", &i ) == 1)

{
if ( i < 0 )
printf("NU introduceti numere negative.\n\n");
else if ( i > 15 )
printf("Introduceti numere mai mici decat 16.\n\n");
else
printf ("\t\tFactorial(%li) = %li\n\n", i, factorial(i));
}
printf("\n");
}
________________________________________________________________________
/* Determinarea sirului Fibonacci utilizand o functie iterativa: */
#include <stdio.h>
int fibi ( int n )
{
int fn1 = 1, fn2 = 1, i , aux;
for ( i = 3 ; i <= n ; ++i )
{
aux = fn1;
fn1 = fn1 + fn2;
fn2 = aux;
}
return ( fn1 );
}
void main ()
{
int
index;
printf("\nProgramul determina iterativ un numar din sirul lui Fibonacci.\n");
do
{
printf ("Pozitia pentru care se determina un numar din sirul "
"Fibonacci (max. 23)\nPoz=");
scanf ("%d", &index );
} while (index < 0 || index > 23);
printf ("Numarul al %d-lea din sir este: %d\n\n", index, fibi (index));
}
________________________________________________________________________
/* Determinarea sirului Fibonacci utilizand o functie recursiva: */
#include <stdio.h>
int fib (int n)
{
int
rezultat;
if (n <= 2 )
rezultat = 1;
else
rezultat = fib ( n-1 ) + fib ( n-2 );
}
void main ()
{
int
index;
printf("\nProgramul determina recursiv un numar din sirul lui Fibonacci.\n");
do
{
printf ("Pozitia pentru care se determina un numar din sirul "
"Fibonacci (max. 23)\nPoz=");
scanf ("%d", &index );
} while (index < 0 || index > 23);
printf ("Numarul al %d-lea din sir este: %d\n", index, fib(index));
}
________________________________________________________________________
/* Programul scrie un cuvant in oglinda (invers), utilizand o functie
recursiva */
#include <stdio.h>
void invers ( void )
{
const char punct = '.';
char c;
c = getchar ( );
if ( c != punct )
invers();
if ( c != punct )
putchar ( c );
}
void main ( )
{
printf("\n\nProgramul afiseaza invers un cuvant (o propozitie) ce se "
"termina cu punct.\nIntroduceti cuvantul:\n");
invers();
printf(".\n");
}
________________________________________________________________________
/* Programul calculeaza puterea intreaga a unui numar real,
folosind o functie recursiva */
#include <stdio.h>
double putere ( double x, int n )
{
double rezultat;
if ( n == 0 )
rezultat = 1;
else if ( n > 0 )
rezultat = x * putere ( x , n - 1 );
else
rezultat = putere ( x , n + 1 ) / x;
}
void main ( void )
{
double numar;
int exponent;
printf("\n\nProgramul calculeaza puterea intreaga a unui numar real,\n");
printf("utilizand o functie recursiva.\n");
printf("Numar = ");
scanf("%lf", &numar);
printf("Putere = ");
scanf("%d", &exponent);
printf("(%.2lf)^(%d) = %.5le\n", numar, exponent, putere(numar, exponent));
}
________________________________________________________________________
/* Problema 'Turnurilor din Hanoi', rezolvata recursiv
*/
#include <stdio.h>
#include <conio.h>
enum pozitie { stanga , mijloc , dreapta};
int nr_linii_ecran = 0;
void tipareste_pozitie ( enum pozitie poz )
{
switch ( poz )
{
case 0 : printf ( "stanga" );/* se poate case stanga */
break;
case 1 : printf ( "mijloc" );
break;
case 2 : printf ( "dreapta" );
}
}
void deplasare( enum pozitie sursa , enum pozitie dest )
{
if ( ++ nr_linii_ecran % 23 == 0 )
{
printf("Apasati ENTER pentru a continua afisarea.");
getchar();
}
printf ( "muta un disc din " );
tipareste_pozitie ( sursa );
printf ( " in " );
tipareste_pozitie ( dest );
printf ( "\n" );
}
void muta ( int n, enum pozitie sursa, enum pozitie inter, enum pozitie dest )
{
if ( n > 0 )
{
muta ( n - 1 , sursa , dest , inter );
deplasare ( sursa , dest );
muta ( n - 1 , inter, sursa , dest );
}
}
void main ()
{
int i , nd;
clrscr();
printf("Problema Turnurilor din Hanoi:\n"
"se muta un turn format din \"n\" discuri de pe pozitia \"stanga\"\n"
"pe pozitia \"dreapta\", utilizand o pozitie intermediara "
"(\"mijloc\"):\n"
"- se muta numai cate 1 disc, la un moment dat si nu se poate pune\n"
"unul de diametru mai mare peste unul de diametru mai mic\n"
"(discurile sunt de diametre diferite si sunt dispuse unul peste "
"altul, initial,\n"
"in ordine descrescatoare a diametrelor- de jos in sus)\n");
printf ("Nr. de discuri :");
scanf ("%d", &nd);
printf ("Mutarile pt. deplasarea unui turn cu %d discuri sunt :\n", nd);
muta (nd , stanga , mijloc , dreapta);
printf("\n\n");
}
________________________________________________________________________
/*
programul afiseaza o valoare intreaga, pozitiva, in binar,
utilizand o functie recursvia pentru conversie
*/
#include <stdio.h>
#include <conio.h>
void binar ( long int k )
{
int r;
r = k % 2;
if ( k >= 2 )
binar ( k / 2 );
putchar ('0' + r);
}
void main (){
long int n;
printf("Programul converteste in binar un numar intreg pozitiv.\n");
printf("Numar de Convertit (stop=valoare nenumerica):");
while ( scanf("%li",&n) == 1 )
{
printf("Reprezentarea binara este: ");
binar ( n );
printf("\n\n");
printf("Numar de Convertit (stop=valoare nenumerica):");
}
}
________________________________________________________________________
/* Programul afiseaza cifrele unui numar n zecimal in ordine ineversa
utilizand o functie recursiva
*/
#include <stdio.h>
void afis_inv (long int n)
{
if (n < 0)
{
putchar ('-');
n = -n;
}
putchar (n % 10 + '0');
if (n / 10)
afis_inv (n / 10);
}
void main(void)
{
long int numar;
printf("Progr. afiseaza cifrele unui numar intreg in ordine inversa.\n");
printf ("Numar= ");
printf("Invers=");
afis_inv (numar);
printf ("\n\n");
}
________________________________________________________________________
/* Programul afiseaza o valoare intreaga, pozitiva, in binar si hexa,
utilizand, pentru conversie, functii recursive */
#include <stdio.h>
#include <conio.h>
int
n;
void binar ( int k )

{
if ( k > 1 ) {
binar ( k/2 );
printf ("%i", k % 2 );
}
else
if ( k )
printf ("1");
}
void afishexa ( int k )
{
if ( k < 10 )
printf("%i",k);
else
printf("%c", k-10+'A');
}
void hexa ( int k )
{
if ( k > 15 ){
hexa ( k/16 );
afishexa ( k%16 );
}
else
if ( k )
afishexa ( k );
}
void main (){
printf("\nProgramul afiseaza in binar si hexazecimal un numar intreg.\n");
printf("Numar de afisat in binar/hexazecimal :");
scanf("%i",&n);
printf("Reprezentarea binara este: ");
binar ( n );
printf("\n");
printf("Apasati ENTER pentru a continua.\n");
getch();
printf("Reprezentarea hexazecimala este: ");
hexa ( n );
printf("\n");
printf("Apasati ENTER pentru a termina programul.\n");
getch();
}
________________________________________________________________________
/* Programul ordoneaza un vector apeland functia recursiva "qsort :
ordoneaza v[stanga]... v[dreapta] in ordine crescatoare" */
#include <stdio.h>
#define MAX 10
void qsort ( int v[ ] , int stanga, int dreapta )
{
int i, ultim;
void swap ( int v[ ], int i, int j ) ;
if ( stanga >= dreapta ) /* nu face nimic daca vectorul contine */
return ;
swap ( v, stanga, ( stanga + dreapta )/2) ; /* muta elementul de partitie */
ultim = stanga;
/* la v[ 0 ] */
for ( i = stanga + 1 ; i <= dreapta ; i++)
/* partitia */
if ( v[i] < v[stanga] )
swap (v, ++ultim, i );
swap ( v, stanga, ultim ); /* reface elementul de partitie */
qsort ( v, stanga, ultim-1 );
qsort ( v, stanga+1, dreapta ) ;
}
void swap ( int v[ ] , int i , int j )
{
int temp ;
temp = v[i];
v [i] = v[j];
v [j] = temp ;
}
void main (void)
{
int
vector[MAX];
int
i, n;
printf("\nProgr. ordoneaza un vector utilizand functia recursiva qsort.\n");
printf("Dimensiune vector: ");
scanf("%d",&n);
printf("Elementele vectorului:\n");
for (i = 0 ; i < n ; i++)
{
printf("v(%d)= ",i+1);
scanf("%d", &vector[i]);
}
qsort(vector, 0, n-1);
printf("\nVectorul ordonat este:\n");
for (i = 0 ; i < n ; i++)
printf("v(%d)=%d\n", i+1, vector[i]);
printf("\n\n");
}
________________________________________________________________________
/* Programul ordoneaza recusiv un vector apeland functia recursiva
qsort : ordoneaza v[stanga]... v[dreapta] in ordine crescatoare */

#include <stdio.h>
#include <math.h>
#define MAX 1000
void qsort ( int v[ ] , int stanga, int dreapta )
{
int i, ultim;
void swap ( int v[ ], int i, int j ) ;
if ( stanga >= dreapta ) /* nu face nimic daca vectorul contine */
return ;
swap ( v, stanga, ( stanga + dreapta )/2) ; /* muta elementul de partitie */
ultim = stanga;
/* la v[ 0 ] */
for ( i = stanga + 1 ; i <= dreapta ; i++)
/* partitia */
if ( v[i] < v[stanga] )
swap (v, ++ultim, i );
swap ( v, stanga, ultim ); /* reface elementul de partitie */
qsort ( v, stanga, ultim-1 );
qsort ( v, stanga+1, dreapta ) ;
}
void swap ( int v[ ] , int i , int j )
{
int temp ;
temp = v[i];
v [i] = v[j];
v [j] = temp ;
}
void main ( void )
{
int vector[MAX], i, n, nel=0, max, nrcifre;
printf("\nProgramul ordoneaza un vector cu metoda recursiva \"qsort\".\n");
printf("Difera fata de prima varianta doar modul de afisare.\n");
printf("Numarul de elemente ale vectorului: ");
scanf("%d", &n);
for ( i = 0 ; i < n ; i++ )
{
printf("v[%d]= ", i+1);
scanf("%d", &vector[i]);
}
/* pentru a determina numarul de campuri necesare */
/* pentru afisarea unui element al vectorului ordonat */
/* se determina maximul in modul */
max = abs (vector[0]);
for ( i = 1 ; i < n ; i++ )
if ( max < abs (vector[i]) )
max = abs(vector[i]);
/* dupa care se determina numarul de cifre pentru afisarea maximului */
nrcifre = 0;
while (max)
{
nrcifre++;
max = max /10;
}
qsort( vector, 0, n-1);
for ( i = 0 ; i < n ; i++ , nel++)
{
if (!(nel % 4))
printf("\n");
printf("v[%d]=%*d ", i+1, nrcifre+1, vector[i]);
}
printf("\n");
}
________________________________________________________________________
/* Programul afiseaza n invers, in zecimal utilizand o functie recursiva */
#include <stdio.h>
void printinv ( long int n )
{
if ( n < 0 )
{
putchar ('-');
n = -n;
}
putchar (n % 10 + '0');
if ( n / 10 )
printinv (n / 10);
}
void main (void)
{
long int numar;
printf("\nProgramul afiseaza invers un numar, folosind o functie recursiva.\n");
printf("Numar= ");
scanf("%ld", &numar);
printf("Invers=");
printinv(numar);
printf("\n");
}
________________________________________________________________________
/* constivr.cpp - programul construieste o coada de numere intregi, pe care
o afiseaza, utilizand functii recursive: adaug_coada, afisez_coada */
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
struct s_coada
{
int
valoare;
};
int nr_val_linie=0; /* contor pentru nr. de valori afisate pe linie */
void adaug_coada (struct s_coada *primul, int val)
{
/*Functia returneaza un pointer la primul element din coada daca s-a putut
adauga un nou element, sau NULL daca nu s-a adaugat ("Memorie plina!") */
if (primul->urmator==NULL){
primul->urmator=(struct s_coada *)malloc(sizeof(struct s_coada));
if(!primul->urmator)
{printf("Memorie plina!!!\n");
exit(1);
}
primul=primul->urmator;
primul->valoare=val;
primul->urmator=NULL;
}
else
adaug_coada(primul->urmator, val);
}
void afisez_coada(struct s_coada *primul)
{
if (primul)
{
printf("%2d-> ", primul->valoare);
nr_val_linie++;
if (nr_val_linie%8==0)
printf("\n");
afisez_coada(primul->urmator);
}
}
void eliberare_spatiu (struct s_coada *ptrs){
struct s_coada *p=ptrs;
if(p){ ptrs=p;
p=p->urmator;
free(ptrs);
eliberare_spatiu(p);
}
}
void main()
{
struct s_coada *prim=NULL;
int numar;
clrscr();
printf("Prg. construieste si afiseaza o coada de nr. intregi, distincte.\n");
printf("Introducerea se termina cu EOF(CTRL-Z, ENTER.\n");
prim=(struct s_coada *)malloc(sizeof(struct s_coada));
if(!prim)
{printf("Memorie plina!!!\n");
exit(1);
}
prim->valoare=numar;
prim->urmator=NULL;
while(scanf("%d", &numar)!=EOF)
{adaug_coada(prim, numar);
}
afisez_coada(prim);
printf("NULL\n");
eliberare_spatiu(prim);
}
________________________________________________________________________
#include <stdio.h>
#include <conio.h>
#define NMAX 9
/* dimensiune maxima pentru tabla de sah +1 */
#define N 6 /* dimensiunea efectiva a tablei+ 1 */
#define NSQ 25
/* NSQ = N^2 */
int a[NMAX]={0, 1, 1, 2, 2,-1,-1,-2,-2};
int b[NMAX]={0, 2,-2, 1,-1, 2,-2, 1,-1};
int h[NMAX][NMAX];
void main(void)
{
void muta (int i, int x, int y, int *q);
int l, c, *q;
clrscr();
for (l=1 ; l < N ; l++)
for (c=1 ; c < N ; c++)
h[l][c] = 0;
h[1][1]=1;
muta(2, 1, 1, q);
if (*q)
{
for (l=1 ; l < N ; l++)
{
for ( c=1 ; c < N ; c++)
printf("%3d ",h[l][c]);
printf("\n");
}
}
else
printf("Nu exista solutie\n");
}
void muta (int i, int x, int y, int *q)
{
int u,v;
int *q1;
int k = 0; /* initializare selectie mutari */
do
{
k = k + 1;
/* selectie urmatorul candidat din lista de mutari */
u = x + a[k];
v = y + b[k];
*q1 = 0;
if (u>=1 && u<N && v>=1 && v<N && h[u][v]==0)
{
h[u][v] = i;
if ( i < NSQ )
{
muta(i+1, u, v, q1);
if (!(*q1))
h[u][v] = 0;
}
else
*q1 = 1;
}
}while(!*q1 && k<8);
*q = *q1;
}
________________________________________________________________________
/* Programul rezolva problema "turul calului", adica acoperirea unei table
de sah prin muatrea unui "cal", cu conditia ca fiecara casuta a tablei
de sah sa fie parcursa o singura data. Problema se rezolva prin metoda
"back tracking" */
#include <stdio.h>
#include <conio.h>
#define NMAX 9
#define NSQ 25
/* NSQ = N^2 */
int a[NMAX]={0, 1, 1, 2, 2,-1,-1,-2,-2};
int b[NMAX]={0, 2,-2, 1,-1, 2,-2, 1,-1};
int h[NMAX][NMAX];
int nr_sol=0, nr_ramuri=0;
void main(void)
{
void muta (int i, int x, int y);
int l, c;
clrscr();
for (l=1 ; l < N ; l++)
for (c=1 ; c < N ; c++)
h[l][c] = 0;
h[1][1]=1;
muta(2, 1, 1);
printf("\nNumarul total de solutii: %d", nr_sol);
printf("\nNumarul total de incercari (ramuri arbore incercari): %d\n",
nr_ramuri);
}
void muta (int i, int x, int y)
{
void afiseaza_solutie(void);
int k, u, v;
for ( k = 1; k <= 8; k++) /* selectie mutarea urmatoare */
{
u = x + a[k];
v = y + b[k];
if (u>=1 && u<N && v>=1 && v<N && h[u][v]==0)
{
h[u][v] = i;
if ( i < NSQ )
muta(i+1, u, v);
else
afiseaza_solutie();
h[u][v] = 0;
}
else
nr_ramuri++; /* s-a ajuns intr-o "fundatura" */
}
}
void afiseaza_solutie(void)
{
int l, c;
nr_sol++;
for ( l = 1; l < N; l++)
{
for ( c = 1; c < N; c++)
printf("%3d", h[l][c]);
printf("\n");
}
printf("\n");
if (nr_sol %4 == 0)
getch();
}
________________________________________________________________________
/* Programul rezolva problema "turul calului", adica acoperirea unei table
de sah prin muatrea unui "cal", cu conditia ca fiecara casuta a tablei
de sah sa fie parcursa o singura data. Problema se rezolva prin metoda
"back tracking" */
#include <stdio.h>
#include <conio.h>
#define NMAX 9
#define NSQ 25
/* NSQ = N^2 */
int a[NMAX]={0, 1, 1, 2, 2,-1,-1,-2,-2};
int b[NMAX]={0, 2,-2, 1,-1, 2,-2, 1,-1};
int h[NMAX][NMAX];
int nr_sol=0, nr_ramuri=0;
void main(void)
{
void muta (int i, int x, int y);
int l, c;
clrscr();
for (l=1 ; l < N ; l++)
for (c=1 ; c < N ; c++)
h[l][c] = 0;
h[1][1]=1;
muta(2, 1, 1);
printf("\n\nNumarul total de solutii: %d", nr_sol);
printf("\nNumarul total de incercari (ramuri arbore - incercari): %d\n",
nr_ramuri);
getch();
}
void muta (int i, int x, int y)
{
void afiseaza_solutie(void);
int k, u, v;
for ( k = 1; k <= 8; k++) /* selectie mutarea urmatoare */
{
u = x + a[k];
v = y + b[k];
if (u>=1 && u<N && v>=1 && v<N && h[u][v]==0)
{
h[u][v] = i;
if ( i < NSQ )
muta(i+1, u, v);
else
afiseaza_solutie();
h[u][v] = 0;
}
else
nr_ramuri++; /* s-a ajuns intr-o "fundatura" */
}
}
void afiseaza_solutie(void)
{
int l, c, xe, ye;
xe = nr_sol % 4;
ye = (nr_sol / 4) % 4;
for ( l = 1; l < N; l++)
{
for ( c = 1; c < N; c++)
{
gotoxy ( xe*20+1 + (c-1)*3, ye*6 + l);
printf("%2d", h[l][c]);
}
}
nr_sol++;
if (nr_sol % 16 == 0)
{
printf("\nApasati ENTER pentru a continua afisarea solutiilor.");
getch();
}
}
________________________________________________________________________
/* Programul ordoneaza valorile de pe diagonala unei matrici,
utilizand un algoritm backtracking */
#include <stdio.h>
#define NR_MAX 20
int a[NR_MAX][NR_MAX], nr_sol=0;
int nl , nc , l , c;
void main (void)

{
void incearca ( int );
printf("\nProgramul ordoneaza valorile de pe diagonala unei matrici,\n"
"utilizand un algoritm backtracking, furnizand toate solutiile.\n");
printf("Numarul de linii/coloane ale matricii:");
scanf("%d%d",&nl,&nc);
for ( l = 0 ; l < nl ; l++ )
for ( c = 0 ; c < nc ; c++ )
{
printf("a[%d,%d]=",l+1,c+1);
scanf("%d", &a[l][c]);
};
getchar();
printf("\nMatricea initiala este:\n");
for (l = 0 ; l < nl ; l++ )
{
for ( c = 0 ; c < nc ; c++ )
printf("%4d", a[l][c]);
printf("\n");
};
getchar();
incearca (0); /* apel functia recursiva de ordonare (backtracking) */
printf("\nIn total au fost gasite %d solutii.\n", nr_sol);
getchar();
}
void incearca ( int i )
{
/* functia furnizeaza toate solutiile posibile, utilizand backtracking */
int lin , col , l , c ;
int
aux ;
for ( lin = i ; lin < nl ; lin++ )
for ( col = i ; col < nc ; col ++ )
{/* se cauta urmatoarea valoare mai mare in submatricea ramasa
[(i,i);(nl,nc)]
*/
if (( i > 0 && a[lin][col] >= a[i-1][i-1] ) || (i == 0))
{/* daca este gasita, se vor interschimba liniile respective */
for ( c = 0 ; c < nc ; c++ )
{ aux = a[i][c];
a[i][c] = a[lin][c];
a[lin][c] = aux;
};
for ( l= 0 ; l < nl ; l++ )
{/* si se interschimba si coloanele respective */

aux = a[l][i];
a[l][i] = a[l][col];
a[l][col] = aux;
}; /* daca nu s-a terminat de ordonat toata diagonala,
se continua
*/
if (i < nl - 1)
incearca ( i+1 );
else
{ /* daca s-a terminat o diagonala de ordonat se tipareste */
nr_sol++;
printf("Solutia %d :\n", nr_sol);
for (l = 0 ; l < nl ; l++ )
{
for ( c = 0 ; c < nc ; c++ )
printf("\n");
};
getchar();
/* se continua programul dupa apasarea unei taste */
};
/* se aduce matricea in forma initiala, prin interschimarea,
din nou, a liniilor si a coloanelor ultim interschimbate,
sau, altfel spus, se sterge ultima solutie (inregistrare)
si se continua
*/
for ( c= 0 ; c < nc ; c++ )
{
aux = a[i][c];
a[lin][c] = aux;
};
for ( l = 0 ; l < nl ; l++ )
{
aux = a[l][i];
a[l][col] = aux;
};
};
};
}
________________________________________________________________________
/* Programul ordoneaza valorile de pe diagonala unei matrici,
utilizand un algoritm backtracking */
#include <stdio.h>
#include <conio.h>
#define NR_MAX 20
int a[NR_MAX][NR_MAX];
int nl , nc , l , c , q;
void main (void)
{
int incearca ( int i, int *q );
printf("\nProgramul ordoneaza valorile de pe diagonala unei matrici,\n"
"utilizand metoda backtracking, furnizand doar prima solutie.\n");
printf("Numarul de linii/coloane ale matricii:");
scanf("%d%d",&nl,&nc);
for ( l = 0 ; l < nl ; l++ )
for ( c = 0 ; c < nc ; c++ )
{
printf("a[%d,%d]=",l+1,c+1);
scanf("%d", &a[l][c]);
};
printf("\nMatricea initiala este:\n");
for (l = 0 ; l < nl ; l++ )
{
for ( c = 0 ; c < nc ; c++ )
printf("\n");
};
printf("\nS-a citit matricea, se cauta o solutie. Pentru afisarea ei "
"tastati ENTER.\n");
getch();
/* daca functia "incearca" returnaeaza o solutie se va tipari aceasta */
if ( incearca(0, &q) )
for (l = 0 ; l < nl ; l++ )
{
for ( c = 0 ; c < nc ; c++ )
printf("\n");
}
else
printf("Nu exista solutie!!!\n");
printf("Pentru terminare program tastati ENTER.\n");
getch();
}
int incearca ( int i , int *q )
{
/* functia furnizeaza o solutiile posibila, utilizand backtracking */
int lin , col , l , c ;
int
aux, q1;
lin = i; col = i;
do
{
q1 = 0;
if (( i > 0 && a[lin][col] >= a[i-1][i-1] ) || (i == 0))
{/* se cauta urmatoarea valoare mai mare in submatricea ramasa
[(i,i);(nl,nc)] */
/* pentru care se vor interschimba liniile respective */
for ( c = 0 ; c < nc ; c++ )
{
aux = a[i][c];
a[lin][c] = aux;
};
/* si se interschimba si coloanele respective */
for ( l= 0 ; l < nl ; l++ )
{
aux = a[l][i];
a[l][col] = aux;
};
if (i < nl-1)
{
incearca ( i+1 , &q1 );
if (!q1)
{
/* se anuleaza ultima alegere, prin refacerea
matricei interschimband, la loc, ultima
interschimbare de linii si de coloane
*/
for ( c= 0 ; c < nc ; c++ )
{
aux = a[i][c];
a[lin][c] = aux;
};
for ( l = 0 ; l < nl ; l++ )
{
aux = a[l][i];
a[l][col] = aux;
};
};
}
else
q1 = 1;
};
if (col == nc-1 )
{
col = i;
lin++;
}
else
col++;
} while (!q && lin < nl-1);
*q = q1;
return (q1);
}
________________________________________________________________________
/* Programul determina o solutie pentru pozitiile a 8 regine amplasate
pe tabla de sah astfel incat ele sa nu se "atace" reciproc;
pe fiecare linie si pe fiecare coloana a matricii va fi doar cate o
regina.
*/
#include <stdio.h>
#include <conio.h>
int x[9]; /* pozitia reginei in linia curenta, i */
int a[9]; /* nu este regina pe coloana curenta, j */
int b[15]; /* nu este acoperita diagonala dreapta */
int c[15]; /* nu este acoperita diagonala stanga */
int i, q;
void incearca (int i, int *q)
{
int j=0, *q1;
do
{
j++; /* selectie urmatoarea pozitie din linie */
if (a[j] && b[i-j+7] && c[i+j])
{
x[i]=j; a[j]=0; b[i-j+7]=0;
c[i+j]=0; *q1=0; /* pune regina */
if ( i < 8 )
{
incearca(i+1,q1);
if ( !(*q1) )
{ /* scoate regina */
a[j]=1;
b[i-j+7]=1;
c[i+j]=1;
}
}
else
*q1=1;
}
} while ( !*q1 && j < 8 );

*q = *q1;
};
void main (void)
{
clrscr();
for (i=1; i <=8; i++)
a[i] = 1;
for (i=0; i <=14; i++)
b[i] = 1;
for (i=0; i <=14; i++)
c[i] = 1;
printf("\nProgramul determina o solutie pentru pozitiile a 8 regine amplasate"
"\npe tabla de sah, astfel incat ele sa nu se \"atace\" reciproc;\n"
"Pe fiecare linie si pe fiecare coloana a matricii va fi doar "
"cate o regina.\n");
incearca(1,&q);
if ( !q )
printf("\nNu exista solutii!!!.\n");
else
{
printf("\nSolutia gasita este urmatoarea:\n\n");
for (i=1; i <=8; i++)
printf("%*d%*s\n",2*(x[i]-1)+2, x[i], 2*(8-x[i]), " ");
}
printf("\n");
}
________________________________________________________________________
/* Programul determina toate solutiile pentru amplasarea pe tabla de sah
a 8 regine astfel incat ele sa nu se "atace" reciproc;
pe fiecare linie si pe fiecare coloana a matricii va fi doar cate o
regina.
*/
#include <stdio.h>
#include <conio.h>
int x[9]; /* pozitia reginei in linia curenta, i */
int a[9]; /* nu este regina pe coloana curenta, j */
int b[15]; /* nu este acoperita diagonala dreapta */
int c[15]; /* nu este acoperita diagonala stanga */
int i, nr_sol=0;
void afiseaza_solutia () {
int i;
nr_sol++;
printf("\nSolutia nr. %d este:\n", nr_sol);
for (i=1; i <=8; i++)

printf("%*d%*s\n",2*(x[i]-1)+2, x[i], 2*(8-x[i]), " ");
printf("\n");
getchar();
}
void incearca (int i)
{
int j;
for (j=1; j<=8; j++)
{ /* selectie urmatoarea pozitie din linie */
if (a[j] && b[i-j+7] && c[i+j])
{
x[i]=j; a[j]=0; b[i-j+7]=0;
c[i+j]=0; /* pune regina */
if ( i < 8 )
incearca(i+1);
else
afiseaza_solutia();
/* scoate regina */
a[j]=1;
b[i-j+7]=1;
c[i+j]=1;
}
};
};
void main (void)
{
clrscr();
for (i=1; i <=8; i++)
a[i] = 1;
for (i=0; i <=14; i++)
b[i] = 1;
for (i=0; i <=14; i++)
c[i] = 1;
printf("\nProgramul determina solutiile pentru pozitiile a 8 regine "
"amplasate\npe tabla de sah, astfel incat ele sa nu se \"atace\" "
"reciproc;\nPe fiecare linie si pe fiecare coloana a matricii "
"va fi doar cate o regina.\n");
incearca(1);
printf("\nApasati tasta ENTER pentru a afisa numarul total de solutii.\n");
getchar();
printf("Au fost gasite, in total, %d solutii.\nTastati ENTER pentru a "
"termina programul.\n", nr_sol);
getchar();}
/* Programul determina solutia incarcarii unui rucsac cu obiecte,

dintr-un numar de obiecte, astfel incat castigul sa fie maxim.
Rucsacul are o anumita capacitate (in Kg), si de asemenea, fiecare
obiect are o greutate proprie, dar fiecare obiect are asociata si o
anumita pondere (importanta sau castig). Alegerea obiectelor se face
prin includerea completa (adica a obiectelor intregi) maximizand
"castigul" total. Se utilizeaza metoda "backtracking"
*/
#include <stdio.h>
#include <conio.h>
int g[11], c[11], st[11], sts[11];
int as, ev, n, k, i, greutate, cs, ccalc;
void init (int st[], int k)
{
st[k] = -1;
}
void valid ( int st[], int k, int *pev )
{
int i, gr=0;
for (i = 1; i <= k; i++ )
gr += st[i]*g[i];
if ( gr <= greutate )
*pev = 1;
else
*pev = 0;
}
void succesor ( int st[], int k, int *pas )
{
if ( st[k] < 1 )
{
st[k] += 1;
*pas = 1;
}
else
*pas = 0;
}
int solutie (int k )
{
return ( k == n );
}
void main ( void )
{
clrscr();
printf("Programul determina solutia incarcarii unui rucsac cu obiecte,\n"
"dintr-un numar dat de obiecte, astfel incat castigul sa fie maxim.\n"
"Rucsacul are o anumita capacitate (in Kg), si de asemenea, fiecare\n"
"obiect are o greutate proprie, dar fiecare obiect are asociata si o\n"
"anumita pondere (importanta sau castig). Alegerea obiectelor se face\n"
"prin includerea completa (adica a obiectelor intregi) maximizand\n"
"\"castigul\" total.\n");
printf("\nNumarul de obiecte de introdus in rucsac:");
scanf("%d", &n);
printf("Capacitatea rucsacului (Kg) : ");
scanf("%d", &greutate);
for ( i = 1; i <= n; i++)
{
printf("\nGreutatea obiectului [%d] = ",i);
scanf("%d", &g[i]);
printf("Importanta obiectului [%d] = ", i);
scanf("%d", &c[i]);
}
for ( i = 1; i <= n; i++)
sts[i] = 0;
cs = 0;
init( st, 1 );
k = 1;
while ( k > 0 )
{
do {
succesor( st, k, &as);
if (as)
valid(st, k, &ev);
} while (as && (!as || !ev));
if (as)
if ( solutie(k) )
{
ccalc = 0;
for ( i = 1; i <= n; i++ )
ccalc += c[i]*st[i];
if (ccalc > cs )
{
for ( i = 1; i <= n; i++)
sts[i] = st[i];
cs = ccalc;
}
}
else
{
k++;
init( st, k);
}
else
k--;
}
printf("\nSolutia problemei este (numai obiectele luate in rucsac):\n");
printf("Obiectele puse in rucsac : ");
for ( i = 1; i <= n; i++ )
if (sts[i])
printf("%d; ", i);
printf("\n");
printf("\nCastig : %d\n", cs);
getch();
}
________________________________________________________________________
#include <stdio.h>
#include <conio.h>
#define NMAX 9
#define NSQ 25
/* NSQ = N^2 */
int a[NMAX]={0, 1, 1, 2, 2,-1,-1,-2,-2};
int b[NMAX]={0, 2,-2, 1,-1, 2,-2, 1,-1};
int h[NMAX][NMAX];
void main(void)
{
void muta (int i, int x, int y, int *q);
int l, c, *q;
clrscr();
for (l=1 ; l < N ; l++)
for (c=1 ; c < N ; c++)
h[l][c] = 0;
h[1][1]=1;
muta(2, 1, 1, q);
if (*q)
{
for (l=1 ; l < N ; l++)
{
for ( c=1 ; c < N ; c++)
printf("%3d ",h[l][c]);
printf("\n");
}
}
else
printf("Nu exista solutie\n");
}
void muta (int i, int x, int y, int *q)
{
int u,v;
int *q1;
int k = 0; /* initializare selectie mutari */
do
{
k = k + 1;
/* selectie urmatorul candidat din lista de mutari */
u = x + a[k];
v = y + b[k];
*q1 = 0;
if (u>=1 && u<N && v>=1 && v<N && h[u][v]==0)
{
h[u][v] = i;
if ( i < NSQ )
{
muta(i+1, u, v, q1);
if (!(*q1))
h[u][v] = 0;
}
else
*q1 = 1;
}
}while(!*q1 && k<8);
*q = *q1;
}
________________________________________________________________________
/* Program ordonare sir , utilizand metoda de selectie directa
*/
#include <stdio.h>
#include <conio.h>
void ordonare_sel_dir(double sir[], int nrelem)
{
int i,j;
double aux;
for(i=0;i<nrelem-1;++i)
for(j=i+1;j<nrelem;++j)
if(sir[i]>sir[j])
{
aux=sir[i];
sir[i]=sir[j];
sir[j]=aux;
}
}
main()
{
int ne,i;
clrscr();
printf("Program ordonare sir, utilizand metoda de selectie directa.\n");
printf("\nNumarul de elemente din sirul de ordonat: ");
scanf("%d",&ne);
printf("\nIntroduceti cele %d elemente ale sirului.\n\n", ne);
for (i=0;i<ne;++i)
{
printf("sir(%d)=",i+1);
scanf("%lf",&val);
sir[i]=val;
}
ordonare_sel_dir(sir,ne);
printf("\nSirul ordonat este:\n\n");
for(i=0;i<ne;++i)
printf("sir(%2d)=%7.2lf ",i,sir[i]);
}
________________________________________________________________________
/* Programul ordoneaza un sir de valori utilizand metoda binara,
folosind o functie sort_ins_binara.
*/
#include<stdio.h>
#include <conio.h>
/*
functia de sortare prin inserare binara
*/
void sort_ins_binara ( double a[], int n )
{
double x;
int i, j, s, d, m;
for ( i = 1 ; i < n ; ++i )
{
x = a[i]; s = 0; d = i - 1;
while ( s <= d )
{
m = ( s + d )/2;
if ( x < a[m] )
d = m - 1;
else
s = m + 1;
}
for ( j = i-1 ; j >= s ; --j )
a[j+1] = a[j];
a[s] = x;
}
}
main()
{
double sir[100];
int ne,i;
clrscr();
printf("Programul ordoneaza un sir de valori utilizand metoda binara.\n");
printf("Numar elemente:");
scanf("%d",&ne);
for(i=0;i<ne;i++)
{
scanf("%lf",&sir[i]);
}
printf("\nSirul ordonat este: \n");
sort_ins_binara(sir , ne);
for (i=0;i<ne;i++)
{
printf(" sir (%2d) = %lf \n" , i+1 , sir[i]);
}
}
________________________________________________________________________
/* Programul ordoneaza un sir de valori prin selectie directa,
utilizand o functie sort_ins_direct
*/
#include <stdio.h>
#include <conio.h>
/*
functia de sortare prin inserare directa
*/
void sort_ins_direct ( double a[], int n )
{
double x;
int i,j;
for ( i = 1 ; i < n ; ++i )
{
x = a[i];
j = i - 1;
while ( x < a[j] && j >= 0 )
{
a[j+1] = a[j];
j--;
}
a[j+1] = x;
}
}
main()
{
double sir[100];
int ne,i;
clrscr();
printf("Programul ordoneaza un sir de valori prin selectie directa.\n");
printf("Numar elemente:");
scanf("%d",&ne);
for(i=0;i<ne;i++)
{
scanf("%lf",& sir[i]);
}
sort_ins_direct (sir,ne);
printf("\n Sirul ordonat:\n");
for(i=0;i<ne;i++)
{
printf(" sir(%d)=%5.2lf ",i+1,sir[i]);
if ( (i+1) %5 == 0 )
printf("\n");
}
printf("\n");
}
________________________________________________________________________
/* Programul ordoneaza un sir de valori utilizand algoritmul "quicksort"
si foloseste o functie 'quicksort' pentru ordonarea sirului
*/
#include<stdio.h>
#include <conio.h>
int a[100];
main()
{
void quiksort ( int s, int d );
int ne,i;
clrscr();
printf("Programul ordoneaza un sir de valori utilizand algoritmul \"quicksort\".\n");
printf("\nNumar elemente:");
scanf("%d",&ne);
for(i=0;i<ne;i++)
{
scanf("%d",&a[i]);
}
quiksort (0 , ne-1);
for (i=0;i<ne;i++)
{
printf(" sir (%2d) = %d \n" , i+1 , a[i]);
}
}
/*
functia de sortare QUICKSORT
*/
void quiksort ( int s, int d )
{
int x,w;
int i=s , j=d , p;
p = ( s + d )/2;
x = a[ p ];
do
{
while ( a[i] < x && i <= d )
i = i + 1;
while ( x < a[j] && j >= s )
j = j - 1;
if ( i <= j )
{
w = a[i]; a[i] = a[j]; a[j] = w;
i = i + 1; j = j - 1;
}
}
while ( i <= j );
if ( s < j ) quiksort(s,j);
if ( i < d ) quiksort(i,d);
}
________________________________________________________________________
/* Programul ordoneaza un sir de valori prin selectie directa,
utilizand o functie de sortare
*/
#include<stdio.h>
#include <conio.h>
void sort_sel_direct ( double a[], int n )
/*
functia sorteaza un vector prin metoda de selectie directa

*/
{
double x;
int i, j , k;
for ( i = 0 ; i < n-1 ; ++i )
{
k = i;
x = a[i];
for ( j = i+1 ; j < n ; ++j )
if (a[j] < x)
{
k = j;
x = a[k];
}
a[k] = a[i];
a[i] = x;
}
}
main()
{
double sir[100];
int ne,i, nl=0;
clrscr();
printf("Programul ordoneaza un sir de valori prin selectie directa.\n");
scanf("%d",&ne);
for(i=0;i<ne;i++)
{
}
sort_sel_direct(sir,ne);
printf("\nSirul ordonat este:\n");
for(i=0;i<ne;i++)
{
printf(" sir(%2d)=%5.1lf",i+1,sir[i]);
nl++;
if ( nl % 5 == 0 )
printf("\n");
}
printf("\n");
}
________________________________________________________________________
/* Program ordonare sir , utilizand metoda de selectie directa,
intr-o varianta putin modificata fata de cea anterioara.
*/
#include<stdio.h>
void ordonare_sel_dir(double sir[], int nrelem)
{
int i,j;
double aux;
for(i=0;i<nrelem-1;++i)
for(j=i+1;j<nrelem;++j)
if(sir[i]>sir[j])
{
aux=sir[i];
sir[i]=sir[j];
sir[j]=aux;
}
}
main()
{
double sir[1000];
int ne,i;
printf("Numarul de elemente: ");
scanf("%d",&ne);
for (i=0;i<ne;++i)
{
printf(" sir(%d)=",i+1);
scanf("%lf",&sir[i]);
}
ordonare_sel_dir(sir,ne);
for(i=0;i<ne;++i)
printf(" sir(%d)=%lf ",i,sir[i]);
}
________________________________________________________________________
/* Programul ordoneaza un sir de valori cu algoritmul "SHAKERSORT".
utilizand o functie pentru ordonare
*/
#include<stdio.h>
#include <conio.h>
/*
functia sorteaza vectorul utilizand algoritmul "SHAKERSORT"
*/
void sort_shakersort( double a[], int n )
{
double x;
int j , s = 1, d = n-1, k = n-1;
do
{
for ( j = d ; j >= s ; --j )

if ( a[j-1] > a[j] )
{
x = a[j-1];
a[j-1] = a[j];
a[j] = x;
k = j; /* pozitia ultimei inversiuni */
}
s = k + 1;
for ( j = s ; j <= d ; ++j )
if ( a[j-1] > a[j] )
{
x = a[j-1];
a[j-1] = a[j];
a[j] = x;
k = j; /* pozitia ultimei inversiuni */
}
d = k - 1;
}
while ( s <= d );
}
main()
{
double sir[100];
int ne,i,nre=0;
clrscr();
printf("\nProgramul ordoneaza un sir de valori cu algoritmul "
"\"SHAKERSORT\".\n");
scanf("%d",&ne);
printf("Introduceti elementele sirului.\n\n");
for(i=0;i<ne;i++)
{
}
sort_shakersort (sir , ne);
for (i=0;i<ne;i++)
{
printf(" sir (%2d) = %lf \n" , i+1 , sir[i]);
}
}
________________________________________________________________________
/*
cautare binara (binsearch): cauta x in sirul ordonat:
v[ 0 ] <= v[ 1 ] <= . . . <= v[ n-1 ] * /
int binsearch ( int x , int v[ ] , int n )

{
int stanga , dreapta , mijloc ;
stanga = 0 ;
dreapta = n - 1 ;
while ( stanga <= dreapta ) {
mijloc = ( stanga <= dreapta ) / 2 ;
if ( x < v [ mijloc] )
dreapta = mijloc - 1 ;
else if ( x > v[ mijloc ] )
stanga = mijloc + 1 ;
else
/ * gasita pozitia in sir * /
return ( mijloc ) ;
}
return ( -1 ); / * nu s-a gasit valoarea x, in sirul v[ ] * /
}

Firul

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Firul

Încărcat de

Drepturi de autor:

Formate disponibile

/* Exemplificare structura program C/C++ */

printf("\nProgramul va determina varsta in numarul total de luni.\n");

printf(" pozitiv\n") : printf(" zero\n"));

/* Programul exemplifica operatori la nivel de bit; se utilizeaza

for ( i = dim-1 ; i >= 0 ; i--, n >>= 1 )

printf("maximul dintre cele doua numere este: %f",max);

printf("\nProgramul determina daca un an este bisect sau nu.\n");

/* Programul afiseaza o valoare numerica, cuprinsa in intervalul 0..999,

case 3: printf ("trei"); break;

case 8: printf ("opt"); break;

/* Programul evalueaza expresii: valoare operator valoare (varianta 2)

printf("\nEvaluarea unei expresii simple: Op.1 Operator Op.2\n"

printf("Progresie geometrica: %d , %d , %d\n",b,c,a);

/* Program ce citeste un numar (si cu parte fractionara) intr-o baza

/* Program pentru calculul datei zilei urmatoare pe baza datei curente

scanf ("%ld", &n);

printf ("Valoarea returnata de functia standard sqrt "

/* Programul determina numarul de caractere, blancuri, virgule si puncte

case 6 : printf("sase"); break;

printf("\nProgramul converteste un numar intreg din zecimal intr-o alta "

/* pentru impartire se poate utiliza '/' */

double ex, x, precizie, termen;

daca este diferite de 1 -> nu sunt numere prime intre ele */

/* Secventa care afiseaza caracterele cu ecou si

scanf ("%lg", &a);

scanf ("%ld", &numar);

Se defineste o functie de sortare utilizand acest algoritm */

scanf ("%d", &n);

este_prim = p % prim [i];

for ( p = 0 ; p <=n ; p++ )

/* Programul descompune o suma de bani, de platit, intr-un numar

"literele alfabetului latin." << endl;

for(i=1; i<=n; i++)

/* Programul genereaza toate permutarile unui vector cu 'n' elemente */

printf("\nProgramul afiseaza un tablou de caractere:\n");

"de memorie.\n", strlen (nume), sizeof nume);

printf ("Numar studenti:"); /* numarul de studenti */

printf ("%-*s %-*s %5.2lf\n", MAXNUME,

struct punct p2;

mai mari decat valoarea transmisa ca parametru;

ruta , datele zborurilor ,precum si costul acestora;

"\t- cu liceu : anul absolvirii liceului si media;\n"

while( getchar() != '\n');

for ( i = 0 ; i < n ; i++ )

"care sunt apoi initializate si tiparite,\n"

struct intrare *urmator;

printf ("%d -> ", ptr_lista -> valoare);

scanf ("%x", &start);

"(Sf. afisare=CTRL-Z) :%p:%p\n", seg, off);

/* Programul utilizeaza un pointer pentru a referi o structura */

/* Programul exemplifica utilizarea unui pointer la un caracter */

printf("Sirul copiat este:\n");

printf("Sirul copiat este:\n");

int xmax, ymax, midx , midy , i;

scanf ("%li", &numar);

aduna_fractii ( &numarator, &numitor, 1, i);

int first, last;

extern char linie [ ] ;

for ( i = 0 ; i < 3 ; i++ )

printf ("Utilizare: cauta x n sir_de_caractere\n");

#define MAXLINIE 1000

char *alloc (int );

/* qsort : ordoneaza v[stanga]v[dreapta] in ordine crescatoare */

swap (v, stanga, ( stanga + dreapta ) /2 );

printf ("%-s %-s %5.2lf\n", MAXNUME,