dinamik dört işlem

[fhalim]

çok büyük sayılarla işlem yapmakla ilgili bir ödev yapıyorum. dün gece kastım toplamayı bitirdim, çarpmanın da algoritması kafamda şekillendi, fakat bölmede tıkandım, aşağıdaki kod toplama için? bölme için bir fikirlerinizi bekliyorum

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
// 3 5 6
// -> ->
// F.Halim

typedef struct digit digit;

struct digit{

int data;
digit* next;
digit* prev;

};

digit* basaEkle(digit*,int);
digit* sonaEkle(digit*,int);
void yaz(digit*);

digit* sonGetir(digit*);
digit* topla(digit*,digit*);


int main()
{
/*
digit* ornek;
ornek = (digit*) malloc( sizeof(digit) );
ornek -> data = -1;
ornek -> next = NULL;
ornek -> prev = NULL;
*/
digit* num1;
num1 = (digit*) malloc( sizeof(digit) );
num1 -> data = -1;
num1 -> next = NULL;
num1 -> prev = NULL;

digit* num2;
num2 = (digit*) malloc( sizeof(digit) );
num2 -> data = -1;
num2 -> next = NULL;
num2 -> prev = NULL;


int i,n;
srand(time(NULL));

for(i=0; i<25; i++)
{
n = (int) (10.0*rand()/(RAND_MAX+1.0));//1 ve 9 dahil
sonaEkle(num1,n);

n = (int) (10.0*rand()/(RAND_MAX+1.0));
sonaEkle(num2,n);
}

for(i=0; i<5; i++)
{
n = (int) (10.0*rand()/(RAND_MAX+1.0));
sonaEkle(num2,n);
}



yaz(num1);
printf("\n");
yaz(num2);


// num2 = basaEkle(num2,3);
// printf("\n");
// yaz(num2);

digit* num3;
num3 = (digit*) malloc( sizeof(digit) );
num3 -> data = -1;
num3 -> next = NULL;
num3 -> prev = NULL;

num3 = topla(num1,num2);
printf("\n");
yaz(num3);



return 0;
}

void yaz(digit* bas)
{
digit* gezici = bas;

while(gezici != NULL)
{
printf("%d",gezici->data);
gezici = gezici->next;
}
}

digit* sonGetir(digit* bas)
{
digit* gezici = bas;
digit* son;
while(gezici != NULL)
{
son = gezici;
gezici = gezici->next;
}

return son;
}


digit* sonaEkle(digit* bas, int ekle)
{
if(bas->data == -1)
{
bas->data=ekle;
return bas;
}
else
{
digit* yeni;
yeni = (digit*) malloc( sizeof(digit) );
yeni -> data = -1;
yeni -> next = NULL;
yeni -> prev = NULL;


digit* eskison = sonGetir(bas);
eskison->next = yeni;
yeni->prev = eskison;
yeni->data = ekle;

return bas;
}
}

digit* basaEkle(digit* bas, int ekle)
{
if(bas->data == -1)
{
bas->data=ekle;
return bas;
}
else
{
digit* yeni;
yeni = (digit*) malloc( sizeof(digit) );
yeni -> data = -1;
yeni -> next = NULL;
yeni -> prev = NULL;


bas->prev = yeni;
yeni->next = bas;
yeni->data = ekle;


return yeni;
}

}

digit* topla(digit* t1, digit* t2)
{
digit* g1=sonGetir(t1);
digit* g2=sonGetir(t2);

digit* yeni;
yeni = (digit*) malloc( sizeof(digit) );
yeni -> data = -1;
yeni -> next = NULL;
yeni -> prev = NULL;

int elde=0;
int aratoplam=0;



while(g1 != NULL && g2 != NULL )
{
aratoplam = g1->data + g2->data + elde;

if(aratoplam > 9)
{
elde=1;
aratoplam = aratoplam - 10;
}
else
{
elde=0;
}

yeni = basaEkle(yeni,aratoplam);
g1 = g1->prev;
g2 = g2->prev;
}

if(g1 == NULL)
{
while(g2 != NULL)
{
aratoplam = g2->data + elde;

if(aratoplam > 9)
{
elde = 1;
aratoplam = aratoplam - 10;
}
else
{
elde = 0;
}

yeni = basaEkle(yeni,aratoplam);
g2=g2->prev;
}

}
else if(g2 == NULL)
{
while(g1 != NULL)
{
aratoplam = g1->data + elde;

if(aratoplam > 9)
{
elde = 1;
aratoplam = aratoplam - 10;
}
else
{
elde = 0;
}
}
}


if(elde == 1)
{
yeni = basaEkle(yeni,1);
}

return yeni;
}

