Algoritmanın gayesi, bir metin içerisinde verilen bir dizginin (string) aranmasıdır. Literatürde arama yapılan metin için T (ingilizcedeki Text (metin) kelimesinden gelmektedir) ve aranan kelime için P (ingilizcedeki Pattern (örüntü) kelimesinden gelmektedir) kullanılmaktadır.

Klasik bir arama, yukarıdaki temsili resimde gösterilmiştir.

Algoritmanın diğer metin arama algoritmalarından en büyük farkı, aranan dizgi (pattern) yerine aranılan metin (text) üzerinden işlem yapmasıdır.

Yukarıdaki şekilde gösterildiği gibi, üzerinde arama işleminin yapıldığı metinde bulunan herhangi bir x harfi için, aranılan metin üzerindeki (pattern) en solda olan harf bulunmaya çalışılır.

arama işlemine başlanan α değerinin ardından gelen harfler eşleştiği sürece, aranan kelimenin (pattern) sonuna kadar eşleştikçe arama işlemi devam eder. Şayet bu aşama uyuşmayan bir harf olursa, zaten aranan kelimenin olmadığı sonucuna varılabilir.

Ardından uyuşma olup olmadığına bakılmaksızın aranan kelimeyi ß değerine denk gelecek şekilde kaydırma işlemi yapılır. Bu kaydırmanın olması için kelimenin (pattern) kalan kısmında ikinci bir değerinin bulunmaması gerekir.

Örnek

Algoritmanın çalışmasını bir örnek üzerinden göstermeye çalışalım.

Yukarıdaki şekilde görüldüğü üzere, aranan kelime için (P) sağdan sola doğru bir numaralandırma yapılmakta ve bu numaralandırma üzerinden aşağıda gösterilen HpBc dizisi çıkarılır. Bu dizi üzerinden metin üzerinde arama yapılır.

Sırasıyla önce, A harfi aranır. Ardından C ve G harfleri aranır. Dikkat edilirse, kelimede üç kere geçen A harfi, dizide bir kere kullanılmaktadır.

Uyuşma oldukça aranan kelime kaydırılmaktadır.

Müsvette Kod (Pseudo Code)

Algoritmanın müsvette kodu aşağıdaki şekilde yazılabilir:

Horspool (P = p₁p₂…p_m,T = t₁t₂…t_n)

Önişleme Aşaması

For c Î ∑ Do d[c] ← m

For j Î 1…m-1 Do d[p_j] ← m – j

Arama Aşaması

pos←0

While pos ≤ n-m Do

j ←m

While j > 0 And t_pos+j = p_j     Do j ← j-1

If j = 0 bulundu: pos+1

pos ← pos +d[t_pos+m]

End of while

Yukarıdaki algoritmada geçen değerlerin, örnek üzerindeki gösterimlerini adım adım anlatmaya çalışalım:

Yukarıdaki ilk adımda aranan ilk harf olan C harfi için öncelikle kümede olup olmadığı kontrolü yapılır. Bunun anlamı aranan kelimenin harflerinden birisi olmaması durumunda vakit kaybedilmemesidir.

İkinci adımda ise daha önce çıkardığımız HpBc[a] dizisine göre her harfin değerleri atanır.

Arama işleminin devamı aşağıdaki şekildedir:

GCATCGCAGAGAGTATACAGTACG

GCAGAGAG

     pos ← 0 + d[t₀₊₇] , pos ← 0 + d[A], pos ← 1

Yukarıda görüldüğü üzere, kelimenin ilk kontrolü için 1. pozisyonda bulunan A değeri aranmıştır. Ardından arama işlemi sonraki harf olan G için aşağıdaki şekilde devam eder:

GCATCGCAGAGAGTATACAGTACG

GCAGAGAG

pos ← 1 + d[t₁₊₇] , pos ← 1 + d[G], pos ← 3

G harfi ile C harfinin tutuşmamasından dolayı aranan kelime (P) kaydırılmıştır.

GCATCGCAGAGAGTATACAGTACG

GCAGAGAG

pos ← 3 + d[t₃₊₇] , pos ← 3 + d[G], pos ← 5

Benzer şekilde C ve G uyuşmamasından dolayı bir kere daha kaydırıyoruz.

GCATCGCAGAGAGTATACAGTACG

GCAGAGAG

While j > 0 And t_pos+j = p_j Do j ← j-1

If j = 0 pos+1′de bulundu

pos ← 5 + d[t₅₊₇] , pos ← 5 + d[G], pos ← 7

Görüldüğü üzere aranan kelime ile uyuşma oldu. Algoritmamızın ilgili satırlarını çalıştırıyor ve bulunduğunu rapor ediyoruz.

GCATCGCAGAGAGTATACAGTACG

GCAGAGAG

pos ← 7 + d[t₇₊₇] , pos ← 7 + d[A], pos ← 8

İkinci kere A harfini arıyoruz.

GCATCGCAGAGAGTATACAGTACG

GCAGAGAG

pos ← 8 + d[t₈₊₇] , pos ← 8 + d[T], pos ← 16

Bulunan A harfi G harfi ile uyuşmadığı için atlıyoruz:

GCATCGCAGAGAGTATACAGTACG

GCAGAGAG

pos ← 16 + d[t₁₆₊₇] , pos ← 16 + d[G], pos ← 18

pos > n-m // pos >23-7

while döngüsünden çık.

Son olarak kelimenin sonuna gelindiği halde aranan yazı bulunmadığı için algoritma sonlanıyor.

Algoritmanın Karmaşıklığı

Algoritmanın zaman karmaşıklığı aranan kelimenin boyu n ve aranılan kelimenin boyu m olmak üzere O(mn)’dir denilebilir. Çünkü en kötü durumda her aranılan kelime harfi için üzerinde arama yaptığımız her harfi karşılaştırmamız gerekebilir. Bu da her n harf için m adet karşılaştırmaya eşittir.

78 views

Bilgisayar bilimlerinde, bir programın incelenmesi sırasında, herhangi bir kaziyenin (predicate, haber, önerme), çeşitli işlemler uygulanmasına karşılık yeknesan olması halidir.

Diğer bir deyişle, program çalışır ve çeşitli işlemlerden geçer, ancak bazı şeyler değişmeden kalıyor ve ne kadar işlem yapılırsa yapılsın değişmiyorsa buna yeknesan (değişmez, invariant) ismi verilir.

