İST 205 Bilgisayar Programlama III C Programlamaya Giriş

1
C
İST 205 Bilgisayar Programlama III
C Programlamaya Giriş
Matematiksel ve İstatistiksel Uygulamalar
Y.Doç.Dr. Levent Özbek
Ankara Üniversitesi Fen Fakültesi
İstatistik Bölümü
[email protected]
Leventmodelleme.com
http://80.251.40.59/science.ankara.edu.tr/ozbek/
1. Bölüm
DERLEYİCİLER VE C DİLİNİN ÖZELLİKLERİ
Üst düzey dillerden biri ile yazılmış olan bir programı, makine diline çeviren programa
derleyici denir. C++ da böyle bir derleyicidir.
C dilini diğerlerinden ayıran özellikleri şöyle sıralayabiliriz.
a) C dili orta sınıf bir dildir.
b) C dili yapısal bir dildir.
c) C dili gerçek programcıların kabul ettiği bir dildir.
d) C dili değişik bilgisayarlara kolayca adapte olan bir dildir.
C, genel amaçlı bir dil olarak hazırlanmıştır. PC’nin, BASIC veya PASCAL gibi diller
kullanılarak ulaşılamayan bazı bölümlerin kullanılmasını sağladığı için, uygulama
programcılarının birçoğu C’yi yeğlerler. C, bilgisayarın herhangi bir yerine kolayca
ulaşmamızı sağlar.
2
C kullanırken yapabileceğimiz en önemli hatayı, yalnızca bilgisayarı kapatıp açarak
düzeltebiliriz. C, PC’nin ortaya çıkması ile başlamadı. C’nin kökeni çok daha eskiye gider.
C, 70’li yılların başında, AT&T tarafından, mini bilgisayarlarda kullanılmak üzere
tasarlanmıştır. Bu dilin beğenilmesi sonucunda, C kısa zamanda yayıldı. Sonunda C,
UNIX adı verilen bir işletim sisteminin oluşturulmasında kullanıldı. 1978’de American
National Standarts Institude (ANSI) tarafından standart hale getirilen C dili orta sınıf bir
dildir.
C’YE GENEL BİR BAKIŞ
Yapısal programlama, program karmaşıklığını azaltmak ve programları daha kolay
anlaşılabilir, okunabilir, geliştirilebilir, değiştirilebilir biçime getirmeyi amaçlayan genel
bir programlama yöntemidir.
Metin kütüğünü yazmak için, bir metin editörü veya bir kelime işlemci kullanılmalıdır.
Derleyicilerin pek azının kendi editörleri vardır.
C ÇEVRESİ
C çevresi, editör ve derleyiciyi tek bir programda birleştirdiği için, programın yazılmasını
ve edit edilmesini kolaylaştırır.
Bir programı oluşturmak için, C editörüne girin ve program metnini yazın. Programın
tümünü yazdıktan sonra, C derleyicisini doğrudan editörden çalıştırabilirsiniz. Programı
derlenmeden önce diske/diskete kaydetmeniz gerekli değildir. Tek bir tuşa basarak
programı derleyebilirsiniz.
Üzerinde çalıştığınız kütük, bellekte tutulduğu için, birleşik çevre derleme işini bütün
derleyicilerden daha hızlı yapar. Ayrı bir editör ve derleyici yerine tek bir program
kullanmanın hızlı olmanın yanında başka avantajları da vardır.
Birleşik C çevresinde, editör derleyicinin bulduğu hataları her zaman bilir. C editörü,
derleyicinin bulduğu her hatanın yerini size gösterir.
Birleşik C çevresi kullanıldığında oluşan yapı;
·
programın yazılması
·
programın işletilmesi
·
programın değiştirilmesi
·
programın işletilmesi
MENÜ SİSTEMİ:
C değişik bir menü sistemi kullanır. Menüler programlama sırasında sık sık kullanılırlar.
Bir menü her zaman, ne yapabileceğinizi çok açık biçimde gösterir.
C PROGRAM YAPISI
3
TÜMCELER : Bütün C programları, bir dizi tümceden oluşurlar. Genellikle bir tümce tek
bir eylem olarak düşünülebilir. Tümceler bir dizi sözcükten (komuttan) oluţurlar. Her
tümce C’de ";" karakteri ile bitirilir.
ÖRNEK
int i;
a=a+1;
while(z<23) a=a+54;
Her satıra tek bir tümce yazılırsa, tümceleri birbirinden ayırmak daha kolay olur. Bu
derleyici için bir zorunluluk değildir.
Tümceler genellikle iki gruptan birine girerler.
·
iţletilebilen
·
bildirim
İşletilebilen tümceler, işlem yapabilen komutlar içerirler. Bu tür tümcelerin bir blok içine
( { } parantezleri içine) yerleştirilmeleri gerekir.
Bildirim tümceleri, programın işletmek zorunda olduğu yapıları belirlerler. Aşağıdaki
özel bildirim tümcesi, bütün C programlarında bulunmalıdır.
Main( )
Bu tümce, programın nerede çalışmaya başlayacığını gösterir.
BLOKLAR
Tümceler, blok adı verilen birimlerde bir araya toplanırlar. Bir blok, herhangi bir tümce
veya blok grubundan oluşabilir. Blokun başlangıcını ve bitişini göstermek için oklu
parantezler ( { } ) kullanılır. Blokları birbirinden ayırmak, programı anlamak açısından
oldukça önemlidir.
ÖRNEK
z=z*x /* blok 1 */
{ /* blok 2 */
printf("%d", z);
for (i=5;i<z;i++);
printf("%d",z);
}
{ /* blok 3 */
i=i-1;
d=z*x-i;
printf("%d", d);
}
{ /* blok 4 */
{ /* blok 4-a */
4
{ /* blok 4-b */
i=78;
i=i*z;
printf("%d", i);
}
printf("%d", z);
}
}
DERLEME KOMUTLARI
Bir C programı, tümcelere ek olarak, derleyici için komutlar da içerebilir. Derleyici
komutları adı verilen bu komutlar, gerçek programın bir parçası değildir. Programda
bulunan diğer tümcelerin çevirisini yönetirler.
Bu komutlar her zaman numara sembolü (#) ile başlarlar. Programın herhangi bir
yerinde, tek bir satırda, yalnız başlarına olmalıdırlar.
AÇIKLAMALAR
Açıklamalar herhangi bir yerde olabilir, /* karakterleri ile başlamalı ve */ karakterleri ile
bitmelidir.
ÖRNEK
# include <stdio.h> /* standart girdi/çıktıyı dahil et*/
main ( )
{
printf ("Merhaba, Dünya\n");
printf ("Bu benim ilk C programım\n");
}
Programın ilk satırı # işareti ile başladığı için bu satırın bir derleyici komutu olduğu
anlaşılır. include komutu, derleyiciye stdio.h kütüğünü bulmasını ve derlemekte olduğu
programa eklemesini söyler. Stdio.h özel bir kütüktür. Giriş ve çıkış için komutlar içerir.
Main ( ) özel bildirimi, kendisini izleyen blokun, program işletiminin başladığı yer
olduğunu bildirir.
Printf ( ) işletilebilir bir komuttur. Parantezler arasına yazılan herhangi bir metni ekranda
yazdırır. Metin üstten (" ") işaretleri arasına yazılmalıdır.
\n karakterleri printf ( ) tarafından özel olarak yorumlanır. Alttaki satırın başına
geçilmesini sağlar. <ENTER> tuşu gibi.
DEĞİŞKENLER
5
Bir C değişkeni, bir kutuya benzer. Kutular nesnelerin saklanması için kullanılırlar,
değişik şekillerdeki nesneler, değişik şekillerdeki kutularda saklanırlar ve her bir kutuya
tek bir nesne konulabilir. Değişkenlerin farklı tipleri vardır. Değişkenin tipi, içinde nasıl
bir nesne saklanabileceğini belirler. En basit değişken tipi int değişkenlerdir. (Tamsayı
anlamındaki integer için kullanılan bir kısaltmadır.) Bir int değişkeninde -32768 ile 32767
arasındaki herhangi bir sayı saklanabilir fakat kesir kullanılamaz.
78 456 9 -38 -89 0 geçerli
9.8
5/8 6.666666 geçersiz
DEĞİŞKENLERİN BİLDİRİLMESİ
Bir değişkenin bildirimini yapmak için, değişkenin tipi ardından da değişkenin adı yazılır.
Değişken isimleri, bir harfle başlamalı ve yalnızca harfler, sayılar ve alt çizgileri ( _ )
içermeleri gerekir. 32 karakterden fazla olmamalıdır.
ÖRNEK
m i sayı dur son_nokta toplam : geçerli
998 7son bu.sonuc adı? gir+bir : geçersiz
DEĞİŞKENE DEĞER VERİLMESİ
C’de bir değişkene bilgi yerleştirmek için eşit(=) işareti kullanılır.
a=10; b=100;
c=0;
gibi
ÖRNEK
# include <stdio.h>
main( )
{
int a;
a=10;
printf("a’nın değeri %d\n", a);
}
6
2.Bölüm
DEĞİŞKEN TİPLERİ
Char : Char tipi, özellikle karakterlerin saklanması içindir.
‘a’ ‘1’ ‘=’ ‘&’ ‘\’ ‘B’ ... geçerli karakterlerdir.
Her bir karakter iki üstten virgül arasındadır.
ÖRNEK
# include <stdio.h>
main( )
{
char a;
a=’z’;
printf("a’nın değeri %c\n", a);
}
NOT: Bir char değişkeni, bir int değişkeninden daha küçüktür, bu nedenle, bir int
değişkeni gibi sayılar alabilmesine karşın, bu sayılar daha küçük olmalıdır. Char tipi bir
değişkene, yalnızca 0 ile 255 arasındaki sayılar saklanabilir.
ÖRNEK
# include <stdio.h>
main( )
{
char a;
a= 8;
printf("a’nın değeri %c\n", a);
}
NOT : Bir char değişkenine 255’den büyük bir sayı sığdırmaya çalışılırsa sonuç 0 olur.
Herhangi bir hata oluşmaz, bu C’nin bir esnekliğidir.
FLOAT : Float tipi bir değişken, ondalıklı bir sayı içerir.
8.7
0.898 4.23E9 6.666 ... gibi
Yukarıdaki değerlerden hiç birisi, bir int değişkeninde saklanamaz. Bir int değişkenini
3.88 ile eşitlerseniz sonuç 3 olur.
7 98 330030 gibi tam sayı değişkenleri float değişkenine eşitlenirse 7 7.0, 98 98.0 olarak
değiştirilir.
ÖRNEK
7
# include <stdio.h>
main( )
{
float a;
a= 8.909;
printf("a’nın değeri %f\n", a);
}
float değişkenleri 3.4E-38 ile 3.4E+38 arasındaki herhangi bir değere eşitlenebilirler.
LONG : (uzun tamsayı), yalnızca çok uzun tamsayılar gerektiği zaman kullanılırlar.
-2,147,843 ile 2,147,843 arasında değer alabilir. Tamsayılar ile yapılan işlemler tam
kesinlikte olacaktır. Toplama ve çarpma gibi işlemler. Float tipi, gezer nokta derişkenleri
için durum böyle değildir. Böyle değişkenler için yalnızca belirli bir sayıda kesinlik rakamı
vardır.
DOUBLE : Float tipi değişkenlerde kesinlik önemli ise bu tür tanımlama yapılır.
TİP ALT ÜST YAKLAŞIK KESİNLİK
Float 3.4E-38 3.4E+38 7 rakam
Double 1.7E-308 1.7E+308 14 rakam
Teorik olarak, sonsuz sayıda gezer_nokta sayısı vardır.
.5 4.55 4.555 4.5555 4.55555 4.555555555 4.555555555555555
Yukarıdaki örnekte son iki sayı float tipi değişkene eşitlenirse, 4.555555556 olarak
yuvarlnır.
Double kullanarak daha iyi bir sonuç elde edilebilir. Sonuç 4.555555555555556 olarak
değişir. Kesinlik önemli ise double kullanılmalıdır.
MAKROLAR : Bir C makrosu, belli bir değeri bir isimle değiştirmek için kullanışlı bir
yöntem sağlar. Sık kullanılan değerlere bir isim vermenin kolay bir yöntemidir. Bir C
tümcesi değildir, derleyici komutuna benzer. Sintaksı (kullanım şekli) şöyledir.
# define isim değer
Bu derleyiciye, ne zaman isim görülürse onun yerine belli bir değer koymasını söyler.
ÖRNEK
# include <stdio.h>
# define PI 3.1415 /* PI için değer belirlenmesi */
main( )
float b=PI;
float a;
a=PI;
8
printf("a’nın değeri %f\n", a);
printf("a’nın değeri %f\né, PI);
}
9
3. Bölüm
MATEMATİKSEL İŞLEMLER
C dili hemen hemen her matematiksel uygulamada kullanılabilir.
+ toplama
- çıkarma
* çarpma
/ bölme
aritmetik işlemler için kullanılırlar.
MODÜLÜS : İki sayının modülüsü, bir sayının diğerine bölünmesinden oluşan kalandır.
Modülüs işlemi için % işareti kullanılır. 5%2 örneğinde 5 sayısı 2’ye tam olarak iki defa
bölünür ve 1 artar. Bu nedenle 5 ve 2’nin modülüsü 1 dir.
ÖRNEK
# include <stdio.h>
main( )
{
int a;
a=6%3;
printf("a’nın değeri %d\n", a);
}
örneğinde a=0’dır. 6’da 3 iki defa vardır, kalan sıfırdır.
# include <stdio.h>
main( )
{
int a;
a=2%6;
printf("a’nın değeri %d\n", a);
}
örneğinde sonuç 2’dir. 2 sayısında 6 hiç olmadığı için kalan 2’dir
ÖNCELİK :
C’de işlemlerin, öncelik adı verilen bir özellikleri vardır. Önceliği yüksek olan işlemler
önce yapılırlar. Beş temel işlem öncelik sırası aşağıda verilmiştir.
İŞLEM ÖNCELİK
* / % ilk
+ - son
10
NOT : Aynı öncelikte iki işlem arasında seçim yapmak gerektiğinde, işlem soldan sağa
doğru çözülür.
ÖRNEK :
# include <stdio.h>
main( )
{
float a;
a=5+6*7/2;
printf("a’nın değeri %f\n", a);
}
Bu program nasıl bir değer verir? Bu eşitlikte, hem çarpmanın hem de bölmenin
toplamaya göre öncelikleri vardır. İlk olarak bu iki işlemden biri yapılmalıdır. Çarpma
daha solda olduğu için ilk önce yapılır.
Bu iţlem 6*7=42 sonucunu verir.
a=5+42/2; Daha sonra bölme işlemi yapılır.
a=5+21; ve toplama işlemi yapılır.
a’nın değeri 26.000000
Öncelik kurallarını karıştırmamak için parantezler kullanılır. parantez içindeki işlemler
önce yapılır.
a=((5+6)*7)/2; gibi
EŞİTLİKLERDE DEĞİŞKEN KULLANIMI
Tipi yazdıktan sonra, değişken isimleri araya virgüller koyarak aynı tipte birden fazla
değişken tanımlanabilir.
Tip isim1, isim2, isim3;
int a,b,c;
ÖRNEK
# include <stdio.h>
main( )
{
int x,y,a;
x=4;y=2;
a=x*x+y*y; printf("a’nın değeri %d\n", a);
}
NOT : Bir değişkenin içeriğini kullanmadan önce, değişkenin bir değere eşitlenmiş
olmasına dikkat edilmelidir. Program derlenirken warning(uyarı mesajı) verebilir. Bu
nedenle C, değişkenlerin tanımı yapılırken değişkenlere değer atanmasına olanak sağlar.
11
Bu tümce ţöyledir.
Tip isim1=değer;
veya
tip isim1=değer1, isim2=değer2;
ÖRNEK
# include <stdio.h>
main( )
{
int a,x=0,y=0;
y=2;
a=x*x+y*y;
printf("a’nın değeri %f\n",a);
}
12
4. Bölüm
FONKSİYON ÇAĞRILARI KÜTÜPHANELER
Bir standart fonksiyon kullanabilmek için, C’ye bu fonksiyonun tanımının nerede
bulunabileceğini belirtmek gerekir. Bu # include derleyici komutu ile yapılır.
Bu tür standart fonksiyon kütükleri bir dizi bildirim tümcesi içerir. Bu komut digesi,
başlatım kütüklerinde toplanır. Bu kütükler kütük adı eki olarak .h alırlar. Biz şimdiye
kadar yalnızca stdio.h başlatım kütüğünü kullandık.
Stdio.h kütüğü C’nin bütün standart giriş/çıkış fonksiyonlarını kullanmasına olanak
sağlar.
En önemlilerinden bazıları şunlardır.
Stdio.h : C’nin en önemli kütüphanesi. Programın bütün üstdüzey giriş ve çıkışlarını
yapar.
Math.h : Bütün matematiksel uygulamalarda kullanılır. tanjant, sinüs, cosinüs... gibi
fonksiyonların kullanılmasına olanak sağlar.
Ctype.h : Bir değişkenin tipini kontrol eden bir dizi kısa yordam. Örneğin bir karakter
değişkeninin nokta içerip içermediğine bakabilirsiniz.
Stdlib.h : Rasgele sayı üreten, sıralama yapan, Dos’a çıkan veya başka gerekli işleri
yapan karışık bir yordam grubu.
C FONKSİYONLARI
Fonksiyon, belli bir işi yapmak üzere tasarlanmış program parçasıdır. Parametre (değer)
kullanabilirler ve kullanmayabilirler. Fonksiyon bittiği zaman bir değer verbilir veya
vermeyebilir. Printf(), en azından bir parametre kullanan bir C fonksiyonudur. Bu
karakterleri ekrana yazdırır ve bir değer vermeden ana programa geri döner.
ÖRNEK
# include <stdio.h>
# include <ctype.h>
main( )
{
char a,b;
b=’F’;
a=tolower(b);
printf("a’nın değeri %c", a);
}
13
tolower( ) fonksiyonu C’nin ctype.h kütüphanesindedir. Bu fonksiyon büyük harfi küçük
harfe çevirir.
Printf( ) fonksiyonu genel amaçlı bir format çevirim fonksyonudur. İki parametresi
vardır. İlki bir karakter dizgisidir. % işareti ikinci parametrenin nereye konulacağını ve
hangi biçimde yazılacağını gösterir.
FORMAT BELİRLEMESİ
char %c
int %d
float %f
ASCII DEĞER: Bilgisayarda, her bir karakter belli bir sayıya eşitlenir. Bu sayıya ASCII
değeri adı verilir. Örneğin A harfi 65 olarak saklanır.
ÖRNEK
# include <stdio.h>
main( )
{
char=65;
printf("a=%c veya %d\n", a, a);
}
program sonucu a=’A’ veya a=65 olur.
SCANF( ) FONKSİYONU
Klavyeden değer okumak için kullanılır. scanf( ) ile kullanılan parametreler, printf( ) ile
kullanılanlarla aynı kurala uyarlar.scanf( )’in format dizgileri genellikle format
belirlemelerinden oluşur.
scanf("%d", &cevap);
Bu tümce bir tamsayı okur ve cevap adlı bir değişkeni bu tamsayıya eşitler.
Scanf( ) bir format dizgisi ve & işareti ile başlayan değişken isimleri listesi gerektirir,
tüm değişken isimlerinin & ile başlaması gerekir. Scanf( ) <ENTER> tuşuna basılana
kadar hiç bir şey okumaz. <ENTER> tuşuna basar basmaz, scanf( ) basılan tuşları
okumaya baţlar.
ÖRNEK
# include <stdio.h>
main( )
{
int sayı;
scanf("%d", &sayı);
printf("sayınıa=%d\n", sayı);
}
14
ÖRNEK
# include <stdio.h>
main( )
{
char kar1,kar2,kar3,kar4;
scanf("%c%c%c%c", &kar1, &kar2, &kar3, &kar4);
printf("%c%c%c%c", kar1, kar2, kar3, kar4);
}
ÖRNEK
# include <stdio.h>
main( )
{
float a,b,c,d;
scanf("%f%f", &a, &b);
scanf("%f%f", &c, &d);
printf("%f%f%f%f", d, c, b, a);
}
NOT: Format belirlemesinin türünün, değişkeninki ile aynı olması gerekir. Sayısal
değerler girilirken değerleri birbirinden boşluk, tab veya return tuşu ile birbirinden
ayırmak gerekir. Char tipi değişkenlerde ise bu işlem yapılmaz.
15
5. Bölüm
KONTROL TÜMCELERİ
Kontrol tümceleri programın akışını kontrol ederler.
KONTROL YAPISI SINIFLARI
Kontrol yapıları üç ayrı grupta toplanabilir.
· if (eğer) tümceleri; farklı koşullar altında farklı tümcelerin işletilmesini sağlarlar.
· döngüler; bir dizi tümcenin bir kaç defa tekrarlanabilmesine olanak sağlarlar
· fonksiyonlar; bir dizi tümcenin programın değişik noktalarında kullanılmasını
sağlarlar. Her kontrol yapısı kontrol ettiği bir tümceyi veya tümce bloğunu içerir.
{
a=a+3;
z=a+b;
}
veya
{a=a+3;z=a+b}
tümceleri birer bloktur.
IF TÜMCELERİ
Bir if (eğer) tümcesi bir eşitliği kontrol eder ve eşitlik doğru ise, kontrol ettiği tümce
işletilir. Eşitlik yanlış ise tümce göz ardı edilir.
İlk biçimi; if (eşitlik)
tümce;
C’de eşitlik için = = (çift eşit) işaretleri kullanılır.
a= =0;a==b;a= =1...
gibi
ÖRNEK
# include <stdio.h>
main( )
{
int a;
printf("a’nın değerini girin:");
16
scanf("%d", &a);
if (a= =1)
printf("a birdir\n");
}
ÖRNEK
# include <stdio.h>
main( )
{
int a;
printf("a’nın değeri :");
scanf("%d", &a);
if (a= =1)
{
a=a+100;
printf("a’nın değeri = %d\n", a);
}
}
NOT: Bir if cümlesi içerisinde eşitleme işlemi yapılabilir. Fonksiyonlar genellikle, işlemi
yapabildikleri zaman doğru yapamadıkları zaman yanlış değerini alırlar.
ÖRNEĞİN atoi( ) fonksiyonu dizgileri sayıya çevirir.
atoi("451") dizgiyi yani "451"’i sayıya çevirebilir ve sonuç olarak doğru verir.
atoi("Ali") dizgiyi "Ali"’yi sayıya çeviremez ve yanlış verir.
ÖRNEK
# include <stdio.h>
main( )
{
int sayı;
if (sayı=atoi("592")) /* "==" değil */
printf("Dizgi bu sayıdır: %d\n", sayı);
}
İLİŞKİ İŞARETLERİ
a<b küçüktür
a>b büyüktür
a<=b küçük veya eţit
a>= büyük veya eţit
a!=b eşit değil
Bütün bu işlemlerde a veya b yerine herhangi bir değer, değişken veya eşitlik konulabilir.
17
a>=780
76<=9
x+23!=y-z
8-3==887-deger
IF-ELSE DEYİMİ : Genel yapısıaşağıdaki şekildedir.
İf (eşitlik)
tümce1;
else
tümce2;
eşitlik doğru ise tümce1 işletilir yanlış ise tümce2 işletilir.
ÖRNEK
# include <stdio.h>
main( )
{
int a, b;
printf("a=\n");
scanf("%d", &a);
printf("b= \n");
scanf("%d", &b);
if (a+b>=5)
printf("4’ten daha fazlalar\");
else
printf("4’den daha azlar\n"); }
KARMAŞIK EŞİTLİKLER
İki veya daha fazla eşitliği karşılaştırarak karmaşık eşitlikler oluşturulabilir. Bunun için
and (ve), or (veya) kullanılır C’de; and için &&, or için || işaretleri kullanılır.
if (a==0 && b==0) Bu örnekte hem a=0, hem de b=0 ise doğru değeri verilir.
if (a==0 || b==0) tümcesinde a veya b sıfır ise doğru değeri verilir.
ÖRNEK
# include <stdio.h>
main( )
{
int a, b;
printf("a=\n");
18
scanf("%d", &a);
printf("b= \n");
scanf("%d", &b);
if (a==5 && b==5)
printf("ikisi de uyuyor\n");
}
Aritmetiksel işlemler gibi ilişkisel ve mantıksal işlemler de sonuç olarak bir değer verirler.
İf tümcesindeki parantezin içinde yalnızca bir değer olması yeterlidir.
İf (değer)
tümce;
Değer doğru ise tümce işletilir. C’de 0 olmayan bütün sayılar doğrudur. Sıfır yanlışı
gösterir. İlişkisel ve mantıksal işlemlerde doğru genellikle -1, yanlış 0 değerini verirler.
ÖNCELİK SIRASINA GÖRE İŞLEMLER
Sembol Anlamı Öceliği
*
çarpma
1
/
bölme
%
modülüs
1
+
toplama
2
-
çıkarma
2
<
küçüktür
3
>
büyüktür
3
<=
küçükeţit
3
>=
büyükeţit
3
==
eţit
3
!=
eşitdeğil
&&
mantıksal ve
||
mantıksal veya
=
eţitlik
1
3
4
4
5
ÖRNEK
# include <stdio.h>
main( )
{
int a=5, b=4, c=1;
if (a+b<=c*45)
printf("Bu doğrudur\n");
}
19
6. Bölüm
DÖNGÜLER (LOOPS)
Döngü adı verilen kontrol yapısı bir tümce blokunu bir kaç kez işletir. Döngü sayısının
nasıl belirleneceği, döngünün tipine bağlıdır. C’de üç tip döngü vardır.
· while döngüsü
· for döngüsü
· do döngüsü
WHILE DÖNGÜSÜ
Bu döngü bir koşul doğru olduğu sürece tümce blokunu tekrarlar. Koşul geçerli olmadığı
anda program döngüyü izleyen komutlara geçer. Koşul tümcesinin kullanımı ile aynıdır.
Genel şekli;
while (koţul)
blok1;
ÖRNEK
# include <stdio.h>
main( )
{
int a;
a=10;
while (a>0)
{
a=a-1;
printf("a’nın değeri= %d\n", a);
}
printf("döngü bitti\n");
}
SONSUZ DÖNGÜ
ÖRNEK
# include <stdio.h>
main( )
{
int a;
a=10;
while (a>0)
{
printf("a’nın değeri= %d\n", a);
}
20
printf("döngü bitti\n");
}
a değişkeni hiç değişmediği için koşul hiç değişmez ve döngü tekrarlanıp durur.
ARTIMLAR VE EKSİLİMLER
Döngü kullanımında kontrol değişkenine 1 eklenir (ileri sayma) veya 1 çıkartılır. (geri
sayma)
Aritmetik olarak a=a+1 veya a=a-1 biçiminde yapılır. Ancak C bu işlemler için daha kısa
yollar sunar. İşlem işaretlerinden ++ ve - artım ve eksilim işaretleri olarak tanınırlar.
++ değişken 1 ekler, -- değişkenden 1 çıkarır. Yukarıdaki örnek şu şekilde yapılabilir di.
# include <stdio.h>
main( )
{
int a=10;
while (a>0)
{
a--;
printf("a’nın değeri= %d\n", a);
printf("döngü bitti\n");
}
}
Bu işlemlerin avantajı, bir eşitliğin içinde kullanılabilmeleridir. Her bir işlem iki biçimde
kullanılabilir.
--a
a-++a
a++
Sembol değişkenden önce gelirse artım veya eksilim işlemin bulunduğu tümceden önce
yapılır. Sembol değişkenden sonra gelirse işlem tümceden sonra yapılır.
a=a-1;
printf("a’nın değeri= %d\n", a);
Bu aşağıdaki tek satıra dönüştürülebilir.
printf("a’nın değeri= %d\n", --a);
Aşağıdaki tümceyi ele alalım;
printf("a’nın değeri= %d\n", a--);
Bu aşağıdaki iki tümce ile aynı işi yapar;
printf("a’nın değeri= %d\n", a);
a=a-1;
21
NOT: Bu işlemler bulundukları eşitliğin bir parçası olmadıklarından diğer işlemlerden
biraz farklı çalışırlar. Diğer tüm işlemlerden daha büyük bir önceliğe sahiptirler.
ÖRNEK
a=c++*12+saatlerin_toplamı;
Önceliği en yüksek işlem ++ olduğu için eşitlik şu duruma gelir.
a=c*12+saatlerin_toplamı;
c=c+1;
Burada c++ olduğu için a üzerinde bir etkisi yoktur.
A=++c*12+saatlerin_toplamı;
Burada ++c olduğundan ++ işleminin a üzerinde bir etkisi vardır.
c=a+++b; eşitliğinde belirsizlik vardır. C, artımı a değişkenine bağlar fakat istenmeyen
durumlardan kaçınmak için
c=a+++b; eşitliği ya c=a++ +b; veya c=(a++) +b; şeklinde yazılır.
FOR DÖNGÜSÜ
For döngüsü program kontrolünü biraz daha basitleştirir. While döngüsü kadar esnek
olmamasına rağmen anlaşılması ve kullanımı daha kolaydır. Genel bir kural olarak, bütün
döngülerin üç ayrı parçası olmalıdır.
·ilk durum belirlenmelidir. (a=10;)
·durumu değiştirilmelidir. (a--;)
·döngünün sürüp sürmeyeceğinin belirlenmesi için durumu belirlemenin bir
yolu olmalıdır. (a>0)
for döngüsünün kullanımı şöyledir.
for (ilk durum; koşul ; değiştirici tümceler)
blok;
ÖRNEK
# include <stdio.h>
main( )
{
22
int a;
for (a=10; a>0; a--)
printf("a’nın değeri %d\n", a);
printf("döngü bitti");
}
for(a=10; a<0;)
printf("a’nın değeri\n");
sonsuz döngü; tümcenin yanlış olduğu hemen görülebilir.
ÖRNEK
# include <stdio.h>
main( )
{
int a;
printf("ilk değeri girin="); /*Başlangıç koşulunun girilmesi*/
scanf("%d", &a);
for(;a>0;a--)
printf("a’nın değeri %d\n", a);
printf("döngü bitti\n");
}
ÖRNEK
# include <stdio.h>
main( )
{
char ch=0;
while (ch!=’q’)
{
printf("döngü başlangıcı\n"); /* Bir miktar tümce */
printf("bitirmek için q’ya devam etmek için herhangi bir tuşa basın;");
ch=getch( );
printf("\n");
}
}
Bu program q harfi yazılana kadar açıklama satırı ile aynı blokta bulunan tümceleri
tekrarlar. Yazılan tuşu okumak için getch( ) fonksiyonu kullanılır. getch( ) <ENTER>
tuşuna basılmasını beklemez.
For döngüsü genellikle tekbir değişkenin değiştiği durumlarda kullanılır.
23
ÖRNEK
# include <stdio.h>
main( )
{
int a,b;
a=0;
b=100;
while (a!=b)
{
printf("ilk değer: \n"); scanf("%d", &a);
printf("2.değer: \n"); scanf("%d", &b);
}
printf("Bu sayılar eşittir\n");
}
Yukarıda verilen örneğin for döngüsü kullanılarak yapılması, bunun yazılması ve de
anlaşılması daha zordur. While ile yapılan program tercih edilir. Döngünün bitiş
noktasının program yazılırken bilindiği uygulamalarda for döngüsü kullanılır.
ÖRNEK
# include <stdio.h>
main( )
{
int a,b;
for (a=0, b=100;a!=b)
{
printf("ilk= %d\n"); scanf("%d", &a);
printf("ikinci= %d\n"); scanf("%d", &b);
}
printf("Bu sayılar eşittir\n");
}
ÖRNEK
for(i=0;i<10;i++)
Bu döngü tam olarak 10 defa işletilir ve yalnızca döngü tümcesine bakılarak bu durum
anlaşılabilir. While döngüleri genellikle koşul değişkenlerinin bir kaç değişik şekilde
değiştirilebildiği durumlarda kullanılır.
while(i<10 && ch!=’q’)
Bu döngünün kaç defa işletileceği ancak döngü içindeki tümcelere bakılarak anlaşılır.
24
DO DÖNGÜSÜ
Do döngüsü for ve while döngüsünde kontrol edilen bitiş koşullarını döngü tümceleri
işletildikten sonra kontrol eder. Bunun en önemli etkisi bir do döngüsündeki tümcelerin
en az bir kez işletilmesidir. Genel kullanımı şöyledir;
do
blok;
while (koţul);
While döngüsünde olduğu gibi blok içindeki tümceler koşul doğru olduğu sürece
iţletilirler. Koţul kontrol edilmeden önce blok içindeki tümceler bir defa iţletilir.
ÖRNEK
# include <stdio.h>
main( )
{
int ch;
do
{
printf("Bitirmek için q’ya basın:\n");
ch=getch( );
}
while(ch!=’q’);
printf("döngü bitti\n");
}
ÖRNEK
# include <stdio.h>
main( )
{
do
{
printf("bitirmek için q’ya basınız\n");
}
while(getch( )!=’q’);
printf("döngü bitti\n");
}
25
7. Bölüm
FONKSİYONLAR
Programın farklı yerlerinde benzer işlemler yapılması gerekiyorsa gerekli komutlar
tekrarlanmalıdır. Fonksiyonlar bu konuda yardımcı olurlar. Fonksiyonlar programınızı
ayrı ve kolay anlaşılabilir parçalara bölmenize olanak sağlarlar.
FONKSİYON BİLDİRİMLERİ
Bütün fonksiyonlar iki parçadan oluţurlar;
·
bildirim
·
gövde
Basit bir fonksiyon bildirimi olan main( )’i gördük. Bunu izleyen blok, main( )
fonksiyonunun gövdesidir.
Fonksiyonların genel sintaksı aşağıdaki gibidir.
tip fonksiyon_ismi (parametre1, parametre2, ..., parametreN)
parametre bildirimleri;
blok;
Tip fonsiyonun verceği değerin tipini gösterir.
ÖRNEK
# include <stdio.h>
merhaba_de( )
{
printf("Merhaba\n");
printf("Bu bir fonksiyon ile yazıldı\n");
}
main( )
{
printf("Bir defa çağır\n");
merhaba_de( );
printf("Bir kaç defa çağır\n");
merhaba_de( );
merhaba_de( );
}
26
Fonksiyon bildirimi main( ) fonsiyonundan önce yapılmıştır. Fonksiyon yalnızca fonksiyon
ismi, parantezler ve bir ;’den oluşan tek bir tümce kullanılarak çağrılabiliyor.
Derleyici ;’ fonksiyon bildirilerini fonksiyon çağrılarından ayırmak kullanır.
RETURN TÜMCESİ
Bir fonksiyondan kendisini çağıran programa geri dönmek için return tümcesi kullanılır.
Return’u herhangi bir terim izleyebilir.
Return (terim)
şeklindedir. Çağıran fonksiyon gerekirse gönderilen terimi göz ardı edebilir.
int toplam(a, b)
int a,b;
{
int c;
c=a+b;
return c;
}
Bu program ana programdan iki değer alır (a ve b) bunlar toplanır ve sonuç c’ye
yerleştirilir. Sonra fonksiyon bu sonucu ana programa göndererek fonksiyonu sona
erdirir.
PARAMETRELER
Parametre program ile fonksiyon arasında bilgi aktarmakta kullanılan özel bir
değişkendir. Parametre tanımlamaları fonksiyon isminden hemen sonra tanımlanır.
Fonksiyon isminden önce tip bildirimi yapılır, bu fonksiyonun ana programa hangi tipte
değer göndereceğini belirtir.
Herhangi bir değer vermeyen bir fonksiyonun tipi void olarak bildirilir. Bir fonksiyonun
gönderdiği değerleri kullanabilmek için bir değişkeni fonksiyonun ismine eşitlemek
gerekir.
ÖRNEK
# include <stdio.h>
int toplam(a, b)
int a, b;
{
int c;
c=a+b;
return c;
}
main( )
{
27
int a;
a=toplam(3, 4);
printf("toplam= %d\n", a);
}
Bir bildirimde tip belirtilmezse C int tipi bir değer istediğimizi varsayar. Bununla birlikte
bazı hatalarla karşılaşmamak için tip belirtilmelidir.
Fonksiyon bir değer vermesini istemiyorsanız void sözcüğünü kullanmalısınız.
YEREL DEĞİŞKENLER
Yukarıdaki örnekte toplam( ) fonksiyonundaki a, main( )’deki a’dan farklıdır. Çünkü a
yerel bir değişkendir. Bu değişken ve parametreler yalnızca bildirdikleri fonksiyonun
içinde tanınabilirler. Hiç bir fonksiyon başka bir fonksiyonun içinde bildirilen parametre
ve değişkenleri tanıyamaz. Bu nedenle bir programda aynı isimde birden fazla değişken
kullanılabilir.
PROTOTİP
Prototip C’ye fonsiyonun formatını gösterir. C’de bunu kullanır ve fonksiyon çağrısı
yapılmadan önce bütün değerlerin uygun tiplerine çevrilmelerini sağlar. Bildirim şekli
şöyledir;
tip fonsiyon_ismi(tip,tip, ...,tip);
Bir bildirimden farklı olarak prototipin sonuna bir noktalı virgül konulmalıdır.
İnt toplam(int, int);
gibi
ÖRNEK
# include <stdio.h>
int toplam(int,int);
int toplam(a,b)
int a,b;
{
int c;
c=a+b;
return c;
}
main( )
{
int a;
a=toplam(3.1,4.2);
printf("a’nın değeri= %d\n", a);
}
28
parametre kullanmayan fonksiyonlar için
void merhaba_de(void);
şeklinde prototip tanımlanır.
İÇ İÇE FONKSİYONLAR
# include <stdio.h>
int toplam(int,int);
void bekle(void);
toplam(a,b)
int a,b;
{
int c;
printf("%d ile %d toplanacak\n",a,b);
bekle( );
c=a+b;
return c;
}
void bekle(void)
{
printf("Devam etmek için herhangi bir tuşa basın\n");
getch( );
}
main( )
{
int x,y;
y=5;
x=toplam(4,y);
printf("sonuç=%d\n",x);
}
29
8. Bölüm
DİZİLER
Dizi aynı ad altında toplanmış ve aynı tipte olan değişkenlerin sıralı bir listesidir. C’de bir
dizi için bildirim yapılırken kullanılan genel kural şudur.
tip dizi_ismi[eleman_sayısı];
Bütün diziler 0 ile baţlar.
ÖRNEK
# include <stdio.h>
main( )
{
int sayı_listesi[10]; /* 10 tamsayı içieren bir dizi */
sayı_listesi[4]=823;
sayı_listesi[0]=38;
printf("eleman %d : %d\n",4,sayı_listesi[4]);
pirntf("eleman %d : %d\n",0,sayı_listesi[0]);
}
ÖRNEK
# include <stddio.h>
main()
{
int i, tpl;
int a[10], b[10], c[10];
for (i=0;i<=9;i++)
a[i]=b[i]=c[i]=0;
tpl=0;
for (i=0;i<=9;i++)
{
a[i]=i;
b[i]=i*i;
c[i]=2*a[i]+b[i];
tpl=tpl+c[i];
}
printf ("
sayi
karesi 2*sayi+karesi \n");
for (i=0;i<=9;i++)
printf("%8d %8d %8d \n", a[i],b[i],c[i]);
printf("
}
toplam =%d \n",tpl);
30
ÖRNEK
# include <stddio.h>
int i;
int kare[21];
{
for (i=1;i<=20;i++)
kare[i]=i*i
}
ÖRNEK
# include <stdio.h>
main( )
{
int i;
float sonuc[10];
printf("10 tane reel sayı girin\n");
for (i=0;i<10;i++);
{
printf("No %d:",i+1);
scanf("%f, &sonuç[i]);
}
printf("sayılar girildi\n");
printf("sonuç için 1 ile 10 arasında bir sayı\n");
printf("çıkış için 0 yazın\n);
do
{
printf(":"); scanf("%d", &i);
if (i>0 && i<11) /* geçerli bir eleman (1-10) */
printf("Eleman %d, %f içeriyor\n", i, sonuç[i-1]); /* elemanlar 0 ile 9 arasında */
}
while (i!=0)
}
KARAKTER DİZGİLERİ
Bir sözcük veya tümceyi bir değişkende saklamak istediğimizde bunu yapmanın bir yolu
tümceyi bir karakter dizisine yerleştirmektir.
Bir dizgi, bir dizi olduğu için = işareti kullanılamaz.
Bir dizgiyi bir karakter dizisinden diiğerine taşımak için dizgi kopyalama fonksiyonu olan
strcpy( )’yi kullanmak gerekir. Bu fonksiyonun iki parametresi vardır. Kaynak dizgisi ve
hedef dizgisi.
char hedef[80];
31
char kaynak[80];
strcpy (hedef,kaynak);
ÖRNEK
# include <stdio.h>
main( )
{
char dizgi1[80], dizgi2[80];
printf("lütfen bir dizgi girin\n:");
scanf("%s", &dizgi1);
printf("bu dizgi2’ye aktarılıyor\n");
strcpy(dizgi2, dizgi1);
printf("Dizgi %s\n", dizgi2);
}
NOT :Bir dizi aynı ad altında bir araya gelmiş olan bir grup değişkenden oluşur. Dizinin
her bir değerine elman adı verilir. Bir elemanı belirtmek için kullanılacak sayı pozitif bir
tam sayı olmalıdır ve bu elemanın içerdiği değer herhangi bir tipte olabilir.
MATRİS İLE İLGİLİ ÖRNEK:
# define sira 3
# define kolon 3
# include <stdio.h>
main()
{
int i, j, k, katsayı;
int matris [sira][kolon];
for (i=0;i<sira;i++)
for (j=0;j<kolon;j++)
matris[i][j]=0;
for (i=0;i<sira;i++)
{
j=0;
while (j<kolon)
{
printf("matris[%d][%d]=",i,j);
scanf("%d",&katsayi);
if (katsayi<0)
break;
matris[i][j]=katsayi;
j++;
}
32
}
for (i=0;i<sira;i++)
{
for (j=0;j<kolon;j++)
printf("matris[%d][%d]=%d",i,j,matris[i][j]);
printf("\n");
}
}
BREAK DEYİMİ
C de döngüden çıkmak için kullanılır. Bilgisayar döngünün sonunu beklemeden, istenilen
koşulun sağlandığını kabul ederek, bir sonraki satırdaki komutları işletir.
for, while veya do..while döngülerinde kullanılır. if..else ile kullanılamaz.
Örnekte, katsayi sıfırdan küçük olursa, o sıradaki diğer elemanların hep sıfır değeri
alması istendi. Bu durumda break ile bilgisayar j döngüsünden çıkıp bir sonraki i değerini
alarak işleme devam eder.
ÖRNEK (CONTINUE deyimi) : C 'de continue "kaldığın yerden devam et", döngüyü
tamamlayıncaya kadar devam et anlamındadır.
# include <stdio.h>
main()
{
int i, j;
int a[5];
for (i=0;i<5;i++)
a[i]=0;
for (i=0;i<5;i++)
scanf("%d",&a[i]);
for (i=0;i<5;i++)
{
if ( a[i]<0)
continue;
printf("%d TAMAM \n", a[j]);
}}
Bu örnekte, eğer a[j] değeri sıfırdan küçükse döngünün sonuna, yani { işaretine kadar
gitmeden başa dön, j nin bir sonraki değerini alarak işleme devam et denmektedir.
program çalıştırıldığında; 11
11 TAMAM
33 TAMAM
-22
33
-44
55
değerleri girilirse
33
55 TAMAM
çıktısı elde edilir.
ÖRNEK : Enter tuşuna basıncaya kadar verilen tüm karakterleri ASCII koduna çeviren
program.
# include <stdio.h>
main()
{
int i;
cahar c;
for (i=0;(c=getchar())!='\n';++i)
printf("%d \n",c);
}
ÖRNEK ( Özel operatörler ve ifadeler)
# include <stdio.h>
main()
{
int a, b, i;
for (i=0;i<=10;i++)
a=a+i;
printf("toplam a nın değeri = %d \n",a);
for (i=0;i<=10;i++)
b+=i;
printf("toplam b nin değeri = %d \n", b);
}
Bu örnekte a=55 ve b=55 değeri elde edilir.
Genel olarak x=x+y yerine x+=y yazılabilir. Yani,
x=x op y yerine x op =y komutu yazılabilir.
Örneğin;
x=x*(y+1) yerine x *=(y+1) yazılabilir.
ÖRNEK
toplamını a, b, n 'in çeşitli değerleri için hesaplanacağını düşünüp
bunun için bir fonksiyon yazalım.
# include <stdio.h>
main()
{
double seri();
34
int i;
for (i=1;i<=5;++i)
printf("%d %1.6f %1.6f %1.6f \n", i, seri(1,i,0), seri(2,i,1));
}
double seri(a,n,b)
int a,n,b;
{
double s, r;
int j;
r=0;
s=0;
for (j=1;j<=n;++i)
{
r=a*j-b;
s=s+(1/r);
}
return(s);
}
ÖRNEK (Kısaltılmış if)
# include <stdio.h>
main()
{
int i; float a, b, z;
a=4; b=1.5; z=0;
for (i=0; b<=a+100.0; i++)
{
a=(a+7.3)*i;
b=(b+1.0)*(i+1.0);
if (a>b)
z=a;
else
z=b;
printf(%12.7f \n", z);
}}
NOT : C ' de mümkün olan diğer bir kısaltma da if ... else deyimlerinde ? işaretinin
operatör olarak kullanılmasıdır. Yukarıdaki programın aynısı bu operatör kullanılarak
aşağıda verilmiştir.
# include <stdio.h>
main()
{
int i; float a, b, z;
35
a=4; b=1.5; z=0;
for (i=0; b<=a+100.0; i++)
{
a=(a+7.3)*i;
b=(b+1.0)*(i+1.0);
z=(a>b) ? a: b;
printf(%12.7f \n", z);
}}
Not:
z=(a>b) ? a: b; ifadesinde önce (a>b) işelem konur, eğer true (yani pozitif,
doğru) ise 2.parametre olan a işlem görür, yani z=a; daha sonra ise yani (a>b) değilse
son parametre olan b işlem görüyor, yani z=b; olur.
36
9. Bölüm
BAZI ÖNEMLİ MATEMATİK FONKSİYONLARI
Eklenecek kütüphaneler:
# include <math.h>
# include <stdlib.h>
radyan = acı*pi/180,
x double tipli değişken
sin(x), cos(x), tan(x), asin(x), acos(x), atan(x), sinh(x), cosh(x), tanh(x), sech(x)
**************************************************************
sqrt(x) : x in karekökünü hesaplar
log(x) : e tabanına göre logaritma alır (ln(x))
log10(x) : 10 tabanına göre logaritma alır
pow(x,y) :
exp(x) :
değerini hesaplar
değerini hesaplar
ceil(x) : x den küçük olmayan en küçük tamsayıyı hesaplar (tamdeğer)
fabs(x) : x in mutlak değerini hesaplar
fmod(x,y) : x/y oranında kalanı hesaplar.
abs(x) : tamsayı olan x in mutlak değerini verir.
labs(x) : long türünden olan x in mutlak değerini verir.
max(x,y) : x, y nin enbüyüğünü bulur
min(x,y) : x, y nin enküçüğünü bulur
rand() : 0 ile 32767 arasında rasgele bir sayı seçer
rand(x) : 0 ile x arasında rasgele bir sayı seçer
randomize(); rasgele sayı için başlangıç değerini değiştirir
( <time.h> da eklenmelidir)
37
10. Bölüm
Başlangıç Örnekler 1
*******************************************************************
faktoryel hesaplayan program
*******************************************************************
#include<stdio.h>
/* 1 den 100 e kadar olan sayilarin faktoriyeli */
main()
{ int a,i;
double f;
f=1;
clrscr();
for (a=1;a<101;a++)
{ f=f*a;
printf(" %d faktoriyel %f \n",a,f);
i++;
if (i>10)
{i=1;
getch(); }
}
getch();
}
*********************************************************************
*
Asal sayıları bulan program
*********************************************************************
*
/*
BIRDEN 2000 E KADAR ASAL SAYILARI BULAN PROGRAM */
#include <stdio.h>
#include <math.h>
float tam(sayi)
float sayi;
{
int i;
i=sayi;
return i+.0;
}
int asal(sayi)
int sayi;
{
int i,sonuc;
38
sonuc=1;
for (i=2;i<sayi/2+1;i++)
{
if ((sayi+.0)/i==tam((sayi+.0)/i))
{
sonuc=0;
i=sayi;
}
}
if (sayi==-1 ||sayi==0||sayi==1) sonuc=0;
return sonuc;
}
main()
{
int j;
clrscr();
for(j=2;j<2000;j++)
if (asal(j)==1) printf("%4d",j);
getch();
}
*******************************************
e değerini hesaplayan program
*******************************************
#include <stdio.h>
#include<math.h>
double fakt(sayi)
int sayi;
{
int i;
double fak=1.0;
for (i=1;i<sayi+1;i++)
fak=fak*i;
return fak;
}
double expu(x)
float x;
{
int i;
double e=0.0;
for (i=0;i<41;i++)
e=e+pow(x,i)/fakt(i);
39
return e;
}
main()
{
float x;
clrscr();
printf("Exp i alinacak sayiyi giriniz..:");
scanf("%f",&x);
printf("Yaklaşık exp(%f)=%.20f\n",x,expu(x));
printf("program fonksiyonu exp(%f)=%.20f",x,exp(x));
getch();
}
*****************************************************
Bazı betimsel istatistikleri hesaplayan program
*****************************************************
#include<stdio.h>
#include<math.h>
# define boyut 1000
main()
{
int t,a,n,i,j;
int dizi[boyut], max,min,gen;
double var,ort,ss,med;
int vr;
clrscr();
printf("dizi kac elemanli = ");
scanf("%d",&n);
printf("elemanlari girin \n ");
for (i=1;i<n+1;i++)
{ printf(" %d",i);printf(".eleman=");
scanf("%d",&dizi[i]);}
/* siralama */
for(i=1;i<n;i++)
for(j=i+1;j<n+1;j++)
if (dizi[i]>dizi[j])
{ a=dizi[i];
dizi[i]=dizi[j];
dizi[j]=a;
}
printf("SIRALI HALi.. ");
for(i=1;i<n+1;i++)
printf("%d ",dizi[i]);
40
printf("\n");
/* max min */
max=dizi[n];min=dizi[1];gen=max-min;
printf("maximum= %d \n",max);
printf("minimum= %d \n",min);
printf("orneklem genisligi= %d \n",gen);
/* ortalama s.sapma varyans*/
t=vr=0;ort=var=ss=0;
for(i=1;i<n+1;i++)
t=t+dizi[i];
ort=t/n;
for(i=1;i<n+1;i++)
vr=vr+pow((dizi[i]-ort),2);
var=vr/(n-1);
ss=sqrt(var);
printf("ortalama %f \n",ort);
printf("varyans %f \n",var);
printf("s.sapma %f \n",ss);
printf("ortanca ");
if (pow(-1,n)<0) med=dizi[(n+1)/2];
else med=(dizi[n/2]+dizi[n/2+1])/2;
printf("%f \n",med);
getch();
}
*****************************************************
program adi : kokbul.c
Çeşitli fonksiyonların köklerini değişik yöntemlerle bulan program
*****************************************************
#include<stdio.h>
#include<math.h>
#include <conio.h>
#include <stdlib.h>
#include <graphics.h>
int e=2.71182818;
char *dizi[14];
void aktar(void)
{
int sayac;
int graphdriver=DETECT,graphmode;
initgraph(&graphdriver,&graphmode,"");
41
setbkcolor(1);
setcolor(14);
settextstyle (GOTHIC_FONT,HORIZ_DIR,1);
setcolor(11);
setlinestyle(0,0,3);
settextstyle(DEFAULT_FONT,HORIZ_DIR,2);
outtextxy(250,15,"SORULAR");
gotoxy(1,1);printf("Selcuk Cobanoglu");
gotoxy(4,2);printf("95052732");
line(0,50,700,50);
settextstyle(SMALL_FONT,HORIZ_DIR,7);
dizi[1]=" X-SIN(X)-1=0 ";
dizi[2]=" X-e^(-X)=0 ";
dizi[3]=" X^3+10X-11.6=0 ";
dizi[4]=" X*e^X-1=0 ";
dizi[5]=" X^3-100=0 ";
dizi[6]=" e^X-3*X=0 ";
dizi[7]=" X*TAN(X)-0.5=0 ";
dizi[8]=" COS(X)=3*X ";
dizi[9]=" X^3-3X+1=1 ; Xo=1.5 ";
dizi[10]=" e^X-LN(X)=20 ";
dizi[11]=" e^X=(2*X)+21 ; Xo=3 ";
dizi[12]=" LN(X)=1+1/(X^2) ";
{
settextstyle(SMALL_FONT,HORIZ_DIR,1);
setcolor(1);
for (sayac=1;sayac<13;sayac++)
{
gotoxy(30,4+sayac);printf("%d",sayac);printf(dizi[sayac]);
printf("\n");
}
}
}
/******************************************/
double fonk(double x,int fno)
{
double f1;
switch(fno)
{
case 1:{f1= x-sin(x)-1;break;}
case 2:{f1= x-pow(e,-1*x);break;}
case 3:{f1= pow(x,3)+10*x-11.6;break;}
case 4:{f1= x*pow(e,x)-1;break;}
42
case 5:{f1= pow(x,3)-100;break;}
case 6:{f1= pow(e,x)-3*x;break;}
case 7:{f1= x*tan(x)-0.5;break;}
case 8:{f1= cos(x)-3*x;break;}
case 9:{f1= pow(x,3)-3*x;break;}
case 10:{f1= pow(e,x)-log(x)-20;break;}
case 11:{f1= pow(e,x)-2*x-21;break;}
case 12:{f1= log(x)-1-1/pow(x,2);break;}
}
return f1;
}
/************************************/
double turev(double x,int fno)
{
double t1;
switch(fno)
{
case 1:{t1= 1-cos(x);break;}
case 2:{t1= 1+pow(e,-1*x);break;}
case 3:{t1= 3*pow(x,2)+10;break;}
case 4:{t1= pow(e,x)+x*pow(e,x);break;}
case 5:{t1= 3*pow(x,2);break;}
case 6:{t1= pow(e,x)-3;break;}
case 7:{t1= tan(x)+x*(1+pow(tan(x),2));break;}
case 8:{t1= -1*sin(x)-3;break;}
case 9:{t1= 3*pow(x,2)-3;break;}
case 10:{t1= pow(e,x)-1/x;break;}
case 11:{t1= pow(e,x)-2;break;}
case 12:{t1= 1/x+2/pow(x,3);break;}
}
return t1;
}
/************************************/
double ifonk(double x,int fno)
{
double f1;
switch(fno)
{
case 1:{f1= sin(x)+1;break;}
case 2:{f1= pow(e,-1*x);break;}
case 3:{f1= (11.6-pow(x,3))/10;break;}
case 4:{f1= pow(e,-1*x);break;}
case 5:{f1= 10/pow(x,0.5);break;}
case 6:{f1= log(3*x);break;}
43
case 7:{f1= atan(1/(2*x));break;}
case 8:{f1= cos(x)/3;break;}
case 9:{f1= pow(x,3)-3*x;break;}
case 10:{f1= log(log(x)+20);break;}
case 11:{f1= log(2*x+21);break;}
case 12:{f1= pow(e,1+1/(x*x));break;}
}
return f1;
}
/************************************/
void cevap(no,yontem)
int no,yontem;
{
int sayac;
float xx,x,x1,x2,eps;
printf("Xo 'i Giriniz..:");
scanf("%f",&xx);
printf("Epsilon'u Giriniz");
scanf("%f",&eps);
printf("\n");
if (yontem==1 && no!=10 && no!=12)
{
/***YARILAMA YONTEMI********/
sayac=1;
x1=-1*5;
x2=5;
x=(x1+x2)/2;
printf("Xo=%f\n",x);
while (-1*eps>=fonk(x,no) || fonk(x,no)>=eps)
{
if (fonk(x1,no)*fonk(x,no)<0) x2=x; else x1=x;
x=(x1+x2)/2;
printf("X%d=%f\n",sayac,x);
sayac++;
}
printf("\nE%d=%.6f\n",sayac-1,fonk(x,no));
}
if (yontem ==2 && no!=10 && no!=6 && no !=12)
{
/***REGULA FALSI YONTEMI****/
sayac=1;
x1=-1*10;
x2=5;
x=(x1+x2)/2;
44
printf("Xo=%f\n",x);
while (-1*eps>=fonk(x,no) || fonk(x,no)>=eps)
{
if (fonk(x1,no)*fonk(x,no)<0) x2=x; else x1=x;
x=(x1*fonk(x2,no)-x2*fonk(x1,no))/(fonk(x2,no)-fonk(x1,no));
printf("X%d=%f\n",sayac,x);
sayac++;
}
printf("\nE%d=%.6f\n",sayac-1,fonk(x,no));
}
if (yontem==3)
{
/*** NEWTON RAPSON YONTEMI***/
sayac=1;
x=xx;
printf("Xo= %f\n",x);
while (-1*eps>=fonk(x,no) || fonk(x,no)>=eps)
{
x=x-(fonk(x,no)/turev(x,no));
printf("X%d= %.6f\n",sayac,x);
x1=x;
}
printf("\nE%d=%.6f\n",sayac-1,ifonk(x,no));
}
if (yontem==4)
{
/***BASIT ITERASYON YONTEMI****/
sayac=1;
x=xx;
printf("Xo= %f\n",x);
while (-1*eps>=x-ifonk(x,no) || x-ifonk(x,no)>=eps)
{
x=fonk(x,no);
printf("X%d= %.6f\n",sayac,x);
}
printf("\nE%d=%.6f\n",sayac-1,x-ifonk(x,no));
}
}
/************************************/
main()
{
int s,y;
aktar();
gotoxy(45,40);printf("Secenek Gir..:");
45
scanf("%d",&s);
gotoxy(50,50);printf(" \n YONTEMLER \n");
gotoxy(50,51);printf("1 => YARILAMA\n");
gotoxy(50,52);printf("2 => REGULA FALSI\n");
gotoxy(50,53);printf("3 => NEWTON RAPSON\n");
gotoxy(50,54);printf("4 => BASIT ITERASYON\n\n");
gotoxy(50,55);printf("Secenek Giriniz..:");
scanf("%d",&y);
if (s>0 && s<14) cevap(s,y);
getch();
}
************************************
matrislerle ilgili iţlem yapan program
************************************
#include<stdio.h>
/* matrislerin toplami max min toplami max-min satir top min olan sutun*/
main()
{
int n;
int ma[100][100],mb[100][100],mc[100][100];
int i,j,k,s;
int maxa,maxb,mina,minb,satir[100],sutun[100];
int iza[100][100],izb[100][100],a[100],b[100];
clrscr();
printf("n= ");
scanf("%d",&n);
for (i=1;i<n+1;i++)
for (j=1;j<n+1;j++)
ma[i][j]=0;
mb[i][j]=0;
mc[i][j]=0;
printf("A matrisi (nxn) \n");
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
scanf("%d",&ma[i][j]);
printf("B matrisi (nxn) \n");
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
scanf("%d",&mb[i][j]);
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
46
mc[i][j]=ma[i][j]+mb[i][j];
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
printf("%d ",mc[i][j]);
printf(" \n ");
/* max - min bulma */
maxa=ma[1][1];mina=ma[1][1];
maxb=mb[1][1];minb=mb[1][1];
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
{if (maxa<ma[i][j]) maxa=ma[i][j];
if (maxb<mb[i][j]) maxb=mb[i][j];
if (mina>ma[i][j]) minb=ma[i][j];
if (minb>mb[i][j]) minb=mb[i][j];}
printf("a matrisinin en buyuk degeri= %d \n",maxa);
printf("b matrisinin en buyuk degeri= %d \n",maxb);
printf("a matrisinin en kucuk degeri= %d \n",mina);
printf("b matrisinin en kucuk degeri= %d \n",minb);
/* satir ve sutunda max min */
for(i=1;i<100;i++)
{satir[i]=0;sutun[i]=0; }
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
{ satir[i]=satir[i]+ma[i][j];
sutun[i]=sutun[i]+mb[j][i];}
maxa=0;minb=0;
maxa=satir[1];minb=sutun[1];
for (i=1;i<n+1;i++)
{ if(maxa<satir[i]) maxa=satir[i];
if(minb>sutun[i]) minb=sutun[i];}
printf("toplami max olan a matrisi satiri= %d \n",maxa);
printf("toplami min olan b matrisi sutunu= %d \n",minb);
/* a ve b matirisinin kosegenleri */
s=0;k=0;
for(i=1;i<n+1;i++)
{a[i]=ma[i][i];
b[i]=mb[i][i];}
printf("a matrisi kosegenleri \n");
for(i=1;i<n+1;i++)
{ k=k+a[i];
printf("%d \n",a[i]);}
47
printf("kosegen toplami= %d \n",k);
printf("b matrisi kosegenleri \n");
for (i=1;i<n+1;i++)
{ s=s+b[i];
printf("%d \n",b[i]); }
printf("kosegen toplami= %d \n",s);
/* matrisin transpozu*/
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
{ iza[j][i]=ma[i][j];
izb[j][i]=mb[i][j]; }
printf("a nin izi \n");
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
printf(" %d ",iza[i][j]);
printf("\n");
printf("b nin izi: \n");
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
printf(" %d ",izb[i][j]);
getch();
}
48
11. Bölüm
Başlangıç Örnekleri 2
********************************
52 lik kağıt destesini karıştıram program
# include <stdio.h>
# include <math.h>
# include <stdlib.h>
# include <time.h>
int dizi[53];
int sayi_cek()
{
int k,num;
k=((rand()+.0)/32767)*4+1;
num=((rand()+.0)/32767)*13+1;
return k*100+num;
}
void kar(void)
{
int i,j,sayi;
for (i=1;i<=52;i++)
{
sayi=sayi_cek();
for (j=1;j<i;j++)
if (sayi==dizi[j])
{
j=i;
i=i-1;
}
if (j<i+2)
{
dizi[i]=sayi;
}
}
}
main()
{
int i,s,t,x,y;
randomize();
clrscr();
49
kar();
x=5;
y=4;
for(i=1;i<=52;i++)
{
s=dizi[i];
t=s/100;
x=x+1;
if (x>18)
{
x=6;
y=y+20;
}
gotoxy(y,x);
switch(t)
{
case 1:printf("%d=> Maca ",i);break;
case 2:printf("%d=> Sinek ",i);break;
case 3:printf("%d=> Kupa ",i);break;
case 4:printf("%d=> Karo ",i);break;
}
if (s-t*100==1)
printf("As "); else printf("%d ",s-t*100);
}
getch();
}
***********************************
******* grafik ekran kullanımı**********
***********************************
# include <stdio.h>
# include <stdlib.h>
# include <math.h>
# include <graphics.h>
main()
{
int x,y,i;
int graphdriver=DETECT,graphmode;
initgraph(&graphdriver,&graphmode,"");
setbkcolor(0);
setcolor(4);
settextstyle (GOTHIC_FONT,HORIZ_DIR,9);
outtextxy(70,100,"simlasyon");
50
setcolor(11);
setlinestyle(0,0,5);
x=getmaxx();
y=getmaxy();
rectangle(0,0,x,y);
getch();
cleardevice();
setcolor(5);
settextstyle(DEFAULT_FONT,HORIZ_DIR,6);
outtextxy(200,25,"ANAMENš");
line(0,100,700,100);
settextstyle(SMALL_FONT,HORIZ_DIR,6);
outtextxy(150,150,"[1]-DAGILIMLARDAN SAYI URETME");
outtextxy(150,175,"[2]-DAGILIMLARIN GRAFIGI");
outtextxy(150,200,"[3]-DAGILIMLARIN TABLOSU");
outtextxy(150,225,"[4]-VERI GIRISI");
outtextxy(150,250,"[5]-CIKIS");
gotoxy(10,25);printf("SECIMINIZ ? ");
getch();
closegraph();
}
****************************************************
******* rasgele hareket eden parçacığın simülasyonu*********
****************************************************
# include <graphics.h>
# include <math.h>
# include <stdio.h>
# include <stdlib.h>
main ()
{
char ch;
double l,x2,y2,x1,y1,alfa;
int x,y,i,r1,r2;
int graphdriver=DETECT,graphmode;
initgraph(&graphdriver,&graphmode,"");
x1=50.0;
y1=50.0;
setbkcolor(0);
setcolor(7);
settextstyle (GOTHIC_FONT,HORIZ_DIR,9);
outtextxy(70,100,"simlasyon");
getch();
51
cleardevice();
setlinestyle(0,0,5);
x=getmaxx();
y=getmaxy();
rectangle(0,0,x,y);
i=1;
while (i<3000)
{
r1=rand();
alfa=r1/32767.0*6.48;
r2=rand();
l=r2/32767.0*10.0;
y2=l*sin(alfa)+y1;
x2=l*cos(alfa)+x1;
line(x1+50,y1+50,x2+50,y2+50);
x1=x2;y1=y2;
i++;
}
getch();
closegraph();
}
****************************************************
/* Monte-Carlo intagrasyon yontemi ile f(x)=(1-x^2)^.5 */
/* fonksiyonunun (0,1) araliginda yaklasik integralini bulur */
****************************************************
# include <stdio.h>
# include <math.h>
main ()
{
int i,k;
double z,alan,x,y;
clrscr();
i=0;
k=0;
for (i=1;i<=500;i++)
{
x=rand()/32767.0;
y=rand()/32767.0;
z=2.0;
/*
z=sqrt(1.0-x*x);*/
52
if ( y <= z )
k++;
/*
gotoxy(10,14);printf("N= %d",i);
gotoxy(10,12);printf("k= %d",k);*/
alan=(k*1.0)/(i*1.0);
gotoxy(10,16);printf("alan= %2.9f",alan);
}
gotoxy(10,24);printf("cikis icin herhengi bir tusa basiniz");
getch();
}
/*********************** */
/*dusen bir topun gozlenmesi*/
/*********************** */
# include <graphics.h>
# include <stdio.h>
# include <math.h>
main ()
{
double a,b,k,y1,li;
float pi =3.14159654;
int x,y,yuks ,iii, ex , ey ,ii,j, i,m,n;
void gotoxy(int a, int b);
int graphdriver=DETECT,graphmode;
initgraph(&graphdriver,&graphmode,"");
line (0,295,510,295);
iii=0;
x=0;
y=0;
yuks=250;
a=pi/70.0;
b=90*pi/180.0;
k=.0014;
for (i=1;i<200;i++)
{
/*cleardevice();*/
line (0,295,510,295);
iii=iii+3;
y1=yuks*sin(a*iii+b)*exp(-k*iii);
y1=300-abs(y1)-10;
circle(x,y,5);
circle(iii+20,y1,10);
53
x=iii+20;
y=y1;
}
getch();cleardevice();
}
********************************************
********* normal dağılım için sayısal integral hesabı
********************************************
# include <stdio.h>
# include <math.h>
main ()
{
int n1;
double sonuc,a1,b1;
double fonk();
double integral();
clrscr();
a1=0.0;
b1=1.0;
n1=500;
gotoxy(10,24);printf(".....lütfen bekleyiniz.........");
sonuc=integral(a1,b1,n1);
gotoxy(10,10);printf("sonu‡ = %4.9f \n",sonuc);
getch();
}
double integral(double a,double b, int n)
{
double x1,h,integ,integ1,integ2;
int i;
h=(b-a)/n*1.0;
integ1=0.0;
integ2=0.0;
integ=0.0;
for (i=1;i<=n;i=i+2)
{
x1=a+i*h*1.0;
integ1=integ1+4.0*fonk(x1);
integ2=integ2+2.0*fonk(x1);
integ=integ1+integ2+fonk(a)+fonk(b);
integ=integ*h/3.0;
}
return(integ);
54
}
double fonk(double x)
{
double y;
y=0.39904*exp(-0.5*pow(x,2.0));
return(y);
}
********************************************************
******** kolmogorov smirnov uyum-iyiliği testi üstel dağılım*******
********************************************************
# include <stdio.h>
# include <stdlib.h>
# include <math.h>
# include <conio.h>
# define BOYUT 200
main()
{
double ustel();
double uretme();
void swap (double *, double *);
double dizi[BOYUT];
double dizi1[BOYUT];
double dizid[BOYUT];
double dizif[BOYUT];
double ddeger[BOYUT];
double levo;
int n,teta,i;
n=5;
teta=9;
clrscr();
{ for(i=1;i<=n;i++)
{ dizi[i]=0.0;
dizi1[i]=0.0;
dizid[i]=0.0;
dizif[i]=0.0; }}
ddeger[4]=.565;
ddeger[5]=.509;
ddeger[6]=.468;
ddeger[7]=.436;
ddeger[8]=.410;
ddeger[9]=.387;
ddeger[10]=.369;
55
ddeger[11]=.352;
ddeger[12]=.338;
ddeger[13]=.325;
ddeger[14]=.314;
ddeger[15]=.304;
ddeger[16]=.295;
ddeger[17]=.286;
ddeger[18]=.279;
ddeger[19]=.271;
ddeger[20]=.265;
ddeger[21]=.259;
ddeger[22]=.253;
ddeger[23]=.247;
ddeger[24]=.242;
ddeger[25]=.238;
ddeger[26]=.233;
ddeger[27]=.229;
ddeger[28]=.225;
ddeger[29]=.221;
ddeger[30]=.218;
ddeger[31]=.214;
ddeger[32]=.211;
ddeger[33]=.208;
ddeger[34]=.205;
ddeger[35]=.202;
ddeger[36]=.199;
ddeger[37]=.196;
ddeger[38]=.194;
ddeger[39]=.191;
ddeger[40]=.189;
clrscr();
uretme(dizi,n,teta);
sirala(dizi,n);
yaz(dizi,n);
for(i=1;i<=n;i++)
{ dizi1[i]=(i*1.0)/n*1.0; }
for(i=1;i<=n;i++)
{ levo=dizi[i];
dizif[i]=ustel(teta,levo);}
56
for(i=1;i<=n;i++)
{ dizid[i]=dizif[i]-dizi1[i];
if (dizid[i]< 0.0)
dizid[i]=-1.0*dizid[i]; }
sirala(dizid,n);
getch();
clrscr();
gotoxy(2,10);printf("hesaplanan d değeri= %f",dizid[n]);
if (n>40)
ddeger[n]=1.22/sqrt(n);
gotoxy(2,12);printf("tablo d değeri= %f",ddeger[n]);
{ if (dizid[n]>ddeger[n])
{ gotoxy(2, 15);printf("H0 red edilecek.....>");}
else
{ gotoxy(2, 17);printf("******** H0 kabul edilecek.....>");}
}
getch();
exit(0);
}
double uretme(sayi,n1,teta1)
double sayi[];
int n1, teta1;
{
int i;
double x;
for(i=1;i<=n1;i++)
{ x=rand();
x=x/32767.0;
x=-1.0*teta1*log(x);
sayi[i]=x; } }
void swap (double *a, double *b)
{ double temp;
temp = *a;
*a= *b;
*b=temp; }
sirala (sayi2,n2)
double sayi2[];
int n2;
{
57
int j,k;
double l1,l2;
for (j=1;j<=n2-1;j++)
{ for(k=j+1;k<=n2;k++)
{ if(sayi2[j]>sayi2[k])
{ l1=sayi2[j];
l2=sayi2[k];
swap (&l1,&l2);
sayi2[j]=l1;
sayi2[k]=l2;
}}}}
yaz (sayi3,n3)
double sayi3[];
int n3;
{ int i;
for(i=1;i<=n3;i++)
{ printf("%f\n",sayi3[i]);} }
double ustel(teta3,x)
int teta3;
double x;
{ double f0;
f0=1.0-exp((-x*1.0)/(1.0*teta3));
return(f0); }
58
12. Bölüm
Sayısal Çözümleme Örnekleri 1
************************************
*** bölünmüş faklar tablosu*************
************************************
#include<stdio.h>
#include<conio.h>
#include<math.h>
main()
{
float y,fx[100],f[100][100],x[100],c=1,p=0;
int n,i,j;
clrscr();
printf("n=");scanf("%d",&n);
printf("x=");scanf("%f",&y);
for(i=0;i<=n;i++)
{
printf("x(%d),f(%d) :",i,i);scanf("%f,%f",&x[i],&fx[i]);
}
for(i=1;i<=n;i++) f[1][i]=(fx[i]-fx[i-1])/(x[i]-x[i-1]);
for(i=2;i<=n;i++)
{
for(j=1;j<=(n-i+1);j++) f[i][j]=(f[i-1][j+1]-f[i-1][j])/(x[i-1+j]-x[j-1]) ;
}
p=fx[0];
for(i=0;i<=(n-1);i++)
{
c*=(y-x[i]);
p+=c*f[i+1][1];
}
for(i=1;i<=n;i++)
{
for(j=1;j<=n-i+1;j++)
{
gotoxy(i*10,n+4+j);printf("%f",f[i][j]);
}
}
gotoxy(1,2*n+9);printf("polinom degeri :%f",p);
getch();}
59
***********************************************
***********gregory newton formulu ****************
***********************************************
#include<stdio.h>
#include<math.h>
#include<conio.h>
main()
{
float x0,x,df[100][100],p,c=1,h,s;
int i,j,n;
clrscr();
printf("n=");scanf("%d",&n);
printf("x,x0,h :");scanf("%f,%f,%f",&x,&x0,&h);
s=(x-x0)/h;
printf("s=%f\n",s);
getch();
for(i=0;i<=n;i++)
{
printf("df[0][%d]=",i);scanf("%f",&df[0][i]);
}
for(i=1;i<=n;i++)
for(j=0;j<=n-i;j++)
{
df[i][j]=df[i-1][j+1]-df[i-1][j];
}
p=df[0][0];
for(i=0;i<=n-1;i++)
{
c*=(s-i)/(i+1);
p+=c*df[i+1][0];
}
for (i=1;i<=n;i++)
{
gotoxy(i*11+1,n+7); printf("df[%d]",i);
for (j=0;j<=n-i;j++)
{
gotoxy(i*11,n+8+j);printf("%f",df[i][j]);
}
}
gotoxy(1,2*n+10); printf("polinomun de§eri:%f",p);
getch();
}
60
***********************************************
/*INTERPOLASYON*/
***********************************************
#include <stdio.h>
main()
{
int i,j,n;
float p=0,l[100];
float y,x[100],fx[100];
clrscr();
printf("n=");scanf("%d",&n);
printf("x=");scanf("%f",&y);
for(i=0;i<=n;++i)
{
printf("x(%d),fx(%d) :",i,i);scanf("%f,%f",&x[i],&fx[i]);
}
for(i=0;i<=n;i++)
{
l[i]=1;
for(j=0;j<=n;j++)
{
if(i!=j) l[i]*=(y-x[j])/(x[i]-x[j]);
}
p+=l[i]*fx[i];
}
printf("Polinom degeri=%f",p);
getch();
}
***********************************************
/* denklem sistemleri ICIN BASIT ITERASYON YONTEMI*/
***********************************************
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define g1(a) (.5*cos(a))
#define g2(b) (.5*sin(b))
main()
{
float f1,f2,x0[3],x1[3],temp[3],eps;
int n=0,i;
61
clrscr();
for(i=1;i<=2;++i)
{
printf("x0(%d)=",i);scanf("%f",&x0[i]);
}
printf("eps=");scanf("%f",&eps);
do
{
x1[1]=g1(x0[2]);
x1[2]=g2(x0[1]);
temp[1]=x0[1];temp[2]=x0[2];
x0[1]=x1[1];
x0[2]=x1[2];
f1=fabs(x1[1]-temp[1]);
f2=fabs(x1[2]-temp[2]);
n++;
}while(max(f1,f2)>eps);
printf("adm says=%d\n",n);
printf("kok=%f,%f",x1[1],x1[2]);
getch();
}
***************************
Üç boyutlu grafik çizen program
***************************
# include <graphics.h>
# include <stdio.h>
# include <math.h>
# include <dos.h>
main ()
{
double yy;
int y,artim,j,i,x;
double a[21] [21];
void gotoxy(int a, int b);
int graphdriver=DETECT,graphmode;
initgraph(&graphdriver,&graphmode,"");
setbkcolor(0);
settextstyle(1,0,5);
outtextxy(1,1,"GRAFIK PROGRAMI");
{
for (j=-10;j<10;j++)
62
{
for (i=-10;i<10;i++)
{
yy=200+sin(j)*cos(i)*12;
a [j+11] [i+11]=yy;
}
}
}
{
setcolor(2);
for (j=1;j<20;j++)
{
for (i=1;i<20;i++)
{
artim=a[i][j];
x=(i*10)+50+(j*5);
y=(j*4)+30+artim/1.1;
if (i==1)
{
moveto(x,y);
line(x,y,x,y);
}
else
lineto(x,y);
}
}
}
{
setcolor(4);
for (i=1;i<20;i++)
{
for (j=1;j<20;j++)
{
artim=a[i][j];
x=(i*10)+50+(j*5);
y=(j*4)+30+artim/1.1;
if (j==1)
{
moveto(x,y);
line(x,y,x,y);
}
else
lineto(x,y);
}
63
}
}
getch();cleardevice();
closegraph();
}
64
13. Bölüm
Genel Örnekler
1.for
2.while
3. Makro
4. a++
5. +aa a++
6. Euclid algoritması (OBEB)
7. OBEB kendi kendini çağıran fonksiyon
8. Çift sayıların çarpımı
9. Çift sayıların çarpımı
10.Asal sayı bulma
11. e nin hesabı (Maclaurin açılımı) (fonksiyon kullanımı)
12. e nin hesabı (Maclaurin açılımı)
13. Faktoriyel hesabı
14. Faktoriyel hesabı
15. Pi sayısının hesabı arctan(x)2in Maclaurin açılımı kullanılarak
16. Satrançta atın rasgele hareketi
17. Matrisler üzerinde işlemler
18. Matris Çarpımı
19. Matrisler üzerinde işlemlere devam
20. Betimsel istatistikler
21. Betimsel istatistikler (fonksiyon kullanarak)
22. karakterler üzerinde işlemler
Örnek-1
/**************************************************/
/* for döngüsü kullanarak 25 den küçük sayıların */
/* karesinin hesaplanması.
*/
/**************************************************/
# include<stdio.h>
main()
{
int i;
for (i=1;i<=25;i++)
printf("%4d%8d\n", i, i*i);
}
Örnek-2
/**********************************************************************/
/* while döngüsü kullanarak 25 den küçük sayıların karelerinin hesabı */
/**********************************************************************/
# include<stdio.h>
main()
{
int a,kare;
i=1;
kare=0;
while(kare<=25)
{
kare=i*i;
printf("%4d%8d\n", i, kare);
i=i+1;
}
}
65
Örnek-3
/*******************************************************/
/* makro kullanımı, makronun kendi kendisini çağırması */
/*******************************************************/
# define kare(x) x*x
# include<stdio.h>
main()
{
long int i,a,b;
for(i=2;i<10;i++)
{
a=kare(i);
b=kare(kare(i));
printf("a=%ld\t b=%ld\n",a,b);
}
getch();
}
Örnek-4
/**********************************/
/* i=i+1 ve i+=1 kullanım örneği */
/**********************************/
# include<stdio.h>
main()
{
int i;
top1=top2=0;
for(i=0;i<=10;i++)
top1=top1+1;
printf("toplam1 = %d\n", top1);
for(i=0;i<=10;i++)
top2+=i;
printf("toplam2= %d\n", top2);
}
Örnek-5
/*********************************************/
/* a++ ve ++a arasındaki farkın incelenmesi */
/*********************************************/
#include<stdio.h>
main()
{
int a,c,b,d;
c=2;
d=3;
clrscr();
for (a=1;a<11;)
printf("a= %d ",a++);
printf("\n a++ için 1.döngü bitti \n\n");
for (a=1;a<11;)
printf("a= %d ",++a);
printf(" \n ++a için 2.döngü bitti \n\n");
66
b=c+++d;
printf("c=2 d=3 için \n");
printf("b=c+++d= %d \n\n",b);
b=(c++)+d;
printf("b=(c++)+d= %d \n\n",b);
getch();
}
Örnek-6
/********************************************************************/
/* p>q iki pozitif tamsayı olmak üzere Euclid Algoritması ile
*/
/* verilen iki sayının ortak bölenlerinin en büyüğünü bulan program */
/********************************************************************/
# include <stdio.h>
main()
{
int p,q,kalan;
clrscr();
printf("1.DEĞER :
");
scanf("%d",&p);
printf("2.DEĞER :
");
scanf("%d",&q);
kalan=1;
while(kalan!=0)
{
kalan=p%q;
printf("kalan %d p=%d q=%d \n",kalan,p,q);
if (kalan==0)
{
printf("obeb =%d\n",q);
getch();
exit();
}
p=q;
q=kalan;
}
}
Örnek-7
/*****************************************************/
/* Kendi kendini çağıran fonksiyon yöntemi ile
*/
/* verilen iki pozitif tamsayının ortak bölenlerinin */
/* en büyüğünü bulan program (p>q Euclid Algoritması */
/*****************************************************/
# include <stdio.h>
int obeb (int p, int q )
{
int r ;
if ((r=p%q ) ==0)
return q;
else
return obeb (q,r);
}
main()
{
int a;
67
int p,q;
printf("1.DEĞER :
scanf("%d",&p);
printf("2.DEĞER :
scanf("%d",&q);
a= obeb (p,q);
printf("OBEB DEĞERİ :
getch();
}
");
");
%d\n",a);
/* örnek-8 */
/*********************************************************************/
/* Verilen bir sayıya kadarki çift sayıların çarpımını veren program */
/*********************************************************************/
#include<stdio.h>
main()
{
int i,sayi;
long float carpim;
clrscr();
printf(" LÜTFEN BİR SAYI GİRİNİZ = ");
scanf("%d",&sayi);
if (sayi>=2)
{
carpim=2;
for(i=4;i<=sayi-1;i=i+2)
carpim=carpim*i;
printf(" SONUÇ = %lf ",carpim);
}
else
printf(" SONUC = 0 ");
getch();
}
/* örnek-9 */
/************************************************************/
/* verilen sayıya kadar olan sayılarım çarpımının bulunması */
/* fonksiyon kullanımına örnek
*/
/************************************************************/
#include <stdio.h>
double ciftcarp(sayi)
int sayi;
{
int i;
double c=1.0;
for (i=1;i<sayi/2;i++)
c=c*i*2;
return c;
}
main()
{
int x;
clrscr();
printf("Sayıyı giriniz..:");
scanf("%d",&x);
printf("(0 - %d) arasındaki çift sayıların çarpımı %.0f\n",x,ciftcarp(x));
getch();
}
68
/* örnek-10 */
/*********************************************************************/
/* Verilen bir sayının asal olup olmadığını bulan program.
*/
/* Verilen sayının kendisinin yarısına kadar olan sayılardan birine */
/* tam olarak bölünüp bölünmediği araştırılır, eğer bölünüyorsa sayı */
/* asal değildir.
*/
/*********************************************************************/
#include<stdio.h>
main()
{
int i;
int k;
long int n;
clrscr();
printf(" SAYIYI GİRİNİZ = ");
scanf("%ld",&n);
k=0;
for(i=2;i<=n/2;i++)
{
if(n%i==0)
/* sayının tam olarak bölünüp bölünmediği kontrol */
k=k+1;
/* ediliyor. Bölünüyorsa k değişkeninin değeri
*/
}
/* 1 arttırılıyor.
*/
if(k>0)
printf(" BU SAYI ASAL DEĞİL\n ");
if(k==0)
printf(" BU SAYI ASAL\n ");
getch();
}
/* örnek-11 */
/*********************************************************/
/* Verilen x için exp(x) değerini, exp(x) fonksiyonunun */
/* Maclaurin serisine açılımında ilk 20 terimin
*/
/* alınarak hesaplanması, fonksiyon kullanımı örneği
*/
/*********************************************************/
#include <stdio.h>
double us(sayi,ust)
float sayi;
int ust;
{
int i;
double c=1.0;
for (i=1;i<ust+1;i++)
c=c*sayi;
return c;
}
double fakt(sayi)
int sayi;
{
int i;
double fak=1.0;
for (i=1;i<sayi+1;i++)
fak=fak*i;
return fak;
}
double expu(x)
69
float x;
{
int i;
double e=0.0;
for (i=0;i<51;i++)
e=e+us(x,i)/fakt(i);
printf("\n");
return e;
}
main()
{
float i;
printf("Bir say gir");
scanf("%f",&i);
clrscr();
printf("exp(%.6f)=%.20f\n",i,expu(i));
getch();
}
/* örnek-12 */
/*********************************************************/
/* Verilen x için exp(x) değerini, exp(x) fonksiyonunun */
/* Maclaurin serisine açılımında ilk 20 terimin
*/
/* alınarak hesaplanması
*/
/*********************************************************/
#include <math.h>
#include <stdio.h>
main()
{
int i;
double fakt=1.0, e=1.0;
float x;
clrscr();
printf("exp(x) değeri hesaplanacak sayıyı giriniz= ");
scanf("%f",&x);
printf("girilen değer=%f\n",x);
clrscr();
for (i=1;i<=20;i++)
{
fakt=fakt*i;
e=e+pow(x,i)/fakt;
printf("%d.adim exp(%.2f)=%.30f\n",i,x,e);
}
getch();
}
/* örnek-13 */
/********************************************************/
/* Verilen bir sayının faktoriyelini hesaplayan program */
/********************************************************/
#include<stdio.h>
main()
{
int sayi,i;
long float fak;
clrscr();
printf(" SAYIYI GİRİNİZ = ");
scanf("%d",&sayi);
70
fak=1;
for(i=1;i<=sayi;i++)
fak=fak*i;
printf(" SAYININ FAKTORİYEL DEĞERİ = %lf ",fak);
getch();
}
/* örnek-14 */
/****************************************************************/
/* 1 den 100'e kadar olan sayıların faktoriyelinin hesaplanması */
/* ekrana 15 satır yazdırılıyor, daha sonra bir
*/
/* tuşa basıncaya kadar bekletiliyor
*/
/****************************************************************/
#include<stdio.h>
main()
{
int sayi,satir;
double fakt;
fakt=1;
satır=0;
clrscr();
for (sayi=1;sayi<101;sayi++)
{
fakt=fakt*sayi;
printf(" %d faktoriyel %f \n",sayi,fakt);
satir++;
if (satir>15)
{
satir=1;
getch();
clrscr();
}
}
getch();
}
Örnek-15
/*************************************************************/
/* arctan(1) fonksiyonunun Maclaurin serisine açılımında ilk */
/* 100 terimin hesaplanması ve çıkan sonucun 4 ile çarpımı
*/
/* bulduğunuz sonucu pi değeri ile karşılaştırınız
*/
/*************************************************************/
#include<stdio.h>
#include<math.h>
main()
{
double toplam;
int i,n,isaret;
double y,x;
toplam=0;
n=2000;
x=-1;
clrscr();
for(i=1;i<=n;i++)
{
x=-1*x;
y=2*i-1;
71
toplam=toplam+x/y;
}
printf("\n arctan(1)= %f",4*toplam);
getch();
}
Örnek-16
/*******************************************************/
/* satrancta at larin rasgele hareketi nin simulasyonu*/
/* Mart 2001
*/
/*******************************************************/
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>
#include<graphics.h>
int tahtaciz(tahta1)
int tahta1[9][9];
{
int i,j,tahta[9][9];
for(j=1;j<=8;j++)
for(i=1;i<=8;i++)
{
gotoxy(j+30,i+10);printf("%1d",tahta1[i][j]);
}
printf("\n\n");
/* getch();*/
}
int yonbul(x)
int x;
{
return random(x)+1;
}
main()
{
int i,j,bi,bj,si,sj,yon,b1i,b1j,s1i,s1j,x,y;
int tahta[9][9];
int graphdriver=DETECT,graphmode;
initgraph(&graphdriver,&graphmode,"");
setbkcolor(4);
setcolor(13);
settextstyle (DEFAULT_FONT,HORIZ_DIR,4);
outtextxy(100,10,"AT SiMULASYONU");
setcolor(12);
setlinestyle(0,0,3);
x=getmaxx(); y=getmaxy();
rectangle(0,0,x,y);
getch();
/*clrscr();*/
for(i=1;i<=8;i++)
{
for(j=1;j<=8;j++)
tahta[i][j]=0;
}
tahtaciz(tahta);
randomize();
do
{
72
bi=yonbul(8);
bj=yonbul(8);
si=yonbul(8);
sj=yonbul(8);
gotoxy(10,23);
printf("baslangi‡ yerleri= bi:%d bj:%d si:%d sj:%d",bi,bj,si,sj);
} while(bi-si+bj-sj==!0);
tahta[bi][bj]=1;
tahta[si][sj]=2;
tahtaciz(tahta);
for(i=1;i<=500;i++)
{
do {
yon=yonbul(8);
switch(yon) {
case 1 : b1i=bi-2; b1j=bj+1;break;
case 2 : b1i=bi-1; b1j=bj+2;break;
case 3 : b1i=bi+1; b1j=bj+2;break;
case 4 : b1i=bi+2; b1j=bj+1;break;
case 5 : b1i=bi+2; b1j=bj-1;break;
case 6 : b1i=bi+1; b1j=bj-2;break;
case 7 : b1i=bi-1; b1j=bj-2;break;
case 8 : b1i=bi-2; b1j=bj-1;break;
}
} while(b1i>=8||b1i<1||b1j>=8||b1j<1);
gotoxy(10,22);
printf("degiŸti= bi:%d bj:%d si:%d sj:%d",bi,bj,si,sj);
if(tahta[b1i][b1j]==2)
{
gotoxy(10,21);
printf(".......beyaz at kazandi ........%d .adim",i);
getch();
exit(1);
}
tahta[bi][bj]=0;
tahta[b1i][b1j]=1;
tahtaciz(tahta);
bi=b1i;bj=b1j;
do {
yon=yonbul(8);
switch(yon) {
case 1 : s1i=si-2; s1j=sj+1;break;
case 2 : s1i=si-1; s1j=sj+2;break;
case 3 : s1i=si+1; s1j=sj+2;break;
case 4 : s1i=si+2; s1j=sj+1;break;
case 5 : s1i=si+2; s1j=sj-1;break;
case 6 : s1i=si+1; s1j=sj-2;break;
case 7 : s1i=si-1; s1j=sj-2;break;
case 8 : s1i=si-2; s1j=sj-1;break;
}
} while(s1i>=8||s1i<1||s1j>=8||s1j<1);
gotoxy(10,22);
printf("degisti= bi:%d bj:%d si:%d sj:%d",bi,bj,si,sj);
if(tahta[s1i][s1j]==1)
{
gotoxy(10,21);
printf(".......siyah at kazandi ........%d .adim=",i);
getch();
exit(1);
}
tahta[si][sj]=0;
73
tahta[s1i][s1j]=2;
tahtaciz(tahta);
si=s1i;sj=s1j;
}
}
Örnek-17
/************************************************/
/* Levent Özbek
/* bu progam matrisler üzerinde işlemleri görmek*/
/* amacıyla yapılmıştır
*/
/************************************************/
#include <stdio.h>
main()
{
int i,j,n;
float ma[11][11];
float x, iza, tersiz, maxa, mina, satir[10],sutun[10], maxb, minb;
clrscr();
printf("boyut=");scanf("%d",&n);
printf("girilen boyut=%d \n",n);
for (i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
ma[i][j]=0;
}
}
printf("...matrisi satr satr giriniz ....\n");
for (i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
scanf("%f",&x);
ma[i][j]=x;
}
}
for (i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
printf("%5f ",ma[i][j]);
}
printf("\n");
}
getch();
printf("satr toplamlar....\n");
for (i=1;i<=n;i++)
{
satir[i]=0;
for (j=1;j<=n;j++)
{
satir[i]=satir[i]+ma[i][j];
}
printf("%d .satır =%5f
\n",i,satir[i]);
}
74
getch();
printf("sutun toplamları....\n");
for (i=1;i<=n;i++)
{
sutun[i]=0;
for (j=1;j<=n;j++)
{
sutun[i]=sutun[i]+ma[j][i];
}
printf("%d .sutun =%5f
\n",i,sutun[i]);
}
getch();
}
Örnek-18
/*******************************************************/
/ Matris çarpımı
*/
/*******************************************************/
#include<stdio.h>
main()
{
/*matris carpimi*/
int a[100][100],b[100][100],c[100][100];
int i,j,k,n,m,l;
clrscr();
printf("a ve b matrislerini girin.. \n");
printf("a(n x m) \n");
printf("n=");
scanf("%d",&n);
printf("m=");
scanf("%d",&m);
printf("b(m x k) \n");
printf("k=");
scanf("%d",&k);
/* matrislerin okunmasi*/
printf("a matrisi \n");
for(i=1;i<n+1;i++)
for(j=1;j<m+1;j++)
scanf("%d",&a[i][j]);
printf("b matrisi \n");
for(j=1;j<m+1;j++)
for(l=1;l<k+1;l++)
scanf("%d",&b[j][l]);
/* matrislerin carpimi */
for(i=1;i<n+1;i++)
for(j=1;j<m+1;j++)
for(l=1;l<k+1;l++)
c[i][j]=c[i][j]+a[i][l]*b[l][j];
/* yazdirma*/
printf("carpim matrisi \n");
for(i=1;i<n+1;i++)
for(j=1;j<k+1;j++)
printf("%d \n",c[i][j]);
getch();
}
75
Örnek-19
#include<stdio.h>
/***********************************************************************/
/* matrislerin toplami max min toplami max-min satir top min olan sutun*/
/***********************************************************************/
main()
{
int n;
int ma[100][100],mb[100][100],mc[100][100];
int i,j,k,s;
int maxa,maxb,mina,minb,satir[100],sutun[100];
int iza[100][100],izb[100][100],a[100],b[100];
clrscr();
printf("n= ");
scanf("%d",&n);
for (i=1;i<n+1;i++)
for (j=1;j<n+1;j++)
ma[i][j]=0;
mb[i][j]=0;
mc[i][j]=0;
printf("A matrisi (nxn) \n");
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
scanf("%d",&ma[i][j]);
printf("B matrisi (nxn) \n");
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
scanf("%d",&mb[i][j]);
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
mc[i][j]=ma[i][j]+mb[i][j];
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
printf("%d ",mc[i][j]);
printf(" \n ");
/* max - min bulma */
maxa=ma[1][1];mina=ma[1][1];
maxb=mb[1][1];minb=mb[1][1];
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
{if (maxa<ma[i][j]) maxa=ma[i][j];
if (maxb<mb[i][j]) maxb=mb[i][j];
if (mina>ma[i][j]) minb=ma[i][j];
if (minb>mb[i][j]) minb=mb[i][j];}
printf("a matrisinin en buyuk degeri=
printf("b matrisinin en buyuk degeri=
printf("a matrisinin en kucuk degeri=
printf("b matrisinin en kucuk degeri=
/* satir ve sutunda max min */
for(i=1;i<100;i++)
{satir[i]=0;sutun[i]=0; }
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
{ satir[i]=satir[i]+ma[i][j];
sutun[i]=sutun[i]+mb[j][i];}
maxa=0;minb=0;
maxa=satir[1];minb=sutun[1];
%d
%d
%d
%d
\n",maxa);
\n",maxb);
\n",mina);
\n",minb);
76
for (i=1;i<n+1;i++)
{ if(maxa<satir[i]) maxa=satir[i];
if(minb>sutun[i]) minb=sutun[i];}
printf("toplami max olan a matrisi satiri= %d \n",maxa);
printf("toplami min olan b matrisi sutunu= %d \n",minb);
/* a ve b matirisinin kosegenleri */
s=0;k=0;
for(i=1;i<n+1;i++)
{a[i]=ma[i][i];
b[i]=mb[i][i];}
printf("a matrisi kosegenleri \n");
for(i=1;i<n+1;i++)
{ k=k+a[i];
printf("%d \n",a[i]);}
printf("kosegen toplami= %d \n",k);
printf("b matrisi kosegenleri \n");
for (i=1;i<n+1;i++)
{ s=s+b[i];
printf("%d \n",b[i]); }
printf("kosegen toplami= %d \n",s);
/* matrisin transpozu*/
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
{ iza[j][i]=ma[i][j];
izb[j][i]=mb[i][j]; }
printf("a nin izi \n");
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
printf(" %d ",iza[i][j]);
printf("\n");
printf("b nin izi: \n");
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
printf(" %d ",izb[i][j]);
getch();
}
Örnek-20
/********************************************/
/* Betimsel istatistikler
*/
/********************************************/
#include<stdio.h>
#include<math.h>
# define boyut 1000
main()
{
int t,a,n,i,j;
int dizi[boyut], max,min,gen;
double var,ort,ss,med;
int vr;
clrscr();
printf("dizi kac elemanli = ");
scanf("%d",&n);
printf("elemanlari girin \n ");
for (i=1;i<n+1;i++)
{ printf(" %d",i);printf(".eleman=");
scanf("%d",&dizi[i]);}
77
/* siralama */
for(i=1;i<n;i++)
for(j=i+1;j<n+1;j++)
if (dizi[i]>dizi[j])
{ a=dizi[i];
dizi[i]=dizi[j];
dizi[j]=a;
}
printf("SIRALI HALi.. ");
for(i=1;i<n+1;i++)
printf("%d ",dizi[i]);
printf("\n");
/* max min */
max=dizi[n];min=dizi[1];gen=max-min;
printf("maximum= %d \n",max);
printf("minimum= %d \n",min);
printf("orneklem genisligi= %d \n",gen);
/* ortalama s.sapma varyans*/
t=vr=0;ort=var=ss=0;
for(i=1;i<n+1;i++)
t=t+dizi[i];
ort=t/n;
for(i=1;i<n+1;i++)
vr=vr+pow((dizi[i]-ort),2);
var=vr/(n-1);
ss=sqrt(var);
printf("ortalama %f \n",ort);
printf("varyans %f \n",var);
printf("s.sapma %f \n",ss);
printf("ortanca ");
if (pow(-1,n)<0) med=dizi[(n+1)/2];
else med=(dizi[n/2]+dizi[n/2+1])/2;
printf("%f \n",med);
getch();
}
ornek-21
/* U(a,b) den sayı üretme ve betimsel istatistikler */
# include <stdio.h>
# include <math.h>
# include <time.h>
# include <stdlib.h>
/* sayı üretme */
float duzgun(float a, float b)
{
double uret;
uret=a+(b-a)*rand()*1.0/32767.0;
return(uret);
}
/* ortalama bulma */
float ortbul(dizi,boyut)
float dizi[];
int boyut;
{
double top=0.0;
int i;
78
for (i=0;i<boyut;i++)
{
top=top+dizi[i];
}
top=top/boyut;
return(top);
}
/* en küçük bulma */
float minbul(dizi,boyut)
float dizi[];
int boyut;
{
double min;
int i;
min=dizi[0];
for (i=0;i<boyut;i++)
{
if (dizi[i]<min)
min=dizi[i];
}
return(min);
}
/* en büyük bulma */
float maxbul(dizi,boyut)
float dizi[];
int boyut;
{
double max;
int i;
max=dizi[0];
for (i=0;i<boyut;i++)
{
if (dizi[i]>max)
max=dizi[i];
}
return(max);
}
/* varyans bulma */
float varbul(dizi,boyut,orta)
float dizi[], orta;
int boyut;
{
double top;
int i;
top=0.0;
for (i=0;i<boyut;i++)
{
top=top+(dizi[i]-orta)*(dizi[i]-orta);
}
top=top/(boyut-1);
return(top);
}
/* ana program */
main()
{
int n, i, sayi;
float dizi[15000];
79
float a1,b1,min1,max1;
double ort, ovar, ssapma;
clrscr();
randomize();
printf("U(a,b) den sayı üretme ve betimsel istatistikler \n\n");
printf("a=");scanf("%f",&a1);
printf("b=");scanf("%f",&b1);
printf("kaç adet sayı üretilecek (<15000 olmalı)=");scanf("%d",&n);
if ( n>15000)
{
printf("girdiğiniz sayı 15000 den büyük\n");
printf("program sonlandırıldı\n");
getch();
exit(1);
}
printf("a= %f b=%f boyut=%d", a1,b1,n);
getch();
for (i=0;i<n;i++)
{
dizi[i]=duzgun(a1,b1);
}
/*for (i=0;i<n;i++)
{
printf("%d . eleman %5f \n", i,dizi[i]);
}*/
getch();
min1=minbul(dizi,n);
max1=maxbul(dizi,n);
ort=ortbul(dizi,n);
ovar=varbul(dizi,n,ort);
printf("en küçük =%f\n",min1);
printf("en büyük =%f\n",max1);
printf("ortalama =%f\n",ort);
printf("orneklem varyansı =%f\n",ovar);
getch();
}
ornek-22
# include<stdio.h>
# include <string.h>
main ()
{
char ad1[15],m[15];
char a[15],b[15],c[15];
int i,n,k;
clrscr();
strcpy (ad1,"Duygu savasci");
n=strlen(ad1);
printf("uzunluk=%d\n",n);
printf(" isim= %s\n",ad1);
for (i=0;i<n;i++)
{
printf("%d=
}
%c = \n",i,ad1[i]);
80
strlwr(ad1);
printf("isim= %s\n",ad1);
strncpy(m,ad1,15);
strupr(m);
printf(" isim= %s\n",m);
strcpy(a,"ahmet");
strcpy(b,"zahmet");
k= strcmp(a,b);
printf("k=%d \n",k);
if(k==0)
printf("a b'ye eşittir\n");
if (k>0)
printf("a b den buyuktur\n");
if(k<0)
printf("a b den kucuktur\n");
strncpy(c,ad1,7);
printf("c=%s\n",c);
getch();
}
81
14. Bölüm
Genel Örnekler – Sayısal Çözümleme
Bazı Ödev Sorularının Çözümü
#include<stdio.h> /* Verilen bir sayının asal olup olmadığını veren program */
main()
{
int i;
int k;
long int n;
clrscr();
printf(" SAYIYI GIRINIZ = ");
scanf("%ld",&n);
k=0;
{
for(i=2;i<=n/2;i++)
if(n%i==0)
k=k+1;
}
if(k>0)
printf(" BU SAYI ASAL DEĞİL\n ");
if(k==0)
printf(" BU SAYI ASAL\n ");
getch();
82
}
# include <graphics.h>
# include <stdio.h>
# include <math.h>
# include <dos.h>
main ()
{
double yy;
int y,artim,j,i,x;
double a[21] [21];
void gotoxy(int a, int b);
int graphdriver=DETECT,graphmode;
initgraph(&graphdriver,&graphmode,"");
setbkcolor(0);
settextstyle(1,0,5);
outtextxy(1,1,"GRAFIK PROGRAMI");
{
for (j=-10;j<10;j++)
{
for (i=-10;i<10;i++)
{
yy=200+sin(j)*cos(i)*12;
83
a [j+11] [i+11]=yy;
}
}
}
{
setcolor(2);
for (j=1;j<20;j++)
{
for (i=1;i<20;i++)
{
artim=a[i][j];
x=(i*10)+50+(j*5);
y=(j*4)+30+artim/1.1;
if (i==1)
{
moveto(x,y);
line(x,y,x,y);
}
else
lineto(x,y);
}
}
}
{
84
setcolor(4);
for (i=1;i<20;i++)
{
for (j=1;j<20;j++)
{
artim=a[i][j];
x=(i*10)+50+(j*5);
y=(j*4)+30+artim/1.1;
if (j==1)
{
moveto(x,y);
line(x,y,x,y);
}
else
lineto(x,y);
}
}
}
getch();cleardevice();
closegraph();
}
85
#include<stdio.h> /* ((2*2*4*4*...)/(3*3*5*5*...))*4 in yaklaşık değerini bulan program */
main()
{
int i;
long float ck,ust,tc,alt;
long float s;
alt=1;
ust=1;
ck=1;
tc=1;
clrscr();
for(i=1;i<40;i++)
{
ck=ck*2*i;
tc=tc*(2*i+1);
ust=ck*ck;
alt=tc*tc;
}
s=ust/alt*4;
printf("SONUC=%lf",s);
getch();
}
86
CHIO YONTEMI
Bu yontem bir matrisin determinant ozlelliklerini kullanarak bir seri işlem
sonucu matrisin boyutunu 2x2 tipinde bir matris olacak sekilde küçültür.
#include<stdio.h>
#include<math.h>
#include<conio.h>
#include<graphics.h>
main()
{
double det;
float a[10][10],b[10][10],p;
int sat,sut,k=0,n=0,kp=0,tek=0;
textmode(3);textcolor(14);textbackground(1);
clrscr();
printf("MATRISIN BOYUTUNU GIRINIZ n=");
scanf("%d",&n);
for(sat=1;sat<=n;sat++)
for(sut=1;sut<=n;sut++) a[sat][sut]=0;
printf("Matrisi giriniz\n");
for(sat=1;sat<=n;sat++)
for(sut=1;sut<=n;sut++)
{
printf("a[%d][%d]=",sat,sut);
87
scanf("%f",&a[sat][sut]);
}
clrscr();
gotoxy(24,1);printf("CHIO YONTEMI ILE DETERMINANT BULMA");
gotoxy(5,9);printf("GIRILEN MATRIS:");
for(sat=1;sat<=n;sat++)
{
for(sut=1;sut<=n;sut++)
{
gotoxy(sut*9+20,sat+10);printf("%4.2f",a[sat][sut]);
}
printf("\n");
}
getch();
/*-------------------------------------------*/
det=1.0;
tek=n-2;
for(k=1;k<=tek;k++)
{
kp=n-k;
det=det/pow(a[1][1],(n-k-1));
for(sat=1;sat<=kp;sat++)
for(sut=1;sut<=kp;sut++)
{
88
b[sat][sut]=a[1][1]*a[sat+1][sut+1]-a[1][sut+1]*a[sat+1][1];
}
for(sat=1;sat<=kp;sat++)
for(sut=1;sut<=kp;sut++)
{
a[sat][sut]=b[sat][sut];
}
}
det=det*(a[1][1]*a[2][2]-a[1][2]*a[2][1]);
(n==1)?printf("det=%f",a[1][1]):printf(" DETERMINANT=%-6.3f",det);
getch();
}
89
#include<stdio.h> /* Verilen bir sayıya kadarki çift sayıların çarpımını veren program */
main()
{
int i,n;
long float c;
clrscr();
printf(" LUTFEN BIR SAYI GIRINIZ = ");
scanf("%d",&n);
if (n>=2)
{
c=2;
{
for(i=4;i<=n-1;i=i+2)
c=c*i;
}
printf(" SONUC = %lf ",c);
}
else
printf(" SONUC = 0 ");
getch();
}
90
#include<stdio.h>
#include<conio.h>
float a[30][30];
float p,det;
int n,i,j,k;
main(void)
{
clrscr();
printf("Determinantı Hesaplanacak Kare Matris Boyutu (nxn n değeri) :");
fflush(stdin);scanf("%2d",&n);
printf("\n%d X %d Kare Matris n De§er Giriniz...\n\n\r",n,n);
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
printf("Matrisin %d,%d indisindeki de§er :",i,j);
fflush(stdin);scanf("%2f",&a[i][j]);puts("");
}
clrscr();
printf("\n%d X %d Kare Matrisin Girilen De§erleri...\n",n,n);
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++) printf(" %f",a[i][j]);
puts("");
}
91
for(k=1;k<=n-1;k++)
for(i=k+1;i<=n;i++)
{
p=a[i][k]/a[k][k];
for(j=k+1;j<=n;j++) a[i][j]-= p * a[k][j];
}
det=1.;
for(i=1;i<=n;i++) det*=a[i][i];
printf("DETERMİNANT = %f",det);
getch();
return 0;
}
92
#include<stdio.h>
#include<conio.h>
float a[30][30];
float p,det;
int n,i,j,k;
main(void)
{
clrscr();
printf("Evriğ (tersi) Hesaplanacak Kare Matris Boyutu (nxn n değeri) :");
fflush(stdin);scanf("%2d",&n);
printf("\n%d X %d Kare Matris n‡in Değer Giriniz...\n\n\r",n,n);
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
printf("Matrisin %d,%d indisindeki de§er :",i,j);
fflush(stdin);scanf("%2f",&a[i][j]);puts("");
}
clrscr();
printf("\n%d X %d Kare Matrisin Girilen De§erleri...\n",n,n);
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++) printf(" %f",a[i][j]);
puts("");
}
93
for(k=1;k<=n;k++)
{
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
if(i!=k||j!=k) a[i][j]-= a[i][k]*a[k][j]/a[k][k];
}
a[k][k]=-1.0/a[k][k];
for(i=1;i<=n;i++) if(i!=k) a[i][k]*=a[k][k];
for(j=1;j<=n;j++) if(j!=k) a[k][j]*=a[k][k];
}
for(i=1;i<=n;i++)
for(j=1;j<=n;j++) a[i][j]=-a[i][j];
printf("\n%d X %d Kare Matrisin Evri§i..:\n",n,n);
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++) printf(" %f",a[i][j]);
puts("");
}
getch();
return 0;
}
94
#include <stdio.h> /* e nin üssünü bulan program */
double us(sayi,ust)
float sayi;
int ust;
{
int i;
double c=1.0;
for (i=1;i<ust+1;i++)
c=c*sayi;
return c;
}
double fakt(sayi)
int sayi;
{
int i;
double fak=1.0;
for (i=1;i<sayi+1;i++)
fak=fak*i;
return fak;
}
double expu(x)
float x;
{
int i;
95
double e=0.0;
for (i=0;i<51;i++)
e=e+us(x,i)/fakt(i);
printf("\n");
return e;
}
main()
{
float i;
printf("Bir say gir");
scanf("%f",&i);
clrscr();
printf("exp(%.6f)=%.20f\n",i,expu(i));
getch();
}
96
#include<stdio.h>
#include<graphics.h>
main()
{
double det=1.0;
float a[10][10],p,b,buf;
int i,k,l,m,n,h=0,j,kp,nm,c;
int graphdriver=DETECT,graphmode;
initgraph(&graphdriver,&graphmode,"");
setbkcolor(1);
setcolor(14);
settextstyle (GOTHIC_FONT,HORIZ_DIR,5);
outtextxy(150,20,"Gauss Yontemi ile Determinant Bulma");
setcolor(11);setfillstyle(1,1);
setlinestyle(0,0,3);
gotoxy(1,3);
printf(" Gauss yönteminde determinantı bulunacak matris, bir üst üçgen matris biçimine
dönüştürülür");
printf(" Daha sonra bu matrisin köşegen elemanları çarpımı determinantı verir.\n");
printf(" Ornegin 4x4 tipindeki matrisin nasıl üst üçgensel matris haline dönüşür
bulalım.\n\n");
printf("%c
%c\n",218,191);
printf("%c a[1][1] a[1][2] a[1][3] a[1][4] %c",179,179);printf(" (2. satır)-( a[2][1]/a[1][1]
)*(1. satır)\n");
97
printf("%c a[2][1] a[2][2] a[2][3] a[2][4] %c",179,179);printf(" (3. satır)-( a[3][1]/a[1][1]
)*(1. satr)\n");
printf("%c a[3][1] a[3][2] a[3][3] a[3][4] %c",179,179);printf(" (4. satır)-( a[4][1]/a[1][1]
)*(1. satır)\n");
printf("%c
%c\n",192,217);
printf("Islemlari uygulandıktan sonra matris:\n\n");
printf("%c
%c\n",218,191);
printf("%c a[1][1] a[1][2] a[1][3] a[1][4] %c\n",179,179);
printf("%c 0
b[2][2] b[2][3] b[2][4] %c",179,179);printf(" (3. satır)-( b[3][2]/b[2][2]
)*(2. satr)\n");
printf("%c 0
0
c[3][3] c[3][4] %c",179,179);printf(" (4. satır)-( b[4][2]/b[2][2] )*(2.
0
c[4][3] c[4][4] %c\n",179,179);
satır)\n");
printf("%c 0
printf("%c
%c\n\n",192,217);
printf(" daha sonra:\n\n");
printf("%c
%c\n",218,191);
printf("%c a[1][1] a[1][2] a[1][3] a[1][4] %c\n",179,179);
printf("%c 0
printf("%c 0
b[2][2] b[2][3] b[2][4] %c\n",179,179);
0
c[3][3] c[3][4] %c",179,179);printf(" (4. satır)-( c[4][3]/c[3][3] )*(3.
satır)\n");
printf("%c 0
printf("%c
0
0
d[4][4] %c\n",179,179);
%c\n",192,217);
98
printf("işlemleri yapılır. A matrisi: |A|=a[1][1]*b[2][2]*c[3][3]*d[4][4] olur.\n");
getch();
gotoxy(1,3);
bar(0,0,640,480);
settextstyle (DEFAULT_FONT,HORIZ_DIR,2);
outtextxy(50,10,"Gauss Yontemi ile Determinant Bulma");
settextstyle (SMALL_FONT,HORIZ_DIR,20);
outtextxy(20,40,"Yapılanları Sözlerle ifade etmek istersek; amacımız her seferinde 2.
satırdan");
outtextxy(5,60,"itibaren üst kosegen hale gelebilecek sekilde bazı satır ve sütunları 0 yap-");
outtextxy(5,80,"maktır. Örnekteki 4x4 Tipindeki Matrisde de önce 2. satır 1. sütun elemanı
0");
outtextxy(5,100,"olmalıdır. Bunun icin 2. satırdan, 1. satırın a[2][1]/a[1][1] katını çıkartma-");
outtextxy(5,120,"lıyız. Boylece 2. satırın ilk elemanı 0 olur. Ancak ikinci satırın diğer ele-");
outtextxy(5,140,"manları değisir. Aynı sekilde 3. satırdan, 1. satırın a[3][1]/a[1][1] katını,");
outtextxy(5,160,"4. satırdan da 1.satırın a[4][1]/a[1][1] katını cıkartmalıyız.");
outtextxy(20,180,"Böylece 1. satır elemaları önceki ile aynı fakat diğer elemanları farklı bir
");
outtextxy(5,200,"matris elde etmis oluruz. Bu farklı elemanları b[i][j] ile gösterelim.Bu mat");
outtextxy(5,220,"risin 1. sütunundaki 1 elemanı dısındaki bütün elemanları 0 olmustur.
Olusan ");
outtextxy(5,240,"bu yeni matriste 3. satırdan 2. satırın b[3][2]/b[2][2] katını cıkarırsak ve ");
outtextxy(5,260,"4. satırdan da 2. satırın b[4][2]/b[2][2] katını cıkarırsak 3.satırından sonra");
99
outtextxy(5,280,"c[i][j] elemanlı farklı bir matris elde etmis oluruz.");
outtextxy(20,300,"Bu yeni matrisin 2. sutunundaki son iki eleman da 0 olmus olur. Son olarak
bu ");
outtextxy(5,320,"yeni matrisin 4.saturundan 3. saturun c[4][3]/c[3][3] katunu cukarırsak üst
");
outtextxy(5,340,"kösegensel matris elde edilmis olur. Bu yeni matrisin kosegen elemanları
çarpımı");
outtextxy(5,360,"verilen matrisimizin determinantıınıı verir.");
getch();
bar(0,0,640,480);
outtextxy(150,20,"Gauss Yontemi ile Determinant Bulma");
gotoxy(10,4);printf("matrisin boyutunu giriniz n=");
scanf("%d",&n);
for(i=1;i<=n;i++)
for(j=1;j<=n;j++) a[i][j]=0;
gotoxy(5,7);
printf("Matrisin Elemanlarını Giriniz \n");
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{
h=h+1;
gotoxy(10,h+9);
printf("A[%d][%d]=",i,j);
scanf("%f",&b);
a[i][j]=b;
100
}
bar(0,0,640,480);
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
gotoxy(24+j*8,i+10);
printf(" %.2f",a[i][j]);
if(j==1&&i==1)
{
gotoxy(25+j*8,i+9);
printf("%c",218);
}
if(j==1)
{
gotoxy(25+j*8,i+10);
printf("%c",179);
}
if(j==1&&i==n)
{
gotoxy(25+j*8,i+11);
printf("%c",192);
}
101
if (j==n&&i==1)
{
gotoxy(30+j*8,i+9);
printf("%c",191);
}
if(j==n)
{
gotoxy(30+j*8,i+10);
printf("%c",179);
}
if (j==n&&i==n)
{
gotoxy(30+j*8,i+11);
printf("%c",217);
}
}
printf("\n");
}
getch();
/*----------------------------------------------*/
nm=n-1;
for(k=1;k<=nm;k++)
{
102
kp=k+1;
for(i=kp;i<=n;i++)
{
if(a[k][k]==0)
{
det*=-1;
for(m=0;m<=n;m++)
{
if(a[m][m]!=0)c=m;
}
for(m=0;m<=n;m++)
{
buf=a[c][m];
a[c][m]=a[k][m];
a[k][m]=buf;
}
}
p=a[i][k]/a[k][k];
for(j=kp;j<=n;j++)
{
a[i][j]=a[i][j]-(p*a[k][j]);
}
}
}
103
for(i=1;i<=n;i++) det=det*a[i][i];
if(det==-0.00)
{
det=0.00;
gotoxy(30,20);printf("Determinant= %.2f",det);
}
else
{
gotoxy(30,17);printf("Determinant= %.2f",det);
}
getch();
}
104
#include<stdio.h>
#include<math.h>
#include <conio.h>
#include <stdlib.h>
#include <graphics.h>
int e=2.71182818;
char *dizi[14];
void aktar(void)
{
int sayac;
int graphdriver=DETECT,graphmode;
initgraph(&graphdriver,&graphmode,"");
setbkcolor(1);
setcolor(14);
settextstyle (GOTHIC_FONT,HORIZ_DIR,1);
setcolor(11);
setlinestyle(0,0,3);
settextstyle(DEFAULT_FONT,HORIZ_DIR,2);
outtextxy(250,15,"SORULAR");
line(0,50,700,50);
settextstyle(SMALL_FONT,HORIZ_DIR,7);
dizi[1]="
X-SIN(X)-1=0 ";
dizi[2]="
X-e^(-X)=0
dizi[3]="
X^3+10X-11.6=0
";
";
105
dizi[4]="
X*e^X-1=0
";
dizi[5]="
X^3-100=0
";
dizi[6]="
e^X-3*X=0
";
dizi[7]="
X*TAN(X)-0.5=0
dizi[8]="
COS(X)=3*X
dizi[9]="
X^3-3X+1=1 ; Xo=1.5 ";
dizi[10]=" e^X-LN(X)=20
";
";
";
dizi[11]=" e^X=(2*X)+21 ; Xo=3 ";
dizi[12]="
LN(X)=1+1/(X^2)
";
{
settextstyle(SMALL_FONT,HORIZ_DIR,1);
setcolor(1);
for (sayac=1;sayac<13;sayac++)
{
gotoxy(30,4+sayac);printf("%d",sayac);printf(dizi[sayac]);
printf("\n");
}
}
}
/******************************************/
double fonk(double x,int fno)
{
double f1;
switch(fno)
106
{
case 1:{f1= x-sin(x)-1;break;}
case 2:{f1= x-pow(e,-1*x);break;}
case 3:{f1= pow(x,3)+10*x-11.6;break;}
case 4:{f1= x*pow(e,x)-1;break;}
case 5:{f1= pow(x,3)-100;break;}
case 6:{f1= pow(e,x)-3*x;break;}
case 7:{f1= x*tan(x)-0.5;break;}
case 8:{f1= cos(x)-3*x;break;}
case 9:{f1= pow(x,3)-3*x;break;}
case 10:{f1= pow(e,x)-log(x)-20;break;}
case 11:{f1= pow(e,x)-2*x-21;break;}
case 12:{f1= log(x)-1-1/pow(x,2);break;}
}
return f1;
}
/************************************/
double turev(double x,int fno)
{
double t1;
switch(fno)
{
case 1:{t1= 1-cos(x);break;}
107
case 2:{t1= 1+pow(e,-1*x);break;}
case 3:{t1= 3*pow(x,2)+10;break;}
case 4:{t1= pow(e,x)+x*pow(e,x);break;}
case 5:{t1= 3*pow(x,2);break;}
case 6:{t1= pow(e,x)-3;break;}
case 7:{t1= tan(x)+x*(1+pow(tan(x),2));break;}
case 8:{t1= -1*sin(x)-3;break;}
case 9:{t1= 3*pow(x,2)-3;break;}
case 10:{t1= pow(e,x)-1/x;break;}
case 11:{t1= pow(e,x)-2;break;}
case 12:{t1= 1/x+2/pow(x,3);break;}
}
return t1;
}
/************************************/
double ifonk(double x,int fno)
{
double f1;
switch(fno)
{
case 1:{f1= sin(x)+1;break;}
case 2:{f1= pow(e,-1*x);break;}
case 3:{f1= (11.6-pow(x,3))/10;break;}
case 4:{f1= pow(e,-1*x);break;}
108
case 5:{f1= 10/pow(x,0.5);break;}
case 6:{f1= log(3*x);break;}
case 7:{f1= atan(1/(2*x));break;}
case 8:{f1= cos(x)/3;break;}
case 9:{f1= pow(x,3)-3*x;break;}
case 10:{f1= log(log(x)+20);break;}
case 11:{f1= log(2*x+21);break;}
case 12:{f1= pow(e,1+1/(x*x));break;}
}
return f1;
}
/************************************/
void cevap(no,yontem)
int no,yontem;
{
int sayac;
float xx,x,x1,x2,eps;
printf("Xo 'i Giriniz..:");
scanf("%f",&xx);
printf("Epsilon'u Giriniz");
scanf("%f",&eps);
printf("\n");
if (yontem==1 && no!=10 && no!=12)
{
109
/***YARILAMA YONTEMI********/
sayac=1;
x1=-1*5;
x2=5;
x=(x1+x2)/2;
printf("Xo=%f\n",x);
while (-1*eps>=fonk(x,no) || fonk(x,no)>=eps)
{
if (fonk(x1,no)*fonk(x,no)<0) x2=x; else x1=x;
x=(x1+x2)/2;
printf("X%d=%f\n",sayac,x);
sayac++;
}
printf("\nE%d=%.6f\n",sayac-1,fonk(x,no));
}
if (yontem ==2 && no!=10 && no!=6 && no !=12)
{
/***REGULA FALSI YONTEMI****/
sayac=1;
x1=-1*10;
x2=5;
x=(x1+x2)/2;
110
printf("Xo=%f\n",x);
while (-1*eps>=fonk(x,no) || fonk(x,no)>=eps)
{
if (fonk(x1,no)*fonk(x,no)<0) x2=x; else x1=x;
x=(x1*fonk(x2,no)-x2*fonk(x1,no))/(fonk(x2,no)-fonk(x1,no));
printf("X%d=%f\n",sayac,x);
sayac++;
}
printf("\nE%d=%.6f\n",sayac-1,fonk(x,no));
}
if (yontem==3)
{
/*** NEWTON RAPSON YONTEMI***/
sayac=1;
x=xx;
printf("Xo= %f\n",x);
while (-1*eps>=fonk(x,no) || fonk(x,no)>=eps)
{
x=x-(fonk(x,no)/turev(x,no));
printf("X%d= %.6f\n",sayac,x);
x1=x;
}
printf("\nE%d=%.6f\n",sayac-1,ifonk(x,no));
111
}
if (yontem==4)
{
/***BASIT ITERASYON YONTEMI****/
sayac=1;
x=xx;
printf("Xo= %f\n",x);
while (-1*eps>=x-ifonk(x,no) || x-ifonk(x,no)>=eps)
{
x=fonk(x,no);
printf("X%d= %.6f\n",sayac,x);
}
printf("\nE%d=%.6f\n",sayac-1,x-ifonk(x,no));
}
}
/************************************/
main()
{
int s,y;
aktar();
gotoxy(45,40);printf("Secenek Gir..:");
scanf("%d",&s);
gotoxy(50,50);printf(" \n YONTEMLER \n");
112
gotoxy(50,51);printf("1 => YARILAMA\n");
gotoxy(50,52);printf("2 => REGULA FALSI\n");
gotoxy(50,53);printf("3 => NEWTON RAPSON\n");
gotoxy(50,54);printf("4 => BASIT ITERASYON\n\n");
gotoxy(50,55);printf("Secenek Giriniz..:");
scanf("%d",&y);
if (s>0 && s<14) cevap(s,y);
getch();
}
113
# include <stdio.h> /* Verilen iki sayının ortak bölenlerinin en büyüğünü bulan program */
int obeb (int p, int q )
{
int r ;
if ((r=p%q ) ==0)
return q;
else
return obeb (q,r);
}
main()
{
int a;
int p,q;
printf("1.DEGER :
");
scanf("%d",&p);
printf("2.DEGER :
");
scanf("%d",&q);
a= obeb (p,q);
printf("OBEB DEGERI : %d\n",a);
getch();
}
114
#include<stdio.h>
/* a++ ve ++a arasindaki fark */
main()
{ int a,c,b,d;
c=2;d=3;
clrscr();
for (a=1;a<11;)
printf("a= %d ",a++);
printf("\n a++ icin 1.dongu bitti \n\n ");
for (a=1;a<11;)
printf("a= %d ",++a);
printf(" \n ++a icin 2.dongu bitti \n\n");
b=c+++d;
printf("c=2 d=3 icin \n ");
printf("b=c+++d= %d \n\n",b);
b=(c++)+d;
printf(" b=(c++)+d= %d \n\n",b);
getch(); }
115
#include<stdio.h>
/* matrislerin toplami max min toplami max-min satir top min olan sutun*/
main()
{
int n;
int ma[100][100],mb[100][100],mc[100][100];
int i,j,k,s;
int maxa,maxb,mina,minb,satir[100],sutun[100];
int iza[100][100],izb[100][100],a[100],b[100];
clrscr();
printf("n= ");
scanf("%d",&n);
for (i=1;i<n+1;i++)
for (j=1;j<n+1;j++)
ma[i][j]=0;
mb[i][j]=0;
mc[i][j]=0;
printf("A matrisi (nxn) \n");
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
scanf("%d",&ma[i][j]);
printf("B matrisi (nxn) \n");
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
116
scanf("%d",&mb[i][j]);
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
mc[i][j]=ma[i][j]+mb[i][j];
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
printf("%d ",mc[i][j]);
printf(" \n ");
/* max - min bulma */
maxa=ma[1][1];mina=ma[1][1];
maxb=mb[1][1];minb=mb[1][1];
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
{if (maxa<ma[i][j]) maxa=ma[i][j];
if (maxb<mb[i][j]) maxb=mb[i][j];
if (mina>ma[i][j]) minb=ma[i][j];
if (minb>mb[i][j]) minb=mb[i][j];}
printf("a matrisinin en buyuk degeri= %d \n",maxa);
printf("b matrisinin en buyuk degeri= %d \n",maxb);
printf("a matrisinin en kucuk degeri= %d \n",mina);
printf("b matrisinin en kucuk degeri= %d \n",minb);
/* satir ve sutunda max min */
for(i=1;i<100;i++)
117
{satir[i]=0;sutun[i]=0; }
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
{ satir[i]=satir[i]+ma[i][j];
sutun[i]=sutun[i]+mb[j][i];}
maxa=0;minb=0;
maxa=satir[1];minb=sutun[1];
for (i=1;i<n+1;i++)
{ if(maxa<satir[i]) maxa=satir[i];
if(minb>sutun[i]) minb=sutun[i];}
printf("toplami max olan a matrisi satiri= %d \n",maxa);
printf("toplami min olan b matrisi sutunu= %d \n",minb);
/* a ve b matirisinin kosegenleri */
s=0;k=0;
for(i=1;i<n+1;i++)
{a[i]=ma[i][i];
b[i]=mb[i][i];}
printf("a matrisi kosegenleri \n");
for(i=1;i<n+1;i++)
{ k=k+a[i];
printf("%d \n",a[i]);}
printf("kosegen toplami= %d \n",k);
118
printf("b matrisi kosegenleri \n");
for (i=1;i<n+1;i++)
{ s=s+b[i];
printf("%d \n",b[i]); }
printf("kosegen toplami= %d \n",s);
/* matrisin transpozu*/
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
{ iza[j][i]=ma[i][j];
izb[j][i]=mb[i][j]; }
printf("a nin izi \n");
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
printf(" %d ",iza[i][j]);
printf("\n");
printf("b nin izi: \n");
for(i=1;i<n+1;i++)
for(j=1;j<n+1;j++)
printf(" %d ",izb[i][j]);
getch();
}
119
#include<stdio.h>
#include<math.h>
# define boyut 1000
main()
{
int t,a,n,i,j;
int dizi[boyut], max,min,gen;
double var,ort,ss,med;
int vr;
clrscr();
printf("dizi kac elemanli = ");
scanf("%d",&n);
printf("elemanlari girin \n ");
for (i=1;i<n+1;i++)
{ printf(" %d",i);printf(".eleman=");
scanf("%d",&dizi[i]);}
/* siralama */
for(i=1;i<n;i++)
for(j=i+1;j<n+1;j++)
if (dizi[i]>dizi[j])
{ a=dizi[i];
dizi[i]=dizi[j];
dizi[j]=a;
}
120
printf("SIRALI HALi.. ");
for(i=1;i<n+1;i++)
printf("%d ",dizi[i]);
printf("\n");
/* max min */
max=dizi[n];min=dizi[1];gen=max-min;
printf("maximum= %d \n",max);
printf("minimum= %d \n",min);
printf("orneklem genisligi= %d \n",gen);
/* ortalama s.sapma varyans*/
t=vr=0;ort=var=ss=0;
for(i=1;i<n+1;i++)
t=t+dizi[i];
ort=t/n;
for(i=1;i<n+1;i++)
vr=vr+pow((dizi[i]-ort),2);
var=vr/(n-1);
ss=sqrt(var);
printf("ortalama %f \n",ort);
printf("varyans %f \n",var);
printf("s.sapma %f \n",ss);
printf("ortanca ");
if (pow(-1,n)<0) med=dizi[(n+1)/2];
else med=(dizi[n/2]+dizi[n/2+1])/2;
121
printf("%f \n",med);
getch();
}
122
#include<stdio.h>
main()
{
/*matris carpimi*/
int a[2][2],b[2][2],c[2][2];
int i,j,k,n,m,l;
clrscr();
printf("a ve b matrislerini girin.. \n");
printf("a(n x m) \n");
printf("n=");
scanf("%d",&n);
printf("m=");
scanf("%d",&m);
printf("b(m x k) \n");
printf("k=");
scanf("%d",&k);
/* matrislerin okunmasi*/
printf("a matrisi \n");
for(i=1;i<n+1;i++)
for(j=1;j<m+1;j++)
scanf("%d",&a[i][j]);
printf("b matrisi \n");
for(j=1;j<m+1;j++)
for(l=1;l<k+1;l++)
123
scanf("%d",&b[j][l]);
/* matrislerin carpimi */
for(i=1;i<n+1;i++)
for(j=1;j<m+1;j++)
for(l=1;l<k+1;l++)
c[i][j]=c[i][j]+a[i][l]*b[l][j];
/* yazdirma*/
printf("carpim matrisi \n");
for(i=1;i<n+1;i++)
for(j=1;j<k+1;j++)
printf("%d \n",c[i][j]);
getch();
}
124
#include<stdio.h>
#include<math.h>
main()
{
/* a=2*(( 2^2*4^2*...60^2)/(3^2*5^2*...61^2))
int n;
double sonuc;
int x,y,a,b;
double alt,ust;
alt=1;
ust=1;
clrscr();
for(n=1;n<31;n++)
{ x=2*n;
y=2*n+1;
a=pow(x,2);
b=pow(y,2);
ust=ust*a;
alt=alt*b;
}
sonuc=ust/alt;
printf("\n A= %f",2*sonuc);
getch();
}
*/
125
#include<stdio.h>
#include<math.h>
double fonk(double x)
{ float c;
c=pow(x,3)+(10*x)-11.6;
return c; }
main()
{
int i;
float a,b,d,z,c;
clrscr();
printf("x^3+10x-11.6=0 \n");
printf("denklemi icin - ve + olacak sekilde \n");
printf("a ve b sayilarini girin \n");
printf("a=");
scanf("%f",&a);
printf("b=");
scanf("%f",&b);
for(i=1;i<101;i++)
{
d=(a+b)/2;
z=fonk(d);
if (z==0) goto sonuc;
{if (z<0) a=d;
126
else b=d;}
}
sonuc:
printf("kok %f dir",(a+b)/2);
getch();
}
127
#include<stdio.h>
#include<math.h>
main()
{
/* arctan(x) ilk 30 terim toplami */
double toplam;
int f,n;
double y,x;
clrscr();
for(n=1;n<31;n++)
{ x=pow(-1,n-1);
y=2*n-1;
toplam=toplam+x*(1/y);
}
printf("\n arctan(x)= %f",4*toplam);
getch();
}
128
#include<stdio.h>
#include<math.h>
/* regula falsi yontemi ile kok bulma */
double regula(double x)
{ double d;
d=pow(x,2)-8 ;
return d;
}
main()
{ int i,n;
float a,b,c,g;
float f,y,z;
clrscr();
printf(" x^2-8=0 denklemi icin \n");
printf("a= ");
scanf("%f",&a);
printf("b= ");
scanf("%f",&b);
/*printf("durdurma kurali icin epsilon=");scanf("%f",&f);*/
for (i=1;i<100;i++)
{
c=(regula(b)*a-regula(a)*b)/(regula(b)-regula(a));
129
y=regula(c);
if(y<0) a=c;
else b=c;
}
printf("kok %f dir",c);
getch();
}
130
#include<stdio.h>
#include<math.h>
double new(double t,double e)
{ double d;
d=pow(e,t)-3*t;
return d;
}
double newt(double t,double e)
{
double d;
d=pow(e,t)-3;
return d;
}
main()
{
/* newton raphson metodu ile kok bulma */
double f,n,w,toplam;
double j,c,a,e,x;
clrscr();
/* e sayisi bulunusu */
f=1;toplam=1;
131
for(n=1;n<31;n++)
{
f=f*n;
x=pow(f,-1);
toplam=toplam+x;
}
e=toplam;
printf("f(x)=e^x-3x icin fonksiyona baslangic degeri verin \n");
printf("a= ");
scanf("%f",&a);
for (n=1;n<101;n++)
{
c=a-(new(a,e)/newt(a,e));
a=c;
}
printf("\n kok %f dir \n",a);
getch();
}
132
#include<stdio.h>
#include<math.h>
double new(double x)
{ double d;
d=pow(x,3)-100;
return d;
}
double newt(x)
{ double z;
z=3*pow(x,2);
return z;
}
main()
{
/* newton raphson metodu ile kok bulma (2) */
double a,b,c,w;
/* clrscr();*/
printf("x^3-100=0 denkleminin koku icin \n");
printf("Baslangic degerini girin.. \n");
printf("a=");
scanf("%f",&a);
for(b=1;b<2;b++)
{
w=new(a)/newt(a);
133
c=a-w;
a=c;
}
printf("Kok %f dir",a);
getch();
}
YOK ETME YONTEMI
#include <stdio.h>
main()
{
double det=1.0;
float a[10][10],b,p;
int i,k,l,m,n,j,kp,nm,c,buf;
clrscr();
printf("matrisin boyutunu giriniz n=");
scanf("%d",&n);
for (i=1;i<=n;i++)
for (j=1;j<=n;j++)
a[i][j]=0;
for (i=1;i<=n;i++)
for (j=1;j<=n;j++)
{
printf("a[%d][%d]=",i,j);
134
scanf("%f",&b);
a[i][j]=b;
}
clrscr();
gotoxy(10,1);printf("GAUSS YONTEMI ILE DETERMINANT BULMA");
for (i=1;i<=n;i++)
{
for (j=1;j<=n;j++)
{
gotoxy(j*9+9,i+3);
printf(" %4.3f",a[i][j]);
}
printf("\n");
}
getch();
nm=n-1;
for (k=1;k<=nm;k++)
{
kp=k+1;
for (i=kp;i<=n;i++)
{
if(a[k][k]==0)
{
for (m=1;m<=n;m++)
135
if (a[m][m]!=0) c=m;
for(m=1;m<=n;m++)
{
buf=a[c][m];
a[c][m]=a[k][m];
a[k][m]=buf;
}
det=det*(-1);
}
p=a[i][k]/a[k][k];
for (j=kp;j<=n;j++)
{
a[i][j]=a[i][j]-(p*a[k][j]);
}
}
}
for (i=1;i<=n;i++)
det=det*a[i][i];
printf("\n"); printf("\n");
printf(" det=%.3f",det);getch();
}
136
#include <stdio.h>
#include <math.h>
float tam(sayi)
float sayi;
{
int i;
i=sayi;
return i+.0;
}
int asal(sayi)
int sayi;
{
int i,sonuc;
sonuc=1;
for (i=2;i<sayi/2+1;i++)
{
if (i>3) i++;
if ((sayi+.0)/i==tam((sayi+.0)/i))
{
sonuc=0;
i=sayi;
}
}
if (sayi==-1 ||sayi==0||sayi==1) sonuc=0;
137
return sonuc;
}
main()
{
int j;
clrscr();
printf("Asallığı arastırılan sayıyı giriniz..:");
scanf("%d",&j);
if (asal(j)==1) printf("%d Asal bir sayıdır");
else
printf("%d Asal bir sayı degildir");
getch();
}
138
#include <stdio.h>
#include<math.h>
double fakt(sayi)
int sayi;
{
int i;
double c=1.0;
for (i=2;i<sayi+1;i++)
c=c*i;
return c;
}
double us(double x,float y)
{
float i;
double u=1.;
for (i=2.;i<=y;i++)
u=u*x;
return u;
}
double fakto(float x,float tet)
{
double f,pi=3.141592654,e=2.71828182845904509;
f=pow(2*pi*x,.5)*pow(x,x)*pow(e,-1*x)*pow(e,tet/(12*(x+1)));
return f;
139
}
main()
{
int y;
double x,f,teta=1; /* teta 0-1 aralıgında olmalı*/
clrscr();
printf("Faktoriyeli alınacak Sayıyı giriniz.:");
scanf("%d",&y);
printf("%d nin Faktoriyeli %f dir\n",y,fakt(y));
printf("%d nin strling yaklasım Faktoriyeli %f dir teta=%f \n",y,fakto(y,teta),teta);
getch();
getch();
}
140
#include <stdio.h>
#include <math.h>
double tan_1(x)
float x;
{
int i;
double tan=0.0;
for (i=1;i<31;i++)
tan=tan+pow(-1.0,i-1)*pow(x,2*i-1)/(2*i-1);
return tan;
}
main()
{
float x;
clrscr();
printf("tan^-1 degeri bulunacak sayıyı giriniz..[-1,+1].:");
scanf("%f",&x);
printf("Yaklasık Tan^-1(%f) = %.20f\n",x,tan_1(x));
printf("Gercek ArcTan(%f) = %.20f\n",x,atan(x));
getch();
}
141
#include <stdio.h>
main()
{
int i,pay=2,payda=1;
double a=2.0;
clrscr();
for (i=1;i<=30;i++)
a=a*(4*i*i)/((2*i+1)*(2*i+1));
printf("a=((2*4*4*6*6*...)/(3*3*5*5*7*7*...))*4=%.20f",a);
getch();
}
142
# include <stdio.h>
# include <math.h>
# include <stdlib.h>
# include <time.h>
int dizi[53];
int sayi_cek()
{
int k,num;
k=((rand()+.0)/32767)*4+1;
num=((rand()+.0)/32767)*13+1;
return k*100+num;
}
void kar(void)
{
int i,j,sayi;
for (i=1;i<=52;i++)
{
sayi=sayi_cek();
for (j=1;j<i;j++)
if (sayi==dizi[j])
{
j=i;
i=i-1;
}
143
if (j<i+2)
{
dizi[i]=sayi;
}
}
}
main()
{
int i,s,t,x,y;
randomize();
clrscr();
kar();
x=5;
y=4;
for(i=1;i<=52;i++)
{
s=dizi[i];
t=s/100;
x=x+1;
if (x>18)
{
x=6;
y=y+20;
}
144
gotoxy(y,x);
switch(t)
{
case 1:printf("%d=> Maca ",i);break;
case 2:printf("%d=> Sinek ",i);break;
case 3:printf("%d=> Kupa ",i);break;
case 4:printf("%d=> Karo ",i);break;
}
if (s-t*100==1)
printf("As
}
getch();
}
"); else printf("%d
",s-t*100);
145
# include<stdio.h>
double fakt(sayi)
{
int i;
double fak=1.0;
for(i=1;i<=sayi;i++)
fak=fak*i;
return fak;
}
double us(sayi,ust)
float sayi;
int ust;
{
int i;
double c=1.0 ;
for(i=1;i<=ust;i++)
c*=sayi;
return c;
}
main()
{
long float z,x,e,f,g,h;
int a,d,k;
printf("x değerini giriniz\n");
146
scanf("%lf",&x);
for(a=1;a<=40;a++)
{
if((a-1)%2==0)
z+=(us(x,(2*a)-1))/fakt((2*a)-1);
else
z-=(us(x,(2*a)-1))/fakt((2*a)-1);
}
printf("%lf\n",z);
getch();
}
147
#include<stdio.h>
#include<math.h>
#include<conio.h>
main()
{
float x0,x,df[100][100],p,c=1,h,s;
int i,j,n;
clrscr();
printf("n=");scanf("%d",&n);
printf("x,x0,h :");scanf("%f,%f,%f",&x,&x0,&h);
s=(x-x0)/h;
printf("s=%f\n",s);
getch();
for(i=0;i<=n;i++)
{
printf("df[0][%d]=",i);scanf("%f",&df[0][i]);
}
for(i=1;i<=n;i++)
for(j=0;j<=n-i;j++)
{
df[i][j]=df[i-1][j+1]-df[i-1][j];
}
148
p=df[0][0];
for(i=0;i<=n-1;i++)
{
c*=(s-i)/(i+1);
p+=c*df[i+1][0];
}
for (i=1;i<=n;i++)
{
gotoxy(i*11+1,n+7); printf("df[%d]",i);
for (j=0;j<=n-i;j++)
{
gotoxy(i*11,n+8+j);printf("%f",df[i][j]);
}
}
gotoxy(1,2*n+10); printf("polinomun değeri:%f",p);
getch();
}
149
/*VEKTORLER ICIN BASIT ITERASYON YONTEMI*/
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define g1(a) (.5*cos(a))
#define g2(b) (.5*sin(b))
main()
{
float f1,f2,x0[3],x1[3],temp[3],eps;
int n=0,i;
clrscr();
for(i=1;i<=2;++i)
{
printf("x0(%d)=",i);scanf("%f",&x0[i]);
}
printf("eps=");scanf("%f",&eps);
do
{
x1[1]=g1(x0[2]);
x1[2]=g2(x0[1]);
temp[1]=x0[1];temp[2]=x0[2];
x0[1]=x1[1];
x0[2]=x1[2];
f1=fabs(x1[1]-temp[1]);
150
f2=fabs(x1[2]-temp[2]);
n++;
}while(max(f1,f2)>eps);
printf("adım sayısı=%d\n",n);
printf("kok=%f,%f",x1[1],x1[2]);
getch();
}
151
/*BASIT ITERASYON YONTEMI*/
#include<stdio.h>
#include<math.h>
#define g(x) ((x*x+6)/5 )
#define f(x) (x*x-5*x+6)
main()
{
int n;
float x0,x1,eps;
clrscr();
printf("x0=");scanf("%f",&x0);
printf("eps=");scanf("%f",&eps);
n=0;
do
{
x1=g(x0);x0=x1;
++n;
}while(f(x1)>eps);
printf("kok=%f\n",x1);
printf("adm says=%d",n);
getch();
}
152
/*NEWTON RAPHSON YONTEMI*/
#include<stdio.h>
#include<math.h>
#define f(x) (x-sin(x)-1)
#define ft(x) (1-cos(x))
main()
{
float eps,x0,x1,temp;
int i=0,n=0;
clrscr();
printf("epsilonu giriniz:");
scanf("%f",&eps);
printf("başlangıç değerini giriniz:");
scanf("%f",&x0);
do
{
x1=x0-(f(x0)/ft(x0));
temp=x0;
x0=x1;
n++;
}while(fabs(x1-temp)>eps);
printf("adom sayısı=%d\n",n);
printf("k”k=%f",x1);
getch();}
153
/*REGULA FALSi YÖNTEMİYLER Y=X^2-64 DENKLEMİNİN KÖKÜNÜN
BULUNMASI*/
#include<stdio.h>
#include<math.h>
#define f(x) (x*x-64)
#define x0(a,b) ((a*f(b)-b*f(a))/(f(b)-f(a)))
main()
{
float x1,eps,a=0,b=0;
int i;
clrscr();
printf("aralIğın birinci sayısını giriniz:");
scanf("%f",&a);
printf("aralIğın ikinci sayısını giriniz:");
scanf("%f",&b);
printf("epslonu giriniz=");
scanf("%f",&eps);
do
{
x1=x0(a,b);
if(f(x1)*f(a)<0) b=x1;
else a=x1;
}while(fabs(f(x1))>eps);
printf("kok=%f",x1);
getch();}
154
*YARILAMA YONTEMI*/
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#define f(x) (x-1-sin(x))
main()
{
float a,b,eps,ort;
int n=1,i;
clrscr();
printf("epsilonu giriniz:");
scanf("%f",&eps);
printf("a giriniz:");
scanf("%f",&a);
printf("b giriniz:");
scanf("%f",&b);
while((fabs(a-b)/pow(2,n+1))>eps) n=n+1;
printf("adım sayısı=%d\n",n);
getch();
for(i=1;i<=n;i++)
{
ort=(a+b)/2;
if(f(a)*f(ort)<0) b=ort;
else a=ort;
155
}
printf("k”k=%f",ort);
getch();
}