altyazıdan kelime anlamlarına.cpp

/*
	Bu program Abdullah Varıcı tarafından yazılmıştır.
	Benim ve program hakkında detaylı bilgi için:
	abdullahvarici.blogspot.com
	Bu programı kişisel ihtiyacınıza uygun olarak düzenleyip kullanabilirsiniz.
	
	Program sizden altyazı.srt dosyasını alır, içerisinden kelimeleri çeker ve 
	tekrar sayısıyla birlikte sıralı bir liste haline getirir. Bir de sizden 
	"bildiklerim.txt" isminde anlamını bildiğiniz kelimelerin içinde bulunduğu 
	bir nevi sizin İngilizce kelime haznenizi yansıtan bir dosyayı alıyor aynı 
	işlemleri buna da uyguluyor. Daha sonra bu iki dosyadaki kelimeleri karşılaştırıyor. 
	İki listedeki kelimeleri fark, kesişim ve birleşim kümesi olarak farklı 
	belgelere yazıyor. Sonrasında altyazıda bulunan ama anlamını bilmediğiniz 
	kelimeleri teker teker herhangi bir çekim eki aldıysa yalın hale çeviriyor 
	(bunu hem veritabanı kullanarak hem de grammer kurallarını kullanarak yapıyor) 
	ve bu kelimelerin anlamlarını sözlük veritabanından kontrol edip yeni bir 
	liste oluşturuyor. Son haldeki listemiz dizide geçen anlamını bilmediğimiz 
	kelimelerini, bu kelimelerin yalın hallerini, dizide tekrar etme miktarını ve 
	sözlükteki anlamlarını içeriyor. Bu programı diziye başlamadan önce çalıştırıp, 
	anlamını bilmediğiniz kelimelerin bir kısmına çalıştıktan sonra çalıştırarak 
	İngilizcemizi, en azından İngilizce kelime bilgimizi rahatça geliştirebiliriz. 
	Bu programın hedefi dizi film ve altyazı ile kısıtlı değil farklı amaçlar 
	için de kullanılabilir. Mesela iki farklı İngilizce metni karşılaştırmak, 
	kelimelerin tekrarlı listesini çıkarıp anlamlarına ulaşmak için de rahatça kullanılabilir.
*/

#include <iostream>
#include <string.h>
#include <vector>
#include <fstream>
using namespace std;

#define UZUNLUK 30			// Max. kelime uzunluğu

struct Kelime{				// Kelimelere ait struct yapısı oluşturuluyor.
	string kelime_ekli;		// Yalın olmayan, ek bulundurabilen kelime. Ör: goes, books, book;
	string kelime_yalin;	// kelime_ekli'deki kelimenin yalın hali. Ör: go, book, book;
	string anlam;			// Kelimenin sözlükteki anlamı. Ör: f. (went, gone) 1. gitmek. 2. -e çıkmak: She´s gone... 
	int tekrar;				// Kelimenin altyazıdaki tekrar miktarı.
	int toplam_tekrar;		// İki metin karşılaştırıldığındaki kelimenin toplam tekrar miktarı.
	bool kiyas_durumu;		// İki metini karşılaştırırken ihtiyaç duyuyoruz. 0 -> default ve ortak değil. 1 -> Kelime iki metinde de mevcut.
	bool sozluk_durumu;		// Kelime sözlükte varsa 1, yoksa 0.
	bool cekim_durumu;		// Kelime conjuge ve çoğullar listesinde varsa 1, yoksa 0
};

void vector_oku(char adres[100], vector <Kelime>* kelimeler);	
void vector_alfabetik_sirala(vector <Kelime>* kelimeler);
void vector_ekrana_yaz_anlamsiz(vector <Kelime> kelimeler);
void vector_dosyaya_yaz_anlamsiz(char adres[100], vector <Kelime> kelimeler);
void vector_tekrari_sil(vector <Kelime>* kelimeler);
void vector_tekrara_gore_sirala(vector <Kelime>* kelimeler);
void vector_karsilastir(vector <Kelime>* kelimeler_1, vector <Kelime>* kelimeler_2, vector <Kelime>* kelimeler_3, 
						vector <Kelime>* kelimeler_4, vector <Kelime>* kelimeler_5, vector <Kelime>* kelimeler_6);