En basit örneği, bir değişkenin (variable) içine değer atanması ama hiç değiştirilememesidir.

int a = 10;
// işlemler
printf("%d",a);

Yukarıdkai kodda, a değerini ilgilendiren işlemler yapılmıyorsa, a için yeknesan olmuş denilebilir. Farklı bir örnek de döngülerde görülür:

for(int i = 0;i<10;i++){
   printf("%d",i);
}

Yukarıdaki döngüde, i<10 şartında bulunan 10′dan küçük olma şartı yeknesan olmuştur. Yani döngünün dönmesi sırasında değişmeden kalmaktadır. Hemen bu noktada önemli bir farkı belirtmek gerekir. Yeknesean kavramı, sabit kavramı ile (constant) karıştırılabilmektedir. Örneğin yukarıdaki döngüde bulunan 10 sayısı bir sabittir ve yeknesan değildir. 10′dan küçük olma durumu ise değişmeden kalan bir yeknesan olarak düşünülmelidir.
Yukarıdaki tip yeknesan örneklerine, özel olarak daire yeknesanı (loop invariant, döngü değişmezi) ismi de verilebilir.

Bu yaklaşım, ayrıca program analizi veya problem analizi sırasında da kullanılabilir. Örneğin MU Probleminin çözümünde, yeknesan bir değer yakalamaya çalışmak gerekir. Benzer şekilde Hoare Mantığı (Hoare Logic), programların belirli bölümlerinde, ön ve son koşullar belirleyerek bunların yeknesan olmasını sağlamaktadır.

Bu yöntem, bilgisayar bilimleri dışında da kullanılır. Örneğin, kanun yapım sürecinde, bütün kanunlarda değişmeyen kötü hasletler vardır. Bu yüzden, hırsızlık veya cinayet gibi suçlar, kanunlar değişmesine karşılık, bütün kanunlarda yerini almaktadır. Bu anlamda, değişen kanun sistemleri için, hırsızlık, yeknesan bir suçtur denilebilir.

243 views

Bilgisayar bilimlerinde de kullanılan ve normal gösterim elde etmeyi hedefleyen, özellikle de sondan normal şekil gösterimi için oynanan bir oyundur.

Oyunun aşağıda tanımlı olan kuralları ile MU kelimesinin elde edilip edilemeyeceği sorulur:

1. Oyunda kullanılabilecek harfler M, I ve U’dur. Bu harfler dışında harf kullanılamaz.
2. Oyuna MI kelimesi ile başlanır.
3. Oyundaki kelimenin sonuna, U harfi eklenebilir. (Örneğin MI kelimesi MIU yapılabilir)
4. Oundaki M harfinden sonra gelen harfler ikiye katlanabilir (Örneğin MIU kelimesi, MIUIU şeklinde, M harfinden sonra gelen IU kelimesini iki kere yazarak elde edilmiştir)
5. Ardışık olarak tekrar eden I harfleri U harfine dönüşebilir. Örneğin MUIIIU kelimesi MUUU kelimesine dönüştürülebilir.
6. Çift U harfi silinebilir. Örneğin MUUU kelimesi, MU kelimesine dönüşebilir.

Sorumuz, başlangıçta bulunan MI kelimesinin, yukarıdaki kurallar kapsamında MU olarak yazılıp yazılamayacağıdır.

Sorunun cevabı, bu şekilde bir geçişin imkansız olduğudur.

Bu tip bir problemin çözümünde bir “yeksan” (invariant, değişmez) aramak gerekir. Yani problemdeki değişen durumlara karşı yeksan olan (değişmeyen) bir kararlı hal yakalanabiliyor mu diye bakılması gerekir.

Çözümün ispatlanması sırasında I harfi içeren kelimelere bakmamız gerekir. Bu harfin (I) sayısını değiştiren kurallar, yukarıdaki listede, 4. ve 5. Kurallardır. 4. kural, sondaki harfleri iki misline katlamaktadır. Dolayısıyla sonda bulunan I harfi kaç tane ise bunun sayısı iki misline katlanacaktır. 5. kuralda ise I harfleri U harfi ile değişebilmektedir.

Bu iki kural dışında I harfinin sayısını değiştiren bir kural yoktur.

Ayrıca, başlangıçta 1 adet I harfi ile başlanmaktadır.

Şimdi kurallarımızı tekrar gözden geçirdiğimizde, I harflerinin sayısının 2 misline çıkabildiğini veya 3 I harfinin U harfine döndüğünü görürüz. Ayrıca oyunun bitmesi için hiç I harfi bulunmamalıdır.

Bu şartlarda oyun bitmez çünkü:

• Başlangıçtaki I sayısı (ki 1ile başlar) 3′e tam bölünmez.
• 3′e tam bölünemeyen bir sayının iki misli de üçe bölünmez.
• 3′e bölünemeyen bir sayıdan 3 çıkarmak ta sayıyı 3′e bölünür hale getirmez.

Dolayısıyla hiç I içermeyen MU kelimesine ulaşılması imkansızdır.

231 views

Bilgisayar bilimlerinde, özellikle özyineli (recursive) problemlerde, problemin bir kısmının tekrar edilmesi durumudur. Örneğin, klasik bir problem olan fibonacci sayıları örneğinde, örtüşen altproblem bulunmaktadır.

Fibonacci serisinin 4. terimini hesaplamak isteyelim ve bunun için aşağıdaki fonksiyonu yazmış olalım:

Matematiksel olarak : fib(0) = 1, fib(1) = 1 ve fib(n) = fib(n-1)+fib(n-2)

Programlama dillerinde:

fib(int n){
   if(n==0||n==1)
      return 1;
   return fib(n-1)+fib(n-2);
}

Yukarıdaki bu fonksiyonun çalışması sırasında çağırdığı alt fonksiyonları bir ağaç şeklinde çizecek olursak:

Yukarıdaki ağaçta, görüldüğü üzere, bazı terimler birden fazla kere hesaplanmaktadır. Örneğin fib(2) fonksiyonu, hem fib(4) hesaplanırken, hem de fib(3) hesaplanırken hesaplanmaktadır. Bu anlamda, problemin bir alt grubunun (subproblem) örtüştüğünden (overlap) bahsedebiliriz. Genelde bu tip örtüşmelerde, hız kazandırmak ve problemin sadece bir kere çözülmesini saplamak için dinamik programlama (dynamic programming) yöntemi kullanılır.

192 views

Yazan : Şadi Evren ŞEKER