[acehreli]

Bolme islemi zamaninda bana da cok zor gelmisti. Sonucta su yontemi kullanmistim:

http://www.bearcave.com/software/divide.htm

Ian Kaplan'a izin icin mektup yazdigimda, bana sitesindeki kodlar icinde o sayfanin en cok kullanilan oldugunu soylemisti :) Simdi emin degilim ama galiba gcc'nin bir surumunun de o kodu kullandigini soylemisti.

Ilkokulda ogrendigimiz basit bolme islemini uyguladigini soylese de ben hAlA anlamiyorum :)

Ali

[fhalim]

algoritma güzel de, benim bunu integer kullanmayacak şekilde gelştirmem lazım, ilk verdiğim kodu incelersen sevinirim

[acehreli]

Oncelikle, islevi kendi turunu alacak sekilde degistirmek gerek:


void unsigned_divide(digit * dividend,
digit * divisor,
digit ** quotient,
digit ** remainder )
{
/* ... */
}


Parametreleri Turkcelestirmek de iyi:

dividend: bolunen
divisor: bolen
quotient: bolum
remainder: kalan

O algoritmanin aldigi parametrelerle neler yaptigina bakip ayni islemleri senin sayi turune uygularsan, algoritma senin icin de calisir. Ornegin, 'divisor == dividend' islemi icin soyle bir islev yazabilirsin:

int esittir(digit *, digit *);

[Not: Sabit nesneleri de karsilastirabilmek icin o parametrelerin aslinda 'digit const *' olmalari gerekir; ama sen hic const kullanmadigin icin ben de const'siz yazdim.]

Sonra algoritmayi ornegin soyle degistireceksin:


if (esittir(divisor, dividend))
{
ata(quotient, 1);
return;
}


operator& islecinin 0x80000000 ile kullanmasinin anlami, sayinin eksi olup olmadigina bakmak olmali. Onun icin de bir islevin olmali...

operator<< ile sola kaydirmak 2 ile carpmakla aynidir. vs.

Dedigim gibi, algoritmayi kendim tam anlamadigim icin bundan fazla yardimci olamiyorum... :)

Ali

[fhalim]

eywallah tşk, kasıp yapacağım, zaten çıkarma bitti :)
bölme işlemi de aslında birsürü çıkarma işlemi gibi. neyse yazalım şanımız yürüsün :)

[atg]

Ilkokulda ogrendigimiz basit bolme islemini uyguladigini soylese de ben hAlA anlamiyorum :)


terzi kendi yamağını dikemezmiş...

sanırım şöyle;

kalandan böleni çıkar eğer sonuç pozitif sayı ise bölüm hanesine 1 eğer sonuç negatif sayı ise bölüm hanesine 0 yaz işlemi geri al

örneğin 404/4 kaç eder?

404 | 4
----
4 |1
- |
------
0


önce en soldan başlarız, dördün içinde 4 kaç kere var? 1 kere tamam yazalım 4 ü bölünenin en alt soluna bölüm hanesinede BİR YAZALIM,

şimdi aradan en soldaki 4 çıktı şimdi onu yok sayabiliriz yukarıda ne var sırada 0 var indirelim aşağıya


404 | 4
----
4 |10
- |
-------
00

0 da 4 kaç kere var ( yada başka bir deyişle 0 - 4 sıfırdan büyük müdür? ) 0 kere var, ha o zaman bölüme bir sıfır ekleyelim ve sona kalan 4 üzerinede aynı işlemi uygulayalım, bölüm = 101

şimdi burda vatandaşın yaptığı şeyde aslında aynı şey