void sozluk_oku(char adres[100], vector <Kelime>* kelimeler);
void cekimli_oku(char adres[100], vector <Kelime>* kelimeler);
int anlamlari_bul(vector <Kelime> kelimeler, vector <Kelime> sozluk_kelimeler, vector <Kelime> cekimli_kelimeler, vector <Kelime>* anlamli_kelimeler);
void anlamlari_duzenle(vector <Kelime>* anlamli_kelimeler);
void vector_ekrana_yaz_anlamli(char adres[100], vector <Kelime> anlamli_kelimeler);
void vector_dosyaya_yaz_anlamli(char adres[100], vector <Kelime> anlamli_kelimeler);


int main(){
	setlocale(LC_ALL, "Turkish");
		
	vector <Kelime> sozluk_vector;
	vector <Kelime> cekimli_vector;	
	vector <Kelime> altyazi_vector;
	vector <Kelime> bildiklerim_vector;
	vector <Kelime> afb;
	vector <Kelime> bfa;
	vector <Kelime> anb;
	vector <Kelime> aub;
	vector <Kelime> anlamli_vector;
	int bulunan;
		
	cout << "Sözlükteki kelimeler taranıyor..." << endl;
	sozluk_oku("sözlük.txt", &sozluk_vector);
	cout << "Sözlükte  <" << sozluk_vector.size() << ">  adet kelime bulundu."<< endl << endl;
	
	cout << "Çekimli kelimeler listesi taranıyor..." << endl;
	cekimli_oku("çekimli kelimeler.txt", &cekimli_vector);
	cout << "Çekimli kelimeler listesinde  <" << cekimli_vector.size() << ">  adet kelime bulundu."<< endl << endl;
	
	cout << "altyazı.srt'deki kelimeler alınıyor..." << endl;
	vector_oku("altyazı.srt", &altyazi_vector);
	cout << "altyazı.srt'den toplam  <" << altyazi_vector.size() << ">  adet kelime alındı." << endl << endl;
	
	cout << "bildiklerim.txt'deki kelimeler alınıyor..." << endl;
	vector_oku("bildiklerim.txt", &bildiklerim_vector);
	cout << "bildiklerim.txt'den toplam  <" << bildiklerim_vector.size() << ">  adet kelime alındı." << endl << endl;
	
	cout << "Listeler alfabetik sıralanıyor..." << endl;
	vector_alfabetik_sirala(&altyazi_vector);
	vector_alfabetik_sirala(&bildiklerim_vector);
	
	cout << "Tekrarsız listeler oluşturuluyor..." << endl << endl;
	vector_tekrari_sil(&altyazi_vector);
	vector_tekrari_sil(&bildiklerim_vector);
	
	cout << "altyazı.srt'de  <" << altyazi_vector.size() << ">  adet 'farklı' kelime var." << endl;
	cout << "bildiklerim.txt'de  <" << bildiklerim_vector.size() << ">  adet 'farklı' kelime var." << endl << endl; 
	
	cout << "altyazı.srt'den alfabetik liste a_alf.txt dosyasına yazdırılıyor..." << endl;
	vector_dosyaya_yaz_anlamsiz("a_alf.txt", altyazi_vector);
	cout << "bildiklerim.txt'den alfabetik liste b_alf.txt dosyasına yazdırılıyor..." << endl << endl;
	vector_dosyaya_yaz_anlamsiz("b_alf.txt", bildiklerim_vector);
	
	cout << "Listeler tekrara göre sıralanıyor..." << endl;
	vector_tekrara_gore_sirala(&altyazi_vector);
	vector_tekrara_gore_sirala(&bildiklerim_vector);
	
	cout << "altyazı.srt'den tekrar sıralı liste a_tek.txt dosyasına yazdırılıyor..." << endl;
	vector_dosyaya_yaz_anlamsiz("a_tek.txt", altyazi_vector);
	cout << "bildiklerim.txt'den tekrar sıralı liste b_tek.txt dosyasına yazdırılıyor..." << endl << endl;
	vector_dosyaya_yaz_anlamsiz("b_tek.txt", bildiklerim_vector);
	
	vector_alfabetik_sirala(&altyazi_vector);
	vector_alfabetik_sirala(&bildiklerim_vector);
	
	cout << "a_alf.txt ve b_alf.txt'deki kelimeler karşılaştırılıyor..." << endl;
	vector_karsilastir(&altyazi_vector, &bildiklerim_vector, &afb, &bfa, &anb, &aub);	
	vector_dosyaya_yaz_anlamsiz("afb.txt", afb);
	vector_dosyaya_yaz_anlamsiz("bfa.txt", bfa);
	vector_dosyaya_yaz_anlamsiz("anb.txt", anb);
	vector_dosyaya_yaz_anlamsiz("aub.txt", aub);
	cout << "Listeler karşılaştırıldı ve dosyalara yazıldı." << endl;
	cout << "afb.txt=a fark b | bfa.txt=b fark a | anb.txt=a kesişim b | aub.txt=a birleşim b" << endl;
	cout << "Son durumda a, b, afb, bfa, anb, aub listelerindeki kelime sayıları:" << endl;
	cout <<"a: "<<altyazi_vector.size() <<"   "<<"b: "<< bildiklerim_vector.size()<<"   "<<"afb: "<< afb.size();
	cout <<"   "<<"bfa: "<< bfa.size()<<"   "<<"anb: "<< anb.size()<<"   "<<"aub: "<< aub.size() << endl << endl;
	cout << "altyazı.srt'deki kelimelerin  %" << (float)anb.size()/altyazi_vector.size()*100 << "'ını zaten biliyorsun." << endl <<endl;
	
	cout << "afb.txt'deki kelimelerin anlamları alınıyor..." << endl;
	bulunan = anlamlari_bul(afb, sozluk_vector, cekimli_vector, &anlamli_vector);
	cout << "Sözlükten   " << bulunan << "  adet kelimenin anlamına bakıldı."<< endl;
	cout << afb.size()-bulunan << " adet kelime sözlükte ve çekimli kelime listesinde bulunamadı. Oran: "; 
	cout << "%"<< (float)bulunan/afb.size()*100 << endl << endl;
	
	cout << "Kelimeler ve anlamları listesi oluşturuluyor..." << endl;
	anlamlari_duzenle(&anlamli_vector);
	vector_dosyaya_yaz_anlamli("afb_anlamlar_alf.txt", anlamli_vector);
	cout << "afb_anlamlar_alf.txt dosyasında alfabetik liste oluşturuldu." << endl << endl;

	cout << "Tekrara dayalı liste oluşturuluyor..." << endl;
	vector_tekrara_gore_sirala(&anlamli_vector);
	vector_dosyaya_yaz_anlamli("afb_anlamlar_tek.txt", anlamli_vector);
	cout << "afb_anlamlar_tek.txt dosyasında tekrara göre sıralı liste oluşturuldu." << endl << endl;
	
	cout <<endl << endl << "Burada bitti işimiz. İyi çalışmalar..." << endl;
		
	getchar();
}