İyileştirme problemleri açısından klasik bir örnektir (optimisation problems). Problem basitçe bir kutunun içerisine en az boş alan bırakarak, eşyaların en iyi şekilde nasıl yerleştireceği olarak düşünülebilir.

Aslında problemi boyutlara göre incelersek aşağıdaki şekilde bir liste yapılabilir:

Tek boyutlu kutulama (1D bin packing) :Bu problemde amaç bir çizgi veya hat gibi görülebilecek yapının içerisine farklı boyutlardaki çizgileri yerleştirmek olarak düşünülebilir.

Örneğin zaman çizelgelemesinde, bir kişinin yapacağı işleri, zaman çizgisinin üzerine yerleştirmesi (ve her işin farklı miktarda zaman gerektirdiğini ve kişinin çalışma saatlerinin sınırlı olduğunu düşünürsek en fazla işi en az zamanda (örneğin 8 saatlik mesailer içinde) yapması ) bir problemdir. Buradaki hem kişinin yapacağı işler hem de bu işlerin yerleştirileceği zaman çizgisi tek boyutludur.

Daha basit olması açısından örneğin 100m uzunluğundaki bir ipi 7 ve 9m uzunluğundaki parçalara en az fire ile bölmek istiyoruz, en verimli bölme işleminde kaç adet 7 ve kaç adet 9 uzunluğunda ipimiz olur gibi soruları düşünebiliriz. Bu tip sorular tek boyutlu kutulama problemleridir.

İki boyutlu kutulama problemleri (2D bin packing optimization): Bu grupta bir tablodan ve iki boyuttan bahsedilebilir. Örneğin kot pantolon üreten bir tekstil firmasında farklı boyutlardaki Pantolon kalıplarının en az fire ile 5x5m büyüklüğündeki bir kare kumaştan kesilmesi isteniyor olsun. Bu problem iki boyutlu (x ve y boyutları) bir kutulama problemidir. Benzer bir problem, bir gazetedeki seri ilanların, en az fire ile sayfaya yerleştirilmesi olarak da düşünülebilir.

3 boyutlu kutulama (3D bin packing) problemin en zor şekli olarak tanımlanır ve 3 boyutlu bir kutunun içerisine konulan her şeklin farklı x,y ve z boyutlarında şekiller olması olarak düşünülebilir. Problemin genel tanımını yaptığımız için belirteyim, örneğin ev taşıma sırasında çıkan eşyaların kutulanması olarak düşünebilirsiniz. Bu durumu daha da karmaşık yapmaktadır çünkü kutular farklı boyut ve şekillerdedir (örneğin silindir bir varil veya küp veya dikdörtgenler prizması gibi kutuların içerisine yerleştirme yapılmakta) ve kutulanan şekillerde farklıdır ve hatta girintilidir (concave , non-convex) (örneğin avize, koltuk, sandalye gibi birbirinin içine girebilen nesneleri düşününüz). 2 ve 3 boyutlu paketleme, paketlenen nesnelerin girintili olup olmamasına göre ikiye ayrılmaktadır. Dış bükey nesnelerin paketlenmesi nispeten daha basit bir problemdir. Ancak nesnelerin iç bükey olması halinde problem biraz daha karmaşıklaşır.

Hatta literatürdeki kısıtlı aramalarım sonucunda ulaşabildiğim kadarıyla tam olarak iç bükey nesnelerin paketlenebildiği bir sonuç ne yazık ki bulamadım. Örneğin iki vidanın en verimlim paketlenmesi sırasında vidaların girinti çıkıntılarının üstüste gelmesi gerektiğini tecrübi olarak biliyoruz. N adet vida için bu durum birbirini tekrar eden bir hal alır. Gerçekten farklı boylarda ve adım sıklığında ve çaplarda vidalar verilse bu durumda en verimli paketlemeyi yapabilen bir algoritma henüz görmedim.

Paketlenen nesnelere göre problemin sınıflandırılması:

Paketlenen nesne çeşitlerinin sabit olması ve ön tanımlı olması halinde problem homojen olarak tanımlanır. Örneğin tek boyutlu kutulama probleminin tanımı sırasında verilen ve “100m uzunluğundaki bir ipi 7 ve 9m uzunluğundaki parçalara en az fire ile bölmek” şeklinde geçen örnek bu tip homojen (homogenous) bir yapıdadır. Buna karşılık heterojen bir problemde, paketlenecek nesnelerin tipleri ya tamamen birbirlerinden farklıdır ya da aynı tipte çok az tekrar vardır. Yine tek boyutlu problem örneğinde verilen zaman çizgisi üzerinde farklı uzunluklardaki randevuların yerleştirilmesi bu tiptendir.

Bu anlamda aşağıdaki problemler, kutulama probleminin birer özel hali olarak düşünülebilir:

• kamyon yükleme problemi (truck loading),

• konteyner yükleme problemi (Container loading problem, CLP)

• şerit paketleme problemi (Strip Packing problem, SPP)

Yukarıda, problemin tanımını yaptıktan sonra çözümlere bir göz atalım:

Homojen tek boyutlu problem çözümü

Şayet problem tek boyutlu ise ve homojen nesnelerin paketlenmesi olarak problemin çözülmesi isteniyorsa problem oldukça basit demektir ve basit matematiksel hesaplamalar ile problemi çözebiliriz.

Örneğin tek nesne ve tek paket varsa işlem basitçe paketin nesneye bölümü olarak bulunur (zaten burada zor Bir şey de yok):

Örneğin 100m uzunluğundaki bir ipten kaç tane 5m uzunluğunda ip kesilebilir:

100 / 5 = 20

biraz daha zorlaştırıp ip sayısını 2 çeşide veya 3 çeşide çıkarırsak problem np-tam (np-complete) bir hal alır. Örneğin aşağıdaki kodu inceleyelim:

Kodda görüldüğü üzere bütün ihtimaller denenmektedir. Basitçe herhangi bir k değeri için, k-a ve k-b değerlerini denemekte ve denenen duruma göre a veya b değerini bir arttırmaktadır. Aslında kodumuz basit bir ikili ağaç (binary tree) oluşturmaktadır:

Önce 9 veya 7 ile başlanması ihtimalleri:

Sonra bu ihtimallerin de 7 veya 9 azalma ihtimalleri:

Yukarıda gösterildiği gibi her düğümden yine ikişer ihtimal indirerek bir alt seviyeye geçilebilir. Neticede 0 olana kadar yapılan bir aramadır ve 0 sonucuna birden farklı yoldan ulaşılabilir.

