Ministerul Educaţiei, Culturii și Cercetării al Republicii

Moldova

Universitatea Tehnică a Moldovei

Departamentul Tehnologia Informatiei

RAPORT

Lucrarea de laborator nr. 3 „Structuri și Fișiere”

Chişinău – 20XX
/*
Pr0301
1.Program care citeste din fisier 3 propozitii si le afiseaza in ordinea inversa, apoi
le salveaza în alt fisier.
*/

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

int main() {
FILE *pf; // fisierul initial cu propozitii
FILE *fr; // fisierul rezultat cu propozitiile inversate
char *nf; // numele fisierului initial
char *rf; // numele fisierului rezultat
char *pr; // o propozitie din fisierul initial
char *rp; // o propozitie din fisierul rezultat
int i;

nf = (char *)malloc(100 * sizeof(char)); // nume fisier initial

rf = (char *)malloc(100 * sizeof(char)); // nume fisier rezultat
pr = (char *)malloc(100 * sizeof(char)); // o propozizie
rp = (char *)malloc(100 * sizeof(char)); // o propozitie inversata

printf("Intoruceti numele fisierului initial: "); scanf("%s", nf);

pf = fopen(nf, "a+"); // am deschis fisierul initial (pf)

 printf("Intoruceti numele fisierului rezultat: "); scanf("%s", rf);
fr = fopen(rf, "w"); // am deschis fisierul rezultat (fr)

while( feof(pf) == 0 ) // citim cate o propozitie din fisierul initial

{
fgets(pr, 100, pf);
printf("\nAti citit din fisier propozitia:\n%s", pr);
for(i = 0; i < strlen(pr); i++) // inversam propozitia pr
{
rp[i] = pr[strlen(pr) - 1 - i];
}
rp[i] = '\0';
printf("Propozitia inversata este: %s", rp);
fprintf(fr, "%s", rp); // sau fputs(rp, fr); // am scris propozitia
inversata in fisierul rezultat (fr)
}

fclose(pf); fclose(fr);

return 0;
}
//////////////////////////////////////////////////////////////////////////////////////
////////////////////////
/* pr0302
2. Sa se scrie un program care creaza un fisier numbers.txt pe discul D, in care
inscrie 5 numere intregi, introduse de la tastatura. Fiecare se scrie pe linie
separata, apoi se afiseaza la ecran.
*/

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

int main()
{
FILE *pf; int x, i, n = 5;
char nf[30] = "F:\\numbers.txt";
pf = fopen(nf, "w");
printf("Introdu %d numere\n", n);
for(i = 0; i < n; i++)
{
printf("Da numarul %d:", i);
scanf("%d", &x);
fprintf(pf, "%d\n", x);
}
fclose(pf);
printf("Ai introdus in fisier numerele:\n");
pf = fopen(nf, "r");
for(i = 0; i < n; i++)
{
fscanf(pf, "%d", &x);
printf("%d\n", x);
}
fclose(pf);

return 0;
}
//////////////////////////////////////////////////////////////////////////////////////
////////////////////////
/* pr0303
3. Sa se scrie un program care creaza un fisier cu 10 elemente de tip intreg.
Citeste din fisier si calculeaza suma acestor elemente, apoi le afiseaza la ecran si
le salveaza în alt fisier.
*/

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

int main() {
FILE *pf, *fp; int i, n = 10, x, s = 0;
char nf[30] = "0303.txt";
pf = fopen(nf, "w"); // deschidem fisierul cu numele nf pentru scriere

printf("Introdu %d numere int:\n", n);

for(i = 0; i < n; i++)
{
printf("Introdu numarul %d : ", i);
scanf("%d", &x);
fprintf(pf, "%d\n", x);
}
fclose(pf); // inchidem fisierul pf
pf = fopen(nf, "r"); // deschidem fisierul cu numele nf pentru citire
fp = fopen("alt_fisier", "r"); // deschidem alt_fisier pentru scriere

printf("Numerele citite din fisier sunt:\n");

 for(i = 0; i < n; i++) // citim cate un numar din fisierul pf, il afisam pe ecran, il
scriem in alt_fisier si calculam suma
{
fscanf(pf, "%d", &x); // citim un numar din fisierul pf
printf("%d\t", x); // afisam numarul citit pe ecran
fprintf(fp, "%d\n", x); // scriem numarul in fisierul alt_fisier
s += x; // acumulam suma
}

fclose(pf); // inchidem fisierul pf

fclose(fp); // inchidem fisierul fp

printf("\nSuma numerelor citite din fisier este:\n%d\n", s);

return 0;
}
//////////////////////////////////////////////////////////////////////////////////////
////////////////////////
/* pr0305
5. Intr-un fisier "cod.dat" este memorata o tabela de codificare, sub forma:
car_de_codif ' ' car_codif '\0'.
Sa se preia un text din fisierul "dat1.dat", sa se codifice conform codului, iar
textul obtinut sa se scrie in fisierul "dat2.txt".
*/

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