// Altyazı dosyasını açar. İçinden 2 ila 30 karakter büyüklüğündeki kelimeleri vector'e atar. 
// Bütün harfleri küçük harfe dönüştürür ve ingilizcedeki 26 karakter haricindeki karakterleri almaz; 
// denk geldiğinde kelimenin o karaktere kadar olan kısmını alır.
// Kelimeye ait tekrar başlangıç değerini 1; cekim_durumu ve sozluk_durumu değerlerini 0 olarak atar.
void vector_oku(char adres[100], vector <Kelime>* kelimeler){		
	FILE *pRead;
	if((pRead = fopen(adres, "r")) == NULL){
		cout << adres <<" açılamadı.";
	}
	
	int k=0;
	char harf, temp[UZUNLUK];
	Kelime tempStruct;
	while(!feof(pRead)){
		memset(temp, 0, UZUNLUK);
		fscanf(pRead, "%c", &harf);
		
		if((harf<='z' && harf>='a') || (harf<='Z' && harf>='A')){
			for(int i=0;i<UZUNLUK;i++){
				if(harf<='z' && harf>='a')
					temp[i]=harf;
				else if(harf<='Z' && harf>='A')
					temp[i]=harf+32;
				else{
					if(strlen(temp)>2){
						tempStruct.kelime_ekli = temp;
						tempStruct.tekrar = 1;
						tempStruct.cekim_durumu = 0;
						tempStruct.sozluk_durumu = 0;
						kelimeler->push_back(tempStruct);
					}
					break;
				}
				fscanf(pRead, "%c", &harf);
			}
		}
	}
	fclose(pRead);
}