Kodumuz çalıştırıldığında çözüm olarak aşağıdaki sonuçları üretmektedir:

cozum : 7*4 + 9*8

cozum : 7*13 + 9*1

Gerçekten de problemin iki farklı çözümü bulunmaktadır.

Yukarıdaki kod basit bir hesaplama ile, 2′nin üstlerinin toplamı kadar adım hesaplamaktadır.

Bu değer yukarıdaki ağaçtan çıkarılabilir:

ilk düğüm için tek ihtimal 2 ⁰

ikinci seviye için iki ihtimal: 2 ¹

üçüncü seviye için dört ihtimal 2 ²

şeklinde gitmektedir ve örneğin problemimiz üçüncü seviyede çözülseydi (sonuç 0 olsaydı) o zaman karmaşıklığımız bu değerlerin toplamı olacaktı ve 2 ⁰ + 2 ¹ + 2 ² şeklinde hesaplanacaktı.

Bu değer, ikili ağaçlardan bilindiği üzere 2 ⁿ-1 şeklinde hesaplanabilir.

Görüldüğü üzere yukarıdaki algoritma O(2 ⁿ) değerinde bir karmaşıklığa sahiptir ve bu değer bir çok terimli (polynom) değildir yani algoritmanın karmaşıklık sınıfı np-tam (NP-Complete) olarak belirtilebilir. Ayrıca yukarıdaki k değeri için bir çözüm bulunmuştur ancak çözüm bulunamasaydı bu değer k terim için denenecekti. Yani 100 için çözüm yoksa bir yaklaşığı olan 99 için ardından iki yaklaşığı 98 için … Bu işlem hiç çözüm bulunamaması halinde k terim için denenecekti.

Yukarıdaki problem, dinamik programlama (dynamic programming) kullanılarak iyileştirilebilir. Bunun sebebi arama işlemi sırasında bazı sonuçların tekrar etmesidir. Örneğin yukarıdaki ikili ağacı aşağıdaki şekilde çizebiliriz:

Farka dikkat ederseniz, 93 – 9 = 84 ve aynı zamanda 91-7 = 84 olduğu görülür. Bu durumda aslında 84 değeri bir önceki kodda iki farklı durum için aranmaktayken şimdi tek bir durum için aransın istiyoruz. Elbette 84 sadece bir örnektir ve buna bağlı olarak çok sayıda tekrar eden değer bulunmaktadır.

Hesaplanan bu değerleri bir dizi (array) içerisinde tutup tekrar hesaplanmasını engellemek istiyoruz:

Yukarıdaki yeni kodda, bir dizi içerisinde tek döngü ile sonucu hesaplattık. Buna göre algoritmamız iki elemanlı bir diziyi kullanmakta, dizinin 0. elemanları 7lerin sayısını ve 1. elemanları ile 9ların sayısını saymaktadır.

Kodumuz ilk başta 0 için 0 tane 7 ve 0 tane 9 gerektiği gerçeği ile çalışmaya başlıyor. 14-23. satırlar arasındaki döngü basitçe i. terim için i-a ve i-b değerlerine bakıyor. Şayet i. terim için i-a veya i-b değerinde bir çözüm varsa (nereden geldiğini önemsemeksizin) bu çözüme bulduğu koşulu ilave ederek mevcut i değeri için çözümü kaydediyor. Şayet bu iki terim de bulunmuyorsa o zaman bir sonraki i değerine geçiyor.

Ekran çıktısı aşağıdaki şekildedir:

Son 20 satır görülmekle birlikte daha önceki satılar alıntılanmamıştır. Ayrıca son 20 satırda görüldüğü üzere, tamamına ait bir çözüm bulunmaktadır. Örneğin 88 sayısı için 7*10 + 9*2 = 88 sonucuna ulaşılmıştır. En son satırda ise 100 için 7*13 + 9*1 sonucu görülmektedir.

Görüldüğü üzere birden fazla sonuç olsa bile tek bir sonucu görmekteyiz bunun sebebi veri yapısının bir sonuç üretmek üzere tasarlanmış olmasıdır. Elbette daha farklı veri yapıları kullanılarak diğer çözümleri de gösteren sonuçlar elde edilebilir.

Yukarıdaki algoritmanın karmaşıklığı ise bir öncekine göre oldukça iyi sayılabilecek O(n) olarak bulunur. Bunun sebebi dizideki her elemanın üzerinden tek bir kere geçiyor olması ve dolayısıyla tek bir döngünün (koddaki 14-21 satırlar arası) çalışıyor olmasıdır.

570 views

Yazan : Şadi Evren ŞEKER

Bilgisayar bilimlerinde algoritma performansının değerlendirilmesinde kullanılan yöntemlerden birisidir. Kısaca, bir algoritmanın en kötü durumunu araştırırken (worst case analysis) en kötü durumun olma ihtimallerinin de beraberinde incelendiği tahlil yöntemidir.

Klasik bir en kötü durum analizi (worst case analysis) yöntemi algoritmanın çalışacağı en kötü durumu ortaya atar ve buradaki performansı ölçer. Örneğin kabarcık sıralaması (bubble sort) ele alalım. Bu algoritma için en kötü durum sıralanacak olan grubun tersten sıralı olarak verilmesidir (küçükten büyüğe doğru sıralamak istediğimiz bir örneğin, tam ters sıralı olarak büyükten küçüğe sıralı olması durumudur).

Ancak itfa tahlil (amortized analysis) yöntemi ile bu en kötü durumun olma ihtimali de göz önünde bulundurulur. Bu durumu daha basit bir örnek üzerinden anlatmaya çalışalım.

Örnek Değişken boyutlu dizi (Dynamic Array)

Bir değişken dizi uygulaması sırasında (dynamic array) hafızada dizinin ne kadar yer kaplayacağı önceden bilinemez. Amacımız hafızada eklenen eleman sayısı arttıkça kapladığı yeri artan bir dizi kodlamaktır. Örneğin tek eleman eklenmesi halinde hafızada tek eleman, beş eleman eklenmesi halinde ise hafızada beş elemanlık yer kaplayan bir dizi kodlamak istiyoruz.