bit = (dividend & 0x80000000) >> 31;

satırını ile dividend( 32 bit integer ) değişkeninin en soldaki(the high order ) bitini bulmuş, e biz biraz öncede aynı şeyi yapmadık mı? en sola bakıp 4 ü alıp, 4 ün içinde 4 kaç kere var diye sormadık mı? varsayalım ki bölenimiz 4 değilde 5 ti, o zaman ne yapardık? bir sağdaki rakamı alırdık, doğru mu? yani 40 ın içinde 5 arardık, şöyle

önce

remainder = (remainder << 1) | bit;

yazarız ve elimizdeki biti kaydederiz, bunun bölenden büyük olup olmadığını kontrol ederiz eğer küçükse

dividend = dividend << 1;

yazarak 2. biti 1 bit konumuna getiririzki (dividend & 0x80000000) >> 31 deyince elimize en orjinal sayıdaki 2. bit geçsin daha sonra tekrar

ikinci biti

remainder = (remainder << 1) | bit;

yazarak kaydederiz yani elimizdeki remaider sayısı 0001 şeklindeyse önce << ile bunu sola kaydırırız yani 0010 yaparız sonrada | 0001 işleminden geçiririz (yeni bitimizinde 1 olduğunu varsayıyorum )


0010
0001
--------
0011

sonuç olarak 4 ün yanına 0 yazmış ve 40 elde etmiş gibi, yani adam bitlere kağıda yazar gibi yazmış,

şu anda öncekinden bir fazla haneli bir sayıda, böleni arıyoruz, nasılki normal bölmede her seferinde örneğin, 4 ün içinde 5 kaç kere var, yok 40 içinde kaç kere var diye arıyorsak, burada

while (remainder < divisor)

şeklinde kontrol edilmiş, evet değiken adları insanı yanıltabiliyor çünkü ilk aşamada 4 yada 40 sayısı bölümden kalan gibi bir manada değiller, henüz daha var mı yok mu diye deniyoruz çünkü, burada num_bits ise kalan sayıların miktarını vermiş yani siz 404 den 4 ü alınca geriye iki hane kalır, bu adamda her bir biti aldıkça, num_bits değerini bir düşürmüş, 32 den aşağıya doğru geliyor.

vs vs derken diğer döngüye girilmiş...

şimdi biz insanlar normalde çarpım tablosuna göre gideriz yani dördün içide beş kaç kere var? hiç kere, peki 40'ın içinde 5 kaç kere var( ıııı.. 5 kere 8.... ıııı... hah 40 ) 8 defa, ama burada şöyle bir durum var, bilgisayar çarpım tablosunu bilmezki?(tamam öğretilebilir ama basit bir bölme işlemi için fazla) o zaman ilkokulda örendiğimiz bölme işlemine bakalım(tabi bunun 2 lik sistemdeki halini ortaokulda öğrendik)
bu bölmede, ana mantık şu "kalandan böleni çıkar"

biraz önceki işlemimizi ikilik sistemde yapalım yanii 404/4


404 -> 110010100,
4 -> 100

110010100 | 100
----
100 | 1
- |
------------
010



1-) 110 da 100 1 defa var kaldı geriye 10, yaz tahtaya(bölüm) bir


110010100 | 100
----
100 | 11
- |
------------
0100
- 100
-----
0000


2-)indirelim aşağı bir sıfır, 100 ın içinde 100 kaç kere var? 1 kere, yaz tahtaya



110010100 | 100
----
100 | 1001
- |
------------
0100
- 100
-----
0000
101
- 100
-------
001



evet rakam sıfır, o zaman en soldaki biri indirelim, 1 de 100 kaç kere var( yada 1 - 100 negatif midir? pozitif mi? ) hiç kere var yaz o zaman bir sıfır, bir sonraki rakamı indir, 10 da varmı yok, yaz bi sıfır daha, indir sıradakini, 101 de varmı evet var, yaz ozaman bir......

sonuç 1100101, bizim bölüm hanesine yazdığımız gibi adamda yine bit kaydırıp yer açma metoduna göre quotient değişkenine atamış hepsi bu