// Aldığı vector'deki kelimelerin kelime_ekli değişkenini baz alarak alfabetik olarak sıralama yapar. 
void vector_alfabetik_sirala(vector <Kelime>* kelimeler){
	Kelime tempStruct;
	for(int i=0; i<kelimeler->size(); i++){
		for(int j=0; j<kelimeler->size()-1; j++){
			if((*kelimeler)[j].kelime_ekli > (*kelimeler)[j+1].kelime_ekli){
				tempStruct = (*kelimeler)[j];
				(*kelimeler)[j] = (*kelimeler)[j+1];
				(*kelimeler)[j+1] = tempStruct;
			}
		}
	}
}

// Aldığı vector'deki sıralamaya uygun olarak (alfabetik - tekrara dayalı - hiçbiri) tekrarı ve kelimeyi konsol ekranına yazar.
void vector_ekrana_yaz_anlamsiz(vector <Kelime> kelimeler){
	for(int i=0; i<kelimeler.size(); i++)
		cout <<"("<< kelimeler[i].tekrar <<")\t"<< kelimeler[i].kelime_ekli << endl;	
}

// Aldığı vector'deki sıralamaya uygun olarak (alfabetik - tekrara dayalı - hiçbiri) tekrarı ve kelimeyi dosyaya yazar.
void vector_dosyaya_yaz_anlamsiz(char adres[100], vector <Kelime> kelimeler){
	ofstream outFile(adres);
	for(int i=0; i<kelimeler.size(); i++)
		outFile <<"("<< kelimeler[i].tekrar <<")\t"<< kelimeler[i].kelime_ekli << endl;
	outFile.close();
}

// Aldığı vector'deki tekrar eden kelimelerin tekrar sayısını hesaplar ve tekrarsız bir liste oluşturur. 
void vector_tekrari_sil(vector <Kelime>* kelimeler){
	vector_alfabetik_sirala(kelimeler);
	for(int i=0; i<kelimeler->size()-1; i++){
		if((*kelimeler)[i].kelime_ekli == (*kelimeler)[i+1].kelime_ekli){
			(*kelimeler)[i].tekrar++;
			kelimeler->erase(kelimeler->begin()+i+1);
			i--;
		}
	}
}

// Aldığı vector'u kelimelerin tekrar sayısına göre çoktan aza doğru sıralar.
// Vector'un tekrar etmeyen ve tekrar sayısı hesaplanmış kelimelerden oluştuğuna emin olunuz. 
void vector_tekrara_gore_sirala(vector <Kelime>* kelimeler){
	Kelime tempStruct;
	for(int i=0; i<kelimeler->size(); i++){
		for(int j=0; j<kelimeler->size()-1; j++){
			if((*kelimeler)[j].tekrar < (*kelimeler)[j+1].tekrar){		// "<" yerine ">" kullanarak azdan çoğa doğru sıramlamış olursun
				tempStruct = (*kelimeler)[j];
				(*kelimeler)[j] = (*kelimeler)[j+1];
				(*kelimeler)[j+1] = tempStruct;
			}
		}
	}	
}