Bu dizi kodlamasının en klasik uygulaması, dizi için hafızada ayrılan yerin dolması halinde, hafızadaki kaplanan yerin iki misline çıkarılmasıdır. Ayrıca iki misline çıkınca önceki dizide bulunan verilerin, yeni diziye kopyalanması da gerekmektedir. Örneğin hafızada iki elemanlı yer ayırarak başladık, 2 eleman dolduğunda hafızadaki yeri 4 elemana çıkarıyoruz, ve eski dizideki iki elemanı, yeni diziye kopyalıyoruz, 4 eleman dolduğunda 8 elemana çıkarıyoruz ve eski dizideki 4 elemanı yeni diziye kopyalıyoruz v.b.

Şimdi eleman ekleme işleminin hafızadaki karmaşıklığına bakalım. En kötü durum analizi bize, analiz sırasında karşılaşılabilecek en kötü durumu hesaplamamız gerektiğini söyler. Buna göre en kötü durum hafızanın dolması ve yeni yer açılmasıdır. Dizimizde n eleman olduğunu kabul edersek dizi dolduğu anda n elemanlık bir yer daha açılacaktır. Bu durumda algoritma karmaşıklığımızın O(n) olduğunu söyleyebiliriz. En kötü durum analizine göre doğru olan bu yaklaşım, itfa tahlilinde (amortize algoritma analizi) geçerli değildir.

Algoritmamızın çalışması sırasında n. elemanın eklenmesi için yeni açılan diziye n eleman kopyalanacaktır. Bu kopyalama işleminden sonra dizimize n adet eleman daha alabileceğiz. Dolayısıyla 2n elemanı eklemek için n adet kopyalama işlemine ihtiyaç duyuyoruz. O halde basit bir hesaplama ile 2n elemanın eklenmesi için 2n işlem + n adet kopyalama = 3n işlem yapmaktadır. Karmaşıklık ise basitçe O(3n/2n) = O(3/2) = O(1) olarak bulunur (sabit değerlerin big-oh değerinin 1 olduğunu hatırlayınız örneğin O(20) = O(1) )

Yukarıdaki işlem sırasında akla gelebilecek bir soru, n adet elemanın eklenmesi işleminin altında da kopyalama işlemleri yapıldığıdır. Örneğin 16 eleman eklenmesi için kaç adım gerektiğini hesaplayalım:

2 eleman eklenir

2 eleman daha eklemek için 2 kopyalanır 2 eklenir: toplam 4 eklenmiş 2 kopyalanmıştır

4 eleman daha eklemek için 4 kopyalanır 4 eklenir: toplam 8 eklenmiş 6 kopyalanmıştır

8 eleman daha eklemek için 8 kopyalanır 8 eklenir: toplam 16 eklenmiş 15 kopyalanmıştır

Yukarıdaki gidişten anlaşılacağı üzere n ekleme için yaklaşık olarak n kopyalama yapılmaktadır. Yani limit alındığında ve eklenen elemanların sayısı sonsuza götürüldüğünde kopyalanan elemanların sayısı neredeyse eklenen elemanların sayısına eşit çıkacaktır. O halde her yeni eleman eklenmesinin maliyeti 1′e daha da yaklaşacaktır (n / n = 1 olduğu için)

Örnek : Binom Sırası (Binomial Queue)

Farklı bir örnek olarak Binom Sırasına bakalım (binomial queue).

Öncelikle sıranın nasıl ilerlediğini hatırlayalım :

B0:

B1:

B2:

B3:

B4:

Yukarıda görüldüğü üzere, her binom sırasında, o ana kadar olan sıraların tamamı içerilmektedir. Örneğin B4′ün kolları, sırasıyla B0, B1, B2, B3 ağaçlarını barındırmaktadır.

Bu durumda i. Terim için aşağıdakine benzer bir hesaplama sayısı gerekmektedir:

T(i) = T(i-1) + 2 – C

ve T(0) = 0

Yukarıdaki özyineli formülde (recursive function) i. adım için T(i) adet ağaç gerekmektedir. Elbette bu sayı da T(i-1) ile gösterilen ve i. adım öncesinde bulunan ağaç sayısına 2-C eleman eklenerek bulunmaktadır. Bu denklemdeki C ile gösterilen değer, i. adımın maliyetini (bilgisayardaki hesaplama işlem maliyeti, hafıza maliyeti vs. ) göstermektedir.

Yukarıdaki işlemi biraz daha ilerletirsek :

C + T(i) – T(i-1) = 2

sonucunu bulur ve buradan bütün denklemleri yazıp toplarsak, n adet eleman için işlem maliyetini aşağıdaki şekilde bulabiliriz:

C ₁ + T(1) – T(0) = 2

C ₂ + T(2) – T(1) = 2

C ₃+ T(3) – T(2) = 2

…

C _n-1+ T(n-1) – T(n-2) = 2

C _n + T(n) – T(n-1) = 2

Yukarıdaki denklemlerin toplamı olarak:

Ayrıca ilk denklem olarak T0 = 0 olduğunu biliyoruz çünkü binom ağacının ilk elemanı 0 çocuk sahibidir.

Dolayısıyla yukarıda bulduğumuz n eleman için 2n maliyeti bize yine itfa tahlili ile O(2n /n) = O(2) = O(1) sonucunu gösterir. Klasik bir en kötü durum analizi ile, bu hesaplamada, O(n) maliyet çıkaracaktık ancak amortize analiz bize burada bir adım ilerisini göstererek en kötü durumun tahlil edilmesinin aslında tek elemana bakılarak yapılamayacağını ve bütün elemanlar incelendiğinde aslında en kötü durumun o kadar da kötü olmadığını göstermektedir

Ortalama durum ile Amortize algoritma analizinin farkı.

Bu anlamda ortalama durum analizinden (average case analysis) ayrılmaktadır. Yani ortalama durum analizinde bütün ihtimallerden ortalama maliyette bir ihtimal üzerinden analiz yapılır. Bütün ihtimaller hesaplanarak ortalamaları bulunur. Amortisman analiz yönteminde ise hala en kötü durumu analiz etmekteyiz ancak analizi bir adım daha genişleterek en kötü durumun beklenenden daha iyi olduğunu ispatlıyoruz. Yukarıdaki iki örnek için de , yani binom yığıtı (binomial heap) veya değişken boyutlu dizi (dynamic array) için de tek elemanın eklenmesi halinde yapılan en kötü durum analizinden daha iyi sonuçlar bulduk ancak bu sonuçlar hala en kötü durumda bulunacak sonuçlardır. Tek farkı en kötü durum analizinde tek bir elemana bakılmaktayken amortize algoritma analizinde olayın geneline baktık.

