C Programlama Dilinde Sınıf Planlama Sistemi

Ara - 12
2017

C Programlama Dilinde Sınıf Planlama Sistemi

Sınıf Planlama Sistemi Z dersini alan öğrencilerin hangi sınıfta derse gireceklerini planlayan bir otomasyon sistemidir.

Sistem içeriğinde öğrencilerin Öğrenci Numarası, Adı, Soyadı, Kayıt Sıra ve Öğretim Türü bilgileri yer almaktadır. Program ilk olarak birden fazla derse atanmış öğrencilerin mükerrer kayıtlarını siler ve bu sayede her farklı kaydın dosyada bir kere bulunmasın sağlar.

Bu işlem sonrasında kayıt sıra bilgilerin tekrar güncellenir. Sisteme dahil olan yeni öğrencilere giriş yılı, sınıfı ve öğretim türünü dikkate alarak otomatik öğrenci numarası ataması yapar. İsme göre verilen içeriği öğrenci numarasına göre yeniden sıralar.

Kullanıcıdan alınan sınıf sayısı ve kapasitesine göre dağılımı gerçekleştiren sistem, yapılan sınıf dağılımlarını programın çalıştığı ana dizin içerisine .txt formatında kaydeder. Sistem yapılan işlemlerin ne kadar sürdüğüne dair bilgiyi ekrana yazdırır.

Ayrıca son aşamada sisteme yeni öğrenci kaydı yapılabilir.

Proje ödevim kapsamında gerçekleştirmiş olduğum bu ödeve ilişkin c kodlarını ve proje raporunu sizlere sunuyorum, eminim ki Bilgisayar Mühendisliği ya da benzeri eğitim gören arkadaşların işine yarayacaktır.

 

Proje Raporunun İndirme İçin Tıklayınız

ogrenci_kayit_bilgileri dosyasını indirip C dizini içerisine atın

Proje Kodları aşağıdaki gibidir.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define BONUS

/*Verilerin tutulacagı yapı*/
typedef struct{
char no[8];
char isim[30];
int kayit;
int ogretim;
}BilgilerStc;

/*Global Degiskenler*/
BilgilerStc Bilgiler[100];
BilgilerStc YeniBilgiler[100];
int elemanSayisi,yeniElemanSayisi, tekrarEdenElemanSayisi;
int tekrarEdenIndexler[100];
int ogrenciEkleniyor = 0;
time_t start,end;
double dif;
/*Prototypes*/
void esitDagilimYap(int sinifSayisi);
void kayitNumaralariniTekrarAl();
void tekrarEdenIsimleriBul(int ogrenciSayisi);
void kayitNumaralariniGuncelle(int index);
void ogrenciNumaralariAta();
void ogrenciNumarasinaGoreSiralamaYap();
void enAzSinifDagilimiYap(int sinifSayisi, int* pSinifKapasitesi);
void swapIntArrayIndex(int index, int* pSinifKapasitesi);
int searchIndexByName(char* isim, int ogrenciSayisi, BilgilerStc* pBilgiler);
int searchIndexByKayit(int kayit, int ogrenciSayisi, BilgilerStc* pBilgiler);
int searchIndexByOgretim(int ogretim, int ogrenciSayisi, BilgilerStc* pBilgiler);