// Sırasıyla a b afb bfa anb aub vector'lerini aldığını düşünelim. 
// afb->a fark b	bfa->b fark a	anb->a kesişim b	aub->a birleşim b
// a ve b vector'leri herhangi iki farklı altyazıdan alınan kelimelerden oluşmuş ve sıralanmış olmalıdır.
// a ve b vector'leri karşılaştırılır. a'da bulunan ama b'de bulunmayan kelimelerin listesi afb'ye atanır.
// b'de bulunan ama a'da bulunmayan kelimelerin listesi bfa'ya atanır. Kelimelerdeki tekrar sayıları korunur ve atanır.
// Hem a'da hem b'de bulunan kelimelerin listesi anb'ye atanır ve anb'deki kelimelerin tekrar sayısı a'daki ve b'deki tekrar sayısının toplamına eşitlenir.
// afb, anb ve bfa vector'leri olduğu gibi birleştirilip aub vector'üne atanır.
void vector_karsilastir(vector <Kelime>* kelimeler_1, vector <Kelime>* kelimeler_2, vector <Kelime>* kelimeler_3, 
					vector <Kelime>* kelimeler_4, vector <Kelime>* kelimeler_5, vector <Kelime>* kelimeler_6){
	for(int i=0; i<kelimeler_1->size(); i++){
		(*kelimeler_1)[i].kiyas_durumu = 0;
	}
	for(int i=0; i<kelimeler_2->size(); i++){
		(*kelimeler_2)[i].kiyas_durumu = 0;
	}
	
	for(int i=0; i<kelimeler_1->size(); i++){
		for(int j=0; j<kelimeler_2->size(); j++){
			if((*kelimeler_1)[i].kelime_ekli == (*kelimeler_2)[j].kelime_ekli){
				(*kelimeler_1)[i].kiyas_durumu = 1;
				(*kelimeler_2)[j].kiyas_durumu = 1;
				(*kelimeler_1)[i].toplam_tekrar = (*kelimeler_1)[i].tekrar + (*kelimeler_2)[j].tekrar;
				(*kelimeler_2)[j].toplam_tekrar = (*kelimeler_1)[i].toplam_tekrar;
				break;
			}
		}
	}
	
	int k=0;
	for(int i=0; i<kelimeler_1->size(); i++){
		if((*kelimeler_1)[i].kiyas_durumu == 0){
			kelimeler_3->push_back((*kelimeler_1)[i]);
		}
		else{
			kelimeler_5->push_back((*kelimeler_1)[i]);
			(*kelimeler_5)[k].tekrar = (*kelimeler_5)[k].toplam_tekrar;
			k++;
		}
	}
		
	for(int i=0; i<kelimeler_2->size(); i++){
		if((*kelimeler_2)[i].kiyas_durumu == 0){
			kelimeler_4->push_back((*kelimeler_2)[i]);
		}
	}
	
	for(int i=0; i<kelimeler_3->size(); i++){
		kelimeler_6->push_back((*kelimeler_3)[i]);
	}
	for(int i=0; i<kelimeler_4->size(); i++){
		kelimeler_6->push_back((*kelimeler_4)[i]);
	}
	for(int i=0; i<kelimeler_5->size(); i++){
		kelimeler_6->push_back((*kelimeler_5)[i]);
	}
	
}

// Sözlük metnini açar ve kelimeleri kelime_yalin'e anlamlarını anlam'e atar.
void sozluk_oku(char adres[100], vector <Kelime>* kelimeler){
	ifstream input(adres);
	Kelime temp;
	while(getline(input, temp.kelime_yalin)){
		getline(input, temp.anlam);
		kelimeler->push_back(temp);
	}
}

// Conjuge ve çoğullar metnini açar. Kelimelerin yalın hallerini kelime_yalin'e, ek bulundaran halini kelime_ekli'e atar.
void cekimli_oku(char adres[100], vector <Kelime>* kelimeler){
	ifstream input(adres);
	Kelime temp;
	while(getline(input, temp.kelime_yalin)){
		getline(input, temp.kelime_ekli);
		kelimeler->push_back(temp);
	}
}