İtfa Tahlili Yöntemleri:

İtfa tahlilinde kullanılan 3 klasik yöntem bulunmaktadır.

Münasebet tahlili (aggregate analysis). Bu tahlil yönteminde, n terim için olan maliyet, özyineli bir fonksiyon olarak yazılır, örneğin T(n) olarak isimlendirelim ve bu değer n terime bölünür, örneğin T(n) / n değeri olarak hesaplanır. Yukarıdaki örneklerden binom ağacı (binomial tree) bu yöntemle tahlil edilmiştir.

Muhasebe tahlili (accounting analysis). Bu yöntemde, her ilave işlemin sisteme getirdiği yük anlık olarak hesaplanır. Örneğin n terimden sonra n+1 terim olduğunda ne kadar yükte değişiklik olacağı anlaşılmaya çalışılır. Sabit uzunlukta çalışma örnekleri alınarak sisteme getirdiği maliyete her elemanın etkisi ölçülür ve buradan n elemanlı bir çalışmaya maliyet genellemesi yapılır. Yukarıdaki örneklerden değişken boyutlu dizi (dynamic array) bu tahlile bir örnektir ve örnekte görüldüğü üzere 2,4,8,16 gibi çalışma uzunlukları alınarak bir genelleme yapılmıştır.

Kapasite tahlili (potential analysis). Bu yöntem, muhasebe tahlili ile tamamen aynıdır. Bu tahlil yönteminde de elemanlara bakılmak suretiyle genelleme yapılmaya çalışılır. Muhasebe tahlilinden tek farkı her elemanın sisteme yaptığı etkinin bir ödeme değil bir kapasite azalması olarak görülmesidir. Bu noktayı biraz açmak gerekirse:

Muhasebe tahlili ile kapasite tahlili aslında algoritma analizine muhasebe dünyasından girmiş yöntemlerdir. Muhasebede kullanılan ve bir birikim fonksiyonunu tahlil etmek için (debit function) kullanılan iki yaklaşımdan birisi, birikimi bir ödeme olarak görmek ve her adımda ödeme yapılmak suretiyle birikimi arttırmak iken ikincisi birikimi bir kapasite olarak görmek ve her adımda bu kapasiteyi azaltmak olarak görmektir.

Aslında ikisi de aynı değeri hesaplamaktadır ancak birincisi her adımda değerleri biriktirmekte, ikincisi ise başta birikimi hesaplayıp her adımda bu birikimi eksiltmektedir.

Yukarıdaki örneklerden değişken boyutlu diziyi (dynamic array) hatırlayacak olursak, bu dizideki maliyeti hesaplarken her elemanın sisteme etkisini bulmuştuk. Bazı elemanlar sisteme 1 etkisi yaparken bazı elemanlar n etkisi yapmıştı. Yani 2,4,8 gibi elemanlarda o ana kadar olan eleman kadar etki yapılmıştı. Ancak örneğin 1,3,5,6,7 gibi sayıların sisteme maliyeti 1 idi. Bu yaklaşım, muhasebe yaklaşımı olup, her elemanın sisteme artan miktardaki etkisi biriktirilmektedir.

Bu yaklaşımın tersi bir yorumla, ilk başta 2n maliyet getireceğini kabul edip (2n değerinde borç kredi aldığımızı kabul edin) her adımda bu değeri düşürmek (her adımın maliyetini kredimize geri ödeme olarak düşünüyor ve kredi borcumuzu kapatıyoruz) ise kapasite yaklaşımıdır (potential analysis).

327 views

Algoritma analizi konusunda geçen meşhur problemlerden eşleşme problemini çözmek için (matching problem, bazı kaynaklarda atama problemi (assignment problem) olarak da geçmektedir) macar araştırmacıların etkisi ile gelişen algoritmanın ismidir.

Algoritmanın ulaşmak istediği amaç, azami eşleşmeye ulaşmaktır. Bu adımda azami eşeleşmeyi tanımlayalım. Eşleşme problemleri (matching) iki grup altında incelenebilir:

• ikili eşleşme (binary matching)

• Azami eşleşme (maximum matching)

ilk gruptaki problemlerde iki üyenin eşleşmesi yeterlidir. Örneğin evlilik problemi gibi, en fazla kişinin evlendiği eşleşmeler veya bir arz / talep eşleşmesi gibi. Örneğin nehri geçmek isteyen kişilerin sallara atanması gibi en az kişinin açıkta kaldığı en fazla kişinin eşleştiği problemlerdir.

İkinci grup olan azami eşeleşme (maximum matching) problemleri ise bu yazının da konusu olan macar algoritması tarafından çözülmesi hedeflenen ve klasik eşleşmenin ötesinde, her eşleşmenin değer sahibi olduğu problemlerdir. Örneğin kişilerin iş bulması ama her işin ve kişinin farklı maaşlar alması halinde azami maaş (maximum maaş) değerine ulaşmak gibi. Yani sadece eşlemek yetmiyor bir de her eşlemeye bir skor verip bu değerin en fazla olmasını istiyoruz. Bu problemin tersten okunuşu ise asgari maliyettir. Yani aynı problemi bir şirket yöneticisi ele aldığında örneğin çalışanlarına en az maliyetle iş yaptırmak isteyecektir.

Problem ve macar algoritması (hungarian algorithm) daha iyi anlaşılsın diye bir örnek üzerinden anlatmaya çalışalım. Örneğin elimizde N adet çalışan ve N adet iş olsun ve her kişinin her işe atanması durumunda alacağı maaşları bir masfufta (matrix) göstermeye çalışalım:

Yukarıdaki masfufta görüldüğü üzere 4 adet iş ve bu 4 iş için 4 adet çalışan atanmış, her hücrede ise ilgili çalışanın ilgili iş için alacağı ücret gösterilmiştir. Örneğin Ş çalışanının C işini yapması halinde 4 lira alacağını anlıyoruz.

Artık problem daha rahat anlaşılabilir. Amacımız yukarıdaki ücret değerlerine göre en düşük maaşlı işe atama olacaktır.

Problem masfuf olarak gösterilebileceği gibi bir şekil (graph) olarak da tasviri mümkündür:

Problem daha iyi anlaşılsın diye örnek bir çözümü ele alalım:

Yukarıdaki eşleşmede A-S , B-T ve C-Ş ataması yapılmıştır. Bunun maliyeti 5+4+4 = 13 olarak hesaplanabilir.