//büyük uğraşlarıma rağmen şu ilk okulda yaptığımız "sola devrilmiş T" işaretini çizdiremedim, boşluklar net çıkmadığı için | işaretleri alt alta gelmemiş düzelttim.

[Euclides]

gooooooole -> "Karatsuba Multiplication"

[fhalim]

şükür bitti, ödev teslim tarihinden hemen sonra(haftaya) buraya kodları koyacağım,
belleğinizin yettiği kadar sayıları çarpıp bölmeniz için :)

[fhalim]

gerek kalmadı

[acehreli]

.exe dosya verilir mi; verilse acilir mi! :) Virusludur, Linux'ta ise yaramaz, vs. vs.

Ali

[fhalim]

.exe dosya verilir mi; verilse acilir mi! :) Virusludur, Linux'ta ise yaramaz, vs. vs.

Ali
acemilik mi dersiniz, iyi niyet mi, yoksa saflık mı :) neyse epey fantezi var kodda, eksikleri hataları fazlalıkları söylerseniz sevinirim
//F.Halimoglu

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

typedef struct digit digit;

struct digit{

int data;
digit* next; //sag basamak
digit* prev; //sol basamak

};

digit* basaEkle(digit*,int); //dizinin soluna basamak ekle
digit* sonaEkle(digit*,int); // "" sagina basamak ekle

void yaz(digit*);
void yaz2(digit*);
digit* temizle(digit*); //soldaki 0 lari siler

digit* sonGetir(digit*); //en sagdaki basamagi getirir
digit* basGetir(digit*); //en soldaki "" ""

digit* topla(digit*,digit*); //digit dizimiz icin toplama islemi
digit* cikar(digit*,digit*); // "" "" "" cikarma ""


int sifirmi(digit*); //dizi 0 ise true, degilse false
int kiyas(digit*,digit*); //1.parametre 2.'den buyukse true, kucukse -1, esitse 0

digit* kopyala(digit*); //program icinde fonksiyonlar pointer cagirdigindan,
//esas diziyi kaybetmemek icin dizinin kopyasi kullanildi
//galiba bunun yerine const kullanilabiliyor

digit* carpDigit(digit*, int); //bir diziyi, bir basamakli bir integerla carpar
digit* carp(digit*, digit*); //bir onceki temel carpmayi kullanarak iki diziyi carpar

digit* bol(digit*, digit*); //asil isi yapan fonk

digit* birekle(digit*); //dizinin sayi degerini 1 artirir

digit* baskes(digit*); //parametre olarak verilen hane ve sol tarafi kesip yeni bir dizi verir
digit* sonkes(digit*); // "" "" "" hanenin bir sagindan baslayarak en saga kadar yeni bir dizi verir
digit* birlestir(digit*, digit*); //baslangiclari verilen iki diziyi birlestirir

int kacdefa(digit*,digit*); //1.diziden birkac kez 2.yi cikararak kalani onemsemeden bolumu bulur
int basamak(digit*); //dizinin kac basamakli oldugunu verir