int main() {
 FILE *pf; // fisierul cu tabela de codificare
FILE *tf; // fisierul cu textul care trebuie codificat
FILE *fc; // fisierul cu textul codificat (adica rezultatul)
char c[4]; // sirul de caractere pentru o linie din tabela de codificare
char text[10][30]; // textul care trebuie codificat (nu mai mult de 10 linii;
fiecare linie nu mai mult de 30 caractere)
char tc[60][4]; // tabela de codificare (nu mai mult de 53 linii; fiecare liniee
din 3 caractere si santinela)
char textc[10][30]; // textul codificat (nu mai mult de 10 linii; fiecare linie
nu mai mult de 30 caractere)
char c1; int i, j; int q; char p; int r;

pf = fopen("cod.dat", "w"); // deschidem fisierul cod.dat pentru a crea

tabela de codificare
// fiecare litera din alfabet(si mare si mica) o vom codifica cu urmatoarea
litera din alfabet
// literele 'z' si 'Z' le vom codifica cu prima litera din alfabet, respectiv 'a' si
'A'

c[1] = ' '; c[3] = '\0';

; for(c1 = 'a'; c1 < 'z'; c1++) // cream tabela de codificare si o scriem in fisierul
cod.dat
{
c[0] = c1; c[2] = c1 + 1;
fprintf(pf, "%s\n", c); // sau asa: fputs(c, pf); fputs("\n", pf);
}
c[0] = 'z'; c[2] = 'a';
fprintf(pf, "%s\n", c); // sau asa: fputs(c, pf); fputs("\n", pf);

for(c1 = 'A'; c1 < 'Z'; c1++)

{
c[0] = c1; c[2] = c1 + 1;
fprintf(pf, "%s\n", c); // sau asa: fputs(c, pf); fputs("\n", pf);
}
c[0] = 'Z'; c[2] = 'A';
fprintf(pf, "%s", c); // sau asa: fputs(c, pf); fputs("\n", pf);
fclose(pf); // inchidem fisierul cod.dat

/* Vom crea fisierul cod1.dat cu textul de codificat

semnele de punctuatie nu le codificam, le lasam fara schimbare

A fost odata ca-n povesti,

A fost ca niciodata,
Din rude mari imparateti,
O prea frumoasa fata.

Si era una la parinti

Si mandra-n toate cele,
Cum e Fecioara intre sfinti
Si luna intre stele.
*/
/*
tf = fopen("cod1.dat", "w");
i = 0;
while( 1 )
{
fgets(text[i], 30, stdin);
if (feof(stdin) != 0) break;
 fprintf(tf, "%s", text[i]);
i += 1;
}
fclose(tf);
*/

i = 0;
tf = fopen("cod1.dat", "r"); // deschidem fisierul cod1.dat pentru a citi
textul de codificat
while( feof(tf) == 0 )
{
fgets(text[i], 30, tf); // text[i] - linia i din textul care trebuie codificat
i++;
}
fclose(tf);

i = 0;
pf = fopen("cod.dat", "r"); // deschidem fisierul cod.dat pentru a citi tabela
de codificare
while( feof(pf) == 0 ) // codificam textul si il inscriem in fisierul dat2.txt
{
fgets(tc[i], 5, pf); // text[i] - linia i din textul care trebuie codificat; cu
5 merge; cu 4 nu merge
i++;
}
fclose(pf);

fc = fopen("dat2.txt", "w"); // deschidem fisierul dat2.txt pentru a scrie in el