Elbette bu çözüm ihtimal havuzundakilerden sadece bir tanesidir. Basit bir olasılık hesabı ile 3×3 boyutundaki bir masfuf için 3! ihtimal olduğu görülebilir. Örneğin A için 3 ihtimal B için kalan 2 ihtimal ve C için tek ihtimal bulunmaktadır. Aynı şekilde nxn boyutundaki bir eşleşme (matching) problemi için de n! ihtimal bulunacaktır.

Klasik bir algoritma kodlanması durumunda n! ihtimalin incelenmesi gerekeceğinden problemi np-zor (np-hard) olarak görebiliriz. Ancak macar algoritması bu problemi çok terimli zamana (polinom, polynomial) indirgeyebilmektedir. Bu anlamda problem np-tam (np-complete) olarak görülebilir.

Gelelim problemin çözümüne. Problem, yukarıdaki şekilden den görüleceği gibi iki parçalı grafiğin (bipartite graph) doğru oluşturulması ile çözülebilmektedir.

Algoritma 3 adımdan oluşmaktadır.

1. adımda 0-ağırlıkta kenarlar oluşturuyoruz (0-weighted edges) bunun için işler kısmında bakarak en düşük değerdeki kenarın ağırlığını diğer kenarlardan çıkarıyoruz ve benzer şekilde kişiler tarafından bakıp en düşük değerdeki kenarın ağırlığını diğer kenarlardan çıkarıyoruz.

   Bu aşama aslında problemin yapısını değiştirmemektedir. Örnek problemimize bu adımı uygulayarak durumu görelim:

Yukarıdaki masfufta görüldüğü üzere A için en düşük değer olan 4, B için en düşük değer olan 1 ve C için en düşük değer olan 3 bütün değerlerden çıkarılmış ve aşağıdaki masfuf elde edilmiştir:

Şimdi çalışanlar açısından olaya bakıp en düşük değerleri çıkaralım:

Masfufta bir değişiklik olmadı çünkü her çalışan için en düşük değer 0 idi. Ancak bu durum farklı örneklerde değişebilir. Şayet çalışanların ücretlerinde 0′dan büyük değer bulunursa bu değerlerin en küçüğü satır bazlı olarak bütün satırdan çıkarılacaktır.

Daha iyi anlaşılması için yukarıdaki masfufun şekil halini aşağıda verelim:

1. Yukarıdaki yeni şekilde 0-ağırlığındaki düğümleri kullanarak eşleme yapıyoruz. Bu adımda azami akış (max-flow) veya dalgalı yol bulma (augmented path) algoritmaları gibi algoritmalardan istifade edebiliriz.

   Eşleşme sonucu şayet mükemmel eşleşme ise (perfect matching) problem çözülmüştür. Şayet mükemmel eşleşme sağlanamazsa, sadece 0-ağırlığındaki kenarları kullanarak en düşük toplam değere sahip alt şekli (subgraph) buluyoruz.

2. Adımdan, problem çözülene kadar 2. adıma dönüyoruz.

Problemimize dönüp 2. adımı uygulayalım. 0-ağırlığına sahip kenarların değerleri aşağıda verilmiştir:

Yukarıdaki şekilde bulunan en düşük maliyetli atamadır. Bu atama A-T , S-C ve Ş-B şeklindedir ve Orijinal değerleri hatırlanacak olursa, 4+3+1 = 8 olarak hesaplanabilir. İddiamız, bu şekilde daha düşük maliyetli bir atama yapılamayacağıdır.

569 views

Yazan : Şadi Evren ŞEKER

Bu yazının amacı, özyineli problemlere bir örnek vermek ve nasıl çözüldüğünü anlatmaktır. Problemimiz oldukça meşhur olan bir çemberin doğrular tarafından bölünmesidir.

Kabaca, bir çemberi 20 adet doğrunun en fazla kaç alana ayırabileceğini soralım.

Örneğin n=0 için alan sayımız 1′dir:

Bir doğru ile çemberi kestiğimizde iki alan çıkar:

ikinci bir doğru eklendiğinde 3 alan çıkmaktadır:

3 doğru için 7 alan bulunur:

4 doğru için 11 alan bulunur:

Şimdi yukarıdaki bulunan değerleri liste halinde yazalım:

0 1

1 2

2 3

3 7

4 11

Buradaki sayılardan çıkan bağlantı, her adımda, bir önceki değere adım değerinin eklenmesidir. Örneğin 4. adım, bir önceki adımdaki değer olan 7+4 = 11 şeklinde bulunmuştur.

Bu ağlantı aşağıdaki şekilde formülize edilebilir:

f(n) = n + f(n-1)

Görüldüğü üzere bu denklem özyineli bir denklemdir (recursive equation).

Şimdi bu özyineli denklemi çözmeye çalışalım. Bu tip denklemlerin çözümü için iki alternatif bulunur. Aslında ikisi de sonuçta aynı şeyi bulmayı amaçlar.

• Top Down Approach (Yukarıdan Aşağıya Yaklaşım)

• Bottom Up Approach (Aşağıdan Yukarıya Yaklaşım)

Denklemimizi önce Yukarıdan aşağıya yaklaşımla açalım:

f(n) = n + f(n-1)

f(n-1) = n-1 + f(n-2)

f(n-2) = n-2 + f(n-3)

…

f(1) = 2

f(0) = 1

Yukarıdaki ilk üç denklemi birbiri cinsinden yazalım:

f(n) = n + n-1 + n-2 + f(n-3)

Buna göre denklemin tamamı açıldığında aşağıdaki gibi bir bağlantı görülebilir:

f(n) = n + n-1 + n-2 + n-3 … + f(1)

Bu denklemi matematiksel olarak aşağıdaki şekilde gösterebiliriz:

Bu denklem de oldukça meşhur olan 1′den n’e kadar olan sayıların toplamı şeklinde düşünülebilir:

Aynı problemi bu defa aşağıdan yukarıya yaklaşımla çözelim (bottom up approach):

f(0)= 1

f(1) = 2

f(2) = 3

f(4) = 7

f(5) = 11

…

Buradaki denklemleri birbiri cinsinden yazıyoruz:

f(0) = 1

f(1) = 1 + f(0)

f(2) = 2 + f(1)

f(3) = 3 + f(2)

f(4) = 4 + f(3)

f(5) = 5 + f(4)

…

şeklinde yazdıktan sonra, son terimi çekelim:

f(5) = 5 + 4 + 3 + 2 + 1 + 1

Buradan çıkan netice ise bir önceki yöntemde elde ettiğimiz netice ile aynıdır.

f(n) = n + n-1 + n-2 … 5 + 4 + 3 + 2 + 1 + 1

dolayısıyla aynı denklemi yazabiliriz:

ve sonuç olarak aşağıdaki hesap doğrudur:

Yukarıdaki denklemleri elde ettikten sonra, bize ilk başta sorulan acaba 20 adet doğru olsaydı en fazla kaç alana bölünebilirdi sorusuna cevap bulabiliriz:

203 views

Bazan biz insanlar için çok kullanılan kelimeler, tanımlanması en güç kelimeler haline dönüşebiliyor. Algoritma da sanırım bilgisayar bilimleri için benzer özellikte olan bir kelime.

Sanırım bu kelimeyi tanımlarken “bir dizi matematiksel adım” ifadesini kullanmak yerinde olur.

Bütün algoritmalar, matematiksel olarak ispatlanabilen ve dizilimi kesinlikle önem taşıyan ve bir metot anlatmasıdır.

Aslında bir kelimeyi başka bir kelime ile ifade etmek bir hatadır. Şayet iki kelime aynı şeyi anlatıyorsa, o zaman bir tanesi fazla demektir ama genelde algoritma için bu “metot” veya “sistem” kelimeleri sıkça kullanılıyor. Oysaki algoritma bunlardan farklı olarak bir, matematiksel bir dizilimdir. Evet, bir problemi çözmek için gerek metodu anlatır bu çözümde kullanılan sistemi gösterir ama atlanmaması gereken ispat edilebilirlik, karmaşıklığının ölçülebilirliği aslında bilgisayar bilimlerinin de temelini oluşturur.

Bu durumu bir örnek üzerinden açıklamaya çalışalım.

Örneğin sık kullanılan sıralama problemini (sorting problem) ele alalım. Elimizde bir dizi karıştırılmış sayı var ve biz bunları küçükten büyüğe doğru sıralamak istiyoruz. Bu durumda birisinin çıkıp ben bunları sıraladım demesi bir algoritma olmaz. Çünkü algoritmanın sistematik olarak probleme yaklaşması gerekir.

Ben bunları sıralayan bir sistem yaptım demesi de algoritma olmaz. Çünkü sistemin bütün adımlarını belirli olması ve analiz edilebilir olması gerekir.

Ben bunları sıralayan ve şu adımlardan oluşan bir sistem yaptım demesi de yeterli olmaz çünkü bu algoritmanın her durumda çalışacağının matematiksel olarak ispatlanabilmesi gerekir.

Ancak bu aşamadan sonra bir algoritmadan bahsediyoruz demektir ve tam da bu aşamadan sonra artık algoritmanın performansından bahsetmeye başlar ve algoritmamızın hafıza ve zaman ihtiyaçlarını ölçebilmeyi isteriz.

Yukarıdaki bütün bu tanımların yanında, bir algoritma elde ettikten sonra ayrıca bu algoritmanın uygulanabilir oluşu da tartışmaya açıktır. Örneğin geliştirilen algoritma, günümüz bilgisayarları için uygulanabilir olmayabilir. Bu durum algoritmamızı , algoritma olmakta çıkarmaz ancak uygulanamaz bir hale sokar (örneğin şu anda yeni yeni gelişen kuantum hesaplama algoritmaları buna birer örnek olabilir).

Ayrıca algoritmaların yaklaşımlarına göre sınıflandırılması da mümkündür. Hatta bu sınıflandırmaya uygun olarak algoritma geliştirilme metodolojileri de bulunmaktadır. Örneğin nesne yönelimli programlama (object oriented programming) , yapısal programlama (structured programming) veya fonksiyonel programlama (functional programming) , Emirli programlama (Imperative Programing), özdevinirli programlama (automat based programming) gibi.

566 views

Emil Post tarafından 1946 yılında ortaya atılan ve belirsiz karar problemi olarak sınıflandırılabilecek olan (undecidable decision problem) problemin ismidir. Literatürde kısaca PCP olarak da geçmektedir. Bu problem, yine Emil Post tarafından geliştirilen, Post Makinesi (post machine) olarak bilinen ve Turing makinesinin (Turing Machine) bir benzeri olan makinenin geliştirilmesini sağlamıştır. Problem, durma problemine göre (halting problem) daha basit bir yapıdadır bu yüzden belirsiz karar problemlerinin ispatlanmasında daha çok tercih edilir.

Problem aşağıdaki şekilde tanımlanabilir.

A bir alfabe olmak üzere, bu alfabeden tanımlı olan n elemanlı iki küme ele alalım:

X = {x₁,x₂, … x_n }

Y = {y₁,y₂, … y_n}

Bu iki küme üzerinden üretilen iki kelimenin eşit olması durumunu arıyoruz.

Örneğin aşağıdaki kümeleri ele alalım:

X = { sad , sek , er, i}

Y = { sa , se, ker , di }

Yukarıdaki örnek kümeler için böyle bir eşitlik bulunabilir:

sad + i + se + ker = sadiseker = sa + di + se + ker

Yukarıdaki eşitliğin sol tarafı X kümesinde, sağ tarafı ise Y kümesinden üretilmiştir.

Bazı problemler çözümsüz, bazı problemler ise birden fazla çözüme sahip olabilir. Örneğin aşağıdaki kümeleri ele alalım:

X= {a,ab,bba}

Y= { baa, aa, bb}

Çözüm aşağıdaki şekilde olabilir:

bba + ab + bba + a = bbaabbbaa = bb + aa + bb + baa

Ancak bu tek çözüm değildir. Örneğin aşağıdaki de bir çözüm üretebilir:

bba + ab + bba + a + bba + ab + bba + a = bbaabbbaabbaabbbaa = bb + aa + bb + baa + bb + aa + bb + baa

Yukarıdaki ikinci çözüm, bir önceki çözümün tekrarı niteliğindedir. Yani üretilen eşitlik dizilimi bir önceki çözümün iki kere tekrarlanması ile oluşturulmuştur. Bu işlem istenildiği kadar tekrar edilebilir.

Örneğin yukarıdaki kümelerin ilk elemanları çıkarılarak aşağıdaki kümeler oluşturulsaydı

X= {ab,bba}

Y= { aa, bb}

Bu kümelerden elde edilen bir çözüm bulunamazdı.

141 views