int main()
{
/*Sure olcumunu baslat.*/
/*Kodun 88. satirinda tekrar sure olculup farki alinacak*/
start = clock();
/*BONUS icin gerekli etiket. Istedigimizde kodu buraya dondurecegiz*/
BAS:
;
/*BONUS icin gerekli*/
if(ogrenciEkleniyor==1)
{
memset(YeniBilgiler, 0, sizeof(YeniBilgiler));
ogrenciEkleniyor = 0;
}
/*KOD ilk acilista buradan baslar*/
/*FILE pointer objesi*/
FILE *fp;
fpos_t pos;
int pozisyon = 0;
elemanSayisi = 0;
yeniElemanSayisi = 0;
/*Dosyayi ac*/
fp = fopen(“C:\\ogrenci_kayit_bilgileri.txt”,”r+”);

while (!feof(fp))
{
if (fscanf(fp,”%s\t%s\t%d\t%d”,&Bilgiler[elemanSayisi].no,
&Bilgiler[elemanSayisi].isim,&Bilgiler[elemanSayisi].kayit,&Bilgiler[elemanSayisi].ogretim)!=4)
{

break;
}
elemanSayisi++;
}
int errCnt = 0;
/*-Tekrar eden isimlerin bulunmasi *
*-Tekrar eden elemanlarinin indexlerinin kaydedilmesi *
*-Global elemanSayisi ve yeniElemanSayisi degiskenlerinin degerlerinin belirlenmesi*
*-Kayit numaralarinin ilk listedeki elemanlar için güncellenmesi */
tekrarEdenIsimleriBul(elemanSayisi);
/*Güncel kayit numaralarinin tekrar alinmasi*/
kayitNumaralariniTekrarAl();
/*Numarasi olmayanlara numara atamasi yapilmasi*/
ogrenciNumaralariAta();
/*Ogrenci numarasina gore siralama yap*/
ogrenciNumarasinaGoreSiralamaYap();
/*Sonuclari yazdir*/
int dagilimTuru = 0;
int sinifSayisi;
int geciciKapasite = 0;
int sinifKapasitesi[10];
int kalanOgrenciSayisi = yeniElemanSayisi;

/*Zamani olc*/
/*Programin basinda alinan olcumle buradaki olcumun farkini al*/
/*time.h ‘de bulunan CLOCKS_PER_SEC’e bol ve saniyeyi bul*/
end = clock();
dif = difftime(end,start) / CLOCKS_PER_SEC;
printf (“Buraya kadar olan islemler su kadar surede tamamlandi: %.4lf saniye.\n”, dif );

printf(“- – -\n”);
printf(“Siniflara dagilim seklini seciniz: \n 1-Esit dagilim \n 2-En az sinif dagilimi\n”);
while(1)
{
scanf(“%d”, &dagilimTuru);
if(dagilimTuru==1)
{
printf(“Esit dagilim secenegini sectiniz. Toplam ogrenci sayisi: %d. \n Her ogretim icin esit kapasiteli kac sinif olsun?\n”, yeniElemanSayisi);
while(1)
{
scanf(“%d”, &sinifSayisi);
if(sinifSayisi<=0 || sinifSayisi>yeniElemanSayisi)
printf(“Gecersiz sinif sayisi girdiniz.\n Sinif sayisini tekrar giriniz:\n”);
else
{
esitDagilimYap(sinifSayisi);
break;
}
}

break;
}
else if (dagilimTuru==2)
{
printf(“En az sinif dagilimi secenegini sectiniz.\n Toplam ogrenci sayisi: %d \n Sinif sayisi giriniz:\n”, yeniElemanSayisi);
scanf(“%d”, &sinifSayisi);
int indx = 0;
for(indx=0; indx<sinifSayisi; indx++)
{
printf(“%d. sinifinin kapasitesini giriniz:\n”, indx+1);
scanf(“%d”, &geciciKapasite);
if(geciciKapasite>=2)
{
sinifKapasitesi[indx] = geciciKapasite;
kalanOgrenciSayisi -= geciciKapasite;
if(kalanOgrenciSayisi>0)
printf(“\(Bilgilendirme: %d ogrenci icin daha yer gerekiyor\)\n”, kalanOgrenciSayisi);
else
printf(“\(Bilgilendirme: Yeterli kapasite saglandi.\)\n”);
}
else
{
printf(“Gecersiz sinif kapasitesi. Kapasite 2 veya daha buyuk olmalidir.\n”);
indx–;
}
}
enAzSinifDagilimiYap(sinifSayisi, &sinifKapasitesi);
break;
}
else
{
printf(“Yanlis secim yaptiniz. Lutfen tekrar secim yapiniz.\n”);
}

}

fclose(fp);
#ifdef BONUS
int eklemeSecimi;
while(1)
{
printf(“\nLISTEYE YENI OGRENCI EKLEYIP ISLEMLERI TEKRARLAMAK ISTER MISINIZ?\n 1-EVET\n 2-HAYIR\nSECIMINIZ: “);
scanf(“%d”, &eklemeSecimi);

if(eklemeSecimi == 1)
{
FILE* ekle = fopen(“C:\\ogrenci_kayit_bilgileri.txt”,”a”);
printf(“Ogrenci ismini giriniz: “);
scanf(“%s”, &Bilgiler[yeniElemanSayisi].isim);
printf(“Ogrenci numarasi giriniz: “);
scanf(“%s”, &Bilgiler[yeniElemanSayisi].no);
printf(“Ogrenci kayit sirasi giriniz: “);
scanf(“%d”, &Bilgiler[yeniElemanSayisi].kayit);
printf(“Ogrenci ogretim turu giriniz \(1 ya da 2\): “);
scanf(“%d”, &Bilgiler[yeniElemanSayisi].ogretim);
fprintf(ekle,”%s\t%s\t%d\t%d\n”,Bilgiler[yeniElemanSayisi].no,Bilgiler[yeniElemanSayisi].isim,Bilgiler[yeniElemanSayisi].kayit,Bilgiler[yeniElemanSayisi].ogretim);
fclose(ekle);
ogrenciEkleniyor = 1;
goto BAS;
break;
}
else if(eklemeSecimi == 2)
{
printf(“PROGRAM SONLANDIRILIYOR…\n”);
break;
}
else
{
printf(“Yanlis secim yapildi.\n”);
}
}
#endif
}
void esitDagilimYap(int sinifSayisi)
{
int kaydedilenOgrenciSayisi = 0;
char dosyaIsmi[18];
int sinifKapasiteleri[20];
int maxKapasite=yeniElemanSayisi;
int gerekliKapasite = yeniElemanSayisi;
int tekKapasite;
int indx = 0, i=0;
//printf(“######%d#######”, sinifSayisi);
while(maxKapasite%sinifSayisi!=0)
{
maxKapasite++;
}
tekKapasite = maxKapasite / sinifSayisi;
while(gerekliKapasite>=tekKapasite)
{
sinifKapasiteleri[indx] = tekKapasite;
indx++;
gerekliKapasite-=tekKapasite;
}
sinifKapasiteleri[indx] = gerekliKapasite;
if(sinifSayisi-indx != 1)
{
sinifKapasiteleri[indx+1] = 0;
printf(“Bu secimde %d ogrenci sayisi icin %d sinif olusturulamadi.\n”, yeniElemanSayisi, sinifSayisi);
printf(“Ancak %d sinif olusturulabilmiştir.\n”, indx+1);
}
printf(“%d sinif sayisi secimi icin olusturulan sinif kapasiteleri: “, sinifSayisi);
for(indx = 0; indx < sinifSayisi; indx++)
printf(“%d “, sinifKapasiteleri[indx]);
printf(“olarak duzenlendi.\n”);
FILE* yaz;
int ogrenciIndex = 0;
while(i<sinifSayisi)
{
while(sinifKapasiteleri[i]!=0)
{
if(YeniBilgiler[ogrenciIndex].ogretim == 1)
{
sprintf(dosyaIsmi, “”);
sprintf(dosyaIsmi, “C:\\sinif%d”, i+1);
strcat(dosyaIsmi, “ogr1\.txt”);
yaz = fopen(dosyaIsmi,”a”);
fprintf(yaz,”%s\t%s\t%d\t%d\n”,YeniBilgiler[ogrenciIndex].no,YeniBilgiler[ogrenciIndex].isim,YeniBilgiler[ogrenciIndex].kayit,YeniBilgiler[ogrenciIndex].ogretim);
printf(“%s isimli ogrenci %s dosyasina kaydedildi.\n”, YeniBilgiler[ogrenciIndex].isim, dosyaIsmi);
kaydedilenOgrenciSayisi++;
}
else if(YeniBilgiler[ogrenciIndex].ogretim == 2)
{
sprintf(dosyaIsmi, “”);
sprintf(dosyaIsmi, “C:\\sinif%d”, i+1);
strcat(dosyaIsmi, “ogr2\.txt”);
yaz = fopen(dosyaIsmi,”a”);
fprintf(yaz,”%s\t%s\t%d\t%d\n”,YeniBilgiler[ogrenciIndex].no,YeniBilgiler[ogrenciIndex].isim,YeniBilgiler[ogrenciIndex].kayit,YeniBilgiler[ogrenciIndex].ogretim);
printf(“%s isimli ogrenci %s dosyasina kaydedildi.\n”, YeniBilgiler[ogrenciIndex].isim, dosyaIsmi);
kaydedilenOgrenciSayisi++;
}
ogrenciIndex++;
sinifKapasiteleri[i]–;
}
if(kaydedilenOgrenciSayisi<yeniElemanSayisi)
{
printf(“—“);
printf(“###\(Bilgilendirme: %d. sinifin kapasitesi doldu\)###\n”, i+1);
}
i++;
}
if(kaydedilenOgrenciSayisi<yeniElemanSayisi)
printf(“%d ogrenci acikta kalmistir. Tum ogrenciler yerlestirilemedi.”, yeniElemanSayisi-kaydedilenOgrenciSayisi);
else
printf(“%d ogrencinin tamami yerlestirildi.”, kaydedilenOgrenciSayisi);

}
void enAzSinifDagilimiYap(int sinifSayisi, int* pSinifKapasitesi)
{
FILE* yaz;
char dosyaIsmi[18];
int indx1 = 0, indx2 = 0,i=0, kaydedilenOgrenciSayisi = 0;
/*Bubble Sort*/
for(indx1 = 0; indx1<sinifSayisi-1; indx1++)
{
for(indx2 = 0; indx2<sinifSayisi-1; indx2++)
{
if(pSinifKapasitesi[indx2] < pSinifKapasitesi[indx2+1])
swapIntArrayIndex(indx2, pSinifKapasitesi);
}
}
printf(“Sinif kapasiteleri: “);
for(indx1 = 0; indx1<sinifSayisi; indx1++)
printf(“%d “, pSinifKapasitesi[indx1]);
printf(“olarak siralandi.\n”);

int ogrenciIndex = 0;
while(i<sinifSayisi)
{
while(pSinifKapasitesi[i]!=0)
{
if(YeniBilgiler[ogrenciIndex].ogretim == 1)
{
sprintf(dosyaIsmi, “”);
sprintf(dosyaIsmi, “C:\\sinif%d”, i+1);
strcat(dosyaIsmi, “ogr1\.txt”);
yaz = fopen(dosyaIsmi,”a”);
fprintf(yaz,”%s\t%s\t%d\t%d\n”,YeniBilgiler[ogrenciIndex].no,YeniBilgiler[ogrenciIndex].isim,YeniBilgiler[ogrenciIndex].kayit,YeniBilgiler[ogrenciIndex].ogretim);
printf(“%s isimli ogrenci %s dosyasina kaydedildi.\n”, YeniBilgiler[ogrenciIndex].isim, dosyaIsmi);
kaydedilenOgrenciSayisi++;
}
else if(YeniBilgiler[ogrenciIndex].ogretim == 2)
{
sprintf(dosyaIsmi, “”);
sprintf(dosyaIsmi, “C:\\sinif%d”, i+1);
strcat(dosyaIsmi, “ogr2\.txt”);
yaz = fopen(dosyaIsmi,”a”);
fprintf(yaz,”%s\t%s\t%d\t%d\n”,YeniBilgiler[ogrenciIndex].no,YeniBilgiler[ogrenciIndex].isim,YeniBilgiler[ogrenciIndex].kayit,YeniBilgiler[ogrenciIndex].ogretim);
printf(“%s isimli ogrenci %s dosyasina kaydedildi.\n”, YeniBilgiler[ogrenciIndex].isim, dosyaIsmi);
kaydedilenOgrenciSayisi++;
}
ogrenciIndex++;
pSinifKapasitesi[i]–;
}
if(kaydedilenOgrenciSayisi<yeniElemanSayisi)
{
printf(“—“);
printf(“###\(Bilgilendirme: %d. sinifin kapasitesi doldu\)###\n”, i+1);
}
i++;
}

if(kaydedilenOgrenciSayisi<yeniElemanSayisi)
printf(“%d ogrenci acikta kalmistir. Tum ogrenciler yerlestirilemedi.”, yeniElemanSayisi-kaydedilenOgrenciSayisi);
else
printf(“%d ogrencinin tamami yerlestirildi.”, kaydedilenOgrenciSayisi);

}
void swapIntArrayIndex(int index, int* pSinifKapasitesi)
{
int tmp;
tmp = pSinifKapasitesi[index];
pSinifKapasitesi[index] = pSinifKapasitesi[index+1];
pSinifKapasitesi[index+1] = tmp;
}
void ogrenciNumarasinaGoreSiralamaYap()
{
int numara, sonrakiNumara, index, loop;
/*Bubble Sort algoritmasi ile kucukten buyuge sıralama*/
for(loop = 0; loop<yeniElemanSayisi;loop++)
{
for(index = 0; index<yeniElemanSayisi-1; index++)
{
numara = atoi(YeniBilgiler[index].no);
sonrakiNumara = atoi(YeniBilgiler[index+1].no);

if(numara > sonrakiNumara)
{
swapDegisken(index);
printf(“Ogrenci numarasi gore siralama yapiliyor… Index:%d\n”, index);
}
else
{

}
}
}
}
void swapDegisken(int index)
{
BilgilerStc bilgilerYedek;
memcpy(&bilgilerYedek, &YeniBilgiler[index], sizeof(YeniBilgiler[index]));
memcpy(&YeniBilgiler[index], &YeniBilgiler[index+1], sizeof(YeniBilgiler[index+1]));
memcpy(&YeniBilgiler[index+1], &bilgilerYedek, sizeof(bilgilerYedek));

}
void ogrenciNumaralariAta()
{
int index = 0;
char ogretimS[5];
char kayitS[5];
for(index=0; index<yeniElemanSayisi; index++)
{

if( strcmp(YeniBilgiler[index].no, “-“) == 0)
{
sprintf(ogretimS, “%d”, YeniBilgiler[index].ogretim);
sprintf(kayitS, “%d”, YeniBilgiler[index].kayit);
char numara[8] = “170”;
strcat(numara, ogretimS);
if(YeniBilgiler[index].kayit >= 0 && YeniBilgiler[index].kayit <=9)
strcat(numara,”00″);
if(YeniBilgiler[index].kayit >= 10 && YeniBilgiler[index].kayit <=99)
strcat(numara,”0″);
strcat(numara, kayitS);

strncpy(YeniBilgiler[index].no, numara, sizeof(numara));
printf(“OgrenciNoAta: %d. satirdaki ogrenciye %s numarasi atandi..\n”, index+1, YeniBilgiler[index].no);
}

}
}
void kayitNumaralariniTekrarAl()
{
int index = 0, tekrarEdenIndex;
for(index = 0; index<yeniElemanSayisi; index++)
{
int checkIndex = searchIndexByName(YeniBilgiler[index].isim, elemanSayisi, &Bilgiler);
for(tekrarEdenIndex = 0; tekrarEdenIndex<tekrarEdenElemanSayisi; tekrarEdenIndex++)
{
if(tekrarEdenIndexler[tekrarEdenIndex] != checkIndex)
{
YeniBilgiler[index].kayit = Bilgiler[checkIndex].kayit;
}
}
}
}
void tekrarEdenIsimleriBul(int ogrenciSayisi)
{
int tmpIndex, tekrarCounter = 0;
for(tmpIndex = 0; tmpIndex < ogrenciSayisi; tmpIndex++)
{
int i = searchIndexByName(Bilgiler[tmpIndex].isim, elemanSayisi, &YeniBilgiler);
if(i == -1)
{
/*Bu isim yok. Kayýtlara ekle*/
strncpy(YeniBilgiler[tmpIndex-tekrarCounter].isim, Bilgiler[tmpIndex].isim, sizeof(YeniBilgiler[tmpIndex].isim));
strncpy(YeniBilgiler[tmpIndex-tekrarCounter].no, Bilgiler[tmpIndex].no, sizeof(YeniBilgiler[tmpIndex].no));
YeniBilgiler[tmpIndex-tekrarCounter].kayit = Bilgiler[tmpIndex].kayit;
YeniBilgiler[tmpIndex-tekrarCounter].ogretim = Bilgiler[tmpIndex].ogretim;

yeniElemanSayisi++;

}
else{
printf(“TekrarlananIsim: %d. satirdaki %s tekrarlanmis. Listeden cikarildi \n”, tmpIndex+1, Bilgiler[tmpIndex].isim);
kayitNumaralariniGuncelle(tmpIndex);

tekrarEdenIndexler[tekrarCounter] = tmpIndex;
tekrarEdenElemanSayisi++;
tekrarCounter++;
}
}
}
void kayitNumaralariniGuncelle(int index)
{
int i;
for(i=0; i<elemanSayisi; i++)
{
if(Bilgiler[i].kayit >= Bilgiler[index].kayit)
{
Bilgiler[i].kayit–;
int tmp = searchIndexByName(Bilgiler[i].isim, yeniElemanSayisi, &YeniBilgiler);
YeniBilgiler[tmp].kayit = Bilgiler[i].kayit;
printf(“KayitNoGuncelle: %s isimli ogrencinin kayit numarasi %d oldu.\n”, Bilgiler[i].isim, Bilgiler[i].kayit);
}
}
}
int searchIndexByName(char* isim, int ogrenciSayisi, BilgilerStc* pBilgiler)
{
int indx;
int result = 0;
for(indx = 0; indx<ogrenciSayisi; indx++)
{
if(strcmp(pBilgiler[indx].isim, isim) == 0)
{
result = 1;
break;
}
}
if(result!=1)
{
indx = -1;
}
return indx;

}
int searchIndexByKayit(int kayit, int ogrenciSayisi, BilgilerStc* pBilgiler)
{
int indx;
for(indx = 0; indx<ogrenciSayisi; indx++)
{
if(pBilgiler[indx].kayit==kayit)
{
break;
}
}
return indx;
}
int searchIndexByOgretim(int ogretim, int ogrenciSayisi, BilgilerStc* pBilgiler)
{
int indx;
for(indx = 0; indx<ogrenciSayisi; indx++)
{
if(pBilgiler[indx].ogretim==ogretim)
{
break;
}
}
return indx;
}