textul codificat
i = 0;
 for(i = 0; i < 9; i++)
{
q = strlen(text[i]) - 1;
for(j = 0; j < q; j++)
{
p = text[i][j]; // caracterul care trebuie codificat; r - codul
pentru litera din p
if( p >= 'a' && p <= 'z' ) { r = p - 'a'; textc[i][j] = tc[r][2]; }

if( p >= 'A' && p <= 'Z' ) { r = p - 'A'+ 26; textc[i][j] = tc[r][2]; }

if( p < 'A' || p > 'Z' && p < 'a' || p > 'z' ) { textc[i][j] = p; }
}

textc[i][j] = '\0'; fprintf(fc,"%s\n", textc[i]);

}
fclose(fc);

return 0;
}
//////////////////////////////////////////////////////////////////////////////////////
////////////////////////
/* pr0323
23. Se da un fisier care contine pe fiecare rand un nume (un cuvint) urmat de 5
note. Se cere sa se construiasca un al doilea fisier
care contine numele urmat de medie, ordonat descrescator dupa medie. Daca
un nume apare pe mai multe linii in fisierul original,
liniile respective vor fi scrise intr-un fisier cu numele 'eronat', si pentru
acestea nu se va calcula media.
*/

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

int main() {
FILE *pf; // pointer la fixierul initial cu note
FILE *rf; // pointer la fisierul rezultat cu mediele
FILE *er; // pointer la fisierul cu numele 'eronat'
int note[25][5]; char nume[25][25]; int fr[25];
// note - notele din borderou (cel mul 25 lini)
// nume - toate numele din borderou (lungimea numelui - cel mult 25
caractere)
// fr - frecventa numelor din borderou
double m[25]; char n[25];
// m - mediile notelor
// n - pentru un nume din borderou
int i, j, p, k, n1, n2, n3, n4, n5;
// n1, n2, n3, n4, n5 - pentru notele de pe o linie

// Vom numi fisierul initial borderou.txt

pf = fopen("borderou.txt", "w"); // cream acest fisier cu numele
borderou.txt
i = 0;
printf("Introdu cate o linie din borderou: numele si 5 note\n");
while( 1 )
{
scanf("%s %d %d %d %d %d", n, &n1, &n2, &n3, &n4, &n5);
// printf("%s %d %d %d %d %d\n", n, n1, n2, n3, n4, n5);
 if( feof(stdin) != 0 ) break;
fprintf(pf, "%s %d %d %d %d %d\n", n, n1, n2, n3, n4, n5);
i += 1;
}
fclose(pf);
printf("Aveti %d linii in borderou\n", i);

pf = fopen("borderou.txt", "r"); // deschidem fisierul borderou.txt pentru a

citi datele
j = 0;
while( feof(pf) == 0)
{
fscanf(pf, "%s %d %d %d %d %d", nume[j], note[j], note[j] + 1, note[j]
+ 2, note[j] + 3, note[j] + 4);
if( feof(pf) != 0) break;
// printf("%s %d %d %d %d %d\n", nume[j], note[j][0], note[j][1],
note[j][2], note[j][3], note[j][4]);
j += 1;
}
p = j; // in borderou sunt p linii

for(i = 0; i < p; i++) // gasim frecventa fiecarui nume in borderou

{
fr[i] = 0;
for(k = 0; k < p; k++)
{
if(strcmp(nume[i], nume[k]) == 0) fr[i] += 1;
}
}
 for(i = 0; i < p; i++) // extragem la ecran frecventele
{
printf("fr[%d] = %d\n", i, fr[i]);
}

rf = fopen("rez.txt", "w"); // deschidem fisierul "rez.txt" pentru a scrie in el

rezultatul (mediile)
er = fopen("eronat.txt", "w"); // deschidem fisierul "eronat" pentru a srie in
el liniile din borderou in care se repeta numele
for(i = 0; i < p; i++) // calculam mediile necesare si scriem in fisiere
{
if(fr[i] == 1)
{
m[i] = (note[i][0] + note[i][1] + note[i][2] + note[i][3] + note[i]
[4]) / 5.0;
fprintf(rf, "%s %.2lf\n",nume[i], m[i]);
}
else fprintf(er, "%s %d %d %d %d %d\n", nume[i], note[i][1], note[i]
[1], note[i][2], note[i][3], note[i][4]);
}
close(rf); close(er); // inchidem fisierele

return 0;
}
//////////////////////////////////////////////////////////////////////////////////////
////////////////////////