int main()
{
FILE* input;
int i;

int kactane,k;
kactane=0;

digit* ornekler[8];
digit* cozumler[4];

for(k=0; k<8; k++)
{
ornekler[k] = (digit*) malloc( sizeof(digit) );
ornekler[k] -> data = -1;
ornekler[k] -> next = NULL;
ornekler[k] -> prev = NULL;
}


if((input=fopen("input.txt","r"))==NULL)
printf("Could not be open file\n");
else{

i = fgetc(input);

while(i != EOF)
{
while(i>47 && i<58)
{
ornekler[kactane] = sonaEkle(ornekler[kactane],i-48);
i=fgetc(input);
}

if(i==10)
{
kactane++;
i=fgetc(input);
}
else
{
i=fgetc(input);
}
}
}

fclose(input);


for(k=0; k<4; k++)
{
cozumler[k] = (digit*) malloc( sizeof(digit) );
cozumler[k] -> data = -1;
cozumler[k] -> next = NULL;
cozumler[k] -> prev = NULL;

printf("\n");
yaz(ornekler[2*k]);
printf(" / ");
yaz(ornekler[(2*k)+1]);
printf(" = ");

ornekler[2*k] = sonaEkle(ornekler[2*k],0); //bolumu virgülden sonra 2 hane ayrintili
ornekler[2*k] = sonaEkle(ornekler[2*k],0); //bulmak icin boluneni 100 ile carpiyoruz

cozumler[k]=bol(ornekler[2*k],ornekler[(2*k)+1]);
yaz2(cozumler[k]);
}


printf("\n----bitti----");
getch();
return 0;



/*
digit* ornek;
ornek = (digit*) malloc( sizeof(digit) );
ornek -> data = -1;
ornek -> next = NULL;
ornek -> prev = NULL;

num1 = sonaEkle(num1,2);
num1 = sonaEkle(num1,4);
num1 = sonaEkle(num1,0);
num1 = sonaEkle(num1,0);

num2 = sonaEkle(num2,1);
num2 = sonaEkle(num2,2);
num2 = sonaEkle(num2,0);


int i,n;
srand(time(NULL));

for(i=0; i<3; i++)
{
n = (int) (10.0*rand()/(RAND_MAX+1.0));//1 ve 9 dahil
num1=sonaEkle(num1,n);

n = (int) (10.0*rand()/(RAND_MAX+1.0));
num2=sonaEkle(num2,n);
}

for(i=0; i<1; i++)
{
n = (int) (10.0*rand()/(RAND_MAX+1.0));
num1=sonaEkle(num1,n);
}

digit* num4;
num4 = (digit*) malloc( sizeof(digit) );
num4 -> data = -1;
num4 -> next = NULL;
num4 -> prev = NULL;

digit* num5;
num5 = (digit*) malloc( sizeof(digit) );
num5 -> data = -1;
num5 -> next = NULL;
num5 -> prev = NULL;

num4 = sonaEkle(num4,2);
num4 = sonaEkle(num4,1);

num5 = sonaEkle(num5,2);
num5 = sonaEkle(num5,1);
*/

}

void yaz(digit* bas) //diziyi ondaliksiz normal yazar
{
digit* gezici = bas;
if(gezici == NULL)
{
printf("bos liste");
return;
}

while(gezici != NULL)
{
printf("%d",gezici->data);
gezici = gezici->next;
}
}

void yaz2(digit* bas) //diziyi ondaliklarina gore yazar
{
digit* gezici = bas;
if(gezici == NULL)
{
printf("bos liste");
return;
}

int i;
i=basamak(gezici);

if(i==1)
{
printf(".0%d",gezici->data);
}
else if(i==2)
{
printf(".%d%d",gezici->data,(gezici->next)->data);
}
else
{
while(gezici != NULL)
{
printf("%d",gezici->data);

if( (((gezici->next)->next)->next) == NULL)
{
printf(".");
printf("%d",(gezici->next)->data);
printf("%d",((gezici->next)->next)->data);
return;
}
gezici = gezici->next;
}
}
return;
}


digit* sonGetir(digit* bas)
{
digit* gezici;
gezici = bas;
digit* son;

while(gezici != NULL)
{
son = gezici;
gezici = gezici->next;
}

return son;
}

digit* basGetir(digit* son)
{
digit* gezici;
gezici = son;
digit* bas;

while(gezici != NULL)
{
bas = gezici;
gezici = gezici->prev;
}

return bas;
}


digit* sonaEkle(digit* bas, int ekle)
{
if(bas->data == -1)
{
bas->data=ekle;
return bas;
}
else
{
digit* yeni;
yeni = (digit*) malloc( sizeof(digit) );
yeni -> data = -1;
yeni -> next = NULL;
yeni -> prev = NULL;


digit* eskison = sonGetir(bas);
eskison->next = yeni;
yeni->prev = eskison;
yeni->data = ekle;

return bas;
}
}

digit* basaEkle(digit* bas, int ekle)
{
if(bas->data == -1)
{
bas->data=ekle;
return bas;
}
else
{
digit* yeni;
yeni = (digit*) malloc( sizeof(digit) );
yeni -> data = -1;
yeni -> next = NULL;
yeni -> prev = NULL;

bas->prev = yeni;
yeni->next = bas;
yeni->data = ekle;

return yeni;
}

}