// Bu fonksiyonun ilk argümenti tarama yapacağı alfabetik sıralı ve tekrarsız kelimelerin bulunduğu altyazı ya da karşılaştırılmış vector'lerden biridir.
// ikinci argument sözlük vector'ü; üçüncüsü conjuge ve çoğullar vector'ü ve sonuncusu da sonuç vector'üdür.
// Bu fonksiyondan önce sozluk_oku ve cekimli_oku fonksiyonları çağırılmalıdır.
// Biraz anlamli ve karışık olan bu fonksiyon özet olarak önce kelimelerin kelime_ekli'lerini sözlükteki kelime_yalin'lerle karşılaştırıp;
// bulduklarını anlamlarıyla beraber sonuç vector'üne yazar. 
// Aynı zamanda sözcüklerin ek almış olma olasılığa karşın conjuge ve çoğullar listesinde arayıp tekrar sözlükte arar ve 
// yine bu kelimelere ait yalın hallerini ve anlamlarını sonuç vector'üne atar.
// Fonksiyon kelimelerin kaçını sözlük veya conjuge listesinde bulduysa sonucu return eder.
int anlamlari_bul(vector <Kelime> kelimeler, vector <Kelime> sozluk_kelimeler, vector <Kelime> cekimli_kelimeler, vector <Kelime>* anlamli_kelimeler){
	Kelime temp;
	int bulunan = kelimeler.size();
	int flag = 0;
	int flag1 = 0;
	int flag2 = 0;
	int flag3 = 0;
	string kelime;
	
	for(int i=0;i<kelimeler.size(); i++){
		for(int j=0; j<sozluk_kelimeler.size(); j++){
			if(kelimeler[i].kelime_ekli == sozluk_kelimeler[j].kelime_yalin){
				temp.kelime_ekli = kelimeler[i].kelime_ekli;
				temp.kelime_yalin = kelimeler[i].kelime_ekli;
				temp.tekrar = kelimeler[i].tekrar;
				temp.anlam = sozluk_kelimeler[j].anlam;
				anlamli_kelimeler->push_back(temp);
				flag1 = 1;
				break;
			}
		}
		
		for(int k=0; k<cekimli_kelimeler.size(); k++){
			if(kelimeler[i].kelime_ekli == cekimli_kelimeler[k].kelime_ekli){
				temp.kelime_ekli = kelimeler[i].kelime_ekli;
				temp.kelime_yalin = cekimli_kelimeler[k].kelime_yalin;
				temp.tekrar = kelimeler[i].tekrar;
				
				for(int m=0; m<sozluk_kelimeler.size(); m++){
					if(temp.kelime_yalin == sozluk_kelimeler[m].kelime_yalin){
						temp.anlam = sozluk_kelimeler[m].anlam;
						flag = 1;
						flag2 = 1;
					}
				}
				
				if(flag == 0)
					temp.anlam = "??????????";
					
				flag = 0;	
				anlamli_kelimeler->push_back(temp);
				break;
			}
		}
		
		if(flag1==0 && flag2==0){
			for(int j=0; j<sozluk_kelimeler.size(); j++){
				if(kelimeler[i].kelime_ekli == sozluk_kelimeler[j].kelime_yalin+"s"){
					temp.kelime_ekli = kelimeler[i].kelime_ekli;
					temp.kelime_yalin = sozluk_kelimeler[j].kelime_yalin;
					temp.tekrar = kelimeler[i].tekrar;
					temp.anlam = sozluk_kelimeler[j].anlam;
					anlamli_kelimeler->push_back(temp);
					flag3=1;
					break;
				}
			}
			
			if(flag3==0){
				temp.kelime_ekli = kelimeler[i].kelime_ekli;
				temp.kelime_yalin = "???";
				temp.tekrar = kelimeler[i].tekrar;
				temp.anlam = "??????????";
				anlamli_kelimeler->push_back(temp);
				bulunan--;
			}
		}
		flag1=0;
		flag2=0;
		flag3=0;
	}
	return bulunan;
}

// anlamli_kelimeler vector'undeki tekrar eden ve anlamları aynı olan kelimelerin tekrarları silinir.
void anlamlari_duzenle(vector <Kelime>* anlamli_kelimeler){
	for(int i=0; i<anlamli_kelimeler->size()-1; i++){
		if(((*anlamli_kelimeler)[i].kelime_ekli == (*anlamli_kelimeler)[i+1].kelime_ekli) && ((*anlamli_kelimeler)[i].anlam == (*anlamli_kelimeler)[i+1].anlam)){
			anlamli_kelimeler->erase(anlamli_kelimeler->begin()+i+1);
		}
	}
}

// anlamli_kelimeler vector'unu sözlükten bulunmuş anlamları ve altyazıdaki tekrar miktarlarıyla ekrana yazar.
void vector_ekrana_yaz_anlamli(char adres[100], vector <Kelime> anlamli_kelimeler){
	for(int i=0; i<anlamli_kelimeler.size(); i++)
		cout <<"("<< anlamli_kelimeler[i].tekrar <<")  "<< anlamli_kelimeler[i].kelime_ekli <<" -> "<< anlamli_kelimeler[i].kelime_yalin <<" = "<< anlamli_kelimeler[i].anlam << endl << endl;
}

// anlamli_kelimeler vector'unu sözlükten bulunmuş anlamları ve altyazıdaki tekrar miktarlarıyla dosyaya yazar.
void vector_dosyaya_yaz_anlamli(char adres[100], vector <Kelime> anlamli_kelimeler){
	ofstream outFile(adres);
	for(int i=0; i<anlamli_kelimeler.size(); i++)
		outFile <<"("<< anlamli_kelimeler[i].tekrar <<")  "<< anlamli_kelimeler[i].kelime_ekli <<" -> "<< anlamli_kelimeler[i].kelime_yalin <<" = "<< anlamli_kelimeler[i].anlam << endl << endl;
	outFile.close();
}