/*

proiect:

#include<stdio.h>
#include <GL/glut.h>
#include<windows.h>

int medie(int a, int b)

{int c;

c=a/b;

return c;
}

int *numar;

struct{
int an, km;
float capacitate,medie,varsta;
char brand[15], nume[15], combustibil[15], tract[15], caroserie [15],
motor[15];
}car[20],aux;

void display(){
int i,j;
char text[5];

glClearColor(1.0f,1.0f,1.0f,0.5f);
glClear(GL_COLOR_BUFFER_BIT);
for(i=0;i < *numar; i++){
glBegin(GL_QUADS);
glColor3f(0.0f,i/5.,1.0f);
glVertex2f(-1.25+i*0.23,-0.5);
glVertex2f(-1.25+i*0.23+0.22,-0.5);
glVertex2f(-1.25+i*0.23+0.22,-0.05+car[i].medie/100000.);
glVertex2f(-1.25+i*0.23,-0.05+car[i].medie/100000.);
glEnd();

glRasterPos2f(-1.3+i*0.25+0.08,-0.5+car[i].medie/100000 + 0.5);
sprintf(text, "%.2f",car[i].medie);
for(j=0;j<strlen(text);j++)
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_10,text[j]);
glRasterPos2f(-1.3+i*0.25+0.08,-0.6);
for(j=0 ; j < strlen(car[i].nume);j++)
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_10,car[i].nume[j]);

}
glFlush();
}
int main(int argc, char **argv)
{
int nr,i,anul,flag;

//scanf("%d",anul)

FILE *date,*file_out;
 date = fopen("date.txt","r");
if(!date)
{
printf("Eroare la deschidere fisier!");
fflush(stdout);
return 1;
}
fscanf(date,"%d%d",&nr,&anul);
for(i=1;i<=nr;i++)
fscanf(date,"%s%s%d%d%s%s%f%s
%s",car[i].brand,car[i].nume,&car[i].an,&car[i].km,car[i].combustibil,car[i].tract,
&car[i].capacitate,car[i].caroserie,car[i].motor);

printf("In acest garaj se afla %d masini \n",nr);

fflush(stdout);
for(i=1;i<=nr;i++)
printf("Masina nr %d este o %s %s din anul %d cu %d km combustibil %s tractiune
%s capacitate %.1f caroserie %s si motor de tip %s\
n",i,car[i].brand,car[i].nume,car[i].an,car[i].km,car[i].combustibil,car[i].tract,c
ar[i].capacitate,car[i].caroserie,car[i].motor);
fflush(stdout);
printf("\nAnul curent este: %d",anul);
fflush(stdout);
printf("\n\n Intr-un an:");
fflush(stdout);
for(i=1;i<=nr;i++)
{
car[i].varsta=anul-car[i].an;
car[i].medie=medie(car[i].km,car[i].varsta);
printf("\n Masina numarul %d are %.0f ani si a facut %.2f km pe
an",i,car[i].varsta,car[i].medie);
fflush(stdout);
}

do{
flag=0;
for(i=0;i<nr;i++)
if(car[i].medie>car[i+1].medie)
{
aux=car[i];
car[i]=car[i+1];
car[i+1]=aux;
flag=1;
}
}while(flag!=0);

file_out=fopen("dateout.txt","w");
fprintf(file_out,"Brand Nume An Kilometri km/an ");
for(i=1;i<=nr;i++)
fprintf(file_out,"\n%s %s %d %d %.2f",
car[i].brand,car[i].nume,car[i].an,car[i].km,car[i].medie);

numar = &nr;

glutInit(&argc, argv);
 glutInitWindowSize(320, 320);
glutInitWindowPosition(100, 100);
glutCreateWindow("Grafic KM Anual");
glutDisplayFunc(display);
glutMainLoop();

return 0;
}

#include <GL/freeglut.h>
#include<stdio.h>
#include<windows.h>

float medie(int a, int b) {

float avg;
avg = (float) a / b;
return avg;
}
int scadere(int a, int b) {
int diferenta;
diferenta = a - b;
return diferenta;
}
float produs(int a, int b){
float pix;
pix = (float) a*b;
return pix;

}
struct {
char titlu[30];
int pagini;
int capitole;
int an_aparitie;
int clasament;
char tari_publicare[20];
char edituri[20];
int pret;
int vanzari;
int vechime;
float medie_vanzari;
float medie_venituri;
} book[30], x;

int *nr;

void display() {
int i, j;
char text[10];
 glClearColor(1.0f, 1.0f, 1.0f, 0.5f);
glClear(GL_COLOR_BUFFER_BIT);

for (i = 1; i <= *nr; i++) {

glBegin(GL_QUADS);
glColor3f(0.0f, i / 10.f, 0.0f);
glVertex2f(-0.95 + i * 0.15, -0.5);
glVertex2f(-0.95 + i * 0.15 + 0.10, -0.5);
glVertex2f(-0.95 + i * 0.15 + 0.10,
-0.05 + book[i].medie_vanzari / 100000.0);
glVertex2f(-0.95 + i * 0.15, -0.05 + book[i].medie_vanzari / 100000.0);

glEnd();

glRasterPos2f(-1 + i * 0.16, -0.6);

for (j = 0; j < strlen(book[i].titlu); j++)
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_10,
book[i].titlu[j]);

glRasterPos2f(-1 + i * 0.13 + 1,
1.9);
sprintf(text, "%.2f", book[i].medie_vanzari);
for (j = 0; j < strlen(text); j++)
glRasterPos2f(-1. + i * 0.15 + .1,
0.9);
sprintf(text, "%.2f", book[i].medie_vanzari);
}

glFlush();
}

int main(int argc, char **argv) {

int i, a, an, y ;

FILE *info, *date_finale;

info = fopen("info.txt", "r");

if (!info) {
printf("Eroare la deschiderea fisierului!");
fflush(stdout);
return -1;
}

fscanf(info, "%d%d", &a, &an);

for (i = 1; i <= a; i++)
fscanf(info, "%s%d%d%d%d%s%s%d%d", book[i].titlu, &book[i].pagini,
&book[i].capitole, &book[i].an_aparitie,
&book[i].clasament,
book[i].tari_publicare, book[i].edituri, &book[i].pret,
&book[i].vanzari);

printf(" ######################################################");

printf("\n\n Salut. Bine ai venit în cadrul proiectului nostru.\n\n");

printf(
" Noi ne ocupăm cu întreținerea unei biblioteci. În prezent nu
dispunem decât de seria ,,CAVALERII PARDAILLAN,,");
 printf(
"\n\n scrisă de Michael Zevaco, dar stați aproape. În curând vor
apărea titluri noi! ;)");
printf(
"\n\n\n Astfel, în bibliotecă avem un număr de 10 volume, toate
fiind în ordine după cum urmează: \n");

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

printf(
"\n\n %d. %s cu un număr de %d pagini și %d capitole a
apărut în anul %d. S-a situat pe locul %d în clasamentul celor mai citite romane de
dragoste din acea perioadă. Țara cu cel mai mare succes de piață este %s în care
editura %s a vândut la prețul aproximativ de %d lei %d exemplare.",
i, book[i].titlu, book[i].pagini, book[i].capitole,
book[i].an_aparitie, book[i].clasament,
book[i].tari_publicare,
book[i].edituri, book[i].pret, book[i].vanzari);

printf("\n\n\n În prezent ne aflăm în anul %d.", an);

printf("\n\n În acest an:");

for (i = 1; i <= a; i++) {

book[i].vechime = scadere(an, book[i].an_aparitie);
book[i].medie_vanzari = medie(book[i].vanzari, book[i].vechime);
book[i].medie_venituri = produs(book[i].vanzari, book[i].pret);
printf(
"\n Volumul numarul %d împlinește %d ani vechime și până
acum a generat ~ %.1f vanzari în fiecare an.",
i, book[i].vechime, book[i].medie_vanzari);
}

do {
y = 0;
for (i = 0; i < a; i++)
if (book[i].medie_venituri > book[i + 1].medie_venituri) {
x = book[i];
book[i] = book[i + 1];
book[i + 1] = x;
y = 1;
}
} while (y != 0);

date_finale = fopen("date_finale.txt", "w");

fprintf(date_finale, "Titlu An_aparitie Vanzari Medie_venituri ");
for (i = 1; i <= a; i++)
fprintf(date_finale, "\n\n%s %d %d %.1f\n", book[i].titlu,
book[i].an_aparitie, book[i].vanzari,
book[i].medie_venituri);

nr = &a;
fflush(stdout);
glutInit(&argc, argv);
glutInitWindowSize(680,480);
glutInitWindowPosition(100, 100);
glutCreateWindow(
"Graficul vânzărilor generat in medie pe parcursul unui an");
glutDisplayFunc(display);
glutMainLoop();
 return 0;
}

1.*Realizați un program care folosește funcții utilizator

* pentru a realiza operații cu numere complexe.
Numerele complexe vor fi variabile de tip struct care conțin două atribute
* (real și imaginar). Funcțiile utilizator pot avea următoarele signaturi:
complex suma(complex, complex);
complex diferenta(complex, complex);
complex produs(complex, complex);

* *
#include<stdio.h>

struct complex
{
float re, im;
};

struct complex s,d, p;

struct complex suma(struct complex c1, struct complex c2)
{
s.re = c1.re + c2.re;
s.im = c1.im + c2.im;
printf("suma: %.f%+.fi\n",s.re, s.im);
//s = s.re + s.im;
//return s;
}
struct complex diferenta(struct complex c1, struct complex c2)
{
d.re = c1.re - c2.re;
d.im = c1.im - c2.im;
printf("diferenta: %.f%+.fi\n",d.re, d.im);
//return d;
}
struct complex produs(struct complex c1, struct complex c2)
{
float rez1, rez2;
rez1 = c1.re * c2.re - c1.im * c2.im ;
rez2 = c1.re * c2.im + c1.im * c2.re;
printf("produsul: %.f%+.fi\n",rez1, rez2);
}

int main()
{
struct complex a, b, sum, dif;
a.re = 1;
a.im = 4;
b.re = 7;
b.im = 6;
//s = a.re + b.re + (a.im + b.im);
//printf("%.2f%.2fi", s.re, s.im);
suma(a,b);
diferenta(a,b);
produs(a,b);
// sum = suma(a,b);
// dif = diferenta(a,b);
// printf("%.f\n%.f", sum, dif);

return 0;
}

2.*Realizați un program care va interschimba valorile a două variabile alocate

dinamic.
*
#include <stdio.h>
#include <stdlib.h>

int main() {
int *v1, *v2, *x;

// Alocarea dinamică a două variabile

v1 = (int *)malloc(sizeof(int));
v2 = (int *)malloc(sizeof(int));

// Citirea valorilor pentru cele două variabile

printf("Introduceți v1: ");
fflush(stdout);
scanf("%d", v1);

printf("Introduceți v2: ");

fflush(stdout);
scanf("%d", v2);

// Afișarea valorilor inițiale

printf("\nValorile inițiale au fost acestea:\n");
printf("v1 = %d\n", *v1);
printf("v2 = %d\n", *v2);

// Schimbarea valorilor între cele două variabile

x = v1;
v1 = v2;
v2 = x;

// Afișarea valorilor schimbate

printf("\nValorile schimbate:\n");
printf("var1 = %d\n", *v1);
printf("var2 = %d\n", *v2);

// Eliberarea memoriei alocate dinamic

free(v1);
free(v2);

return 0;
}
3.*Realizați suma a doi vectori declarați în mod dinamic.
* *
#include <stdio.h>
#include <stdlib.h>

int main() {
int *vector1, *vector2, *suma;
int dimensiune;
int i;

// Citirea dimensiunii vectorilor

printf("Introduceți dimensiunea vectorilor: \n");
fflush(stdout);
scanf("%d", &dimensiune);

// Alocarea dinamică a memoriei pentru vectorii și suma

vector1 = (int *)malloc(dimensiune * sizeof(int));
vector2 = (int *)malloc(dimensiune * sizeof(int));
suma = (int *)malloc(dimensiune * sizeof(int));

// Citirea valorilor pentru primul vector

printf("Introduceți valorile pentru primul vector:\n");
fflush(stdout);
for (i = 0; i < dimensiune; i++) {
printf("vector1[%d] = ", i);
fflush(stdout);
scanf("%d", &vector1[i]);
}

// Citirea valorilor pentru al doilea vector

printf("\nIntroduceți valorile pentru al doilea vector:\n");
fflush(stdout);
for (i = 0; i < dimensiune; i++) {
printf("vector2[%d] = ", i);
fflush(stdout);
scanf("%d", &vector2[i]);
}

// Calcularea sumei vectorilor

for (i = 0; i < dimensiune; i++) {
suma[i] = vector1[i] + vector2[i];
}

// Afișarea sumei
printf("\nSuma vectorilor:\n");
fflush(stdout);
for (i = 0; i < dimensiune; i++) {
printf("suma[%d] = %d\n", i, suma[i]);
fflush(stdout);
}

// Eliberarea memoriei alocate dinamic

free(vector1);
free(vector2);
free(suma);

return 0;
}
4.*Scrieti un program care
* sa deseneze un hexagon rosu pe un fundal verde inchis.*
#include <GL/glut.h>
#include<windows.h>
// Funcția de afișare
void display() {
glClear(GL_COLOR_BUFFER_BIT);

// Setarea culorii fundalului

glClearColor(0.0, 0.4, 0.0, 1.0); // Verde închis

// Setarea culorii hexagonului

glColor3f(1.0, 0.0, 0.0); // Roșu

// Desenarea hexagonului
glBegin(GL_POLYGON);
glVertex2f(-0.5, 0.866);
glVertex2f(-1.0, 0.0);
glVertex2f(-0.5, -0.866);
glVertex2f(0.5, -0.866);
glVertex2f(1.0, 0.0);
glVertex2f(0.5, 0.866);
glEnd();

glFlush();
}

// Funcția de redimensionare a ferestrei

void reshape(int width, int height) {
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(-1.5, 1.5, -1.5, 1.5);
glMatrixMode(GL_MODELVIEW);
}

int main(int argc, char** argv) {

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(600, 600);
glutCreateWindow("Hexagon");
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

5.*Realizati un program care sa deseneze simbolul + cu negru pe un fundal alb.*

#include<windows.h>
#include <GL/glut.h>

// Funcția de afișare
void display() {
glClear(GL_COLOR_BUFFER_BIT);

// Setarea culorii fundalului

glClearColor(1.0, 1.0, 1.0, 1.0); // Alb

// Setarea culorii simbolului "+"

glColor3f(0.0, 0.0, 0.0); // Negru

// Desenarea simbolului "+"

glLineWidth(5.0);
glBegin(GL_LINES);
// Linia verticală
glVertex2f(0.0, 0.5);
glVertex2f(0.0, -0.5);

// Linia orizontală
glVertex2f(-0.5, 0.0);
glVertex2f(0.5, 0.0);
glEnd();

glFlush();
}

// Funcția de redimensionare a ferestrei

void reshape(int width, int height) {
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(-1.0, 1.0, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
}

int main(int argc, char** argv) {

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(600, 600);
glutCreateWindow("Simbol +");
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}

6.*Realizați un program care va determina dacă un număr introdus

* de la tastatură este palindrom (un număr palindrom este un număr
* care citit de la dreapta la stânga are aceeași valoare cu numărul citit de la
stânga la dreapta).
* *
#include <stdio.h>
int main() {
int nr, nr_initial, nr_intors = 0;

printf("Introduceți un număr: ");

fflush(stdout);
scanf("%d", &nr);

nr_initial = nr;

while (nr > 0) {

int rest = nr % 10;
nr_intors = nr_intors * 10 + rest;
nr /= 10;
}

if (nr_initial == nr_intors) {
printf("%d este un număr palindrom.\n", nr_initial);
} else {
printf("%d nu este un număr palindrom.\n", nr_intors);
}

return 0;
}

7.*Validați o adresă de email (să conțină o singură dată caracterul @,

* iar după caracterul . să fie cel puțin două litere).
* *

#include <stdio.h>
#include <string.h>

int main() {
char email[20];
int ar = 0;
int pct = 0;
int lungime_sir;
int valid = 1;

printf("Introduceți adresa de e-mail: ");

fflush(stdout);
fgets(email, sizeof(email), stdin);
email[strcspn(email, "\n")] = '\0';

lungime_sir = strlen(email);

for (int i = 0; i < lungime_sir; i++) {

if (email[i] == '@') {
ar++;
} else if (email[i] == '.') {
pct++;
}
}
 if (ar != 1) {
printf("Adresa de e-mail nu conține exact un caracter @.\n");
valid = 0;
}

if (pct != 1) {
printf("Adresa de e-mail nu contine exact un caracter '.'.\n");
valid = 0;
}

if (email[lungime_sir - 1] < 'A' || (email[lungime_sir - 1] > 'Z' &&

email[lungime_sir - 1] < 'a')
|| email[lungime_sir - 1] > 'z' || email[lungime_sir - 2] < 'A' ||
(email[lungime_sir - 2] > 'Z' && email[lungime_sir - 2] < 'a') ||
email[lungime_sir - 2] > 'z')
{
printf("După caracterul '.' trebuie să fie cel puțin două litere.\n");
valid = 0;
}

if (valid) {
printf("Adresa de e-mail este validă.\n");
} else {
printf("Adresa de e-mail nu este validă.\n");
}

return 0;
}

8.*Realizati un program care sa deseneze um om cu mainile violet, picioarele

verzi , corpul roz si capul galben.*

#include <GL/freeglut.h>
#include<windows.h>
void display() {
glClear(GL_COLOR_BUFFER_BIT);

// Desenăm capul
glColor3f(1.0f, 1.0f, 0.0f); // Setăm culoarea la galben
glPushMatrix();
glTranslatef(0.0f, 0.6f, 0.0f);
glutSolidSphere(0.3f, 100, 100);
glPopMatrix();

// Desenăm corpul
glColor3f(1.0f, 0.0f, 0.5f); // Setăm culoarea la roz
glPushMatrix();
glTranslatef(0.0f, 0.0f, 0.0f);
glScalef(0.6f, 1.0f, 0.3f);
glutSolidCube(1.0f);
glPopMatrix();

// Desenăm brațele
 glColor3f(0.6f, 0.0f, 1.0f); // Setăm culoarea la violet
glPushMatrix();
glTranslatef(-0.4f, 0.2f, 0.0f);
glScalef(0.3f, 0.6f, 0.3f);
glutSolidCube(1.0f);
glPopMatrix();

glPushMatrix();
glTranslatef(0.4f, 0.2f, 0.0f);
glScalef(0.3f, 0.6f, 0.3f);
glutSolidCube(1.0f);
glPopMatrix();

// Desenăm picioarele
glColor3f(0.0f, 1.0f, 0.0f); // Setăm culoarea la verde
glPushMatrix();
glTranslatef(-0.2f, -0.7f, 0.0f);
glScalef(0.3f, 0.6f, 0.3f);
glutSolidCube(1.0f);
glPopMatrix();

glPushMatrix();
glTranslatef(0.2f, -0.7f, 0.0f);
glScalef(0.3f, 0.6f, 0.3f);
glutSolidCube(1.0f);
glPopMatrix();

glFlush();
}

int main(int argc, char** argv) {

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(400, 400);
glutCreateWindow("Desenare om");
glClearColor(1.0f, 1.0f, 1.0f, 1.0f); // Setăm culoarea fundalului la alb
gluOrtho2D(-1.0, 1.0, -1.0, 1.0); // Setăm sistemul de coordonate
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

9.*Considerăm un fișier de date care conține trei numere întregi. Să se scrie

* un program care citește numerele din fișier și afișează cele trei numere și
media acestora. *
#include <stdio.h>

int main() {
FILE *file;
int num1, num2, num3;
float average;

// Deschideți fișierul în modul de citire

file = fopen("numere.txt", "r");
 if (file == NULL) {
printf("Nu se poate deschide fisierul.\n");
return 1;
}

// Citirea celor trei numere din fișier

fscanf(file, "%d %d %d", &num1, &num2, &num3);

// Închideți fișierul
fclose(file);

// Calculați media celor trei numere

average = (float)(num1 + num2 + num3) / 3;

// Afișarea numerelor și a mediei

printf("Numerele sunt: %d, %d, %d\n", num1, num2, num3);
printf("Media este: %.2f\n", average);

return 0;
}

10.*Scrieţi un program care va afişa toate cifrele unui număr, în ordine inversă,
* cu câte un spaţiu între ele. Ex. pt 12345 programul va afişa 5 4 3 2 1.
* *

#include <stdio.h>

int main() {
int nr;

printf("Introduceti un numar: ");

fflush(stdout);
scanf("%d", &nr);

printf("Cifrele numarului in ordine inversa sunt: ");

fflush(stdout);

while (nr > 0) {

printf("%d ", nr % 10);
nr /= 10;
}

printf("\n");

return 0;
}

probleme facute de mine

1)
#include<stdio.h>
int main() {
int v[100], aux, i, n, v2[100], j;
// int m=0;
printf("Introduceti numarul de numere: ");
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &v[i]);
}
for (i = 0; i < n; i++) {
if (v[i] % 2 != 0) {
v2[i] = v[i];
// m++;
}
}
for (i = 0; i < n; i++)
printf("%d ", v2[i]);
printf("\n");
do {
j = 0;
for (i = 0; i < n; i++)
if (v2[i] < v2[i + 1]) {
aux = v2[i];
v2[i] = v2[i + 1];
v2[i + 1] = aux;
j++;
}
} while (j != 0);
for (i = 0; i < n; i++)
if (v2[i] == 0)
break;
else

printf("%d ", v2[i]);

do {
j = 0;
for (i = 0; i < n; i++)
if (v[i] > v[i + 1]) {
aux = v[i];
v[i] = v[i + 1];
v[i + 1] = aux;
j++;
}
} while (j != 0);
for (i = 0; i < n; i++) {
if (i % 6 == 0) {
printf("\n");
}
printf("%d ", v[i]);
}

return 0;
}
//Dati la tastatura un interval de numere (maxim 100 de numere sa fie in interval)
//si apoi codul sa salvexe numerele impare in mod descrescator (adica v[0] =
// cel mai mare nr) si sa afiseze cate 6 numere pe rand, in ordine crescatoare,
//adica de la cel mai mic numar
2)

#include<stdio.h>
#include<string.h>
#include <ctype.h>
*Să se scrie un program care va citi de la tastatură un șir de caractere și va
determina:

dacă șirul conține cifre, se va determina șirul rezultat prin eliminarea cifrelor
(ex. in:"dsACdg544Edsgf", out:"dsACdgEdsgf")
la fel și în cazul literelor (se extrage numărul întreg format din cifrele
șirului:
"dsACdg544Edsgf" -> 544 int)

*
int main() {
char sir[20], sir2[20], sir3[20];
int len, i, nr, nr2, nr3, sum = 0, mic, mare, nr4;
scanf("%s", sir);
len = strlen(sir);
//nr de cifre
for (i = 0; i < len; i++) {
if (sir[i] >= '0' && sir[i] <= '9')
nr++;
}
printf("\n\n%d", nr);
//nr de vocale
for (i = 0; i < len; i++)
if (sir[i] == 'A' || sir[i] == 'E' || sir[i] == 'I' || sir[i] == 'O'
|| sir[i] == 'U' || sir[i] == 'a' || sir[i] == 'e'
|| sir[i] == 'i' || sir[i] == 'o' || sir[i] == 'u')
nr2++;
printf("\n%d", nr2);
//suma cifrelor din sir
for (i = 0; i < len; i++) {
if (sir[i] >= '0' && sir[i] <= '9') {
nr3 = sir[i] - '0';
sum += nr3;
}
//sum+= <=> sum = sum + ...
}
printf("\n%d", sum);
//nr de litere mici si litere mari
for (i = 0; i < len; i++) {
if (sir[i] >= 'a' && sir[i] <= 'z')
mic++;
}
for (i = 0; i < len; i++) {
if (sir[i] >= 'A' && sir[i] <= 'Z')
mare++;
}
nr4 = mic + mare;
printf("\n%d", nr4);
 //litere mici in litere mari
strcpy(sir,sir2);
for (i = 0; i < len; i++) {
if (sir[i] >= 'a' && sir[i] <= 'z')
sir2[i]-=32;
}
printf("\n");
printf("%s", sir2);
//litere mari in litere mici
strcpy(sir,sir3);
for (i = 0; i < len; i++) {
if (sir[i] >= 'A' && sir[i] <= 'Z')
sir3[i]+=32;
}
printf("\n");
printf("%s", sir3);
return 0;
}
*

*#include<stdio.h>
#include<string.h>
int main () {

struct complex{
int re, im;
};

struct complex c[10];

FILE *f;
f = fopen("date.txt", "r");
int n, i, sre = 0, sim = 0;

fscanf(f, "%d", &n);

for(i = 0; i < n; i++){
fscanf(f, "%d%d", &c[i].re, &c[i].im);
sre = sre + c[i].re;
sim = sim + c[i].im;
}

printf("%d%+di", sre, sim);

return 0;
}
*

*#include<stdio.h>
#include<string.h>
int main(){
int n=0,i;
int plitere=0;
char hotelmic[20];
int pretmic=0;
struct hotel{
char numehotel[20];
 char localitate[20];
int nrcam;
int pret;
}hotel[5];
FILE *a;
a=fopen("hm.txt","r");
while(fscanf(a, "%s%s%d
%d",hotel[n].numehotel,hotel[n].localitate,&hotel[n].nrcam,&hotel[n].pret)!=EOF){
n++;
}
for(i=0;i<n;i++){
fscanf(a, "%s%s%d
%d",hotel[i].numehotel,hotel[i].localitate,&hotel[i].nrcam,&hotel[i].pret);
}
plitere = strlen(hotel[0].numehotel);
strcpy(hotelmic, hotel[0].numehotel);
for(i=1;i<n;i++)
{
if(plitere > strlen(hotel[i].numehotel))
{
strcpy(hotelmic, hotel[i].numehotel);
plitere = strlen(hotel[i].numehotel);
}

}
for(i=0;i<n;i++)
{
if(hotel[i].pret>=300)
pretmic++;
}
printf("Hotelul cu cele mai putine litere:%s\n",hotelmic);
printf("nr de hoteluri peste 300eur: %d",pretmic);

return 0;
}
*

*#include<stdio.h>
#include<string.h>
int main(){
char vangn[20],vangp[20];
int n=0,i,vechimea, suma=0;
struct angajat{
char nume[10];
char prenume[10];
int nastere;
int angajare;
int sal;
}angajat[5];
FILE *a;
a = fopen("note.txt","r");
while(fscanf(a,"%s%s%d%d
%d",angajat[n].nume,angajat[n].prenume,&angajat[n].nastere,&angajat[n].angajare,
&angajat[n].sal)!=EOF){
n++;
}
for(i=0;i<n;i++)
 {fscanf(a,"%s%s%d%d
%d",angajat[i].nume,angajat[i].prenume,&angajat[i].nastere,&angajat[i].angajare,
&angajat[i].sal);

}
//vechimea
vechimea = angajat[0].angajare;
strcpy(vangn, angajat[0].nume);
strcpy(vangp, angajat[0].prenume);
for(i=1;i<n;i++)
{
if(vechimea<angajat[i].angajare){
vechimea = angajat[i].angajare;
strcpy(vangn, angajat[i].nume);
strcpy(vangp, angajat[i].prenume);
}
}
for(i=0;i<n;i++)
{
if(angajat[i].sal>=1000)
suma++;
}
printf("Vechimea cea mai mare o are %s %s \n",vangn , vangp);
printf("Cati au salariu mai mare de 1000: %d",suma);

return 0;
}
* *
*/