digit* topla(digit* t1, digit* t2)
{
digit* g1=sonGetir(t1);
digit* g2=sonGetir(t2);

digit* yeni;
yeni = (digit*) malloc( sizeof(digit) );
yeni -> data = -1;
yeni -> next = NULL;
yeni -> prev = NULL;

int elde=0;
int aratoplam=0;

if(g1->data == -1) // bos dizi ile toplama yapmak icin
{
g1->data = 0;
}
if(g2->data == -1)
{
g2->data = 0;
}

while(g1 != NULL && g2 != NULL )
{
aratoplam = g1->data + g2->data + elde;

if(aratoplam > 9)
{
elde=1;
aratoplam = aratoplam - 10;
}
else
{
elde=0;
}

yeni = basaEkle(yeni,aratoplam);
g1 = g1->prev;
g2 = g2->prev;
}

if(g1 == NULL)
{
while(g2 != NULL)
{
aratoplam = g2->data + elde;


if(aratoplam > 9)
{
elde = 1;
aratoplam = aratoplam - 10;
}
else
{
elde = 0;
}

yeni = basaEkle(yeni,aratoplam);
g2=g2->prev;
}

}
else if(g2 == NULL)
{
while(g1 != NULL)
{
aratoplam = g1->data + elde;

if(aratoplam > 9)
{
elde = 1;
aratoplam = aratoplam - 10;
}
else
{
elde = 0;
}

yeni = basaEkle(yeni,aratoplam);
g1=g1->prev;
}
}


if(elde == 1)
{
yeni = basaEkle(yeni,1);
}

return yeni;
}



digit* cikar(digit* c1, digit* c2)
{
digit* c1clone; //islemde klonlar kullaniyoruz
digit* c2clone;

c1clone = kopyala(c1);
c2clone = kopyala(c2);

digit* g1 = sonGetir(c1clone);
digit* g2 = sonGetir(c2clone);


digit* yeni;
yeni = (digit*) malloc( sizeof(digit) );
yeni -> data = -1;
yeni -> next = NULL;
yeni -> prev = NULL;
int toplamkasa=0;
digit* eldeci;

while(g1 != NULL && g2 != NULL)
{
toplamkasa = g1->data - g2->data;

if(toplamkasa < 0)
{
eldeci = g1->prev;

while(eldeci != NULL && eldeci->data == 0)
{
eldeci=eldeci->prev;
}

if(eldeci == NULL)
{
//return -1 * cikar(g2-g1);
//printf("\nilk sayi kucuk olmamali-1");
return NULL;
}

eldeci->data--;

while(eldeci != g1)
{
eldeci = eldeci->next;
if(eldeci != g1)
{
eldeci->data = 9;
}
}

toplamkasa = toplamkasa + 10;
}

yeni = basaEkle(yeni,toplamkasa);
g1=g1->prev;
g2=g2->prev;

}


if(g2 == NULL && g1 != NULL)
{
while(g1 != NULL)
{
yeni = basaEkle(yeni,g1->data);
g1 = g1->prev;
}
}
else if(g1 == NULL && g2 != NULL)
{
//return -1 * cikar(g2-g1);
//printf("\nilk sayi kucuk olmamali-2");
return NULL;
}

return yeni;

}

digit* temizle(digit* bas)
{
digit* temizler;
temizler = bas;

while(temizler->data == 0 && temizler->next != NULL)
{
temizler = temizler->next;
temizler->prev = NULL;
}
return temizler;
}



int sifirmi(digit* d1)
{
digit* gezgin;
gezgin = d1;

while(gezgin != NULL)
{
if(gezgin->data != 0)
{
return -1;
}
gezgin = gezgin->next;
}

return 1;
}


int kiyas(digit* d1, digit* d2)
{
//printf("\nkiyaslananlar ");
//yaz(d1);
//printf("\t");
//yaz(d2);
digit* g1;
digit* g2;

digit* d1clone;
digit* d2clone;

d1clone = kopyala(d1);
d2clone = kopyala(d2);

g1 = d1clone;
g2 = d2clone;

int i1,i2;
i1=basamak(d1clone);
i2=basamak(d2clone);

int son;

if(i1==i2)
{
while(g1 != NULL)
{

if(g1->data > g2->data)
{
return 1;
}
else if(g1->data < g2->data)
{
return -1;
}
else
{
g1=g1->next;
g2=g2->next;
}
}
son = 0;

}
else
{
if(i1>i2)
{
son = 1;
}
else
{
son = -1;
}
}

return son;
}


digit* kopyala(digit* d1)
{
digit* yeni;
yeni = (digit*) malloc( sizeof(digit) );
yeni -> data = -1;
yeni -> next = NULL;
yeni -> prev = NULL;

digit* gezgin;
gezgin = d1;

while(gezgin != NULL)
{
yeni = sonaEkle(yeni,gezgin->data);
gezgin = gezgin->next;
}

return yeni;
}


digit* carpDigit(digit* d1, int i1)
{
digit* d1clone;

d1clone = kopyala(d1);

digit* g1 = sonGetir(d1clone);


digit* yeni;
yeni = (digit*) malloc( sizeof(digit) );
yeni -> data = -1;
yeni -> next = NULL;
yeni -> prev = NULL;

int elde,aracarpim;
elde = 0;
aracarpim = 0;

while(g1 != NULL)
{
aracarpim = (g1->data * i1) + elde;

if(aracarpim > 9)
{
elde = (aracarpim-aracarpim%10)/10;
aracarpim = aracarpim%10;
}
else
{
elde = 0;
}

yeni = basaEkle(yeni,aracarpim);
g1 = g1->prev;
}

if(elde != 0)
{
yeni = basaEkle(yeni,elde);
}

return yeni;
}

digit* carp(digit* d1, digit* d2)
{
digit* d1clone;
digit* d2clone;

d1clone = kopyala(d1);
d2clone = kopyala(d2);

digit* g1 = sonGetir(d1clone);
digit* g2 = sonGetir(d2clone);


digit* aradizi;
aradizi = (digit*) malloc( sizeof(digit) );
aradizi -> data = -1;
aradizi -> next = NULL;
aradizi -> prev = NULL;

digit* yeni;
yeni = (digit*) malloc( sizeof(digit) );
yeni -> data = -1;
yeni -> next = NULL;
yeni -> prev = NULL;


int i,carpan;
carpan = 0;

while(g2 != NULL)
{
while(g1 != NULL)
{
aradizi = carpDigit(g1,g2->data);
g1 = g1->prev;
}

for(i=0; i<carpan; i++)
{
aradizi = sonaEkle(aradizi,0);
}

yeni = topla( yeni,aradizi );

carpan++;
g2 = g2->prev;
g1 = sonGetir(d1clone);
}

return yeni;
}

digit* bol(digit* d1, digit* d2)
{
digit* d1clone;
digit* d2clone;

d1clone = kopyala(d1);
d2clone = kopyala(d2);

digit* g1 = d1clone;
digit* g2 = d2clone;

digit* yeni;
yeni = (digit*) malloc( sizeof(digit) );
yeni -> data = -1;
yeni -> next = NULL;
yeni -> prev = NULL;

digit* gleft;
gleft = (digit*) malloc( sizeof(digit) );
gleft -> data = -1;
gleft -> next = NULL;
gleft -> prev = NULL;

digit* gright;
gright = (digit*) malloc( sizeof(digit) );
gright -> data = -1;
gright -> next = NULL;
gright -> prev = NULL;


if( kiyas(g1,g2) == -1)
{
printf("\nbolunen buyuk olacak");
}
else if( kiyas(g1,g2) == 0)
{
return birekle(yeni);
}
else
{
int n,i,z;
n=0;

int bolenbas;
bolenbas = basamak(d2clone);
digit* yenibolunen;
digit* check;
digit* f1;
yenibolunen = d1clone;

while(kiyas(yenibolunen,d2clone) != -1 )
{
//printf("\n");
//printf("su an bolunen = ");
//yaz(yenibolunen);
z=0;
for(i=1; i<bolenbas; i++)
{
g1=g1->next;
}

while( kiyas(baskes(g1),d2clone) == -1 )
{
g1=g1->next;
}

gright = sonkes(g1);
gleft = baskes(g1);
//printf("\n");
//yaz(gleft);
//printf(" - ");
//yaz(gright);
//printf(" ");


n = kacdefa(gleft,d2clone);
yeni = sonaEkle(yeni,n);
//printf("\n");
//printf("%d tane ",n);
//yaz(d2clone);
//printf(" bulundu");

f1=g1;

check = cikar(gleft,carpDigit(d2clone,n));
check = temizle(check);
//printf("\nkontrol ediliyor\t");
//yaz(check);
if( kiyas(temizle(birlestir(check,gright)),d2clone) ==-1 )
{
int m;
for(m=0; m<basamak(gright); m++)
{
yeni = sonaEkle(yeni,0);
}
}
else{



while( kiyas(check,d2clone) == -1)
{
z++;

if(f1->next != NULL)
{
f1=f1->next;

check = sonaEkle(check,f1->data);
check = temizle(check);

if(z>1)
{
yeni = sonaEkle(yeni,0);
//printf("\n\t\t\t\tbolume 0 eklendi\t******************");
//yaz(yeni);
}
}
else
{
break;
}
}
}

yenibolunen = birlestir(cikar(gleft, carpDigit(d2clone,n)),gright);
g1=yenibolunen;
yenibolunen=temizle(yenibolunen);
//printf("\nalta gecen yeni bolunen ise = ");
//yaz(yenibolunen);

}


return(yeni);

}

return(NULL);
}

digit* birekle(digit* d1)
{
digit* yeni;
yeni = (digit*) malloc( sizeof(digit) );
yeni -> data = 1;
yeni -> next = NULL;
yeni -> prev = NULL;

return topla(d1,yeni);
}

int kacdefa(digit* a1, digit* a2)
{
digit* g1;
digit* g2;

digit* a1clone;
digit* a2clone;

a1clone = kopyala(a1);
a2clone = kopyala(a2);

g1 = a1clone;
g2 = a2clone;

int i;
i=0;

while(kiyas(g1,g2) != -1)
{
g1 = cikar(g1,g2);
if(g1!=NULL)
{
i++;
}
}

return i;
}

digit* baskes(digit* a)
{
digit* gezgin;
gezgin = a;

digit* yeni;
yeni = (digit*) malloc( sizeof(digit) );
yeni -> data = -1;
yeni -> next = NULL;
yeni -> prev = NULL;


while(gezgin != NULL)
{
yeni = basaEkle(yeni,gezgin->data);
gezgin = gezgin->prev;
}

return yeni;
}

digit* sonkes(digit* a)
{
digit* gezgin;

if(a->next == NULL)
{
return NULL;
}
gezgin = a->next;

digit* yeni;
yeni = (digit*) malloc( sizeof(digit) );
yeni -> data = -1;
yeni -> next = NULL;
yeni -> prev = NULL;


while(gezgin != NULL)
{
yeni = sonaEkle(yeni,gezgin->data);
gezgin = gezgin->next;
}

return yeni;
}

digit* birlestir(digit* b1, digit* b2)
{
digit* g1;
digit* g2;
g1=b1;
g2=b2;

digit* yeni;
yeni = (digit*) malloc( sizeof(digit) );
yeni -> data = -1;
yeni -> next = NULL;
yeni -> prev = NULL;

while(g1 != NULL)
{
yeni = sonaEkle(yeni,g1->data);
g1 = g1->next;
}

while(g2 != NULL)
{
yeni = sonaEkle(yeni,g2->data);
g2 = g2->next;
}

return yeni;
}

int basamak(digit* d)
{
int i;
i=0;
digit* g;
g=d;

while(g != NULL)
{
i++;
g=g->next;
}

return i;
}

[fhalim]

bir de hayatımde debugger kullanmadım. biraz zor oluyor ama adım adım manuel kontrol edince hatalar azalıyor gibi